1 /*
   2  * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   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 "oops/oop.inline.hpp"
  27 #include "oops/symbol.hpp"
  28 #include "prims/methodComparator.hpp"
  29 #include "runtime/handles.inline.hpp"
  30 #include "utilities/globalDefinitions.hpp"
  31 
  32 BytecodeStream *MethodComparator::_s_old;
  33 BytecodeStream *MethodComparator::_s_new;
  34 ConstantPool* MethodComparator::_old_cp;
  35 ConstantPool* MethodComparator::_new_cp;
  36 
  37 bool MethodComparator::methods_EMCP(Method* old_method, Method* new_method) {
  38   if (old_method->code_size() != new_method->code_size())
  39     return false;
  40   if (check_stack_and_locals_size(old_method, new_method) != 0) {
  41     if (log_is_enabled(Debug, redefine, class, methodcomparator)) {
  42       ResourceMark rm;
  43       log_debug(redefine, class, methodcomparator)
  44         ("Methods %s non-comparable with diagnosis %d",
  45          old_method->name()->as_C_string(), check_stack_and_locals_size(old_method, new_method));
  46     }
  47     return false;
  48   }
  49 
  50   _old_cp = old_method->constants();
  51   _new_cp = new_method->constants();
  52   BytecodeStream s_old(old_method);
  53   BytecodeStream s_new(new_method);
  54   _s_old = &s_old;
  55   _s_new = &s_new;
  56   Bytecodes::Code c_old, c_new;
  57 
  58   while ((c_old = s_old.next()) >= 0) {
  59     if ((c_new = s_new.next()) < 0 || c_old != c_new)
  60       return false;
  61 
  62     if (! args_same(c_old, c_new))
  63       return false;
  64   }
  65   return true;
  66 }
  67 
  68 bool MethodComparator::args_same(Bytecodes::Code c_old, Bytecodes::Code c_new) {
  69   // BytecodeStream returns the correct standard Java bytecodes for various "fast"
  70   // bytecode versions, so we don't have to bother about them here..
  71   switch (c_old) {
  72   case Bytecodes::_new            : // fall through
  73   case Bytecodes::_anewarray      : // fall through
  74   case Bytecodes::_multianewarray : // fall through
  75   case Bytecodes::_checkcast      : // fall through
  76   case Bytecodes::_instanceof     : {
  77     u2 cpi_old = _s_old->get_index_u2();
  78     u2 cpi_new = _s_new->get_index_u2();
  79     if ((_old_cp->klass_at_noresolve(cpi_old) != _new_cp->klass_at_noresolve(cpi_new)))
  80         return false;
  81     if (c_old == Bytecodes::_multianewarray &&
  82         *(jbyte*)(_s_old->bcp() + 3) != *(jbyte*)(_s_new->bcp() + 3))
  83       return false;
  84     break;
  85   }
  86 
  87   case Bytecodes::_getstatic       : // fall through
  88   case Bytecodes::_putstatic       : // fall through
  89   case Bytecodes::_getfield        : // fall through
  90   case Bytecodes::_putfield        : // fall through
  91   case Bytecodes::_invokevirtual   : // fall through
  92   case Bytecodes::_invokespecial   : // fall through
  93   case Bytecodes::_invokestatic    : // fall through
  94   case Bytecodes::_invokeinterface : {
  95     int cpci_old = _s_old->get_index_u2_cpcache();
  96     int cpci_new = _s_new->get_index_u2_cpcache();
  97     // Check if the names of classes, field/method names and signatures at these indexes
  98     // are the same. Indices which are really into constantpool cache (rather than constant
  99     // pool itself) are accepted by the constantpool query routines below.
 100     if ((_old_cp->klass_ref_at_noresolve(cpci_old) != _new_cp->klass_ref_at_noresolve(cpci_new)) ||
 101         (_old_cp->name_ref_at(cpci_old) != _new_cp->name_ref_at(cpci_new)) ||
 102         (_old_cp->signature_ref_at(cpci_old) != _new_cp->signature_ref_at(cpci_new)))
 103       return false;
 104     break;
 105   }
 106   case Bytecodes::_invokedynamic: {
 107     int cpci_old = _s_old->get_index_u4();
 108     int cpci_new = _s_new->get_index_u4();
 109 
 110     // Check if the names of classes, field/method names and signatures at these indexes
 111     // are the same. Indices which are really into constantpool cache (rather than constant
 112     // pool itself) are accepted by the constantpool query routines below.
 113     if ((_old_cp->name_ref_at(cpci_old) != _new_cp->name_ref_at(cpci_new)) ||
 114         (_old_cp->signature_ref_at(cpci_old) != _new_cp->signature_ref_at(cpci_new)))
 115       return false;
 116 
 117     // Translate object indexes to constant pool cache indexes.
 118     cpci_old = _old_cp->invokedynamic_cp_cache_index(cpci_old);
 119     cpci_new = _new_cp->invokedynamic_cp_cache_index(cpci_new);
 120 
 121     int cpi_old = _old_cp->cache()->entry_at(cpci_old)->constant_pool_index();
 122     int cpi_new = _new_cp->cache()->entry_at(cpci_new)->constant_pool_index();
 123     int bsm_old = _old_cp->invoke_dynamic_bootstrap_method_ref_index_at(cpi_old);
 124     int bsm_new = _new_cp->invoke_dynamic_bootstrap_method_ref_index_at(cpi_new);
 125     if (!pool_constants_same(bsm_old, bsm_new))
 126       return false;
 127     int cnt_old = _old_cp->invoke_dynamic_argument_count_at(cpi_old);
 128     int cnt_new = _new_cp->invoke_dynamic_argument_count_at(cpi_new);
 129     if (cnt_old != cnt_new)
 130       return false;
 131     for (int arg_i = 0; arg_i < cnt_old; arg_i++) {
 132       int idx_old = _old_cp->invoke_dynamic_argument_index_at(cpi_old, arg_i);
 133       int idx_new = _new_cp->invoke_dynamic_argument_index_at(cpi_new, arg_i);
 134       if (!pool_constants_same(idx_old, idx_new))
 135         return false;
 136     }
 137     break;
 138   }
 139 
 140   case Bytecodes::_ldc   : // fall through
 141   case Bytecodes::_ldc_w : {
 142     Bytecode_loadconstant ldc_old(_s_old->method(), _s_old->bci());
 143     Bytecode_loadconstant ldc_new(_s_new->method(), _s_new->bci());
 144     int cpi_old = ldc_old.pool_index();
 145     int cpi_new = ldc_new.pool_index();
 146     if (!pool_constants_same(cpi_old, cpi_new))
 147       return false;
 148     break;
 149   }
 150 
 151   case Bytecodes::_ldc2_w : {
 152     u2 cpi_old = _s_old->get_index_u2();
 153     u2 cpi_new = _s_new->get_index_u2();
 154     constantTag tag_old = _old_cp->tag_at(cpi_old);
 155     constantTag tag_new = _new_cp->tag_at(cpi_new);
 156     if (tag_old.value() != tag_new.value())
 157       return false;
 158     if (tag_old.is_long()) {
 159       if (_old_cp->long_at(cpi_old) != _new_cp->long_at(cpi_new))
 160         return false;
 161     } else {
 162       // Use jlong_cast to compare the bits rather than numerical values.
 163       // This makes a difference for NaN constants.
 164       if (jlong_cast(_old_cp->double_at(cpi_old)) != jlong_cast(_new_cp->double_at(cpi_new)))
 165         return false;
 166     }
 167     break;
 168   }
 169 
 170   case Bytecodes::_bipush :
 171     if (_s_old->bcp()[1] != _s_new->bcp()[1])
 172       return false;
 173     break;
 174 
 175   case Bytecodes::_sipush    :
 176     if (_s_old->get_index_u2() != _s_new->get_index_u2())
 177       return false;
 178     break;
 179 
 180   case Bytecodes::_aload  : // fall through
 181   case Bytecodes::_astore : // fall through
 182   case Bytecodes::_dload  : // fall through
 183   case Bytecodes::_dstore : // fall through
 184   case Bytecodes::_fload  : // fall through
 185   case Bytecodes::_fstore : // fall through
 186   case Bytecodes::_iload  : // fall through
 187   case Bytecodes::_istore : // fall through
 188   case Bytecodes::_lload  : // fall through
 189   case Bytecodes::_lstore : // fall through
 190   case Bytecodes::_ret    :
 191     if (_s_old->is_wide() != _s_new->is_wide())
 192       return false;
 193     if (_s_old->get_index() != _s_new->get_index())
 194       return false;
 195     break;
 196 
 197   case Bytecodes::_goto      : // fall through
 198   case Bytecodes::_if_acmpeq : // fall through
 199   case Bytecodes::_if_acmpne : // fall through
 200   case Bytecodes::_if_icmpeq : // fall through
 201   case Bytecodes::_if_icmpne : // fall through
 202   case Bytecodes::_if_icmplt : // fall through
 203   case Bytecodes::_if_icmpge : // fall through
 204   case Bytecodes::_if_icmpgt : // fall through
 205   case Bytecodes::_if_icmple : // fall through
 206   case Bytecodes::_ifeq      : // fall through
 207   case Bytecodes::_ifne      : // fall through
 208   case Bytecodes::_iflt      : // fall through
 209   case Bytecodes::_ifge      : // fall through
 210   case Bytecodes::_ifgt      : // fall through
 211   case Bytecodes::_ifle      : // fall through
 212   case Bytecodes::_ifnonnull : // fall through
 213   case Bytecodes::_ifnull    : // fall through
 214   case Bytecodes::_jsr       : {
 215     int old_ofs = _s_old->bytecode().get_offset_s2(c_old);
 216     int new_ofs = _s_new->bytecode().get_offset_s2(c_new);
 217     if (old_ofs != new_ofs)
 218       return false;
 219     break;
 220   }
 221 
 222   case Bytecodes::_iinc :
 223     if (_s_old->is_wide() != _s_new->is_wide())
 224       return false;
 225     if (! _s_old->is_wide()) {
 226       // We could use get_index_u1 and get_constant_u1, but it's simpler to grab both bytes at once:
 227       if (Bytes::get_Java_u2(_s_old->bcp() + 1) != Bytes::get_Java_u2(_s_new->bcp() + 1))
 228         return false;
 229     } else {
 230       // We could use get_index_u2 and get_constant_u2, but it's simpler to grab all four bytes at once:
 231       if (Bytes::get_Java_u4(_s_old->bcp() + 1) != Bytes::get_Java_u4(_s_new->bcp() + 1))
 232         return false;
 233     }
 234     break;
 235 
 236   case Bytecodes::_goto_w : // fall through
 237   case Bytecodes::_jsr_w  : {
 238     int old_ofs = _s_old->bytecode().get_offset_s4(c_old);
 239     int new_ofs = _s_new->bytecode().get_offset_s4(c_new);
 240     if (old_ofs != new_ofs)
 241       return false;
 242     break;
 243   }
 244 
 245   case Bytecodes::_lookupswitch : // fall through
 246   case Bytecodes::_tableswitch  : {
 247     int len_old = _s_old->instruction_size();
 248     int len_new = _s_new->instruction_size();
 249     if (len_old != len_new)
 250       return false;
 251     if (memcmp(_s_old->bcp(), _s_new->bcp(), len_old) != 0)
 252       return false;
 253     break;
 254   }
 255   }
 256 
 257   return true;
 258 }
 259 
 260 bool MethodComparator::pool_constants_same(int cpi_old, int cpi_new) {
 261   constantTag tag_old = _old_cp->tag_at(cpi_old);
 262   constantTag tag_new = _new_cp->tag_at(cpi_new);
 263   if (tag_old.is_int() || tag_old.is_float()) {
 264     if (tag_old.value() != tag_new.value())
 265       return false;
 266     if (tag_old.is_int()) {
 267       if (_old_cp->int_at(cpi_old) != _new_cp->int_at(cpi_new))
 268         return false;
 269     } else {
 270       // Use jint_cast to compare the bits rather than numerical values.
 271       // This makes a difference for NaN constants.
 272       if (jint_cast(_old_cp->float_at(cpi_old)) != jint_cast(_new_cp->float_at(cpi_new)))
 273         return false;
 274     }
 275   } else if (tag_old.is_string() && tag_new.is_string()) {
 276     if (strcmp(_old_cp->string_at_noresolve(cpi_old),
 277                _new_cp->string_at_noresolve(cpi_new)) != 0)
 278       return false;
 279     if (_old_cp->is_pseudo_string_at(cpi_old) || _new_cp->is_pseudo_string_at(cpi_new))
 280       return (_old_cp->is_pseudo_string_at(cpi_old) == _new_cp->is_pseudo_string_at(cpi_new));
 281   } else if (tag_old.is_klass() || tag_old.is_unresolved_klass()) {
 282     // tag_old should be klass - 4881222
 283     if (! (tag_new.is_unresolved_klass() || tag_new.is_klass()))
 284       return false;
 285     if (_old_cp->klass_at_noresolve(cpi_old) !=
 286         _new_cp->klass_at_noresolve(cpi_new))
 287       return false;
 288   } else if (tag_old.is_method_type() && tag_new.is_method_type()) {
 289     int mti_old = _old_cp->method_type_index_at(cpi_old);
 290     int mti_new = _new_cp->method_type_index_at(cpi_new);
 291     if ((_old_cp->symbol_at(mti_old) != _new_cp->symbol_at(mti_new)))
 292       return false;
 293   } else if (tag_old.is_method_handle() && tag_new.is_method_handle()) {
 294     if (_old_cp->method_handle_ref_kind_at(cpi_old) !=
 295         _new_cp->method_handle_ref_kind_at(cpi_new))
 296       return false;
 297     int mhi_old = _old_cp->method_handle_index_at(cpi_old);
 298     int mhi_new = _new_cp->method_handle_index_at(cpi_new);
 299     if ((_old_cp->uncached_klass_ref_at_noresolve(mhi_old) != _new_cp->uncached_klass_ref_at_noresolve(mhi_new)) ||
 300         (_old_cp->uncached_name_ref_at(mhi_old) != _new_cp->uncached_name_ref_at(mhi_new)) ||
 301         (_old_cp->uncached_signature_ref_at(mhi_old) != _new_cp->uncached_signature_ref_at(mhi_new)))
 302       return false;
 303   } else {
 304     return false;  // unknown tag
 305   }
 306   return true;
 307 }
 308 
 309 
 310 int MethodComparator::check_stack_and_locals_size(Method* old_method, Method* new_method) {
 311   if (old_method->max_stack() != new_method->max_stack()) {
 312     return 1;
 313   } else if (old_method->max_locals() != new_method->max_locals()) {
 314     return 2;
 315   } else if (old_method->size_of_parameters() != new_method->size_of_parameters()) {
 316     return 3;
 317   } else return 0;
 318 }