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