/*

 * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_idealGraphPrinter.cpp.incl"

#ifndef PRODUCT

// Constants

// Keep consistent with Java constants

const char *IdealGraphPrinter::INDENT = "  ";

const char *IdealGraphPrinter::TOP_ELEMENT = "graphDocument";

const char *IdealGraphPrinter::GROUP_ELEMENT = "group";

const char *IdealGraphPrinter::GRAPH_ELEMENT = "graph";

const char *IdealGraphPrinter::PROPERTIES_ELEMENT = "properties";

const char *IdealGraphPrinter::EDGES_ELEMENT = "edges";

const char *IdealGraphPrinter::PROPERTY_ELEMENT = "p";

const char *IdealGraphPrinter::EDGE_ELEMENT = "edge";

const char *IdealGraphPrinter::NODE_ELEMENT = "node";

const char *IdealGraphPrinter::NODES_ELEMENT = "nodes";

const char *IdealGraphPrinter::REMOVE_EDGE_ELEMENT = "removeEdge";

const char *IdealGraphPrinter::REMOVE_NODE_ELEMENT = "removeNode";

const char *IdealGraphPrinter::METHOD_NAME_PROPERTY = "name";

const char *IdealGraphPrinter::METHOD_IS_PUBLIC_PROPERTY = "public";

const char *IdealGraphPrinter::METHOD_IS_STATIC_PROPERTY = "static";

const char *IdealGraphPrinter::TRUE_VALUE = "true";

const char *IdealGraphPrinter::NODE_NAME_PROPERTY = "name";

const char *IdealGraphPrinter::EDGE_NAME_PROPERTY = "name";

const char *IdealGraphPrinter::NODE_ID_PROPERTY = "id";

const char *IdealGraphPrinter::FROM_PROPERTY = "from";

const char *IdealGraphPrinter::TO_PROPERTY = "to";

const char *IdealGraphPrinter::PROPERTY_NAME_PROPERTY = "name";

const char *IdealGraphPrinter::GRAPH_NAME_PROPERTY = "name";

const char *IdealGraphPrinter::INDEX_PROPERTY = "index";

const char *IdealGraphPrinter::METHOD_ELEMENT = "method";

const char *IdealGraphPrinter::INLINE_ELEMENT = "inline";

const char *IdealGraphPrinter::BYTECODES_ELEMENT = "bytecodes";

const char *IdealGraphPrinter::METHOD_BCI_PROPERTY = "bci";

const char *IdealGraphPrinter::METHOD_SHORT_NAME_PROPERTY = "shortName";

const char *IdealGraphPrinter::CONTROL_FLOW_ELEMENT = "controlFlow";

const char *IdealGraphPrinter::BLOCK_NAME_PROPERTY = "name";

const char *IdealGraphPrinter::BLOCK_DOMINATOR_PROPERTY = "dom";

const char *IdealGraphPrinter::BLOCK_ELEMENT = "block";

const char *IdealGraphPrinter::SUCCESSORS_ELEMENT = "successors";

const char *IdealGraphPrinter::SUCCESSOR_ELEMENT = "successor";

const char *IdealGraphPrinter::ASSEMBLY_ELEMENT = "assembly";

int IdealGraphPrinter::_file_count = 0;

IdealGraphPrinter *IdealGraphPrinter::printer() {

  if (PrintIdealGraphLevel == 0) return NULL;

  JavaThread *thread = JavaThread::current();

  if (!thread->is_Compiler_thread()) return NULL;

  CompilerThread *compiler_thread = (CompilerThread *)thread;

  if (compiler_thread->ideal_graph_printer() == NULL) {

    IdealGraphPrinter *printer = new IdealGraphPrinter();

    compiler_thread->set_ideal_graph_printer(printer);

  }

  return compiler_thread->ideal_graph_printer();

}

void IdealGraphPrinter::clean_up() {

  JavaThread *p;

  for (p = Threads::first(); p; p = p->next()) {

    if (p->is_Compiler_thread()) {

      CompilerThread *c = (CompilerThread *)p;

      IdealGraphPrinter *printer = c->ideal_graph_printer();

      if (printer) {

        delete printer;

      }

      c->set_ideal_graph_printer(NULL);

    }

  }

}

// Constructor, either file or network output

IdealGraphPrinter::IdealGraphPrinter() {

  _traverse_outs = false;

  _should_send_method = true;

  _output = NULL;

  buffer[0] = 0;

  _depth = 0;

  _current_method = NULL;

  assert(!_current_method, "current method must be initialized to NULL");

  _arena = new Arena();

  _stream = new (ResourceObj::C_HEAP) networkStream();

  if (PrintIdealGraphFile != NULL) {

    ThreadCritical tc;

    // User wants all output to go to files

    if (_file_count != 0) {

      ResourceMark rm;

      stringStream st;

      const char* dot = strrchr(PrintIdealGraphFile, '.');

      if (dot) {

        st.write(PrintIdealGraphFile, dot - PrintIdealGraphFile);

        st.print("%d%s", _file_count, dot);

      } else {

        st.print("%s%d", PrintIdealGraphFile, _file_count);

      }

      _output = new (ResourceObj::C_HEAP) fileStream(st.as_string());

    } else {

      _output = new (ResourceObj::C_HEAP) fileStream(PrintIdealGraphFile);

    }

    _file_count++;

  } else {

    // Try to connect to visualizer

    if (_stream->connect(PrintIdealGraphAddress, PrintIdealGraphPort)) {

      char c = 0;

      _stream->read(&c, 1);

      if (c != 'y') {

        tty->print_cr("Client available, but does not want to receive data!");

        _stream->close();

        delete _stream;

        _stream = NULL;

        return;

      }

      _output = _stream;

    } else {

      // It would be nice if we could shut down cleanly but it should

      // be an error if we can't connect to the visualizer.

      fatal2("Couldn't connect to visualizer at %s:%d", PrintIdealGraphAddress, PrintIdealGraphPort);

    }

  }

  start_element(TOP_ELEMENT);

}

// Destructor, close file or network stream

IdealGraphPrinter::~IdealGraphPrinter() {

  end_element(TOP_ELEMENT);

  if (_stream) {

    delete _stream;

    if (_stream == _output) {

      _output = NULL;

    }

    _stream = NULL;

  }

  if (_output) {

    delete _output;

    _output = NULL;

  }

}

void IdealGraphPrinter::print_ifg(PhaseIFG* ifg) {

  // Code to print an interference graph to tty, currently not used

  /*

  if (!_current_method) return;

   // Remove neighbor colors

  for (uint i = 0; i < ifg._maxlrg; i++) {

    IndexSet *s = ifg.neighbors(i);

    IndexSetIterator elements(s);

    uint neighbor;

    while ((neighbor = elements.next()) != 0) {

        tty->print_cr("Edge between %d and %d\n", i, neighbor);

    }

  }

  for (uint i = 0; i < ifg._maxlrg; i++) {

    LRG &l = ifg.lrgs(i);

    if (l._def) {

      OptoReg::Name name = l.reg();

      tty->print("OptoReg::dump: ");

      OptoReg::dump(name);

      tty->print_cr("");

      tty->print_cr("name=%d\n", name);

      if (name) {

        if (OptoReg::is_stack(name)) {

          tty->print_cr("Stack number %d\n", OptoReg::reg2stack(name));

        } else if (!OptoReg::is_valid(name)) {

          tty->print_cr("BAD!!!");

        } else {

          if (OptoReg::is_reg(name)) {

          tty->print_cr(OptoReg::regname(name));

          } else {

            int x = 0;

          }

        }

        int x = 0;

      }

      if (l._def == NodeSentinel) {

        tty->print("multiple mapping from %d: ", i);

        for (int j=0; j<l._defs->length(); j++) {

          tty->print("%d ", l._defs->at(j)->_idx);

        }

        tty->print_cr("");

      } else {

        tty->print_cr("mapping between %d and %d\n", i, l._def->_idx);

      }

    }

  }*/

}

