init_req( KlassNode , klass_node);

init_req( InitialTest , initial_test);

init_req( ALength , topnode);

init_req( ValidLengthTest , topnode);

C->add_macro_node(this);

}

}

}

Node*AllocateArrayNode::Ideal(PhaseGVN *phase,bool can_reshape) {

if (remove_dead_region(phase, can_reshape))returnthis;

if (in(0) &&in(0)->is_top())returnNULL;

const Type* type = phase->type(Ideal_length());

if (type->isa_int() && type->is_int()->_hi <0) {

if (can_reshape) {

PhaseIterGVN *igvn = phase->is_IterGVN();

Node* proj =proj_out_or_null(TypeFunc::Control);

Node* catchproj =NULL;

if (proj !=NULL) {

for (DUIterator_Fast imax, i = proj->fast_outs(imax); i < imax; i++) {

Node *cn = proj->fast_out(i);

if (cn->is_Catch()) {

catchproj = cn->as_Multi()->proj_out_or_null(CatchProjNode::fall_through_index);

break;

}

}

}

if (catchproj !=NULL && catchproj->outcnt() >0 &&

(catchproj->outcnt() >1 ||

catchproj->unique_out()->Opcode() != Op_Halt)) {

assert(catchproj->is_CatchProj(),"must be a CatchProjNode");

Node* nproj = catchproj->clone();

igvn->register_new_node_with_optimizer(nproj);

Node *frame =newParmNode( phase->C->start(), TypeFunc::FramePtr );

frame = phase->transform(frame);

Node* halt =newHaltNode(nproj, frame,"unexpected negative array length");

phase->C->root()->add_req(halt);

phase->transform(halt);

igvn->replace_node(catchproj, phase->C->top());

returnthis;

}

}else {

phase->C->record_for_igvn(this);

}

}

returnNULL;

}

KlassNode,// type (maybe dynamic) of the obj.

InitialTest,// slow-path test (may be constant)

ALength,// array length (or TOP if none)

ValidLengthTest,

ParmLimit

};

fields[KlassNode] = TypeInstPtr::NOTNULL;

fields[InitialTest] = TypeInt::BOOL;

fields[ALength] = t;// length (can be a bad length)

fields[ValidLengthTest] = TypeInt::BOOL;

const TypeTuple *domain =TypeTuple::make(ParmLimit, fields);

