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