if (is_new) {
debug_only(dump_orig(debug_orig(), st));
Node_Notes* nn = C->node_notes_at(_idx);
if (nn != NULL && !nn->is_clear()) {
if (nn->jvms() != NULL) {
st->print(" !jvms:");
nn->jvms()->dump_spec(st);
}
}
}
if (suffix) st->print("%s", suffix);
C->_in_dump_cnt--;
}
void Node::dump_req(outputStream *st) const {
for (uint i = 0; i < req(); i++) { // For all required inputs
Node* d = in(i);
if (d == NULL) {
st->print("_ ");
} else if (NotANode(d)) {
st->print("NotANode "); // uninitialized, sentinel, garbage, etc.
} else {
st->print("%c%d ", Compile::current()->node_arena()->contains(d) ? ' ' : 'o', d->_idx);
}
}
}
void Node::dump_prec(outputStream *st) const {
int any_prec = 0;
for (uint i = req(); i < len(); i++) { // For all precedence inputs
Node* p = in(i);
if (p != NULL) {
if (!any_prec++) st->print(" |");
if (NotANode(p)) { st->print("NotANode "); continue; }
st->print("%c%d ", Compile::current()->node_arena()->contains(in(i)) ? ' ' : 'o', in(i)->_idx);
}
}
}
void Node::dump_out(outputStream *st) const {
st->print(" [[");
for (uint i = 0; i < _outcnt; i++) { // For all outputs
Node* u = _out[i];
if (u == NULL) {
st->print("_ ");
} else if (NotANode(u)) {
st->print("NotANode ");
} else {
st->print("%c%d ", Compile::current()->node_arena()->contains(u) ? ' ' : 'o', u->_idx);
}
}
st->print("]] ");
}
static void dump_nodes(const Node* start, int d, bool only_ctrl) {
Node* s = (Node*)start; // remove const
if (NotANode(s)) return;
uint depth = (uint)ABS(d);
int direction = d;
Compile* C = Compile::current();
GrowableArray <Node *> nstack(C->live_nodes());
nstack.append(s);
int begin = 0;
int end = 0;
for(uint i = 0; i < depth; i++) {
end = nstack.length();
for(int j = begin; j < end; j++) {
Node* tp = nstack.at(j);
uint limit = direction > 0 ? tp->len() : tp->outcnt();
for(uint k = 0; k < limit; k++) {
Node* n = direction > 0 ? tp->in(k) : tp->raw_out(k);
if (NotANode(n)) continue;
if (n->is_Root() || n->is_top()) continue;
if (only_ctrl && !n->is_CFG()) continue;
bool on_stack = nstack.contains(n);
if (!on_stack) {
nstack.append(n);
}
}
}
begin = end;
}
end = nstack.length();
if (direction > 0) {
for(int j = end-1; j >= 0; j--) {
nstack.at(j)->dump();
}
} else {
for(int j = 0; j < end; j++) {
nstack.at(j)->dump();
}
}
}
void Node::dump(int d) const {
dump_nodes(this, d, false);
}
void Node::dump_ctrl(int d) const {
dump_nodes(this, d, true);
}
void Node::verify_edges(Unique_Node_List &visited) {
uint i, j, idx;
int cnt;
Node *n;
if (visited.member(this)) return;
visited.push(this);
for( i = 0; i < len(); i++ ) {
n = in(i);
if (n != NULL && !n->is_top()) {
cnt = 0;
for (idx = 0; idx < n->_outcnt; idx++ ) {
if (n->_out[idx] == (Node *)this) cnt++;
}
assert( cnt > 0,"Failed to find Def-Use edge." );
for( j = 0; j < len(); j++ ) {
if( in(j) == n ) cnt--;
}
assert( cnt == 0,"Mismatched edge count.");
} else if (n == NULL) {
assert(i >= req() || i == 0 || is_Region() || is_Phi(), "only regions or phis have null data edges");
} else {
assert(n->is_top(), "sanity");
}
}
for( i = 0; i < len(); i++ ) {
n = in(i);
if( n != NULL )
in(i)->verify_edges(visited);
}
}
static const Node *unique_top = NULL;
void Node::verify_recur(const Node *n, int verify_depth,
VectorSet &old_space, VectorSet &new_space) {
if ( verify_depth == 0 ) return;
if (verify_depth > 0) --verify_depth;
Compile* C = Compile::current();
VectorSet *v = C->node_arena()->contains(n) ? &new_space : &old_space;
if( v->test_set(n->_idx) ) return;
if (n->is_Con() && n->bottom_type() == Type::TOP) {
if (C->cached_top_node() == NULL)
C->set_cached_top_node((Node*)n);
assert(C->cached_top_node() == n, "TOP node must be unique");
}
for( uint i = 0; i < n->len(); i++ ) {
Node *x = n->in(i);
if (!x || x->is_top()) continue;
if (true /*VerifyDefUse*/) {
int cnt = 0;
for( uint j = 0; j < n->len(); j++ )
if( n->in(j) == x )
cnt++;
uint max = x->_outcnt;
for( uint k = 0; k < max; k++ )
if (x->_out[k] == n)
cnt--;
assert( cnt == 0, "mismatched def-use edge counts" );
}
verify_recur(x, verify_depth, old_space, new_space);
}
}
void Node::verify() const {
Compile* C = Compile::current();
Node* old_top = C->cached_top_node();
ResourceMark rm;
ResourceArea *area = Thread::current()->resource_area();
VectorSet old_space(area), new_space(area);
verify_recur(this, -1, old_space, new_space);
C->set_cached_top_node(old_top);
}
#endif
void Node::walk(NFunc pre, NFunc post, void *env) {
VectorSet visited(Thread::current()->resource_area()); // Setup for local walk
walk_(pre, post, env, visited);
}
void Node::walk_(NFunc pre, NFunc post, void *env, VectorSet &visited) {
if( visited.test_set(_idx) ) return;
pre(*this,env); // Call the pre-order walk function
for( uint i=0; i<_max; i++ )
if( in(i) ) // Input exists and is not walked?
in(i)->walk_(pre,post,env,visited); // Walk it with pre & post functions
post(*this,env); // Call the post-order walk function
}
void Node::nop(Node &, void*) {}
uint Node::match_edge(uint idx) const {
return idx; // True for other than index 0 (control)
}
static RegMask _not_used_at_all;
const RegMask &Node::out_RegMask() const {
ShouldNotCallThis();
return _not_used_at_all;
}
const RegMask &Node::in_RegMask(uint) const {
ShouldNotCallThis();
return _not_used_at_all;
}
void Node_Array::reset( Arena *new_arena ) {
_a->Afree(_nodes,_max*sizeof(Node*));
_max = 0;
_nodes = NULL;
_a = new_arena;
}
void Node_Array::clear() {
Copy::zero_to_bytes( _nodes, _max*sizeof(Node*) );
}
void Node_Array::grow( uint i ) {
if( !_max ) {
_max = 1;
_nodes = (Node**)_a->Amalloc( _max * sizeof(Node*) );
_nodes[0] = NULL;
}
uint old = _max;
while( i >= _max ) _max <<= 1; // Double to fit
_nodes = (Node**)_a->Arealloc( _nodes, old*sizeof(Node*),_max*sizeof(Node*));
Copy::zero_to_bytes( &_nodes[old], (_max-old)*sizeof(Node*) );
}
void Node_Array::insert( uint i, Node *n ) {
if( _nodes[_max-1] ) grow(_max); // Get more space if full
Copy::conjoint_words_to_higher((HeapWord*)&_nodes[i], (HeapWord*)&_nodes[i+1], ((_max-i-1)*sizeof(Node*)));
_nodes[i] = n;
}
void Node_Array::remove( uint i ) {
Copy::conjoint_words_to_lower((HeapWord*)&_nodes[i+1], (HeapWord*)&_nodes[i], ((_max-i-1)*sizeof(Node*)));
_nodes[_max-1] = NULL;
}
void Node_Array::sort( C_sort_func_t func) {
qsort( _nodes, _max, sizeof( Node* ), func );
}
void Node_Array::dump() const {
#ifndef PRODUCT
for( uint i = 0; i < _max; i++ ) {
Node *nn = _nodes[i];
if( nn != NULL ) {
tty->print("%5d--> ",i); nn->dump();
}
}
#endif
}
bool Node::is_iteratively_computed() {
if (ideal_reg()) { // does operation have a result register?
for (uint i = 1; i < req(); i++) {
Node* n = in(i);
if (n != NULL && n->is_Phi()) {
for (uint j = 1; j < n->req(); j++) {
if (n->in(j) == this) {
return true;
}
}
}
}
}
return false;
}
Node* Node::find_similar(int opc) {
if (req() >= 2) {
Node* def = in(1);
if (def && def->outcnt() >= 2) {
for (DUIterator_Fast dmax, i = def->fast_outs(dmax); i < dmax; i++) {
Node* use = def->fast_out(i);
if (use->Opcode() == opc &&
use->req() == req()) {
uint j;
for (j = 0; j < use->req(); j++) {
if (use->in(j) != in(j)) {
break;
}
}
if (j == use->req()) {
return use;
}
}
}
}
}
return NULL;
}
Node* Node::unique_ctrl_out() {
Node* found = NULL;
for (uint i = 0; i < outcnt(); i++) {
Node* use = raw_out(i);
if (use->is_CFG() && use != this) {
if (found != NULL) return NULL;
found = use;
}
}
return found;
}
void Node_List::yank( Node *n ) {
uint i;
for( i = 0; i < _cnt; i++ )
if( _nodes[i] == n )
break;
if( i < _cnt )
_nodes[i] = _nodes[--_cnt];
}
void Node_List::dump() const {
#ifndef PRODUCT
for( uint i = 0; i < _cnt; i++ )
if( _nodes[i] ) {
tty->print("%5d--> ",i);
_nodes[i]->dump();
}
#endif
}
void Node_List::dump_simple() const {
#ifndef PRODUCT
for( uint i = 0; i < _cnt; i++ )
if( _nodes[i] ) {
tty->print(" %d", _nodes[i]->_idx);
} else {
tty->print(" NULL");
}
#endif
}
void Unique_Node_List::remove( Node *n ) {
if( _in_worklist[n->_idx] ) {
for( uint i = 0; i < size(); i++ )
if( _nodes[i] == n ) {
map(i,Node_List::pop());
_in_worklist >>= n->_idx;
return;
}
ShouldNotReachHere();
}
}
void Unique_Node_List::remove_useless_nodes(VectorSet &useful) {
for( uint i = 0; i < size(); ++i ) {
Node *n = at(i);
assert( n != NULL, "Did not expect null entries in worklist");
if( ! useful.test(n->_idx) ) {
_in_worklist >>= n->_idx;
map(i,Node_List::pop());
--i; // Visit popped node
}
}
}
void Node_Stack::grow() {
size_t old_top = pointer_delta(_inode_top,_inodes,sizeof(INode)); // save _top
size_t old_max = pointer_delta(_inode_max,_inodes,sizeof(INode));
size_t max = old_max << 1; // max * 2
_inodes = REALLOC_ARENA_ARRAY(_a, INode, _inodes, old_max, max);
_inode_max = _inodes + max;
_inode_top = _inodes + old_top; // restore _top
}
Node* Node_Stack::find(uint idx) const {
uint sz = size();
for (uint i=0; i < sz; i++) {
if (idx == index_at(i) )
return node_at(i);
}
return NULL;
}
uint TypeNode::size_of() const { return sizeof(*this); }
#ifndef PRODUCT
void TypeNode::dump_spec(outputStream *st) const {
if( !Verbose && !WizardMode ) {
st->print(" #"); _type->dump_on(st);
}
}
#endif
uint TypeNode::hash() const {
return Node::hash() + _type->hash();
}
uint TypeNode::cmp( const Node &n ) const
{ return !Type::cmp( _type, ((TypeNode&)n)._type ); }
const Type *TypeNode::bottom_type() const { return _type; }
const Type *TypeNode::Value( PhaseTransform * ) const { return _type; }
uint TypeNode::ideal_reg() const {
return _type->ideal_reg();
}
C:\hotspot-69087d08d473\src\share\vm/opto/node.hpp
#ifndef SHARE_VM_OPTO_NODE_HPP
#define SHARE_VM_OPTO_NODE_HPP
#include "libadt/port.hpp"
#include "libadt/vectset.hpp"
#include "opto/compile.hpp"
#include "opto/type.hpp"
class AbstractLockNode;
class AddNode;
class AddPNode;
class AliasInfo;
class AllocateArrayNode;
class AllocateNode;
class Block;
class BoolNode;
class BoxLockNode;
class CMoveNode;
class CallDynamicJavaNode;
class CallJavaNode;
class CallLeafNode;
class CallNode;
class CallRuntimeNode;
class CallStaticJavaNode;
class CatchNode;
class CatchProjNode;
class CheckCastPPNode;
class CastIINode;
class ClearArrayNode;
class CmpNode;
class CodeBuffer;
class ConstraintCastNode;
class ConNode;
class CountedLoopNode;
class CountedLoopEndNode;
class DecodeNarrowPtrNode;
class DecodeNNode;
class DecodeNKlassNode;
class EncodeNarrowPtrNode;
class EncodePNode;
class EncodePKlassNode;
class FastLockNode;
class FastUnlockNode;
class IfNode;
class IfFalseNode;
class IfTrueNode;
class InitializeNode;
class JVMState;
class JumpNode;
class JumpProjNode;
class LoadNode;
class LoadStoreNode;
class LockNode;
class LoopNode;
class MachBranchNode;
class MachCallDynamicJavaNode;
class MachCallJavaNode;
class MachCallLeafNode;
class MachCallNode;
class MachCallRuntimeNode;
class MachCallStaticJavaNode;
class MachConstantBaseNode;
class MachConstantNode;
class MachGotoNode;
class MachIfNode;
class MachNode;
class MachNullCheckNode;
class MachProjNode;
class MachReturnNode;
class MachSafePointNode;
class MachSpillCopyNode;
class MachTempNode;
class MachMergeNode;
class Matcher;
class MemBarNode;
class MemBarStoreStoreNode;
class MemNode;
class MergeMemNode;
class MulNode;
class MultiNode;
class MultiBranchNode;
class NeverBranchNode;
class Node;
class Node_Array;
class Node_List;
class Node_Stack;
class NullCheckNode;
class OopMap;
class ParmNode;
class PCTableNode;
class PhaseCCP;
class PhaseGVN;
class PhaseIterGVN;
class PhaseRegAlloc;
class PhaseTransform;
class PhaseValues;
class PhiNode;
class Pipeline;
class ProjNode;
class RegMask;
class RegionNode;
class RootNode;
class SafePointNode;
class SafePointScalarObjectNode;
class StartNode;
class State;
class StoreNode;
class SubNode;
class Type;
class TypeNode;
class UnlockNode;
class VectorNode;
class LoadVectorNode;
class StoreVectorNode;
class VectorSet;
typedef void (*NFunc)(Node&,void*);
extern "C" {
typedef int (*C_sort_func_t)(const void *, const void *);
}
typedef unsigned int node_idx_t;
#ifndef OPTO_DU_ITERATOR_ASSERT
#ifdef ASSERT
#define OPTO_DU_ITERATOR_ASSERT 1
#else
#define OPTO_DU_ITERATOR_ASSERT 0
#endif
#endif //OPTO_DU_ITERATOR_ASSERT
#if OPTO_DU_ITERATOR_ASSERT
class DUIterator;
class DUIterator_Fast;
class DUIterator_Last;
#else
typedef uint DUIterator;
typedef Node** DUIterator_Fast;
typedef Node** DUIterator_Last;
#endif
#define NodeSentinel (Node*)-1
#define COUNT_UNKNOWN (-1.0f)
class Node {
friend class VMStructs;
Node(const Node&); // not defined; linker error to use these
Node &operator=(const Node &rhs);
public:
friend class Compile;
#if OPTO_DU_ITERATOR_ASSERT
friend class DUIterator_Common;
friend class DUIterator;
friend class DUIterator_Fast;
friend class DUIterator_Last;
#endif
inline void* operator new( size_t x, Compile* C) throw() {
Node* n = (Node*)C->node_arena()->Amalloc_D(x);
#ifdef ASSERT
n->_in = (Node**)n; // magic cookie for assertion check
#endif
n->_out = (Node**)C;
return (void*)n;
}
void operator delete( void *ptr ) {}
void destruct();
Node( uint required );
Node( Node *n0 );
Node( Node *n0, Node *n1 );
Node( Node *n0, Node *n1, Node *n2 );
Node( Node *n0, Node *n1, Node *n2, Node *n3 );
Node( Node *n0, Node *n1, Node *n2, Node *n3, Node *n4 );
Node( Node *n0, Node *n1, Node *n2, Node *n3, Node *n4, Node *n5 );
Node( Node *n0, Node *n1, Node *n2, Node *n3,
Node *n4, Node *n5, Node *n6 );
Node* clone() const;
Node* clone_with_data_edge(Node* in1, Node* in2 = NULL) const {
Node* nn = clone();
if (in1 != NULL) nn->set_req(1, in1);
if (in2 != NULL) nn->set_req(2, in2);
return nn;
}
private:
inline int Init(int req, Compile* C);
protected:
friend class PhaseCFG; // Access to address of _in array elements
Node **_in; // Array of use-def references to Nodes
Node **_out; // Array of def-use references to Nodes
node_idx_t _cnt; // Total number of required Node inputs.
node_idx_t _max; // Actual length of input array.
node_idx_t _outcnt; // Total number of Node outputs.
node_idx_t _outmax; // Actual length of output array.
void grow( uint len );
void out_grow( uint len );
public:
const node_idx_t _idx;
DEBUG_ONLY(const node_idx_t _parse_idx;)
uint req() const { return _cnt; }
uint len() const { return _max; }
uint outcnt() const { return _outcnt; }
#if OPTO_DU_ITERATOR_ASSERT
inline DUIterator outs() const;
inline DUIterator& refresh_out_pos(DUIterator& i) const;
inline bool has_out(DUIterator& i) const;
inline Node* out(DUIterator& i) const;
inline DUIterator_Fast fast_outs(DUIterator_Fast& max) const;
inline Node* fast_out(DUIterator_Fast& i) const;
inline DUIterator_Last last_outs(DUIterator_Last& min) const;
inline Node* last_out(DUIterator_Last& i) const;
#else
DUIterator outs() const { return 0; }
DUIterator refresh_out_pos(DUIterator i) const { return i; }
Node* out(DUIterator i) const { assert(i < _outcnt, "oob"); return _out[i]; }
bool has_out(DUIterator i) const { return i < _outcnt; }
DUIterator_Fast fast_outs(DUIterator_Fast& max) const {
Node** out = _out;
max = out + (ptrdiff_t)_outcnt;
return out;
}
Node* fast_out(DUIterator_Fast i) const { return *i; }
DUIterator_Last last_outs(DUIterator_Last& min) const {
Node** out = _out;
min = out;
return out + (ptrdiff_t)_outcnt - 1;
}
Node* last_out(DUIterator_Last i) const { return *i; }
#endif
Node* in(uint i) const { assert(i < _max, err_msg_res("oob: i=%d, _max=%d", i, _max)); return _in[i]; }
Node* lookup(uint i) const { return ((i < _max) ? _in[i] : NULL); }
Node* raw_out(uint i) const { assert(i < _outcnt,"oob"); return _out[i]; }
Node* unique_out() const { assert(_outcnt==1,"not unique"); return _out[0]; }
void raw_del_out(uint i) {
assert(i < _outcnt,"oob");
assert(_outcnt > 0,"oob");
#if OPTO_DU_ITERATOR_ASSERT
debug_only(_last_del = _out[i]; ++_del_tick);
#endif
_out[i] = _out[--_outcnt];
debug_only(_out[_outcnt] = (Node *)(uintptr_t)0xdeadbeef);
}
#ifdef ASSERT
bool is_dead() const;
#define is_not_dead(n) ((n) == NULL || !VerifyIterativeGVN || !((n)->is_dead()))
#endif
bool is_unreachable(PhaseIterGVN &igvn) const;
void add_req( Node *n ); // Append a NEW required input
void add_req( Node *n0, Node *n1 ) {
add_req(n0); add_req(n1); }
void add_req( Node *n0, Node *n1, Node *n2 ) {
add_req(n0); add_req(n1); add_req(n2); }
void add_req_batch( Node* n, uint m ); // Append m NEW required inputs (all n).
void del_req( uint idx ); // Delete required edge & compact
void del_req_ordered( uint idx ); // Delete required edge & compact with preserved order
void ins_req( uint i, Node *n ); // Insert a NEW required input
void set_req( uint i, Node *n ) {
assert( is_not_dead(n), "can not use dead node");
assert( i < _cnt, err_msg_res("oob: i=%d, _cnt=%d", i, _cnt));
assert( !VerifyHashTableKeys || _hash_lock == 0,
"remove node from hash table before modifying it");
Node** p = &_in[i]; // cache this._in, across the del_out call
if (*p != NULL) (*p)->del_out((Node *)this);
(*p) = n;
if (n != NULL) n->add_out((Node *)this);
}
void init_req( uint i, Node *n ) {
assert( i == 0 && this == n ||
is_not_dead(n), "can not use dead node");
assert( i < _cnt, "oob");
assert( !VerifyHashTableKeys || _hash_lock == 0,
"remove node from hash table before modifying it");
assert( _in[i] == NULL, "sanity");
_in[i] = n;
if (n != NULL) n->add_out((Node *)this);
}
int find_edge(Node* n);
int find_prec_edge(Node* n) {
for (uint i = req(); i < len(); i++) {
if (_in[i] == n) return i;
if (_in[i] == NULL) {
DEBUG_ONLY( while ((++i) < len()) assert(_in[i] == NULL, "Gap in prec edges!"); )
break;
}
}
return -1;
}
int replace_edge(Node* old, Node* neww);
int replace_edges_in_range(Node* old, Node* neww, int start, int end);
int disconnect_inputs(Node *n, Compile *c);
bool is_top() const {
assert((this == (Node*) Compile::current()->top()) == (_out == NULL), "");
return (_out == NULL);
}
void setup_is_top();
Node* uncast() const;
bool eqv_uncast(const Node* n) const {
return (this->uncast() == n->uncast());
}
Node* find_out_with(int opcode);
private:
static Node* uncast_helper(const Node* n);
void add_out( Node *n ) {
if (is_top()) return;
if( _outcnt == _outmax ) out_grow(_outcnt);
_out[_outcnt++] = n;
}
void del_out( Node *n ) {
if (is_top()) return;
Node** outp = &_out[_outcnt];
do {
assert(outp > _out, "Missing Def-Use edge");
} while (*--outp != n);
debug_only(_out[_outcnt] = (Node *)(uintptr_t)0xdeadbeef);
#if OPTO_DU_ITERATOR_ASSERT
debug_only(_last_del = n; ++_del_tick);
#endif
}
void close_prec_gap_at(uint gap) {
assert(_cnt <= gap && gap < _max, "no valid prec edge");
uint i = gap;
Node *last = NULL;
for (; i < _max-1; ++i) {
Node *next = _in[i+1];
if (next == NULL) break;
last = next;
}
_in[gap] = last; // Move last slot to empty one.
_in[i] = NULL; // NULL out last slot.
}
public:
void replace_by(Node* new_node);
void subsume_by(Node* new_node, Compile* c) {
replace_by(new_node);
disconnect_inputs(NULL, c);
}
void set_req_X( uint i, Node *n, PhaseIterGVN *igvn );
Node *nonnull_req() const;
void add_prec( Node *n );
void rm_prec( uint i );
void set_prec( uint i, Node *n ) {
assert(i < _max, err_msg("oob: i=%d, _max=%d", i, _max));
assert(is_not_dead(n), "can not use dead node");
assert(i >= _cnt, "not a precedence edge");
if (_in[i] == n) return;
if (n == NULL || find_prec_edge(n) != -1) {
rm_prec(i);
return;
}
if (_in[i] != NULL) _in[i]->del_out((Node *)this);
_in[i] = n;
if (n != NULL) n->add_out((Node *)this);
}
void set_idx(uint new_idx) {
const node_idx_t* ref = &_idx;
}
void swap_edges(uint i1, uint i2) {
debug_only(uint check_hash = (VerifyHashTableKeys && _hash_lock) ? hash() : NO_HASH);
Node* n1 = in(i1);
Node* n2 = in(i2);
_in[i1] = n2;
_in[i2] = n1;
assert(check_hash == NO_HASH || check_hash == hash(), "edge swap must preserve hash code");
}
#define DEFINE_CLASS_ID(cl, supcl, subn) \
Bit_##cl = (Class_##supcl == 0) ? 1 << subn : (Bit_##supcl) << (1 + subn) , \
Class_##cl = Class_##supcl + Bit_##cl , \
ClassMask_##cl = ((Bit_##cl << 1) - 1) ,
enum NodeClasses {
Bit_Node = 0x0000,
Class_Node = 0x0000,
ClassMask_Node = 0xFFFF,
DEFINE_CLASS_ID(Multi, Node, 0)
DEFINE_CLASS_ID(SafePoint, Multi, 0)
DEFINE_CLASS_ID(Call, SafePoint, 0)
DEFINE_CLASS_ID(CallJava, Call, 0)
DEFINE_CLASS_ID(CallStaticJava, CallJava, 0)
DEFINE_CLASS_ID(CallDynamicJava, CallJava, 1)
DEFINE_CLASS_ID(CallRuntime, Call, 1)
DEFINE_CLASS_ID(CallLeaf, CallRuntime, 0)
DEFINE_CLASS_ID(Allocate, Call, 2)
DEFINE_CLASS_ID(AllocateArray, Allocate, 0)
DEFINE_CLASS_ID(AbstractLock, Call, 3)
DEFINE_CLASS_ID(Lock, AbstractLock, 0)
DEFINE_CLASS_ID(Unlock, AbstractLock, 1)
DEFINE_CLASS_ID(MultiBranch, Multi, 1)
DEFINE_CLASS_ID(PCTable, MultiBranch, 0)
DEFINE_CLASS_ID(Catch, PCTable, 0)
DEFINE_CLASS_ID(Jump, PCTable, 1)
DEFINE_CLASS_ID(If, MultiBranch, 1)
DEFINE_CLASS_ID(CountedLoopEnd, If, 0)
DEFINE_CLASS_ID(NeverBranch, MultiBranch, 2)
DEFINE_CLASS_ID(Start, Multi, 2)
DEFINE_CLASS_ID(MemBar, Multi, 3)
DEFINE_CLASS_ID(Initialize, MemBar, 0)
DEFINE_CLASS_ID(MemBarStoreStore, MemBar, 1)
DEFINE_CLASS_ID(Mach, Node, 1)
DEFINE_CLASS_ID(MachReturn, Mach, 0)
DEFINE_CLASS_ID(MachSafePoint, MachReturn, 0)
DEFINE_CLASS_ID(MachCall, MachSafePoint, 0)
DEFINE_CLASS_ID(MachCallJava, MachCall, 0)
DEFINE_CLASS_ID(MachCallStaticJava, MachCallJava, 0)
DEFINE_CLASS_ID(MachCallDynamicJava, MachCallJava, 1)
DEFINE_CLASS_ID(MachCallRuntime, MachCall, 1)
DEFINE_CLASS_ID(MachCallLeaf, MachCallRuntime, 0)
DEFINE_CLASS_ID(MachBranch, Mach, 1)
DEFINE_CLASS_ID(MachIf, MachBranch, 0)
DEFINE_CLASS_ID(MachGoto, MachBranch, 1)
DEFINE_CLASS_ID(MachNullCheck, MachBranch, 2)
DEFINE_CLASS_ID(MachSpillCopy, Mach, 2)
DEFINE_CLASS_ID(MachTemp, Mach, 3)
DEFINE_CLASS_ID(MachConstantBase, Mach, 4)
DEFINE_CLASS_ID(MachConstant, Mach, 5)
DEFINE_CLASS_ID(MachMerge, Mach, 6)
DEFINE_CLASS_ID(Type, Node, 2)
DEFINE_CLASS_ID(Phi, Type, 0)
DEFINE_CLASS_ID(ConstraintCast, Type, 1)
DEFINE_CLASS_ID(CastII, ConstraintCast, 0)
DEFINE_CLASS_ID(CheckCastPP, Type, 2)
DEFINE_CLASS_ID(CMove, Type, 3)
DEFINE_CLASS_ID(SafePointScalarObject, Type, 4)
DEFINE_CLASS_ID(DecodeNarrowPtr, Type, 5)
DEFINE_CLASS_ID(DecodeN, DecodeNarrowPtr, 0)
DEFINE_CLASS_ID(DecodeNKlass, DecodeNarrowPtr, 1)
DEFINE_CLASS_ID(EncodeNarrowPtr, Type, 6)
DEFINE_CLASS_ID(EncodeP, EncodeNarrowPtr, 0)
DEFINE_CLASS_ID(EncodePKlass, EncodeNarrowPtr, 1)
DEFINE_CLASS_ID(Proj, Node, 3)
DEFINE_CLASS_ID(CatchProj, Proj, 0)
DEFINE_CLASS_ID(JumpProj, Proj, 1)
DEFINE_CLASS_ID(IfTrue, Proj, 2)
DEFINE_CLASS_ID(IfFalse, Proj, 3)
DEFINE_CLASS_ID(Parm, Proj, 4)
DEFINE_CLASS_ID(MachProj, Proj, 5)
DEFINE_CLASS_ID(Mem, Node, 4)
DEFINE_CLASS_ID(Load, Mem, 0)
DEFINE_CLASS_ID(LoadVector, Load, 0)
DEFINE_CLASS_ID(Store, Mem, 1)
DEFINE_CLASS_ID(StoreVector, Store, 0)
DEFINE_CLASS_ID(LoadStore, Mem, 2)
DEFINE_CLASS_ID(Region, Node, 5)
DEFINE_CLASS_ID(Loop, Region, 0)
DEFINE_CLASS_ID(Root, Loop, 0)
DEFINE_CLASS_ID(CountedLoop, Loop, 1)
DEFINE_CLASS_ID(Sub, Node, 6)
DEFINE_CLASS_ID(Cmp, Sub, 0)
DEFINE_CLASS_ID(FastLock, Cmp, 0)
DEFINE_CLASS_ID(FastUnlock, Cmp, 1)
DEFINE_CLASS_ID(MergeMem, Node, 7)
DEFINE_CLASS_ID(Bool, Node, 8)
DEFINE_CLASS_ID(AddP, Node, 9)
DEFINE_CLASS_ID(BoxLock, Node, 10)
DEFINE_CLASS_ID(Add, Node, 11)
DEFINE_CLASS_ID(Mul, Node, 12)
DEFINE_CLASS_ID(Vector, Node, 13)
DEFINE_CLASS_ID(ClearArray, Node, 14)
_max_classes = ClassMask_ClearArray
};
#undef DEFINE_CLASS_ID
enum NodeFlags {
Flag_is_Copy = 0x01, // should be first bit to avoid shift
Flag_rematerialize = Flag_is_Copy << 1,
Flag_needs_anti_dependence_check = Flag_rematerialize << 1,
Flag_is_macro = Flag_needs_anti_dependence_check << 1,
Flag_is_Con = Flag_is_macro << 1,
Flag_is_cisc_alternate = Flag_is_Con << 1,
Flag_is_dead_loop_safe = Flag_is_cisc_alternate << 1,
Flag_may_be_short_branch = Flag_is_dead_loop_safe << 1,
Flag_avoid_back_to_back_before = Flag_may_be_short_branch << 1,
Flag_avoid_back_to_back_after = Flag_avoid_back_to_back_before << 1,
Flag_has_call = Flag_avoid_back_to_back_after << 1,
Flag_is_expensive = Flag_has_call << 1,
_max_flags = (Flag_is_expensive << 1) - 1 // allow flags combination
};
private:
jushort _class_id;
jushort _flags;
protected:
void init_class_id(jushort c) {
assert(c <= _max_classes, "invalid node class");
_class_id = c; // cast out const
}
void init_flags(jushort fl) {
assert(fl <= _max_flags, "invalid node flag");
_flags |= fl;
}
void clear_flag(jushort fl) {
assert(fl <= _max_flags, "invalid node flag");
_flags &= ~fl;
}
public:
const jushort class_id() const { return _class_id; }
const jushort flags() const { return _flags; }
virtual int Opcode() const;
virtual uint size_of() const;
#define DEFINE_CLASS_QUERY(type) \
bool is_##type() const { \
return ((_class_id & ClassMask_##type) == Class_##type); \
} \
type##Node *as_##type() const { \
assert(is_##type(), "invalid node class"); \
return (type##Node*)this; \
} \
type##Node* isa_##type() const { \
return (is_##type()) ? as_##type() : NULL; \
}
DEFINE_CLASS_QUERY(AbstractLock)
DEFINE_CLASS_QUERY(Add)
DEFINE_CLASS_QUERY(AddP)
DEFINE_CLASS_QUERY(Allocate)
DEFINE_CLASS_QUERY(AllocateArray)
DEFINE_CLASS_QUERY(Bool)
DEFINE_CLASS_QUERY(BoxLock)
DEFINE_CLASS_QUERY(Call)
DEFINE_CLASS_QUERY(CallDynamicJava)
DEFINE_CLASS_QUERY(CallJava)
DEFINE_CLASS_QUERY(CallLeaf)
DEFINE_CLASS_QUERY(CallRuntime)
DEFINE_CLASS_QUERY(CallStaticJava)
DEFINE_CLASS_QUERY(Catch)
DEFINE_CLASS_QUERY(CatchProj)
DEFINE_CLASS_QUERY(CheckCastPP)
DEFINE_CLASS_QUERY(CastII)
DEFINE_CLASS_QUERY(ConstraintCast)
DEFINE_CLASS_QUERY(ClearArray)
DEFINE_CLASS_QUERY(CMove)
DEFINE_CLASS_QUERY(Cmp)
DEFINE_CLASS_QUERY(CountedLoop)
DEFINE_CLASS_QUERY(CountedLoopEnd)
DEFINE_CLASS_QUERY(DecodeNarrowPtr)
DEFINE_CLASS_QUERY(DecodeN)
DEFINE_CLASS_QUERY(DecodeNKlass)
DEFINE_CLASS_QUERY(EncodeNarrowPtr)
DEFINE_CLASS_QUERY(EncodeP)
DEFINE_CLASS_QUERY(EncodePKlass)
DEFINE_CLASS_QUERY(FastLock)
DEFINE_CLASS_QUERY(FastUnlock)
DEFINE_CLASS_QUERY(If)
DEFINE_CLASS_QUERY(IfFalse)
DEFINE_CLASS_QUERY(IfTrue)
DEFINE_CLASS_QUERY(Initialize)
DEFINE_CLASS_QUERY(Jump)
DEFINE_CLASS_QUERY(JumpProj)
DEFINE_CLASS_QUERY(Load)
DEFINE_CLASS_QUERY(LoadStore)
DEFINE_CLASS_QUERY(Lock)
DEFINE_CLASS_QUERY(Loop)
DEFINE_CLASS_QUERY(Mach)
DEFINE_CLASS_QUERY(MachBranch)
DEFINE_CLASS_QUERY(MachCall)
DEFINE_CLASS_QUERY(MachCallDynamicJava)
DEFINE_CLASS_QUERY(MachCallJava)
DEFINE_CLASS_QUERY(MachCallLeaf)
DEFINE_CLASS_QUERY(MachCallRuntime)
DEFINE_CLASS_QUERY(MachCallStaticJava)
DEFINE_CLASS_QUERY(MachConstantBase)
DEFINE_CLASS_QUERY(MachConstant)
DEFINE_CLASS_QUERY(MachGoto)
DEFINE_CLASS_QUERY(MachIf)
DEFINE_CLASS_QUERY(MachNullCheck)
DEFINE_CLASS_QUERY(MachProj)
DEFINE_CLASS_QUERY(MachReturn)
DEFINE_CLASS_QUERY(MachSafePoint)
DEFINE_CLASS_QUERY(MachSpillCopy)
DEFINE_CLASS_QUERY(MachTemp)
DEFINE_CLASS_QUERY(MachMerge)
DEFINE_CLASS_QUERY(Mem)
DEFINE_CLASS_QUERY(MemBar)
DEFINE_CLASS_QUERY(MemBarStoreStore)
DEFINE_CLASS_QUERY(MergeMem)
DEFINE_CLASS_QUERY(Mul)
DEFINE_CLASS_QUERY(Multi)
DEFINE_CLASS_QUERY(MultiBranch)
DEFINE_CLASS_QUERY(Parm)
DEFINE_CLASS_QUERY(PCTable)
DEFINE_CLASS_QUERY(Phi)
DEFINE_CLASS_QUERY(Proj)
DEFINE_CLASS_QUERY(Region)
DEFINE_CLASS_QUERY(Root)
DEFINE_CLASS_QUERY(SafePoint)
DEFINE_CLASS_QUERY(SafePointScalarObject)
DEFINE_CLASS_QUERY(Start)
DEFINE_CLASS_QUERY(Store)
DEFINE_CLASS_QUERY(Sub)
DEFINE_CLASS_QUERY(Type)
DEFINE_CLASS_QUERY(Vector)
DEFINE_CLASS_QUERY(LoadVector)
DEFINE_CLASS_QUERY(StoreVector)
DEFINE_CLASS_QUERY(Unlock)
#undef DEFINE_CLASS_QUERY
bool is_SpillCopy () const {
return ((_class_id & ClassMask_MachSpillCopy) == Class_MachSpillCopy);
}
bool is_Con () const { return (_flags & Flag_is_Con) != 0; }
bool is_dead_loop_safe() const {
return is_Phi() || (is_Proj() && in(0) == NULL) ||
((_flags & (Flag_is_dead_loop_safe | Flag_is_Con)) != 0 &&
(!is_Proj() || !in(0)->is_Allocate()));
}
uint is_Copy() const { return (_flags & Flag_is_Copy); }
virtual bool is_CFG() const { return false; }
virtual bool depends_only_on_test() const { assert(!is_CFG(), ""); return true; };
bool is_block_start() const {
if ( is_Region() )
return this == (const Node*)in(0);
else
return is_Start();
}
virtual const Node *is_block_proj() const;
bool is_macro() const { return (_flags & Flag_is_macro) != 0; }
bool is_expensive() const { return (_flags & Flag_is_expensive) != 0 && in(0) != NULL; }
virtual const class Type *bottom_type() const;
void raise_bottom_type(const Type* new_type);
virtual const class TypePtr *adr_type() const { return NULL; }
virtual Node *Identity( PhaseTransform *phase );
virtual const Type *Value( PhaseTransform *phase ) const;
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
bool has_special_unique_user() const;
Node* find_exact_control(Node* ctrl);
bool dominates(Node* sub, Node_List &nlist);
protected:
bool remove_dead_region(PhaseGVN *phase, bool can_reshape);
public:
virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
static const Pipeline *pipeline_class();
virtual const Pipeline *pipeline() const;
uint latency(uint i);
enum { NO_HASH = 0 };
virtual uint hash() const;
virtual uint cmp( const Node &n ) const;
bool is_iteratively_computed();
const Node* is_loop_iv() const;
Node* find_similar(int opc);
Node* unique_ctrl_out();
virtual uint ideal_reg() const;
static const uint NotAMachineReg; // must be > max. machine register
virtual uint match_edge(uint idx) const;
virtual const RegMask &out_RegMask() const;
virtual const RegMask &in_RegMask(uint) const;
bool rematerialize() const;
virtual JVMState* jvms() const;
virtual void format( PhaseRegAlloc *, outputStream* st = tty ) const;
virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;
virtual uint size(PhaseRegAlloc *ra_) const;
jint find_int_con(jint value_if_unknown) const {
const TypeInt* t = find_int_type();
return (t != NULL && t->is_con()) ? t->get_con() : value_if_unknown;
}
jint get_int() const {
const TypeInt* t = find_int_type();
guarantee(t != NULL, "must be con");
return t->get_con();
}
const TypeInt* find_int_type() const;
jlong get_long() const {
const TypeLong* t = find_long_type();
guarantee(t != NULL, "must be con");
return t->get_con();
}
jlong find_long_con(jint value_if_unknown) const {
const TypeLong* t = find_long_type();
return (t != NULL && t->is_con()) ? t->get_con() : value_if_unknown;
}
const TypeLong* find_long_type() const;
const TypePtr* get_ptr_type() const;
intptr_t get_ptr() const;
intptr_t get_narrowcon() const;
jdouble getd() const;
jfloat getf() const;
virtual bool pinned() const { return false; }
bool needs_anti_dependence_check() const;
virtual int cisc_operand() const { return AdlcVMDeps::Not_cisc_spillable; }
bool is_cisc_alternate() const { return (_flags & Flag_is_cisc_alternate) != 0; }
public:
void walk(NFunc pre, NFunc post, void *env);
static void nop(Node &, void*); // Dummy empty function
static void packregion( Node &n, void* );
private:
void walk_(NFunc pre, NFunc post, void *env, VectorSet &visited);
public:
#ifndef PRODUCT
Node* find(int idx) const; // Search the graph for the given idx.
Node* find_ctrl(int idx) const; // Search control ancestors for the given idx.
void dump() const { dump("\n"); } // Print this node.
void dump(const char* suffix, outputStream *st = tty) const;// Print this node.
void dump(int depth) const; // Print this node, recursively to depth d
void dump_ctrl(int depth) const; // Print control nodes, to depth d
virtual void dump_req(outputStream *st = tty) const; // Print required-edge info
virtual void dump_prec(outputStream *st = tty) const; // Print precedence-edge info
virtual void dump_out(outputStream *st = tty) const; // Print the output edge info
virtual void dump_spec(outputStream *st) const {}; // Print per-node info
void verify_edges(Unique_Node_List &visited); // Verify bi-directional edges
void verify() const; // Check Def-Use info for my subgraph
static void verify_recur(const Node *n, int verify_depth, VectorSet &old_space, VectorSet &new_space);
virtual const char *Name() const;
void dump_format(PhaseRegAlloc *ra) const; // debug access to MachNode::format(...)
void dump_in_regmask(int idx) { in_RegMask(idx).dump(); }
void dump_out_regmask() { out_RegMask().dump(); }
static bool in_dump() { return Compile::current()->_in_dump_cnt > 0; }
void fast_dump() const {
tty->print("%4d: %-17s", _idx, Name());
for (uint i = 0; i < len(); i++)
if (in(i))
tty->print(" %4d", in(i)->_idx);
else
tty->print(" NULL");
tty->print("\n");
}
#endif
#ifdef ASSERT
void verify_construction();
bool verify_jvms(const JVMState* jvms) const;
int _debug_idx; // Unique value assigned to every node.
int debug_idx() const { return _debug_idx; }
void set_debug_idx( int debug_idx ) { _debug_idx = debug_idx; }
Node* _debug_orig; // Original version of this, if any.
Node* debug_orig() const { return _debug_orig; }
void set_debug_orig(Node* orig); // _debug_orig = orig
int _hash_lock; // Barrier to modifications of nodes in the hash table
void enter_hash_lock() { ++_hash_lock; assert(_hash_lock < 99, "in too many hash tables?"); }
void exit_hash_lock() { --_hash_lock; assert(_hash_lock >= 0, "mispaired hash locks"); }
static void init_NodeProperty();
#if OPTO_DU_ITERATOR_ASSERT
const Node* _last_del; // The last deleted node.
uint _del_tick; // Bumped when a deletion happens..
#endif
#endif
};
#if OPTO_DU_ITERATOR_ASSERT
class DUIterator_Common VALUE_OBJ_CLASS_SPEC {
#ifdef ASSERT
protected:
bool _vdui; // cached value of VerifyDUIterators
const Node* _node; // the node containing the _out array
uint _outcnt; // cached node->_outcnt
uint _del_tick; // cached node->_del_tick
Node* _last; // last value produced by the iterator
void sample(const Node* node); // used by c'tor to set up for verifies
void verify(const Node* node, bool at_end_ok = false);
void verify_resync();
void reset(const DUIterator_Common& that);
#define I_VDUI_ONLY(i,x) { if ((i)._vdui) { x; } }
#else
#define I_VDUI_ONLY(i,x) { }
#endif //ASSERT
};
#define VDUI_ONLY(x) I_VDUI_ONLY(*this, x)
class DUIterator : public DUIterator_Common {
friend class Node;
uint _idx;
#ifdef ASSERT
uint _refresh_tick; // Records the refresh activity.
void sample(const Node* node); // Initialize _refresh_tick etc.
void verify(const Node* node, bool at_end_ok = false);
void verify_increment(); // Verify an increment operation.
void verify_resync(); // Verify that we can back up over a deletion.
void verify_finish(); // Verify that the loop terminated properly.
void refresh(); // Resample verification info.
void reset(const DUIterator& that); // Resample after assignment.
#endif
DUIterator(const Node* node, int dummy_to_avoid_conversion)
{ _idx = 0; debug_only(sample(node)); }
public:
DUIterator()
{ /*initialize to garbage*/ debug_only(_vdui = false); }
void operator++(int dummy_to_specify_postfix_op)
{ _idx++; VDUI_ONLY(verify_increment()); }
void operator--()
{ VDUI_ONLY(verify_resync()); --_idx; }
~DUIterator()
{ VDUI_ONLY(verify_finish()); }
void operator=(const DUIterator& that)
{ _idx = that._idx; debug_only(reset(that)); }
};
DUIterator Node::outs() const
{ return DUIterator(this, 0); }
DUIterator& Node::refresh_out_pos(DUIterator& i) const
{ I_VDUI_ONLY(i, i.refresh()); return i; }
bool Node::has_out(DUIterator& i) const
{ I_VDUI_ONLY(i, i.verify(this,true));return i._idx < _outcnt; }
Node* Node::out(DUIterator& i) const
{ I_VDUI_ONLY(i, i.verify(this)); return debug_only(i._last=) _out[i._idx]; }
class DUIterator_Fast : public DUIterator_Common {
friend class Node;
friend class DUIterator_Last;
Node** _outp;
#ifdef ASSERT
void verify(const Node* node, bool at_end_ok = false);
void verify_limit();
void verify_resync();
void verify_relimit(uint n);
void reset(const DUIterator_Fast& that);
#endif
DUIterator_Fast(const Node* node, ptrdiff_t offset)
{ _outp = node->_out + offset; debug_only(sample(node)); }
public:
DUIterator_Fast()
{ /*initialize to garbage*/ debug_only(_vdui = false); }
void operator++(int dummy_to_specify_postfix_op)
{ _outp++; VDUI_ONLY(verify(_node, true)); }
void operator--()
{ VDUI_ONLY(verify_resync()); --_outp; }
void operator-=(uint n) // applied to the limit only
{ _outp -= n; VDUI_ONLY(verify_relimit(n)); }
bool operator<(DUIterator_Fast& limit) {
I_VDUI_ONLY(*this, this->verify(_node, true));
I_VDUI_ONLY(limit, limit.verify_limit());
return _outp < limit._outp;
}
void operator=(const DUIterator_Fast& that)
{ _outp = that._outp; debug_only(reset(that)); }
};
DUIterator_Fast Node::fast_outs(DUIterator_Fast& imax) const {
imax = DUIterator_Fast(this, (ptrdiff_t)_outcnt);
return DUIterator_Fast(this, 0);
}
Node* Node::fast_out(DUIterator_Fast& i) const {
I_VDUI_ONLY(i, i.verify(this));
return debug_only(i._last=) *i._outp;
}
class DUIterator_Last : private DUIterator_Fast {
friend class Node;
#ifdef ASSERT
void verify(const Node* node, bool at_end_ok = false);
void verify_limit();
void verify_step(uint num_edges);
#endif
DUIterator_Last(const Node* node, ptrdiff_t offset)
: DUIterator_Fast(node, offset) { }
void operator++(int dummy_to_specify_postfix_op) {} // do not use
void operator<(int) {} // do not use
public:
DUIterator_Last() { }
void operator--()
{ _outp--; VDUI_ONLY(verify_step(1)); }
void operator-=(uint n)
{ _outp -= n; VDUI_ONLY(verify_step(n)); }
bool operator>=(DUIterator_Last& limit) {
I_VDUI_ONLY(*this, this->verify(_node, true));
I_VDUI_ONLY(limit, limit.verify_limit());
return _outp >= limit._outp;
}
void operator=(const DUIterator_Last& that)
{ DUIterator_Fast::operator=(that); }
};
DUIterator_Last Node::last_outs(DUIterator_Last& imin) const {
imin = DUIterator_Last(this, 0);
return DUIterator_Last(this, (ptrdiff_t)_outcnt - 1);
}
Node* Node::last_out(DUIterator_Last& i) const {
I_VDUI_ONLY(i, i.verify(this));
return debug_only(i._last=) *i._outp;
}
#endif //OPTO_DU_ITERATOR_ASSERT
#undef I_VDUI_ONLY
#undef VDUI_ONLY
class SimpleDUIterator : public StackObj {
private:
Node* node;
DUIterator_Fast i;
DUIterator_Fast imax;
public:
SimpleDUIterator(Node* n): node(n), i(n->fast_outs(imax)) {}
bool has_next() { return i < imax; }
void next() { i++; }
Node* get() { return node->fast_out(i); }
};
class Node_Array : public ResourceObj {
friend class VMStructs;
protected:
Arena *_a; // Arena to allocate in
uint _max;
Node **_nodes;
void grow( uint i ); // Grow array node to fit
public:
Node_Array(Arena *a) : _a(a), _max(OptoNodeListSize) {
_nodes = NEW_ARENA_ARRAY( a, Node *, OptoNodeListSize );
for( int i = 0; i < OptoNodeListSize; i++ ) {
_nodes[i] = NULL;
}
}
Node_Array(Node_Array *na) : _a(na->_a), _max(na->_max), _nodes(na->_nodes) {}
Node *operator[] ( uint i ) const // Lookup, or NULL for not mapped
{ return (i<_max) ? _nodes[i] : (Node*)NULL; }
Node *at( uint i ) const { assert(i<_max,"oob"); return _nodes[i]; }
Node **adr() { return _nodes; }
void map( uint i, Node *n ) { if( i>=_max ) grow(i); _nodes[i] = n; }
void insert( uint i, Node *n );
void remove( uint i ); // Remove, preserving order
void sort( C_sort_func_t func);
void reset( Arena *new_a ); // Zap mapping to empty; reclaim storage
void clear(); // Set all entries to NULL, keep storage
uint Size() const { return _max; }
void dump() const;
};
class Node_List : public Node_Array {
friend class VMStructs;
uint _cnt;
public:
Node_List() : Node_Array(Thread::current()->resource_area()), _cnt(0) {}
Node_List(Arena *a) : Node_Array(a), _cnt(0) {}
bool contains(const Node* n) const {
for (uint e = 0; e < size(); e++) {
if (at(e) == n) return true;
}
return false;
}
void insert( uint i, Node *n ) { Node_Array::insert(i,n); _cnt++; }
void remove( uint i ) { Node_Array::remove(i); _cnt--; }
void push( Node *b ) { map(_cnt++,b); }
void yank( Node *n ); // Find and remove
Node *pop() { return _nodes[--_cnt]; }
Node *rpop() { Node *b = _nodes[0]; _nodes[0]=_nodes[--_cnt]; return b;}
void clear() { _cnt = 0; Node_Array::clear(); } // retain storage
uint size() const { return _cnt; }
void dump() const;
void dump_simple() const;
};
class Unique_Node_List : public Node_List {
friend class VMStructs;
VectorSet _in_worklist;
uint _clock_index; // Index in list where to pop from next
public:
Unique_Node_List() : Node_List(), _in_worklist(Thread::current()->resource_area()), _clock_index(0) {}
Unique_Node_List(Arena *a) : Node_List(a), _in_worklist(a), _clock_index(0) {}
void remove( Node *n );
bool member( Node *n ) { return _in_worklist.test(n->_idx) != 0; }
VectorSet &member_set(){ return _in_worklist; }
void push( Node *b ) {
if( !_in_worklist.test_set(b->_idx) )
Node_List::push(b);
}
Node *pop() {
if( _clock_index >= size() ) _clock_index = 0;
Node *b = at(_clock_index);
map( _clock_index, Node_List::pop());
if (size() != 0) _clock_index++; // Always start from 0
_in_worklist >>= b->_idx;
return b;
}
Node *remove( uint i ) {
Node *b = Node_List::at(i);
_in_worklist >>= b->_idx;
map(i,Node_List::pop());
return b;
}
void yank( Node *n ) { _in_worklist >>= n->_idx; Node_List::yank(n); }
void clear() {
_in_worklist.Clear(); // Discards storage but grows automatically
Node_List::clear();
_clock_index = 0;
}
void remove_useless_nodes(VectorSet &useful);
#ifndef PRODUCT
void print_set() const { _in_worklist.print(); }
#endif
};
inline void Compile::record_for_igvn(Node* n) {
_for_igvn->push(n);
}
class Node_Stack {
friend class VMStructs;
protected:
struct INode {
Node *node; // Processed node
uint indx; // Index of next node's child
};
INode *_inode_top; // tos, stack grows up
INode *_inode_max; // End of _inodes == _inodes + _max
INode *_inodes; // Array storage for the stack
Arena *_a; // Arena to allocate in
void grow();
public:
Node_Stack(int size) {
size_t max = (size > OptoNodeListSize) ? size : OptoNodeListSize;
_a = Thread::current()->resource_area();
_inodes = NEW_ARENA_ARRAY( _a, INode, max );
_inode_max = _inodes + max;
_inode_top = _inodes - 1; // stack is empty
}
Node_Stack(Arena *a, int size) : _a(a) {
size_t max = (size > OptoNodeListSize) ? size : OptoNodeListSize;
_inodes = NEW_ARENA_ARRAY( _a, INode, max );
_inode_max = _inodes + max;
_inode_top = _inodes - 1; // stack is empty
}
void pop() {
assert(_inode_top >= _inodes, "node stack underflow");
--_inode_top;
}
void push(Node *n, uint i) {
++_inode_top;
if (_inode_top >= _inode_max) grow();
INode *top = _inode_top; // optimization
top->node = n;
top->indx = i;
}
Node *node() const {
return _inode_top->node;
}
Node* node_at(uint i) const {
assert(_inodes + i <= _inode_top, "in range");
return _inodes[i].node;
}
uint index() const {
return _inode_top->indx;
}
uint index_at(uint i) const {
assert(_inodes + i <= _inode_top, "in range");
return _inodes[i].indx;
}
void set_node(Node *n) {
_inode_top->node = n;
}
void set_index(uint i) {
_inode_top->indx = i;
}
uint size_max() const { return (uint)pointer_delta(_inode_max, _inodes, sizeof(INode)); } // Max size
uint size() const { return (uint)pointer_delta((_inode_top+1), _inodes, sizeof(INode)); } // Current size
bool is_nonempty() const { return (_inode_top >= _inodes); }
bool is_empty() const { return (_inode_top < _inodes); }
void clear() { _inode_top = _inodes - 1; } // retain storage
Node* find(uint idx) const;
};
class Node_Notes VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
JVMState* _jvms;
public:
Node_Notes(JVMState* jvms = NULL) {
_jvms = jvms;
}
JVMState* jvms() { return _jvms; }
void set_jvms(JVMState* x) { _jvms = x; }
bool is_clear() {
return (_jvms == NULL);
}
void clear() {
_jvms = NULL;
}
static Node_Notes* make(Compile* C) {
Node_Notes* nn = NEW_ARENA_ARRAY(C->comp_arena(), Node_Notes, 1);
nn->clear();
return nn;
}
Node_Notes* clone(Compile* C) {
Node_Notes* nn = NEW_ARENA_ARRAY(C->comp_arena(), Node_Notes, 1);
(*nn) = (*this);
return nn;
}
bool update_from(Node_Notes* source) {
bool changed = false;
if (source != NULL) {
if (source->jvms() != NULL) {
set_jvms(source->jvms());
changed = true;
}
}
return changed;
}
};
inline Node_Notes*
Compile::locate_node_notes(GrowableArray<Node_Notes*>* arr,
int idx, bool can_grow) {
assert(idx >= 0, "oob");
int block_idx = (idx >> _log2_node_notes_block_size);
int grow_by = (block_idx - (arr == NULL? 0: arr->length()));
if (grow_by >= 0) {
if (!can_grow) return NULL;
grow_node_notes(arr, grow_by + 1);
}
return arr->at(block_idx) + (idx & (_node_notes_block_size-1));
}
inline bool
Compile::set_node_notes_at(int idx, Node_Notes* value) {
if (value == NULL || value->is_clear())
return false; // nothing to write => write nothing
Node_Notes* loc = locate_node_notes(_node_note_array, idx, true);
assert(loc != NULL, "");
return loc->update_from(value);
}
class TypeNode : public Node {
protected:
virtual uint hash() const; // Check the type
virtual uint cmp( const Node &n ) const;
virtual uint size_of() const; // Size is bigger
const Type* const _type;
public:
void set_type(const Type* t) {
assert(t != NULL, "sanity");
debug_only(uint check_hash = (VerifyHashTableKeys && _hash_lock) ? hash() : NO_HASH);
assert(check_hash == NO_HASH || check_hash == hash(), "type change must preserve hash code");
}
const Type* type() const { assert(_type != NULL, "sanity"); return _type; };
TypeNode( const Type *t, uint required ) : Node(required), _type(t) {
init_class_id(Class_Type);
}
virtual const Type *Value( PhaseTransform *phase ) const;
virtual const Type *bottom_type() const;
virtual uint ideal_reg() const;
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const;
#endif
};
#endif // SHARE_VM_OPTO_NODE_HPP
C:\hotspot-69087d08d473\src\share\vm/opto/opcodes.cpp
#define macro(x) #x,
const char *NodeClassNames[] = {
"Node",
"Set",
"RegN",
"RegI",
"RegP",
"RegF",
"RegD",
"RegL",
"RegFlags",
"VecS",
"VecD",
"VecX",
"VecY",
"_last_machine_leaf",
#include "classes.hpp"
"_last_class_name",
};
#undef macro
C:\hotspot-69087d08d473\src\share\vm/opto/opcodes.hpp
#ifndef SHARE_VM_OPTO_OPCODES_HPP
#define SHARE_VM_OPTO_OPCODES_HPP
#define macro(x) Op_##x,
enum Opcodes {
Op_Node = 0,
macro(Set) // Instruction selection match rule
macro(RegN) // Machine narrow oop register
macro(RegI) // Machine integer register
macro(RegP) // Machine pointer register
macro(RegF) // Machine float register
macro(RegD) // Machine double register
macro(RegL) // Machine long register
macro(VecS) // Machine vectors register
macro(VecD) // Machine vectord register
macro(VecX) // Machine vectorx register
macro(VecY) // Machine vectory register
macro(RegFlags) // Machine flags register
_last_machine_leaf, // Split between regular opcodes and machine
#include "classes.hpp"
_last_opcode
};
#undef macro
extern const char *NodeClassNames[];
#endif // SHARE_VM_OPTO_OPCODES_HPP
C:\hotspot-69087d08d473\src\share\vm/opto/optoreg.hpp
#ifndef SHARE_VM_OPTO_OPTOREG_HPP
#define SHARE_VM_OPTO_OPTOREG_HPP
class OptoReg VALUE_OBJ_CLASS_SPEC {
friend class C2Compiler;
public:
typedef int Name;
enum {
Physical = AdlcVMDeps::Physical, // Start of physical regs
Special = -2, // All special (not allocated) values
Bad = -1 // Not a register
};
private:
static const VMReg opto2vm[REG_COUNT];
static Name vm2opto[ConcreteRegisterImpl::number_of_registers];
public:
static OptoReg::Name c_frame_pointer;
static Name add( Name x, int y ) { return Name(x+y); }
static void dump(int, outputStream *st = tty);
static unsigned int reg2stack( OptoReg::Name r) {
assert( r >= stack0(), " must be");
return r - stack0();
}
static OptoReg::Name stack2reg( int idx) {
return Name(stack0() + idx);
}
static bool is_stack(Name n) {
return n >= stack0();
}
static bool is_valid(Name n) {
return (n != Bad);
}
static bool is_reg(Name n) {
return is_valid(n) && !is_stack(n);
}
static VMReg as_VMReg(OptoReg::Name n) {
if (is_reg(n)) {
return opto2vm[n];
} else {
assert(!is_stack(n), "must un warp");
return VMRegImpl::Bad();
}
}
static VMReg as_VMReg(OptoReg::Name n, int frame_size, int arg_count) {
if (is_reg(n)) {
return opto2vm[n];
} else if (is_stack(n)) {
int stack_slot = reg2stack(n);
if (stack_slot < arg_count) {
return VMRegImpl::stack2reg(stack_slot + frame_size);
}
return VMRegImpl::stack2reg(stack_slot - arg_count);
} else {
return VMRegImpl::Bad();
}
}
static OptoReg::Name as_OptoReg(VMReg r) {
if (r->is_stack()) {
assert(false, "must warp");
return stack2reg(r->reg2stack());
} else if (r->is_valid()) {
return vm2opto[r->value()];
} else {
return Bad;
}
}
static OptoReg::Name stack0() {
return VMRegImpl::stack0->value();
}
static const char* regname(OptoReg::Name n) {
return as_VMReg(n)->name();
}
};
class OptoRegPair {
friend class VMStructs;
private:
short _second;
short _first;
public:
void set_bad ( ) { _second = OptoReg::Bad; _first = OptoReg::Bad; }
void set1 ( OptoReg::Name n ) { _second = OptoReg::Bad; _first = n; }
void set2 ( OptoReg::Name n ) { _second = n + 1; _first = n; }
void set_pair( OptoReg::Name second, OptoReg::Name first ) { _second= second; _first= first; }
void set_ptr ( OptoReg::Name ptr ) {
#ifdef _LP64
_second = ptr+1;
#else
_second = OptoReg::Bad;
#endif
_first = ptr;
}
OptoReg::Name second() const { return _second; }
OptoReg::Name first() const { return _first; }
OptoRegPair(OptoReg::Name second, OptoReg::Name first) { _second = second; _first = first; }
OptoRegPair(OptoReg::Name f) { _second = OptoReg::Bad; _first = f; }
OptoRegPair() { _second = OptoReg::Bad; _first = OptoReg::Bad; }
};
#endif // SHARE_VM_OPTO_OPTOREG_HPP
C:\hotspot-69087d08d473\src\share\vm/opto/output.cpp
#include "precompiled.hpp"
#include "asm/assembler.inline.hpp"
#include "code/compiledIC.hpp"
#include "code/debugInfo.hpp"
#include "code/debugInfoRec.hpp"
#include "compiler/compileBroker.hpp"
#include "compiler/disassembler.hpp"
#include "compiler/oopMap.hpp"
#include "memory/allocation.inline.hpp"
#include "opto/callnode.hpp"
#include "opto/cfgnode.hpp"
#include "opto/locknode.hpp"
#include "opto/machnode.hpp"
#include "opto/output.hpp"
#include "opto/regalloc.hpp"
#include "opto/runtime.hpp"
#include "opto/subnode.hpp"
#include "opto/type.hpp"
#include "runtime/handles.inline.hpp"
#include "utilities/xmlstream.hpp"
#ifndef PRODUCT
#define DEBUG_ARG(x) , x
#else
#define DEBUG_ARG(x)
#endif
void Compile::Output() {
assert( _cfg->get_root_block()->number_of_nodes() == 0, "" );
if ( C->check_node_count((NodeLimitFudgeFactor + C->java_calls()*3 +
C->inner_loops()*(OptoLoopAlignment-1)),
"out of nodes before code generation" ) ) {
return;
}
Block *entry = _cfg->get_block(1);
Block *broot = _cfg->get_root_block();
const StartNode *start = entry->head()->as_Start();
MachPrologNode *prolog = new (this) MachPrologNode();
entry->map_node(prolog, 0);
_cfg->map_node_to_block(prolog, entry);
_cfg->unmap_node_from_block(start); // start is no longer in any block
if( is_osr_compilation() ) {
if( PoisonOSREntry ) {
_cfg->insert( broot, 0, new (this) MachBreakpointNode() );
}
} else {
if( _method && !_method->flags().is_static() ) {
_cfg->insert( broot, 0, new (this) MachUEPNode() );
}
}
if( (_method && _method->break_at_execute())
#ifndef PRODUCT
||(OptoBreakpoint && is_method_compilation())
||(OptoBreakpointOSR && is_osr_compilation())
||(OptoBreakpointC2R && !_method)
#endif
) {
_cfg->insert( entry, 1, new (this) MachBreakpointNode() );
}
for (uint i = 0; i < _cfg->number_of_blocks(); i++) {
Block* block = _cfg->get_block(i);
if (!block->is_connector() && block->non_connector_successor(0) == _cfg->get_root_block()) { // Found a program exit point?
Node* m = block->end();
if (m->is_Mach() && m->as_Mach()->ideal_Opcode() != Op_Halt) {
MachEpilogNode* epilog = new (this) MachEpilogNode(m->as_Mach()->ideal_Opcode() == Op_Return);
block->add_inst(epilog);
_cfg->map_node_to_block(epilog, block);
}
}
}
# ifdef ENABLE_ZAP_DEAD_LOCALS
if (ZapDeadCompiledLocals) {
Insert_zap_nodes();
}
# endif
uint* blk_starts = NEW_RESOURCE_ARRAY(uint, _cfg->number_of_blocks() + 1);
blk_starts[0] = 0;
CodeBuffer* cb = init_buffer(blk_starts);
if (cb == NULL || failing()) {
return;
}
ScheduleAndBundle();
#ifndef PRODUCT
if (trace_opto_output()) {
tty->print("\n---- After ScheduleAndBundle ----\n");
for (uint i = 0; i < _cfg->number_of_blocks(); i++) {
tty->print("\nBB#%03d:\n", i);
Block* block = _cfg->get_block(i);
for (uint j = 0; j < block->number_of_nodes(); j++) {
Node* n = block->get_node(j);
OptoReg::Name reg = _regalloc->get_reg_first(n);
tty->print(" %-6s ", reg >= 0 && reg < REG_COUNT ? Matcher::regName[reg] : "");
n->dump();
}
}
}
#endif
if (failing()) {
return;
}
BuildOopMaps();
if (failing()) {
return;
}
fill_buffer(cb, blk_starts);
}
bool Compile::need_stack_bang(int frame_size_in_bytes) const {
return (UseStackBanging && stub_function() == NULL &&
(has_java_calls() || frame_size_in_bytes > os::vm_page_size()>>3
DEBUG_ONLY(|| true)));
}
bool Compile::need_register_stack_bang() const {
return (stub_function() == NULL && has_java_calls());
}
# ifdef ENABLE_ZAP_DEAD_LOCALS
int Compile::_CompiledZap_count = 0;
void Compile::Insert_zap_nodes() {
bool skip = false;
if ( CompileZapFirst == 0 ) ; // nothing special
else if ( CompileZapFirst > CompiledZap_count() ) skip = true;
else if ( CompileZapFirst == CompiledZap_count() )
warning("starting zap compilation after skipping");
if ( CompileZapLast == -1 ) ; // nothing special
else if ( CompileZapLast < CompiledZap_count() ) skip = true;
else if ( CompileZapLast == CompiledZap_count() )
warning("about to compile last zap");
++_CompiledZap_count; // counts skipped zaps, too
if ( skip ) return;
if ( _method == NULL )
return; // no safepoints/oopmaps emitted for calls in stubs,so we don't care
for( uint i=0; i<_cfg->number_of_blocks(); i++ ) {
Block *b = _cfg->get_block(i);
for ( uint j = 0; j < b->number_of_nodes(); ++j ) {
Node *n = b->get_node(j);
bool insert = n->is_MachSafePoint() && (n->as_MachSafePoint()->oop_map() != NULL);
if ( insert ) { // it is MachSafePoint
if ( !n->is_MachCall() ) {
insert = false;
} else if ( n->is_MachCall() ) {
MachCallNode* call = n->as_MachCall();
if (call->entry_point() == OptoRuntime::new_instance_Java() ||
call->entry_point() == OptoRuntime::new_array_Java() ||
call->entry_point() == OptoRuntime::multianewarray2_Java() ||
call->entry_point() == OptoRuntime::multianewarray3_Java() ||
call->entry_point() == OptoRuntime::multianewarray4_Java() ||
call->entry_point() == OptoRuntime::multianewarray5_Java() ||
call->entry_point() == OptoRuntime::slow_arraycopy_Java() ||
call->entry_point() == OptoRuntime::complete_monitor_locking_Java()
) {
insert = false;
}
}
if (insert) {
Node *zap = call_zap_node(n->as_MachSafePoint(), i);
b->insert_node(zap, j);
_cfg->map_node_to_block(zap, b);
++j;
}
}
}
}
}
Node* Compile::call_zap_node(MachSafePointNode* node_to_check, int block_no) {
const TypeFunc *tf = OptoRuntime::zap_dead_locals_Type();
CallStaticJavaNode* ideal_node =
new (this) CallStaticJavaNode( tf,
OptoRuntime::zap_dead_locals_stub(_method->flags().is_native()),
"call zap dead locals stub", 0, TypePtr::BOTTOM);
OopMap* clone = node_to_check->oop_map()->deep_copy();
ideal_node->set_oop_map(clone);
return _matcher->match_sfpt(ideal_node);
}
bool Compile::is_node_getting_a_safepoint( Node* n) {
if( n->is_MachSafePoint() ) return true;
return false;
}
# endif // ENABLE_ZAP_DEAD_LOCALS
void Compile::compute_loop_first_inst_sizes() {
if (MaxLoopPad < OptoLoopAlignment - 1) {
uint last_block = _cfg->number_of_blocks() - 1;
for (uint i = 1; i <= last_block; i++) {
Block* block = _cfg->get_block(i);
if (block->loop_alignment() > (uint)relocInfo::addr_unit()) {
uint sum_size = 0;
uint inst_cnt = NumberOfLoopInstrToAlign;
inst_cnt = block->compute_first_inst_size(sum_size, inst_cnt, _regalloc);
Block *nb = block;
while(inst_cnt > 0 &&
i < last_block &&
!_cfg->get_block(i + 1)->has_loop_alignment() &&
!nb->has_successor(block)) {
i++;
nb = _cfg->get_block(i);
inst_cnt = nb->compute_first_inst_size(sum_size, inst_cnt, _regalloc);
} // while( inst_cnt > 0 && i < last_block )
block->set_first_inst_size(sum_size);
} // f( b->head()->is_Loop() )
} // for( i <= last_block )
} // if( MaxLoopPad < OptoLoopAlignment-1 )
}
void Compile::shorten_branches(uint* blk_starts, int& code_size, int& reloc_size, int& stub_size) {
uint nblocks = _cfg->number_of_blocks();
uint* jmp_offset = NEW_RESOURCE_ARRAY(uint,nblocks);
uint* jmp_size = NEW_RESOURCE_ARRAY(uint,nblocks);
int* jmp_nidx = NEW_RESOURCE_ARRAY(int ,nblocks);
int* block_worst_case_pad = NEW_RESOURCE_ARRAY(int, nblocks);
memset(block_worst_case_pad, 0, nblocks * sizeof(int));
DEBUG_ONLY( uint *jmp_target = NEW_RESOURCE_ARRAY(uint,nblocks); )
DEBUG_ONLY( uint *jmp_rule = NEW_RESOURCE_ARRAY(uint,nblocks); )
bool has_short_branch_candidate = false;
code_size = 0; // Size in bytes of generated code
stub_size = 0; // Size in bytes of all stub entries
reloc_size = 1; // Number of relocation entries
uint last_call_adr = max_uint;
uint last_avoid_back_to_back_adr = max_uint;
uint nop_size = (new (this) MachNopNode())->size(_regalloc);
for (uint i = 0; i < nblocks; i++) { // For all blocks
Block* block = _cfg->get_block(i);
jmp_offset[i] = 0;
jmp_size[i] = 0;
jmp_nidx[i] = -1;
DEBUG_ONLY( jmp_target[i] = 0; )
DEBUG_ONLY( jmp_rule[i] = 0; )
uint last_inst = block->number_of_nodes();
uint blk_size = 0;
for (uint j = 0; j < last_inst; j++) {
Node* nj = block->get_node(j);
if (nj->is_Mach()) {
MachNode *mach = nj->as_Mach();
blk_size += (mach->alignment_required() - 1) * relocInfo::addr_unit(); // assume worst case padding
reloc_size += mach->reloc();
if (mach->is_MachCall()) {
stub_size += CallStubImpl::size_call_trampoline();
reloc_size += CallStubImpl::reloc_call_trampoline();
MachCallNode *mcall = mach->as_MachCall();
mcall->method_set((intptr_t)mcall->entry_point());
if (mcall->is_MachCallJava() && mcall->as_MachCallJava()->_method) {
stub_size += CompiledStaticCall::to_interp_stub_size();
reloc_size += CompiledStaticCall::reloc_to_interp_stub();
}
} else if (mach->is_MachSafePoint()) {
if (last_call_adr >= blk_starts[i]) {
blk_size += nop_size;
}
}
if (mach->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
if (last_avoid_back_to_back_adr >= blk_starts[i]) {
blk_size += nop_size;
}
}
if (mach->may_be_short_branch()) {
if (!nj->is_MachBranch()) {
#ifndef PRODUCT
nj->dump(3);
#endif
Unimplemented();
}
assert(jmp_nidx[i] == -1, "block should have only one branch");
jmp_offset[i] = blk_size;
jmp_size[i] = nj->size(_regalloc);
jmp_nidx[i] = j;
has_short_branch_candidate = true;
}
}
blk_size += nj->size(_regalloc);
if (nj->is_MachCall() && !nj->is_MachCallLeaf()) {
last_call_adr = blk_starts[i]+blk_size;
}
if (nj->is_Mach() && nj->as_Mach()->avoid_back_to_back(MachNode::AVOID_AFTER)) {
last_avoid_back_to_back_adr = blk_starts[i]+blk_size;
}
}
if (i < nblocks - 1) {
Block* nb = _cfg->get_block(i + 1);
int max_loop_pad = nb->code_alignment()-relocInfo::addr_unit();
if (max_loop_pad > 0) {
assert(is_power_of_2(max_loop_pad+relocInfo::addr_unit()), "");
if (last_call_adr == blk_starts[i]+blk_size) {
last_call_adr += max_loop_pad;
}
if (last_avoid_back_to_back_adr == blk_starts[i]+blk_size) {
last_avoid_back_to_back_adr += max_loop_pad;
}
blk_size += max_loop_pad;
block_worst_case_pad[i + 1] = max_loop_pad;
}
}
blk_starts[i+1] = blk_starts[i]+blk_size;
}
bool progress = true;
uint last_may_be_short_branch_adr = max_uint;
while (has_short_branch_candidate && progress) {
progress = false;
has_short_branch_candidate = false;
int adjust_block_start = 0;
for (uint i = 0; i < nblocks; i++) {
Block* block = _cfg->get_block(i);
int idx = jmp_nidx[i];
MachNode* mach = (idx == -1) ? NULL: block->get_node(idx)->as_Mach();
if (mach != NULL && mach->may_be_short_branch()) {
#ifdef ASSERT
assert(jmp_size[i] > 0 && mach->is_MachBranch(), "sanity");
int j;
for (j = block->number_of_nodes()-1; j>=0; j--) {
Node* n = block->get_node(j);
if (!n->is_Mach() || n->as_Mach()->ideal_Opcode() != Op_Con)
break;
}
assert(j >= 0 && j == idx && block->get_node(j) == (Node*)mach, "sanity");
#endif
int br_size = jmp_size[i];
int br_offs = blk_starts[i] + jmp_offset[i];
uint bnum = block->non_connector_successor(0)->_pre_order;
int offset = blk_starts[bnum] - br_offs;
if (bnum > i) { // adjust following block's offset
offset -= adjust_block_start;
}
int block_padding = block_worst_case_pad[i];
assert(i == 0 || block_padding == 0 || br_offs >= block_padding, "Should have at least a padding on top");
bool needs_padding = ((uint)(br_offs - block_padding) == last_may_be_short_branch_adr);
assert(!needs_padding || jmp_offset[i] == 0, "padding only branches at the beginning of block");
if (needs_padding && offset <= 0)
offset -= nop_size;
if (_matcher->is_short_branch_offset(mach->rule(), br_size, offset)) {
MachNode* replacement = mach->as_MachBranch()->short_branch_version(this);
int new_size = replacement->size(_regalloc);
int diff = br_size - new_size;
assert(diff >= (int)nop_size, "short_branch size should be smaller");
if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
jmp_offset[i] += nop_size;
diff -= nop_size;
}
adjust_block_start += diff;
block->map_node(replacement, idx);
mach->subsume_by(replacement, C);
mach = replacement;
progress = true;
jmp_size[i] = new_size;
DEBUG_ONLY( jmp_target[i] = bnum; );
DEBUG_ONLY( jmp_rule[i] = mach->rule(); );
} else {
has_short_branch_candidate = true;
}
} // (mach->may_be_short_branch())
if (mach != NULL && (mach->may_be_short_branch() ||
mach->avoid_back_to_back(MachNode::AVOID_AFTER))) {
last_may_be_short_branch_adr = blk_starts[i] + jmp_offset[i] + jmp_size[i];
}
blk_starts[i+1] -= adjust_block_start;
}
}
#ifdef ASSERT
for (uint i = 0; i < nblocks; i++) { // For all blocks
if (jmp_target[i] != 0) {
int br_size = jmp_size[i];
int offset = blk_starts[jmp_target[i]]-(blk_starts[i] + jmp_offset[i]);
if (!_matcher->is_short_branch_offset(jmp_rule[i], br_size, offset)) {
tty->print_cr("target (%d) - jmp_offset(%d) = offset (%d), jump_size(%d), jmp_block B%d, target_block B%d", blk_starts[jmp_target[i]], blk_starts[i] + jmp_offset[i], offset, br_size, i, jmp_target[i]);
}
assert(_matcher->is_short_branch_offset(jmp_rule[i], br_size, offset), "Displacement too large for short jmp");
}
}
#endif
code_size = blk_starts[nblocks];
reloc_size += 1; // Relo entry for exception handler
reloc_size *= 10 / sizeof(relocInfo);
}
static LocationValue *new_loc_value( PhaseRegAlloc *ra, OptoReg::Name regnum, Location::Type l_type ) {
assert(OptoReg::is_valid(regnum), "location must be valid");
return (OptoReg::is_reg(regnum))
? new LocationValue(Location::new_reg_loc(l_type, OptoReg::as_VMReg(regnum)) )
: new LocationValue(Location::new_stk_loc(l_type, ra->reg2offset(regnum)));
}
ObjectValue*
Compile::sv_for_node_id(GrowableArray<ScopeValue*> *objs, int id) {
for (int i = 0; i < objs->length(); i++) {
assert(objs->at(i)->is_object(), "corrupt object cache");
ObjectValue* sv = (ObjectValue*) objs->at(i);
if (sv->id() == id) {
return sv;
}
}
return NULL;
}
void Compile::set_sv_for_object_node(GrowableArray<ScopeValue*> *objs,
ObjectValue* sv ) {
assert(sv_for_node_id(objs, sv->id()) == NULL, "Precondition");
objs->append(sv);
}
void Compile::FillLocArray( int idx, MachSafePointNode* sfpt, Node *local,
GrowableArray<ScopeValue*> *array,
GrowableArray<ScopeValue*> *objs ) {
assert( local, "use _top instead of null" );
if (array->length() != idx) {
assert(array->length() == idx + 1, "Unexpected array count");
assert(local == top(), "LocArray collision");
if (local == top()) {
return;
}
array->pop();
}
const Type *t = local->bottom_type();
if (local->is_SafePointScalarObject()) {
SafePointScalarObjectNode* spobj = local->as_SafePointScalarObject();
ObjectValue* sv = Compile::sv_for_node_id(objs, spobj->_idx);
if (sv == NULL) {
ciKlass* cik = t->is_oopptr()->klass();
assert(cik->is_instance_klass() ||
cik->is_array_klass(), "Not supported allocation.");
sv = new ObjectValue(spobj->_idx,
new ConstantOopWriteValue(cik->java_mirror()->constant_encoding()));
Compile::set_sv_for_object_node(objs, sv);
uint first_ind = spobj->first_index(sfpt->jvms());
for (uint i = 0; i < spobj->n_fields(); i++) {
Node* fld_node = sfpt->in(first_ind+i);
(void)FillLocArray(sv->field_values()->length(), sfpt, fld_node, sv->field_values(), objs);
}
}
array->append(sv);
return;
}
OptoReg::Name regnum = _regalloc->get_reg_first(local);
if( OptoReg::is_valid(regnum) ) {// Got a register/stack?
#ifdef _LP64
if( t->base() == Type::DoubleBot || t->base() == Type::DoubleCon ) {
array->append(new ConstantIntValue(0));
array->append(new_loc_value( _regalloc, regnum, Location::dbl ));
} else if ( t->base() == Type::Long ) {
array->append(new ConstantIntValue(0));
array->append(new_loc_value( _regalloc, regnum, Location::lng ));
} else if ( t->base() == Type::RawPtr ) {
array->append(new_loc_value( _regalloc, regnum, Location::lng ));
}
#else //_LP64
#ifdef SPARC
if (t->base() == Type::Long && OptoReg::is_reg(regnum)) {
array->append(new_loc_value( _regalloc, regnum , Location::normal ));
array->append(new_loc_value( _regalloc, OptoReg::add(regnum,1), Location::normal ));
} else
#endif //SPARC
if( t->base() == Type::DoubleBot || t->base() == Type::DoubleCon || t->base() == Type::Long ) {
array->append(new_loc_value( _regalloc, OptoReg::add(regnum,1), Location::normal ));
array->append(new_loc_value( _regalloc, regnum , Location::normal ));
}
#endif //_LP64
else if( (t->base() == Type::FloatBot || t->base() == Type::FloatCon) &&
OptoReg::is_reg(regnum) ) {
array->append(new_loc_value( _regalloc, regnum, Matcher::float_in_double()
? Location::float_in_dbl : Location::normal ));
} else if( t->base() == Type::Int && OptoReg::is_reg(regnum) ) {
array->append(new_loc_value( _regalloc, regnum, Matcher::int_in_long
? Location::int_in_long : Location::normal ));
} else if( t->base() == Type::NarrowOop ) {
array->append(new_loc_value( _regalloc, regnum, Location::narrowoop ));
} else {
array->append(new_loc_value( _regalloc, regnum, _regalloc->is_oop(local) ? Location::oop : Location::normal ));
}
return;
}
switch (t->base()) {
case Type::Half: // Second half of a double
ShouldNotReachHere(); // Caller should skip 2nd halves
break;
case Type::AnyPtr:
array->append(new ConstantOopWriteValue(NULL));
break;
case Type::AryPtr:
case Type::InstPtr: // fall through
array->append(new ConstantOopWriteValue(t->isa_oopptr()->const_oop()->constant_encoding()));
break;
case Type::NarrowOop:
if (t == TypeNarrowOop::NULL_PTR) {
array->append(new ConstantOopWriteValue(NULL));
} else {
array->append(new ConstantOopWriteValue(t->make_ptr()->isa_oopptr()->const_oop()->constant_encoding()));
}
break;
case Type::Int:
array->append(new ConstantIntValue(t->is_int()->get_con()));
break;
case Type::RawPtr:
assert((intptr_t)t->is_ptr()->get_con() < (intptr_t)0x10000, "must be a valid BCI");
#ifdef _LP64
array->append(new ConstantLongValue(t->is_ptr()->get_con()));
#else
array->append(new ConstantIntValue(t->is_ptr()->get_con()));
#endif
break;
case Type::FloatCon: {
float f = t->is_float_constant()->getf();
array->append(new ConstantIntValue(jint_cast(f)));
break;
}
case Type::DoubleCon: {
jdouble d = t->is_double_constant()->getd();
#ifdef _LP64
array->append(new ConstantIntValue(0));
array->append(new ConstantDoubleValue(d));
#else
jlong_accessor acc;
acc.long_value = jlong_cast(d);
array->append(new ConstantIntValue(acc.words[1]));
array->append(new ConstantIntValue(acc.words[0]));
#endif
break;
}
case Type::Long: {
jlong d = t->is_long()->get_con();
#ifdef _LP64
array->append(new ConstantIntValue(0));
array->append(new ConstantLongValue(d));
#else
jlong_accessor acc;
acc.long_value = d;
array->append(new ConstantIntValue(acc.words[1]));
array->append(new ConstantIntValue(acc.words[0]));
#endif
break;
}
case Type::Top: // Add an illegal value here
array->append(new LocationValue(Location()));
break;
default:
ShouldNotReachHere();
break;
}
}
bool Compile::starts_bundle(const Node *n) const {
return (_node_bundling_limit > n->_idx &&
_node_bundling_base[n->_idx].starts_bundle());
}
void Compile::Process_OopMap_Node(MachNode *mach, int current_offset) {
MachSafePointNode *sfn = mach->as_MachSafePoint();
MachCallNode *mcall;
#ifdef ENABLE_ZAP_DEAD_LOCALS
assert( is_node_getting_a_safepoint(mach), "logic does not match; false negative");
#endif
int safepoint_pc_offset = current_offset;
bool is_method_handle_invoke = false;
bool return_oop = false;
if( !mach->is_MachCall() ) {
mcall = NULL;
debug_info()->add_safepoint(safepoint_pc_offset, sfn->_oop_map);
} else {
mcall = mach->as_MachCall();
if (mcall->is_MachCallJava()) {
if (mcall->as_MachCallJava()->_method_handle_invoke) {
assert(has_method_handle_invokes(), "must have been set during call generation");
is_method_handle_invoke = true;
}
}
if (mcall->returns_pointer()) {
return_oop = true;
}
safepoint_pc_offset += mcall->ret_addr_offset();
debug_info()->add_safepoint(safepoint_pc_offset, mcall->_oop_map);
}
JVMState* youngest_jvms = sfn->jvms();
int max_depth = youngest_jvms->depth();
GrowableArray<ScopeValue*> *objs = new GrowableArray<ScopeValue*>();
for (int depth = 1; depth <= max_depth; depth++) {
JVMState* jvms = youngest_jvms->of_depth(depth);
int idx;
ciMethod* method = jvms->has_method() ? jvms->method() : NULL;
int num_locs = (method == NULL) ? 0 : jvms->loc_size();
int num_exps = (method == NULL) ? 0 : jvms->stk_size();
int num_mon = jvms->nof_monitors();
assert(method == NULL || jvms->bci() < 0 || num_locs == method->max_locals(),
"JVMS local count must match that of the method");
GrowableArray<ScopeValue*> *locarray = new GrowableArray<ScopeValue*>(num_locs);
for( idx = 0; idx < num_locs; idx++ ) {
FillLocArray( idx, sfn, sfn->local(jvms, idx), locarray, objs );
}
GrowableArray<ScopeValue*> *exparray = new GrowableArray<ScopeValue*>(num_exps);
for( idx = 0; idx < num_exps; idx++ ) {
FillLocArray( idx, sfn, sfn->stack(jvms, idx), exparray, objs );
}
assert( !method ||
!method->is_synchronized() ||
method->is_native() ||
num_mon > 0 ||
!GenerateSynchronizationCode,
"monitors must always exist for synchronized methods");
GrowableArray<MonitorValue*> *monarray = new GrowableArray<MonitorValue*>(num_mon);
for (idx = 0; idx < num_mon; idx++) {
Node* box_node = sfn->monitor_box(jvms, idx);
Node* obj_node = sfn->monitor_obj(jvms, idx);
ScopeValue *scval = NULL;
if (obj_node->is_SafePointScalarObject()) {
SafePointScalarObjectNode* spobj = obj_node->as_SafePointScalarObject();
scval = Compile::sv_for_node_id(objs, spobj->_idx);
if (scval == NULL) {
const Type *t = spobj->bottom_type();
ciKlass* cik = t->is_oopptr()->klass();
assert(cik->is_instance_klass() ||
cik->is_array_klass(), "Not supported allocation.");
ObjectValue* sv = new ObjectValue(spobj->_idx,
new ConstantOopWriteValue(cik->java_mirror()->constant_encoding()));
Compile::set_sv_for_object_node(objs, sv);
uint first_ind = spobj->first_index(youngest_jvms);
for (uint i = 0; i < spobj->n_fields(); i++) {
Node* fld_node = sfn->in(first_ind+i);
(void)FillLocArray(sv->field_values()->length(), sfn, fld_node, sv->field_values(), objs);
}
scval = sv;
}
} else if (!obj_node->is_Con()) {
OptoReg::Name obj_reg = _regalloc->get_reg_first(obj_node);
if( obj_node->bottom_type()->base() == Type::NarrowOop ) {
scval = new_loc_value( _regalloc, obj_reg, Location::narrowoop );
} else {
scval = new_loc_value( _regalloc, obj_reg, Location::oop );
}
} else {
const TypePtr *tp = obj_node->get_ptr_type();
scval = new ConstantOopWriteValue(tp->is_oopptr()->const_oop()->constant_encoding());
}
OptoReg::Name box_reg = BoxLockNode::reg(box_node);
Location basic_lock = Location::new_stk_loc(Location::normal,_regalloc->reg2offset(box_reg));
bool eliminated = (box_node->is_BoxLock() && box_node->as_BoxLock()->is_eliminated());
monarray->append(new MonitorValue(scval, basic_lock, eliminated));
}
debug_info()->dump_object_pool(objs);
DebugToken *locvals = debug_info()->create_scope_values(locarray);
DebugToken *expvals = debug_info()->create_scope_values(exparray);
DebugToken *monvals = debug_info()->create_monitor_values(monarray);
ciMethod* scope_method = method ? method : _method;
assert(jvms->bci() >= InvocationEntryBci && jvms->bci() <= 0x10000, "must be a valid or entry BCI");
assert(!jvms->should_reexecute() || depth == max_depth, "reexecute allowed only for the youngest");
debug_info()->describe_scope(safepoint_pc_offset, scope_method, jvms->bci(), jvms->should_reexecute(), is_method_handle_invoke, return_oop, locvals, expvals, monvals);
} // End jvms loop
debug_info()->end_safepoint(safepoint_pc_offset);
}
class NonSafepointEmitter {
Compile* C;
JVMState* _pending_jvms;
int _pending_offset;
void emit_non_safepoint();
public:
NonSafepointEmitter(Compile* compile) {
this->C = compile;
_pending_jvms = NULL;
_pending_offset = 0;
}
void observe_instruction(Node* n, int pc_offset) {
if (!C->debug_info()->recording_non_safepoints()) return;
Node_Notes* nn = C->node_notes_at(n->_idx);
if (nn == NULL || nn->jvms() == NULL) return;
if (_pending_jvms != NULL &&
_pending_jvms->same_calls_as(nn->jvms())) {
_pending_offset = pc_offset;
} else {
if (_pending_jvms != NULL &&
_pending_offset < pc_offset) {
emit_non_safepoint();
}
_pending_jvms = NULL;
if (pc_offset > C->debug_info()->last_pc_offset()) {
_pending_jvms = nn->jvms();
_pending_offset = pc_offset;
}
}
}
void observe_safepoint(JVMState* jvms, int pc_offset) {
if (_pending_jvms != NULL &&
!_pending_jvms->same_calls_as(jvms) &&
_pending_offset < pc_offset) {
emit_non_safepoint();
}
_pending_jvms = NULL;
}
void flush_at_end() {
if (_pending_jvms != NULL) {
emit_non_safepoint();
}
_pending_jvms = NULL;
}
};
void NonSafepointEmitter::emit_non_safepoint() {
JVMState* youngest_jvms = _pending_jvms;
int pc_offset = _pending_offset;
_pending_jvms = NULL;
DebugInformationRecorder* debug_info = C->debug_info();
assert(debug_info->recording_non_safepoints(), "sanity");
debug_info->add_non_safepoint(pc_offset);
int max_depth = youngest_jvms->depth();
for (int depth = 1; depth <= max_depth; depth++) {
JVMState* jvms = youngest_jvms->of_depth(depth);
ciMethod* method = jvms->has_method() ? jvms->method() : NULL;
assert(!jvms->should_reexecute() || depth==max_depth, "reexecute allowed only for the youngest");
debug_info->describe_scope(pc_offset, method, jvms->bci(), jvms->should_reexecute());
}
debug_info->end_non_safepoint(pc_offset);
}
CodeBuffer* Compile::init_buffer(uint* blk_starts) {
int code_req = initial_code_capacity;
int locs_req = initial_locs_capacity;
int stub_req = TraceJumps ? initial_stub_capacity * 10 : initial_stub_capacity;
int const_req = initial_const_capacity;
int pad_req = NativeCall::instruction_size;
if (fixed_slots() != 0) {
_orig_pc_slot_offset_in_bytes = _regalloc->reg2offset(OptoReg::stack2reg(_orig_pc_slot));
}
_method_size = 0;
_frame_slots = OptoReg::reg2stack(_matcher->_old_SP)+_regalloc->_framesize;
#if defined(IA64) && !defined(AIX)
if (save_argument_registers()) {
_frame_slots += 8*(16/BytesPerInt);
}
#endif
assert(_frame_slots >= 0 && _frame_slots < 1000000, "sanity check");
if (has_mach_constant_base_node()) {
uint add_size = 0;
for (uint i = 0; i < _cfg->number_of_blocks(); i++) {
Block* b = _cfg->get_block(i);
for (uint j = 0; j < b->number_of_nodes(); j++) {
Node* n = b->get_node(j);
if (n->is_MachConstant()) {
MachConstantNode* machcon = n->as_MachConstant();
machcon->eval_constant(C);
} else if (n->is_Mach()) {
add_size += (n->as_Mach()->ins_num_consts() * 8);
}
}
}
constant_table().calculate_offsets_and_size();
const_req = constant_table().size() + add_size;
}
init_scratch_buffer_blob(const_req);
if (failing()) return NULL; // Out of memory
shorten_branches(blk_starts, code_req, locs_req, stub_req);
int exception_handler_req = HandlerImpl::size_exception_handler() + MAX_stubs_size; // add marginal slop for handler
int deopt_handler_req = HandlerImpl::size_deopt_handler() + MAX_stubs_size; // add marginal slop for handler
stub_req += MAX_stubs_size; // ensure per-stub margin
code_req += MAX_inst_size; // ensure per-instruction margin
if (StressCodeBuffers)
code_req = const_req = stub_req = exception_handler_req = deopt_handler_req = 0x10; // force expansion
int total_req =
const_req +
code_req +
pad_req +
stub_req +
exception_handler_req +
deopt_handler_req; // deopt handler
if (has_method_handle_invokes())
total_req += deopt_handler_req; // deopt MH handler
CodeBuffer* cb = code_buffer();
cb->initialize(total_req, locs_req);
if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
C->record_failure("CodeCache is full");
return NULL;
}
cb->initialize_consts_size(const_req);
cb->initialize_stubs_size(stub_req);
cb->initialize_oop_recorder(env()->oop_recorder());
MachNode *_nop_list[Bundle::_nop_count];
Bundle::initialize_nops(_nop_list, this);
return cb;
}
void Compile::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
compute_loop_first_inst_sizes();
_oop_map_set = new OopMapSet();
debug_info()->set_oopmaps(_oop_map_set);
uint nblocks = _cfg->number_of_blocks();
uint inct_cnt = 0;
uint *inct_starts = NEW_RESOURCE_ARRAY(uint, nblocks+1);
uint *call_returns = NEW_RESOURCE_ARRAY(uint, nblocks+1);
uint return_offset = 0;
int nop_size = (new (this) MachNopNode())->size(_regalloc);
int previous_offset = 0;
int current_offset = 0;
int last_call_offset = -1;
int last_avoid_back_to_back_offset = -1;
#ifdef ASSERT
uint* jmp_target = NEW_RESOURCE_ARRAY(uint,nblocks);
uint* jmp_offset = NEW_RESOURCE_ARRAY(uint,nblocks);
uint* jmp_size = NEW_RESOURCE_ARRAY(uint,nblocks);
uint* jmp_rule = NEW_RESOURCE_ARRAY(uint,nblocks);
#endif
#ifndef PRODUCT
int *node_offsets = NULL;
uint node_offset_limit = unique();
if (print_assembly())
node_offsets = NEW_RESOURCE_ARRAY(int, node_offset_limit);
#endif
NonSafepointEmitter non_safepoints(this); // emit non-safepoints lazily
if (has_mach_constant_base_node()) {
constant_table().emit(*cb);
}
Label *blk_labels = NEW_RESOURCE_ARRAY(Label, nblocks+1);
for (uint i=0; i <= nblocks; i++) {
blk_labels[i].init();
}
Node *delay_slot = NULL;
for (uint i = 0; i < nblocks; i++) {
Block* block = _cfg->get_block(i);
Node* head = block->head();
if (Pipeline::requires_bundling() && starts_bundle(head)) {
cb->flush_bundle(true);
}
#ifdef ASSERT
if (!block->is_connector()) {
stringStream st;
block->dump_head(_cfg, &st);
MacroAssembler(cb).block_comment(st.as_string());
}
jmp_target[i] = 0;
jmp_offset[i] = 0;
jmp_size[i] = 0;
jmp_rule[i] = 0;
#endif
int blk_offset = current_offset;
MacroAssembler(cb).bind(blk_labels[block->_pre_order]);
uint last_inst = block->number_of_nodes();
for (uint j = 0; j<last_inst; j++) {
Node* n = block->get_node(j);
if (valid_bundle_info(n) &&
node_bundling(n)->used_in_unconditional_delay()) {
assert(delay_slot == NULL, "no use of delay slot node");
assert(n->size(_regalloc) == Pipeline::instr_unit_size(), "delay slot instruction wrong size");
delay_slot = n;
continue;
}
if (Pipeline::requires_bundling() && starts_bundle(n))
cb->flush_bundle(false);
bool is_mcall = false;
if (n->is_Mach()) {
MachNode *mach = n->as_Mach();
is_mcall = n->is_MachCall();
bool is_sfn = n->is_MachSafePoint();
if (is_sfn || is_mcall || mach->alignment_required() != 1) {
cb->flush_bundle(true);
current_offset = cb->insts_size();
}
int padding = mach->compute_padding(current_offset);
if (is_sfn && !is_mcall && padding == 0 && current_offset == last_call_offset) {
padding = nop_size;
}
if (padding == 0 && mach->avoid_back_to_back(MachNode::AVOID_BEFORE) &&
current_offset == last_avoid_back_to_back_offset) {
padding = nop_size;
}
if(padding > 0) {
assert((padding % nop_size) == 0, "padding is not a multiple of NOP size");
int nops_cnt = padding / nop_size;
MachNode *nop = new (this) MachNopNode(nops_cnt);
block->insert_node(nop, j++);
last_inst++;
_cfg->map_node_to_block(nop, block);
nop->emit(*cb, _regalloc);
cb->flush_bundle(true);
current_offset = cb->insts_size();
}
if (is_mcall) {
MachCallNode *mcall = mach->as_MachCall();
mcall->method_set((intptr_t)mcall->entry_point());
call_returns[block->_pre_order] = current_offset + mcall->ret_addr_offset();
if (mcall->is_MachCallLeaf()) {
is_mcall = false;
is_sfn = false;
}
}
if (is_sfn || is_mcall) {
if (!is_mcall) {
MachSafePointNode *sfn = mach->as_MachSafePoint();
if (sfn->jvms()->method() == NULL) {
# ifdef ENABLE_ZAP_DEAD_LOCALS
assert( !is_node_getting_a_safepoint(sfn), "logic does not match; false positive");
# endif
continue;
}
} // End synchronization
non_safepoints.observe_safepoint(mach->as_MachSafePoint()->jvms(),
current_offset);
Process_OopMap_Node(mach, current_offset);
} // End if safepoint
else if( mach->is_MachNullCheck() ) {
inct_starts[inct_cnt++] = previous_offset;
}
else if (mach->is_MachBranch()) {
uint block_num = block->non_connector_successor(0)->_pre_order;
bool delay_slot_is_used = valid_bundle_info(n) &&
node_bundling(n)->use_unconditional_delay();
if (!delay_slot_is_used && mach->may_be_short_branch()) {
assert(delay_slot == NULL, "not expecting delay slot node");
int br_size = n->size(_regalloc);
int offset = blk_starts[block_num] - current_offset;
if (block_num >= i) {
offset -= (blk_starts[i] - blk_offset);
}
bool needs_padding = (current_offset == last_avoid_back_to_back_offset);
if (needs_padding && offset <= 0)
offset -= nop_size;
if (_matcher->is_short_branch_offset(mach->rule(), br_size, offset)) {
MachNode* replacement = mach->as_MachBranch()->short_branch_version(this);
int new_size = replacement->size(_regalloc);
assert((br_size - new_size) >= (int)nop_size, "short_branch size should be smaller");
if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
MachNode *nop = new (this) MachNopNode();
block->insert_node(nop, j++);
_cfg->map_node_to_block(nop, block);
last_inst++;
nop->emit(*cb, _regalloc);
cb->flush_bundle(true);
current_offset = cb->insts_size();
}
#ifdef ASSERT
jmp_target[i] = block_num;
jmp_offset[i] = current_offset - blk_offset;
jmp_size[i] = new_size;
jmp_rule[i] = mach->rule();
#endif
block->map_node(replacement, j);
mach->subsume_by(replacement, C);
n = replacement;
mach = replacement;
}
}
mach->as_MachBranch()->label_set( &blk_labels[block_num], block_num );
} else if (mach->ideal_Opcode() == Op_Jump) {
for (uint h = 0; h < block->_num_succs; h++) {
Block* succs_block = block->_succs[h];
for (uint j = 1; j < succs_block->num_preds(); j++) {
Node* jpn = succs_block->pred(j);
if (jpn->is_JumpProj() && jpn->in(0) == mach) {
uint block_num = succs_block->non_connector()->_pre_order;
Label *blkLabel = &blk_labels[block_num];
mach->add_case_label(jpn->as_JumpProj()->proj_no(), blkLabel);
}
}
}
}
#ifdef ASSERT
else if (mach->ideal_Opcode() == Op_StoreCM) {
uint storeCM_idx = j;
int count = 0;
for (uint prec = mach->req(); prec < mach->len(); prec++) {
Node *oop_store = mach->in(prec); // Precedence edge
if (oop_store == NULL) continue;
count++;
uint i4;
for (i4 = 0; i4 < last_inst; ++i4) {
if (block->get_node(i4) == oop_store) {
break;
}
}
assert(i4 == last_inst || i4 < storeCM_idx, "CM card-mark executes before oop-store");
}
assert(count > 0, "storeCM expects at least one precedence edge");
}
#endif
else if (!n->is_Proj()) {
previous_offset = current_offset;
}
if (mach->is_TrapBasedCheckNode()) {
inct_starts[inct_cnt++] = current_offset;
}
}
cb->insts()->maybe_expand_to_ensure_remaining(MAX_inst_size);
if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
C->record_failure("CodeCache is full");
return;
}
#ifndef PRODUCT
if (node_offsets && n->_idx < node_offset_limit)
node_offsets[n->_idx] = cb->insts_size();
#endif
DEBUG_ONLY( uint instr_offset = cb->insts_size(); )
n->emit(*cb, _regalloc);
current_offset = cb->insts_size();
if (failing()) {
return;
}
#ifdef ASSERT
uint n_size = n->size(_regalloc);
if (n_size < (current_offset-instr_offset)) {
MachNode* mach = n->as_Mach();
n->dump();
mach->dump_format(_regalloc, tty);
tty->print_cr(" n_size (%d), current_offset (%d), instr_offset (%d)", n_size, current_offset, instr_offset);
Disassembler::decode(cb->insts_begin() + instr_offset, cb->insts_begin() + current_offset + 1, tty);
tty->print_cr(" ------------------- ");
BufferBlob* blob = this->scratch_buffer_blob();
address blob_begin = blob->content_begin();
Disassembler::decode(blob_begin, blob_begin + n_size + 1, tty);
assert(false, "wrong size of mach node");
}
#endif
non_safepoints.observe_instruction(n, current_offset);
if (is_mcall) {
last_call_offset = current_offset;
}
if (n->is_Mach() && n->as_Mach()->avoid_back_to_back(MachNode::AVOID_AFTER)) {
last_avoid_back_to_back_offset = current_offset;
}
if (valid_bundle_info(n) && node_bundling(n)->use_unconditional_delay()) {
assert(delay_slot != NULL, "expecting delay slot node");
cb->set_insts_end(cb->insts_end() - Pipeline::instr_unit_size());
#ifndef PRODUCT
if (node_offsets && delay_slot->_idx < node_offset_limit)
node_offsets[delay_slot->_idx] = cb->insts_size();
#endif
if (delay_slot->is_MachSafePoint()) {
MachNode *mach = delay_slot->as_Mach();
if (!mach->is_MachCall() && mach->as_MachSafePoint()->jvms()->method() == NULL) {
# ifdef ENABLE_ZAP_DEAD_LOCALS
assert( !is_node_getting_a_safepoint(mach), "logic does not match; false positive");
# endif
delay_slot = NULL;
continue;
}
int adjusted_offset = current_offset - Pipeline::instr_unit_size();
non_safepoints.observe_safepoint(mach->as_MachSafePoint()->jvms(),
adjusted_offset);
Process_OopMap_Node(mach, adjusted_offset);
}
delay_slot->emit(*cb, _regalloc);
delay_slot = NULL;
}
} // End for all instructions in block
if (i < nblocks-1) {
Block *nb = _cfg->get_block(i + 1);
int padding = nb->alignment_padding(current_offset);
if( padding > 0 ) {
MachNode *nop = new (this) MachNopNode(padding / nop_size);
block->insert_node(nop, block->number_of_nodes());
_cfg->map_node_to_block(nop, block);
nop->emit(*cb, _regalloc);
current_offset = cb->insts_size();
}
}
guarantee((int)(blk_starts[i+1] - blk_starts[i]) >= (current_offset - blk_offset), "shouldn't increase block size");
blk_starts[i] = blk_offset;
} // End of for all blocks
blk_starts[nblocks] = current_offset;
non_safepoints.flush_at_end();
if (failing()) return;
MacroAssembler(cb).bind( blk_labels[nblocks] );
_first_block_size = blk_labels[1].loc_pos() - blk_labels[0].loc_pos();
assert(cb->insts_size() < 500000, "method is unreasonably large");
#ifdef ASSERT
for (uint i = 0; i < nblocks; i++) { // For all blocks
if (jmp_target[i] != 0) {
int br_size = jmp_size[i];
int offset = blk_starts[jmp_target[i]]-(blk_starts[i] + jmp_offset[i]);
if (!_matcher->is_short_branch_offset(jmp_rule[i], br_size, offset)) {
tty->print_cr("target (%d) - jmp_offset(%d) = offset (%d), jump_size(%d), jmp_block B%d, target_block B%d", blk_starts[jmp_target[i]], blk_starts[i] + jmp_offset[i], offset, br_size, i, jmp_target[i]);
assert(false, "Displacement too large for short jmp");
}
}
}
#endif
#ifndef PRODUCT
Scheduling::increment_method_size(cb->insts_size());
#endif
FillExceptionTables(inct_cnt, call_returns, inct_starts, blk_labels);
if (_method) {
_code_offsets.set_value(CodeOffsets::Exceptions, HandlerImpl::emit_exception_handler(*cb));
if (failing()) {
return; // CodeBuffer::expand failed
}
_code_offsets.set_value(CodeOffsets::Deopt, HandlerImpl::emit_deopt_handler(*cb));
if (has_method_handle_invokes() && !failing()) {
_code_offsets.set_value(CodeOffsets::DeoptMH, HandlerImpl::emit_deopt_handler(*cb));
}
}
if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
C->record_failure("CodeCache is full");
return;
}
#ifndef PRODUCT
if (print_assembly()) {
ttyLocker ttyl; // keep the following output all in one block
if (!VMThread::should_terminate()) { // test this under the tty lock
if (xtty != NULL) {
xtty->head("opto_assembly compile_id='%d'%s", compile_id(),
is_osr_compilation() ? " compile_kind='osr'" :
"");
}
if (method() != NULL) {
method()->print_metadata();
} else if (stub_name() != NULL) {
tty->print_cr("Generating RuntimeStub - %s", stub_name());
}
dump_asm(node_offsets, node_offset_limit);
if (xtty != NULL) {
xtty->tail("opto_assembly");
}
}
}
#endif
}
void Compile::FillExceptionTables(uint cnt, uint *call_returns, uint *inct_starts, Label *blk_labels) {
_inc_table.set_size(cnt);
uint inct_cnt = 0;
for (uint i = 0; i < _cfg->number_of_blocks(); i++) {
Block* block = _cfg->get_block(i);
Node *n = NULL;
int j;
for (j = block->number_of_nodes() - 1; j >= 0; j--) {
n = block->get_node(j);
if (!n->is_Mach() || n->as_Mach()->ideal_Opcode() != Op_Con) {
break;
}
}
if (j < 0) {
continue;
}
if (n->is_Catch()) {
uint call_return = call_returns[block->_pre_order];
#ifdef ASSERT
assert( call_return > 0, "no call seen for this basic block" );
while (block->get_node(--j)->is_MachProj()) ;
assert(block->get_node(j)->is_MachCall(), "CatchProj must follow call");
#endif
int nof_succs = block->_num_succs;
GrowableArray<intptr_t> handler_bcis(nof_succs);
GrowableArray<intptr_t> handler_pcos(nof_succs);
for (int j = 0; j < nof_succs; j++) {
Block* s = block->_succs[j];
bool found_p = false;
for (uint k = 1; k < s->num_preds(); k++) {
Node* pk = s->pred(k);
if (pk->is_CatchProj() && pk->in(0) == n) {
const CatchProjNode* p = pk->as_CatchProj();
found_p = true;
if (p->_con != CatchProjNode::fall_through_index) {
assert(s == _cfg->get_block(s->_pre_order), "bad numbering");
if (!handler_bcis.contains(p->handler_bci())) {
uint block_num = s->non_connector()->_pre_order;
handler_bcis.append(p->handler_bci());
handler_pcos.append(blk_labels[block_num].loc_pos());
}
}
}
}
assert(found_p, "no matching predecessor found");
}
_handler_table.add_subtable(call_return, &handler_bcis, NULL, &handler_pcos);
continue;
}
if (n->is_MachNullCheck()) {
uint block_num = block->non_connector_successor(0)->_pre_order;
_inc_table.append(inct_starts[inct_cnt++], blk_labels[block_num].loc_pos());
continue;
}
if (n->is_Mach() && n->as_Mach()->is_TrapBasedCheckNode()) {
uint block_num = block->non_connector_successor(0)->_pre_order;
_inc_table.append(inct_starts[inct_cnt++], blk_labels[block_num].loc_pos());
continue;
}
} // End of for all blocks fill in exception table entries
}
#ifndef PRODUCT
uint Scheduling::_total_nop_size = 0;
uint Scheduling::_total_method_size = 0;
uint Scheduling::_total_branches = 0;
uint Scheduling::_total_unconditional_delays = 0;
uint Scheduling::_total_instructions_per_bundle[Pipeline::_max_instrs_per_cycle+1];
#endif
Scheduling::Scheduling(Arena *arena, Compile &compile)
: _arena(arena),
_cfg(compile.cfg()),
_regalloc(compile.regalloc()),
_reg_node(arena),
_bundle_instr_count(0),
_bundle_cycle_number(0),
_scheduled(arena),
_available(arena),
_next_node(NULL),
_bundle_use(0, 0, resource_count, &_bundle_use_elements[0]),
_pinch_free_list(arena)
#ifndef PRODUCT
, _branches(0)
, _unconditional_delays(0)
#endif
{
_nop = new (&compile) MachNopNode();
_node_bundling_limit = compile.unique();
uint node_max = _regalloc->node_regs_max_index();
compile.set_node_bundling_limit(_node_bundling_limit);
_node_bundling_base = NEW_ARENA_ARRAY(compile.comp_arena(), Bundle, node_max);
_node_latency = NEW_ARENA_ARRAY(arena, unsigned short, node_max);
_uses = NEW_ARENA_ARRAY(arena, short, node_max);
_current_latency = NEW_ARENA_ARRAY(arena, unsigned short, node_max);
memset(_node_bundling_base, 0, node_max * sizeof(Bundle));
memset(_node_latency, 0, node_max * sizeof(unsigned short));
memset(_uses, 0, node_max * sizeof(short));
memset(_current_latency, 0, node_max * sizeof(unsigned short));
memcpy(_bundle_use_elements, Pipeline_Use::elaborated_elements, sizeof(Pipeline_Use::elaborated_elements));
Block* block = _cfg->get_block(_cfg->number_of_blocks() - 1);
_next_node = block->get_node(block->number_of_nodes() - 1);
}
#ifndef PRODUCT
Scheduling::~Scheduling() {
_total_branches += _branches;
_total_unconditional_delays += _unconditional_delays;
}
#endif
void Scheduling::step(uint i) {
Bundle *bundle = node_bundling(_next_node);
bundle->set_starts_bundle();
if (_bundle_instr_count > 0) {
bundle->set_instr_count(_bundle_instr_count);
bundle->set_resources_used(_bundle_use.resourcesUsed());
}
_bundle_instr_count = 0;
_bundle_cycle_number += i;
_bundle_use.step(i);
}
void Scheduling::step_and_clear() {
Bundle *bundle = node_bundling(_next_node);
bundle->set_starts_bundle();
if (_bundle_instr_count > 0) {
bundle->set_instr_count(_bundle_instr_count);
bundle->set_resources_used(_bundle_use.resourcesUsed());
_bundle_cycle_number += 1;
}
_bundle_instr_count = 0;
_bundle_use.reset();
memcpy(_bundle_use_elements,
Pipeline_Use::elaborated_elements,
sizeof(Pipeline_Use::elaborated_elements));
}
void Compile::ScheduleAndBundle() {
if (!_method)
return;
if (!do_scheduling())
return;
if (max_vector_size() > 8)
return;
NOT_PRODUCT( TracePhase t2("isched", &_t_instrSched, TimeCompiler); )
Scheduling scheduling(Thread::current()->resource_area(), *this);
scheduling.DoScheduling();
}
void Scheduling::ComputeLocalLatenciesForward(const Block *bb) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# -> ComputeLocalLatenciesForward\n");
#endif
for( uint j=_bb_start; j < _bb_end; j++ ) {
uint latency = 1;
Node *use = bb->get_node(j);
uint nlen = use->len();
for ( uint k=0; k < nlen; k++ ) {
Node *def = use->in(k);
if (!def)
continue;
uint l = _node_latency[def->_idx] + use->latency(k);
if (latency < l)
latency = l;
}
_node_latency[use->_idx] = latency;
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# latency %4d: ", latency);
use->dump();
}
#endif
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# <- ComputeLocalLatenciesForward\n");
#endif
} // end ComputeLocalLatenciesForward
bool Scheduling::NodeFitsInBundle(Node *n) {
uint n_idx = n->_idx;
if (n == _unconditional_delay_slot) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# NodeFitsInBundle [%4d]: TRUE; is in unconditional delay slot\n", n->_idx);
#endif
return (true);
}
if (_current_latency[n_idx] > _bundle_cycle_number) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# NodeFitsInBundle [%4d]: FALSE; latency %4d > %d\n",
n->_idx, _current_latency[n_idx], _bundle_cycle_number);
#endif
return (false);
}
const Pipeline *node_pipeline = n->pipeline();
uint instruction_count = node_pipeline->instructionCount();
if (node_pipeline->mayHaveNoCode() && n->size(_regalloc) == 0)
instruction_count = 0;
else if (node_pipeline->hasBranchDelay() && !_unconditional_delay_slot)
instruction_count++;
if (_bundle_instr_count + instruction_count > Pipeline::_max_instrs_per_cycle) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# NodeFitsInBundle [%4d]: FALSE; too many instructions: %d > %d\n",
n->_idx, _bundle_instr_count + instruction_count, Pipeline::_max_instrs_per_cycle);
#endif
return (false);
}
if (!n->is_Mach() && instruction_count == 0)
return (false);
uint delay = _bundle_use.full_latency(0, node_pipeline->resourceUse());
if (delay > 0) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# NodeFitsInBundle [%4d]: FALSE; functional units overlap\n", n_idx);
#endif
return false;
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# NodeFitsInBundle [%4d]: TRUE\n", n_idx);
#endif
return true;
}
Node * Scheduling::ChooseNodeToBundle() {
uint siz = _available.size();
if (siz == 0) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# ChooseNodeToBundle: NULL\n");
#endif
return (NULL);
}
if (siz == 1) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# ChooseNodeToBundle (only 1): ");
_available[0]->dump();
}
#endif
return (_available[0]);
}
if (_bundle_instr_count < Pipeline::_max_instrs_per_cycle) {
for ( uint i = 0; i < siz; i++ ) {
Node *n = _available[i];
if (n->is_Proj())
continue;
if (NodeFitsInBundle(n)) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# ChooseNodeToBundle: ");
n->dump();
}
#endif
return (n);
}
}
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# ChooseNodeToBundle: ");
_available[0]->dump();
}
#endif
return _available[0];
}
void Scheduling::AddNodeToAvailableList(Node *n) {
assert( !n->is_Proj(), "projections never directly made available" );
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# AddNodeToAvailableList: ");
n->dump();
}
#endif
int latency = _current_latency[n->_idx];
uint i;
for ( i=0; i < _available.size(); i++ )
if (_current_latency[_available[i]->_idx] > latency)
break;
if( n->is_Mach() && _scheduled.size() > 0 ) {
int op = n->as_Mach()->ideal_Opcode();
Node *last = _scheduled[0];
if( last->is_MachIf() && last->in(1) == n &&
( op == Op_CmpI ||
op == Op_CmpU ||
op == Op_CmpUL ||
op == Op_CmpP ||
op == Op_CmpF ||
op == Op_CmpD ||
op == Op_CmpL ) ) {
for ( i=0 ; i < _available.size(); i++ )
if (_current_latency[_available[i]->_idx] >= latency)
break;
}
}
_available.insert(i, n);
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
dump_available();
#endif
}
void Scheduling::DecrementUseCounts(Node *n, const Block *bb) {
for ( uint i=0; i < n->len(); i++ ) {
Node *def = n->in(i);
if (!def) continue;
if( def->is_Proj() ) // If this is a machine projection, then
def = def->in(0); // propagate usage thru to the base instruction
if(_cfg->get_block_for_node(def) != bb) { // Ignore if not block-local
continue;
}
uint l = _bundle_cycle_number + n->latency(i);
if (_current_latency[def->_idx] < l)
_current_latency[def->_idx] = l;
if ((--_uses[def->_idx]) == 0)
AddNodeToAvailableList(def);
}
}
void Scheduling::AddNodeToBundle(Node *n, const Block *bb) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# AddNodeToBundle: ");
n->dump();
}
#endif
uint i;
for (i = 0; i < _available.size(); i++)
if (_available[i] == n)
break;
assert(i < _available.size(), "entry in _available list not found");
_available.remove(i);
const Pipeline *node_pipeline = n->pipeline();
const Pipeline_Use& node_usage = node_pipeline->resourceUse();
if (Pipeline::_branch_has_delay_slot &&
node_pipeline->hasBranchDelay() &&
!_unconditional_delay_slot) {
uint siz = _available.size();
if ( n->is_MachBranch() ) {
assert( !n->is_MachNullCheck(), "should not look for delay slot for Null Check" );
assert( !n->is_Catch(), "should not look for delay slot for Catch" );
#ifndef PRODUCT
_branches++;
#endif
for (uint i = 0; i < siz; i++) {
Node *d = _available[i];
const Pipeline *avail_pipeline = d->pipeline();
if ( avail_pipeline->instructionCount() == 1 &&
!avail_pipeline->hasMultipleBundles() &&
!avail_pipeline->hasBranchDelay() &&
Pipeline::instr_has_unit_size() &&
d->size(_regalloc) == Pipeline::instr_unit_size() &&
NodeFitsInBundle(d) &&
!node_bundling(d)->used_in_delay()) {
if (d->is_Mach() && !d->is_MachSafePoint()) {
_unconditional_delay_slot = d;
node_bundling(n)->set_use_unconditional_delay();
node_bundling(d)->set_used_in_unconditional_delay();
_bundle_use.add_usage(avail_pipeline->resourceUse());
_current_latency[d->_idx] = _bundle_cycle_number;
_next_node = d;
++_bundle_instr_count;
#ifndef PRODUCT
_unconditional_delays++;
#endif
break;
}
}
}
}
if (!_unconditional_delay_slot) {
if (!NodeFitsInBundle(_nop)) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# *** STEP(1 instruction for delay slot) ***\n");
#endif
step(1);
}
_bundle_use.add_usage(_nop->pipeline()->resourceUse());
_next_node = _nop;
++_bundle_instr_count;
}
if (!NodeFitsInBundle(n)) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# *** STEP(branch won't fit) ***\n");
#endif
_bundle_instr_count = 0;
_bundle_cycle_number += 1;
_bundle_use.step(1);
}
}
uint instruction_count = node_pipeline->instructionCount();
if (node_pipeline->mayHaveNoCode() && n->size(_regalloc) == 0)
instruction_count = 0;
uint delay = 0;
if (instruction_count > 0 || !node_pipeline->mayHaveNoCode()) {
int relative_latency = _current_latency[n->_idx] - _bundle_cycle_number;
if (relative_latency < 0)
relative_latency = 0;
delay = _bundle_use.full_latency(relative_latency, node_usage);
if (delay > 0) {
step(delay);
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# *** STEP(%d) ***\n", delay);
#endif
}
}
if (n != _unconditional_delay_slot) {
if (delay == 0) {
if (node_pipeline->hasMultipleBundles()) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# *** STEP(multiple instructions) ***\n");
#endif
step(1);
}
else if (instruction_count + _bundle_instr_count > Pipeline::_max_instrs_per_cycle) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# *** STEP(%d >= %d instructions) ***\n",
instruction_count + _bundle_instr_count,
Pipeline::_max_instrs_per_cycle);
#endif
step(1);
}
}
if (node_pipeline->hasBranchDelay() && !_unconditional_delay_slot)
_bundle_instr_count++;
_current_latency[n->_idx] = _bundle_cycle_number;
if (instruction_count > 0 || !node_pipeline->mayHaveNoCode())
_bundle_use.add_usage(node_usage);
_bundle_instr_count += instruction_count;
if (n->is_Mach())
_next_node = n;
}
int op = n->Opcode();
if( (op == Op_Node && n->req() == 0) || // anti-dependence node OR
(op != Op_Node && // Not an unused antidepedence node and
(OptoReg::is_valid(_regalloc->get_reg_first(n)) || op != Op_BoxLock)) ) {
if( bb->get_node(bb->number_of_nodes()-1) != n ) {
for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
Node *foi = n->fast_out(i);
if( foi->is_Proj() )
_scheduled.push(foi);
}
}
_scheduled.push(n);
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
dump_available();
#endif
DecrementUseCounts(n,bb);
}
void Scheduling::ComputeUseCount(const Block *bb) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# -> ComputeUseCount\n");
#endif
_available.clear();
_scheduled.clear();
_unconditional_delay_slot = NULL;
#ifdef ASSERT
for( uint i=0; i < bb->number_of_nodes(); i++ )
assert( _uses[bb->get_node(i)->_idx] == 0, "_use array not clean" );
#endif
for( uint k = 0; k < _bb_start; k++ )
_uses[bb->get_node(k)->_idx] = 1;
for( uint l = _bb_end; l < bb->number_of_nodes(); l++ )
_uses[bb->get_node(l)->_idx] = 1;
for( uint j = _bb_end-1; j >= _bb_start; j-- ) {
Node *n = bb->get_node(j);
if( n->is_Proj() ) continue; // Projections handled another way
for ( uint k = 0; k < n->len(); k++ ) {
Node *inp = n->in(k);
if (!inp) continue;
assert(inp != n, "no cycles allowed" );
if (_cfg->get_block_for_node(inp) == bb) { // Block-local use?
if (inp->is_Proj()) { // Skip through Proj's
inp = inp->in(0);
}
++_uses[inp->_idx]; // Count 1 block-local use
}
}
if (!_uses[n->_idx]) {
_current_latency[n->_idx] = _bundle_cycle_number;
AddNodeToAvailableList(n);
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# uses: %3d: ", _uses[n->_idx]);
n->dump();
}
#endif
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# <- ComputeUseCount\n");
#endif
}
void Scheduling::DoScheduling() {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# -> DoScheduling\n");
#endif
Block *succ_bb = NULL;
Block *bb;
for (int i = _cfg->number_of_blocks() - 1; i >= 0; succ_bb = bb, i--) {
bb = _cfg->get_block(i);
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# Schedule BB#%03d (initial)\n", i);
for (uint j = 0; j < bb->number_of_nodes(); j++) {
bb->get_node(j)->dump();
}
}
#endif
if (bb == _cfg->get_root_block()) {
continue;
}
if (bb->is_connector())
continue;
if (bb->_num_succs != 1 || bb->non_connector_successor(0) != succ_bb) {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("*** bundle start of next BB, node %d, for %d instructions\n",
_next_node->_idx, _bundle_instr_count);
}
#endif
step_and_clear();
}
_bb_end = bb->number_of_nodes()-1;
for( _bb_start=1; _bb_start <= _bb_end; _bb_start++ ) {
Node *n = bb->get_node(_bb_start);
if( !n->is_Mach() ) continue; // Skip non-machine nodes
MachNode *mach = n->as_Mach();
int iop = mach->ideal_Opcode();
if( iop == Op_CreateEx ) continue; // CreateEx is pinned
if( iop == Op_Con ) continue; // Do not schedule Top
if( iop == Op_Node && // Do not schedule PhiNodes, ProjNodes
mach->pipeline() == MachNode::pipeline_class() &&
!n->is_SpillCopy() && !n->is_MachMerge() ) // Breakpoints, Prolog, etc
continue;
break; // Funny loop structure to be sure...
}
Node *last = bb->get_node(_bb_end);
while (_bb_end > 0 && last->is_Mach() &&
last->as_Mach()->ideal_Opcode() == Op_Con) {
last = bb->get_node(--_bb_end);
}
assert(!last->is_Mach() || last->as_Mach()->ideal_Opcode() != Op_Con, "");
if( last->is_Catch() ||
(_bb_end > 1 && last->is_Mach() && last->as_Mach()->ideal_Opcode() == Op_Halt) ) {
while( !bb->get_node(--_bb_end)->is_MachCall() ) {
assert( bb->get_node(_bb_end)->is_MachProj(), "skipping projections after expected call" );
}
} else if( last->is_MachNullCheck() ) {
Node *mem = last->in(1);
do {
_bb_end--;
} while (mem != bb->get_node(_bb_end));
} else {
_bb_end++;
}
assert( _bb_start <= _bb_end, "inverted block ends" );
ComputeRegisterAntidependencies(bb);
if (_cfg->C->failing()) return; // too many D-U pinch points
ComputeLocalLatenciesForward(bb);
ComputeUseCount(bb);
while ( _available.size() > 0 ) {
Node *n = ChooseNodeToBundle();
guarantee(n != NULL, "no nodes available");
AddNodeToBundle(n,bb);
}
assert( _scheduled.size() == _bb_end - _bb_start, "wrong number of instructions" );
#ifdef ASSERT
for( uint l = _bb_start; l < _bb_end; l++ ) {
Node *n = bb->get_node(l);
uint m;
for( m = 0; m < _bb_end-_bb_start; m++ )
if( _scheduled[m] == n )
break;
assert( m < _bb_end-_bb_start, "instruction missing in schedule" );
}
#endif
for ( uint k = _bb_start; k < _bb_end; k++ )
bb->map_node(_scheduled[_bb_end-k-1], k);
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
tty->print("# Schedule BB#%03d (final)\n", i);
uint current = 0;
for (uint j = 0; j < bb->number_of_nodes(); j++) {
Node *n = bb->get_node(j);
if( valid_bundle_info(n) ) {
Bundle *bundle = node_bundling(n);
if (bundle->instr_count() > 0 || bundle->flags() > 0) {
tty->print("*** Bundle: ");
bundle->dump();
}
n->dump();
}
}
}
#endif
#ifdef ASSERT
verify_good_schedule(bb,"after block local scheduling");
#endif
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output())
tty->print("# <- DoScheduling\n");
#endif
_regalloc->C->set_node_bundling_base(_node_bundling_base);
} // end DoScheduling
static bool edge_from_to( Node *from, Node *to ) {
for( uint i=0; i<from->len(); i++ )
if( from->in(i) == to )
return true;
return false;
}
#ifdef ASSERT
void Scheduling::verify_do_def( Node *n, OptoReg::Name def, const char *msg ) {
if( OptoReg::is_valid(def) ) { // Ignore stores & control flow
Node *prior_use = _reg_node[def];
if( prior_use && !edge_from_to(prior_use,n) ) {
tty->print("%s = ",OptoReg::as_VMReg(def)->name());
n->dump();
tty->print_cr("...");
prior_use->dump();
assert(edge_from_to(prior_use,n),msg);
}
_reg_node.map(def,NULL); // Kill live USEs
}
}
void Scheduling::verify_good_schedule( Block *b, const char *msg ) {
_reg_node.clear();
for( uint i = b->number_of_nodes()-1; i >= _bb_start; i-- ) {
Node *n = b->get_node(i);
int n_op = n->Opcode();
if( n_op == Op_MachProj && n->ideal_reg() == MachProjNode::fat_proj ) {
RegMask rm = n->out_RegMask();// Make local copy
while( rm.is_NotEmpty() ) {
OptoReg::Name kill = rm.find_first_elem();
rm.Remove(kill);
verify_do_def( n, kill, msg );
}
} else if( n_op != Op_Node ) { // Avoid brand new antidependence nodes
verify_do_def( n, _regalloc->get_reg_first(n), msg );
verify_do_def( n, _regalloc->get_reg_second(n), msg );
}
for( uint i=1; i<n->req(); i++ ) {
Node *def = n->in(i);
assert(def != 0, "input edge required");
OptoReg::Name reg_lo = _regalloc->get_reg_first(def);
OptoReg::Name reg_hi = _regalloc->get_reg_second(def);
if( OptoReg::is_valid(reg_lo) ) {
assert(!_reg_node[reg_lo] || edge_from_to(_reg_node[reg_lo],def), msg);
_reg_node.map(reg_lo,n);
}
if( OptoReg::is_valid(reg_hi) ) {
assert(!_reg_node[reg_hi] || edge_from_to(_reg_node[reg_hi],def), msg);
_reg_node.map(reg_hi,n);
}
}
}
_reg_node.clear();
}
#endif
static void add_prec_edge_from_to( Node *from, Node *to ) {
if( from->is_Proj() ) { // Put precedence edge on Proj's input
assert( from->req() == 1 && (from->len() == 1 || from->in(1)==0), "no precedence edges on projections" );
from = from->in(0);
}
if( from != to && // No cycles (for things like LD L0,[L0+4] )
!edge_from_to( from, to ) ) // Avoid duplicate edge
from->add_prec(to);
}
void Scheduling::anti_do_def( Block *b, Node *def, OptoReg::Name def_reg, int is_def ) {
if( !OptoReg::is_valid(def_reg) ) // Ignore stores & control flow
return;
Node *pinch = _reg_node[def_reg]; // Get pinch point
if ((pinch == NULL) || _cfg->get_block_for_node(pinch) != b || // No pinch-point yet?
is_def ) { // Check for a true def (not a kill)
_reg_node.map(def_reg,def); // Record def/kill as the optimistic pinch-point
return;
}
Node *kill = def; // Rename 'def' to more descriptive 'kill'
debug_only( def = (Node*)((intptr_t)0xdeadbeef); )
Node *later_def = NULL;
if( pinch->Opcode() != Op_Node ) { // Or later-def/kill as pinch-point?
later_def = pinch; // Must be def/kill as optimistic pinch-point
if ( _pinch_free_list.size() > 0) {
pinch = _pinch_free_list.pop();
} else {
pinch = new (_cfg->C) Node(1); // Pinch point to-be
}
if (pinch->_idx >= _regalloc->node_regs_max_index()) {
_cfg->C->record_method_not_compilable("too many D-U pinch points");
return;
}
_cfg->map_node_to_block(pinch, b); // Pretend it's valid in this block (lazy init)
_reg_node.map(def_reg,pinch); // Record pinch-point
if( later_def->outcnt() == 0 || later_def->ideal_reg() == MachProjNode::fat_proj ) { // Distinguish def from kill
pinch->init_req(0, _cfg->C->top()); // set not NULL for the next call
add_prec_edge_from_to(later_def,pinch); // Add edge from kill to pinch
later_def = NULL; // and no later def
}
pinch->set_req(0,later_def); // Hook later def so we can find it
} else { // Else have valid pinch point
if( pinch->in(0) ) // If there is a later-def
later_def = pinch->in(0); // Get it
}
if( later_def ) // If there is some original def
add_prec_edge_from_to(later_def,kill); // Add edge from def to kill
if( pinch->Opcode() == Op_Node ) {
Node *uses = kill->is_Proj() ? kill->in(0) : kill;
for( uint i=1; i<uses->req(); i++ ) {
if( _regalloc->get_reg_first(uses->in(i)) == def_reg ||
_regalloc->get_reg_second(uses->in(i)) == def_reg ) {
pinch->set_req(0,NULL); //
pinch->replace_by(kill); // Move anti-dep edges up
pinch = kill;
_reg_node.map(def_reg,pinch);
return;
}
}
}
add_prec_edge_from_to(kill,pinch);
}
void Scheduling::anti_do_use( Block *b, Node *use, OptoReg::Name use_reg ) {
if( !OptoReg::is_valid(use_reg) ) // Ignore stores & control flow
return;
Node *pinch = _reg_node[use_reg]; // Get pinch point
if ((pinch != NULL) && _cfg->get_block_for_node(pinch) == b &&
_cfg->get_block_for_node(use) == b) {
if( pinch->Opcode() == Op_Node && // Real pinch-point (not optimistic?)
pinch->req() == 1 ) { // pinch not yet in block?
pinch->del_req(0); // yank pointer to later-def, also set flag
b->insert_node(pinch, b->find_node(use) + 1);
_bb_end++; // Increase size scheduled region in block
}
add_prec_edge_from_to(pinch,use);
}
}
void Scheduling::ComputeRegisterAntidependencies(Block *b) {
#ifdef ASSERT
verify_good_schedule(b,"before block local scheduling");
#endif
bool fat_proj_seen = false;
uint last_safept = _bb_end-1;
Node* end_node = (_bb_end-1 >= _bb_start) ? b->get_node(last_safept) : NULL;
Node* last_safept_node = end_node;
for( uint i = _bb_end-1; i >= _bb_start; i-- ) {
Node *n = b->get_node(i);
int is_def = n->outcnt(); // def if some uses prior to adding precedence edges
if( n->is_MachProj() && n->ideal_reg() == MachProjNode::fat_proj ) {
fat_proj_seen = true;
RegMask rm = n->out_RegMask();// Make local copy
while( rm.is_NotEmpty() ) {
OptoReg::Name kill = rm.find_first_elem();
rm.Remove(kill);
anti_do_def( b, n, kill, is_def );
}
} else {
anti_do_def( b, n, _regalloc->get_reg_first(n), is_def );
anti_do_def( b, n, _regalloc->get_reg_second(n), is_def );
}
if (n->is_MachBranch() || n->is_Mach() && n->as_Mach()->ideal_Opcode() == Op_Jump) {
for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
Node* use = n->fast_out(i);
if (use->is_Proj()) {
RegMask rm = use->out_RegMask();// Make local copy
while( rm.is_NotEmpty() ) {
OptoReg::Name kill = rm.find_first_elem();
rm.Remove(kill);
anti_do_def( b, n, kill, false );
}
}
}
}
for( uint j=0; j<n->req(); j++ ) {
Node *def = n->in(j);
if( def ) {
assert( !def->is_MachProj() || def->ideal_reg() != MachProjNode::fat_proj, "" );
anti_do_use( b, n, _regalloc->get_reg_first(def) );
anti_do_use( b, n, _regalloc->get_reg_second(def) );
}
}
Node *m = b->get_node(i);
if( last_safept_node != end_node &&
m != last_safept_node) {
for (uint k = 1; k < m->req(); k++) {
const Type *t = m->in(k)->bottom_type();
if( t->isa_oop_ptr() &&
t->is_ptr()->offset() != 0 ) {
last_safept_node->add_prec( m );
break;
}
}
}
if( n->jvms() ) { // Precedence edge from derived to safept
if( b->get_node(last_safept) != last_safept_node ) {
last_safept = b->find_node(last_safept_node);
}
for( uint j=last_safept; j > i; j-- ) {
Node *mach = b->get_node(j);
if( mach->is_Mach() && mach->as_Mach()->ideal_Opcode() == Op_AddP )
mach->add_prec( n );
}
last_safept = i;
last_safept_node = m;
}
}
if (fat_proj_seen) {
garbage_collect_pinch_nodes();
}
}
void Scheduling::garbage_collect_pinch_nodes() {
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) tty->print("Reclaimed pinch nodes:");
#endif
int trace_cnt = 0;
for (uint k = 0; k < _reg_node.Size(); k++) {
Node* pinch = _reg_node[k];
if ((pinch != NULL) && pinch->Opcode() == Op_Node &&
(pinch->req() == pinch->len() || pinch->in(pinch->req()) == NULL) ) {
cleanup_pinch(pinch);
_pinch_free_list.push(pinch);
_reg_node.map(k, NULL);
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) {
trace_cnt++;
if (trace_cnt > 40) {
tty->print("\n");
trace_cnt = 0;
}
tty->print(" %d", pinch->_idx);
}
#endif
}
}
#ifndef PRODUCT
if (_cfg->C->trace_opto_output()) tty->print("\n");
#endif
}
void Scheduling::cleanup_pinch( Node *pinch ) {
assert (pinch && pinch->Opcode() == Op_Node && pinch->req() == 1, "just checking");
for (DUIterator_Last imin, i = pinch->last_outs(imin); i >= imin; ) {
Node* use = pinch->last_out(i);
uint uses_found = 0;
for (uint j = use->req(); j < use->len(); j++) {
if (use->in(j) == pinch) {
use->rm_prec(j);
uses_found++;
}
}
assert(uses_found > 0, "must be a precedence edge");
i -= uses_found; // we deleted 1 or more copies of this edge
}
pinch->set_req(0, NULL);
}
#ifndef PRODUCT
void Scheduling::dump_available() const {
tty->print("#Availist ");
for (uint i = 0; i < _available.size(); i++)
tty->print(" N%d/l%d", _available[i]->_idx,_current_latency[_available[i]->_idx]);
tty->cr();
}
void Scheduling::print_statistics() {
tty->print("Nops added %d bytes to total of %d bytes",
_total_nop_size, _total_method_size);
if (_total_method_size > 0)
tty->print(", for %.2f%%",
((double)_total_nop_size) / ((double) _total_method_size) * 100.0);
tty->print("\n");
if (Pipeline::_branch_has_delay_slot) {
tty->print("Of %d branches, %d had unconditional delay slots filled",
_total_branches, _total_unconditional_delays);
if (_total_branches > 0)
tty->print(", for %.2f%%",
((double)_total_unconditional_delays) / ((double)_total_branches) * 100.0);
tty->print("\n");
}
uint total_instructions = 0, total_bundles = 0;
for (uint i = 1; i <= Pipeline::_max_instrs_per_cycle; i++) {
uint bundle_count = _total_instructions_per_bundle[i];
total_instructions += bundle_count * i;
total_bundles += bundle_count;
}
if (total_bundles > 0)
tty->print("Average ILP (excluding nops) is %.2f\n",
((double)total_instructions) / ((double)total_bundles));
}
#endif
C:\hotspot-69087d08d473\src\share\vm/opto/output.hpp
#ifndef SHARE_VM_OPTO_OUTPUT_HPP
#define SHARE_VM_OPTO_OUTPUT_HPP
#include "opto/block.hpp"
#include "opto/node.hpp"
#if defined AD_MD_HPP
# include AD_MD_HPP
#elif defined TARGET_ARCH_MODEL_x86_32
# include "adfiles/ad_x86_32.hpp"
#elif defined TARGET_ARCH_MODEL_x86_64
# include "adfiles/ad_x86_64.hpp"
#elif defined TARGET_ARCH_MODEL_aarch64
# include "adfiles/ad_aarch64.hpp"
#elif defined TARGET_ARCH_MODEL_sparc
# include "adfiles/ad_sparc.hpp"
#elif defined TARGET_ARCH_MODEL_zero
# include "adfiles/ad_zero.hpp"
#elif defined TARGET_ARCH_MODEL_ppc_64
# include "adfiles/ad_ppc_64.hpp"
#endif
class Arena;
class Bundle;
class Block;
class Block_Array;
class Node;
class Node_Array;
class Node_List;
class PhaseCFG;
class PhaseChaitin;
class Pipeline_Use_Element;
class Pipeline_Use;
#ifndef PRODUCT
#define DEBUG_ARG(x) , x
#else
#define DEBUG_ARG(x)
#endif
enum {
initial_code_capacity = 16 * 1024,
initial_stub_capacity = 4 * 1024,
initial_const_capacity = 4 * 1024,
initial_locs_capacity = 3 * 1024
};
class Scheduling {
private:
Arena *_arena;
PhaseCFG *_cfg;
PhaseRegAlloc *_regalloc;
uint _node_bundling_limit;
Node_List _scheduled;
Node_List _available;
Bundle *_node_bundling_base;
Node_List _reg_node;
Node_List _pinch_free_list;
unsigned short *_node_latency;
short *_uses;
uint _bb_start, _bb_end;
unsigned short *_current_latency;
Node *_next_node;
Node *_unconditional_delay_slot;
MachNopNode *_nop;
uint _bundle_instr_count;
uint _bundle_cycle_number;
Pipeline_Use_Element _bundle_use_elements[resource_count];
Pipeline_Use _bundle_use;
void dump_available() const;
public:
Scheduling(Arena *arena, Compile &compile);
NOT_PRODUCT( ~Scheduling(); )
void step(uint i);
void step_and_clear();
Bundle* node_bundling(const Node *n) {
assert(valid_bundle_info(n), "oob");
return (&_node_bundling_base[n->_idx]);
}
bool valid_bundle_info(const Node *n) const {
return (_node_bundling_limit > n->_idx);
}
bool starts_bundle(const Node *n) const {
return (_node_bundling_limit > n->_idx && _node_bundling_base[n->_idx].starts_bundle());
}
void DoScheduling();
void ComputeLocalLatenciesForward(const Block *bb);
void ComputeRegisterAntidependencies(Block *bb);
void verify_do_def( Node *n, OptoReg::Name def, const char *msg );
void verify_good_schedule( Block *b, const char *msg );
void anti_do_def( Block *b, Node *def, OptoReg::Name def_reg, int is_def );
void anti_do_use( Block *b, Node *use, OptoReg::Name use_reg );
void AddNodeToBundle(Node *n, const Block *bb);
void AddNodeToAvailableList(Node *n);
void ComputeUseCount(const Block *bb);
Node * ChooseNodeToBundle();
bool NodeFitsInBundle(Node *n);
void DecrementUseCounts(Node *n, const Block *bb);
void garbage_collect_pinch_nodes();
void cleanup_pinch( Node *pinch );
#ifndef PRODUCT
private:
uint _branches, _unconditional_delays;
static uint _total_nop_size, _total_method_size;
static uint _total_branches, _total_unconditional_delays;
static uint _total_instructions_per_bundle[Pipeline::_max_instrs_per_cycle+1];
public:
static void print_statistics();
static void increment_instructions_per_bundle(uint i) {
_total_instructions_per_bundle[i]++;
}
static void increment_nop_size(uint s) {
_total_nop_size += s;
}
static void increment_method_size(uint s) {
_total_method_size += s;
}
#endif
};
#endif // SHARE_VM_OPTO_OUTPUT_HPP
C:\hotspot-69087d08d473\src\share\vm/opto/parse.hpp
#ifndef SHARE_VM_OPTO_PARSE_HPP
#define SHARE_VM_OPTO_PARSE_HPP
#include "ci/ciMethodData.hpp"
#include "ci/ciTypeFlow.hpp"
#include "compiler/methodLiveness.hpp"
#include "libadt/vectset.hpp"
#include "oops/generateOopMap.hpp"
#include "opto/graphKit.hpp"
#include "opto/subnode.hpp"
class BytecodeParseHistogram;
class InlineTree;
class Parse;
class SwitchRange;
class InlineTree : public ResourceObj {
friend class VMStructs;
Compile* C; // cache
JVMState* _caller_jvms; // state of caller
ciMethod* _method; // method being called by the caller_jvms
InlineTree* _caller_tree;
uint _count_inline_bcs; // Accumulated count of inlined bytecodes
const float _site_invoke_ratio;
const int _max_inline_level; // the maximum inline level for this sub-tree (may be adjusted)
float compute_callee_frequency( int caller_bci ) const;
GrowableArray<InlineTree*> _subtrees;
void print_impl(outputStream* stj, int indent) const PRODUCT_RETURN;
const char* _msg;
protected:
InlineTree(Compile* C,
const InlineTree* caller_tree,
ciMethod* callee_method,
JVMState* caller_jvms,
int caller_bci,
float site_invoke_ratio,
int max_inline_level);
InlineTree *build_inline_tree_for_callee(ciMethod* callee_method,
JVMState* caller_jvms,
int caller_bci);
bool try_to_inline(ciMethod* callee_method,
ciMethod* caller_method,
int caller_bci,
JVMState* jvms,
ciCallProfile& profile,
WarmCallInfo* wci_result,
bool& should_delay);
bool should_inline(ciMethod* callee_method,
ciMethod* caller_method,
int caller_bci,
ciCallProfile& profile,
WarmCallInfo* wci_result);
bool should_not_inline(ciMethod* callee_method,
ciMethod* caller_method,
JVMState* jvms,
WarmCallInfo* wci_result);
void print_inlining(ciMethod* callee_method, int caller_bci,
ciMethod* caller_method, bool success) const;
InlineTree* caller_tree() const { return _caller_tree; }
InlineTree* callee_at(int bci, ciMethod* m) const;
int inline_level() const { return stack_depth(); }
int stack_depth() const { return _caller_jvms ? _caller_jvms->depth() : 0; }
const char* msg() const { return _msg; }
void set_msg(const char* msg) { _msg = msg; }
public:
static const char* check_can_parse(ciMethod* callee);
static InlineTree* build_inline_tree_root();
static InlineTree* find_subtree_from_root(InlineTree* root, JVMState* jvms, ciMethod* callee);
InlineTree(Compile* c, ciMethod* callee_method, JVMState* caller_jvms, float site_invoke_ratio, int max_inline_level);
enum InlineStyle {
Inline_do_not_inline = 0, //
Inline_cha_is_monomorphic = 1, //
Inline_type_profile_monomorphic = 2 //
};
WarmCallInfo* ok_to_inline(ciMethod *call_method, JVMState* caller_jvms, ciCallProfile& profile, WarmCallInfo* wci, bool& should_delay);
JVMState* caller_jvms() const { return _caller_jvms; }
ciMethod *method() const { return _method; }
int caller_bci() const { return _caller_jvms ? _caller_jvms->bci() : InvocationEntryBci; }
uint count_inline_bcs() const { return _count_inline_bcs; }
float site_invoke_ratio() const { return _site_invoke_ratio; };
#ifndef PRODUCT
private:
uint _count_inlines; // Count of inlined methods
public:
uint count_inlines() const { return _count_inlines; };
#endif
GrowableArray<InlineTree*> subtrees() { return _subtrees; }
void print_value_on(outputStream* st) const PRODUCT_RETURN;
bool _forced_inline; // Inlining was forced by CompilerOracle, ciReplay or annotation
bool forced_inline() const { return _forced_inline; }
int count() const;
void dump_replay_data(outputStream* out);
};
class Parse : public GraphKit {
public:
class Block {
private:
ciTypeFlow::Block* _flow;
int _pred_count; // how many predecessors in CFG?
int _preds_parsed; // how many of these have been parsed?
uint _count; // how many times executed? Currently only set by _goto's
bool _is_parsed; // has this block been parsed yet?
bool _is_handler; // is this block an exception handler?
bool _has_merged_backedge; // does this block have merged backedge?
SafePointNode* _start_map; // all values flowing into this block
MethodLivenessResult _live_locals; // lazily initialized liveness bitmap
int _num_successors; // Includes only normal control flow.
int _all_successors; // Include exception paths also.
Block** _successors;
Block() : _live_locals(NULL,0) { ShouldNotReachHere(); }
public:
void init_node(Parse* outer, int po);
void init_graph(Parse* outer);
ciTypeFlow::Block* flow() const { return _flow; }
int pred_count() const { return _pred_count; }
int preds_parsed() const { return _preds_parsed; }
bool is_parsed() const { return _is_parsed; }
bool is_handler() const { return _is_handler; }
void set_count( uint x ) { _count = x; }
uint count() const { return _count; }
SafePointNode* start_map() const { assert(is_merged(),""); return _start_map; }
void set_start_map(SafePointNode* m) { assert(!is_merged(), ""); _start_map = m; }
bool is_merged() const { return _start_map != NULL; }
#ifdef ASSERT
bool has_merged_backedge() const { return _has_merged_backedge; }
void mark_merged_backedge(Block* pred) {
assert(is_SEL_head(), "should be loop head");
if (pred != NULL && is_SEL_backedge(pred)) {
assert(is_parsed(), "block should be parsed before merging backedges");
_has_merged_backedge = true;
}
}
#endif
bool is_ready() const { return preds_parsed() == pred_count(); }
int num_successors() const { return _num_successors; }
int all_successors() const { return _all_successors; }
Block* successor_at(int i) const {
assert((uint)i < (uint)all_successors(), "");
return _successors[i];
}
Block* successor_for_bci(int bci);
int start() const { return flow()->start(); }
int limit() const { return flow()->limit(); }
int rpo() const { return flow()->rpo(); }
int start_sp() const { return flow()->stack_size(); }
bool is_loop_head() const { return flow()->is_loop_head(); }
bool is_SEL_head() const { return flow()->is_single_entry_loop_head(); }
bool is_SEL_backedge(Block* pred) const{ return is_SEL_head() && pred->rpo() >= rpo(); }
bool is_invariant_local(uint i) const {
const JVMState* jvms = start_map()->jvms();
if (!jvms->is_loc(i) || flow()->outer()->has_irreducible_entry()) return false;
return flow()->is_invariant_local(i - jvms->locoff());
}
bool can_elide_SEL_phi(uint i) const { assert(is_SEL_head(),""); return is_invariant_local(i); }
const Type* peek(int off=0) const { return stack_type_at(start_sp() - (off+1)); }
const Type* stack_type_at(int i) const;
const Type* local_type_at(int i) const;
static const Type* get_type(ciType* t) { return Type::get_typeflow_type(t); }
bool has_trap_at(int bci) const { return flow()->has_trap() && flow()->trap_bci() == bci; }
void mark_parsed() {
assert(!_is_parsed, "must parse each block exactly once");
_is_parsed = true;
}
int next_path_num() {
assert(preds_parsed() < pred_count(), "too many preds?");
return pred_count() - _preds_parsed++;
}
int add_new_path();
void record_state(Parse* outer);
};
#ifndef PRODUCT
class BytecodeParseHistogram : public ResourceObj {
private:
enum BPHType {
BPH_transforms,
BPH_values
};
static bool _initialized;
static uint _bytecodes_parsed [Bytecodes::number_of_codes];
static uint _nodes_constructed[Bytecodes::number_of_codes];
static uint _nodes_transformed[Bytecodes::number_of_codes];
static uint _new_values [Bytecodes::number_of_codes];
Bytecodes::Code _initial_bytecode;
int _initial_node_count;
int _initial_transforms;
int _initial_values;
Parse *_parser;
Compile *_compiler;
static void reset();
int current_count(BPHType info_selector);
public:
BytecodeParseHistogram(Parse *p, Compile *c);
static bool initialized();
void set_initial_state( Bytecodes::Code bc );
void record_change();
static void print(float cutoff = 0.01F); // cutoff in percent
};
public:
BytecodeParseHistogram* _parse_histogram;
void set_parse_histogram(BytecodeParseHistogram *bph) { _parse_histogram = bph; }
BytecodeParseHistogram* parse_histogram() { return _parse_histogram; }
#endif
private:
friend class Block;
JVMState* _caller; // JVMS which carries incoming args & state.
float _expected_uses; // expected number of calls to this code
float _prof_factor; // discount applied to my profile counts
int _depth; // Inline tree depth, for debug printouts
const TypeFunc*_tf; // My kind of function type
int _entry_bci; // the osr bci or InvocationEntryBci
ciTypeFlow* _flow; // Results of previous flow pass.
Block* _blocks; // Array of basic-block structs.
int _block_count; // Number of elements in _blocks.
GraphKit _exits; // Record all normal returns and throws here.
bool _wrote_final; // Did we write a final field?
bool _wrote_volatile; // Did we write a volatile field?
bool _count_invocations; // update and test invocation counter
bool _method_data_update; // update method data oop
Node* _alloc_with_final; // An allocation node with final field
Block* _block; // block currently getting parsed
ciBytecodeStream _iter; // stream of this method's bytecodes
int _blocks_merged; // Progress meter: state merges from BB preds
int _blocks_parsed; // Progress meter: BBs actually parsed
const FastLockNode* _synch_lock; // FastLockNode for synchronized method
#ifndef PRODUCT
int _max_switch_depth; // Debugging SwitchRanges.
int _est_switch_depth; // Debugging SwitchRanges.
#endif
bool _first_return; // true if return is the first to be parsed
bool _replaced_nodes_for_exceptions; // needs processing of replaced nodes in exception paths?
uint _new_idx; // any node with _idx above were new during this parsing. Used to trim the replaced nodes list.
public:
Parse(JVMState* caller, ciMethod* parse_method, float expected_uses);
virtual Parse* is_Parse() const { return (Parse*)this; }
JVMState* caller() const { return _caller; }
float expected_uses() const { return _expected_uses; }
float prof_factor() const { return _prof_factor; }
int depth() const { return _depth; }
const TypeFunc* tf() const { return _tf; }
ciTypeFlow* flow() const { return _flow; }
int block_count() const { return _block_count; }
GraphKit& exits() { return _exits; }
bool wrote_final() const { return _wrote_final; }
void set_wrote_final(bool z) { _wrote_final = z; }
bool wrote_volatile() const { return _wrote_volatile; }
void set_wrote_volatile(bool z) { _wrote_volatile = z; }
bool count_invocations() const { return _count_invocations; }
bool method_data_update() const { return _method_data_update; }
Node* alloc_with_final() const { return _alloc_with_final; }
void set_alloc_with_final(Node* n) {
assert((_alloc_with_final == NULL) || (_alloc_with_final == n), "different init objects?");
_alloc_with_final = n;
}
Block* block() const { return _block; }
ciBytecodeStream& iter() { return _iter; }
Bytecodes::Code bc() const { return _iter.cur_bc(); }
void set_block(Block* b) { _block = b; }
bool is_normal_parse() const { return _entry_bci == InvocationEntryBci; }
bool is_osr_parse() const { return _entry_bci != InvocationEntryBci; }
int osr_bci() const { assert(is_osr_parse(),""); return _entry_bci; }
void set_parse_bci(int bci);
bool failing() { return C->failing(); }
Block* rpo_at(int rpo) {
assert(0 <= rpo && rpo < _block_count, "oob");
return &_blocks[rpo];
}
Block* start_block() {
return rpo_at(flow()->start_block()->rpo());
}
Block* successor_for_bci(int bci) {
return block()->successor_for_bci(bci);
}
private:
SafePointNode* create_entry_map();
Node *fetch_interpreter_state(int index, BasicType bt, Node *local_addrs, Node *local_addrs_base);
Node* check_interpreter_type(Node* l, const Type* type, SafePointNode* &bad_type_exit);
void load_interpreter_state(Node* osr_buf);
void init_blocks();
void load_state_from(Block* b);
void store_state_to(Block* b) { b->record_state(this); }
void do_all_blocks();
void do_one_block();
void handle_missing_successor(int bci);
void do_method_entry();
void do_monitor_enter();
void do_monitor_exit();
void ensure_phis_everywhere();
void merge( int target_bci);
void merge_new_path( int target_bci);
void merge_exception(int target_bci);
void merge_common(Block* target, int pnum);
PhiNode *ensure_phi( int idx, bool nocreate = false);
PhiNode *ensure_memory_phi(int idx, bool nocreate = false);
void merge_memory_edges(MergeMemNode* n, int pnum, bool nophi);
void do_one_bytecode();
void array_store_check();
void array_load(BasicType etype);
void array_store(BasicType etype);
Node* array_addressing(BasicType type, int vals, const Type* *result2=NULL);
void rtm_deopt();
void return_current(Node* value);
void call_register_finalizer();
void add_safepoint();
void maybe_add_safepoint(int target_bci) {
if (UseLoopSafepoints && target_bci <= bci()) {
add_safepoint();
}
}
void do_call();
bool can_not_compile_call_site(ciMethod *dest_method, ciInstanceKlass *klass);
bool prepare_type_profile_inline(ciInstanceKlass* prof_klass, ciMethod* prof_method);
void do_checkcast();
void do_instanceof();
void modf();
void modd();
void l2f();
void do_irem();
void do_getstatic() { do_field_access(true, false); }
void do_getfield () { do_field_access(true, true); }
void do_putstatic() { do_field_access(false, false); }
void do_putfield () { do_field_access(false, true); }
void do_field_access(bool is_get, bool is_field);
bool static_field_ok_in_clinit(ciField *field, ciMethod *method);
void do_get_xxx(Node* obj, ciField* field, bool is_field);
void do_put_xxx(Node* obj, ciField* field, bool is_field);
bool push_constant(ciConstant con, bool require_constant = false, bool is_autobox_cache = false, const Type* basic_type = NULL);
void emit_guard_for_new(ciInstanceKlass* klass);
void do_new();
void do_newarray(BasicType elemtype);
void do_anewarray();
void do_multianewarray();
Node* expand_multianewarray(ciArrayKlass* array_klass, Node* *lengths, int ndimensions, int nargs);
void do_jsr();
void do_ret();
float dynamic_branch_prediction(float &cnt, BoolTest::mask btest, Node* test);
float branch_prediction(float &cnt, BoolTest::mask btest, int target_bci, Node* test);
bool seems_never_taken(float prob) const;
bool path_is_suitable_for_uncommon_trap(float prob) const;
bool seems_stable_comparison() const;
void do_ifnull(BoolTest::mask btest, Node* c);
void do_if(BoolTest::mask btest, Node* c);
int repush_if_args();
void adjust_map_after_if(BoolTest::mask btest, Node* c, float prob,
Block* path, Block* other_path);
void sharpen_type_after_if(BoolTest::mask btest,
Node* con, const Type* tcon,
Node* val, const Type* tval);
IfNode* jump_if_fork_int(Node* a, Node* b, BoolTest::mask mask);
Node* jump_if_join(Node* iffalse, Node* iftrue);
void jump_if_true_fork(IfNode *ifNode, int dest_bci_if_true, int prof_table_index);
void jump_if_false_fork(IfNode *ifNode, int dest_bci_if_false, int prof_table_index);
void jump_if_always_fork(int dest_bci_if_true, int prof_table_index);
friend class SwitchRange;
void do_tableswitch();
void do_lookupswitch();
void jump_switch_ranges(Node* a, SwitchRange* lo, SwitchRange* hi, int depth = 0);
bool create_jump_tables(Node* a, SwitchRange* lo, SwitchRange* hi);
void test_counter_against_threshold(Node* cnt, int limit);
void increment_and_test_invocation_counter(int limit);
void test_for_osr_md_counter_at(ciMethodData* md, ciProfileData* data, ByteSize offset, int limit);
Node* method_data_addressing(ciMethodData* md, ciProfileData* data, ByteSize offset, Node* idx = NULL, uint stride = 0);
void increment_md_counter_at(ciMethodData* md, ciProfileData* data, ByteSize offset, Node* idx = NULL, uint stride = 0);
void set_md_flag_at(ciMethodData* md, ciProfileData* data, int flag_constant);
void profile_method_entry();
void profile_taken_branch(int target_bci, bool force_update = false);
void profile_not_taken_branch(bool force_update = false);
void profile_call(Node* receiver);
void profile_generic_call();
void profile_receiver_type(Node* receiver);
void profile_ret(int target_bci);
void profile_null_checkcast();
void profile_switch_case(int table_index);
void count_compiled_calls(bool at_method_entry, bool is_inline) PRODUCT_RETURN;
Node_Notes* make_node_notes(Node_Notes* caller_nn);
void build_exits();
void do_exceptions();
void do_exits();
void catch_call_exceptions(ciExceptionHandlerStream&);
void catch_inline_exceptions(SafePointNode* ex_map);
void throw_to_exit(SafePointNode* ex_map);
Node* optimize_cmp_with_klass(Node* c);
public:
#ifndef PRODUCT
void show_parse_info();
void dump_map_adr_mem() const;
static void print_statistics(); // Print some performance counters
void dump();
void dump_bci(int bci);
#endif
};
#endif // SHARE_VM_OPTO_PARSE_HPP
C:\hotspot-69087d08d473\src\share\vm/opto/parse1.cpp
#include "precompiled.hpp"
#include "compiler/compileLog.hpp"
#include "interpreter/linkResolver.hpp"
#include "oops/method.hpp"
#include "opto/addnode.hpp"
#include "opto/c2compiler.hpp"
#include "opto/idealGraphPrinter.hpp"
#include "opto/locknode.hpp"
#include "opto/memnode.hpp"
#include "opto/parse.hpp"
#include "opto/rootnode.hpp"
#include "opto/runtime.hpp"
#include "runtime/arguments.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/sharedRuntime.hpp"
#include "utilities/copy.hpp"
int nodes_created = 0;
int methods_parsed = 0;
int methods_seen = 0;
int blocks_parsed = 0;
int blocks_seen = 0;
int explicit_null_checks_inserted = 0;
int explicit_null_checks_elided = 0;
int all_null_checks_found = 0, implicit_null_checks = 0;
int implicit_null_throws = 0;
int reclaim_idx = 0;
int reclaim_in = 0;
int reclaim_node = 0;
#ifndef PRODUCT
bool Parse::BytecodeParseHistogram::_initialized = false;
uint Parse::BytecodeParseHistogram::_bytecodes_parsed [Bytecodes::number_of_codes];
uint Parse::BytecodeParseHistogram::_nodes_constructed[Bytecodes::number_of_codes];
uint Parse::BytecodeParseHistogram::_nodes_transformed[Bytecodes::number_of_codes];
uint Parse::BytecodeParseHistogram::_new_values [Bytecodes::number_of_codes];
#endif
#ifndef PRODUCT
void Parse::print_statistics() {
tty->print_cr("--- Compiler Statistics ---");
tty->print("Methods seen: %d Methods parsed: %d", methods_seen, methods_parsed);
tty->print(" Nodes created: %d", nodes_created);
tty->cr();
if (methods_seen != methods_parsed)
tty->print_cr("Reasons for parse failures (NOT cumulative):");
tty->print_cr("Blocks parsed: %d Blocks seen: %d", blocks_parsed, blocks_seen);
if( explicit_null_checks_inserted )
tty->print_cr("%d original NULL checks - %d elided (%2d%%); optimizer leaves %d,", explicit_null_checks_inserted, explicit_null_checks_elided, (100*explicit_null_checks_elided)/explicit_null_checks_inserted, all_null_checks_found);
if( all_null_checks_found )
tty->print_cr("%d made implicit (%2d%%)", implicit_null_checks,
(100*implicit_null_checks)/all_null_checks_found);
if( implicit_null_throws )
tty->print_cr("%d implicit null exceptions at runtime",
implicit_null_throws);
if( PrintParseStatistics && BytecodeParseHistogram::initialized() ) {
BytecodeParseHistogram::print();
}
}
#endif
Node *Parse::fetch_interpreter_state(int index,
BasicType bt,
Node *local_addrs,
Node *local_addrs_base) {
Node *mem = memory(Compile::AliasIdxRaw);
Node *adr = basic_plus_adr( local_addrs_base, local_addrs, -index*wordSize );
Node *ctl = control();
Node *l = NULL;
switch (bt) { // Signature is flattened
case T_INT: l = new (C) LoadINode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInt::INT, MemNode::unordered); break;
case T_FLOAT: l = new (C) LoadFNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::FLOAT, MemNode::unordered); break;
case T_ADDRESS: l = new (C) LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, MemNode::unordered); break;
case T_OBJECT: l = new (C) LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInstPtr::BOTTOM, MemNode::unordered); break;
case T_LONG:
case T_DOUBLE: {
adr = basic_plus_adr(local_addrs_base, local_addrs, -(index+1)*wordSize);
if (Matcher::misaligned_doubles_ok) {
l = (bt == T_DOUBLE)
? (Node*)new (C) LoadDNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::DOUBLE, MemNode::unordered)
: (Node*)new (C) LoadLNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeLong::LONG, MemNode::unordered);
} else {
l = (bt == T_DOUBLE)
? (Node*)new (C) LoadD_unalignedNode(ctl, mem, adr, TypeRawPtr::BOTTOM, MemNode::unordered)
: (Node*)new (C) LoadL_unalignedNode(ctl, mem, adr, TypeRawPtr::BOTTOM, MemNode::unordered);
}
break;
}
default: ShouldNotReachHere();
}
return _gvn.transform(l);
}
Node* Parse::check_interpreter_type(Node* l, const Type* type,
SafePointNode* &bad_type_exit) {
const TypeOopPtr* tp = type->isa_oopptr();
if (type == TypePtr::NULL_PTR ||
(tp != NULL && !tp->klass()->is_loaded())) {
Node* chk = _gvn.transform( new (C) CmpPNode(l, null()) );
Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) );
IfNode* iff = create_and_map_if(control(), tst, PROB_MAX, COUNT_UNKNOWN);
set_control(_gvn.transform( new (C) IfTrueNode(iff) ));
Node* bad_type = _gvn.transform( new (C) IfFalseNode(iff) );
bad_type_exit->control()->add_req(bad_type);
l = null();
}
if (tp != NULL && tp->klass() != C->env()->Object_klass()) {
Node* bad_type_ctrl = NULL;
l = gen_checkcast(l, makecon(TypeKlassPtr::make(tp->klass())), &bad_type_ctrl);
bad_type_exit->control()->add_req(bad_type_ctrl);
}
BasicType bt_l = _gvn.type(l)->basic_type();
BasicType bt_t = type->basic_type();
assert(_gvn.type(l)->higher_equal(type), "must constrain OSR typestate");
return l;
}
void Parse::load_interpreter_state(Node* osr_buf) {
int index;
int max_locals = jvms()->loc_size();
int max_stack = jvms()->stk_size();
assert(max_locals == method()->max_locals(), "sanity");
assert(max_stack >= method()->max_stack(), "sanity");
assert((int)jvms()->endoff() == TypeFunc::Parms + max_locals + max_stack, "sanity");
assert((int)jvms()->endoff() == (int)map()->req(), "sanity");
Block* osr_block = start_block();
assert(osr_block->start() == osr_bci(), "sanity");
set_parse_bci(osr_block->start());
set_sp(osr_block->start_sp());
if (sp() != 0) {
C->record_method_not_compilable("OSR starts with non-empty stack");
return;
}
if (osr_block->has_trap_at(osr_block->start())) {
C->record_method_not_compilable("OSR starts with an immediate trap");
return;
}
assert(jvms()->monitor_depth() == 0, "should be no active locks at beginning of osr");
int mcnt = osr_block->flow()->monitor_count();
Node *monitors_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals+mcnt*2-1)*wordSize);
for (index = 0; index < mcnt; index++) {
Node *box = _gvn.transform(new (C) BoxLockNode(next_monitor()));
Node *lock_object = fetch_interpreter_state(index*2, T_OBJECT, monitors_addr, osr_buf);
Node *displaced_hdr = fetch_interpreter_state((index*2) + 1, T_ADDRESS, monitors_addr, osr_buf);
store_to_memory(control(), box, displaced_hdr, T_ADDRESS, Compile::AliasIdxRaw, MemNode::unordered);
const FastLockNode *flock = _gvn.transform(new (C) FastLockNode( 0, lock_object, box ))->as_FastLock();
map()->push_monitor(flock);
if (index == 0 && method()->is_synchronized()) {
_synch_lock = flock;
}
}
MethodLivenessResult live_locals = method()->liveness_at_bci(osr_bci());
if (!live_locals.is_valid()) {
C->record_method_not_compilable("OSR in empty or breakpointed method");
return;
}
Node *locals_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals-1)*wordSize);
const BitMap live_oops = method()->live_local_oops_at_bci(osr_bci());
for (index = 0; index < max_locals; index++) {
if (!live_locals.at(index)) {
continue;
}
const Type *type = osr_block->local_type_at(index);
if (type->isa_oopptr() != NULL) {
if (!live_oops.at(index)) {
if (C->log() != NULL) {
C->log()->elem("OSR_mismatch local_index='%d'",index);
}
set_local(index, null());
continue;
}
}
if (type == Type::TOP || type == Type::HALF) {
continue;
}
if (type == Type::BOTTOM) {
continue;
}
BasicType bt = type->basic_type();
if (type == TypePtr::NULL_PTR) {
bt = T_OBJECT;
}
Node *value = fetch_interpreter_state(index, bt, locals_addr, osr_buf);
set_local(index, value);
}
for (index = 0; index < sp(); index++) {
const Type *type = osr_block->stack_type_at(index);
if (type != Type::TOP) {
ShouldNotReachHere();
}
}
make_runtime_call(RC_LEAF, OptoRuntime::osr_end_Type(),
CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_end),
"OSR_migration_end", TypeRawPtr::BOTTOM,
osr_buf);
SafePointNode* bad_type_exit = clone_map();
bad_type_exit->set_control(new (C) RegionNode(1));
assert(osr_block->flow()->jsrs()->size() == 0, "should be no jsrs live at osr point");
for (index = 0; index < max_locals; index++) {
if (stopped()) break;
Node* l = local(index);
if (l->is_top()) continue; // nothing here
const Type *type = osr_block->local_type_at(index);
if (type->isa_oopptr() != NULL) {
if (!live_oops.at(index)) {
continue;
}
}
if (osr_block->flow()->local_type_at(index)->is_return_address()) {
continue;
}
set_local(index, check_interpreter_type(l, type, bad_type_exit));
}
for (index = 0; index < sp(); index++) {
if (stopped()) break;
Node* l = stack(index);
if (l->is_top()) continue; // nothing here
const Type *type = osr_block->stack_type_at(index);
set_stack(index, check_interpreter_type(l, type, bad_type_exit));
}
if (bad_type_exit->control()->req() > 1) {
bad_type_exit->set_control(_gvn.transform( bad_type_exit->control() ));
record_for_igvn(bad_type_exit->control());
SafePointNode* types_are_good = map();
set_map(bad_type_exit);
uncommon_trap(Deoptimization::Reason_constraint,
Deoptimization::Action_reinterpret);
set_map(types_are_good);
}
}
Parse::Parse(JVMState* caller, ciMethod* parse_method, float expected_uses)
: _exits(caller)
{
_caller = caller;
_method = parse_method;
_expected_uses = expected_uses;
_depth = 1 + (caller->has_method() ? caller->depth() : 0);
_wrote_final = false;
_wrote_volatile = false;
_alloc_with_final = NULL;
_entry_bci = InvocationEntryBci;
_tf = NULL;
_block = NULL;
_first_return = true;
_replaced_nodes_for_exceptions = false;
_new_idx = C->unique();
debug_only(_block_count = -1);
debug_only(_blocks = (Block*)-1);
#ifndef PRODUCT
if (PrintCompilation || PrintOpto) {
JVMState* ilt_caller = is_osr_parse() ? caller->caller() : caller;
InlineTree::find_subtree_from_root(C->ilt(), ilt_caller, parse_method);
}
_max_switch_depth = 0;
_est_switch_depth = 0;
#endif
_tf = TypeFunc::make(method());
_iter.reset_to_method(method());
_flow = method()->get_flow_analysis();
if (_flow->failing()) {
C->record_method_not_compilable_all_tiers(_flow->failure_reason());
}
#ifndef PRODUCT
if (_flow->has_irreducible_entry()) {
C->set_parsed_irreducible_loop(true);
}
#endif
if (_expected_uses <= 0) {
_prof_factor = 1;
} else {
float prof_total = parse_method->interpreter_invocation_count();
if (prof_total <= _expected_uses) {
_prof_factor = 1;
} else {
_prof_factor = _expected_uses / prof_total;
}
}
CompileLog* log = C->log();
if (log != NULL) {
log->begin_head("parse method='%d' uses='%g'",
log->identify(parse_method), expected_uses);
if (depth() == 1 && C->is_osr_compilation()) {
log->print(" osr_bci='%d'", C->entry_bci());
}
log->stamp();
log->end_head();
}
ciMethodData* md = method()->method_data();
for (uint reason = 0; reason < md->trap_reason_limit(); reason++) {
uint md_count = md->trap_count(reason);
if (md_count != 0) {
if (md_count == md->trap_count_limit())
md_count += md->overflow_trap_count();
uint total_count = C->trap_count(reason);
uint old_count = total_count;
total_count += md_count;
if (total_count < old_count || total_count < md_count)
total_count = (uint)-1;
C->set_trap_count(reason, total_count);
if (log != NULL)
log->elem("observe trap='%s' count='%d' total='%d'",
Deoptimization::trap_reason_name(reason),
md_count, total_count);
}
}
C->set_decompile_count(C->decompile_count() + md->decompile_count());
_count_invocations = C->do_count_invocations();
_method_data_update = C->do_method_data_update();
if (log != NULL && method()->has_exception_handlers()) {
log->elem("observe that='has_exception_handlers'");
}
assert(method()->can_be_compiled(), "Can not parse this method, cutout earlier");
assert(method()->has_balanced_monitors(), "Can not parse unbalanced monitors, cutout earlier");
if (C->env()->jvmti_can_hotswap_or_post_breakpoint()) {
C->dependencies()->assert_evol_method(method());
}
methods_seen++;
if (depth() == 1 && C->is_osr_compilation()) {
_entry_bci = C->entry_bci();
_flow = method()->get_osr_flow_analysis(osr_bci());
if (_flow->failing()) {
C->record_method_not_compilable(_flow->failure_reason());
#ifndef PRODUCT
if (PrintOpto && (Verbose || WizardMode)) {
tty->print_cr("OSR @%d type flow bailout: %s", _entry_bci, _flow->failure_reason());
if (Verbose) {
method()->print();
method()->print_codes();
_flow->print();
}
}
#endif
}
_tf = C->tf(); // the OSR entry type is different
}
#ifdef ASSERT
if (depth() == 1) {
assert(C->is_osr_compilation() == this->is_osr_parse(), "OSR in sync");
if (C->tf() != tf()) {
MutexLockerEx ml(Compile_lock, Mutex::_no_safepoint_check_flag);
assert(C->env()->system_dictionary_modification_counter_changed(),
"Must invalidate if TypeFuncs differ");
}
} else {
assert(!this->is_osr_parse(), "no recursive OSR");
}
#endif
methods_parsed++;
#ifndef PRODUCT
if (TimeCompiler)
_total_bytes_compiled += method()->code_size();
show_parse_info();
#endif
if (failing()) {
if (log) log->done("parse");
return;
}
gvn().set_type(root(), root()->bottom_type());
gvn().transform(top());
init_blocks();
build_exits();
SafePointNode* entry_map = create_entry_map();
if (failing() || entry_map == NULL) {
if (log) log->done("parse");
return;
}
Node_Notes* caller_nn = C->default_node_notes();
if (DebugInlinedCalls || depth() == 1) {
C->set_default_node_notes(make_node_notes(caller_nn));
}
if (is_osr_parse()) {
Node* osr_buf = entry_map->in(TypeFunc::Parms+0);
entry_map->set_req(TypeFunc::Parms+0, top());
set_map(entry_map);
load_interpreter_state(osr_buf);
} else {
set_map(entry_map);
do_method_entry();
}
if (depth() == 1 && !failing()) {
rtm_deopt();
}
if (failing()) {
if (log) log->done("parse");
C->set_default_node_notes(caller_nn);
return;
}
entry_map = map(); // capture any changes performed by method setup code
assert(jvms()->endoff() == map()->req(), "map matches JVMS layout");
Block* entry_block = start_block();
assert(entry_block->start() == (is_osr_parse() ? osr_bci() : 0), "");
set_map_clone(entry_map);
merge_common(entry_block, entry_block->next_path_num());
#ifndef PRODUCT
BytecodeParseHistogram *parse_histogram_obj = new (C->env()->arena()) BytecodeParseHistogram(this, C);
set_parse_histogram( parse_histogram_obj );
#endif
do_all_blocks();
C->set_default_node_notes(caller_nn);
if (failing()) {
if (log) log->done("parse");
return;
}
set_map(entry_map);
do_exits();
if (log) log->done("parse nodes='%d' live='%d' memory='" SIZE_FORMAT "'",
C->unique(), C->live_nodes(), C->node_arena()->used());
}
void Parse::do_all_blocks() {
bool has_irreducible = flow()->has_irreducible_entry();
while (true) {
bool progress = false;
for (int rpo = 0; rpo < block_count(); rpo++) {
Block* block = rpo_at(rpo);
if (block->is_parsed()) continue;
if (!block->is_merged()) {
continue;
}
load_state_from(block);
if (stopped()) {
continue;
}
blocks_parsed++;
progress = true;
if (block->is_loop_head() || block->is_handler() || has_irreducible && !block->is_ready()) {
ensure_phis_everywhere();
if (block->is_SEL_head() &&
(UseLoopPredicate || LoopLimitCheck)) {
assert(!block->has_merged_backedge(), "only entry paths should be merged for now");
set_parse_bci(block->start());
add_predicate();
int edges = block->pred_count() - block->preds_parsed() + 1; // +1 for original region
RegionNode *r = new (C) RegionNode(edges+1);
_gvn.set_type(r, Type::CONTROL);
record_for_igvn(r);
r->init_req(edges, control());
set_control(r);
ensure_phis_everywhere();
}
set_map(clone_map());
}
if (control()->is_Region() && !block->is_loop_head() && !has_irreducible && !block->is_handler()) {
Node* c = control();
Node* result = _gvn.transform_no_reclaim(control());
if (c != result && TraceOptoParse) {
tty->print_cr("Block #%d replace %d with %d", block->rpo(), c->_idx, result->_idx);
}
if (result != top()) {
record_for_igvn(result);
}
}
do_one_block();
if (failing()) return;
}
if (!has_irreducible || !progress) {
break;
}
}
blocks_seen += block_count();
#ifndef PRODUCT
for (int rpo = 0; rpo < block_count(); rpo++) {
Block* block = rpo_at(rpo);
if (!block->is_parsed()) {
if (TraceOptoParse) {
tty->print_cr("Skipped dead block %d at bci:%d", rpo, block->start());
}
assert(!block->is_merged(), "no half-processed blocks");
}
}
#endif
}
static Node* mask_int_value(Node* v, BasicType bt, PhaseGVN* gvn) {
Compile* C = gvn->C;
switch (bt) {
case T_BYTE:
v = gvn->transform(new (C) LShiftINode(v, gvn->intcon(24)));
v = gvn->transform(new (C) RShiftINode(v, gvn->intcon(24)));
break;
case T_SHORT:
v = gvn->transform(new (C) LShiftINode(v, gvn->intcon(16)));
v = gvn->transform(new (C) RShiftINode(v, gvn->intcon(16)));
break;
case T_CHAR:
v = gvn->transform(new (C) AndINode(v, gvn->intcon(0xFFFF)));
break;
case T_BOOLEAN:
v = gvn->transform(new (C) AndINode(v, gvn->intcon(0x1)));
break;
}
return v;
}
void Parse::build_exits() {
_exits.set_map(_exits.clone_map());
_exits.clean_stack(_exits.sp());
_exits.sync_jvms();
RegionNode* region = new (C) RegionNode(1);
record_for_igvn(region);
gvn().set_type_bottom(region);
_exits.set_control(region);
Node* iophi = new (C) PhiNode(region, Type::ABIO);
Node* memphi = new (C) PhiNode(region, Type::MEMORY, TypePtr::BOTTOM);
gvn().set_type_bottom(iophi);
gvn().set_type_bottom(memphi);
_exits.set_i_o(iophi);
_exits.set_all_memory(memphi);
if (tf()->range()->cnt() > TypeFunc::Parms) {
const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms);
if (ret_type->isa_int()) {
BasicType ret_bt = method()->return_type()->basic_type();
if (ret_bt == T_BOOLEAN ||
ret_bt == T_CHAR ||
ret_bt == T_BYTE ||
ret_bt == T_SHORT) {
ret_type = TypeInt::INT;
}
}
const TypeOopPtr* ret_oop_type = ret_type->isa_oopptr();
if (ret_oop_type && !ret_oop_type->klass()->is_loaded()) {
ret_type = TypeOopPtr::BOTTOM;
}
int ret_size = type2size[ret_type->basic_type()];
Node* ret_phi = new (C) PhiNode(region, ret_type);
gvn().set_type_bottom(ret_phi);
_exits.ensure_stack(ret_size);
assert((int)(tf()->range()->cnt() - TypeFunc::Parms) == ret_size, "good tf range");
assert(method()->return_type()->size() == ret_size, "tf agrees w/ method");
_exits.set_argument(0, ret_phi); // here is where the parser finds it
}
}
JVMState* Compile::build_start_state(StartNode* start, const TypeFunc* tf) {
int arg_size = tf->domain()->cnt();
int max_size = MAX2(arg_size, (int)tf->range()->cnt());
JVMState* jvms = new (this) JVMState(max_size - TypeFunc::Parms);
SafePointNode* map = new (this) SafePointNode(max_size, NULL);
record_for_igvn(map);
assert(arg_size == TypeFunc::Parms + (is_osr_compilation() ? 1 : method()->arg_size()), "correct arg_size");
Node_Notes* old_nn = default_node_notes();
if (old_nn != NULL && has_method()) {
Node_Notes* entry_nn = old_nn->clone(this);
JVMState* entry_jvms = new(this) JVMState(method(), old_nn->jvms());
entry_jvms->set_offsets(0);
entry_jvms->set_bci(entry_bci());
entry_nn->set_jvms(entry_jvms);
set_default_node_notes(entry_nn);
}
uint i;
for (i = 0; i < (uint)arg_size; i++) {
Node* parm = initial_gvn()->transform(new (this) ParmNode(start, i));
map->init_req(i, parm);
record_for_igvn(parm);
}
for (; i < map->req(); i++) {
map->init_req(i, top());
}
assert(jvms->argoff() == TypeFunc::Parms, "parser gets arguments here");
set_default_node_notes(old_nn);
map->set_jvms(jvms);
jvms->set_map(map);
return jvms;
}
Node_Notes* Parse::make_node_notes(Node_Notes* caller_nn) {
if (caller_nn == NULL) return NULL;
Node_Notes* nn = caller_nn->clone(C);
JVMState* caller_jvms = nn->jvms();
JVMState* jvms = new (C) JVMState(method(), caller_jvms);
jvms->set_offsets(0);
jvms->set_bci(_entry_bci);
nn->set_jvms(jvms);
return nn;
}
void Compile::return_values(JVMState* jvms) {
GraphKit kit(jvms);
Node* ret = new (this) ReturnNode(TypeFunc::Parms,
kit.control(),
kit.i_o(),
kit.reset_memory(),
kit.frameptr(),
kit.returnadr());
int ret_size = tf()->range()->cnt() - TypeFunc::Parms;
if (ret_size > 0) {
kit.inc_sp(-ret_size); // pop the return value(s)
kit.sync_jvms();
ret->add_req(kit.argument(0));
}
root()->add_req(ret);
record_for_igvn(ret);
initial_gvn()->transform_no_reclaim(ret);
}
void Compile::rethrow_exceptions(JVMState* jvms) {
GraphKit kit(jvms);
if (!kit.has_exceptions()) return; // nothing to generate
SafePointNode* ex_map = kit.combine_and_pop_all_exception_states();
Node* ex_oop = kit.use_exception_state(ex_map);
RethrowNode* exit = new (this) RethrowNode(kit.control(),
kit.i_o(), kit.reset_memory(),
kit.frameptr(), kit.returnadr(),
ex_oop);
root()->add_req(exit);
record_for_igvn(exit);
initial_gvn()->transform_no_reclaim(exit);
}
void Parse::do_exceptions() {
if (!has_exceptions()) return;
if (failing()) {
while (pop_exception_state() != NULL) ;
return;
}
PreserveJVMState pjvms(this, false);
SafePointNode* ex_map;
while ((ex_map = pop_exception_state()) != NULL) {
if (!method()->has_exception_handlers()) {
throw_to_exit(ex_map);
} else {
assert(stopped(), "catch_inline_exceptions trashes the map");
catch_inline_exceptions(ex_map);
stop_and_kill_map(); // we used up this exception state; kill it
}
}
}
void Parse::throw_to_exit(SafePointNode* ex_map) {
GraphKit caller;
caller.set_map_clone(_caller->map());
caller.set_bci(_caller->bci());
caller.set_sp(_caller->sp());
for (uint i = 0; i < TypeFunc::Parms; i++) {
caller.map()->set_req(i, ex_map->in(i));
}
if (ex_map->has_replaced_nodes()) {
_replaced_nodes_for_exceptions = true;
}
caller.map()->transfer_replaced_nodes_from(ex_map, _new_idx);
Node* ex_oop = saved_ex_oop(ex_map);
SafePointNode* caller_ex_map = caller.make_exception_state(ex_oop);
_exits.add_exception_state(caller_ex_map);
}
void Parse::do_exits() {
set_parse_bci(InvocationEntryBci);
Node* region = _exits.control();
_exits.set_control(gvn().transform(region));
Node* iophi = _exits.i_o();
_exits.set_i_o(gvn().transform(iophi));
if (wrote_final() PPC64_ONLY(|| (wrote_volatile() && method()->is_initializer()))) {
_exits.insert_mem_bar(Op_MemBarRelease, alloc_with_final());
#ifndef PRODUCT
if (PrintOpto && (Verbose || WizardMode)) {
method()->print_name();
tty->print_cr(" writes finals and needs a memory barrier");
}
#endif
}
for (MergeMemStream mms(_exits.merged_memory()); mms.next_non_empty(); ) {
mms.set_memory(_gvn.transform(mms.memory()));
}
if (tf()->range()->cnt() > TypeFunc::Parms) {
const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms);
Node* ret_phi = _gvn.transform( _exits.argument(0) );
if (!_exits.control()->is_top() && _gvn.type(ret_phi)->empty()) {
{
MutexLockerEx ml(Compile_lock, Mutex::_no_safepoint_check_flag);
if (C->env()->system_dictionary_modification_counter_changed()) {
C->record_failure(C2Compiler::retry_class_loading_during_parsing());
} else {
C->record_method_not_compilable("Can't determine return type.");
}
}
return;
}
if (ret_type->isa_int()) {
BasicType ret_bt = method()->return_type()->basic_type();
ret_phi = mask_int_value(ret_phi, ret_bt, &_gvn);
}
_exits.push_node(ret_type->basic_type(), ret_phi);
}
bool do_synch = method()->is_synchronized() && GenerateSynchronizationCode;
if (do_synch || C->env()->dtrace_method_probes() || _replaced_nodes_for_exceptions) {
GraphKit kit(_exits.transfer_exceptions_into_jvms());
SafePointNode* normal_map = kit.map(); // keep this guy safe
SafePointNode* ex_map;
while ((ex_map = kit.pop_exception_state()) != NULL) {
Node* ex_oop = kit.use_exception_state(ex_map);
JVMState* caller = kit.jvms();
JVMState* ex_jvms = caller->clone_shallow(C);
ex_jvms->set_map(kit.clone_map());
ex_jvms->map()->set_jvms(ex_jvms);
ex_jvms->set_bci( InvocationEntryBci);
kit.set_jvms(ex_jvms);
if (do_synch) {
kit.map()->push_monitor(_synch_lock);
kit.shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node());
}
if (C->env()->dtrace_method_probes()) {
kit.make_dtrace_method_exit(method());
}
if (_replaced_nodes_for_exceptions) {
kit.map()->apply_replaced_nodes(_new_idx);
}
ex_map = kit.make_exception_state(ex_oop);
assert(ex_jvms->same_calls_as(ex_map->jvms()), "sanity");
ex_map->set_jvms(caller->clone_shallow(C));
ex_map->jvms()->set_map(ex_map);
_exits.push_exception_state(ex_map);
}
assert(_exits.map() == normal_map, "keep the same return state");
}
{
GraphKit caller(_caller);
SafePointNode* ex_map;
while ((ex_map = caller.pop_exception_state()) != NULL) {
_exits.add_exception_state(ex_map);
}
}
_exits.map()->apply_replaced_nodes(_new_idx);
}
SafePointNode* Parse::create_entry_map() {
uint len = TypeFunc::Parms + method()->max_locals() + method()->max_stack();
if (len >= 32760) {
C->record_method_not_compilable_all_tiers("too many local variables");
return NULL;
}
_caller->map()->delete_replaced_nodes();
if (_caller->has_method() && is_normal_parse() && !method()->is_static()) {
GraphKit kit(_caller);
kit.null_check_receiver_before_call(method());
_caller = kit.transfer_exceptions_into_jvms();
if (kit.stopped()) {
_exits.add_exception_states_from(_caller);
_exits.set_jvms(_caller);
return NULL;
}
}
assert(method() != NULL, "parser must have a method");
JVMState* jvms = new (C) JVMState(method(), _caller->has_method() ? _caller : NULL);
set_map(new (C) SafePointNode(len, jvms));
jvms->set_map(map());
record_for_igvn(map());
assert(jvms->endoff() == len, "correct jvms sizing");
SafePointNode* inmap = _caller->map();
assert(inmap != NULL, "must have inmap");
map()->transfer_replaced_nodes_from(inmap, _new_idx);
uint i;
for (i = 0; i < TypeFunc::Parms; i++) {
map()->init_req(i, inmap->in(i));
}
if (depth() == 1) {
assert(map()->memory()->Opcode() == Op_Parm, "");
set_all_memory(reset_memory());
}
assert(merged_memory(), "");
uint arg_size = tf()->domain()->cnt();
ensure_stack(arg_size - TypeFunc::Parms); // OSR methods have funny args
for (i = TypeFunc::Parms; i < arg_size; i++) {
map()->init_req(i, inmap->argument(_caller, i - TypeFunc::Parms));
}
for (i = arg_size; i < len; i++) {
map()->init_req(i, top());
}
SafePointNode* entry_map = stop();
return entry_map;
}
void Parse::do_method_entry() {
set_parse_bci(InvocationEntryBci); // Pseudo-BCP
set_sp(0); // Java Stack Pointer
NOT_PRODUCT( count_compiled_calls(true/*at_method_entry*/, false/*is_inline*/); )
if (C->env()->dtrace_method_probes()) {
make_dtrace_method_entry(method());
}
if (method()->is_synchronized()) {
Node *lock_obj = NULL;
if(method()->is_static()) {
ciInstance* mirror = _method->holder()->java_mirror();
const TypeInstPtr *t_lock = TypeInstPtr::make(mirror);
lock_obj = makecon(t_lock);
} else { // Else pass the "this" pointer,
lock_obj = local(0); // which is Parm0 from StartNode
}
kill_dead_locals();
_synch_lock = shared_lock(lock_obj);
}
record_profiled_parameters_for_speculation();
if (depth() == 1) {
increment_and_test_invocation_counter(Tier2CompileThreshold);
}
}
void Parse::init_blocks() {
_block_count = flow()->block_count();
_blocks = NEW_RESOURCE_ARRAY(Block, _block_count);
Copy::zero_to_bytes(_blocks, sizeof(Block)*_block_count);
int rpo;
for (rpo = 0; rpo < block_count(); rpo++) {
Block* block = rpo_at(rpo);
block->init_node(this, rpo);
}
for (rpo = 0; rpo < block_count(); rpo++) {
Block* block = rpo_at(rpo);
block->init_graph(this);
}
}
void Parse::Block::init_node(Parse* outer, int rpo) {
_flow = outer->flow()->rpo_at(rpo);
_pred_count = 0;
_preds_parsed = 0;
_count = 0;
assert(pred_count() == 0 && preds_parsed() == 0, "sanity");
assert(!(is_merged() || is_parsed() || is_handler() || has_merged_backedge()), "sanity");
assert(_live_locals.size() == 0, "sanity");
if (flow()->is_start()) _pred_count++;
assert(flow()->is_start() == (this == outer->start_block()), "");
}
void Parse::Block::init_graph(Parse* outer) {
GrowableArray<ciTypeFlow::Block*>* tfs = flow()->successors();
GrowableArray<ciTypeFlow::Block*>* tfe = flow()->exceptions();
int ns = tfs->length();
int ne = tfe->length();
_num_successors = ns;
_all_successors = ns+ne;
_successors = (ns+ne == 0) ? NULL : NEW_RESOURCE_ARRAY(Block*, ns+ne);
int p = 0;
for (int i = 0; i < ns+ne; i++) {
ciTypeFlow::Block* tf2 = (i < ns) ? tfs->at(i) : tfe->at(i-ns);
Block* block2 = outer->rpo_at(tf2->rpo());
_successors[i] = block2;
if (i < ns) {
block2->_pred_count++;
} else {
block2->_is_handler = true;
}
#ifdef ASSERT
for (int j = 0; j < i; j++) {
Block* block1 = _successors[j];
if (block1 == block2) continue; // duplicates are OK
assert(block1->start() != block2->start(), "successors have unique bcis");
}
#endif
}
}
Parse::Block* Parse::Block::successor_for_bci(int bci) {
for (int i = 0; i < all_successors(); i++) {
Block* block2 = successor_at(i);
if (block2->start() == bci) return block2;
}
return NULL;
}
const Type* Parse::Block::stack_type_at(int i) const {
return get_type(flow()->stack_type_at(i));
}
const Type* Parse::Block::local_type_at(int i) const {
if (_live_locals.size() == 0) {
MethodLivenessResult live_locals = flow()->outer()->method()->liveness_at_bci(start());
((Block*)this)->_live_locals = live_locals;
}
if (_live_locals.size() > 0 && !_live_locals.at(i))
return Type::BOTTOM;
return get_type(flow()->local_type_at(i));
}
#ifndef PRODUCT
static const char* name_for_bc(int i) {
return Bytecodes::is_defined(i) ? Bytecodes::name(Bytecodes::cast(i)) : "xxxunusedxxx";
}
Parse::BytecodeParseHistogram::BytecodeParseHistogram(Parse *p, Compile *c) {
_parser = p;
_compiler = c;
if( ! _initialized ) { _initialized = true; reset(); }
}
int Parse::BytecodeParseHistogram::current_count(BPHType bph_type) {
switch( bph_type ) {
case BPH_transforms: { return _parser->gvn().made_progress(); }
case BPH_values: { return _parser->gvn().made_new_values(); }
default: { ShouldNotReachHere(); return 0; }
}
}
bool Parse::BytecodeParseHistogram::initialized() { return _initialized; }
void Parse::BytecodeParseHistogram::reset() {
int i = Bytecodes::number_of_codes;
while (i-- > 0) { _bytecodes_parsed[i] = 0; _nodes_constructed[i] = 0; _nodes_transformed[i] = 0; _new_values[i] = 0; }
}
void Parse::BytecodeParseHistogram::set_initial_state( Bytecodes::Code bc ) {
if( PrintParseStatistics && !_parser->is_osr_parse() ) {
_initial_bytecode = bc;
_initial_node_count = _compiler->unique();
_initial_transforms = current_count(BPH_transforms);
_initial_values = current_count(BPH_values);
}
}
void Parse::BytecodeParseHistogram::record_change() {
if( PrintParseStatistics && !_parser->is_osr_parse() ) {
++_bytecodes_parsed[_initial_bytecode];
_nodes_constructed [_initial_bytecode] += (_compiler->unique() - _initial_node_count);
_nodes_transformed [_initial_bytecode] += (current_count(BPH_transforms) - _initial_transforms);
_new_values [_initial_bytecode] += (current_count(BPH_values) - _initial_values);
}
}
void Parse::BytecodeParseHistogram::print(float cutoff) {
ResourceMark rm;
int total = 0;
int i = 0;
for( i = 0; i < Bytecodes::number_of_codes; ++i ) { total += _bytecodes_parsed[i]; }
int abs_sum = 0;
tty->cr(); //0123456789012345678901234567890123456789012345678901234567890123456789
tty->print_cr("Histogram of %d parsed bytecodes:", total);
if( total == 0 ) { return; }
tty->cr();
tty->print_cr("absolute: count of compiled bytecodes of this type");
tty->print_cr("relative: percentage contribution to compiled nodes");
tty->print_cr("nodes : Average number of nodes constructed per bytecode");
tty->print_cr("rnodes : Significance towards total nodes constructed, (nodes*relative)");
tty->print_cr("transforms: Average amount of tranform progress per bytecode compiled");
tty->print_cr("values : Average number of node values improved per bytecode");
tty->print_cr("name : Bytecode name");
tty->cr();
tty->print_cr(" absolute relative nodes rnodes transforms values name");
tty->print_cr("----------------------------------------------------------------------");
while (--i > 0) {
int abs = _bytecodes_parsed[i];
float rel = abs * 100.0F / total;
float nodes = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_constructed[i])/_bytecodes_parsed[i];
float rnodes = _bytecodes_parsed[i] == 0 ? 0 : rel * nodes;
float xforms = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_transformed[i])/_bytecodes_parsed[i];
float values = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _new_values [i])/_bytecodes_parsed[i];
if (cutoff <= rel) {
tty->print_cr("%10d %7.2f%% %6.1f %6.2f %6.1f %6.1f %s", abs, rel, nodes, rnodes, xforms, values, name_for_bc(i));
abs_sum += abs;
}
}
tty->print_cr("----------------------------------------------------------------------");
float rel_sum = abs_sum * 100.0F / total;
tty->print_cr("%10d %7.2f%% (cutoff = %.2f%%)", abs_sum, rel_sum, cutoff);
tty->print_cr("----------------------------------------------------------------------");
tty->cr();
}
#endif
void Parse::load_state_from(Block* block) {
set_block(block);
set_map(block->start_map());
set_sp( block->start_sp());
}
void Parse::Block::record_state(Parse* p) {
assert(!is_merged(), "can only record state once, on 1st inflow");
assert(start_sp() == p->sp(), "stack pointer must agree with ciTypeFlow");
set_start_map(p->stop());
}
void Parse::do_one_block() {
if (TraceOptoParse) {
Block *b = block();
int ns = b->num_successors();
int nt = b->all_successors();
tty->print("Parsing block #%d at bci [%d,%d), successors: ",
block()->rpo(), block()->start(), block()->limit());
for (int i = 0; i < nt; i++) {
tty->print((( i < ns) ? " %d" : " %d(e)"), b->successor_at(i)->rpo());
}
if (b->is_loop_head()) tty->print(" lphd");
tty->cr();
}
assert(block()->is_merged(), "must be merged before being parsed");
block()->mark_parsed();
++_blocks_parsed;
iter().reset_to_bci(block()->start());
CompileLog* log = C->log();
while (!stopped() && !failing()) {
iter().next();
set_parse_bci(iter().cur_bci());
if (bci() == block()->limit()) {
merge(bci());
break;
}
assert(bci() < block()->limit(), "bci still in block");
if (log != NULL) {
log->set_context("bc code='%d' bci='%d'", (int)bc(), bci());
}
if (block()->has_trap_at(bci())) {
int trap_index = block()->flow()->trap_index();
assert(trap_index != 0, "trap index must be valid");
uncommon_trap(trap_index);
break;
}
NOT_PRODUCT( parse_histogram()->set_initial_state(bc()); );
#ifdef ASSERT
int pre_bc_sp = sp();
int inputs, depth;
bool have_se = !stopped() && compute_stack_effects(inputs, depth);
assert(!have_se || pre_bc_sp >= inputs, err_msg_res("have enough stack to execute this BC: pre_bc_sp=%d, inputs=%d", pre_bc_sp, inputs));
#endif //ASSERT
do_one_bytecode();
assert(!have_se || stopped() || failing() || (sp() - pre_bc_sp) == depth,
err_msg_res("incorrect depth prediction: sp=%d, pre_bc_sp=%d, depth=%d", sp(), pre_bc_sp, depth));
do_exceptions();
NOT_PRODUCT( parse_histogram()->record_change(); );
if (log != NULL)
log->clear_context(); // skip marker if nothing was printed
}
}
void Parse::set_parse_bci(int bci) {
set_bci(bci);
Node_Notes* nn = C->default_node_notes();
if (nn == NULL) return;
if (!DebugInlinedCalls && depth() > 1) {
return;
}
JVMState* jvms = nn->jvms();
if (jvms != NULL && jvms->bci() != bci) {
jvms = jvms->clone_shallow(C);
jvms->set_bci(bci);
nn->set_jvms(jvms);
}
}
void Parse::merge(int target_bci) {
Block* target = successor_for_bci(target_bci);
if (target == NULL) { handle_missing_successor(target_bci); return; }
assert(!target->is_ready(), "our arrival must be expected");
int pnum = target->next_path_num();
merge_common(target, pnum);
}
void Parse::merge_new_path(int target_bci) {
Block* target = successor_for_bci(target_bci);
if (target == NULL) { handle_missing_successor(target_bci); return; }
assert(!target->is_ready(), "new path into frozen graph");
int pnum = target->add_new_path();
merge_common(target, pnum);
}
void Parse::merge_exception(int target_bci) {
assert(sp() == 1, "must have only the throw exception on the stack");
Block* target = successor_for_bci(target_bci);
if (target == NULL) { handle_missing_successor(target_bci); return; }
assert(target->is_handler(), "exceptions are handled by special blocks");
int pnum = target->add_new_path();
merge_common(target, pnum);
}
void Parse::handle_missing_successor(int target_bci) {
#ifndef PRODUCT
Block* b = block();
int trap_bci = b->flow()->has_trap()? b->flow()->trap_bci(): -1;
tty->print_cr("### Missing successor at bci:%d for block #%d (trap_bci:%d)", target_bci, b->rpo(), trap_bci);
#endif
ShouldNotReachHere();
}
void Parse::merge_common(Parse::Block* target, int pnum) {
if (TraceOptoParse) {
tty->print("Merging state at block #%d bci:%d", target->rpo(), target->start());
}
assert(sp() == target->start_sp(), "");
clean_stack(sp());
if (!target->is_merged()) { // No prior mapping at this bci
if (TraceOptoParse) { tty->print(" with empty state"); }
if (stopped()) {
if (TraceOptoParse) tty->print_cr(", but path is dead and doesn't count");
return;
}
++_blocks_merged;
if (pnum > PhiNode::Input // Known multiple inputs.
|| target->is_handler() // These have unpredictable inputs.
|| target->is_loop_head() // Known multiple inputs
|| control()->is_Region()) { // We must hide this guy.
int current_bci = bci();
set_parse_bci(target->start()); // Set target bci
if (target->is_SEL_head()) {
DEBUG_ONLY( target->mark_merged_backedge(block()); )
if (target->start() == 0) {
add_predicate();
}
}
int edges = target->pred_count();
if (edges < pnum) edges = pnum; // might be a new path!
RegionNode *r = new (C) RegionNode(edges+1);
gvn().set_type(r, Type::CONTROL);
record_for_igvn(r);
r->init_req(pnum, control());
set_control(r);
set_parse_bci(current_bci); // Restore bci
}
store_state_to(target);
assert(target->is_merged(), "do not come here twice");
} else { // Prior mapping at this bci
if (TraceOptoParse) { tty->print(" with previous state"); }
#ifdef ASSERT
if (target->is_SEL_head()) {
target->mark_merged_backedge(block());
}
#endif
bool nophi = target->is_parsed();
SafePointNode* newin = map();// Hang on to incoming mapping
Block* save_block = block(); // Hang on to incoming block;
load_state_from(target); // Get prior mapping
assert(newin->jvms()->locoff() == jvms()->locoff(), "JVMS layouts agree");
assert(newin->jvms()->stkoff() == jvms()->stkoff(), "JVMS layouts agree");
assert(newin->jvms()->monoff() == jvms()->monoff(), "JVMS layouts agree");
assert(newin->jvms()->endoff() == jvms()->endoff(), "JVMS layouts agree");
assert(control()->is_Region(), "must be merging to a region");
RegionNode* r = control()->as_Region();
r->init_req(pnum, newin->control());
if (pnum == 1) { // Last merge for this Region?
if (!block()->flow()->is_irreducible_entry()) {
Node* result = _gvn.transform_no_reclaim(r);
if (r != result && TraceOptoParse) {
tty->print_cr("Block #%d replace %d with %d", block()->rpo(), r->_idx, result->_idx);
}
}
record_for_igvn(r);
}
assert(TypeFunc::Parms == newin->jvms()->locoff(), "parser map should contain only youngest jvms");
bool check_elide_phi = target->is_SEL_backedge(save_block);
for (uint j = 1; j < newin->req(); j++) {
Node* m = map()->in(j); // Current state of target.
Node* n = newin->in(j); // Incoming change to target state.
PhiNode* phi;
if (m->is_Phi() && m->as_Phi()->region() == r)
phi = m->as_Phi();
else
phi = NULL;
if (m != n) { // Different; must merge
switch (j) {
case TypeFunc::FramePtr:// Drop m, use the original value
case TypeFunc::ReturnAdr:
break;
case TypeFunc::Memory: // Merge inputs to the MergeMem node
assert(phi == NULL, "the merge contains phis, not vice versa");
merge_memory_edges(n->as_MergeMem(), pnum, nophi);
continue;
default: // All normal stuff
if (phi == NULL) {
const JVMState* jvms = map()->jvms();
if (EliminateNestedLocks &&
jvms->is_mon(j) && jvms->is_monitor_box(j)) {
assert(newin->jvms()->is_monitor_box(j), "sanity");
assert(BoxLockNode::same_slot(n, m), "sanity");
C->gvn_replace_by(n, m);
} else if (!check_elide_phi || !target->can_elide_SEL_phi(j)) {
phi = ensure_phi(j, nophi);
}
}
break;
}
}
if (phi != NULL) {
assert(n != top() || r->in(pnum) == top(), "live value must not be garbage");
assert(phi->region() == r, "");
phi->set_req(pnum, n); // Then add 'n' to the merge
if (pnum == PhiNode::Input) {
debug_only(const Type* bt1 = phi->bottom_type());
assert(bt1 != Type::BOTTOM, "should not be building conflict phis");
map()->set_req(j, _gvn.transform_no_reclaim(phi));
debug_only(const Type* bt2 = phi->bottom_type());
assert(bt2->higher_equal_speculative(bt1), "must be consistent with type-flow");
record_for_igvn(phi);
}
}
} // End of for all values to be merged
if (pnum == PhiNode::Input &&
!r->in(0)) { // The occasional useless Region
assert(control() == r, "");
set_control(r->nonnull_req());
}
map()->merge_replaced_nodes_with(newin);
set_block(save_block);
stop(); // done with this guy, for now
}
if (TraceOptoParse) {
tty->print_cr(" on path %d", pnum);
}
assert(stopped(), "");
}
void Parse::merge_memory_edges(MergeMemNode* n, int pnum, bool nophi) {
assert(n != NULL, "");
MergeMemNode* m = merged_memory();
assert(control()->is_Region(), "must be merging to a region");
RegionNode* r = control()->as_Region();
PhiNode* base = NULL;
MergeMemNode* remerge = NULL;
for (MergeMemStream mms(m, n); mms.next_non_empty2(); ) {
Node *p = mms.force_memory();
Node *q = mms.memory2();
if (mms.is_empty() && nophi) {
if (remerge == NULL) {
assert(base != NULL, "");
assert(base->in(0) != NULL, "should not be xformed away");
remerge = MergeMemNode::make(C, base->in(pnum));
gvn().set_type(remerge, Type::MEMORY);
base->set_req(pnum, remerge);
}
remerge->set_memory_at(mms.alias_idx(), q);
continue;
}
assert(!q->is_MergeMem(), "");
PhiNode* phi;
if (p != q) {
phi = ensure_memory_phi(mms.alias_idx(), nophi);
} else {
if (p->is_Phi() && p->as_Phi()->region() == r)
phi = p->as_Phi();
else
phi = NULL;
}
if (phi != NULL) {
assert(phi->region() == r, "");
p = phi;
phi->set_req(pnum, q);
if (mms.at_base_memory()) {
base = phi; // delay transforming it
} else if (pnum == 1) {
record_for_igvn(phi);
p = _gvn.transform_no_reclaim(phi);
}
mms.set_memory(p);// store back through the iterator
}
}
if (base != NULL && pnum == 1) {
record_for_igvn(base);
m->set_base_memory( _gvn.transform_no_reclaim(base) );
}
}
void Parse::ensure_phis_everywhere() {
ensure_phi(TypeFunc::I_O);
for (MergeMemStream mms(merged_memory()); mms.next_non_empty(); ) {
ensure_memory_phi(mms.alias_idx());
debug_only(mms.set_memory()); // keep the iterator happy
}
uint monoff = map()->jvms()->monoff();
uint nof_monitors = map()->jvms()->nof_monitors();
assert(TypeFunc::Parms == map()->jvms()->locoff(), "parser map should contain only youngest jvms");
bool check_elide_phi = block()->is_SEL_head();
for (uint i = TypeFunc::Parms; i < monoff; i++) {
if (!check_elide_phi || !block()->can_elide_SEL_phi(i)) {
ensure_phi(i);
}
}
for (uint m = 0; m < nof_monitors; m++) {
ensure_phi(map()->jvms()->monitor_obj_offset(m));
}
}
int Parse::Block::add_new_path() {
if (!is_merged()) return pred_count()+1; // there will be a map shortly
SafePointNode* map = start_map();
if (!map->control()->is_Region())
return pred_count()+1; // there may be a region some day
RegionNode* r = map->control()->as_Region();
uint pnum = r->req();
r->add_req(NULL);
for (uint i = 1; i < map->req(); i++) {
Node* n = map->in(i);
if (i == TypeFunc::Memory) {
for (MergeMemStream mms(n->as_MergeMem()); mms.next_non_empty(); ) {
Node* phi = mms.memory();
if (phi->is_Phi() && phi->as_Phi()->region() == r) {
assert(phi->req() == pnum, "must be same size as region");
phi->add_req(NULL);
}
}
} else {
if (n->is_Phi() && n->as_Phi()->region() == r) {
assert(n->req() == pnum, "must be same size as region");
n->add_req(NULL);
}
}
}
return pnum;
}
PhiNode *Parse::ensure_phi(int idx, bool nocreate) {
SafePointNode* map = this->map();
Node* region = map->control();
assert(region->is_Region(), "");
Node* o = map->in(idx);
assert(o != NULL, "");
if (o == top()) return NULL; // TOP always merges into TOP
if (o->is_Phi() && o->as_Phi()->region() == region) {
return o->as_Phi();
}
assert(!nocreate, "Cannot build a phi for a block already parsed.");
const JVMState* jvms = map->jvms();
const Type* t = NULL;
if (jvms->is_loc(idx)) {
t = block()->local_type_at(idx - jvms->locoff());
} else if (jvms->is_stk(idx)) {
t = block()->stack_type_at(idx - jvms->stkoff());
} else if (jvms->is_mon(idx)) {
assert(!jvms->is_monitor_box(idx), "no phis for boxes");
t = TypeInstPtr::BOTTOM; // this is sufficient for a lock object
} else if ((uint)idx < TypeFunc::Parms) {
t = o->bottom_type(); // Type::RETURN_ADDRESS or such-like.
} else {
assert(false, "no type information for this phi");
}
if (t == Type::BOTTOM) {
map->set_req(idx, top());
return NULL;
}
if (t == Type::TOP || t == Type::HALF) {
map->set_req(idx, top());
return NULL;
}
PhiNode* phi = PhiNode::make(region, o, t);
gvn().set_type(phi, t);
if (C->do_escape_analysis()) record_for_igvn(phi);
map->set_req(idx, phi);
return phi;
}
PhiNode *Parse::ensure_memory_phi(int idx, bool nocreate) {
MergeMemNode* mem = merged_memory();
Node* region = control();
assert(region->is_Region(), "");
Node *o = (idx == Compile::AliasIdxBot)? mem->base_memory(): mem->memory_at(idx);
assert(o != NULL && o != top(), "");
PhiNode* phi;
if (o->is_Phi() && o->as_Phi()->region() == region) {
phi = o->as_Phi();
if (phi == mem->base_memory() && idx >= Compile::AliasIdxRaw) {
assert(!nocreate, "Cannot build a phi for a block already parsed.");
const Type* t = phi->bottom_type();
const TypePtr* adr_type = C->get_adr_type(idx);
phi = phi->slice_memory(adr_type);
gvn().set_type(phi, t);
}
return phi;
}
assert(!nocreate, "Cannot build a phi for a block already parsed.");
const Type* t = o->bottom_type();
const TypePtr* adr_type = C->get_adr_type(idx);
phi = PhiNode::make(region, o, t, adr_type);
gvn().set_type(phi, t);
if (idx == Compile::AliasIdxBot)
mem->set_base_memory(phi);
else
mem->set_memory_at(idx, phi);
return phi;
}
void Parse::call_register_finalizer() {
Node* receiver = local(0);
assert(receiver != NULL && receiver->bottom_type()->isa_instptr() != NULL,
"must have non-null instance type");
const TypeInstPtr *tinst = receiver->bottom_type()->isa_instptr();
if (tinst != NULL && tinst->klass()->is_loaded() && !tinst->klass_is_exact()) {
ciInstanceKlass* ik = tinst->klass()->as_instance_klass();
if (!Dependencies::has_finalizable_subclass(ik)) {
C->dependencies()->assert_has_no_finalizable_subclasses(ik);
return;
}
}
Node* klass_addr = basic_plus_adr( receiver, receiver, oopDesc::klass_offset_in_bytes() );
Node* klass = _gvn.transform(LoadKlassNode::make(_gvn, NULL, immutable_memory(), klass_addr, TypeInstPtr::KLASS));
Node* access_flags_addr = basic_plus_adr(klass, klass, in_bytes(Klass::access_flags_offset()));
Node* access_flags = make_load(NULL, access_flags_addr, TypeInt::INT, T_INT, MemNode::unordered);
Node* mask = _gvn.transform(new (C) AndINode(access_flags, intcon(JVM_ACC_HAS_FINALIZER)));
Node* check = _gvn.transform(new (C) CmpINode(mask, intcon(0)));
Node* test = _gvn.transform(new (C) BoolNode(check, BoolTest::ne));
IfNode* iff = create_and_map_if(control(), test, PROB_MAX, COUNT_UNKNOWN);
RegionNode* result_rgn = new (C) RegionNode(3);
record_for_igvn(result_rgn);
Node *skip_register = _gvn.transform(new (C) IfFalseNode(iff));
result_rgn->init_req(1, skip_register);
Node *needs_register = _gvn.transform(new (C) IfTrueNode(iff));
set_control(needs_register);
if (stopped()) {
result_rgn->init_req(2, top());
} else {
Node *call = make_runtime_call(RC_NO_LEAF,
OptoRuntime::register_finalizer_Type(),
OptoRuntime::register_finalizer_Java(),
NULL, TypePtr::BOTTOM,
receiver);
make_slow_call_ex(call, env()->Throwable_klass(), true);
Node* fast_io = call->in(TypeFunc::I_O);
Node* fast_mem = call->in(TypeFunc::Memory);
Node* io_phi = PhiNode::make(result_rgn, fast_io, Type::ABIO);
Node* mem_phi = PhiNode::make(result_rgn, fast_mem, Type::MEMORY, TypePtr::BOTTOM);
result_rgn->init_req(2, control());
io_phi ->init_req(2, i_o());
mem_phi ->init_req(2, reset_memory());
set_all_memory( _gvn.transform(mem_phi) );
set_i_o( _gvn.transform(io_phi) );
}
set_control( _gvn.transform(result_rgn) );
}
void Parse::rtm_deopt() {
#if INCLUDE_RTM_OPT
if (C->profile_rtm()) {
assert(C->method() != NULL, "only for normal compilations");
assert(!C->method()->method_data()->is_empty(), "MDO is needed to record RTM state");
assert(depth() == 1, "generate check only for main compiled method");
set_parse_bci(is_osr_parse() ? osr_bci() : 0);
const TypePtr* adr_type = TypeMetadataPtr::make(C->method()->method_data());
Node* mdo = makecon(adr_type);
int offset = MethodData::rtm_state_offset_in_bytes();
Node* adr_node = basic_plus_adr(mdo, mdo, offset);
Node* rtm_state = make_load(control(), adr_node, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
Node* profile_state = makecon(TypeInt::make(ProfileRTM));
Node* opq = _gvn.transform( new (C) Opaque3Node(C, rtm_state, Opaque3Node::RTM_OPT) );
Node* chk = _gvn.transform( new (C) CmpINode(opq, profile_state) );
Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) );
{ BuildCutout unless(this, tst, PROB_ALWAYS);
uncommon_trap(Deoptimization::Reason_rtm_state_change,
Deoptimization::Action_make_not_entrant);
}
}
#endif
}
void Parse::return_current(Node* value) {
if (RegisterFinalizersAtInit &&
method()->intrinsic_id() == vmIntrinsics::_Object_init) {
call_register_finalizer();
}
set_bci(InvocationEntryBci);
if (method()->is_synchronized() && GenerateSynchronizationCode) {
shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node());
}
if (C->env()->dtrace_method_probes()) {
make_dtrace_method_exit(method());
}
SafePointNode* exit_return = _exits.map();
exit_return->in( TypeFunc::Control )->add_req( control() );
exit_return->in( TypeFunc::I_O )->add_req( i_o () );
Node *mem = exit_return->in( TypeFunc::Memory );
for (MergeMemStream mms(mem->as_MergeMem(), merged_memory()); mms.next_non_empty2(); ) {
if (mms.is_empty()) {
const TypePtr* adr_type = mms.adr_type(C);
Node* phi = mms.force_memory()->as_Phi()->slice_memory(adr_type);
assert(phi->as_Phi()->region() == mms.base_memory()->in(0), "");
gvn().set_type_bottom(phi);
phi->del_req(phi->req()-1); // prepare to re-patch
mms.set_memory(phi);
}
mms.memory()->add_req(mms.memory2());
}
if (value != NULL) {
Node* phi = _exits.argument(0);
const TypeInstPtr *tr = phi->bottom_type()->isa_instptr();
if (tr && tr->klass()->is_loaded() &&
tr->klass()->is_interface()) {
const TypeInstPtr *tp = value->bottom_type()->isa_instptr();
if (tp && tp->klass()->is_loaded() &&
!tp->klass()->is_interface()) {
if (tp->higher_equal(TypeInstPtr::NOTNULL))
tr = tr->join_speculative(TypeInstPtr::NOTNULL)->is_instptr();
value = _gvn.transform(new (C) CheckCastPPNode(0, value, tr));
}
} else {
const TypeInstPtr* phi_tip;
const TypeInstPtr* val_tip;
Type::get_arrays_base_elements(phi->bottom_type(), value->bottom_type(), &phi_tip, &val_tip);
if (phi_tip != NULL && phi_tip->is_loaded() && phi_tip->klass()->is_interface() &&
val_tip != NULL && val_tip->is_loaded() && !val_tip->klass()->is_interface()) {
value = _gvn.transform(new (C) CheckCastPPNode(0, value, phi->bottom_type()));
}
}
phi->add_req(value);
}
if (_first_return) {
_exits.map()->transfer_replaced_nodes_from(map(), _new_idx);
_first_return = false;
} else {
_exits.map()->merge_replaced_nodes_with(map());
}
stop_and_kill_map(); // This CFG path dies here
}
void Parse::add_safepoint() {
Node *proj = control();
bool add_poll_param = SafePointNode::needs_polling_address_input();
uint parms = add_poll_param ? TypeFunc::Parms+1 : TypeFunc::Parms;
if( proj->is_Proj() ) {
Node *n0 = proj->in(0);
if( n0->is_Catch() ) {
n0 = n0->in(0)->in(0);
assert( n0->is_Call(), "expect a call here" );
}
if( n0->is_Call() ) {
if( n0->as_Call()->guaranteed_safepoint() )
return;
} else if( n0->is_SafePoint() && n0->req() >= parms ) {
return;
}
}
kill_dead_locals();
SafePointNode *sfpnt = new (C) SafePointNode(parms, NULL);
Node* mem = MergeMemNode::make(C, map()->memory());
mem = _gvn.transform(mem);
sfpnt->init_req(TypeFunc::Control , control());
sfpnt->init_req(TypeFunc::I_O , top() );
sfpnt->init_req(TypeFunc::Memory , mem );
sfpnt->init_req(TypeFunc::ReturnAdr, top() );
sfpnt->init_req(TypeFunc::FramePtr , top() );
if( add_poll_param ) {
Node *polladr = ConPNode::make(C, (address)os::get_polling_page());
sfpnt->init_req(TypeFunc::Parms+0, _gvn.transform(polladr));
}
add_safepoint_edges(sfpnt);
Node *transformed_sfpnt = _gvn.transform(sfpnt);
set_control(transformed_sfpnt);
if( OptoRemoveUseless && transformed_sfpnt->is_SafePoint() ) {
assert(C->root() != NULL, "Expect parse is still valid");
C->root()->add_prec(transformed_sfpnt);
}
}
#ifndef PRODUCT
void Parse::show_parse_info() {
InlineTree* ilt = NULL;
if (C->ilt() != NULL) {
JVMState* caller_jvms = is_osr_parse() ? caller()->caller() : caller();
ilt = InlineTree::find_subtree_from_root(C->ilt(), caller_jvms, method());
}
if (PrintCompilation && Verbose) {
if (depth() == 1) {
if( ilt->count_inlines() ) {
tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(),
ilt->count_inline_bcs());
tty->cr();
}
} else {
if (method()->is_synchronized()) tty->print("s");
if (method()->has_exception_handlers()) tty->print("!");
if (C->trap_can_recompile()) {
tty->print("-");
} else {
tty->print(" ");
}
method()->print_short_name();
if (is_osr_parse()) {
tty->print(" @ %d", osr_bci());
}
tty->print(" (%d bytes)",method()->code_size());
if (ilt->count_inlines()) {
tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(),
ilt->count_inline_bcs());
}
tty->cr();
}
}
if (PrintOpto && (depth() == 1 || PrintOptoInlining)) {
if (method()->is_synchronized()) tty->print("s");
if (method()->has_exception_handlers()) tty->print("!");
if (C->trap_can_recompile() && depth() == 1) {
tty->print("-");
} else {
tty->print(" ");
}
if( depth() != 1 ) { tty->print(" "); } // missing compile count
for (int i = 1; i < depth(); ++i) { tty->print(" "); }
method()->print_short_name();
if (is_osr_parse()) {
tty->print(" @ %d", osr_bci());
}
if (ilt->caller_bci() != -1) {
tty->print(" @ %d", ilt->caller_bci());
}
tty->print(" (%d bytes)",method()->code_size());
if (ilt->count_inlines()) {
tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(),
ilt->count_inline_bcs());
}
tty->cr();
}
}
void Parse::dump() {
if( method() != NULL ) {
ciBytecodeStream iter(method());
for( Bytecodes::Code bc = iter.next(); bc != ciBytecodeStream::EOBC() ; bc = iter.next() ) {
dump_bci( iter.cur_bci() );
tty->cr();
}
}
}
void Parse::dump_bci(int bci) {
tty->print(" bci:%d", bci);
}
#endif
C:\hotspot-69087d08d473\src\share\vm/opto/parse2.cpp
#include "precompiled.hpp"
#include "ci/ciMethodData.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
#include "compiler/compileLog.hpp"
#include "interpreter/linkResolver.hpp"
#include "memory/universe.inline.hpp"
#include "opto/addnode.hpp"
#include "opto/divnode.hpp"
#include "opto/idealGraphPrinter.hpp"
#include "opto/matcher.hpp"
#include "opto/memnode.hpp"
#include "opto/mulnode.hpp"
#include "opto/parse.hpp"
#include "opto/runtime.hpp"
#include "runtime/deoptimization.hpp"
#include "runtime/sharedRuntime.hpp"
extern int explicit_null_checks_inserted,
explicit_null_checks_elided;
void Parse::array_load(BasicType elem_type) {
const Type* elem = Type::TOP;
Node* adr = array_addressing(elem_type, 0, &elem);
if (stopped()) return; // guaranteed null or range check
dec_sp(2); // Pop array and index
const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type);
Node* ld = make_load(control(), adr, elem, elem_type, adr_type, MemNode::unordered);
push(ld);
}
void Parse::array_store(BasicType elem_type) {
const Type* elem = Type::TOP;
Node* adr = array_addressing(elem_type, 1, &elem);
if (stopped()) return; // guaranteed null or range check
Node* val = pop();
dec_sp(2); // Pop array and index
const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type);
if (elem == TypeInt::BOOL) {
elem_type = T_BOOLEAN;
}
store_to_memory(control(), adr, val, elem_type, adr_type, StoreNode::release_if_reference(elem_type));
}
Node* Parse::array_addressing(BasicType type, int vals, const Type* *result2) {
Node *idx = peek(0+vals); // Get from stack without popping
Node *ary = peek(1+vals); // in case of exception
ary = null_check(ary, T_ARRAY);
if (stopped()) return top();
const TypeAryPtr* arytype = _gvn.type(ary)->is_aryptr();
const TypeInt* sizetype = arytype->size();
const Type* elemtype = arytype->elem();
if (UseUniqueSubclasses && result2 != NULL) {
const Type* el = elemtype->make_ptr();
if (el && el->isa_instptr()) {
const TypeInstPtr* toop = el->is_instptr();
if (toop->klass()->as_instance_klass()->unique_concrete_subklass()) {
const Type* subklass = Type::get_const_type(toop->klass());
elemtype = subklass->join_speculative(el);
}
}
}
const TypeInt* idxtype = _gvn.type(idx)->is_int();
bool need_range_check = true;
if (idxtype->_hi < sizetype->_lo && idxtype->_lo >= 0) {
need_range_check = false;
if (C->log() != NULL) C->log()->elem("observe that='!need_range_check'");
}
ciKlass * arytype_klass = arytype->klass();
if ((arytype_klass != NULL) && (!arytype_klass->is_loaded())) {
uncommon_trap(Deoptimization::Reason_unloaded,
Deoptimization::Action_reinterpret,
arytype->klass(), "!loaded array");
return top();
}
if (GenerateRangeChecks && need_range_check) {
Node* tst;
if (sizetype->_hi <= 0) {
tst = _gvn.intcon(0);
} else {
Node* len = load_array_length(ary);
Node* chk = _gvn.transform( new (C) CmpUNode(idx, len) );
BoolTest::mask btest = BoolTest::lt;
tst = _gvn.transform( new (C) BoolNode(chk, btest) );
}
{ BuildCutout unless(this, tst, PROB_MAX);
if (C->allow_range_check_smearing()) {
uncommon_trap(Deoptimization::Reason_range_check,
Deoptimization::Action_make_not_entrant,
NULL, "range_check");
} else {
builtin_throw(Deoptimization::Reason_range_check, idx);
}
}
}
if (stopped()) return top();
Node* ptr = array_element_address(ary, idx, type, sizetype, control());
if (result2 != NULL) *result2 = elemtype;
assert(ptr != top(), "top should go hand-in-hand with stopped");
return ptr;
}
IfNode* Parse::jump_if_fork_int(Node* a, Node* b, BoolTest::mask mask) {
Node *cmp = _gvn.transform( new (C) CmpINode( a, b)); // two cases: shiftcount > 32 and shiftcount <= 32
Node *tst = _gvn.transform( new (C) BoolNode( cmp, mask));
IfNode *iff = create_and_map_if( control(), tst, ((mask == BoolTest::eq) ? PROB_STATIC_INFREQUENT : PROB_FAIR), COUNT_UNKNOWN );
return iff;
}
Node* Parse::jump_if_join(Node* iffalse, Node* iftrue) {
Node *region = new (C) RegionNode(3); // 2 results
record_for_igvn(region);
region->init_req(1, iffalse);
region->init_req(2, iftrue );
_gvn.set_type(region, Type::CONTROL);
region = _gvn.transform(region);
set_control (region);
return region;
}
void Parse::jump_if_true_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) {
{ PreserveJVMState pjvms(this);
Node *iftrue = _gvn.transform( new (C) IfTrueNode (iff) );
set_control( iftrue );
profile_switch_case(prof_table_index);
merge_new_path(dest_bci_if_true);
}
Node *iffalse = _gvn.transform( new (C) IfFalseNode(iff) );
set_control( iffalse );
}
void Parse::jump_if_false_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) {
{ PreserveJVMState pjvms(this);
Node *iffalse = _gvn.transform( new (C) IfFalseNode (iff) );
set_control( iffalse );
profile_switch_case(prof_table_index);
merge_new_path(dest_bci_if_true);
}
Node *iftrue = _gvn.transform( new (C) IfTrueNode(iff) );
set_control( iftrue );
}
void Parse::jump_if_always_fork(int dest_bci, int prof_table_index) {
profile_switch_case(prof_table_index);
merge_new_path(dest_bci);
}
extern "C" {
static int jint_cmp(const void *i, const void *j) {
int a = *(jint *)i;
int b = *(jint *)j;
return a > b ? 1 : a < b ? -1 : 0;
}
}
#define NullTableIndex -1
class SwitchRange : public StackObj {
jint _lo; // inclusive lower limit
jint _hi; // inclusive upper limit
int _dest;
int _table_index; // index into method data table
public:
jint lo() const { return _lo; }
jint hi() const { return _hi; }
int dest() const { return _dest; }
int table_index() const { return _table_index; }
bool is_singleton() const { return _lo == _hi; }
void setRange(jint lo, jint hi, int dest, int table_index) {
assert(lo <= hi, "must be a non-empty range");
_lo = lo, _hi = hi; _dest = dest; _table_index = table_index;
}
bool adjoinRange(jint lo, jint hi, int dest, int table_index) {
assert(lo <= hi, "must be a non-empty range");
if (lo == _hi+1 && dest == _dest && table_index == _table_index) {
_hi = hi;
return true;
}
return false;
}
void set (jint value, int dest, int table_index) {
setRange(value, value, dest, table_index);
}
bool adjoin(jint value, int dest, int table_index) {
return adjoinRange(value, value, dest, table_index);
}
void print() {
if (is_singleton())
tty->print(" {%d}=>%d", lo(), dest());
else if (lo() == min_jint)
tty->print(" {..%d}=>%d", hi(), dest());
else if (hi() == max_jint)
tty->print(" {%d..}=>%d", lo(), dest());
else
tty->print(" {%d..%d}=>%d", lo(), hi(), dest());
}
};
void Parse::do_tableswitch() {
Node* lookup = pop();
int default_dest = iter().get_dest_table(0);
int lo_index = iter().get_int_table(1);
int hi_index = iter().get_int_table(2);
int len = hi_index - lo_index + 1;
if (len < 1) {
maybe_add_safepoint(default_dest);
merge(default_dest);
return;
}
int rnum = len+2;
bool makes_backward_branch = false;
SwitchRange* ranges = NEW_RESOURCE_ARRAY(SwitchRange, rnum);
int rp = -1;
if (lo_index != min_jint) {
ranges[++rp].setRange(min_jint, lo_index-1, default_dest, NullTableIndex);
}
for (int j = 0; j < len; j++) {
jint match_int = lo_index+j;
int dest = iter().get_dest_table(j+3);
makes_backward_branch |= (dest <= bci());
int table_index = method_data_update() ? j : NullTableIndex;
if (rp < 0 || !ranges[rp].adjoin(match_int, dest, table_index)) {
ranges[++rp].set(match_int, dest, table_index);
}
}
jint highest = lo_index+(len-1);
assert(ranges[rp].hi() == highest, "");
if (highest != max_jint
&& !ranges[rp].adjoinRange(highest+1, max_jint, default_dest, NullTableIndex)) {
ranges[++rp].setRange(highest+1, max_jint, default_dest, NullTableIndex);
}
assert(rp < len+2, "not too many ranges");
if( makes_backward_branch && UseLoopSafepoints )
add_safepoint();
jump_switch_ranges(lookup, &ranges[0], &ranges[rp]);
}
void Parse::do_lookupswitch() {
Node *lookup = pop(); // lookup value
int default_dest = iter().get_dest_table(0);
int len = iter().get_int_table(1);
if (len < 1) { // If this is a backward branch, add safepoint
maybe_add_safepoint(default_dest);
merge(default_dest);
return;
}
jint* table = NEW_RESOURCE_ARRAY(jint, len*2);
{
for( int j = 0; j < len; j++ ) {
table[j+j+0] = iter().get_int_table(2+j+j);
table[j+j+1] = iter().get_dest_table(2+j+j+1);
}
qsort( table, len, 2*sizeof(table[0]), jint_cmp );
}
int rnum = len*2+1;
bool makes_backward_branch = false;
SwitchRange* ranges = NEW_RESOURCE_ARRAY(SwitchRange, rnum);
int rp = -1;
for( int j = 0; j < len; j++ ) {
jint match_int = table[j+j+0];
int dest = table[j+j+1];
int next_lo = rp < 0 ? min_jint : ranges[rp].hi()+1;
int table_index = method_data_update() ? j : NullTableIndex;
makes_backward_branch |= (dest <= bci());
if( match_int != next_lo ) {
ranges[++rp].setRange(next_lo, match_int-1, default_dest, NullTableIndex);
}
if( rp < 0 || !ranges[rp].adjoin(match_int, dest, table_index) ) {
ranges[++rp].set(match_int, dest, table_index);
}
}
jint highest = table[2*(len-1)];
assert(ranges[rp].hi() == highest, "");
if( highest != max_jint
&& !ranges[rp].adjoinRange(highest+1, max_jint, default_dest, NullTableIndex) ) {
ranges[++rp].setRange(highest+1, max_jint, default_dest, NullTableIndex);
}
assert(rp < rnum, "not too many ranges");
if( makes_backward_branch && UseLoopSafepoints )
add_safepoint();
jump_switch_ranges(lookup, &ranges[0], &ranges[rp]);
}
bool Parse::create_jump_tables(Node* key_val, SwitchRange* lo, SwitchRange* hi) {
if (!UseJumpTables) return false;
if (!Matcher::has_match_rule(Op_Jump)) return false;
if (method_data_update()) return false;
bool needs_guard = false;
int default_dest;
int64 total_outlier_size = 0;
int64 hi_size = ((int64)hi->hi()) - ((int64)hi->lo()) + 1;
int64 lo_size = ((int64)lo->hi()) - ((int64)lo->lo()) + 1;
if (lo->dest() == hi->dest()) {
total_outlier_size = hi_size + lo_size;
default_dest = lo->dest();
} else if (lo_size > hi_size) {
total_outlier_size = lo_size;
default_dest = lo->dest();
} else {
total_outlier_size = hi_size;
default_dest = hi->dest();
}
if (total_outlier_size > (MaxJumpTableSparseness * 4)) {
needs_guard = true;
if (default_dest == lo->dest()) lo++;
if (default_dest == hi->dest()) hi--;
}
int64 num_cases = ((int64)hi->hi()) - ((int64)lo->lo()) + 1;
int num_range = hi - lo + 1;
if (num_cases < MinJumpTableSize || num_cases > MaxJumpTableSize)
return false;
if (num_cases > (MaxJumpTableSparseness * num_range))
return false;
int lowval = lo->lo();
key_val = _gvn.transform( new (C) SubINode(key_val, _gvn.intcon(lowval)) );
if (needs_guard) {
Node* size = _gvn.intcon(num_cases);
Node* cmp = _gvn.transform( new (C) CmpUNode(key_val, size) );
Node* tst = _gvn.transform( new (C) BoolNode(cmp, BoolTest::ge) );
IfNode* iff = create_and_map_if( control(), tst, PROB_FAIR, COUNT_UNKNOWN);
jump_if_true_fork(iff, default_dest, NullTableIndex);
}
#ifdef _LP64
const TypeInt* ikeytype = TypeInt::make(0, num_cases-1, Type::WidenMin);
key_val = C->constrained_convI2L(&_gvn, key_val, ikeytype, control());
#endif
Node *shiftWord = _gvn.MakeConX(wordSize);
key_val = _gvn.transform( new (C) MulXNode( key_val, shiftWord));
Node* jtn = _gvn.transform( new (C) JumpNode(control(), key_val, num_cases) );
int i = 0;
for (SwitchRange* r = lo; r <= hi; r++) {
for (int64 j = r->lo(); j <= r->hi(); j++, i++) {
Node* input = _gvn.transform(new (C) JumpProjNode(jtn, i, r->dest(), (int)(j - lowval)));
{
PreserveJVMState pjvms(this);
set_control(input);
jump_if_always_fork(r->dest(), r->table_index());
}
}
}
assert(i == num_cases, "miscount of cases");
stop_and_kill_map(); // no more uses for this JVMS
return true;
}
扫一扫
01-05
1596
1596
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
