something that only builds ...

1 files changed, 0 insertions, 1699 deletions

diff --git a/src/ir_rose.cc b/src/ir_rose.cc
deleted file mode 100644
index f4039ab..0000000
--- a/src/ir_rose.cc
+++ /dev/null
@@ -1,1699 +0,0 @@
-/*****************************************************************************
- 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 "code_gen/rose_attributes.h"
-#include "code_gen/CG_roseRepr.h"
-#include "code_gen/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) {
-		  ; // not sure if this case will happen
-	  }
-  }
-
-  return dim;
-}
-
-omega::CG_outputRepr *IR_roseArraySymbol::size(int dim) const {
-  
-  SgArrayType* arrType = isSgArrayType(vs_->get_type());
-  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* node_ = static_cast<omega::CG_roseRepr *>(repr)->GetCode();
-  SgNode * tf_old;
-  
-  /* May need future revision if 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;
-}
-
-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));
-    } 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);
-  
-}
-