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