//===- Linker.cpp - Module Linker Implementation --------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// This file implements the LLVM module linker.
//
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Utils/Linker.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/SymbolTable.h"
-#include "llvm/DerivedTypes.h"
#include "llvm/iOther.h"
-#include "llvm/Constants.h"
+#include "llvm/Assembly/Writer.h"
+using namespace llvm;
// Error - Simple wrapper function to conditionally assign to E and return true.
// This just makes error return conditions a little bit simpler...
return true;
}
-// ResolveTypes - Attempt to link the two specified types together. Return true
-// if there is an error and they cannot yet be linked.
+//
+// Function: ResolveTypes()
+//
+// Description:
+// Attempt to link the two specified types together.
+//
+// Inputs:
+// DestTy - The type to which we wish to resolve.
+// SrcTy - The original type which we want to resolve.
+// Name - The name of the type.
+//
+// Outputs:
+// DestST - The symbol table in which the new type should be placed.
+//
+// Return value:
+// true - There is an error and the types cannot yet be linked.
+// false - No errors.
//
static bool ResolveTypes(const Type *DestTy, const Type *SrcTy,
SymbolTable *DestST, const std::string &Name) {
if (DestTy) // Type _is_ in module, just opaque...
const_cast<OpaqueType*>(cast<OpaqueType>(DestTy))
->refineAbstractTypeTo(SrcTy);
- else
+ else if (!Name.empty())
DestST->insert(Name, const_cast<Type*>(SrcTy));
}
return false;
// recurses down into derived types, merging the used types if the parent types
// are compatible.
//
-static bool RecursiveResolveTypes(const PATypeHolder &DestTy,
- const PATypeHolder &SrcTy,
- SymbolTable *DestST, const std::string &Name){
+static bool RecursiveResolveTypesI(const PATypeHolder &DestTy,
+ const PATypeHolder &SrcTy,
+ SymbolTable *DestST, const std::string &Name,
+ std::vector<std::pair<PATypeHolder, PATypeHolder> > &Pointers) {
const Type *SrcTyT = SrcTy.get();
const Type *DestTyT = DestTy.get();
if (DestTyT == SrcTyT) return false; // If already equal, noop
switch (DestTyT->getPrimitiveID()) {
case Type::FunctionTyID: {
if (cast<FunctionType>(DestTyT)->isVarArg() !=
- cast<FunctionType>(SrcTyT)->isVarArg())
+ cast<FunctionType>(SrcTyT)->isVarArg() ||
+ cast<FunctionType>(DestTyT)->getNumContainedTypes() !=
+ cast<FunctionType>(SrcTyT)->getNumContainedTypes())
return true;
for (unsigned i = 0, e = getFT(DestTy)->getNumContainedTypes(); i != e; ++i)
- if (RecursiveResolveTypes(getFT(DestTy)->getContainedType(i),
- getFT(SrcTy)->getContainedType(i), DestST,Name))
+ if (RecursiveResolveTypesI(getFT(DestTy)->getContainedType(i),
+ getFT(SrcTy)->getContainedType(i), DestST, "",
+ Pointers))
return true;
return false;
}
if (getST(DestTy)->getNumContainedTypes() !=
getST(SrcTy)->getNumContainedTypes()) return 1;
for (unsigned i = 0, e = getST(DestTy)->getNumContainedTypes(); i != e; ++i)
- if (RecursiveResolveTypes(getST(DestTy)->getContainedType(i),
- getST(SrcTy)->getContainedType(i), DestST,Name))
+ if (RecursiveResolveTypesI(getST(DestTy)->getContainedType(i),
+ getST(SrcTy)->getContainedType(i), DestST, "",
+ Pointers))
return true;
return false;
}
const ArrayType *DAT = cast<ArrayType>(DestTy.get());
const ArrayType *SAT = cast<ArrayType>(SrcTy.get());
if (DAT->getNumElements() != SAT->getNumElements()) return true;
- return RecursiveResolveTypes(DAT->getElementType(), SAT->getElementType(),
- DestST, Name);
+ return RecursiveResolveTypesI(DAT->getElementType(), SAT->getElementType(),
+ DestST, "", Pointers);
+ }
+ case Type::PointerTyID: {
+ // If this is a pointer type, check to see if we have already seen it. If
+ // so, we are in a recursive branch. Cut off the search now. We cannot use
+ // an associative container for this search, because the type pointers (keys
+ // in the container) change whenever types get resolved...
+ //
+ for (unsigned i = 0, e = Pointers.size(); i != e; ++i)
+ if (Pointers[i].first == DestTy)
+ return Pointers[i].second != SrcTy;
+
+ // Otherwise, add the current pointers to the vector to stop recursion on
+ // this pair.
+ Pointers.push_back(std::make_pair(DestTyT, SrcTyT));
+ bool Result =
+ RecursiveResolveTypesI(cast<PointerType>(DestTy.get())->getElementType(),
+ cast<PointerType>(SrcTy.get())->getElementType(),
+ DestST, "", Pointers);
+ Pointers.pop_back();
+ return Result;
}
- case Type::PointerTyID:
- return RecursiveResolveTypes(
- cast<PointerType>(DestTy.get())->getElementType(),
- cast<PointerType>(SrcTy.get())->getElementType(),
- DestST, Name);
default: assert(0 && "Unexpected type!"); return true;
}
}
+static bool RecursiveResolveTypes(const PATypeHolder &DestTy,
+ const PATypeHolder &SrcTy,
+ SymbolTable *DestST, const std::string &Name){
+ std::vector<std::pair<PATypeHolder, PATypeHolder> > PointerTypes;
+ return RecursiveResolveTypesI(DestTy, SrcTy, DestST, Name, PointerTypes);
+}
+
// LinkTypes - Go through the symbol table of the Src module and see if any
// types are named in the src module that are not named in the Dst module.
SymbolTable::const_iterator PI = SrcST->find(Type::TypeTy);
if (PI == SrcST->end()) return false; // No named types, do nothing.
- // Some types cannot be resolved immediately becuse they depend on other types
- // being resolved to each other first. This contains a list of types we are
- // waiting to recheck.
+ // Some types cannot be resolved immediately because they depend on other
+ // types being resolved to each other first. This contains a list of types we
+ // are waiting to recheck.
std::vector<std::string> DelayedTypesToResolve;
const SymbolTable::VarMap &VM = PI->second;
}
// If we STILL cannot resolve the types, then there is something wrong.
- // Report the error.
+ // Report the warning and delete one of the names.
if (DelayedTypesToResolve.size() == OldSize) {
- // Build up an error message of all of the mismatched types.
- std::string ErrorMessage;
- for (unsigned i = 0, e = DelayedTypesToResolve.size(); i != e; ++i) {
- const std::string &Name = DelayedTypesToResolve[i];
- const Type *T1 = cast<Type>(VM.find(Name)->second);
- const Type *T2 = cast<Type>(DestST->lookup(Type::TypeTy, Name));
- ErrorMessage += " Type named '" + Name +
- "' conflicts.\n Src='" + T1->getDescription() +
- "'.\n Dest='" + T2->getDescription() + "'\n";
- }
- return Error(Err, "Type conflict between types in modules:\n" +
- ErrorMessage);
+ const std::string &Name = DelayedTypesToResolve.back();
+
+ const Type *T1 = cast<Type>(VM.find(Name)->second);
+ const Type *T2 = cast<Type>(DestST->lookup(Type::TypeTy, Name));
+ std::cerr << "WARNING: Type conflict between types named '" << Name
+ << "'.\n Src='";
+ WriteTypeSymbolic(std::cerr, T1, Src);
+ std::cerr << "'.\n Dest='";
+ WriteTypeSymbolic(std::cerr, T2, Dest);
+ std::cerr << "'\n";
+
+ // Remove the symbol name from the destination.
+ DelayedTypesToResolve.pop_back();
}
}
}
// Check to see if it's a constant that we are interesting in transforming...
if (const Constant *CPV = dyn_cast<Constant>(In)) {
- if (!isa<DerivedType>(CPV->getType()) && !isa<ConstantExpr>(CPV))
+ if ((!isa<DerivedType>(CPV->getType()) && !isa<ConstantExpr>(CPV)) ||
+ isa<ConstantAggregateZero>(CPV))
return const_cast<Constant*>(CPV); // Simple constants stay identical...
Constant *Result = 0;
Value *V2 = RemapOperand(CE->getOperand(1), LocalMap, GlobalMap);
Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(V1),
- cast<Constant>(V2));
+ cast<Constant>(V2));
} else {
assert(0 && "Unknown constant expr type!");
}
return 0;
}
+/// FindGlobalNamed - Look in the specified symbol table for a global with the
+/// specified name and type. If an exactly matching global does not exist, see
+/// if there is a global which is "type compatible" with the specified
+/// name/type. This allows us to resolve things like '%x = global int*' with
+/// '%x = global opaque*'.
+///
+static GlobalValue *FindGlobalNamed(const std::string &Name, const Type *Ty,
+ SymbolTable *ST) {
+ // See if an exact match exists in the symbol table...
+ if (Value *V = ST->lookup(Ty, Name)) return cast<GlobalValue>(V);
+
+ // It doesn't exist exactly, scan through all of the type planes in the symbol
+ // table, checking each of them for a type-compatible version.
+ //
+ for (SymbolTable::iterator I = ST->begin(), E = ST->end(); I != E; ++I)
+ if (I->first != Type::TypeTy) {
+ SymbolTable::VarMap &VM = I->second;
+
+ // Does this type plane contain an entry with the specified name?
+ SymbolTable::type_iterator TI = VM.find(Name);
+ if (TI != VM.end()) {
+ //
+ // Ensure that this type if placed correctly into the symbol table.
+ //
+ assert(TI->second->getType() == I->first && "Type conflict!");
+
+ //
+ // Save a reference to the new type. Resolving the type can modify the
+ // symbol table, invalidating the TI variable.
+ //
+ Value *ValPtr = TI->second;
+
+ //
+ // Determine whether we can fold the two types together, resolving them.
+ // If so, we can use this value.
+ //
+ if (!RecursiveResolveTypes(Ty, I->first, ST, ""))
+ return cast<GlobalValue>(ValPtr);
+ }
+ }
+ return 0; // Otherwise, nothing could be found.
+}
+
// LinkGlobals - Loop through the global variables in the src module and merge
// them into the dest module.
// that may be in a module level symbol table are Global Vars and
// Functions, and they both have distinct, nonoverlapping, possible types.
//
- DGV = cast_or_null<GlobalVariable>(ST->lookup(SGV->getType(),
- SGV->getName()));
+ DGV = cast_or_null<GlobalVariable>(FindGlobalNamed(SGV->getName(),
+ SGV->getType(), ST));
}
assert(SGV->hasInitializer() || SGV->hasExternalLinkage() &&
} else if (DGV->isExternal()) { // If DGV is external but SGV is not...
ValueMap.insert(std::make_pair(SGV, DGV));
DGV->setLinkage(SGV->getLinkage()); // Inherit linkage!
+ } else if (SGV->hasWeakLinkage() || SGV->hasLinkOnceLinkage()) {
+ // At this point we know that DGV has LinkOnce, Appending, Weak, or
+ // External linkage. If DGV is Appending, this is an error.
+ if (DGV->hasAppendingLinkage())
+ return Error(Err, "Linking globals named '" + SGV->getName() +
+ " ' with 'weak' and 'appending' linkage is not allowed!");
+
+ if (SGV->isConstant() != DGV->isConstant())
+ return Error(Err, "Global Variable Collision on '" +
+ SGV->getType()->getDescription() + " %" + SGV->getName() +
+ "' - Global variables differ in const'ness");
+
+ // Otherwise, just perform the link.
+ ValueMap.insert(std::make_pair(SGV, DGV));
+
+ // Linkonce+Weak = Weak
+ if (DGV->hasLinkOnceLinkage() && SGV->hasWeakLinkage())
+ DGV->setLinkage(SGV->getLinkage());
+
+ } else if (DGV->hasWeakLinkage() || DGV->hasLinkOnceLinkage()) {
+ // At this point we know that SGV has LinkOnce, Appending, or External
+ // linkage. If SGV is Appending, this is an error.
+ if (SGV->hasAppendingLinkage())
+ return Error(Err, "Linking globals named '" + SGV->getName() +
+ " ' with 'weak' and 'appending' linkage is not allowed!");
+
+ if (SGV->isConstant() != DGV->isConstant())
+ return Error(Err, "Global Variable Collision on '" +
+ SGV->getType()->getDescription() + " %" + SGV->getName() +
+ "' - Global variables differ in const'ness");
+
+ if (!SGV->hasLinkOnceLinkage())
+ DGV->setLinkage(SGV->getLinkage()); // Inherit linkage!
+ ValueMap.insert(std::make_pair(SGV, DGV));
+
} else if (SGV->getLinkage() != DGV->getLinkage()) {
return Error(Err, "Global variables named '" + SGV->getName() +
"' have different linkage specifiers!");
} else if (SGV->hasExternalLinkage()) {
// Allow linking two exactly identical external global variables...
- if (SGV->isConstant() != DGV->isConstant() ||
- SGV->getInitializer() != DGV->getInitializer())
+ if (SGV->isConstant() != DGV->isConstant())
return Error(Err, "Global Variable Collision on '" +
SGV->getType()->getDescription() + " %" + SGV->getName() +
"' - Global variables differ in const'ness");
- ValueMap.insert(std::make_pair(SGV, DGV));
- } else if (SGV->hasLinkOnceLinkage()) {
- // If the global variable has a name, and that name is already in use in
- // the Dest module, make sure that the name is a compatible global
- // variable...
- //
- // Check to see if the two GV's have the same Const'ness...
- if (SGV->isConstant() != DGV->isConstant())
+
+ if (SGV->getInitializer() != DGV->getInitializer())
return Error(Err, "Global Variable Collision on '" +
SGV->getType()->getDescription() + " %" + SGV->getName() +
- "' - Global variables differ in const'ness");
+ "' - External linkage globals have different initializers");
- // Okay, everything is cool, remember the mapping...
ValueMap.insert(std::make_pair(SGV, DGV));
} else if (SGV->hasAppendingLinkage()) {
// No linking is performed yet. Just insert a new copy of the global, and
GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]);
if (DGV->hasInitializer()) {
- assert(SGV->getLinkage() == DGV->getLinkage());
if (SGV->hasExternalLinkage()) {
if (DGV->getInitializer() != SInit)
return Error(Err, "Global Variable Collision on '" +
SGV->getType()->getDescription() +"':%"+SGV->getName()+
" - Global variables have different initializers");
- } else if (DGV->hasLinkOnceLinkage()) {
+ } else if (DGV->hasLinkOnceLinkage() || DGV->hasWeakLinkage()) {
+ // Nothing is required, mapped values will take the new global
+ // automatically.
+ } else if (SGV->hasLinkOnceLinkage() || SGV->hasWeakLinkage()) {
// Nothing is required, mapped values will take the new global
// automatically.
} else if (DGV->hasAppendingLinkage()) {
// that may be in a module level symbol table are Global Vars and
// Functions, and they both have distinct, nonoverlapping, possible types.
//
- DF = cast_or_null<Function>(ST->lookup(SF->getType(), SF->getName()));
+ DF = cast_or_null<Function>(FindGlobalNamed(SF->getName(), SF->getType(),
+ ST));
if (!DF || SF->hasInternalLinkage() || DF->hasInternalLinkage()) {
// Function does not already exist, simply insert an function signature
ValueMap.insert(std::make_pair(SF, DF));
DF->setLinkage(SF->getLinkage());
+ } else if (SF->hasWeakLinkage() || SF->hasLinkOnceLinkage()) {
+ // At this point we know that DF has LinkOnce, Weak, or External linkage.
+ ValueMap.insert(std::make_pair(SF, DF));
+
+ // Linkonce+Weak = Weak
+ if (DF->hasLinkOnceLinkage() && SF->hasWeakLinkage())
+ DF->setLinkage(SF->getLinkage());
+
+ } else if (DF->hasWeakLinkage() || DF->hasLinkOnceLinkage()) {
+ // At this point we know that SF has LinkOnce or External linkage.
+ ValueMap.insert(std::make_pair(SF, DF));
+ if (!SF->hasLinkOnceLinkage()) // Don't inherit linkonce linkage
+ DF->setLinkage(SF->getLinkage());
+
} else if (SF->getLinkage() != DF->getLinkage()) {
return Error(Err, "Functions named '" + SF->getName() +
"' have different linkage specifiers!");
return Error(Err, "Function '" +
SF->getFunctionType()->getDescription() + "':\"" +
SF->getName() + "\" - Function is already defined!");
- } else if (SF->hasLinkOnceLinkage()) {
- // Completely ignore the source function.
- ValueMap.insert(std::make_pair(SF, DF));
} else {
assert(0 && "Unknown linkage configuration found!");
}
Function *DF = cast<Function>(ValueMap[SF]); // Destination function
// DF not external SF external?
- if (!DF->isExternal()) {
- if (DF->hasLinkOnceLinkage()) continue; // No relinkage for link-once!
- if (Err)
- *Err = "Function '" + (SF->hasName() ? SF->getName() :std::string(""))
- + "' body multiply defined!";
- return true;
+ if (DF->isExternal()) {
+ // Only provide the function body if there isn't one already.
+ if (LinkFunctionBody(DF, SF, ValueMap, Err))
+ return true;
}
-
- if (LinkFunctionBody(DF, SF, ValueMap, Err)) return true;
}
}
return false;
// Merge the initializer...
Inits.reserve(NewSize);
- ConstantArray *I = cast<ConstantArray>(G1->getInitializer());
- for (unsigned i = 0, e = T1->getNumElements(); i != e; ++i)
- Inits.push_back(cast<Constant>(I->getValues()[i]));
- I = cast<ConstantArray>(G2->getInitializer());
- for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
- Inits.push_back(cast<Constant>(I->getValues()[i]));
+ if (ConstantArray *I = dyn_cast<ConstantArray>(G1->getInitializer())) {
+ for (unsigned i = 0, e = T1->getNumElements(); i != e; ++i)
+ Inits.push_back(cast<Constant>(I->getValues()[i]));
+ } else {
+ assert(isa<ConstantAggregateZero>(G1->getInitializer()));
+ Constant *CV = Constant::getNullValue(T1->getElementType());
+ for (unsigned i = 0, e = T1->getNumElements(); i != e; ++i)
+ Inits.push_back(CV);
+ }
+ if (ConstantArray *I = dyn_cast<ConstantArray>(G2->getInitializer())) {
+ for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
+ Inits.push_back(cast<Constant>(I->getValues()[i]));
+ } else {
+ assert(isa<ConstantAggregateZero>(G2->getInitializer()));
+ Constant *CV = Constant::getNullValue(T2->getElementType());
+ for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
+ Inits.push_back(CV);
+ }
NG->setInitializer(ConstantArray::get(NewType, Inits));
Inits.clear();
// the problem. Upon failure, the Dest module could be in a modified state, and
// shouldn't be relied on to be consistent.
//
-bool LinkModules(Module *Dest, const Module *Src, std::string *ErrorMsg) {
- if (Dest->getEndianness() != Src->getEndianness())
+bool llvm::LinkModules(Module *Dest, const Module *Src, std::string *ErrorMsg) {
+ if (Dest->getEndianness() == Module::AnyEndianness)
+ Dest->setEndianness(Src->getEndianness());
+ if (Dest->getPointerSize() == Module::AnyPointerSize)
+ Dest->setPointerSize(Src->getPointerSize());
+
+ if (Src->getEndianness() != Module::AnyEndianness &&
+ Dest->getEndianness() != Src->getEndianness())
std::cerr << "WARNING: Linking two modules of different endianness!\n";
- if (Dest->getPointerSize() != Src->getPointerSize())
+ if (Src->getPointerSize() != Module::AnyPointerSize &&
+ Dest->getPointerSize() != Src->getPointerSize())
std::cerr << "WARNING: Linking two modules of different pointer size!\n";
// LinkTypes - Go through the symbol table of the Src module and see if any
projects / oota-llvm.git / blobdiff