Mercurial > hg > truffle
annotate src/share/vm/prims/jvm.cpp @ 7588:f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
Summary: This patch addresses an alignment trap due to the storage format of method parameters data in constMethod. It also adds code to validate constant pool indexes for method parameters data.
Reviewed-by: jrose, dholmes
Contributed-by: eric.mccorkle@oracle.com
| author | coleenp |
|---|---|
| date | Mon, 14 Jan 2013 11:01:39 -0500 |
| parents | ade95d680b42 |
| children | f422634e5828 b14da2e6f2dc |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4717
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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:
1324
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1324
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:
1324
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/classLoader.hpp" | |
| 27 #include "classfile/javaAssertions.hpp" | |
| 28 #include "classfile/javaClasses.hpp" | |
| 29 #include "classfile/symbolTable.hpp" | |
| 30 #include "classfile/systemDictionary.hpp" | |
| 31 #include "classfile/vmSymbols.hpp" | |
| 32 #include "gc_interface/collectedHeap.inline.hpp" | |
| 33 #include "memory/oopFactory.hpp" | |
| 34 #include "memory/universe.inline.hpp" | |
| 3938 | 35 #include "oops/fieldStreams.hpp" |
| 1972 | 36 #include "oops/instanceKlass.hpp" |
| 37 #include "oops/objArrayKlass.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
38 #include "oops/method.hpp" |
| 1972 | 39 #include "prims/jvm.h" |
| 40 #include "prims/jvm_misc.hpp" | |
| 41 #include "prims/jvmtiExport.hpp" | |
| 42 #include "prims/jvmtiThreadState.hpp" | |
| 43 #include "prims/nativeLookup.hpp" | |
| 44 #include "prims/privilegedStack.hpp" | |
| 45 #include "runtime/arguments.hpp" | |
| 46 #include "runtime/dtraceJSDT.hpp" | |
| 47 #include "runtime/handles.inline.hpp" | |
| 48 #include "runtime/init.hpp" | |
| 49 #include "runtime/interfaceSupport.hpp" | |
| 50 #include "runtime/java.hpp" | |
| 51 #include "runtime/javaCalls.hpp" | |
| 52 #include "runtime/jfieldIDWorkaround.hpp" | |
| 53 #include "runtime/os.hpp" | |
| 54 #include "runtime/perfData.hpp" | |
| 55 #include "runtime/reflection.hpp" | |
| 56 #include "runtime/vframe.hpp" | |
| 57 #include "runtime/vm_operations.hpp" | |
| 58 #include "services/attachListener.hpp" | |
| 59 #include "services/management.hpp" | |
| 60 #include "services/threadService.hpp" | |
| 61 #include "utilities/copy.hpp" | |
| 62 #include "utilities/defaultStream.hpp" | |
| 63 #include "utilities/dtrace.hpp" | |
| 64 #include "utilities/events.hpp" | |
| 65 #include "utilities/histogram.hpp" | |
| 66 #include "utilities/top.hpp" | |
| 67 #include "utilities/utf8.hpp" | |
| 68 #ifdef TARGET_OS_FAMILY_linux | |
| 69 # include "jvm_linux.h" | |
| 70 #endif | |
| 71 #ifdef TARGET_OS_FAMILY_solaris | |
| 72 # include "jvm_solaris.h" | |
| 73 #endif | |
| 74 #ifdef TARGET_OS_FAMILY_windows | |
| 75 # include "jvm_windows.h" | |
| 76 #endif | |
| 3960 | 77 #ifdef TARGET_OS_FAMILY_bsd |
| 78 # include "jvm_bsd.h" | |
| 79 #endif | |
| 1972 | 80 |
| 0 | 81 #include <errno.h> |
| 82 | |
| 4006 | 83 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
84 HS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__begin, long long); |
|
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
85 HS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__end, int); |
|
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
86 HS_DTRACE_PROBE_DECL0(hotspot, thread__yield); |
| 4006 | 87 #endif /* !USDT2 */ |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
88 |
| 0 | 89 /* |
| 90 NOTE about use of any ctor or function call that can trigger a safepoint/GC: | |
| 91 such ctors and calls MUST NOT come between an oop declaration/init and its | |
| 92 usage because if objects are move this may cause various memory stomps, bus | |
| 93 errors and segfaults. Here is a cookbook for causing so called "naked oop | |
| 94 failures": | |
| 95 | |
| 96 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> { | |
| 97 JVMWrapper("JVM_GetClassDeclaredFields"); | |
| 98 | |
| 99 // Object address to be held directly in mirror & not visible to GC | |
| 100 oop mirror = JNIHandles::resolve_non_null(ofClass); | |
| 101 | |
| 102 // If this ctor can hit a safepoint, moving objects around, then | |
| 103 ComplexConstructor foo; | |
| 104 | |
| 105 // Boom! mirror may point to JUNK instead of the intended object | |
| 106 (some dereference of mirror) | |
| 107 | |
| 108 // Here's another call that may block for GC, making mirror stale | |
| 109 MutexLocker ml(some_lock); | |
| 110 | |
| 111 // And here's an initializer that can result in a stale oop | |
| 112 // all in one step. | |
| 113 oop o = call_that_can_throw_exception(TRAPS); | |
| 114 | |
| 115 | |
| 116 The solution is to keep the oop declaration BELOW the ctor or function | |
| 117 call that might cause a GC, do another resolve to reassign the oop, or | |
| 118 consider use of a Handle instead of an oop so there is immunity from object | |
| 119 motion. But note that the "QUICK" entries below do not have a handlemark | |
| 120 and thus can only support use of handles passed in. | |
| 121 */ | |
| 122 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
123 static void trace_class_resolution_impl(Klass* to_class, TRAPS) { |
| 0 | 124 ResourceMark rm; |
| 125 int line_number = -1; | |
| 126 const char * source_file = NULL; | |
|
657
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
127 const char * trace = "explicit"; |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
128 InstanceKlass* caller = NULL; |
| 0 | 129 JavaThread* jthread = JavaThread::current(); |
| 130 if (jthread->has_last_Java_frame()) { | |
| 131 vframeStream vfst(jthread); | |
| 132 | |
| 133 // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
134 TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
135 Klass* access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
136 TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
137 Klass* privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
138 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
139 Method* last_caller = NULL; |
| 0 | 140 |
| 141 while (!vfst.at_end()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
142 Method* m = vfst.method(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
143 if (!vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass())&& |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
144 !vfst.method()->method_holder()->is_subclass_of(access_controller_klass) && |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
145 !vfst.method()->method_holder()->is_subclass_of(privileged_action_klass)) { |
| 0 | 146 break; |
| 147 } | |
| 148 last_caller = m; | |
| 149 vfst.next(); | |
| 150 } | |
| 151 // if this is called from Class.forName0 and that is called from Class.forName, | |
| 152 // then print the caller of Class.forName. If this is Class.loadClass, then print | |
| 153 // that caller, otherwise keep quiet since this should be picked up elsewhere. | |
| 154 bool found_it = false; | |
| 155 if (!vfst.at_end() && | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
156 vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() && |
| 0 | 157 vfst.method()->name() == vmSymbols::forName0_name()) { |
| 158 vfst.next(); | |
| 159 if (!vfst.at_end() && | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
160 vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() && |
| 0 | 161 vfst.method()->name() == vmSymbols::forName_name()) { |
| 162 vfst.next(); | |
| 163 found_it = true; | |
| 164 } | |
| 165 } else if (last_caller != NULL && | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
166 last_caller->method_holder()->name() == |
| 0 | 167 vmSymbols::java_lang_ClassLoader() && |
| 168 (last_caller->name() == vmSymbols::loadClassInternal_name() || | |
| 169 last_caller->name() == vmSymbols::loadClass_name())) { | |
| 170 found_it = true; | |
|
657
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
171 } else if (!vfst.at_end()) { |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
172 if (vfst.method()->is_native()) { |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
173 // JNI call |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
174 found_it = true; |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
175 } |
| 0 | 176 } |
| 177 if (found_it && !vfst.at_end()) { | |
| 178 // found the caller | |
| 179 caller = vfst.method()->method_holder(); | |
| 180 line_number = vfst.method()->line_number_from_bci(vfst.bci()); | |
|
657
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
181 if (line_number == -1) { |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
182 // show method name if it's a native method |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
183 trace = vfst.method()->name_and_sig_as_C_string(); |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
184 } |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
185 Symbol* s = caller->source_file_name(); |
| 0 | 186 if (s != NULL) { |
| 187 source_file = s->as_C_string(); | |
| 188 } | |
| 189 } | |
| 190 } | |
| 191 if (caller != NULL) { | |
| 192 if (to_class != caller) { | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
193 const char * from = caller->external_name(); |
|
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
194 const char * to = to_class->external_name(); |
| 0 | 195 // print in a single call to reduce interleaving between threads |
| 196 if (source_file != NULL) { | |
|
657
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
197 tty->print("RESOLVE %s %s %s:%d (%s)\n", from, to, source_file, line_number, trace); |
| 0 | 198 } else { |
|
657
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
199 tty->print("RESOLVE %s %s (%s)\n", from, to, trace); |
| 0 | 200 } |
| 201 } | |
| 202 } | |
| 203 } | |
| 204 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
205 void trace_class_resolution(Klass* to_class) { |
| 0 | 206 EXCEPTION_MARK; |
| 207 trace_class_resolution_impl(to_class, THREAD); | |
| 208 if (HAS_PENDING_EXCEPTION) { | |
| 209 CLEAR_PENDING_EXCEPTION; | |
| 210 } | |
| 211 } | |
| 212 | |
| 213 // Wrapper to trace JVM functions | |
| 214 | |
| 215 #ifdef ASSERT | |
| 216 class JVMTraceWrapper : public StackObj { | |
| 217 public: | |
| 218 JVMTraceWrapper(const char* format, ...) { | |
| 219 if (TraceJVMCalls) { | |
| 220 va_list ap; | |
| 221 va_start(ap, format); | |
| 222 tty->print("JVM "); | |
| 223 tty->vprint_cr(format, ap); | |
| 224 va_end(ap); | |
| 225 } | |
| 226 } | |
| 227 }; | |
| 228 | |
| 229 Histogram* JVMHistogram; | |
| 230 volatile jint JVMHistogram_lock = 0; | |
| 231 | |
| 232 class JVMHistogramElement : public HistogramElement { | |
| 233 public: | |
| 234 JVMHistogramElement(const char* name); | |
| 235 }; | |
| 236 | |
| 237 JVMHistogramElement::JVMHistogramElement(const char* elementName) { | |
| 238 _name = elementName; | |
| 239 uintx count = 0; | |
| 240 | |
| 241 while (Atomic::cmpxchg(1, &JVMHistogram_lock, 0) != 0) { | |
| 242 while (OrderAccess::load_acquire(&JVMHistogram_lock) != 0) { | |
| 243 count +=1; | |
| 244 if ( (WarnOnStalledSpinLock > 0) | |
| 245 && (count % WarnOnStalledSpinLock == 0)) { | |
| 246 warning("JVMHistogram_lock seems to be stalled"); | |
| 247 } | |
| 248 } | |
| 249 } | |
| 250 | |
| 251 if(JVMHistogram == NULL) | |
| 252 JVMHistogram = new Histogram("JVM Call Counts",100); | |
| 253 | |
| 254 JVMHistogram->add_element(this); | |
| 255 Atomic::dec(&JVMHistogram_lock); | |
| 256 } | |
| 257 | |
| 258 #define JVMCountWrapper(arg) \ | |
| 259 static JVMHistogramElement* e = new JVMHistogramElement(arg); \ | |
| 260 if (e != NULL) e->increment_count(); // Due to bug in VC++, we need a NULL check here eventhough it should never happen! | |
| 261 | |
| 262 #define JVMWrapper(arg1) JVMCountWrapper(arg1); JVMTraceWrapper(arg1) | |
| 263 #define JVMWrapper2(arg1, arg2) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2) | |
| 264 #define JVMWrapper3(arg1, arg2, arg3) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3) | |
| 265 #define JVMWrapper4(arg1, arg2, arg3, arg4) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3, arg4) | |
| 266 #else | |
| 267 #define JVMWrapper(arg1) | |
| 268 #define JVMWrapper2(arg1, arg2) | |
| 269 #define JVMWrapper3(arg1, arg2, arg3) | |
| 270 #define JVMWrapper4(arg1, arg2, arg3, arg4) | |
| 271 #endif | |
| 272 | |
| 273 | |
| 274 // Interface version ///////////////////////////////////////////////////////////////////// | |
| 275 | |
| 276 | |
| 277 JVM_LEAF(jint, JVM_GetInterfaceVersion()) | |
| 278 return JVM_INTERFACE_VERSION; | |
| 279 JVM_END | |
| 280 | |
| 281 | |
| 282 // java.lang.System ////////////////////////////////////////////////////////////////////// | |
| 283 | |
| 284 | |
| 285 JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)) | |
| 286 JVMWrapper("JVM_CurrentTimeMillis"); | |
| 287 return os::javaTimeMillis(); | |
| 288 JVM_END | |
| 289 | |
| 290 JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored)) | |
| 291 JVMWrapper("JVM_NanoTime"); | |
| 292 return os::javaTimeNanos(); | |
| 293 JVM_END | |
| 294 | |
| 295 | |
| 296 JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, | |
| 297 jobject dst, jint dst_pos, jint length)) | |
| 298 JVMWrapper("JVM_ArrayCopy"); | |
| 299 // Check if we have null pointers | |
| 300 if (src == NULL || dst == NULL) { | |
| 301 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 302 } | |
| 303 arrayOop s = arrayOop(JNIHandles::resolve_non_null(src)); | |
| 304 arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst)); | |
| 305 assert(s->is_oop(), "JVM_ArrayCopy: src not an oop"); | |
| 306 assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop"); | |
| 307 // Do copy | |
| 6983 | 308 s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread); |
| 0 | 309 JVM_END |
| 310 | |
| 311 | |
| 312 static void set_property(Handle props, const char* key, const char* value, TRAPS) { | |
| 313 JavaValue r(T_OBJECT); | |
| 314 // public synchronized Object put(Object key, Object value); | |
| 315 HandleMark hm(THREAD); | |
| 316 Handle key_str = java_lang_String::create_from_platform_dependent_str(key, CHECK); | |
| 317 Handle value_str = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK); | |
| 318 JavaCalls::call_virtual(&r, | |
| 319 props, | |
| 1142 | 320 KlassHandle(THREAD, SystemDictionary::Properties_klass()), |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
321 vmSymbols::put_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
322 vmSymbols::object_object_object_signature(), |
| 0 | 323 key_str, |
| 324 value_str, | |
| 325 THREAD); | |
| 326 } | |
| 327 | |
| 328 | |
| 329 #define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties)); | |
| 330 | |
| 331 | |
| 332 JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties)) | |
| 333 JVMWrapper("JVM_InitProperties"); | |
| 334 ResourceMark rm; | |
| 335 | |
| 336 Handle props(THREAD, JNIHandles::resolve_non_null(properties)); | |
| 337 | |
| 338 // System property list includes both user set via -D option and | |
| 339 // jvm system specific properties. | |
| 340 for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) { | |
| 341 PUTPROP(props, p->key(), p->value()); | |
| 342 } | |
| 343 | |
| 344 // Convert the -XX:MaxDirectMemorySize= command line flag | |
| 345 // to the sun.nio.MaxDirectMemorySize property. | |
| 346 // Do this after setting user properties to prevent people | |
| 347 // from setting the value with a -D option, as requested. | |
| 348 { | |
|
6199
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
5967
diff
changeset
|
349 if (FLAG_IS_DEFAULT(MaxDirectMemorySize)) { |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
5967
diff
changeset
|
350 PUTPROP(props, "sun.nio.MaxDirectMemorySize", "-1"); |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
5967
diff
changeset
|
351 } else { |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
5967
diff
changeset
|
352 char as_chars[256]; |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
5967
diff
changeset
|
353 jio_snprintf(as_chars, sizeof(as_chars), UINTX_FORMAT, MaxDirectMemorySize); |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
5967
diff
changeset
|
354 PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars); |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
5967
diff
changeset
|
355 } |
| 0 | 356 } |
| 357 | |
| 358 // JVM monitoring and management support | |
| 359 // Add the sun.management.compiler property for the compiler's name | |
| 360 { | |
| 361 #undef CSIZE | |
| 362 #if defined(_LP64) || defined(_WIN64) | |
| 363 #define CSIZE "64-Bit " | |
| 364 #else | |
| 365 #define CSIZE | |
| 366 #endif // 64bit | |
| 367 | |
| 368 #ifdef TIERED | |
| 369 const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers"; | |
| 370 #else | |
| 371 #if defined(COMPILER1) | |
| 372 const char* compiler_name = "HotSpot " CSIZE "Client Compiler"; | |
| 373 #elif defined(COMPILER2) | |
| 374 const char* compiler_name = "HotSpot " CSIZE "Server Compiler"; | |
| 375 #else | |
| 376 const char* compiler_name = ""; | |
| 377 #endif // compilers | |
| 378 #endif // TIERED | |
| 379 | |
| 380 if (*compiler_name != '\0' && | |
| 381 (Arguments::mode() != Arguments::_int)) { | |
| 382 PUTPROP(props, "sun.management.compiler", compiler_name); | |
| 383 } | |
| 384 } | |
| 385 | |
| 386 return properties; | |
| 387 JVM_END | |
| 388 | |
| 389 | |
| 390 // java.lang.Runtime ///////////////////////////////////////////////////////////////////////// | |
| 391 | |
| 392 extern volatile jint vm_created; | |
| 393 | |
| 394 JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code)) | |
| 395 if (vm_created != 0 && (code == 0)) { | |
| 396 // The VM is about to exit. We call back into Java to check whether finalizers should be run | |
| 397 Universe::run_finalizers_on_exit(); | |
| 398 } | |
| 399 before_exit(thread); | |
| 400 vm_exit(code); | |
| 401 JVM_END | |
| 402 | |
| 403 | |
| 404 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code)) | |
| 405 before_exit(thread); | |
| 406 vm_exit(code); | |
| 407 JVM_END | |
| 408 | |
| 409 | |
| 410 JVM_LEAF(void, JVM_OnExit(void (*func)(void))) | |
| 411 register_on_exit_function(func); | |
| 412 JVM_END | |
| 413 | |
| 414 | |
| 415 JVM_ENTRY_NO_ENV(void, JVM_GC(void)) | |
| 416 JVMWrapper("JVM_GC"); | |
| 417 if (!DisableExplicitGC) { | |
| 418 Universe::heap()->collect(GCCause::_java_lang_system_gc); | |
| 419 } | |
| 420 JVM_END | |
| 421 | |
| 422 | |
| 423 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void)) | |
| 424 JVMWrapper("JVM_MaxObjectInspectionAge"); | |
| 425 return Universe::heap()->millis_since_last_gc(); | |
| 426 JVM_END | |
| 427 | |
| 428 | |
| 429 JVM_LEAF(void, JVM_TraceInstructions(jboolean on)) | |
| 430 if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported"); | |
| 431 JVM_END | |
| 432 | |
| 433 | |
| 434 JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on)) | |
| 435 if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported"); | |
| 436 JVM_END | |
| 437 | |
| 438 static inline jlong convert_size_t_to_jlong(size_t val) { | |
| 439 // In the 64-bit vm, a size_t can overflow a jlong (which is signed). | |
| 440 NOT_LP64 (return (jlong)val;) | |
| 441 LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);) | |
| 442 } | |
| 443 | |
| 444 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void)) | |
| 445 JVMWrapper("JVM_TotalMemory"); | |
| 446 size_t n = Universe::heap()->capacity(); | |
| 447 return convert_size_t_to_jlong(n); | |
| 448 JVM_END | |
| 449 | |
| 450 | |
| 451 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void)) | |
| 452 JVMWrapper("JVM_FreeMemory"); | |
| 453 CollectedHeap* ch = Universe::heap(); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
116
diff
changeset
|
454 size_t n; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
116
diff
changeset
|
455 { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
116
diff
changeset
|
456 MutexLocker x(Heap_lock); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
116
diff
changeset
|
457 n = ch->capacity() - ch->used(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
116
diff
changeset
|
458 } |
| 0 | 459 return convert_size_t_to_jlong(n); |
| 460 JVM_END | |
| 461 | |
| 462 | |
| 463 JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void)) | |
| 464 JVMWrapper("JVM_MaxMemory"); | |
| 465 size_t n = Universe::heap()->max_capacity(); | |
| 466 return convert_size_t_to_jlong(n); | |
| 467 JVM_END | |
| 468 | |
| 469 | |
| 470 JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void)) | |
| 471 JVMWrapper("JVM_ActiveProcessorCount"); | |
| 472 return os::active_processor_count(); | |
| 473 JVM_END | |
| 474 | |
| 475 | |
| 476 | |
| 477 // java.lang.Throwable ////////////////////////////////////////////////////// | |
| 478 | |
| 479 | |
| 480 JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver)) | |
| 481 JVMWrapper("JVM_FillInStackTrace"); | |
| 482 Handle exception(thread, JNIHandles::resolve_non_null(receiver)); | |
| 483 java_lang_Throwable::fill_in_stack_trace(exception); | |
| 484 JVM_END | |
| 485 | |
| 486 | |
| 487 JVM_ENTRY(void, JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)) | |
| 488 JVMWrapper("JVM_PrintStackTrace"); | |
| 489 // Note: This is no longer used in Merlin, but we still support it for compatibility. | |
| 490 oop exception = JNIHandles::resolve_non_null(receiver); | |
| 491 oop stream = JNIHandles::resolve_non_null(printable); | |
| 492 java_lang_Throwable::print_stack_trace(exception, stream); | |
| 493 JVM_END | |
| 494 | |
| 495 | |
| 496 JVM_ENTRY(jint, JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)) | |
| 497 JVMWrapper("JVM_GetStackTraceDepth"); | |
| 498 oop exception = JNIHandles::resolve(throwable); | |
| 499 return java_lang_Throwable::get_stack_trace_depth(exception, THREAD); | |
| 500 JVM_END | |
| 501 | |
| 502 | |
| 503 JVM_ENTRY(jobject, JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)) | |
| 504 JVMWrapper("JVM_GetStackTraceElement"); | |
| 505 JvmtiVMObjectAllocEventCollector oam; // This ctor (throughout this module) may trigger a safepoint/GC | |
| 506 oop exception = JNIHandles::resolve(throwable); | |
| 507 oop element = java_lang_Throwable::get_stack_trace_element(exception, index, CHECK_NULL); | |
| 508 return JNIHandles::make_local(env, element); | |
| 509 JVM_END | |
| 510 | |
| 511 | |
| 512 // java.lang.Object /////////////////////////////////////////////// | |
| 513 | |
| 514 | |
| 515 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle)) | |
| 516 JVMWrapper("JVM_IHashCode"); | |
| 517 // as implemented in the classic virtual machine; return 0 if object is NULL | |
| 518 return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ; | |
| 519 JVM_END | |
| 520 | |
| 521 | |
| 522 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)) | |
| 523 JVMWrapper("JVM_MonitorWait"); | |
| 524 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); | |
| 525 JavaThreadInObjectWaitState jtiows(thread, ms != 0); | |
| 526 if (JvmtiExport::should_post_monitor_wait()) { | |
| 527 JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms); | |
| 528 } | |
| 529 ObjectSynchronizer::wait(obj, ms, CHECK); | |
| 530 JVM_END | |
| 531 | |
| 532 | |
| 533 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle)) | |
| 534 JVMWrapper("JVM_MonitorNotify"); | |
| 535 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); | |
| 536 ObjectSynchronizer::notify(obj, CHECK); | |
| 537 JVM_END | |
| 538 | |
| 539 | |
| 540 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)) | |
| 541 JVMWrapper("JVM_MonitorNotifyAll"); | |
| 542 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); | |
| 543 ObjectSynchronizer::notifyall(obj, CHECK); | |
| 544 JVM_END | |
| 545 | |
| 546 | |
| 547 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle)) | |
| 548 JVMWrapper("JVM_Clone"); | |
| 549 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); | |
| 550 const KlassHandle klass (THREAD, obj->klass()); | |
| 551 JvmtiVMObjectAllocEventCollector oam; | |
| 552 | |
| 553 #ifdef ASSERT | |
| 554 // Just checking that the cloneable flag is set correct | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
555 if (obj->is_array()) { |
| 0 | 556 guarantee(klass->is_cloneable(), "all arrays are cloneable"); |
| 557 } else { | |
| 558 guarantee(obj->is_instance(), "should be instanceOop"); | |
| 1142 | 559 bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass()); |
| 0 | 560 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag"); |
| 561 } | |
| 562 #endif | |
| 563 | |
| 564 // Check if class of obj supports the Cloneable interface. | |
| 565 // All arrays are considered to be cloneable (See JLS 20.1.5) | |
| 566 if (!klass->is_cloneable()) { | |
| 567 ResourceMark rm(THREAD); | |
| 568 THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name()); | |
| 569 } | |
| 570 | |
| 571 // Make shallow object copy | |
| 572 const int size = obj->size(); | |
| 573 oop new_obj = NULL; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
574 if (obj->is_array()) { |
| 0 | 575 const int length = ((arrayOop)obj())->length(); |
| 576 new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL); | |
| 577 } else { | |
| 578 new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL); | |
| 579 } | |
| 580 // 4839641 (4840070): We must do an oop-atomic copy, because if another thread | |
| 581 // is modifying a reference field in the clonee, a non-oop-atomic copy might | |
| 582 // be suspended in the middle of copying the pointer and end up with parts | |
| 583 // of two different pointers in the field. Subsequent dereferences will crash. | |
| 584 // 4846409: an oop-copy of objects with long or double fields or arrays of same | |
| 585 // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead | |
| 586 // of oops. We know objects are aligned on a minimum of an jlong boundary. | |
| 587 // The same is true of StubRoutines::object_copy and the various oop_copy | |
| 588 // variants, and of the code generated by the inline_native_clone intrinsic. | |
| 589 assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned"); | |
| 590 Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj, | |
| 591 (size_t)align_object_size(size) / HeapWordsPerLong); | |
| 592 // Clear the header | |
| 593 new_obj->init_mark(); | |
| 594 | |
| 595 // Store check (mark entire object and let gc sort it out) | |
| 596 BarrierSet* bs = Universe::heap()->barrier_set(); | |
| 597 assert(bs->has_write_region_opt(), "Barrier set does not have write_region"); | |
| 598 bs->write_region(MemRegion((HeapWord*)new_obj, size)); | |
| 599 | |
| 600 // Caution: this involves a java upcall, so the clone should be | |
| 601 // "gc-robust" by this stage. | |
| 602 if (klass->has_finalizer()) { | |
| 603 assert(obj->is_instance(), "should be instanceOop"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
604 new_obj = InstanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL); |
| 0 | 605 } |
| 606 | |
| 607 return JNIHandles::make_local(env, oop(new_obj)); | |
| 608 JVM_END | |
| 609 | |
| 610 // java.lang.Compiler //////////////////////////////////////////////////// | |
| 611 | |
| 612 // The initial cuts of the HotSpot VM will not support JITs, and all existing | |
| 613 // JITs would need extensive changes to work with HotSpot. The JIT-related JVM | |
| 614 // functions are all silently ignored unless JVM warnings are printed. | |
| 615 | |
| 616 JVM_LEAF(void, JVM_InitializeCompiler (JNIEnv *env, jclass compCls)) | |
| 617 if (PrintJVMWarnings) warning("JVM_InitializeCompiler not supported"); | |
| 618 JVM_END | |
| 619 | |
| 620 | |
| 621 JVM_LEAF(jboolean, JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)) | |
| 622 if (PrintJVMWarnings) warning("JVM_IsSilentCompiler not supported"); | |
| 623 return JNI_FALSE; | |
| 624 JVM_END | |
| 625 | |
| 626 | |
| 627 JVM_LEAF(jboolean, JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)) | |
| 628 if (PrintJVMWarnings) warning("JVM_CompileClass not supported"); | |
| 629 return JNI_FALSE; | |
| 630 JVM_END | |
| 631 | |
| 632 | |
| 633 JVM_LEAF(jboolean, JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)) | |
| 634 if (PrintJVMWarnings) warning("JVM_CompileClasses not supported"); | |
| 635 return JNI_FALSE; | |
| 636 JVM_END | |
| 637 | |
| 638 | |
| 639 JVM_LEAF(jobject, JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)) | |
| 640 if (PrintJVMWarnings) warning("JVM_CompilerCommand not supported"); | |
| 641 return NULL; | |
| 642 JVM_END | |
| 643 | |
| 644 | |
| 645 JVM_LEAF(void, JVM_EnableCompiler(JNIEnv *env, jclass compCls)) | |
| 646 if (PrintJVMWarnings) warning("JVM_EnableCompiler not supported"); | |
| 647 JVM_END | |
| 648 | |
| 649 | |
| 650 JVM_LEAF(void, JVM_DisableCompiler(JNIEnv *env, jclass compCls)) | |
| 651 if (PrintJVMWarnings) warning("JVM_DisableCompiler not supported"); | |
| 652 JVM_END | |
| 653 | |
| 654 | |
| 655 | |
| 656 // Error message support ////////////////////////////////////////////////////// | |
| 657 | |
| 658 JVM_LEAF(jint, JVM_GetLastErrorString(char *buf, int len)) | |
| 659 JVMWrapper("JVM_GetLastErrorString"); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
660 return (jint)os::lasterror(buf, len); |
| 0 | 661 JVM_END |
| 662 | |
| 663 | |
| 664 // java.io.File /////////////////////////////////////////////////////////////// | |
| 665 | |
| 666 JVM_LEAF(char*, JVM_NativePath(char* path)) | |
| 667 JVMWrapper2("JVM_NativePath (%s)", path); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
668 return os::native_path(path); |
| 0 | 669 JVM_END |
| 670 | |
| 671 | |
| 672 // Misc. class handling /////////////////////////////////////////////////////////// | |
| 673 | |
| 674 | |
| 675 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth)) | |
| 676 JVMWrapper("JVM_GetCallerClass"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
677 Klass* k = thread->security_get_caller_class(depth); |
| 6983 | 678 return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror()); |
| 0 | 679 JVM_END |
| 680 | |
| 681 | |
| 682 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf)) | |
| 683 JVMWrapper("JVM_FindPrimitiveClass"); | |
| 684 oop mirror = NULL; | |
| 685 BasicType t = name2type(utf); | |
| 686 if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) { | |
| 687 mirror = Universe::java_mirror(t); | |
| 688 } | |
| 689 if (mirror == NULL) { | |
| 690 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf); | |
| 691 } else { | |
| 692 return (jclass) JNIHandles::make_local(env, mirror); | |
| 693 } | |
| 694 JVM_END | |
| 695 | |
| 696 | |
| 697 JVM_ENTRY(void, JVM_ResolveClass(JNIEnv* env, jclass cls)) | |
| 698 JVMWrapper("JVM_ResolveClass"); | |
| 699 if (PrintJVMWarnings) warning("JVM_ResolveClass not implemented"); | |
| 700 JVM_END | |
| 701 | |
|
878
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
702 |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
703 // Returns a class loaded by the bootstrap class loader; or null |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
704 // if not found. ClassNotFoundException is not thrown. |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
705 // |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
706 // Rationale behind JVM_FindClassFromBootLoader |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
707 // a> JVM_FindClassFromClassLoader was never exported in the export tables. |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
708 // b> because of (a) java.dll has a direct dependecy on the unexported |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
709 // private symbol "_JVM_FindClassFromClassLoader@20". |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
710 // c> the launcher cannot use the private symbol as it dynamically opens |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
711 // the entry point, so if something changes, the launcher will fail |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
712 // unexpectedly at runtime, it is safest for the launcher to dlopen a |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
713 // stable exported interface. |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
714 // d> re-exporting JVM_FindClassFromClassLoader as public, will cause its |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
715 // signature to change from _JVM_FindClassFromClassLoader@20 to |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
716 // JVM_FindClassFromClassLoader and will not be backward compatible |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
717 // with older JDKs. |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
718 // Thus a public/stable exported entry point is the right solution, |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
719 // public here means public in linker semantics, and is exported only |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
720 // to the JDK, and is not intended to be a public API. |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
721 |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
722 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env, |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
723 const char* name)) |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
724 JVMWrapper2("JVM_FindClassFromBootLoader %s", name); |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
725 |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
726 // Java libraries should ensure that name is never null... |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
727 if (name == NULL || (int)strlen(name) > Symbol::max_length()) { |
|
878
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
728 // It's impossible to create this class; the name cannot fit |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
729 // into the constant pool. |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
730 return NULL; |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
731 } |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
732 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
733 TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
734 Klass* k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL); |
|
878
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
735 if (k == NULL) { |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
736 return NULL; |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
737 } |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
738 |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
739 if (TraceClassResolution) { |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
740 trace_class_resolution(k); |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
741 } |
| 6983 | 742 return (jclass) JNIHandles::make_local(env, k->java_mirror()); |
|
878
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
743 JVM_END |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
744 |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
745 JVM_ENTRY(jclass, JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
746 jboolean init, jobject loader, |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
747 jboolean throwError)) |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
748 JVMWrapper3("JVM_FindClassFromClassLoader %s throw %s", name, |
|
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
749 throwError ? "error" : "exception"); |
| 388 | 750 // Java libraries should ensure that name is never null... |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
751 if (name == NULL || (int)strlen(name) > Symbol::max_length()) { |
| 388 | 752 // It's impossible to create this class; the name cannot fit |
| 753 // into the constant pool. | |
| 754 if (throwError) { | |
| 755 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); | |
| 756 } else { | |
| 757 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), name); | |
| 758 } | |
| 759 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
760 TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL); |
| 388 | 761 Handle h_loader(THREAD, JNIHandles::resolve(loader)); |
| 762 jclass result = find_class_from_class_loader(env, h_name, init, h_loader, | |
| 763 Handle(), throwError, THREAD); | |
| 764 | |
| 765 if (TraceClassResolution && result != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
766 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))); |
| 388 | 767 } |
| 768 return result; | |
| 0 | 769 JVM_END |
| 770 | |
| 771 | |
| 772 JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name, | |
| 773 jboolean init, jclass from)) | |
| 774 JVMWrapper2("JVM_FindClassFromClass %s", name); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
775 if (name == NULL || (int)strlen(name) > Symbol::max_length()) { |
| 0 | 776 // It's impossible to create this class; the name cannot fit |
| 777 // into the constant pool. | |
| 778 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); | |
| 779 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
780 TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL); |
| 0 | 781 oop from_class_oop = JNIHandles::resolve(from); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
782 Klass* from_class = (from_class_oop == NULL) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
783 ? (Klass*)NULL |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
784 : java_lang_Class::as_Klass(from_class_oop); |
| 0 | 785 oop class_loader = NULL; |
| 786 oop protection_domain = NULL; | |
| 787 if (from_class != NULL) { | |
| 6983 | 788 class_loader = from_class->class_loader(); |
| 789 protection_domain = from_class->protection_domain(); | |
| 0 | 790 } |
| 791 Handle h_loader(THREAD, class_loader); | |
| 792 Handle h_prot (THREAD, protection_domain); | |
| 793 jclass result = find_class_from_class_loader(env, h_name, init, h_loader, | |
| 794 h_prot, true, thread); | |
| 795 | |
| 796 if (TraceClassResolution && result != NULL) { | |
| 797 // this function is generally only used for class loading during verification. | |
| 798 ResourceMark rm; | |
| 799 oop from_mirror = JNIHandles::resolve_non_null(from); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
800 Klass* from_class = java_lang_Class::as_Klass(from_mirror); |
| 6983 | 801 const char * from_name = from_class->external_name(); |
| 0 | 802 |
| 803 oop mirror = JNIHandles::resolve_non_null(result); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
804 Klass* to_class = java_lang_Class::as_Klass(mirror); |
| 6983 | 805 const char * to = to_class->external_name(); |
| 0 | 806 tty->print("RESOLVE %s %s (verification)\n", from_name, to); |
| 807 } | |
| 808 | |
| 809 return result; | |
| 810 JVM_END | |
| 811 | |
| 812 static void is_lock_held_by_thread(Handle loader, PerfCounter* counter, TRAPS) { | |
| 813 if (loader.is_null()) { | |
| 814 return; | |
| 815 } | |
| 816 | |
| 817 // check whether the current caller thread holds the lock or not. | |
| 818 // If not, increment the corresponding counter | |
| 819 if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader) != | |
| 820 ObjectSynchronizer::owner_self) { | |
| 821 counter->inc(); | |
| 822 } | |
| 823 } | |
| 824 | |
| 825 // common code for JVM_DefineClass() and JVM_DefineClassWithSource() | |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
826 // and JVM_DefineClassWithSourceCond() |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
827 static jclass jvm_define_class_common(JNIEnv *env, const char *name, |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
828 jobject loader, const jbyte *buf, |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
829 jsize len, jobject pd, const char *source, |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
830 jboolean verify, TRAPS) { |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
388
diff
changeset
|
831 if (source == NULL) source = "__JVM_DefineClass__"; |
| 0 | 832 |
|
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
833 assert(THREAD->is_Java_thread(), "must be a JavaThread"); |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
834 JavaThread* jt = (JavaThread*) THREAD; |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
835 |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
836 PerfClassTraceTime vmtimer(ClassLoader::perf_define_appclass_time(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
837 ClassLoader::perf_define_appclass_selftime(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
838 ClassLoader::perf_define_appclasses(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
839 jt->get_thread_stat()->perf_recursion_counts_addr(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
840 jt->get_thread_stat()->perf_timers_addr(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
841 PerfClassTraceTime::DEFINE_CLASS); |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
842 |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
843 if (UsePerfData) { |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
844 ClassLoader::perf_app_classfile_bytes_read()->inc(len); |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
845 } |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
846 |
| 0 | 847 // Since exceptions can be thrown, class initialization can take place |
| 848 // if name is NULL no check for class name in .class stream has to be made. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
849 TempNewSymbol class_name = NULL; |
| 0 | 850 if (name != NULL) { |
| 851 const int str_len = (int)strlen(name); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
852 if (str_len > Symbol::max_length()) { |
| 0 | 853 // It's impossible to create this class; the name cannot fit |
| 854 // into the constant pool. | |
| 855 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); | |
| 856 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
857 class_name = SymbolTable::new_symbol(name, str_len, CHECK_NULL); |
| 0 | 858 } |
| 859 | |
| 860 ResourceMark rm(THREAD); | |
| 861 ClassFileStream st((u1*) buf, len, (char *)source); | |
| 862 Handle class_loader (THREAD, JNIHandles::resolve(loader)); | |
| 863 if (UsePerfData) { | |
| 864 is_lock_held_by_thread(class_loader, | |
| 865 ClassLoader::sync_JVMDefineClassLockFreeCounter(), | |
| 866 THREAD); | |
| 867 } | |
| 868 Handle protection_domain (THREAD, JNIHandles::resolve(pd)); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
869 Klass* k = SystemDictionary::resolve_from_stream(class_name, class_loader, |
| 0 | 870 protection_domain, &st, |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
871 verify != 0, |
| 0 | 872 CHECK_NULL); |
| 873 | |
| 874 if (TraceClassResolution && k != NULL) { | |
| 875 trace_class_resolution(k); | |
| 876 } | |
| 877 | |
| 6983 | 878 return (jclass) JNIHandles::make_local(env, k->java_mirror()); |
| 0 | 879 } |
| 880 | |
| 881 | |
| 882 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)) | |
| 883 JVMWrapper2("JVM_DefineClass %s", name); | |
| 884 | |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
885 return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, true, THREAD); |
| 0 | 886 JVM_END |
| 887 | |
| 888 | |
| 889 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)) | |
| 890 JVMWrapper2("JVM_DefineClassWithSource %s", name); | |
| 891 | |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
892 return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD); |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
893 JVM_END |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
894 |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
895 JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
896 jobject loader, const jbyte *buf, |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
897 jsize len, jobject pd, |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
898 const char *source, jboolean verify)) |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
899 JVMWrapper2("JVM_DefineClassWithSourceCond %s", name); |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
900 |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
901 return jvm_define_class_common(env, name, loader, buf, len, pd, source, verify, THREAD); |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
878
diff
changeset
|
902 JVM_END |
| 0 | 903 |
| 904 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)) | |
| 905 JVMWrapper("JVM_FindLoadedClass"); | |
| 906 ResourceMark rm(THREAD); | |
| 907 | |
| 908 Handle h_name (THREAD, JNIHandles::resolve_non_null(name)); | |
| 909 Handle string = java_lang_String::internalize_classname(h_name, CHECK_NULL); | |
| 910 | |
| 911 const char* str = java_lang_String::as_utf8_string(string()); | |
| 912 // Sanity check, don't expect null | |
| 913 if (str == NULL) return NULL; | |
| 914 | |
| 915 const int str_len = (int)strlen(str); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
916 if (str_len > Symbol::max_length()) { |
| 0 | 917 // It's impossible to create this class; the name cannot fit |
| 918 // into the constant pool. | |
| 919 return NULL; | |
| 920 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
921 TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len, CHECK_NULL); |
| 0 | 922 |
| 923 // Security Note: | |
| 924 // The Java level wrapper will perform the necessary security check allowing | |
| 925 // us to pass the NULL as the initiating class loader. | |
| 926 Handle h_loader(THREAD, JNIHandles::resolve(loader)); | |
| 927 if (UsePerfData) { | |
| 928 is_lock_held_by_thread(h_loader, | |
| 929 ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(), | |
| 930 THREAD); | |
| 931 } | |
| 932 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
933 Klass* k = SystemDictionary::find_instance_or_array_klass(klass_name, |
| 0 | 934 h_loader, |
| 935 Handle(), | |
| 936 CHECK_NULL); | |
| 937 | |
| 938 return (k == NULL) ? NULL : | |
| 6983 | 939 (jclass) JNIHandles::make_local(env, k->java_mirror()); |
| 0 | 940 JVM_END |
| 941 | |
| 942 | |
| 943 // Reflection support ////////////////////////////////////////////////////////////////////////////// | |
| 944 | |
| 945 JVM_ENTRY(jstring, JVM_GetClassName(JNIEnv *env, jclass cls)) | |
| 946 assert (cls != NULL, "illegal class"); | |
| 947 JVMWrapper("JVM_GetClassName"); | |
| 948 JvmtiVMObjectAllocEventCollector oam; | |
| 949 ResourceMark rm(THREAD); | |
| 950 const char* name; | |
| 951 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { | |
| 952 name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls))); | |
| 953 } else { | |
| 954 // Consider caching interned string in Klass | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
955 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); |
| 0 | 956 assert(k->is_klass(), "just checking"); |
| 6983 | 957 name = k->external_name(); |
| 0 | 958 } |
| 959 oop result = StringTable::intern((char*) name, CHECK_NULL); | |
| 960 return (jstring) JNIHandles::make_local(env, result); | |
| 961 JVM_END | |
| 962 | |
| 963 | |
| 964 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls)) | |
| 965 JVMWrapper("JVM_GetClassInterfaces"); | |
| 966 JvmtiVMObjectAllocEventCollector oam; | |
| 967 oop mirror = JNIHandles::resolve_non_null(cls); | |
| 968 | |
| 969 // Special handling for primitive objects | |
| 970 if (java_lang_Class::is_primitive(mirror)) { | |
| 971 // Primitive objects does not have any interfaces | |
| 1142 | 972 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); |
| 0 | 973 return (jobjectArray) JNIHandles::make_local(env, r); |
| 974 } | |
| 975 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
976 KlassHandle klass(thread, java_lang_Class::as_Klass(mirror)); |
| 0 | 977 // Figure size of result array |
| 978 int size; | |
| 979 if (klass->oop_is_instance()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
980 size = InstanceKlass::cast(klass())->local_interfaces()->length(); |
| 0 | 981 } else { |
| 982 assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass"); | |
| 983 size = 2; | |
| 984 } | |
| 985 | |
| 986 // Allocate result array | |
| 1142 | 987 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), size, CHECK_NULL); |
| 0 | 988 objArrayHandle result (THREAD, r); |
| 989 // Fill in result | |
| 990 if (klass->oop_is_instance()) { | |
| 991 // Regular instance klass, fill in all local interfaces | |
| 992 for (int index = 0; index < size; index++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
993 Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index); |
| 6983 | 994 result->obj_at_put(index, k->java_mirror()); |
| 0 | 995 } |
| 996 } else { | |
| 997 // All arrays implement java.lang.Cloneable and java.io.Serializable | |
| 6983 | 998 result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror()); |
| 999 result->obj_at_put(1, SystemDictionary::Serializable_klass()->java_mirror()); | |
| 0 | 1000 } |
| 1001 return (jobjectArray) JNIHandles::make_local(env, result()); | |
| 1002 JVM_END | |
| 1003 | |
| 1004 | |
| 1005 JVM_ENTRY(jobject, JVM_GetClassLoader(JNIEnv *env, jclass cls)) | |
| 1006 JVMWrapper("JVM_GetClassLoader"); | |
| 1007 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { | |
| 1008 return NULL; | |
| 1009 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1010 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 6983 | 1011 oop loader = k->class_loader(); |
| 0 | 1012 return JNIHandles::make_local(env, loader); |
| 1013 JVM_END | |
| 1014 | |
| 1015 | |
| 1016 JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls)) | |
| 1017 JVMWrapper("JVM_IsInterface"); | |
| 1018 oop mirror = JNIHandles::resolve_non_null(cls); | |
| 1019 if (java_lang_Class::is_primitive(mirror)) { | |
| 1020 return JNI_FALSE; | |
| 1021 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1022 Klass* k = java_lang_Class::as_Klass(mirror); |
| 6983 | 1023 jboolean result = k->is_interface(); |
| 1024 assert(!result || k->oop_is_instance(), | |
| 0 | 1025 "all interfaces are instance types"); |
| 1026 // The compiler intrinsic for isInterface tests the | |
| 1027 // Klass::_access_flags bits in the same way. | |
| 1028 return result; | |
| 1029 JVM_END | |
| 1030 | |
| 1031 | |
| 1032 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls)) | |
| 1033 JVMWrapper("JVM_GetClassSigners"); | |
| 1034 JvmtiVMObjectAllocEventCollector oam; | |
| 1035 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { | |
| 1036 // There are no signers for primitive types | |
| 1037 return NULL; | |
| 1038 } | |
| 1039 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1040 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 1041 objArrayOop signers = NULL; |
| 6983 | 1042 if (k->oop_is_instance()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1043 signers = InstanceKlass::cast(k)->signers(); |
| 0 | 1044 } |
| 1045 | |
| 1046 // If there are no signers set in the class, or if the class | |
| 1047 // is an array, return NULL. | |
| 1048 if (signers == NULL) return NULL; | |
| 1049 | |
| 1050 // copy of the signers array | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
1051 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass(); |
| 0 | 1052 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL); |
| 1053 for (int index = 0; index < signers->length(); index++) { | |
| 1054 signers_copy->obj_at_put(index, signers->obj_at(index)); | |
| 1055 } | |
| 1056 | |
| 1057 // return the copy | |
| 1058 return (jobjectArray) JNIHandles::make_local(env, signers_copy); | |
| 1059 JVM_END | |
| 1060 | |
| 1061 | |
| 1062 JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)) | |
| 1063 JVMWrapper("JVM_SetClassSigners"); | |
| 1064 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { | |
| 1065 // This call is ignored for primitive types and arrays. | |
| 1066 // Signers are only set once, ClassLoader.java, and thus shouldn't | |
| 1067 // be called with an array. Only the bootstrap loader creates arrays. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1068 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 6983 | 1069 if (k->oop_is_instance()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1070 InstanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers))); |
| 0 | 1071 } |
| 1072 } | |
| 1073 JVM_END | |
| 1074 | |
| 1075 | |
| 1076 JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls)) | |
| 1077 JVMWrapper("JVM_GetProtectionDomain"); | |
| 1078 if (JNIHandles::resolve(cls) == NULL) { | |
| 1079 THROW_(vmSymbols::java_lang_NullPointerException(), NULL); | |
| 1080 } | |
| 1081 | |
| 1082 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { | |
| 1083 // Primitive types does not have a protection domain. | |
| 1084 return NULL; | |
| 1085 } | |
| 1086 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1087 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); |
| 6983 | 1088 return (jobject) JNIHandles::make_local(env, k->protection_domain()); |
| 0 | 1089 JVM_END |
| 1090 | |
| 1091 | |
| 1092 // Obsolete since 1.2 (Class.setProtectionDomain removed), although | |
| 1093 // still defined in core libraries as of 1.5. | |
| 1094 JVM_ENTRY(void, JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)) | |
| 1095 JVMWrapper("JVM_SetProtectionDomain"); | |
| 1096 if (JNIHandles::resolve(cls) == NULL) { | |
| 1097 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 1098 } | |
| 1099 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { | |
| 1100 // Call is ignored for primitive types | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1101 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); |
| 0 | 1102 |
| 1103 // cls won't be an array, as this called only from ClassLoader.defineClass | |
| 6983 | 1104 if (k->oop_is_instance()) { |
| 0 | 1105 oop pd = JNIHandles::resolve(protection_domain); |
| 1106 assert(pd == NULL || pd->is_oop(), "just checking"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1107 InstanceKlass::cast(k)->set_protection_domain(pd); |
| 0 | 1108 } |
| 1109 } | |
| 1110 JVM_END | |
| 1111 | |
| 1112 | |
| 1113 JVM_ENTRY(jobject, JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)) | |
| 1114 JVMWrapper("JVM_DoPrivileged"); | |
| 1115 | |
| 1116 if (action == NULL) { | |
| 1117 THROW_MSG_0(vmSymbols::java_lang_NullPointerException(), "Null action"); | |
| 1118 } | |
| 1119 | |
| 1120 // Stack allocated list of privileged stack elements | |
| 1121 PrivilegedElement pi; | |
| 1122 | |
| 1123 // Check that action object understands "Object run()" | |
| 1124 Handle object (THREAD, JNIHandles::resolve(action)); | |
| 1125 | |
| 1126 // get run() method | |
| 6983 | 1127 Method* m_oop = object->klass()->uncached_lookup_method( |
| 0 | 1128 vmSymbols::run_method_name(), |
| 1129 vmSymbols::void_object_signature()); | |
| 1130 methodHandle m (THREAD, m_oop); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1131 if (m.is_null() || !m->is_method() || !m()->is_public() || m()->is_static()) { |
| 0 | 1132 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method"); |
| 1133 } | |
| 1134 | |
| 1135 // Compute the frame initiating the do privileged operation and setup the privileged stack | |
| 1136 vframeStream vfst(thread); | |
| 1137 vfst.security_get_caller_frame(1); | |
| 1138 | |
| 1139 if (!vfst.at_end()) { | |
| 1140 pi.initialize(&vfst, JNIHandles::resolve(context), thread->privileged_stack_top(), CHECK_NULL); | |
| 1141 thread->set_privileged_stack_top(&pi); | |
| 1142 } | |
| 1143 | |
| 1144 | |
| 1145 // invoke the Object run() in the action object. We cannot use call_interface here, since the static type | |
| 1146 // is not really known - it is either java.security.PrivilegedAction or java.security.PrivilegedExceptionAction | |
| 1147 Handle pending_exception; | |
| 1148 JavaValue result(T_OBJECT); | |
| 1149 JavaCallArguments args(object); | |
| 1150 JavaCalls::call(&result, m, &args, THREAD); | |
| 1151 | |
| 1152 // done with action, remove ourselves from the list | |
| 1153 if (!vfst.at_end()) { | |
| 1154 assert(thread->privileged_stack_top() != NULL && thread->privileged_stack_top() == &pi, "wrong top element"); | |
| 1155 thread->set_privileged_stack_top(thread->privileged_stack_top()->next()); | |
| 1156 } | |
| 1157 | |
| 1158 if (HAS_PENDING_EXCEPTION) { | |
| 1159 pending_exception = Handle(THREAD, PENDING_EXCEPTION); | |
| 1160 CLEAR_PENDING_EXCEPTION; | |
| 1161 | |
| 1142 | 1162 if ( pending_exception->is_a(SystemDictionary::Exception_klass()) && |
| 1163 !pending_exception->is_a(SystemDictionary::RuntimeException_klass())) { | |
| 0 | 1164 // Throw a java.security.PrivilegedActionException(Exception e) exception |
| 1165 JavaCallArguments args(pending_exception); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1166 THROW_ARG_0(vmSymbols::java_security_PrivilegedActionException(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1167 vmSymbols::exception_void_signature(), |
| 0 | 1168 &args); |
| 1169 } | |
| 1170 } | |
| 1171 | |
| 1172 if (pending_exception.not_null()) THROW_OOP_0(pending_exception()); | |
| 1173 return JNIHandles::make_local(env, (oop) result.get_jobject()); | |
| 1174 JVM_END | |
| 1175 | |
| 1176 | |
| 1177 // Returns the inherited_access_control_context field of the running thread. | |
| 1178 JVM_ENTRY(jobject, JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)) | |
| 1179 JVMWrapper("JVM_GetInheritedAccessControlContext"); | |
| 1180 oop result = java_lang_Thread::inherited_access_control_context(thread->threadObj()); | |
| 1181 return JNIHandles::make_local(env, result); | |
| 1182 JVM_END | |
| 1183 | |
| 1184 class RegisterArrayForGC { | |
| 1185 private: | |
| 1186 JavaThread *_thread; | |
| 1187 public: | |
| 1188 RegisterArrayForGC(JavaThread *thread, GrowableArray<oop>* array) { | |
| 1189 _thread = thread; | |
| 1190 _thread->register_array_for_gc(array); | |
| 1191 } | |
| 1192 | |
| 1193 ~RegisterArrayForGC() { | |
| 1194 _thread->register_array_for_gc(NULL); | |
| 1195 } | |
| 1196 }; | |
| 1197 | |
| 1198 | |
| 1199 JVM_ENTRY(jobject, JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)) | |
| 1200 JVMWrapper("JVM_GetStackAccessControlContext"); | |
| 1201 if (!UsePrivilegedStack) return NULL; | |
| 1202 | |
| 1203 ResourceMark rm(THREAD); | |
| 1204 GrowableArray<oop>* local_array = new GrowableArray<oop>(12); | |
| 1205 JvmtiVMObjectAllocEventCollector oam; | |
| 1206 | |
| 1207 // count the protection domains on the execution stack. We collapse | |
| 1208 // duplicate consecutive protection domains into a single one, as | |
| 1209 // well as stopping when we hit a privileged frame. | |
| 1210 | |
| 1211 // Use vframeStream to iterate through Java frames | |
| 1212 vframeStream vfst(thread); | |
| 1213 | |
| 1214 oop previous_protection_domain = NULL; | |
| 1215 Handle privileged_context(thread, NULL); | |
| 1216 bool is_privileged = false; | |
| 1217 oop protection_domain = NULL; | |
| 1218 | |
| 1219 for(; !vfst.at_end(); vfst.next()) { | |
| 1220 // get method of frame | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1221 Method* method = vfst.method(); |
| 0 | 1222 intptr_t* frame_id = vfst.frame_id(); |
| 1223 | |
| 1224 // check the privileged frames to see if we have a match | |
| 1225 if (thread->privileged_stack_top() && thread->privileged_stack_top()->frame_id() == frame_id) { | |
| 1226 // this frame is privileged | |
| 1227 is_privileged = true; | |
| 1228 privileged_context = Handle(thread, thread->privileged_stack_top()->privileged_context()); | |
| 1229 protection_domain = thread->privileged_stack_top()->protection_domain(); | |
| 1230 } else { | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
1231 protection_domain = method->method_holder()->protection_domain(); |
| 0 | 1232 } |
| 1233 | |
| 1234 if ((previous_protection_domain != protection_domain) && (protection_domain != NULL)) { | |
| 1235 local_array->push(protection_domain); | |
| 1236 previous_protection_domain = protection_domain; | |
| 1237 } | |
| 1238 | |
| 1239 if (is_privileged) break; | |
| 1240 } | |
| 1241 | |
| 1242 | |
| 1243 // either all the domains on the stack were system domains, or | |
| 1244 // we had a privileged system domain | |
| 1245 if (local_array->is_empty()) { | |
| 1246 if (is_privileged && privileged_context.is_null()) return NULL; | |
| 1247 | |
| 1248 oop result = java_security_AccessControlContext::create(objArrayHandle(), is_privileged, privileged_context, CHECK_NULL); | |
| 1249 return JNIHandles::make_local(env, result); | |
| 1250 } | |
| 1251 | |
| 1252 // the resource area must be registered in case of a gc | |
| 1253 RegisterArrayForGC ragc(thread, local_array); | |
| 1142 | 1254 objArrayOop context = oopFactory::new_objArray(SystemDictionary::ProtectionDomain_klass(), |
| 0 | 1255 local_array->length(), CHECK_NULL); |
| 1256 objArrayHandle h_context(thread, context); | |
| 1257 for (int index = 0; index < local_array->length(); index++) { | |
| 1258 h_context->obj_at_put(index, local_array->at(index)); | |
| 1259 } | |
| 1260 | |
| 1261 oop result = java_security_AccessControlContext::create(h_context, is_privileged, privileged_context, CHECK_NULL); | |
| 1262 | |
| 1263 return JNIHandles::make_local(env, result); | |
| 1264 JVM_END | |
| 1265 | |
| 1266 | |
| 1267 JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls)) | |
| 1268 JVMWrapper("JVM_IsArrayClass"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1269 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 6983 | 1270 return (k != NULL) && k->oop_is_array() ? true : false; |
| 0 | 1271 JVM_END |
| 1272 | |
| 1273 | |
| 1274 JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)) | |
| 1275 JVMWrapper("JVM_IsPrimitiveClass"); | |
| 1276 oop mirror = JNIHandles::resolve_non_null(cls); | |
| 1277 return (jboolean) java_lang_Class::is_primitive(mirror); | |
| 1278 JVM_END | |
| 1279 | |
| 1280 | |
| 1281 JVM_ENTRY(jclass, JVM_GetComponentType(JNIEnv *env, jclass cls)) | |
| 1282 JVMWrapper("JVM_GetComponentType"); | |
| 1283 oop mirror = JNIHandles::resolve_non_null(cls); | |
| 1284 oop result = Reflection::array_component_type(mirror, CHECK_NULL); | |
| 1285 return (jclass) JNIHandles::make_local(env, result); | |
| 1286 JVM_END | |
| 1287 | |
| 1288 | |
| 1289 JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv *env, jclass cls)) | |
| 1290 JVMWrapper("JVM_GetClassModifiers"); | |
| 1291 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { | |
| 1292 // Primitive type | |
| 1293 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; | |
| 1294 } | |
| 1295 | |
| 6983 | 1296 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 1297 debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0)); |
| 1298 assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK"); | |
| 1299 return k->modifier_flags(); | |
| 1300 JVM_END | |
| 1301 | |
| 1302 | |
| 1303 // Inner class reflection /////////////////////////////////////////////////////////////////////////////// | |
| 1304 | |
| 1305 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)) | |
| 1306 JvmtiVMObjectAllocEventCollector oam; | |
| 1307 // ofClass is a reference to a java_lang_Class object. The mirror object | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1308 // of an InstanceKlass |
| 0 | 1309 |
| 1310 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || | |
| 6983 | 1311 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_instance()) { |
| 1142 | 1312 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); |
| 0 | 1313 return (jobjectArray)JNIHandles::make_local(env, result); |
| 1314 } | |
| 1315 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1316 instanceKlassHandle k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); |
|
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1317 InnerClassesIterator iter(k); |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1318 |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1319 if (iter.length() == 0) { |
| 0 | 1320 // Neither an inner nor outer class |
| 1142 | 1321 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); |
| 0 | 1322 return (jobjectArray)JNIHandles::make_local(env, result); |
| 1323 } | |
| 1324 | |
| 1325 // find inner class info | |
| 1326 constantPoolHandle cp(thread, k->constants()); | |
|
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1327 int length = iter.length(); |
| 0 | 1328 |
| 1329 // Allocate temp. result array | |
| 1142 | 1330 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), length/4, CHECK_NULL); |
| 0 | 1331 objArrayHandle result (THREAD, r); |
| 1332 int members = 0; | |
| 1333 | |
|
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1334 for (; !iter.done(); iter.next()) { |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1335 int ioff = iter.inner_class_info_index(); |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1336 int ooff = iter.outer_class_info_index(); |
| 0 | 1337 |
| 1338 if (ioff != 0 && ooff != 0) { | |
| 1339 // Check to see if the name matches the class we're looking for | |
| 1340 // before attempting to find the class. | |
| 1341 if (cp->klass_name_at_matches(k, ooff)) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1342 Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL); |
| 0 | 1343 if (outer_klass == k()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1344 Klass* ik = cp->klass_at(ioff, CHECK_NULL); |
| 0 | 1345 instanceKlassHandle inner_klass (THREAD, ik); |
| 1346 | |
| 1347 // Throws an exception if outer klass has not declared k as | |
| 1348 // an inner klass | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1349 Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL); |
| 0 | 1350 |
| 1351 result->obj_at_put(members, inner_klass->java_mirror()); | |
| 1352 members++; | |
| 1353 } | |
| 1354 } | |
| 1355 } | |
| 1356 } | |
| 1357 | |
| 1358 if (members != length) { | |
| 1359 // Return array of right length | |
| 1142 | 1360 objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL); |
| 0 | 1361 for(int i = 0; i < members; i++) { |
| 1362 res->obj_at_put(i, result->obj_at(i)); | |
| 1363 } | |
| 1364 return (jobjectArray)JNIHandles::make_local(env, res); | |
| 1365 } | |
| 1366 | |
| 1367 return (jobjectArray)JNIHandles::make_local(env, result()); | |
| 1368 JVM_END | |
| 1369 | |
| 1370 | |
| 1371 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)) | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1372 { |
| 0 | 1373 // ofClass is a reference to a java_lang_Class object. |
| 1374 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || | |
| 6983 | 1375 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_instance()) { |
| 0 | 1376 return NULL; |
| 1377 } | |
| 1378 | |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1379 bool inner_is_member = false; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1380 Klass* outer_klass |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1381 = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)) |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1382 )->compute_enclosing_class(&inner_is_member, CHECK_NULL); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1383 if (outer_klass == NULL) return NULL; // already a top-level class |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1384 if (!inner_is_member) return NULL; // an anonymous class (inside a method) |
| 6983 | 1385 return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror()); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1386 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1387 JVM_END |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1388 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1389 // should be in InstanceKlass.cpp, but is here for historical reasons |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1390 Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k, |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1391 bool* inner_is_member, |
|
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1392 TRAPS) { |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1393 Thread* thread = THREAD; |
|
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1394 InnerClassesIterator iter(k); |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1395 if (iter.length() == 0) { |
| 0 | 1396 // No inner class info => no declaring class |
| 1397 return NULL; | |
| 1398 } | |
| 1399 | |
| 1400 constantPoolHandle i_cp(thread, k->constants()); | |
| 1401 | |
| 1402 bool found = false; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1403 Klass* ok; |
| 0 | 1404 instanceKlassHandle outer_klass; |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1405 *inner_is_member = false; |
| 0 | 1406 |
| 1407 // Find inner_klass attribute | |
|
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1408 for (; !iter.done() && !found; iter.next()) { |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1409 int ioff = iter.inner_class_info_index(); |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1410 int ooff = iter.outer_class_info_index(); |
|
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4872
diff
changeset
|
1411 int noff = iter.inner_name_index(); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1412 if (ioff != 0) { |
| 0 | 1413 // Check to see if the name matches the class we're looking for |
| 1414 // before attempting to find the class. | |
| 1415 if (i_cp->klass_name_at_matches(k, ioff)) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1416 Klass* inner_klass = i_cp->klass_at(ioff, CHECK_NULL); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1417 found = (k() == inner_klass); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1418 if (found && ooff != 0) { |
| 0 | 1419 ok = i_cp->klass_at(ooff, CHECK_NULL); |
| 1420 outer_klass = instanceKlassHandle(thread, ok); | |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1421 *inner_is_member = true; |
| 0 | 1422 } |
| 1423 } | |
| 1424 } | |
| 1425 } | |
| 1426 | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1427 if (found && outer_klass.is_null()) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1428 // It may be anonymous; try for that. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1429 int encl_method_class_idx = k->enclosing_method_class_index(); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1430 if (encl_method_class_idx != 0) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1431 ok = i_cp->klass_at(encl_method_class_idx, CHECK_NULL); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1432 outer_klass = instanceKlassHandle(thread, ok); |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1433 *inner_is_member = false; |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1434 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1435 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1436 |
| 0 | 1437 // If no inner class attribute found for this class. |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1438 if (outer_klass.is_null()) return NULL; |
| 0 | 1439 |
| 1440 // Throws an exception if outer klass has not declared k as an inner klass | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1441 // We need evidence that each klass knows about the other, or else |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1442 // the system could allow a spoof of an inner class to gain access rights. |
|
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1059
diff
changeset
|
1443 Reflection::check_for_inner_class(outer_klass, k, *inner_is_member, CHECK_NULL); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1444 return outer_klass(); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
1445 } |
| 0 | 1446 |
| 1447 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls)) | |
| 1448 assert (cls != NULL, "illegal class"); | |
| 1449 JVMWrapper("JVM_GetClassSignature"); | |
| 1450 JvmtiVMObjectAllocEventCollector oam; | |
| 1451 ResourceMark rm(THREAD); | |
| 1452 // Return null for arrays and primatives | |
| 1453 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1454 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); |
| 6983 | 1455 if (k->oop_is_instance()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1456 Symbol* sym = InstanceKlass::cast(k)->generic_signature(); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1457 if (sym == NULL) return NULL; |
| 0 | 1458 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); |
| 1459 return (jstring) JNIHandles::make_local(env, str()); | |
| 1460 } | |
| 1461 } | |
| 1462 return NULL; | |
| 1463 JVM_END | |
| 1464 | |
| 1465 | |
| 1466 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls)) | |
| 1467 assert (cls != NULL, "illegal class"); | |
| 1468 JVMWrapper("JVM_GetClassAnnotations"); | |
| 1469 ResourceMark rm(THREAD); | |
| 1470 // Return null for arrays and primitives | |
| 1471 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1472 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); |
| 6983 | 1473 if (k->oop_is_instance()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1474 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1475 return (jbyteArray) JNIHandles::make_local(env, a); |
| 0 | 1476 } |
| 1477 } | |
| 1478 return NULL; | |
| 1479 JVM_END | |
| 1480 | |
| 1481 | |
| 1482 JVM_ENTRY(jbyteArray, JVM_GetFieldAnnotations(JNIEnv *env, jobject field)) | |
| 1483 assert(field != NULL, "illegal field"); | |
| 1484 JVMWrapper("JVM_GetFieldAnnotations"); | |
| 1485 | |
| 1486 // some of this code was adapted from from jni_FromReflectedField | |
| 1487 | |
| 1488 // field is a handle to a java.lang.reflect.Field object | |
| 1489 oop reflected = JNIHandles::resolve_non_null(field); | |
| 1490 oop mirror = java_lang_reflect_Field::clazz(reflected); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1491 Klass* k = java_lang_Class::as_Klass(mirror); |
| 0 | 1492 int slot = java_lang_reflect_Field::slot(reflected); |
| 1493 int modifiers = java_lang_reflect_Field::modifiers(reflected); | |
| 1494 | |
| 1495 fieldDescriptor fd; | |
| 1496 KlassHandle kh(THREAD, k); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1497 intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot); |
| 0 | 1498 |
| 1499 if (modifiers & JVM_ACC_STATIC) { | |
| 1500 // for static fields we only look in the current class | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1501 if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) { |
| 0 | 1502 assert(false, "cannot find static field"); |
| 1503 return NULL; // robustness | |
| 1504 } | |
| 1505 } else { | |
| 1506 // for instance fields we start with the current class and work | |
| 1507 // our way up through the superclass chain | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1508 if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) { |
| 0 | 1509 assert(false, "cannot find instance field"); |
| 1510 return NULL; // robustness | |
| 1511 } | |
| 1512 } | |
| 1513 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1514 return (jbyteArray) JNIHandles::make_local(env, Annotations::make_java_array(fd.annotations(), THREAD)); |
| 0 | 1515 JVM_END |
| 1516 | |
| 1517 | |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1518 static Method* jvm_get_method_common(jobject method) { |
| 0 | 1519 // some of this code was adapted from from jni_FromReflectedMethod |
| 1520 | |
| 1521 oop reflected = JNIHandles::resolve_non_null(method); | |
| 1522 oop mirror = NULL; | |
| 1523 int slot = 0; | |
| 1524 | |
| 1142 | 1525 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) { |
| 0 | 1526 mirror = java_lang_reflect_Constructor::clazz(reflected); |
| 1527 slot = java_lang_reflect_Constructor::slot(reflected); | |
| 1528 } else { | |
| 1142 | 1529 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), |
| 0 | 1530 "wrong type"); |
| 1531 mirror = java_lang_reflect_Method::clazz(reflected); | |
| 1532 slot = java_lang_reflect_Method::slot(reflected); | |
| 1533 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1534 Klass* k = java_lang_Class::as_Klass(mirror); |
| 0 | 1535 |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1536 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot); |
| 0 | 1537 if (m == NULL) { |
| 1538 assert(false, "cannot find method"); | |
| 1539 return NULL; // robustness | |
| 1540 } | |
| 1541 | |
| 1542 return m; | |
| 1543 } | |
| 1544 | |
| 1545 | |
| 1546 JVM_ENTRY(jbyteArray, JVM_GetMethodAnnotations(JNIEnv *env, jobject method)) | |
| 1547 JVMWrapper("JVM_GetMethodAnnotations"); | |
| 1548 | |
| 1549 // method is a handle to a java.lang.reflect.Method object | |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1550 Method* m = jvm_get_method_common(method); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1551 return (jbyteArray) JNIHandles::make_local(env, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1552 Annotations::make_java_array(m->annotations(), THREAD)); |
| 0 | 1553 JVM_END |
| 1554 | |
| 1555 | |
| 1556 JVM_ENTRY(jbyteArray, JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)) | |
| 1557 JVMWrapper("JVM_GetMethodDefaultAnnotationValue"); | |
| 1558 | |
| 1559 // method is a handle to a java.lang.reflect.Method object | |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1560 Method* m = jvm_get_method_common(method); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1561 return (jbyteArray) JNIHandles::make_local(env, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1562 Annotations::make_java_array(m->annotation_default(), THREAD)); |
| 0 | 1563 JVM_END |
| 1564 | |
| 1565 | |
| 1566 JVM_ENTRY(jbyteArray, JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)) | |
| 1567 JVMWrapper("JVM_GetMethodParameterAnnotations"); | |
| 1568 | |
| 1569 // method is a handle to a java.lang.reflect.Method object | |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1570 Method* m = jvm_get_method_common(method); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1571 return (jbyteArray) JNIHandles::make_local(env, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1572 Annotations::make_java_array(m->parameter_annotations(), THREAD)); |
| 0 | 1573 JVM_END |
| 1574 | |
|
7457
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1575 /* Type use annotations support (JDK 1.8) */ |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1576 |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1577 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls)) |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1578 assert (cls != NULL, "illegal class"); |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1579 JVMWrapper("JVM_GetClassTypeAnnotations"); |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1580 ResourceMark rm(THREAD); |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1581 // Return null for arrays and primitives |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1582 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1583 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1584 if (k->oop_is_instance()) { |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1585 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->type_annotations()->class_annotations(), CHECK_NULL); |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1586 return (jbyteArray) JNIHandles::make_local(env, a); |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1587 } |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1588 } |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1589 return NULL; |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1590 JVM_END |
|
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
6983
diff
changeset
|
1591 |
|
7588
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1592 static void bounds_check(constantPoolHandle cp, jint index, TRAPS) { |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1593 if (!cp->is_within_bounds(index)) { |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1594 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds"); |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1595 } |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1596 } |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1597 |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1598 JVM_ENTRY(jobjectArray, JVM_GetMethodParameters(JNIEnv *env, jobject method)) |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1599 { |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1600 JVMWrapper("JVM_GetMethodParameters"); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1601 // method is a handle to a java.lang.reflect.Method object |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1602 Method* method_ptr = jvm_get_method_common(method); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1603 methodHandle mh (THREAD, method_ptr); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1604 Handle reflected_method (THREAD, JNIHandles::resolve_non_null(method)); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1605 const int num_params = mh->method_parameters_length(); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1606 |
|
7588
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1607 if (0 != num_params) { |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1608 // make sure all the symbols are properly formatted |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1609 for (int i = 0; i < num_params; i++) { |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1610 MethodParametersElement* params = mh->method_parameters_start(); |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1611 int index = params[i].name_cp_index; |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1612 bounds_check(mh->constants(), index, CHECK_NULL); |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1613 |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1614 if (0 != index && !mh->constants()->tag_at(index).is_utf8()) { |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1615 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1616 "Wrong type at constant pool index"); |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1617 } |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1618 |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1619 } |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1620 |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1621 objArrayOop result_oop = oopFactory::new_objArray(SystemDictionary::reflect_Parameter_klass(), num_params, CHECK_NULL); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1622 objArrayHandle result (THREAD, result_oop); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1623 |
|
7588
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1624 for (int i = 0; i < num_params; i++) { |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1625 MethodParametersElement* params = mh->method_parameters_start(); |
|
7588
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1626 // For a 0 index, give a NULL symbol |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1627 Symbol* const sym = 0 != params[i].name_cp_index ? |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1628 mh->constants()->symbol_at(params[i].name_cp_index) : NULL; |
|
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1629 int flags = build_int_from_shorts(params[i].flags_lo, params[i].flags_hi); |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1630 oop param = Reflection::new_parameter(reflected_method, i, sym, |
|
7588
f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
coleenp
parents:
7462
diff
changeset
|
1631 flags, CHECK_NULL); |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1632 result->obj_at_put(i, param); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1633 } |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1634 return (jobjectArray)JNIHandles::make_local(env, result()); |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1635 } else { |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1636 return (jobjectArray)NULL; |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1637 } |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1638 } |
|
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1639 JVM_END |
| 0 | 1640 |
| 1641 // New (JDK 1.4) reflection implementation ///////////////////////////////////// | |
| 1642 | |
| 1643 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)) | |
| 1644 { | |
| 1645 JVMWrapper("JVM_GetClassDeclaredFields"); | |
| 1646 JvmtiVMObjectAllocEventCollector oam; | |
| 1647 | |
| 1648 // Exclude primitive types and array types | |
| 1649 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || | |
| 6983 | 1650 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_array()) { |
| 0 | 1651 // Return empty array |
| 1142 | 1652 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL); |
| 0 | 1653 return (jobjectArray) JNIHandles::make_local(env, res); |
| 1654 } | |
| 1655 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1656 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); |
| 0 | 1657 constantPoolHandle cp(THREAD, k->constants()); |
| 1658 | |
| 1659 // Ensure class is linked | |
| 1660 k->link_class(CHECK_NULL); | |
| 1661 | |
| 1662 // 4496456 We need to filter out java.lang.Throwable.backtrace | |
| 1663 bool skip_backtrace = false; | |
| 1664 | |
| 1665 // Allocate result | |
| 1666 int num_fields; | |
| 1667 | |
| 1668 if (publicOnly) { | |
| 1669 num_fields = 0; | |
| 3938 | 1670 for (JavaFieldStream fs(k()); !fs.done(); fs.next()) { |
| 1671 if (fs.access_flags().is_public()) ++num_fields; | |
| 0 | 1672 } |
| 1673 } else { | |
| 3938 | 1674 num_fields = k->java_fields_count(); |
| 0 | 1675 |
| 1142 | 1676 if (k() == SystemDictionary::Throwable_klass()) { |
| 0 | 1677 num_fields--; |
| 1678 skip_backtrace = true; | |
| 1679 } | |
| 1680 } | |
| 1681 | |
| 1142 | 1682 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), num_fields, CHECK_NULL); |
| 0 | 1683 objArrayHandle result (THREAD, r); |
| 1684 | |
| 1685 int out_idx = 0; | |
| 1686 fieldDescriptor fd; | |
| 3938 | 1687 for (JavaFieldStream fs(k); !fs.done(); fs.next()) { |
| 0 | 1688 if (skip_backtrace) { |
| 1689 // 4496456 skip java.lang.Throwable.backtrace | |
| 3938 | 1690 int offset = fs.offset(); |
| 0 | 1691 if (offset == java_lang_Throwable::get_backtrace_offset()) continue; |
| 1692 } | |
| 1693 | |
| 3938 | 1694 if (!publicOnly || fs.access_flags().is_public()) { |
| 1695 fd.initialize(k(), fs.index()); | |
| 0 | 1696 oop field = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL); |
| 1697 result->obj_at_put(out_idx, field); | |
| 1698 ++out_idx; | |
| 1699 } | |
| 1700 } | |
| 1701 assert(out_idx == num_fields, "just checking"); | |
| 1702 return (jobjectArray) JNIHandles::make_local(env, result()); | |
| 1703 } | |
| 1704 JVM_END | |
| 1705 | |
| 1706 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)) | |
| 1707 { | |
| 1708 JVMWrapper("JVM_GetClassDeclaredMethods"); | |
| 1709 JvmtiVMObjectAllocEventCollector oam; | |
| 1710 | |
| 1711 // Exclude primitive types and array types | |
| 1712 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) | |
| 6983 | 1713 || java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_array()) { |
| 0 | 1714 // Return empty array |
| 1142 | 1715 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Method_klass(), 0, CHECK_NULL); |
| 0 | 1716 return (jobjectArray) JNIHandles::make_local(env, res); |
| 1717 } | |
| 1718 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1719 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); |
| 0 | 1720 |
| 1721 // Ensure class is linked | |
| 1722 k->link_class(CHECK_NULL); | |
| 1723 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1724 Array<Method*>* methods = k->methods(); |
| 0 | 1725 int methods_length = methods->length(); |
| 1726 int num_methods = 0; | |
| 1727 | |
| 1728 int i; | |
| 1729 for (i = 0; i < methods_length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1730 methodHandle method(THREAD, methods->at(i)); |
| 0 | 1731 if (!method->is_initializer()) { |
| 1732 if (!publicOnly || method->is_public()) { | |
| 1733 ++num_methods; | |
| 1734 } | |
| 1735 } | |
| 1736 } | |
| 1737 | |
| 1738 // Allocate result | |
| 1142 | 1739 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Method_klass(), num_methods, CHECK_NULL); |
| 0 | 1740 objArrayHandle result (THREAD, r); |
| 1741 | |
| 1742 int out_idx = 0; | |
| 1743 for (i = 0; i < methods_length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1744 methodHandle method(THREAD, methods->at(i)); |
| 0 | 1745 if (!method->is_initializer()) { |
| 1746 if (!publicOnly || method->is_public()) { | |
| 1747 oop m = Reflection::new_method(method, UseNewReflection, false, CHECK_NULL); | |
| 1748 result->obj_at_put(out_idx, m); | |
| 1749 ++out_idx; | |
| 1750 } | |
| 1751 } | |
| 1752 } | |
| 1753 assert(out_idx == num_methods, "just checking"); | |
| 1754 return (jobjectArray) JNIHandles::make_local(env, result()); | |
| 1755 } | |
| 1756 JVM_END | |
| 1757 | |
| 1758 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)) | |
| 1759 { | |
| 1760 JVMWrapper("JVM_GetClassDeclaredConstructors"); | |
| 1761 JvmtiVMObjectAllocEventCollector oam; | |
| 1762 | |
| 1763 // Exclude primitive types and array types | |
| 1764 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) | |
| 6983 | 1765 || java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_array()) { |
| 0 | 1766 // Return empty array |
| 1142 | 1767 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), 0 , CHECK_NULL); |
| 0 | 1768 return (jobjectArray) JNIHandles::make_local(env, res); |
| 1769 } | |
| 1770 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1771 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); |
| 0 | 1772 |
| 1773 // Ensure class is linked | |
| 1774 k->link_class(CHECK_NULL); | |
| 1775 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1776 Array<Method*>* methods = k->methods(); |
| 0 | 1777 int methods_length = methods->length(); |
| 1778 int num_constructors = 0; | |
| 1779 | |
| 1780 int i; | |
| 1781 for (i = 0; i < methods_length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1782 methodHandle method(THREAD, methods->at(i)); |
| 0 | 1783 if (method->is_initializer() && !method->is_static()) { |
| 1784 if (!publicOnly || method->is_public()) { | |
| 1785 ++num_constructors; | |
| 1786 } | |
| 1787 } | |
| 1788 } | |
| 1789 | |
| 1790 // Allocate result | |
| 1142 | 1791 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), num_constructors, CHECK_NULL); |
| 0 | 1792 objArrayHandle result(THREAD, r); |
| 1793 | |
| 1794 int out_idx = 0; | |
| 1795 for (i = 0; i < methods_length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1796 methodHandle method(THREAD, methods->at(i)); |
| 0 | 1797 if (method->is_initializer() && !method->is_static()) { |
| 1798 if (!publicOnly || method->is_public()) { | |
| 1799 oop m = Reflection::new_constructor(method, CHECK_NULL); | |
| 1800 result->obj_at_put(out_idx, m); | |
| 1801 ++out_idx; | |
| 1802 } | |
| 1803 } | |
| 1804 } | |
| 1805 assert(out_idx == num_constructors, "just checking"); | |
| 1806 return (jobjectArray) JNIHandles::make_local(env, result()); | |
| 1807 } | |
| 1808 JVM_END | |
| 1809 | |
| 1810 JVM_ENTRY(jint, JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)) | |
| 1811 { | |
| 1812 JVMWrapper("JVM_GetClassAccessFlags"); | |
| 1813 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { | |
| 1814 // Primitive type | |
| 1815 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; | |
| 1816 } | |
| 1817 | |
| 6983 | 1818 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 1819 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS; |
| 1820 } | |
| 1821 JVM_END | |
| 1822 | |
| 1823 | |
| 1824 // Constant pool access ////////////////////////////////////////////////////////// | |
| 1825 | |
| 1826 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls)) | |
| 1827 { | |
| 1828 JVMWrapper("JVM_GetClassConstantPool"); | |
| 1829 JvmtiVMObjectAllocEventCollector oam; | |
| 1830 | |
| 1831 // Return null for primitives and arrays | |
| 1832 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1833 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 6983 | 1834 if (k->oop_is_instance()) { |
| 0 | 1835 instanceKlassHandle k_h(THREAD, k); |
| 1836 Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1837 sun_reflect_ConstantPool::set_cp(jcp(), k_h->constants()); |
| 0 | 1838 return JNIHandles::make_local(jcp()); |
| 1839 } | |
| 1840 } | |
| 1841 return NULL; | |
| 1842 } | |
| 1843 JVM_END | |
| 1844 | |
| 1845 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1846 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused)) |
| 0 | 1847 { |
| 1848 JVMWrapper("JVM_ConstantPoolGetSize"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1849 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1850 return cp->length(); |
| 1851 } | |
| 1852 JVM_END | |
| 1853 | |
| 1854 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1855 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 1856 { |
| 1857 JVMWrapper("JVM_ConstantPoolGetClassAt"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1858 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1859 bounds_check(cp, index, CHECK_NULL); |
| 1860 constantTag tag = cp->tag_at(index); | |
| 1861 if (!tag.is_klass() && !tag.is_unresolved_klass()) { | |
| 1862 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 1863 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1864 Klass* k = cp->klass_at(index, CHECK_NULL); |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2191
diff
changeset
|
1865 return (jclass) JNIHandles::make_local(k->java_mirror()); |
| 0 | 1866 } |
| 1867 JVM_END | |
| 1868 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1869 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 1870 { |
| 1871 JVMWrapper("JVM_ConstantPoolGetClassAtIfLoaded"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1872 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1873 bounds_check(cp, index, CHECK_NULL); |
| 1874 constantTag tag = cp->tag_at(index); | |
| 1875 if (!tag.is_klass() && !tag.is_unresolved_klass()) { | |
| 1876 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 1877 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1878 Klass* k = ConstantPool::klass_at_if_loaded(cp, index); |
| 0 | 1879 if (k == NULL) return NULL; |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2191
diff
changeset
|
1880 return (jclass) JNIHandles::make_local(k->java_mirror()); |
| 0 | 1881 } |
| 1882 JVM_END | |
| 1883 | |
| 1884 static jobject get_method_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) { | |
| 1885 constantTag tag = cp->tag_at(index); | |
| 1886 if (!tag.is_method() && !tag.is_interface_method()) { | |
| 1887 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 1888 } | |
| 1889 int klass_ref = cp->uncached_klass_ref_index_at(index); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1890 Klass* k_o; |
| 0 | 1891 if (force_resolution) { |
| 1892 k_o = cp->klass_at(klass_ref, CHECK_NULL); | |
| 1893 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1894 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref); |
| 0 | 1895 if (k_o == NULL) return NULL; |
| 1896 } | |
| 1897 instanceKlassHandle k(THREAD, k_o); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1898 Symbol* name = cp->uncached_name_ref_at(index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1899 Symbol* sig = cp->uncached_signature_ref_at(index); |
| 0 | 1900 methodHandle m (THREAD, k->find_method(name, sig)); |
| 1901 if (m.is_null()) { | |
| 1902 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class"); | |
| 1903 } | |
| 1904 oop method; | |
| 1905 if (!m->is_initializer() || m->is_static()) { | |
| 1906 method = Reflection::new_method(m, true, true, CHECK_NULL); | |
| 1907 } else { | |
| 1908 method = Reflection::new_constructor(m, CHECK_NULL); | |
| 1909 } | |
| 1910 return JNIHandles::make_local(method); | |
| 1911 } | |
| 1912 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1913 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 1914 { |
| 1915 JVMWrapper("JVM_ConstantPoolGetMethodAt"); | |
| 1916 JvmtiVMObjectAllocEventCollector oam; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1917 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1918 bounds_check(cp, index, CHECK_NULL); |
| 1919 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL); | |
| 1920 return res; | |
| 1921 } | |
| 1922 JVM_END | |
| 1923 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1924 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 1925 { |
| 1926 JVMWrapper("JVM_ConstantPoolGetMethodAtIfLoaded"); | |
| 1927 JvmtiVMObjectAllocEventCollector oam; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1928 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1929 bounds_check(cp, index, CHECK_NULL); |
| 1930 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL); | |
| 1931 return res; | |
| 1932 } | |
| 1933 JVM_END | |
| 1934 | |
| 1935 static jobject get_field_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) { | |
| 1936 constantTag tag = cp->tag_at(index); | |
| 1937 if (!tag.is_field()) { | |
| 1938 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 1939 } | |
| 1940 int klass_ref = cp->uncached_klass_ref_index_at(index); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1941 Klass* k_o; |
| 0 | 1942 if (force_resolution) { |
| 1943 k_o = cp->klass_at(klass_ref, CHECK_NULL); | |
| 1944 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1945 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref); |
| 0 | 1946 if (k_o == NULL) return NULL; |
| 1947 } | |
| 1948 instanceKlassHandle k(THREAD, k_o); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1949 Symbol* name = cp->uncached_name_ref_at(index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1950 Symbol* sig = cp->uncached_signature_ref_at(index); |
| 0 | 1951 fieldDescriptor fd; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1952 Klass* target_klass = k->find_field(name, sig, &fd); |
| 0 | 1953 if (target_klass == NULL) { |
| 1954 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class"); | |
| 1955 } | |
| 1956 oop field = Reflection::new_field(&fd, true, CHECK_NULL); | |
| 1957 return JNIHandles::make_local(field); | |
| 1958 } | |
| 1959 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1960 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject obj, jobject unusedl, jint index)) |
| 0 | 1961 { |
| 1962 JVMWrapper("JVM_ConstantPoolGetFieldAt"); | |
| 1963 JvmtiVMObjectAllocEventCollector oam; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1964 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1965 bounds_check(cp, index, CHECK_NULL); |
| 1966 jobject res = get_field_at_helper(cp, index, true, CHECK_NULL); | |
| 1967 return res; | |
| 1968 } | |
| 1969 JVM_END | |
| 1970 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1971 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 1972 { |
| 1973 JVMWrapper("JVM_ConstantPoolGetFieldAtIfLoaded"); | |
| 1974 JvmtiVMObjectAllocEventCollector oam; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1975 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1976 bounds_check(cp, index, CHECK_NULL); |
| 1977 jobject res = get_field_at_helper(cp, index, false, CHECK_NULL); | |
| 1978 return res; | |
| 1979 } | |
| 1980 JVM_END | |
| 1981 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1982 JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 1983 { |
| 1984 JVMWrapper("JVM_ConstantPoolGetMemberRefInfoAt"); | |
| 1985 JvmtiVMObjectAllocEventCollector oam; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1986 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 1987 bounds_check(cp, index, CHECK_NULL); |
| 1988 constantTag tag = cp->tag_at(index); | |
| 1989 if (!tag.is_field_or_method()) { | |
| 1990 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 1991 } | |
| 1992 int klass_ref = cp->uncached_klass_ref_index_at(index); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1993 Symbol* klass_name = cp->klass_name_at(klass_ref); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1994 Symbol* member_name = cp->uncached_name_ref_at(index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
1995 Symbol* member_sig = cp->uncached_signature_ref_at(index); |
| 1142 | 1996 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::String_klass(), 3, CHECK_NULL); |
| 0 | 1997 objArrayHandle dest(THREAD, dest_o); |
| 1998 Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL); | |
| 1999 dest->obj_at_put(0, str()); | |
| 2000 str = java_lang_String::create_from_symbol(member_name, CHECK_NULL); | |
| 2001 dest->obj_at_put(1, str()); | |
| 2002 str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL); | |
| 2003 dest->obj_at_put(2, str()); | |
| 2004 return (jobjectArray) JNIHandles::make_local(dest()); | |
| 2005 } | |
| 2006 JVM_END | |
| 2007 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2008 JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 2009 { |
| 2010 JVMWrapper("JVM_ConstantPoolGetIntAt"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2011 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 2012 bounds_check(cp, index, CHECK_0); |
| 2013 constantTag tag = cp->tag_at(index); | |
| 2014 if (!tag.is_int()) { | |
| 2015 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 2016 } | |
| 2017 return cp->int_at(index); | |
| 2018 } | |
| 2019 JVM_END | |
| 2020 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2021 JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 2022 { |
| 2023 JVMWrapper("JVM_ConstantPoolGetLongAt"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2024 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 2025 bounds_check(cp, index, CHECK_(0L)); |
| 2026 constantTag tag = cp->tag_at(index); | |
| 2027 if (!tag.is_long()) { | |
| 2028 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 2029 } | |
| 2030 return cp->long_at(index); | |
| 2031 } | |
| 2032 JVM_END | |
| 2033 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2034 JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 2035 { |
| 2036 JVMWrapper("JVM_ConstantPoolGetFloatAt"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2037 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 2038 bounds_check(cp, index, CHECK_(0.0f)); |
| 2039 constantTag tag = cp->tag_at(index); | |
| 2040 if (!tag.is_float()) { | |
| 2041 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 2042 } | |
| 2043 return cp->float_at(index); | |
| 2044 } | |
| 2045 JVM_END | |
| 2046 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2047 JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 2048 { |
| 2049 JVMWrapper("JVM_ConstantPoolGetDoubleAt"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2050 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 2051 bounds_check(cp, index, CHECK_(0.0)); |
| 2052 constantTag tag = cp->tag_at(index); | |
| 2053 if (!tag.is_double()) { | |
| 2054 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 2055 } | |
| 2056 return cp->double_at(index); | |
| 2057 } | |
| 2058 JVM_END | |
| 2059 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2060 JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 2061 { |
| 2062 JVMWrapper("JVM_ConstantPoolGetStringAt"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2063 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 2064 bounds_check(cp, index, CHECK_NULL); |
| 2065 constantTag tag = cp->tag_at(index); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2066 if (!tag.is_string()) { |
| 0 | 2067 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); |
| 2068 } | |
| 2069 oop str = cp->string_at(index, CHECK_NULL); | |
| 2070 return (jstring) JNIHandles::make_local(str); | |
| 2071 } | |
| 2072 JVM_END | |
| 2073 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2074 JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject obj, jobject unused, jint index)) |
| 0 | 2075 { |
| 2076 JVMWrapper("JVM_ConstantPoolGetUTF8At"); | |
| 2077 JvmtiVMObjectAllocEventCollector oam; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2078 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); |
| 0 | 2079 bounds_check(cp, index, CHECK_NULL); |
| 2080 constantTag tag = cp->tag_at(index); | |
| 2081 if (!tag.is_symbol()) { | |
| 2082 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); | |
| 2083 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2084 Symbol* sym = cp->symbol_at(index); |
| 0 | 2085 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); |
| 2086 return (jstring) JNIHandles::make_local(str()); | |
| 2087 } | |
| 2088 JVM_END | |
| 2089 | |
| 2090 | |
| 2091 // Assertion support. ////////////////////////////////////////////////////////// | |
| 2092 | |
| 2093 JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)) | |
| 2094 JVMWrapper("JVM_DesiredAssertionStatus"); | |
| 2095 assert(cls != NULL, "bad class"); | |
| 2096 | |
| 2097 oop r = JNIHandles::resolve(cls); | |
| 2098 assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed"); | |
| 2099 if (java_lang_Class::is_primitive(r)) return false; | |
| 2100 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2101 Klass* k = java_lang_Class::as_Klass(r); |
| 6983 | 2102 assert(k->oop_is_instance(), "must be an instance klass"); |
| 2103 if (! k->oop_is_instance()) return false; | |
| 0 | 2104 |
| 2105 ResourceMark rm(THREAD); | |
| 6983 | 2106 const char* name = k->name()->as_C_string(); |
| 2107 bool system_class = k->class_loader() == NULL; | |
| 0 | 2108 return JavaAssertions::enabled(name, system_class); |
| 2109 | |
| 2110 JVM_END | |
| 2111 | |
| 2112 | |
| 2113 // Return a new AssertionStatusDirectives object with the fields filled in with | |
| 2114 // command-line assertion arguments (i.e., -ea, -da). | |
| 2115 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)) | |
| 2116 JVMWrapper("JVM_AssertionStatusDirectives"); | |
| 2117 JvmtiVMObjectAllocEventCollector oam; | |
| 2118 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL); | |
| 2119 return JNIHandles::make_local(env, asd); | |
| 2120 JVM_END | |
| 2121 | |
| 2122 // Verification //////////////////////////////////////////////////////////////////////////////// | |
| 2123 | |
| 2124 // Reflection for the verifier ///////////////////////////////////////////////////////////////// | |
| 2125 | |
| 2126 // RedefineClasses support: bug 6214132 caused verification to fail. | |
| 2127 // All functions from this section should call the jvmtiThreadSate function: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2128 // Klass* class_to_verify_considering_redefinition(Klass* klass). |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2129 // The function returns a Klass* of the _scratch_class if the verifier |
| 0 | 2130 // was invoked in the middle of the class redefinition. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2131 // Otherwise it returns its argument value which is the _the_class Klass*. |
| 0 | 2132 // Please, refer to the description in the jvmtiThreadSate.hpp. |
| 2133 | |
| 2134 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls)) | |
| 2135 JVMWrapper("JVM_GetClassNameUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2136 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2137 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
| 6983 | 2138 return k->name()->as_utf8(); |
| 0 | 2139 JVM_END |
| 2140 | |
| 2141 | |
| 2142 JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)) | |
| 2143 JVMWrapper("JVM_GetClassCPTypes"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2144 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2145 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2146 // types will have length zero if this is not an InstanceKlass |
| 0 | 2147 // (length is determined by call to JVM_GetClassCPEntriesCount) |
| 6983 | 2148 if (k->oop_is_instance()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2149 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2150 for (int index = cp->length() - 1; index >= 0; index--) { |
| 2151 constantTag tag = cp->tag_at(index); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2152 types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : tag.value(); |
| 0 | 2153 } |
| 2154 } | |
| 2155 JVM_END | |
| 2156 | |
| 2157 | |
| 2158 JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)) | |
| 2159 JVMWrapper("JVM_GetClassCPEntriesCount"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2160 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2161 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
| 6983 | 2162 if (!k->oop_is_instance()) |
| 0 | 2163 return 0; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2164 return InstanceKlass::cast(k)->constants()->length(); |
| 0 | 2165 JVM_END |
| 2166 | |
| 2167 | |
| 2168 JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)) | |
| 2169 JVMWrapper("JVM_GetClassFieldsCount"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2170 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2171 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
| 6983 | 2172 if (!k->oop_is_instance()) |
| 0 | 2173 return 0; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2174 return InstanceKlass::cast(k)->java_fields_count(); |
| 0 | 2175 JVM_END |
| 2176 | |
| 2177 | |
| 2178 JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)) | |
| 2179 JVMWrapper("JVM_GetClassMethodsCount"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2180 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2181 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
| 6983 | 2182 if (!k->oop_is_instance()) |
| 0 | 2183 return 0; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2184 return InstanceKlass::cast(k)->methods()->length(); |
| 0 | 2185 JVM_END |
| 2186 | |
| 2187 | |
| 2188 // The following methods, used for the verifier, are never called with | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2189 // array klasses, so a direct cast to InstanceKlass is safe. |
| 0 | 2190 // Typically, these methods are called in a loop with bounds determined |
| 2191 // by the results of JVM_GetClass{Fields,Methods}Count, which return | |
| 2192 // zero for arrays. | |
| 2193 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)) | |
| 2194 JVMWrapper("JVM_GetMethodIxExceptionIndexes"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2195 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2196 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2197 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2198 int length = method->checked_exceptions_length(); |
| 0 | 2199 if (length > 0) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2200 CheckedExceptionElement* table= method->checked_exceptions_start(); |
| 0 | 2201 for (int i = 0; i < length; i++) { |
| 2202 exceptions[i] = table[i].class_cp_index; | |
| 2203 } | |
| 2204 } | |
| 2205 JVM_END | |
| 2206 | |
| 2207 | |
| 2208 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)) | |
| 2209 JVMWrapper("JVM_GetMethodIxExceptionsCount"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2210 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2211 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2212 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2213 return method->checked_exceptions_length(); |
| 0 | 2214 JVM_END |
| 2215 | |
| 2216 | |
| 2217 JVM_QUICK_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)) | |
| 2218 JVMWrapper("JVM_GetMethodIxByteCode"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2219 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2220 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2221 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2222 memcpy(code, method->code_base(), method->code_size()); |
| 0 | 2223 JVM_END |
| 2224 | |
| 2225 | |
| 2226 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)) | |
| 2227 JVMWrapper("JVM_GetMethodIxByteCodeLength"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2228 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2229 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2230 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2231 return method->code_size(); |
| 0 | 2232 JVM_END |
| 2233 | |
| 2234 | |
| 2235 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)) | |
| 2236 JVMWrapper("JVM_GetMethodIxExceptionTableEntry"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2237 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2238 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2239 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2240 ExceptionTable extable(method); |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
5967
diff
changeset
|
2241 entry->start_pc = extable.start_pc(entry_index); |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
5967
diff
changeset
|
2242 entry->end_pc = extable.end_pc(entry_index); |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
5967
diff
changeset
|
2243 entry->handler_pc = extable.handler_pc(entry_index); |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
5967
diff
changeset
|
2244 entry->catchType = extable.catch_type_index(entry_index); |
| 0 | 2245 JVM_END |
| 2246 | |
| 2247 | |
| 2248 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)) | |
| 2249 JVMWrapper("JVM_GetMethodIxExceptionTableLength"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2250 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2251 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2252 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2253 return method->exception_table_length(); |
| 0 | 2254 JVM_END |
| 2255 | |
| 2256 | |
| 2257 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)) | |
| 2258 JVMWrapper("JVM_GetMethodIxModifiers"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2259 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2260 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2261 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2262 return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; |
| 0 | 2263 JVM_END |
| 2264 | |
| 2265 | |
| 2266 JVM_QUICK_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)) | |
| 2267 JVMWrapper("JVM_GetFieldIxModifiers"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2268 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2269 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2270 return InstanceKlass::cast(k)->field_access_flags(field_index) & JVM_RECOGNIZED_FIELD_MODIFIERS; |
| 0 | 2271 JVM_END |
| 2272 | |
| 2273 | |
| 2274 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)) | |
| 2275 JVMWrapper("JVM_GetMethodIxLocalsCount"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2276 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2277 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2278 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2279 return method->max_locals(); |
| 0 | 2280 JVM_END |
| 2281 | |
| 2282 | |
| 2283 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)) | |
| 2284 JVMWrapper("JVM_GetMethodIxArgsSize"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2285 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2286 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2287 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2288 return method->size_of_parameters(); |
| 0 | 2289 JVM_END |
| 2290 | |
| 2291 | |
| 2292 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)) | |
| 2293 JVMWrapper("JVM_GetMethodIxMaxStack"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2294 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2295 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2296 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2297 return method->verifier_max_stack(); |
| 0 | 2298 JVM_END |
| 2299 | |
| 2300 | |
| 2301 JVM_QUICK_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)) | |
| 2302 JVMWrapper("JVM_IsConstructorIx"); | |
| 2303 ResourceMark rm(THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2304 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2305 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2306 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2307 return method->name() == vmSymbols::object_initializer_name(); |
| 0 | 2308 JVM_END |
| 2309 | |
| 2310 | |
| 2311 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)) | |
| 2312 JVMWrapper("JVM_GetMethodIxIxUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2313 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2314 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2315 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2316 return method->name()->as_utf8(); |
| 0 | 2317 JVM_END |
| 2318 | |
| 2319 | |
| 2320 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)) | |
| 2321 JVMWrapper("JVM_GetMethodIxSignatureUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2322 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2323 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2324 Method* method = InstanceKlass::cast(k)->methods()->at(method_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2325 return method->signature()->as_utf8(); |
| 0 | 2326 JVM_END |
| 2327 | |
| 2328 /** | |
| 2329 * All of these JVM_GetCP-xxx methods are used by the old verifier to | |
| 2330 * read entries in the constant pool. Since the old verifier always | |
| 2331 * works on a copy of the code, it will not see any rewriting that | |
| 2332 * may possibly occur in the middle of verification. So it is important | |
| 2333 * that nothing it calls tries to use the cpCache instead of the raw | |
| 2334 * constant pool, so we must use cp->uncached_x methods when appropriate. | |
| 2335 */ | |
| 2336 JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)) | |
| 2337 JVMWrapper("JVM_GetCPFieldNameUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2338 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2339 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2340 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2341 switch (cp->tag_at(cp_index).value()) { |
| 2342 case JVM_CONSTANT_Fieldref: | |
| 2343 return cp->uncached_name_ref_at(cp_index)->as_utf8(); | |
| 2344 default: | |
| 2345 fatal("JVM_GetCPFieldNameUTF: illegal constant"); | |
| 2346 } | |
| 2347 ShouldNotReachHere(); | |
| 2348 return NULL; | |
| 2349 JVM_END | |
| 2350 | |
| 2351 | |
| 2352 JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)) | |
| 2353 JVMWrapper("JVM_GetCPMethodNameUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2354 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2355 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2356 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2357 switch (cp->tag_at(cp_index).value()) { |
| 2358 case JVM_CONSTANT_InterfaceMethodref: | |
| 2359 case JVM_CONSTANT_Methodref: | |
|
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
973
diff
changeset
|
2360 case JVM_CONSTANT_NameAndType: // for invokedynamic |
| 0 | 2361 return cp->uncached_name_ref_at(cp_index)->as_utf8(); |
| 2362 default: | |
| 2363 fatal("JVM_GetCPMethodNameUTF: illegal constant"); | |
| 2364 } | |
| 2365 ShouldNotReachHere(); | |
| 2366 return NULL; | |
| 2367 JVM_END | |
| 2368 | |
| 2369 | |
| 2370 JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) | |
| 2371 JVMWrapper("JVM_GetCPMethodSignatureUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2372 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2373 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2374 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2375 switch (cp->tag_at(cp_index).value()) { |
| 2376 case JVM_CONSTANT_InterfaceMethodref: | |
| 2377 case JVM_CONSTANT_Methodref: | |
|
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
973
diff
changeset
|
2378 case JVM_CONSTANT_NameAndType: // for invokedynamic |
| 0 | 2379 return cp->uncached_signature_ref_at(cp_index)->as_utf8(); |
| 2380 default: | |
| 2381 fatal("JVM_GetCPMethodSignatureUTF: illegal constant"); | |
| 2382 } | |
| 2383 ShouldNotReachHere(); | |
| 2384 return NULL; | |
| 2385 JVM_END | |
| 2386 | |
| 2387 | |
| 2388 JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) | |
| 2389 JVMWrapper("JVM_GetCPFieldSignatureUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2390 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2391 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2392 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2393 switch (cp->tag_at(cp_index).value()) { |
| 2394 case JVM_CONSTANT_Fieldref: | |
| 2395 return cp->uncached_signature_ref_at(cp_index)->as_utf8(); | |
| 2396 default: | |
| 2397 fatal("JVM_GetCPFieldSignatureUTF: illegal constant"); | |
| 2398 } | |
| 2399 ShouldNotReachHere(); | |
| 2400 return NULL; | |
| 2401 JVM_END | |
| 2402 | |
| 2403 | |
| 2404 JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) | |
| 2405 JVMWrapper("JVM_GetCPClassNameUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2406 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2407 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2408 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2409 Symbol* classname = cp->klass_name_at(cp_index); |
| 0 | 2410 return classname->as_utf8(); |
| 2411 JVM_END | |
| 2412 | |
| 2413 | |
| 2414 JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) | |
| 2415 JVMWrapper("JVM_GetCPFieldClassNameUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2416 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2417 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2418 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2419 switch (cp->tag_at(cp_index).value()) { |
| 2420 case JVM_CONSTANT_Fieldref: { | |
| 2421 int class_index = cp->uncached_klass_ref_index_at(cp_index); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2422 Symbol* classname = cp->klass_name_at(class_index); |
| 0 | 2423 return classname->as_utf8(); |
| 2424 } | |
| 2425 default: | |
| 2426 fatal("JVM_GetCPFieldClassNameUTF: illegal constant"); | |
| 2427 } | |
| 2428 ShouldNotReachHere(); | |
| 2429 return NULL; | |
| 2430 JVM_END | |
| 2431 | |
| 2432 | |
| 2433 JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) | |
| 2434 JVMWrapper("JVM_GetCPMethodClassNameUTF"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2435 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
| 0 | 2436 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2437 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2438 switch (cp->tag_at(cp_index).value()) { |
| 2439 case JVM_CONSTANT_Methodref: | |
| 2440 case JVM_CONSTANT_InterfaceMethodref: { | |
| 2441 int class_index = cp->uncached_klass_ref_index_at(cp_index); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2442 Symbol* classname = cp->klass_name_at(class_index); |
| 0 | 2443 return classname->as_utf8(); |
| 2444 } | |
| 2445 default: | |
| 2446 fatal("JVM_GetCPMethodClassNameUTF: illegal constant"); | |
| 2447 } | |
| 2448 ShouldNotReachHere(); | |
| 2449 return NULL; | |
| 2450 JVM_END | |
| 2451 | |
| 2452 | |
| 3938 | 2453 JVM_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) |
| 0 | 2454 JVMWrapper("JVM_GetCPFieldModifiers"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2455 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2456 Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls)); |
| 0 | 2457 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
| 2458 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2459 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2460 ConstantPool* cp_called = InstanceKlass::cast(k_called)->constants(); |
| 0 | 2461 switch (cp->tag_at(cp_index).value()) { |
| 2462 case JVM_CONSTANT_Fieldref: { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2463 Symbol* name = cp->uncached_name_ref_at(cp_index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2464 Symbol* signature = cp->uncached_signature_ref_at(cp_index); |
| 3938 | 2465 for (JavaFieldStream fs(k_called); !fs.done(); fs.next()) { |
| 2466 if (fs.name() == name && fs.signature() == signature) { | |
| 2467 return fs.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS; | |
| 0 | 2468 } |
| 2469 } | |
| 2470 return -1; | |
| 2471 } | |
| 2472 default: | |
| 2473 fatal("JVM_GetCPFieldModifiers: illegal constant"); | |
| 2474 } | |
| 2475 ShouldNotReachHere(); | |
| 2476 return 0; | |
| 2477 JVM_END | |
| 2478 | |
| 2479 | |
| 2480 JVM_QUICK_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) | |
| 2481 JVMWrapper("JVM_GetCPMethodModifiers"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2482 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2483 Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls)); |
| 0 | 2484 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); |
| 2485 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2486 ConstantPool* cp = InstanceKlass::cast(k)->constants(); |
| 0 | 2487 switch (cp->tag_at(cp_index).value()) { |
| 2488 case JVM_CONSTANT_Methodref: | |
| 2489 case JVM_CONSTANT_InterfaceMethodref: { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2490 Symbol* name = cp->uncached_name_ref_at(cp_index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2491 Symbol* signature = cp->uncached_signature_ref_at(cp_index); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2492 Array<Method*>* methods = InstanceKlass::cast(k_called)->methods(); |
| 0 | 2493 int methods_count = methods->length(); |
| 2494 for (int i = 0; i < methods_count; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2495 Method* method = methods->at(i); |
| 0 | 2496 if (method->name() == name && method->signature() == signature) { |
| 2497 return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; | |
| 2498 } | |
| 2499 } | |
| 2500 return -1; | |
| 2501 } | |
| 2502 default: | |
| 2503 fatal("JVM_GetCPMethodModifiers: illegal constant"); | |
| 2504 } | |
| 2505 ShouldNotReachHere(); | |
| 2506 return 0; | |
| 2507 JVM_END | |
| 2508 | |
| 2509 | |
| 2510 // Misc ////////////////////////////////////////////////////////////////////////////////////////////// | |
| 2511 | |
| 2512 JVM_LEAF(void, JVM_ReleaseUTF(const char *utf)) | |
| 2513 // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything | |
| 2514 JVM_END | |
| 2515 | |
| 2516 | |
| 2517 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)) | |
| 2518 JVMWrapper("JVM_IsSameClassPackage"); | |
| 2519 oop class1_mirror = JNIHandles::resolve_non_null(class1); | |
| 2520 oop class2_mirror = JNIHandles::resolve_non_null(class2); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2521 Klass* klass1 = java_lang_Class::as_Klass(class1_mirror); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2522 Klass* klass2 = java_lang_Class::as_Klass(class2_mirror); |
| 0 | 2523 return (jboolean) Reflection::is_same_class_package(klass1, klass2); |
| 2524 JVM_END | |
| 2525 | |
| 2526 | |
| 2527 // IO functions //////////////////////////////////////////////////////////////////////////////////////// | |
| 2528 | |
| 2529 JVM_LEAF(jint, JVM_Open(const char *fname, jint flags, jint mode)) | |
| 2530 JVMWrapper2("JVM_Open (%s)", fname); | |
| 2531 | |
| 2532 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2533 int result = os::open(fname, flags, mode); |
| 0 | 2534 if (result >= 0) { |
| 2535 return result; | |
| 2536 } else { | |
| 2537 switch(errno) { | |
| 2538 case EEXIST: | |
| 2539 return JVM_EEXIST; | |
| 2540 default: | |
| 2541 return -1; | |
| 2542 } | |
| 2543 } | |
| 2544 JVM_END | |
| 2545 | |
| 2546 | |
| 2547 JVM_LEAF(jint, JVM_Close(jint fd)) | |
| 2548 JVMWrapper2("JVM_Close (0x%x)", fd); | |
| 2549 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2550 return os::close(fd); |
| 0 | 2551 JVM_END |
| 2552 | |
| 2553 | |
| 2554 JVM_LEAF(jint, JVM_Read(jint fd, char *buf, jint nbytes)) | |
| 2555 JVMWrapper2("JVM_Read (0x%x)", fd); | |
| 2556 | |
| 2557 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2558 return (jint)os::restartable_read(fd, buf, nbytes); |
| 0 | 2559 JVM_END |
| 2560 | |
| 2561 | |
| 2562 JVM_LEAF(jint, JVM_Write(jint fd, char *buf, jint nbytes)) | |
| 2563 JVMWrapper2("JVM_Write (0x%x)", fd); | |
| 2564 | |
| 2565 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2566 return (jint)os::write(fd, buf, nbytes); |
| 0 | 2567 JVM_END |
| 2568 | |
| 2569 | |
| 2570 JVM_LEAF(jint, JVM_Available(jint fd, jlong *pbytes)) | |
| 2571 JVMWrapper2("JVM_Available (0x%x)", fd); | |
| 2572 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2573 return os::available(fd, pbytes); |
| 0 | 2574 JVM_END |
| 2575 | |
| 2576 | |
| 2577 JVM_LEAF(jlong, JVM_Lseek(jint fd, jlong offset, jint whence)) | |
| 2578 JVMWrapper4("JVM_Lseek (0x%x, %Ld, %d)", fd, offset, whence); | |
| 2579 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2580 return os::lseek(fd, offset, whence); |
| 0 | 2581 JVM_END |
| 2582 | |
| 2583 | |
| 2584 JVM_LEAF(jint, JVM_SetLength(jint fd, jlong length)) | |
| 2585 JVMWrapper3("JVM_SetLength (0x%x, %Ld)", fd, length); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2586 return os::ftruncate(fd, length); |
| 0 | 2587 JVM_END |
| 2588 | |
| 2589 | |
| 2590 JVM_LEAF(jint, JVM_Sync(jint fd)) | |
| 2591 JVMWrapper2("JVM_Sync (0x%x)", fd); | |
| 2592 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
2593 return os::fsync(fd); |
| 0 | 2594 JVM_END |
| 2595 | |
| 2596 | |
| 2597 // Printing support ////////////////////////////////////////////////// | |
| 2598 extern "C" { | |
| 2599 | |
| 2600 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) { | |
| 2601 // see bug 4399518, 4417214 | |
| 2602 if ((intptr_t)count <= 0) return -1; | |
| 2603 return vsnprintf(str, count, fmt, args); | |
| 2604 } | |
| 2605 | |
| 2606 | |
| 2607 int jio_snprintf(char *str, size_t count, const char *fmt, ...) { | |
| 2608 va_list args; | |
| 2609 int len; | |
| 2610 va_start(args, fmt); | |
| 2611 len = jio_vsnprintf(str, count, fmt, args); | |
| 2612 va_end(args); | |
| 2613 return len; | |
| 2614 } | |
| 2615 | |
| 2616 | |
| 2617 int jio_fprintf(FILE* f, const char *fmt, ...) { | |
| 2618 int len; | |
| 2619 va_list args; | |
| 2620 va_start(args, fmt); | |
| 2621 len = jio_vfprintf(f, fmt, args); | |
| 2622 va_end(args); | |
| 2623 return len; | |
| 2624 } | |
| 2625 | |
| 2626 | |
| 2627 int jio_vfprintf(FILE* f, const char *fmt, va_list args) { | |
| 2628 if (Arguments::vfprintf_hook() != NULL) { | |
| 2629 return Arguments::vfprintf_hook()(f, fmt, args); | |
| 2630 } else { | |
| 2631 return vfprintf(f, fmt, args); | |
| 2632 } | |
| 2633 } | |
| 2634 | |
| 2635 | |
| 2191 | 2636 JNIEXPORT int jio_printf(const char *fmt, ...) { |
| 0 | 2637 int len; |
| 2638 va_list args; | |
| 2639 va_start(args, fmt); | |
| 2640 len = jio_vfprintf(defaultStream::output_stream(), fmt, args); | |
| 2641 va_end(args); | |
| 2642 return len; | |
| 2643 } | |
| 2644 | |
| 2645 | |
| 2646 // HotSpot specific jio method | |
| 2647 void jio_print(const char* s) { | |
| 2648 // Try to make this function as atomic as possible. | |
| 2649 if (Arguments::vfprintf_hook() != NULL) { | |
| 2650 jio_fprintf(defaultStream::output_stream(), "%s", s); | |
| 2651 } else { | |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
431
diff
changeset
|
2652 // Make an unused local variable to avoid warning from gcc 4.x compiler. |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
431
diff
changeset
|
2653 size_t count = ::write(defaultStream::output_fd(), s, (int)strlen(s)); |
| 0 | 2654 } |
| 2655 } | |
| 2656 | |
| 2657 } // Extern C | |
| 2658 | |
| 2659 // java.lang.Thread ////////////////////////////////////////////////////////////////////////////// | |
| 2660 | |
| 2661 // In most of the JVM Thread support functions we need to be sure to lock the Threads_lock | |
| 2662 // to prevent the target thread from exiting after we have a pointer to the C++ Thread or | |
| 2663 // OSThread objects. The exception to this rule is when the target object is the thread | |
| 2664 // doing the operation, in which case we know that the thread won't exit until the | |
| 2665 // operation is done (all exits being voluntary). There are a few cases where it is | |
| 2666 // rather silly to do operations on yourself, like resuming yourself or asking whether | |
| 2667 // you are alive. While these can still happen, they are not subject to deadlocks if | |
| 2668 // the lock is held while the operation occurs (this is not the case for suspend, for | |
| 2669 // instance), and are very unlikely. Because IsAlive needs to be fast and its | |
| 2670 // implementation is local to this file, we always lock Threads_lock for that one. | |
| 2671 | |
| 2672 static void thread_entry(JavaThread* thread, TRAPS) { | |
| 2673 HandleMark hm(THREAD); | |
| 2674 Handle obj(THREAD, thread->threadObj()); | |
| 2675 JavaValue result(T_VOID); | |
| 2676 JavaCalls::call_virtual(&result, | |
| 2677 obj, | |
| 1142 | 2678 KlassHandle(THREAD, SystemDictionary::Thread_klass()), |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2679 vmSymbols::run_method_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
2680 vmSymbols::void_method_signature(), |
| 0 | 2681 THREAD); |
| 2682 } | |
| 2683 | |
| 2684 | |
| 2685 JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread)) | |
| 2686 JVMWrapper("JVM_StartThread"); | |
| 2687 JavaThread *native_thread = NULL; | |
| 2688 | |
| 2689 // We cannot hold the Threads_lock when we throw an exception, | |
| 2690 // due to rank ordering issues. Example: we might need to grab the | |
| 2691 // Heap_lock while we construct the exception. | |
| 2692 bool throw_illegal_thread_state = false; | |
| 2693 | |
| 2694 // We must release the Threads_lock before we can post a jvmti event | |
| 2695 // in Thread::start. | |
| 2696 { | |
| 2697 // Ensure that the C++ Thread and OSThread structures aren't freed before | |
| 2698 // we operate. | |
| 2699 MutexLocker mu(Threads_lock); | |
| 2700 | |
|
2162
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2701 // Since JDK 5 the java.lang.Thread threadStatus is used to prevent |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2702 // re-starting an already started thread, so we should usually find |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2703 // that the JavaThread is null. However for a JNI attached thread |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2704 // there is a small window between the Thread object being created |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2705 // (with its JavaThread set) and the update to its threadStatus, so we |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2706 // have to check for this |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2707 if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) { |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2708 throw_illegal_thread_state = true; |
| 0 | 2709 } else { |
|
2162
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2710 // We could also check the stillborn flag to see if this thread was already stopped, but |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2711 // for historical reasons we let the thread detect that itself when it starts running |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2712 |
| 0 | 2713 jlong size = |
| 2714 java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread)); | |
| 2715 // Allocate the C++ Thread structure and create the native thread. The | |
| 2716 // stack size retrieved from java is signed, but the constructor takes | |
| 2717 // size_t (an unsigned type), so avoid passing negative values which would | |
| 2718 // result in really large stacks. | |
| 2719 size_t sz = size > 0 ? (size_t) size : 0; | |
| 2720 native_thread = new JavaThread(&thread_entry, sz); | |
| 2721 | |
| 2722 // At this point it may be possible that no osthread was created for the | |
| 2723 // JavaThread due to lack of memory. Check for this situation and throw | |
| 2724 // an exception if necessary. Eventually we may want to change this so | |
| 2725 // that we only grab the lock if the thread was created successfully - | |
| 2726 // then we can also do this check and throw the exception in the | |
| 2727 // JavaThread constructor. | |
| 2728 if (native_thread->osthread() != NULL) { | |
| 2729 // Note: the current thread is not being used within "prepare". | |
| 2730 native_thread->prepare(jthread); | |
| 2731 } | |
| 2732 } | |
| 2733 } | |
| 2734 | |
| 2735 if (throw_illegal_thread_state) { | |
| 2736 THROW(vmSymbols::java_lang_IllegalThreadStateException()); | |
| 2737 } | |
| 2738 | |
| 2739 assert(native_thread != NULL, "Starting null thread?"); | |
| 2740 | |
| 2741 if (native_thread->osthread() == NULL) { | |
| 2742 // No one should hold a reference to the 'native_thread'. | |
| 2743 delete native_thread; | |
| 2744 if (JvmtiExport::should_post_resource_exhausted()) { | |
| 2745 JvmtiExport::post_resource_exhausted( | |
| 2746 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS, | |
| 2747 "unable to create new native thread"); | |
| 2748 } | |
| 2749 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), | |
| 2750 "unable to create new native thread"); | |
| 2751 } | |
| 2752 | |
| 2753 Thread::start(native_thread); | |
| 2754 | |
| 2755 JVM_END | |
| 2756 | |
| 2757 // JVM_Stop is implemented using a VM_Operation, so threads are forced to safepoints | |
| 2758 // before the quasi-asynchronous exception is delivered. This is a little obtrusive, | |
| 2759 // but is thought to be reliable and simple. In the case, where the receiver is the | |
|
2162
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2760 // same thread as the sender, no safepoint is needed. |
| 0 | 2761 JVM_ENTRY(void, JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)) |
| 2762 JVMWrapper("JVM_StopThread"); | |
| 2763 | |
| 2764 oop java_throwable = JNIHandles::resolve(throwable); | |
| 2765 if (java_throwable == NULL) { | |
| 2766 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 2767 } | |
| 2768 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 2769 JavaThread* receiver = java_lang_Thread::thread(java_thread); | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4717
diff
changeset
|
2770 Events::log_exception(JavaThread::current(), |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4717
diff
changeset
|
2771 "JVM_StopThread thread JavaThread " INTPTR_FORMAT " as oop " INTPTR_FORMAT " [exception " INTPTR_FORMAT "]", |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4717
diff
changeset
|
2772 receiver, (address)java_thread, throwable); |
|
2162
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2773 // First check if thread is alive |
| 0 | 2774 if (receiver != NULL) { |
| 2775 // Check if exception is getting thrown at self (use oop equality, since the | |
| 2776 // target object might exit) | |
| 2777 if (java_thread == thread->threadObj()) { | |
| 2778 THROW_OOP(java_throwable); | |
| 2779 } else { | |
| 2780 // Enques a VM_Operation to stop all threads and then deliver the exception... | |
| 2781 Thread::send_async_exception(java_thread, JNIHandles::resolve(throwable)); | |
| 2782 } | |
| 2783 } | |
|
2162
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2784 else { |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2785 // Either: |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2786 // - target thread has not been started before being stopped, or |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2787 // - target thread already terminated |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2788 // We could read the threadStatus to determine which case it is |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2789 // but that is overkill as it doesn't matter. We must set the |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2790 // stillborn flag for the first case, and if the thread has already |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2791 // exited setting this flag has no affect |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2792 java_lang_Thread::set_stillborn(java_thread); |
|
ccfcb502af3f
6566340: Restore use of stillborn flag to signify a thread that was stopped before it started
dholmes
parents:
1980
diff
changeset
|
2793 } |
| 0 | 2794 JVM_END |
| 2795 | |
| 2796 | |
| 2797 JVM_ENTRY(jboolean, JVM_IsThreadAlive(JNIEnv* env, jobject jthread)) | |
| 2798 JVMWrapper("JVM_IsThreadAlive"); | |
| 2799 | |
| 2800 oop thread_oop = JNIHandles::resolve_non_null(jthread); | |
| 2801 return java_lang_Thread::is_alive(thread_oop); | |
| 2802 JVM_END | |
| 2803 | |
| 2804 | |
| 2805 JVM_ENTRY(void, JVM_SuspendThread(JNIEnv* env, jobject jthread)) | |
| 2806 JVMWrapper("JVM_SuspendThread"); | |
| 2807 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 2808 JavaThread* receiver = java_lang_Thread::thread(java_thread); | |
| 2809 | |
| 2810 if (receiver != NULL) { | |
| 2811 // thread has run and has not exited (still on threads list) | |
| 2812 | |
| 2813 { | |
| 2814 MutexLockerEx ml(receiver->SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 2815 if (receiver->is_external_suspend()) { | |
| 2816 // Don't allow nested external suspend requests. We can't return | |
| 2817 // an error from this interface so just ignore the problem. | |
| 2818 return; | |
| 2819 } | |
| 2820 if (receiver->is_exiting()) { // thread is in the process of exiting | |
| 2821 return; | |
| 2822 } | |
| 2823 receiver->set_external_suspend(); | |
| 2824 } | |
| 2825 | |
| 2826 // java_suspend() will catch threads in the process of exiting | |
| 2827 // and will ignore them. | |
| 2828 receiver->java_suspend(); | |
| 2829 | |
| 2830 // It would be nice to have the following assertion in all the | |
| 2831 // time, but it is possible for a racing resume request to have | |
| 2832 // resumed this thread right after we suspended it. Temporarily | |
| 2833 // enable this assertion if you are chasing a different kind of | |
| 2834 // bug. | |
| 2835 // | |
| 2836 // assert(java_lang_Thread::thread(receiver->threadObj()) == NULL || | |
| 2837 // receiver->is_being_ext_suspended(), "thread is not suspended"); | |
| 2838 } | |
| 2839 JVM_END | |
| 2840 | |
| 2841 | |
| 2842 JVM_ENTRY(void, JVM_ResumeThread(JNIEnv* env, jobject jthread)) | |
| 2843 JVMWrapper("JVM_ResumeThread"); | |
| 2844 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate. | |
| 2845 // We need to *always* get the threads lock here, since this operation cannot be allowed during | |
| 2846 // a safepoint. The safepoint code relies on suspending a thread to examine its state. If other | |
| 2847 // threads randomly resumes threads, then a thread might not be suspended when the safepoint code | |
| 2848 // looks at it. | |
| 2849 MutexLocker ml(Threads_lock); | |
| 2850 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); | |
| 2851 if (thr != NULL) { | |
| 2852 // the thread has run and is not in the process of exiting | |
| 2853 thr->java_resume(); | |
| 2854 } | |
| 2855 JVM_END | |
| 2856 | |
| 2857 | |
| 2858 JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)) | |
| 2859 JVMWrapper("JVM_SetThreadPriority"); | |
| 2860 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate | |
| 2861 MutexLocker ml(Threads_lock); | |
| 2862 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 2863 java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio); | |
| 2864 JavaThread* thr = java_lang_Thread::thread(java_thread); | |
| 2865 if (thr != NULL) { // Thread not yet started; priority pushed down when it is | |
| 2866 Thread::set_priority(thr, (ThreadPriority)prio); | |
| 2867 } | |
| 2868 JVM_END | |
| 2869 | |
| 2870 | |
| 2871 JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass)) | |
| 2872 JVMWrapper("JVM_Yield"); | |
| 2873 if (os::dont_yield()) return; | |
| 4006 | 2874 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
2875 HS_DTRACE_PROBE0(hotspot, thread__yield); |
| 4006 | 2876 #else /* USDT2 */ |
| 2877 HOTSPOT_THREAD_YIELD(); | |
| 2878 #endif /* USDT2 */ | |
| 0 | 2879 // When ConvertYieldToSleep is off (default), this matches the classic VM use of yield. |
| 2880 // Critical for similar threading behaviour | |
| 2881 if (ConvertYieldToSleep) { | |
| 2882 os::sleep(thread, MinSleepInterval, false); | |
| 2883 } else { | |
| 2884 os::yield(); | |
| 2885 } | |
| 2886 JVM_END | |
| 2887 | |
| 2888 | |
| 2889 JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)) | |
| 2890 JVMWrapper("JVM_Sleep"); | |
| 2891 | |
| 2892 if (millis < 0) { | |
| 2893 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative"); | |
| 2894 } | |
| 2895 | |
| 2896 if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) { | |
| 2897 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted"); | |
| 2898 } | |
| 2899 | |
| 2900 // Save current thread state and restore it at the end of this block. | |
| 2901 // And set new thread state to SLEEPING. | |
| 2902 JavaThreadSleepState jtss(thread); | |
| 2903 | |
| 4006 | 2904 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
2905 HS_DTRACE_PROBE1(hotspot, thread__sleep__begin, millis); |
| 4006 | 2906 #else /* USDT2 */ |
| 2907 HOTSPOT_THREAD_SLEEP_BEGIN( | |
| 2908 millis); | |
| 2909 #endif /* USDT2 */ | |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
2910 |
| 0 | 2911 if (millis == 0) { |
| 2912 // When ConvertSleepToYield is on, this matches the classic VM implementation of | |
| 2913 // JVM_Sleep. Critical for similar threading behaviour (Win32) | |
| 2914 // It appears that in certain GUI contexts, it may be beneficial to do a short sleep | |
| 2915 // for SOLARIS | |
| 2916 if (ConvertSleepToYield) { | |
| 2917 os::yield(); | |
| 2918 } else { | |
| 2919 ThreadState old_state = thread->osthread()->get_state(); | |
| 2920 thread->osthread()->set_state(SLEEPING); | |
| 2921 os::sleep(thread, MinSleepInterval, false); | |
| 2922 thread->osthread()->set_state(old_state); | |
| 2923 } | |
| 2924 } else { | |
| 2925 ThreadState old_state = thread->osthread()->get_state(); | |
| 2926 thread->osthread()->set_state(SLEEPING); | |
| 2927 if (os::sleep(thread, millis, true) == OS_INTRPT) { | |
| 2928 // An asynchronous exception (e.g., ThreadDeathException) could have been thrown on | |
| 2929 // us while we were sleeping. We do not overwrite those. | |
| 2930 if (!HAS_PENDING_EXCEPTION) { | |
| 4006 | 2931 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
2932 HS_DTRACE_PROBE1(hotspot, thread__sleep__end,1); |
| 4006 | 2933 #else /* USDT2 */ |
| 2934 HOTSPOT_THREAD_SLEEP_END( | |
| 2935 1); | |
| 2936 #endif /* USDT2 */ | |
| 0 | 2937 // TODO-FIXME: THROW_MSG returns which means we will not call set_state() |
| 2938 // to properly restore the thread state. That's likely wrong. | |
| 2939 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted"); | |
| 2940 } | |
| 2941 } | |
| 2942 thread->osthread()->set_state(old_state); | |
| 2943 } | |
| 4006 | 2944 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1144
diff
changeset
|
2945 HS_DTRACE_PROBE1(hotspot, thread__sleep__end,0); |
| 4006 | 2946 #else /* USDT2 */ |
| 2947 HOTSPOT_THREAD_SLEEP_END( | |
| 2948 0); | |
| 2949 #endif /* USDT2 */ | |
| 0 | 2950 JVM_END |
| 2951 | |
| 2952 JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass)) | |
| 2953 JVMWrapper("JVM_CurrentThread"); | |
| 2954 oop jthread = thread->threadObj(); | |
| 2955 assert (thread != NULL, "no current thread!"); | |
| 2956 return JNIHandles::make_local(env, jthread); | |
| 2957 JVM_END | |
| 2958 | |
| 2959 | |
| 2960 JVM_ENTRY(jint, JVM_CountStackFrames(JNIEnv* env, jobject jthread)) | |
| 2961 JVMWrapper("JVM_CountStackFrames"); | |
| 2962 | |
| 2963 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate | |
| 2964 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 2965 bool throw_illegal_thread_state = false; | |
| 2966 int count = 0; | |
| 2967 | |
| 2968 { | |
| 2969 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock); | |
| 2970 // We need to re-resolve the java_thread, since a GC might have happened during the | |
| 2971 // acquire of the lock | |
| 2972 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); | |
| 2973 | |
| 2974 if (thr == NULL) { | |
| 2975 // do nothing | |
| 2976 } else if(! thr->is_external_suspend() || ! thr->frame_anchor()->walkable()) { | |
| 2977 // Check whether this java thread has been suspended already. If not, throws | |
| 2978 // IllegalThreadStateException. We defer to throw that exception until | |
| 2979 // Threads_lock is released since loading exception class has to leave VM. | |
| 2980 // The correct way to test a thread is actually suspended is | |
| 2981 // wait_for_ext_suspend_completion(), but we can't call that while holding | |
| 2982 // the Threads_lock. The above tests are sufficient for our purposes | |
| 2983 // provided the walkability of the stack is stable - which it isn't | |
| 2984 // 100% but close enough for most practical purposes. | |
| 2985 throw_illegal_thread_state = true; | |
| 2986 } else { | |
| 2987 // Count all java activation, i.e., number of vframes | |
| 2988 for(vframeStream vfst(thr); !vfst.at_end(); vfst.next()) { | |
| 2989 // Native frames are not counted | |
| 2990 if (!vfst.method()->is_native()) count++; | |
| 2991 } | |
| 2992 } | |
| 2993 } | |
| 2994 | |
| 2995 if (throw_illegal_thread_state) { | |
| 2996 THROW_MSG_0(vmSymbols::java_lang_IllegalThreadStateException(), | |
| 2997 "this thread is not suspended"); | |
| 2998 } | |
| 2999 return count; | |
| 3000 JVM_END | |
| 3001 | |
| 3002 // Consider: A better way to implement JVM_Interrupt() is to acquire | |
| 3003 // Threads_lock to resolve the jthread into a Thread pointer, fetch | |
| 3004 // Thread->platformevent, Thread->native_thr, Thread->parker, etc., | |
| 3005 // drop Threads_lock, and the perform the unpark() and thr_kill() operations | |
| 3006 // outside the critical section. Threads_lock is hot so we want to minimize | |
| 3007 // the hold-time. A cleaner interface would be to decompose interrupt into | |
| 3008 // two steps. The 1st phase, performed under Threads_lock, would return | |
| 3009 // a closure that'd be invoked after Threads_lock was dropped. | |
| 3010 // This tactic is safe as PlatformEvent and Parkers are type-stable (TSM) and | |
| 3011 // admit spurious wakeups. | |
| 3012 | |
| 3013 JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread)) | |
| 3014 JVMWrapper("JVM_Interrupt"); | |
| 3015 | |
| 3016 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate | |
| 3017 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 3018 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock); | |
| 3019 // We need to re-resolve the java_thread, since a GC might have happened during the | |
| 3020 // acquire of the lock | |
| 3021 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); | |
| 3022 if (thr != NULL) { | |
| 3023 Thread::interrupt(thr); | |
| 3024 } | |
| 3025 JVM_END | |
| 3026 | |
| 3027 | |
| 3028 JVM_QUICK_ENTRY(jboolean, JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)) | |
| 3029 JVMWrapper("JVM_IsInterrupted"); | |
| 3030 | |
| 3031 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate | |
| 3032 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 3033 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock); | |
| 3034 // We need to re-resolve the java_thread, since a GC might have happened during the | |
| 3035 // acquire of the lock | |
| 3036 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); | |
| 3037 if (thr == NULL) { | |
| 3038 return JNI_FALSE; | |
| 3039 } else { | |
| 3040 return (jboolean) Thread::is_interrupted(thr, clear_interrupted != 0); | |
| 3041 } | |
| 3042 JVM_END | |
| 3043 | |
| 3044 | |
| 3045 // Return true iff the current thread has locked the object passed in | |
| 3046 | |
| 3047 JVM_ENTRY(jboolean, JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)) | |
| 3048 JVMWrapper("JVM_HoldsLock"); | |
| 3049 assert(THREAD->is_Java_thread(), "sanity check"); | |
| 3050 if (obj == NULL) { | |
| 3051 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE); | |
| 3052 } | |
| 3053 Handle h_obj(THREAD, JNIHandles::resolve(obj)); | |
| 3054 return ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, h_obj); | |
| 3055 JVM_END | |
| 3056 | |
| 3057 | |
| 3058 JVM_ENTRY(void, JVM_DumpAllStacks(JNIEnv* env, jclass)) | |
| 3059 JVMWrapper("JVM_DumpAllStacks"); | |
| 3060 VM_PrintThreads op; | |
| 3061 VMThread::execute(&op); | |
| 3062 if (JvmtiExport::should_post_data_dump()) { | |
| 3063 JvmtiExport::post_data_dump(); | |
| 3064 } | |
| 3065 JVM_END | |
| 3066 | |
| 4006 | 3067 JVM_ENTRY(void, JVM_SetNativeThreadName(JNIEnv* env, jobject jthread, jstring name)) |
| 3068 JVMWrapper("JVM_SetNativeThreadName"); | |
| 3069 ResourceMark rm(THREAD); | |
| 3070 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 3071 JavaThread* thr = java_lang_Thread::thread(java_thread); | |
| 3072 // Thread naming only supported for the current thread, doesn't work for | |
| 3073 // target threads. | |
| 3074 if (Thread::current() == thr && !thr->has_attached_via_jni()) { | |
| 3075 // we don't set the name of an attached thread to avoid stepping | |
| 3076 // on other programs | |
| 3077 const char *thread_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name)); | |
| 3078 os::set_native_thread_name(thread_name); | |
| 3079 } | |
| 3080 JVM_END | |
| 0 | 3081 |
| 3082 // java.lang.SecurityManager /////////////////////////////////////////////////////////////////////// | |
| 3083 | |
| 3084 static bool is_trusted_frame(JavaThread* jthread, vframeStream* vfst) { | |
| 3085 assert(jthread->is_Java_thread(), "must be a Java thread"); | |
| 3086 if (jthread->privileged_stack_top() == NULL) return false; | |
| 3087 if (jthread->privileged_stack_top()->frame_id() == vfst->frame_id()) { | |
| 3088 oop loader = jthread->privileged_stack_top()->class_loader(); | |
| 3089 if (loader == NULL) return true; | |
| 3090 bool trusted = java_lang_ClassLoader::is_trusted_loader(loader); | |
| 3091 if (trusted) return true; | |
| 3092 } | |
| 3093 return false; | |
| 3094 } | |
| 3095 | |
| 3096 JVM_ENTRY(jclass, JVM_CurrentLoadedClass(JNIEnv *env)) | |
| 3097 JVMWrapper("JVM_CurrentLoadedClass"); | |
| 3098 ResourceMark rm(THREAD); | |
| 3099 | |
| 3100 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { | |
| 3101 // if a method in a class in a trusted loader is in a doPrivileged, return NULL | |
| 3102 bool trusted = is_trusted_frame(thread, &vfst); | |
| 3103 if (trusted) return NULL; | |
| 3104 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3105 Method* m = vfst.method(); |
| 0 | 3106 if (!m->is_native()) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3107 InstanceKlass* holder = m->method_holder(); |
|
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3108 oop loader = holder->class_loader(); |
| 0 | 3109 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3110 return (jclass) JNIHandles::make_local(env, holder->java_mirror()); |
| 0 | 3111 } |
| 3112 } | |
| 3113 } | |
| 3114 return NULL; | |
| 3115 JVM_END | |
| 3116 | |
| 3117 | |
| 3118 JVM_ENTRY(jobject, JVM_CurrentClassLoader(JNIEnv *env)) | |
| 3119 JVMWrapper("JVM_CurrentClassLoader"); | |
| 3120 ResourceMark rm(THREAD); | |
| 3121 | |
| 3122 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { | |
| 3123 | |
| 3124 // if a method in a class in a trusted loader is in a doPrivileged, return NULL | |
| 3125 bool trusted = is_trusted_frame(thread, &vfst); | |
| 3126 if (trusted) return NULL; | |
| 3127 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3128 Method* m = vfst.method(); |
| 0 | 3129 if (!m->is_native()) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3130 InstanceKlass* holder = m->method_holder(); |
| 0 | 3131 assert(holder->is_klass(), "just checking"); |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3132 oop loader = holder->class_loader(); |
| 0 | 3133 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { |
| 3134 return JNIHandles::make_local(env, loader); | |
| 3135 } | |
| 3136 } | |
| 3137 } | |
| 3138 return NULL; | |
| 3139 JVM_END | |
| 3140 | |
| 3141 | |
| 3142 // Utility object for collecting method holders walking down the stack | |
| 3143 class KlassLink: public ResourceObj { | |
| 3144 public: | |
| 3145 KlassHandle klass; | |
| 3146 KlassLink* next; | |
| 3147 | |
| 3148 KlassLink(KlassHandle k) { klass = k; next = NULL; } | |
| 3149 }; | |
| 3150 | |
| 3151 | |
| 3152 JVM_ENTRY(jobjectArray, JVM_GetClassContext(JNIEnv *env)) | |
| 3153 JVMWrapper("JVM_GetClassContext"); | |
| 3154 ResourceMark rm(THREAD); | |
| 3155 JvmtiVMObjectAllocEventCollector oam; | |
| 3156 // Collect linked list of (handles to) method holders | |
| 3157 KlassLink* first = NULL; | |
| 3158 KlassLink* last = NULL; | |
| 3159 int depth = 0; | |
| 3160 | |
| 3161 for(vframeStream vfst(thread); !vfst.at_end(); vfst.security_get_caller_frame(1)) { | |
| 3162 // Native frames are not returned | |
| 3163 if (!vfst.method()->is_native()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3164 Klass* holder = vfst.method()->method_holder(); |
| 0 | 3165 assert(holder->is_klass(), "just checking"); |
| 3166 depth++; | |
| 3167 KlassLink* l = new KlassLink(KlassHandle(thread, holder)); | |
| 3168 if (first == NULL) { | |
| 3169 first = last = l; | |
| 3170 } else { | |
| 3171 last->next = l; | |
| 3172 last = l; | |
| 3173 } | |
| 3174 } | |
| 3175 } | |
| 3176 | |
| 3177 // Create result array of type [Ljava/lang/Class; | |
| 1142 | 3178 objArrayOop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), depth, CHECK_NULL); |
| 0 | 3179 // Fill in mirrors corresponding to method holders |
| 3180 int index = 0; | |
| 3181 while (first != NULL) { | |
| 6983 | 3182 result->obj_at_put(index++, first->klass()->java_mirror()); |
| 0 | 3183 first = first->next; |
| 3184 } | |
| 3185 assert(index == depth, "just checking"); | |
| 3186 | |
| 3187 return (jobjectArray) JNIHandles::make_local(env, result); | |
| 3188 JVM_END | |
| 3189 | |
| 3190 | |
| 3191 JVM_ENTRY(jint, JVM_ClassDepth(JNIEnv *env, jstring name)) | |
| 3192 JVMWrapper("JVM_ClassDepth"); | |
| 3193 ResourceMark rm(THREAD); | |
| 3194 Handle h_name (THREAD, JNIHandles::resolve_non_null(name)); | |
| 3195 Handle class_name_str = java_lang_String::internalize_classname(h_name, CHECK_0); | |
| 3196 | |
| 3197 const char* str = java_lang_String::as_utf8_string(class_name_str()); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
3198 TempNewSymbol class_name_sym = SymbolTable::probe(str, (int)strlen(str)); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
3199 if (class_name_sym == NULL) { |
| 0 | 3200 return -1; |
| 3201 } | |
| 3202 | |
| 3203 int depth = 0; | |
| 3204 | |
| 3205 for(vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { | |
| 3206 if (!vfst.method()->is_native()) { | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3207 InstanceKlass* holder = vfst.method()->method_holder(); |
| 0 | 3208 assert(holder->is_klass(), "just checking"); |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3209 if (holder->name() == class_name_sym) { |
| 0 | 3210 return depth; |
| 3211 } | |
| 3212 depth++; | |
| 3213 } | |
| 3214 } | |
| 3215 return -1; | |
| 3216 JVM_END | |
| 3217 | |
| 3218 | |
| 3219 JVM_ENTRY(jint, JVM_ClassLoaderDepth(JNIEnv *env)) | |
| 3220 JVMWrapper("JVM_ClassLoaderDepth"); | |
| 3221 ResourceMark rm(THREAD); | |
| 3222 int depth = 0; | |
| 3223 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { | |
| 3224 // if a method in a class in a trusted loader is in a doPrivileged, return -1 | |
| 3225 bool trusted = is_trusted_frame(thread, &vfst); | |
| 3226 if (trusted) return -1; | |
| 3227 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3228 Method* m = vfst.method(); |
| 0 | 3229 if (!m->is_native()) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3230 InstanceKlass* holder = m->method_holder(); |
| 0 | 3231 assert(holder->is_klass(), "just checking"); |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3232 oop loader = holder->class_loader(); |
| 0 | 3233 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { |
| 3234 return depth; | |
| 3235 } | |
| 3236 depth++; | |
| 3237 } | |
| 3238 } | |
| 3239 return -1; | |
| 3240 JVM_END | |
| 3241 | |
| 3242 | |
| 3243 // java.lang.Package //////////////////////////////////////////////////////////////// | |
| 3244 | |
| 3245 | |
| 3246 JVM_ENTRY(jstring, JVM_GetSystemPackage(JNIEnv *env, jstring name)) | |
| 3247 JVMWrapper("JVM_GetSystemPackage"); | |
| 3248 ResourceMark rm(THREAD); | |
| 3249 JvmtiVMObjectAllocEventCollector oam; | |
| 3250 char* str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name)); | |
| 3251 oop result = ClassLoader::get_system_package(str, CHECK_NULL); | |
| 3252 return (jstring) JNIHandles::make_local(result); | |
| 3253 JVM_END | |
| 3254 | |
| 3255 | |
| 3256 JVM_ENTRY(jobjectArray, JVM_GetSystemPackages(JNIEnv *env)) | |
| 3257 JVMWrapper("JVM_GetSystemPackages"); | |
| 3258 JvmtiVMObjectAllocEventCollector oam; | |
| 3259 objArrayOop result = ClassLoader::get_system_packages(CHECK_NULL); | |
| 3260 return (jobjectArray) JNIHandles::make_local(result); | |
| 3261 JVM_END | |
| 3262 | |
| 3263 | |
| 3264 // ObjectInputStream /////////////////////////////////////////////////////////////// | |
| 3265 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3266 bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessFlags access, bool classloader_only) { |
| 0 | 3267 if (current_class == NULL) { |
| 3268 return true; | |
| 3269 } | |
| 3270 if ((current_class == field_class) || access.is_public()) { | |
| 3271 return true; | |
| 3272 } | |
| 3273 | |
| 3274 if (access.is_protected()) { | |
| 3275 // See if current_class is a subclass of field_class | |
| 6983 | 3276 if (current_class->is_subclass_of(field_class)) { |
| 0 | 3277 return true; |
| 3278 } | |
| 3279 } | |
| 3280 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3281 return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class)); |
| 0 | 3282 } |
| 3283 | |
| 3284 | |
| 3285 // JVM_AllocateNewObject and JVM_AllocateNewArray are unused as of 1.4 | |
| 3286 JVM_ENTRY(jobject, JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)) | |
| 3287 JVMWrapper("JVM_AllocateNewObject"); | |
| 3288 JvmtiVMObjectAllocEventCollector oam; | |
| 3289 // Receiver is not used | |
| 3290 oop curr_mirror = JNIHandles::resolve_non_null(currClass); | |
| 3291 oop init_mirror = JNIHandles::resolve_non_null(initClass); | |
| 3292 | |
| 3293 // Cannot instantiate primitive types | |
| 3294 if (java_lang_Class::is_primitive(curr_mirror) || java_lang_Class::is_primitive(init_mirror)) { | |
| 3295 ResourceMark rm(THREAD); | |
| 3296 THROW_0(vmSymbols::java_lang_InvalidClassException()); | |
| 3297 } | |
| 3298 | |
| 3299 // Arrays not allowed here, must use JVM_AllocateNewArray | |
| 6983 | 3300 if (java_lang_Class::as_Klass(curr_mirror)->oop_is_array() || |
| 3301 java_lang_Class::as_Klass(init_mirror)->oop_is_array()) { | |
| 0 | 3302 ResourceMark rm(THREAD); |
| 3303 THROW_0(vmSymbols::java_lang_InvalidClassException()); | |
| 3304 } | |
| 3305 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3306 instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_Klass(curr_mirror)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3307 instanceKlassHandle init_klass (THREAD, java_lang_Class::as_Klass(init_mirror)); |
| 0 | 3308 |
| 3309 assert(curr_klass->is_subclass_of(init_klass()), "just checking"); | |
| 3310 | |
| 3311 // Interfaces, abstract classes, and java.lang.Class classes cannot be instantiated directly. | |
| 3312 curr_klass->check_valid_for_instantiation(false, CHECK_NULL); | |
| 3313 | |
| 3314 // Make sure klass is initialized, since we are about to instantiate one of them. | |
| 3315 curr_klass->initialize(CHECK_NULL); | |
| 3316 | |
| 3317 methodHandle m (THREAD, | |
| 3318 init_klass->find_method(vmSymbols::object_initializer_name(), | |
| 3319 vmSymbols::void_method_signature())); | |
| 3320 if (m.is_null()) { | |
| 3321 ResourceMark rm(THREAD); | |
| 3322 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), | |
| 6983 | 3323 Method::name_and_sig_as_C_string(init_klass(), |
| 0 | 3324 vmSymbols::object_initializer_name(), |
| 3325 vmSymbols::void_method_signature())); | |
| 3326 } | |
| 3327 | |
| 3328 if (curr_klass == init_klass && !m->is_public()) { | |
| 3329 // Calling the constructor for class 'curr_klass'. | |
| 3330 // Only allow calls to a public no-arg constructor. | |
| 3331 // This path corresponds to creating an Externalizable object. | |
| 3332 THROW_0(vmSymbols::java_lang_IllegalAccessException()); | |
| 3333 } | |
| 3334 | |
| 3335 if (!force_verify_field_access(curr_klass(), init_klass(), m->access_flags(), false)) { | |
| 3336 // subclass 'curr_klass' does not have access to no-arg constructor of 'initcb' | |
| 3337 THROW_0(vmSymbols::java_lang_IllegalAccessException()); | |
| 3338 } | |
| 3339 | |
| 3340 Handle obj = curr_klass->allocate_instance_handle(CHECK_NULL); | |
| 3341 // Call constructor m. This might call a constructor higher up in the hierachy | |
| 3342 JavaCalls::call_default_constructor(thread, m, obj, CHECK_NULL); | |
| 3343 | |
| 3344 return JNIHandles::make_local(obj()); | |
| 3345 JVM_END | |
| 3346 | |
| 3347 | |
| 3348 JVM_ENTRY(jobject, JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)) | |
| 3349 JVMWrapper("JVM_AllocateNewArray"); | |
| 3350 JvmtiVMObjectAllocEventCollector oam; | |
| 3351 oop mirror = JNIHandles::resolve_non_null(currClass); | |
| 3352 | |
| 3353 if (java_lang_Class::is_primitive(mirror)) { | |
| 3354 THROW_0(vmSymbols::java_lang_InvalidClassException()); | |
| 3355 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3356 Klass* k = java_lang_Class::as_Klass(mirror); |
| 0 | 3357 oop result; |
| 3358 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3359 if (k->oop_is_typeArray()) { |
| 0 | 3360 // typeArray |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
3361 result = TypeArrayKlass::cast(k)->allocate(length, CHECK_NULL); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3362 } else if (k->oop_is_objArray()) { |
| 0 | 3363 // objArray |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
3364 ObjArrayKlass* oak = ObjArrayKlass::cast(k); |
| 0 | 3365 oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior) |
| 3366 result = oak->allocate(length, CHECK_NULL); | |
| 3367 } else { | |
| 3368 THROW_0(vmSymbols::java_lang_InvalidClassException()); | |
| 3369 } | |
| 3370 return JNIHandles::make_local(env, result); | |
| 3371 JVM_END | |
| 3372 | |
| 3373 | |
| 3374 // Return the first non-null class loader up the execution stack, or null | |
| 3375 // if only code from the null class loader is on the stack. | |
| 3376 | |
| 3377 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env)) | |
| 3378 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { | |
| 3379 // UseNewReflection | |
| 3380 vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3381 oop loader = vfst.method()->method_holder()->class_loader(); |
| 0 | 3382 if (loader != NULL) { |
| 3383 return JNIHandles::make_local(env, loader); | |
| 3384 } | |
| 3385 } | |
| 3386 return NULL; | |
| 3387 JVM_END | |
| 3388 | |
| 3389 | |
| 3390 // Load a class relative to the most recent class on the stack with a non-null | |
| 3391 // classloader. | |
| 3392 // This function has been deprecated and should not be considered part of the | |
| 3393 // specified JVM interface. | |
| 3394 | |
| 3395 JVM_ENTRY(jclass, JVM_LoadClass0(JNIEnv *env, jobject receiver, | |
| 3396 jclass currClass, jstring currClassName)) | |
| 3397 JVMWrapper("JVM_LoadClass0"); | |
| 3398 // Receiver is not used | |
| 3399 ResourceMark rm(THREAD); | |
| 3400 | |
| 3401 // Class name argument is not guaranteed to be in internal format | |
| 3402 Handle classname (THREAD, JNIHandles::resolve_non_null(currClassName)); | |
| 3403 Handle string = java_lang_String::internalize_classname(classname, CHECK_NULL); | |
| 3404 | |
| 3405 const char* str = java_lang_String::as_utf8_string(string()); | |
| 3406 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
3407 if (str == NULL || (int)strlen(str) > Symbol::max_length()) { |
| 0 | 3408 // It's impossible to create this class; the name cannot fit |
| 3409 // into the constant pool. | |
| 3410 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), str); | |
| 3411 } | |
| 3412 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
3413 TempNewSymbol name = SymbolTable::new_symbol(str, CHECK_NULL); |
| 0 | 3414 Handle curr_klass (THREAD, JNIHandles::resolve(currClass)); |
| 3415 // Find the most recent class on the stack with a non-null classloader | |
| 3416 oop loader = NULL; | |
| 3417 oop protection_domain = NULL; | |
| 3418 if (curr_klass.is_null()) { | |
| 3419 for (vframeStream vfst(thread); | |
| 3420 !vfst.at_end() && loader == NULL; | |
| 3421 vfst.next()) { | |
| 3422 if (!vfst.method()->is_native()) { | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3423 InstanceKlass* holder = vfst.method()->method_holder(); |
|
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3424 loader = holder->class_loader(); |
|
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6831
diff
changeset
|
3425 protection_domain = holder->protection_domain(); |
| 0 | 3426 } |
| 3427 } | |
| 3428 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3429 Klass* curr_klass_oop = java_lang_Class::as_Klass(curr_klass()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3430 loader = InstanceKlass::cast(curr_klass_oop)->class_loader(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3431 protection_domain = InstanceKlass::cast(curr_klass_oop)->protection_domain(); |
| 0 | 3432 } |
| 3433 Handle h_loader(THREAD, loader); | |
| 3434 Handle h_prot (THREAD, protection_domain); | |
|
657
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
3435 jclass result = find_class_from_class_loader(env, name, true, h_loader, h_prot, |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
3436 false, thread); |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
3437 if (TraceClassResolution && result != NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3438 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))); |
|
657
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
3439 } |
|
715dceaa89b7
6603316: Improve instrumentation for classes loaded at startup
acorn
parents:
579
diff
changeset
|
3440 return result; |
| 0 | 3441 JVM_END |
| 3442 | |
| 3443 | |
| 3444 // Array /////////////////////////////////////////////////////////////////////////////////////////// | |
| 3445 | |
| 3446 | |
| 3447 // resolve array handle and check arguments | |
| 3448 static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) { | |
| 3449 if (arr == NULL) { | |
| 3450 THROW_0(vmSymbols::java_lang_NullPointerException()); | |
| 3451 } | |
| 3452 oop a = JNIHandles::resolve_non_null(arr); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
3453 if (!a->is_array() || (type_array_only && !a->is_typeArray())) { |
| 0 | 3454 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array"); |
| 3455 } | |
| 3456 return arrayOop(a); | |
| 3457 } | |
| 3458 | |
| 3459 | |
| 3460 JVM_ENTRY(jint, JVM_GetArrayLength(JNIEnv *env, jobject arr)) | |
| 3461 JVMWrapper("JVM_GetArrayLength"); | |
| 3462 arrayOop a = check_array(env, arr, false, CHECK_0); | |
| 3463 return a->length(); | |
| 3464 JVM_END | |
| 3465 | |
| 3466 | |
| 3467 JVM_ENTRY(jobject, JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)) | |
| 3468 JVMWrapper("JVM_Array_Get"); | |
| 3469 JvmtiVMObjectAllocEventCollector oam; | |
| 3470 arrayOop a = check_array(env, arr, false, CHECK_NULL); | |
| 3471 jvalue value; | |
| 3472 BasicType type = Reflection::array_get(&value, a, index, CHECK_NULL); | |
| 3473 oop box = Reflection::box(&value, type, CHECK_NULL); | |
| 3474 return JNIHandles::make_local(env, box); | |
| 3475 JVM_END | |
| 3476 | |
| 3477 | |
| 3478 JVM_ENTRY(jvalue, JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)) | |
| 3479 JVMWrapper("JVM_GetPrimitiveArrayElement"); | |
| 3480 jvalue value; | |
| 3481 value.i = 0; // to initialize value before getting used in CHECK | |
| 3482 arrayOop a = check_array(env, arr, true, CHECK_(value)); | |
| 3483 assert(a->is_typeArray(), "just checking"); | |
| 3484 BasicType type = Reflection::array_get(&value, a, index, CHECK_(value)); | |
| 3485 BasicType wide_type = (BasicType) wCode; | |
| 3486 if (type != wide_type) { | |
| 3487 Reflection::widen(&value, type, wide_type, CHECK_(value)); | |
| 3488 } | |
| 3489 return value; | |
| 3490 JVM_END | |
| 3491 | |
| 3492 | |
| 3493 JVM_ENTRY(void, JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)) | |
| 3494 JVMWrapper("JVM_SetArrayElement"); | |
| 3495 arrayOop a = check_array(env, arr, false, CHECK); | |
| 3496 oop box = JNIHandles::resolve(val); | |
| 3497 jvalue value; | |
| 3498 value.i = 0; // to initialize value before getting used in CHECK | |
| 3499 BasicType value_type; | |
| 3500 if (a->is_objArray()) { | |
| 3501 // Make sure we do no unbox e.g. java/lang/Integer instances when storing into an object array | |
| 3502 value_type = Reflection::unbox_for_regular_object(box, &value); | |
| 3503 } else { | |
| 3504 value_type = Reflection::unbox_for_primitive(box, &value, CHECK); | |
| 3505 } | |
| 3506 Reflection::array_set(&value, a, index, value_type, CHECK); | |
| 3507 JVM_END | |
| 3508 | |
| 3509 | |
| 3510 JVM_ENTRY(void, JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)) | |
| 3511 JVMWrapper("JVM_SetPrimitiveArrayElement"); | |
| 3512 arrayOop a = check_array(env, arr, true, CHECK); | |
| 3513 assert(a->is_typeArray(), "just checking"); | |
| 3514 BasicType value_type = (BasicType) vCode; | |
| 3515 Reflection::array_set(&v, a, index, value_type, CHECK); | |
| 3516 JVM_END | |
| 3517 | |
| 3518 | |
| 3519 JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)) | |
| 3520 JVMWrapper("JVM_NewArray"); | |
| 3521 JvmtiVMObjectAllocEventCollector oam; | |
| 3522 oop element_mirror = JNIHandles::resolve(eltClass); | |
| 3523 oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL); | |
| 3524 return JNIHandles::make_local(env, result); | |
| 3525 JVM_END | |
| 3526 | |
| 3527 | |
| 3528 JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)) | |
| 3529 JVMWrapper("JVM_NewMultiArray"); | |
| 3530 JvmtiVMObjectAllocEventCollector oam; | |
| 3531 arrayOop dim_array = check_array(env, dim, true, CHECK_NULL); | |
| 3532 oop element_mirror = JNIHandles::resolve(eltClass); | |
| 3533 assert(dim_array->is_typeArray(), "just checking"); | |
| 3534 oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL); | |
| 3535 return JNIHandles::make_local(env, result); | |
| 3536 JVM_END | |
| 3537 | |
| 3538 | |
| 3539 // Networking library support //////////////////////////////////////////////////////////////////// | |
| 3540 | |
| 3541 JVM_LEAF(jint, JVM_InitializeSocketLibrary()) | |
| 3542 JVMWrapper("JVM_InitializeSocketLibrary"); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3543 return 0; |
| 0 | 3544 JVM_END |
| 3545 | |
| 3546 | |
| 3547 JVM_LEAF(jint, JVM_Socket(jint domain, jint type, jint protocol)) | |
| 3548 JVMWrapper("JVM_Socket"); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3549 return os::socket(domain, type, protocol); |
| 0 | 3550 JVM_END |
| 3551 | |
| 3552 | |
| 3553 JVM_LEAF(jint, JVM_SocketClose(jint fd)) | |
| 3554 JVMWrapper2("JVM_SocketClose (0x%x)", fd); | |
| 3555 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3556 return os::socket_close(fd); |
| 0 | 3557 JVM_END |
| 3558 | |
| 3559 | |
| 3560 JVM_LEAF(jint, JVM_SocketShutdown(jint fd, jint howto)) | |
| 3561 JVMWrapper2("JVM_SocketShutdown (0x%x)", fd); | |
| 3562 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3563 return os::socket_shutdown(fd, howto); |
| 0 | 3564 JVM_END |
| 3565 | |
| 3566 | |
| 3567 JVM_LEAF(jint, JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)) | |
| 3568 JVMWrapper2("JVM_Recv (0x%x)", fd); | |
| 3569 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3570 return os::recv(fd, buf, (size_t)nBytes, (uint)flags); |
| 0 | 3571 JVM_END |
| 3572 | |
| 3573 | |
| 3574 JVM_LEAF(jint, JVM_Send(jint fd, char *buf, jint nBytes, jint flags)) | |
| 3575 JVMWrapper2("JVM_Send (0x%x)", fd); | |
| 3576 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3577 return os::send(fd, buf, (size_t)nBytes, (uint)flags); |
| 0 | 3578 JVM_END |
| 3579 | |
| 3580 | |
| 3581 JVM_LEAF(jint, JVM_Timeout(int fd, long timeout)) | |
| 3582 JVMWrapper2("JVM_Timeout (0x%x)", fd); | |
| 3583 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3584 return os::timeout(fd, timeout); |
| 0 | 3585 JVM_END |
| 3586 | |
| 3587 | |
| 3588 JVM_LEAF(jint, JVM_Listen(jint fd, jint count)) | |
| 3589 JVMWrapper2("JVM_Listen (0x%x)", fd); | |
| 3590 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3591 return os::listen(fd, count); |
| 0 | 3592 JVM_END |
| 3593 | |
| 3594 | |
| 3595 JVM_LEAF(jint, JVM_Connect(jint fd, struct sockaddr *him, jint len)) | |
| 3596 JVMWrapper2("JVM_Connect (0x%x)", fd); | |
| 3597 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3598 return os::connect(fd, him, (socklen_t)len); |
| 0 | 3599 JVM_END |
| 3600 | |
| 3601 | |
| 3602 JVM_LEAF(jint, JVM_Bind(jint fd, struct sockaddr *him, jint len)) | |
| 3603 JVMWrapper2("JVM_Bind (0x%x)", fd); | |
| 3604 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3605 return os::bind(fd, him, (socklen_t)len); |
| 0 | 3606 JVM_END |
| 3607 | |
| 3608 | |
| 3609 JVM_LEAF(jint, JVM_Accept(jint fd, struct sockaddr *him, jint *len)) | |
| 3610 JVMWrapper2("JVM_Accept (0x%x)", fd); | |
| 3611 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3612 socklen_t socklen = (socklen_t)(*len); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3613 jint result = os::accept(fd, him, &socklen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3614 *len = (jint)socklen; |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3615 return result; |
| 0 | 3616 JVM_END |
| 3617 | |
| 3618 | |
| 3619 JVM_LEAF(jint, JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)) | |
| 3620 JVMWrapper2("JVM_RecvFrom (0x%x)", fd); | |
| 3621 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3622 socklen_t socklen = (socklen_t)(*fromlen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3623 jint result = os::recvfrom(fd, buf, (size_t)nBytes, (uint)flags, from, &socklen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3624 *fromlen = (int)socklen; |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3625 return result; |
| 0 | 3626 JVM_END |
| 3627 | |
| 3628 | |
| 3629 JVM_LEAF(jint, JVM_GetSockName(jint fd, struct sockaddr *him, int *len)) | |
| 3630 JVMWrapper2("JVM_GetSockName (0x%x)", fd); | |
| 3631 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3632 socklen_t socklen = (socklen_t)(*len); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3633 jint result = os::get_sock_name(fd, him, &socklen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3634 *len = (int)socklen; |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3635 return result; |
| 0 | 3636 JVM_END |
| 3637 | |
| 3638 | |
| 3639 JVM_LEAF(jint, JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)) | |
| 3640 JVMWrapper2("JVM_SendTo (0x%x)", fd); | |
| 3641 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3642 return os::sendto(fd, buf, (size_t)len, (uint)flags, to, (socklen_t)tolen); |
| 0 | 3643 JVM_END |
| 3644 | |
| 3645 | |
| 3646 JVM_LEAF(jint, JVM_SocketAvailable(jint fd, jint *pbytes)) | |
| 3647 JVMWrapper2("JVM_SocketAvailable (0x%x)", fd); | |
| 3648 //%note jvm_r6 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3649 return os::socket_available(fd, pbytes); |
| 0 | 3650 JVM_END |
| 3651 | |
| 3652 | |
| 3653 JVM_LEAF(jint, JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)) | |
| 3654 JVMWrapper2("JVM_GetSockOpt (0x%x)", fd); | |
| 3655 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3656 socklen_t socklen = (socklen_t)(*optlen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3657 jint result = os::get_sock_opt(fd, level, optname, optval, &socklen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3658 *optlen = (int)socklen; |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3659 return result; |
| 0 | 3660 JVM_END |
| 3661 | |
| 3662 | |
| 3663 JVM_LEAF(jint, JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)) | |
| 3664 JVMWrapper2("JVM_GetSockOpt (0x%x)", fd); | |
| 3665 //%note jvm_r6 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3666 return os::set_sock_opt(fd, level, optname, optval, (socklen_t)optlen); |
| 0 | 3667 JVM_END |
| 3668 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3669 |
| 0 | 3670 JVM_LEAF(int, JVM_GetHostName(char* name, int namelen)) |
| 3671 JVMWrapper("JVM_GetHostName"); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3672 return os::get_host_name(name, namelen); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3673 JVM_END |
| 0 | 3674 |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3675 |
| 0 | 3676 // Library support /////////////////////////////////////////////////////////////////////////// |
| 3677 | |
| 3678 JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name)) | |
| 3679 //%note jvm_ct | |
| 3680 JVMWrapper2("JVM_LoadLibrary (%s)", name); | |
| 3681 char ebuf[1024]; | |
| 3682 void *load_result; | |
| 3683 { | |
| 3684 ThreadToNativeFromVM ttnfvm(thread); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3685 load_result = os::dll_load(name, ebuf, sizeof ebuf); |
| 0 | 3686 } |
| 3687 if (load_result == NULL) { | |
| 3688 char msg[1024]; | |
| 3689 jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf); | |
| 3690 // Since 'ebuf' may contain a string encoded using | |
| 3691 // platform encoding scheme, we need to pass | |
| 3692 // Exceptions::unsafe_to_utf8 to the new_exception method | |
| 3693 // as the last argument. See bug 6367357. | |
| 3694 Handle h_exception = | |
| 3695 Exceptions::new_exception(thread, | |
| 3696 vmSymbols::java_lang_UnsatisfiedLinkError(), | |
| 3697 msg, Exceptions::unsafe_to_utf8); | |
| 3698 | |
| 3699 THROW_HANDLE_0(h_exception); | |
| 3700 } | |
| 3701 return load_result; | |
| 3702 JVM_END | |
| 3703 | |
| 3704 | |
| 3705 JVM_LEAF(void, JVM_UnloadLibrary(void* handle)) | |
| 3706 JVMWrapper("JVM_UnloadLibrary"); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3707 os::dll_unload(handle); |
| 0 | 3708 JVM_END |
| 3709 | |
| 3710 | |
| 3711 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name)) | |
| 3712 JVMWrapper2("JVM_FindLibraryEntry (%s)", name); | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
3713 return os::dll_lookup(handle, name); |
| 0 | 3714 JVM_END |
| 3715 | |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
3716 |
| 0 | 3717 // Floating point support //////////////////////////////////////////////////////////////////// |
| 3718 | |
| 3719 JVM_LEAF(jboolean, JVM_IsNaN(jdouble a)) | |
| 3720 JVMWrapper("JVM_IsNaN"); | |
| 3721 return g_isnan(a); | |
| 3722 JVM_END | |
| 3723 | |
| 3724 | |
| 3725 // JNI version /////////////////////////////////////////////////////////////////////////////// | |
| 3726 | |
| 3727 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version)) | |
| 3728 JVMWrapper2("JVM_IsSupportedJNIVersion (%d)", version); | |
| 3729 return Threads::is_supported_jni_version_including_1_1(version); | |
| 3730 JVM_END | |
| 3731 | |
| 3732 | |
| 3733 // String support /////////////////////////////////////////////////////////////////////////// | |
| 3734 | |
| 3735 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str)) | |
| 3736 JVMWrapper("JVM_InternString"); | |
| 3737 JvmtiVMObjectAllocEventCollector oam; | |
| 3738 if (str == NULL) return NULL; | |
| 3739 oop string = JNIHandles::resolve_non_null(str); | |
| 3740 oop result = StringTable::intern(string, CHECK_NULL); | |
| 3741 return (jstring) JNIHandles::make_local(env, result); | |
| 3742 JVM_END | |
| 3743 | |
| 3744 | |
| 3745 // Raw monitor support ////////////////////////////////////////////////////////////////////// | |
| 3746 | |
| 3747 // The lock routine below calls lock_without_safepoint_check in order to get a raw lock | |
| 3748 // without interfering with the safepoint mechanism. The routines are not JVM_LEAF because | |
| 3749 // they might be called by non-java threads. The JVM_LEAF installs a NoHandleMark check | |
| 3750 // that only works with java threads. | |
| 3751 | |
| 3752 | |
| 3753 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void) { | |
| 3754 VM_Exit::block_if_vm_exited(); | |
| 3755 JVMWrapper("JVM_RawMonitorCreate"); | |
| 3756 return new Mutex(Mutex::native, "JVM_RawMonitorCreate"); | |
| 3757 } | |
| 3758 | |
| 3759 | |
| 3760 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon) { | |
| 3761 VM_Exit::block_if_vm_exited(); | |
| 3762 JVMWrapper("JVM_RawMonitorDestroy"); | |
| 3763 delete ((Mutex*) mon); | |
| 3764 } | |
| 3765 | |
| 3766 | |
| 3767 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon) { | |
| 3768 VM_Exit::block_if_vm_exited(); | |
| 3769 JVMWrapper("JVM_RawMonitorEnter"); | |
| 3770 ((Mutex*) mon)->jvm_raw_lock(); | |
| 3771 return 0; | |
| 3772 } | |
| 3773 | |
| 3774 | |
| 3775 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon) { | |
| 3776 VM_Exit::block_if_vm_exited(); | |
| 3777 JVMWrapper("JVM_RawMonitorExit"); | |
| 3778 ((Mutex*) mon)->jvm_raw_unlock(); | |
| 3779 } | |
| 3780 | |
| 3781 | |
| 3782 // Support for Serialization | |
| 3783 | |
| 3784 typedef jfloat (JNICALL *IntBitsToFloatFn )(JNIEnv* env, jclass cb, jint value); | |
| 3785 typedef jdouble (JNICALL *LongBitsToDoubleFn)(JNIEnv* env, jclass cb, jlong value); | |
| 3786 typedef jint (JNICALL *FloatToIntBitsFn )(JNIEnv* env, jclass cb, jfloat value); | |
| 3787 typedef jlong (JNICALL *DoubleToLongBitsFn)(JNIEnv* env, jclass cb, jdouble value); | |
| 3788 | |
| 3789 static IntBitsToFloatFn int_bits_to_float_fn = NULL; | |
| 3790 static LongBitsToDoubleFn long_bits_to_double_fn = NULL; | |
| 3791 static FloatToIntBitsFn float_to_int_bits_fn = NULL; | |
| 3792 static DoubleToLongBitsFn double_to_long_bits_fn = NULL; | |
| 3793 | |
| 3794 | |
| 3795 void initialize_converter_functions() { | |
| 3796 if (JDK_Version::is_gte_jdk14x_version()) { | |
| 3797 // These functions only exist for compatibility with 1.3.1 and earlier | |
| 3798 return; | |
| 3799 } | |
| 3800 | |
| 3801 // called from universe_post_init() | |
| 3802 assert( | |
| 3803 int_bits_to_float_fn == NULL && | |
| 3804 long_bits_to_double_fn == NULL && | |
| 3805 float_to_int_bits_fn == NULL && | |
| 3806 double_to_long_bits_fn == NULL , | |
| 3807 "initialization done twice" | |
| 3808 ); | |
| 3809 // initialize | |
| 3810 int_bits_to_float_fn = CAST_TO_FN_PTR(IntBitsToFloatFn , NativeLookup::base_library_lookup("java/lang/Float" , "intBitsToFloat" , "(I)F")); | |
| 3811 long_bits_to_double_fn = CAST_TO_FN_PTR(LongBitsToDoubleFn, NativeLookup::base_library_lookup("java/lang/Double", "longBitsToDouble", "(J)D")); | |
| 3812 float_to_int_bits_fn = CAST_TO_FN_PTR(FloatToIntBitsFn , NativeLookup::base_library_lookup("java/lang/Float" , "floatToIntBits" , "(F)I")); | |
| 3813 double_to_long_bits_fn = CAST_TO_FN_PTR(DoubleToLongBitsFn, NativeLookup::base_library_lookup("java/lang/Double", "doubleToLongBits", "(D)J")); | |
| 3814 // verify | |
| 3815 assert( | |
| 3816 int_bits_to_float_fn != NULL && | |
| 3817 long_bits_to_double_fn != NULL && | |
| 3818 float_to_int_bits_fn != NULL && | |
| 3819 double_to_long_bits_fn != NULL , | |
| 3820 "initialization failed" | |
| 3821 ); | |
| 3822 } | |
| 3823 | |
| 3824 | |
| 3825 // Serialization | |
| 3826 JVM_ENTRY(void, JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, | |
| 3827 jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)) | |
| 3828 assert(!JDK_Version::is_gte_jdk14x_version(), "should only be used in 1.3.1 and earlier"); | |
| 3829 | |
| 3830 typeArrayOop tcodes = typeArrayOop(JNIHandles::resolve(typecodes)); | |
| 3831 typeArrayOop dbuf = typeArrayOop(JNIHandles::resolve(data)); | |
| 3832 typeArrayOop fids = typeArrayOop(JNIHandles::resolve(fieldIDs)); | |
| 3833 oop o = JNIHandles::resolve(obj); | |
| 3834 | |
| 3835 if (o == NULL || fids == NULL || dbuf == NULL || tcodes == NULL) { | |
| 3836 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 3837 } | |
| 3838 | |
| 3839 jsize nfids = fids->length(); | |
| 3840 if (nfids == 0) return; | |
| 3841 | |
| 3842 if (tcodes->length() < nfids) { | |
| 3843 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); | |
| 3844 } | |
| 3845 | |
| 3846 jsize off = 0; | |
| 3847 /* loop through fields, setting values */ | |
| 3848 for (jsize i = 0; i < nfids; i++) { | |
| 3849 jfieldID fid = (jfieldID)(intptr_t) fids->long_at(i); | |
| 3850 int field_offset; | |
| 3851 if (fid != NULL) { | |
| 3852 // NULL is a legal value for fid, but retrieving the field offset | |
| 3853 // trigger assertion in that case | |
| 3854 field_offset = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid); | |
| 3855 } | |
| 3856 | |
| 3857 switch (tcodes->char_at(i)) { | |
| 3858 case 'Z': | |
| 3859 if (fid != NULL) { | |
| 3860 jboolean val = (dbuf->byte_at(off) != 0) ? JNI_TRUE : JNI_FALSE; | |
| 3861 o->bool_field_put(field_offset, val); | |
| 3862 } | |
| 3863 off++; | |
| 3864 break; | |
| 3865 | |
| 3866 case 'B': | |
| 3867 if (fid != NULL) { | |
| 3868 o->byte_field_put(field_offset, dbuf->byte_at(off)); | |
| 3869 } | |
| 3870 off++; | |
| 3871 break; | |
| 3872 | |
| 3873 case 'C': | |
| 3874 if (fid != NULL) { | |
| 3875 jchar val = ((dbuf->byte_at(off + 0) & 0xFF) << 8) | |
| 3876 + ((dbuf->byte_at(off + 1) & 0xFF) << 0); | |
| 3877 o->char_field_put(field_offset, val); | |
| 3878 } | |
| 3879 off += 2; | |
| 3880 break; | |
| 3881 | |
| 3882 case 'S': | |
| 3883 if (fid != NULL) { | |
| 3884 jshort val = ((dbuf->byte_at(off + 0) & 0xFF) << 8) | |
| 3885 + ((dbuf->byte_at(off + 1) & 0xFF) << 0); | |
| 3886 o->short_field_put(field_offset, val); | |
| 3887 } | |
| 3888 off += 2; | |
| 3889 break; | |
| 3890 | |
| 3891 case 'I': | |
| 3892 if (fid != NULL) { | |
| 3893 jint ival = ((dbuf->byte_at(off + 0) & 0xFF) << 24) | |
| 3894 + ((dbuf->byte_at(off + 1) & 0xFF) << 16) | |
| 3895 + ((dbuf->byte_at(off + 2) & 0xFF) << 8) | |
| 3896 + ((dbuf->byte_at(off + 3) & 0xFF) << 0); | |
| 3897 o->int_field_put(field_offset, ival); | |
| 3898 } | |
| 3899 off += 4; | |
| 3900 break; | |
| 3901 | |
| 3902 case 'F': | |
| 3903 if (fid != NULL) { | |
| 3904 jint ival = ((dbuf->byte_at(off + 0) & 0xFF) << 24) | |
| 3905 + ((dbuf->byte_at(off + 1) & 0xFF) << 16) | |
| 3906 + ((dbuf->byte_at(off + 2) & 0xFF) << 8) | |
| 3907 + ((dbuf->byte_at(off + 3) & 0xFF) << 0); | |
| 3908 jfloat fval = (*int_bits_to_float_fn)(env, NULL, ival); | |
| 3909 o->float_field_put(field_offset, fval); | |
| 3910 } | |
| 3911 off += 4; | |
| 3912 break; | |
| 3913 | |
| 3914 case 'J': | |
| 3915 if (fid != NULL) { | |
| 3916 jlong lval = (((jlong) dbuf->byte_at(off + 0) & 0xFF) << 56) | |
| 3917 + (((jlong) dbuf->byte_at(off + 1) & 0xFF) << 48) | |
| 3918 + (((jlong) dbuf->byte_at(off + 2) & 0xFF) << 40) | |
| 3919 + (((jlong) dbuf->byte_at(off + 3) & 0xFF) << 32) | |
| 3920 + (((jlong) dbuf->byte_at(off + 4) & 0xFF) << 24) | |
| 3921 + (((jlong) dbuf->byte_at(off + 5) & 0xFF) << 16) | |
| 3922 + (((jlong) dbuf->byte_at(off + 6) & 0xFF) << 8) | |
| 3923 + (((jlong) dbuf->byte_at(off + 7) & 0xFF) << 0); | |
| 3924 o->long_field_put(field_offset, lval); | |
| 3925 } | |
| 3926 off += 8; | |
| 3927 break; | |
| 3928 | |
| 3929 case 'D': | |
| 3930 if (fid != NULL) { | |
| 3931 jlong lval = (((jlong) dbuf->byte_at(off + 0) & 0xFF) << 56) | |
| 3932 + (((jlong) dbuf->byte_at(off + 1) & 0xFF) << 48) | |
| 3933 + (((jlong) dbuf->byte_at(off + 2) & 0xFF) << 40) | |
| 3934 + (((jlong) dbuf->byte_at(off + 3) & 0xFF) << 32) | |
| 3935 + (((jlong) dbuf->byte_at(off + 4) & 0xFF) << 24) | |
| 3936 + (((jlong) dbuf->byte_at(off + 5) & 0xFF) << 16) | |
| 3937 + (((jlong) dbuf->byte_at(off + 6) & 0xFF) << 8) | |
| 3938 + (((jlong) dbuf->byte_at(off + 7) & 0xFF) << 0); | |
| 3939 jdouble dval = (*long_bits_to_double_fn)(env, NULL, lval); | |
| 3940 o->double_field_put(field_offset, dval); | |
| 3941 } | |
| 3942 off += 8; | |
| 3943 break; | |
| 3944 | |
| 3945 default: | |
| 3946 // Illegal typecode | |
| 3947 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "illegal typecode"); | |
| 3948 } | |
| 3949 } | |
| 3950 JVM_END | |
| 3951 | |
| 3952 | |
| 3953 JVM_ENTRY(void, JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, | |
| 3954 jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)) | |
| 3955 assert(!JDK_Version::is_gte_jdk14x_version(), "should only be used in 1.3.1 and earlier"); | |
| 3956 | |
| 3957 typeArrayOop tcodes = typeArrayOop(JNIHandles::resolve(typecodes)); | |
| 3958 typeArrayOop dbuf = typeArrayOop(JNIHandles::resolve(data)); | |
| 3959 typeArrayOop fids = typeArrayOop(JNIHandles::resolve(fieldIDs)); | |
| 3960 oop o = JNIHandles::resolve(obj); | |
| 3961 | |
| 3962 if (o == NULL || fids == NULL || dbuf == NULL || tcodes == NULL) { | |
| 3963 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 3964 } | |
| 3965 | |
| 3966 jsize nfids = fids->length(); | |
| 3967 if (nfids == 0) return; | |
| 3968 | |
| 3969 if (tcodes->length() < nfids) { | |
| 3970 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); | |
| 3971 } | |
| 3972 | |
| 3973 /* loop through fields, fetching values */ | |
| 3974 jsize off = 0; | |
| 3975 for (jsize i = 0; i < nfids; i++) { | |
| 3976 jfieldID fid = (jfieldID)(intptr_t) fids->long_at(i); | |
| 3977 if (fid == NULL) { | |
| 3978 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 3979 } | |
| 3980 int field_offset = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid); | |
| 3981 | |
| 3982 switch (tcodes->char_at(i)) { | |
| 3983 case 'Z': | |
| 3984 { | |
| 3985 jboolean val = o->bool_field(field_offset); | |
| 3986 dbuf->byte_at_put(off++, (val != 0) ? 1 : 0); | |
| 3987 } | |
| 3988 break; | |
| 3989 | |
| 3990 case 'B': | |
| 3991 dbuf->byte_at_put(off++, o->byte_field(field_offset)); | |
| 3992 break; | |
| 3993 | |
| 3994 case 'C': | |
| 3995 { | |
| 3996 jchar val = o->char_field(field_offset); | |
| 3997 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); | |
| 3998 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); | |
| 3999 } | |
| 4000 break; | |
| 4001 | |
| 4002 case 'S': | |
| 4003 { | |
| 4004 jshort val = o->short_field(field_offset); | |
| 4005 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); | |
| 4006 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); | |
| 4007 } | |
| 4008 break; | |
| 4009 | |
| 4010 case 'I': | |
| 4011 { | |
| 4012 jint val = o->int_field(field_offset); | |
| 4013 dbuf->byte_at_put(off++, (val >> 24) & 0xFF); | |
| 4014 dbuf->byte_at_put(off++, (val >> 16) & 0xFF); | |
| 4015 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); | |
| 4016 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); | |
| 4017 } | |
| 4018 break; | |
| 4019 | |
| 4020 case 'F': | |
| 4021 { | |
| 4022 jfloat fval = o->float_field(field_offset); | |
| 4023 jint ival = (*float_to_int_bits_fn)(env, NULL, fval); | |
| 4024 dbuf->byte_at_put(off++, (ival >> 24) & 0xFF); | |
| 4025 dbuf->byte_at_put(off++, (ival >> 16) & 0xFF); | |
| 4026 dbuf->byte_at_put(off++, (ival >> 8) & 0xFF); | |
| 4027 dbuf->byte_at_put(off++, (ival >> 0) & 0xFF); | |
| 4028 } | |
| 4029 break; | |
| 4030 | |
| 4031 case 'J': | |
| 4032 { | |
| 4033 jlong val = o->long_field(field_offset); | |
| 4034 dbuf->byte_at_put(off++, (val >> 56) & 0xFF); | |
| 4035 dbuf->byte_at_put(off++, (val >> 48) & 0xFF); | |
| 4036 dbuf->byte_at_put(off++, (val >> 40) & 0xFF); | |
| 4037 dbuf->byte_at_put(off++, (val >> 32) & 0xFF); | |
| 4038 dbuf->byte_at_put(off++, (val >> 24) & 0xFF); | |
| 4039 dbuf->byte_at_put(off++, (val >> 16) & 0xFF); | |
| 4040 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); | |
| 4041 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); | |
| 4042 } | |
| 4043 break; | |
| 4044 | |
| 4045 case 'D': | |
| 4046 { | |
| 4047 jdouble dval = o->double_field(field_offset); | |
| 4048 jlong lval = (*double_to_long_bits_fn)(env, NULL, dval); | |
| 4049 dbuf->byte_at_put(off++, (lval >> 56) & 0xFF); | |
| 4050 dbuf->byte_at_put(off++, (lval >> 48) & 0xFF); | |
| 4051 dbuf->byte_at_put(off++, (lval >> 40) & 0xFF); | |
| 4052 dbuf->byte_at_put(off++, (lval >> 32) & 0xFF); | |
| 4053 dbuf->byte_at_put(off++, (lval >> 24) & 0xFF); | |
| 4054 dbuf->byte_at_put(off++, (lval >> 16) & 0xFF); | |
| 4055 dbuf->byte_at_put(off++, (lval >> 8) & 0xFF); | |
| 4056 dbuf->byte_at_put(off++, (lval >> 0) & 0xFF); | |
| 4057 } | |
| 4058 break; | |
| 4059 | |
| 4060 default: | |
| 4061 // Illegal typecode | |
| 4062 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "illegal typecode"); | |
| 4063 } | |
| 4064 } | |
| 4065 JVM_END | |
| 4066 | |
| 4067 | |
| 4068 // Shared JNI/JVM entry points ////////////////////////////////////////////////////////////// | |
| 4069 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
4070 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, Handle loader, Handle protection_domain, jboolean throwError, TRAPS) { |
| 0 | 4071 // Security Note: |
| 4072 // The Java level wrapper will perform the necessary security check allowing | |
| 4073 // us to pass the NULL as the initiating class loader. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
4074 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL); |
|
878
abe076e3636f
6864003: Modify JVM_FindClassFromBootLoader to return null if class not found
mchung
parents:
875
diff
changeset
|
4075 |
| 0 | 4076 KlassHandle klass_handle(THREAD, klass); |
| 4077 // Check if we should initialize the class | |
| 4078 if (init && klass_handle->oop_is_instance()) { | |
| 4079 klass_handle->initialize(CHECK_NULL); | |
| 4080 } | |
| 4081 return (jclass) JNIHandles::make_local(env, klass_handle->java_mirror()); | |
| 4082 } | |
| 4083 | |
| 4084 | |
| 4085 // Internal SQE debugging support /////////////////////////////////////////////////////////// | |
| 4086 | |
| 4087 #ifndef PRODUCT | |
| 4088 | |
| 4089 extern "C" { | |
| 4090 JNIEXPORT jboolean JNICALL JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get); | |
| 4091 JNIEXPORT jboolean JNICALL JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get); | |
| 4092 JNIEXPORT void JNICALL JVM_VMBreakPoint(JNIEnv *env, jobject obj); | |
| 4093 } | |
| 4094 | |
| 4095 JVM_LEAF(jboolean, JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)) | |
| 4096 JVMWrapper("JVM_AccessBoolVMFlag"); | |
| 4097 return is_get ? CommandLineFlags::boolAt((char*) name, (bool*) value) : CommandLineFlags::boolAtPut((char*) name, (bool*) value, INTERNAL); | |
| 4098 JVM_END | |
| 4099 | |
| 4100 JVM_LEAF(jboolean, JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)) | |
| 4101 JVMWrapper("JVM_AccessVMIntFlag"); | |
| 4102 intx v; | |
| 4103 jboolean result = is_get ? CommandLineFlags::intxAt((char*) name, &v) : CommandLineFlags::intxAtPut((char*) name, &v, INTERNAL); | |
| 4104 *value = (jint)v; | |
| 4105 return result; | |
| 4106 JVM_END | |
| 4107 | |
| 4108 | |
| 4109 JVM_ENTRY(void, JVM_VMBreakPoint(JNIEnv *env, jobject obj)) | |
| 4110 JVMWrapper("JVM_VMBreakPoint"); | |
| 4111 oop the_obj = JNIHandles::resolve(obj); | |
| 4112 BREAKPOINT; | |
| 4113 JVM_END | |
| 4114 | |
| 4115 | |
| 4116 #endif | |
| 4117 | |
| 4118 | |
| 4119 // Method /////////////////////////////////////////////////////////////////////////////////////////// | |
| 4120 | |
| 4121 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)) | |
| 4122 JVMWrapper("JVM_InvokeMethod"); | |
| 4123 Handle method_handle; | |
| 4124 if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) { | |
| 4125 method_handle = Handle(THREAD, JNIHandles::resolve(method)); | |
| 4126 Handle receiver(THREAD, JNIHandles::resolve(obj)); | |
| 4127 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0))); | |
| 4128 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL); | |
| 4129 jobject res = JNIHandles::make_local(env, result); | |
| 4130 if (JvmtiExport::should_post_vm_object_alloc()) { | |
| 4131 oop ret_type = java_lang_reflect_Method::return_type(method_handle()); | |
| 4132 assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!"); | |
| 4133 if (java_lang_Class::is_primitive(ret_type)) { | |
| 4134 // Only for primitive type vm allocates memory for java object. | |
| 4135 // See box() method. | |
| 4136 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result); | |
| 4137 } | |
| 4138 } | |
| 4139 return res; | |
| 4140 } else { | |
| 4141 THROW_0(vmSymbols::java_lang_StackOverflowError()); | |
| 4142 } | |
| 4143 JVM_END | |
| 4144 | |
| 4145 | |
| 4146 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0)) | |
| 4147 JVMWrapper("JVM_NewInstanceFromConstructor"); | |
| 4148 oop constructor_mirror = JNIHandles::resolve(c); | |
| 4149 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0))); | |
| 4150 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL); | |
| 4151 jobject res = JNIHandles::make_local(env, result); | |
| 4152 if (JvmtiExport::should_post_vm_object_alloc()) { | |
| 4153 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result); | |
| 4154 } | |
| 4155 return res; | |
| 4156 JVM_END | |
| 4157 | |
| 4158 // Atomic /////////////////////////////////////////////////////////////////////////////////////////// | |
| 4159 | |
| 4160 JVM_LEAF(jboolean, JVM_SupportsCX8()) | |
| 4161 JVMWrapper("JVM_SupportsCX8"); | |
| 4162 return VM_Version::supports_cx8(); | |
| 4163 JVM_END | |
| 4164 | |
| 4165 | |
| 4166 JVM_ENTRY(jboolean, JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)) | |
| 4167 JVMWrapper("JVM_CX8Field"); | |
| 4168 jlong res; | |
| 4169 oop o = JNIHandles::resolve(obj); | |
| 4170 intptr_t fldOffs = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid); | |
| 4171 volatile jlong* addr = (volatile jlong*)((address)o + fldOffs); | |
| 4172 | |
| 4173 assert(VM_Version::supports_cx8(), "cx8 not supported"); | |
| 4174 res = Atomic::cmpxchg(newVal, addr, oldVal); | |
| 4175 | |
| 4176 return res == oldVal; | |
| 4177 JVM_END | |
| 4178 | |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4179 // DTrace /////////////////////////////////////////////////////////////////// |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4180 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4181 JVM_ENTRY(jint, JVM_DTraceGetVersion(JNIEnv* env)) |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4182 JVMWrapper("JVM_DTraceGetVersion"); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4183 return (jint)JVM_TRACING_DTRACE_VERSION; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4184 JVM_END |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4185 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4186 JVM_ENTRY(jlong,JVM_DTraceActivate( |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4187 JNIEnv* env, jint version, jstring module_name, jint providers_count, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4188 JVM_DTraceProvider* providers)) |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4189 JVMWrapper("JVM_DTraceActivate"); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4190 return DTraceJSDT::activate( |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4191 version, module_name, providers_count, providers, CHECK_0); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4192 JVM_END |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4193 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4194 JVM_ENTRY(jboolean,JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method)) |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4195 JVMWrapper("JVM_DTraceIsProbeEnabled"); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4196 return DTraceJSDT::is_probe_enabled(method); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4197 JVM_END |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4198 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4199 JVM_ENTRY(void,JVM_DTraceDispose(JNIEnv* env, jlong handle)) |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4200 JVMWrapper("JVM_DTraceDispose"); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4201 DTraceJSDT::dispose(handle); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4202 JVM_END |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4203 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4204 JVM_ENTRY(jboolean,JVM_DTraceIsSupported(JNIEnv* env)) |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4205 JVMWrapper("JVM_DTraceIsSupported"); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4206 return DTraceJSDT::is_supported(); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4207 JVM_END |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
0
diff
changeset
|
4208 |
| 0 | 4209 // Returns an array of all live Thread objects (VM internal JavaThreads, |
| 4210 // jvmti agent threads, and JNI attaching threads are skipped) | |
| 4211 // See CR 6404306 regarding JNI attaching threads | |
| 4212 JVM_ENTRY(jobjectArray, JVM_GetAllThreads(JNIEnv *env, jclass dummy)) | |
| 4213 ResourceMark rm(THREAD); | |
| 4214 ThreadsListEnumerator tle(THREAD, false, false); | |
| 4215 JvmtiVMObjectAllocEventCollector oam; | |
| 4216 | |
| 4217 int num_threads = tle.num_threads(); | |
| 1142 | 4218 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Thread_klass(), num_threads, CHECK_NULL); |
| 0 | 4219 objArrayHandle threads_ah(THREAD, r); |
| 4220 | |
| 4221 for (int i = 0; i < num_threads; i++) { | |
| 4222 Handle h = tle.get_threadObj(i); | |
| 4223 threads_ah->obj_at_put(i, h()); | |
| 4224 } | |
| 4225 | |
| 4226 return (jobjectArray) JNIHandles::make_local(env, threads_ah()); | |
| 4227 JVM_END | |
| 4228 | |
| 4229 | |
| 4230 // Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods | |
| 4231 // Return StackTraceElement[][], each element is the stack trace of a thread in | |
| 4232 // the corresponding entry in the given threads array | |
| 4233 JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)) | |
| 4234 JVMWrapper("JVM_DumpThreads"); | |
| 4235 JvmtiVMObjectAllocEventCollector oam; | |
| 4236 | |
| 4237 // Check if threads is null | |
| 4238 if (threads == NULL) { | |
| 4239 THROW_(vmSymbols::java_lang_NullPointerException(), 0); | |
| 4240 } | |
| 4241 | |
| 4242 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(threads)); | |
| 4243 objArrayHandle ah(THREAD, a); | |
| 4244 int num_threads = ah->length(); | |
| 4245 // check if threads is non-empty array | |
| 4246 if (num_threads == 0) { | |
| 4247 THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0); | |
| 4248 } | |
| 4249 | |
| 4250 // check if threads is not an array of objects of Thread class | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
4251 Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass(); |
| 1142 | 4252 if (k != SystemDictionary::Thread_klass()) { |
| 0 | 4253 THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0); |
| 4254 } | |
| 4255 | |
| 4256 ResourceMark rm(THREAD); | |
| 4257 | |
| 4258 GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads); | |
| 4259 for (int i = 0; i < num_threads; i++) { | |
| 4260 oop thread_obj = ah->obj_at(i); | |
| 4261 instanceHandle h(THREAD, (instanceOop) thread_obj); | |
| 4262 thread_handle_array->append(h); | |
| 4263 } | |
| 4264 | |
| 4265 Handle stacktraces = ThreadService::dump_stack_traces(thread_handle_array, num_threads, CHECK_NULL); | |
| 4266 return (jobjectArray)JNIHandles::make_local(env, stacktraces()); | |
| 4267 | |
| 4268 JVM_END | |
| 4269 | |
| 4270 // JVM monitoring and management support | |
| 4271 JVM_ENTRY_NO_ENV(void*, JVM_GetManagement(jint version)) | |
| 4272 return Management::get_jmm_interface(version); | |
| 4273 JVM_END | |
| 4274 | |
| 4275 // com.sun.tools.attach.VirtualMachine agent properties support | |
| 4276 // | |
| 4277 // Initialize the agent properties with the properties maintained in the VM | |
| 4278 JVM_ENTRY(jobject, JVM_InitAgentProperties(JNIEnv *env, jobject properties)) | |
| 4279 JVMWrapper("JVM_InitAgentProperties"); | |
| 4280 ResourceMark rm; | |
| 4281 | |
| 4282 Handle props(THREAD, JNIHandles::resolve_non_null(properties)); | |
| 4283 | |
| 4284 PUTPROP(props, "sun.java.command", Arguments::java_command()); | |
| 4285 PUTPROP(props, "sun.jvm.flags", Arguments::jvm_flags()); | |
| 4286 PUTPROP(props, "sun.jvm.args", Arguments::jvm_args()); | |
| 4287 return properties; | |
| 4288 JVM_END | |
| 4289 | |
| 4290 JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)) | |
| 4291 { | |
| 4292 JVMWrapper("JVM_GetEnclosingMethodInfo"); | |
| 4293 JvmtiVMObjectAllocEventCollector oam; | |
| 4294 | |
| 4295 if (ofClass == NULL) { | |
| 4296 return NULL; | |
| 4297 } | |
| 4298 Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass)); | |
| 4299 // Special handling for primitive objects | |
| 4300 if (java_lang_Class::is_primitive(mirror())) { | |
| 4301 return NULL; | |
| 4302 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
4303 Klass* k = java_lang_Class::as_Klass(mirror()); |
| 6983 | 4304 if (!k->oop_is_instance()) { |
| 0 | 4305 return NULL; |
| 4306 } | |
| 4307 instanceKlassHandle ik_h(THREAD, k); | |
| 4308 int encl_method_class_idx = ik_h->enclosing_method_class_index(); | |
| 4309 if (encl_method_class_idx == 0) { | |
| 4310 return NULL; | |
| 4311 } | |
| 1142 | 4312 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL); |
| 0 | 4313 objArrayHandle dest(THREAD, dest_o); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
4314 Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL); |
| 6983 | 4315 dest->obj_at_put(0, enc_k->java_mirror()); |
| 0 | 4316 int encl_method_method_idx = ik_h->enclosing_method_method_index(); |
| 4317 if (encl_method_method_idx != 0) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
4318 Symbol* sym = ik_h->constants()->symbol_at( |
| 0 | 4319 extract_low_short_from_int( |
| 4320 ik_h->constants()->name_and_type_at(encl_method_method_idx))); | |
| 4321 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); | |
| 4322 dest->obj_at_put(1, str()); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2162
diff
changeset
|
4323 sym = ik_h->constants()->symbol_at( |
| 0 | 4324 extract_high_short_from_int( |
| 4325 ik_h->constants()->name_and_type_at(encl_method_method_idx))); | |
| 4326 str = java_lang_String::create_from_symbol(sym, CHECK_NULL); | |
| 4327 dest->obj_at_put(2, str()); | |
| 4328 } | |
| 4329 return (jobjectArray) JNIHandles::make_local(dest()); | |
| 4330 } | |
| 4331 JVM_END | |
| 4332 | |
| 4333 JVM_ENTRY(jintArray, JVM_GetThreadStateValues(JNIEnv* env, | |
| 4334 jint javaThreadState)) | |
| 4335 { | |
| 4336 // If new thread states are added in future JDK and VM versions, | |
| 4337 // this should check if the JDK version is compatible with thread | |
| 4338 // states supported by the VM. Return NULL if not compatible. | |
| 4339 // | |
| 4340 // This function must map the VM java_lang_Thread::ThreadStatus | |
| 4341 // to the Java thread state that the JDK supports. | |
| 4342 // | |
| 4343 | |
| 4344 typeArrayHandle values_h; | |
| 4345 switch (javaThreadState) { | |
| 4346 case JAVA_THREAD_STATE_NEW : { | |
| 4347 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); | |
| 4348 values_h = typeArrayHandle(THREAD, r); | |
| 4349 values_h->int_at_put(0, java_lang_Thread::NEW); | |
| 4350 break; | |
| 4351 } | |
| 4352 case JAVA_THREAD_STATE_RUNNABLE : { | |
| 4353 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); | |
| 4354 values_h = typeArrayHandle(THREAD, r); | |
| 4355 values_h->int_at_put(0, java_lang_Thread::RUNNABLE); | |
| 4356 break; | |
| 4357 } | |
| 4358 case JAVA_THREAD_STATE_BLOCKED : { | |
| 4359 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); | |
| 4360 values_h = typeArrayHandle(THREAD, r); | |
| 4361 values_h->int_at_put(0, java_lang_Thread::BLOCKED_ON_MONITOR_ENTER); | |
| 4362 break; | |
| 4363 } | |
| 4364 case JAVA_THREAD_STATE_WAITING : { | |
| 4365 typeArrayOop r = oopFactory::new_typeArray(T_INT, 2, CHECK_NULL); | |
| 4366 values_h = typeArrayHandle(THREAD, r); | |
| 4367 values_h->int_at_put(0, java_lang_Thread::IN_OBJECT_WAIT); | |
| 4368 values_h->int_at_put(1, java_lang_Thread::PARKED); | |
| 4369 break; | |
| 4370 } | |
| 4371 case JAVA_THREAD_STATE_TIMED_WAITING : { | |
| 4372 typeArrayOop r = oopFactory::new_typeArray(T_INT, 3, CHECK_NULL); | |
| 4373 values_h = typeArrayHandle(THREAD, r); | |
| 4374 values_h->int_at_put(0, java_lang_Thread::SLEEPING); | |
| 4375 values_h->int_at_put(1, java_lang_Thread::IN_OBJECT_WAIT_TIMED); | |
| 4376 values_h->int_at_put(2, java_lang_Thread::PARKED_TIMED); | |
| 4377 break; | |
| 4378 } | |
| 4379 case JAVA_THREAD_STATE_TERMINATED : { | |
| 4380 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); | |
| 4381 values_h = typeArrayHandle(THREAD, r); | |
| 4382 values_h->int_at_put(0, java_lang_Thread::TERMINATED); | |
| 4383 break; | |
| 4384 } | |
| 4385 default: | |
| 4386 // Unknown state - probably incompatible JDK version | |
| 4387 return NULL; | |
| 4388 } | |
| 4389 | |
| 4390 return (jintArray) JNIHandles::make_local(env, values_h()); | |
| 4391 } | |
| 4392 JVM_END | |
| 4393 | |
| 4394 | |
| 4395 JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env, | |
| 4396 jint javaThreadState, | |
| 4397 jintArray values)) | |
| 4398 { | |
| 4399 // If new thread states are added in future JDK and VM versions, | |
| 4400 // this should check if the JDK version is compatible with thread | |
| 4401 // states supported by the VM. Return NULL if not compatible. | |
| 4402 // | |
| 4403 // This function must map the VM java_lang_Thread::ThreadStatus | |
| 4404 // to the Java thread state that the JDK supports. | |
| 4405 // | |
| 4406 | |
| 4407 ResourceMark rm; | |
| 4408 | |
| 4409 // Check if threads is null | |
| 4410 if (values == NULL) { | |
| 4411 THROW_(vmSymbols::java_lang_NullPointerException(), 0); | |
| 4412 } | |
| 4413 | |
| 4414 typeArrayOop v = typeArrayOop(JNIHandles::resolve_non_null(values)); | |
| 4415 typeArrayHandle values_h(THREAD, v); | |
| 4416 | |
| 4417 objArrayHandle names_h; | |
| 4418 switch (javaThreadState) { | |
| 4419 case JAVA_THREAD_STATE_NEW : { | |
| 4420 assert(values_h->length() == 1 && | |
| 4421 values_h->int_at(0) == java_lang_Thread::NEW, | |
| 4422 "Invalid threadStatus value"); | |
| 4423 | |
| 1142 | 4424 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(), |
| 0 | 4425 1, /* only 1 substate */ |
| 4426 CHECK_NULL); | |
| 4427 names_h = objArrayHandle(THREAD, r); | |
| 4428 Handle name = java_lang_String::create_from_str("NEW", CHECK_NULL); | |
| 4429 names_h->obj_at_put(0, name()); | |
| 4430 break; | |
| 4431 } | |
| 4432 case JAVA_THREAD_STATE_RUNNABLE : { | |
| 4433 assert(values_h->length() == 1 && | |
| 4434 values_h->int_at(0) == java_lang_Thread::RUNNABLE, | |
| 4435 "Invalid threadStatus value"); | |
| 4436 | |
| 1142 | 4437 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(), |
| 0 | 4438 1, /* only 1 substate */ |
| 4439 CHECK_NULL); | |
| 4440 names_h = objArrayHandle(THREAD, r); | |
| 4441 Handle name = java_lang_String::create_from_str("RUNNABLE", CHECK_NULL); | |
| 4442 names_h->obj_at_put(0, name()); | |
| 4443 break; | |
| 4444 } | |
| 4445 case JAVA_THREAD_STATE_BLOCKED : { | |
| 4446 assert(values_h->length() == 1 && | |
| 4447 values_h->int_at(0) == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER, | |
| 4448 "Invalid threadStatus value"); | |
| 4449 | |
| 1142 | 4450 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(), |
| 0 | 4451 1, /* only 1 substate */ |
| 4452 CHECK_NULL); | |
| 4453 names_h = objArrayHandle(THREAD, r); | |
| 4454 Handle name = java_lang_String::create_from_str("BLOCKED", CHECK_NULL); | |
| 4455 names_h->obj_at_put(0, name()); | |
| 4456 break; | |
| 4457 } | |
| 4458 case JAVA_THREAD_STATE_WAITING : { | |
| 4459 assert(values_h->length() == 2 && | |
| 4460 values_h->int_at(0) == java_lang_Thread::IN_OBJECT_WAIT && | |
| 4461 values_h->int_at(1) == java_lang_Thread::PARKED, | |
| 4462 "Invalid threadStatus value"); | |
| 1142 | 4463 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(), |
| 0 | 4464 2, /* number of substates */ |
| 4465 CHECK_NULL); | |
| 4466 names_h = objArrayHandle(THREAD, r); | |
| 4467 Handle name0 = java_lang_String::create_from_str("WAITING.OBJECT_WAIT", | |
| 4468 CHECK_NULL); | |
| 4469 Handle name1 = java_lang_String::create_from_str("WAITING.PARKED", | |
| 4470 CHECK_NULL); | |
| 4471 names_h->obj_at_put(0, name0()); | |
| 4472 names_h->obj_at_put(1, name1()); | |
| 4473 break; | |
| 4474 } | |
| 4475 case JAVA_THREAD_STATE_TIMED_WAITING : { | |
| 4476 assert(values_h->length() == 3 && | |
| 4477 values_h->int_at(0) == java_lang_Thread::SLEEPING && | |
| 4478 values_h->int_at(1) == java_lang_Thread::IN_OBJECT_WAIT_TIMED && | |
| 4479 values_h->int_at(2) == java_lang_Thread::PARKED_TIMED, | |
| 4480 "Invalid threadStatus value"); | |
| 1142 | 4481 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(), |
| 0 | 4482 3, /* number of substates */ |
| 4483 CHECK_NULL); | |
| 4484 names_h = objArrayHandle(THREAD, r); | |
| 4485 Handle name0 = java_lang_String::create_from_str("TIMED_WAITING.SLEEPING", | |
| 4486 CHECK_NULL); | |
| 4487 Handle name1 = java_lang_String::create_from_str("TIMED_WAITING.OBJECT_WAIT", | |
| 4488 CHECK_NULL); | |
| 4489 Handle name2 = java_lang_String::create_from_str("TIMED_WAITING.PARKED", | |
| 4490 CHECK_NULL); | |
| 4491 names_h->obj_at_put(0, name0()); | |
| 4492 names_h->obj_at_put(1, name1()); | |
| 4493 names_h->obj_at_put(2, name2()); | |
| 4494 break; | |
| 4495 } | |
| 4496 case JAVA_THREAD_STATE_TERMINATED : { | |
| 4497 assert(values_h->length() == 1 && | |
| 4498 values_h->int_at(0) == java_lang_Thread::TERMINATED, | |
| 4499 "Invalid threadStatus value"); | |
| 1142 | 4500 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(), |
| 0 | 4501 1, /* only 1 substate */ |
| 4502 CHECK_NULL); | |
| 4503 names_h = objArrayHandle(THREAD, r); | |
| 4504 Handle name = java_lang_String::create_from_str("TERMINATED", CHECK_NULL); | |
| 4505 names_h->obj_at_put(0, name()); | |
| 4506 break; | |
| 4507 } | |
| 4508 default: | |
| 4509 // Unknown state - probably incompatible JDK version | |
| 4510 return NULL; | |
| 4511 } | |
| 4512 return (jobjectArray) JNIHandles::make_local(env, names_h()); | |
| 4513 } | |
| 4514 JVM_END | |
| 4515 | |
| 4516 JVM_ENTRY(void, JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)) | |
| 4517 { | |
| 4518 memset(info, 0, sizeof(info_size)); | |
| 4519 | |
| 4520 info->jvm_version = Abstract_VM_Version::jvm_version(); | |
| 4521 info->update_version = 0; /* 0 in HotSpot Express VM */ | |
| 4522 info->special_update_version = 0; /* 0 in HotSpot Express VM */ | |
| 4523 | |
| 4524 // when we add a new capability in the jvm_version_info struct, we should also | |
| 4525 // consider to expose this new capability in the sun.rt.jvmCapabilities jvmstat | |
| 4526 // counter defined in runtimeService.cpp. | |
| 4527 info->is_attachable = AttachListener::is_attach_supported(); | |
| 4528 #ifdef KERNEL | |
| 4529 info->is_kernel_jvm = 1; // true; | |
| 4530 #else // KERNEL | |
| 4531 info->is_kernel_jvm = 0; // false; | |
| 4532 #endif // KERNEL | |
| 4533 } | |
| 4534 JVM_END |