truffle: src/share/vm/classfile/classFileParser.hpp annotate

annotate src/share/vm/classfile/classFileParser.hpp @ 6972:bd7a7ce2e264

6830717: replay of compilations would help with debugging Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method. Reviewed-by: kvn, twisti, sspitsyn Contributed-by: yumin.qi@oracle.com

author	minqi
date	Mon, 12 Nov 2012 14:03:53 -0800
parents	4735d2c84362
children	90273fc0a981

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4744 diff changeset	2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 974 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 974 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 974 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	25 #ifndef SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	26 #define SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	28 #include "classfile/classFileStream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	29 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	30 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	31 #include "oops/typeArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	32 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	33 #include "utilities/accessFlags.hpp"
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	34 #include "classfile/symbolTable.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	35
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 2416 diff changeset	36 class FieldAllocationCount;
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 2416 diff changeset	37
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 2416 diff changeset	38
0 a61af66fc99e Initial load duke parents: diff changeset	39 // Parser for for .class files
a61af66fc99e Initial load duke parents: diff changeset	40 //
a61af66fc99e Initial load duke parents: diff changeset	41 // The bytes describing the class file structure is read from a Stream object
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43 class ClassFileParser VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	44 private:
a61af66fc99e Initial load duke parents: diff changeset	45 bool _need_verify;
a61af66fc99e Initial load duke parents: diff changeset	46 bool _relax_verify;
a61af66fc99e Initial load duke parents: diff changeset	47 u2 _major_version;
a61af66fc99e Initial load duke parents: diff changeset	48 u2 _minor_version;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	49 Symbol* _class_name;
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 470 diff changeset	50 KlassHandle _host_klass;
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	51 GrowableArray<Handle>* _cp_patches; // overrides for CP entries
0 a61af66fc99e Initial load duke parents: diff changeset	52
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	53 // precomputed flags
0 a61af66fc99e Initial load duke parents: diff changeset	54 bool _has_finalizer;
a61af66fc99e Initial load duke parents: diff changeset	55 bool _has_empty_finalizer;
a61af66fc99e Initial load duke parents: diff changeset	56 bool _has_vanilla_constructor;
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	57 int _max_bootstrap_specifier_index; // detects BSS values
0 a61af66fc99e Initial load duke parents: diff changeset	58
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	59 // class attributes parsed before the instance klass is created:
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	60 bool _synthetic_flag;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	61 Symbol* _sourcefile;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	62 Symbol* _generic_signature;
6226 9c9fb30d2b3b Merge kvn parents: 6222 diff changeset	63 char* _sde_buffer;
9c9fb30d2b3b Merge kvn parents: 6222 diff changeset	64 int _sde_length;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	65 Array<u2>* _inner_classes;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	66 AnnotationArray* _annotations;
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	67
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	68 void set_class_synthetic_flag(bool x) { _synthetic_flag = x; }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	69 void set_class_sourcefile(Symbol* x) { _sourcefile = x; }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	70 void set_class_generic_signature(Symbol* x) { _generic_signature = x; }
6226 9c9fb30d2b3b Merge kvn parents: 6222 diff changeset	71 void set_class_sde_buffer(char* x, int len) { _sde_buffer = x; _sde_length = len; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	72 void set_class_inner_classes(Array<u2>* x) { _inner_classes = x; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	73 void set_class_annotations(AnnotationArray* x) { _annotations = x; }
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	74 void init_parsed_class_attributes() {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	75 _synthetic_flag = false;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	76 _sourcefile = NULL;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	77 _generic_signature = NULL;
6226 9c9fb30d2b3b Merge kvn parents: 6222 diff changeset	78 _sde_buffer = NULL;
9c9fb30d2b3b Merge kvn parents: 6222 diff changeset	79 _sde_length = 0;
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	80 // initialize the other flags too:
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	81 _has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	82 _max_bootstrap_specifier_index = -1;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	83 }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	84 void apply_parsed_class_attributes(instanceKlassHandle k); // update k
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	85
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	86 class AnnotationCollector {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	87 public:
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	88 enum Location { _in_field, _in_method, _in_class };
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	89 enum ID {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	90 _unknown = 0,
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	91 _method_ForceInline,
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	92 _method_DontInline,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	93 _method_LambdaForm_Compiled,
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	94 _method_LambdaForm_Hidden,
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	95 _annotation_LIMIT
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	96 };
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	97 const Location _location;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	98 int _annotations_present;
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	99 AnnotationCollector(Location location)
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	100 : _location(location), _annotations_present(0)
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	101 {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	102 assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, "");
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	103 }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	104 // If this annotation name has an ID, report it (or _none).
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	105 ID annotation_index(Symbol* name);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	106 // Set the annotation name:
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	107 void set_annotation(ID id) {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	108 assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob");
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	109 _annotations_present \|= nth_bit((int)id);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	110 }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	111 // Report if the annotation is present.
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	112 bool has_any_annotations() { return _annotations_present != 0; }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	113 bool has_annotation(ID id) { return (nth_bit((int)id) & _annotations_present) != 0; }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	114 };
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	115 class FieldAnnotationCollector: public AnnotationCollector {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	116 public:
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	117 FieldAnnotationCollector() : AnnotationCollector(_in_field) { }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	118 void apply_to(FieldInfo* f);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	119 };
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	120 class MethodAnnotationCollector: public AnnotationCollector {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	121 public:
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	122 MethodAnnotationCollector() : AnnotationCollector(_in_method) { }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	123 void apply_to(methodHandle m);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	124 };
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	125 class ClassAnnotationCollector: public AnnotationCollector {
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	126 public:
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	127 ClassAnnotationCollector() : AnnotationCollector(_in_class) { }
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	128 void apply_to(instanceKlassHandle k);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	129 };
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	130
0 a61af66fc99e Initial load duke parents: diff changeset	131 enum { fixed_buffer_size = 128 };
a61af66fc99e Initial load duke parents: diff changeset	132 u_char linenumbertable_buffer[fixed_buffer_size];
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 ClassFileStream* _stream; // Actual input stream
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 enum { LegalClass, LegalField, LegalMethod }; // used to verify unqualified names
a61af66fc99e Initial load duke parents: diff changeset	137
a61af66fc99e Initial load duke parents: diff changeset	138 // Accessors
a61af66fc99e Initial load duke parents: diff changeset	139 ClassFileStream* stream() { return _stream; }
a61af66fc99e Initial load duke parents: diff changeset	140 void set_stream(ClassFileStream* st) { _stream = st; }
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 // Constant pool parsing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	143 void parse_constant_pool_entries(ClassLoaderData* loader_data,
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4744 diff changeset	144 constantPoolHandle cp, int length, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	145
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	146 constantPoolHandle parse_constant_pool(ClassLoaderData* loader_data, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	147
a61af66fc99e Initial load duke parents: diff changeset	148 // Interface parsing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	149 Array<Klass> parse_interfaces(constantPoolHandle cp,
0 a61af66fc99e Initial load duke parents: diff changeset	150 int length,
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	151 ClassLoaderData* loader_data,
0 a61af66fc99e Initial load duke parents: diff changeset	152 Handle protection_domain,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	153 Symbol* class_name,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6853 diff changeset	154 bool* has_default_methods,
0 a61af66fc99e Initial load duke parents: diff changeset	155 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	156 void record_defined_class_dependencies(instanceKlassHandle defined_klass, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // Field parsing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	159 void parse_field_attributes(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	160 constantPoolHandle cp, u2 attributes_count,
0 a61af66fc99e Initial load duke parents: diff changeset	161 bool is_static, u2 signature_index,
a61af66fc99e Initial load duke parents: diff changeset	162 u2* constantvalue_index_addr,
a61af66fc99e Initial load duke parents: diff changeset	163 bool* is_synthetic_addr,
a61af66fc99e Initial load duke parents: diff changeset	164 u2* generic_signature_index_addr,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	165 AnnotationArray** field_annotations,
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	166 FieldAnnotationCollector* parsed_annotations,
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	167 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	168 Array<u2>* parse_fields(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	169 Symbol* class_name,
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	170 constantPoolHandle cp, bool is_interface,
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	171 FieldAllocationCount *fac,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	172 Array<AnnotationArray>* fields_annotations,
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	173 u2* java_fields_count_ptr, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	174
a61af66fc99e Initial load duke parents: diff changeset	175 // Method parsing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	176 methodHandle parse_method(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	177 constantPoolHandle cp,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	178 bool is_interface,
0 a61af66fc99e Initial load duke parents: diff changeset	179 AccessFlags* promoted_flags,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	180 AnnotationArray** method_annotations,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	181 AnnotationArray** method_parameter_annotations,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	182 AnnotationArray** method_default_annotations,
0 a61af66fc99e Initial load duke parents: diff changeset	183 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	184 Array<Method> parse_methods(ClassLoaderData* loader_data,
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	185 constantPoolHandle cp,
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	186 bool is_interface,
0 a61af66fc99e Initial load duke parents: diff changeset	187 AccessFlags* promoted_flags,
a61af66fc99e Initial load duke parents: diff changeset	188 bool* has_final_method,
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	189 Array<AnnotationArray>* methods_annotations,
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	190 Array<AnnotationArray>* methods_parameter_annotations,
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	191 Array<AnnotationArray>* methods_default_annotations,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6853 diff changeset	192 bool* has_default_method,
0 a61af66fc99e Initial load duke parents: diff changeset	193 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	194 Array<int>* sort_methods(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	195 Array<Method> methods,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	196 Array<AnnotationArray> methods_annotations,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	197 Array<AnnotationArray> methods_parameter_annotations,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	198 Array<AnnotationArray> methods_default_annotations,
0 a61af66fc99e Initial load duke parents: diff changeset	199 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	200 u2* parse_exception_table(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	201 u4 code_length, u4 exception_table_length,
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 5983 diff changeset	202 constantPoolHandle cp, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	203 void parse_linenumber_table(
a61af66fc99e Initial load duke parents: diff changeset	204 u4 code_attribute_length, u4 code_length,
a61af66fc99e Initial load duke parents: diff changeset	205 CompressedLineNumberWriteStream** write_stream, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	206 u2* parse_localvariable_table(u4 code_length, u2 max_locals, u4 code_attribute_length,
a61af66fc99e Initial load duke parents: diff changeset	207 constantPoolHandle cp, u2* localvariable_table_length,
a61af66fc99e Initial load duke parents: diff changeset	208 bool isLVTT, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	209 u2* parse_checked_exceptions(u2* checked_exceptions_length, u4 method_attribute_length,
a61af66fc99e Initial load duke parents: diff changeset	210 constantPoolHandle cp, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	211 void parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
a61af66fc99e Initial load duke parents: diff changeset	212 u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	213 Array<u1>* parse_stackmap_table(ClassLoaderData* loader_data, u4 code_attribute_length, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 // Classfile attribute parsing
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	216 void parse_classfile_sourcefile_attribute(constantPoolHandle cp, TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	217 void parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	218 int length, TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	219 u2 parse_classfile_inner_classes_attribute(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	220 u1* inner_classes_attribute_start,
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4744 diff changeset	221 bool parsed_enclosingmethod_attribute,
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4744 diff changeset	222 u2 enclosing_method_class_index,
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4744 diff changeset	223 u2 enclosing_method_method_index,
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4744 diff changeset	224 constantPoolHandle cp,
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	225 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	226 void parse_classfile_attributes(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	227 constantPoolHandle cp,
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	228 ClassAnnotationCollector* parsed_annotations,
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	229 TRAPS);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	230 void parse_classfile_synthetic_attribute(constantPoolHandle cp, TRAPS);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	231 void parse_classfile_signature_attribute(constantPoolHandle cp, TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	232 void parse_classfile_bootstrap_methods_attribute(ClassLoaderData* loader_data, constantPoolHandle cp, u4 attribute_length, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 // Annotations handling
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	235 AnnotationArray* assemble_annotations(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	236 u1* runtime_visible_annotations,
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	237 int runtime_visible_annotations_length,
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	238 u1* runtime_invisible_annotations,
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	239 int runtime_invisible_annotations_length, TRAPS);
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	240 int skip_annotation(u1* buffer, int limit, int index);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	241 int skip_annotation_value(u1* buffer, int limit, int index);
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	242 void parse_annotations(u1* buffer, int limit, constantPoolHandle cp,
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	243 /* Results (currently, only one result is supported): */
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	244 AnnotationCollector* result,
6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 5983 diff changeset	245 TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	246
a61af66fc99e Initial load duke parents: diff changeset	247 // Final setup
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	248 unsigned int compute_oop_map_count(instanceKlassHandle super,
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	249 unsigned int nonstatic_oop_count,
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	250 int first_nonstatic_oop_offset);
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	251 void fill_oop_maps(instanceKlassHandle k,
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	252 unsigned int nonstatic_oop_map_count,
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	253 int* nonstatic_oop_offsets,
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	254 unsigned int* nonstatic_oop_counts);
0 a61af66fc99e Initial load duke parents: diff changeset	255 void set_precomputed_flags(instanceKlassHandle k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	256 Array<Klass> compute_transitive_interfaces(ClassLoaderData* loader_data,
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	257 instanceKlassHandle super,
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	258 Array<Klass> local_ifs, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 // Format checker methods
a61af66fc99e Initial load duke parents: diff changeset	261 void classfile_parse_error(const char* msg, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	262 void classfile_parse_error(const char* msg, int index, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	263 void classfile_parse_error(const char* msg, const char *name, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	264 void classfile_parse_error(const char* msg, int index, const char *name, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	265 inline void guarantee_property(bool b, const char* msg, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	266 if (!b) { classfile_parse_error(msg, CHECK); }
a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 inline void assert_property(bool b, const char* msg, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	270 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	271 if (!b) { fatal(msg); }
a61af66fc99e Initial load duke parents: diff changeset	272 #endif
a61af66fc99e Initial load duke parents: diff changeset	273 }
a61af66fc99e Initial load duke parents: diff changeset	274
a61af66fc99e Initial load duke parents: diff changeset	275 inline void check_property(bool property, const char* msg, int index, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	276 if (_need_verify) {
a61af66fc99e Initial load duke parents: diff changeset	277 guarantee_property(property, msg, index, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	278 } else {
a61af66fc99e Initial load duke parents: diff changeset	279 assert_property(property, msg, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	280 }
a61af66fc99e Initial load duke parents: diff changeset	281 }
a61af66fc99e Initial load duke parents: diff changeset	282
a61af66fc99e Initial load duke parents: diff changeset	283 inline void check_property(bool property, const char* msg, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	284 if (_need_verify) {
a61af66fc99e Initial load duke parents: diff changeset	285 guarantee_property(property, msg, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	286 } else {
a61af66fc99e Initial load duke parents: diff changeset	287 assert_property(property, msg, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	288 }
a61af66fc99e Initial load duke parents: diff changeset	289 }
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 inline void guarantee_property(bool b, const char* msg, int index, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	292 if (!b) { classfile_parse_error(msg, index, CHECK); }
a61af66fc99e Initial load duke parents: diff changeset	293 }
a61af66fc99e Initial load duke parents: diff changeset	294 inline void guarantee_property(bool b, const char* msg, const char *name, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	295 if (!b) { classfile_parse_error(msg, name, CHECK); }
a61af66fc99e Initial load duke parents: diff changeset	296 }
a61af66fc99e Initial load duke parents: diff changeset	297 inline void guarantee_property(bool b, const char* msg, int index, const char *name, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	298 if (!b) { classfile_parse_error(msg, index, name, CHECK); }
a61af66fc99e Initial load duke parents: diff changeset	299 }
a61af66fc99e Initial load duke parents: diff changeset	300
1586 086d73ccd6c0 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases kamg parents: 974 diff changeset	301 void throwIllegalSignature(
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	302 const char* type, Symbol* name, Symbol* sig, TRAPS);
1586 086d73ccd6c0 6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases kamg parents: 974 diff changeset	303
0 a61af66fc99e Initial load duke parents: diff changeset	304 bool is_supported_version(u2 major, u2 minor);
a61af66fc99e Initial load duke parents: diff changeset	305 bool has_illegal_visibility(jint flags);
a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 void verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	308 void verify_legal_utf8(const unsigned char* buffer, int length, TRAPS);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	309 void verify_legal_class_name(Symbol* name, TRAPS);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	310 void verify_legal_field_name(Symbol* name, TRAPS);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	311 void verify_legal_method_name(Symbol* name, TRAPS);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	312 void verify_legal_field_signature(Symbol* fieldname, Symbol* signature, TRAPS);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	313 int verify_legal_method_signature(Symbol* methodname, Symbol* signature, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	314 void verify_legal_class_modifiers(jint flags, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	315 void verify_legal_field_modifiers(jint flags, bool is_interface, TRAPS);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	316 void verify_legal_method_modifiers(jint flags, bool is_interface, Symbol* name, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	317 bool verify_unqualified_name(char* name, unsigned int length, int type);
a61af66fc99e Initial load duke parents: diff changeset	318 char* skip_over_field_name(char* name, bool slash_ok, unsigned int length);
a61af66fc99e Initial load duke parents: diff changeset	319 char* skip_over_field_signature(char* signature, bool void_ok, unsigned int length, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	320
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 470 diff changeset	321 bool is_anonymous() {
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2376 diff changeset	322 assert(EnableInvokeDynamic \|\| _host_klass.is_null(), "");
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 470 diff changeset	323 return _host_klass.not_null();
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 470 diff changeset	324 }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	325 bool has_cp_patch_at(int index) {
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2376 diff changeset	326 assert(EnableInvokeDynamic, "");
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	327 assert(index >= 0, "oob");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	328 return (_cp_patches != NULL
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	329 && index < _cp_patches->length()
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	330 && _cp_patches->adr_at(index)->not_null());
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	331 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	332 Handle cp_patch_at(int index) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	333 assert(has_cp_patch_at(index), "oob");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	334 return _cp_patches->at(index);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	335 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	336 Handle clear_cp_patch_at(int index) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	337 Handle patch = cp_patch_at(index);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	338 _cp_patches->at_put(index, Handle());
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	339 assert(!has_cp_patch_at(index), "");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	340 return patch;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	341 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	342 void patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	343
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	344 // Wrapper for constantTag.is_klass_[or_]reference.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	345 // In older versions of the VM, Klass*s cannot sneak into early phases of
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	346 // constant pool construction, but in later versions they can.
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	347 // %%% Let's phase out the old is_klass_reference.
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	348 bool is_klass_reference(constantPoolHandle cp, int index) {
6852 19eb999cb72c 8000740: remove LinkWellKnownClasses twisti parents: 6725 diff changeset	349 return (EnableInvokeDynamic
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	350 ? cp->tag_at(index).is_klass_or_reference()
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	351 : cp->tag_at(index).is_klass_reference());
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	352 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	353
0 a61af66fc99e Initial load duke parents: diff changeset	354 public:
a61af66fc99e Initial load duke parents: diff changeset	355 // Constructor
a61af66fc99e Initial load duke parents: diff changeset	356 ClassFileParser(ClassFileStream* st) { set_stream(st); }
a61af66fc99e Initial load duke parents: diff changeset	357
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	358 // Parse .class file and return new Klass. The Klass is not hooked up
0 a61af66fc99e Initial load duke parents: diff changeset	359 // to the system dictionary or any other structures, so a .class file can
a61af66fc99e Initial load duke parents: diff changeset	360 // be loaded several times if desired.
a61af66fc99e Initial load duke parents: diff changeset	361 // The system dictionary hookup is done by the caller.
a61af66fc99e Initial load duke parents: diff changeset	362 //
a61af66fc99e Initial load duke parents: diff changeset	363 // "parsed_name" is updated by this method, and is the name found
a61af66fc99e Initial load duke parents: diff changeset	364 // while parsing the stream.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	365 instanceKlassHandle parseClassFile(Symbol* name,
0 a61af66fc99e Initial load duke parents: diff changeset	366 Handle class_loader,
a61af66fc99e Initial load duke parents: diff changeset	367 Handle protection_domain,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	368 TempNewSymbol& parsed_name,
973 ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 875 diff changeset	369 bool verify,
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	370 TRAPS) {
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 470 diff changeset	371 KlassHandle no_host_klass;
973 ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 875 diff changeset	372 return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD);
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	373 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	374 instanceKlassHandle parseClassFile(Symbol* name,
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	375 Handle class_loader,
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	376 Handle protection_domain,
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 470 diff changeset	377 KlassHandle host_klass,
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	378 GrowableArray<Handle>* cp_patches,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	379 TempNewSymbol& parsed_name,
973 ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 875 diff changeset	380 bool verify,
0 a61af66fc99e Initial load duke parents: diff changeset	381 TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	382
a61af66fc99e Initial load duke parents: diff changeset	383 // Verifier checks
a61af66fc99e Initial load duke parents: diff changeset	384 static void check_super_class_access(instanceKlassHandle this_klass, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	385 static void check_super_interface_access(instanceKlassHandle this_klass, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	386 static void check_final_method_override(instanceKlassHandle this_klass, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	387 static void check_illegal_static_method(instanceKlassHandle this_klass, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	388 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	389
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	390 #endif // SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP

Mercurial > hg > truffle

annotate src/share/vm/classfile/classFileParser.hpp @ 6972:bd7a7ce2e264