void IdealGraphPrinter::print_method(ciMethod *method, int bci, InlineTree *tree) {

  Properties properties;

  stringStream str;

  method->print_name(&str);

  stringStream shortStr;

  method->print_short_name(&shortStr);

  properties.add(new Property(METHOD_NAME_PROPERTY, str.as_string()));

  properties.add(new Property(METHOD_SHORT_NAME_PROPERTY, shortStr.as_string()));

  properties.add(new Property(METHOD_BCI_PROPERTY, bci));

  start_element(METHOD_ELEMENT, &properties);

  start_element(BYTECODES_ELEMENT);

  output()->print_cr("<![CDATA[");

  method->print_codes_on(output());

  output()->print_cr("]]>");

  end_element(BYTECODES_ELEMENT);

  start_element(INLINE_ELEMENT);

  if (tree != NULL) {

    GrowableArray<InlineTree *> subtrees = tree->subtrees();

    for (int i = 0; i < subtrees.length(); i++) {

      print_inline_tree(subtrees.at(i));

    }

  }

  end_element(INLINE_ELEMENT);

  end_element(METHOD_ELEMENT);

  output()->flush();

}

void IdealGraphPrinter::print_inline_tree(InlineTree *tree) {

  if (tree == NULL) return;

  ciMethod *method = tree->method();

  print_method(tree->method(), tree->caller_bci(), tree);

}

