mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 02:30:00 +00:00
The fix is simply to use CurI instead of I when handling aliases to avoid accessing a invalid iterator. original message: Convert linkonce* to weak* instead of strong. Also refactor the logic into a helper function. This is an important improve on mingw where the linker complains about mixed weak and strong symbols. Converting to weak ensures that the symbol is not dropped, but keeps in a comdat, making the linker happy. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@195477 91177308-0d34-0410-b5e6-96231b3b80d8
156 lines
4.7 KiB
C++
156 lines
4.7 KiB
C++
//===-- ExtractGV.cpp - Global Value extraction pass ----------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This pass extracts global values
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/IPO.h"
|
|
#include "llvm/ADT/SetVector.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/Instructions.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Pass.h"
|
|
#include <algorithm>
|
|
using namespace llvm;
|
|
|
|
/// Make sure GV is visible from both modules. Delete is true if it is
|
|
/// being deleted from this module.
|
|
/// This also makes sure GV cannot be dropped so that references from
|
|
/// the split module remain valid.
|
|
static void makeVisible(GlobalValue &GV, bool Delete) {
|
|
bool Local = GV.hasLocalLinkage();
|
|
if (Local)
|
|
GV.setVisibility(GlobalValue::HiddenVisibility);
|
|
|
|
if (Local || Delete) {
|
|
GV.setLinkage(GlobalValue::ExternalLinkage);
|
|
return;
|
|
}
|
|
|
|
if (!GV.hasLinkOnceLinkage()) {
|
|
assert(!GV.isDiscardableIfUnused());
|
|
return;
|
|
}
|
|
|
|
// Map linkonce* to weak* so that llvm doesn't drop this GV.
|
|
switch(GV.getLinkage()) {
|
|
default:
|
|
llvm_unreachable("Unexpected linkage");
|
|
case GlobalValue::LinkOnceAnyLinkage:
|
|
GV.setLinkage(GlobalValue::WeakAnyLinkage);
|
|
return;
|
|
case GlobalValue::LinkOnceODRLinkage:
|
|
GV.setLinkage(GlobalValue::WeakODRLinkage);
|
|
return;
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
/// @brief A pass to extract specific functions and their dependencies.
|
|
class GVExtractorPass : public ModulePass {
|
|
SetVector<GlobalValue *> Named;
|
|
bool deleteStuff;
|
|
public:
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
/// FunctionExtractorPass - If deleteFn is true, this pass deletes as the
|
|
/// specified function. Otherwise, it deletes as much of the module as
|
|
/// possible, except for the function specified.
|
|
///
|
|
explicit GVExtractorPass(std::vector<GlobalValue*>& GVs, bool deleteS = true)
|
|
: ModulePass(ID), Named(GVs.begin(), GVs.end()), deleteStuff(deleteS) {}
|
|
|
|
bool runOnModule(Module &M) {
|
|
// Visit the global inline asm.
|
|
if (!deleteStuff)
|
|
M.setModuleInlineAsm("");
|
|
|
|
// For simplicity, just give all GlobalValues ExternalLinkage. A trickier
|
|
// implementation could figure out which GlobalValues are actually
|
|
// referenced by the Named set, and which GlobalValues in the rest of
|
|
// the module are referenced by the NamedSet, and get away with leaving
|
|
// more internal and private things internal and private. But for now,
|
|
// be conservative and simple.
|
|
|
|
// Visit the GlobalVariables.
|
|
for (Module::global_iterator I = M.global_begin(), E = M.global_end();
|
|
I != E; ++I) {
|
|
bool Delete =
|
|
deleteStuff == (bool)Named.count(I) && !I->isDeclaration();
|
|
if (!Delete) {
|
|
if (I->hasAvailableExternallyLinkage())
|
|
continue;
|
|
if (I->getName() == "llvm.global_ctors")
|
|
continue;
|
|
}
|
|
|
|
makeVisible(*I, Delete);
|
|
|
|
if (Delete)
|
|
I->setInitializer(0);
|
|
}
|
|
|
|
// Visit the Functions.
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
|
|
bool Delete =
|
|
deleteStuff == (bool)Named.count(I) && !I->isDeclaration();
|
|
if (!Delete) {
|
|
if (I->hasAvailableExternallyLinkage())
|
|
continue;
|
|
}
|
|
|
|
makeVisible(*I, Delete);
|
|
|
|
if (Delete)
|
|
I->deleteBody();
|
|
}
|
|
|
|
// Visit the Aliases.
|
|
for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
|
|
I != E;) {
|
|
Module::alias_iterator CurI = I;
|
|
++I;
|
|
|
|
bool Delete = deleteStuff == (bool)Named.count(CurI);
|
|
makeVisible(*CurI, Delete);
|
|
|
|
if (Delete) {
|
|
Type *Ty = CurI->getType()->getElementType();
|
|
|
|
CurI->removeFromParent();
|
|
llvm::Value *Declaration;
|
|
if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
|
|
Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage,
|
|
CurI->getName(), &M);
|
|
|
|
} else {
|
|
Declaration =
|
|
new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage,
|
|
0, CurI->getName());
|
|
|
|
}
|
|
CurI->replaceAllUsesWith(Declaration);
|
|
delete CurI;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
char GVExtractorPass::ID = 0;
|
|
}
|
|
|
|
ModulePass *llvm::createGVExtractionPass(std::vector<GlobalValue*>& GVs,
|
|
bool deleteFn) {
|
|
return new GVExtractorPass(GVs, deleteFn);
|
|
}
|