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