rev 1026 : imported patch indy.compiler.inline.patch

          --- old/src/share/vm/utilities/constantTag.hpp
          +++ new/src/share/vm/utilities/constantTag.hpp

   1    1  /*
   2    2   * Copyright 1997-2008 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  20   20   * CA 95054 USA or visit www.sun.com if you need additional information or
  21   21   * have any questions.
  22   22   *
  23   23   */
  24   24  
  25   25  // constant tags in Java .class files
  26   26  
  27   27  
  28   28  enum {

  29   29    // See jvm.h for shared JVM_CONSTANT_XXX tags
  30   30    // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/utilities/ConstantTag.java
  31   31    // Hotspot specific tags
  32   32    JVM_CONSTANT_Invalid                  = 0,    // For bad value initialization
  33   33    JVM_CONSTANT_InternalMin              = 100,  // First implementation tag (aside from bad value of course)
  34   34    JVM_CONSTANT_UnresolvedClass          = 100,  // Temporary tag until actual use
  35   35    JVM_CONSTANT_ClassIndex               = 101,  // Temporary tag while constructing constant pool
  36   36    JVM_CONSTANT_UnresolvedString         = 102,  // Temporary tag until actual use
  37   37    JVM_CONSTANT_StringIndex              = 103,  // Temporary tag while constructing constant pool
  38   38    JVM_CONSTANT_UnresolvedClassInError   = 104,  // Error tag due to resolution error
  39      -  JVM_CONSTANT_InternalMax              = 104   // Last implementation tag
       39 +  JVM_CONSTANT_Object                   = 105,  // Required for BoundMethodHandle arguments.
       40 +  JVM_CONSTANT_InternalMax              = 105   // Last implementation tag
  40   41  };
  41   42  
  42   43  
  43   44  class constantTag VALUE_OBJ_CLASS_SPEC {
  44   45   private:
  45   46    jbyte _tag;
  46   47   public:
  47   48    bool is_klass() const             { return _tag == JVM_CONSTANT_Class; }
  48   49    bool is_field () const            { return _tag == JVM_CONSTANT_Fieldref; }
  49   50    bool is_method() const            { return _tag == JVM_CONSTANT_Methodref; }

  50   51    bool is_interface_method() const  { return _tag == JVM_CONSTANT_InterfaceMethodref; }
  51   52    bool is_string() const            { return _tag == JVM_CONSTANT_String; }
  52   53    bool is_int() const               { return _tag == JVM_CONSTANT_Integer; }
  53   54    bool is_float() const             { return _tag == JVM_CONSTANT_Float; }
  54   55    bool is_long() const              { return _tag == JVM_CONSTANT_Long; }
  55   56    bool is_double() const            { return _tag == JVM_CONSTANT_Double; }
  56   57    bool is_name_and_type() const     { return _tag == JVM_CONSTANT_NameAndType; }
  57   58    bool is_utf8() const              { return _tag == JVM_CONSTANT_Utf8; }
  58   59  
  59   60    bool is_invalid() const           { return _tag == JVM_CONSTANT_Invalid; }
  60   61  
  61   62    bool is_unresolved_klass() const {
  62   63      return _tag == JVM_CONSTANT_UnresolvedClass || _tag == JVM_CONSTANT_UnresolvedClassInError;

  63   64    }
  64   65  
  65   66    bool is_unresolved_klass_in_error() const {
  66   67      return _tag == JVM_CONSTANT_UnresolvedClassInError;
  67   68    }
  68   69  
  69   70    bool is_klass_index() const       { return _tag == JVM_CONSTANT_ClassIndex; }
  70   71    bool is_unresolved_string() const { return _tag == JVM_CONSTANT_UnresolvedString; }
  71   72    bool is_string_index() const      { return _tag == JVM_CONSTANT_StringIndex; }
  72   73  
       74 +  bool is_object() const            { return _tag == JVM_CONSTANT_Object; }
       75 +
  73   76    bool is_klass_reference() const   { return is_klass_index() || is_unresolved_klass(); }
  74   77    bool is_klass_or_reference() const{ return is_klass() || is_klass_reference(); }
  75   78    bool is_field_or_method() const   { return is_field() || is_method() || is_interface_method(); }
  76   79    bool is_symbol() const            { return is_utf8(); }
  77   80  
  78   81    constantTag(jbyte tag) {
  79   82      assert((tag >= 0 && tag <= JVM_CONSTANT_NameAndType) ||
  80   83             (tag >= JVM_CONSTANT_InternalMin && tag <= JVM_CONSTANT_InternalMax), "Invalid constant tag");
  81   84      _tag = tag;
  82   85    }
  83   86  
  84   87    jbyte value()                      { return _tag; }
  85   88  
  86   89    void print_on(outputStream* st) const PRODUCT_RETURN;
  87   90  };
    

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX