tester.cxx

Go to the documentation of this file.

// -*-Mode: C++;-*-
// $Header: /Volumes/cvsrep/developer/OpenADFortTk/src/testers/tester.cxx,v 1.20 2005/03/31 03:44:33 utke Exp $

#include <stdlib.h> // ANSI: cstdlib // for strtol
#include <string.h> // ANSI: cstring // for strcmp, etc.
#include <iostream>

#include "OpenAnalysis/ExprTree/ExprTree.hpp"

#include "Open64IRInterface/Open64BasicTypes.h"
#include "ir_reader.h" // fdump_tree
#include "w2f_driver.h" // W2F_*
#include "Open64IRInterface/Open64IRInterface.hpp"
#include "Open64IRInterface/SymTab.h"

#include "ScalarizedRefTab.h"
#include "Diagnostics.h"

#include "tester.h"

using std::cerr;
using std::endl;

static int
DumpExprTree(std::ostream& os, WN* wn);

static int
DumpExprTree(std::ostream& os, OA::OA_ptr<OA::ExprTree> tree);

static int
TestForEachPU(std::ostream& os, PU_Info* pu_forest);

static int
TestForEachWNPU(std::ostream& os, WN* wn_pu);

static int
TestForEachWN(std::ostream& os, WN* wn);

static void
RecursiveFnWN(std::ostream& os, WN* wn);


int
whirltester::TestIR(std::ostream& os, PU_Info* pu_forest)
{
 Diag_Set_Phase("WHIRL tester: TestIR");
 
 if (!pu_forest) { return 0; }
 
 // Here is where we can do something
 TestForEachPU(os, pu_forest);

 return 0;
}

static int
TestForEachPU(std::ostream& os, PU_Info* pu_forest)
{
 Open64IRProcIterator procIt(pu_forest);
 for ( ; procIt.isValid(); ++procIt) { 
 
 // The PU_Info* for this PU
 PU_Info* pu = (PU_Info*)procIt.current().hval();

 // The root of the WHIRL tree
 WN* wn_pu = PU_Info_tree_ptr(pu);
 
 TestForEachWNPU(os, wn_pu);
 }
 return 0;
}

static int
TestForEachWNPU(std::ostream& os, WN* wn_pu)
{
 // We may want to do something special with the top level WN (FUNC_ENTRY)
 //...
 
 // Iterate over each WN and do something
 WN_TREE_CONTAINER<PRE_ORDER> wtree(wn_pu);
 WN_TREE_CONTAINER<PRE_ORDER>::iterator it;
 
 for (it = wtree.begin(); it != wtree.end(); ++it) {
 WN* curWN = it.Wn();

 TestForEachWN(os, curWN);
 }

 // Alternatively we may want to recursively do something with the WHIRL tree
 RecursiveFnWN(os, wn_pu);
 
 return 0;
}

static int
TestForEachWN(std::ostream& os, WN* wn)
{
 if (wn) {
 DumpExprTree(os, wn);
 os << endl;
 }
 return 0;
}

static void
RecursiveFnWN(std::ostream& os, WN* wn)
{
 if (wn == NULL) {
 // Base case

 } 
 
 OPERATOR opr = WN_operator(wn);

 if ( /* some test */ false ) {
 // Base case
 } else if (!OPERATOR_is_leaf(opr)) {
 
 // General recursive case
 if (WN_operator(wn) == OPR_BLOCK) {
 WN *kid = WN_first(wn);
 while (kid) {
 RecursiveFnWN(os, kid);
 kid = WN_next(kid);
 }
 } else {
 for (INT kidno = 0; kidno < WN_kid_count(wn); kidno++) {
 WN* kid = WN_kid(wn, kidno);
 RecursiveFnWN(os, kid);
 }
 }
 }
}

//****************************************************************************

static int
DumpExprNode(std::ostream& os, OA::OA_ptr<OA::ExprTree::Node> node, 
 OA::OA_ptr<Open64IRInterface> ir);

