hotspot/src/share/vm/classfile/classFileParser.hpp
author jiangli
Wed, 28 Dec 2011 12:15:57 -0500
changeset 11412 62fe312f32c5
parent 10546 e79347eebbc5
child 12263 d20640f4f8fe
child 12231 6a9cfc59a18a
permissions -rw-r--r--
7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. Summary: Change instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count to u2 type. Reviewed-by: never, bdelsart, dholmes Contributed-by: Jiangli Zhou <jiangli.zhou@oracle.com>
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8076
diff changeset
     2
 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3821
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3821
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3821
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    25
#ifndef SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    26
#define SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    28
#include "classfile/classFileStream.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    29
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    30
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    31
#include "oops/typeArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    32
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    33
#include "utilities/accessFlags.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    34
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
    35
class TempNewSymbol;
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8883
diff changeset
    36
class FieldAllocationCount;
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8883
diff changeset
    37
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8883
diff changeset
    38
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// Parser for for .class files
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// The bytes describing the class file structure is read from a Stream object
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
class ClassFileParser VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  bool _need_verify;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  bool _relax_verify;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  u2   _major_version;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  u2   _minor_version;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
    49
  Symbol* _class_name;
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1623
diff changeset
    50
  KlassHandle _host_klass;
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    51
  GrowableArray<Handle>* _cp_patches; // overrides for CP entries
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  bool _has_finalizer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  bool _has_empty_finalizer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  bool _has_vanilla_constructor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
    57
  int _max_bootstrap_specifier_index;
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
    58
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  enum { fixed_buffer_size = 128 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  u_char linenumbertable_buffer[fixed_buffer_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  ClassFileStream* _stream;              // Actual input stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  enum { LegalClass, LegalField, LegalMethod }; // used to verify unqualified names
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  // Accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  ClassFileStream* stream()                        { return _stream; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  void set_stream(ClassFileStream* st)             { _stream = st; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  // Constant pool parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  void parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  constantPoolHandle parse_constant_pool(TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  // Interface parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  objArrayHandle parse_interfaces(constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
                                  int length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
                                  Handle class_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
                                  Handle protection_domain,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
    80
                                  Symbol* class_name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
                                  TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // Field parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  void parse_field_attributes(constantPoolHandle cp, u2 attributes_count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
                              bool is_static, u2 signature_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
                              u2* constantvalue_index_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
                              bool* is_synthetic_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
                              u2* generic_signature_index_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
                              typeArrayHandle* field_annotations, TRAPS);
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8883
diff changeset
    90
  typeArrayHandle parse_fields(Symbol* class_name,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8883
diff changeset
    91
                               constantPoolHandle cp, bool is_interface,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8883
diff changeset
    92
                               FieldAllocationCount *fac,
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8883
diff changeset
    93
                               objArrayHandle* fields_annotations,
11412
62fe312f32c5 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type.
jiangli
parents: 10546
diff changeset
    94
                               u2* java_fields_count_ptr, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // Method parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  methodHandle parse_method(constantPoolHandle cp, bool is_interface,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
                            AccessFlags* promoted_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
                            typeArrayHandle* method_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
                            typeArrayHandle* method_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
                            typeArrayHandle* method_default_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
                            TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  objArrayHandle parse_methods (constantPoolHandle cp, bool is_interface,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
                                AccessFlags* promoted_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
                                bool* has_final_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
                                objArrayOop* methods_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
                                objArrayOop* methods_parameter_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
                                objArrayOop* methods_default_annotations_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
                                TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  typeArrayHandle sort_methods (objArrayHandle methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
                                objArrayHandle methods_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
                                objArrayHandle methods_parameter_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
                                objArrayHandle methods_default_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
                                TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  typeArrayHandle parse_exception_table(u4 code_length, u4 exception_table_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
                                        constantPoolHandle cp, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  void parse_linenumber_table(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
      u4 code_attribute_length, u4 code_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
      CompressedLineNumberWriteStream** write_stream, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  u2* parse_localvariable_table(u4 code_length, u2 max_locals, u4 code_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
                                constantPoolHandle cp, u2* localvariable_table_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
                                bool isLVTT, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  u2* parse_checked_exceptions(u2* checked_exceptions_length, u4 method_attribute_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
                               constantPoolHandle cp, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  void parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
                        u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  typeArrayOop parse_stackmap_table(u4 code_attribute_length, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // Classfile attribute parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  void parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  void parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
                                                instanceKlassHandle k, int length, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  u2   parse_classfile_inner_classes_attribute(constantPoolHandle cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
                                               instanceKlassHandle k, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  void parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  void parse_classfile_synthetic_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  void parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS);
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   138
  void parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, instanceKlassHandle k, u4 attribute_length, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  // Annotations handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  typeArrayHandle assemble_annotations(u1* runtime_visible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
                                       int runtime_visible_annotations_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
                                       u1* runtime_invisible_annotations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
                                       int runtime_invisible_annotations_length, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  // Final setup
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   147
  unsigned int compute_oop_map_count(instanceKlassHandle super,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   148
                                     unsigned int nonstatic_oop_count,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   149
                                     int first_nonstatic_oop_offset);
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   150
  void fill_oop_maps(instanceKlassHandle k,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   151
                     unsigned int nonstatic_oop_map_count,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   152
                     int* nonstatic_oop_offsets,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   153
                     unsigned int* nonstatic_oop_counts);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  void set_precomputed_flags(instanceKlassHandle k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  objArrayHandle compute_transitive_interfaces(instanceKlassHandle super,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
                                               objArrayHandle local_ifs, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // Format checker methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  void classfile_parse_error(const char* msg, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  void classfile_parse_error(const char* msg, int index, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  void classfile_parse_error(const char* msg, const char *name, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  void classfile_parse_error(const char* msg, int index, const char *name, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  inline void guarantee_property(bool b, const char* msg, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    if (!b) { classfile_parse_error(msg, CHECK); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  inline void assert_property(bool b, const char* msg, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    if (!b) { fatal(msg); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  inline void check_property(bool property, const char* msg, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
    if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
      guarantee_property(property, msg, index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
      assert_property(property, msg, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  inline void check_property(bool property, const char* msg, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
    if (_need_verify) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      guarantee_property(property, msg, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
      assert_property(property, msg, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  inline void guarantee_property(bool b, const char* msg, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    if (!b) { classfile_parse_error(msg, index, CHECK); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  inline void guarantee_property(bool b, const char* msg, const char *name, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    if (!b) { classfile_parse_error(msg, name, CHECK); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  inline void guarantee_property(bool b, const char* msg, int index, const char *name, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    if (!b) { classfile_parse_error(msg, index, name, CHECK); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 3821
diff changeset
   199
  void throwIllegalSignature(
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   200
      const char* type, Symbol* name, Symbol* sig, TRAPS);
5709
3b5307e27c1d 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents: 3821
diff changeset
   201
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  bool is_supported_version(u2 major, u2 minor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  bool has_illegal_visibility(jint flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  void verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  void verify_legal_utf8(const unsigned char* buffer, int length, TRAPS);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   207
  void verify_legal_class_name(Symbol* name, TRAPS);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   208
  void verify_legal_field_name(Symbol* name, TRAPS);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   209
  void verify_legal_method_name(Symbol* name, TRAPS);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   210
  void verify_legal_field_signature(Symbol* fieldname, Symbol* signature, TRAPS);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   211
  int  verify_legal_method_signature(Symbol* methodname, Symbol* signature, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  void verify_legal_class_modifiers(jint flags, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  void verify_legal_field_modifiers(jint flags, bool is_interface, TRAPS);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   214
  void verify_legal_method_modifiers(jint flags, bool is_interface, Symbol* name, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  bool verify_unqualified_name(char* name, unsigned int length, int type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  char* skip_over_field_name(char* name, bool slash_ok, unsigned int length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  char* skip_over_field_signature(char* signature, bool void_ok, unsigned int length, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1623
diff changeset
   219
  bool is_anonymous() {
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   220
    assert(EnableInvokeDynamic || _host_klass.is_null(), "");
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1623
diff changeset
   221
    return _host_klass.not_null();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1623
diff changeset
   222
  }
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   223
  bool has_cp_patch_at(int index) {
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   224
    assert(EnableInvokeDynamic, "");
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   225
    assert(index >= 0, "oob");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   226
    return (_cp_patches != NULL
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   227
            && index < _cp_patches->length()
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   228
            && _cp_patches->adr_at(index)->not_null());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   229
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   230
  Handle cp_patch_at(int index) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   231
    assert(has_cp_patch_at(index), "oob");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   232
    return _cp_patches->at(index);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   233
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   234
  Handle clear_cp_patch_at(int index) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   235
    Handle patch = cp_patch_at(index);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   236
    _cp_patches->at_put(index, Handle());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   237
    assert(!has_cp_patch_at(index), "");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   238
    return patch;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   239
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   240
  void patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   241
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   242
  // Wrapper for constantTag.is_klass_[or_]reference.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   243
  // In older versions of the VM, klassOops cannot sneak into early phases of
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   244
  // constant pool construction, but in later versions they can.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   245
  // %%% Let's phase out the old is_klass_reference.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   246
  bool is_klass_reference(constantPoolHandle cp, int index) {
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8725
diff changeset
   247
    return ((LinkWellKnownClasses || EnableInvokeDynamic)
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   248
            ? cp->tag_at(index).is_klass_or_reference()
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   249
            : cp->tag_at(index).is_klass_reference());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   250
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   251
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  ClassFileParser(ClassFileStream* st) { set_stream(st); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  // Parse .class file and return new klassOop. The klassOop is not hooked up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  // to the system dictionary or any other structures, so a .class file can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // be loaded several times if desired.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // The system dictionary hookup is done by the caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  // "parsed_name" is updated by this method, and is the name found
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  // while parsing the stream.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   263
  instanceKlassHandle parseClassFile(Symbol* name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
                                     Handle class_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
                                     Handle protection_domain,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   266
                                     TempNewSymbol& parsed_name,
3820
0a8fbbe180db 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 3575
diff changeset
   267
                                     bool verify,
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   268
                                     TRAPS) {
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1623
diff changeset
   269
    KlassHandle no_host_klass;
3820
0a8fbbe180db 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 3575
diff changeset
   270
    return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   271
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   272
  instanceKlassHandle parseClassFile(Symbol* name,
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   273
                                     Handle class_loader,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   274
                                     Handle protection_domain,
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 1623
diff changeset
   275
                                     KlassHandle host_klass,
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   276
                                     GrowableArray<Handle>* cp_patches,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7436
diff changeset
   277
                                     TempNewSymbol& parsed_name,
3820
0a8fbbe180db 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 3575
diff changeset
   278
                                     bool verify,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
                                     TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  // Verifier checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  static void check_super_class_access(instanceKlassHandle this_klass, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  static void check_super_interface_access(instanceKlassHandle this_klass, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  static void check_final_method_override(instanceKlassHandle this_klass, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  static void check_illegal_static_method(instanceKlassHandle this_klass, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
   287
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
   288
#endif // SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP