diff options
Diffstat (limited to 'lib/CodeGen/CodeGenModule.h')
| -rw-r--r-- | lib/CodeGen/CodeGenModule.h | 155 |
1 files changed, 107 insertions, 48 deletions
diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h index 22c4463b2c810..ee64ed4f2ae20 100644 --- a/lib/CodeGen/CodeGenModule.h +++ b/lib/CodeGen/CodeGenModule.h @@ -324,6 +324,10 @@ private: /// is defined once we get to the end of the of the translation unit. std::vector<GlobalDecl> Aliases; + /// List of multiversion functions that have to be emitted. Used to make sure + /// we properly emit the iFunc. + std::vector<GlobalDecl> MultiVersionFuncs; + typedef llvm::StringMap<llvm::TrackingVH<llvm::Constant> > ReplacementsTy; ReplacementsTy Replacements; @@ -362,6 +366,13 @@ private: llvm::MapVector<GlobalDecl, StringRef> MangledDeclNames; llvm::StringMap<GlobalDecl, llvm::BumpPtrAllocator> Manglings; + // An ordered map of canonical GlobalDecls paired with the cpu-index for + // cpu-specific name manglings. + llvm::MapVector<std::pair<GlobalDecl, unsigned>, StringRef> + CPUSpecificMangledDeclNames; + llvm::StringMap<std::pair<GlobalDecl, unsigned>, llvm::BumpPtrAllocator> + CPUSpecificManglings; + /// Global annotations. std::vector<llvm::Constant*> Annotations; @@ -387,10 +398,10 @@ private: llvm::GlobalValue *> StaticExternCMap; StaticExternCMap StaticExternCValues; - /// \brief thread_local variables defined or used in this TU. + /// thread_local variables defined or used in this TU. std::vector<const VarDecl *> CXXThreadLocals; - /// \brief thread_local variables with initializers that need to run + /// thread_local variables with initializers that need to run /// before any thread_local variable in this TU is odr-used. std::vector<llvm::Function *> CXXThreadLocalInits; std::vector<const VarDecl *> CXXThreadLocalInitVars; @@ -421,14 +432,14 @@ private: /// Global destructor functions and arguments that need to run on termination. std::vector<std::pair<llvm::WeakTrackingVH, llvm::Constant *>> CXXGlobalDtors; - /// \brief The complete set of modules that has been imported. + /// The complete set of modules that has been imported. llvm::SetVector<clang::Module *> ImportedModules; - /// \brief The set of modules for which the module initializers + /// The set of modules for which the module initializers /// have been emitted. llvm::SmallPtrSet<clang::Module *, 16> EmittedModuleInitializers; - /// \brief A vector of metadata strings. + /// A vector of metadata strings. SmallVector<llvm::MDNode *, 16> LinkerOptionsMetadata; /// @name Cache for Objective-C runtime types @@ -438,7 +449,7 @@ private: /// int * but is actually an Obj-C class pointer. llvm::WeakTrackingVH CFConstantStringClassRef; - /// \brief The type used to describe the state of a fast enumeration in + /// The type used to describe the state of a fast enumeration in /// Objective-C's for..in loop. QualType ObjCFastEnumerationStateType; @@ -499,6 +510,7 @@ private: /// MDNodes. typedef llvm::DenseMap<QualType, llvm::Metadata *> MetadataTypeMap; MetadataTypeMap MetadataIdMap; + MetadataTypeMap VirtualMetadataIdMap; MetadataTypeMap GeneralizedMetadataIdMap; public: @@ -685,6 +697,11 @@ public: TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB); + /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the + /// purposes of memory transfer calls. + TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, + TBAAAccessInfo SrcInfo); + /// getTBAAInfoForSubobject - Get TBAA information for an access with a given /// base lvalue. TBAAAccessInfo getTBAAInfoForSubobject(LValue Base, QualType AccessType) { @@ -710,8 +727,19 @@ public: llvm::ConstantInt *getSize(CharUnits numChars); /// Set the visibility for the given LLVM GlobalValue. - void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D, - ForDefinition_t IsForDefinition) const; + void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const; + + void setGlobalVisibilityAndLocal(llvm::GlobalValue *GV, + const NamedDecl *D) const; + + void setDSOLocal(llvm::GlobalValue *GV) const; + + void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const; + void setDLLImportDLLExport(llvm::GlobalValue *GV, const NamedDecl *D) const; + /// Set visibility, dllimport/dllexport and dso_local. + /// This must be called after dllimport/dllexport is set. + void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const; + void setGVProperties(llvm::GlobalValue *GV, const NamedDecl *D) const; /// Set the TLS mode for the given LLVM GlobalValue for the thread-local /// variable declaration D. @@ -757,7 +785,7 @@ public: /// Return the llvm::Constant for the address of the given global variable. /// If Ty is non-null and if the global doesn't exist, then it will be created /// with the specified type instead of whatever the normal requested type - /// would be. If IsForDefinition is true, it is guranteed that an actual + /// would be. If IsForDefinition is true, it is guaranteed that an actual /// global with type Ty will be returned, not conversion of a variable with /// the same mangled name but some other type. llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D, @@ -765,6 +793,13 @@ public: ForDefinition_t IsForDefinition = NotForDefinition); + /// Return the AST address space of string literal, which is used to emit + /// the string literal as global variable in LLVM IR. + /// Note: This is not necessarily the address space of the string literal + /// in AST. For address space agnostic language, e.g. C++, string literal + /// in AST is always in default address space. + LangAS getStringLiteralAddressSpace() const; + /// Return the address of the given function. If Ty is non-null, then this /// function will use the specified type if it has to create it. llvm::Constant *GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty = nullptr, @@ -780,7 +815,8 @@ public: ConstantAddress GetAddrOfUuidDescriptor(const CXXUuidofExpr* E); /// Get the address of the thunk for the given global decl. - llvm::Constant *GetAddrOfThunk(GlobalDecl GD, const ThunkInfo &Thunk); + llvm::Constant *GetAddrOfThunk(StringRef Name, llvm::Type *FnTy, + GlobalDecl GD); /// Get a reference to the target of VD. ConstantAddress GetWeakRefReference(const ValueDecl *VD); @@ -879,12 +915,12 @@ public: void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV); - /// \brief Returns a pointer to a global variable representing a temporary + /// Returns a pointer to a global variable representing a temporary /// with static or thread storage duration. ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner); - /// \brief Retrieve the record type that describes the state of an + /// Retrieve the record type that describes the state of an /// Objective-C fast enumeration loop (for..in). QualType getObjCFastEnumerationStateType(); @@ -912,22 +948,22 @@ public: /// Emit code for a single top level declaration. void EmitTopLevelDecl(Decl *D); - /// \brief Stored a deferred empty coverage mapping for an unused + /// Stored a deferred empty coverage mapping for an unused /// and thus uninstrumented top level declaration. void AddDeferredUnusedCoverageMapping(Decl *D); - /// \brief Remove the deferred empty coverage mapping as this + /// Remove the deferred empty coverage mapping as this /// declaration is actually instrumented. void ClearUnusedCoverageMapping(const Decl *D); - /// \brief Emit all the deferred coverage mappings + /// Emit all the deferred coverage mappings /// for the uninstrumented functions. void EmitDeferredUnusedCoverageMappings(); /// Tell the consumer that this variable has been instantiated. void HandleCXXStaticMemberVarInstantiation(VarDecl *VD); - /// \brief If the declaration has internal linkage but is inside an + /// If the declaration has internal linkage but is inside an /// extern "C" linkage specification, prepare to emit an alias for it /// to the expected name. template<typename SomeDecl> @@ -976,7 +1012,7 @@ public: llvm::Constant *getMemberPointerConstant(const UnaryOperator *e); - /// \brief Emit type info if type of an expression is a variably modified + /// Emit type info if type of an expression is a variably modified /// type. Also emit proper debug info for cast types. void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF = nullptr); @@ -1002,7 +1038,7 @@ public: /// Set the attributes on the LLVM function for the given decl and function /// info. This applies attributes necessary for handling the ABI as well as /// user specified attributes like section. - void SetInternalFunctionAttributes(const Decl *D, llvm::Function *F, + void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI); /// Set the LLVM function attributes (sext, zext, etc). @@ -1061,6 +1097,10 @@ public: /// It's up to you to ensure that this is safe. void AddDefaultFnAttrs(llvm::Function &F); + /// Parses the target attributes passed in, and returns only the ones that are + /// valid feature names. + TargetAttr::ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD); + // Fills in the supplied string map with the set of target features for the // passed in function. void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap, @@ -1075,25 +1115,24 @@ public: void RefreshTypeCacheForClass(const CXXRecordDecl *Class); - /// \brief Appends Opts to the "llvm.linker.options" metadata value. + /// Appends Opts to the "llvm.linker.options" metadata value. void AppendLinkerOptions(StringRef Opts); - /// \brief Appends a detect mismatch command to the linker options. + /// Appends a detect mismatch command to the linker options. void AddDetectMismatch(StringRef Name, StringRef Value); - /// \brief Appends a dependent lib to the "llvm.linker.options" metadata + /// Appends a dependent lib to the "llvm.linker.options" metadata /// value. void AddDependentLib(StringRef Lib); + void AddELFLibDirective(StringRef Lib); + llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD); void setFunctionLinkage(GlobalDecl GD, llvm::Function *F) { F->setLinkage(getFunctionLinkage(GD)); } - /// Set the DLL storage class on F. - void setFunctionDLLStorageClass(GlobalDecl GD, llvm::Function *F); - /// Return the appropriate linkage for the vtable, VTT, and type information /// of the given class. llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD); @@ -1158,40 +1197,29 @@ public: DeferredVTables.push_back(RD); } - /// Emit code for a singal global function or var decl. Forward declarations + /// Emit code for a single global function or var decl. Forward declarations /// are emitted lazily. void EmitGlobal(GlobalDecl D); - bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target); bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D); - /// Set attributes for a global definition. - void setFunctionDefinitionAttributes(const FunctionDecl *D, - llvm::Function *F); - llvm::GlobalValue *GetGlobalValue(StringRef Ref); /// Set attributes which are common to any form of a global definition (alias, /// Objective-C method, function, global variable). /// /// NOTE: This should only be called for definitions. - void SetCommonAttributes(const Decl *D, llvm::GlobalValue *GV); - - /// Set attributes which must be preserved by an alias. This includes common - /// attributes (i.e. it includes a call to SetCommonAttributes). - /// - /// NOTE: This should only be called for definitions. - void setAliasAttributes(const Decl *D, llvm::GlobalValue *GV); + void SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV); void addReplacement(StringRef Name, llvm::Constant *C); void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C); - /// \brief Emit a code for threadprivate directive. + /// Emit a code for threadprivate directive. /// \param D Threadprivate declaration. void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D); - /// \brief Emit a code for declare reduction construct. + /// Emit a code for declare reduction construct. void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF = nullptr); @@ -1212,13 +1240,18 @@ public: /// internal identifiers). llvm::Metadata *CreateMetadataIdentifierForType(QualType T); + /// Create a metadata identifier that is intended to be used to check virtual + /// calls via a member function pointer. + llvm::Metadata *CreateMetadataIdentifierForVirtualMemPtrType(QualType T); + /// Create a metadata identifier for the generalization of the given type. /// This may either be an MDString (for external identifiers) or a distinct /// unnamed MDNode (for internal identifiers). llvm::Metadata *CreateMetadataIdentifierGeneralized(QualType T); /// Create and attach type metadata to the given function. - void CreateFunctionTypeMetadata(const FunctionDecl *FD, llvm::Function *F); + void CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD, + llvm::Function *F); /// Returns whether this module needs the "all-vtables" type identifier. bool NeedAllVtablesTypeId() const; @@ -1227,7 +1260,15 @@ public: void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD); - /// \brief Get the declaration of std::terminate for the platform. + /// Return a vector of most-base classes for RD. This is used to implement + /// control flow integrity checks for member function pointers. + /// + /// A most-base class of a class C is defined as a recursive base class of C, + /// including C itself, that does not have any bases. + std::vector<const CXXRecordDecl *> + getMostBaseClasses(const CXXRecordDecl *RD); + + /// Get the declaration of std::terminate for the platform. llvm::Constant *getTerminateFn(); llvm::SanitizerStatReport &getSanStats(); @@ -1247,18 +1288,24 @@ private: llvm::AttributeList ExtraAttrs = llvm::AttributeList(), ForDefinition_t IsForDefinition = NotForDefinition); + llvm::Constant *GetOrCreateMultiVersionIFunc(GlobalDecl GD, + llvm::Type *DeclTy, + const FunctionDecl *FD); + void UpdateMultiVersionNames(GlobalDecl GD, const FunctionDecl *FD); + llvm::Constant *GetOrCreateLLVMGlobal(StringRef MangledName, llvm::PointerType *PTy, const VarDecl *D, ForDefinition_t IsForDefinition = NotForDefinition); - void setNonAliasAttributes(const Decl *D, llvm::GlobalObject *GO); + bool GetCPUAndFeaturesAttributes(const Decl *D, + llvm::AttrBuilder &AttrBuilder); + void setNonAliasAttributes(GlobalDecl GD, llvm::GlobalObject *GO); /// Set function attributes for a function declaration. void SetFunctionAttributes(GlobalDecl GD, llvm::Function *F, - bool IsIncompleteFunction, bool IsThunk, - ForDefinition_t IsForDefinition); + bool IsIncompleteFunction, bool IsThunk); void EmitGlobalDefinition(GlobalDecl D, llvm::GlobalValue *GV = nullptr); @@ -1266,6 +1313,7 @@ private: void EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative = false); void EmitAliasDefinition(GlobalDecl GD); void emitIFuncDefinition(GlobalDecl GD); + void emitCPUDispatchDefinition(GlobalDecl GD); void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D); void EmitObjCIvarInitializations(ObjCImplementationDecl *D); @@ -1274,7 +1322,7 @@ private: void EmitDeclContext(const DeclContext *DC); void EmitLinkageSpec(const LinkageSpecDecl *D); - /// \brief Emit the function that initializes C++ thread_local variables. + /// Emit the function that initializes C++ thread_local variables. void EmitCXXThreadLocalInitFunc(); /// Emit the function that initializes C++ globals. @@ -1319,6 +1367,14 @@ private: void checkAliases(); + std::map<int, llvm::TinyPtrVector<llvm::Function *>> DtorsUsingAtExit; + + /// Register functions annotated with __attribute__((destructor)) using + /// __cxa_atexit, if it is available, or atexit otherwise. + void registerGlobalDtorsWithAtExit(); + + void emitMultiVersionFunctions(); + /// Emit any vtables which we deferred and still have a use for. void EmitDeferredVTables(); @@ -1329,16 +1385,16 @@ private: /// Emit the llvm.used and llvm.compiler.used metadata. void emitLLVMUsed(); - /// \brief Emit the link options introduced by imported modules. + /// Emit the link options introduced by imported modules. void EmitModuleLinkOptions(); - /// \brief Emit aliases for internal-linkage declarations inside "C" language + /// Emit aliases for internal-linkage declarations inside "C" language /// linkage specifications, giving them the "expected" name where possible. void EmitStaticExternCAliases(); void EmitDeclMetadata(); - /// \brief Emit the Clang version as llvm.ident metadata. + /// Emit the Clang version as llvm.ident metadata. void EmitVersionIdentMetadata(); /// Emits target specific Metadata for global declarations. @@ -1373,6 +1429,9 @@ private: void ConstructDefaultFnAttrList(StringRef Name, bool HasOptnone, bool AttrOnCallSite, llvm::AttrBuilder &FuncAttrs); + + llvm::Metadata *CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map, + StringRef Suffix); }; } // end namespace CodeGen |