2009-03-03 10:04:23 +00:00
|
|
|
//===- lib/Linker/LinkModules.cpp - Module Linker Implementation ----------===//
|
2005-04-21 22:55:34 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 22:55:34 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-10-13 07:03:50 +00:00
|
|
|
//
|
|
|
|
// This file implements the LLVM module linker.
|
|
|
|
//
|
|
|
|
// Specifically, this:
|
2001-10-15 03:12:52 +00:00
|
|
|
// * Merges global variables between the two modules
|
|
|
|
// * Uninit + Uninit = Init, Init + Uninit = Init, Init + Init = Error if !=
|
2002-05-07 18:36:35 +00:00
|
|
|
// * Merges functions between two modules
|
2001-10-13 07:03:50 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-11-14 23:27:04 +00:00
|
|
|
#include "llvm/Linker.h"
|
2003-11-20 18:23:14 +00:00
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/DerivedTypes.h"
|
2009-07-07 21:07:14 +00:00
|
|
|
#include "llvm/LLVMContext.h"
|
2001-10-14 23:29:15 +00:00
|
|
|
#include "llvm/Module.h"
|
2007-01-06 07:24:44 +00:00
|
|
|
#include "llvm/TypeSymbolTable.h"
|
2007-02-05 20:47:22 +00:00
|
|
|
#include "llvm/ValueSymbolTable.h"
|
2004-07-29 17:30:56 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2003-11-20 18:23:14 +00:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
2006-11-27 10:09:12 +00:00
|
|
|
#include "llvm/Support/Streams.h"
|
2004-09-11 04:25:17 +00:00
|
|
|
#include "llvm/System/Path.h"
|
2008-06-16 21:00:18 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2006-12-07 23:41:45 +00:00
|
|
|
#include <sstream>
|
2004-01-09 06:12:26 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2001-10-14 23:29:15 +00:00
|
|
|
// Error - Simple wrapper function to conditionally assign to E and return true.
|
|
|
|
// This just makes error return conditions a little bit simpler...
|
2003-05-13 21:33:43 +00:00
|
|
|
static inline bool Error(std::string *E, const std::string &Message) {
|
2001-10-14 23:29:15 +00:00
|
|
|
if (E) *E = Message;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2003-11-04 15:22:26 +00:00
|
|
|
// 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.
|
|
|
|
//
|
|
|
|
// 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.
|
2003-05-15 16:30:55 +00:00
|
|
|
//
|
2008-06-16 18:19:05 +00:00
|
|
|
static bool ResolveTypes(const Type *DestTy, const Type *SrcTy) {
|
2003-08-22 06:07:12 +00:00
|
|
|
if (DestTy == SrcTy) return false; // If already equal, noop
|
2008-06-16 18:19:05 +00:00
|
|
|
assert(DestTy && SrcTy && "Can't handle null types");
|
2003-08-22 06:07:12 +00:00
|
|
|
|
2008-06-16 18:19:05 +00:00
|
|
|
if (const OpaqueType *OT = dyn_cast<OpaqueType>(DestTy)) {
|
|
|
|
// Type _is_ in module, just opaque...
|
|
|
|
const_cast<OpaqueType*>(OT)->refineAbstractTypeTo(SrcTy);
|
|
|
|
} else if (const OpaqueType *OT = dyn_cast<OpaqueType>(SrcTy)) {
|
|
|
|
const_cast<OpaqueType*>(OT)->refineAbstractTypeTo(DestTy);
|
|
|
|
} else {
|
|
|
|
return true; // Cannot link types... not-equal and neither is opaque.
|
2003-05-15 16:30:55 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
/// LinkerTypeMap - This implements a map of types that is stable
|
|
|
|
/// even if types are resolved/refined to other types. This is not a general
|
|
|
|
/// purpose map, it is specific to the linker's use.
|
|
|
|
namespace {
|
|
|
|
class LinkerTypeMap : public AbstractTypeUser {
|
|
|
|
typedef DenseMap<const Type*, PATypeHolder> TheMapTy;
|
|
|
|
TheMapTy TheMap;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 23:06:51 +00:00
|
|
|
LinkerTypeMap(const LinkerTypeMap&); // DO NOT IMPLEMENT
|
|
|
|
void operator=(const LinkerTypeMap&); // DO NOT IMPLEMENT
|
|
|
|
public:
|
|
|
|
LinkerTypeMap() {}
|
|
|
|
~LinkerTypeMap() {
|
2008-06-16 21:00:18 +00:00
|
|
|
for (DenseMap<const Type*, PATypeHolder>::iterator I = TheMap.begin(),
|
|
|
|
E = TheMap.end(); I != E; ++I)
|
|
|
|
I->first->removeAbstractTypeUser(this);
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
/// lookup - Return the value for the specified type or null if it doesn't
|
|
|
|
/// exist.
|
|
|
|
const Type *lookup(const Type *Ty) const {
|
|
|
|
TheMapTy::const_iterator I = TheMap.find(Ty);
|
|
|
|
if (I != TheMap.end()) return I->second;
|
|
|
|
return 0;
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
/// erase - Remove the specified type, returning true if it was in the set.
|
|
|
|
bool erase(const Type *Ty) {
|
|
|
|
if (!TheMap.erase(Ty))
|
|
|
|
return false;
|
|
|
|
if (Ty->isAbstract())
|
|
|
|
Ty->removeAbstractTypeUser(this);
|
|
|
|
return true;
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
/// insert - This returns true if the pointer was new to the set, false if it
|
|
|
|
/// was already in the set.
|
|
|
|
bool insert(const Type *Src, const Type *Dst) {
|
2008-07-07 17:46:23 +00:00
|
|
|
if (!TheMap.insert(std::make_pair(Src, PATypeHolder(Dst))).second)
|
2008-06-16 21:00:18 +00:00
|
|
|
return false; // Already in map.
|
|
|
|
if (Src->isAbstract())
|
|
|
|
Src->addAbstractTypeUser(this);
|
|
|
|
return true;
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
protected:
|
|
|
|
/// refineAbstractType - The callback method invoked when an abstract type is
|
|
|
|
/// resolved to another type. An object must override this method to update
|
|
|
|
/// its internal state to reference NewType instead of OldType.
|
|
|
|
///
|
|
|
|
virtual void refineAbstractType(const DerivedType *OldTy,
|
|
|
|
const Type *NewTy) {
|
|
|
|
TheMapTy::iterator I = TheMap.find(OldTy);
|
|
|
|
const Type *DstTy = I->second;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
TheMap.erase(I);
|
|
|
|
if (OldTy->isAbstract())
|
|
|
|
OldTy->removeAbstractTypeUser(this);
|
|
|
|
|
|
|
|
// Don't reinsert into the map if the key is concrete now.
|
|
|
|
if (NewTy->isAbstract())
|
|
|
|
insert(NewTy, DstTy);
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
/// The other case which AbstractTypeUsers must be aware of is when a type
|
|
|
|
/// makes the transition from being abstract (where it has clients on it's
|
|
|
|
/// AbstractTypeUsers list) to concrete (where it does not). This method
|
|
|
|
/// notifies ATU's when this occurs for a type.
|
|
|
|
virtual void typeBecameConcrete(const DerivedType *AbsTy) {
|
|
|
|
TheMap.erase(AbsTy);
|
|
|
|
AbsTy->removeAbstractTypeUser(this);
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
// for debugging...
|
|
|
|
virtual void dump() const {
|
|
|
|
cerr << "AbstractTypeSet!\n";
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-08-22 06:07:12 +00:00
|
|
|
// RecursiveResolveTypes - This is just like ResolveTypes, except that it
|
|
|
|
// recurses down into derived types, merging the used types if the parent types
|
|
|
|
// are compatible.
|
2008-06-16 21:17:12 +00:00
|
|
|
static bool RecursiveResolveTypesI(const Type *DstTy, const Type *SrcTy,
|
2008-06-16 21:00:18 +00:00
|
|
|
LinkerTypeMap &Pointers) {
|
2008-06-16 21:17:12 +00:00
|
|
|
if (DstTy == SrcTy) return false; // If already equal, noop
|
2005-04-21 22:55:34 +00:00
|
|
|
|
2003-08-22 06:07:12 +00:00
|
|
|
// If we found our opaque type, resolve it now!
|
2008-06-16 21:17:12 +00:00
|
|
|
if (isa<OpaqueType>(DstTy) || isa<OpaqueType>(SrcTy))
|
|
|
|
return ResolveTypes(DstTy, SrcTy);
|
2005-04-21 22:55:34 +00:00
|
|
|
|
2003-08-22 06:07:12 +00:00
|
|
|
// Two types cannot be resolved together if they are of different primitive
|
|
|
|
// type. For example, we cannot resolve an int to a float.
|
2008-06-16 21:17:12 +00:00
|
|
|
if (DstTy->getTypeID() != SrcTy->getTypeID()) return true;
|
2003-08-22 06:07:12 +00:00
|
|
|
|
2008-06-16 20:03:01 +00:00
|
|
|
// If neither type is abstract, then they really are just different types.
|
2008-06-16 21:17:12 +00:00
|
|
|
if (!DstTy->isAbstract() && !SrcTy->isAbstract())
|
2008-06-16 20:03:01 +00:00
|
|
|
return true;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2003-08-22 06:07:12 +00:00
|
|
|
// Otherwise, resolve the used type used by this derived type...
|
2008-06-16 21:17:12 +00:00
|
|
|
switch (DstTy->getTypeID()) {
|
2008-06-16 18:27:53 +00:00
|
|
|
default:
|
|
|
|
return true;
|
2003-08-22 06:07:12 +00:00
|
|
|
case Type::FunctionTyID: {
|
2008-06-16 21:17:12 +00:00
|
|
|
const FunctionType *DstFT = cast<FunctionType>(DstTy);
|
|
|
|
const FunctionType *SrcFT = cast<FunctionType>(SrcTy);
|
2008-06-16 19:55:40 +00:00
|
|
|
if (DstFT->isVarArg() != SrcFT->isVarArg() ||
|
|
|
|
DstFT->getNumContainedTypes() != SrcFT->getNumContainedTypes())
|
2003-08-22 19:12:55 +00:00
|
|
|
return true;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:17:12 +00:00
|
|
|
// Use TypeHolder's so recursive resolution won't break us.
|
|
|
|
PATypeHolder ST(SrcFT), DT(DstFT);
|
|
|
|
for (unsigned i = 0, e = DstFT->getNumContainedTypes(); i != e; ++i) {
|
|
|
|
const Type *SE = ST->getContainedType(i), *DE = DT->getContainedType(i);
|
|
|
|
if (SE != DE && RecursiveResolveTypesI(DE, SE, Pointers))
|
2003-08-22 06:07:12 +00:00
|
|
|
return true;
|
2008-06-16 21:17:12 +00:00
|
|
|
}
|
2003-08-22 06:07:12 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
case Type::StructTyID: {
|
2008-06-16 21:17:12 +00:00
|
|
|
const StructType *DstST = cast<StructType>(DstTy);
|
|
|
|
const StructType *SrcST = cast<StructType>(SrcTy);
|
2008-06-16 19:55:40 +00:00
|
|
|
if (DstST->getNumContainedTypes() != SrcST->getNumContainedTypes())
|
2008-06-16 18:27:53 +00:00
|
|
|
return true;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:17:12 +00:00
|
|
|
PATypeHolder ST(SrcST), DT(DstST);
|
|
|
|
for (unsigned i = 0, e = DstST->getNumContainedTypes(); i != e; ++i) {
|
|
|
|
const Type *SE = ST->getContainedType(i), *DE = DT->getContainedType(i);
|
|
|
|
if (SE != DE && RecursiveResolveTypesI(DE, SE, Pointers))
|
2003-08-22 06:07:12 +00:00
|
|
|
return true;
|
2008-06-16 21:17:12 +00:00
|
|
|
}
|
2003-08-22 06:07:12 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
case Type::ArrayTyID: {
|
2008-06-16 21:17:12 +00:00
|
|
|
const ArrayType *DAT = cast<ArrayType>(DstTy);
|
|
|
|
const ArrayType *SAT = cast<ArrayType>(SrcTy);
|
2003-08-22 06:07:12 +00:00
|
|
|
if (DAT->getNumElements() != SAT->getNumElements()) return true;
|
2003-08-23 21:25:54 +00:00
|
|
|
return RecursiveResolveTypesI(DAT->getElementType(), SAT->getElementType(),
|
2008-06-16 18:19:05 +00:00
|
|
|
Pointers);
|
2003-08-23 21:25:54 +00:00
|
|
|
}
|
2008-06-16 18:27:53 +00:00
|
|
|
case Type::VectorTyID: {
|
2008-06-16 21:17:12 +00:00
|
|
|
const VectorType *DVT = cast<VectorType>(DstTy);
|
|
|
|
const VectorType *SVT = cast<VectorType>(SrcTy);
|
2008-06-16 18:27:53 +00:00
|
|
|
if (DVT->getNumElements() != SVT->getNumElements()) return true;
|
|
|
|
return RecursiveResolveTypesI(DVT->getElementType(), SVT->getElementType(),
|
|
|
|
Pointers);
|
|
|
|
}
|
2003-08-23 21:25:54 +00:00
|
|
|
case Type::PointerTyID: {
|
2008-06-16 21:17:12 +00:00
|
|
|
const PointerType *DstPT = cast<PointerType>(DstTy);
|
|
|
|
const PointerType *SrcPT = cast<PointerType>(SrcTy);
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 19:55:40 +00:00
|
|
|
if (DstPT->getAddressSpace() != SrcPT->getAddressSpace())
|
|
|
|
return true;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2003-08-23 21:25:54 +00:00
|
|
|
// 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
|
2008-06-16 21:00:18 +00:00
|
|
|
// in the container) change whenever types get resolved.
|
|
|
|
if (SrcPT->isAbstract())
|
|
|
|
if (const Type *ExistingDestTy = Pointers.lookup(SrcPT))
|
|
|
|
return ExistingDestTy != DstPT;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 21:00:18 +00:00
|
|
|
if (DstPT->isAbstract())
|
|
|
|
if (const Type *ExistingSrcTy = Pointers.lookup(DstPT))
|
|
|
|
return ExistingSrcTy != SrcPT;
|
2003-08-23 21:25:54 +00:00
|
|
|
// Otherwise, add the current pointers to the vector to stop recursion on
|
|
|
|
// this pair.
|
2008-06-16 21:00:18 +00:00
|
|
|
if (DstPT->isAbstract())
|
|
|
|
Pointers.insert(DstPT, SrcPT);
|
|
|
|
if (SrcPT->isAbstract())
|
|
|
|
Pointers.insert(SrcPT, DstPT);
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-16 19:55:40 +00:00
|
|
|
return RecursiveResolveTypesI(DstPT->getElementType(),
|
|
|
|
SrcPT->getElementType(), Pointers);
|
2003-08-22 06:07:12 +00:00
|
|
|
}
|
2005-04-21 22:55:34 +00:00
|
|
|
}
|
2003-08-22 06:07:12 +00:00
|
|
|
}
|
|
|
|
|
2008-06-16 21:17:12 +00:00
|
|
|
static bool RecursiveResolveTypes(const Type *DestTy, const Type *SrcTy) {
|
2008-06-16 21:00:18 +00:00
|
|
|
LinkerTypeMap PointerTypes;
|
2008-06-16 18:19:05 +00:00
|
|
|
return RecursiveResolveTypesI(DestTy, SrcTy, PointerTypes);
|
2003-08-23 21:25:54 +00:00
|
|
|
}
|
|
|
|
|
2003-08-22 06:07:12 +00:00
|
|
|
|
2001-11-03 05:18:24 +00:00
|
|
|
// 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.
|
|
|
|
// Make sure there are no type name conflicts.
|
2003-01-30 19:53:34 +00:00
|
|
|
static bool LinkTypes(Module *Dest, const Module *Src, std::string *Err) {
|
2007-01-06 07:24:44 +00:00
|
|
|
TypeSymbolTable *DestST = &Dest->getTypeSymbolTable();
|
|
|
|
const TypeSymbolTable *SrcST = &Src->getTypeSymbolTable();
|
2001-11-03 05:18:24 +00:00
|
|
|
|
|
|
|
// Look for a type plane for Type's...
|
2007-01-06 07:24:44 +00:00
|
|
|
TypeSymbolTable::const_iterator TI = SrcST->begin();
|
|
|
|
TypeSymbolTable::const_iterator TE = SrcST->end();
|
2004-05-25 08:52:20 +00:00
|
|
|
if (TI == TE) return false; // No named types, do nothing.
|
2001-11-03 05:18:24 +00:00
|
|
|
|
2003-10-10 17:57:28 +00:00
|
|
|
// 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.
|
2003-05-15 16:30:55 +00:00
|
|
|
std::vector<std::string> DelayedTypesToResolve;
|
|
|
|
|
2004-05-25 08:52:20 +00:00
|
|
|
for ( ; TI != TE; ++TI ) {
|
|
|
|
const std::string &Name = TI->first;
|
2004-07-04 11:52:49 +00:00
|
|
|
const Type *RHS = TI->second;
|
2001-11-03 05:18:24 +00:00
|
|
|
|
2008-06-16 18:19:05 +00:00
|
|
|
// Check to see if this type name is already in the dest module.
|
2007-01-06 07:24:44 +00:00
|
|
|
Type *Entry = DestST->lookup(Name);
|
2003-05-15 16:30:55 +00:00
|
|
|
|
2008-06-16 18:19:05 +00:00
|
|
|
// If the name is just in the source module, bring it over to the dest.
|
|
|
|
if (Entry == 0) {
|
|
|
|
if (!Name.empty())
|
|
|
|
DestST->insert(Name, const_cast<Type*>(RHS));
|
|
|
|
} else if (ResolveTypes(Entry, RHS)) {
|
2003-05-15 16:30:55 +00:00
|
|
|
// They look different, save the types 'till later to resolve.
|
|
|
|
DelayedTypesToResolve.push_back(Name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Iteratively resolve types while we can...
|
|
|
|
while (!DelayedTypesToResolve.empty()) {
|
|
|
|
// Loop over all of the types, attempting to resolve them if possible...
|
|
|
|
unsigned OldSize = DelayedTypesToResolve.size();
|
|
|
|
|
2003-08-22 06:07:12 +00:00
|
|
|
// Try direct resolution by name...
|
2003-05-15 16:30:55 +00:00
|
|
|
for (unsigned i = 0; i != DelayedTypesToResolve.size(); ++i) {
|
|
|
|
const std::string &Name = DelayedTypesToResolve[i];
|
2007-01-06 07:24:44 +00:00
|
|
|
Type *T1 = SrcST->lookup(Name);
|
|
|
|
Type *T2 = DestST->lookup(Name);
|
2008-06-16 18:19:05 +00:00
|
|
|
if (!ResolveTypes(T2, T1)) {
|
2003-05-15 16:30:55 +00:00
|
|
|
// We are making progress!
|
|
|
|
DelayedTypesToResolve.erase(DelayedTypesToResolve.begin()+i);
|
|
|
|
--i;
|
2003-01-30 20:53:43 +00:00
|
|
|
}
|
2003-05-15 16:30:55 +00:00
|
|
|
}
|
2003-01-30 20:53:43 +00:00
|
|
|
|
2003-05-15 16:30:55 +00:00
|
|
|
// Did we not eliminate any types?
|
|
|
|
if (DelayedTypesToResolve.size() == OldSize) {
|
2003-08-22 06:07:12 +00:00
|
|
|
// Attempt to resolve subelements of types. This allows us to merge these
|
|
|
|
// two types: { int* } and { opaque* }
|
2003-05-15 16:30:55 +00:00
|
|
|
for (unsigned i = 0, e = DelayedTypesToResolve.size(); i != e; ++i) {
|
|
|
|
const std::string &Name = DelayedTypesToResolve[i];
|
2008-06-16 21:17:12 +00:00
|
|
|
if (!RecursiveResolveTypes(SrcST->lookup(Name), DestST->lookup(Name))) {
|
2003-08-22 06:07:12 +00:00
|
|
|
// We are making progress!
|
|
|
|
DelayedTypesToResolve.erase(DelayedTypesToResolve.begin()+i);
|
2005-04-21 22:55:34 +00:00
|
|
|
|
2003-08-22 06:07:12 +00:00
|
|
|
// Go back to the main loop, perhaps we can resolve directly by name
|
|
|
|
// now...
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we STILL cannot resolve the types, then there is something wrong.
|
|
|
|
if (DelayedTypesToResolve.size() == OldSize) {
|
2003-10-21 22:46:38 +00:00
|
|
|
// Remove the symbol name from the destination.
|
|
|
|
DelayedTypesToResolve.pop_back();
|
2003-05-15 16:30:55 +00:00
|
|
|
}
|
2001-11-03 05:18:24 +00:00
|
|
|
}
|
|
|
|
}
|
2003-05-15 16:30:55 +00:00
|
|
|
|
|
|
|
|
2001-11-03 05:18:24 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-07-14 05:52:33 +00:00
|
|
|
#ifndef NDEBUG
|
2003-01-30 19:53:34 +00:00
|
|
|
static void PrintMap(const std::map<const Value*, Value*> &M) {
|
|
|
|
for (std::map<const Value*, Value*>::const_iterator I = M.begin(), E =M.end();
|
2001-11-03 03:27:29 +00:00
|
|
|
I != E; ++I) {
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << " Fr: " << (void*)I->first << " ";
|
2002-04-07 22:31:23 +00:00
|
|
|
I->first->dump();
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << " To: " << (void*)I->second << " ";
|
2002-04-07 22:31:23 +00:00
|
|
|
I->second->dump();
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << "\n";
|
2001-11-03 03:27:29 +00:00
|
|
|
}
|
|
|
|
}
|
2008-07-14 05:52:33 +00:00
|
|
|
#endif
|
2001-11-03 03:27:29 +00:00
|
|
|
|
|
|
|
|
2007-02-04 04:43:17 +00:00
|
|
|
// RemapOperand - Use ValueMap to convert constants from one module to another.
|
2003-01-30 19:53:34 +00:00
|
|
|
static Value *RemapOperand(const Value *In,
|
2009-07-07 21:07:14 +00:00
|
|
|
std::map<const Value*, Value*> &ValueMap,
|
|
|
|
LLVMContext &Context) {
|
2004-11-16 17:12:38 +00:00
|
|
|
std::map<const Value*,Value*>::const_iterator I = ValueMap.find(In);
|
2009-03-03 07:22:23 +00:00
|
|
|
if (I != ValueMap.end())
|
2007-02-05 20:47:22 +00:00
|
|
|
return I->second;
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2007-02-04 04:43:17 +00:00
|
|
|
// Check to see if it's a constant that we are interested in transforming.
|
2006-06-01 19:14:22 +00:00
|
|
|
Value *Result = 0;
|
2002-06-25 16:12:52 +00:00
|
|
|
if (const Constant *CPV = dyn_cast<Constant>(In)) {
|
2004-02-15 05:55:15 +00:00
|
|
|
if ((!isa<DerivedType>(CPV->getType()) && !isa<ConstantExpr>(CPV)) ||
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
isa<ConstantInt>(CPV) || isa<ConstantAggregateZero>(CPV))
|
2004-11-16 17:12:38 +00:00
|
|
|
return const_cast<Constant*>(CPV); // Simple constants stay identical.
|
2001-10-15 03:12:52 +00:00
|
|
|
|
2002-06-25 16:12:52 +00:00
|
|
|
if (const ConstantArray *CPA = dyn_cast<ConstantArray>(CPV)) {
|
2004-08-04 08:08:13 +00:00
|
|
|
std::vector<Constant*> Operands(CPA->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
|
2009-07-07 21:07:14 +00:00
|
|
|
Operands[i] =cast<Constant>(RemapOperand(CPA->getOperand(i), ValueMap,
|
|
|
|
Context));
|
|
|
|
Result =
|
|
|
|
Context.getConstantArray(cast<ArrayType>(CPA->getType()), Operands);
|
2002-06-25 16:12:52 +00:00
|
|
|
} else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) {
|
2004-08-04 08:08:13 +00:00
|
|
|
std::vector<Constant*> Operands(CPS->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
|
2009-07-07 21:07:14 +00:00
|
|
|
Operands[i] =cast<Constant>(RemapOperand(CPS->getOperand(i), ValueMap,
|
|
|
|
Context));
|
|
|
|
Result =
|
|
|
|
Context.getConstantStruct(cast<StructType>(CPS->getType()), Operands);
|
2004-10-16 18:08:06 +00:00
|
|
|
} else if (isa<ConstantPointerNull>(CPV) || isa<UndefValue>(CPV)) {
|
2002-06-25 16:12:52 +00:00
|
|
|
Result = const_cast<Constant*>(CPV);
|
2007-02-15 02:26:10 +00:00
|
|
|
} else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CPV)) {
|
2006-01-19 23:15:58 +00:00
|
|
|
std::vector<Constant*> Operands(CP->getNumOperands());
|
|
|
|
for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
|
2009-07-07 21:07:14 +00:00
|
|
|
Operands[i] = cast<Constant>(RemapOperand(CP->getOperand(i), ValueMap,
|
|
|
|
Context));
|
|
|
|
Result = Context.getConstantVector(Operands);
|
2002-07-18 00:13:08 +00:00
|
|
|
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
|
2006-07-14 22:21:31 +00:00
|
|
|
std::vector<Constant*> Ops;
|
|
|
|
for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
|
2009-07-07 21:07:14 +00:00
|
|
|
Ops.push_back(cast<Constant>(RemapOperand(CE->getOperand(i),ValueMap,
|
|
|
|
Context)));
|
2006-07-14 22:21:31 +00:00
|
|
|
Result = CE->getWithOperands(Ops);
|
2001-10-15 03:12:52 +00:00
|
|
|
} else {
|
2008-07-14 05:52:33 +00:00
|
|
|
assert(!isa<GlobalValue>(CPV) && "Unmapped global?");
|
2001-10-15 03:12:52 +00:00
|
|
|
assert(0 && "Unknown type of derived type constant value!");
|
|
|
|
}
|
2006-06-01 19:14:22 +00:00
|
|
|
} else if (isa<InlineAsm>(In)) {
|
|
|
|
Result = const_cast<Value*>(In);
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2007-02-04 04:43:17 +00:00
|
|
|
// Cache the mapping in our local map structure
|
2006-06-01 19:14:22 +00:00
|
|
|
if (Result) {
|
2008-03-10 22:36:08 +00:00
|
|
|
ValueMap[In] = Result;
|
2001-10-15 03:12:52 +00:00
|
|
|
return Result;
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 05:52:33 +00:00
|
|
|
#ifndef NDEBUG
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << "LinkModules ValueMap: \n";
|
2004-11-16 17:12:38 +00:00
|
|
|
PrintMap(ValueMap);
|
2001-11-03 03:27:29 +00:00
|
|
|
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << "Couldn't remap value: " << (void*)In << " " << *In << "\n";
|
2001-10-15 03:12:52 +00:00
|
|
|
assert(0 && "Couldn't remap value!");
|
2008-07-14 05:52:33 +00:00
|
|
|
#endif
|
2001-10-15 03:12:52 +00:00
|
|
|
return 0;
|
2001-10-14 23:29:15 +00:00
|
|
|
}
|
|
|
|
|
2007-02-04 04:29:21 +00:00
|
|
|
/// 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.
|
2004-08-04 07:05:54 +00:00
|
|
|
static void ForceRenaming(GlobalValue *GV, const std::string &Name) {
|
|
|
|
assert(GV->getName() != Name && "Can't force rename to self");
|
2007-02-05 20:47:22 +00:00
|
|
|
ValueSymbolTable &ST = GV->getParent()->getValueSymbolTable();
|
2004-08-04 07:05:54 +00:00
|
|
|
|
|
|
|
// If there is a conflict, rename the conflict.
|
2007-02-11 00:39:38 +00:00
|
|
|
if (GlobalValue *ConflictGV = cast_or_null<GlobalValue>(ST.lookup(Name))) {
|
2009-01-15 20:18:42 +00:00
|
|
|
assert(ConflictGV->hasLocalLinkage() &&
|
2007-02-05 20:47:22 +00:00
|
|
|
"Not conflicting with a static global, should link instead!");
|
2007-02-11 00:39:38 +00:00
|
|
|
GV->takeName(ConflictGV);
|
|
|
|
ConflictGV->setName(Name); // This will cause ConflictGV to get renamed
|
2007-02-05 20:47:22 +00:00
|
|
|
assert(ConflictGV->getName() != Name && "ForceRenaming didn't work");
|
2007-02-11 00:39:38 +00:00
|
|
|
} else {
|
|
|
|
GV->setName(Name); // Force the name back
|
2007-02-05 20:47:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// CopyGVAttributes - copy additional attributes (those not needed to construct
|
2009-03-03 07:22:23 +00:00
|
|
|
/// a GlobalValue) from the SrcGV to the DestGV.
|
2007-02-05 20:47:22 +00:00
|
|
|
static void CopyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) {
|
2008-05-26 19:58:59 +00:00
|
|
|
// Use the maximum alignment, rather than just copying the alignment of SrcGV.
|
|
|
|
unsigned Alignment = std::max(DestGV->getAlignment(), SrcGV->getAlignment());
|
|
|
|
DestGV->copyAttributesFrom(SrcGV);
|
|
|
|
DestGV->setAlignment(Alignment);
|
2004-08-04 07:05:54 +00:00
|
|
|
}
|
|
|
|
|
2004-12-03 22:18:41 +00:00
|
|
|
/// GetLinkageResult - This analyzes the two global values and determines what
|
|
|
|
/// the result will look like in the destination module. In particular, it
|
|
|
|
/// computes the resultant linkage type, computes whether the global in the
|
|
|
|
/// source should be copied over to the destination (replacing the existing
|
2007-04-29 20:56:48 +00:00
|
|
|
/// one), and computes whether this linkage is an error or not. It also performs
|
|
|
|
/// visibility checks: we cannot link together two symbols with different
|
|
|
|
/// visibilities.
|
2008-03-10 22:33:53 +00:00
|
|
|
static bool GetLinkageResult(GlobalValue *Dest, const GlobalValue *Src,
|
2004-12-03 22:18:41 +00:00
|
|
|
GlobalValue::LinkageTypes <, bool &LinkFromSrc,
|
|
|
|
std::string *Err) {
|
2009-01-15 20:18:42 +00:00
|
|
|
assert((!Dest || !Src->hasLocalLinkage()) &&
|
2004-12-03 22:18:41 +00:00
|
|
|
"If Src has internal linkage, Dest shouldn't be set!");
|
|
|
|
if (!Dest) {
|
|
|
|
// Linking something to nothing.
|
|
|
|
LinkFromSrc = true;
|
|
|
|
LT = Src->getLinkage();
|
2007-01-30 20:08:39 +00:00
|
|
|
} else if (Src->isDeclaration()) {
|
2008-03-10 22:33:22 +00:00
|
|
|
// If Src is external or if both Src & Dest are external.. Just link the
|
2004-12-03 22:18:41 +00:00
|
|
|
// external globals, we aren't adding anything.
|
2006-09-14 18:23:27 +00:00
|
|
|
if (Src->hasDLLImportLinkage()) {
|
2006-12-01 00:25:12 +00:00
|
|
|
// If one of GVs has DLLImport linkage, result should be dllimport'ed.
|
2007-01-30 20:08:39 +00:00
|
|
|
if (Dest->isDeclaration()) {
|
2006-09-14 18:23:27 +00:00
|
|
|
LinkFromSrc = true;
|
|
|
|
LT = Src->getLinkage();
|
2009-03-03 07:22:23 +00:00
|
|
|
}
|
2006-12-15 17:35:32 +00:00
|
|
|
} else if (Dest->hasExternalWeakLinkage()) {
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
// If the Dest is weak, use the source linkage.
|
2006-12-15 17:35:32 +00:00
|
|
|
LinkFromSrc = true;
|
|
|
|
LT = Src->getLinkage();
|
2006-09-14 18:23:27 +00:00
|
|
|
} else {
|
|
|
|
LinkFromSrc = false;
|
|
|
|
LT = Dest->getLinkage();
|
|
|
|
}
|
2007-01-30 20:08:39 +00:00
|
|
|
} else if (Dest->isDeclaration() && !Dest->hasDLLImportLinkage()) {
|
2004-12-03 22:18:41 +00:00
|
|
|
// If Dest is external but Src is not:
|
|
|
|
LinkFromSrc = true;
|
|
|
|
LT = Src->getLinkage();
|
|
|
|
} else if (Src->hasAppendingLinkage() || Dest->hasAppendingLinkage()) {
|
|
|
|
if (Src->getLinkage() != Dest->getLinkage())
|
|
|
|
return Error(Err, "Linking globals named '" + Src->getName() +
|
|
|
|
"': can only link appending global with another appending global!");
|
|
|
|
LinkFromSrc = true; // Special cased.
|
|
|
|
LT = Src->getLinkage();
|
2009-03-08 13:35:23 +00:00
|
|
|
} else if (Src->isWeakForLinker()) {
|
2008-05-14 20:12:51 +00:00
|
|
|
// At this point we know that Dest has LinkOnce, External*, Weak, Common,
|
|
|
|
// or DLL* linkage.
|
2009-04-13 05:44:34 +00:00
|
|
|
if (Dest->hasExternalWeakLinkage() ||
|
|
|
|
Dest->hasAvailableExternallyLinkage() ||
|
|
|
|
(Dest->hasLinkOnceLinkage() &&
|
|
|
|
(Src->hasWeakLinkage() || Src->hasCommonLinkage()))) {
|
2004-12-03 22:18:41 +00:00
|
|
|
LinkFromSrc = true;
|
|
|
|
LT = Src->getLinkage();
|
|
|
|
} else {
|
|
|
|
LinkFromSrc = false;
|
|
|
|
LT = Dest->getLinkage();
|
|
|
|
}
|
2009-03-08 13:35:23 +00:00
|
|
|
} else if (Dest->isWeakForLinker()) {
|
2006-12-01 00:25:12 +00:00
|
|
|
// At this point we know that Src has External* or DLL* linkage.
|
|
|
|
if (Src->hasExternalWeakLinkage()) {
|
|
|
|
LinkFromSrc = false;
|
|
|
|
LT = Dest->getLinkage();
|
|
|
|
} else {
|
|
|
|
LinkFromSrc = true;
|
|
|
|
LT = GlobalValue::ExternalLinkage;
|
|
|
|
}
|
2004-12-03 22:18:41 +00:00
|
|
|
} else {
|
2006-09-14 18:23:27 +00:00
|
|
|
assert((Dest->hasExternalLinkage() ||
|
|
|
|
Dest->hasDLLImportLinkage() ||
|
2006-12-01 00:25:12 +00:00
|
|
|
Dest->hasDLLExportLinkage() ||
|
|
|
|
Dest->hasExternalWeakLinkage()) &&
|
2006-09-14 18:23:27 +00:00
|
|
|
(Src->hasExternalLinkage() ||
|
|
|
|
Src->hasDLLImportLinkage() ||
|
2006-12-01 00:25:12 +00:00
|
|
|
Src->hasDLLExportLinkage() ||
|
|
|
|
Src->hasExternalWeakLinkage()) &&
|
2004-12-03 22:18:41 +00:00
|
|
|
"Unexpected linkage type!");
|
2005-04-21 22:55:34 +00:00
|
|
|
return Error(Err, "Linking globals named '" + Src->getName() +
|
2004-12-03 22:18:41 +00:00
|
|
|
"': symbol multiply defined!");
|
|
|
|
}
|
2007-04-29 20:56:48 +00:00
|
|
|
|
|
|
|
// Check visibility
|
|
|
|
if (Dest && Src->getVisibility() != Dest->getVisibility())
|
2007-08-19 22:22:54 +00:00
|
|
|
if (!Src->isDeclaration() && !Dest->isDeclaration())
|
|
|
|
return Error(Err, "Linking globals named '" + Src->getName() +
|
|
|
|
"': symbols have different visibilities!");
|
2004-12-03 22:18:41 +00:00
|
|
|
return false;
|
|
|
|
}
|
2001-10-14 23:29:15 +00:00
|
|
|
|
|
|
|
// LinkGlobals - Loop through the global variables in the src module and merge
|
2003-05-13 21:33:43 +00:00
|
|
|
// them into the dest module.
|
2008-03-10 22:33:53 +00:00
|
|
|
static bool LinkGlobals(Module *Dest, const Module *Src,
|
2003-01-30 19:53:34 +00:00
|
|
|
std::map<const Value*, Value*> &ValueMap,
|
2003-05-13 21:33:43 +00:00
|
|
|
std::multimap<std::string, GlobalVariable *> &AppendingVars,
|
2003-01-30 19:53:34 +00:00
|
|
|
std::string *Err) {
|
2008-07-14 06:49:45 +00:00
|
|
|
ValueSymbolTable &DestSymTab = Dest->getValueSymbolTable();
|
2009-07-07 21:07:14 +00:00
|
|
|
LLVMContext &Context = Dest->getContext();
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2001-10-14 23:29:15 +00:00
|
|
|
// Loop over all of the globals in the src module, mapping them over as we go
|
2008-07-14 05:52:33 +00:00
|
|
|
for (Module::const_global_iterator I = Src->global_begin(),
|
|
|
|
E = Src->global_end(); I != E; ++I) {
|
2008-03-10 22:33:53 +00:00
|
|
|
const GlobalVariable *SGV = I;
|
2008-03-10 22:34:28 +00:00
|
|
|
GlobalValue *DGV = 0;
|
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// Check to see if may have to link the global with the global, alias or
|
|
|
|
// function.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (SGV->hasName() && !SGV->hasLocalLinkage())
|
2008-07-14 06:49:45 +00:00
|
|
|
DGV = cast_or_null<GlobalValue>(DestSymTab.lookup(SGV->getNameStart(),
|
|
|
|
SGV->getNameEnd()));
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 06:52:19 +00:00
|
|
|
// 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.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (DGV && DGV->hasLocalLinkage())
|
2008-07-14 06:52:19 +00:00
|
|
|
DGV = 0;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// If types don't agree due to opaque types, try to resolve them.
|
|
|
|
if (DGV && DGV->getType() != SGV->getType())
|
|
|
|
RecursiveResolveTypes(SGV->getType(), DGV->getType());
|
2008-03-10 22:34:28 +00:00
|
|
|
|
2007-10-08 15:13:30 +00:00
|
|
|
assert((SGV->hasInitializer() || SGV->hasExternalWeakLinkage() ||
|
|
|
|
SGV->hasExternalLinkage() || SGV->hasDLLImportLinkage()) &&
|
2003-04-16 20:28:45 +00:00
|
|
|
"Global must either be external or have an initializer!");
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2006-11-09 05:18:12 +00:00
|
|
|
GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage;
|
|
|
|
bool LinkFromSrc = false;
|
2004-12-03 22:18:41 +00:00
|
|
|
if (GetLinkageResult(DGV, SGV, NewLinkage, LinkFromSrc, Err))
|
|
|
|
return true;
|
2003-04-21 21:07:05 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
if (DGV == 0) {
|
2001-10-14 23:29:15 +00:00
|
|
|
// No linking to be performed, simply create an identical version of the
|
2001-10-15 03:12:52 +00:00
|
|
|
// symbol over in the dest module... the initializer will be filled in
|
2008-07-14 06:49:45 +00:00
|
|
|
// later by LinkGlobalInits.
|
2003-04-21 21:15:04 +00:00
|
|
|
GlobalVariable *NewDGV =
|
|
|
|
new GlobalVariable(SGV->getType()->getElementType(),
|
|
|
|
SGV->isConstant(), SGV->getLinkage(), /*init*/0,
|
2008-06-27 03:10:24 +00:00
|
|
|
SGV->getName(), Dest, false,
|
|
|
|
SGV->getType()->getAddressSpace());
|
2007-02-04 04:30:33 +00:00
|
|
|
// Propagate alignment, visibility and section info.
|
2007-02-05 20:47:22 +00:00
|
|
|
CopyGVAttributes(NewDGV, SGV);
|
2007-02-01 17:12:54 +00:00
|
|
|
|
2003-04-21 21:15:04 +00:00
|
|
|
// If the LLVM runtime renamed the global, but it is an externally visible
|
|
|
|
// symbol, DGV must be an existing global with internal linkage. Rename
|
|
|
|
// it.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (!NewDGV->hasLocalLinkage() && NewDGV->getName() != SGV->getName())
|
2004-08-04 07:05:54 +00:00
|
|
|
ForceRenaming(NewDGV, SGV->getName());
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Make sure to remember this mapping.
|
2008-03-10 22:36:08 +00:00
|
|
|
ValueMap[SGV] = NewDGV;
|
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// Keep track that this is an appending variable.
|
2003-05-13 21:33:43 +00:00
|
|
|
if (SGV->hasAppendingLinkage())
|
|
|
|
AppendingVars.insert(std::make_pair(SGV->getName(), NewDGV));
|
2008-07-14 07:23:24 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// If the visibilities of the symbols disagree and the destination is a
|
|
|
|
// prototype, take the visibility of its input.
|
|
|
|
if (DGV->isDeclaration())
|
|
|
|
DGV->setVisibility(SGV->getVisibility());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
if (DGV->hasAppendingLinkage()) {
|
2003-05-13 21:33:43 +00:00
|
|
|
// No linking is performed yet. Just insert a new copy of the global, and
|
|
|
|
// keep track of the fact that it is an appending variable in the
|
|
|
|
// AppendingVars map. The name is cleared out so that no linkage is
|
|
|
|
// performed.
|
|
|
|
GlobalVariable *NewDGV =
|
|
|
|
new GlobalVariable(SGV->getType()->getElementType(),
|
|
|
|
SGV->isConstant(), SGV->getLinkage(), /*init*/0,
|
2008-06-27 03:10:24 +00:00
|
|
|
"", Dest, false,
|
|
|
|
SGV->getType()->getAddressSpace());
|
2003-05-13 21:33:43 +00:00
|
|
|
|
2008-03-07 18:34:50 +00:00
|
|
|
// Set alignment allowing CopyGVAttributes merge it with alignment of SGV.
|
2007-02-05 20:47:22 +00:00
|
|
|
NewDGV->setAlignment(DGV->getAlignment());
|
2008-03-07 18:34:50 +00:00
|
|
|
// Propagate alignment, section and visibility info.
|
2007-02-05 20:47:22 +00:00
|
|
|
CopyGVAttributes(NewDGV, SGV);
|
2007-02-01 17:12:54 +00:00
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// Make sure to remember this mapping...
|
2008-03-10 22:36:08 +00:00
|
|
|
ValueMap[SGV] = NewDGV;
|
2003-05-13 21:33:43 +00:00
|
|
|
|
|
|
|
// Keep track that this is an appending variable...
|
|
|
|
AppendingVars.insert(std::make_pair(SGV->getName(), NewDGV));
|
2008-07-14 07:23:24 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
if (LinkFromSrc) {
|
|
|
|
if (isa<GlobalAlias>(DGV))
|
2008-03-10 22:34:46 +00:00
|
|
|
return Error(Err, "Global-Alias Collision on '" + SGV->getName() +
|
|
|
|
"': symbol multiple defined");
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// If the types don't match, and if we are to link from the source, nuke
|
|
|
|
// DGV and create a new one of the appropriate type. Note that the thing
|
|
|
|
// we are replacing may be a function (if a prototype, weak, etc) or a
|
|
|
|
// global variable.
|
|
|
|
GlobalVariable *NewDGV =
|
2008-07-14 07:23:24 +00:00
|
|
|
new GlobalVariable(SGV->getType()->getElementType(), SGV->isConstant(),
|
|
|
|
NewLinkage, /*init*/0, DGV->getName(), Dest, false,
|
2008-07-14 06:49:45 +00:00
|
|
|
SGV->getType()->getAddressSpace());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// Propagate alignment, section, and visibility info.
|
|
|
|
CopyGVAttributes(NewDGV, SGV);
|
2009-07-07 21:07:14 +00:00
|
|
|
DGV->replaceAllUsesWith(Context.getConstantExprBitCast(NewDGV,
|
|
|
|
DGV->getType()));
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// DGV will conflict with NewDGV because they both had the same
|
|
|
|
// name. We must erase this now so ForceRenaming doesn't assert
|
|
|
|
// because DGV might not have internal linkage.
|
|
|
|
if (GlobalVariable *Var = dyn_cast<GlobalVariable>(DGV))
|
|
|
|
Var->eraseFromParent();
|
|
|
|
else
|
|
|
|
cast<Function>(DGV)->eraseFromParent();
|
|
|
|
DGV = NewDGV;
|
|
|
|
|
|
|
|
// If the symbol table renamed the global, but it is an externally visible
|
|
|
|
// symbol, DGV must be an existing global with internal linkage. Rename.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (NewDGV->getName() != SGV->getName() && !NewDGV->hasLocalLinkage())
|
2008-07-14 06:49:45 +00:00
|
|
|
ForceRenaming(NewDGV, SGV->getName());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Inherit const as appropriate.
|
2008-07-14 06:49:45 +00:00
|
|
|
NewDGV->setConstant(SGV->isConstant());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Make sure to remember this mapping.
|
|
|
|
ValueMap[SGV] = NewDGV;
|
|
|
|
continue;
|
2001-10-14 23:29:15 +00:00
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Not "link from source", keep the one in the DestModule and remap the
|
|
|
|
// input onto it.
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Special case for const propagation.
|
|
|
|
if (GlobalVariable *DGVar = dyn_cast<GlobalVariable>(DGV))
|
|
|
|
if (DGVar->isDeclaration() && SGV->isConstant() && !DGVar->isConstant())
|
|
|
|
DGVar->setConstant(true);
|
|
|
|
|
2008-10-15 20:10:50 +00:00
|
|
|
// SGV is global, but DGV is alias.
|
|
|
|
if (isa<GlobalAlias>(DGV)) {
|
|
|
|
// The only valid mappings are:
|
|
|
|
// - SGV is external declaration, which is effectively a no-op.
|
|
|
|
// - SGV is weak, when we just need to throw SGV out.
|
2009-03-08 13:35:23 +00:00
|
|
|
if (!SGV->isDeclaration() && !SGV->isWeakForLinker())
|
2008-10-15 20:10:50 +00:00
|
|
|
return Error(Err, "Global-Alias Collision on '" + SGV->getName() +
|
|
|
|
"': symbol multiple defined");
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Set calculated linkage
|
|
|
|
DGV->setLinkage(NewLinkage);
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Make sure to remember this mapping...
|
2009-07-07 21:07:14 +00:00
|
|
|
ValueMap[SGV] = Context.getConstantExprBitCast(DGV, SGV->getType());
|
2001-10-14 23:29:15 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-03-05 22:22:46 +00:00
|
|
|
static GlobalValue::LinkageTypes
|
|
|
|
CalculateAliasLinkage(const GlobalValue *SGV, const GlobalValue *DGV) {
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
GlobalValue::LinkageTypes SL = SGV->getLinkage();
|
|
|
|
GlobalValue::LinkageTypes DL = DGV->getLinkage();
|
|
|
|
if (SL == GlobalValue::ExternalLinkage || DL == GlobalValue::ExternalLinkage)
|
2008-03-05 22:22:46 +00:00
|
|
|
return GlobalValue::ExternalLinkage;
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
else if (SL == GlobalValue::WeakAnyLinkage ||
|
|
|
|
DL == GlobalValue::WeakAnyLinkage)
|
|
|
|
return GlobalValue::WeakAnyLinkage;
|
|
|
|
else if (SL == GlobalValue::WeakODRLinkage ||
|
|
|
|
DL == GlobalValue::WeakODRLinkage)
|
|
|
|
return GlobalValue::WeakODRLinkage;
|
|
|
|
else if (SL == GlobalValue::InternalLinkage &&
|
|
|
|
DL == GlobalValue::InternalLinkage)
|
2008-03-05 22:22:46 +00:00
|
|
|
return GlobalValue::InternalLinkage;
|
2009-01-15 20:18:42 +00:00
|
|
|
else {
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
assert (SL == GlobalValue::PrivateLinkage &&
|
|
|
|
DL == GlobalValue::PrivateLinkage && "Unexpected linkage type");
|
2009-01-15 20:18:42 +00:00
|
|
|
return GlobalValue::PrivateLinkage;
|
2008-03-05 22:22:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-28 19:02:54 +00:00
|
|
|
// LinkAlias - Loop through the alias in the src module and link them into the
|
2008-03-05 22:22:46 +00:00
|
|
|
// dest module. We're assuming, that all functions/global variables were already
|
|
|
|
// linked in.
|
2008-03-05 15:27:21 +00:00
|
|
|
static bool LinkAlias(Module *Dest, const Module *Src,
|
|
|
|
std::map<const Value*, Value*> &ValueMap,
|
|
|
|
std::string *Err) {
|
2009-07-07 21:07:14 +00:00
|
|
|
LLVMContext &Context = Dest->getContext();
|
|
|
|
|
2007-06-28 19:02:54 +00:00
|
|
|
// Loop over all alias in the src module
|
|
|
|
for (Module::const_alias_iterator I = Src->alias_begin(),
|
|
|
|
E = Src->alias_end(); I != E; ++I) {
|
2008-03-05 22:22:46 +00:00
|
|
|
const GlobalAlias *SGA = I;
|
|
|
|
const GlobalValue *SAliasee = SGA->getAliasedGlobal();
|
|
|
|
GlobalAlias *NewGA = NULL;
|
|
|
|
|
|
|
|
// Globals were already linked, thus we can just query ValueMap for variant
|
2008-05-10 14:41:43 +00:00
|
|
|
// of SAliasee in Dest.
|
2008-03-09 18:32:50 +00:00
|
|
|
std::map<const Value*,Value*>::const_iterator VMI = ValueMap.find(SAliasee);
|
|
|
|
assert(VMI != ValueMap.end() && "Aliasee not linked");
|
|
|
|
GlobalValue* DAliasee = cast<GlobalValue>(VMI->second);
|
2008-05-10 14:41:43 +00:00
|
|
|
GlobalValue* DGV = NULL;
|
2008-03-05 22:22:46 +00:00
|
|
|
|
|
|
|
// Try to find something 'similar' to SGA in destination module.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (!DGV && !SGA->hasLocalLinkage()) {
|
2008-05-10 14:41:43 +00:00
|
|
|
DGV = Dest->getNamedAlias(SGA->getName());
|
|
|
|
|
|
|
|
// If types don't agree due to opaque types, try to resolve them.
|
|
|
|
if (DGV && DGV->getType() != SGA->getType())
|
2008-07-10 01:09:33 +00:00
|
|
|
RecursiveResolveTypes(SGA->getType(), DGV->getType());
|
2008-05-10 14:41:43 +00:00
|
|
|
}
|
|
|
|
|
2009-01-15 20:18:42 +00:00
|
|
|
if (!DGV && !SGA->hasLocalLinkage()) {
|
2008-05-10 14:41:43 +00:00
|
|
|
DGV = Dest->getGlobalVariable(SGA->getName());
|
|
|
|
|
2008-03-05 22:22:46 +00:00
|
|
|
// If types don't agree due to opaque types, try to resolve them.
|
2008-05-10 14:41:43 +00:00
|
|
|
if (DGV && DGV->getType() != SGA->getType())
|
2008-07-10 01:09:33 +00:00
|
|
|
RecursiveResolveTypes(SGA->getType(), DGV->getType());
|
2008-05-10 14:41:43 +00:00
|
|
|
}
|
2008-03-05 22:22:46 +00:00
|
|
|
|
2009-01-15 20:18:42 +00:00
|
|
|
if (!DGV && !SGA->hasLocalLinkage()) {
|
2008-05-10 14:41:43 +00:00
|
|
|
DGV = Dest->getFunction(SGA->getName());
|
|
|
|
|
|
|
|
// If types don't agree due to opaque types, try to resolve them.
|
|
|
|
if (DGV && DGV->getType() != SGA->getType())
|
2008-07-10 01:09:33 +00:00
|
|
|
RecursiveResolveTypes(SGA->getType(), DGV->getType());
|
2008-05-10 14:41:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// No linking to be performed on internal stuff.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (DGV && DGV->hasLocalLinkage())
|
2008-05-10 14:41:43 +00:00
|
|
|
DGV = NULL;
|
|
|
|
|
|
|
|
if (GlobalAlias *DGA = dyn_cast_or_null<GlobalAlias>(DGV)) {
|
|
|
|
// Types are known to be the same, check whether aliasees equal. As
|
2008-03-05 22:22:46 +00:00
|
|
|
// globals are already linked we just need query ValueMap to find the
|
|
|
|
// mapping.
|
|
|
|
if (DAliasee == DGA->getAliasedGlobal()) {
|
|
|
|
// This is just two copies of the same alias. Propagate linkage, if
|
|
|
|
// necessary.
|
|
|
|
DGA->setLinkage(CalculateAliasLinkage(SGA, DGA));
|
|
|
|
|
|
|
|
NewGA = DGA;
|
|
|
|
// Proceed to 'common' steps
|
|
|
|
} else
|
2008-03-10 22:34:46 +00:00
|
|
|
return Error(Err, "Alias Collision on '" + SGA->getName()+
|
|
|
|
"': aliases have different aliasees");
|
2008-05-10 14:41:43 +00:00
|
|
|
} else if (GlobalVariable *DGVar = dyn_cast_or_null<GlobalVariable>(DGV)) {
|
2008-07-05 23:33:22 +00:00
|
|
|
// The only allowed way is to link alias with external declaration or weak
|
|
|
|
// symbol..
|
2009-03-08 13:35:23 +00:00
|
|
|
if (DGVar->isDeclaration() || DGVar->isWeakForLinker()) {
|
2008-03-10 22:36:53 +00:00
|
|
|
// But only if aliasee is global too...
|
|
|
|
if (!isa<GlobalVariable>(DAliasee))
|
2008-05-10 14:41:43 +00:00
|
|
|
return Error(Err, "Global-Alias Collision on '" + SGA->getName() +
|
|
|
|
"': aliasee is not global variable");
|
2008-03-10 22:36:53 +00:00
|
|
|
|
2008-03-05 22:22:46 +00:00
|
|
|
NewGA = new GlobalAlias(SGA->getType(), SGA->getLinkage(),
|
|
|
|
SGA->getName(), DAliasee, Dest);
|
|
|
|
CopyGVAttributes(NewGA, SGA);
|
|
|
|
|
|
|
|
// Any uses of DGV need to change to NewGA, with cast, if needed.
|
2008-05-10 14:41:43 +00:00
|
|
|
if (SGA->getType() != DGVar->getType())
|
2009-07-07 21:07:14 +00:00
|
|
|
DGVar->replaceAllUsesWith(Context.getConstantExprBitCast(NewGA,
|
2008-05-10 14:41:43 +00:00
|
|
|
DGVar->getType()));
|
2008-03-05 22:22:46 +00:00
|
|
|
else
|
2008-05-10 14:41:43 +00:00
|
|
|
DGVar->replaceAllUsesWith(NewGA);
|
2008-03-05 22:22:46 +00:00
|
|
|
|
2008-05-10 14:41:43 +00:00
|
|
|
// DGVar will conflict with NewGA because they both had the same
|
2008-03-05 22:22:46 +00:00
|
|
|
// name. We must erase this now so ForceRenaming doesn't assert
|
|
|
|
// because DGV might not have internal linkage.
|
2008-05-10 14:41:43 +00:00
|
|
|
DGVar->eraseFromParent();
|
2008-03-05 22:22:46 +00:00
|
|
|
|
|
|
|
// Proceed to 'common' steps
|
|
|
|
} else
|
2008-03-10 22:34:46 +00:00
|
|
|
return Error(Err, "Global-Alias Collision on '" + SGA->getName() +
|
|
|
|
"': symbol multiple defined");
|
2008-05-10 14:41:43 +00:00
|
|
|
} else if (Function *DF = dyn_cast_or_null<Function>(DGV)) {
|
2008-07-05 23:33:22 +00:00
|
|
|
// The only allowed way is to link alias with external declaration or weak
|
|
|
|
// symbol...
|
2009-03-08 13:35:23 +00:00
|
|
|
if (DF->isDeclaration() || DF->isWeakForLinker()) {
|
2008-03-10 22:36:53 +00:00
|
|
|
// But only if aliasee is function too...
|
|
|
|
if (!isa<Function>(DAliasee))
|
2008-05-10 14:41:43 +00:00
|
|
|
return Error(Err, "Function-Alias Collision on '" + SGA->getName() +
|
|
|
|
"': aliasee is not function");
|
2008-03-10 22:36:53 +00:00
|
|
|
|
2008-03-05 23:08:16 +00:00
|
|
|
NewGA = new GlobalAlias(SGA->getType(), SGA->getLinkage(),
|
|
|
|
SGA->getName(), DAliasee, Dest);
|
|
|
|
CopyGVAttributes(NewGA, SGA);
|
|
|
|
|
|
|
|
// Any uses of DF need to change to NewGA, with cast, if needed.
|
|
|
|
if (SGA->getType() != DF->getType())
|
2009-07-07 21:07:14 +00:00
|
|
|
DF->replaceAllUsesWith(Context.getConstantExprBitCast(NewGA,
|
2008-03-05 23:08:16 +00:00
|
|
|
DF->getType()));
|
|
|
|
else
|
|
|
|
DF->replaceAllUsesWith(NewGA);
|
|
|
|
|
|
|
|
// DF will conflict with NewGA because they both had the same
|
|
|
|
// name. We must erase this now so ForceRenaming doesn't assert
|
|
|
|
// because DF might not have internal linkage.
|
|
|
|
DF->eraseFromParent();
|
|
|
|
|
|
|
|
// Proceed to 'common' steps
|
|
|
|
} else
|
2008-03-10 22:34:46 +00:00
|
|
|
return Error(Err, "Function-Alias Collision on '" + SGA->getName() +
|
|
|
|
"': symbol multiple defined");
|
2008-03-05 22:22:46 +00:00
|
|
|
} else {
|
2008-05-10 14:41:43 +00:00
|
|
|
// No linking to be performed, simply create an identical version of the
|
|
|
|
// alias over in the dest module...
|
2008-03-05 22:22:46 +00:00
|
|
|
|
|
|
|
NewGA = new GlobalAlias(SGA->getType(), SGA->getLinkage(),
|
|
|
|
SGA->getName(), DAliasee, Dest);
|
|
|
|
CopyGVAttributes(NewGA, SGA);
|
|
|
|
|
|
|
|
// Proceed to 'common' steps
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(NewGA && "No alias was created in destination module!");
|
|
|
|
|
2008-03-10 22:36:35 +00:00
|
|
|
// If the symbol table renamed the alias, but it is an externally visible
|
2008-05-10 14:41:43 +00:00
|
|
|
// symbol, DGA must be an global value with internal linkage. Rename it.
|
2008-03-05 22:22:46 +00:00
|
|
|
if (NewGA->getName() != SGA->getName() &&
|
2009-01-15 20:18:42 +00:00
|
|
|
!NewGA->hasLocalLinkage())
|
2008-03-05 22:22:46 +00:00
|
|
|
ForceRenaming(NewGA, SGA->getName());
|
|
|
|
|
|
|
|
// Remember this mapping so uses in the source module get remapped
|
|
|
|
// later by RemapOperand.
|
2008-03-10 22:36:08 +00:00
|
|
|
ValueMap[SGA] = NewGA;
|
2007-06-28 19:02:54 +00:00
|
|
|
}
|
2008-03-05 22:22:46 +00:00
|
|
|
|
2007-06-28 19:02:54 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2001-10-15 03:12:52 +00:00
|
|
|
// LinkGlobalInits - Update the initializers in the Dest module now that all
|
|
|
|
// globals that may be referenced are in Dest.
|
|
|
|
static bool LinkGlobalInits(Module *Dest, const Module *Src,
|
2003-01-30 19:53:34 +00:00
|
|
|
std::map<const Value*, Value*> &ValueMap,
|
|
|
|
std::string *Err) {
|
2001-10-15 03:12:52 +00:00
|
|
|
// Loop over all of the globals in the src module, mapping them over as we go
|
2006-06-16 01:24:04 +00:00
|
|
|
for (Module::const_global_iterator I = Src->global_begin(),
|
|
|
|
E = Src->global_end(); I != E; ++I) {
|
2002-06-25 16:12:52 +00:00
|
|
|
const GlobalVariable *SGV = I;
|
2001-10-15 03:12:52 +00:00
|
|
|
|
|
|
|
if (SGV->hasInitializer()) { // Only process initialized GV's
|
|
|
|
// Figure out what the initializer looks like in the dest module...
|
2003-04-16 20:28:45 +00:00
|
|
|
Constant *SInit =
|
2009-07-07 21:07:14 +00:00
|
|
|
cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap,
|
|
|
|
Dest->getContext()));
|
2008-10-15 20:10:50 +00:00
|
|
|
// Grab destination global variable or alias.
|
|
|
|
GlobalValue *DGV = cast<GlobalValue>(ValueMap[SGV]->stripPointerCasts());
|
|
|
|
|
|
|
|
// If dest if global variable, check that initializers match.
|
|
|
|
if (GlobalVariable *DGVar = dyn_cast<GlobalVariable>(DGV)) {
|
|
|
|
if (DGVar->hasInitializer()) {
|
|
|
|
if (SGV->hasExternalLinkage()) {
|
|
|
|
if (DGVar->getInitializer() != SInit)
|
|
|
|
return Error(Err, "Global Variable Collision on '" +
|
|
|
|
SGV->getName() +
|
|
|
|
"': global variables have different initializers");
|
2009-03-08 13:35:23 +00:00
|
|
|
} else if (DGVar->isWeakForLinker()) {
|
2008-10-15 20:10:50 +00:00
|
|
|
// Nothing is required, mapped values will take the new global
|
|
|
|
// automatically.
|
2009-03-08 13:35:23 +00:00
|
|
|
} else if (SGV->isWeakForLinker()) {
|
2008-10-15 20:10:50 +00:00
|
|
|
// Nothing is required, mapped values will take the new global
|
|
|
|
// automatically.
|
|
|
|
} else if (DGVar->hasAppendingLinkage()) {
|
|
|
|
assert(0 && "Appending linkage unimplemented!");
|
|
|
|
} else {
|
|
|
|
assert(0 && "Unknown linkage!");
|
|
|
|
}
|
2003-04-16 20:28:45 +00:00
|
|
|
} else {
|
2008-10-15 20:10:50 +00:00
|
|
|
// Copy the initializer over now...
|
|
|
|
DGVar->setInitializer(SInit);
|
2003-04-16 20:28:45 +00:00
|
|
|
}
|
2001-10-15 03:12:52 +00:00
|
|
|
} else {
|
2008-10-15 20:10:50 +00:00
|
|
|
// Destination is alias, the only valid situation is when source is
|
|
|
|
// weak. Also, note, that we already checked linkage in LinkGlobals(),
|
|
|
|
// thus we assert here.
|
|
|
|
// FIXME: Should we weaken this assumption, 'dereference' alias and
|
|
|
|
// check for initializer of aliasee?
|
2009-03-08 13:35:23 +00:00
|
|
|
assert(SGV->isWeakForLinker());
|
2001-10-15 03:12:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2002-03-26 18:01:55 +00:00
|
|
|
// LinkFunctionProtos - Link the functions together between the two modules,
|
2002-05-07 18:36:35 +00:00
|
|
|
// without doing function bodies... this just adds external function prototypes
|
|
|
|
// to the Dest function...
|
2001-10-14 23:29:15 +00:00
|
|
|
//
|
2002-03-26 18:01:55 +00:00
|
|
|
static bool LinkFunctionProtos(Module *Dest, const Module *Src,
|
2003-01-30 19:53:34 +00:00
|
|
|
std::map<const Value*, Value*> &ValueMap,
|
|
|
|
std::string *Err) {
|
2008-07-14 06:49:45 +00:00
|
|
|
ValueSymbolTable &DestSymTab = Dest->getValueSymbolTable();
|
2009-07-07 21:07:14 +00:00
|
|
|
LLVMContext &Context = Dest->getContext();
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2007-02-04 04:43:17 +00:00
|
|
|
// Loop over all of the functions in the src module, mapping them over
|
2001-10-14 23:29:15 +00:00
|
|
|
for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) {
|
2002-06-25 16:12:52 +00:00
|
|
|
const Function *SF = I; // SrcFunction
|
2008-07-05 23:03:21 +00:00
|
|
|
GlobalValue *DGV = 0;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// Check to see if may have to link the function with the global, alias or
|
|
|
|
// function.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (SF->hasName() && !SF->hasLocalLinkage())
|
2008-07-14 06:49:45 +00:00
|
|
|
DGV = cast_or_null<GlobalValue>(DestSymTab.lookup(SF->getNameStart(),
|
|
|
|
SF->getNameEnd()));
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 06:52:19 +00:00
|
|
|
// 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.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (DGV && DGV->hasLocalLinkage())
|
2008-07-14 06:52:19 +00:00
|
|
|
DGV = 0;
|
|
|
|
|
2008-07-14 06:49:45 +00:00
|
|
|
// If types don't agree due to opaque types, try to resolve them.
|
|
|
|
if (DGV && DGV->getType() != SF->getType())
|
|
|
|
RecursiveResolveTypes(SF->getType(), DGV->getType());
|
2008-07-05 23:03:21 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage;
|
|
|
|
bool LinkFromSrc = false;
|
|
|
|
if (GetLinkageResult(DGV, SF, NewLinkage, LinkFromSrc, Err))
|
|
|
|
return true;
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-09 07:36:11 +00:00
|
|
|
// If there is no linkage to be performed, just bring over SF without
|
|
|
|
// modifying it.
|
2008-07-05 23:03:21 +00:00
|
|
|
if (DGV == 0) {
|
2008-06-09 07:36:11 +00:00
|
|
|
// Function does not already exist, simply insert an function signature
|
|
|
|
// identical to SF into the dest module.
|
|
|
|
Function *NewDF = Function::Create(SF->getFunctionType(),
|
|
|
|
SF->getLinkage(),
|
|
|
|
SF->getName(), Dest);
|
|
|
|
CopyGVAttributes(NewDF, SF);
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-09 07:36:11 +00:00
|
|
|
// If the LLVM runtime renamed the function, but it is an externally
|
|
|
|
// visible symbol, DF must be an existing function with internal linkage.
|
|
|
|
// Rename it.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (!NewDF->hasLocalLinkage() && NewDF->getName() != SF->getName())
|
2008-06-09 07:36:11 +00:00
|
|
|
ForceRenaming(NewDF, SF->getName());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-06-09 07:36:11 +00:00
|
|
|
// ... and remember this mapping...
|
|
|
|
ValueMap[SF] = NewDF;
|
|
|
|
continue;
|
2007-08-19 22:22:54 +00:00
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// If the visibilities of the symbols disagree and the destination is a
|
|
|
|
// prototype, take the visibility of its input.
|
|
|
|
if (DGV->isDeclaration())
|
|
|
|
DGV->setVisibility(SF->getVisibility());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
if (LinkFromSrc) {
|
|
|
|
if (isa<GlobalAlias>(DGV))
|
|
|
|
return Error(Err, "Function-Alias Collision on '" + SF->getName() +
|
|
|
|
"': symbol multiple defined");
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// We have a definition of the same name but different type in the
|
|
|
|
// source module. Copy the prototype to the destination and replace
|
|
|
|
// uses of the destination's prototype with the new prototype.
|
|
|
|
Function *NewDF = Function::Create(SF->getFunctionType(), NewLinkage,
|
|
|
|
SF->getName(), Dest);
|
|
|
|
CopyGVAttributes(NewDF, SF);
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Any uses of DF need to change to NewDF, with cast
|
2009-07-07 21:07:14 +00:00
|
|
|
DGV->replaceAllUsesWith(Context.getConstantExprBitCast(NewDF,
|
|
|
|
DGV->getType()));
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// DF will conflict with NewDF because they both had the same. We must
|
|
|
|
// erase this now so ForceRenaming doesn't assert because DF might
|
2009-03-03 07:22:23 +00:00
|
|
|
// not have internal linkage.
|
2008-07-14 07:23:24 +00:00
|
|
|
if (GlobalVariable *Var = dyn_cast<GlobalVariable>(DGV))
|
|
|
|
Var->eraseFromParent();
|
|
|
|
else
|
|
|
|
cast<Function>(DGV)->eraseFromParent();
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// If the symbol table renamed the function, but it is an externally
|
2009-03-03 07:22:23 +00:00
|
|
|
// visible symbol, DF must be an existing function with internal
|
2008-07-14 07:23:24 +00:00
|
|
|
// linkage. Rename it.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (NewDF->getName() != SF->getName() && !NewDF->hasLocalLinkage())
|
2008-07-14 07:23:24 +00:00
|
|
|
ForceRenaming(NewDF, SF->getName());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Remember this mapping so uses in the source module get remapped
|
|
|
|
// later by RemapOperand.
|
|
|
|
ValueMap[SF] = NewDF;
|
2008-06-09 07:47:34 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
// Not "link from source", keep the one in the DestModule and remap the
|
|
|
|
// input onto it.
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2008-07-14 07:23:24 +00:00
|
|
|
if (isa<GlobalAlias>(DGV)) {
|
|
|
|
// The only valid mappings are:
|
|
|
|
// - SF is external declaration, which is effectively a no-op.
|
|
|
|
// - SF is weak, when we just need to throw SF out.
|
2009-03-08 13:35:23 +00:00
|
|
|
if (!SF->isDeclaration() && !SF->isWeakForLinker())
|
2008-07-14 07:23:24 +00:00
|
|
|
return Error(Err, "Function-Alias Collision on '" + SF->getName() +
|
|
|
|
"': symbol multiple defined");
|
2008-06-09 07:47:34 +00:00
|
|
|
}
|
2008-07-14 07:23:24 +00:00
|
|
|
|
|
|
|
// Set calculated linkage
|
|
|
|
DGV->setLinkage(NewLinkage);
|
|
|
|
|
|
|
|
// Make sure to remember this mapping.
|
2009-07-07 21:07:14 +00:00
|
|
|
ValueMap[SF] = Context.getConstantExprBitCast(DGV, SF->getType());
|
2001-10-14 23:29:15 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2002-05-07 18:36:35 +00:00
|
|
|
// 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.
|
2004-11-16 07:31:51 +00:00
|
|
|
static bool LinkFunctionBody(Function *Dest, Function *Src,
|
2007-02-05 20:47:22 +00:00
|
|
|
std::map<const Value*, Value*> &ValueMap,
|
2003-01-30 19:53:34 +00:00
|
|
|
std::string *Err) {
|
2007-01-30 20:08:39 +00:00
|
|
|
assert(Src && Dest && Dest->isDeclaration() && !Src->isDeclaration());
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2004-11-16 17:12:38 +00:00
|
|
|
// Go through and convert function arguments over, remembering the mapping.
|
2005-03-15 04:54:21 +00:00
|
|
|
Function::arg_iterator DI = Dest->arg_begin();
|
|
|
|
for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();
|
2002-10-13 20:57:00 +00:00
|
|
|
I != E; ++I, ++DI) {
|
2008-04-14 17:38:21 +00:00
|
|
|
DI->setName(I->getName()); // Copy the name information over...
|
2001-10-14 23:29:15 +00:00
|
|
|
|
|
|
|
// Add a mapping to our local map
|
2008-03-10 22:36:08 +00:00
|
|
|
ValueMap[I] = DI;
|
2001-10-14 23:29:15 +00:00
|
|
|
}
|
|
|
|
|
2004-11-16 07:31:51 +00:00
|
|
|
// Splice the body of the source function into the dest function.
|
|
|
|
Dest->getBasicBlockList().splice(Dest->end(), Src->getBasicBlockList());
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2002-05-07 18:36:35 +00:00
|
|
|
// At this point, all of the instructions and values of the function are now
|
|
|
|
// copied over. The only problem is that they are still referencing values in
|
|
|
|
// the Source function as operands. Loop through all of the operands of the
|
|
|
|
// functions and patch them up to point to the local versions...
|
2001-10-14 23:29:15 +00:00
|
|
|
//
|
2002-06-25 16:12:52 +00:00
|
|
|
for (Function::iterator BB = Dest->begin(), BE = Dest->end(); BB != BE; ++BB)
|
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
|
|
|
|
for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end();
|
2002-02-12 21:07:25 +00:00
|
|
|
OI != OE; ++OI)
|
2004-11-16 07:31:51 +00:00
|
|
|
if (!isa<Instruction>(*OI) && !isa<BasicBlock>(*OI))
|
2009-07-07 21:07:14 +00:00
|
|
|
*OI = RemapOperand(*OI, ValueMap, *Dest->getContext());
|
2004-11-16 17:12:38 +00:00
|
|
|
|
|
|
|
// There is no need to map the arguments anymore.
|
2006-06-16 01:24:04 +00:00
|
|
|
for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();
|
|
|
|
I != E; ++I)
|
2007-02-05 20:47:22 +00:00
|
|
|
ValueMap.erase(I);
|
2001-10-14 23:29:15 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-05-07 18:36:35 +00:00
|
|
|
// LinkFunctionBodies - Link in the function bodies that are defined in the
|
|
|
|
// source module into the DestModule. This consists basically of copying the
|
|
|
|
// function over and fixing up references to values.
|
2004-11-16 07:31:51 +00:00
|
|
|
static bool LinkFunctionBodies(Module *Dest, Module *Src,
|
2003-01-30 19:53:34 +00:00
|
|
|
std::map<const Value*, Value*> &ValueMap,
|
|
|
|
std::string *Err) {
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2007-02-04 04:29:21 +00:00
|
|
|
// Loop over all of the functions in the src module, mapping them over as we
|
|
|
|
// go
|
2004-11-16 07:31:51 +00:00
|
|
|
for (Module::iterator SF = Src->begin(), E = Src->end(); SF != E; ++SF) {
|
2007-02-04 04:43:17 +00:00
|
|
|
if (!SF->isDeclaration()) { // No body if function is external
|
2008-06-20 05:29:39 +00:00
|
|
|
Function *DF = dyn_cast<Function>(ValueMap[SF]); // Destination function
|
2001-10-23 20:43:42 +00:00
|
|
|
|
2002-06-25 16:12:52 +00:00
|
|
|
// DF not external SF external?
|
2008-06-20 05:29:39 +00:00
|
|
|
if (DF && DF->isDeclaration())
|
2003-10-27 16:39:39 +00:00
|
|
|
// Only provide the function body if there isn't one already.
|
|
|
|
if (LinkFunctionBody(DF, SF, ValueMap, Err))
|
|
|
|
return true;
|
2001-10-23 20:43:42 +00:00
|
|
|
}
|
2001-10-14 23:29:15 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// LinkAppendingVars - If there were any appending global variables, link them
|
|
|
|
// together now. Return true on error.
|
|
|
|
static bool LinkAppendingVars(Module *M,
|
|
|
|
std::multimap<std::string, GlobalVariable *> &AppendingVars,
|
|
|
|
std::string *ErrorMsg) {
|
|
|
|
if (AppendingVars.empty()) return false; // Nothing to do.
|
2005-04-21 22:55:34 +00:00
|
|
|
|
2009-07-07 21:07:14 +00:00
|
|
|
LLVMContext &Context = M->getContext();
|
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// Loop over the multimap of appending vars, processing any variables with the
|
|
|
|
// same name, forming a new appending global variable with both of the
|
|
|
|
// initializers merged together, then rewrite references to the old variables
|
|
|
|
// and delete them.
|
|
|
|
std::vector<Constant*> Inits;
|
|
|
|
while (AppendingVars.size() > 1) {
|
|
|
|
// Get the first two elements in the map...
|
|
|
|
std::multimap<std::string,
|
|
|
|
GlobalVariable*>::iterator Second = AppendingVars.begin(), First=Second++;
|
|
|
|
|
|
|
|
// If the first two elements are for different names, there is no pair...
|
|
|
|
// Otherwise there is a pair, so link them together...
|
|
|
|
if (First->first == Second->first) {
|
|
|
|
GlobalVariable *G1 = First->second, *G2 = Second->second;
|
|
|
|
const ArrayType *T1 = cast<ArrayType>(G1->getType()->getElementType());
|
|
|
|
const ArrayType *T2 = cast<ArrayType>(G2->getType()->getElementType());
|
2005-04-21 22:55:34 +00:00
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// Check to see that they two arrays agree on type...
|
|
|
|
if (T1->getElementType() != T2->getElementType())
|
|
|
|
return Error(ErrorMsg,
|
|
|
|
"Appending variables with different element types need to be linked!");
|
|
|
|
if (G1->isConstant() != G2->isConstant())
|
|
|
|
return Error(ErrorMsg,
|
|
|
|
"Appending variables linked with different const'ness!");
|
|
|
|
|
2007-06-06 22:01:12 +00:00
|
|
|
if (G1->getAlignment() != G2->getAlignment())
|
|
|
|
return Error(ErrorMsg,
|
|
|
|
"Appending variables with different alignment need to be linked!");
|
|
|
|
|
|
|
|
if (G1->getVisibility() != G2->getVisibility())
|
|
|
|
return Error(ErrorMsg,
|
|
|
|
"Appending variables with different visibility need to be linked!");
|
|
|
|
|
|
|
|
if (G1->getSection() != G2->getSection())
|
|
|
|
return Error(ErrorMsg,
|
|
|
|
"Appending variables with different section name need to be linked!");
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
unsigned NewSize = T1->getNumElements() + T2->getNumElements();
|
2009-07-07 21:07:14 +00:00
|
|
|
ArrayType *NewType = Context.getArrayType(T1->getElementType(),
|
|
|
|
NewSize);
|
2003-05-13 21:33:43 +00:00
|
|
|
|
2005-12-06 17:30:58 +00:00
|
|
|
G1->setName(""); // Clear G1's name in case of a conflict!
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// Create the new global variable...
|
|
|
|
GlobalVariable *NG =
|
|
|
|
new GlobalVariable(NewType, G1->isConstant(), G1->getLinkage(),
|
2008-06-27 03:10:24 +00:00
|
|
|
/*init*/0, First->first, M, G1->isThreadLocal(),
|
|
|
|
G1->getType()->getAddressSpace());
|
2003-05-13 21:33:43 +00:00
|
|
|
|
2007-06-06 22:01:12 +00:00
|
|
|
// Propagate alignment, visibility and section info.
|
|
|
|
CopyGVAttributes(NG, G1);
|
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// Merge the initializer...
|
|
|
|
Inits.reserve(NewSize);
|
2004-02-15 05:55:15 +00:00
|
|
|
if (ConstantArray *I = dyn_cast<ConstantArray>(G1->getInitializer())) {
|
|
|
|
for (unsigned i = 0, e = T1->getNumElements(); i != e; ++i)
|
2004-08-04 08:08:13 +00:00
|
|
|
Inits.push_back(I->getOperand(i));
|
2004-02-15 05:55:15 +00:00
|
|
|
} else {
|
|
|
|
assert(isa<ConstantAggregateZero>(G1->getInitializer()));
|
2009-07-07 21:07:14 +00:00
|
|
|
Constant *CV = Context.getNullValue(T1->getElementType());
|
2004-02-15 05:55:15 +00:00
|
|
|
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)
|
2004-08-04 08:08:13 +00:00
|
|
|
Inits.push_back(I->getOperand(i));
|
2004-02-15 05:55:15 +00:00
|
|
|
} else {
|
|
|
|
assert(isa<ConstantAggregateZero>(G2->getInitializer()));
|
2009-07-07 21:07:14 +00:00
|
|
|
Constant *CV = Context.getNullValue(T2->getElementType());
|
2004-02-15 05:55:15 +00:00
|
|
|
for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
|
|
|
|
Inits.push_back(CV);
|
|
|
|
}
|
2009-07-07 21:07:14 +00:00
|
|
|
NG->setInitializer(Context.getConstantArray(NewType, Inits));
|
2003-05-13 21:33:43 +00:00
|
|
|
Inits.clear();
|
|
|
|
|
|
|
|
// Replace any uses of the two global variables with uses of the new
|
|
|
|
// global...
|
|
|
|
|
|
|
|
// FIXME: This should rewrite simple/straight-forward uses such as
|
|
|
|
// getelementptr instructions to not use the Cast!
|
2009-07-07 21:07:14 +00:00
|
|
|
G1->replaceAllUsesWith(Context.getConstantExprBitCast(NG,
|
|
|
|
G1->getType()));
|
|
|
|
G2->replaceAllUsesWith(Context.getConstantExprBitCast(NG,
|
|
|
|
G2->getType()));
|
2003-05-13 21:33:43 +00:00
|
|
|
|
|
|
|
// Remove the two globals from the module now...
|
|
|
|
M->getGlobalList().erase(G1);
|
|
|
|
M->getGlobalList().erase(G2);
|
|
|
|
|
|
|
|
// Put the new global into the AppendingVars map so that we can handle
|
|
|
|
// linking of more than two vars...
|
|
|
|
Second->second = NG;
|
|
|
|
}
|
|
|
|
AppendingVars.erase(First);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2001-10-13 07:03:50 +00:00
|
|
|
|
2008-03-05 23:21:39 +00:00
|
|
|
static bool ResolveAliases(Module *Dest) {
|
|
|
|
for (Module::alias_iterator I = Dest->alias_begin(), E = Dest->alias_end();
|
2008-03-11 22:51:09 +00:00
|
|
|
I != E; ++I)
|
2008-09-09 20:05:04 +00:00
|
|
|
if (const GlobalValue *GV = I->resolveAliasedGlobal())
|
2008-09-09 18:23:48 +00:00
|
|
|
if (GV != I && !GV->isDeclaration())
|
2008-03-11 22:51:09 +00:00
|
|
|
I->replaceAllUsesWith(const_cast<GlobalValue*>(GV));
|
2008-03-05 23:21:39 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2001-10-13 07:03:50 +00:00
|
|
|
|
|
|
|
// LinkModules - This function links two modules together, with the resulting
|
|
|
|
// left 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
|
2001-10-14 23:29:15 +00:00
|
|
|
// the problem. Upon failure, the Dest module could be in a modified state, and
|
|
|
|
// shouldn't be relied on to be consistent.
|
2005-04-21 22:55:34 +00:00
|
|
|
bool
|
2004-12-13 03:00:16 +00:00
|
|
|
Linker::LinkModules(Module *Dest, Module *Src, std::string *ErrorMsg) {
|
2004-09-11 04:25:17 +00:00
|
|
|
assert(Dest != 0 && "Invalid Destination module");
|
|
|
|
assert(Src != 0 && "Invalid Source Module");
|
|
|
|
|
2007-01-29 00:21:34 +00:00
|
|
|
if (Dest->getDataLayout().empty()) {
|
|
|
|
if (!Src->getDataLayout().empty()) {
|
2007-01-29 02:18:13 +00:00
|
|
|
Dest->setDataLayout(Src->getDataLayout());
|
2007-01-29 00:21:34 +00:00
|
|
|
} else {
|
|
|
|
std::string DataLayout;
|
|
|
|
|
2008-02-20 11:27:04 +00:00
|
|
|
if (Dest->getEndianness() == Module::AnyEndianness) {
|
2007-01-29 00:21:34 +00:00
|
|
|
if (Src->getEndianness() == Module::BigEndian)
|
|
|
|
DataLayout.append("E");
|
|
|
|
else if (Src->getEndianness() == Module::LittleEndian)
|
|
|
|
DataLayout.append("e");
|
2008-02-20 11:27:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Dest->getPointerSize() == Module::AnyPointerSize) {
|
2007-01-29 00:21:34 +00:00
|
|
|
if (Src->getPointerSize() == Module::Pointer64)
|
|
|
|
DataLayout.append(DataLayout.length() == 0 ? "p:64:64" : "-p:64:64");
|
|
|
|
else if (Src->getPointerSize() == Module::Pointer32)
|
|
|
|
DataLayout.append(DataLayout.length() == 0 ? "p:32:32" : "-p:32:32");
|
2008-02-20 11:27:04 +00:00
|
|
|
}
|
2007-01-29 00:21:34 +00:00
|
|
|
Dest->setDataLayout(DataLayout);
|
|
|
|
}
|
|
|
|
}
|
2003-08-24 19:26:42 +00:00
|
|
|
|
2008-02-19 18:49:08 +00:00
|
|
|
// Copy the target triple from the source to dest if the dest's is empty.
|
2007-01-29 00:21:34 +00:00
|
|
|
if (Dest->getTargetTriple().empty() && !Src->getTargetTriple().empty())
|
|
|
|
Dest->setTargetTriple(Src->getTargetTriple());
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2007-01-29 00:21:34 +00:00
|
|
|
if (!Src->getDataLayout().empty() && !Dest->getDataLayout().empty() &&
|
|
|
|
Src->getDataLayout() != Dest->getDataLayout())
|
2007-01-26 08:11:39 +00:00
|
|
|
cerr << "WARNING: Linking two modules of different data layouts!\n";
|
2004-12-10 20:26:15 +00:00
|
|
|
if (!Src->getTargetTriple().empty() &&
|
|
|
|
Dest->getTargetTriple() != Src->getTargetTriple())
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << "WARNING: Linking two modules of different target triples!\n";
|
2005-04-21 22:55:34 +00:00
|
|
|
|
2008-02-19 18:49:08 +00:00
|
|
|
// Append the module inline asm string.
|
2006-01-24 04:14:29 +00:00
|
|
|
if (!Src->getModuleInlineAsm().empty()) {
|
|
|
|
if (Dest->getModuleInlineAsm().empty())
|
|
|
|
Dest->setModuleInlineAsm(Src->getModuleInlineAsm());
|
2006-01-23 23:08:37 +00:00
|
|
|
else
|
2006-01-24 04:14:29 +00:00
|
|
|
Dest->setModuleInlineAsm(Dest->getModuleInlineAsm()+"\n"+
|
|
|
|
Src->getModuleInlineAsm());
|
2006-01-23 23:08:37 +00:00
|
|
|
}
|
2009-03-03 07:22:23 +00:00
|
|
|
|
2004-11-25 09:29:44 +00:00
|
|
|
// Update the destination module's dependent libraries list with the libraries
|
2004-09-11 04:25:17 +00:00
|
|
|
// from the source module. There's no opportunity for duplicates here as the
|
|
|
|
// Module ensures that duplicate insertions are discarded.
|
2008-02-19 18:49:08 +00:00
|
|
|
for (Module::lib_iterator SI = Src->lib_begin(), SE = Src->lib_end();
|
2009-03-03 07:22:23 +00:00
|
|
|
SI != SE; ++SI)
|
2004-09-11 04:25:17 +00:00
|
|
|
Dest->addLibrary(*SI);
|
|
|
|
|
2001-11-03 05:18:24 +00:00
|
|
|
// 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.
|
|
|
|
// Make sure there are no type name conflicts.
|
2009-03-03 07:22:23 +00:00
|
|
|
if (LinkTypes(Dest, Src, ErrorMsg))
|
2007-02-04 04:43:17 +00:00
|
|
|
return true;
|
2001-11-03 05:18:24 +00:00
|
|
|
|
2001-10-14 23:29:15 +00:00
|
|
|
// ValueMap - Mapping of values from what they used to be in Src, to what they
|
|
|
|
// are now in Dest.
|
2003-01-30 19:53:34 +00:00
|
|
|
std::map<const Value*, Value*> ValueMap;
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// AppendingVars - Keep track of global variables in the destination module
|
|
|
|
// with appending linkage. After the module is linked together, they are
|
|
|
|
// appended and the module is rewritten.
|
|
|
|
std::multimap<std::string, GlobalVariable *> AppendingVars;
|
2006-06-16 01:24:04 +00:00
|
|
|
for (Module::global_iterator I = Dest->global_begin(), E = Dest->global_end();
|
|
|
|
I != E; ++I) {
|
2004-08-04 07:44:58 +00:00
|
|
|
// Add all of the appending globals already in the Dest module to
|
|
|
|
// AppendingVars.
|
2003-05-14 12:11:51 +00:00
|
|
|
if (I->hasAppendingLinkage())
|
|
|
|
AppendingVars.insert(std::make_pair(I->getName(), I));
|
2004-08-04 07:44:58 +00:00
|
|
|
}
|
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// Insert all of the globals in src into the Dest module... without linking
|
|
|
|
// initializers (which could refer to functions not yet mapped over).
|
2007-02-05 20:47:22 +00:00
|
|
|
if (LinkGlobals(Dest, Src, ValueMap, AppendingVars, ErrorMsg))
|
2004-08-04 07:44:58 +00:00
|
|
|
return true;
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2002-05-07 18:36:35 +00:00
|
|
|
// Link the functions together between the two modules, without doing function
|
|
|
|
// bodies... this just adds external function prototypes to the Dest
|
|
|
|
// function... We do this so that when we begin processing function bodies,
|
|
|
|
// all of the global values that may be referenced are available in our
|
|
|
|
// ValueMap.
|
2007-02-05 20:47:22 +00:00
|
|
|
if (LinkFunctionProtos(Dest, Src, ValueMap, ErrorMsg))
|
2004-08-04 07:44:58 +00:00
|
|
|
return true;
|
2001-10-14 23:29:15 +00:00
|
|
|
|
2008-03-05 15:27:21 +00:00
|
|
|
// If there were any alias, link them now. We really need to do this now,
|
|
|
|
// because all of the aliases that may be referenced need to be available in
|
|
|
|
// ValueMap
|
|
|
|
if (LinkAlias(Dest, Src, ValueMap, ErrorMsg)) return true;
|
|
|
|
|
2002-07-18 00:13:08 +00:00
|
|
|
// Update the initializers in the Dest module now that all globals that may
|
|
|
|
// be referenced are in Dest.
|
|
|
|
if (LinkGlobalInits(Dest, Src, ValueMap, ErrorMsg)) return true;
|
|
|
|
|
2002-05-07 18:36:35 +00:00
|
|
|
// Link in the function bodies that are defined in the source module into the
|
|
|
|
// DestModule. This consists basically of copying the function over and
|
|
|
|
// fixing up references to values.
|
2002-03-26 18:01:55 +00:00
|
|
|
if (LinkFunctionBodies(Dest, Src, ValueMap, ErrorMsg)) return true;
|
2001-10-13 07:03:50 +00:00
|
|
|
|
2003-05-13 21:33:43 +00:00
|
|
|
// If there were any appending global variables, link them together now.
|
|
|
|
if (LinkAppendingVars(Dest, AppendingVars, ErrorMsg)) return true;
|
|
|
|
|
2008-03-05 23:08:47 +00:00
|
|
|
// Resolve all uses of aliases with aliasees
|
|
|
|
if (ResolveAliases(Dest)) return true;
|
|
|
|
|
2004-09-11 04:25:17 +00:00
|
|
|
// If the source library's module id is in the dependent library list of the
|
|
|
|
// destination library, remove it since that module is now linked in.
|
|
|
|
sys::Path modId;
|
2005-07-07 23:21:43 +00:00
|
|
|
modId.set(Src->getModuleIdentifier());
|
2004-11-05 22:15:36 +00:00
|
|
|
if (!modId.isEmpty())
|
|
|
|
Dest->removeLibrary(modId.getBasename());
|
2004-09-11 04:25:17 +00:00
|
|
|
|
2001-10-13 07:03:50 +00:00
|
|
|
return false;
|
|
|
|
}
|
2001-10-28 21:38:02 +00:00
|
|
|
|
2004-05-25 08:52:20 +00:00
|
|
|
// vim: sw=2
|