diff options
Diffstat (limited to 'lib/rosecg/src/CG_roseBuilder.cc')
| -rw-r--r-- | lib/rosecg/src/CG_roseBuilder.cc | 1093 |
1 files changed, 0 insertions, 1093 deletions
diff --git a/lib/rosecg/src/CG_roseBuilder.cc b/lib/rosecg/src/CG_roseBuilder.cc deleted file mode 100644 index 8f7e3df..0000000 --- a/lib/rosecg/src/CG_roseBuilder.cc +++ /dev/null @@ -1,1093 +0,0 @@ -/***************************************************************************** - Copyright (C) 2008 University of Southern California - Copyright (C) 2009-2010 University of Utah - All Rights Reserved. - - Purpose: - generate suif code for omega - - Notes: - - History: - 02/01/06 created by Chun Chen - *****************************************************************************/ - -#include <stack> -#include "code_gen/CG_roseBuilder.h" -#include <string> - -struct ir_error: public std::runtime_error { - ir_error(const std::string &msg) : - std::runtime_error(msg) { - } -}; - -using namespace SageBuilder; -using namespace SageInterface; -using namespace OmpSupport; - -namespace omega { - -//----------------------------------------------------------------------------- -// make suif initilization happy -//----------------------------------------------------------------------------- -char *k_ocg_comment; - -CG_roseBuilder::CG_roseBuilder(int is_fortran, SgGlobal* global, SgGlobal* firstScope, - SgSymbolTable* symtab, SgSymbolTable* symtab2, SgNode* root) : - isFortran(is_fortran), global_(global), global_scope(firstScope), symtab_(symtab), symtab2_( - symtab2), root_(root) { -} - - -CG_roseBuilder::~CG_roseBuilder() { -} - -// Manu:: returns true if input is in fortran, else returns false -bool CG_roseBuilder::isInputFortran() const{ - if (isFortran) - return true; - else - return false; -} - -//----------------------------------------------------------------------------- -// place holder generation -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, - const std::vector<std::string> &vars, std::vector<CG_outputRepr*> &subs) const { - - SgStatementPtrList* list = static_cast<CG_roseRepr *>(stmt)->list_; - SgNode *tnl; - SgStatement* statement; - if (list != NULL) { - delete stmt; - for (int i = 0; i < subs.size(); i++) { - if (subs[i] == NULL) - continue; - - CG_roseRepr *repr = static_cast<CG_roseRepr*>(subs[i]); - SgExpression* op = repr->op_; - - for (SgStatementPtrList::iterator it = (*list).begin(); - it != (*list).end(); it++) { - statement = (*it); - tnl = isSgNode(statement); - - int j; - int not_in_symtab_; - - not_in_symtab_ = 0; - - SgVariableSymbol *vs = symtab_->find_variable( - SgName(vars[i].c_str())); - - if (vs == NULL) { - - not_in_symtab_ = 1; - - vs = symtab2_->find_variable(SgName(vars[i].c_str())); - } - if (vs != NULL) { - - std::vector<SgVarRefExp *> array = substitute(tnl, - (const SgVariableSymbol*) vs, op, root_); - for (std::vector<SgVarRefExp *>::iterator it = - array.begin(); it != array.end(); it++) { - - if (isSgVarRefExp(op)) { - if (strcmp( - isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), - vs->get_name().getString().c_str())) { - - (*it)->set_symbol( - isSgVarRefExp(op)->get_symbol()); - - } - } else if (isSgExpression(op)) { - - if (isSgBinaryOp((*it)->get_parent())) - isSgBinaryOp((*it)->get_parent())->replace_expression( - *it, op); - else if (isSgUnaryOp((*it)->get_parent())) - isSgUnaryOp((*it)->get_parent())->replace_expression( - *it, op); - else if (isSgExprListExp((*it)->get_parent())) - isSgExprListExp((*it)->get_parent())->replace_expression( - *it, op); - else - throw ir_error("unrecognized expression type"); - } - - } - } - - } - - delete repr; - subs[i] = NULL; - - if (subs[i] != NULL) - throw ir_error("not freed properly"); - - } - - return new CG_roseRepr(list); - - } else { - tnl = static_cast<CG_roseRepr *>(stmt)->tnl_; - - if (tnl == NULL) - throw ir_error("both list and tnl are null!!"); - - delete stmt; - int j; - int not_in_symtab_; - for (int i = 0; i < subs.size(); i++) { - if (subs[i] == NULL) - continue; - not_in_symtab_ = 0; - - - CG_roseRepr *repr = static_cast<CG_roseRepr*>(subs[i]); - SgExpression* op = repr->op_; - delete repr; - subs[i] = NULL; - - SgVariableSymbol *vs = symtab_->find_variable( - SgName(vars[i].c_str())); - - if (vs == NULL) { - - not_in_symtab_ = 1; - - vs = symtab2_->find_variable(SgName(vars[i].c_str())); - } - if (vs != NULL) { - std::vector<SgVarRefExp *> array = substitute(tnl, vs, op, - root_); - - if (not_in_symtab_ && isSgVarRefExp(op)) { - if (strcmp( - isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), - vs->get_name().getString().c_str())) { - } - } - - for (std::vector<SgVarRefExp *>::iterator j = array.begin(); - j != array.end(); j++) { - - if (isSgVarRefExp(op)) { - if (strcmp( - isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), - vs->get_name().getString().c_str())) { - (*j)->set_symbol(isSgVarRefExp(op)->get_symbol()); - - } - } else if (isSgExpression(op)) { - - if (isSgBinaryOp((*j)->get_parent())) - isSgBinaryOp((*j)->get_parent())->replace_expression( - *j, op); - else if (isSgUnaryOp((*j)->get_parent())) - isSgUnaryOp((*j)->get_parent())->replace_expression( - *j, op); - else if (isSgExprListExp((*j)->get_parent())) { // Manu:: fortran indices are stored this way - isSgExprListExp((*j)->get_parent())->replace_expression(*j, op); - } - else - throw ir_error("unrecognized expression type"); - - } - - } - } - } - return new CG_roseRepr(tnl); - } - -} - -//----------------------------------------------------------------------------- -// assignment generation -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateAssignment(int, CG_outputRepr *lhs, - CG_outputRepr *rhs) const { - if (lhs == NULL || rhs == NULL) { - fprintf(stderr, "Code generation: Missing lhs or rhs\n"); - return NULL; - } - - SgExpression* src = static_cast<CG_roseRepr*>(rhs)->op_; - SgExpression* dst = static_cast<CG_roseRepr*>(lhs)->op_; - - SgExprStatement* ins = buildAssignStatement(dst, src); - src->set_parent(ins); - dst->set_parent(ins); - - SgStatementPtrList* new_list = new SgStatementPtrList; - - (*new_list).push_back(isSgStatement(ins)); - - delete lhs; - delete rhs; - - return new CG_roseRepr(new_list); - -} - -//----------------------------------------------------------------------------- -// function invocation generation -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateInvoke(const std::string &fname, - std::vector<CG_outputRepr *> &list) const { - - if (fname == std::string("max") || fname == std::string("min")) { - if (list.size() == 0) { - return NULL; - } else if (list.size() == 1) { - return list[0]; - } else { - int last = list.size() - 1; - SgExpression* op2 = static_cast<CG_roseRepr*>(list[last])->op_; - delete list[last]; - list.erase(list.end()-1); - CG_roseRepr *repr = static_cast<CG_roseRepr*>(CreateInvoke(fname, - list)); - SgExpression* op1 = repr->op_; - - - SgExpression *ins; - SgExprListExp* arg_list = buildExprListExp(); - appendExpression(arg_list, op1); - appendExpression(arg_list, op2); - SgVarRefExp* opaque_var; - - - if (fname == std::string("max")) { - opaque_var = buildOpaqueVarRefExp("__rose_gt", global_); - ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list)); - - // Manu:: fortran support - if (isInputFortran()) { - SgName fName("merge"); - SgTypeInt *retType = buildIntType(); - - SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op2), new CG_roseRepr(op1)))->op_; - appendExpression(arg_list, cond); - ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); - } - - } else { - opaque_var = buildOpaqueVarRefExp("__rose_lt", global_); - ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list)); - - // Manu:: fortran support - if (isInputFortran()) { - SgName fName("merge"); - SgTypeInt *retType = buildIntType(); - - SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op1), new CG_roseRepr(op2)))->op_; - appendExpression(arg_list, cond); - ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); - } - - } - - repr->op_ = ins; - return repr; - } - } else { - fprintf(stderr, - "Code generation: invoke function io_call not implemented\n"); - return NULL; - } - -} - -//----------------------------------------------------------------------------- -// comment generation -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateComment(int, - const std::string &commentText) const { - if (commentText == std::string("")) { - return NULL; - } - - SgLocatedNode *tnl = new SgLocatedNode(); - buildComment(tnl, "//omega_comment: " + commentText); - - return new CG_roseRepr(isSgNode(tnl)); - -} - -//----------------------------------------------------------------------------- -// if stmt gen operations -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateIf(int, CG_outputRepr *guardList, - CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { - - if (true_stmtList == NULL && false_stmtList == NULL) { - delete guardList; - return NULL; - } else if (guardList == NULL) { - return StmtListAppend(true_stmtList, false_stmtList); - } - - SgExpression* header = static_cast<CG_roseRepr*>(guardList)->op_; - - SgStatementPtrList *then_part1, *else_part1; - SgStatement* then_part; - SgStatement* else_part; - SgBasicBlock* then_part2; - SgBasicBlock* else_part2; - if (true_stmtList != NULL) { - then_part1 = static_cast<CG_roseRepr*>(true_stmtList)->list_; - if (then_part1 != NULL) { - then_part = *((*then_part1).begin()); - - if ((*then_part1).size() > 1) { - then_part2 = buildBasicBlock(); - for (SgStatementPtrList::iterator it = (*then_part1).begin(); - it != (*then_part1).end(); it++) { - then_part2->append_statement(*it); - - } - then_part = isSgStatement(then_part2); - - } - } else { - // Manu:: fortran support (if part) - if (isInputFortran()) { - then_part2 = buildBasicBlock(); - then_part2->append_statement(isSgStatement(static_cast<CG_roseRepr*>(true_stmtList)->tnl_)); - then_part = isSgStatement(then_part2); - } else - then_part = isSgStatement(static_cast<CG_roseRepr*>(true_stmtList)->tnl_); - } - } else { - then_part = NULL; - } - if (false_stmtList != NULL) { - else_part1 = static_cast<CG_roseRepr*>(false_stmtList)->list_; - if (else_part1 != NULL) { - else_part = *((*else_part1).begin()); - if ((*else_part1).size() > 1) { - else_part2 = buildBasicBlock(); - for (SgStatementPtrList::iterator it2 = (*else_part1).begin(); - it2 != (*else_part1).end(); it2++) { - else_part2->append_statement(*it2); - - } - else_part = isSgStatement(else_part2); - - } - } else { - // Manu:: fortran support (if part) - if (isInputFortran()) { - else_part2 = buildBasicBlock(); - else_part2->append_statement(isSgStatement(static_cast<CG_roseRepr*>(false_stmtList)->tnl_)); - else_part = isSgStatement(else_part2); - } else - else_part = isSgStatement(static_cast<CG_roseRepr*>(false_stmtList)->tnl_); - } - } else { - else_part = NULL; - } - - SgIfStmt* ti = buildIfStmt(header, isSgStatement(then_part), - isSgStatement(else_part)); - - delete guardList; - delete true_stmtList; - delete false_stmtList; - - return new CG_roseRepr(isSgNode(ti)); - -} - -//----------------------------------------------------------------------------- -// inductive variable generation, to be used in CreateLoop as control -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateInductive(CG_outputRepr *index, - CG_outputRepr *lower, CG_outputRepr *upper, CG_outputRepr *step) const { - - if (index == NULL || lower == NULL || upper == NULL) { - fprintf(stderr, - "Code generation: something wrong in CreateInductive\n"); - return NULL; - } - - if (step == NULL) - step = new CG_roseRepr(isSgExpression(buildIntVal(1))); - - SgVarRefExp *index_sym = isSgVarRefExp( - static_cast<CG_roseRepr*>(index)->op_); - SgExpression* lower_bound = static_cast<CG_roseRepr*>(lower)->op_; - SgExpression* upper_bound = static_cast<CG_roseRepr*>(upper)->op_; - SgExpression* step_size = static_cast<CG_roseRepr*>(step)->op_; - - SgStatement* for_init_stmt = buildAssignStatement(index_sym, lower_bound); - SgLessOrEqualOp* cond = buildLessOrEqualOp(index_sym, upper_bound); - SgExprStatement* test = buildExprStatement(cond); - SgPlusAssignOp* increment = buildPlusAssignOp(index_sym, step_size); - SgForStatement *for_stmt = buildForStatement(for_init_stmt, - isSgStatement(test), increment, NULL); - - delete index; - delete lower; - delete upper; - delete step; - - - // Manu - if (isInputFortran()) { - SgFortranDo * forStmt=new SgFortranDo(Sg_File_Info::generateDefaultFileInfoForTransformationNode()); - forStmt->set_has_end_statement(true); - forStmt->set_bound(upper_bound); - forStmt->set_increment(step_size); - forStmt->set_initialization(isSgExprStatement(for_init_stmt)->get_expression()); - return new CG_roseRepr(isSgNode(forStmt)); - } else { - - return new CG_roseRepr(isSgNode(for_stmt)); - - } - -} - -//----------------------------------------------------------------------------- -// Attribute Creation -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateAttribute(CG_outputRepr *control, - const std::string &commentText) const { - - SgNode *tnl = static_cast<CG_roseRepr*>(control)->tnl_; - - tnl->setAttribute("omega_comment", new AstTextAttribute(commentText)); - - return static_cast<CG_roseRepr*>(control); - -} - -//----------------------------------------------------------------------------- -// Pragma Attribute -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreatePragmaAttribute(CG_outputRepr *stmt, int looplevel, const std::string &pragmaText) const { - SgNode *tnl = static_cast<CG_roseRepr*>(stmt)->tnl_; - CodeInsertionAttribute* attr = NULL; - if (!tnl->attributeExists("code_insertion")) { - attr = new CodeInsertionAttribute(); - tnl->setAttribute("code_insertion", attr); - } - else { - attr = static_cast<CodeInsertionAttribute*>(tnl->getAttribute("code_insertion")); - } - attr->add(new PragmaInsertion(looplevel, pragmaText)); - return stmt; -} - -//----------------------------------------------------------------------------- -// Prefetch Attribute -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreatePrefetchAttribute(CG_outputRepr* stmt, int looplevel, const std::string &arrName, int hint) const { - SgNode *tnl = static_cast<CG_roseRepr*>(stmt)->tnl_; - CodeInsertionAttribute *attr = getOrCreateCodeInsertionAttribute(tnl); - attr->add(new MMPrefetchInsertion(looplevel, arrName, hint)); -} - -//----------------------------------------------------------------------------- -// loop stmt generation -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateLoop(int, CG_outputRepr *control, - CG_outputRepr *stmtList) const { - if (stmtList == NULL) { - delete control; - return NULL; - } else if (control == NULL) { - fprintf(stderr, "Code generation: no inductive for this loop\n"); - return stmtList; - } - - SgNode *tnl = static_cast<CG_roseRepr*>(control)->tnl_; - SgForStatement *tf = isSgForStatement(tnl); - - // Manu :: fortran support - SgFortranDo *tfd = NULL; - if (isInputFortran()) { - tfd = isSgFortranDo(tnl); - } - SgStatementPtrList * body = static_cast<CG_roseRepr*>(stmtList)->list_; - - if (body != NULL) { - if (!((*body).empty())) { - if ((*body).size() == 1) { - if (!isInputFortran()) { // Manu:: added if-else for fortran support - tf->set_loop_body(*((*body).begin())); - (*((*body).begin()))->set_parent(tf); - } else { - SgBasicBlock* bb1 = buildBasicBlock(); - bb1->set_parent(tfd); - bb1->append_statement(*((*body).begin())); - tfd->set_body(bb1); - } - } else { - // Manu:: support for fortran label (do - continue) - SgName *sname = NULL; - - SgBasicBlock* bb = buildBasicBlock(); - if (!isInputFortran()) - bb->set_parent(tf); - else - bb->set_parent(tfd); - for (SgStatementPtrList::iterator it = (*body).begin(); - it != (*body).end(); it++) { - bb->append_statement(*it); - (*it)->set_parent(bb); - } - if (!isInputFortran()) - tf->set_loop_body(bb); - else { - tfd->set_body(bb); - } - } - } - } else { - SgNode* tnl2 = static_cast<CG_roseRepr*>(stmtList)->tnl_; - - if (tnl2 != NULL) { - if (!isInputFortran()) { - tf->set_loop_body(isSgStatement(tnl2)); - tnl2->set_parent(tf); - } else { - SgBasicBlock* bb1 = buildBasicBlock(); - bb1->set_parent(tfd); - bb1->append_statement(isSgStatement(tnl2)); - tfd->set_body(bb1); - tnl2->set_parent(bb1); - } - } - } - - delete stmtList; - - return control; -} - -//----------------------------------------------------------------------------- -// basic int, identifier gen operations -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateInt(int _i) const { - return new CG_roseRepr(isSgExpression(buildIntVal(_i))); -} -bool CG_roseBuilder::isInteger(CG_outputRepr *op) const{ - - SgExpression *op1 = static_cast<CG_roseRepr *>(op)->op_; - - if(op1) - if(isSgIntVal(op1)) - return true; - - return false; -} -CG_outputRepr* CG_roseBuilder::CreateIdent(const std::string &_s) const { - - SgVariableSymbol *vs = symtab_->find_variable(SgName(_s.c_str())); - SgVariableSymbol *vs2 = symtab2_->find_variable(SgName(_s.c_str())); - - if (vs == NULL && vs2 == NULL) { - - SgVariableDeclaration* defn = buildVariableDeclaration( - SgName(_s.c_str()), buildIntType()); - SgInitializedNamePtrList& variables = defn->get_variables(); - SgInitializedNamePtrList::const_iterator i = variables.begin(); - SgInitializedName* initializedName = *i; - vs = new SgVariableSymbol(initializedName); - prependStatement(defn, isSgScopeStatement(root_)); - - vs->set_parent(symtab2_); - symtab2_->insert(SgName(_s.c_str()), vs); - return new CG_roseRepr(isSgExpression(buildVarRefExp(vs))); - - } - - /* May have problem */ - - if (!isSgExpression(buildVarRefExp(SgName(_s.c_str())))) - throw ir_error("error in Create ident!!"); - if (vs2 != NULL) - return new CG_roseRepr(isSgExpression(buildVarRefExp(vs2))); - - return new CG_roseRepr(isSgExpression(buildVarRefExp(vs))); - -} - -//----------------------------------------------------------------------------- -// binary arithmetic operations -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreatePlus(CG_outputRepr *lop, - CG_outputRepr *rop) const { - if (rop == NULL) { - return lop; - } else if (lop == NULL) { - return rop; - } - - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - SgAddOp *ins = buildAddOp(op1, op2); - op1->set_parent(ins); - op2->set_parent(ins); - delete lop; - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - -} - -CG_outputRepr* CG_roseBuilder::CreateMinus(CG_outputRepr *lop, - CG_outputRepr *rop) const { - if (rop == NULL) { - return lop; /* May Cause Problem */ - } else if (lop == NULL) { - SgExpression *op = static_cast<CG_roseRepr*>(rop)->op_; - SgMinusOp *ins = buildMinusOp(op); - - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - } else { - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - SgSubtractOp *ins = buildSubtractOp(op1, op2); - op1->set_parent(ins); - op2->set_parent(ins); - delete lop; - delete rop; - return new CG_roseRepr(isSgExpression(ins)); - } - -} - -CG_outputRepr* CG_roseBuilder::CreateTimes(CG_outputRepr *lop, - CG_outputRepr *rop) const { - if (rop == NULL || lop == NULL) { - if (rop != NULL) { - rop->clear(); - delete rop; - } - if (lop != NULL) { - lop->clear(); - delete lop; - } - return NULL; - } - - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - SgMultiplyOp *ins = buildMultiplyOp(op1, op2); - op1->set_parent(ins); - op2->set_parent(ins); - delete lop; - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - -} - -CG_outputRepr* CG_roseBuilder::CreateIntegerFloor(CG_outputRepr *lop, - CG_outputRepr *rop) const { - if (rop == NULL) { - fprintf(stderr, "Code generation: divide by NULL\n"); - return NULL; - } else if (lop == NULL) { - delete rop; - return NULL; - } - - // (6+5)*10 / 4 - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - // bugs in SUIF prevent use of correct io_divfloor - SgDivideOp *ins = buildDivideOp(op1, op2); - - delete lop; - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - -} - -CG_outputRepr* CG_roseBuilder::CreateIntegerMod(CG_outputRepr *lop, - CG_outputRepr *rop) const { - if (rop == NULL || lop == NULL) { - return NULL; - } - - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - // bugs in SUIF prevent use of correct io_mod - SgModOp *ins; - if (!isInputFortran()) { - ins = buildModOp(op1, op2); - delete lop; - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - } else { // Manu:: fortran mod is a function call and not an operator (f77 and f90) - SgExpression *fins; - SgName fName("MOD"); - SgExprListExp* arg_list = buildExprListExp(); - appendExpression(arg_list, op1); - appendExpression(arg_list, op2); - SgTypeInt *retType = buildIntType(); - fins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); - return new CG_roseRepr(isSgExpression(fins)); - } - -} - -//----------------------------------------------------------------------------- -// binary logical operations -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateAnd(CG_outputRepr *lop, - CG_outputRepr *rop) const { - - if (rop == NULL) - return lop; - else if (lop == NULL) - return rop; - - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - SgAndOp *ins = buildAndOp(op1, op2); - - delete lop; - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - -} - -//----------------------------------------------------------------------------- -// binary relational operations -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::CreateLE(CG_outputRepr *lop, - CG_outputRepr *rop) const { - if (rop == NULL || lop == NULL) { - return NULL; - } - - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - SgLessOrEqualOp *ins = buildLessOrEqualOp(op1, op2); - - delete lop; - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - -} - -CG_outputRepr* CG_roseBuilder::CreateEQ(CG_outputRepr *lop, - CG_outputRepr *rop) const { - if (rop == NULL || lop == NULL) { - return NULL; - } - - SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_; - SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_; - - SgEqualityOp *ins = buildEqualityOp(op1, op2); - - delete lop; - delete rop; - - return new CG_roseRepr(isSgExpression(ins)); - -} - -//----------------------------------------------------------------------------- -// stmt list gen operations -//----------------------------------------------------------------------------- -CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, - CG_outputRepr *list2) const { - - if (list2 == NULL) { - return list1; - } else if (list1 == NULL) { - return list2; - } - - SgStatementPtrList* new_list; - - SgStatementPtrList* tnl1 = static_cast<CG_roseRepr *>(list1)->list_; - SgStatementPtrList* tnl2 = static_cast<CG_roseRepr *>(list2)->list_; - SgNode* one = static_cast<CG_roseRepr *>(list1)->tnl_; - SgNode* two = static_cast<CG_roseRepr *>(list2)->tnl_; - - SgExpression* exp1 = static_cast<CG_roseRepr *>(list1)->op_; - SgExpression* exp2 = static_cast<CG_roseRepr *>(list2)->op_; - - if (exp1 || exp2) - throw ir_error("error in stmtlistappend!!"); - - if (tnl1 && one) - throw ir_error("error in stmtlistappend!!"); - - if (tnl2 && two) - throw ir_error("error in stmtlistappend!!"); - if ((tnl1 == NULL) && (tnl2 == NULL)) { - - if ((one != NULL) && (two != NULL)) { - - new_list = new SgStatementPtrList; - - (*new_list).push_back(isSgStatement(one)); - (*new_list).push_back(isSgStatement(two)); - - CG_roseRepr* new_rep = new CG_roseRepr(new_list); - - return static_cast<CG_outputRepr *>(new_rep); - - } else if ((one != NULL) && (two == NULL)) { - - return static_cast<CG_outputRepr *>(new CG_roseRepr(one)); - - } else if ((two != NULL) && (one == NULL)) { - return static_cast<CG_outputRepr *>(new CG_roseRepr(two)); - - } - - } else { - if ((tnl2 != NULL) && (tnl1 == NULL)) { - if (one == NULL) - return list2; - else { - new_list = new SgStatementPtrList; - (*new_list).push_back(isSgStatement(one)); - - for (SgStatementPtrList::iterator it = (*tnl2).begin(); - it != (*tnl2).end(); it++) { - (*new_list).push_back(*it); - - } - return static_cast<CG_outputRepr *>(new CG_roseRepr(new_list)); - } - } else if ((tnl1 != NULL) && (tnl2 == NULL)) { - if (two == NULL) - return list1; - else { - - (*tnl1).push_back(isSgStatement(two)); - return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1)); - - } - - } else if ((tnl1 != NULL) && (tnl2 != NULL)) { - - for (SgStatementPtrList::iterator it = (*tnl2).begin(); - it != (*tnl2).end(); it++) { - (*tnl1).push_back(*it); - - } - - return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1)); - } - - } - -} - - -CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, CG_outputRepr* arg1, - CG_outputRepr* arg2, CG_outputRepr* arg3) const { - - SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( - SgName("dim3")); - - SgExprListExp * ctor_args; - if(arg3 != NULL) - ctor_args = buildExprListExp(static_cast<CG_roseRepr*>(arg1)->op_, - static_cast<CG_roseRepr*>(arg2)->op_, static_cast<CG_roseRepr*>(arg3)->op_); - else - ctor_args = buildExprListExp(static_cast<CG_roseRepr*>(arg1)->op_, - static_cast<CG_roseRepr*>(arg2)->op_); - SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( - buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); - - char joined_str[20]; - - strcpy(joined_str, "dim3 "); - strcat(joined_str, varName); - - SgExprStatement* decl = buildAssignStatement( - buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), - dim3_func_call); - - SgStatementPtrList *tnl2 = new SgStatementPtrList; - - (*tnl2).push_back(decl); - return new CG_roseRepr(tnl2); - -} - -std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, - SgExpression* expr, SgNode* root) { - - SgStatement* stmt; - SgExpression* op; - std::vector<SgVarRefExp *> arrays; - - if (in != NULL) { - if (stmt = isSgStatement(in)) { - if (isSgBasicBlock(stmt)) { - SgStatementPtrList& stmts = - isSgBasicBlock(stmt)->get_statements(); - for (int i = 0; i < stmts.size(); i++) { - stmts[i]->set_parent(stmt); - std::vector<SgVarRefExp *> a = substitute( - isSgNode(stmts[i]), sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - } - } else if (isSgForStatement(stmt)) { - SgForStatement *tnf = isSgForStatement(stmt); - tnf->get_for_init_stmt()->set_parent(tnf); - tnf->get_test()->set_parent(tnf); - tnf->get_increment()->set_parent(tnf); - tnf->get_loop_body()->set_parent(tnf); - std::vector<SgVarRefExp *> a = substitute( - isSgNode(tnf->get_for_init_stmt()), sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a1 = substitute( - isSgNode(tnf->get_test()), sym, expr, root); - std::copy(a1.begin(), a1.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a2 = substitute( - isSgNode(tnf->get_increment()), sym, expr, root); - std::copy(a2.begin(), a2.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a3 = substitute( - isSgNode(tnf->get_loop_body()), sym, expr, root); - std::copy(a3.begin(), a3.end(), back_inserter(arrays)); - } else if (isSgFortranDo(stmt)) { // Manu:: fortran support - SgFortranDo *tnf = isSgFortranDo(stmt); - tnf->get_initialization()->set_parent(tnf); - tnf->get_bound()->set_parent(tnf); - tnf->get_increment()->set_parent(tnf); - tnf->get_body()->set_parent(tnf); - std::vector<SgVarRefExp *> a = substitute( - isSgNode(tnf->get_initialization()), sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a1 = substitute( - isSgNode(tnf->get_bound()), sym, expr, root); - std::copy(a1.begin(), a1.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a2 = substitute( - isSgNode(tnf->get_increment()), sym, expr, root); - std::copy(a2.begin(), a2.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a3 = substitute( - isSgNode(tnf->get_body()), sym, expr, root); - std::copy(a3.begin(), a3.end(), back_inserter(arrays)); - } else if (isSgForInitStatement(stmt)) { - - SgStatementPtrList& stmts = - isSgForInitStatement(stmt)->get_init_stmt(); - - for (SgStatementPtrList::iterator it = stmts.begin(); - it != stmts.end(); it++) { - std::vector<SgVarRefExp *> a = substitute(isSgNode(*it), - sym, expr, root); - - std::copy(a.begin(), a.end(), back_inserter(arrays)); - } - } - else if (isSgVariableDeclaration(stmt)) { - if (SgExpression *init = - isSgVariableDeclaration(stmt)->get_variables().front()->get_initializer()) { - if (isSgAssignInitializer(init)) { - std::vector<SgVarRefExp *> a = substitute( - isSgAssignInitializer(init)->get_operand(), sym, - expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - } - } - } else if (isSgIfStmt(stmt)) { - SgIfStmt* tni = isSgIfStmt(stmt); - std::vector<SgVarRefExp *> a = substitute( - isSgNode(tni->get_conditional()), sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a1 = substitute( - isSgNode(tni->get_true_body()), sym, expr, root); - std::copy(a1.begin(), a1.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a2 = substitute( - isSgNode(tni->get_false_body()), sym, expr, root); - std::copy(a2.begin(), a2.end(), back_inserter(arrays)); - } else if (isSgExprStatement(stmt)) { - (isSgExprStatement(stmt)->get_expression())->set_parent( - isSgExprStatement(stmt)); - std::vector<SgVarRefExp *> a = substitute( - isSgNode(isSgExprStatement(stmt)->get_expression()), - sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - } - } - else { - op = isSgExpression(in); - std::string y = sym->get_name().getString(); - - if (isSgBinaryOp(op)) { - - isSgBinaryOp(op)->get_lhs_operand()->set_parent(op); - isSgBinaryOp(op)->get_rhs_operand()->set_parent(op); - - std::vector<SgVarRefExp *> a = substitute( - isSgBinaryOp(op)->get_lhs_operand(), sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - std::vector<SgVarRefExp *> a1 = substitute( - isSgBinaryOp(op)->get_rhs_operand(), sym, expr, root); - std::copy(a1.begin(), a1.end(), back_inserter(arrays)); - } else if (isSgUnaryOp(op)) { - std::vector<SgVarRefExp *> a = substitute( - isSgUnaryOp(op)->get_operand(), sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - } else if (isSgVarRefExp(op)) { - std::string z = - isSgVarRefExp(op)->get_symbol()->get_name().getString(); - if (!strcmp(z.c_str(), y.c_str())) { - arrays.push_back(isSgVarRefExp(op)); - } - } - else if (isSgCallExpression(op)) { - SgExprListExp* exprs = isSgCallExpression(op)->get_args(); - SgExpressionPtrList &expr_list = exprs->get_expressions(); - - for (SgExpressionPtrList::iterator it = expr_list.begin(); - it != expr_list.end(); it++) { - std::vector<SgVarRefExp *> a = substitute(isSgNode(*it), - sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - } - } else if (isSgExprListExp(op)) { // Manu:: fortran indices are stored this way - SgExpressionPtrList &expr_list = isSgExprListExp(op)->get_expressions(); - - for (SgExpressionPtrList::iterator it = expr_list.begin(); - it != expr_list.end(); it++) { - std::vector<SgVarRefExp *> a = substitute(isSgNode(*it), - sym, expr, root); - std::copy(a.begin(), a.end(), back_inserter(arrays)); - } - - } - - } - } - - return arrays; -} - -} // namespace |