classAllocateArrayNode :publicAllocateNode {

AllocateArrayNode(Compile* C,const TypeFunc* atype, Node* ctrl, Node* mem, Node* abio, Node* size, Node* klass_node,

Node* initial_test, Node* count_val, Node* valid_length_test)

AllocateArrayNode(Compile* C,const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,

Node* size, Node* klass_node, Node* initial_test,

Node* count_val

)

: AllocateNode(C, atype, ctrl, mem, abio, size, klass_node,

initial_test)

{

init_class_id(Class_AllocateArray);

set_req(AllocateNode::ALength, count_val);

set_req(AllocateNode::ValidLengthTest, valid_length_test);

}

virtualintOpcode()const;

virtual Node *Ideal(PhaseGVN *phase,bool can_reshape);

Node*Ideal_length() {

if (call->entry_point() ==OptoRuntime::rethrow_stub()) {

f[CatchProjNode::fall_through_index] = Type::TOP;

}elseif (call->is_AllocateArray()) {

Node* klass_node = call->in(AllocateNode::KlassNode);

Node* length = call->in(AllocateNode::ALength);

const Type* length_type = phase->type(length);

const Type* klass_type = phase->type(klass_node);

Node* valid_length_test = call->in(AllocateNode::ValidLengthTest);

const Type*valid_length_test_t = phase->type(valid_length_test);

if (length_type == Type::TOP || klass_type == Type::TOP ||valid_length_test_t == Type::TOP ||

valid_length_test_t->is_int()->is_con(0)) {

f[CatchProjNode::fall_through_index] = Type::TOP;

}

}elseif( call->req() > TypeFunc::Parms ) {

const Type *arg0 = phase->type( call->in(TypeFunc::Parms) );

if (n->is_PCTable() && n->in(0) && n->in(0)->in(0)) {

if (n->in(0)->in(0)->is_Call()) {

CallNode*call = n->in(0)->in(0)->as_Call();

CallNode *call = n->in(0)->in(0)->as_Call();

if (call->entry_point() ==OptoRuntime::rethrow_stub()) {

required_outcnt--;// Rethrow always has 1 less kid

}elseif (call->req() > TypeFunc::Parms &&

Node*arg0 = call->in(TypeFunc::Parms);

Node *arg0 = call->in(TypeFunc::Parms);

if (arg0->is_Type() &&

arg0->as_Type()->type()->higher_equal(TypePtr::NULL_PTR)) {

required_outcnt--;

}

}elseif (call->entry_point() ==OptoRuntime::new_array_Java() ||

call->entry_point() ==OptoRuntime::new_array_nozero_Java()) {

}elseif (call->entry_point() ==OptoRuntime::new_array_Java() &&

call->req() > TypeFunc::Parms+1 &&

call->is_CallStaticJava()) {

assert(call->is_CallStaticJava(),"static call expected");

assert(call->req() == call->jvms()->endoff() +1,"missing extra input");

Node* valid_length_test = call->in(call->req()-1);

call->del_req(call->req()-1);

if (valid_length_test->find_int_con(1) ==0) {

Node *arg1 = call->in(TypeFunc::Parms+1);

if (arg1->is_Type() &&

arg1->as_Type()->type()->join(TypeInt::POS)->empty()) {

required_outcnt--;

}

assert(n->outcnt() == required_outcnt,"malformed control flow");

continue;

}

}

}

record_method_not_compilable("malformed control flow");

returntrue;// Not all targets reachable!

}

}elseif (n->is_PCTable() && n->in(0) && n->in(0)->in(0) && n->in(0)->in(0)->is_Call()) {

CallNode* call = n->in(0)->in(0)->as_Call();

if (call->entry_point() ==OptoRuntime::new_array_Java() ||

call->entry_point() ==OptoRuntime::new_array_nozero_Java()) {

assert(call->is_CallStaticJava(),"static call expected");

assert(call->req() == call->jvms()->endoff() +1,"missing extra input");

call->del_req(call->req()-1);// valid length test useless now

}

}

Node* i_o = _gvn.transform(newProjNode(call, TypeFunc::I_O, separate_io_proj) );

Node* catc = _gvn.transform(newCatchNode(control(), i_o,2) );

Node* norm =newCatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci);

_gvn.set_type_bottom(norm);

C->record_for_igvn(norm);

Node* norm = _gvn.transform(newCatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );

Node* excp = _gvn.transform(newCatchProjNode(catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci) );

{ PreserveJVMStatepjvms(this);

initial_slow_test = initial_slow_test->as_Bool()->as_int_value(&_gvn);

}

const TypeOopPtr* ary_type = _gvn.type(klass_node)->is_klassptr()->as_instance_type();

Node* valid_length_test = _gvn.intcon(1);

if (ary_type->klass()->is_array_klass()) {

BasicType bt = ary_type->klass()->as_array_klass()->element_type()->basic_type();

jint max =TypeAryPtr::max_array_length(bt);

Node* valid_length_cmp = _gvn.transform(newCmpUNode(length,intcon(max)));

valid_length_test = _gvn.transform(newBoolNode(valid_length_cmp, BoolTest::le));

}

AllocateArrayNode* alloc

=newAllocateArrayNode(C,AllocateArrayNode::alloc_type(TypeInt::INT),

control(), mem,i_o(),

size, klass_node,

initial_slow_test,

length, valid_length_test);

length);

const TypeInt* length_type = _gvn.find_int_type(length);