void IdealGraphPrinter::clear_nodes() {

 // for (int i = 0; i < _nodes.length(); i++) {

 //   _nodes.at(i)->clear_node();

 // }

}

void IdealGraphPrinter::print_inlining(Compile* compile) {

  // Print inline tree

  if (_should_send_method) {

    InlineTree *inlineTree = compile->ilt();

    if (inlineTree != NULL) {

      print_inline_tree(inlineTree);

    } else {

      // print this method only

    }

  }

}

// Has to be called whenever a method is compiled

void IdealGraphPrinter::begin_method(Compile* compile) {

  ciMethod *method = compile->method();

  assert(_output, "output stream must exist!");

  assert(method, "null methods are not allowed!");

  assert(!_current_method, "current method must be null!");

  _arena->destruct_contents();

  start_element(GROUP_ELEMENT);

  // Print properties

  Properties properties;

  // Add method name

  stringStream strStream;

  method->print_name(&strStream);

  properties.add(new Property(METHOD_NAME_PROPERTY, strStream.as_string()));

  if (method->flags().is_public()) {

    properties.add(new Property(METHOD_IS_PUBLIC_PROPERTY, TRUE_VALUE));

  }

  if (method->flags().is_static()) {

    properties.add(new Property(METHOD_IS_STATIC_PROPERTY, TRUE_VALUE));

  }

  properties.print(this);

  if (_stream) {

    char answer = 0;

    _stream->flush();

    int result = _stream->read(&answer, 1);

    _should_send_method = (answer == 'y');

  }

  this->_nodes = GrowableArray<NodeDescription *>(_arena, 2, 0, NULL);

  this->_edges = GrowableArray< EdgeDescription * >(_arena, 2, 0, NULL);

  this->_current_method = method;

  _output->flush();

}

// Has to be called whenever a method has finished compilation

void IdealGraphPrinter::end_method() {

//  if (finish && !in_method) return;

  nmethod* method = (nmethod*)this->_current_method->code();

  start_element(ASSEMBLY_ELEMENT);

 // Disassembler::decode(method, _output);

  end_element(ASSEMBLY_ELEMENT);

  end_element(GROUP_ELEMENT);

  _current_method = NULL;

  _output->flush();

  for (int i = 0; i < _nodes.length(); i++) {

    NodeDescription *desc = _nodes.at(i);

    if (desc) {

      delete desc;

      _nodes.at_put(i, NULL);

    }

  }

  this->_nodes.clear();

  for (int i = 0; i < _edges.length(); i++) {

   // for (int j=0; j<_edges.at(i)->length(); j++) {

      EdgeDescription *conn = _edges.at(i);

      conn->print(this);

      if (conn) {

        delete conn;

        _edges.at_put(i, NULL);

      }

    //}

    //_edges.at(i)->clear();

    //delete _edges.at(i);

    //_edges.at_put(i, NULL);

  }

  this->_edges.clear();

//  in_method = false;

}

// Outputs an XML start element

