7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "opto/callnode.hpp"

  27 #include "opto/matcher.hpp"
  28 #include "opto/mathexactnode.hpp"
  29 #include "opto/multnode.hpp"
  30 #include "opto/opcodes.hpp"
  31 #include "opto/phaseX.hpp"
  32 #include "opto/regmask.hpp"
  33 #include "opto/type.hpp"
  34 
  35 //=============================================================================
  36 //------------------------------MultiNode--------------------------------------
  37 const RegMask &MultiNode::out_RegMask() const {
  38   return RegMask::Empty;
  39 }
  40 
  41 Node *MultiNode::match( const ProjNode *proj, const Matcher *m ) { return proj->clone(); }
  42 
  43 //------------------------------proj_out---------------------------------------
  44 // Get a named projection
  45 ProjNode* MultiNode::proj_out(uint which_proj) const {
  46   assert(Opcode() != Op_If || which_proj == (uint)true || which_proj == (uint)false, "must be 1 or 0");

 132   const Type* t = n->bottom_type();
 133   if (t == Type::TOP)  return;  // multi is dead
 134   assert(_con < t->is_tuple()->cnt(), "ProjNode::_con must be in range");
 135 }
 136 
 137 //------------------------------Value------------------------------------------
 138 const Type *ProjNode::Value( PhaseTransform *phase ) const {
 139   if (in(0) == NULL) return Type::TOP;
 140   return proj_type(phase->type(in(0)));
 141 }
 142 
 143 //------------------------------out_RegMask------------------------------------
 144 // Pass the buck uphill
 145 const RegMask &ProjNode::out_RegMask() const {
 146   return RegMask::Empty;
 147 }
 148 
 149 //------------------------------ideal_reg--------------------------------------
 150 uint ProjNode::ideal_reg() const {
 151   return bottom_type()->ideal_reg();
























































 152 }

   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "opto/callnode.hpp"
  27 #include "opto/cfgnode.hpp"
  28 #include "opto/matcher.hpp"
  29 #include "opto/mathexactnode.hpp"
  30 #include "opto/multnode.hpp"
  31 #include "opto/opcodes.hpp"
  32 #include "opto/phaseX.hpp"
  33 #include "opto/regmask.hpp"
  34 #include "opto/type.hpp"
  35 
  36 //=============================================================================
  37 //------------------------------MultiNode--------------------------------------
  38 const RegMask &MultiNode::out_RegMask() const {
  39   return RegMask::Empty;
  40 }
  41 
  42 Node *MultiNode::match( const ProjNode *proj, const Matcher *m ) { return proj->clone(); }
  43 
  44 //------------------------------proj_out---------------------------------------
  45 // Get a named projection
  46 ProjNode* MultiNode::proj_out(uint which_proj) const {
  47   assert(Opcode() != Op_If || which_proj == (uint)true || which_proj == (uint)false, "must be 1 or 0");

 133   const Type* t = n->bottom_type();
 134   if (t == Type::TOP)  return;  // multi is dead
 135   assert(_con < t->is_tuple()->cnt(), "ProjNode::_con must be in range");
 136 }
 137 
 138 //------------------------------Value------------------------------------------
 139 const Type *ProjNode::Value( PhaseTransform *phase ) const {
 140   if (in(0) == NULL) return Type::TOP;
 141   return proj_type(phase->type(in(0)));
 142 }
 143 
 144 //------------------------------out_RegMask------------------------------------
 145 // Pass the buck uphill
 146 const RegMask &ProjNode::out_RegMask() const {
 147   return RegMask::Empty;
 148 }
 149 
 150 //------------------------------ideal_reg--------------------------------------
 151 uint ProjNode::ideal_reg() const {
 152   return bottom_type()->ideal_reg();
 153 }
 154 
 155 //-------------------------------is_uncommon_trap_proj----------------------------
 156 // Return true if proj is the form of "proj->[region->..]call_uct"
 157 bool ProjNode::is_uncommon_trap_proj(Deoptimization::DeoptReason reason) {
 158   int path_limit = 10;
 159   Node* out = this;
 160   for (int ct = 0; ct < path_limit; ct++) {
 161     out = out->unique_ctrl_out();
 162     if (out == NULL)
 163       return false;
 164     if (out->is_CallStaticJava()) {
 165       int req = out->as_CallStaticJava()->uncommon_trap_request();
 166       if (req != 0) {
 167         Deoptimization::DeoptReason trap_reason = Deoptimization::trap_request_reason(req);
 168         if (trap_reason == reason || reason == Deoptimization::Reason_none) {
 169            return true;
 170         }
 171       }
 172       return false; // don't do further after call
 173     }
 174     if (out->Opcode() != Op_Region)
 175       return false;
 176   }
 177   return false;
 178 }
 179 
 180 //-------------------------------is_uncommon_trap_if_pattern-------------------------
 181 // Return true  for "if(test)-> proj -> ...
 182 //                          |
 183 //                          V
 184 //                      other_proj->[region->..]call_uct"
 185 //
 186 // "must_reason_predicate" means the uct reason must be Reason_predicate
 187 bool ProjNode::is_uncommon_trap_if_pattern(Deoptimization::DeoptReason reason) {
 188   Node *in0 = in(0);
 189   if (!in0->is_If()) return false;
 190   // Variation of a dead If node.
 191   if (in0->outcnt() < 2)  return false;
 192   IfNode* iff = in0->as_If();
 193 
 194   // we need "If(Conv2B(Opaque1(...)))" pattern for reason_predicate
 195   if (reason != Deoptimization::Reason_none) {
 196     if (iff->in(1)->Opcode() != Op_Conv2B ||
 197        iff->in(1)->in(1)->Opcode() != Op_Opaque1) {
 198       return false;
 199     }
 200   }
 201 
 202   ProjNode* other_proj = iff->proj_out(1-_con)->as_Proj();
 203   if (other_proj->is_uncommon_trap_proj(reason)) {
 204     assert(reason == Deoptimization::Reason_none ||
 205            Compile::current()->is_predicate_opaq(iff->in(1)->in(1)), "should be on the list");
 206     return true;
 207   }
 208   return false;
 209 }