From e250b13ab9728e07308672056905936db53ad855 Mon Sep 17 00:00:00 2001 From: Rafael Espindola Date: Mon, 27 Oct 2014 02:35:46 +0000 Subject: [PATCH] LinkModules.cpp: don't repeat names in comments. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@220662 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Linker/LinkModules.cpp | 130 +++++++++++++++++-------------------- 1 file changed, 61 insertions(+), 69 deletions(-) diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 2467f678316..02b8b6503ec 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -36,47 +36,44 @@ using namespace llvm; //===----------------------------------------------------------------------===// namespace { - typedef SmallPtrSet TypeSet; +typedef SmallPtrSet TypeSet; class TypeMapTy : public ValueMapTypeRemapper { - /// MappedTypes - This is a mapping from a source type to a destination type - /// to use. + /// This is a mapping from a source type to a destination type to use. DenseMap MappedTypes; - /// SpeculativeTypes - When checking to see if two subgraphs are isomorphic, - /// we speculatively add types to MappedTypes, but keep track of them here in - /// case we need to roll back. + /// When checking to see if two subgraphs are isomorphic, we speculatively + /// add types to MappedTypes, but keep track of them here in case we need to + /// roll back. SmallVector SpeculativeTypes; - /// SrcDefinitionsToResolve - This is a list of non-opaque structs in the - /// source module that are mapped to an opaque struct in the destination - /// module. + /// This is a list of non-opaque structs in the source module that are mapped + /// to an opaque struct in the destination module. SmallVector SrcDefinitionsToResolve; - /// DstResolvedOpaqueTypes - This is the set of opaque types in the - /// destination modules who are getting a body from the source module. + /// This is the set of opaque types in the destination modules who are + /// getting a body from the source module. SmallPtrSet DstResolvedOpaqueTypes; public: TypeMapTy(TypeSet &Set) : DstStructTypesSet(Set) {} TypeSet &DstStructTypesSet; - /// addTypeMapping - Indicate that the specified type in the destination - /// module is conceptually equivalent to the specified type in the source - /// module. + /// Indicate that the specified type in the destination module is conceptually + /// equivalent to the specified type in the source module. void addTypeMapping(Type *DstTy, Type *SrcTy); /// linkDefinedTypeBodies - Produce a body for an opaque type in the dest /// module from a type definition in the source module. void linkDefinedTypeBodies(); - /// get - Return the mapped type to use for the specified input type from the + /// Return the mapped type to use for the specified input type from the /// source module. Type *get(Type *SrcTy); FunctionType *get(FunctionType *T) {return cast(get((Type*)T));} - /// dump - Dump out the type map for debugging purposes. + /// Dump out the type map for debugging purposes. void dump() const { for (DenseMap::const_iterator I = MappedTypes.begin(), E = MappedTypes.end(); I != E; ++I) { @@ -90,7 +87,7 @@ public: private: Type *getImpl(Type *T); - /// remapType - Implement the ValueMapTypeRemapper interface. + /// Implement the ValueMapTypeRemapper interface. Type *remapType(Type *SrcTy) override { return get(SrcTy); } @@ -119,8 +116,8 @@ void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) { SpeculativeTypes.clear(); } -/// areTypesIsomorphic - Recursively walk this pair of types, returning true -/// if they are isomorphic, false if they are not. +/// Recursively walk this pair of types, returning true if they are isomorphic, +/// false if they are not. bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) { // Two types with differing kinds are clearly not isomorphic. if (DstTy->getTypeID() != SrcTy->getTypeID()) return false; @@ -204,8 +201,8 @@ bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) { return true; } -/// linkDefinedTypeBodies - Produce a body for an opaque type in the dest -/// module from a type definition in the source module. +/// Produce a body for an opaque type in the dest module from a type definition +/// in the source module. void TypeMapTy::linkDefinedTypeBodies() { SmallVector Elements; SmallString<16> TmpName; @@ -245,8 +242,6 @@ void TypeMapTy::linkDefinedTypeBodies() { DstResolvedOpaqueTypes.clear(); } -/// get - Return the mapped type to use for the specified input type from the -/// source module. Type *TypeMapTy::get(Type *Ty) { Type *Result = getImpl(Ty); @@ -256,7 +251,7 @@ Type *TypeMapTy::get(Type *Ty) { return Result; } -/// getImpl - This is the recursive version of get(). +/// This is the recursive version of get(). Type *TypeMapTy::getImpl(Type *Ty) { // If we already have an entry for this type, return it. Type **Entry = &MappedTypes[Ty]; @@ -362,9 +357,9 @@ Type *TypeMapTy::getImpl(Type *Ty) { namespace { class ModuleLinker; - /// ValueMaterializerTy - Creates prototypes for functions that are lazily - /// linked on the fly. This speeds up linking for modules with many - /// lazily linked functions of which few get used. + /// Creates prototypes for functions that are lazily linked on the fly. This + /// speeds up linking for modules with many/ lazily linked functions of which + /// few get used. class ValueMaterializerTy : public ValueMaterializer { TypeMapTy &TypeMap; Module *DstM; @@ -393,18 +388,18 @@ namespace { void LinkDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; } } - /// ModuleLinker - This is an implementation class for the LinkModules - /// function, which is the entrypoint for this file. + /// This is an implementation class for the LinkModules function, which is the + /// entrypoint for this file. class ModuleLinker { Module *DstM, *SrcM; TypeMapTy TypeMap; ValueMaterializerTy ValMaterializer; - /// ValueMap - Mapping of values from what they used to be in Src, to what - /// they are now in DstM. ValueToValueMapTy is a ValueMap, which involves - /// some overhead due to the use of Value handles which the Linker doesn't - /// actually need, but this allows us to reuse the ValueMapper code. + /// Mapping of values from what they used to be in Src, to what they are now + /// in DstM. ValueToValueMapTy is a ValueMap, which involves some overhead + /// due to the use of Value handles which the Linker doesn't actually need, + /// but this allows us to reuse the ValueMapper code. ValueToValueMapTy ValueMap; struct AppendingVarInfo { @@ -456,15 +451,15 @@ namespace { bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK, bool &LinkFromSrc); - /// getLinkageResult - This analyzes the two global values and determines - /// what the result will look like in the destination module. + /// This analyzes the two global values and determines what the result will + /// look like in the destination module. bool getLinkageResult(GlobalValue *Dest, const GlobalValue *Src, GlobalValue::LinkageTypes <, GlobalValue::VisibilityTypes &Vis, bool &LinkFromSrc); - /// getLinkedToGlobal - Given a global in the source module, return the - /// global in the destination module that is being linked to, if any. + /// Given a global in the source module, return the global in the + /// destination module that is being linked to, if any. GlobalValue *getLinkedToGlobal(GlobalValue *SrcGV) { // If the source has no name it can't link. If it has local linkage, // there is no name match-up going on. @@ -503,9 +498,9 @@ namespace { }; } -/// forceRenaming - The LLVM SymbolTable class autorenames globals that conflict -/// in the symbol table. This is good for all clients except for us. Go -/// through the trouble to force this back. +/// The LLVM SymbolTable class autorenames globals that conflict in the symbol +/// table. This is good for all clients except for us. Go through the trouble +/// to force this back. static void forceRenaming(GlobalValue *GV, StringRef Name) { // If the global doesn't force its name or if it already has the right name, // there is nothing for us to do. @@ -524,8 +519,8 @@ static void forceRenaming(GlobalValue *GV, StringRef Name) { } } -/// copyGVAttributes - copy additional attributes (those not needed to construct -/// a GlobalValue) from the SrcGV to the DestGV. +/// copy additional attributes (those not needed to construct a GlobalValue) +/// from the SrcGV to the DestGV. static void copyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) { // Use the maximum alignment, rather than just copying the alignment of SrcGV. auto *DestGO = dyn_cast(DestGV); @@ -789,10 +784,10 @@ bool ModuleLinker::getLinkageResult(GlobalValue *Dest, const GlobalValue *Src, return false; } -/// computeTypeMapping - Loop over all of the linked values to compute type -/// mappings. For example, if we link "extern Foo *x" and "Foo *x = NULL", then -/// we have two struct types 'Foo' but one got renamed when the module was -/// loaded into the same LLVMContext. +/// Loop over all of the linked values to compute type mappings. For example, +/// if we link "extern Foo *x" and "Foo *x = NULL", then we have two struct +/// types 'Foo' but one got renamed when the module was loaded into the same +/// LLVMContext. void ModuleLinker::computeTypeMapping() { // Incorporate globals. for (Module::global_iterator I = SrcM->global_begin(), @@ -944,8 +939,8 @@ void ModuleLinker::upgradeMismatchedGlobals() { upgradeMismatchedGlobalArray("llvm.global_dtors"); } -/// linkAppendingVarProto - If there were any appending global variables, link -/// them together now. Return true on error. +/// If there were any appending global variables, link them together now. +/// Return true on error. bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV, GlobalVariable *SrcGV) { @@ -1012,8 +1007,8 @@ bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV, return false; } -/// linkGlobalProto - Loop through the global variables in the src module and -/// merge them into the dest module. +/// Loop through the global variables in the src module and merge them into the +/// dest module. bool ModuleLinker::linkGlobalProto(GlobalVariable *SGV) { GlobalValue *DGV = getLinkedToGlobal(SGV); llvm::Optional NewVisibility; @@ -1114,8 +1109,8 @@ bool ModuleLinker::linkGlobalProto(GlobalVariable *SGV) { return false; } -/// linkFunctionProto - Link the function in the source module into the -/// destination module if needed, setting up mapping information. +/// Link the function in the source module into the destination module if +/// needed, setting up mapping information. bool ModuleLinker::linkFunctionProto(Function *SF) { GlobalValue *DGV = getLinkedToGlobal(SF); llvm::Optional NewVisibility; @@ -1195,8 +1190,7 @@ bool ModuleLinker::linkFunctionProto(Function *SF) { return false; } -/// LinkAliasProto - Set up prototypes for any aliases that come over from the -/// source module. +/// Set up prototypes for any aliases that come over from the source module. bool ModuleLinker::linkAliasProto(GlobalAlias *SGA) { GlobalValue *DGV = getLinkedToGlobal(SGA); llvm::Optional NewVisibility; @@ -1305,8 +1299,8 @@ void ModuleLinker::linkAppendingVarInit(const AppendingVarInfo &AVI) { AVI.NewGV->setInitializer(ConstantArray::get(NewType, DstElements)); } -/// linkGlobalInits - Update the initializers in the Dest module now that all -/// globals that may be referenced are in Dest. +/// Update the initializers in the Dest module now that all globals that may be +/// referenced are in Dest. void ModuleLinker::linkGlobalInits() { // Loop over all of the globals in the src module, mapping them over as we go for (Module::const_global_iterator I = SrcM->global_begin(), @@ -1323,9 +1317,9 @@ void ModuleLinker::linkGlobalInits() { } } -/// linkFunctionBody - Copy the source function over into the dest function and -/// fix up references to values. At this point we know that Dest is an external -/// function, and that Src is not. +/// Copy the source function over into the dest function and fix up references +/// to values. At this point we know that Dest is an external function, and +/// that Src is not. void ModuleLinker::linkFunctionBody(Function *Dst, Function *Src) { assert(Src && Dst && Dst->isDeclaration() && !Src->isDeclaration()); @@ -1366,7 +1360,7 @@ void ModuleLinker::linkFunctionBody(Function *Dst, Function *Src) { } -/// linkAliasBodies - Insert all of the aliases in Src into the Dest module. +/// Insert all of the aliases in Src into the Dest module. void ModuleLinker::linkAliasBodies() { for (Module::alias_iterator I = SrcM->alias_begin(), E = SrcM->alias_end(); I != E; ++I) { @@ -1381,8 +1375,7 @@ void ModuleLinker::linkAliasBodies() { } } -/// linkNamedMDNodes - Insert all of the named MDNodes in Src into the Dest -/// module. +/// Insert all of the named MDNodes in Src into the Dest module. void ModuleLinker::linkNamedMDNodes() { const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); for (Module::const_named_metadata_iterator I = SrcM->named_metadata_begin(), @@ -1397,8 +1390,7 @@ void ModuleLinker::linkNamedMDNodes() { } } -/// linkModuleFlagsMetadata - Merge the linker flags in Src into the Dest -/// module. +/// Merge the linker flags in Src into the Dest module. bool ModuleLinker::linkModuleFlagsMetadata() { // If the source module has no module flags, we are done. const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); @@ -1752,11 +1744,11 @@ bool Linker::linkInModule(Module *Src, unsigned Mode) { // LinkModules entrypoint. //===----------------------------------------------------------------------===// -/// LinkModules - This function links two modules together, with the resulting -/// Dest module modified to be the composite of the two input modules. If an -/// error occurs, true is returned and ErrorMsg (if not null) is set to indicate -/// the problem. Upon failure, the Dest module could be in a modified state, -/// and shouldn't be relied on to be consistent. +/// This function links two modules together, with the resulting Dest module +/// modified to be the composite of the two input modules. If an error occurs, +/// true is returned and ErrorMsg (if not null) is set to indicate the problem. +/// Upon failure, the Dest module could be in a modified state, and shouldn't be +/// relied on to be consistent. bool Linker::LinkModules(Module *Dest, Module *Src, unsigned Mode) { Linker L(Dest); return L.linkInModule(Src, Mode); -- 2.34.1