const TypeOopPtr* ary_type = _gvn.type(klass_node)->is_klassptr()->as_instance_type();

if (ary_type->isa_aryptr() && length_type !=NULL) {

ary_type = ary_type->is_aryptr()->cast_to_size(length_type);

AllocateNode* alloc,// allocation node to be expanded

Node* length,// array length for an array allocation

const TypeFunc* slow_call_type,// Type of slow call

address slow_call_address,// Address of slow call

Node* valid_length_test// whether length is valid or not

address slow_call_address// Address of slow call

)

{

copy_call_debug_info((CallNode *) alloc, call);

if (valid_length_test !=NULL) {

call->add_req(valid_length_test);

}

if (!always_slow) {

call->set_cnt(PROB_UNLIKELY_MAG(4));// Same effect as RC_UNCOMMON.

}else {

voidPhaseMacroExpand::expand_allocate(AllocateNode *alloc) {

expand_allocate_common(alloc,NULL,

OptoRuntime::new_instance_Type(),

OptoRuntime::new_instance_Java(),NULL);

OptoRuntime::new_instance_Java());

}

voidPhaseMacroExpand::expand_allocate_array(AllocateArrayNode *alloc) {

Node* length = alloc->in(AllocateNode::ALength);

Node* valid_length_test = alloc->in(AllocateNode::ValidLengthTest);

InitializeNode* init = alloc->initialization();

Node* klass_node = alloc->in(AllocateNode::KlassNode);

ciKlass* k = _igvn.type(klass_node)->is_klassptr()->klass();

}

expand_allocate_common(alloc, length,

OptoRuntime::new_array_Type(),

slow_call_address, valid_length_test);

slow_call_address);

}

voidexpand_allocate_common(AllocateNode* alloc,

Node* length,

const TypeFunc* slow_call_type,

address slow_call_address,

Node* valid_length_test);

address slow_call_address);

Node *value_from_mem(Node *mem, Node *ctl, BasicType ft,const Type *ftype,const TypeOopPtr *adr_t, AllocateNode *alloc);

Node *value_from_mem_phi(Node *mem, BasicType ft,const Type *ftype,const TypeOopPtr *adr_t, AllocateNode *alloc, Node_Stack *value_phis,int level);

}

}else {

assert(use->is_If() || use->is_CMove() || use->Opcode() == Op_Opaque1 || use->is_AllocateArray(),"unexpected node type");

Node *use_c =(use->is_If() || use->is_AllocateArray()) ? use->in(0) :get_ctrl(use);

assert(use->is_If() || use->is_CMove() || use->Opcode() == Op_Opaque1,"unexpected node type");

Node *use_c = use->is_If() ? use->in(0) :get_ctrl(use);

if (use_c == blk1 || use_c == blk2) {

assert(use->is_CMove(),"unexpected node type");

continue;

--j;

}else {

assert(u->is_If() || u->is_CMove() || u->Opcode() == Op_Opaque1 || u->is_AllocateArray(),"unexpected node type");

assert(u->is_AllocateArray() || u->in(1) == bol,"");

assert(!u->is_AllocateArray() || u->in(AllocateNode::ValidLengthTest) == bol,"wrong input to AllocateArray");

assert(u->is_If() || u->is_CMove() || u->Opcode() == Op_Opaque1,"unexpected node type");

assert(u->in(1) == bol,"");

Node *u_ctrl =(u->is_If() || u->is_AllocateArray()) ? u->in(0) :get_ctrl(u);

Node *u_ctrl = u->is_If() ? u->in(0) :get_ctrl(u);

assert((u_ctrl != blk1 && u_ctrl != blk2) || u->is_CMove(),"won't converge");

Node *x = bol->clone();

register_new_node(x, u_ctrl);

_igvn.replace_input_of(u,u->is_AllocateArray() ? AllocateNode::ValidLengthTest :1, x);

_igvn.replace_input_of(u,1, x);

--j;

}

}