/***************************************************************************** Copyright (C) 2009-2010 University of Utah All Rights Reserved. Purpose: CHiLL's rose interface. Notes: Array supports mixed pointer and array type in a single declaration. History: 02/23/2009 Created by Chun Chen. *****************************************************************************/ #include #include "ir_rose.hh" #include "ir_rose_utils.hh" #include "rose_attributes.h" #include "CG_roseRepr.h" #include "CG_roseBuilder.h" using namespace SageBuilder; using namespace SageInterface; using namespace omega; // ---------------------------------------------------------------------------- // Class: IR_roseScalarSymbol // ---------------------------------------------------------------------------- std::string IR_roseScalarSymbol::name() const { return vs_->get_name().getString(); } int IR_roseScalarSymbol::size() const { return (vs_->get_type()->memoryUsage()) / (vs_->get_type()->numberOfNodes()); } bool IR_roseScalarSymbol::operator==(const IR_Symbol &that) const { if (typeid(*this) != typeid(that)) return false; const IR_roseScalarSymbol *l_that = static_cast(&that); return this->vs_ == l_that->vs_; } IR_Symbol *IR_roseScalarSymbol::clone() const { return NULL; } // ---------------------------------------------------------------------------- // Class: IR_roseArraySymbol // ---------------------------------------------------------------------------- std::string IR_roseArraySymbol::name() const { return (vs_->get_declaration()->get_name().getString()); } int IR_roseArraySymbol::elem_size() const { SgType *tn = vs_->get_type(); SgType* arrType; int elemsize; if (arrType = isSgArrayType(tn)) { while (isSgArrayType(arrType)) { arrType = arrType->findBaseType(); } } else if (arrType = isSgPointerType(tn)) { while (isSgPointerType(arrType)) { arrType = arrType->findBaseType(); } } elemsize = (int) arrType->memoryUsage() / arrType->numberOfNodes(); return elemsize; } int IR_roseArraySymbol::n_dim() const { int dim = 0; SgType* arrType = isSgArrayType(vs_->get_type()); SgType* ptrType = isSgPointerType(vs_->get_type()); if (arrType != NULL) { while (isSgArrayType(arrType)) { arrType = isSgArrayType(arrType)->get_base_type(); dim++; } } else if (ptrType != NULL) { while (isSgPointerType(ptrType)) { ptrType = isSgPointerType(ptrType)->get_base_type(); dim++; } } // Manu:: fortran support if (static_cast(ir_)->is_fortran_) { if (arrType != NULL) { dim = 0; SgExprListExp * dimList = isSgArrayType(vs_->get_type())->get_dim_info(); SgExpressionPtrList::iterator it = dimList->get_expressions().begin(); for(;it != dimList->get_expressions().end(); it++) { dim++; } } else if (ptrType != NULL) { //std::cout << "pntrType \n"; ; // not sure if this case will happen } } return dim; } omega::CG_outputRepr *IR_roseArraySymbol::size(int dim) const { SgArrayType* arrType = isSgArrayType(vs_->get_type()); // SgExprListExp* dimList = arrType->get_dim_info(); int count = 0; SgExpression* expr; SgType* pntrType = isSgPointerType(vs_->get_type()); if (arrType != NULL) { SgExprListExp* dimList = arrType->get_dim_info(); if (!static_cast(ir_)->is_fortran_) { SgExpressionPtrList::iterator it = dimList->get_expressions().begin(); while ((it != dimList->get_expressions().end()) && (count < dim)) { it++; count++; } expr = *it; } else { SgExpressionPtrList::reverse_iterator i = dimList->get_expressions().rbegin(); for (; (i != dimList->get_expressions().rend()) && (count < dim); i++) { count++; } expr = *i; } } else if (pntrType != NULL) { while (count < dim) { pntrType = (isSgPointerType(pntrType))->get_base_type(); count++; } if (isSgPointerType(pntrType)) expr = new SgExpression; } if (!expr) throw ir_error("Index variable is NULL!!"); // Manu :: debug std::cout << "---------- size :: " << isSgNode(expr)->unparseToString().c_str() << "\n"; return new omega::CG_roseRepr(expr); } IR_ARRAY_LAYOUT_TYPE IR_roseArraySymbol::layout_type() const { if (static_cast(ir_)->is_fortran_) return IR_ARRAY_LAYOUT_COLUMN_MAJOR; else return IR_ARRAY_LAYOUT_ROW_MAJOR; } bool IR_roseArraySymbol::operator==(const IR_Symbol &that) const { if (typeid(*this) != typeid(that)) return false; const IR_roseArraySymbol *l_that = static_cast(&that); return this->vs_ == l_that->vs_; } IR_Symbol *IR_roseArraySymbol::clone() const { return new IR_roseArraySymbol(ir_, vs_); } // ---------------------------------------------------------------------------- // Class: IR_roseConstantRef // ---------------------------------------------------------------------------- bool IR_roseConstantRef::operator==(const IR_Ref &that) const { if (typeid(*this) != typeid(that)) return false; const IR_roseConstantRef *l_that = static_cast(&that); if (this->type_ != l_that->type_) return false; if (this->type_ == IR_CONSTANT_INT) return this->i_ == l_that->i_; else return this->f_ == l_that->f_; } omega::CG_outputRepr *IR_roseConstantRef::convert() { if (type_ == IR_CONSTANT_INT) { omega::CG_roseRepr *result = new omega::CG_roseRepr( isSgExpression(buildIntVal(static_cast(i_)))); delete this; return result; } else throw ir_error("constant type not supported"); } IR_Ref *IR_roseConstantRef::clone() const { if (type_ == IR_CONSTANT_INT) return new IR_roseConstantRef(ir_, i_); else if (type_ == IR_CONSTANT_FLOAT) return new IR_roseConstantRef(ir_, f_); else throw ir_error("constant type not supported"); } // ---------------------------------------------------------------------------- // Class: IR_roseScalarRef // ---------------------------------------------------------------------------- bool IR_roseScalarRef::is_write() const { if (is_write_ == 1) return true; return false; } IR_ScalarSymbol *IR_roseScalarRef::symbol() const { return new IR_roseScalarSymbol(ir_, vs_->get_symbol()); } bool IR_roseScalarRef::operator==(const IR_Ref &that) const { if (typeid(*this) != typeid(that)) return false; const IR_roseScalarRef *l_that = static_cast(&that); if (this->ins_pos_ == NULL) return this->vs_ == l_that->vs_; else return this->ins_pos_ == l_that->ins_pos_ && this->op_pos_ == l_that->op_pos_; } omega::CG_outputRepr *IR_roseScalarRef::convert() { omega::CG_roseRepr *result = new omega::CG_roseRepr(isSgExpression(vs_)); delete this; return result; } IR_Ref * IR_roseScalarRef::clone() const { return new IR_roseScalarRef(ir_, vs_, this->is_write_); } // ---------------------------------------------------------------------------- // Class: IR_roseArrayRef // ---------------------------------------------------------------------------- bool IR_roseArrayRef::is_write() const { SgAssignOp* assignment; if (is_write_ == 1 || is_write_ == 0) return is_write_; if (assignment = isSgAssignOp(ia_->get_parent())) { if (assignment->get_lhs_operand() == ia_) return true; } else if (SgExprStatement* expr_stmt = isSgExprStatement( ia_->get_parent())) { SgExpression* exp = expr_stmt->get_expression(); if (exp) { if (assignment = isSgAssignOp(exp)) { if (assignment->get_lhs_operand() == ia_) return true; } } } return false; } omega::CG_outputRepr *IR_roseArrayRef::index(int dim) const { SgExpression *current = isSgExpression(ia_); SgExpression* expr; int count = 0; while (isSgPntrArrRefExp(current)) { current = isSgPntrArrRefExp(current)->get_lhs_operand(); count++; } current = ia_; while (count > dim) { expr = isSgPntrArrRefExp(current)->get_rhs_operand(); current = isSgPntrArrRefExp(current)->get_lhs_operand(); count--; } // Manu:: fortran support if (static_cast(ir_)->is_fortran_) { expr = isSgPntrArrRefExp(ia_)->get_rhs_operand(); count = 0; if (isSgExprListExp(expr)) { SgExpressionPtrList::iterator indexList = isSgExprListExp(expr)->get_expressions().begin(); while (count < dim) { indexList++; count++; } expr = isSgExpression(*indexList); } } if (!expr) throw ir_error("Index variable is NULL!!"); omega::CG_roseRepr* ind = new omega::CG_roseRepr(expr); return ind->clone(); } IR_ArraySymbol *IR_roseArrayRef::symbol() const { SgExpression *current = isSgExpression(ia_); SgVarRefExp* base; SgVariableSymbol *arrSymbol; while (isSgPntrArrRefExp(current) || isSgUnaryOp(current)) { if (isSgPntrArrRefExp(current)) current = isSgPntrArrRefExp(current)->get_lhs_operand(); else if (isSgUnaryOp(current)) /* To handle support for addressof operator and pointer dereference * both of which are unary ops */ current = isSgUnaryOp(current)->get_operand(); } if (base = isSgVarRefExp(current)) { arrSymbol = (SgVariableSymbol*) (base->get_symbol()); std::string x = arrSymbol->get_name().getString(); } else throw ir_error("Array Symbol is not a variable?!"); return new IR_roseArraySymbol(ir_, arrSymbol); } bool IR_roseArrayRef::operator==(const IR_Ref &that) const { if (typeid(*this) != typeid(that)) return false; const IR_roseArrayRef *l_that = static_cast(&that); return this->ia_ == l_that->ia_; } omega::CG_outputRepr *IR_roseArrayRef::convert() { omega::CG_roseRepr *temp = new omega::CG_roseRepr( isSgExpression(this->ia_)); omega::CG_outputRepr *result = temp->clone(); // delete this; // Commented by Manu return result; } IR_Ref *IR_roseArrayRef::clone() const { return new IR_roseArrayRef(ir_, ia_, is_write_); } // ---------------------------------------------------------------------------- // Class: IR_roseLoop // ---------------------------------------------------------------------------- IR_ScalarSymbol *IR_roseLoop::index() const { SgForStatement *tf = isSgForStatement(tf_); SgFortranDo *tfortran = isSgFortranDo(tf_); SgVariableSymbol* vs = NULL; if (tf) { SgForInitStatement* list = tf->get_for_init_stmt(); SgStatementPtrList& initStatements = list->get_init_stmt(); SgStatementPtrList::const_iterator j = initStatements.begin(); if (SgExprStatement *expr = isSgExprStatement(*j)) if (SgAssignOp* op = isSgAssignOp(expr->get_expression())) if (SgVarRefExp* var_ref = isSgVarRefExp(op->get_lhs_operand())) vs = var_ref->get_symbol(); } else if (tfortran) { SgExpression* init = tfortran->get_initialization(); if (SgAssignOp* op = isSgAssignOp(init)) if (SgVarRefExp* var_ref = isSgVarRefExp(op->get_lhs_operand())) vs = var_ref->get_symbol(); } if (vs == NULL) throw ir_error("Index variable is NULL!!"); return new IR_roseScalarSymbol(ir_, vs); } omega::CG_outputRepr *IR_roseLoop::lower_bound() const { SgForStatement *tf = isSgForStatement(tf_); SgFortranDo *tfortran = isSgFortranDo(tf_); SgExpression* lowerBound = NULL; if (tf) { SgForInitStatement* list = tf->get_for_init_stmt(); SgStatementPtrList& initStatements = list->get_init_stmt(); SgStatementPtrList::const_iterator j = initStatements.begin(); if (SgExprStatement *expr = isSgExprStatement(*j)) if (SgAssignOp* op = isSgAssignOp(expr->get_expression())) { lowerBound = op->get_rhs_operand(); //Rose sometimes introduces an unnecessary cast which is a unary op if (isSgUnaryOp(lowerBound)) lowerBound = isSgUnaryOp(lowerBound)->get_operand(); } } else if (tfortran) { SgExpression* init = tfortran->get_initialization(); if (SgAssignOp* op = isSgAssignOp(init)) lowerBound = op->get_rhs_operand(); } if (lowerBound == NULL) throw ir_error("Lower Bound is NULL!!"); return new omega::CG_roseRepr(lowerBound); } omega::CG_outputRepr *IR_roseLoop::upper_bound() const { SgForStatement *tf = isSgForStatement(tf_); SgFortranDo *tfortran = isSgFortranDo(tf_); SgExpression* upperBound = NULL; if (tf) { SgBinaryOp* test_expr = isSgBinaryOp(tf->get_test_expr()); if (test_expr == NULL) throw ir_error("Test Expression is NULL!!"); upperBound = test_expr->get_rhs_operand(); //Rose sometimes introduces an unnecessary cast which is a unary op if (isSgUnaryOp(upperBound)) upperBound = isSgUnaryOp(upperBound)->get_operand(); if (upperBound == NULL) throw ir_error("Upper Bound is NULL!!"); } else if (tfortran) { upperBound = tfortran->get_bound(); } return new omega::CG_roseRepr(upperBound); } IR_CONDITION_TYPE IR_roseLoop::stop_cond() const { SgForStatement *tf = isSgForStatement(tf_); SgFortranDo *tfortran = isSgFortranDo(tf_); if (tf) { SgExpression* stopCond = NULL; SgExpression* test_expr = tf->get_test_expr(); if (isSgLessThanOp(test_expr)) return IR_COND_LT; else if (isSgLessOrEqualOp(test_expr)) return IR_COND_LE; else if (isSgGreaterThanOp(test_expr)) return IR_COND_GT; else if (isSgGreaterOrEqualOp(test_expr)) return IR_COND_GE; else throw ir_error("loop stop condition unsupported"); } else if (tfortran) { SgExpression* increment = tfortran->get_increment(); if (!isSgNullExpression(increment)) { if (isSgMinusOp(increment) && !isSgBinaryOp(isSgMinusOp(increment)->get_operand())) return IR_COND_GE; else return IR_COND_LE; } else { return IR_COND_LE; // Manu:: if increment is not present, assume it to be 1. Just a workaround, not sure if it will be correct for all cases. SgExpression* lowerBound = NULL; SgExpression* upperBound = NULL; SgExpression* init = tfortran->get_initialization(); SgIntVal* ub; SgIntVal* lb; if (SgAssignOp* op = isSgAssignOp(init)) lowerBound = op->get_rhs_operand(); upperBound = tfortran->get_bound(); if ((upperBound != NULL) && (lowerBound != NULL)) { if ((ub = isSgIntVal(isSgValueExp(upperBound))) && (lb = isSgIntVal(isSgValueExp(lowerBound)))) { if (ub->get_value() > lb->get_value()) return IR_COND_LE; else return IR_COND_GE; } else throw ir_error("loop stop condition unsupported"); } else throw ir_error("malformed fortran loop bounds!!"); } } } IR_Block *IR_roseLoop::body() const { SgForStatement *tf = isSgForStatement(tf_); SgFortranDo *tfortran = isSgFortranDo(tf_); SgNode* loop_body = NULL; SgStatement* body_statements = NULL; if (tf) { body_statements = tf->get_loop_body(); } else if (tfortran) { body_statements = isSgStatement(tfortran->get_body()); } loop_body = isSgNode(body_statements); SgStatementPtrList list; if (isSgBasicBlock(loop_body)) { list = isSgBasicBlock(loop_body)->get_statements(); if (list.size() == 1) loop_body = isSgNode(*(list.begin())); } if (loop_body == NULL) throw ir_error("for loop body is NULL!!"); return new IR_roseBlock(ir_, loop_body); } int IR_roseLoop::step_size() const { SgForStatement *tf = isSgForStatement(tf_); SgFortranDo *tfortran = isSgFortranDo(tf_); if (tf) { SgExpression *increment = tf->get_increment(); if (isSgPlusPlusOp(increment)) return 1; if (isSgMinusMinusOp(increment)) return -1; else if (SgAssignOp* assignment = isSgAssignOp(increment)) { SgBinaryOp* stepsize = isSgBinaryOp(assignment->get_lhs_operand()); if (stepsize == NULL) throw ir_error("Step size expression is NULL!!"); SgIntVal* step = isSgIntVal(stepsize->get_lhs_operand()); return step->get_value(); } else if (SgBinaryOp* inc = isSgPlusAssignOp(increment)) { SgIntVal* step = isSgIntVal(inc->get_rhs_operand()); return (step->get_value()); } else if (SgBinaryOp * inc = isSgMinusAssignOp(increment)) { SgIntVal* step = isSgIntVal(inc->get_rhs_operand()); return -(step->get_value()); } else if (SgBinaryOp * inc = isSgCompoundAssignOp(increment)) { SgIntVal* step = isSgIntVal(inc->get_rhs_operand()); return (step->get_value()); } } else if (tfortran) { SgExpression* increment = tfortran->get_increment(); if (!isSgNullExpression(increment)) { if (isSgMinusOp(increment)) { if (SgValueExp *inc = isSgValueExp( isSgMinusOp(increment)->get_operand())) if (isSgIntVal(inc)) return -(isSgIntVal(inc)->get_value()); } else { if (SgValueExp* inc = isSgValueExp(increment)) if (isSgIntVal(inc)) return isSgIntVal(inc)->get_value(); } } else { return 1; // Manu:: if increment is not present, assume it to be 1. Just a workaround, not sure if it will be correct for all cases. SgExpression* lowerBound = NULL; SgExpression* upperBound = NULL; SgExpression* init = tfortran->get_initialization(); SgIntVal* ub; SgIntVal* lb; if (SgAssignOp* op = isSgAssignOp(init)) lowerBound = op->get_rhs_operand(); upperBound = tfortran->get_bound(); if ((upperBound != NULL) && (lowerBound != NULL)) { if ((ub = isSgIntVal(isSgValueExp(upperBound))) && (lb = isSgIntVal(isSgValueExp(lowerBound)))) { if (ub->get_value() > lb->get_value()) return 1; else return -1; } else throw ir_error("loop stop condition unsupported"); } else throw ir_error("loop stop condition unsupported"); } } } IR_Block *IR_roseLoop::convert() { const IR_Code *ir = ir_; SgNode *tnl = isSgNode(tf_); delete this; return new IR_roseBlock(ir, tnl); } IR_Control *IR_roseLoop::clone() const { return new IR_roseLoop(ir_, tf_); } // ---------------------------------------------------------------------------- // Class: IR_roseBlock // ---------------------------------------------------------------------------- omega::CG_outputRepr *IR_roseBlock::original() const { omega::CG_outputRepr * tnl; if (isSgBasicBlock(tnl_)) { SgStatementPtrList *bb = new SgStatementPtrList(); SgStatementPtrList::iterator it; for (it = (isSgBasicBlock(tnl_)->get_statements()).begin(); it != (isSgBasicBlock(tnl_)->get_statements()).end() && (*it != start_); it++) ; if (it != (isSgBasicBlock(tnl_)->get_statements()).end()) { for (; it != (isSgBasicBlock(tnl_)->get_statements()).end(); it++) { bb->push_back(*it); if ((*it) == end_) break; } } tnl = new omega::CG_roseRepr(bb); } else { tnl = new omega::CG_roseRepr(tnl_); } return tnl; } omega::CG_outputRepr *IR_roseBlock::extract() const { std::string x = tnl_->unparseToString(); omega::CG_roseRepr * tnl; omega::CG_outputRepr* block; if (isSgBasicBlock(tnl_)) { SgStatementPtrList *bb = new SgStatementPtrList(); SgStatementPtrList::iterator it; for (it = (isSgBasicBlock(tnl_)->get_statements()).begin(); it != (isSgBasicBlock(tnl_)->get_statements()).end() && (*it != start_); it++) ; if (it != (isSgBasicBlock(tnl_)->get_statements()).end()) { for (; it != (isSgBasicBlock(tnl_)->get_statements()).end(); it++) { bb->push_back(*it); if ((*it) == end_) break; } } tnl = new omega::CG_roseRepr(bb); block = tnl->clone(); } else { tnl = new omega::CG_roseRepr(tnl_); block = tnl->clone(); } delete tnl; return block; } IR_Control *IR_roseBlock::clone() const { return new IR_roseBlock(ir_, tnl_, start_, end_); } // ---------------------------------------------------------------------------- // Class: IR_roseIf // ---------------------------------------------------------------------------- omega::CG_outputRepr *IR_roseIf::condition() const { SgNode *tnl = isSgNode(isSgIfStmt(ti_)->get_conditional()); SgExpression* exp = NULL; if (SgExprStatement* stmt = isSgExprStatement(tnl)) exp = stmt->get_expression(); if (exp == NULL) return new omega::CG_roseRepr(tnl); else return new omega::CG_roseRepr(exp); } IR_Block *IR_roseIf::then_body() const { SgNode *tnl = isSgNode(isSgIfStmt(ti_)->get_true_body()); if (tnl == NULL) return NULL; return new IR_roseBlock(ir_, tnl); } IR_Block *IR_roseIf::else_body() const { SgNode *tnl = isSgNode(isSgIfStmt(ti_)->get_false_body()); if (tnl == NULL) return NULL; return new IR_roseBlock(ir_, tnl); } IR_Block *IR_roseIf::convert() { const IR_Code *ir = ir_; delete this; return new IR_roseBlock(ir, ti_); } IR_Control *IR_roseIf::clone() const { return new IR_roseIf(ir_, ti_); } // -----------------------------------------------------------y----------------- // Class: IR_roseCode_Global_Init // ---------------------------------------------------------------------------- IR_roseCode_Global_Init *IR_roseCode_Global_Init::pinstance = 0; IR_roseCode_Global_Init * IR_roseCode_Global_Init::Instance(char** argv) { if (pinstance == 0) { pinstance = new IR_roseCode_Global_Init; pinstance->project = frontend(2, argv); } return pinstance; } // ---------------------------------------------------------------------------- // Class: IR_roseCode // ---------------------------------------------------------------------------- IR_roseCode::IR_roseCode(const char *filename, const char* proc_name) : IR_Code() { SgProject* project; char* argv[2]; int counter = 0; argv[0] = (char*) malloc(5 * sizeof(char)); argv[1] = (char*) malloc((strlen(filename) + 1) * sizeof(char)); strcpy(argv[0], "rose"); strcpy(argv[1], filename); project = (IR_roseCode_Global_Init::Instance(argv))->project; firstScope = getFirstGlobalScope(project); SgFilePtrList& file_list = project->get_fileList(); for (SgFilePtrList::iterator it = file_list.begin(); it != file_list.end(); it++) { file = isSgSourceFile(*it); if (file->get_outputLanguage() == SgFile::e_Fortran_output_language) is_fortran_ = true; else is_fortran_ = false; root = file->get_globalScope(); if (!is_fortran_) { // Manu:: this macro should not be created if the input code is in fortran buildCpreprocessorDefineDeclaration(root, "#define __rose_lt(x,y) ((x)<(y)?(x):(y))", PreprocessingInfo::before); buildCpreprocessorDefineDeclaration(root, "#define __rose_gt(x,y) ((x)>(y)?(x):(y))", PreprocessingInfo::before); } symtab_ = isSgScopeStatement(root)->get_symbol_table(); SgDeclarationStatementPtrList& declList = root->get_declarations(); p = declList.begin(); while (p != declList.end()) { func = isSgFunctionDeclaration(*p); if (func) { if (!strcmp((func->get_name().getString()).c_str(), proc_name)) break; } p++; counter++; } if (p != declList.end()) break; } symtab2_ = func->get_definition()->get_symbol_table(); symtab3_ = func->get_definition()->get_body()->get_symbol_table(); // Manu:: added is_fortran_ parameter // TODO Substitute it with a better builder ocg_ = new omega::CG_roseBuilder(is_fortran_, root, firstScope, func->get_definition()->get_symbol_table(), func->get_definition()->get_body()->get_symbol_table(), isSgNode(func->get_definition()->get_body())); i_ = 0; /*i_ handling may need revision */ free(argv[1]); free(argv[0]); } IR_roseCode::~IR_roseCode() { } void IR_roseCode::finalizeRose() { SgProject* project = (IR_roseCode_Global_Init::Instance(NULL))->project; project->unparse(); } IR_ScalarSymbol *IR_roseCode::CreateScalarSymbol(const IR_Symbol *sym, int) { char str1[14]; if (typeid(*sym) == typeid(IR_roseScalarSymbol)) { SgType *tn = static_cast(sym)->vs_->get_type(); sprintf(str1, "newVariable%i", i_); SgVariableDeclaration* defn = buildVariableDeclaration(str1, tn); i_++; SgInitializedNamePtrList& variables = defn->get_variables(); SgInitializedNamePtrList::const_iterator i = variables.begin(); SgInitializedName* initializedName = *i; SgVariableSymbol* vs = new SgVariableSymbol(initializedName); prependStatement(defn, isSgScopeStatement(func->get_definition()->get_body())); vs->set_parent(symtab_); symtab_->insert(str1, vs); if (vs == NULL) throw ir_error("in CreateScalarSymbol: vs is NULL!!"); return new IR_roseScalarSymbol(this, vs); } else if (typeid(*sym) == typeid(IR_roseArraySymbol)) { SgType *tn1 = static_cast(sym)->vs_->get_type(); while (isSgArrayType(tn1) || isSgPointerType(tn1)) { if (isSgArrayType(tn1)) tn1 = isSgArrayType(tn1)->get_base_type(); else if (isSgPointerType(tn1)) tn1 = isSgPointerType(tn1)->get_base_type(); else throw ir_error( "in CreateScalarSymbol: symbol not an array nor a pointer!"); } sprintf(str1, "newVariable%i", i_); i_++; SgVariableDeclaration* defn1 = buildVariableDeclaration(str1, tn1); SgInitializedNamePtrList& variables1 = defn1->get_variables(); SgInitializedNamePtrList::const_iterator i1 = variables1.begin(); SgInitializedName* initializedName1 = *i1; SgVariableSymbol *vs1 = new SgVariableSymbol(initializedName1); prependStatement(defn1, isSgScopeStatement(func->get_definition()->get_body())); vs1->set_parent(symtab_); symtab_->insert(str1, vs1); if (vs1 == NULL) throw ir_error("in CreateScalarSymbol: vs1 is NULL!!"); return new IR_roseScalarSymbol(this, vs1); } else throw std::bad_typeid(); } IR_ArraySymbol *IR_roseCode::CreateArraySymbol(const IR_Symbol *sym, std::vector &size, int) { SgType *tn; char str1[14]; if (typeid(*sym) == typeid(IR_roseScalarSymbol)) { tn = static_cast(sym)->vs_->get_type(); } else if (typeid(*sym) == typeid(IR_roseArraySymbol)) { tn = static_cast(sym)->vs_->get_type(); while (isSgArrayType(tn) || isSgPointerType(tn)) { if (isSgArrayType(tn)) tn = isSgArrayType(tn)->get_base_type(); else if (isSgPointerType(tn)) tn = isSgPointerType(tn)->get_base_type(); else throw ir_error( "in CreateScalarSymbol: symbol not an array nor a pointer!"); } } else throw std::bad_typeid(); // Manu:: Fortran support std::vectorexprs; SgExprListExp *exprLstExp; SgExpression* sizeExpression = new SgNullExpression(); SgArrayType* arrayType = new SgArrayType(tn,sizeExpression); sizeExpression->set_parent(arrayType); if (!is_fortran_) { for (int i = size.size() - 1; i >= 0; i--) { tn = buildArrayType(tn,static_cast(size[i])->GetExpression()); } } else { // Manu:: required for fortran support for (int i = size.size() - 1; i >= 0; i--) { exprs.push_back(static_cast(size[i])->GetExpression()); } } if (is_fortran_) { exprLstExp = buildExprListExp(exprs); arrayType->set_dim_info(exprLstExp); exprLstExp->set_parent(arrayType); arrayType->set_rank(exprLstExp->get_expressions().size()); } static int rose_array_counter = 1; SgVariableDeclaration* defn2; std::string s; if (!is_fortran_) { s = std::string("_P") + omega::to_string(rose_array_counter++); defn2 = buildVariableDeclaration(const_cast(s.c_str()), tn); } else {// Manu:: fortran support s = std::string("f_P") + omega::to_string(rose_array_counter++); defn2 = buildVariableDeclaration(const_cast(s.c_str()), arrayType); } SgInitializedNamePtrList& variables2 = defn2->get_variables(); SgInitializedNamePtrList::const_iterator i2 = variables2.begin(); SgInitializedName* initializedName2 = *i2; SgVariableSymbol *vs = new SgVariableSymbol(initializedName2); prependStatement(defn2, isSgScopeStatement(func->get_definition()->get_body())); vs->set_parent(symtab_); symtab_->insert(SgName(s.c_str()), vs); return new IR_roseArraySymbol(this, vs); } IR_ScalarRef *IR_roseCode::CreateScalarRef(const IR_ScalarSymbol *sym) { return new IR_roseScalarRef(this, buildVarRefExp(static_cast(sym)->vs_)); } IR_ArrayRef *IR_roseCode::CreateArrayRef(const IR_ArraySymbol *sym, std::vector &index) { int t; if (sym->n_dim() != index.size()) throw std::invalid_argument("incorrect array symbol dimensionality"); const IR_roseArraySymbol *l_sym = static_cast(sym); SgVariableSymbol *vs = l_sym->vs_; SgExpression* ia1 = buildVarRefExp(vs); if (is_fortran_) { // Manu:: fortran support std::vectorexprs; for (int i = 0 ; i < index.size(); i++) { exprs.push_back(static_cast(index[i])->GetExpression()); } SgExprListExp *exprLstExp; exprLstExp = buildExprListExp(exprs); ia1 = buildPntrArrRefExp(ia1,exprLstExp); } else { for (int i = 0; i < index.size(); i++) { ia1 = buildPntrArrRefExp(ia1, static_cast(index[i])->GetExpression()); } } SgPntrArrRefExp *ia = isSgPntrArrRefExp(ia1); return new IR_roseArrayRef(this, ia, -1); } std::vector IR_roseCode::FindScalarRef( const omega::CG_outputRepr *repr) const { std::vector scalars; SgNode *tnl = static_cast(repr)->GetCode(); SgStatementPtrList *list = static_cast(repr)->GetList(); SgStatement* stmt; SgExpression * exp; if (list != NULL) { for (SgStatementPtrList::iterator it = (*list).begin(); it != (*list).end(); it++) { omega::CG_roseRepr *r = new omega::CG_roseRepr(isSgNode(*it)); std::vector a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); } } else if (tnl != NULL) { if (stmt = isSgStatement(tnl)) { if (isSgBasicBlock(stmt)) { SgStatementPtrList& stmts = isSgBasicBlock(stmt)->get_statements(); for (int i = 0; i < stmts.size(); i++) { omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgNode(stmts[i])); std::vector a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); } } else if (isSgForStatement(stmt)) { SgForStatement *tnf = isSgForStatement(stmt); omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgStatement(tnf->get_loop_body())); std::vector a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); } else if (isSgFortranDo(stmt)) { SgFortranDo *tfortran = isSgFortranDo(stmt); omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgStatement(tfortran->get_body())); std::vector a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); } else if (isSgIfStmt(stmt)) { SgIfStmt* tni = isSgIfStmt(stmt); omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgNode(tni->get_conditional())); std::vector a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); r = new omega::CG_roseRepr(isSgNode(tni->get_true_body())); a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); r = new omega::CG_roseRepr(isSgNode(tni->get_false_body())); a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); } else if (isSgExprStatement(stmt)) { omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgExpression( isSgExprStatement(stmt)->get_expression())); std::vector a = FindScalarRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(scalars)); } } } else { SgExpression* op = static_cast(repr)->GetExpression(); if (isSgVarRefExp(op) && (!isSgArrayType(isSgVarRefExp(op)->get_type()))) { if (SgBinaryOp* op_ = isSgBinaryOp( isSgVarRefExp(op)->get_parent())) { if (SgCompoundAssignOp *op__ = isSgCompoundAssignOp(op_)) { if (isSgCompoundAssignOp(op_)->get_lhs_operand() == isSgVarRefExp(op)) { scalars.push_back( new IR_roseScalarRef(this, isSgVarRefExp(op), 1)); scalars.push_back( new IR_roseScalarRef(this, isSgVarRefExp(op), 0)); } } } else if (SgAssignOp* assmt = isSgAssignOp( isSgVarRefExp(op)->get_parent())) { if (assmt->get_lhs_operand() == isSgVarRefExp(op)) scalars.push_back( new IR_roseScalarRef(this, isSgVarRefExp(op), 1)); } else if (SgAssignOp * assmt = isSgAssignOp( isSgVarRefExp(op)->get_parent())) { if (assmt->get_rhs_operand() == isSgVarRefExp(op)) scalars.push_back( new IR_roseScalarRef(this, isSgVarRefExp(op), 0)); } else scalars.push_back( new IR_roseScalarRef(this, isSgVarRefExp(op), 0)); } else if (isSgAssignOp(op)) { omega::CG_roseRepr *r1 = new omega::CG_roseRepr( isSgAssignOp(op)->get_lhs_operand()); std::vector a1 = FindScalarRef(r1); delete r1; std::copy(a1.begin(), a1.end(), back_inserter(scalars)); omega::CG_roseRepr *r2 = new omega::CG_roseRepr( isSgAssignOp(op)->get_rhs_operand()); std::vector a2 = FindScalarRef(r2); delete r2; std::copy(a2.begin(), a2.end(), back_inserter(scalars)); } else if (isSgBinaryOp(op)) { omega::CG_roseRepr *r1 = new omega::CG_roseRepr( isSgBinaryOp(op)->get_lhs_operand()); std::vector a1 = FindScalarRef(r1); delete r1; std::copy(a1.begin(), a1.end(), back_inserter(scalars)); omega::CG_roseRepr *r2 = new omega::CG_roseRepr( isSgBinaryOp(op)->get_rhs_operand()); std::vector a2 = FindScalarRef(r2); delete r2; std::copy(a2.begin(), a2.end(), back_inserter(scalars)); } else if (isSgUnaryOp(op)) { omega::CG_roseRepr *r1 = new omega::CG_roseRepr( isSgUnaryOp(op)->get_operand()); std::vector a1 = FindScalarRef(r1); delete r1; std::copy(a1.begin(), a1.end(), back_inserter(scalars)); } } return scalars; } std::vector IR_roseCode::FindArrayRef( const omega::CG_outputRepr *repr) const { std::vector arrays; SgNode *tnl = static_cast(repr)->GetCode(); SgStatementPtrList* list = static_cast(repr)->GetList(); SgStatement* stmt; SgExpression * exp; if (list != NULL) { for (SgStatementPtrList::iterator it = (*list).begin(); it != (*list).end(); it++) { omega::CG_roseRepr *r = new omega::CG_roseRepr(isSgNode(*it)); std::vector a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); } } else if (tnl != NULL) { if (stmt = isSgStatement(tnl)) { if (isSgBasicBlock(stmt)) { SgStatementPtrList& stmts = isSgBasicBlock(stmt)->get_statements(); for (int i = 0; i < stmts.size(); i++) { omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgNode(stmts[i])); std::vector a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); } } else if (isSgForStatement(stmt)) { SgForStatement *tnf = isSgForStatement(stmt); omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgStatement(tnf->get_loop_body())); std::vector a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); } else if (isSgFortranDo(stmt)) { SgFortranDo *tfortran = isSgFortranDo(stmt); omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgStatement(tfortran->get_body())); std::vector a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); } else if (isSgIfStmt(stmt)) { SgIfStmt* tni = isSgIfStmt(stmt); omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgNode(tni->get_conditional())); std::vector a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); r = new omega::CG_roseRepr(isSgNode(tni->get_true_body())); a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); r = new omega::CG_roseRepr(isSgNode(tni->get_false_body())); a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); } else if (isSgExprStatement(stmt)) { omega::CG_roseRepr *r = new omega::CG_roseRepr( isSgExpression( isSgExprStatement(stmt)->get_expression())); std::vector a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); } } } else { SgExpression* op = static_cast(repr)->GetExpression(); if (isSgPntrArrRefExp(op)) { SgVarRefExp* base; SgExpression* op2; if (isSgCompoundAssignOp(isSgPntrArrRefExp(op)->get_parent())) { IR_roseArrayRef *ref1 = new IR_roseArrayRef(this, isSgPntrArrRefExp(op), 0); arrays.push_back(ref1); IR_roseArrayRef *ref2 = new IR_roseArrayRef(this, isSgPntrArrRefExp(op), 1); arrays.push_back(ref2); } else { IR_roseArrayRef *ref3 = new IR_roseArrayRef(this, isSgPntrArrRefExp(op), -1); arrays.push_back(ref3); while (isSgPntrArrRefExp(op)) { op2 = isSgPntrArrRefExp(op)->get_rhs_operand(); op = isSgPntrArrRefExp(op)->get_lhs_operand(); omega::CG_roseRepr *r = new omega::CG_roseRepr(op2); std::vector a = FindArrayRef(r); delete r; std::copy(a.begin(), a.end(), back_inserter(arrays)); } } } else if (isSgAssignOp(op)) { omega::CG_roseRepr *r1 = new omega::CG_roseRepr( isSgAssignOp(op)->get_lhs_operand()); std::vector a1 = FindArrayRef(r1); delete r1; std::copy(a1.begin(), a1.end(), back_inserter(arrays)); omega::CG_roseRepr *r2 = new omega::CG_roseRepr( isSgAssignOp(op)->get_rhs_operand()); std::vector a2 = FindArrayRef(r2); delete r2; std::copy(a2.begin(), a2.end(), back_inserter(arrays)); } else if (isSgBinaryOp(op)) { omega::CG_roseRepr *r1 = new omega::CG_roseRepr( isSgBinaryOp(op)->get_lhs_operand()); std::vector a1 = FindArrayRef(r1); delete r1; std::copy(a1.begin(), a1.end(), back_inserter(arrays)); omega::CG_roseRepr *r2 = new omega::CG_roseRepr( isSgBinaryOp(op)->get_rhs_operand()); std::vector a2 = FindArrayRef(r2); delete r2; std::copy(a2.begin(), a2.end(), back_inserter(arrays)); } else if (isSgUnaryOp(op)) { omega::CG_roseRepr *r1 = new omega::CG_roseRepr( isSgUnaryOp(op)->get_operand()); std::vector a1 = FindArrayRef(r1); delete r1; std::copy(a1.begin(), a1.end(), back_inserter(arrays)); } } return arrays; } std::vector IR_roseCode::FindOneLevelControlStructure( const IR_Block *block) const { std::vector controls; int i; int j; int begin; int end; SgNode* tnl_ = ((static_cast(const_cast(block)))->tnl_); if (isSgForStatement(tnl_)) controls.push_back(new IR_roseLoop(this, tnl_)); else if (isSgFortranDo(tnl_)) controls.push_back(new IR_roseLoop(this, tnl_)); else if (isSgIfStmt(tnl_)) controls.push_back(new IR_roseIf(this, tnl_)); else if (isSgBasicBlock(tnl_)) { SgStatementPtrList& stmts = isSgBasicBlock(tnl_)->get_statements(); for (i = 0; i < stmts.size(); i++) { if (isSgNode(stmts[i]) == ((static_cast(const_cast(block)))->start_)) begin = i; if (isSgNode(stmts[i]) == ((static_cast(const_cast(block)))->end_)) end = i; } SgNode* start = NULL; SgNode* prev = NULL; for (i = begin; i <= end; i++) { if (isSgForStatement(stmts[i]) || isSgFortranDo(stmts[i])) { if (start != NULL) { controls.push_back( new IR_roseBlock(this, (static_cast(const_cast(block)))->tnl_, start, prev)); start = NULL; } controls.push_back(new IR_roseLoop(this, isSgNode(stmts[i]))); } else if (isSgIfStmt(stmts[i])) { if (start != NULL) { controls.push_back( new IR_roseBlock(this, (static_cast(const_cast(block)))->tnl_, start, prev)); start = NULL; } controls.push_back(new IR_roseIf(this, isSgNode(stmts[i]))); } else if (start == NULL) start = isSgNode(stmts[i]); prev = isSgNode(stmts[i]); } if ((start != NULL) && (start != isSgNode(stmts[begin]))) controls.push_back( new IR_roseBlock(this, (static_cast(const_cast(block)))->tnl_, start, prev)); } return controls; } IR_Block *IR_roseCode::MergeNeighboringControlStructures( const std::vector &controls) const { if (controls.size() == 0) return NULL; SgNode *tnl = NULL; SgNode *start, *end; for (int i = 0; i < controls.size(); i++) { switch (controls[i]->type()) { case IR_CONTROL_LOOP: { SgNode *tf = static_cast(controls[i])->tf_; if (tnl == NULL) { tnl = tf->get_parent(); start = end = tf; } else { if (tnl != tf->get_parent()) throw ir_error("controls to merge not at the same level"); end = tf; } break; } case IR_CONTROL_BLOCK: { if (tnl == NULL) { tnl = static_cast(controls[0])->tnl_; start = static_cast(controls[0])->start_; end = static_cast(controls[0])->end_; } else { if (tnl != static_cast(controls[0])->tnl_) throw ir_error("controls to merge not at the same level"); end = static_cast(controls[0])->end_; } break; } default: throw ir_error("unrecognized control to merge"); } } return new IR_roseBlock(controls[0]->ir_, tnl, start, end); } IR_Block *IR_roseCode::GetCode() const { SgFunctionDefinition* def = NULL; SgBasicBlock* block = NULL; if (func != 0) { if (def = func->get_definition()) { if (block = def->get_body()) return new IR_roseBlock(this, func->get_definition()->get_body()); } } return NULL; } void IR_roseCode::ReplaceCode(IR_Control *old, omega::CG_outputRepr *repr) { /* SgStatementPtrList *tnl = static_cast(repr)->GetList(); SgNode *tf_old; */ SgStatementPtrList *tnl = static_cast(repr)->GetList(); SgNode* node_ = static_cast(repr)->GetCode(); SgNode * tf_old; /* May need future revision it tnl has more than one statement */ switch (old->type()) { case IR_CONTROL_LOOP: tf_old = static_cast(old)->tf_; break; case IR_CONTROL_BLOCK: tf_old = static_cast(old)->start_; break; default: throw ir_error("control structure to be replaced not supported"); break; } std::string y = tf_old->unparseToString(); SgStatement *s = isSgStatement(tf_old); if (s != 0) { SgStatement *p = isSgStatement(tf_old->get_parent()); if (p != 0) { SgStatement* temp = s; if (tnl != NULL) { SgStatementPtrList::iterator it = (*tnl).begin(); p->insert_statement(temp, *it, true); temp = *it; p->remove_statement(s); it++; for (; it != (*tnl).end(); it++) { p->insert_statement(temp, *it, false); temp = *it; } } else if (node_ != NULL) { if (!isSgStatement(node_)) throw ir_error("Replacing Code not a statement!"); else { SgStatement* replace_ = isSgStatement(node_); p->insert_statement(s, replace_, true); p->remove_statement(s); } } else { throw ir_error("Replacing Code not a statement!"); } } else throw ir_error("Replacing Code not a statement!"); } else throw ir_error("Replacing Code not a statement!"); delete old; delete repr; /* May need future revision it tnl has more than one statement */ /* switch (old->type()) { case IR_CONTROL_LOOP: tf_old = static_cast(old)->tf_; break; case IR_CONTROL_BLOCK: tf_old = static_cast(old)->start_; break; default: throw ir_error("control structure to be replaced not supported"); break; } // std::string y = tf_old->unparseToString(); SgStatement *s = isSgStatement(tf_old); if (s != 0) { SgStatement *p = isSgStatement(tf_old->get_parent()); if (p != 0) { // SgStatement* it2 = isSgStatement(tnl); // if(it2 != NULL){ p->replace_statement(s, *tnl); // } // else { // throw ir_error("Replacing Code not a statement!"); // } } else throw ir_error("Replacing Code not a statement!"); } else throw ir_error("Replacing Code not a statement!"); // y = tnl->unparseToString(); delete old; delete repr; */ } void IR_roseCode::ReplaceExpression(IR_Ref *old, omega::CG_outputRepr *repr) { SgExpression* op = static_cast(repr)->GetExpression(); if (typeid(*old) == typeid(IR_roseArrayRef)) { SgPntrArrRefExp* ia_orig = static_cast(old)->ia_; SgExpression* parent = isSgExpression(isSgNode(ia_orig)->get_parent()); std::string x = isSgNode(op)->unparseToString(); std::string y = isSgNode(ia_orig)->unparseToString(); if (parent != NULL) { std::string z = isSgNode(parent)->unparseToString(); parent->replace_expression(ia_orig, op); isSgNode(op)->set_parent(isSgNode(parent)); /* if(isSgBinaryOp(parent)) { if(isSgBinaryOp(parent)->get_lhs_operand() == ia_orig){ isSgBinaryOp(parent)->set_lhs_operand(op); }else if(isSgBinaryOp(parent)->get_rhs_operand() == ia_orig){ isSgBinaryOp(parent)->set_rhs_operand(op); } else parent->replace_expression(ia_orig, op); */ } else { SgStatement* parent_stmt = isSgStatement( isSgNode(ia_orig)->get_parent()); if (parent_stmt != NULL) parent_stmt->replace_expression(ia_orig, op); else throw ir_error( "ReplaceExpression: parent neither expression nor statement"); } } else throw ir_error("replacing a scalar variable not implemented"); delete old; } IR_OPERATION_TYPE IR_roseCode::QueryExpOperation( const omega::CG_outputRepr *repr) const { SgExpression* op = static_cast(repr)->GetExpression(); if (isSgValueExp(op)) return IR_OP_CONSTANT; else if (isSgVarRefExp(op) || isSgPntrArrRefExp(op)) return IR_OP_VARIABLE; else if (isSgAssignOp(op) || isSgCompoundAssignOp(op)) return IR_OP_ASSIGNMENT; else if (isSgAddOp(op)) return IR_OP_PLUS; else if (isSgSubtractOp(op)) return IR_OP_MINUS; else if (isSgMultiplyOp(op)) return IR_OP_MULTIPLY; else if (isSgDivideOp(op)) return IR_OP_DIVIDE; else if (isSgMinusOp(op)) return IR_OP_NEGATIVE; else if (isSgConditionalExp(op)) { SgExpression* cond = isSgConditionalExp(op)->get_conditional_exp(); if (isSgGreaterThanOp(cond)) return IR_OP_MAX; else if (isSgLessThanOp(cond)) return IR_OP_MIN; } else if (isSgUnaryAddOp(op)) return IR_OP_POSITIVE; else if (isSgNullExpression(op)) return IR_OP_NULL; else return IR_OP_UNKNOWN; } IR_CONDITION_TYPE IR_roseCode::QueryBooleanExpOperation( const omega::CG_outputRepr *repr) const { SgExpression* op2 = static_cast(repr)->GetExpression(); SgNode* op; if (op2 == NULL) { op = static_cast(repr)->GetCode(); if (op != NULL) { if (isSgExprStatement(op)) op2 = isSgExprStatement(op)->get_expression(); else return IR_COND_UNKNOWN; } else return IR_COND_UNKNOWN; } if (isSgEqualityOp(op2)) return IR_COND_EQ; else if (isSgNotEqualOp(op2)) return IR_COND_NE; else if (isSgLessThanOp(op2)) return IR_COND_LT; else if (isSgLessOrEqualOp(op2)) return IR_COND_LE; else if (isSgGreaterThanOp(op2)) return IR_COND_GT; else if (isSgGreaterOrEqualOp(op2)) return IR_COND_GE; return IR_COND_UNKNOWN; } std::vector IR_roseCode::QueryExpOperand( const omega::CG_outputRepr *repr) const { std::vector v; SgExpression* op1; SgExpression* op2; SgExpression* op = static_cast(repr)->GetExpression(); omega::CG_roseRepr *repr1; if (isSgValueExp(op) || isSgVarRefExp(op)) { omega::CG_roseRepr *repr = new omega::CG_roseRepr(op); v.push_back(repr); } else if (isSgAssignOp(op)) { op1 = isSgAssignOp(op)->get_rhs_operand(); repr1 = new omega::CG_roseRepr(op1); v.push_back(repr1); /*may be a problem as assignOp is a binaryop destop might be needed */ } else if (isSgMinusOp(op)) { op1 = isSgMinusOp(op)->get_operand(); repr1 = new omega::CG_roseRepr(op1); v.push_back(repr1); } else if (isSgUnaryAddOp(op)) { op1 = isSgUnaryAddOp(op)->get_operand(); repr1 = new omega::CG_roseRepr(op1); v.push_back(repr1); } else if ((isSgAddOp(op) || isSgSubtractOp(op)) || (isSgMultiplyOp(op) || isSgDivideOp(op))) { op1 = isSgBinaryOp(op)->get_lhs_operand(); repr1 = new omega::CG_roseRepr(op1); v.push_back(repr1); op2 = isSgBinaryOp(op)->get_rhs_operand(); repr1 = new omega::CG_roseRepr(op2); v.push_back(repr1); } else if (isSgConditionalExp(op)) { SgExpression* cond = isSgConditionalExp(op)->get_conditional_exp(); op1 = isSgBinaryOp(cond)->get_lhs_operand(); repr1 = new omega::CG_roseRepr(op1); v.push_back(repr1); op2 = isSgBinaryOp(cond)->get_rhs_operand(); repr1 = new omega::CG_roseRepr(op2); v.push_back(repr1); } else if (isSgCompoundAssignOp(op)) { SgExpression* cond = isSgCompoundAssignOp(op); op1 = isSgBinaryOp(cond)->get_lhs_operand(); repr1 = new omega::CG_roseRepr(op1); v.push_back(repr1); op2 = isSgBinaryOp(cond)->get_rhs_operand(); repr1 = new omega::CG_roseRepr(op2); v.push_back(repr1); } else if (isSgBinaryOp(op)) { op1 = isSgBinaryOp(op)->get_lhs_operand(); repr1 = new omega::CG_roseRepr(op1); v.push_back(repr1); op2 = isSgBinaryOp(op)->get_rhs_operand(); repr1 = new omega::CG_roseRepr(op2); v.push_back(repr1); } else throw ir_error("operation not supported"); return v; } IR_Ref *IR_roseCode::Repr2Ref(const omega::CG_outputRepr *repr) const { SgExpression* op = static_cast(repr)->GetExpression(); if (SgValueExp* im = isSgValueExp(op)) { if (isSgIntVal(im)) return new IR_roseConstantRef(this, static_cast(isSgIntVal(im)->get_value())); else if (isSgUnsignedIntVal(im)) return new IR_roseConstantRef(this, static_cast(isSgUnsignedIntVal(im)->get_value())); else if (isSgLongIntVal(im)) return new IR_roseConstantRef(this, static_cast(isSgLongIntVal(im)->get_value())); else if (isSgFloatVal(im)) return new IR_roseConstantRef(this, isSgFloatVal(im)->get_value()); else assert(0); } else if (isSgVarRefExp(op)) return new IR_roseScalarRef(this, isSgVarRefExp(op)); else assert(0); }