void
CompassAnalyses::DiscardAssignment::Traversal::
visit(SgNode* node)
{
if (isSgAssignOp(node))
{
// simple case: the parent of a "real" assignment op must be an
// expression statement
if (!isSgExprStatement(node->get_parent()))
{
output->addOutput(new CheckerOutput(node));
}
else
{
// not so simple case: the parent is an expression statement, but if
// that statement is an if/loop condition, we still want to complain
SgNode *assignment = node->get_parent();
SgNode *p = assignment->get_parent();
SgDoWhileStmt *dws;
SgForStatement *fs;
SgIfStmt *is;
SgSwitchStatement *ss;
SgWhileStmt *ws;
if ((dws = isSgDoWhileStmt(p)) && dws->get_condition() == assignment)
{
output->addOutput(new CheckerOutput(node));
}
else if ((fs = isSgForStatement(p)) && fs->get_test() == assignment)
{
output->addOutput(new CheckerOutput(node));
}
else if ((is = isSgIfStmt(p)) && is->get_conditional() == assignment)
{
output->addOutput(new CheckerOutput(node));
}
else if ((ss = isSgSwitchStatement(p)) && ss->get_item_selector() == assignment)
{
output->addOutput(new CheckerOutput(node));
}
else if ((ws = isSgWhileStmt(p)) && ws->get_condition() == assignment)
{
output->addOutput(new CheckerOutput(node));
}
}
}
else if (SgMemberFunctionRefExp *mf = isSgMemberFunctionRefExp(node))
{
// not so simple case: call to operator= member function that is not an
// expression statement by itself
SgFunctionCallExp *call = isSgFunctionCallExp(mf->get_parent()->get_parent());
if (call && !isSgExprStatement(call->get_parent())
&& mf->get_parent() == call->get_function()
&& std::strcmp(mf->get_symbol()->get_name().str(), "operator=") == 0)
{
output->addOutput(new CheckerOutput(call));
}
}
} //End of the visit function.
void
CompassAnalyses::ExplicitTestForNonBooleanValue::Traversal::
visit(SgNode* node)
{
// Implement your traversal here.
// 1. conditional expression
if(NULL != isSgBasicBlock(node))
{
Rose_STL_Container<SgNode*> conditionalExpList = NodeQuery::querySubTree(node, V_SgConditionalExp);
for(Rose_STL_Container<SgNode*>::iterator i=conditionalExpList.begin(); i != conditionalExpList.end(); i++)
{
SgConditionalExp* conditionalExp = isSgConditionalExp(*i);
//ROSE_ASSERT(conditionalExp != NULL);
if(NULL != conditionalExp && NULL != isSgCastExp(conditionalExp->get_conditional_exp()))
{
output->addOutput(new CheckerOutput(conditionalExp));
}
}
} else {
SgExprStatement* exprStatement = NULL;
// 2. test statement in a if statement
SgIfStmt* ifStmt = isSgIfStmt(node);
if(NULL != ifStmt)
exprStatement = isSgExprStatement(ifStmt->get_conditional());
// 3. test statement in a while statement
SgWhileStmt* whileStmt = isSgWhileStmt(node);
if(NULL != whileStmt)
exprStatement = isSgExprStatement(whileStmt->get_condition());
// 4. test statement in a do-while statement
SgDoWhileStmt* doWhileStmt = isSgDoWhileStmt(node);
if(NULL != doWhileStmt)
exprStatement = isSgExprStatement(doWhileStmt->get_condition());
// 5. test statement in a for statement
SgForStatement* forStatement = isSgForStatement(node);
if(NULL != forStatement)
exprStatement = isSgExprStatement(forStatement->get_test());
if(NULL != exprStatement && NULL != isSgCastExp(exprStatement->get_expression()))
{
output->addOutput(new CheckerOutput(node));
}
}
} //End of the visit function.
void
CompassAnalyses::FloatingPointExactComparison::Traversal::
visit(SgNode* node)
{
// Implement your traversal here.
SgExprStatement* exprStatement = NULL;
SgIfStmt* ifStmt = isSgIfStmt(node);
if(NULL != ifStmt)
exprStatement = isSgExprStatement(ifStmt->get_conditional());
SgWhileStmt* whileStmt = isSgWhileStmt(node);
if(NULL != whileStmt)
exprStatement = isSgExprStatement(whileStmt->get_condition());
SgDoWhileStmt* doWhileStmt = isSgDoWhileStmt(node);
if(NULL != doWhileStmt)
exprStatement = isSgExprStatement(doWhileStmt->get_condition());
SgForStatement* forStatement = isSgForStatement(node);
if(NULL != forStatement)
exprStatement = isSgExprStatement(forStatement->get_test());
if(NULL != exprStatement && NULL != isSgNotEqualOp(exprStatement->get_expression()))
{
SgNotEqualOp* comparison = isSgNotEqualOp(exprStatement->get_expression());
if((comparison->get_lhs_operand_i() != NULL &&
isSgDoubleVal(comparison->get_lhs_operand_i()) != NULL) ||
(comparison->get_rhs_operand_i() != NULL &&
isSgDoubleVal(comparison->get_rhs_operand_i()) != NULL))
{
output->addOutput(new CheckerOutput(comparison));
}
}
if(NULL != exprStatement && NULL != isSgEqualityOp(exprStatement->get_expression()))
{
SgEqualityOp* comparison = isSgEqualityOp(exprStatement->get_expression());
if((comparison->get_lhs_operand_i() != NULL &&
isSgDoubleVal(comparison->get_lhs_operand_i()) != NULL) ||
(comparison->get_rhs_operand_i() != NULL &&
isSgDoubleVal(comparison->get_rhs_operand_i()) != NULL))
{
output->addOutput(new CheckerOutput(comparison));
}
}
} //End of the visit function.
unsigned int
PathGrader::
checkNode(const SgNode& var,
SgNode& node,
const SgIfStmt & dominator,
int & checkedOnLine)
{
std::cout << "Calling " << __PRETTY_FUNCTION__ << std::endl;
const SgStatement * const conditional = dominator.get_conditional();
std::cout << "Conditional is: " << conditional->unparseToString() << std::endl;
if( !isSgExprStatement( conditional ) ) return 0;
const SgExprStatement * const exprStmt = dynamic_cast<const SgExprStatement * const>(conditional);
ROSE_ASSERT( exprStmt != NULL );
const SgExpression * const expr = exprStmt->get_expression();
return checkConditional(expr);
}
void SSAGenerator::findConditionNodes()
{
Flow::node_iterator i = flow->nodes_begin();
while(i != flow->nodes_end())
{
SgNode* node = labeler->getNode(*i);
SgNode* current = node;
while(true)
{
assert(current != NULL);
SgFunctionDefinition* funcDef = dynamic_cast<SgFunctionDefinition*>(current);
SgIfStmt* ifStmt = dynamic_cast<SgIfStmt*>(current);
if(funcDef != NULL) //*node is not enclosed in an if statement
{
break;
}
else if(ifStmt != NULL)
{
SgNode* condition = ifStmt->get_conditional();
if(node == condition) //*node is the condition of the found if statement; Keep searching upwards
{
current = current->get_parent();
continue;
}
else //*node is enclosed in the if statement with the condition *condition
{
Label conditionLabel = labeler->getLabel(condition);
conditionMap.insert(pair<Label, Label>(*i, conditionLabel));
break;
}
}
current = current->get_parent();
}
i++;
}
//Print
map<Label, Label>::iterator j = conditionMap.begin();
while(j != conditionMap.end())
{
logger[Sawyer::Message::DEBUG] << "(" << j->first << ", " << j->second << ")" << endl;
j++;
}
}
ExprSynAttr *examineStatement(SgStatement *stmt, ostream &out) {
SgExpression *expr;
SgExprStatement *expr_stmt;
ExprSynAttr *expr_attr = NULL;
ExprSynAttr *attr1 = NULL;
stringstream fake;
int i;
if (NULL == stmt)
return NULL;
//out << "/* " << stmt->unparseToString() << " */" << endl;
switch(stmt->variantT()) {
case V_SgExprStatement:
{
expr_stmt = isSgExprStatement(stmt);
expr_attr = examineExpr(expr_stmt->get_expression(), fake);
//out << ";";
if (NULL != expr_attr) {
expr_attr->output_comments(out);
}
break;
}
case V_SgVariableDeclaration:
{
SgVariableDeclaration *vardecl = isSgVariableDeclaration(stmt);
expr_attr = examineVariableDeclaration(vardecl, out);
break;
}
case V_SgBreakStmt:
{
out << "break;";
expr_attr->code << "break;";
break;
}
case V_SgContinueStmt:
{
out << "continue;";
expr_attr->code << "continue;";
break;
}
case V_SgReturnStmt:
{
SgReturnStmt *retstmt = isSgReturnStmt(stmt);
expr_attr = new ExprSynAttr();
out << "return ";
expr = retstmt->get_expression();
if (expr) {
attr1 = examineExpr(expr, out);
expr_attr->union_tmp_decls(attr1);
expr_attr->code << attr1->code.str();
}
out << ";";
expr_attr->code << "return ";
if (attr1) {
expr_attr->result_var = attr1->result_var;
expr_attr->code << expr_attr->result_var;
}
expr_attr->code << ";";
break;
}
case V_SgForStatement:
{
stringstream head;
head << "for (";
SgForStatement *forstmt = isSgForStatement(stmt);
SgStatementPtrList &init_stmt_list = forstmt->get_init_stmt();
SgStatementPtrList::const_iterator init_stmt_iter;
for (init_stmt_iter = init_stmt_list.begin();
init_stmt_iter != init_stmt_list.end();
init_stmt_iter++) {
stmt = *init_stmt_iter;
if (init_stmt_iter != init_stmt_list.begin())
head << ", ";
expr_stmt = isSgExprStatement(stmt);
if (expr_stmt)
examineExpr(expr_stmt->get_expression(), head);
}
head << "; ";
expr_stmt = isSgExprStatement(forstmt->get_test());
if (expr_stmt)
examineExpr(expr_stmt->get_expression(), head);
head << "; ";
expr = forstmt->get_increment();
examineExpr(expr, head);
head << ")" << endl;
/* Loop body */
stmt = forstmt->get_loop_body();
expr_attr = examineStatement(stmt, fake);
attr1 = new ExprSynAttr();
attr1->code << head.str();
if (!isSgScopeStatement(stmt)) {
attr1->code << "{" << endl;
}
expr_attr->output_tmp_decls(attr1->code);
attr1->code << expr_attr->code.str();
if (!isSgScopeStatement(stmt)) {
attr1->code << "}" << endl;
}
delete expr_attr;
expr_attr = attr1;
attr1 = NULL;
out << head.str();
out << fake.str();
break;
}
case V_SgBasicBlock:
{
SgScopeStatement *scope = isSgScopeStatement(stmt);
expr_attr = examineScopeStatement(scope, "scope", out);
break;
}
case V_SgIfStmt:
{
stringstream head;
SgIfStmt *ifstmt = isSgIfStmt(stmt);
head << "if (";
stmt = ifstmt->get_conditional();
expr_stmt = isSgExprStatement(stmt);
if (expr_stmt) {
attr1 = examineExpr(expr_stmt->get_expression(), head);
if (attr1 != NULL)
delete attr1;
}
head << ")" << endl;
out << head.str();
/* True body */
stmt = ifstmt->get_true_body();
expr_attr = examineStatement(stmt, fake);
attr1 = new ExprSynAttr();
attr1->code << head.str();
if (!isSgScopeStatement(stmt)) {
attr1->code << "{" << endl;
}
expr_attr->output_tmp_decls(attr1->code);
attr1->code << expr_attr->code.str();
if (!isSgScopeStatement(stmt)) {
attr1->code << "}" << endl;
}
delete expr_attr;
expr_attr = attr1;
attr1 = NULL;
out << head.str();
out << fake.str();
/* False body */
stmt = ifstmt->get_false_body();
if (stmt) {
out << endl << "else" << endl;
expr_attr->code << endl << "else" << endl;
attr1 = examineStatement(stmt, out);
if (!isSgScopeStatement(stmt)) {
expr_attr->code << "{" << endl;
}
attr1->output_tmp_decls(expr_attr->code);
expr_attr->code << attr1->code.str();
if (!isSgScopeStatement(stmt)) {
expr_attr->code << "}" << endl;
}
}
break;
}
case V_SgWhileStmt:
{
stringstream head;
SgWhileStmt *whilestmt = isSgWhileStmt(stmt);
expr_stmt = isSgExprStatement(whilestmt->get_condition());
head << "while (";
if (expr_stmt) {
attr1 = examineExpr(expr_stmt->get_expression(), head);
if (NULL != attr1)
delete attr1;
}
out << head.str() << ")" << endl;
head << ")" << endl;
if (!isSgScopeStatement(stmt)) {
head << "{" << endl;
}
expr_attr = new ExprSynAttr();
expr_attr->code << head.str();
/* Loop Body */
stmt = whilestmt->get_body();
attr1 = examineStatement(stmt, out);
attr1->output_tmp_decls(expr_attr->code);
expr_attr->code << attr1->code.str();
if (!isSgScopeStatement(stmt)) {
expr_attr->code << "}" << endl;
}
delete attr1;
break;
}
case V_SgDoWhileStmt:
{
stringstream head;
SgDoWhileStmt *dowhilestmt = isSgDoWhileStmt(stmt);
expr_stmt = isSgExprStatement(dowhilestmt->get_condition());
stmt = dowhilestmt->get_body();
out << "do";
head << "do" << endl;
if (!isSgScopeStatement(stmt)) {
head << "{" << endl;
}
expr_attr = new ExprSynAttr();
expr_attr->code << head.str();
attr1 = examineStatement(stmt, out);
attr1->output_tmp_decls(expr_attr->code);
expr_attr->code << attr1->code.str();
if (!isSgScopeStatement(stmt)) {
expr_attr->code << "}" << endl;
}
expr_attr->code << " while (";
delete attr1;
out << " while (";
head.str("");
if (expr_stmt) {
attr1 = examineExpr(expr_stmt->get_expression(), head);
delete attr1;
out << head.str();
expr_attr->code << head.str();
}
out << ");" << endl;
expr_attr->code << ");" << endl;
break;
}
}
return expr_attr;
}
