--- old/hotspot/src/share/vm/opto/idealGraphPrinter.cpp 2009-08-01 04:13:46.137165295 +0100 +++ new/hotspot/src/share/vm/opto/idealGraphPrinter.cpp 2009-08-01 04:13:46.055375477 +0100 @@ -1,8 +1,5 @@ -#ifdef USE_PRAGMA_IDENT_HDR -#pragma ident "@(#)idealGraphPrinter.cpp 1.2 07/10/02 11:32:04 JVM" -#endif /* - * Copyright 2007 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 2007-2008 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 @@ -22,7 +19,7 @@ * 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" @@ -103,16 +100,18 @@ // Constructor, either file or network output IdealGraphPrinter::IdealGraphPrinter() { - _traverse_outs = false; + // By default dump both ins and outs since dead or unreachable code + // needs to appear in the graph. There are also some special cases + // in the mach where kill projections have no users but should + // appear in the dump. + _traverse_outs = true; _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(); + _stream = NULL; if (PrintIdealGraphFile != NULL) { ThreadCritical tc; @@ -127,12 +126,16 @@ } else { st.print("%s%d", PrintIdealGraphFile, _file_count); } - _output = new (ResourceObj::C_HEAP) fileStream(st.as_string()); + fileStream *stream = new (ResourceObj::C_HEAP) fileStream(st.as_string()); + _output = stream; } else { - _output = new (ResourceObj::C_HEAP) fileStream(PrintIdealGraphFile); + fileStream *stream = new (ResourceObj::C_HEAP) fileStream(PrintIdealGraphFile); + _output = stream; } _file_count++; } else { + _stream = new (ResourceObj::C_HEAP) networkStream(); + // Try to connect to visualizer if (_stream->connect(PrintIdealGraphAddress, PrintIdealGraphPort)) { char c = 0; @@ -152,14 +155,25 @@ } } - start_element(TOP_ELEMENT); + _xml = new (ResourceObj::C_HEAP) xmlStream(_output); + + head(TOP_ELEMENT); } // Destructor, close file or network stream -IdealGraphPrinter::~IdealGraphPrinter() { - - end_element(TOP_ELEMENT); - +IdealGraphPrinter::~IdealGraphPrinter() { + + tail(TOP_ELEMENT); + + // tty->print_cr("Walk time: %d", (int)_walk_time.milliseconds()); + // tty->print_cr("Output time: %d", (int)_output_time.milliseconds()); + // tty->print_cr("Build blocks time: %d", (int)_build_blocks_time.milliseconds()); + + if(_xml) { + delete _xml; + _xml = NULL; + } + if (_stream) { delete _stream; if (_stream == _output) { @@ -174,94 +188,93 @@ } } -void IdealGraphPrinter::print_ifg(PhaseIFG* ifg) { - // Code to print an interference graph to tty, currently not used +void IdealGraphPrinter::begin_elem(const char *s) { + _xml->begin_elem(s); +} - /* - if (!_current_method) return; - // Remove neighbor colors +void IdealGraphPrinter::end_elem() { + _xml->end_elem(); +} - for (uint i = 0; i < ifg._maxlrg; i++) { +void IdealGraphPrinter::begin_head(const char *s) { + _xml->begin_head(s); +} - 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); - } - } +void IdealGraphPrinter::end_head() { + _xml->end_head(); +} - - 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 { +void IdealGraphPrinter::print_attr(const char *name, intptr_t val) { + stringStream stream; + stream.print(INTX_FORMAT, val); + print_attr(name, stream.as_string()); +} - if (OptoReg::is_reg(name)) { - tty->print_cr(OptoReg::regname(name)); - } else { - int x = 0; - } - } - int x = 0; - } +void IdealGraphPrinter::print_attr(const char *name, const char *val) { + _xml->print(" %s='", name); + text(val); + _xml->print("'"); +} - if (l._def == NodeSentinel) { - tty->print("multiple mapping from %d: ", i); - for (int j=0; jlength(); 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::head(const char *name) { + _xml->head(name); +} + +void IdealGraphPrinter::tail(const char *name) { + _xml->tail(name); +} + +void IdealGraphPrinter::text(const char *s) { + _xml->text(s); +} + +void IdealGraphPrinter::print_prop(const char *name, int val) { + + stringStream stream; + stream.print("%d", val); + print_prop(name, stream.as_string()); +} + +void IdealGraphPrinter::print_prop(const char *name, const char *val) { + begin_head(PROPERTY_ELEMENT); + print_attr(PROPERTY_NAME_PROPERTY, name); + end_head(); + text(val); + tail(PROPERTY_ELEMENT); } void IdealGraphPrinter::print_method(ciMethod *method, int bci, InlineTree *tree) { + begin_head(METHOD_ELEMENT); - Properties properties; stringStream str; method->print_name(&str); stringStream shortStr; method->print_short_name(&shortStr); + print_attr(METHOD_NAME_PROPERTY, str.as_string()); + print_attr(METHOD_SHORT_NAME_PROPERTY, shortStr.as_string()); + print_attr(METHOD_BCI_PROPERTY, bci); - 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); + end_head(); - start_element(BYTECODES_ELEMENT); + head(BYTECODES_ELEMENT); output()->print_cr("print_codes_on(output()); output()->print_cr("]]>"); - end_element(BYTECODES_ELEMENT); + tail(BYTECODES_ELEMENT); - start_element(INLINE_ELEMENT); + head(INLINE_ELEMENT); if (tree != NULL) { GrowableArray subtrees = tree->subtrees(); for (int i = 0; i < subtrees.length(); i++) { print_inline_tree(subtrees.at(i)); } } - end_element(INLINE_ELEMENT); + tail(INLINE_ELEMENT); - end_element(METHOD_ELEMENT); + tail(METHOD_ELEMENT); output()->flush(); } @@ -274,12 +287,6 @@ } -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 @@ -301,143 +308,56 @@ assert(method, "null methods are not allowed!"); assert(!_current_method, "current method must be null!"); - _arena->destruct_contents(); + head(GROUP_ELEMENT); - start_element(GROUP_ELEMENT); - - // Print properties - Properties properties; - + head(PROPERTIES_ELEMENT); + + // Print properties // Add method name stringStream strStream; method->print_name(&strStream); - properties.add(new Property(METHOD_NAME_PROPERTY, strStream.as_string())); + print_prop(METHOD_NAME_PROPERTY, strStream.as_string()); if (method->flags().is_public()) { - properties.add(new Property(METHOD_IS_PUBLIC_PROPERTY, TRUE_VALUE)); + print_prop(METHOD_IS_PUBLIC_PROPERTY, TRUE_VALUE); } if (method->flags().is_static()) { - properties.add(new Property(METHOD_IS_STATIC_PROPERTY, TRUE_VALUE)); + print_prop(METHOD_IS_STATIC_PROPERTY, TRUE_VALUE); } - properties.print(this); + tail(PROPERTIES_ELEMENT); if (_stream) { char answer = 0; - _stream->flush(); + _xml->flush(); int result = _stream->read(&answer, 1); _should_send_method = (answer == 'y'); } - this->_nodes = GrowableArray(_arena, 2, 0, NULL); - this->_edges = GrowableArray< EdgeDescription * >(_arena, 2, 0, NULL); - - this->_current_method = method; - - - _output->flush(); + _xml->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); + tail(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(""); - + _xml->flush(); } // Print indent void IdealGraphPrinter::print_indent() { + tty->print_cr("printing ident %d", _depth); for (int i = 0; i < _depth; i++) { - _output->print(INDENT); + _xml->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("print(s); - _output->print(">"); - if (print_return) _output->print_cr(""); - -} - bool IdealGraphPrinter::traverse_outs() { return _traverse_outs; } @@ -446,1477 +366,341 @@ _traverse_outs = b; } -void IdealGraphPrinter::walk(Node *start) { +intptr_t IdealGraphPrinter::get_node_id(Node *n) { + return (intptr_t)(n); +} - - VectorSet visited(Thread::current()->resource_area()); - GrowableArray 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); +void IdealGraphPrinter::visit_node(Node *n, void *param) { - 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); - } - } - } + if(param) { + // Output edge + intptr_t dest_id = get_node_id(n); 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)); - } + Node *source = n->in(i); + begin_elem(EDGE_ELEMENT); + intptr_t source_id = get_node_id(source); + print_attr(FROM_PROPERTY, source_id); + print_attr(TO_PROPERTY, dest_id); + print_attr(INDEX_PROPERTY, i); + end_elem(); } } - } -} - -void IdealGraphPrinter::compress(int index, GrowableArray* 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); + } else { - 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); - } + // Output node + begin_head(NODE_ELEMENT); + print_attr(NODE_ID_PROPERTY, get_node_id(n)); + end_head(); - block->set_ancestor(ancestor_block->ancestor()); - } -} + head(PROPERTIES_ELEMENT); -int IdealGraphPrinter::eval(int index, GrowableArray* blocks) { - Block *block = blocks->adr_at(index); - if (block->ancestor() == -1) { - return index; - } else { - compress(index, blocks); - return block->label(); - } -} + Node *node = n; +#ifndef PRODUCT + node->_in_dump_cnt++; + print_prop(NODE_NAME_PROPERTY, (const char *)node->Name()); + const Type *t = node->bottom_type(); + print_prop("type", (const char *)Type::msg[t->base()]); + print_prop("idx", node->_idx); +#ifdef ASSERT + print_prop("debug_idx", node->_debug_idx); +#endif -void IdealGraphPrinter::link(int index1, int index2, GrowableArray* blocks) { - Block *block2 = blocks->adr_at(index2); - block2->set_ancestor(index1); -} - -void IdealGraphPrinter::build_dominators(GrowableArray* blocks) { - - if (blocks->length() == 0) return; - - GrowableArray stack; - stack.append(0); - - GrowableArray array; - - assert(blocks->length() > 0, ""); - blocks->adr_at(0)->set_dominator(0); - - int n = 0; - while(!stack.is_empty()) { - int index = stack.pop(); - Block *block = blocks->adr_at(index); - block->set_semi(n); - array.append(block); - n = n + 1; - for (int i = 0; i < block->succs()->length(); i++) { - int succ_index = block->succs()->at(i); - Block *succ = blocks->adr_at(succ_index); - if (succ->semi() == -1) { - succ->set_parent(index); - stack.push(succ_index); + if(C->cfg() != NULL) { + Block *block = C->cfg()->_bbs[node->_idx]; + if(block == NULL) { + print_prop("block", C->cfg()->_blocks[0]->_pre_order); + } else { + print_prop("block", block->_pre_order); } - succ->add_pred(index); } - } - for (int i=n-1; i>0; i--) { - Block *block = array.at(i); - int block_index = block->index(); - for (int j=0; jpred()->length(); j++) { - int pred_index = block->pred()->at(j); - int cur_index = eval(pred_index, blocks); - - Block *cur_block = blocks->adr_at(cur_index); - if (cur_block->semi() < block->semi()) { - block->set_semi(cur_block->semi()); - } + const jushort flags = node->flags(); + if (flags & Node::Flag_is_Copy) { + print_prop("is_copy", "true"); } - - int semi_index = block->semi(); - Block *semi_block = array.at(semi_index); - semi_block->add_to_bucket(block_index); - - link(block->parent(), block_index, blocks); - Block *parent_block = blocks->adr_at(block->parent()); - - for (int j=0; jbucket()->length(); j++) { - int cur_index = parent_block->bucket()->at(j); - int new_index = eval(cur_index, blocks); - Block *cur_block = blocks->adr_at(cur_index); - Block *new_block = blocks->adr_at(new_index); - int dom = block->parent(); - - if (new_block->semi() < cur_block->semi()) { - dom = new_index; - } - - cur_block->set_dominator(dom); + if (flags & Node::Flag_is_Call) { + print_prop("is_call", "true"); } - - parent_block->clear_bucket(); - } - - for (int i=1; i < n; i++) { - - Block *block = array.at(i); - int block_index = block->index(); - - int semi_index = block->semi(); - Block *semi_block = array.at(semi_index); - - if (block->dominator() != semi_block->index()) { - int new_dom = blocks->adr_at(block->dominator())->dominator(); - block->set_dominator(new_dom); + if (flags & Node::Flag_rematerialize) { + print_prop("rematerialize", "true"); } - } - - for (int i = 0; i < blocks->length(); i++) { - if (blocks->adr_at(i)->dominator() == -1) { - blocks->adr_at(i)->set_dominator(0); + if (flags & Node::Flag_needs_anti_dependence_check) { + print_prop("needs_anti_dependence_check", "true"); } - } - - // Build dominates array - for (int i=1; i < blocks->length(); i++) { - Block *block = blocks->adr_at(i); - int dominator = block->dominator(); - Block *dom_block = blocks->adr_at(dominator); - dom_block->add_dominates(i); - dom_block->add_child(i); - - while(dominator != 0) { - dominator = dom_block->dominator(); - dom_block = blocks->adr_at(dominator); - dom_block->add_child(i); + if (flags & Node::Flag_is_macro) { + print_prop("is_macro", "true"); } - } -} - -void IdealGraphPrinter::build_common_dominator(int **common_dominator, int index, GrowableArray* blocks) { - - common_dominator[index][index] = index; - Block *block = blocks->adr_at(index); - for (int i = 0; i < block->dominates()->length(); i++) { - Block *dominated = blocks->adr_at(block->dominates()->at(i)); - - for (int j=0; jchildren()->length(); j++) { - Block *child = blocks->adr_at(dominated->children()->at(j)); - common_dominator[index][child->index()] = common_dominator[child->index()][index] = index; - - for (int k=0; kadr_at(block->dominates()->at(k)); - common_dominator[child->index()][other_dominated->index()] = common_dominator[other_dominated->index()][child->index()] = index; - - for (int l=0 ; lchildren()->length(); l++) { - Block *other_child = blocks->adr_at(other_dominated->children()->at(l)); - common_dominator[child->index()][other_child->index()] = common_dominator[other_child->index()][child->index()] = index; - } - } + if (flags & Node::Flag_is_Con) { + print_prop("is_con", "true"); } - - build_common_dominator(common_dominator, dominated->index(), blocks); - } -} - -void IdealGraphPrinter::schedule_latest(int **common_dominator, GrowableArray* blocks) { - - int queue_size = _nodes.length() + 1; - NodeDescription **queue = NEW_RESOURCE_ARRAY(NodeDescription *, queue_size); - int queue_start = 0; - int queue_end = 0; - Arena *a = new Arena(); - VectorSet on_queue(a); - - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc) { - desc->init_succs(); + if (flags & Node::Flag_is_cisc_alternate) { + print_prop("is_cisc_alternate", "true"); } - } - - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc) { - for (uint j=0; jnode()->len(); j++) { - Node *n = desc->node()->in(j); - if (n) { - NodeDescription *other_desc = _nodes.at(n->_idx); - other_desc->add_succ(desc); - } - } + if (flags & Node::Flag_is_Branch) { + print_prop("is_branch", "true"); + } + if (flags & Node::Flag_is_block_start) { + print_prop("is_block_start", "true"); + } + if (flags & Node::Flag_is_Goto) { + print_prop("is_goto", "true"); + } + if (flags & Node::Flag_is_dead_loop_safe) { + print_prop("is_dead_loop_safe", "true"); + } + if (flags & Node::Flag_may_be_short_branch) { + print_prop("may_be_short_branch", "true"); + } + if (flags & Node::Flag_is_safepoint_node) { + print_prop("is_safepoint_node", "true"); + } + if (flags & Node::Flag_is_pc_relative) { + print_prop("is_pc_relative", "true"); } - } - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc && desc->block_index() == -1) { - - // Put Phi into same block as region - if (desc->node()->is_Phi() && desc->node()->in(0) && _nodes.at(desc->node()->in(0)->_idx)->block_index() != -1) { - int index = _nodes.at(desc->node()->in(0)->_idx)->block_index(); - desc->set_block_index(index); - blocks->adr_at(index)->add_node(desc); - - // Put Projections to same block as parent - } else if (desc->node()->is_block_proj() && _nodes.at(desc->node()->is_block_proj()->_idx)->block_index() != -1) { - int index = _nodes.at(desc->node()->is_block_proj()->_idx)->block_index(); - desc->set_block_index(index); - blocks->adr_at(index)->add_node(desc); + if (C->matcher() != NULL) { + if (C->matcher()->is_shared(node)) { + print_prop("is_shared", "true"); } else { - queue[queue_end] = desc; - queue_end++; - on_queue.set(desc->node()->_idx); + print_prop("is_shared", "false"); } - } - } - - - int z = 0; - while(queue_start != queue_end && z < 10000) { - - NodeDescription *desc = queue[queue_start]; - queue_start = (queue_start + 1) % queue_size; - on_queue >>= desc->node()->_idx; - - Node* node = desc->node(); - - if (desc->succs()->length() == 0) { - int x = 0; - } - - int block_index = -1; - if (desc->succs()->length() != 0) { - for (int i = 0; i < desc->succs()->length(); i++) { - NodeDescription *cur_desc = desc->succs()->at(i); - if (cur_desc != desc) { - if (cur_desc->succs()->length() == 0) { - - // Ignore nodes with 0 successors - - } else if (cur_desc->block_index() == -1) { - - // Let this node schedule first - block_index = -1; - break; - - } else if (cur_desc->node()->is_Phi()){ - - // Special treatment for Phi functions - PhiNode *phi = cur_desc->node()->as_Phi(); - assert(phi->in(0) && phi->in(0)->is_Region(), "Must have region node in first input"); - RegionNode *region = phi->in(0)->as_Region(); - - for (uint j=1; jlen(); j++) { - Node *cur_phi_input = phi->in(j); - if (cur_phi_input == desc->node() && region->in(j)) { - NodeDescription *cur_region_input = _nodes.at(region->in(j)->_idx); - if (cur_region_input->block_index() == -1) { - - // Let this node schedule first - block_index = -1; - break; - } else { - if (block_index == -1) { - block_index = cur_region_input->block_index(); - } else { - block_index = common_dominator[block_index][cur_region_input->block_index()]; - } - } - } - } - - } else { - if (block_index == -1) { - block_index = cur_desc->block_index(); - } else { - block_index = common_dominator[block_index][cur_desc->block_index()]; - } - } - } + if (C->matcher()->is_dontcare(node)) { + print_prop("is_dontcare", "true"); + } else { + print_prop("is_dontcare", "false"); } - } - if (block_index == -1) { - queue[queue_end] = desc; - queue_end = (queue_end + 1) % queue_size; - on_queue.set(desc->node()->_idx); - z++; - } else { - assert(desc->block_index() == -1, ""); - desc->set_block_index(block_index); - blocks->adr_at(block_index)->add_node(desc); - z = 0; +#ifdef ASSERT + Node* old = C->matcher()->find_old_node(node); + if (old != NULL) { + print_prop("old_node_idx", old->_idx); + } +#endif } - } - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc && desc->block_index() == -1) { - - //if (desc->node()->is_Proj() || desc->node()->is_Con()) { - Node *parent = desc->node()->in(0); - uint cur = 1; - while(!parent && cur < desc->node()->len()) { - parent = desc->node()->in(cur); - cur++; - } - - if (parent && _nodes.at(parent->_idx)->block_index() != -1) { - int index = _nodes.at(parent->_idx)->block_index(); - desc->set_block_index(index); - blocks->adr_at(index)->add_node(desc); - } else { - desc->set_block_index(0); - blocks->adr_at(0)->add_node(desc); - //ShouldNotReachHere(); - } - //} - /* - if (desc->node()->is_block_proj() && _nodes.at(desc->node()->is_block_proj()->_idx)->block_index() != -1) { - int index = _nodes.at(desc->node()->is_block_proj()->_idx)->block_index(); - desc->set_block_index(index); - blocks->adr_at(index)->add_node(desc); - } */ + if (node->is_Proj()) { + print_prop("con", (int)node->as_Proj()->_con); } - } - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc) { - desc->clear_succs(); + if (node->is_Mach()) { + print_prop("idealOpcode", (const char *)NodeClassNames[node->as_Mach()->ideal_Opcode()]); } - } - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc) { - int block_index = desc->block_index(); + buffer[0] = 0; + stringStream s2(buffer, sizeof(buffer) - 1); - assert(block_index >= 0 && block_index < blocks->length(), "Block index must be in range"); - assert(blocks->adr_at(block_index)->nodes()->contains(desc), "Node must be child of block"); + node->dump_spec(&s2); + if (t != NULL && (t->isa_instptr() || t->isa_klassptr())) { + const TypeInstPtr *toop = t->isa_instptr(); + const TypeKlassPtr *tkls = t->isa_klassptr(); + ciKlass* klass = toop ? toop->klass() : (tkls ? tkls->klass() : NULL ); + if( klass && klass->is_loaded() && klass->is_interface() ) { + s2.print(" Interface:"); + } else if( toop ) { + s2.print(" Oop:"); + } else if( tkls ) { + s2.print(" Klass:"); + } + t->dump_on(&s2); + } else if( t == Type::MEMORY ) { + s2.print(" Memory:"); + MemNode::dump_adr_type(node, node->adr_type(), &s2); } - } - a->destruct_contents(); -} - -void IdealGraphPrinter::build_blocks(Node *root) { - - Arena *a = new Arena(); - Node_Stack stack(a, 100); - - VectorSet visited(a); - stack.push(root, 0); - GrowableArray blocks(a, 2, 0, Block(0)); - - for (int i = 0; i < _nodes.length(); i++) { - if (_nodes.at(i)) _nodes.at(i)->set_block_index(-1); - } + assert(s2.size() < sizeof(buffer), "size in range"); + print_prop("dump_spec", buffer); - // Order nodes such that node index is equal to idx - for (int i = 0; i < _nodes.length(); i++) { - - if (_nodes.at(i)) { - NodeDescription *node = _nodes.at(i); - int index = node->node()->_idx; - if (index != i) { - _nodes.at_grow(index); - NodeDescription *tmp = _nodes.at(index); - *(_nodes.adr_at(index)) = node; - *(_nodes.adr_at(i)) = tmp; - i--; - } + if (node->is_block_proj()) { + print_prop("is_block_proj", "true"); } - } - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *node = _nodes.at(i); - if (node) { - assert(node->node()->_idx == (uint)i, ""); + if (node->is_block_start()) { + print_prop("is_block_start", "true"); } - } - - while(stack.is_nonempty()) { - //Node *n = stack.node(); - //int index = stack.index(); - Node *proj = stack.node();//n->in(index); - const Node *parent = proj->is_block_proj(); - if (parent == NULL) { - parent = proj; - } - - if (!visited.test_set(parent->_idx)) { - - NodeDescription *end_desc = _nodes.at(parent->_idx); - int block_index = blocks.length(); - Block block(block_index); - blocks.append(block); - Block *b = blocks.adr_at(block_index); - b->set_start(end_desc); - // assert(end_desc->block_index() == -1, ""); - end_desc->set_block_index(block_index); - b->add_node(end_desc); - - // Skip any control-pinned middle'in stuff - Node *p = proj; - NodeDescription *start_desc = NULL; - do { - proj = p; // Update pointer to last Control - if (p->in(0) == NULL) { - start_desc = end_desc; - break; - } - p = p->in(0); // Move control forward - start_desc = _nodes.at(p->_idx); - assert(start_desc, ""); - - if (start_desc != end_desc && start_desc->block_index() == -1) { - assert(start_desc->block_index() == -1, ""); - assert(block_index < blocks.length(), ""); - start_desc->set_block_index(block_index); - b->add_node(start_desc); - } - } while( !p->is_block_proj() && - !p->is_block_start() ); - - for (uint i = 0; i < start_desc->node()->len(); i++) { - - Node *pred_node = start_desc->node()->in(i); - - - if (pred_node && pred_node != start_desc->node()) { - const Node *cur_parent = pred_node->is_block_proj(); - if (cur_parent != NULL) { - pred_node = (Node *)cur_parent; - } - - NodeDescription *pred_node_desc = _nodes.at(pred_node->_idx); - if (pred_node_desc->block_index() != -1) { - blocks.adr_at(pred_node_desc->block_index())->add_succ(block_index); - } - } + const char *short_name = "short_name"; + if (strcmp(node->Name(), "Parm") == 0 && node->as_Proj()->_con >= TypeFunc::Parms) { + int index = node->as_Proj()->_con - TypeFunc::Parms; + if (index >= 10) { + print_prop(short_name, "PA"); + } else { + sprintf(buffer, "P%d", index); + print_prop(short_name, buffer); } - - for (DUIterator_Fast dmax, i = end_desc->node()->fast_outs(dmax); i < dmax; i++) { - Node* cur_succ = end_desc->node()->fast_out(i); - NodeDescription *cur_succ_desc = _nodes.at(cur_succ->_idx); - - DUIterator_Fast dmax2, i2 = cur_succ->fast_outs(dmax2); - if (cur_succ->is_block_proj() && i2 < dmax2 && !cur_succ->is_Root()) { - - for (; i2fast_out(i2); - if (cur_succ2) { - cur_succ_desc = _nodes.at(cur_succ2->_idx); - if (cur_succ_desc == NULL) { - // dead node so skip it - continue; - } - if (cur_succ2 != end_desc->node() && cur_succ_desc->block_index() != -1) { - b->add_succ(cur_succ_desc->block_index()); - } - } - } - + } else if (strcmp(node->Name(), "IfTrue") == 0) { + print_prop(short_name, "T"); + } else if (strcmp(node->Name(), "IfFalse") == 0) { + print_prop(short_name, "F"); + } else if ((node->is_Con() && node->is_Type()) || node->is_Proj()) { + + if (t->base() == Type::Int && t->is_int()->is_con()) { + const TypeInt *typeInt = t->is_int(); + assert(typeInt->is_con(), "must be constant"); + jint value = typeInt->get_con(); + + // max. 2 chars allowed + if (value >= -9 && value <= 99) { + sprintf(buffer, "%d", value); + print_prop(short_name, buffer); } else { - - if (cur_succ != end_desc->node() && cur_succ_desc && cur_succ_desc->block_index() != -1) { - b->add_succ(cur_succ_desc->block_index()); - } + print_prop(short_name, "I"); } - } - - - int num_preds = p->len(); - int bottom = -1; - if (p->is_Region() || p->is_Phi()) { - bottom = 0; - } - - int pushed = 0; - for (int i=num_preds - 1; i > bottom; i--) { - if (p->in(i) != NULL && p->in(i) != p) { - stack.push(p->in(i), 0); - pushed++; + } else if (t == Type::TOP) { + print_prop(short_name, "^"); + } else if (t->base() == Type::Long && t->is_long()->is_con()) { + const TypeLong *typeLong = t->is_long(); + assert(typeLong->is_con(), "must be constant"); + jlong value = typeLong->get_con(); + + // max. 2 chars allowed + if (value >= -9 && value <= 99) { + sprintf(buffer, "%d", value); + print_prop(short_name, buffer); + } else { + print_prop(short_name, "L"); } + } else if (t->base() == Type::KlassPtr) { + const TypeKlassPtr *typeKlass = t->is_klassptr(); + print_prop(short_name, "CP"); + } else if (t->base() == Type::Control) { + print_prop(short_name, "C"); + } else if (t->base() == Type::Memory) { + print_prop(short_name, "M"); + } else if (t->base() == Type::Abio) { + print_prop(short_name, "IO"); + } else if (t->base() == Type::Return_Address) { + print_prop(short_name, "RA"); + } else if (t->base() == Type::AnyPtr) { + print_prop(short_name, "P"); + } else if (t->base() == Type::RawPtr) { + print_prop(short_name, "RP"); + } else if (t->base() == Type::AryPtr) { + print_prop(short_name, "AP"); } + } - if (pushed == 0 && p->is_Root() && !_matcher) { - // Special case when backedges to root are not yet built - for (int i = 0; i < _nodes.length(); i++) { - if (_nodes.at(i) && _nodes.at(i)->node()->is_SafePoint() && _nodes.at(i)->node()->outcnt() == 0) { - stack.push(_nodes.at(i)->node(), 0); - } - } + JVMState* caller = NULL; + if (node->is_SafePoint()) { + caller = node->as_SafePoint()->jvms(); + } else { + Node_Notes* notes = C->node_notes_at(node->_idx); + if (notes != NULL) { + caller = notes->jvms(); } + } - } else { - stack.pop(); + if (caller != NULL) { + stringStream bciStream; + while(caller) { + bciStream.print("%d ", caller->bci()); + caller = caller->caller(); + } + print_prop("bci", bciStream.as_string()); } - } - build_dominators(&blocks); + if (_chaitin && _chaitin != (PhaseChaitin *)0xdeadbeef) { + buffer[0] = 0; + _chaitin->dump_register(node, buffer); + print_prop("reg", buffer); + print_prop("lrg", _chaitin->n2lidx(node)); + } - int **common_dominator = NEW_RESOURCE_ARRAY(int *, blocks.length()); - for (int i = 0; i < blocks.length(); i++) { - int *cur = NEW_RESOURCE_ARRAY(int, blocks.length()); - common_dominator[i] = cur; + node->_in_dump_cnt--; +#endif - for (int j=0; jadd_child(blocks.adr_at(i)->index()); - } - build_common_dominator(common_dominator, 0, &blocks); +void IdealGraphPrinter::walk_nodes(Node *start, void *param) { - schedule_latest(common_dominator, &blocks); - start_element(CONTROL_FLOW_ELEMENT); + VectorSet visited(Thread::current()->resource_area()); + GrowableArray nodeStack(Thread::current()->resource_area(), 0, 0, NULL); + nodeStack.push(start); + visited.test_set(start->_idx); + while(nodeStack.length() > 0) { - for (int i = 0; i < blocks.length(); i++) { - Block *block = blocks.adr_at(i); + Node *n = nodeStack.pop(); + visit_node(n, param); - Properties props; - props.add(new Property(BLOCK_NAME_PROPERTY, i)); - props.add(new Property(BLOCK_DOMINATOR_PROPERTY, block->dominator())); - start_element(BLOCK_ELEMENT, &props); - - if (block->succs()->length() > 0) { - start_element(SUCCESSORS_ELEMENT); - for (int j=0; jsuccs()->length(); j++) { - int cur_index = block->succs()->at(j); - if (cur_index != 0 /* start_block has must not have inputs */) { - Properties properties; - properties.add(new Property(BLOCK_NAME_PROPERTY, cur_index)); - simple_element(SUCCESSOR_ELEMENT, &properties); + 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); } } - end_element(SUCCESSORS_ELEMENT); } - start_element(NODES_ELEMENT); - - for (int j=0; jnodes()->length(); j++) { - NodeDescription *n = block->nodes()->at(j); - Properties properties; - properties.add(new Property(NODE_ID_PROPERTY, n->id())); - simple_element(NODE_ELEMENT, &properties); + 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)); + } + } } - - end_element(NODES_ELEMENT); - - end_element(BLOCK_ELEMENT); } - - - end_element(CONTROL_FLOW_ELEMENT); - - a->destruct_contents(); } void IdealGraphPrinter::print_method(Compile* compile, const char *name, int level, bool clear_nodes) { - print(compile, name, (Node *)compile->root(), level, clear_nodes); + print(compile, name, (Node *)compile->root(), level, clear_nodes); } // Print current ideal graph void IdealGraphPrinter::print(Compile* compile, const char *name, Node *node, int level, bool clear_nodes) { -// if (finish && !in_method) return; if (!_current_method || !_should_send_method || level > PrintIdealGraphLevel) return; - assert(_current_method, "newMethod has to be called first!"); - - if (clear_nodes) { - int x = 0; - } - - _clear_nodes = clear_nodes; + this->C = compile; // Warning, unsafe cast? - _chaitin = (PhaseChaitin *)compile->regalloc(); - _matcher = compile->matcher(); + _chaitin = (PhaseChaitin *)C->regalloc(); + begin_head(GRAPH_ELEMENT); + print_attr(GRAPH_NAME_PROPERTY, (const char *)name); + end_head(); - // Update nodes - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc) { - desc->set_state(Invalid); - } - } - Node *n = node; - walk(n); - - // Update edges - for (int i = 0; i < _edges.length(); i++) { - _edges.at(i)->set_state(Invalid); - } - - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc && desc->state() != Invalid) { - - int to = desc->id(); - uint len = desc->node()->len(); - for (uint j=0; jnode()->in(j); - - if (n) { - - - intptr_t from = (intptr_t)n; - - // Assert from node is valid - /* - bool ok = false; - for (int k=0; k<_nodes.length(); k++) { - NodeDescription *desc = _nodes.at(k); - if (desc && desc->id() == from) { - assert(desc->state() != Invalid, ""); - ok = true; - } - } - assert(ok, "");*/ - - uint index = j; - if (index >= desc->node()->req()) { - index = desc->node()->req(); - } - - print_edge(from, to, index); - } - } - } - } + head(NODES_ELEMENT); + walk_nodes(node, NULL); + tail(NODES_ELEMENT); - bool is_different = false; - - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc && desc->state() != Valid) { - is_different = true; - break; - } - } + head(EDGES_ELEMENT); + walk_nodes(node, (void *)1); + tail(EDGES_ELEMENT); + if (C->cfg() != NULL) { + head(CONTROL_FLOW_ELEMENT); + for (uint i = 0; i < C->cfg()->_blocks.size(); i++) { + Block *b = C->cfg()->_blocks[i]; + begin_head(BLOCK_ELEMENT); + print_attr(BLOCK_NAME_PROPERTY, b->_pre_order); + end_head(); - if (!is_different) { - for (int i = 0; i < _edges.length(); i++) { - EdgeDescription *conn = _edges.at(i); - if (conn && conn->state() != Valid) { - is_different = true; - break; + head(SUCCESSORS_ELEMENT); + for (uint s = 0; s < C->cfg()->_blocks[i]->_num_succs; s++) { + begin_elem(SUCCESSOR_ELEMENT); + print_attr(BLOCK_NAME_PROPERTY, b->_succs[s]->_pre_order); + end_elem(); } - } - } - - // No changes -> do not print graph - if (!is_different) return; + tail(SUCCESSORS_ELEMENT); - Properties properties; - properties.add(new Property(GRAPH_NAME_PROPERTY, (const char *)name)); - start_element(GRAPH_ELEMENT, &properties); - - start_element(NODES_ELEMENT); - for (int i = 0; i < _nodes.length(); i++) { - NodeDescription *desc = _nodes.at(i); - if (desc) { - desc->print(this); - if (desc->state() == Invalid) { - delete desc; - _nodes.at_put(i, NULL); - } else { - desc->set_state(Valid); - } + tail(BLOCK_ELEMENT); } - } - end_element(NODES_ELEMENT); - - build_blocks(node); - - start_element(EDGES_ELEMENT); - for (int i = 0; i < _edges.length(); i++) { - EdgeDescription *conn = _edges.at(i); - - // Assert from and to nodes are valid - /* - if (!conn->state() == Invalid) { - bool ok1 = false; - bool ok2 = false; - for (int j=0; j<_nodes.length(); j++) { - NodeDescription *desc = _nodes.at(j); - if (desc && desc->id() == conn->from()) { - ok1 = true; - } - - if (desc && desc->id() == conn->to()) { - ok2 = true; - } - } - assert(ok1, "from node not found!"); - assert(ok2, "to node not found!"); - }*/ - - conn->print(this); - if (conn->state() == Invalid) { - _edges.remove_at(i); - delete conn; - i--; - } + tail(CONTROL_FLOW_ELEMENT); } - - end_element(EDGES_ELEMENT); - - end_element(GRAPH_ELEMENT); - - _output->flush(); + tail(GRAPH_ELEMENT); + output()->flush(); } -// Print edge -void IdealGraphPrinter::print_edge(int from, int to, int index) { - - EdgeDescription *conn = new EdgeDescription(from, to, index); - for (int i = 0; i < _edges.length(); i++) { - if (_edges.at(i)->equals(conn)) { - conn->set_state(Valid); - delete _edges.at(i); - _edges.at_put(i, conn); - return; - } - } - - _edges.append(conn); -} - -extern const char *NodeClassNames[]; - -// Create node description -IdealGraphPrinter::NodeDescription *IdealGraphPrinter::create_node_description(Node* node) { - -#ifndef PRODUCT - node->_in_dump_cnt++; - NodeDescription *desc = new NodeDescription(node); - desc->properties()->add(new Property(NODE_NAME_PROPERTY, (const char *)node->Name())); - - const Type *t = node->bottom_type(); - desc->properties()->add(new Property("type", (const char *)Type::msg[t->base()])); - - desc->properties()->add(new Property("idx", node->_idx)); -#ifdef ASSERT - desc->properties()->add(new Property("debug_idx", node->_debug_idx)); -#endif - - - const jushort flags = node->flags(); - if (flags & Node::Flag_is_Copy) { - desc->properties()->add(new Property("is_copy", "true")); - } - if (flags & Node::Flag_is_Call) { - desc->properties()->add(new Property("is_call", "true")); - } - if (flags & Node::Flag_rematerialize) { - desc->properties()->add(new Property("rematerialize", "true")); - } - if (flags & Node::Flag_needs_anti_dependence_check) { - desc->properties()->add(new Property("needs_anti_dependence_check", "true")); - } - if (flags & Node::Flag_is_macro) { - desc->properties()->add(new Property("is_macro", "true")); - } - if (flags & Node::Flag_is_Con) { - desc->properties()->add(new Property("is_con", "true")); - } - if (flags & Node::Flag_is_cisc_alternate) { - desc->properties()->add(new Property("is_cisc_alternate", "true")); - } - if (flags & Node::Flag_is_Branch) { - desc->properties()->add(new Property("is_branch", "true")); - } - if (flags & Node::Flag_is_block_start) { - desc->properties()->add(new Property("is_block_start", "true")); - } - if (flags & Node::Flag_is_Goto) { - desc->properties()->add(new Property("is_goto", "true")); - } - if (flags & Node::Flag_is_dead_loop_safe) { - desc->properties()->add(new Property("is_dead_loop_safe", "true")); - } - if (flags & Node::Flag_may_be_short_branch) { - desc->properties()->add(new Property("may_be_short_branch", "true")); - } - if (flags & Node::Flag_is_safepoint_node) { - desc->properties()->add(new Property("is_safepoint_node", "true")); - } - if (flags & Node::Flag_is_pc_relative) { - desc->properties()->add(new Property("is_pc_relative", "true")); - } - - if (_matcher) { - if (_matcher->is_shared(desc->node())) { - desc->properties()->add(new Property("is_shared", "true")); - } else { - desc->properties()->add(new Property("is_shared", "false")); - } - - if (_matcher->is_dontcare(desc->node())) { - desc->properties()->add(new Property("is_dontcare", "true")); - } else { - desc->properties()->add(new Property("is_dontcare", "false")); - } - } - - if (node->is_Proj()) { - desc->properties()->add(new Property("con", (int)node->as_Proj()->_con)); - } - - if (node->is_Mach()) { - desc->properties()->add(new Property("idealOpcode", (const char *)NodeClassNames[node->as_Mach()->ideal_Opcode()])); - } - - - - - - outputStream *oldTty = tty; - buffer[0] = 0; - stringStream s2(buffer, sizeof(buffer) - 1); - - node->dump_spec(&s2); - assert(s2.size() < sizeof(buffer), "size in range"); - desc->properties()->add(new Property("dump_spec", buffer)); - - if (node->is_block_proj()) { - desc->properties()->add(new Property("is_block_proj", "true")); - } - - if (node->is_block_start()) { - desc->properties()->add(new Property("is_block_start", "true")); - } - - const char *short_name = "short_name"; - if (strcmp(node->Name(), "Parm") == 0 && node->as_Proj()->_con >= TypeFunc::Parms) { - int index = node->as_Proj()->_con - TypeFunc::Parms; - if (index >= 10) { - desc->properties()->add(new Property(short_name, "PA")); - } else { - sprintf(buffer, "P%d", index); - desc->properties()->add(new Property(short_name, buffer)); - } - } else if (strcmp(node->Name(), "IfTrue") == 0) { - desc->properties()->add(new Property(short_name, "T")); - } else if (strcmp(node->Name(), "IfFalse") == 0) { - desc->properties()->add(new Property(short_name, "F")); - } else if ((node->is_Con() && node->is_Type()) || node->is_Proj()) { - - if (t->base() == Type::Int && t->is_int()->is_con()) { - const TypeInt *typeInt = t->is_int(); - assert(typeInt->is_con(), "must be constant"); - jint value = typeInt->get_con(); - - // max. 2 chars allowed - if (value >= -9 && value <= 99) { - sprintf(buffer, "%d", value); - desc->properties()->add(new Property(short_name, buffer)); - } - else - { - desc->properties()->add(new Property(short_name, "I")); - } - } else if (t == Type::TOP) { - desc->properties()->add(new Property(short_name, "^")); - } else if (t->base() == Type::Long && t->is_long()->is_con()) { - const TypeLong *typeLong = t->is_long(); - assert(typeLong->is_con(), "must be constant"); - jlong value = typeLong->get_con(); - - // max. 2 chars allowed - if (value >= -9 && value <= 99) { - sprintf(buffer, "%d", value); - desc->properties()->add(new Property(short_name, buffer)); - } - else - { - desc->properties()->add(new Property(short_name, "L")); - } - } else if (t->base() == Type::KlassPtr) { - const TypeKlassPtr *typeKlass = t->is_klassptr(); - desc->properties()->add(new Property(short_name, "CP")); - } else if (t->base() == Type::Control) { - desc->properties()->add(new Property(short_name, "C")); - } else if (t->base() == Type::Memory) { - desc->properties()->add(new Property(short_name, "M")); - } else if (t->base() == Type::Abio) { - desc->properties()->add(new Property(short_name, "IO")); - } else if (t->base() == Type::Return_Address) { - desc->properties()->add(new Property(short_name, "RA")); - } else if (t->base() == Type::AnyPtr) { - desc->properties()->add(new Property(short_name, "P")); - } else if (t->base() == Type::RawPtr) { - desc->properties()->add(new Property(short_name, "RP")); - } else if (t->base() == Type::AryPtr) { - desc->properties()->add(new Property(short_name, "AP")); - } - } - - if (node->is_SafePoint()) { - SafePointNode *safePointNode = node->as_SafePoint(); - if (safePointNode->jvms()) { - stringStream bciStream; - bciStream.print("%d ", safePointNode->jvms()->bci()); - JVMState *caller = safePointNode->jvms()->caller(); - while(caller) { - bciStream.print("%d ", caller->bci()); - - caller = caller->caller(); - } - desc->properties()->add(new Property("bci", bciStream.as_string())); - } - } - - if (_chaitin && _chaitin != (PhaseChaitin *)0xdeadbeef) { - buffer[0] = 0; - _chaitin->dump_register(node, buffer); - desc->properties()->add(new Property("reg", buffer)); - desc->properties()->add(new Property("lrg", _chaitin->n2lidx(node))); - } - - - node->_in_dump_cnt--; - return desc; -#else - return NULL; -#endif -} - -void IdealGraphPrinter::pre_node(Node* node, void *env) { - - IdealGraphPrinter *printer = (IdealGraphPrinter *)env; - - NodeDescription *newDesc = printer->create_node_description(node); - - if (printer->_clear_nodes) { - - printer->_nodes.append(newDesc); - } else { - - NodeDescription *desc = printer->_nodes.at_grow(node->_idx, NULL); - - if (desc && desc->equals(newDesc)) { - //desc->set_state(Valid); - //desc->set_node(node); - delete desc; - printer->_nodes.at_put(node->_idx, NULL); - newDesc->set_state(Valid); - //printer->_nodes.at_put(node->_idx, newDesc); - } else { - - if (desc && desc->id() == newDesc->id()) { - delete desc; - printer->_nodes.at_put(node->_idx, NULL); - newDesc->set_state(New); - - } - - //if (desc) { - // delete desc; - //} - - //printer->_nodes.at_put(node->_idx, newDesc); - } - - printer->_nodes.append(newDesc); - } -} - -void IdealGraphPrinter::post_node(Node* node, void *env) { -} +extern const char *NodeClassNames[]; outputStream *IdealGraphPrinter::output() { - return _output; -} - -IdealGraphPrinter::Description::Description() { - _state = New; -} - -void IdealGraphPrinter::Description::print(IdealGraphPrinter *printer) { - if (_state == Invalid) { - print_removed(printer); - } else if (_state == New) { - print_changed(printer); - } -} - -void IdealGraphPrinter::Description::set_state(State s) { - _state = s; -} - -IdealGraphPrinter::State IdealGraphPrinter::Description::state() { - return _state; -} - -void IdealGraphPrinter::Block::set_proj(NodeDescription *n) { - _proj = n; -} - -void IdealGraphPrinter::Block::set_start(NodeDescription *n) { - _start = n; -} - -int IdealGraphPrinter::Block::semi() { - return _semi; -} - -int IdealGraphPrinter::Block::parent() { - return _parent; -} - -GrowableArray* IdealGraphPrinter::Block::bucket() { - return &_bucket; -} - -GrowableArray* IdealGraphPrinter::Block::children() { - return &_children; -} - -void IdealGraphPrinter::Block::add_child(int i) { - _children.append(i); -} - -GrowableArray* IdealGraphPrinter::Block::dominates() { - return &_dominates; -} - -void IdealGraphPrinter::Block::add_dominates(int i) { - _dominates.append(i); -} - -void IdealGraphPrinter::Block::add_to_bucket(int i) { - _bucket.append(i); -} - -void IdealGraphPrinter::Block::clear_bucket() { - _bucket.clear(); -} - -void IdealGraphPrinter::Block::set_dominator(int i) { - _dominator = i; -} - -void IdealGraphPrinter::Block::set_label(int i) { - _label = i; -} - -int IdealGraphPrinter::Block::label() { - return _label; -} - -int IdealGraphPrinter::Block::ancestor() { - return _ancestor; -} - -void IdealGraphPrinter::Block::set_ancestor(int i) { - _ancestor = i; -} - -int IdealGraphPrinter::Block::dominator() { - return _dominator; -} - -int IdealGraphPrinter::Block::index() { - return _index; -} - -void IdealGraphPrinter::Block::set_parent(int i) { - _parent = i; -} - -GrowableArray* IdealGraphPrinter::Block::pred() { - return &_pred; -} - -void IdealGraphPrinter::Block::set_semi(int i) { - _semi = i; -} - -IdealGraphPrinter::Block::Block() { -} - -IdealGraphPrinter::Block::Block(int index) { - _index = index; - _label = index; - _semi = -1; - _ancestor = -1; - _dominator = -1; -} - -void IdealGraphPrinter::Block::add_pred(int i) { - _pred.append(i); -} - -IdealGraphPrinter::NodeDescription *IdealGraphPrinter::Block::proj() { - return _proj; -} - -IdealGraphPrinter::NodeDescription *IdealGraphPrinter::Block::start() { - return _start; -} - -GrowableArray* IdealGraphPrinter::Block::succs() { - return &_succs; -} - -void IdealGraphPrinter::Block::add_succ(int index) { - - if (this->_index == 16 && index == 15) { - int x = 0; - } - - if (!_succs.contains(index)) { - _succs.append(index); - } -} - - -void IdealGraphPrinter::Block::add_node(NodeDescription *n) { - if (!_nodes.contains(n)) { - _nodes.append(n); - } -} - -GrowableArray* IdealGraphPrinter::Block::nodes() { - return &_nodes; -} - -int IdealGraphPrinter::NodeDescription::count = 0; - -IdealGraphPrinter::NodeDescription::NodeDescription(Node* node) : _node(node) { - _id = (intptr_t)(node); - _block_index = -1; -} - -IdealGraphPrinter::NodeDescription::~NodeDescription() { - _properties.clean(); -} - -// void IdealGraphPrinter::NodeDescription::set_node(Node* node) { -// //this->_node = node; -// } - -int IdealGraphPrinter::NodeDescription::block_index() { - return _block_index; -} - - -GrowableArray* IdealGraphPrinter::NodeDescription::succs() { - return &_succs; -} - -void IdealGraphPrinter::NodeDescription::clear_succs() { - _succs.clear(); -} - -void IdealGraphPrinter::NodeDescription::init_succs() { - _succs = GrowableArray(); -} - -void IdealGraphPrinter::NodeDescription::add_succ(NodeDescription *desc) { - _succs.append(desc); -} - -void IdealGraphPrinter::NodeDescription::set_block_index(int i) { - _block_index = i; -} - -bool IdealGraphPrinter::NodeDescription::equals(NodeDescription *desc) { - if (desc == NULL) return false; - if (desc->id() != id()) return false; - return properties()->equals(desc->properties()); -} - -Node* IdealGraphPrinter::NodeDescription::node() { - return _node; -} - -IdealGraphPrinter::Properties* IdealGraphPrinter::NodeDescription::properties() { - return &_properties; -} - -uint IdealGraphPrinter::NodeDescription::id() { - return _id; -} - -void IdealGraphPrinter::NodeDescription::print_changed(IdealGraphPrinter *printer) { - - - Properties properties; - properties.add(new Property(NODE_ID_PROPERTY, id())); - printer->start_element(NODE_ELEMENT, &properties); - - this->properties()->print(printer); - - - printer->end_element(NODE_ELEMENT); -} - -void IdealGraphPrinter::NodeDescription::print_removed(IdealGraphPrinter *printer) { - - Properties properties; - properties.add(new Property(NODE_ID_PROPERTY, id())); - printer->simple_element(REMOVE_NODE_ELEMENT, &properties); -} - -IdealGraphPrinter::EdgeDescription::EdgeDescription(int from, int to, int index) { - this->_from = from; - this->_to = to; - this->_index = index; -} - -IdealGraphPrinter::EdgeDescription::~EdgeDescription() { -} - -int IdealGraphPrinter::EdgeDescription::from() { - return _from; -} - -int IdealGraphPrinter::EdgeDescription::to() { - return _to; -} - -void IdealGraphPrinter::EdgeDescription::print_changed(IdealGraphPrinter *printer) { - - Properties properties; - properties.add(new Property(INDEX_PROPERTY, _index)); - properties.add(new Property(FROM_PROPERTY, _from)); - properties.add(new Property(TO_PROPERTY, _to)); - printer->simple_element(EDGE_ELEMENT, &properties); -} - -void IdealGraphPrinter::EdgeDescription::print_removed(IdealGraphPrinter *printer) { - - Properties properties; - properties.add(new Property(INDEX_PROPERTY, _index)); - properties.add(new Property(FROM_PROPERTY, _from)); - properties.add(new Property(TO_PROPERTY, _to)); - printer->simple_element(REMOVE_EDGE_ELEMENT, &properties); -} - -bool IdealGraphPrinter::EdgeDescription::equals(IdealGraphPrinter::EdgeDescription *desc) { - if (desc == NULL) return false; - return (_from == desc->_from && _to == desc->_to && _index == desc->_index); -} - -IdealGraphPrinter::Properties::Properties() : list(new (ResourceObj::C_HEAP) GrowableArray(2, 0, NULL, true)) { -} - -IdealGraphPrinter::Properties::~Properties() { - clean(); - delete list; -} - -void IdealGraphPrinter::Properties::add(Property *p) { - assert(p != NULL, "Property not NULL"); - list->append(p); -} - -void IdealGraphPrinter::Properties::print(IdealGraphPrinter *printer) { - printer->start_element(PROPERTIES_ELEMENT); - - for (int i = 0; i < list->length(); i++) { - list->at(i)->print(printer); - } - - printer->end_element(PROPERTIES_ELEMENT); -} - -void IdealGraphPrinter::Properties::clean() { - for (int i = 0; i < list->length(); i++) { - delete list->at(i); - list->at_put(i, NULL); - } - list->clear(); - assert(list->length() == 0, "List cleared"); -} - -void IdealGraphPrinter::Properties::remove(const char *name) { - for (int i = 0; i < list->length(); i++) { - if (strcmp(list->at(i)->name(), name) == 0) { - delete list->at(i); - list->remove_at(i); - i--; - } - } -} - -void IdealGraphPrinter::Properties::print_as_attributes(IdealGraphPrinter *printer) { - - for (int i = 0; i < list->length(); i++) { - assert(list->at(i) != NULL, "Property not null!"); - printer->output()->print(" "); - list->at(i)->print_as_attribute(printer); - } -} - -bool IdealGraphPrinter::Properties::equals(Properties* p) { - if (p->list->length() != this->list->length()) return false; - - for (int i = 0; i < list->length(); i++) { - assert(list->at(i) != NULL, "Property not null!"); - if (!list->at(i)->equals(p->list->at(i))) return false; - } - - return true; -} - -IdealGraphPrinter::Property::Property() { - _name = NULL; - _value = NULL; -} - -const char *IdealGraphPrinter::Property::name() { - return _name; -} - -IdealGraphPrinter::Property::Property(const Property* p) { - - this->_name = NULL; - this->_value = NULL; - - if (p->_name != NULL) { - _name = dup(p->_name); - } - - if (p->_value) { - _value = dup(p->_value); - } -} - -IdealGraphPrinter::Property::~Property() { - - clean(); -} - -IdealGraphPrinter::Property::Property(const char *name, const char *value) { - - assert(name, "Name must not be null!"); - assert(value, "Value must not be null!"); - - _name = dup(name); - _value = dup(value); -} - -IdealGraphPrinter::Property::Property(const char *name, int intValue) { - _name = dup(name); - - stringStream stream; - stream.print("%d", intValue); - _value = dup(stream.as_string()); -} - -void IdealGraphPrinter::Property::clean() { - if (_name) { - delete _name; - _name = NULL; - } - - if (_value) { - delete _value; - _value = NULL; - } -} - - -bool IdealGraphPrinter::Property::is_null() { - return _name == NULL; -} - -void IdealGraphPrinter::Property::print(IdealGraphPrinter *printer) { - - assert(!is_null(), "null properties cannot be printed!"); - Properties properties; - properties.add(new Property(PROPERTY_NAME_PROPERTY, _name)); - printer->start_element(PROPERTY_ELEMENT, &properties, false, false); - printer->print_xml(_value); - printer->end_element(PROPERTY_ELEMENT, false, true); -} - -void IdealGraphPrinter::Property::print_as_attribute(IdealGraphPrinter *printer) { - - printer->output()->print(_name); - printer->output()->print("=\""); - printer->print_xml(_value); - printer->output()->print("\""); -} - - -bool IdealGraphPrinter::Property::equals(Property* p) { - - if (is_null() && p->is_null()) return true; - if (is_null()) return false; - if (p->is_null()) return false; - - int cmp1 = strcmp(p->_name, _name); - if (cmp1 != 0) return false; - - int cmp2 = strcmp(p->_value, _value); - if (cmp2 != 0) return false; - - return true; -} - -void IdealGraphPrinter::print_xml(const char *value) { - size_t len = strlen(value); - - char buf[2]; - buf[1] = 0; - for (size_t i = 0; i < len; i++) { - char c = value[i]; - - switch(c) { - case '<': - output()->print("<"); - break; - - case '>': - output()->print(">"); - break; - - default: - buf[0] = c; - output()->print(buf); - break; - } - } + return _xml; } #endif