6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-23 01:30:19 +00:00
Code Issues Projects Releases Wiki Activity

LinkModules.cpp: don't repeat names in comments.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@220662 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2014-10-27 02:35:46 +00:00
parent bcc5753df8
commit e250b13ab9
1 changed files with 61 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
lib/Linker/LinkModules.cpp
View File

@ -36,47 +36,44 @@ using namespace llvm;
//===----------------------------------------------------------------------===//
namespace {
typedef SmallPtrSet<StructType*, 32> TypeSet;
typedef SmallPtrSet<StructType *, 32> 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<Type*, Type*> 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<Type*, 16> 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<StructType*, 16> 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<StructType*, 16> 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<FunctionType>(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<Type*, Type*>::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<Type*, 16> 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 &LT,
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<GlobalObject>(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<GlobalValue::VisibilityTypes> 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<GlobalValue::VisibilityTypes> 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<GlobalValue::VisibilityTypes> 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);