Moved most modules into lib

1 files changed, 1756 insertions, 0 deletions

diff --git a/src/ir_rose.cc b/src/ir_rose.cc
new file mode 100644
index 0000000..dc3eed8
--- /dev/null
+++ b/src/ir_rose.cc
@@ -0,0 +1,1756 @@
+/*****************************************************************************
+ 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 <string>
+#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<const IR_roseScalarSymbol *>(&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<const IR_roseCode *>(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<const IR_roseCode *>(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<const IR_roseCode *>(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<const IR_roseArraySymbol *>(&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<const IR_roseConstantRef *>(&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<int>(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<const IR_roseScalarRef *>(&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<const IR_roseCode *>(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<const IR_roseArrayRef *>(&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<const IR_roseScalarSymbol *>(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<const IR_roseArraySymbol *>(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<omega::CG_outputRepr *> &size, int) {
+  SgType *tn;
+  char str1[14];
+  
+  if (typeid(*sym) == typeid(IR_roseScalarSymbol)) {
+    tn = static_cast<const IR_roseScalarSymbol *>(sym)->vs_->get_type();
+  } else if (typeid(*sym) == typeid(IR_roseArraySymbol)) {
+    tn = static_cast<const IR_roseArraySymbol *>(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::vector<SgExpression *>exprs;
+  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<omega::CG_roseRepr *>(size[i])->GetExpression());
+	  }
+  } else { // Manu:: required for fortran support
+	  for (int i = size.size() - 1; i >= 0; i--) {
+		exprs.push_back(static_cast<omega::CG_roseRepr *>(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<char *>(s.c_str()), tn);
+  } else {// Manu:: fortran support
+	  s = std::string("f_P") + omega::to_string(rose_array_counter++);
+	  defn2 = buildVariableDeclaration(const_cast<char *>(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<const IR_roseScalarSymbol *>(sym)->vs_));
+  
+}
+
+IR_ArrayRef *IR_roseCode::CreateArrayRef(const IR_ArraySymbol *sym,
+                                         std::vector<omega::CG_outputRepr *> &index) {
+  
+  int t;
+  
+  if (sym->n_dim() != index.size())
+    throw std::invalid_argument("incorrect array symbol dimensionality");
+  
+  const IR_roseArraySymbol *l_sym =
+    static_cast<const IR_roseArraySymbol *>(sym);
+  
+  SgVariableSymbol *vs = l_sym->vs_;
+  SgExpression* ia1 = buildVarRefExp(vs);
+  
+
+
+  if (is_fortran_) { // Manu:: fortran support
+	  std::vector<SgExpression *>exprs;
+	  for (int i = 0 ; i < index.size(); i++) {
+		exprs.push_back(static_cast<omega::CG_roseRepr *>(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<omega::CG_roseRepr *>(index[i])->GetExpression());
+    
+     }
+  }
+  
+  SgPntrArrRefExp *ia = isSgPntrArrRefExp(ia1);
+  
+  return new IR_roseArrayRef(this, ia, -1);
+  
+}
+
+std::vector<IR_ScalarRef *> IR_roseCode::FindScalarRef(
+  const omega::CG_outputRepr *repr) const {
+  std::vector<IR_ScalarRef *> scalars;
+  SgNode *tnl = static_cast<const omega::CG_roseRepr *>(repr)->GetCode();
+  SgStatementPtrList *list =
+    static_cast<const omega::CG_roseRepr *>(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<IR_ScalarRef *> 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<IR_ScalarRef *> 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<IR_ScalarRef *> 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<IR_ScalarRef *> 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<IR_ScalarRef *> 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<IR_ScalarRef *> a = FindScalarRef(r);
+        delete r;
+        std::copy(a.begin(), a.end(), back_inserter(scalars));
+        
+      }
+    }
+  } else {
+    SgExpression* op =
+      static_cast<const omega::CG_roseRepr *>(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<IR_ScalarRef *> 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<IR_ScalarRef *> 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<IR_ScalarRef *> 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<IR_ScalarRef *> 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<IR_ScalarRef *> a1 = FindScalarRef(r1);
+      delete r1;
+      std::copy(a1.begin(), a1.end(), back_inserter(scalars));
+    }
+    
+  }
+  return scalars;
+  
+}
+
+std::vector<IR_ArrayRef *> IR_roseCode::FindArrayRef(
+  const omega::CG_outputRepr *repr) const {
+  std::vector<IR_ArrayRef *> arrays;
+  SgNode *tnl = static_cast<const omega::CG_roseRepr *>(repr)->GetCode();
+  SgStatementPtrList* list =
+    static_cast<const omega::CG_roseRepr *>(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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> a = FindArrayRef(r);
+        delete r;
+        std::copy(a.begin(), a.end(), back_inserter(arrays));
+        
+      }
+    }
+  } else {
+    SgExpression* op =
+      static_cast<const omega::CG_roseRepr *>(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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> 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<IR_ArrayRef *> a1 = FindArrayRef(r1);
+      delete r1;
+      std::copy(a1.begin(), a1.end(), back_inserter(arrays));
+    }
+    
+  }
+  return arrays;
+}
+
+std::vector<IR_Control *> IR_roseCode::FindOneLevelControlStructure(
+  const IR_Block *block) const {
+
+  std::vector<IR_Control *> controls;
+  int i;
+  int j;
+  int begin;
+  int end;
+  SgNode* tnl_ =
+    ((static_cast<IR_roseBlock *>(const_cast<IR_Block *>(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<IR_roseBlock *>(const_cast<IR_Block *>(block)))->start_))
+        begin = i;
+      if (isSgNode(stmts[i])
+          == ((static_cast<IR_roseBlock *>(const_cast<IR_Block *>(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<IR_roseBlock *>(const_cast<IR_Block *>(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<IR_roseBlock *>(const_cast<IR_Block *>(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<IR_roseBlock *>(const_cast<IR_Block *>(block)))->tnl_,
+                         start, prev));
+  }
+  
+  return controls;
+  
+}
+
+IR_Block *IR_roseCode::MergeNeighboringControlStructures(
+  const std::vector<IR_Control *> &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<IR_roseLoop *>(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<IR_roseBlock *>(controls[0])->tnl_;
+        start = static_cast<IR_roseBlock *>(controls[0])->start_;
+        end = static_cast<IR_roseBlock *>(controls[0])->end_;
+      } else {
+        if (tnl != static_cast<IR_roseBlock *>(controls[0])->tnl_)
+          throw ir_error("controls to merge not at the same level");
+        end = static_cast<IR_roseBlock *>(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<omega::CG_roseRepr *>(repr)->GetList();
+        SgNode *tf_old;
+  */
+  SgStatementPtrList *tnl =
+    static_cast<omega::CG_roseRepr *>(repr)->GetList();
+  SgNode* node_ = static_cast<omega::CG_roseRepr *>(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<IR_roseLoop *>(old)->tf_;
+    break;
+  case IR_CONTROL_BLOCK:
+    tf_old = static_cast<IR_roseBlock *>(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<IR_roseLoop *>(old)->tf_;
+    break;
+    case IR_CONTROL_BLOCK:
+    tf_old = static_cast<IR_roseBlock *>(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<omega::CG_roseRepr *>(repr)->GetExpression();
+  
+  if (typeid(*old) == typeid(IR_roseArrayRef)) {
+    SgPntrArrRefExp* ia_orig = static_cast<IR_roseArrayRef *>(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<const omega::CG_roseRepr *>(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<const omega::CG_roseRepr *>(repr)->GetExpression();
+  SgNode* op;
+  
+  if (op2 == NULL) {
+    op = static_cast<const omega::CG_roseRepr *>(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<omega::CG_outputRepr *> IR_roseCode::QueryExpOperand(
+  const omega::CG_outputRepr *repr) const {
+  std::vector<omega::CG_outputRepr *> v;
+  SgExpression* op1;
+  SgExpression* op2;
+  SgExpression* op =
+    static_cast<const omega::CG_roseRepr *>(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<const omega::CG_roseRepr *>(repr)->GetExpression();
+  
+  if (SgValueExp* im = isSgValueExp(op)) {
+    if (isSgIntVal(im))
+      return new IR_roseConstantRef(this,
+                                    static_cast<omega::coef_t>(isSgIntVal(im)->get_value()));
+    else if (isSgUnsignedIntVal(im))
+      return new IR_roseConstantRef(this,
+                                    static_cast<omega::coef_t>(isSgUnsignedIntVal(im)->get_value()));
+    else if (isSgLongIntVal(im))
+      return new IR_roseConstantRef(this,
+                                    static_cast<omega::coef_t>(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);
+  
+}
+