Mercurial > hg > truffle
annotate src/share/vm/runtime/reflection.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
author | johnc |
---|---|
date | Wed, 18 Aug 2010 10:59:06 -0700 |
parents | c18cbe5936b8 |
children | f95d63e2154a |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
2 * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
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:
665
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
25 // Class Reflection contains utility methods needed for implementing the | |
26 // reflection api. | |
27 // | |
28 // Used by functions in the JVM interface. | |
29 // | |
30 // NOTE that in JDK 1.4 most of reflection is now implemented in Java | |
31 // using dynamic bytecode generation. The Array class has not yet been | |
32 // rewritten using bytecodes; if it were, most of the rest of this | |
33 // class could go away, as well as a few more entry points in jvm.cpp. | |
34 | |
35 class FieldStream; | |
36 | |
37 class Reflection: public AllStatic { | |
38 private: | |
39 // Access checking | |
40 static bool reflect_check_access(klassOop field_class, AccessFlags acc, klassOop target_class, bool is_method_invoke, TRAPS); | |
41 | |
42 // Conversion | |
43 static klassOop basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS); | |
44 static oop basic_type_arrayklass_to_mirror(klassOop basic_type_arrayklass, TRAPS); | |
45 | |
46 static objArrayHandle get_parameter_types(methodHandle method, int parameter_count, oop* return_type, TRAPS); | |
47 static objArrayHandle get_exception_types(methodHandle method, TRAPS); | |
48 // Creating new java.lang.reflect.xxx wrappers | |
49 static Handle new_type(symbolHandle signature, KlassHandle k, TRAPS); | |
50 | |
51 public: | |
52 // Constants defined by java reflection api classes | |
53 enum SomeConstants { | |
54 PUBLIC = 0, | |
55 DECLARED = 1, | |
56 MEMBER_PUBLIC = 0, | |
57 MEMBER_DECLARED = 1, | |
58 MAX_DIM = 255 | |
59 }; | |
60 | |
61 // Boxing. Returns boxed value of appropriate type. Throws IllegalArgumentException. | |
62 static oop box(jvalue* v, BasicType type, TRAPS); | |
63 // Unboxing. Returns type code and sets value. | |
64 static BasicType unbox_for_primitive(oop boxed_value, jvalue* value, TRAPS); | |
65 static BasicType unbox_for_regular_object(oop boxed_value, jvalue* value); | |
66 | |
67 // Widening of basic types. Throws IllegalArgumentException. | |
68 static void widen(jvalue* value, BasicType current_type, BasicType wide_type, TRAPS); | |
69 | |
70 // Reflective array access. Returns type code. Throws ArrayIndexOutOfBoundsException. | |
71 static BasicType array_get(jvalue* value, arrayOop a, int index, TRAPS); | |
72 static void array_set(jvalue* value, arrayOop a, int index, BasicType value_type, TRAPS); | |
73 // Returns mirror on array element type (NULL for basic type arrays and non-arrays). | |
74 static oop array_component_type(oop mirror, TRAPS); | |
75 | |
76 // Object creation | |
77 static arrayOop reflect_new_array(oop element_mirror, jint length, TRAPS); | |
78 static arrayOop reflect_new_multi_array(oop element_mirror, typeArrayOop dimensions, TRAPS); | |
79 | |
80 // Verification | |
81 static bool verify_class_access(klassOop current_class, klassOop new_class, bool classloader_only); | |
82 | |
83 static bool verify_field_access(klassOop current_class, | |
84 klassOop resolved_class, | |
85 klassOop field_class, | |
86 AccessFlags access, | |
87 bool classloader_only, | |
88 bool protected_restriction = false); | |
89 static bool is_same_class_package(klassOop class1, klassOop class2); | |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
90 static bool is_same_package_member(klassOop class1, klassOop class2, TRAPS); |
0 | 91 |
92 static bool can_relax_access_check_for( | |
93 klassOop accessor, klassOop accesee, bool classloader_only); | |
94 | |
95 // inner class reflection | |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
96 // raise an ICCE unless the required relationship can be proven to hold |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
97 // If inner_is_member, require the inner to be a member of the outer. |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
98 // If !inner_is_member, require the inner to be anonymous (a non-member). |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
99 // Caller is responsible for figuring out in advance which case must be true. |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
100 static void check_for_inner_class(instanceKlassHandle outer, instanceKlassHandle inner, |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
0
diff
changeset
|
101 bool inner_is_member, TRAPS); |
0 | 102 |
103 // | |
104 // Support for reflection based on dynamic bytecode generation (JDK 1.4) | |
105 // | |
106 | |
107 // Create a java.lang.reflect.Method object based on a method | |
108 static oop new_method(methodHandle method, bool intern_name, bool for_constant_pool_access, TRAPS); | |
109 // Create a java.lang.reflect.Constructor object based on a method | |
110 static oop new_constructor(methodHandle method, TRAPS); | |
111 // Create a java.lang.reflect.Field object based on a field descriptor | |
112 static oop new_field(fieldDescriptor* fd, bool intern_name, TRAPS); | |
113 | |
114 //--------------------------------------------------------------------------- | |
115 // | |
116 // Support for old native code-based reflection (pre-JDK 1.4) | |
117 // | |
118 // NOTE: the method and constructor invocation code is still used | |
119 // for startup time reasons; see reflectionCompat.hpp. | |
120 // | |
121 //--------------------------------------------------------------------------- | |
122 | |
123 #ifdef SUPPORT_OLD_REFLECTION | |
124 private: | |
125 // method resolution for invoke | |
126 static methodHandle resolve_interface_call(instanceKlassHandle klass, methodHandle method, KlassHandle recv_klass, Handle receiver, TRAPS); | |
127 // Method call (shared by invoke_method and invoke_constructor) | |
128 static oop invoke(instanceKlassHandle klass, methodHandle method, Handle receiver, bool override, objArrayHandle ptypes, BasicType rtype, objArrayHandle args, bool is_method_invoke, TRAPS); | |
129 | |
130 // Narrowing of basic types. Used to create correct jvalues for | |
131 // boolean, byte, char and short return return values from interpreter | |
132 // which are returned as ints. Throws IllegalArgumentException. | |
133 static void narrow(jvalue* value, BasicType narrow_type, TRAPS); | |
134 | |
135 // Conversion | |
136 static BasicType basic_type_mirror_to_basic_type(oop basic_type_mirror, TRAPS); | |
137 | |
138 static bool match_parameter_types(methodHandle method, objArrayHandle types, int parameter_count, TRAPS); | |
139 // Creating new java.lang.reflect.xxx wrappers | |
140 static oop new_field(FieldStream* st, TRAPS); | |
141 | |
142 public: | |
143 // Field lookup and verification. | |
144 static bool resolve_field(Handle field_mirror, Handle& receiver, fieldDescriptor* fd, bool check_final, TRAPS); | |
145 | |
146 // Reflective field access. Returns type code. Throws IllegalArgumentException. | |
147 static BasicType field_get(jvalue* value, fieldDescriptor* fd, Handle receiver); | |
148 static void field_set(jvalue* value, fieldDescriptor* fd, Handle receiver, BasicType value_type, TRAPS); | |
149 | |
150 // Reflective lookup of fields. Returns java.lang.reflect.Field instances. | |
151 static oop reflect_field(oop mirror, symbolOop field_name, jint which, TRAPS); | |
152 static objArrayOop reflect_fields(oop mirror, jint which, TRAPS); | |
153 | |
154 // Reflective lookup of methods. Returns java.lang.reflect.Method instances. | |
155 static oop reflect_method(oop mirror, symbolHandle method_name, objArrayHandle types, jint which, TRAPS); | |
156 static objArrayOop reflect_methods(oop mirror, jint which, TRAPS); | |
157 | |
158 // Reflective lookup of constructors. Returns java.lang.reflect.Constructor instances. | |
159 static oop reflect_constructor(oop mirror, objArrayHandle types, jint which, TRAPS); | |
160 static objArrayOop reflect_constructors(oop mirror, jint which, TRAPS); | |
161 | |
162 // Method invokation through java.lang.reflect.Method | |
163 static oop invoke_method(oop method_mirror, Handle receiver, objArrayHandle args, TRAPS); | |
164 // Method invokation through java.lang.reflect.Constructor | |
165 static oop invoke_constructor(oop method_mirror, objArrayHandle args, TRAPS); | |
166 #endif /* SUPPORT_OLD_REFLECTION */ | |
167 | |
168 }; |