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