101 

   101 

   102 extern void print_alias_types();

   102 extern void print_alias_types();

   103 

   103 

   104 #endif

   104 #endif

   105 

   105 

   109     return mchain;  // don't try to optimize non-instance types

   113     return mchain;  // don't try to optimize non-instance types

   111   Node *start_mem = phase->C->start()->proj_out(TypeFunc::Memory);

   115   Node *start_mem = phase->C->start()->proj_out(TypeFunc::Memory);

   112   Node *prev = NULL;

   116   Node *prev = NULL;

   113   Node *result = mchain;

   117   Node *result = mchain;

   114   while (prev != result) {

   118   while (prev != result) {

   115     prev = result;

   119     prev = result;

   120       Node *proj_in = result->in(0);

   124       Node *proj_in = result->in(0);

   121       if (proj_in->is_Allocate() && proj_in->_idx == instance_id) {

   125       if (proj_in->is_Allocate() && proj_in->_idx == instance_id) {

   122         break;  // hit one of our sentinels

   126         break;  // hit one of our sentinels

   123       } else if (proj_in->is_Call()) {

   127       } else if (proj_in->is_Call()) {

   124         CallNode *call = proj_in->as_Call();

   128         CallNode *call = proj_in->as_Call();

   126           result = call->in(TypeFunc::Memory);

   130           result = call->in(TypeFunc::Memory);

   127         }

   131         }

   128       } else if (proj_in->is_Initialize()) {

   132       } else if (proj_in->is_Initialize()) {

   129         AllocateNode* alloc = proj_in->as_Initialize()->allocation();

   133         AllocateNode* alloc = proj_in->as_Initialize()->allocation();

   130         // Stop if this is the initialization for the object instance which

   134         // Stop if this is the initialization for the object instance which

   131         // which contains this memory slice, otherwise skip over it.

   135         // which contains this memory slice, otherwise skip over it.

   133           result = proj_in->in(TypeFunc::Memory);

   140           result = proj_in->in(TypeFunc::Memory);

   134         }

   147         }

   135       } else if (proj_in->is_MemBar()) {

   148       } else if (proj_in->is_MemBar()) {

   136         result = proj_in->in(TypeFunc::Memory);

   149         result = proj_in->in(TypeFunc::Memory);

   137       } else {

   150       } else {

   138         assert(false, "unexpected projection");

   151         assert(false, "unexpected projection");

   139       }

   152       }

   140     } else if (result->is_ClearArray()) {

   153     } else if (result->is_ClearArray()) {

   142         // Can not bypass initialization of the instance

   155         // Can not bypass initialization of the instance

   143         // we are looking for.

   156         // we are looking for.

   144         break;

   157         break;

   145       }

   158       }

   146       // Otherwise skip it (the call updated 'result' value).

   159       // Otherwise skip it (the call updated 'result' value).

   147     } else if (result->is_MergeMem()) {

   160     } else if (result->is_MergeMem()) {

   149     }

   162     }

   150   }

   163   }

   151   return result;

   164   return result;

   152 }

   165 }

   153 

   166 

   157   PhaseIterGVN *igvn = phase->is_IterGVN();

   173   PhaseIterGVN *igvn = phase->is_IterGVN();

   160   if (is_instance && igvn != NULL  && result->is_Phi()) {

   174   if (is_instance && igvn != NULL  && result->is_Phi()) {

   161     PhiNode *mphi = result->as_Phi();

   175     PhiNode *mphi = result->as_Phi();

   162     assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");

   176     assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");

   163     const TypePtr *t = mphi->adr_type();

   177     const TypePtr *t = mphi->adr_type();

   164     if (t == TypePtr::BOTTOM || t == TypeRawPtr::BOTTOM ||

   178     if (t == TypePtr::BOTTOM || t == TypeRawPtr::BOTTOM ||

   381 

   395 

   382   // Currently 'sub' is either Allocate, Initialize or Start nodes.

   396   // Currently 'sub' is either Allocate, Initialize or Start nodes.

   383   // Or Region for the check in LoadNode::Ideal();

   397   // Or Region for the check in LoadNode::Ideal();

   384   // 'sub' should have sub->in(0) != NULL.

   398   // 'sub' should have sub->in(0) != NULL.

   385   assert(sub->is_Allocate() || sub->is_Initialize() || sub->is_Start() ||

   399   assert(sub->is_Allocate() || sub->is_Initialize() || sub->is_Start() ||

   387 

   401 

   388   // Get control edge of 'sub'.

   402   // Get control edge of 'sub'.

   389   Node* orig_sub = sub;

   403   Node* orig_sub = sub;

   390   sub = sub->find_exact_control(sub->in(0));

   404   sub = sub->find_exact_control(sub->in(0));

   391   if (sub == NULL || sub->is_top())

   405   if (sub == NULL || sub->is_top())

   955 // same time (uses the Oracle model of aliasing), then some

   969 // same time (uses the Oracle model of aliasing), then some

   956 // LoadXNode::Identity will fold things back to the equivalence-class model

   970 // LoadXNode::Identity will fold things back to the equivalence-class model

   957 // of aliasing.

   971 // of aliasing.

   958 Node* MemNode::can_see_stored_value(Node* st, PhaseTransform* phase) const {

   972 Node* MemNode::can_see_stored_value(Node* st, PhaseTransform* phase) const {

   959   Node* ld_adr = in(MemNode::Address);

   973   Node* ld_adr = in(MemNode::Address);

   961   const TypeInstPtr* tp = phase->type(ld_adr)->isa_instptr();

   976   const TypeInstPtr* tp = phase->type(ld_adr)->isa_instptr();

   965     uint alias_idx = atp->index();

   982     uint alias_idx = atp->index();

   966     bool final = atp->field()->is_final();

   983     bool final = atp->field()->is_final();

   967     Node* result = NULL;

   984     Node* result = NULL;

   968     Node* current = st;

   985     Node* current = st;

   969     // Skip through chains of MemBarNodes checking the MergeMems for

   986     // Skip through chains of MemBarNodes checking the MergeMems for

   981         if (mem->is_MergeMem()) {

   998         if (mem->is_MergeMem()) {

   982           MergeMemNode* merge = mem->as_MergeMem();

   999           MergeMemNode* merge = mem->as_MergeMem();

   983           Node* new_st = merge->memory_at(alias_idx);

  1000           Node* new_st = merge->memory_at(alias_idx);

   984           if (new_st == merge->base_memory()) {

  1001           if (new_st == merge->base_memory()) {

   985             // Keep searching

  1002             // Keep searching

   987             continue;

  1004             continue;

   988           }

  1005           }

   989           // Save the new memory state for the slice and fall through

  1006           // Save the new memory state for the slice and fall through

   990           // to exit.

  1007           // to exit.

   991           result = new_st;

  1008           result = new_st;

  1008       if (!phase->eqv(st_adr, ld_adr)) {

  1025       if (!phase->eqv(st_adr, ld_adr)) {

  1009         // Try harder before giving up...  Match raw and non-raw pointers.

  1026         // Try harder before giving up...  Match raw and non-raw pointers.

  1010         intptr_t st_off = 0;

  1027         intptr_t st_off = 0;

  1011         AllocateNode* alloc = AllocateNode::Ideal_allocation(st_adr, phase, st_off);

  1028         AllocateNode* alloc = AllocateNode::Ideal_allocation(st_adr, phase, st_off);

  1012         if (alloc == NULL)       return NULL;

  1029         if (alloc == NULL)       return NULL;

  1016         if (ld_off != st_off)    return NULL;

  1031         if (ld_off != st_off)    return NULL;

  1017         // At this point we have proven something like this setup:

  1032         // At this point we have proven something like this setup:

  1018         //  A = Allocate(...)

  1033         //  A = Allocate(...)

  1019         //  L = LoadQ(,  AddP(CastPP(, A.Parm),, #Off))

  1034         //  L = LoadQ(,  AddP(CastPP(, A.Parm),, #Off))

  1020         //  S = StoreQ(, AddP(,        A.Parm  , #Off), V)

  1035         //  S = StoreQ(, AddP(,        A.Parm  , #Off), V)

  1027       if (store_Opcode() != st->Opcode())

  1042       if (store_Opcode() != st->Opcode())

  1028         return NULL;

  1043         return NULL;

  1029       return st->in(MemNode::ValueIn);

  1044       return st->in(MemNode::ValueIn);

  1030     }

  1045     }

  1031 

  1046 

  1034     // A load from a freshly-created object always returns zero.

  1047     // A load from a freshly-created object always returns zero.

  1035     // (This can happen after LoadNode::Ideal resets the load's memory input

  1048     // (This can happen after LoadNode::Ideal resets the load's memory input

  1036     // to find_captured_store, which returned InitializeNode::zero_memory.)

  1049     // to find_captured_store, which returned InitializeNode::zero_memory.)

  1037     if (st->is_Proj() && st->in(0)->is_Allocate() &&

  1050     if (st->is_Proj() && st->in(0)->is_Allocate() &&

  1040       // return a zero value for the load's basic type

  1053       // return a zero value for the load's basic type

  1041       // (This is one of the few places where a generic PhaseTransform

  1054       // (This is one of the few places where a generic PhaseTransform

  1042       // can create new nodes.  Think of it as lazily manifesting

  1055       // can create new nodes.  Think of it as lazily manifesting

  1043       // virtually pre-existing constants.)

  1056       // virtually pre-existing constants.)

  1044       return phase->zerocon(memory_type());

  1057       return phase->zerocon(memory_type());

  1046 

  1059 

  1047     // A load from an initialization barrier can match a captured store.

  1060     // A load from an initialization barrier can match a captured store.

  1048     if (st->is_Proj() && st->in(0)->is_Initialize()) {

  1061     if (st->is_Proj() && st->in(0)->is_Initialize()) {

  1049       InitializeNode* init = st->in(0)->as_Initialize();

  1062       InitializeNode* init = st->in(0)->as_Initialize();

  1050       AllocateNode* alloc = init->allocation();

  1063       AllocateNode* alloc = init->allocation();

  1053         // examine a captured store value

  1065         // examine a captured store value

  1055         if (st != NULL)

  1067         if (st != NULL)

  1056           continue;             // take one more trip around

  1068           continue;             // take one more trip around

  1057       }

  1069       }

  1058     }

  1070     }

  1059 

  1071 

  1060     break;

  1085     break;

  1061   }

  1086   }

  1062 

  1087 

  1063   return NULL;

  1088   return NULL;

  1064 }

  1089 }

  1065 

  1090 

  1066 //----------------------is_instance_field_load_with_local_phi------------------

  1091 //----------------------is_instance_field_load_with_local_phi------------------

  1067 bool LoadNode::is_instance_field_load_with_local_phi(Node* ctrl) {

  1092 bool LoadNode::is_instance_field_load_with_local_phi(Node* ctrl) {

  1073         t_oop->offset() != Type::OffsetBot &&

  1100         t_oop->offset() != Type::OffsetBot &&

  1074         t_oop->offset() != Type::OffsetTop) {

  1101         t_oop->offset() != Type::OffsetTop) {

  1075       return true;

  1102       return true;

  1076     }

  1103     }

  1077   }

  1104   }

  1081 //------------------------------Identity---------------------------------------

  1108 //------------------------------Identity---------------------------------------

  1082 // Loads are identity if previous store is to same address

  1109 // Loads are identity if previous store is to same address

  1083 Node *LoadNode::Identity( PhaseTransform *phase ) {

  1110 Node *LoadNode::Identity( PhaseTransform *phase ) {

  1084   // If the previous store-maker is the right kind of Store, and the store is

  1111   // If the previous store-maker is the right kind of Store, and the store is

  1085   // to the same address, then we are equal to the value stored.

  1112   // to the same address, then we are equal to the value stored.

  1087   Node* value = can_see_stored_value(mem, phase);

  1114   Node* value = can_see_stored_value(mem, phase);

  1088   if( value ) {

  1115   if( value ) {

  1089     // byte, short & char stores truncate naturally.

  1116     // byte, short & char stores truncate naturally.

  1090     // A load has to load the truncated value which requires

  1117     // A load has to load the truncated value which requires

  1091     // some sort of masking operation and that requires an

  1118     // some sort of masking operation and that requires an

  1103 

  1130 

  1104   // Search for an existing data phi which was generated before for the same

  1131   // Search for an existing data phi which was generated before for the same

  1105   // instance's field to avoid infinite generation of phis in a loop.

  1132   // instance's field to avoid infinite generation of phis in a loop.

  1106   Node *region = mem->in(0);

  1133   Node *region = mem->in(0);

  1107   if (is_instance_field_load_with_local_phi(region)) {

  1134   if (is_instance_field_load_with_local_phi(region)) {

  1109     int this_index  = phase->C->get_alias_index(addr_t);

  1136     int this_index  = phase->C->get_alias_index(addr_t);

  1110     int this_offset = addr_t->offset();

  1137     int this_offset = addr_t->offset();

  1112     const Type* this_type = bottom_type();

  1146     const Type* this_type = bottom_type();

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

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

  1114       Node* phi = region->fast_out(i);

  1148       Node* phi = region->fast_out(i);

  1115       if (phi->is_Phi() && phi != mem &&

  1149       if (phi->is_Phi() && phi != mem &&

  1117         return phi;

  1151         return phi;

  1118       }

  1152       }

  1119     }

  1153     }

  1120   }

  1154   }

  1121 

  1155 

  1122   return this;

  1156   return this;

  1123 }

  1157 }

  1181 

  1158 

  1182 // We're loading from an object which has autobox behaviour.

  1159 // We're loading from an object which has autobox behaviour.

  1183 // If this object is result of a valueOf call we'll have a phi

  1160 // If this object is result of a valueOf call we'll have a phi

  1184 // merging a newly allocated object and a load from the cache.

  1161 // merging a newly allocated object and a load from the cache.

  1185 // We want to replace this load with the original incoming

  1162 // We want to replace this load with the original incoming

  1186 // argument to the valueOf call.

  1163 // argument to the valueOf call.

  1187 Node* LoadNode::eliminate_autobox(PhaseGVN* phase) {

  1164 Node* LoadNode::eliminate_autobox(PhaseGVN* phase) {

  1241   } else if (base->is_Load() ||

  1173   } else if (base->is_Load() ||

  1242              base->is_DecodeN() && base->in(1)->is_Load()) {

  1174              base->is_DecodeN() && base->in(1)->is_Load()) {

  1248     // array by deriving the value from the index into the array.

  1176     // array by deriving the value from the index into the array.

  1249     // Capture the offset of the load and then reverse the computation.

  1177     // Capture the offset of the load and then reverse the computation.

  1265         Node* elements[4];

  1195         Node* elements[4];

  1274           }

  1258           }

  1289         }

  1259         }

  1290       }

  1260       }

  1291     }

  1261     }

  1292   }

  1262   }

  1293   return NULL;

  1263   return NULL;

  1294 }

  1264 }

  1295 

  1265 

  1308   if (region == NULL) {

  1268   if (region == NULL) {

  1312   for (uint i = 1; i < cnt; i++) {

  1272   for (uint i = 1; i < cnt; i++) {

  1313     Node* rc = region->in(i);

  1273     Node* rc = region->in(i);

  1314     if (rc == NULL || phase->type(rc) == Type::TOP)

  1274     if (rc == NULL || phase->type(rc) == Type::TOP)

  1315       return NULL; // Wait stable graph

  1308       return NULL; // Wait stable graph

  1318       return NULL; // Wait stable graph

  1325       return NULL; // Wait stable graph

  1319     }

  1326     }

  1332   // Split through Phi (see original code in loopopts.cpp).

  1340   // Split through Phi (see original code in loopopts.cpp).

  1334 

  1342 

  1335   // Do nothing here if Identity will find a value

  1343   // Do nothing here if Identity will find a value

  1336   // (to avoid infinite chain of value phis generation).

  1344   // (to avoid infinite chain of value phis generation).

  1337   if (!phase->eqv(this, this->Identity(phase)))

  1345   if (!phase->eqv(this, this->Identity(phase)))

  1338     return NULL;

  1346     return NULL;

  1339 

  1347 

  1343 

  1375 

  1344   const Type* this_type = this->bottom_type();

  1376   const Type* this_type = this->bottom_type();

  1350   for (uint i = 1; i < region->req(); i++) {

  1386   for (uint i = 1; i < region->req(); i++) {

  1352     Node* the_clone = NULL;

  1388     Node* the_clone = NULL;

  1355     } else {

  1391     } else {

  1356       x = this->clone();        // Else clone up the data op

  1392       x = this->clone();        // Else clone up the data op

  1357       the_clone = x;            // Remember for possible deletion.

  1393       the_clone = x;            // Remember for possible deletion.

  1358       // Alter data node to use pre-phi inputs

  1394       // Alter data node to use pre-phi inputs

  1359       if (this->in(0) == region) {

  1395       if (this->in(0) == region) {

  1360         x->set_req(0, region->in(i));

  1396         x->set_req(0, region->in(i));

  1361       } else {

  1397       } else {

  1362         x->set_req(0, NULL);

  1398         x->set_req(0, NULL);

  1363       }

  1399       }

  1368       }

  1410       }

  1369     }

  1411     }

  1370     // Check for a 'win' on some paths

  1412     // Check for a 'win' on some paths

  1371     const Type *t = x->Value(igvn);

  1413     const Type *t = x->Value(igvn);

  1372 

  1414 

  1392       x->raise_bottom_type(t);

  1434       x->raise_bottom_type(t);

  1393       Node *y = x->Identity(igvn);

  1435       Node *y = x->Identity(igvn);

  1394       if (y != x) {

  1436       if (y != x) {

  1395         x = y;

  1437         x = y;

  1396       } else {

  1438       } else {

  1398         if (y) {

  1440         if (y) {

  1399           x = y;

  1441           x = y;

  1400         } else {

  1442         } else {

  1401           // Else x is a new node we are keeping

  1443           // Else x is a new node we are keeping

  1402           // We do not need register_new_node_with_optimizer

  1444           // We do not need register_new_node_with_optimizer

  1403           // because set_type has already been called.

  1445           // because set_type has already been called.

  1404           igvn->_worklist.push(x);

  1446           igvn->_worklist.push(x);

  1405         }

  1447         }

  1406       }

  1448       }

  1407     }

  1449     }

  1409       igvn->remove_dead_node(the_clone);

  1451       igvn->remove_dead_node(the_clone);

  1410     phi->set_req(i, x);

  1453     phi->set_req(i, x);

  1411   }

  1454   }

  1412   // Record Phi

  1455   // Record Phi

  1413   igvn->register_new_node_with_optimizer(phi);

  1456   igvn->register_new_node_with_optimizer(phi);

  1414   return phi;

  1457   return phi;

  1443         && phase->type(base)->higher_equal(TypePtr::NOTNULL)

  1486         && phase->type(base)->higher_equal(TypePtr::NOTNULL)

  1444         && all_controls_dominate(base, phase->C->start())) {

  1487         && all_controls_dominate(base, phase->C->start())) {

  1445       // A method-invariant, non-null address (constant or 'this' argument).

  1488       // A method-invariant, non-null address (constant or 'this' argument).

  1446       set_req(MemNode::Control, NULL);

  1489       set_req(MemNode::Control, NULL);

  1447     }

  1490     }

  1457   }

  1491   }

  1458 

  1492 

  1459   Node* mem = in(MemNode::Memory);

  1493   Node* mem = in(MemNode::Memory);

  1460   const TypePtr *addr_t = phase->type(address)->isa_ptr();

  1494   const TypePtr *addr_t = phase->type(address)->isa_ptr();

  1461 

  1495 

  1463     // try to optimize our memory input

  1497     // try to optimize our memory input

  1465     if (opt_mem != mem) {

  1499     if (opt_mem != mem) {

  1466       set_req(MemNode::Memory, opt_mem);

  1500       set_req(MemNode::Memory, opt_mem);

  1467       if (phase->type( opt_mem ) == Type::TOP) return NULL;

  1501       if (phase->type( opt_mem ) == Type::TOP) return NULL;

  1468       return this;

  1502       return this;

  1469     }

  1503     }

  1470     const TypeOopPtr *t_oop = addr_t->isa_oopptr();

  1504     const TypeOopPtr *t_oop = addr_t->isa_oopptr();

  1473       PhaseIterGVN *igvn = phase->is_IterGVN();

  1508       PhaseIterGVN *igvn = phase->is_IterGVN();

  1474       if (igvn != NULL && igvn->_worklist.member(opt_mem)) {

  1509       if (igvn != NULL && igvn->_worklist.member(opt_mem)) {

  1475         // Delay this transformation until memory Phi is processed.

  1510         // Delay this transformation until memory Phi is processed.

  1476         phase->is_IterGVN()->_worklist.push(this);

  1511         phase->is_IterGVN()->_worklist.push(this);

  1477         return NULL;

  1512         return NULL;

  1478       }

  1513       }

  1479       // Split instance field load through Phi.

  1514       // Split instance field load through Phi.

  1480       Node* result = split_through_phi(phase);

  1515       Node* result = split_through_phi(phase);

  1481       if (result != NULL) return result;

  1516       if (result != NULL) return result;

  1482     }

  1522     }

  1483   }

  1523   }

  1484 

  1524 

  1485   // Check for prior store with a different base or offset; make Load

  1525   // Check for prior store with a different base or offset; make Load

  1486   // independent.  Skip through any number of them.  Bail out if the stores

  1526   // independent.  Skip through any number of them.  Bail out if the stores

  1585         // In any case, do not allow the join, per se, to empty out the type.

  1625         // In any case, do not allow the join, per se, to empty out the type.

  1586         if (jt->empty() && !t->empty()) {

  1626         if (jt->empty() && !t->empty()) {

  1587           // This can happen if a interface-typed array narrows to a class type.

  1627           // This can happen if a interface-typed array narrows to a class type.

  1588           jt = _type;

  1628           jt = _type;

  1589         }

  1629         }

  1592           // The pointers in the autobox arrays are always non-null

  1632           // The pointers in the autobox arrays are always non-null

  1593           Node* base = adr->in(AddPNode::Base);

  1633           Node* base = adr->in(AddPNode::Base);

  1599             }

  1643             }

  1600           }

  1644           }

  1601         }

  1645         }

  1602         return jt;

  1647         return jt;

  1603       }

  1648       }

  1604     }

  1649     }

  1605   } else if (tp->base() == Type::InstPtr) {

  1650   } else if (tp->base() == Type::InstPtr) {

  1606     ciEnv* env = C->env();

  1651     ciEnv* env = C->env();

  1636       }

  1681       }

  1637     }

  1682     }

  1638     // Optimizations for constant objects

  1683     // Optimizations for constant objects

  1639     ciObject* const_oop = tinst->const_oop();

  1684     ciObject* const_oop = tinst->const_oop();

  1640     if (const_oop != NULL) {

  1685     if (const_oop != NULL) {

  1641       // For constant CallSites treat the target field as a compile time constant.

  1690       // For constant CallSites treat the target field as a compile time constant.

  1642       if (const_oop->is_call_site()) {

  1691       if (const_oop->is_call_site()) {

  1643         ciCallSite* call_site = const_oop->as_call_site();

  1692         ciCallSite* call_site = const_oop->as_call_site();

  1644         ciField* field = call_site->klass()->as_instance_klass()->get_field_by_offset(off, /*is_static=*/ false);

  1693         ciField* field = call_site->klass()->as_instance_klass()->get_field_by_offset(off, /*is_static=*/ false);

  1645         if (field != NULL && field->is_call_site_target()) {

  1694         if (field != NULL && field->is_call_site_target()) {

  1757   // If we are loading from a freshly-allocated object, produce a zero,

  1806   // If we are loading from a freshly-allocated object, produce a zero,

  1758   // if the load is provably beyond the header of the object.

  1807   // if the load is provably beyond the header of the object.

  1759   // (Also allow a variable load from a fresh array to produce zero.)

  1808   // (Also allow a variable load from a fresh array to produce zero.)

  1760   const TypeOopPtr *tinst = tp->isa_oopptr();

  1809   const TypeOopPtr *tinst = tp->isa_oopptr();

  1761   bool is_instance = (tinst != NULL) && tinst->is_known_instance_field();

  1810   bool is_instance = (tinst != NULL) && tinst->is_known_instance_field();

  1763     Node* value = can_see_stored_value(mem,phase);

  1813     Node* value = can_see_stored_value(mem,phase);

  1764     if (value != NULL && value->is_Con()) {

  1814     if (value != NULL && value->is_Con()) {

  1765       assert(value->bottom_type()->higher_equal(_type),"sanity");

  1815       assert(value->bottom_type()->higher_equal(_type),"sanity");

  1766       return value->bottom_type();

  1816       return value->bottom_type();

  1767     }

  1817     }

  2881   if (remove_dead_region(phase, can_reshape)) return this;

  2931   if (remove_dead_region(phase, can_reshape)) return this;

  2882   // Don't bother trying to transform a dead node

  2932   // Don't bother trying to transform a dead node

  2883   if (in(0) && in(0)->is_top())  return NULL;

  2933   if (in(0) && in(0)->is_top())  return NULL;

  2884 

  2934 

  2885   // Eliminate volatile MemBars for scalar replaced objects.

  2935   // Eliminate volatile MemBars for scalar replaced objects.

  2904     }

  2968     }

  2905   }

  2969   }

  2906   return NULL;

  2970   return NULL;

  2907 }

  2971 }

  2908 

  2972 

  3111 // "simple enough" to be folded into an object initialization.

  3175 // "simple enough" to be folded into an object initialization.

  3112 // Attempts to prove that a store's initial value 'n' can be captured

  3176 // Attempts to prove that a store's initial value 'n' can be captured

  3113 // within the initialization without creating a vicious cycle, such as:

  3177 // within the initialization without creating a vicious cycle, such as:

  3114 //     { Foo p = new Foo(); p.next = p; }

  3178 //     { Foo p = new Foo(); p.next = p; }

  3115 // True for constants and parameters and small combinations thereof.

  3179 // True for constants and parameters and small combinations thereof.

  3119   if (n == NULL)      return true;   // (can this really happen?)

  3181   if (n == NULL)      return true;   // (can this really happen?)

  3120   if (n->is_Proj())   n = n->in(0);

  3182   if (n->is_Proj())   n = n->in(0);

  3121   if (n == this)      return false;  // found a cycle

  3183   if (n == this)      return false;  // found a cycle

  3122   if (n->is_Con())    return true;

  3184   if (n->is_Con())    return true;

  3123   if (n->is_Start())  return true;   // params, etc., are OK

  3185   if (n->is_Start())  return true;   // params, etc., are OK

  3133     // must have preceded the init, or else be equal to the init.

  3195     // must have preceded the init, or else be equal to the init.

  3134     // Even after loop optimizations (which might change control edges)

  3196     // Even after loop optimizations (which might change control edges)

  3135     // a store is never pinned *before* the availability of its inputs.

  3197     // a store is never pinned *before* the availability of its inputs.

  3136     if (!MemNode::all_controls_dominate(n, this))

  3198     if (!MemNode::all_controls_dominate(n, this))

  3137       return false;                  // failed to prove a good control

  3199       return false;                  // failed to prove a good control

  3139   }

  3200   }

  3140 

  3201 

  3141   // Check data edges for possible dependencies on 'this'.

  3202   // Check data edges for possible dependencies on 'this'.

  3142   if ((count += 1) > 20)  return false;  // complexity limit

  3203   if ((count += 1) > 20)  return false;  // complexity limit

  3143   for (uint i = 1; i < n->req(); i++) {

  3204   for (uint i = 1; i < n->req(); i++) {

  3144     Node* m = n->in(i);

  3205     Node* m = n->in(i);

  3145     if (m == NULL || m == n || m->is_top())  continue;

  3206     if (m == NULL || m == n || m->is_top())  continue;

  3146     uint first_i = n->find_edge(m);

  3207     uint first_i = n->find_edge(m);

  3147     if (i != first_i)  continue;  // process duplicate edge just once

  3208     if (i != first_i)  continue;  // process duplicate edge just once

  3149       return false;

  3210       return false;

  3150     }

  3211     }

  3151   }

  3212   }

  3152 

  3213 

  3153   return true;

  3214   return true;

  3174     return FAIL;                // inscrutable address

  3235     return FAIL;                // inscrutable address

  3175   if (alloc != allocation())

  3236   if (alloc != allocation())

  3176     return FAIL;                // wrong allocation!  (store needs to float up)

  3237     return FAIL;                // wrong allocation!  (store needs to float up)

  3177   Node* val = st->in(MemNode::ValueIn);

  3238   Node* val = st->in(MemNode::ValueIn);

  3178   int complexity_count = 0;

  3239   int complexity_count = 0;

  3180     return FAIL;                // stored value must be 'simple enough'

  3241     return FAIL;                // stored value must be 'simple enough'

  3181 

  3242 

  3182   // The Store can be captured only if nothing after the allocation

  3243   // The Store can be captured only if nothing after the allocation

  3183   // and before the Store is using the memory location that the store

  3244   // and before the Store is using the memory location that the store

  3184   // overwrites.

  3245   // overwrites.