std::string SPRAY::VariableIdSetPrettyPrint::str(VariableIdSet& vset, VariableIdMapping& vidm)
{
std::ostringstream ostr;
ostr << "[";
VariableIdSet::iterator it = vset.begin();
for( ; it != vset.end(); )
{
ostr << "<" << (*it).toString() << ", " << vidm.variableName(*it) << ">";
it++;
if(it != vset.end())
ostr << ", ";
}
ostr << "]";
return ostr.str();
}
void printResult(VariableIdMapping& variableIdMapping, VarConstSetMap& map) {
cout<<"Result:"<<endl;
VariableConstInfo vci(&variableIdMapping, &map);
for(VarConstSetMap::iterator i=map.begin();i!=map.end();++i) {
VariableId varId=(*i).first;
//string variableName=variableIdMapping.uniqueShortVariableName(varId);
string variableName=variableIdMapping.variableName(varId);
set<ConstIntLattice> valueSet=(*i).second;
stringstream setstr;
setstr<<"{";
for(set<ConstIntLattice>::iterator i=valueSet.begin();i!=valueSet.end();++i) {
if(i!=valueSet.begin())
setstr<<",";
setstr<<(*i).toString();
}
setstr<<"}";
cout<<variableName<<"="<<setstr.str()<<";";
#if 1
cout<<"Range:"<<VariableConstInfo::createVariableValueRangeInfo(varId,map).toString();
cout<<" width: "<<VariableConstInfo::createVariableValueRangeInfo(varId,map).width().toString();
cout<<" top: "<<VariableConstInfo::createVariableValueRangeInfo(varId,map).isTop();
cout<<endl;
#endif
cout<<" isAny:"<<vci.isAny(varId)
<<" isUniqueConst:"<<vci.isUniqueConst(varId)
<<" isMultiConst:"<<vci.isMultiConst(varId);
if(vci.isUniqueConst(varId)||vci.isMultiConst(varId)) {
cout<<" width:"<<vci.width(varId);
} else {
cout<<" width:unknown";
}
cout<<" Test34:"<<vci.isInConstSet(varId,34);
cout<<endl;
}
cout<<"---------------------"<<endl;
}
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);
}
}
}
/* format: varname, isAny, isUniqueconst, isMultiConst, width(>=1 or 0 or -1 (for any)), min, max, numBits, "{...}"
*/
void FIConstAnalysis::writeCvsConstResult(VariableIdMapping& variableIdMapping, string filename) {
ofstream myfile;
myfile.open(filename.c_str());
// cout<<"Result:"<<endl;
//VariableConstInfo vci(&variableIdMapping, &map);
for(VarConstSetMap::iterator i=_varConstSetMap.begin(); i!=_varConstSetMap.end(); ++i) {
VariableId varId=(*i).first;
//string variableName=variableIdMapping.uniqueShortVariableName(varId);
string variableName=variableIdMapping.variableName(varId);
myfile<<variableName;
myfile<<",";
myfile<<global_variableConstInfo->isAny(varId);
myfile<<",";
myfile<<global_variableConstInfo->isUniqueConst(varId);
myfile<<",";
myfile<<global_variableConstInfo->isMultiConst(varId);
myfile<<",";
if(global_variableConstInfo->isUniqueConst(varId)||global_variableConstInfo->isMultiConst(varId)) {
myfile<<global_variableConstInfo->minConst(varId);
myfile<<",";
myfile<<global_variableConstInfo->maxConst(varId);
size_t mywidth=global_variableConstInfo->width(varId);
assert(mywidth==(size_t)global_variableConstInfo->maxConst(varId)-global_variableConstInfo->minConst(varId)+1);
int mylog2=log2(mywidth);
// compute upper whole number
int bits=-1;
// casts on pow args to ensure that the correct overloaded C++ cmath function is selected
if(mywidth==static_cast<size_t>(pow(2.0,(double)mylog2))) {
if(mylog2==0)
bits=1;
else
bits=mylog2;
} else {
bits=mylog2+1;
}
assert(bits!=-1);
myfile<<",";
myfile<<bits;
} else {
myfile<<INT_MIN
<<","
<<INT_MAX
<<","
<<sizeof(int)*8;
}
myfile<<",";
// TODO: print array size
// myfile<<",";
SgType* varType=variableIdMapping.getType(varId);
if(isSgArrayType(varType))
myfile<<"CA_ARRAY";
else if(isSgPointerType(varType))
myfile<<"CA_PTR";
else if(isSgTypeInt(varType))
myfile<<"CA_INT";
else
myfile<<"CA_UNKNOWN";
myfile<<",";
//myfile<<arraySize<<",";
#if 1
set<CppCapsuleConstIntLattice> valueSet=(*i).second;
stringstream setstr;
myfile<<"{";
for(set<CppCapsuleConstIntLattice>::iterator i=valueSet.begin(); i!=valueSet.end(); ++i) {
if(i!=valueSet.begin())
myfile<<",";
myfile<<(*i).getValue().toString();
}
myfile<<"}";
#endif
myfile<<endl;
}
myfile.close();
}
