bool MipsOs16::runOnModule(Module &M) {
bool usingMask = Mips32FunctionMask.length() > 0;
bool doneUsingMask = false; // this will make it stop repeating
DEBUG(dbgs() << "Run on Module MipsOs16 \n" << Mips32FunctionMask << "\n");
if (usingMask)
DEBUG(dbgs() << "using mask \n" << Mips32FunctionMask << "\n");
unsigned int functionIndex = 0;
bool modified = false;
for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
if (F->isDeclaration()) continue;
DEBUG(dbgs() << "Working on " << F->getName() << "\n");
if (usingMask) {
if (!doneUsingMask) {
if (functionIndex == Mips32FunctionMask.length())
functionIndex = 0;
switch (Mips32FunctionMask[functionIndex]) {
case '1':
DEBUG(dbgs() << "mask forced mips32: " << F->getName() << "\n");
F->addFnAttr("nomips16");
break;
case '.':
doneUsingMask = true;
break;
default:
break;
}
functionIndex++;
}
}
else {
if (needsFP(*F)) {
DEBUG(dbgs() << "os16 forced mips32: " << F->getName() << "\n");
F->addFnAttr("nomips16");
}
else {
DEBUG(dbgs() << "os16 forced mips16: " << F->getName() << "\n");
F->addFnAttr("mips16");
}
}
}
return modified;
}
CFG *Add_target(CFG *cfg,int target,string checkstr){
check = trim(checkstr);
CFG *cfg1=new CFG();
cfg1=cfg;
int len=check.length();
char x[len];
int numCheck=1;//count of equations
for(int i=0;i<len;i++){
x[i]=check.at(i);
if(x[i]=='&')
numCheck++;
}
State *old_target=cfg->searchState(target);
string funcName = old_target->funcName;
State *new_target=new State(false,-1,"q1",funcName);
new_target->transList.clear();
new_target->consList.clear();
Transition *temp=new Transition(-2,"p1");
temp->fromState=old_target;
temp->fromName=cfg->getNodeName(target);
temp->level=temp->fromState->level+1;
temp->toState=new_target;
new_target->level = temp->level;
temp->toName="q1";
temp->guardList.clear();
int a[numCheck+1];
int k=0;
a[k++]=0;
for(int i=0;i<len;i++)
if(x[i]=='&')
a[k++]=i+1;
a[numCheck]=len+1;
string b[numCheck];
for(int i=0;i<numCheck;i++)
b[i]=check.substr(a[i],a[i+1]-a[i]-1);
Constraint cTemp;
for(int i=0;i<numCheck;i++){
cTemp = StringToConstraints(b[i], funcName);
temp->guardList.push_back(cTemp);
}
cfg1->stateList.push_back(*new_target);
cfg1->transitionList.push_back(*temp);
return cfg1;
}
static std::string getProgram(const char *name, const cl::opt<std::string> &opt, const char *envVar = 0)
{
std::string path;
const char *prog = NULL;
if (opt.getNumOccurrences() > 0 && opt.length() > 0 && (prog = opt.c_str()))
path = findProgramByName(prog);
if (path.empty() && envVar && (prog = getenv(envVar)))
path = findProgramByName(prog);
if (path.empty())
path = findProgramByName(name);
if (path.empty()) {
error(Loc(), "failed to locate %s", name);
fatal();
}
return path;
}
sys::Path getGcc() {
const char *cc = NULL;
if (gcc.getNumOccurrences() > 0 && gcc.length() > 0)
cc = gcc.c_str();
if (!cc)
cc = getenv("CC");
if (!cc)
cc = "gcc";
sys::Path path = sys::Program::FindProgramByName(cc);
if (path.empty() && !cc) {
if (cc) {
path.set(cc);
} else {
error("failed to locate gcc");
fatal();
}
}
return path;
}
sys::Path getProgram(const char *name, const cl::opt<std::string> &opt, const char *envVar = 0)
{
const char *prog = NULL;
if (opt.getNumOccurrences() > 0 && opt.length() > 0)
prog = gcc.c_str();
if (!prog && envVar)
prog = getenv(envVar);
if (!prog)
prog = name;
sys::Path path = sys::Program::FindProgramByName(prog);
if (path.empty() && !prog) {
if (prog) {
path.set(prog);
} else {
error("failed to locate %s", name);
fatal();
}
}
return path;
}
int main(int argc, char *argv[])
{
cl::SetVersionPrinter(&versionPrinter);
cl::ParseCommandLineOptions(argc, argv, "llvm2kittel\n");
if (boundedIntegers && divisionConstraintType == Exact) {
std::cerr << "Cannot use \"-division-constraint=exact\" in combination with \"-bounded-integers\"" << std::endl;
return 333;
}
if (!boundedIntegers && unsignedEncoding) {
std::cerr << "Cannot use \"-unsigned-encoding\" without \"-bounded-integers\"" << std::endl;
return 333;
}
if (!boundedIntegers && bitwiseConditions) {
std::cerr << "Cannot use \"-bitwise-conditions\" without \"-bounded-integers\"" << std::endl;
return 333;
}
if (numInlines != 0 && eagerInline) {
std::cerr << "Cannot use \"-inline\" in combination with \"-eager-inline\"" << std::endl;
return 333;
}
#if LLVM_VERSION < VERSION(3, 5)
llvm::OwningPtr<llvm::MemoryBuffer> owningBuffer;
llvm::MemoryBuffer::getFileOrSTDIN(filename, owningBuffer);
llvm::MemoryBuffer *buffer = owningBuffer.get();
#else
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> owningBuffer = llvm::MemoryBuffer::getFileOrSTDIN(filename);
llvm::MemoryBuffer *buffer = NULL;
if (!owningBuffer.getError()) {
buffer = owningBuffer->get();
}
#endif
if (buffer == NULL) {
std::cerr << "LLVM bitcode file \"" << filename << "\" does not exist or cannot be read." << std::endl;
return 1;
}
llvm::LLVMContext context;
std::string errMsg;
#if LLVM_VERSION < VERSION(3, 5)
llvm::Module *module = llvm::ParseBitcodeFile(buffer, context, &errMsg);
#elif LLVM_VERSION == VERSION(3, 5)
llvm::Module *module = NULL;
llvm::ErrorOr<llvm::Module*> moduleOrError = llvm::parseBitcodeFile(buffer, context);
std::error_code ec = moduleOrError.getError();
if (ec) {
errMsg = ec.message();
} else {
module = moduleOrError.get();
}
#elif LLVM_VERSION == VERSION(3, 6)
llvm::Module *module = NULL;
llvm::ErrorOr<llvm::Module*> moduleOrError = llvm::parseBitcodeFile(buffer->getMemBufferRef(), context);
std::error_code ec = moduleOrError.getError();
if (ec) {
errMsg = ec.message();
} else {
module = moduleOrError.get();
}
#else
llvm::Module *module = NULL;
llvm::ErrorOr<std::unique_ptr<llvm::Module>> moduleOrError = llvm::parseBitcodeFile(buffer->getMemBufferRef(), context);
std::error_code ec = moduleOrError.getError();
if (ec) {
errMsg = ec.message();
} else {
module = moduleOrError->get();
}
#endif
// check if the file is a proper bitcode file and contains a module
if (module == NULL) {
std::cerr << "LLVM bitcode file doesn't contain a valid module." << std::endl;
return 2;
}
llvm::Function *function = NULL;
llvm::Function *firstFunction = NULL;
unsigned int numFunctions = 0;
std::list<std::string> functionNames;
for (llvm::Module::iterator i = module->begin(), e = module->end(); i != e; ++i) {
if (i->getName() == functionname) {
function = &*i;
break;
} else if (functionname.empty() && i->getName() == "main") {
function = &*i;
break;
} else if (!i->isDeclaration()) {
++numFunctions;
functionNames.push_back(i->getName());
if (firstFunction == NULL) {
firstFunction = &*i;
}
}
}
if (function == NULL) {
if (numFunctions == 0) {
std::cerr << "Module does not contain any function." << std::endl;
return 3;
}
if (functionname.empty()) {
if (numFunctions == 1) {
function = firstFunction;
} else {
std::cerr << "LLVM module contains more than one function:" << std::endl;
for (std::list<std::string>::iterator i = functionNames.begin(), e = functionNames.end(); i != e; ++i) {
std::cerr << " " << *i << std::endl;
}
std::cerr << "Please specify which function should be used." << std::endl;
return 4;
}
} else {
std::cerr << "Specified function not found." << std::endl;
std::cerr << "Candidates are:" << std::endl;
for (std::list<std::string>::iterator i = functionNames.begin(), e = functionNames.end(); i != e; ++i) {
std::cerr << " " << *i << std::endl;
}
return 5;
}
}
// check for cyclic call hierarchies
HierarchyBuilder checkHierarchy;
checkHierarchy.computeHierarchy(module);
if (eagerInline && checkHierarchy.isCyclic()) {
std::cerr << "Cannot use \"-eager-inline\" with a cyclic call hierarchy!" << std::endl;
return 7;
}
// transform!
NondefFactory ndf(module);
transformModule(module, function, ndf);
// name them!
InstNamer namer;
namer.visit(module);
// check them!
const llvm::Type *boolType = llvm::Type::getInt1Ty(context);
const llvm::Type *floatType = llvm::Type::getFloatTy(context);
const llvm::Type *doubleType = llvm::Type::getDoubleTy(context);
InstChecker checker(boolType, floatType, doubleType);
checker.visit(module);
// print it!
if (debug) {
#if LLVM_VERSION < VERSION(3, 5)
llvm::PassManager printPass;
printPass.add(llvm::createPrintModulePass(&llvm::outs()));
printPass.run(*module);
#else
llvm::outs() << *module << '\n';
#endif
}
if (dumpLL) {
std::string outFile = filename.substr(0, filename.length() - 3) + ".ll";
#if LLVM_VERSION < VERSION(3, 5)
std::string errorInfo;
llvm::raw_fd_ostream stream(outFile.data(), errorInfo);
if (errorInfo.empty()) {
llvm::PassManager dumpPass;
dumpPass.add(llvm::createPrintModulePass(&stream));
dumpPass.run(*module);
stream.close();
}
#elif LLVM_VERSION == VERSION(3, 5)
std::string errorInfo;
llvm::raw_fd_ostream stream(outFile.data(), errorInfo, llvm::sys::fs::F_Text);
if (errorInfo.empty()) {
stream << *module << '\n';
stream.close();
}
#else
std::error_code errorCode;
llvm::raw_fd_ostream stream(outFile.data(), errorCode, llvm::sys::fs::F_Text);
if (!errorCode) {
stream << *module << '\n';
stream.close();
}
#endif
}
// check for junk
std::list<llvm::Instruction*> unsuitable = checker.getUnsuitableInsts();
if (!unsuitable.empty()) {
std::cerr << "Unsuitable instructions detected:" << std::endl;
for (std::list<llvm::Instruction*>::iterator i = unsuitable.begin(), e = unsuitable.end(); i != e; ++i) {
(*i)->dump();
}
return 6;
}
// compute recursion hierarchy
HierarchyBuilder hierarchy;
hierarchy.computeHierarchy(module);
std::list<std::list<llvm::Function*> > sccs = hierarchy.getSccs();
std::map<llvm::Function*, std::list<llvm::Function*> > funToScc;
for (std::list<std::list<llvm::Function*> >::iterator i = sccs.begin(), e = sccs.end(); i != e; ++i) {
std::list<llvm::Function*> scc = *i;
for (std::list<llvm::Function*>::iterator si = scc.begin(), se = scc.end(); si != se; ++si) {
funToScc.insert(std::make_pair(*si, scc));
}
}
std::list<llvm::Function*> dependsOnList = hierarchy.getTransitivelyCalledFunctions(function);
std::set<llvm::Function*> dependsOn;
dependsOn.insert(dependsOnList.begin(), dependsOnList.end());
dependsOn.insert(function);
std::list<std::list<llvm::Function*> > dependsOnSccs;
for (std::list<std::list<llvm::Function*> >::iterator i = sccs.begin(), e = sccs.end(); i != e; ++i) {
std::list<llvm::Function*> scc = *i;
for (std::list<llvm::Function*>::iterator fi = scc.begin(), fe = scc.end(); fi != fe; ++fi) {
llvm::Function *f = *fi;
if (dependsOn.find(f) != dependsOn.end()) {
dependsOnSccs.push_back(scc);
break;
}
}
}
// compute may/must info, propagated conditions, and compute loop exiting blocks for all functions
std::map<llvm::Function*, MayMustMap> mmMap;
std::map<llvm::Function*, std::set<llvm::GlobalVariable*> > funcMayZapDirect;
std::map<llvm::Function*, TrueFalseMap> tfMap;
std::map<llvm::Function*, std::set<llvm::BasicBlock*> > lebMap;
std::map<llvm::Function*, ConditionMap> elcMap;
for (std::set<llvm::Function*>::iterator df = dependsOn.begin(), dfe = dependsOn.end(); df != dfe; ++df) {
llvm::Function *func = *df;
std::pair<MayMustMap, std::set<llvm::GlobalVariable*> > tmp = getMayMustMap(func);
mmMap.insert(std::make_pair(func, tmp.first));
funcMayZapDirect.insert(std::make_pair(func, tmp.second));
std::set<llvm::BasicBlock*> lcbs;
if (onlyLoopConditions) {
lcbs = getLoopConditionBlocks(func);
lebMap.insert(std::make_pair(func, lcbs));
}
if (propagateConditions) {
tfMap.insert(std::make_pair(func, getConditionPropagationMap(func, lcbs)));
}
if (explicitizeLoopConditions) {
elcMap.insert(std::make_pair(func, getExplicitizedLoopConditionMap(func)));
}
}
// transitively close funcMayZapDirect
std::map<llvm::Function*, std::set<llvm::GlobalVariable*> > funcMayZap;
for (std::set<llvm::Function*>::iterator df = dependsOn.begin(), dfe = dependsOn.end(); df != dfe; ++df) {
llvm::Function *func = *df;
std::set<llvm::GlobalVariable*> funcTransZap;
std::list<llvm::Function*> funcDependsOnList = hierarchy.getTransitivelyCalledFunctions(func);
std::set<llvm::Function*> funcDependsOn;
funcDependsOn.insert(funcDependsOnList.begin(), funcDependsOnList.end());
funcDependsOn.insert(func);
for (std::set<llvm::Function*>::iterator depfi = funcDependsOn.begin(), depfe = funcDependsOn.end(); depfi != depfe; ++depfi) {
llvm::Function *depf = *depfi;
std::map<llvm::Function*, std::set<llvm::GlobalVariable*> >::iterator depfZap = funcMayZapDirect.find(depf);
if (depfZap == funcMayZapDirect.end()) {
std::cerr << "Could not find alias information (" << __FILE__ << ":" << __LINE__ << ")!" << std::endl;
exit(9876);
}
funcTransZap.insert(depfZap->second.begin(), depfZap->second.end());
}
funcMayZap.insert(std::make_pair(func, funcTransZap));
}
// convert sccs separately
unsigned int num = static_cast<unsigned int>(dependsOnSccs.size());
unsigned int currNum = 0;
for (std::list<std::list<llvm::Function*> >::iterator scci = dependsOnSccs.begin(), scce = dependsOnSccs.end(); scci != scce; ++scci) {
std::list<llvm::Function*> scc = *scci;
std::list<ref<Rule> > allRules;
std::list<ref<Rule> > allCondensedRules;
std::list<ref<Rule> > allKittelizedRules;
std::list<ref<Rule> > allSlicedRules;
if (debug) {
std::cout << "========================================" << std::endl;
}
if ((!complexityTuples && !uniformComplexityTuples) || debug) {
std::cout << "///*** " << getPartNumber(++currNum, num) << '_' << getSccName(scc) << " ***///" << std::endl;
}
std::set<llvm::Function*> sccSet;
sccSet.insert(scc.begin(), scc.end());
std::set<std::string> complexityLHSs;
for (std::list<llvm::Function*>::iterator fi = scc.begin(), fe = scc.end(); fi != fe; ++fi) {
llvm::Function *curr = *fi;
Converter converter(boolType, assumeIsControl, selectIsControl, onlyMultiPredIsControl, boundedIntegers, unsignedEncoding, onlyLoopConditions, divisionConstraintType, bitwiseConditions, complexityTuples || uniformComplexityTuples);
std::map<llvm::Function*, MayMustMap>::iterator tmp1 = mmMap.find(curr);
if (tmp1 == mmMap.end()) {
std::cerr << "Could not find alias information (" << __FILE__ << ":" << __LINE__ << ")!" << std::endl;
exit(9876);
}
MayMustMap curr_mmMap = tmp1->second;
std::map<llvm::Function*, TrueFalseMap>::iterator tmp2 = tfMap.find(curr);
TrueFalseMap curr_tfMap;
if (tmp2 != tfMap.end()) {
curr_tfMap = tmp2->second;
}
std::map<llvm::Function*, std::set<llvm::BasicBlock*> >::iterator tmp3 = lebMap.find(curr);
std::set<llvm::BasicBlock*> curr_leb;
if (tmp3 != lebMap.end()) {
curr_leb = tmp3->second;
}
std::map<llvm::Function*, ConditionMap>::iterator tmp4 = elcMap.find(curr);
ConditionMap curr_elcMap;
if (tmp4 != elcMap.end()) {
curr_elcMap = tmp4->second;
}
converter.phase1(curr, sccSet, curr_mmMap, funcMayZap, curr_tfMap, curr_leb, curr_elcMap);
converter.phase2(curr, sccSet, curr_mmMap, funcMayZap, curr_tfMap, curr_leb, curr_elcMap);
std::list<ref<Rule> > rules = converter.getRules();
std::list<ref<Rule> > condensedRules = converter.getCondensedRules();
std::list<ref<Rule> > kittelizedRules = kittelize(condensedRules, smtSolver);
Slicer slicer(curr, converter.getPhiVariables());
std::list<ref<Rule> > slicedRules;
if (noSlicing) {
slicedRules = kittelizedRules;
} else {
slicedRules = slicer.sliceUsage(kittelizedRules);
slicedRules = slicer.sliceConstraint(slicedRules);
slicedRules = slicer.sliceDefined(slicedRules);
slicedRules = slicer.sliceStillUsed(slicedRules, conservativeSlicing);
slicedRules = slicer.sliceTrivialNondefConstraints(slicedRules);
slicedRules = slicer.sliceDuplicates(slicedRules);
}
if (boundedIntegers) {
slicedRules = kittelize(addBoundConstraints(slicedRules, converter.getBitwidthMap(), unsignedEncoding), smtSolver);
}
if (debug) {
allRules.insert(allRules.end(), rules.begin(), rules.end());
allCondensedRules.insert(allCondensedRules.end(), condensedRules.begin(), condensedRules.end());
allKittelizedRules.insert(allKittelizedRules.end(), kittelizedRules.begin(), kittelizedRules.end());
}
if (simplifyConds) {
slicedRules = simplifyConstraints(slicedRules);
}
allSlicedRules.insert(allSlicedRules.end(), slicedRules.begin(), slicedRules.end());
if (complexityTuples || uniformComplexityTuples) {
std::set<std::string> tmpLHSs = converter.getComplexityLHSs();
complexityLHSs.insert(tmpLHSs.begin(), tmpLHSs.end());
}
}
if (debug) {
std::cout << "========================================" << std::endl;
for (std::list<ref<Rule> >::iterator i = allRules.begin(), e = allRules.end(); i != e; ++i) {
ref<Rule> tmp = *i;
std::cout << tmp->toString() << std::endl;
}
std::cout << "========================================" << std::endl;
for (std::list<ref<Rule> >::iterator i = allCondensedRules.begin(), e = allCondensedRules.end(); i != e; ++i) {
ref<Rule> tmp = *i;
std::cout << tmp->toString() << std::endl;
}
std::cout << "========================================" << std::endl;
for (std::list<ref<Rule> >::iterator i = allKittelizedRules.begin(), e = allKittelizedRules.end(); i != e; ++i) {
ref<Rule> tmp = *i;
std::cout << tmp->toString() << std::endl;
}
std::cout << "========================================" << std::endl;
}
if (complexityTuples) {
printComplexityTuples(allSlicedRules, complexityLHSs, std::cout);
} else if (uniformComplexityTuples) {
std::ostringstream startfun;
startfun << "eval_" << getSccName(scc) << "_start";
std::string name = startfun.str();
printUniformComplexityTuples(allSlicedRules, complexityLHSs, name, std::cout);
} else if (t2output) {
std::string startFun = "eval_" + getSccName(scc) + "_start";
printT2System(allSlicedRules, startFun, std::cout);
} else {
for (std::list<ref<Rule> >::iterator i = allSlicedRules.begin(), e = allSlicedRules.end(); i != e; ++i) {
ref<Rule> tmp = *i;
std::cout << tmp->toKittelString() << std::endl;
}
}
}
return 0;
}