mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
in final cleanups. Then you had to run the whole mess again with -disable-final-cleanups. This makes bugpoint run the cleanups in a protected environment so that if they crash, bugpoint itself doesn't crash. This makes things much happier, implements a FIXME, and gets rid of YABPO (yet another bugpoint option). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9743 91177308-0d34-0410-b5e6-96231b3b80d8
411 lines
16 KiB
C++
411 lines
16 KiB
C++
//===- CodeGeneratorBug.cpp - Debug code generation bugs ------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements program code generation debugging support.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "BugDriver.h"
|
|
#include "ListReducer.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/GlobalValue.h"
|
|
#include "llvm/iMemory.h"
|
|
#include "llvm/iTerminators.h"
|
|
#include "llvm/iOther.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/Analysis/Verifier.h"
|
|
#include "llvm/Support/Mangler.h"
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
|
#include "llvm/Transforms/Utils/Linker.h"
|
|
#include "Support/CommandLine.h"
|
|
#include "Support/Debug.h"
|
|
#include "Support/StringExtras.h"
|
|
#include "Support/FileUtilities.h"
|
|
#include <algorithm>
|
|
#include <set>
|
|
|
|
extern cl::list<std::string> InputArgv;
|
|
|
|
class ReduceMisCodegenFunctions : public ListReducer<Function*> {
|
|
BugDriver &BD;
|
|
public:
|
|
ReduceMisCodegenFunctions(BugDriver &bd) : BD(bd) {}
|
|
|
|
virtual TestResult doTest(std::vector<Function*> &Prefix,
|
|
std::vector<Function*> &Suffix) {
|
|
if (!Prefix.empty() && TestFuncs(Prefix))
|
|
return KeepPrefix;
|
|
if (!Suffix.empty() && TestFuncs(Suffix))
|
|
return KeepSuffix;
|
|
return NoFailure;
|
|
}
|
|
|
|
bool TestFuncs(const std::vector<Function*> &CodegenTest,
|
|
bool KeepFiles = false);
|
|
};
|
|
|
|
|
|
bool ReduceMisCodegenFunctions::TestFuncs(const std::vector<Function*> &Funcs,
|
|
bool KeepFiles) {
|
|
std::cout << "Testing functions: ";
|
|
BD.PrintFunctionList(Funcs);
|
|
std::cout << "\t";
|
|
|
|
// Clone the module for the two halves of the program we want.
|
|
Module *SafeModule = CloneModule(BD.Program);
|
|
|
|
// Make sure functions & globals are all external so that linkage
|
|
// between the two modules will work.
|
|
for (Module::iterator I = SafeModule->begin(), E = SafeModule->end();I!=E;++I)
|
|
I->setLinkage(GlobalValue::ExternalLinkage);
|
|
for (Module::giterator I=SafeModule->gbegin(),E = SafeModule->gend();I!=E;++I)
|
|
I->setLinkage(GlobalValue::ExternalLinkage);
|
|
|
|
Module *TestModule = CloneModule(SafeModule);
|
|
|
|
// Make sure global initializers exist only in the safe module (CBE->.so)
|
|
for (Module::giterator I=TestModule->gbegin(),E = TestModule->gend();I!=E;++I)
|
|
I->setInitializer(0); // Delete the initializer to make it external
|
|
|
|
// Remove the Test functions from the Safe module
|
|
for (unsigned i = 0, e = Funcs.size(); i != e; ++i) {
|
|
Function *TNOF = SafeModule->getFunction(Funcs[i]->getName(),
|
|
Funcs[i]->getFunctionType());
|
|
DEBUG(std::cerr << "Removing function " << Funcs[i]->getName() << "\n");
|
|
assert(TNOF && "Function doesn't exist in module!");
|
|
DeleteFunctionBody(TNOF); // Function is now external in this module!
|
|
}
|
|
|
|
// Remove the Safe functions from the Test module
|
|
for (Module::iterator I=TestModule->begin(),E=TestModule->end(); I!=E; ++I) {
|
|
bool funcFound = false;
|
|
for (std::vector<Function*>::const_iterator F=Funcs.begin(),Fe=Funcs.end();
|
|
F != Fe; ++F)
|
|
if (I->getName() == (*F)->getName()) funcFound = true;
|
|
|
|
if (!funcFound && !(BD.isExecutingJIT() && I->getName() == "main"))
|
|
DeleteFunctionBody(I);
|
|
}
|
|
|
|
// This is only applicable if we are debugging the JIT:
|
|
// Find all external functions in the Safe modules that are actually used
|
|
// (called or taken address of), and make them call the JIT wrapper instead
|
|
if (BD.isExecutingJIT()) {
|
|
// Must delete `main' from Safe module if it has it
|
|
Function *safeMain = SafeModule->getNamedFunction("main");
|
|
assert(safeMain && "`main' function not found in safe module!");
|
|
DeleteFunctionBody(safeMain);
|
|
|
|
// Add an external function "getPointerToNamedFunction" that JIT provides
|
|
// Prototype: void *getPointerToNamedFunction(const char* Name)
|
|
std::vector<const Type*> Params;
|
|
Params.push_back(PointerType::get(Type::SByteTy)); // std::string&
|
|
FunctionType *resolverTy = FunctionType::get(PointerType::get(Type::VoidTy),
|
|
Params, false /* isVarArg */);
|
|
Function *resolverFunc = new Function(resolverTy,
|
|
GlobalValue::ExternalLinkage,
|
|
"getPointerToNamedFunction",
|
|
SafeModule);
|
|
|
|
// Use the function we just added to get addresses of functions we need
|
|
// Iterate over the global declarations in the Safe module
|
|
for (Module::iterator F=SafeModule->begin(),E=SafeModule->end(); F!=E; ++F){
|
|
if (F->isExternal() && !F->use_empty() && &*F != resolverFunc &&
|
|
F->getIntrinsicID() == 0 /* ignore intrinsics */ &&
|
|
// Don't forward functions which are external in the test module too.
|
|
!TestModule->getNamedFunction(F->getName())->isExternal()) {
|
|
// If it has a non-zero use list,
|
|
// 1. Add a string constant with its name to the global file
|
|
// The correct type is `const [ NUM x sbyte ]' where NUM is length of
|
|
// function name + 1
|
|
const std::string &Name = F->getName();
|
|
GlobalVariable *funcName =
|
|
new GlobalVariable(ArrayType::get(Type::SByteTy, Name.length()+1),
|
|
true /* isConstant */,
|
|
GlobalValue::InternalLinkage,
|
|
ConstantArray::get(Name),
|
|
Name + "_name",
|
|
SafeModule);
|
|
|
|
// 2. Use `GetElementPtr *funcName, 0, 0' to convert the string to an
|
|
// sbyte* so it matches the signature of the resolver function.
|
|
std::vector<Constant*> GEPargs(2, Constant::getNullValue(Type::LongTy));
|
|
|
|
// 3. Replace all uses of `func' with calls to resolver by:
|
|
// (a) Iterating through the list of uses of this function
|
|
// (b) Insert a cast instruction in front of each use
|
|
// (c) Replace use of old call with new call
|
|
|
|
// GetElementPtr *funcName, ulong 0, ulong 0
|
|
Value *GEP =
|
|
ConstantExpr::getGetElementPtr(ConstantPointerRef::get(funcName),
|
|
GEPargs);
|
|
std::vector<Value*> ResolverArgs;
|
|
ResolverArgs.push_back(GEP);
|
|
|
|
// Insert code at the beginning of the function
|
|
while (!F->use_empty())
|
|
if (Instruction *Inst = dyn_cast<Instruction>(F->use_back())) {
|
|
// call resolver(GetElementPtr...)
|
|
CallInst *resolve = new CallInst(resolverFunc, ResolverArgs,
|
|
"resolver", Inst);
|
|
// cast the result from the resolver to correctly-typed function
|
|
CastInst *castResolver =
|
|
new CastInst(resolve, PointerType::get(F->getFunctionType()),
|
|
"resolverCast", Inst);
|
|
// actually use the resolved function
|
|
Inst->replaceUsesOfWith(F, castResolver);
|
|
} else {
|
|
// FIXME: need to take care of cases where a function is used that
|
|
// is not an instruction, e.g. global variable initializer...
|
|
std::cerr <<
|
|
"UNSUPPORTED: External function used as global initializer!\n";
|
|
abort();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (verifyModule(*SafeModule) || verifyModule(*TestModule)) {
|
|
std::cerr << "Bugpoint has a bug, an corrupted a module!!\n";
|
|
abort();
|
|
}
|
|
|
|
DEBUG(std::cerr << "Safe module:\n";
|
|
typedef Module::iterator MI;
|
|
typedef Module::giterator MGI;
|
|
|
|
for (MI I = SafeModule->begin(), E = SafeModule->end(); I != E; ++I)
|
|
if (!I->isExternal()) std::cerr << "\t" << I->getName() << "\n";
|
|
for (MGI I = SafeModule->gbegin(), E = SafeModule->gend(); I!=E; ++I)
|
|
if (!I->isExternal()) std::cerr << "\t" << I->getName() << "\n";
|
|
|
|
std::cerr << "Test module:\n";
|
|
for (MI I = TestModule->begin(), E = TestModule->end(); I != E; ++I)
|
|
if (!I->isExternal()) std::cerr << "\t" << I->getName() << "\n";
|
|
for (MGI I=TestModule->gbegin(),E = TestModule->gend(); I!= E; ++I)
|
|
if (!I->isExternal()) std::cerr << "\t" << I->getName() << "\n";
|
|
);
|
|
|
|
// Write out the bytecode to be sent to CBE
|
|
std::string SafeModuleBC = getUniqueFilename("bugpoint.safe.bc");
|
|
|
|
if (BD.writeProgramToFile(SafeModuleBC, SafeModule)) {
|
|
std::cerr << "Error writing bytecode to `" << SafeModuleBC << "'\nExiting.";
|
|
exit(1);
|
|
}
|
|
|
|
// Remove all functions from the Test module EXCEPT for the ones specified in
|
|
// Funcs. We know which ones these are because they are non-external in
|
|
// ToOptimize, but external in ToNotOptimize.
|
|
//
|
|
for (Module::iterator I = TestModule->begin(), E = TestModule->end();I!=E;++I)
|
|
if (!I->isExternal()) {
|
|
Function *TNOF = SafeModule->getFunction(I->getName(),
|
|
I->getFunctionType());
|
|
assert(TNOF && "Function doesn't exist in ToNotOptimize module??");
|
|
if (!TNOF->isExternal())
|
|
DeleteFunctionBody(I);
|
|
}
|
|
|
|
std::string TestModuleBC = getUniqueFilename("bugpoint.test.bc");
|
|
if (verifyModule(*TestModule)) {
|
|
std::cerr << "Bytecode file corrupted!\n";
|
|
exit(1);
|
|
}
|
|
|
|
// Clean up the modules, removing extra cruft that we don't need anymore...
|
|
SafeModule = BD.performFinalCleanups(SafeModule);
|
|
TestModule = BD.performFinalCleanups(TestModule);
|
|
|
|
if (BD.writeProgramToFile(TestModuleBC, TestModule)) {
|
|
std::cerr << "Error writing bytecode to `" << SafeModuleBC << "'\nExiting.";
|
|
exit(1);
|
|
}
|
|
|
|
// Make a shared library
|
|
std::string SharedObject = BD.compileSharedObject(SafeModuleBC);
|
|
|
|
delete SafeModule;
|
|
delete TestModule;
|
|
|
|
// Run the code generator on the `Test' code, loading the shared library.
|
|
// The function returns whether or not the new output differs from reference.
|
|
int Result = BD.diffProgram(TestModuleBC, SharedObject, false);
|
|
|
|
if (Result)
|
|
std::cerr << ": still failing!\n";
|
|
else
|
|
std::cerr << ": didn't fail.\n";
|
|
|
|
if (KeepFiles) {
|
|
std::cout << "You can reproduce the problem with the command line: \n";
|
|
if (BD.isExecutingJIT()) {
|
|
std::cout << " lli -load " << SharedObject << " " << TestModuleBC;
|
|
} else {
|
|
std::cout << " llc " << TestModuleBC << " -o " << TestModuleBC << ".s\n";
|
|
std::cout << " gcc " << SharedObject << " " << TestModuleBC
|
|
<< ".s -o " << TestModuleBC << ".exe -Wl,-R.\n";
|
|
std::cout << " " << TestModuleBC << ".exe";
|
|
}
|
|
for (unsigned i=0, e = InputArgv.size(); i != e; ++i)
|
|
std::cout << " " << InputArgv[i];
|
|
std::cout << "\n";
|
|
std::cout << "The shared object was created with:\n llvm-dis -c "
|
|
<< SafeModuleBC << " -o temporary.c\n"
|
|
<< " gcc -xc temporary.c -O2 -o " << SharedObject
|
|
#if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
|
|
<< " -G" // Compile a shared library, `-G' for Sparc
|
|
#else
|
|
<< " -shared" // `-shared' for Linux/X86, maybe others
|
|
#endif
|
|
<< " -fno-strict-aliasing\n";
|
|
} else {
|
|
removeFile(TestModuleBC);
|
|
removeFile(SafeModuleBC);
|
|
removeFile(SharedObject);
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
namespace {
|
|
struct Disambiguator {
|
|
std::set<std::string> SymbolNames;
|
|
std::set<GlobalValue*> Symbols;
|
|
uint64_t uniqueCounter;
|
|
bool externalOnly;
|
|
public:
|
|
Disambiguator() : uniqueCounter(0), externalOnly(true) {}
|
|
void setExternalOnly(bool value) { externalOnly = value; }
|
|
void add(GlobalValue &V) {
|
|
// If we're only processing externals and this isn't external, bail
|
|
if (externalOnly && !V.isExternal()) return;
|
|
// If we're already processed this symbol, don't add it again
|
|
if (Symbols.count(&V) != 0) return;
|
|
// Ignore intrinsic functions
|
|
if (Function *F = dyn_cast<Function>(&V))
|
|
if (F->getIntrinsicID() != 0)
|
|
return;
|
|
|
|
std::string SymName = V.getName();
|
|
|
|
// Use the Mangler facility to make symbol names that will be valid in
|
|
// shared objects.
|
|
SymName = Mangler::makeNameProper(SymName);
|
|
V.setName(SymName);
|
|
|
|
if (SymbolNames.count(SymName) == 0) {
|
|
DEBUG(std::cerr << "Disambiguator: adding " << SymName
|
|
<< ", no conflicts.\n");
|
|
SymbolNames.insert(SymName);
|
|
} else {
|
|
// Mangle name before adding
|
|
std::string newName;
|
|
do {
|
|
newName = SymName + "_" + utostr(uniqueCounter);
|
|
if (SymbolNames.count(newName) == 0) break;
|
|
else ++uniqueCounter;
|
|
} while (1);
|
|
//while (SymbolNames.count(V->getName()+utostr(uniqueCounter++))==0);
|
|
DEBUG(std::cerr << "Disambiguator: conflict: " << SymName
|
|
<< ", adding: " << newName << "\n");
|
|
V.setName(newName);
|
|
SymbolNames.insert(newName);
|
|
}
|
|
Symbols.insert(&V);
|
|
}
|
|
};
|
|
}
|
|
|
|
void DisambiguateGlobalSymbols(Module *M) {
|
|
// First, try not to cause collisions by minimizing chances of renaming an
|
|
// already-external symbol, so take in external globals and functions as-is.
|
|
Disambiguator D;
|
|
DEBUG(std::cerr << "Disambiguating globals (external-only)\n");
|
|
for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) D.add(*I);
|
|
DEBUG(std::cerr << "Disambiguating functions (external-only)\n");
|
|
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) D.add(*I);
|
|
|
|
// Now just rename functions and globals as necessary, keeping what's already
|
|
// in the set unique.
|
|
D.setExternalOnly(false);
|
|
DEBUG(std::cerr << "Disambiguating globals\n");
|
|
for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) D.add(*I);
|
|
DEBUG(std::cerr << "Disambiguating globals\n");
|
|
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) D.add(*I);
|
|
}
|
|
|
|
|
|
bool BugDriver::debugCodeGenerator() {
|
|
// See if we can pin down which functions are being miscompiled...
|
|
//First, build a list of all of the non-external functions in the program.
|
|
std::vector<Function*> MisCodegenFunctions;
|
|
for (Module::iterator I = Program->begin(), E = Program->end(); I != E; ++I)
|
|
if (!I->isExternal())
|
|
MisCodegenFunctions.push_back(I);
|
|
|
|
// If we are executing the JIT, we *must* keep the function `main' in the
|
|
// module that is passed in, and not the shared library. However, we still
|
|
// want to be able to debug the `main' function alone. Thus, we create a new
|
|
// function `main' which just calls the old one.
|
|
if (isExecutingJIT()) {
|
|
// Get the `main' function
|
|
Function *oldMain = Program->getNamedFunction("main");
|
|
assert(oldMain && "`main' function not found in program!");
|
|
// Rename it
|
|
oldMain->setName("llvm_old_main");
|
|
// Create a NEW `main' function with same type
|
|
Function *newMain = new Function(oldMain->getFunctionType(),
|
|
GlobalValue::ExternalLinkage,
|
|
"main", Program);
|
|
// Call the old main function and return its result
|
|
BasicBlock *BB = new BasicBlock("entry", newMain);
|
|
std::vector<Value*> args;
|
|
for (Function::aiterator I = newMain->abegin(), E = newMain->aend(),
|
|
OI = oldMain->abegin(); I != E; ++I, ++OI) {
|
|
I->setName(OI->getName()); // Copy argument names from oldMain
|
|
args.push_back(I);
|
|
}
|
|
CallInst *call = new CallInst(oldMain, args);
|
|
BB->getInstList().push_back(call);
|
|
|
|
// if the type of old function wasn't void, return value of call
|
|
ReturnInst *ret;
|
|
if (oldMain->getReturnType() != Type::VoidTy) {
|
|
ret = new ReturnInst(call);
|
|
} else {
|
|
ret = new ReturnInst();
|
|
}
|
|
|
|
// Add the return instruction to the BasicBlock
|
|
BB->getInstList().push_back(ret);
|
|
}
|
|
|
|
DisambiguateGlobalSymbols(Program);
|
|
|
|
// Do the reduction...
|
|
if (!ReduceMisCodegenFunctions(*this).reduceList(MisCodegenFunctions)) {
|
|
std::cerr << "*** Execution matches reference output! "
|
|
<< "bugpoint can't help you with your problem!\n";
|
|
return false;
|
|
}
|
|
|
|
std::cout << "\n*** The following functions are being miscompiled: ";
|
|
PrintFunctionList(MisCodegenFunctions);
|
|
std::cout << "\n";
|
|
|
|
// Output a bunch of bytecode files for the user...
|
|
ReduceMisCodegenFunctions(*this).TestFuncs(MisCodegenFunctions, true);
|
|
|
|
return false;
|
|
}
|