void IdealGraphPrinter::start_element(const char *s, Properties *properties /* = NULL */, bool print_indent /* = false */, bool print_return /* = true */) {

  start_element_helper(s, properties, false, print_indent, print_return);

  _depth++;

}

// Outputs an XML start element without body

void IdealGraphPrinter::simple_element(const char *s, Properties *properties /* = NULL */, bool print_indent /* = false */) {

  start_element_helper(s, properties, true, print_indent, true);

}

// Outputs an XML start element. If outputEnd is true, the element has no body.

void IdealGraphPrinter::start_element_helper(const char *s, Properties *properties, bool outputEnd, bool print_indent /* = false */, bool print_return /* = true */) {

  assert(_output, "output stream must exist!");

  if (print_indent) this->print_indent();

  _output->print("<");

  _output->print(s);

  if (properties) properties->print_as_attributes(this);

  if (outputEnd) {

    _output->print("/");

  }

  _output->print(">");

  if (print_return) _output->print_cr("");

}

// Print indent

void IdealGraphPrinter::print_indent() {

  for (int i = 0; i < _depth; i++) {

    _output->print(INDENT);

  }

}

// Outputs an XML end element

void IdealGraphPrinter::end_element(const char *s, bool print_indent /* = true */, bool print_return /* = true */) {

  assert(_output, "output stream must exist!");

  _depth--;

  if (print_indent) this->print_indent();

  _output->print("</");

  _output->print(s);

  _output->print(">");

  if (print_return) _output->print_cr("");

}

bool IdealGraphPrinter::traverse_outs() {

  return _traverse_outs;

}

void IdealGraphPrinter::set_traverse_outs(bool b) {

  _traverse_outs = b;

}

void IdealGraphPrinter::walk(Node *start) {

  VectorSet visited(Thread::current()->resource_area());

  GrowableArray<Node *> nodeStack(Thread::current()->resource_area(), 0, 0, NULL);

  nodeStack.push(start);

  visited.test_set(start->_idx);

  while(nodeStack.length() > 0) {

    Node *n = nodeStack.pop();

    IdealGraphPrinter::pre_node(n, this);

    if (_traverse_outs) {

      for (DUIterator i = n->outs(); n->has_out(i); i++) {

        Node* p = n->out(i);

        if (!visited.test_set(p->_idx)) {

          nodeStack.push(p);

        }

      }

    }

    for ( uint i = 0; i < n->len(); i++ ) {

      if ( n->in(i) ) {

        if (!visited.test_set(n->in(i)->_idx)) {

          nodeStack.push(n->in(i));

        }

      }

    }

  }

}

void IdealGraphPrinter::compress(int index, GrowableArray<Block>* blocks) {

  Block *block = blocks->adr_at(index);

  int ancestor = block->ancestor();

  assert(ancestor != -1, "");

  Block *ancestor_block = blocks->adr_at(ancestor);

  if (ancestor_block->ancestor() != -1) {

    compress(ancestor, blocks);

    int label = block->label();

    Block *label_block = blocks->adr_at(label);

    int ancestor_label = ancestor_block->label();

    Block *ancestor_label_block = blocks->adr_at(label);

    if (ancestor_label_block->semi() < label_block->semi()) {

      block->set_label(ancestor_label);

    }

    block->set_ancestor(ancestor_block->ancestor());

  }

}

int IdealGraphPrinter::eval(int index, GrowableArray<Block>* blocks) {

  Block *block = blocks->adr_at(index);

  if (block->ancestor() == -1) {

    return index;

  } else {

    compress(index, blocks);

    return block->label();

  }

}

void IdealGraphPrinter::link(int index1, int index2, GrowableArray<Block>* blocks) {

  Block *block2 = blocks->adr_at(index2);

  block2->set_ancestor(index1);

}

void IdealGraphPrinter::build_dominators(GrowableArray<Block>* blocks) {

  if (blocks->length() == 0) return;

  GrowableArray<int> stack;

  stack.append(0);

  GrowableArray<Block *> array;

  assert(blocks->length() > 0, "");

  blocks->adr_at(0)->set_dominator(0);

  int n = 0;

  while(!stack.is_empty()) {

    int index = stack.pop();