static int
DumpExprTree(std::ostream& os, WN* wn)
{
 OA::OA_ptr<Open64IRInterface> ir;
 ir = new Open64IRInterface;

 OPERATOR opr = WN_operator(wn);
 if (OPERATOR_is_expression(opr)) {
 OA::OA_ptr<OA::ExprTree> tree = 
 ir->getExprTree(OA::ExprHandle((OA::irhandle_t)wn));
 DumpExprTree(os, tree);
 }
 
 return 0;
}

static int
DumpExprTree(std::ostream& os, OA::OA_ptr<OA::ExprTree> tree)
{
 OA::OA_ptr<Open64IRInterface> ir;
 ir = new Open64IRInterface;
 
 OA::Tree::PreOrderIterator nodes_iter(*tree);
 for ( ; nodes_iter.isValid(); ++nodes_iter) {
 OA::OA_ptr<OA::Tree::Node> ntmp = nodes_iter.current();
 OA::OA_ptr<OA::ExprTree::Node> node = ntmp.convert<OA::ExprTree::Node>();
 DumpExprNode(os, node, ir);
 }
 
 return 0;
}

static int
DumpExprNode(std::ostream& os, OA::OA_ptr<OA::ExprTree::Node> node, 
 OA::OA_ptr<Open64IRInterface> ir)
{
#if 0
 std::string& attr = node->getAttr();
 os << "{ " << attr;
 
 if (node->isSym()) {
 const char* nm = ir.toString(node->getSymHandle());
 os << " sym: " << nm; 
 } else if (node->isConst()) {
 os << " const"; 
 }
 os << " }";
#endif

 return 0;
}


//****************************************************************************
// TestIR_OA: 
//****************************************************************************

static int
TestIR_OA_ForEachWNPU(std::ostream& os, WN* wn_pu);

#if 0 
static void
TestIR_OA_ForEachVarRef(std::ostream& os, WN* wn, 
 Open64IRInterface& ir, UJNumbers& vnmap);
#endif

int
whirltester::TestIR_OA(std::ostream& os, PU_Info* pu_forest)
{
 Diag_Set_Phase("WHIRL tester: TestIR_OA");
 
 if (!pu_forest) { return 0; }

 Open64IRProcIterator procIt(pu_forest);
 for ( ; procIt.isValid(); ++procIt) { 
 
 // The PU_Info* for this PU
 PU_Info* pu = (PU_Info*)procIt.current().hval();

 // The root of the WHIRL tree
 WN* wn_pu = PU_Info_tree_ptr(pu);
 
 TestIR_OA_ForEachWNPU(os, wn_pu);
 }
 return 0;
}

static int
TestIR_OA_ForEachWNPU(std::ostream& os, WN* wn_pu)
{
 WN* fbody = WN_func_body(wn_pu);

#if 0 
 Open64IRInterface irInterface;
 Open64IRStmtIterator irStmtIter(fbody);
 CFG cfg(irInterface, &irStmtIter, (SymHandle)WN_st(wn_pu), true);

 // Accumulate the ST* for parameters
 std::set<SymHandle> params;
 INT nparam = WN_num_formals(wn_pu);
 for (int i = 0; i < nparam; ++i) {
 ST* st = WN_st(WN_formal(wn_pu, i));
 params.insert((SymHandle)st);
 }

 UJNumbers vnmap(cfg, params);
 TestIR_OA_ForEachVarRef(os, wn_pu, irInterface, vnmap);
#endif

 return 0;
}

