int main(int argc, char* argv[]) {
try {
if(argc==1) {
cout << "Error: wrong command line options."<<endl;
exit(1);
}
// Command line option handling.
namespace po = boost::program_options;
po::options_description desc
("analyterix V0.2\n"
"Written by Markus Schordan\n"
"Supported options");
desc.add_options()
("help,h", "produce this help message.")
("rose-help", "show help for compiler frontend options.")
("version,v", "display the version.")
("stats", "display code statistics.")
("fi-constanalysis", "perform flow-insensitive constant analysis.")
("csv-fi-constanalysis",po::value< string >(), "generate csv-file [arg] with const-analysis data.")
("rd-analysis", "perform reaching definitions analysis.")
("rose-rd-analysis", "perform rose reaching definitions analysis.")
("lv-analysis", "perform live variables analysis.")
("ud-analysis", "use-def analysis.")
("at-analysis", "address-taken analysis.")
("icfg-dot", "generates the ICFG as dot file.")
("interval-analysis", "perform interval analysis.")
("trace", "show operations as performed by selected solver.")
("print-varidmapping", "prints variableIdMapping")
("print-varidmapping-array", "prints variableIdMapping with array element varids.")
("prefix",po::value< string >(), "set prefix for all generated files.")
;
// ("int-option",po::value< int >(),"option info")
po::store(po::command_line_parser(argc, argv).options(desc).allow_unregistered().run(), args);
po::notify(args);
if (args.count("help")) {
cout << "analyterix <filename> [OPTIONS]"<<endl;
cout << desc << "\n";
return 0;
}
if (args.count("version")) {
cout << "analyterix version 0.1\n";
cout << "Written by Markus Schordan 2014\n";
return 0;
}
if (args.count("rose-help")) {
argv[1] = strdup("--help");
}
if (args.count("prefix")) {
option_prefix=args["prefix"].as<string>().c_str();
}
if (args.count("trace")) {
option_trace=true;
}
if(args.count("stats")) {
option_stats=true;
}
if(args.count("rd-analysis")) {
option_rd_analysis=true;
}
if(args.count("lv-analysis")) {
option_lv_analysis=true;
}
if(args.count("interval-analysis")) {
option_interval_analysis=true;
}
if(args.count("ud-analysis")) {
option_rd_analysis=true; // required
option_ud_analysis=true;
}
if(args.count("rose-rd-analysis")) {
option_rose_rd_analysis=true;
}
if(args.count("fi-constanalysis")) {
option_fi_constanalysis=true;
}
if (args.count("csv-fi-constanalysis")) {
csvConstResultFileName=args["csv-fi-constanalysis"].as<string>().c_str();
option_fi_constanalysis=true;
}
if(args.count("at-analysis")) {
option_at_analysis=true;
}
// clean up string-options in argv
for (int i=1; i<argc; ++i) {
if (string(argv[i]) == "--prefix"
|| string(argv[i]) == "--csv-const-result"
) {
// do not confuse ROSE frontend
argv[i] = strdup("");
assert(i+1<argc);
argv[i+1] = strdup("");
}
}
cout << "INIT: Parsing and creating AST."<<endl;
boolOptions.registerOption("semantic-fold",false); // temporary
boolOptions.registerOption("post-semantic-fold",false); // temporary
SgProject* root = frontend(argc,argv);
// AstTests::runAllTests(root);
if(option_stats) {
SPRAY::ProgramStatistics::printBasicCodeInfo(root);
}
cout<<"STATUS: computing variableid mapping"<<endl;
VariableIdMapping variableIdMapping;
if (args.count("print-varidmapping-array")) {
variableIdMapping.setModeVariableIdForEachArrayElement(true);
}
variableIdMapping.computeVariableSymbolMapping(root);
cout<<"VariableIdMapping size: "<<variableIdMapping.getVariableIdSet().size()<<endl;
Labeler* labeler=new Labeler(root);
//cout<<"Labelling:\n"<<labeler->toString()<<endl;
#if 0
IOLabeler* iolabeler=new IOLabeler(root,&variableIdMapping);
//cout<<"IOLabelling:\n"<<iolabeler->toString()<<endl;
#endif
if (args.count("print-varidmapping")||args.count("print-varidmapping-array")) {
variableIdMapping.toStream(cout);
}
runAnalyses(root, labeler, &variableIdMapping);
cout << "INFO: generating annotated source code."<<endl;
root->unparse(0,0);
if(option_rose_rd_analysis) {
Experimental::RoseRDAnalysis::generateRoseRDDotFiles(labeler,root);
}
cout<< "STATUS: finished."<<endl;
// main function try-catch
} catch(char* str) {
cerr << "*Exception raised: " << str << endl;
return 1;
} catch(const char* str) {
cerr << "Exception raised: " << str << endl;
return 1;
} catch(string str) {
cerr << "Exception raised: " << str << endl;
return 1;
}
return 0;
}
void runAnalyses(SgProject* root, Labeler* labeler, VariableIdMapping* variableIdMapping) {
SPRAY::DFAnalysisBase::normalizeProgram(root);
if(option_fi_constanalysis) {
VarConstSetMap varConstSetMap;
FIConstAnalysis fiConstAnalysis(variableIdMapping);
fiConstAnalysis.runAnalysis(root);
fiConstAnalysis.attachAstAttributes(labeler,"const-analysis-inout"); // not iolabeler
if(csvConstResultFileName) {
cout<<"INFO: generating const CSV file "<<option_prefix+csvConstResultFileName<<endl;
fiConstAnalysis.writeCvsConstResult(*variableIdMapping, option_prefix+csvConstResultFileName);
}
cout << "INFO: annotating analysis results as comments."<<endl;
AstAnnotator ara(labeler);
ara.annotateAstAttributesAsCommentsBeforeStatements(root, "const-analysis-inout");
ara.annotateAstAttributesAsCommentsAfterStatements(root, "const-analysis-inout");
}
if(option_at_analysis) {
cout<<"STATUS: running address taken analysis."<<endl;
cout << "STATUS: computing variable and function mappings."<<endl;
// compute variableId mappings
VariableIdMapping variableIdMapping;
variableIdMapping.computeVariableSymbolMapping(root);
// Compute function id mappings:
FunctionIdMapping functionIdMapping;
functionIdMapping.computeFunctionSymbolMapping(root);
if(option_trace) {
std::cout << std::endl << "TRACE: Variable Id Mapping:" << std::endl;
variableIdMapping.toStream(std::cout);
std::cout << std::endl << "TRACE: Function Id Mapping:" << std::endl;
functionIdMapping.toStream(std::cout);
}
cout << "STATUS: computing address taken sets."<<endl;
SPRAY::FIPointerAnalysis fipa(&variableIdMapping, &functionIdMapping, root);
fipa.initialize();
fipa.run();
//cout << "STATUS: computed address taken sets:"<<endl;
//fipa.getFIPointerInfo()->printInfoSets();
bool createCsv = false;
ofstream addressTakenCsvFile;
if(csvAddressTakenResultFileName) {
std::string addressTakenCsvFileName = option_prefix;
addressTakenCsvFileName += csvAddressTakenResultFileName;
addressTakenCsvFile.open(addressTakenCsvFileName.c_str());
createCsv = true;
}
cout << "INFO: annotating declarations of address taken variables and functions."<<endl;
// Annotate declarations/definitions of variables from which the address was taken:
VariableIdSet addressTakenVariableIds = fipa.getAddressTakenVariables();
for(VariableIdSet::const_iterator idIter = addressTakenVariableIds.begin(); idIter != addressTakenVariableIds.end(); ++idIter) {
// Determine the variable declaration/definition:
SgLocatedNode* decl = variableIdMapping.getVariableDeclaration(*idIter);
if(!decl) {
// The current variable is presumably a function parameter: Try to get the initialized name:
SgVariableSymbol* varSymbol = isSgVariableSymbol(variableIdMapping.getSymbol(*idIter));
ROSE_ASSERT(varSymbol);
SgInitializedName* paramDecl = isSgInitializedName(varSymbol->get_declaration());
// We should not have a real variable declaration for the parameter:
ROSE_ASSERT(isSgFunctionParameterList(paramDecl->get_declaration()));
// Use the InitializedName:
decl = paramDecl;
}
if(decl) {
// Create the comment:
ostringstream commentStream;
commentStream << "/* Address of \"" << variableIdMapping.variableName(*idIter) << "\" is "
<< "presumably taken.*/";
// Annotate first declaration:
insertComment(commentStream.str(), PreprocessingInfo::before, decl);
// TODO: Annotate other declarations too!
// Annotate definition if available (e.g. not available in case of parameter):
if(SgDeclarationStatement* variableDeclaration = isSgDeclarationStatement(decl)) {
if(SgDeclarationStatement* definingDeclaration = variableDeclaration->get_definingDeclaration()) {
insertComment(commentStream.str(), PreprocessingInfo::before, definingDeclaration);
}
}
if(createCsv) {
// Write variable info to csv:
addressTakenCsvFile << VariableId::idKindIndicator << ","
// The id of the variable (id codes are influenced by the used system headers
// and are therefore not stable/portable):
<< (option_csv_stable ? string("<unstable>") : int_to_string((*idIter).getIdCode())) << ","
// Name of the variable:
<< variableIdMapping.variableName(*idIter) << ","
// TODO: Mangled scope and type are currently not stable/portable
// (see comments in getScopeAsMangledStableString(...))
// Mangled type of the variable (non-mangled type may contain commas (e.g. "A<int,bool>"):
<< (option_csv_stable ? string("<unstable>") : variableIdMapping.getType(*idIter)->get_mangled().getString()) << ","
// Mangled scope of the variable:
<< (option_csv_stable ? string("<unstable>") : getScopeAsMangledStableString(decl)) << ","
// Is the address taken? (currently only address taken variables are output to csv)
<< "1" << endl;
}
}
else {
cout << "ERROR: No declaration for " << variableIdMapping.uniqueShortVariableName(*idIter) << " available." << endl;
ROSE_ASSERT(false);
}
}
// Annotate declarations and definitions of functions from which the address was taken:
FunctionIdSet addressTakenFunctionIds = fipa.getAddressTakenFunctions();
for(FunctionIdSet::const_iterator idIter = addressTakenFunctionIds.begin(); idIter != addressTakenFunctionIds.end(); ++idIter) {
if(SgFunctionDeclaration* decl = functionIdMapping.getFunctionDeclaration(*idIter)) {
// Create the comment:
ostringstream commentStream;
commentStream << "/* Address of \"" << functionIdMapping.getFunctionNameFromFunctionId(*idIter) << "(...)\" is "
<< "presumably taken.*/";
// Annotate first declaration:
insertComment(commentStream.str(), PreprocessingInfo::before, decl);
// TODO: Annotate other declarations too!
// Annotate definition if available:
if(SgDeclarationStatement* definingDeclaration = decl->get_definingDeclaration()) {
insertComment(commentStream.str(), PreprocessingInfo::before, definingDeclaration);
}
if(createCsv) {
addressTakenCsvFile << FunctionId::idKindIndicator << ","
// The id of the function (id codes are influenced by the used system headers
// and are therefore not stable/portable):
<< (option_csv_stable ? string("<unstable>") : int_to_string((*idIter).getIdCode())) << ","
// Name of the function:
<< functionIdMapping.getFunctionNameFromFunctionId(*idIter) << ","
// TODO: Mangled scope and type are currently not stable/portable
// (see comments in getScopeAsMangledStableString(...))
// Mangled type of the function (non-mangled type may contain commas (e.g. "void (A<int,bool>)"):
<< (option_csv_stable ? string("<unstable>") : functionIdMapping.getTypeFromFunctionId(*idIter)->get_mangled().getString()) << ","
// Mangled scope of the function:
<< (option_csv_stable ? string("<unstable>") :getScopeAsMangledStableString(decl)) << ","
// Is the address taken? (currently only address taken functions are output to csv)
<< "1" << endl;
}
}
else {
cout << "ERROR: No declaration for " << functionIdMapping.getUniqueShortNameFromFunctionId(*idIter) << " available." << endl;
ROSE_ASSERT(false);
}
}
if(createCsv) {
addressTakenCsvFile.close();
}
#if 0
VariableIdSet vidset=fipa.getModByPointer();
cout<<"mod-set: "<<SPRAY::VariableIdSetPrettyPrint::str(vidset,variableIdMapping)<<endl;
#endif
}
if(option_interval_analysis) {
cout << "STATUS: creating interval analyzer."<<endl;
SPRAY::IntervalAnalysis* intervalAnalyzer=new SPRAY::IntervalAnalysis();
cout << "STATUS: initializing interval analyzer."<<endl;
intervalAnalyzer->setNoTopologicalSort(option_no_topological_sort);
intervalAnalyzer->initialize(root);
cout << "STATUS: running pointer analysis."<<endl;
ROSE_ASSERT(intervalAnalyzer->getVariableIdMapping());
SPRAY::FIPointerAnalysis* fipa=new FIPointerAnalysis(intervalAnalyzer->getVariableIdMapping(), intervalAnalyzer->getFunctionIdMapping(), root);
fipa->initialize();
fipa->run();
intervalAnalyzer->setPointerAnalysis(fipa);
cout << "STATUS: initializing interval transfer functions."<<endl;
intervalAnalyzer->initializeTransferFunctions();
cout << "STATUS: initializing interval global variables."<<endl;
intervalAnalyzer->initializeGlobalVariables(root);
intervalAnalyzer->setSolverTrace(option_trace);
std::string funtofind="main";
RoseAst completeast(root);
SgFunctionDefinition* startFunRoot=completeast.findFunctionByName(funtofind);
intervalAnalyzer->determineExtremalLabels(startFunRoot);
intervalAnalyzer->run();
#if 0
intervalAnalyzer->attachInInfoToAst("iv-analysis-in");
intervalAnalyzer->attachOutInfoToAst("iv-analysis-out");
AstAnnotator ara(intervalAnalyzer->getLabeler(),intervalAnalyzer->getVariableIdMapping());
ara.annotateAstAttributesAsCommentsBeforeStatements(root, "iv-analysis-in");
ara.annotateAstAttributesAsCommentsAfterStatements(root, "iv-analysis-out");
#else
AnalysisAstAnnotator ara(intervalAnalyzer->getLabeler(),intervalAnalyzer->getVariableIdMapping());
ara.annotateAnalysisPrePostInfoAsComments(root,"iv-analysis",intervalAnalyzer);
#endif
if(option_check_static_array_bounds) {
checkStaticArrayBounds(root,intervalAnalyzer);
}
// schroder3 (2016-08-08): Generate csv-file that contains unreachable statements:
if(csvDeadCodeUnreachableFileName) {
// Generate file name and open file:
std::string deadCodeCsvFileName = option_prefix;
deadCodeCsvFileName += csvDeadCodeUnreachableFileName;
ofstream deadCodeCsvFile;
deadCodeCsvFile.open(deadCodeCsvFileName.c_str());
// Iteratate over all CFG nodes/ labels:
for(Flow::const_node_iterator i = intervalAnalyzer->getFlow()->nodes_begin(); i != intervalAnalyzer->getFlow()->nodes_end(); ++i) {
const Label& label = *i;
// Do not output a function call twice (only the function call label and not the function call return label):
if(!intervalAnalyzer->getLabeler()->isFunctionCallReturnLabel(label)) {
/*const*/ IntervalPropertyState& intervalsLattice = *static_cast<IntervalPropertyState*>(intervalAnalyzer->getPreInfo(label.getId()));
if(intervalsLattice.isBot()) {
// Unreachable statement found:
const SgNode* correspondingNode = intervalAnalyzer->getLabeler()->getNode(label);
ROSE_ASSERT(correspondingNode);
// Do not output scope statements ({ }, ...)
if(!isSgScopeStatement(correspondingNode)) {
deadCodeCsvFile << correspondingNode->get_file_info()->get_line()
<< "," << SPRAY::replace_string(correspondingNode->unparseToString(), ",", "/*comma*/")
<< endl;
}
}
}
}
deadCodeCsvFile.close();
}
delete fipa;
}
if(option_lv_analysis) {
cout << "STATUS: creating LV analysis."<<endl;
SPRAY::LVAnalysis* lvAnalysis=new SPRAY::LVAnalysis();
cout << "STATUS: initializing LV analysis."<<endl;
lvAnalysis->setBackwardAnalysis();
lvAnalysis->setNoTopologicalSort(option_no_topological_sort);
lvAnalysis->initialize(root);
cout << "STATUS: running pointer analysis."<<endl;
ROSE_ASSERT(lvAnalysis->getVariableIdMapping());
SPRAY::FIPointerAnalysis* fipa = new FIPointerAnalysis(lvAnalysis->getVariableIdMapping(), lvAnalysis->getFunctionIdMapping(), root);
fipa->initialize();
fipa->run();
lvAnalysis->setPointerAnalysis(fipa);
cout << "STATUS: initializing LV transfer functions."<<endl;
lvAnalysis->initializeTransferFunctions();
cout << "STATUS: initializing LV global variables."<<endl;
lvAnalysis->initializeGlobalVariables(root);
std::string funtofind="main";
RoseAst completeast(root);
SgFunctionDefinition* startFunRoot=completeast.findFunctionByName(funtofind);
cout << "generating icfg_backward.dot."<<endl;
write_file("icfg_backward.dot", lvAnalysis->getFlow()->toDot(lvAnalysis->getLabeler()));
lvAnalysis->determineExtremalLabels(startFunRoot);
lvAnalysis->run();
cout << "INFO: attaching LV-data to AST."<<endl;
#if 0
lvAnalysis->attachInInfoToAst("lv-analysis-in");
lvAnalysis->attachOutInfoToAst("lv-analysis-out");
AstAnnotator ara(lvAnalysis->getLabeler(),lvAnalysis->getVariableIdMapping());
ara.annotateAstAttributesAsCommentsBeforeStatements(root, "lv-analysis-in");
ara.annotateAstAttributesAsCommentsAfterStatements(root, "lv-analysis-out");
#else
AnalysisAstAnnotator ara(lvAnalysis->getLabeler(),lvAnalysis->getVariableIdMapping());
ara.annotateAnalysisPrePostInfoAsComments(root,"lv-analysis",lvAnalysis);
#endif
// schroder3 (2016-08-15): Generate csv-file that contains dead assignments/ initializations:
if(csvDeadCodeDeadStoreFileName) {
// Generate file name and open file:
std::string deadCodeCsvFileName = option_prefix;
deadCodeCsvFileName += csvDeadCodeDeadStoreFileName;
ofstream deadCodeCsvFile;
deadCodeCsvFile.open(deadCodeCsvFileName.c_str());
if(option_trace) {
cout << "TRACE: checking for dead stores." << endl;
}
// Iteratate over all CFG nodes/ labels:
for(Flow::const_node_iterator labIter = lvAnalysis->getFlow()->nodes_begin(); labIter != lvAnalysis->getFlow()->nodes_end(); ++labIter) {
const Label& label = *labIter;
// Do not output a function call twice (only the function call return label and not the function call label):
if(!lvAnalysis->getLabeler()->isFunctionCallLabel(label)) {
/*const*/ SgNode* correspondingNode = lvAnalysis->getLabeler()->getNode(label);
ROSE_ASSERT(correspondingNode);
if(/*const*/ SgExprStatement* exprStmt = isSgExprStatement(correspondingNode)) {
correspondingNode = exprStmt->get_expression();
}
/*const*/ SgNode* association = 0;
// Check if the corresponding node is an assignment or an initialization:
if(isSgAssignOp(correspondingNode)) {
association = correspondingNode;
}
else if(SgVariableDeclaration* varDecl = isSgVariableDeclaration(correspondingNode)) {
SgInitializedName* initName = SgNodeHelper::getInitializedNameOfVariableDeclaration(varDecl);
ROSE_ASSERT(initName);
// Check whether there is an initialization that can be eliminated (reference initialization can not be eliminated).
if(!SgNodeHelper::isReferenceType(initName->get_type()) && initName->get_initializer()) {
association = correspondingNode;
}
}
if(association) {
if(option_trace) {
cout << endl << "association: " << association->unparseToString() << endl;
}
VariableIdSet assignedVars = AnalysisAbstractionLayer::defVariables(association, *lvAnalysis->getVariableIdMapping(), fipa);
/*const*/ LVLattice& liveVarsLattice = *static_cast<LVLattice*>(lvAnalysis->getPreInfo(label.getId()));
if(option_trace) {
cout << "live: " << liveVarsLattice.toString(lvAnalysis->getVariableIdMapping()) << endl;
cout << "assigned: " << endl;
}
bool minOneIsLive = false;
for(VariableIdSet::const_iterator assignedVarIter = assignedVars.begin(); assignedVarIter != assignedVars.end(); ++assignedVarIter) {
if(option_trace) {
cout << (*assignedVarIter).toString(*lvAnalysis->getVariableIdMapping()) << endl;
}
if(liveVarsLattice.exists(*assignedVarIter)) {
minOneIsLive = true;
break;
}
}
if(!minOneIsLive) {
if(option_trace) {
cout << "association is dead." << endl;
}
// assignment to only dead variables found:
deadCodeCsvFile << correspondingNode->get_file_info()->get_line()
<< "," << SPRAY::replace_string(correspondingNode->unparseToString(), ",", "/*comma*/")
<< endl;
}
}
}
}
deadCodeCsvFile.close();
}
delete lvAnalysis;
}
if(option_rd_analysis) {
cout << "STATUS: creating RD analyzer."<<endl;
SPRAY::RDAnalysis* rdAnalysis=new SPRAY::RDAnalysis();
cout << "STATUS: initializing RD analyzer."<<endl;
rdAnalysis->setNoTopologicalSort(option_no_topological_sort);
rdAnalysis->initialize(root);
cout << "STATUS: initializing RD transfer functions."<<endl;
rdAnalysis->initializeTransferFunctions();
cout << "STATUS: initializing RD global variables."<<endl;
rdAnalysis->initializeGlobalVariables(root);
cout << "generating icfg_forward.dot."<<endl;
write_file("icfg_forward.dot", rdAnalysis->getFlow()->toDot(rdAnalysis->getLabeler()));
std::string funtofind="main";
RoseAst completeast(root);
SgFunctionDefinition* startFunRoot=completeast.findFunctionByName(funtofind);
rdAnalysis->determineExtremalLabels(startFunRoot);
rdAnalysis->run();
cout << "INFO: attaching RD-data to AST."<<endl;
rdAnalysis->attachInInfoToAst("rd-analysis-in");
rdAnalysis->attachOutInfoToAst("rd-analysis-out");
//printAttributes<RDAstAttribute>(rdAnalysis->getLabeler(),rdAnalysis->getVariableIdMapping(),"rd-analysis-in");
cout << "INFO: annotating analysis results as comments."<<endl;
ROSE_ASSERT(rdAnalysis->getVariableIdMapping());
#if 0
AstAnnotator ara(rdAnalysis->getLabeler(),rdAnalysis->getVariableIdMapping());
ara.annotateAstAttributesAsCommentsBeforeStatements(root, "rd-analysis-in");
ara.annotateAstAttributesAsCommentsAfterStatements(root, "rd-analysis-out");
#else
AnalysisAstAnnotator ara(rdAnalysis->getLabeler(),rdAnalysis->getVariableIdMapping());
ara.annotateAnalysisPrePostInfoAsComments(root,"rd-analysis",rdAnalysis);
#endif
#if 0
cout << "INFO: substituting uses with rhs of defs."<<endl;
substituteUsesWithAvailableExpRhsOfDef("ud-analysis", root, rdAnalysis->getLabeler(), rdAnalysis->getVariableIdMapping());
#endif
if(option_ud_analysis) {
ROSE_ASSERT(option_rd_analysis);
cout << "INFO: generating and attaching UD-data to AST."<<endl;
createUDAstAttributeFromRDAttribute(rdAnalysis->getLabeler(),"rd-analysis-in", "ud-analysis");
Flow* flow=rdAnalysis->getFlow();
cout<<"Flow label-set size: "<<flow->nodeLabels().size()<<endl;
CFAnalysis* cfAnalyzer0=rdAnalysis->getCFAnalyzer();
int red=cfAnalyzer0->reduceBlockBeginNodes(*flow);
cout<<"INFO: eliminated "<<red<<" block-begin nodes in ICFG."<<endl;
#if 0
cout << "INFO: computing program statistics."<<endl;
ProgramStatistics ps(rdAnalysis->getVariableIdMapping(),
rdAnalysis->getLabeler(),
rdAnalysis->getFlow(),
"ud-analysis");
ps.computeStatistics();
//ps.printStatistics();
cout << "INFO: generating resource usage visualization."<<endl;
ps.setGenerateWithSource(false);
ps.generateResourceUsageICFGDotFile("resourceusageicfg.dot");
flow->resetDotOptions();
#endif
cout << "INFO: generating visualization data."<<endl;
// generate ICFG visualization
cout << "generating icfg.dot."<<endl;
write_file("icfg.dot", flow->toDot(rdAnalysis->getLabeler()));
// cout << "INFO: generating control dependence graph."<<endl;
//Flow cdg=rdAnalysis->getCFAnalyzer()->controlDependenceGraph(*flow);
cout << "generating datadependencegraph.dot."<<endl;
DataDependenceVisualizer ddvis0(rdAnalysis->getLabeler(),
rdAnalysis->getVariableIdMapping(),
"ud-analysis");
//printAttributes<UDAstAttribute>(rdAnalysis->getLabeler(),rdAnalysis->getVariableIdMapping(),"ud-analysis");
//ddvis._showSourceCode=false; // for large programs
ddvis0.generateDefUseDotGraph(root,"datadependencegraph.dot");
flow->resetDotOptions();
cout << "generating icfgdatadependencegraph.dot."<<endl;
DataDependenceVisualizer ddvis1(rdAnalysis->getLabeler(),
rdAnalysis->getVariableIdMapping(),
"ud-analysis");
ddvis1.includeFlowGraphEdges(flow);
ddvis1.generateDefUseDotGraph(root,"icfgdatadependencegraph.dot");
flow->resetDotOptions();
cout << "generating icfgdatadependencegraph_clustered.dot."<<endl;
DataDependenceVisualizer ddvis2(rdAnalysis->getLabeler(),
rdAnalysis->getVariableIdMapping(),
"ud-analysis");
ddvis2.generateDotFunctionClusters(root,rdAnalysis->getCFAnalyzer(),"icfgdatadependencegraph_clustered.dot",true);
cout << "generating icfg_clustered.dot."<<endl;
DataDependenceVisualizer ddvis3(rdAnalysis->getLabeler(),
rdAnalysis->getVariableIdMapping(),
"ud-analysis");
ddvis3.generateDotFunctionClusters(root,rdAnalysis->getCFAnalyzer(),"icfg_clustered.dot",false);
}
}
}
