CodeGenModule.cpp revision 198092
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), MangleCtx(C), 43 VtableInfo(*this), Runtime(0), 44 MemCpyFn(0), MemMoveFn(0), MemSetFn(0), CFConstantStringClassRef(0), 45 VMContext(M.getContext()) { 46 47 if (!Features.ObjC1) 48 Runtime = 0; 49 else if (!Features.NeXTRuntime) 50 Runtime = CreateGNUObjCRuntime(*this); 51 else if (Features.ObjCNonFragileABI) 52 Runtime = CreateMacNonFragileABIObjCRuntime(*this); 53 else 54 Runtime = CreateMacObjCRuntime(*this); 55 56 // If debug info generation is enabled, create the CGDebugInfo object. 57 DebugInfo = CompileOpts.DebugInfo ? new CGDebugInfo(this) : 0; 58} 59 60CodeGenModule::~CodeGenModule() { 61 delete Runtime; 62 delete DebugInfo; 63} 64 65void CodeGenModule::Release() { 66 // We need to call this first because it can add deferred declarations. 67 EmitCXXGlobalInitFunc(); 68 69 EmitDeferred(); 70 if (Runtime) 71 if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction()) 72 AddGlobalCtor(ObjCInitFunction); 73 EmitCtorList(GlobalCtors, "llvm.global_ctors"); 74 EmitCtorList(GlobalDtors, "llvm.global_dtors"); 75 EmitAnnotations(); 76 EmitLLVMUsed(); 77} 78 79/// ErrorUnsupported - Print out an error that codegen doesn't support the 80/// specified stmt yet. 81void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type, 82 bool OmitOnError) { 83 if (OmitOnError && getDiags().hasErrorOccurred()) 84 return; 85 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 86 "cannot compile this %0 yet"); 87 std::string Msg = Type; 88 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 89 << Msg << S->getSourceRange(); 90} 91 92/// ErrorUnsupported - Print out an error that codegen doesn't support the 93/// specified decl yet. 94void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type, 95 bool OmitOnError) { 96 if (OmitOnError && getDiags().hasErrorOccurred()) 97 return; 98 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 99 "cannot compile this %0 yet"); 100 std::string Msg = Type; 101 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 102} 103 104LangOptions::VisibilityMode 105CodeGenModule::getDeclVisibilityMode(const Decl *D) const { 106 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 107 if (VD->getStorageClass() == VarDecl::PrivateExtern) 108 return LangOptions::Hidden; 109 110 if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) { 111 switch (attr->getVisibility()) { 112 default: assert(0 && "Unknown visibility!"); 113 case VisibilityAttr::DefaultVisibility: 114 return LangOptions::Default; 115 case VisibilityAttr::HiddenVisibility: 116 return LangOptions::Hidden; 117 case VisibilityAttr::ProtectedVisibility: 118 return LangOptions::Protected; 119 } 120 } 121 122 return getLangOptions().getVisibilityMode(); 123} 124 125void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 126 const Decl *D) const { 127 // Internal definitions always have default visibility. 128 if (GV->hasLocalLinkage()) { 129 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 130 return; 131 } 132 133 switch (getDeclVisibilityMode(D)) { 134 default: assert(0 && "Unknown visibility!"); 135 case LangOptions::Default: 136 return GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 137 case LangOptions::Hidden: 138 return GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 139 case LangOptions::Protected: 140 return GV->setVisibility(llvm::GlobalValue::ProtectedVisibility); 141 } 142} 143 144const char *CodeGenModule::getMangledName(const GlobalDecl &GD) { 145 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl()); 146 147 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) 148 return getMangledCXXCtorName(D, GD.getCtorType()); 149 if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) 150 return getMangledCXXDtorName(D, GD.getDtorType()); 151 152 return getMangledName(ND); 153} 154 155/// \brief Retrieves the mangled name for the given declaration. 156/// 157/// If the given declaration requires a mangled name, returns an 158/// const char* containing the mangled name. Otherwise, returns 159/// the unmangled name. 160/// 161const char *CodeGenModule::getMangledName(const NamedDecl *ND) { 162 // In C, functions with no attributes never need to be mangled. Fastpath them. 163 if (!getLangOptions().CPlusPlus && !ND->hasAttrs()) { 164 assert(ND->getIdentifier() && "Attempt to mangle unnamed decl."); 165 return ND->getNameAsCString(); 166 } 167 168 llvm::SmallString<256> Name; 169 llvm::raw_svector_ostream Out(Name); 170 if (!mangleName(getMangleContext(), ND, Out)) { 171 assert(ND->getIdentifier() && "Attempt to mangle unnamed decl."); 172 return ND->getNameAsCString(); 173 } 174 175 Name += '\0'; 176 return UniqueMangledName(Name.begin(), Name.end()); 177} 178 179const char *CodeGenModule::UniqueMangledName(const char *NameStart, 180 const char *NameEnd) { 181 assert(*(NameEnd - 1) == '\0' && "Mangled name must be null terminated!"); 182 183 return MangledNames.GetOrCreateValue(NameStart, NameEnd).getKeyData(); 184} 185 186/// AddGlobalCtor - Add a function to the list that will be called before 187/// main() runs. 188void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { 189 // FIXME: Type coercion of void()* types. 190 GlobalCtors.push_back(std::make_pair(Ctor, Priority)); 191} 192 193/// AddGlobalDtor - Add a function to the list that will be called 194/// when the module is unloaded. 195void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { 196 // FIXME: Type coercion of void()* types. 197 GlobalDtors.push_back(std::make_pair(Dtor, Priority)); 198} 199 200void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 201 // Ctor function type is void()*. 202 llvm::FunctionType* CtorFTy = 203 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 204 std::vector<const llvm::Type*>(), 205 false); 206 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 207 208 // Get the type of a ctor entry, { i32, void ()* }. 209 llvm::StructType* CtorStructTy = 210 llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext), 211 llvm::PointerType::getUnqual(CtorFTy), NULL); 212 213 // Construct the constructor and destructor arrays. 214 std::vector<llvm::Constant*> Ctors; 215 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 216 std::vector<llvm::Constant*> S; 217 S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 218 I->second, false)); 219 S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)); 220 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 221 } 222 223 if (!Ctors.empty()) { 224 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 225 new llvm::GlobalVariable(TheModule, AT, false, 226 llvm::GlobalValue::AppendingLinkage, 227 llvm::ConstantArray::get(AT, Ctors), 228 GlobalName); 229 } 230} 231 232void CodeGenModule::EmitAnnotations() { 233 if (Annotations.empty()) 234 return; 235 236 // Create a new global variable for the ConstantStruct in the Module. 237 llvm::Constant *Array = 238 llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(), 239 Annotations.size()), 240 Annotations); 241 llvm::GlobalValue *gv = 242 new llvm::GlobalVariable(TheModule, Array->getType(), false, 243 llvm::GlobalValue::AppendingLinkage, Array, 244 "llvm.global.annotations"); 245 gv->setSection("llvm.metadata"); 246} 247 248static CodeGenModule::GVALinkage 249GetLinkageForFunction(ASTContext &Context, const FunctionDecl *FD, 250 const LangOptions &Features) { 251 // Everything located semantically within an anonymous namespace is 252 // always internal. 253 if (FD->isInAnonymousNamespace()) 254 return CodeGenModule::GVA_Internal; 255 256 // The kind of external linkage this function will have, if it is not 257 // inline or static. 258 CodeGenModule::GVALinkage External = CodeGenModule::GVA_StrongExternal; 259 if (Context.getLangOptions().CPlusPlus && 260 FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 261 External = CodeGenModule::GVA_TemplateInstantiation; 262 263 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 264 // C++ member functions defined inside the class are always inline. 265 if (MD->isInline() || !MD->isOutOfLine()) 266 return CodeGenModule::GVA_CXXInline; 267 268 return External; 269 } 270 271 // "static" functions get internal linkage. 272 if (FD->getStorageClass() == FunctionDecl::Static) 273 return CodeGenModule::GVA_Internal; 274 275 if (!FD->isInline()) 276 return External; 277 278 if (!Features.CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 279 // GNU or C99 inline semantics. Determine whether this symbol should be 280 // externally visible. 281 if (FD->isInlineDefinitionExternallyVisible()) 282 return External; 283 284 // C99 inline semantics, where the symbol is not externally visible. 285 return CodeGenModule::GVA_C99Inline; 286 } 287 288 // C++ inline semantics 289 assert(Features.CPlusPlus && "Must be in C++ mode"); 290 return CodeGenModule::GVA_CXXInline; 291} 292 293/// SetFunctionDefinitionAttributes - Set attributes for a global. 294/// 295/// FIXME: This is currently only done for aliases and functions, but not for 296/// variables (these details are set in EmitGlobalVarDefinition for variables). 297void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 298 llvm::GlobalValue *GV) { 299 GVALinkage Linkage = GetLinkageForFunction(getContext(), D, Features); 300 301 if (Linkage == GVA_Internal) { 302 GV->setLinkage(llvm::Function::InternalLinkage); 303 } else if (D->hasAttr<DLLExportAttr>()) { 304 GV->setLinkage(llvm::Function::DLLExportLinkage); 305 } else if (D->hasAttr<WeakAttr>()) { 306 GV->setLinkage(llvm::Function::WeakAnyLinkage); 307 } else if (Linkage == GVA_C99Inline) { 308 // In C99 mode, 'inline' functions are guaranteed to have a strong 309 // definition somewhere else, so we can use available_externally linkage. 310 GV->setLinkage(llvm::Function::AvailableExternallyLinkage); 311 } else if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) { 312 // In C++, the compiler has to emit a definition in every translation unit 313 // that references the function. We should use linkonce_odr because 314 // a) if all references in this translation unit are optimized away, we 315 // don't need to codegen it. b) if the function persists, it needs to be 316 // merged with other definitions. c) C++ has the ODR, so we know the 317 // definition is dependable. 318 GV->setLinkage(llvm::Function::LinkOnceODRLinkage); 319 } else { 320 assert(Linkage == GVA_StrongExternal); 321 // Otherwise, we have strong external linkage. 322 GV->setLinkage(llvm::Function::ExternalLinkage); 323 } 324 325 SetCommonAttributes(D, GV); 326} 327 328void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 329 const CGFunctionInfo &Info, 330 llvm::Function *F) { 331 unsigned CallingConv; 332 AttributeListType AttributeList; 333 ConstructAttributeList(Info, D, AttributeList, CallingConv); 334 F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(), 335 AttributeList.size())); 336 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 337} 338 339void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 340 llvm::Function *F) { 341 if (!Features.Exceptions && !Features.ObjCNonFragileABI) 342 F->addFnAttr(llvm::Attribute::NoUnwind); 343 344 if (D->hasAttr<AlwaysInlineAttr>()) 345 F->addFnAttr(llvm::Attribute::AlwaysInline); 346 347 if (D->hasAttr<NoInlineAttr>()) 348 F->addFnAttr(llvm::Attribute::NoInline); 349 350 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>()) 351 F->setAlignment(AA->getAlignment()/8); 352 // C++ ABI requires 2-byte alignment for member functions. 353 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 354 F->setAlignment(2); 355} 356 357void CodeGenModule::SetCommonAttributes(const Decl *D, 358 llvm::GlobalValue *GV) { 359 setGlobalVisibility(GV, D); 360 361 if (D->hasAttr<UsedAttr>()) 362 AddUsedGlobal(GV); 363 364 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 365 GV->setSection(SA->getName()); 366} 367 368void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 369 llvm::Function *F, 370 const CGFunctionInfo &FI) { 371 SetLLVMFunctionAttributes(D, FI, F); 372 SetLLVMFunctionAttributesForDefinition(D, F); 373 374 F->setLinkage(llvm::Function::InternalLinkage); 375 376 SetCommonAttributes(D, F); 377} 378 379void CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD, 380 llvm::Function *F, 381 bool IsIncompleteFunction) { 382 if (!IsIncompleteFunction) 383 SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(FD), F); 384 385 // Only a few attributes are set on declarations; these may later be 386 // overridden by a definition. 387 388 if (FD->hasAttr<DLLImportAttr>()) { 389 F->setLinkage(llvm::Function::DLLImportLinkage); 390 } else if (FD->hasAttr<WeakAttr>() || 391 FD->hasAttr<WeakImportAttr>()) { 392 // "extern_weak" is overloaded in LLVM; we probably should have 393 // separate linkage types for this. 394 F->setLinkage(llvm::Function::ExternalWeakLinkage); 395 } else { 396 F->setLinkage(llvm::Function::ExternalLinkage); 397 } 398 399 if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 400 F->setSection(SA->getName()); 401} 402 403void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 404 assert(!GV->isDeclaration() && 405 "Only globals with definition can force usage."); 406 LLVMUsed.push_back(GV); 407} 408 409void CodeGenModule::EmitLLVMUsed() { 410 // Don't create llvm.used if there is no need. 411 if (LLVMUsed.empty()) 412 return; 413 414 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext); 415 416 // Convert LLVMUsed to what ConstantArray needs. 417 std::vector<llvm::Constant*> UsedArray; 418 UsedArray.resize(LLVMUsed.size()); 419 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 420 UsedArray[i] = 421 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 422 i8PTy); 423 } 424 425 if (UsedArray.empty()) 426 return; 427 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size()); 428 429 llvm::GlobalVariable *GV = 430 new llvm::GlobalVariable(getModule(), ATy, false, 431 llvm::GlobalValue::AppendingLinkage, 432 llvm::ConstantArray::get(ATy, UsedArray), 433 "llvm.used"); 434 435 GV->setSection("llvm.metadata"); 436} 437 438void CodeGenModule::EmitDeferred() { 439 // Emit code for any potentially referenced deferred decls. Since a 440 // previously unused static decl may become used during the generation of code 441 // for a static function, iterate until no changes are made. 442 while (!DeferredDeclsToEmit.empty()) { 443 GlobalDecl D = DeferredDeclsToEmit.back(); 444 DeferredDeclsToEmit.pop_back(); 445 446 // The mangled name for the decl must have been emitted in GlobalDeclMap. 447 // Look it up to see if it was defined with a stronger definition (e.g. an 448 // extern inline function with a strong function redefinition). If so, 449 // just ignore the deferred decl. 450 llvm::GlobalValue *CGRef = GlobalDeclMap[getMangledName(D)]; 451 assert(CGRef && "Deferred decl wasn't referenced?"); 452 453 if (!CGRef->isDeclaration()) 454 continue; 455 456 // Otherwise, emit the definition and move on to the next one. 457 EmitGlobalDefinition(D); 458 } 459} 460 461/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 462/// annotation information for a given GlobalValue. The annotation struct is 463/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 464/// GlobalValue being annotated. The second field is the constant string 465/// created from the AnnotateAttr's annotation. The third field is a constant 466/// string containing the name of the translation unit. The fourth field is 467/// the line number in the file of the annotated value declaration. 468/// 469/// FIXME: this does not unique the annotation string constants, as llvm-gcc 470/// appears to. 471/// 472llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 473 const AnnotateAttr *AA, 474 unsigned LineNo) { 475 llvm::Module *M = &getModule(); 476 477 // get [N x i8] constants for the annotation string, and the filename string 478 // which are the 2nd and 3rd elements of the global annotation structure. 479 const llvm::Type *SBP = llvm::Type::getInt8PtrTy(VMContext); 480 llvm::Constant *anno = llvm::ConstantArray::get(VMContext, 481 AA->getAnnotation(), true); 482 llvm::Constant *unit = llvm::ConstantArray::get(VMContext, 483 M->getModuleIdentifier(), 484 true); 485 486 // Get the two global values corresponding to the ConstantArrays we just 487 // created to hold the bytes of the strings. 488 llvm::GlobalValue *annoGV = 489 new llvm::GlobalVariable(*M, anno->getType(), false, 490 llvm::GlobalValue::PrivateLinkage, anno, 491 GV->getName()); 492 // translation unit name string, emitted into the llvm.metadata section. 493 llvm::GlobalValue *unitGV = 494 new llvm::GlobalVariable(*M, unit->getType(), false, 495 llvm::GlobalValue::PrivateLinkage, unit, 496 ".str"); 497 498 // Create the ConstantStruct for the global annotation. 499 llvm::Constant *Fields[4] = { 500 llvm::ConstantExpr::getBitCast(GV, SBP), 501 llvm::ConstantExpr::getBitCast(annoGV, SBP), 502 llvm::ConstantExpr::getBitCast(unitGV, SBP), 503 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo) 504 }; 505 return llvm::ConstantStruct::get(VMContext, Fields, 4, false); 506} 507 508bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 509 // Never defer when EmitAllDecls is specified or the decl has 510 // attribute used. 511 if (Features.EmitAllDecls || Global->hasAttr<UsedAttr>()) 512 return false; 513 514 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 515 // Constructors and destructors should never be deferred. 516 if (FD->hasAttr<ConstructorAttr>() || 517 FD->hasAttr<DestructorAttr>()) 518 return false; 519 520 GVALinkage Linkage = GetLinkageForFunction(getContext(), FD, Features); 521 522 // static, static inline, always_inline, and extern inline functions can 523 // always be deferred. Normal inline functions can be deferred in C99/C++. 524 if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 525 Linkage == GVA_CXXInline) 526 return true; 527 return false; 528 } 529 530 const VarDecl *VD = cast<VarDecl>(Global); 531 assert(VD->isFileVarDecl() && "Invalid decl"); 532 533 // We never want to defer structs that have non-trivial constructors or 534 // destructors. 535 536 // FIXME: Handle references. 537 if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 538 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 539 if (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor()) 540 return false; 541 } 542 } 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())) 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->isInAnonymousNamespace()) 1025 GV->setLinkage(llvm::Function::InternalLinkage); 1026 else if (D->getStorageClass() == VarDecl::Static) 1027 GV->setLinkage(llvm::Function::InternalLinkage); 1028 else if (D->hasAttr<DLLImportAttr>()) 1029 GV->setLinkage(llvm::Function::DLLImportLinkage); 1030 else if (D->hasAttr<DLLExportAttr>()) 1031 GV->setLinkage(llvm::Function::DLLExportLinkage); 1032 else if (D->hasAttr<WeakAttr>()) { 1033 if (GV->isConstant()) 1034 GV->setLinkage(llvm::GlobalVariable::WeakODRLinkage); 1035 else 1036 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage); 1037 } else if (!CompileOpts.NoCommon && 1038 !D->hasExternalStorage() && !D->getInit() && 1039 !D->getAttr<SectionAttr>()) { 1040 GV->setLinkage(llvm::GlobalVariable::CommonLinkage); 1041 // common vars aren't constant even if declared const. 1042 GV->setConstant(false); 1043 } else 1044 GV->setLinkage(llvm::GlobalVariable::ExternalLinkage); 1045 1046 SetCommonAttributes(D, GV); 1047 1048 // Emit global variable debug information. 1049 if (CGDebugInfo *DI = getDebugInfo()) { 1050 DI->setLocation(D->getLocation()); 1051 DI->EmitGlobalVariable(GV, D); 1052 } 1053} 1054 1055/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 1056/// implement a function with no prototype, e.g. "int foo() {}". If there are 1057/// existing call uses of the old function in the module, this adjusts them to 1058/// call the new function directly. 1059/// 1060/// This is not just a cleanup: the always_inline pass requires direct calls to 1061/// functions to be able to inline them. If there is a bitcast in the way, it 1062/// won't inline them. Instcombine normally deletes these calls, but it isn't 1063/// run at -O0. 1064static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 1065 llvm::Function *NewFn) { 1066 // If we're redefining a global as a function, don't transform it. 1067 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old); 1068 if (OldFn == 0) return; 1069 1070 const llvm::Type *NewRetTy = NewFn->getReturnType(); 1071 llvm::SmallVector<llvm::Value*, 4> ArgList; 1072 1073 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end(); 1074 UI != E; ) { 1075 // TODO: Do invokes ever occur in C code? If so, we should handle them too. 1076 unsigned OpNo = UI.getOperandNo(); 1077 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*UI++); 1078 if (!CI || OpNo != 0) continue; 1079 1080 // If the return types don't match exactly, and if the call isn't dead, then 1081 // we can't transform this call. 1082 if (CI->getType() != NewRetTy && !CI->use_empty()) 1083 continue; 1084 1085 // If the function was passed too few arguments, don't transform. If extra 1086 // arguments were passed, we silently drop them. If any of the types 1087 // mismatch, we don't transform. 1088 unsigned ArgNo = 0; 1089 bool DontTransform = false; 1090 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(), 1091 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) { 1092 if (CI->getNumOperands()-1 == ArgNo || 1093 CI->getOperand(ArgNo+1)->getType() != AI->getType()) { 1094 DontTransform = true; 1095 break; 1096 } 1097 } 1098 if (DontTransform) 1099 continue; 1100 1101 // Okay, we can transform this. Create the new call instruction and copy 1102 // over the required information. 1103 ArgList.append(CI->op_begin()+1, CI->op_begin()+1+ArgNo); 1104 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(), 1105 ArgList.end(), "", CI); 1106 ArgList.clear(); 1107 if (!NewCall->getType()->isVoidTy()) 1108 NewCall->takeName(CI); 1109 NewCall->setAttributes(CI->getAttributes()); 1110 NewCall->setCallingConv(CI->getCallingConv()); 1111 1112 // Finally, remove the old call, replacing any uses with the new one. 1113 if (!CI->use_empty()) 1114 CI->replaceAllUsesWith(NewCall); 1115 1116 // Copy any custom metadata attached with CI. 1117 llvm::MetadataContext &TheMetadata = CI->getContext().getMetadata(); 1118 TheMetadata.copyMD(CI, NewCall); 1119 1120 CI->eraseFromParent(); 1121 } 1122} 1123 1124 1125void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 1126 const llvm::FunctionType *Ty; 1127 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 1128 1129 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 1130 bool isVariadic = D->getType()->getAs<FunctionProtoType>()->isVariadic(); 1131 1132 Ty = getTypes().GetFunctionType(getTypes().getFunctionInfo(MD), isVariadic); 1133 } else { 1134 Ty = cast<llvm::FunctionType>(getTypes().ConvertType(D->getType())); 1135 1136 // As a special case, make sure that definitions of K&R function 1137 // "type foo()" aren't declared as varargs (which forces the backend 1138 // to do unnecessary work). 1139 if (D->getType()->isFunctionNoProtoType()) { 1140 assert(Ty->isVarArg() && "Didn't lower type as expected"); 1141 // Due to stret, the lowered function could have arguments. 1142 // Just create the same type as was lowered by ConvertType 1143 // but strip off the varargs bit. 1144 std::vector<const llvm::Type*> Args(Ty->param_begin(), Ty->param_end()); 1145 Ty = llvm::FunctionType::get(Ty->getReturnType(), Args, false); 1146 } 1147 } 1148 1149 // Get or create the prototype for the function. 1150 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 1151 1152 // Strip off a bitcast if we got one back. 1153 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1154 assert(CE->getOpcode() == llvm::Instruction::BitCast); 1155 Entry = CE->getOperand(0); 1156 } 1157 1158 1159 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 1160 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 1161 1162 // If the types mismatch then we have to rewrite the definition. 1163 assert(OldFn->isDeclaration() && 1164 "Shouldn't replace non-declaration"); 1165 1166 // F is the Function* for the one with the wrong type, we must make a new 1167 // Function* and update everything that used F (a declaration) with the new 1168 // Function* (which will be a definition). 1169 // 1170 // This happens if there is a prototype for a function 1171 // (e.g. "int f()") and then a definition of a different type 1172 // (e.g. "int f(int x)"). Start by making a new function of the 1173 // correct type, RAUW, then steal the name. 1174 GlobalDeclMap.erase(getMangledName(D)); 1175 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 1176 NewFn->takeName(OldFn); 1177 1178 // If this is an implementation of a function without a prototype, try to 1179 // replace any existing uses of the function (which may be calls) with uses 1180 // of the new function 1181 if (D->getType()->isFunctionNoProtoType()) { 1182 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 1183 OldFn->removeDeadConstantUsers(); 1184 } 1185 1186 // Replace uses of F with the Function we will endow with a body. 1187 if (!Entry->use_empty()) { 1188 llvm::Constant *NewPtrForOldDecl = 1189 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 1190 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1191 } 1192 1193 // Ok, delete the old function now, which is dead. 1194 OldFn->eraseFromParent(); 1195 1196 Entry = NewFn; 1197 } 1198 1199 llvm::Function *Fn = cast<llvm::Function>(Entry); 1200 1201 CodeGenFunction(*this).GenerateCode(D, Fn); 1202 1203 SetFunctionDefinitionAttributes(D, Fn); 1204 SetLLVMFunctionAttributesForDefinition(D, Fn); 1205 1206 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 1207 AddGlobalCtor(Fn, CA->getPriority()); 1208 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 1209 AddGlobalDtor(Fn, DA->getPriority()); 1210} 1211 1212void CodeGenModule::EmitAliasDefinition(const ValueDecl *D) { 1213 const AliasAttr *AA = D->getAttr<AliasAttr>(); 1214 assert(AA && "Not an alias?"); 1215 1216 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 1217 1218 // Unique the name through the identifier table. 1219 const char *AliaseeName = AA->getAliasee().c_str(); 1220 AliaseeName = getContext().Idents.get(AliaseeName).getName(); 1221 1222 // Create a reference to the named value. This ensures that it is emitted 1223 // if a deferred decl. 1224 llvm::Constant *Aliasee; 1225 if (isa<llvm::FunctionType>(DeclTy)) 1226 Aliasee = GetOrCreateLLVMFunction(AliaseeName, DeclTy, GlobalDecl()); 1227 else 1228 Aliasee = GetOrCreateLLVMGlobal(AliaseeName, 1229 llvm::PointerType::getUnqual(DeclTy), 0); 1230 1231 // Create the new alias itself, but don't set a name yet. 1232 llvm::GlobalValue *GA = 1233 new llvm::GlobalAlias(Aliasee->getType(), 1234 llvm::Function::ExternalLinkage, 1235 "", Aliasee, &getModule()); 1236 1237 // See if there is already something with the alias' name in the module. 1238 const char *MangledName = getMangledName(D); 1239 llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName]; 1240 1241 if (Entry && !Entry->isDeclaration()) { 1242 // If there is a definition in the module, then it wins over the alias. 1243 // This is dubious, but allow it to be safe. Just ignore the alias. 1244 GA->eraseFromParent(); 1245 return; 1246 } 1247 1248 if (Entry) { 1249 // If there is a declaration in the module, then we had an extern followed 1250 // by the alias, as in: 1251 // extern int test6(); 1252 // ... 1253 // int test6() __attribute__((alias("test7"))); 1254 // 1255 // Remove it and replace uses of it with the alias. 1256 1257 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 1258 Entry->getType())); 1259 Entry->eraseFromParent(); 1260 } 1261 1262 // Now we know that there is no conflict, set the name. 1263 Entry = GA; 1264 GA->setName(MangledName); 1265 1266 // Set attributes which are particular to an alias; this is a 1267 // specialization of the attributes which may be set on a global 1268 // variable/function. 1269 if (D->hasAttr<DLLExportAttr>()) { 1270 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1271 // The dllexport attribute is ignored for undefined symbols. 1272 if (FD->getBody()) 1273 GA->setLinkage(llvm::Function::DLLExportLinkage); 1274 } else { 1275 GA->setLinkage(llvm::Function::DLLExportLinkage); 1276 } 1277 } else if (D->hasAttr<WeakAttr>() || 1278 D->hasAttr<WeakImportAttr>()) { 1279 GA->setLinkage(llvm::Function::WeakAnyLinkage); 1280 } 1281 1282 SetCommonAttributes(D, GA); 1283} 1284 1285/// getBuiltinLibFunction - Given a builtin id for a function like 1286/// "__builtin_fabsf", return a Function* for "fabsf". 1287llvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD, 1288 unsigned BuiltinID) { 1289 assert((Context.BuiltinInfo.isLibFunction(BuiltinID) || 1290 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) && 1291 "isn't a lib fn"); 1292 1293 // Get the name, skip over the __builtin_ prefix (if necessary). 1294 const char *Name = Context.BuiltinInfo.GetName(BuiltinID); 1295 if (Context.BuiltinInfo.isLibFunction(BuiltinID)) 1296 Name += 10; 1297 1298 // Get the type for the builtin. 1299 ASTContext::GetBuiltinTypeError Error; 1300 QualType Type = Context.GetBuiltinType(BuiltinID, Error); 1301 assert(Error == ASTContext::GE_None && "Can't get builtin type"); 1302 1303 const llvm::FunctionType *Ty = 1304 cast<llvm::FunctionType>(getTypes().ConvertType(Type)); 1305 1306 // Unique the name through the identifier table. 1307 Name = getContext().Idents.get(Name).getName(); 1308 return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD)); 1309} 1310 1311llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys, 1312 unsigned NumTys) { 1313 return llvm::Intrinsic::getDeclaration(&getModule(), 1314 (llvm::Intrinsic::ID)IID, Tys, NumTys); 1315} 1316 1317llvm::Function *CodeGenModule::getMemCpyFn() { 1318 if (MemCpyFn) return MemCpyFn; 1319 const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext); 1320 return MemCpyFn = getIntrinsic(llvm::Intrinsic::memcpy, &IntPtr, 1); 1321} 1322 1323llvm::Function *CodeGenModule::getMemMoveFn() { 1324 if (MemMoveFn) return MemMoveFn; 1325 const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext); 1326 return MemMoveFn = getIntrinsic(llvm::Intrinsic::memmove, &IntPtr, 1); 1327} 1328 1329llvm::Function *CodeGenModule::getMemSetFn() { 1330 if (MemSetFn) return MemSetFn; 1331 const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext); 1332 return MemSetFn = getIntrinsic(llvm::Intrinsic::memset, &IntPtr, 1); 1333} 1334 1335static llvm::StringMapEntry<llvm::Constant*> & 1336GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 1337 const StringLiteral *Literal, 1338 bool TargetIsLSB, 1339 bool &IsUTF16, 1340 unsigned &StringLength) { 1341 unsigned NumBytes = Literal->getByteLength(); 1342 1343 // Check for simple case. 1344 if (!Literal->containsNonAsciiOrNull()) { 1345 StringLength = NumBytes; 1346 return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(), 1347 StringLength)); 1348 } 1349 1350 // Otherwise, convert the UTF8 literals into a byte string. 1351 llvm::SmallVector<UTF16, 128> ToBuf(NumBytes); 1352 const UTF8 *FromPtr = (UTF8 *)Literal->getStrData(); 1353 UTF16 *ToPtr = &ToBuf[0]; 1354 1355 ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 1356 &ToPtr, ToPtr + NumBytes, 1357 strictConversion); 1358 1359 // Check for conversion failure. 1360 if (Result != conversionOK) { 1361 // FIXME: Have Sema::CheckObjCString() validate the UTF-8 string and remove 1362 // this duplicate code. 1363 assert(Result == sourceIllegal && "UTF-8 to UTF-16 conversion failed"); 1364 StringLength = NumBytes; 1365 return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(), 1366 StringLength)); 1367 } 1368 1369 // ConvertUTF8toUTF16 returns the length in ToPtr. 1370 StringLength = ToPtr - &ToBuf[0]; 1371 1372 // Render the UTF-16 string into a byte array and convert to the target byte 1373 // order. 1374 // 1375 // FIXME: This isn't something we should need to do here. 1376 llvm::SmallString<128> AsBytes; 1377 AsBytes.reserve(StringLength * 2); 1378 for (unsigned i = 0; i != StringLength; ++i) { 1379 unsigned short Val = ToBuf[i]; 1380 if (TargetIsLSB) { 1381 AsBytes.push_back(Val & 0xFF); 1382 AsBytes.push_back(Val >> 8); 1383 } else { 1384 AsBytes.push_back(Val >> 8); 1385 AsBytes.push_back(Val & 0xFF); 1386 } 1387 } 1388 // Append one extra null character, the second is automatically added by our 1389 // caller. 1390 AsBytes.push_back(0); 1391 1392 IsUTF16 = true; 1393 return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size())); 1394} 1395 1396llvm::Constant * 1397CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 1398 unsigned StringLength = 0; 1399 bool isUTF16 = false; 1400 llvm::StringMapEntry<llvm::Constant*> &Entry = 1401 GetConstantCFStringEntry(CFConstantStringMap, Literal, 1402 getTargetData().isLittleEndian(), 1403 isUTF16, StringLength); 1404 1405 if (llvm::Constant *C = Entry.getValue()) 1406 return C; 1407 1408 llvm::Constant *Zero = 1409 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 1410 llvm::Constant *Zeros[] = { Zero, Zero }; 1411 1412 // If we don't already have it, get __CFConstantStringClassReference. 1413 if (!CFConstantStringClassRef) { 1414 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 1415 Ty = llvm::ArrayType::get(Ty, 0); 1416 llvm::Constant *GV = CreateRuntimeVariable(Ty, 1417 "__CFConstantStringClassReference"); 1418 // Decay array -> ptr 1419 CFConstantStringClassRef = 1420 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1421 } 1422 1423 QualType CFTy = getContext().getCFConstantStringType(); 1424 1425 const llvm::StructType *STy = 1426 cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 1427 1428 std::vector<llvm::Constant*> Fields(4); 1429 1430 // Class pointer. 1431 Fields[0] = CFConstantStringClassRef; 1432 1433 // Flags. 1434 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 1435 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 1436 llvm::ConstantInt::get(Ty, 0x07C8); 1437 1438 // String pointer. 1439 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 1440 1441 const char *Sect = 0; 1442 llvm::GlobalValue::LinkageTypes Linkage; 1443 bool isConstant; 1444 if (isUTF16) { 1445 Sect = getContext().Target.getUnicodeStringSection(); 1446 // FIXME: why do utf strings get "_" labels instead of "L" labels? 1447 Linkage = llvm::GlobalValue::InternalLinkage; 1448 // Note: -fwritable-strings doesn't make unicode CFStrings writable, but 1449 // does make plain ascii ones writable. 1450 isConstant = true; 1451 } else { 1452 Linkage = llvm::GlobalValue::PrivateLinkage; 1453 isConstant = !Features.WritableStrings; 1454 } 1455 1456 llvm::GlobalVariable *GV = 1457 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 1458 ".str"); 1459 if (Sect) 1460 GV->setSection(Sect); 1461 if (isUTF16) { 1462 unsigned Align = getContext().getTypeAlign(getContext().ShortTy)/8; 1463 GV->setAlignment(Align); 1464 } 1465 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1466 1467 // String length. 1468 Ty = getTypes().ConvertType(getContext().LongTy); 1469 Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 1470 1471 // The struct. 1472 C = llvm::ConstantStruct::get(STy, Fields); 1473 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 1474 llvm::GlobalVariable::PrivateLinkage, C, 1475 "_unnamed_cfstring_"); 1476 if (const char *Sect = getContext().Target.getCFStringSection()) 1477 GV->setSection(Sect); 1478 Entry.setValue(GV); 1479 1480 return GV; 1481} 1482 1483/// GetStringForStringLiteral - Return the appropriate bytes for a 1484/// string literal, properly padded to match the literal type. 1485std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) { 1486 const char *StrData = E->getStrData(); 1487 unsigned Len = E->getByteLength(); 1488 1489 const ConstantArrayType *CAT = 1490 getContext().getAsConstantArrayType(E->getType()); 1491 assert(CAT && "String isn't pointer or array!"); 1492 1493 // Resize the string to the right size. 1494 std::string Str(StrData, StrData+Len); 1495 uint64_t RealLen = CAT->getSize().getZExtValue(); 1496 1497 if (E->isWide()) 1498 RealLen *= getContext().Target.getWCharWidth()/8; 1499 1500 Str.resize(RealLen, '\0'); 1501 1502 return Str; 1503} 1504 1505/// GetAddrOfConstantStringFromLiteral - Return a pointer to a 1506/// constant array for the given string literal. 1507llvm::Constant * 1508CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 1509 // FIXME: This can be more efficient. 1510 return GetAddrOfConstantString(GetStringForStringLiteral(S)); 1511} 1512 1513/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 1514/// array for the given ObjCEncodeExpr node. 1515llvm::Constant * 1516CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 1517 std::string Str; 1518 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 1519 1520 return GetAddrOfConstantCString(Str); 1521} 1522 1523 1524/// GenerateWritableString -- Creates storage for a string literal. 1525static llvm::Constant *GenerateStringLiteral(const std::string &str, 1526 bool constant, 1527 CodeGenModule &CGM, 1528 const char *GlobalName) { 1529 // Create Constant for this string literal. Don't add a '\0'. 1530 llvm::Constant *C = 1531 llvm::ConstantArray::get(CGM.getLLVMContext(), str, false); 1532 1533 // Create a global variable for this string 1534 return new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 1535 llvm::GlobalValue::PrivateLinkage, 1536 C, GlobalName); 1537} 1538 1539/// GetAddrOfConstantString - Returns a pointer to a character array 1540/// containing the literal. This contents are exactly that of the 1541/// given string, i.e. it will not be null terminated automatically; 1542/// see GetAddrOfConstantCString. Note that whether the result is 1543/// actually a pointer to an LLVM constant depends on 1544/// Feature.WriteableStrings. 1545/// 1546/// The result has pointer to array type. 1547llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str, 1548 const char *GlobalName) { 1549 bool IsConstant = !Features.WritableStrings; 1550 1551 // Get the default prefix if a name wasn't specified. 1552 if (!GlobalName) 1553 GlobalName = ".str"; 1554 1555 // Don't share any string literals if strings aren't constant. 1556 if (!IsConstant) 1557 return GenerateStringLiteral(str, false, *this, GlobalName); 1558 1559 llvm::StringMapEntry<llvm::Constant *> &Entry = 1560 ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 1561 1562 if (Entry.getValue()) 1563 return Entry.getValue(); 1564 1565 // Create a global variable for this. 1566 llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName); 1567 Entry.setValue(C); 1568 return C; 1569} 1570 1571/// GetAddrOfConstantCString - Returns a pointer to a character 1572/// array containing the literal and a terminating '\-' 1573/// character. The result has pointer to array type. 1574llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str, 1575 const char *GlobalName){ 1576 return GetAddrOfConstantString(str + '\0', GlobalName); 1577} 1578 1579/// EmitObjCPropertyImplementations - Emit information for synthesized 1580/// properties for an implementation. 1581void CodeGenModule::EmitObjCPropertyImplementations(const 1582 ObjCImplementationDecl *D) { 1583 for (ObjCImplementationDecl::propimpl_iterator 1584 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 1585 ObjCPropertyImplDecl *PID = *i; 1586 1587 // Dynamic is just for type-checking. 1588 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 1589 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 1590 1591 // Determine which methods need to be implemented, some may have 1592 // been overridden. Note that ::isSynthesized is not the method 1593 // we want, that just indicates if the decl came from a 1594 // property. What we want to know is if the method is defined in 1595 // this implementation. 1596 if (!D->getInstanceMethod(PD->getGetterName())) 1597 CodeGenFunction(*this).GenerateObjCGetter( 1598 const_cast<ObjCImplementationDecl *>(D), PID); 1599 if (!PD->isReadOnly() && 1600 !D->getInstanceMethod(PD->getSetterName())) 1601 CodeGenFunction(*this).GenerateObjCSetter( 1602 const_cast<ObjCImplementationDecl *>(D), PID); 1603 } 1604 } 1605} 1606 1607/// EmitNamespace - Emit all declarations in a namespace. 1608void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 1609 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 1610 I != E; ++I) 1611 EmitTopLevelDecl(*I); 1612} 1613 1614// EmitLinkageSpec - Emit all declarations in a linkage spec. 1615void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 1616 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 1617 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 1618 ErrorUnsupported(LSD, "linkage spec"); 1619 return; 1620 } 1621 1622 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 1623 I != E; ++I) 1624 EmitTopLevelDecl(*I); 1625} 1626 1627/// EmitTopLevelDecl - Emit code for a single top level declaration. 1628void CodeGenModule::EmitTopLevelDecl(Decl *D) { 1629 // If an error has occurred, stop code generation, but continue 1630 // parsing and semantic analysis (to ensure all warnings and errors 1631 // are emitted). 1632 if (Diags.hasErrorOccurred()) 1633 return; 1634 1635 // Ignore dependent declarations. 1636 if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 1637 return; 1638 1639 switch (D->getKind()) { 1640 case Decl::CXXConversion: 1641 case Decl::CXXMethod: 1642 case Decl::Function: 1643 // Skip function templates 1644 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate()) 1645 return; 1646 1647 EmitGlobal(cast<FunctionDecl>(D)); 1648 break; 1649 1650 case Decl::Var: 1651 EmitGlobal(cast<VarDecl>(D)); 1652 break; 1653 1654 // C++ Decls 1655 case Decl::Namespace: 1656 EmitNamespace(cast<NamespaceDecl>(D)); 1657 break; 1658 // No code generation needed. 1659 case Decl::Using: 1660 case Decl::UsingDirective: 1661 case Decl::ClassTemplate: 1662 case Decl::FunctionTemplate: 1663 case Decl::NamespaceAlias: 1664 break; 1665 case Decl::CXXConstructor: 1666 EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 1667 break; 1668 case Decl::CXXDestructor: 1669 EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 1670 break; 1671 1672 case Decl::StaticAssert: 1673 // Nothing to do. 1674 break; 1675 1676 // Objective-C Decls 1677 1678 // Forward declarations, no (immediate) code generation. 1679 case Decl::ObjCClass: 1680 case Decl::ObjCForwardProtocol: 1681 case Decl::ObjCCategory: 1682 case Decl::ObjCInterface: 1683 break; 1684 1685 case Decl::ObjCProtocol: 1686 Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D)); 1687 break; 1688 1689 case Decl::ObjCCategoryImpl: 1690 // Categories have properties but don't support synthesize so we 1691 // can ignore them here. 1692 Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 1693 break; 1694 1695 case Decl::ObjCImplementation: { 1696 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 1697 EmitObjCPropertyImplementations(OMD); 1698 Runtime->GenerateClass(OMD); 1699 break; 1700 } 1701 case Decl::ObjCMethod: { 1702 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 1703 // If this is not a prototype, emit the body. 1704 if (OMD->getBody()) 1705 CodeGenFunction(*this).GenerateObjCMethod(OMD); 1706 break; 1707 } 1708 case Decl::ObjCCompatibleAlias: 1709 // compatibility-alias is a directive and has no code gen. 1710 break; 1711 1712 case Decl::LinkageSpec: 1713 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 1714 break; 1715 1716 case Decl::FileScopeAsm: { 1717 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 1718 std::string AsmString(AD->getAsmString()->getStrData(), 1719 AD->getAsmString()->getByteLength()); 1720 1721 const std::string &S = getModule().getModuleInlineAsm(); 1722 if (S.empty()) 1723 getModule().setModuleInlineAsm(AsmString); 1724 else 1725 getModule().setModuleInlineAsm(S + '\n' + AsmString); 1726 break; 1727 } 1728 1729 default: 1730 // Make sure we handled everything we should, every other kind is a 1731 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 1732 // function. Need to recode Decl::Kind to do that easily. 1733 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 1734 } 1735} 1736