something that only builds ...

3 files changed, 0 insertions, 1401 deletions

diff --git a/lib/rosecg/src/CG_roseBuilder.cc b/lib/rosecg/src/CG_roseBuilder.cc
deleted file mode 100644
index 8f7e3df..0000000
--- a/lib/rosecg/src/CG_roseBuilder.cc
+++ /dev/null
@@ -1,1093 +0,0 @@
-/*****************************************************************************
- Copyright (C) 2008 University of Southern California
- Copyright (C) 2009-2010 University of Utah
- All Rights Reserved.
-
- Purpose:
- generate suif code for omega
-
- Notes:
-
- History:
- 02/01/06 created by Chun Chen
- *****************************************************************************/
-
-#include <stack>
-#include "code_gen/CG_roseBuilder.h"
-#include <string>
-
-struct ir_error: public std::runtime_error {
-	ir_error(const std::string &msg) :
-			std::runtime_error(msg) {
-	}
-};
-
-using namespace SageBuilder;
-using namespace SageInterface;
-using namespace OmpSupport;
-
-namespace omega {
-
-//-----------------------------------------------------------------------------
-// make suif initilization happy
-//-----------------------------------------------------------------------------
-char *k_ocg_comment;
-
-CG_roseBuilder::CG_roseBuilder(int is_fortran, SgGlobal* global, SgGlobal* firstScope,
-		SgSymbolTable* symtab, SgSymbolTable* symtab2, SgNode* root) :
-		isFortran(is_fortran), global_(global), global_scope(firstScope), symtab_(symtab), symtab2_(
-				symtab2), root_(root) {
-}
-
-
-CG_roseBuilder::~CG_roseBuilder() {
-}
-
-// Manu:: returns true if input is in fortran, else returns false
-bool CG_roseBuilder::isInputFortran() const{
-	if (isFortran)
-		return true;
-	else
-		return false;
-}
-
-//-----------------------------------------------------------------------------
-// place holder generation
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt,
-		const std::vector<std::string> &vars, std::vector<CG_outputRepr*> &subs) const {
-
-	SgStatementPtrList* list = static_cast<CG_roseRepr *>(stmt)->list_;
-	SgNode *tnl;
-	SgStatement* statement;
-	if (list != NULL) {
-		delete stmt;
-		for (int i = 0; i < subs.size(); i++) {
-                  if (subs[i] == NULL)
-                        continue;
-
-			CG_roseRepr *repr = static_cast<CG_roseRepr*>(subs[i]);
-			SgExpression* op = repr->op_;
-
-			for (SgStatementPtrList::iterator it = (*list).begin();
-					it != (*list).end(); it++) {
-				statement = (*it);
-				tnl = isSgNode(statement);
-
-				int j;
-				int not_in_symtab_;
-
-				not_in_symtab_ = 0;
-
-				SgVariableSymbol *vs = symtab_->find_variable(
-						SgName(vars[i].c_str()));
-
-				if (vs == NULL) {
-
-					not_in_symtab_ = 1;
-
-					vs = symtab2_->find_variable(SgName(vars[i].c_str()));
-				}
-				if (vs != NULL) {
-
-					std::vector<SgVarRefExp *> array = substitute(tnl,
-							(const SgVariableSymbol*) vs, op, root_);
-					for (std::vector<SgVarRefExp *>::iterator it =
-							array.begin(); it != array.end(); it++) {
-
-						if (isSgVarRefExp(op)) {
-							if (strcmp(
-									isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(),
-									vs->get_name().getString().c_str())) {
-
-								(*it)->set_symbol(
-										isSgVarRefExp(op)->get_symbol());
-
-							}
-						} else if (isSgExpression(op)) {
-
-							if (isSgBinaryOp((*it)->get_parent()))
-								isSgBinaryOp((*it)->get_parent())->replace_expression(
-										*it, op);
-							else if (isSgUnaryOp((*it)->get_parent()))
-								isSgUnaryOp((*it)->get_parent())->replace_expression(
-										*it, op);
-							else if (isSgExprListExp((*it)->get_parent()))
-								isSgExprListExp((*it)->get_parent())->replace_expression(
-										*it, op);
-							else
-								throw ir_error("unrecognized expression type");
-						}
-
-					}
-				}
-
-			}
-
-			delete repr;
-			subs[i] = NULL;
-
-			if (subs[i] != NULL)
-				throw ir_error("not freed properly");
-
-		}
-
-		return new CG_roseRepr(list);
-
-	} else {
-		tnl = static_cast<CG_roseRepr *>(stmt)->tnl_;
-
-		if (tnl == NULL)
-			throw ir_error("both list and tnl are null!!");
-
-		delete stmt;
-		int j;
-		int not_in_symtab_;
-	 for (int i = 0; i < subs.size(); i++) {
-                if (subs[i] == NULL)
-                       continue;
-			not_in_symtab_ = 0;
-
-			
-			CG_roseRepr *repr = static_cast<CG_roseRepr*>(subs[i]);
-			SgExpression* op = repr->op_;
-			delete repr;
-			subs[i] = NULL;
-
-			SgVariableSymbol *vs = symtab_->find_variable(
-					SgName(vars[i].c_str()));
-
-			if (vs == NULL) {
-
-				not_in_symtab_ = 1;
-
-				vs = symtab2_->find_variable(SgName(vars[i].c_str()));
-			}
-			if (vs != NULL) {
-				std::vector<SgVarRefExp *> array = substitute(tnl, vs, op,
-						root_);
-
-				if (not_in_symtab_ && isSgVarRefExp(op)) {
-					if (strcmp(
-							isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(),
-							vs->get_name().getString().c_str())) {
-					}
-				}
-				
-				for (std::vector<SgVarRefExp *>::iterator j = array.begin();
-						j != array.end(); j++) {
-
-					if (isSgVarRefExp(op)) {
-						if (strcmp(
-								isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(),
-								vs->get_name().getString().c_str())) {
-							(*j)->set_symbol(isSgVarRefExp(op)->get_symbol());
-
-						}
-					} else if (isSgExpression(op)) {
-
-						if (isSgBinaryOp((*j)->get_parent()))
-							isSgBinaryOp((*j)->get_parent())->replace_expression(
-									*j, op);
-						else if (isSgUnaryOp((*j)->get_parent()))
-							isSgUnaryOp((*j)->get_parent())->replace_expression(
-									*j, op);
-						else if (isSgExprListExp((*j)->get_parent())) { // Manu:: fortran indices are stored this way
-							isSgExprListExp((*j)->get_parent())->replace_expression(*j, op);
-						}
-						else
-							throw ir_error("unrecognized expression type");
-
-					}
-
-				}
-			}
-		}
-		return new CG_roseRepr(tnl);
-	}
-
-}
-
-//-----------------------------------------------------------------------------
-// assignment generation
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateAssignment(int, CG_outputRepr *lhs,
-		CG_outputRepr *rhs) const {
-	if (lhs == NULL || rhs == NULL) {
-		fprintf(stderr, "Code generation: Missing lhs or rhs\n");
-		return NULL;
-	}
-
-	SgExpression* src = static_cast<CG_roseRepr*>(rhs)->op_;
-	SgExpression* dst = static_cast<CG_roseRepr*>(lhs)->op_;
-
-	SgExprStatement* ins = buildAssignStatement(dst, src);
-	src->set_parent(ins);
-	dst->set_parent(ins);
-
-	SgStatementPtrList* new_list = new SgStatementPtrList;
-
-	(*new_list).push_back(isSgStatement(ins));
-
-	delete lhs;
-	delete rhs;
-
-	return new CG_roseRepr(new_list);
-
-}
-
-//-----------------------------------------------------------------------------
-// function invocation generation
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateInvoke(const std::string &fname,
-		std::vector<CG_outputRepr *> &list) const {
-
-	if (fname == std::string("max") || fname == std::string("min")) {
-		if (list.size() == 0) {
-			return NULL;
-		} else if (list.size() == 1) {
-			 return list[0];
-		} else {
-			 int last = list.size() - 1;
-			SgExpression* op2 = static_cast<CG_roseRepr*>(list[last])->op_;
-			delete list[last];
-		    list.erase(list.end()-1);
-			CG_roseRepr *repr = static_cast<CG_roseRepr*>(CreateInvoke(fname,
-					list));
-			SgExpression* op1 = repr->op_;
-
-
-			SgExpression *ins;
-			SgExprListExp* arg_list = buildExprListExp();
-			appendExpression(arg_list, op1);
-			appendExpression(arg_list, op2);
-			SgVarRefExp* opaque_var;
-
-
-			if (fname == std::string("max")) {
-				opaque_var = buildOpaqueVarRefExp("__rose_gt", global_);
-				ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list));
-
-				// Manu:: fortran support
-				if (isInputFortran()) {
-					SgName fName("merge");
-					SgTypeInt *retType = buildIntType();
-
-					SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op2), new CG_roseRepr(op1)))->op_;
-		            appendExpression(arg_list, cond);
-					ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_));
-				}
-
-			} else {
-				opaque_var = buildOpaqueVarRefExp("__rose_lt", global_);
-				ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list));
-
-				// Manu:: fortran support
-				if (isInputFortran()) {
-					SgName fName("merge");
-					SgTypeInt *retType = buildIntType();
-
-					SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op1), new CG_roseRepr(op2)))->op_;
-		            appendExpression(arg_list, cond);
-					ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_));
-				}
-
-			}
-
-			repr->op_ = ins;
-			return repr;
-		}
-	} else {
-		fprintf(stderr,
-				"Code generation: invoke function io_call not implemented\n");
-		return NULL;
-	}
-
-}
-
-//-----------------------------------------------------------------------------
-// comment generation
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateComment(int,
-		const std::string &commentText) const {
-	if (commentText == std::string("")) {
-		return NULL;
-	}
-
-	SgLocatedNode *tnl = new SgLocatedNode();
-	buildComment(tnl, "//omega_comment: " + commentText);
-
-	return new CG_roseRepr(isSgNode(tnl));
-
-}
-
-//-----------------------------------------------------------------------------
-// if stmt gen operations
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateIf(int, CG_outputRepr *guardList,
-		CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const {
-
-	if (true_stmtList == NULL && false_stmtList == NULL) {
-		delete guardList;
-		return NULL;
-	} else if (guardList == NULL) {
-		return StmtListAppend(true_stmtList, false_stmtList);
-	}
-
-	SgExpression* header = static_cast<CG_roseRepr*>(guardList)->op_;
-
-	SgStatementPtrList *then_part1, *else_part1;
-	SgStatement* then_part;
-	SgStatement* else_part;
-	SgBasicBlock* then_part2;
-	SgBasicBlock* else_part2;
-	if (true_stmtList != NULL) {
-		then_part1 = static_cast<CG_roseRepr*>(true_stmtList)->list_;
-		if (then_part1 != NULL) {
-			then_part = *((*then_part1).begin());
-
-			if ((*then_part1).size() > 1) {
-				then_part2 = buildBasicBlock();
-				for (SgStatementPtrList::iterator it = (*then_part1).begin();
-						it != (*then_part1).end(); it++) {
-					then_part2->append_statement(*it);
-
-				}
-				then_part = isSgStatement(then_part2);
-
-			}
-		} else {
-			// Manu:: fortran support (if part)
-			if (isInputFortran()) {
-				then_part2 = buildBasicBlock();
-				then_part2->append_statement(isSgStatement(static_cast<CG_roseRepr*>(true_stmtList)->tnl_));
-				then_part = isSgStatement(then_part2);
-			} else
-				then_part = isSgStatement(static_cast<CG_roseRepr*>(true_stmtList)->tnl_);
-		}
-	} else {
-		then_part = NULL;
-	}
-	if (false_stmtList != NULL) {
-		else_part1 = static_cast<CG_roseRepr*>(false_stmtList)->list_;
-		if (else_part1 != NULL) {
-			else_part = *((*else_part1).begin());
-			if ((*else_part1).size() > 1) {
-				else_part2 = buildBasicBlock();
-				for (SgStatementPtrList::iterator it2 = (*else_part1).begin();
-						it2 != (*else_part1).end(); it2++) {
-					else_part2->append_statement(*it2);
-
-				}
-				else_part = isSgStatement(else_part2);
-
-			}
-		} else {
-			// Manu:: fortran support (if part)
-			if (isInputFortran()) {
-				else_part2 = buildBasicBlock();
-				else_part2->append_statement(isSgStatement(static_cast<CG_roseRepr*>(false_stmtList)->tnl_));
-				else_part = isSgStatement(else_part2);
-			} else
-				else_part = isSgStatement(static_cast<CG_roseRepr*>(false_stmtList)->tnl_);
-		}
-	} else {
-		else_part = NULL;
-	}
-
-	SgIfStmt* ti = buildIfStmt(header, isSgStatement(then_part),
-			isSgStatement(else_part));
-
-	delete guardList;
-	delete true_stmtList;
-	delete false_stmtList;
-
-	return new CG_roseRepr(isSgNode(ti));
-
-}
-
-//-----------------------------------------------------------------------------
-// inductive variable generation, to be used in CreateLoop as control
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateInductive(CG_outputRepr *index,
-		CG_outputRepr *lower, CG_outputRepr *upper, CG_outputRepr *step) const {
-
-	if (index == NULL || lower == NULL || upper == NULL) {
-		fprintf(stderr,
-				"Code generation: something wrong in CreateInductive\n");
-		return NULL;
-	}
-
-	if (step == NULL)
-		step = new CG_roseRepr(isSgExpression(buildIntVal(1)));
-
-	SgVarRefExp *index_sym = isSgVarRefExp(
-			static_cast<CG_roseRepr*>(index)->op_);
-	SgExpression* lower_bound = static_cast<CG_roseRepr*>(lower)->op_;
-	SgExpression* upper_bound = static_cast<CG_roseRepr*>(upper)->op_;
-	SgExpression* step_size = static_cast<CG_roseRepr*>(step)->op_;
-
-	SgStatement* for_init_stmt = buildAssignStatement(index_sym, lower_bound);
-	SgLessOrEqualOp* cond = buildLessOrEqualOp(index_sym, upper_bound);
-	SgExprStatement* test = buildExprStatement(cond);
-	SgPlusAssignOp* increment = buildPlusAssignOp(index_sym, step_size);
-	SgForStatement *for_stmt = buildForStatement(for_init_stmt,
-			isSgStatement(test), increment, NULL);
-
-	delete index;
-	delete lower;
-	delete upper;
-	delete step;
-
-
-	// Manu
-	if (isInputFortran()) {
-        SgFortranDo * forStmt=new SgFortranDo(Sg_File_Info::generateDefaultFileInfoForTransformationNode());
-        forStmt->set_has_end_statement(true);
-        forStmt->set_bound(upper_bound);
-        forStmt->set_increment(step_size);
-        forStmt->set_initialization(isSgExprStatement(for_init_stmt)->get_expression());
-        return new CG_roseRepr(isSgNode(forStmt));
-	} else {
-
-		return new CG_roseRepr(isSgNode(for_stmt));
-
-	}
-
-}
-
-//-----------------------------------------------------------------------------
-// Attribute Creation
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateAttribute(CG_outputRepr *control,
-		const std::string &commentText) const {
-
-	SgNode *tnl = static_cast<CG_roseRepr*>(control)->tnl_;
-
-	tnl->setAttribute("omega_comment", new AstTextAttribute(commentText));
-
-	return static_cast<CG_roseRepr*>(control);
-
-}
-
-//-----------------------------------------------------------------------------
-// Pragma Attribute
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreatePragmaAttribute(CG_outputRepr *stmt, int looplevel, const std::string &pragmaText) const {
-	SgNode *tnl = static_cast<CG_roseRepr*>(stmt)->tnl_;
-	CodeInsertionAttribute* attr = NULL;
-	if (!tnl->attributeExists("code_insertion")) {
-		attr = new CodeInsertionAttribute();
-		tnl->setAttribute("code_insertion", attr);
-	}
-	else {
-		attr = static_cast<CodeInsertionAttribute*>(tnl->getAttribute("code_insertion"));
-	}
-	attr->add(new PragmaInsertion(looplevel, pragmaText));
-	return stmt;
-}
-
-//-----------------------------------------------------------------------------
-// Prefetch Attribute
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreatePrefetchAttribute(CG_outputRepr* stmt, int looplevel, const std::string &arrName, int hint) const {
-	SgNode *tnl = static_cast<CG_roseRepr*>(stmt)->tnl_;
-	CodeInsertionAttribute *attr = getOrCreateCodeInsertionAttribute(tnl);
-	attr->add(new MMPrefetchInsertion(looplevel, arrName, hint));
-}
-
-//-----------------------------------------------------------------------------
-// loop stmt generation
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateLoop(int, CG_outputRepr *control,
-		CG_outputRepr *stmtList) const {
-	if (stmtList == NULL) {
-		delete control;
-		return NULL;
-	} else if (control == NULL) {
-		fprintf(stderr, "Code generation: no inductive for this loop\n");
-		return stmtList;
-	}
-
-	SgNode *tnl = static_cast<CG_roseRepr*>(control)->tnl_;
-	SgForStatement *tf = isSgForStatement(tnl);
-
-	// Manu :: fortran support
-	SgFortranDo *tfd = NULL;
-	if (isInputFortran()) {
-		tfd = isSgFortranDo(tnl);
-	}
-	SgStatementPtrList * body = static_cast<CG_roseRepr*>(stmtList)->list_;
-
-	if (body != NULL) {
-		if (!((*body).empty())) {
-			if ((*body).size() == 1) {
-				if (!isInputFortran()) {  // Manu:: added if-else for fortran support
-				  tf->set_loop_body(*((*body).begin()));
-				  (*((*body).begin()))->set_parent(tf);
-				} else {
-					SgBasicBlock* bb1 = buildBasicBlock();
-					bb1->set_parent(tfd);
-					bb1->append_statement(*((*body).begin()));
-					tfd->set_body(bb1);
-				}
-			} else {
-				// Manu:: support for fortran label (do - continue)
-				SgName *sname = NULL;
-
-				SgBasicBlock* bb = buildBasicBlock();
-				if (!isInputFortran())
-				    bb->set_parent(tf);
-				else
-					bb->set_parent(tfd);
-				for (SgStatementPtrList::iterator it = (*body).begin();
-						it != (*body).end(); it++) {
-					bb->append_statement(*it);
-					(*it)->set_parent(bb);
-				}
-				if (!isInputFortran())
-				   tf->set_loop_body(bb);
-				else {
-					tfd->set_body(bb);
-				}
-			}
-		}
-	} else {
-		SgNode* tnl2 = static_cast<CG_roseRepr*>(stmtList)->tnl_;
-
-		if (tnl2 != NULL) {
-			if (!isInputFortran()) {
-			   tf->set_loop_body(isSgStatement(tnl2));
-			   tnl2->set_parent(tf);
-			} else {
-				SgBasicBlock* bb1 = buildBasicBlock();
-				bb1->set_parent(tfd);
-				bb1->append_statement(isSgStatement(tnl2));
-				tfd->set_body(bb1);
-  			    tnl2->set_parent(bb1);
-			}
-		}
-	}
-
-	delete stmtList;
-
-	return control;
-}
-
-//-----------------------------------------------------------------------------
-// basic int, identifier gen operations
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateInt(int _i) const {
-	return new CG_roseRepr(isSgExpression(buildIntVal(_i)));
-}
-bool CG_roseBuilder::isInteger(CG_outputRepr *op) const{
-
-	 SgExpression *op1 = static_cast<CG_roseRepr *>(op)->op_;
-
-	 if(op1)
-       if(isSgIntVal(op1))
-	       return true;
-
-     return false;
-}
-CG_outputRepr* CG_roseBuilder::CreateIdent(const std::string &_s) const {
-
-	SgVariableSymbol *vs = symtab_->find_variable(SgName(_s.c_str()));
-	SgVariableSymbol *vs2 = symtab2_->find_variable(SgName(_s.c_str()));
-
-	if (vs == NULL && vs2 == NULL) {
-
-		SgVariableDeclaration* defn = buildVariableDeclaration(
-				SgName(_s.c_str()), buildIntType());
-		SgInitializedNamePtrList& variables = defn->get_variables();
-		SgInitializedNamePtrList::const_iterator i = variables.begin();
-		SgInitializedName* initializedName = *i;
-		vs = new SgVariableSymbol(initializedName);
-		prependStatement(defn, isSgScopeStatement(root_));
-
-		vs->set_parent(symtab2_);
-		symtab2_->insert(SgName(_s.c_str()), vs);
-		return new CG_roseRepr(isSgExpression(buildVarRefExp(vs)));
-
-	}
-
-	/* May have problem */
-
-	if (!isSgExpression(buildVarRefExp(SgName(_s.c_str()))))
-		throw ir_error("error in Create ident!!");
-	if (vs2 != NULL)
-		return new CG_roseRepr(isSgExpression(buildVarRefExp(vs2)));
-
-	return new CG_roseRepr(isSgExpression(buildVarRefExp(vs)));
-
-}
-
-//-----------------------------------------------------------------------------
-// binary arithmetic operations
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreatePlus(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-	if (rop == NULL) {
-		return lop;
-	} else if (lop == NULL) {
-		return rop;
-	}
-
-	SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-	SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-	SgAddOp *ins = buildAddOp(op1, op2);
-	op1->set_parent(ins);
-	op2->set_parent(ins);
-	delete lop;
-	delete rop;
-
-	return new CG_roseRepr(isSgExpression(ins));
-
-}
-
-CG_outputRepr* CG_roseBuilder::CreateMinus(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-	if (rop == NULL) {
-		return lop; /* May Cause Problem */
-	} else if (lop == NULL) {
-		SgExpression *op = static_cast<CG_roseRepr*>(rop)->op_;
-		SgMinusOp *ins = buildMinusOp(op);
-
-		delete rop;
-
-		return new CG_roseRepr(isSgExpression(ins));
-	} else {
-		SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-		SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-		SgSubtractOp *ins = buildSubtractOp(op1, op2);
-		op1->set_parent(ins);
-		op2->set_parent(ins);
-		delete lop;
-		delete rop;
-		return new CG_roseRepr(isSgExpression(ins));
-	}
-
-}
-
-CG_outputRepr* CG_roseBuilder::CreateTimes(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-	if (rop == NULL || lop == NULL) {
-		if (rop != NULL) {
-			rop->clear();
-			delete rop;
-		}
-		if (lop != NULL) {
-			lop->clear();
-			delete lop;
-		}
-		return NULL;
-	}
-
-	SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-	SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-	SgMultiplyOp *ins = buildMultiplyOp(op1, op2);
-	op1->set_parent(ins);
-	op2->set_parent(ins);
-	delete lop;
-	delete rop;
-
-	return new CG_roseRepr(isSgExpression(ins));
-
-}
-
-CG_outputRepr* CG_roseBuilder::CreateIntegerFloor(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-	if (rop == NULL) {
-		fprintf(stderr, "Code generation: divide by NULL\n");
-		return NULL;
-	} else if (lop == NULL) {
-		delete rop;
-		return NULL;
-	}
-
-	//  (6+5)*10 / 4
-	SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-	SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-	// bugs in SUIF prevent use of correct io_divfloor
-	SgDivideOp *ins = buildDivideOp(op1, op2);
-
-	delete lop;
-	delete rop;
-
-	return new CG_roseRepr(isSgExpression(ins));
-
-}
-
-CG_outputRepr* CG_roseBuilder::CreateIntegerMod(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-	if (rop == NULL || lop == NULL) {
-		return NULL;
-	}
-
-	SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-	SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-	// bugs in SUIF prevent use of correct io_mod
-	SgModOp *ins;
-	if (!isInputFortran()) {
-		ins = buildModOp(op1, op2);
-		delete lop;
-		delete rop;
-
-		return new CG_roseRepr(isSgExpression(ins));
-	} else { // Manu:: fortran mod is a function call and not an operator (f77 and f90)
-		SgExpression *fins;
-		SgName fName("MOD");
-		SgExprListExp* arg_list = buildExprListExp();
-		appendExpression(arg_list, op1);
-		appendExpression(arg_list, op2);
-		SgTypeInt *retType = buildIntType();
-		fins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_));
-		return new CG_roseRepr(isSgExpression(fins));
-	}
-
-}
-
-//-----------------------------------------------------------------------------
-// binary logical operations
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateAnd(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-
-	if (rop == NULL)
-		return lop;
-	else if (lop == NULL)
-		return rop;
-
-	SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-	SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-	SgAndOp *ins = buildAndOp(op1, op2);
-
-	delete lop;
-	delete rop;
-
-	return new CG_roseRepr(isSgExpression(ins));
-
-}
-
-//-----------------------------------------------------------------------------
-// binary relational operations
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::CreateLE(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-	if (rop == NULL || lop == NULL) {
-		return NULL;
-	}
-
-	SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-	SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-	SgLessOrEqualOp *ins = buildLessOrEqualOp(op1, op2);
-
-	delete lop;
-	delete rop;
-
-	return new CG_roseRepr(isSgExpression(ins));
-
-}
-
-CG_outputRepr* CG_roseBuilder::CreateEQ(CG_outputRepr *lop,
-		CG_outputRepr *rop) const {
-	if (rop == NULL || lop == NULL) {
-		return NULL;
-	}
-
-	SgExpression* op1 = static_cast<CG_roseRepr*>(lop)->op_;
-	SgExpression* op2 = static_cast<CG_roseRepr*>(rop)->op_;
-
-	SgEqualityOp *ins = buildEqualityOp(op1, op2);
-
-	delete lop;
-	delete rop;
-
-	return new CG_roseRepr(isSgExpression(ins));
-
-}
-
-//-----------------------------------------------------------------------------
-// stmt list gen operations
-//-----------------------------------------------------------------------------
-CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1,
-		CG_outputRepr *list2) const {
-
-	if (list2 == NULL) {
-		return list1;
-	} else if (list1 == NULL) {
-		return list2;
-	}
-
-	SgStatementPtrList* new_list;
-
-	SgStatementPtrList* tnl1 = static_cast<CG_roseRepr *>(list1)->list_;
-	SgStatementPtrList* tnl2 = static_cast<CG_roseRepr *>(list2)->list_;
-	SgNode* one = static_cast<CG_roseRepr *>(list1)->tnl_;
-	SgNode* two = static_cast<CG_roseRepr *>(list2)->tnl_;
-
-	SgExpression* exp1 = static_cast<CG_roseRepr *>(list1)->op_;
-	SgExpression* exp2 = static_cast<CG_roseRepr *>(list2)->op_;
-
-	if (exp1 || exp2)
-		throw ir_error("error in stmtlistappend!!");
-
-	if (tnl1 && one)
-		throw ir_error("error in stmtlistappend!!");
-
-	if (tnl2 && two)
-		throw ir_error("error in stmtlistappend!!");
-	if ((tnl1 == NULL) && (tnl2 == NULL)) {
-
-		if ((one != NULL) && (two != NULL)) {
-
-			new_list = new SgStatementPtrList;
-
-			(*new_list).push_back(isSgStatement(one));
-			(*new_list).push_back(isSgStatement(two));
-
-			CG_roseRepr* new_rep = new CG_roseRepr(new_list);
-
-			return static_cast<CG_outputRepr *>(new_rep);
-
-		} else if ((one != NULL) && (two == NULL)) {
-
-			return static_cast<CG_outputRepr *>(new CG_roseRepr(one));
-
-		} else if ((two != NULL) && (one == NULL)) {
-			return static_cast<CG_outputRepr *>(new CG_roseRepr(two));
-
-		}
-
-	} else {
-		if ((tnl2 != NULL) && (tnl1 == NULL)) {
-			if (one == NULL)
-				return list2;
-			else {
-				new_list = new SgStatementPtrList;
-				(*new_list).push_back(isSgStatement(one));
-
-				for (SgStatementPtrList::iterator it = (*tnl2).begin();
-						it != (*tnl2).end(); it++) {
-					(*new_list).push_back(*it);
-
-				}
-				return static_cast<CG_outputRepr *>(new CG_roseRepr(new_list));
-			}
-		} else if ((tnl1 != NULL) && (tnl2 == NULL)) {
-			if (two == NULL)
-				return list1;
-			else {
-
-				(*tnl1).push_back(isSgStatement(two));
-				return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1));
-
-			}
-
-		} else if ((tnl1 != NULL) && (tnl2 != NULL)) {
-
-			for (SgStatementPtrList::iterator it = (*tnl2).begin();
-					it != (*tnl2).end(); it++) {
-				(*tnl1).push_back(*it);
-
-			}
-
-			return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1));
-		}
-
-	}
-
-}
-
-
-CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, CG_outputRepr* arg1,
-		CG_outputRepr* arg2, CG_outputRepr* arg3) const {
-
-    SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol(
-			SgName("dim3"));
-
-	SgExprListExp * ctor_args;
-	if(arg3 != NULL)
-	ctor_args = buildExprListExp(static_cast<CG_roseRepr*>(arg1)->op_,
-			static_cast<CG_roseRepr*>(arg2)->op_, static_cast<CG_roseRepr*>(arg3)->op_);
-	else
-    ctor_args = buildExprListExp(static_cast<CG_roseRepr*>(arg1)->op_,
-    		static_cast<CG_roseRepr*>(arg2)->op_);
-	SgFunctionCallExp * dim3_func_call = buildFunctionCallExp(
-			buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args);
-
-	char joined_str[20];
-
-	strcpy(joined_str, "dim3 ");
-	strcat(joined_str, varName);
-
-	SgExprStatement* decl = buildAssignStatement(
-			buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)),
-			dim3_func_call);
-
-	SgStatementPtrList *tnl2 = new SgStatementPtrList;
-
-	(*tnl2).push_back(decl);
-	return new CG_roseRepr(tnl2);
-
-}
-
-std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym,
-		SgExpression* expr, SgNode* root) {
-
-	SgStatement* stmt;
-	SgExpression* op;
-	std::vector<SgVarRefExp *> arrays;
-
-	if (in != NULL) {
-		if (stmt = isSgStatement(in)) {
-			if (isSgBasicBlock(stmt)) {
-				SgStatementPtrList& stmts =
-						isSgBasicBlock(stmt)->get_statements();
-				for (int i = 0; i < stmts.size(); i++) {
-					stmts[i]->set_parent(stmt);
-					std::vector<SgVarRefExp *> a = substitute(
-							isSgNode(stmts[i]), sym, expr, root);
-					std::copy(a.begin(), a.end(), back_inserter(arrays));
-				}
-			} else if (isSgForStatement(stmt)) {
-				SgForStatement *tnf = isSgForStatement(stmt);
-				tnf->get_for_init_stmt()->set_parent(tnf);
-				tnf->get_test()->set_parent(tnf);
-				tnf->get_increment()->set_parent(tnf);
-				tnf->get_loop_body()->set_parent(tnf);
-				std::vector<SgVarRefExp *> a = substitute(
-						isSgNode(tnf->get_for_init_stmt()), sym, expr, root);
-				std::copy(a.begin(), a.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a1 = substitute(
-						isSgNode(tnf->get_test()), sym, expr, root);
-				std::copy(a1.begin(), a1.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a2 = substitute(
-						isSgNode(tnf->get_increment()), sym, expr, root);
-				std::copy(a2.begin(), a2.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a3 = substitute(
-						isSgNode(tnf->get_loop_body()), sym, expr, root);
-				std::copy(a3.begin(), a3.end(), back_inserter(arrays));
-			} else if (isSgFortranDo(stmt)) { // Manu:: fortran support
-				SgFortranDo *tnf = isSgFortranDo(stmt);
-				tnf->get_initialization()->set_parent(tnf);
-				tnf->get_bound()->set_parent(tnf);
-				tnf->get_increment()->set_parent(tnf);
-				tnf->get_body()->set_parent(tnf);
-				std::vector<SgVarRefExp *> a = substitute(
-						isSgNode(tnf->get_initialization()), sym, expr, root);
-				std::copy(a.begin(), a.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a1 = substitute(
-						isSgNode(tnf->get_bound()), sym, expr, root);
-				std::copy(a1.begin(), a1.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a2 = substitute(
-						isSgNode(tnf->get_increment()), sym, expr, root);
-				std::copy(a2.begin(), a2.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a3 = substitute(
-						isSgNode(tnf->get_body()), sym, expr, root);
-				std::copy(a3.begin(), a3.end(), back_inserter(arrays));
-			} else if (isSgForInitStatement(stmt)) {
-
-				SgStatementPtrList& stmts =
-						isSgForInitStatement(stmt)->get_init_stmt();
-
-				for (SgStatementPtrList::iterator it = stmts.begin();
-						it != stmts.end(); it++) {
-					std::vector<SgVarRefExp *> a = substitute(isSgNode(*it),
-							sym, expr, root);
-
-					std::copy(a.begin(), a.end(), back_inserter(arrays));
-				}
-			}
-			else if (isSgVariableDeclaration(stmt)) {
-				if (SgExpression *init =
-						isSgVariableDeclaration(stmt)->get_variables().front()->get_initializer()) {
-					if (isSgAssignInitializer(init)) {
-						std::vector<SgVarRefExp *> a = substitute(
-								isSgAssignInitializer(init)->get_operand(), sym,
-								expr, root);
-						std::copy(a.begin(), a.end(), back_inserter(arrays));
-					}
-				}
-			} else if (isSgIfStmt(stmt)) {
-				SgIfStmt* tni = isSgIfStmt(stmt);
-				std::vector<SgVarRefExp *> a = substitute(
-						isSgNode(tni->get_conditional()), sym, expr, root);
-				std::copy(a.begin(), a.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a1 = substitute(
-						isSgNode(tni->get_true_body()), sym, expr, root);
-				std::copy(a1.begin(), a1.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a2 = substitute(
-						isSgNode(tni->get_false_body()), sym, expr, root);
-				std::copy(a2.begin(), a2.end(), back_inserter(arrays));
-			} else if (isSgExprStatement(stmt)) {
-				(isSgExprStatement(stmt)->get_expression())->set_parent(
-						isSgExprStatement(stmt));
-				std::vector<SgVarRefExp *> a = substitute(
-						isSgNode(isSgExprStatement(stmt)->get_expression()),
-						sym, expr, root);
-				std::copy(a.begin(), a.end(), back_inserter(arrays));
-			}  
-		} 
-		else {
-			op = isSgExpression(in);
-			std::string y = sym->get_name().getString();
-
-			if (isSgBinaryOp(op)) {
-
-				isSgBinaryOp(op)->get_lhs_operand()->set_parent(op);
-				isSgBinaryOp(op)->get_rhs_operand()->set_parent(op);
-
-				std::vector<SgVarRefExp *> a = substitute(
-						isSgBinaryOp(op)->get_lhs_operand(), sym, expr, root);
-				std::copy(a.begin(), a.end(), back_inserter(arrays));
-				std::vector<SgVarRefExp *> a1 = substitute(
-						isSgBinaryOp(op)->get_rhs_operand(), sym, expr, root);
-				std::copy(a1.begin(), a1.end(), back_inserter(arrays));
-			} else if (isSgUnaryOp(op)) {
-				std::vector<SgVarRefExp *> a = substitute(
-						isSgUnaryOp(op)->get_operand(), sym, expr, root);
-				std::copy(a.begin(), a.end(), back_inserter(arrays));
-			} else if (isSgVarRefExp(op)) {
-				std::string z =
-						isSgVarRefExp(op)->get_symbol()->get_name().getString();
-				if (!strcmp(z.c_str(), y.c_str())) {
-					arrays.push_back(isSgVarRefExp(op));
-				}   
-			}    
-			else if (isSgCallExpression(op)) {
-				SgExprListExp* exprs = isSgCallExpression(op)->get_args();
-				SgExpressionPtrList &expr_list = exprs->get_expressions();
-
-				for (SgExpressionPtrList::iterator it = expr_list.begin();
-						it != expr_list.end(); it++) {
-					std::vector<SgVarRefExp *> a = substitute(isSgNode(*it),
-							sym, expr, root);
-					std::copy(a.begin(), a.end(), back_inserter(arrays));
-				}
-			} else if (isSgExprListExp(op)) { // Manu:: fortran indices are stored this way
-				SgExpressionPtrList &expr_list = isSgExprListExp(op)->get_expressions();
-
-				for (SgExpressionPtrList::iterator it = expr_list.begin();
-						it != expr_list.end(); it++) {
-					std::vector<SgVarRefExp *> a = substitute(isSgNode(*it),
-							sym, expr, root);
-					std::copy(a.begin(), a.end(), back_inserter(arrays));
-				}
-
-			}
-
-		}  
-	}       
-
-	return arrays;
-}
-
-} // namespace
diff --git a/lib/rosecg/src/CG_roseRepr.cc b/lib/rosecg/src/CG_roseRepr.cc
deleted file mode 100644
index 5472239..0000000
--- a/lib/rosecg/src/CG_roseRepr.cc
+++ /dev/null
@@ -1,125 +0,0 @@
-/*****************************************************************************
- Copyright (C) 2008 University of Southern California. 
- All Rights Reserved.
-
- Purpose:
-   omega holder for suif implementaion
-
- Notes:
-
- History:
-   02/01/06 - Chun Chen - created
-*****************************************************************************/
-
-#include "code_gen/CG_roseRepr.h"
-#include "code_gen/rose_attributes.h"
-#include <stdio.h>
-#include <string.h>
-#include <cstring>
-namespace omega {
-
-
-
-
-CG_roseRepr::CG_roseRepr(): tnl_(NULL), op_(NULL), list_(NULL){
-
-}
-
-CG_roseRepr::CG_roseRepr(SgNode *tnl): tnl_(tnl), op_(NULL),list_(NULL) {
-}
-
-CG_roseRepr::CG_roseRepr(SgExpression* op): tnl_(NULL), op_(op),list_(NULL){
-}
-CG_roseRepr::CG_roseRepr(SgStatementPtrList* stmtlist):tnl_(NULL), op_(NULL), list_(stmtlist){
-}
-  
-CG_roseRepr::~CG_roseRepr() {
-  // delete nothing here. operand or tree_node_list should already be
-  // grafted to other expression tree or statement list
-}
-
-CG_outputRepr* CG_roseRepr::clone()  const {
-
-  if( tnl_ != NULL) {
-    SgTreeCopy  tc;      
-    SgNode *tnl = tnl_->copy(tc);
-    copyAttributes(tnl_, tnl);
-    
-    tnl->set_parent(tnl_->get_parent());
-    return new CG_roseRepr(tnl);
-  }
-  else if(op_ != NULL)
-  {
-     SgTreeCopy tc1;
-     SgNode* op =  isSgNode(op_)->copy(tc1);
-     copyAttributes(op_, op);
-  
-     op->set_parent(isSgNode(op_)->get_parent());   
-     return new CG_roseRepr(isSgExpression(op));
-  }
-  else if(list_ != NULL) 
-  {
-     SgStatementPtrList* list2 = new SgStatementPtrList;
-     
-     for(SgStatementPtrList::iterator it = (*list_).begin(); it != (*list_).end(); it++){
-        SgTreeCopy  tc3;      
-        SgNode *tnl2  =  isSgNode(*it)->copy(tc3);
-        copyAttributes(*it, tnl2);
-        
-        tnl2->set_parent(isSgNode(*it)->get_parent());
-       
-        (*list2).push_back(isSgStatement(tnl2));       
-    }   
-    return new CG_roseRepr(list2);
-  }
-  
-  return NULL;
-}
-
-void CG_roseRepr::clear() {
-  if(tnl_ != NULL) {
-    delete tnl_;
-    tnl_ = NULL;
-  }
-}
-
-SgNode* CG_roseRepr::GetCode() const {
-  return tnl_;
-}
-
-SgStatementPtrList* CG_roseRepr::GetList() const {
-  return list_;
-}
-
-SgExpression* CG_roseRepr::GetExpression() const {
-   return op_;
-} 
-void CG_roseRepr::Dump() const {
-SgNode* tnl = tnl_;
-SgExpression* op = op_ ;
- if(tnl != NULL)
-  DumpFileHelper(tnl, stdout);
- else if(op != NULL)
-   DumpFileHelper(isSgNode(op), stdout);             
-
-}
-
-void  CG_roseRepr::DumpFileHelper(SgNode* node, FILE *fp) const{
-  std::string x;
-  size_t numberOfSuccessors = node->get_numberOfTraversalSuccessors();
- if(numberOfSuccessors == 0){
-    x = node->unparseToString ();   
-    fprintf(fp, "%s", x.c_str());
- }
- else{     
-   for (size_t idx = 0; idx < numberOfSuccessors; idx++)
-   {
-       SgNode *child = NULL;
-       child = node->get_traversalSuccessorByIndex(idx);
-       DumpFileHelper(child, fp);                 
-   }
- 
-}
-}
-
-} // namespace
diff --git a/lib/rosecg/src/rose_attributes.cc b/lib/rosecg/src/rose_attributes.cc
deleted file mode 100644
index c5ba30b..0000000
--- a/lib/rosecg/src/rose_attributes.cc
+++ /dev/null
@@ -1,183 +0,0 @@
-#include "code_gen/rose_attributes.h"
-
-namespace omega {
-
-CodeInsertionAttribute* getOrCreateCodeInsertionAttribute(SgNode* node) {
-	CodeInsertionAttribute* attr;
-	if(node->attributeExists("code_insertion"))
-		return static_cast<CodeInsertionAttribute*>(node->getAttribute("code_insertion"));
-	attr = new CodeInsertionAttribute();
-	node->setAttribute("code_insertion", attr);
-	return attr;
-}
-
-void postProcessRoseCodeInsertion(SgProject* proj) {
-	//generatePDF(*proj);
-	CodeInsertionVisitor visitor = CodeInsertionVisitor();
-	visitor.initialize();
-	visitor.traverseInputFiles(proj);
-	visitor.insertCode();
-}
-
-// Swap a code insertion from one node (sn) to another (dn)
-// -- note that this function does not currently remove the insertion from the sn node
-void moveCodeInsertion(SgNode* sn, CodeInsertion* ci, SgNode* dn) {
-	CodeInsertionAttribute* new_attr;
-	// TODO in the near future: replace the above statement with 'new_attr = getOrCreateCodeInsertionAttribute(...)'
-	CodeInsertionAttribute* old_attr = static_cast<CodeInsertionAttribute*>(sn->getAttribute("code_insertion"));
-	if(dn->attributeExists("code_insertion")) {
-		new_attr = static_cast<CodeInsertionAttribute*>(dn->getAttribute("code_insertion"));
-	}
-	else {
-		new_attr = new CodeInsertionAttribute();
-		dn->setAttribute("code_insertion", new_attr);
-	}
-	new_attr->add(ci);
-}
-
-// A function that copies a specific attribute from one node to another
-// this function exists to get around a ROSE limitation that does not
-// copy attributes
-void copyAttribute(std::string attr_name, SgNode* s, SgNode* d) {
-	if(s->attributeExists(attr_name)) {
-		d->setAttribute(attr_name,s->getAttribute(attr_name));
-	}
-}
-
-// TODO: find all existng attributes and iterate over them instead of doing them
-//       individually
-void copyAttributes(SgNode* s, SgNode* d) {
-	copyAttribute("code_insertion", s, d);
-	//...any other attributes...
-}
-
-void CodeInsertionVisitor::initialize() {
-	this->loop_level = 0;
-	this->ci_marks = std::vector<CodeInsertionMark*>();
-}
-
-void CodeInsertionVisitor::markStmt(SgStatement* stmt, CodeInsertion* ci) {
-	// this check prevents multiple copies of stmts
-	// -- may be changed in the future
-	if(!ci->marked) {
-		CodeInsertionMark* pos = new CodeInsertionMark();
-		pos->stmt = stmt;
-		pos->ci = ci;
-		this->ci_marks.push_back(pos);
-		ci->marked = true;
-	}
-}
-
-// increase loop_level as the visitor descends
-void CodeInsertionVisitor::preOrderVisit(SgNode* n) {
-	if (isSgForStatement(n)) {
-		this->loop_level++;
-	}
-}
-
-void CodeInsertionVisitor::postOrderVisit(SgNode* n) {
-	if(isSgForStatement(n)) {
-		this->loop_level--;
-	}
-	if(isSgStatement(n)) {
-		if(n->attributeExists("code_insertion")) {
-			CodeInsertionAttribute *attr = static_cast<CodeInsertionAttribute*>(n->getAttribute("code_insertion"));
-			for(CodeInsertionPtrListItr itr = attr->begin(); itr != attr->end(); ++itr) {
-				CodeInsertion *insertion = *itr;
-				// check loop level -- if it is equivelent, mark statement for insertion
-				//                  -- else, move attribute up to parent
-				if(insertion->loop_level != this->loop_level) {
-					moveCodeInsertion(n, insertion, n->get_parent());
-				}
-				else {
-					this->markStmt(isSgStatement(n), insertion);
-				}
-			}
-		}
-	}
-}
-
-// final stage of algorithm that inserts marked statements
-void CodeInsertionVisitor::insertCode() {
-	for(std::vector<CodeInsertionMark*>::iterator itr = this->ci_marks.begin(); itr != this->ci_marks.end(); ++itr) {
-		CodeInsertionMark* mark = *itr;
-		SgScopeStatement* scope = static_cast<SgScopeStatement*>(mark->stmt->get_parent());
-		SageInterface::insertStatementBefore(mark->stmt, mark->ci->getStatement(scope));
-	}
-}
-
-SgStatement* PragmaInsertion::getStatement(SgScopeStatement* scopeStmt) {
-	SgStatement* stmt = SageBuilder::buildPragmaDeclaration(this->name);
-	return stmt;
-}
-
-//SgStatement* MMPrefetchInsertion::getStatement(SgScopeStatement* scopeStmt) {
-//	const SgName& name = SgName("_mm_prefetch");
-//	SgType* rtype = SageBuilder::buildVoidType();
-//	SgExpression* arr_arg = SageBuilder::buildVarRefExp(this->arrName);
-//	SgExpression* hint_arg = SageBuilder::buildShortVal(this->cacheHint);
-//	SgExprListExp* args = SageBuilder::buildExprListExp(arr_arg,hint_arg);
-//	SgStatement* stmt = SageBuilder::buildFunctionCallStmt(name, rtype, args, scopeStmt);
-//	return stmt;
-//}
-
-SgStatement* MMPrefetchInsertion::getStatement(SgScopeStatement* scopeStmt) {
-	const SgName fname = SgName("_mm_prefetch");
-	SgType* rtype = SageBuilder::buildVoidType();
-	SgExpression* arr_arg = this->buildArrArg(scopeStmt);
-	SgExpression* hint_arg = SageBuilder::buildShortVal(this->cacheHint);
-	SgExprListExp* args = SageBuilder::buildExprListExp(arr_arg, hint_arg);
-	return SageBuilder::buildFunctionCallStmt(fname, rtype, args, scopeStmt);
-}
-
-SgExpression* MMPrefetchInsertion::buildArrArg(SgScopeStatement* scopeStmt) {
-	// if there are no index arguments given, just return a variable reference
-	if(this->indexCount == 0) {
-		const SgName aname = SgName(this->arrName);
-		return SageBuilder::buildVarRefExp(aname, scopeStmt);
-	}
-	std::vector<SgExpression*> argList = std::vector<SgExpression*>();
-	// foreach dimension
-	for(int i = 0; i < this->indexCount; i++) {
-		argList.push_back(this->makeIndexExp(i, scopeStmt));
-	}
-	return SageBuilder::buildExprListExp(argList);
-}
-
-SgExpression* MMPrefetchInsertion::makeIndexExp(int dim, SgScopeStatement* scopeStmt) {
-	//(i + offset) or (offset) or (i)
-	std::string* indexer = this->indecies.at(dim);
-	int offset = this->offsets.at(dim);
-	if(indexer == NULL) {
-		return SageBuilder::buildIntVal(offset);
-	}
-	else {
-		const SgName name = SgName(*indexer);
-		SgVarRefExp* iref = SageBuilder::buildVarRefExp(name, scopeStmt);
-		if(offset == 0) {
-			return iref;
-		}
-		else {
-			return SageBuilder::buildAddOp(iref, SageBuilder::buildIntVal(offset));
-		}
-	}
-}
-
-void MMPrefetchInsertion::initialize(const std::string& arrName, int hint) {
-	this->arrName = std::string(arrName);
-	this->cacheHint = hint;
-	this->indecies = std::vector<std::string*>();
-	this->offsets = std::vector<int>();
-	this->indexCount = 0;
-}
-void MMPrefetchInsertion::addDim(int offset) {
-	this->offsets.push_back(offset);
-	this->indecies.push_back(NULL);
-	this->indexCount++;
-}
-void MMPrefetchInsertion::addDim(int offset, const std::string& indexer) {
-	this->offsets.push_back(offset);
-	this->indecies.push_back(new std::string(indexer));
-	this->indexCount++;
-}
-}