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