#include "llvm/Support/Path.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/ValueMapper.h"
-
-#include "llvm/Support/Debug.h"
using namespace llvm;
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
namespace {
-
class TypeMapTy : public ValueMapTypeRemapper {
/// MappedTypes - This is a mapping from a source type to a destination type
/// to use.
/// DstResolvedOpaqueTypes - 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:
+
/// addTypeMapping - Indicate that the specified type in the destination
/// module is conceptually equivalent to the specified type in the source
/// module.
bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
};
-
-} // end anonymous namespace
-
-/// endsInDotNumber - Check to see if there is a dot in the name followed by a
-/// digit.
-static bool endsInDotNumber(StructType *Ty) {
- size_t DotPos = Ty->getName().rfind('.');
- return DotPos != 0 && DotPos != StringRef::npos &&
- Ty->getName().back() != '.' && isdigit(Ty->getName()[DotPos + 1]);
}
void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {
Entry = DstTy;
return;
}
-
+
// Check to see if these types are recursively isomorphic and establish a
// mapping between them if so.
- if (!areTypesIsomorphic(DstTy, SrcTy))
+ if (!areTypesIsomorphic(DstTy, SrcTy)) {
// Oops, they aren't isomorphic. Just discard this request by rolling out
// any speculative mappings we've established.
for (unsigned i = 0, e = SpeculativeTypes.size(); i != e; ++i)
MappedTypes.erase(SpeculativeTypes[i]);
-
+ }
SpeculativeTypes.clear();
}
Entry = DstTy;
return true;
}
-
+
// Okay, we have two types with identical kinds that we haven't seen before.
// If this is an opaque struct type, special case it.
Entry = DstTy;
SpeculativeTypes.push_back(SrcTy);
- for (unsigned i = 0, e = SrcTy->getNumContainedTypes(); i != e; ++i) {
- Type *SrcSubTy = SrcTy->getContainedType(i);
- Type *DstSubTy = DstTy->getContainedType(i);
-
- if (StructType *DST = dyn_cast<StructType>(DstSubTy))
- if (DST->hasName() && endsInDotNumber(DST))
- std::swap(SrcSubTy, DstSubTy);
-
- if (!areTypesIsomorphic(DstSubTy, SrcSubTy))
+ for (unsigned i = 0, e = SrcTy->getNumContainedTypes(); i != e; ++i)
+ if (!areTypesIsomorphic(DstTy->getContainedType(i),
+ SrcTy->getContainedType(i)))
return false;
- }
// If everything seems to have lined up, then everything is great.
return true;
DstResolvedOpaqueTypes.clear();
}
+
/// get - Return the mapped type to use for the specified input type from the
/// source module.
Type *TypeMapTy::get(Type *Ty) {
// If we already have an entry for this type, return it.
Type **Entry = &MappedTypes[Ty];
if (*Entry) return *Entry;
-
+
// If this is not a named struct type, then just map all of the elements and
// then rebuild the type from inside out.
if (!isa<StructType>(Ty) || cast<StructType>(Ty)->isLiteral()) {
// If the type is opaque, we can just use it directly.
if (STy->isOpaque())
return *Entry = STy;
-
+
// Otherwise we create a new type and resolve its body later. This will be
// resolved by the top level of get().
SrcDefinitionsToResolve.push_back(STy);
return *Entry = DTy;
}
+
+
//===----------------------------------------------------------------------===//
// ModuleLinker implementation.
//===----------------------------------------------------------------------===//
// there is no name match-up going on.
if (!SrcGV->hasName() || SrcGV->hasLocalLinkage())
return 0;
-
+
// Otherwise see if we have a match in the destination module's symtab.
GlobalValue *DGV = DstM->getNamedValue(SrcGV->getName());
if (DGV == 0) return 0;
-
+
// If we found a global with the same name in the dest module, but it has
// internal linkage, we are really not doing any linkage here.
if (DGV->hasLocalLinkage())
void linkAliasBodies();
void linkNamedMDNodes();
};
-} // end anonymous namespace
+}
+
+
/// forceRenaming - The LLVM SymbolTable class autorenames globals that conflict
/// in the symbol table. This is good for all clients except for us. Go
/// we have two struct types 'Foo' but one got renamed when the module was
/// loaded into the same LLVMContext.
void ModuleLinker::computeTypeMapping() {
- return;
// Incorporate globals.
for (Module::global_iterator I = SrcM->global_begin(),
E = SrcM->global_end(); I != E; ++I) {
TypeMap.addTypeMapping(DGV->getType(), I->getType());
}
- // Incorporate types by name, scanning all the types in the source module. At
- // this point, the destination module may have a type "%foo = { i32 }" for
+ // Incorporate types by name, scanning all the types in the source module.
+ // At this point, the destination module may have a type "%foo = { i32 }" for
// example. When the source module got loaded into the same LLVMContext, if
// it had the same type, it would have been renamed to "%foo.42 = { i32 }".
- // Attempt to link these up to clean up the IR.
+ // Though it isn't required for correctness, attempt to link these up to clean
+ // up the IR.
std::vector<StructType*> SrcStructTypes;
SrcM->findUsedStructTypes(SrcStructTypes);
if (!ST->hasName()) continue;
// Check to see if there is a dot in the name followed by a digit.
- if (endsInDotNumber(ST)) continue;
-
- if (endsInDotNumber(ST))
- DstM->dump();
+ size_t DotPos = ST->getName().rfind('.');
+ if (DotPos == 0 || DotPos == StringRef::npos ||
+ ST->getName().back() == '.' || !isdigit(ST->getName()[DotPos+1]))
+ continue;
// Check to see if the destination module has a struct with the prefix name.
- size_t DotPos = ST->getName().rfind('.');
- if (StructType *DST = DstM->getTypeByName(ST->getName().substr(0,DotPos))) {
+ if (StructType *DST = DstM->getTypeByName(ST->getName().substr(0, DotPos)))
// Don't use it if this actually came from the source module. They're in
// the same LLVMContext after all.
if (!SrcStructTypesSet.count(DST))
TypeMap.addTypeMapping(DST, ST);
- }
}
// Don't bother incorporating aliases, they aren't generally typed well.
-
+
// Now that we have discovered all of the type equivalences, get a body for
// any 'opaque' types in the dest module that are now resolved.
TypeMap.linkDefinedTypeBodies();
/// them together now. Return true on error.
bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV,
GlobalVariable *SrcGV) {
+
if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage())
return emitError("Linking globals named '" + SrcGV->getName() +
"': can only link appending global with another appending global!");
OSDN Git Service
