aboutsummaryrefslogtreecommitdiff
path: root/lib/Transforms
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Transforms')
-rw-r--r--lib/Transforms/IPO/ExtractFunction.cpp8
-rw-r--r--lib/Transforms/IPO/Internalize.cpp4
-rw-r--r--lib/Transforms/IPO/MutateStructTypes.cpp3
-rw-r--r--lib/Transforms/IPO/Parallelize.cpp3
-rw-r--r--lib/Transforms/IPO/PoolAllocate.cpp3
-rw-r--r--lib/Transforms/Instrumentation/EmitFunctions.cpp3
-rw-r--r--lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp13
-rw-r--r--lib/Transforms/Instrumentation/TraceValues.cpp3
-rw-r--r--lib/Transforms/Utils/CloneFunction.cpp2
-rw-r--r--lib/Transforms/Utils/CloneModule.cpp13
-rw-r--r--lib/Transforms/Utils/Linker.cpp125
11 files changed, 104 insertions, 76 deletions
diff --git a/lib/Transforms/IPO/ExtractFunction.cpp b/lib/Transforms/IPO/ExtractFunction.cpp
index a2d28f58c6..f16c3f3253 100644
--- a/lib/Transforms/IPO/ExtractFunction.cpp
+++ b/lib/Transforms/IPO/ExtractFunction.cpp
@@ -16,13 +16,13 @@ namespace {
}
// Make sure our result is globally accessable...
- Named->setInternalLinkage(false);
+ Named->setLinkage(GlobalValue::ExternalLinkage);
// Mark all global variables internal
for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
if (!I->isExternal()) {
I->setInitializer(0); // Make all variables external
- I->setInternalLinkage(false); // Make sure it's not internal
+ I->setLinkage(GlobalValue::ExternalLinkage);
}
// All of the functions may be used by global variables or the named
@@ -35,7 +35,9 @@ namespace {
for (Module::iterator I = M.begin(); ; ++I) {
if (&*I != Named) {
- Function *New = new Function(I->getFunctionType(),false,I->getName());
+ Function *New = new Function(I->getFunctionType(),
+ GlobalValue::ExternalLinkage,
+ I->getName());
I->setName(""); // Remove Old name
// If it's not the named function, delete the body of the function
diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp
index 910e1d4322..f09fd141c7 100644
--- a/lib/Transforms/IPO/Internalize.cpp
+++ b/lib/Transforms/IPO/Internalize.cpp
@@ -29,7 +29,7 @@ namespace {
if (&*I != MainFunc && // Leave the main function external
!I->isExternal() && // Function must be defined here
!I->hasInternalLinkage()) { // Can't already have internal linkage
- I->setInternalLinkage(true);
+ I->setLinkage(GlobalValue::InternalLinkage);
Changed = true;
++NumFunctions;
DEBUG(std::cerr << "Internalizing func " << I->getName() << "\n");
@@ -38,7 +38,7 @@ namespace {
// Mark all global variables with initializers as internal as well...
for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
if (!I->isExternal() && I->hasExternalLinkage()) {
- I->setInternalLinkage(true);
+ I->setLinkage(GlobalValue::InternalLinkage);
Changed = true;
++NumGlobals;
DEBUG(std::cerr << "Internalizing gvar " << I->getName() << "\n");
diff --git a/lib/Transforms/IPO/MutateStructTypes.cpp b/lib/Transforms/IPO/MutateStructTypes.cpp
index b7418ec6e3..8e58d4dbb2 100644
--- a/lib/Transforms/IPO/MutateStructTypes.cpp
+++ b/lib/Transforms/IPO/MutateStructTypes.cpp
@@ -250,8 +250,7 @@ void MutateStructTypes::processGlobals(Module &M) {
cast<FunctionType>(ConvertType(I->getFunctionType()));
// Create a new function to put stuff into...
- Function *NewMeth = new Function(NewMTy, I->hasInternalLinkage(),
- I->getName());
+ Function *NewMeth = new Function(NewMTy, I->getLinkage(), I->getName());
if (I->hasName())
I->setName("OLD."+I->getName());
diff --git a/lib/Transforms/IPO/Parallelize.cpp b/lib/Transforms/IPO/Parallelize.cpp
index 08c800eb1c..46fbcc7d85 100644
--- a/lib/Transforms/IPO/Parallelize.cpp
+++ b/lib/Transforms/IPO/Parallelize.cpp
@@ -137,7 +137,8 @@ Cilkifier::Cilkifier(Module& M)
DummySyncFunc = new Function(FunctionType::get( Type::VoidTy,
std::vector<const Type*>(),
/*isVararg*/ false),
- /*isInternal*/ false, DummySyncFuncName, &M);
+ GlobalValue::ExternalLinkage, DummySyncFuncName,
+ &M);
}
void Cilkifier::TransformFunc(Function* F,
diff --git a/lib/Transforms/IPO/PoolAllocate.cpp b/lib/Transforms/IPO/PoolAllocate.cpp
index b2efc12de2..844d0c15ff 100644
--- a/lib/Transforms/IPO/PoolAllocate.cpp
+++ b/lib/Transforms/IPO/PoolAllocate.cpp
@@ -161,7 +161,8 @@ Function *PoolAllocate::MakeFunctionClone(Function &F) {
FunctionType *FuncTy = FunctionType::get(OldFuncTy->getReturnType(), ArgTys,
OldFuncTy->isVarArg());
// Create the new function...
- Function *New = new Function(FuncTy, true, F.getName(), F.getParent());
+ Function *New = new Function(FuncTy, GlobalValue::InternalLinkage,
+ F.getName(), F.getParent());
// Set the rest of the new arguments names to be PDa<n> and add entries to the
// pool descriptors map
diff --git a/lib/Transforms/Instrumentation/EmitFunctions.cpp b/lib/Transforms/Instrumentation/EmitFunctions.cpp
index d4a99e2c67..32488d69b5 100644
--- a/lib/Transforms/Instrumentation/EmitFunctions.cpp
+++ b/lib/Transforms/Instrumentation/EmitFunctions.cpp
@@ -33,7 +33,8 @@ bool EmitFunctionTable::run(Module &M){
StructType *sttype = StructType::get(vType);
ConstantStruct *cstruct = ConstantStruct::get(sttype, vConsts);
- GlobalVariable *gb = new GlobalVariable(cstruct->getType(), true, false,
+ GlobalVariable *gb = new GlobalVariable(cstruct->getType(), true,
+ GlobalValue::ExternalLinkage,
cstruct, "llvmFunctionTable");
M.getGlobalList().push_back(gb);
return true; // Always modifies program
diff --git a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
index 39e7c35121..57b17a590f 100644
--- a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
+++ b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
@@ -183,14 +183,19 @@ bool ProfilePaths::runOnFunction(Function &F){
for(int xi=0; xi<numPaths; xi++)
arrayInitialize.push_back(ConstantSInt::get(Type::IntTy, 0));
- Constant *initializer = ConstantArray::get(ArrayType::get(Type::IntTy, numPaths), arrayInitialize);
- GlobalVariable *countVar = new GlobalVariable(ArrayType::get(Type::IntTy, numPaths), false, true, initializer, "Count", F.getParent());
+ const ArrayType *ATy = ArrayType::get(Type::IntTy, numPaths);
+ Constant *initializer = ConstantArray::get(ATy, arrayInitialize);
+ GlobalVariable *countVar = new GlobalVariable(ATy, false,
+ GlobalValue::InternalLinkage,
+ initializer, "Count",
+ F.getParent());
static GlobalVariable *threshold = NULL;
static bool insertedThreshold = false;
if(!insertedThreshold){
- threshold = new GlobalVariable(Type::IntTy, false, false, 0,
- "reopt_threshold");
+ threshold = new GlobalVariable(Type::IntTy, false,
+ GlobalValue::ExternalLinkage, 0,
+ "reopt_threshold");
F.getParent()->getGlobalList().push_back(threshold);
insertedThreshold = true;
diff --git a/lib/Transforms/Instrumentation/TraceValues.cpp b/lib/Transforms/Instrumentation/TraceValues.cpp
index c19848dd4b..75149ce912 100644
--- a/lib/Transforms/Instrumentation/TraceValues.cpp
+++ b/lib/Transforms/Instrumentation/TraceValues.cpp
@@ -154,7 +154,8 @@ static inline GlobalVariable *getStringRef(Module *M, const string &str) {
// Create the global variable and record it in the module
// The GV will be renamed to a unique name if needed.
- GlobalVariable *GV = new GlobalVariable(Init->getType(), true, true, Init,
+ GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
+ GlobalValue::InternalLinkage, Init,
"trstr");
M->getGlobalList().push_back(GV);
return GV;
diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp
index ca22003b40..512bd38d83 100644
--- a/lib/Transforms/Utils/CloneFunction.cpp
+++ b/lib/Transforms/Utils/CloneFunction.cpp
@@ -110,7 +110,7 @@ Function *CloneFunction(const Function *F,
ArgTypes, F->getFunctionType()->isVarArg());
// Create the new function...
- Function *NewF = new Function(FTy, F->hasInternalLinkage(), F->getName());
+ Function *NewF = new Function(FTy, F->getLinkage(), F->getName());
// Loop over the arguments, copying the names of the mapped arguments over...
Function::aiterator DestI = NewF->abegin();
diff --git a/lib/Transforms/Utils/CloneModule.cpp b/lib/Transforms/Utils/CloneModule.cpp
index 043e06d543..223e3fd88c 100644
--- a/lib/Transforms/Utils/CloneModule.cpp
+++ b/lib/Transforms/Utils/CloneModule.cpp
@@ -29,13 +29,14 @@ Module *CloneModule(const Module *M) {
// don't worry about attributes or initializers, they will come later.
//
for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
- ValueMap[I] = new GlobalVariable(I->getType()->getElementType(),
- false, false, 0, I->getName(), New);
+ ValueMap[I] = new GlobalVariable(I->getType()->getElementType(), false,
+ GlobalValue::ExternalLinkage, 0,
+ I->getName(), New);
// Loop over the functions in the module, making external functions as before
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
ValueMap[I]=new Function(cast<FunctionType>(I->getType()->getElementType()),
- false, I->getName(), New);
+ GlobalValue::ExternalLinkage, I->getName(), New);
// Now that all of the things that global variable initializer can refer to
// have been created, loop through and copy the global variable referrers
@@ -46,8 +47,7 @@ Module *CloneModule(const Module *M) {
if (I->hasInitializer())
GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(),
ValueMap)));
- if (I->hasInternalLinkage())
- GV->setInternalLinkage(true);
+ GV->setLinkage(I->getLinkage());
}
// Similarly, copy over function bodies now...
@@ -65,8 +65,7 @@ Module *CloneModule(const Module *M) {
CloneFunctionInto(F, I, ValueMap, Returns);
}
- if (I->hasInternalLinkage())
- F->setInternalLinkage(true);
+ F->setLinkage(I->getLinkage());
}
return New;
diff --git a/lib/Transforms/Utils/Linker.cpp b/lib/Transforms/Utils/Linker.cpp
index 60c6e03ae1..b5207a8542 100644
--- a/lib/Transforms/Utils/Linker.cpp
+++ b/lib/Transforms/Utils/Linker.cpp
@@ -189,42 +189,48 @@ static bool LinkGlobals(Module *Dest, const Module *Src,
//
for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){
const GlobalVariable *SGV = I;
- Value *V;
-
- // 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...
- //
- if (SGV->hasExternalLinkage() && SGV->hasName() &&
- (V = ST->lookup(SGV->getType(), SGV->getName())) &&
- cast<GlobalVariable>(V)->hasExternalLinkage()) {
- // The same named thing is a global variable, because the only two things
+ GlobalVariable *DGV = 0;
+ if (SGV->hasName()) {
+ // A same named thing is a global variable, because the only two things
// that may be in a module level symbol table are Global Vars and
// Functions, and they both have distinct, nonoverlapping, possible types.
//
- GlobalVariable *DGV = cast<GlobalVariable>(V);
+ DGV = cast_or_null<GlobalVariable>(ST->lookup(SGV->getType(),
+ SGV->getName()));
+ }
- // Check to see if the two GV's have the same Const'ness...
- if (SGV->isConstant() != DGV->isConstant())
- return Error(Err, "Global Variable Collision on '" +
- SGV->getType()->getDescription() + "':%" + SGV->getName() +
- " - Global variables differ in const'ness");
+ assert(SGV->hasInitializer() || SGV->hasExternalLinkage() &&
+ "Global must either be external or have an initializer!");
- // Okay, everything is cool, remember the mapping...
- ValueMap.insert(std::make_pair(SGV, DGV));
- } else {
+ if (!DGV || DGV->hasInternalLinkage() || SGV->hasInternalLinkage()) {
// No linking to be performed, simply create an identical version of the
// symbol over in the dest module... the initializer will be filled in
// later by LinkGlobalInits...
//
- GlobalVariable *DGV =
- new GlobalVariable(SGV->getType()->getElementType(), SGV->isConstant(),
- SGV->hasInternalLinkage(), 0, SGV->getName());
-
- // Add the new global to the dest module
- Dest->getGlobalList().push_back(DGV);
+ DGV = new GlobalVariable(SGV->getType()->getElementType(),
+ SGV->isConstant(), SGV->getLinkage(), /*init*/0,
+ SGV->getName(), Dest);
// Make sure to remember this mapping...
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() || SGV->hasLinkOnceLinkage() ||
+ SGV->hasAppendingLinkage()) {
+ // 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())
+ return Error(Err, "Global Variable Collision on '" +
+ SGV->getType()->getDescription() + "':%" + SGV->getName() +
+ " - Global variables differ in const'ness");
+ // Okay, everything is cool, remember the mapping...
+ ValueMap.insert(std::make_pair(SGV, DGV));
+ } else {
+ assert(0 && "Unknown linkage!");
}
}
return false;
@@ -245,19 +251,28 @@ static bool LinkGlobalInits(Module *Dest, const Module *Src,
if (SGV->hasInitializer()) { // Only process initialized GV's
// Figure out what the initializer looks like in the dest module...
- Constant *DInit =
+ Constant *SInit =
cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap, 0));
GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]);
- if (DGV->hasInitializer() && SGV->hasExternalLinkage() &&
- DGV->hasExternalLinkage()) {
- if (DGV->getInitializer() != DInit)
- return Error(Err, "Global Variable Collision on '" +
- SGV->getType()->getDescription() + "':%" +SGV->getName()+
- " - Global variables have different initializers");
+ 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()) {
+ // Nothing is required, mapped values will take the new global
+ // automatically.
+ } else if (DGV->hasAppendingLinkage()) {
+ assert(0 && "Appending linkage unimplemented!");
+ } else {
+ assert(0 && "Unknown linkage!");
+ }
} else {
// Copy the initializer over now...
- DGV->setInitializer(DInit);
+ DGV->setInitializer(SInit);
}
}
}
@@ -278,39 +293,42 @@ static bool LinkFunctionProtos(Module *Dest, const Module *Src,
//
for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) {
const Function *SF = I; // SrcFunction
- Value *V;
-
- // If the function has a name, and that name is already in use in the Dest
- // module, make sure that the name is a compatible function...
- //
- if (SF->hasExternalLinkage() && SF->hasName() &&
- (V = ST->lookup(SF->getType(), SF->getName())) &&
- cast<Function>(V)->hasExternalLinkage()) {
+ Function *DF = 0;
+ if (SF->hasName())
// The same named thing is a Function, because the only two things
// that may be in a module level symbol table are Global Vars and
// Functions, and they both have distinct, nonoverlapping, possible types.
//
- Function *DF = cast<Function>(V); // DestFunction
+ DF = cast_or_null<Function>(ST->lookup(SF->getType(), SF->getName()));
+ if (!DF || SF->hasInternalLinkage() || DF->hasInternalLinkage()) {
+ // Function does not already exist, simply insert an external function
+ // signature identical to SF into the dest module...
+ Function *DF = new Function(SF->getFunctionType(), SF->getLinkage(),
+ SF->getName(), Dest);
+
+ // ... and remember this mapping...
+ ValueMap.insert(std::make_pair(SF, DF));
+ } else if (SF->getLinkage() != DF->getLinkage()) {
+ return Error(Err, "Functions named '" + SF->getName() +
+ "' have different linkage specifiers!");
+ } else if (SF->getLinkage() == GlobalValue::AppendingLinkage) {
+ return Error(Err, "Functions named '" + SF->getName() +
+ "' have appending linkage!");
+ } else if (SF->getLinkage() == GlobalValue::ExternalLinkage) {
+ // If the function has a name, and that name is already in use in the Dest
+ // module, make sure that the name is a compatible function...
+ //
// Check to make sure the function is not defined in both modules...
if (!SF->isExternal() && !DF->isExternal())
return Error(Err, "Function '" +
SF->getFunctionType()->getDescription() + "':\"" +
SF->getName() + "\" - Function is already defined!");
-
+
// Otherwise, just remember this mapping...
ValueMap.insert(std::make_pair(SF, DF));
- } else {
- // Function does not already exist, simply insert an external function
- // signature identical to SF into the dest module...
- Function *DF = new Function(SF->getFunctionType(),
- SF->hasInternalLinkage(),
- SF->getName());
-
- // Add the function signature to the dest module...
- Dest->getFunctionList().push_back(DF);
-
- // ... and remember this mapping...
+ } else if (SF->getLinkage() == GlobalValue::LinkOnceLinkage) {
+ // Completely ignore the source function.
ValueMap.insert(std::make_pair(SF, DF));
}
}
@@ -391,6 +409,7 @@ static bool LinkFunctionBodies(Module *Dest, const Module *Src,
// 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!";
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-08-03 08:44:41 +0000