1 //===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----*- C++ -*-===// 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 is the internal per-translation-unit state used for llvm translation. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef CLANG_CODEGEN_CODEGENMODULE_H 15 #define CLANG_CODEGEN_CODEGENMODULE_H 16 17 #include "CGVTables.h" 18 #include "CodeGenTypes.h" 19 #include "clang/AST/Attr.h" 20 #include "clang/AST/DeclCXX.h" 21 #include "clang/AST/DeclObjC.h" 22 #include "clang/AST/GlobalDecl.h" 23 #include "clang/AST/Mangle.h" 24 #include "clang/Basic/ABI.h" 25 #include "clang/Basic/LangOptions.h" 26 #include "clang/Basic/Module.h" 27 #include "llvm/ADT/DenseMap.h" 28 #include "llvm/ADT/SetVector.h" 29 #include "llvm/ADT/SmallPtrSet.h" 30 #include "llvm/ADT/StringMap.h" 31 #include "llvm/IR/CallingConv.h" 32 #include "llvm/IR/Module.h" 33 #include "llvm/Support/ValueHandle.h" 34 #include "llvm/Transforms/Utils/SpecialCaseList.h" 35 36 namespace llvm { 37 class Module; 38 class Constant; 39 class ConstantInt; 40 class Function; 41 class GlobalValue; 42 class DataLayout; 43 class FunctionType; 44 class LLVMContext; 45 } 46 47 namespace clang { 48 class TargetCodeGenInfo; 49 class ASTContext; 50 class AtomicType; 51 class FunctionDecl; 52 class IdentifierInfo; 53 class ObjCMethodDecl; 54 class ObjCImplementationDecl; 55 class ObjCCategoryImplDecl; 56 class ObjCProtocolDecl; 57 class ObjCEncodeExpr; 58 class BlockExpr; 59 class CharUnits; 60 class Decl; 61 class Expr; 62 class Stmt; 63 class InitListExpr; 64 class StringLiteral; 65 class NamedDecl; 66 class ValueDecl; 67 class VarDecl; 68 class LangOptions; 69 class CodeGenOptions; 70 class DiagnosticsEngine; 71 class AnnotateAttr; 72 class CXXDestructorDecl; 73 class MangleBuffer; 74 class Module; 75 76 namespace CodeGen { 77 78 class CallArgList; 79 class CodeGenFunction; 80 class CodeGenTBAA; 81 class CGCXXABI; 82 class CGDebugInfo; 83 class CGObjCRuntime; 84 class CGOpenCLRuntime; 85 class CGCUDARuntime; 86 class BlockFieldFlags; 87 class FunctionArgList; 88 89 struct OrderGlobalInits { 90 unsigned int priority; 91 unsigned int lex_order; 92 OrderGlobalInits(unsigned int p, unsigned int l) 93 : priority(p), lex_order(l) {} 94 95 bool operator==(const OrderGlobalInits &RHS) const { 96 return priority == RHS.priority && 97 lex_order == RHS.lex_order; 98 } 99 100 bool operator<(const OrderGlobalInits &RHS) const { 101 if (priority < RHS.priority) 102 return true; 103 104 return priority == RHS.priority && lex_order < RHS.lex_order; 105 } 106 }; 107 108 struct CodeGenTypeCache { 109 /// void 110 llvm::Type *VoidTy; 111 112 /// i8, i16, i32, and i64 113 llvm::IntegerType *Int8Ty, *Int16Ty, *Int32Ty, *Int64Ty; 114 /// float, double 115 llvm::Type *FloatTy, *DoubleTy; 116 117 /// int 118 llvm::IntegerType *IntTy; 119 120 /// intptr_t, size_t, and ptrdiff_t, which we assume are the same size. 121 union { 122 llvm::IntegerType *IntPtrTy; 123 llvm::IntegerType *SizeTy; 124 llvm::IntegerType *PtrDiffTy; 125 }; 126 127 /// void* in address space 0 128 union { 129 llvm::PointerType *VoidPtrTy; 130 llvm::PointerType *Int8PtrTy; 131 }; 132 133 /// void** in address space 0 134 union { 135 llvm::PointerType *VoidPtrPtrTy; 136 llvm::PointerType *Int8PtrPtrTy; 137 }; 138 139 /// The width of a pointer into the generic address space. 140 unsigned char PointerWidthInBits; 141 142 /// The size and alignment of a pointer into the generic address 143 /// space. 144 union { 145 unsigned char PointerAlignInBytes; 146 unsigned char PointerSizeInBytes; 147 unsigned char SizeSizeInBytes; // sizeof(size_t) 148 }; 149 150 llvm::CallingConv::ID RuntimeCC; 151 llvm::CallingConv::ID getRuntimeCC() const { 152 return RuntimeCC; 153 } 154 }; 155 156 struct RREntrypoints { 157 RREntrypoints() { memset(this, 0, sizeof(*this)); } 158 /// void objc_autoreleasePoolPop(void*); 159 llvm::Constant *objc_autoreleasePoolPop; 160 161 /// void *objc_autoreleasePoolPush(void); 162 llvm::Constant *objc_autoreleasePoolPush; 163 }; 164 165 struct ARCEntrypoints { 166 ARCEntrypoints() { memset(this, 0, sizeof(*this)); } 167 168 /// id objc_autorelease(id); 169 llvm::Constant *objc_autorelease; 170 171 /// id objc_autoreleaseReturnValue(id); 172 llvm::Constant *objc_autoreleaseReturnValue; 173 174 /// void objc_copyWeak(id *dest, id *src); 175 llvm::Constant *objc_copyWeak; 176 177 /// void objc_destroyWeak(id*); 178 llvm::Constant *objc_destroyWeak; 179 180 /// id objc_initWeak(id*, id); 181 llvm::Constant *objc_initWeak; 182 183 /// id objc_loadWeak(id*); 184 llvm::Constant *objc_loadWeak; 185 186 /// id objc_loadWeakRetained(id*); 187 llvm::Constant *objc_loadWeakRetained; 188 189 /// void objc_moveWeak(id *dest, id *src); 190 llvm::Constant *objc_moveWeak; 191 192 /// id objc_retain(id); 193 llvm::Constant *objc_retain; 194 195 /// id objc_retainAutorelease(id); 196 llvm::Constant *objc_retainAutorelease; 197 198 /// id objc_retainAutoreleaseReturnValue(id); 199 llvm::Constant *objc_retainAutoreleaseReturnValue; 200 201 /// id objc_retainAutoreleasedReturnValue(id); 202 llvm::Constant *objc_retainAutoreleasedReturnValue; 203 204 /// id objc_retainBlock(id); 205 llvm::Constant *objc_retainBlock; 206 207 /// void objc_release(id); 208 llvm::Constant *objc_release; 209 210 /// id objc_storeStrong(id*, id); 211 llvm::Constant *objc_storeStrong; 212 213 /// id objc_storeWeak(id*, id); 214 llvm::Constant *objc_storeWeak; 215 216 /// A void(void) inline asm to use to mark that the return value of 217 /// a call will be immediately retain. 218 llvm::InlineAsm *retainAutoreleasedReturnValueMarker; 219 220 /// void clang.arc.use(...); 221 llvm::Constant *clang_arc_use; 222 }; 223 224 /// CodeGenModule - This class organizes the cross-function state that is used 225 /// while generating LLVM code. 226 class CodeGenModule : public CodeGenTypeCache { 227 CodeGenModule(const CodeGenModule &) LLVM_DELETED_FUNCTION; 228 void operator=(const CodeGenModule &) LLVM_DELETED_FUNCTION; 229 230 typedef std::vector<std::pair<llvm::Constant*, int> > CtorList; 231 232 ASTContext &Context; 233 const LangOptions &LangOpts; 234 const CodeGenOptions &CodeGenOpts; 235 llvm::Module &TheModule; 236 DiagnosticsEngine &Diags; 237 const llvm::DataLayout &TheDataLayout; 238 const TargetInfo &Target; 239 CGCXXABI &ABI; 240 llvm::LLVMContext &VMContext; 241 242 CodeGenTBAA *TBAA; 243 244 mutable const TargetCodeGenInfo *TheTargetCodeGenInfo; 245 246 // This should not be moved earlier, since its initialization depends on some 247 // of the previous reference members being already initialized and also checks 248 // if TheTargetCodeGenInfo is NULL 249 CodeGenTypes Types; 250 251 /// VTables - Holds information about C++ vtables. 252 CodeGenVTables VTables; 253 friend class CodeGenVTables; 254 255 CGObjCRuntime* ObjCRuntime; 256 CGOpenCLRuntime* OpenCLRuntime; 257 CGCUDARuntime* CUDARuntime; 258 CGDebugInfo* DebugInfo; 259 ARCEntrypoints *ARCData; 260 llvm::MDNode *NoObjCARCExceptionsMetadata; 261 RREntrypoints *RRData; 262 263 // WeakRefReferences - A set of references that have only been seen via 264 // a weakref so far. This is used to remove the weak of the reference if we 265 // ever see a direct reference or a definition. 266 llvm::SmallPtrSet<llvm::GlobalValue*, 10> WeakRefReferences; 267 268 /// DeferredDecls - This contains all the decls which have definitions but 269 /// which are deferred for emission and therefore should only be output if 270 /// they are actually used. If a decl is in this, then it is known to have 271 /// not been referenced yet. 272 llvm::StringMap<GlobalDecl> DeferredDecls; 273 274 /// DeferredDeclsToEmit - This is a list of deferred decls which we have seen 275 /// that *are* actually referenced. These get code generated when the module 276 /// is done. 277 std::vector<GlobalDecl> DeferredDeclsToEmit; 278 279 /// DeferredVTables - A queue of (optional) vtables to consider emitting. 280 std::vector<const CXXRecordDecl*> DeferredVTables; 281 282 /// LLVMUsed - List of global values which are required to be 283 /// present in the object file; bitcast to i8*. This is used for 284 /// forcing visibility of symbols which may otherwise be optimized 285 /// out. 286 std::vector<llvm::WeakVH> LLVMUsed; 287 288 /// GlobalCtors - Store the list of global constructors and their respective 289 /// priorities to be emitted when the translation unit is complete. 290 CtorList GlobalCtors; 291 292 /// GlobalDtors - Store the list of global destructors and their respective 293 /// priorities to be emitted when the translation unit is complete. 294 CtorList GlobalDtors; 295 296 /// MangledDeclNames - A map of canonical GlobalDecls to their mangled names. 297 llvm::DenseMap<GlobalDecl, StringRef> MangledDeclNames; 298 llvm::BumpPtrAllocator MangledNamesAllocator; 299 300 /// Global annotations. 301 std::vector<llvm::Constant*> Annotations; 302 303 /// Map used to get unique annotation strings. 304 llvm::StringMap<llvm::Constant*> AnnotationStrings; 305 306 llvm::StringMap<llvm::Constant*> CFConstantStringMap; 307 llvm::StringMap<llvm::GlobalVariable*> ConstantStringMap; 308 llvm::DenseMap<const Decl*, llvm::Constant *> StaticLocalDeclMap; 309 llvm::DenseMap<const Decl*, llvm::GlobalVariable*> StaticLocalDeclGuardMap; 310 llvm::DenseMap<const Expr*, llvm::Constant *> MaterializedGlobalTemporaryMap; 311 312 llvm::DenseMap<QualType, llvm::Constant *> AtomicSetterHelperFnMap; 313 llvm::DenseMap<QualType, llvm::Constant *> AtomicGetterHelperFnMap; 314 315 /// Map used to track internal linkage functions declared within 316 /// extern "C" regions. 317 typedef llvm::MapVector<IdentifierInfo *, 318 llvm::GlobalValue *> StaticExternCMap; 319 StaticExternCMap StaticExternCValues; 320 321 /// \brief thread_local variables defined or used in this TU. 322 std::vector<std::pair<const VarDecl *, llvm::GlobalVariable *> > 323 CXXThreadLocals; 324 325 /// \brief thread_local variables with initializers that need to run 326 /// before any thread_local variable in this TU is odr-used. 327 std::vector<llvm::Constant*> CXXThreadLocalInits; 328 329 /// CXXGlobalInits - Global variables with initializers that need to run 330 /// before main. 331 std::vector<llvm::Constant*> CXXGlobalInits; 332 333 /// When a C++ decl with an initializer is deferred, null is 334 /// appended to CXXGlobalInits, and the index of that null is placed 335 /// here so that the initializer will be performed in the correct 336 /// order. 337 llvm::DenseMap<const Decl*, unsigned> DelayedCXXInitPosition; 338 339 typedef std::pair<OrderGlobalInits, llvm::Function*> GlobalInitData; 340 341 struct GlobalInitPriorityCmp { 342 bool operator()(const GlobalInitData &LHS, 343 const GlobalInitData &RHS) const { 344 return LHS.first.priority < RHS.first.priority; 345 } 346 }; 347 348 /// - Global variables with initializers whose order of initialization 349 /// is set by init_priority attribute. 350 SmallVector<GlobalInitData, 8> PrioritizedCXXGlobalInits; 351 352 /// CXXGlobalDtors - Global destructor functions and arguments that need to 353 /// run on termination. 354 std::vector<std::pair<llvm::WeakVH,llvm::Constant*> > CXXGlobalDtors; 355 356 /// \brief The complete set of modules that has been imported. 357 llvm::SetVector<clang::Module *> ImportedModules; 358 359 /// \brief A vector of metadata strings. 360 SmallVector<llvm::Value *, 16> LinkerOptionsMetadata; 361 362 /// @name Cache for Objective-C runtime types 363 /// @{ 364 365 /// CFConstantStringClassRef - Cached reference to the class for constant 366 /// strings. This value has type int * but is actually an Obj-C class pointer. 367 llvm::WeakVH CFConstantStringClassRef; 368 369 /// ConstantStringClassRef - Cached reference to the class for constant 370 /// strings. This value has type int * but is actually an Obj-C class pointer. 371 llvm::WeakVH ConstantStringClassRef; 372 373 /// \brief The LLVM type corresponding to NSConstantString. 374 llvm::StructType *NSConstantStringType; 375 376 /// \brief The type used to describe the state of a fast enumeration in 377 /// Objective-C's for..in loop. 378 QualType ObjCFastEnumerationStateType; 379 380 /// @} 381 382 /// Lazily create the Objective-C runtime 383 void createObjCRuntime(); 384 385 void createOpenCLRuntime(); 386 void createCUDARuntime(); 387 388 bool isTriviallyRecursive(const FunctionDecl *F); 389 bool shouldEmitFunction(GlobalDecl GD); 390 391 /// @name Cache for Blocks Runtime Globals 392 /// @{ 393 394 llvm::Constant *NSConcreteGlobalBlock; 395 llvm::Constant *NSConcreteStackBlock; 396 397 llvm::Constant *BlockObjectAssign; 398 llvm::Constant *BlockObjectDispose; 399 400 llvm::Type *BlockDescriptorType; 401 llvm::Type *GenericBlockLiteralType; 402 403 struct { 404 int GlobalUniqueCount; 405 } Block; 406 407 /// void @llvm.lifetime.start(i64 %size, i8* nocapture <ptr>) 408 llvm::Constant *LifetimeStartFn; 409 410 /// void @llvm.lifetime.end(i64 %size, i8* nocapture <ptr>) 411 llvm::Constant *LifetimeEndFn; 412 413 GlobalDecl initializedGlobalDecl; 414 415 llvm::SpecialCaseList SanitizerBlacklist; 416 417 const SanitizerOptions &SanOpts; 418 419 /// @} 420 public: 421 CodeGenModule(ASTContext &C, const CodeGenOptions &CodeGenOpts, 422 llvm::Module &M, const llvm::DataLayout &TD, 423 DiagnosticsEngine &Diags); 424 425 ~CodeGenModule(); 426 427 /// Release - Finalize LLVM code generation. 428 void Release(); 429 430 /// getObjCRuntime() - Return a reference to the configured 431 /// Objective-C runtime. 432 CGObjCRuntime &getObjCRuntime() { 433 if (!ObjCRuntime) createObjCRuntime(); 434 return *ObjCRuntime; 435 } 436 437 /// hasObjCRuntime() - Return true iff an Objective-C runtime has 438 /// been configured. 439 bool hasObjCRuntime() { return !!ObjCRuntime; } 440 441 /// getOpenCLRuntime() - Return a reference to the configured OpenCL runtime. 442 CGOpenCLRuntime &getOpenCLRuntime() { 443 assert(OpenCLRuntime != 0); 444 return *OpenCLRuntime; 445 } 446 447 /// getCUDARuntime() - Return a reference to the configured CUDA runtime. 448 CGCUDARuntime &getCUDARuntime() { 449 assert(CUDARuntime != 0); 450 return *CUDARuntime; 451 } 452 453 ARCEntrypoints &getARCEntrypoints() const { 454 assert(getLangOpts().ObjCAutoRefCount && ARCData != 0); 455 return *ARCData; 456 } 457 458 RREntrypoints &getRREntrypoints() const { 459 assert(RRData != 0); 460 return *RRData; 461 } 462 463 llvm::Constant *getStaticLocalDeclAddress(const VarDecl *D) { 464 return StaticLocalDeclMap[D]; 465 } 466 void setStaticLocalDeclAddress(const VarDecl *D, 467 llvm::Constant *C) { 468 StaticLocalDeclMap[D] = C; 469 } 470 471 llvm::GlobalVariable *getStaticLocalDeclGuardAddress(const VarDecl *D) { 472 return StaticLocalDeclGuardMap[D]; 473 } 474 void setStaticLocalDeclGuardAddress(const VarDecl *D, 475 llvm::GlobalVariable *C) { 476 StaticLocalDeclGuardMap[D] = C; 477 } 478 479 llvm::Constant *getAtomicSetterHelperFnMap(QualType Ty) { 480 return AtomicSetterHelperFnMap[Ty]; 481 } 482 void setAtomicSetterHelperFnMap(QualType Ty, 483 llvm::Constant *Fn) { 484 AtomicSetterHelperFnMap[Ty] = Fn; 485 } 486 487 llvm::Constant *getAtomicGetterHelperFnMap(QualType Ty) { 488 return AtomicGetterHelperFnMap[Ty]; 489 } 490 void setAtomicGetterHelperFnMap(QualType Ty, 491 llvm::Constant *Fn) { 492 AtomicGetterHelperFnMap[Ty] = Fn; 493 } 494 495 CGDebugInfo *getModuleDebugInfo() { return DebugInfo; } 496 497 llvm::MDNode *getNoObjCARCExceptionsMetadata() { 498 if (!NoObjCARCExceptionsMetadata) 499 NoObjCARCExceptionsMetadata = 500 llvm::MDNode::get(getLLVMContext(), 501 SmallVector<llvm::Value*,1>()); 502 return NoObjCARCExceptionsMetadata; 503 } 504 505 ASTContext &getContext() const { return Context; } 506 const LangOptions &getLangOpts() const { return LangOpts; } 507 const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; } 508 llvm::Module &getModule() const { return TheModule; } 509 DiagnosticsEngine &getDiags() const { return Diags; } 510 const llvm::DataLayout &getDataLayout() const { return TheDataLayout; } 511 const TargetInfo &getTarget() const { return Target; } 512 CGCXXABI &getCXXABI() { return ABI; } 513 llvm::LLVMContext &getLLVMContext() { return VMContext; } 514 515 bool shouldUseTBAA() const { return TBAA != 0; } 516 517 const TargetCodeGenInfo &getTargetCodeGenInfo(); 518 519 CodeGenTypes &getTypes() { return Types; } 520 521 CodeGenVTables &getVTables() { return VTables; } 522 VTableContext &getVTableContext() { return VTables.getVTableContext(); } 523 524 llvm::MDNode *getTBAAInfo(QualType QTy); 525 llvm::MDNode *getTBAAInfoForVTablePtr(); 526 llvm::MDNode *getTBAAStructInfo(QualType QTy); 527 /// Return the MDNode in the type DAG for the given struct type. 528 llvm::MDNode *getTBAAStructTypeInfo(QualType QTy); 529 /// Return the path-aware tag for given base type, access node and offset. 530 llvm::MDNode *getTBAAStructTagInfo(QualType BaseTy, llvm::MDNode *AccessN, 531 uint64_t O); 532 533 bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor); 534 535 bool isPaddedAtomicType(QualType type); 536 bool isPaddedAtomicType(const AtomicType *type); 537 538 /// Decorate the instruction with a TBAA tag. For scalar TBAA, the tag 539 /// is the same as the type. For struct-path aware TBAA, the tag 540 /// is different from the type: base type, access type and offset. 541 /// When ConvertTypeToTag is true, we create a tag based on the scalar type. 542 void DecorateInstruction(llvm::Instruction *Inst, 543 llvm::MDNode *TBAAInfo, 544 bool ConvertTypeToTag = true); 545 546 /// getSize - Emit the given number of characters as a value of type size_t. 547 llvm::ConstantInt *getSize(CharUnits numChars); 548 549 /// setGlobalVisibility - Set the visibility for the given LLVM 550 /// GlobalValue. 551 void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const; 552 553 /// setTLSMode - Set the TLS mode for the given LLVM GlobalVariable 554 /// for the thread-local variable declaration D. 555 void setTLSMode(llvm::GlobalVariable *GV, const VarDecl &D) const; 556 557 /// TypeVisibilityKind - The kind of global variable that is passed to 558 /// setTypeVisibility 559 enum TypeVisibilityKind { 560 TVK_ForVTT, 561 TVK_ForVTable, 562 TVK_ForConstructionVTable, 563 TVK_ForRTTI, 564 TVK_ForRTTIName 565 }; 566 567 /// setTypeVisibility - Set the visibility for the given global 568 /// value which holds information about a type. 569 void setTypeVisibility(llvm::GlobalValue *GV, const CXXRecordDecl *D, 570 TypeVisibilityKind TVK) const; 571 572 static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V) { 573 switch (V) { 574 case DefaultVisibility: return llvm::GlobalValue::DefaultVisibility; 575 case HiddenVisibility: return llvm::GlobalValue::HiddenVisibility; 576 case ProtectedVisibility: return llvm::GlobalValue::ProtectedVisibility; 577 } 578 llvm_unreachable("unknown visibility!"); 579 } 580 581 llvm::Constant *GetAddrOfGlobal(GlobalDecl GD) { 582 if (isa<CXXConstructorDecl>(GD.getDecl())) 583 return GetAddrOfCXXConstructor(cast<CXXConstructorDecl>(GD.getDecl()), 584 GD.getCtorType()); 585 else if (isa<CXXDestructorDecl>(GD.getDecl())) 586 return GetAddrOfCXXDestructor(cast<CXXDestructorDecl>(GD.getDecl()), 587 GD.getDtorType()); 588 else if (isa<FunctionDecl>(GD.getDecl())) 589 return GetAddrOfFunction(GD); 590 else 591 return GetAddrOfGlobalVar(cast<VarDecl>(GD.getDecl())); 592 } 593 594 /// CreateOrReplaceCXXRuntimeVariable - Will return a global variable of the 595 /// given type. If a variable with a different type already exists then a new 596 /// variable with the right type will be created and all uses of the old 597 /// variable will be replaced with a bitcast to the new variable. 598 llvm::GlobalVariable * 599 CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, 600 llvm::GlobalValue::LinkageTypes Linkage); 601 602 /// GetGlobalVarAddressSpace - Return the address space of the underlying 603 /// global variable for D, as determined by its declaration. Normally this 604 /// is the same as the address space of D's type, but in CUDA, address spaces 605 /// are associated with declarations, not types. 606 unsigned GetGlobalVarAddressSpace(const VarDecl *D, unsigned AddrSpace); 607 608 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 609 /// given global variable. If Ty is non-null and if the global doesn't exist, 610 /// then it will be greated with the specified type instead of whatever the 611 /// normal requested type would be. 612 llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D, 613 llvm::Type *Ty = 0); 614 615 616 /// GetAddrOfFunction - Return the address of the given function. If Ty is 617 /// non-null, then this function will use the specified type if it has to 618 /// create it. 619 llvm::Constant *GetAddrOfFunction(GlobalDecl GD, 620 llvm::Type *Ty = 0, 621 bool ForVTable = false); 622 623 /// GetAddrOfRTTIDescriptor - Get the address of the RTTI descriptor 624 /// for the given type. 625 llvm::Constant *GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH = false); 626 627 /// GetAddrOfUuidDescriptor - Get the address of a uuid descriptor . 628 llvm::Constant *GetAddrOfUuidDescriptor(const CXXUuidofExpr* E); 629 630 /// GetAddrOfThunk - Get the address of the thunk for the given global decl. 631 llvm::Constant *GetAddrOfThunk(GlobalDecl GD, const ThunkInfo &Thunk); 632 633 /// GetWeakRefReference - Get a reference to the target of VD. 634 llvm::Constant *GetWeakRefReference(const ValueDecl *VD); 635 636 /// GetNonVirtualBaseClassOffset - Returns the offset from a derived class to 637 /// a class. Returns null if the offset is 0. 638 llvm::Constant * 639 GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl, 640 CastExpr::path_const_iterator PathBegin, 641 CastExpr::path_const_iterator PathEnd); 642 643 /// A pair of helper functions for a __block variable. 644 class ByrefHelpers : public llvm::FoldingSetNode { 645 public: 646 llvm::Constant *CopyHelper; 647 llvm::Constant *DisposeHelper; 648 649 /// The alignment of the field. This is important because 650 /// different offsets to the field within the byref struct need to 651 /// have different helper functions. 652 CharUnits Alignment; 653 654 ByrefHelpers(CharUnits alignment) : Alignment(alignment) {} 655 virtual ~ByrefHelpers(); 656 657 void Profile(llvm::FoldingSetNodeID &id) const { 658 id.AddInteger(Alignment.getQuantity()); 659 profileImpl(id); 660 } 661 virtual void profileImpl(llvm::FoldingSetNodeID &id) const = 0; 662 663 virtual bool needsCopy() const { return true; } 664 virtual void emitCopy(CodeGenFunction &CGF, 665 llvm::Value *dest, llvm::Value *src) = 0; 666 667 virtual bool needsDispose() const { return true; } 668 virtual void emitDispose(CodeGenFunction &CGF, llvm::Value *field) = 0; 669 }; 670 671 llvm::FoldingSet<ByrefHelpers> ByrefHelpersCache; 672 673 /// getUniqueBlockCount - Fetches the global unique block count. 674 int getUniqueBlockCount() { return ++Block.GlobalUniqueCount; } 675 676 /// getBlockDescriptorType - Fetches the type of a generic block 677 /// descriptor. 678 llvm::Type *getBlockDescriptorType(); 679 680 /// getGenericBlockLiteralType - The type of a generic block literal. 681 llvm::Type *getGenericBlockLiteralType(); 682 683 /// GetAddrOfGlobalBlock - Gets the address of a block which 684 /// requires no captures. 685 llvm::Constant *GetAddrOfGlobalBlock(const BlockExpr *BE, const char *); 686 687 /// GetAddrOfConstantCFString - Return a pointer to a constant CFString object 688 /// for the given string. 689 llvm::Constant *GetAddrOfConstantCFString(const StringLiteral *Literal); 690 691 /// GetAddrOfConstantString - Return a pointer to a constant NSString object 692 /// for the given string. Or a user defined String object as defined via 693 /// -fconstant-string-class=class_name option. 694 llvm::Constant *GetAddrOfConstantString(const StringLiteral *Literal); 695 696 /// GetConstantArrayFromStringLiteral - Return a constant array for the given 697 /// string. 698 llvm::Constant *GetConstantArrayFromStringLiteral(const StringLiteral *E); 699 700 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a constant array 701 /// for the given string literal. 702 llvm::Constant *GetAddrOfConstantStringFromLiteral(const StringLiteral *S); 703 704 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 705 /// array for the given ObjCEncodeExpr node. 706 llvm::Constant *GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *); 707 708 /// GetAddrOfConstantString - Returns a pointer to a character array 709 /// containing the literal. This contents are exactly that of the given 710 /// string, i.e. it will not be null terminated automatically; see 711 /// GetAddrOfConstantCString. Note that whether the result is actually a 712 /// pointer to an LLVM constant depends on Feature.WriteableStrings. 713 /// 714 /// The result has pointer to array type. 715 /// 716 /// \param GlobalName If provided, the name to use for the global 717 /// (if one is created). 718 llvm::Constant *GetAddrOfConstantString(StringRef Str, 719 const char *GlobalName=0, 720 unsigned Alignment=0); 721 722 /// GetAddrOfConstantCString - Returns a pointer to a character array 723 /// containing the literal and a terminating '\0' character. The result has 724 /// pointer to array type. 725 /// 726 /// \param GlobalName If provided, the name to use for the global (if one is 727 /// created). 728 llvm::Constant *GetAddrOfConstantCString(const std::string &str, 729 const char *GlobalName=0, 730 unsigned Alignment=0); 731 732 /// GetAddrOfConstantCompoundLiteral - Returns a pointer to a constant global 733 /// variable for the given file-scope compound literal expression. 734 llvm::Constant *GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr*E); 735 736 /// \brief Returns a pointer to a global variable representing a temporary 737 /// with static or thread storage duration. 738 llvm::Constant *GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, 739 const Expr *Inner); 740 741 /// \brief Retrieve the record type that describes the state of an 742 /// Objective-C fast enumeration loop (for..in). 743 QualType getObjCFastEnumerationStateType(); 744 745 /// GetAddrOfCXXConstructor - Return the address of the constructor of the 746 /// given type. 747 llvm::GlobalValue *GetAddrOfCXXConstructor(const CXXConstructorDecl *ctor, 748 CXXCtorType ctorType, 749 const CGFunctionInfo *fnInfo = 0); 750 751 /// GetAddrOfCXXDestructor - Return the address of the constructor of the 752 /// given type. 753 llvm::GlobalValue *GetAddrOfCXXDestructor(const CXXDestructorDecl *dtor, 754 CXXDtorType dtorType, 755 const CGFunctionInfo *fnInfo = 0, 756 llvm::FunctionType *fnType = 0); 757 758 /// getBuiltinLibFunction - Given a builtin id for a function like 759 /// "__builtin_fabsf", return a Function* for "fabsf". 760 llvm::Value *getBuiltinLibFunction(const FunctionDecl *FD, 761 unsigned BuiltinID); 762 763 llvm::Function *getIntrinsic(unsigned IID, ArrayRef<llvm::Type*> Tys = None); 764 765 /// EmitTopLevelDecl - Emit code for a single top level declaration. 766 void EmitTopLevelDecl(Decl *D); 767 768 /// HandleCXXStaticMemberVarInstantiation - Tell the consumer that this 769 // variable has been instantiated. 770 void HandleCXXStaticMemberVarInstantiation(VarDecl *VD); 771 772 /// \brief If the declaration has internal linkage but is inside an 773 /// extern "C" linkage specification, prepare to emit an alias for it 774 /// to the expected name. 775 template<typename SomeDecl> 776 void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV); 777 778 /// AddUsedGlobal - Add a global which should be forced to be 779 /// present in the object file; these are emitted to the llvm.used 780 /// metadata global. 781 void AddUsedGlobal(llvm::GlobalValue *GV); 782 783 /// AddCXXDtorEntry - Add a destructor and object to add to the C++ global 784 /// destructor function. 785 void AddCXXDtorEntry(llvm::Constant *DtorFn, llvm::Constant *Object) { 786 CXXGlobalDtors.push_back(std::make_pair(DtorFn, Object)); 787 } 788 789 /// CreateRuntimeFunction - Create a new runtime function with the specified 790 /// type and name. 791 llvm::Constant *CreateRuntimeFunction(llvm::FunctionType *Ty, 792 StringRef Name, 793 llvm::AttributeSet ExtraAttrs = 794 llvm::AttributeSet()); 795 /// CreateRuntimeVariable - Create a new runtime global variable with the 796 /// specified type and name. 797 llvm::Constant *CreateRuntimeVariable(llvm::Type *Ty, 798 StringRef Name); 799 800 ///@name Custom Blocks Runtime Interfaces 801 ///@{ 802 803 llvm::Constant *getNSConcreteGlobalBlock(); 804 llvm::Constant *getNSConcreteStackBlock(); 805 llvm::Constant *getBlockObjectAssign(); 806 llvm::Constant *getBlockObjectDispose(); 807 808 ///@} 809 810 llvm::Constant *getLLVMLifetimeStartFn(); 811 llvm::Constant *getLLVMLifetimeEndFn(); 812 813 // UpdateCompleteType - Make sure that this type is translated. 814 void UpdateCompletedType(const TagDecl *TD); 815 816 llvm::Constant *getMemberPointerConstant(const UnaryOperator *e); 817 818 /// EmitConstantInit - Try to emit the initializer for the given declaration 819 /// as a constant; returns 0 if the expression cannot be emitted as a 820 /// constant. 821 llvm::Constant *EmitConstantInit(const VarDecl &D, CodeGenFunction *CGF = 0); 822 823 /// EmitConstantExpr - Try to emit the given expression as a 824 /// constant; returns 0 if the expression cannot be emitted as a 825 /// constant. 826 llvm::Constant *EmitConstantExpr(const Expr *E, QualType DestType, 827 CodeGenFunction *CGF = 0); 828 829 /// EmitConstantValue - Emit the given constant value as a constant, in the 830 /// type's scalar representation. 831 llvm::Constant *EmitConstantValue(const APValue &Value, QualType DestType, 832 CodeGenFunction *CGF = 0); 833 834 /// EmitConstantValueForMemory - Emit the given constant value as a constant, 835 /// in the type's memory representation. 836 llvm::Constant *EmitConstantValueForMemory(const APValue &Value, 837 QualType DestType, 838 CodeGenFunction *CGF = 0); 839 840 /// EmitNullConstant - Return the result of value-initializing the given 841 /// type, i.e. a null expression of the given type. This is usually, 842 /// but not always, an LLVM null constant. 843 llvm::Constant *EmitNullConstant(QualType T); 844 845 /// EmitNullConstantForBase - Return a null constant appropriate for 846 /// zero-initializing a base class with the given type. This is usually, 847 /// but not always, an LLVM null constant. 848 llvm::Constant *EmitNullConstantForBase(const CXXRecordDecl *Record); 849 850 /// Error - Emit a general error that something can't be done. 851 void Error(SourceLocation loc, StringRef error); 852 853 /// ErrorUnsupported - Print out an error that codegen doesn't support the 854 /// specified stmt yet. 855 /// \param OmitOnError - If true, then this error should only be emitted if no 856 /// other errors have been reported. 857 void ErrorUnsupported(const Stmt *S, const char *Type, 858 bool OmitOnError=false); 859 860 /// ErrorUnsupported - Print out an error that codegen doesn't support the 861 /// specified decl yet. 862 /// \param OmitOnError - If true, then this error should only be emitted if no 863 /// other errors have been reported. 864 void ErrorUnsupported(const Decl *D, const char *Type, 865 bool OmitOnError=false); 866 867 /// SetInternalFunctionAttributes - Set the attributes on the LLVM 868 /// function for the given decl and function info. This applies 869 /// attributes necessary for handling the ABI as well as user 870 /// specified attributes like section. 871 void SetInternalFunctionAttributes(const Decl *D, llvm::Function *F, 872 const CGFunctionInfo &FI); 873 874 /// SetLLVMFunctionAttributes - Set the LLVM function attributes 875 /// (sext, zext, etc). 876 void SetLLVMFunctionAttributes(const Decl *D, 877 const CGFunctionInfo &Info, 878 llvm::Function *F); 879 880 /// SetLLVMFunctionAttributesForDefinition - Set the LLVM function attributes 881 /// which only apply to a function definintion. 882 void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F); 883 884 /// ReturnTypeUsesSRet - Return true iff the given type uses 'sret' when used 885 /// as a return type. 886 bool ReturnTypeUsesSRet(const CGFunctionInfo &FI); 887 888 /// ReturnTypeUsesFPRet - Return true iff the given type uses 'fpret' when 889 /// used as a return type. 890 bool ReturnTypeUsesFPRet(QualType ResultType); 891 892 /// ReturnTypeUsesFP2Ret - Return true iff the given type uses 'fp2ret' when 893 /// used as a return type. 894 bool ReturnTypeUsesFP2Ret(QualType ResultType); 895 896 /// ConstructAttributeList - Get the LLVM attributes and calling convention to 897 /// use for a particular function type. 898 /// 899 /// \param Info - The function type information. 900 /// \param TargetDecl - The decl these attributes are being constructed 901 /// for. If supplied the attributes applied to this decl may contribute to the 902 /// function attributes and calling convention. 903 /// \param PAL [out] - On return, the attribute list to use. 904 /// \param CallingConv [out] - On return, the LLVM calling convention to use. 905 void ConstructAttributeList(const CGFunctionInfo &Info, 906 const Decl *TargetDecl, 907 AttributeListType &PAL, 908 unsigned &CallingConv, 909 bool AttrOnCallSite); 910 911 StringRef getMangledName(GlobalDecl GD); 912 void getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer, 913 const BlockDecl *BD); 914 915 void EmitTentativeDefinition(const VarDecl *D); 916 917 void EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired); 918 919 /// \brief Appends Opts to the "Linker Options" metadata value. 920 void AppendLinkerOptions(StringRef Opts); 921 922 /// \brief Appends a detect mismatch command to the linker options. 923 void AddDetectMismatch(StringRef Name, StringRef Value); 924 925 /// \brief Appends a dependent lib to the "Linker Options" metadata value. 926 void AddDependentLib(StringRef Lib); 927 928 llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD); 929 930 void setFunctionLinkage(GlobalDecl GD, llvm::GlobalValue *V) { 931 V->setLinkage(getFunctionLinkage(GD)); 932 } 933 934 /// getVTableLinkage - Return the appropriate linkage for the vtable, VTT, 935 /// and type information of the given class. 936 llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD); 937 938 /// GetTargetTypeStoreSize - Return the store size, in character units, of 939 /// the given LLVM type. 940 CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const; 941 942 /// GetLLVMLinkageVarDefinition - Returns LLVM linkage for a global 943 /// variable. 944 llvm::GlobalValue::LinkageTypes 945 GetLLVMLinkageVarDefinition(const VarDecl *D, bool isConstant); 946 947 /// Emit all the global annotations. 948 void EmitGlobalAnnotations(); 949 950 /// Emit an annotation string. 951 llvm::Constant *EmitAnnotationString(StringRef Str); 952 953 /// Emit the annotation's translation unit. 954 llvm::Constant *EmitAnnotationUnit(SourceLocation Loc); 955 956 /// Emit the annotation line number. 957 llvm::Constant *EmitAnnotationLineNo(SourceLocation L); 958 959 /// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 960 /// annotation information for a given GlobalValue. The annotation struct is 961 /// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 962 /// GlobalValue being annotated. The second field is the constant string 963 /// created from the AnnotateAttr's annotation. The third field is a constant 964 /// string containing the name of the translation unit. The fourth field is 965 /// the line number in the file of the annotated value declaration. 966 llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV, 967 const AnnotateAttr *AA, 968 SourceLocation L); 969 970 /// Add global annotations that are set on D, for the global GV. Those 971 /// annotations are emitted during finalization of the LLVM code. 972 void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV); 973 974 const llvm::SpecialCaseList &getSanitizerBlacklist() const { 975 return SanitizerBlacklist; 976 } 977 978 const SanitizerOptions &getSanOpts() const { return SanOpts; } 979 980 void addDeferredVTable(const CXXRecordDecl *RD) { 981 DeferredVTables.push_back(RD); 982 } 983 984 /// EmitGlobal - Emit code for a singal global function or var decl. Forward 985 /// declarations are emitted lazily. 986 void EmitGlobal(GlobalDecl D); 987 988 private: 989 llvm::GlobalValue *GetGlobalValue(StringRef Ref); 990 991 llvm::Constant *GetOrCreateLLVMFunction(StringRef MangledName, 992 llvm::Type *Ty, 993 GlobalDecl D, 994 bool ForVTable, 995 llvm::AttributeSet ExtraAttrs = 996 llvm::AttributeSet()); 997 llvm::Constant *GetOrCreateLLVMGlobal(StringRef MangledName, 998 llvm::PointerType *PTy, 999 const VarDecl *D, 1000 bool UnnamedAddr = false); 1001 1002 /// SetCommonAttributes - Set attributes which are common to any 1003 /// form of a global definition (alias, Objective-C method, 1004 /// function, global variable). 1005 /// 1006 /// NOTE: This should only be called for definitions. 1007 void SetCommonAttributes(const Decl *D, llvm::GlobalValue *GV); 1008 1009 /// SetFunctionDefinitionAttributes - Set attributes for a global definition. 1010 void SetFunctionDefinitionAttributes(const FunctionDecl *D, 1011 llvm::GlobalValue *GV); 1012 1013 /// SetFunctionAttributes - Set function attributes for a function 1014 /// declaration. 1015 void SetFunctionAttributes(GlobalDecl GD, 1016 llvm::Function *F, 1017 bool IsIncompleteFunction); 1018 1019 void EmitGlobalDefinition(GlobalDecl D); 1020 1021 void EmitGlobalFunctionDefinition(GlobalDecl GD); 1022 void EmitGlobalVarDefinition(const VarDecl *D); 1023 void EmitAliasDefinition(GlobalDecl GD); 1024 void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D); 1025 void EmitObjCIvarInitializations(ObjCImplementationDecl *D); 1026 1027 // C++ related functions. 1028 1029 bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target); 1030 bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D); 1031 1032 void EmitNamespace(const NamespaceDecl *D); 1033 void EmitLinkageSpec(const LinkageSpecDecl *D); 1034 void CompleteDIClassType(const CXXMethodDecl* D); 1035 1036 /// EmitCXXConstructor - Emit a single constructor with the given type from 1037 /// a C++ constructor Decl. 1038 void EmitCXXConstructor(const CXXConstructorDecl *D, CXXCtorType Type); 1039 1040 /// EmitCXXDestructor - Emit a single destructor with the given type from 1041 /// a C++ destructor Decl. 1042 void EmitCXXDestructor(const CXXDestructorDecl *D, CXXDtorType Type); 1043 1044 /// \brief Emit the function that initializes C++ thread_local variables. 1045 void EmitCXXThreadLocalInitFunc(); 1046 1047 /// EmitCXXGlobalInitFunc - Emit the function that initializes C++ globals. 1048 void EmitCXXGlobalInitFunc(); 1049 1050 /// EmitCXXGlobalDtorFunc - Emit the function that destroys C++ globals. 1051 void EmitCXXGlobalDtorFunc(); 1052 1053 /// EmitCXXGlobalVarDeclInitFunc - Emit the function that initializes the 1054 /// specified global (if PerformInit is true) and registers its destructor. 1055 void EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, 1056 llvm::GlobalVariable *Addr, 1057 bool PerformInit); 1058 1059 // FIXME: Hardcoding priority here is gross. 1060 void AddGlobalCtor(llvm::Function *Ctor, int Priority=65535); 1061 void AddGlobalDtor(llvm::Function *Dtor, int Priority=65535); 1062 1063 /// EmitCtorList - Generates a global array of functions and priorities using 1064 /// the given list and name. This array will have appending linkage and is 1065 /// suitable for use as a LLVM constructor or destructor array. 1066 void EmitCtorList(const CtorList &Fns, const char *GlobalName); 1067 1068 /// EmitFundamentalRTTIDescriptor - Emit the RTTI descriptors for the 1069 /// given type. 1070 void EmitFundamentalRTTIDescriptor(QualType Type); 1071 1072 /// EmitFundamentalRTTIDescriptors - Emit the RTTI descriptors for the 1073 /// builtin types. 1074 void EmitFundamentalRTTIDescriptors(); 1075 1076 /// EmitDeferred - Emit any needed decls for which code generation 1077 /// was deferred. 1078 void EmitDeferred(); 1079 1080 /// EmitDeferredVTables - Emit any vtables which we deferred and 1081 /// still have a use for. 1082 void EmitDeferredVTables(); 1083 1084 /// EmitLLVMUsed - Emit the llvm.used metadata used to force 1085 /// references to global which may otherwise be optimized out. 1086 void EmitLLVMUsed(); 1087 1088 /// \brief Emit the link options introduced by imported modules. 1089 void EmitModuleLinkOptions(); 1090 1091 /// \brief Emit aliases for internal-linkage declarations inside "C" language 1092 /// linkage specifications, giving them the "expected" name where possible. 1093 void EmitStaticExternCAliases(); 1094 1095 void EmitDeclMetadata(); 1096 1097 /// EmitCoverageFile - Emit the llvm.gcov metadata used to tell LLVM where 1098 /// to emit the .gcno and .gcda files in a way that persists in .bc files. 1099 void EmitCoverageFile(); 1100 1101 /// Emits the initializer for a uuidof string. 1102 llvm::Constant *EmitUuidofInitializer(StringRef uuidstr, QualType IIDType); 1103 1104 /// MayDeferGeneration - Determine if the given decl can be emitted 1105 /// lazily; this is only relevant for definitions. The given decl 1106 /// must be either a function or var decl. 1107 bool MayDeferGeneration(const ValueDecl *D); 1108 1109 /// SimplifyPersonality - Check whether we can use a "simpler", more 1110 /// core exceptions personality function. 1111 void SimplifyPersonality(); 1112 }; 1113 } // end namespace CodeGen 1114 } // end namespace clang 1115 1116 #endif 1117