#if 0
static void
TestIR_OA_ForEachVarRef(std::ostream& os, WN* wn, 
 Open64IRInterface& ir, UJNumbers& vnmap)
{
 if (wn == NULL) {
 // Base case
 } 

 OPERATOR opr = WN_operator(wn);
 // OPR_STID is a special case. It is a base case in the sense the
 // it represents a LHS definition; but it is also a recursive case
 // because uses are embedded in its RHS subtree.
 bool varref = IsRefTranslatableToXAIF(wn);
 bool recur = false;

 // Base case
 if (varref || opr == OPR_STID) {
 VN vn = vnmap.Find((ExprHandle)wn);

 ExprTree* tree = ir.GetExprTreeForExprHandle((ExprHandle)wn); 
 os << "VN = " << vn << endl;
 os << " ";
 DumpExprTree(os, tree);
 os << endl;
 delete tree;

 if (opr == OPR_STID) { recur = true; }
 } 

 // General recursive case
 if ( (!varref || recur) && !OPERATOR_is_leaf(opr) ) {
 
 if (WN_operator(wn) == OPR_BLOCK) {
 WN *kid = WN_first(wn);
 while (kid) {
 TestIR_OA_ForEachVarRef(os, kid, ir, vnmap);
 kid = WN_next(kid);
 }
 } else {
 for (INT kidno = 0; kidno < WN_kid_count(wn); ++kidno) {
 WN* kid = WN_kid(wn, kidno);
 TestIR_OA_ForEachVarRef(os, kid, ir, vnmap);
 }
 }
 }
}
#endif


//****************************************************************************
// TestIR_whirl2f: 
//****************************************************************************

static WN*
PleaseGetMeSomething(WN* wn_pu);

int
whirltester::TestIR_whirl2f(std::ostream& os, PU_Info* pu_forest)
{
 static const int bufSZ = 1024 * 1024;
 static char buf[bufSZ];
 
 Diag_Set_Phase("WHIRL tester: TestIR_whirl2f");
 if (!pu_forest) { return 0; }
 
 PU_AllocBEGlobalSymtab();
 W2F_Init();
 
 Open64IRProcIterator procIt(pu_forest);
 for ( ; procIt.isValid(); ++procIt) { 
 
 // The PU_Info* for this PU
 PU_Info* pu = (PU_Info*)procIt.current().hval();
 
 // The root of the WHIRL tree and a statement to translate
 WN* wn_pu = PU_Info_tree_ptr(pu);
 WN* wn = PleaseGetMeSomething(wn_pu);

 PU_AllocBELocalSymtab(pu);
 W2F_Push_PU(wn_pu, wn);
 
 // Translate and output
 os << "----> The tree:" << endl;
 fdump_tree(stdout, wn);
 os << endl;
 
 os << "----> The translation:" << endl;
 W2F_Translate_Wn_Str(buf, bufSZ-1, wn);
 os << buf << endl;
 
 W2F_Pop_PU();
 PU_FreeBELocalSymtab(pu);
 break;
 }
 
 W2F_Fini();
 PU_FreeBEGlobalSymtab();
 return 0;
}

static WN*
PleaseGetMeSomething(WN* wn_pu) 
{
 WN_TREE_CONTAINER<PRE_ORDER> wtree(wn_pu);
 WN_TREE_CONTAINER<PRE_ORDER>::iterator it;

 // Find the first non-empty block
 WN* blk = NULL;
 for (it = wtree.begin(); it != wtree.end(); ++it) {
 WN* curWN = it.Wn();
 OPERATOR opr = WN_operator(curWN);
 if (opr == OPR_BLOCK && WN_first(curWN)) { // non-empty block
 blk = curWN;
 break;
 }
 }
 
 if (blk) {
 // Create a comment and insert it into the block
 WN* com1 = WN_CreateComment("$OpenAD BEGIN FRAGMENT(1)");
 WN_INSERT_BlockFirst(blk, com1);
 
 WN* com2 = WN_CreateComment("$OpenAD END FRAGMENT(1)");
 WN_INSERT_BlockLast(blk, com2);
 }
 
 // Return body of the wn_pu
 return WN_func_body(wn_pu); // blk;
}


//****************************************************************************