--- old/src/share/vm/ci/ciSignature.cpp
          +++ new/src/share/vm/ci/ciSignature.cpp

   1    1  /*
   2    2   * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.
   8    8   *
   9    9   * This code is distributed in the hope that it will be useful, but WITHOUT
  10   10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12   12   * version 2 for more details (a copy is included in the LICENSE file that
  13   13   * accompanied this code).
  14   14   *
  15   15   * You should have received a copy of the GNU General Public License version
  16   16   * 2 along with this work; if not, write to the Free Software Foundation,
  17   17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18   18   *
  19   19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20   20   * or visit www.oracle.com if you need additional information or have any
  21   21   * questions.
  22   22   *
  23   23   */
  24   24  
  25   25  #include "precompiled.hpp"
  26   26  #include "ci/ciSignature.hpp"
  27   27  #include "ci/ciUtilities.hpp"
  28   28  #include "memory/allocation.inline.hpp"
  29   29  #include "oops/oop.inline.hpp"
  30   30  #include "runtime/signature.hpp"
  31   31  
  32   32  // ciSignature
  33   33  //
  34   34  // This class represents the signature of a method.
  35   35  
  36   36  // ------------------------------------------------------------------
  37   37  // ciSignature::ciSignature
  38   38  ciSignature::ciSignature(ciKlass* accessing_klass, constantPoolHandle cpool, ciSymbol* symbol) {
  39   39    ASSERT_IN_VM;
  40   40    EXCEPTION_CONTEXT;
  41   41    _accessing_klass = accessing_klass;
  42   42    _symbol = symbol;
  43   43  
  44   44    ciEnv* env = CURRENT_ENV;
  45   45    Arena* arena = env->arena();
  46   46    _types = new (arena) GrowableArray<ciType*>(arena, 8, 0, NULL);
  47   47  
  48   48    int size = 0;
  49   49    int count = 0;
  50   50    ResourceMark rm(THREAD);
  51   51    Symbol* sh = symbol->get_symbol();
  52   52    SignatureStream ss(sh);
  53   53    for (; ; ss.next()) {
  54   54      // Process one element of the signature
  55   55      ciType* type;
  56   56      if (!ss.is_object()) {
  57   57        type = ciType::make(ss.type());
  58   58      } else {
  59   59        Symbol* name = ss.as_symbol(THREAD);
  60   60        if (HAS_PENDING_EXCEPTION) {
  61   61          type = ss.is_array() ? (ciType*)ciEnv::unloaded_ciobjarrayklass()
  62   62            : (ciType*)ciEnv::unloaded_ciinstance_klass();
  63   63          env->record_out_of_memory_failure();
  64   64          CLEAR_PENDING_EXCEPTION;
  65   65        } else {
  66   66          ciSymbol* klass_name = env->get_symbol(name);
  67   67          type = env->get_klass_by_name_impl(_accessing_klass, cpool, klass_name, false);
  68   68        }
  69   69      }
  70   70      _types->append(type);
  71   71      if (ss.at_return_type()) {
  72   72        // Done processing the return type; do not add it into the count.

  73   73        break;
  74   74      }
  75   75      size += type->size();
  76   76      count++;
  77   77    }
  78   78    _size = size;
  79   79    _count = count;
  80   80  }
  81   81  
  82   82  // ------------------------------------------------------------------
  83      -// ciSignature::return_ciType
       83 +// ciSignature::return_type
  84   84  //
  85   85  // What is the return type of this signature?
  86   86  ciType* ciSignature::return_type() const {
  87   87    return _types->at(_count);
  88   88  }
  89   89  
  90   90  // ------------------------------------------------------------------
  91      -// ciSignature::ciType_at
       91 +// ciSignature::type_at
  92   92  //
  93   93  // What is the type of the index'th element of this
  94   94  // signature?
  95   95  ciType* ciSignature::type_at(int index) const {
  96   96    assert(index < _count, "out of bounds");
  97   97    // The first _klasses element holds the return klass.
  98   98    return _types->at(index);
  99   99  }
 100  100  
 101  101  // ------------------------------------------------------------------
      102 +// ciSignature::equals
      103 +//
      104 +// Compare this signature to another one.  Signatures with different
      105 +// accessing classes but with signature-types resolved to the same
      106 +// types are defined to be equal.
      107 +bool ciSignature::equals(ciSignature* that) {
      108 +  // Compare signature
      109 +  if (!this->as_symbol()->equals(that->as_symbol()))  return false;
      110 +  // Compare all types of the arguments
      111 +  for (int i = 0; i < _count; i++) {
      112 +    if (this->type_at(i) != that->type_at(i))         return false;
      113 +  }
      114 +  // Compare the return type
      115 +  if (this->return_type() != that->return_type())     return false;
      116 +  return true;
      117 +}
      118 +
      119 +// ------------------------------------------------------------------
 102  120  // ciSignature::print_signature
 103  121  void ciSignature::print_signature() {
 104  122    _symbol->print_symbol();
 105  123  }
 106  124  
 107  125  // ------------------------------------------------------------------
 108  126  // ciSignature::print
 109  127  void ciSignature::print() {
 110  128    tty->print("<ciSignature symbol=");
 111  129    print_signature();
 112  130   tty->print(" accessing_klass=");
 113  131    _accessing_klass->print();
 114  132    tty->print(" address=0x%x>", (address)this);
 115  133  }
    

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX