Mercurial > hg > graal-jvmci-8

comparison src/share/vm/prims/jniCheck.cpp @ 6725:da91efe96a93

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author coleenp
date Sat, 01 Sep 2012 13:25:18 -0400
parents d2a62e0f25eb
children d8ce2825b193
comparison
equal deleted inserted replaced
6724:36d1d483d5d6 6725:da91efe96a93
1 /* 1 /*
2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 * 4 *
5 * This code is free software; you can redistribute it and/or modify it 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 6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
213 if (!jfieldIDWorkaround::is_static_jfieldID(fid)) 213 if (!jfieldIDWorkaround::is_static_jfieldID(fid))
214 ReportJNIFatalError(thr, fatal_should_be_static); 214 ReportJNIFatalError(thr, fatal_should_be_static);
215 215
216 /* validate the class being passed */ 216 /* validate the class being passed */
217 ASSERT_OOPS_ALLOWED; 217 ASSERT_OOPS_ALLOWED;
218 klassOop k_oop = jniCheck::validate_class(thr, cls, false); 218 Klass* k_oop = jniCheck::validate_class(thr, cls, false);
219 219
220 /* check for proper subclass hierarchy */ 220 /* check for proper subclass hierarchy */
221 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid); 221 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid);
222 klassOop f_oop = id->holder(); 222 Klass* f_oop = id->holder();
223 if (!instanceKlass::cast(k_oop)->is_subtype_of(f_oop)) 223 if (!InstanceKlass::cast(k_oop)->is_subtype_of(f_oop))
224 ReportJNIFatalError(thr, fatal_wrong_static_field); 224 ReportJNIFatalError(thr, fatal_wrong_static_field);
225 225
226 /* check for proper field type */ 226 /* check for proper field type */
227 if (!id->find_local_field(&fd)) 227 if (!id->find_local_field(&fd))
228 ReportJNIFatalError(thr, fatal_static_field_not_found); 228 ReportJNIFatalError(thr, fatal_static_field_not_found);
245 ASSERT_OOPS_ALLOWED; 245 ASSERT_OOPS_ALLOWED;
246 oop oopObj = jniCheck::validate_object(thr, obj); 246 oop oopObj = jniCheck::validate_object(thr, obj);
247 if (!oopObj) { 247 if (!oopObj) {
248 ReportJNIFatalError(thr, fatal_null_object); 248 ReportJNIFatalError(thr, fatal_null_object);
249 } 249 }
250 klassOop k_oop = oopObj->klass(); 250 Klass* k_oop = oopObj->klass();
251 251
252 if (!jfieldIDWorkaround::is_valid_jfieldID(k_oop, fid)) { 252 if (!jfieldIDWorkaround::is_valid_jfieldID(k_oop, fid)) {
253 ReportJNIFatalError(thr, fatal_wrong_field); 253 ReportJNIFatalError(thr, fatal_wrong_field);
254 } 254 }
255 255
256 /* make sure the field exists */ 256 /* make sure the field exists */
257 int offset = jfieldIDWorkaround::from_instance_jfieldID(k_oop, fid); 257 int offset = jfieldIDWorkaround::from_instance_jfieldID(k_oop, fid);
258 if (!instanceKlass::cast(k_oop)->contains_field_offset(offset)) 258 if (!InstanceKlass::cast(k_oop)->contains_field_offset(offset))
259 ReportJNIFatalError(thr, fatal_wrong_field); 259 ReportJNIFatalError(thr, fatal_wrong_field);
260 260
261 /* check for proper field type */ 261 /* check for proper field type */
262 if (!instanceKlass::cast(k_oop)->find_field_from_offset(offset, 262 if (!InstanceKlass::cast(k_oop)->find_field_from_offset(offset,
263 false, &fd)) 263 false, &fd))
264 ReportJNIFatalError(thr, fatal_instance_field_not_found); 264 ReportJNIFatalError(thr, fatal_instance_field_not_found);
265 265
266 if ((fd.field_type() != ftype) && 266 if ((fd.field_type() != ftype) &&
267 !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) { 267 !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {
314 ReportJNIFatalError(thr, fatal_bad_ref_to_jni); 314 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
315 return NULL; 315 return NULL;
316 } 316 }
317 317
318 318
319 methodOop jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) { 319 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
320 ASSERT_OOPS_ALLOWED; 320 ASSERT_OOPS_ALLOWED;
321 // do the fast jmethodID check first 321 // do the fast jmethodID check first
322 methodOop moop = JNIHandles::checked_resolve_jmethod_id(method_id); 322 Method* moop = Method::checked_resolve_jmethod_id(method_id);
323 if (moop == NULL) { 323 if (moop == NULL) {
324 ReportJNIFatalError(thr, fatal_wrong_class_or_method); 324 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
325 } 325 }
326 // jmethodIDs are supposed to be weak global handles, but that 326 // jmethodIDs are supposed to be weak handles in the class loader data,
327 // can be expensive so check it last 327 // but that can be expensive so check it last
328 else if (!JNIHandles::is_weak_global_handle((jobject) method_id)) { 328 else if (!Method::is_method_id(method_id)) {
329 ReportJNIFatalError(thr, fatal_non_weak_method); 329 ReportJNIFatalError(thr, fatal_non_weak_method);
330 } 330 }
331 return moop; 331 return moop;
332 } 332 }
333 333
358 jio_snprintf(msg, JVM_MAXPATHLEN, warn_bad_class_descriptor, name); 358 jio_snprintf(msg, JVM_MAXPATHLEN, warn_bad_class_descriptor, name);
359 ReportJNIWarning(thr, msg); 359 ReportJNIWarning(thr, msg);
360 } 360 }
361 } 361 }
362 362
363 klassOop jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_primitive) { 363 Klass* jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_primitive) {
364 ASSERT_OOPS_ALLOWED; 364 ASSERT_OOPS_ALLOWED;
365 oop mirror = jniCheck::validate_handle(thr, clazz); 365 oop mirror = jniCheck::validate_handle(thr, clazz);
366 if (!mirror) { 366 if (!mirror) {
367 ReportJNIFatalError(thr, fatal_received_null_class); 367 ReportJNIFatalError(thr, fatal_received_null_class);
368 } 368 }
369 369
370 if (mirror->klass() != SystemDictionary::Class_klass()) { 370 if (mirror->klass() != SystemDictionary::Class_klass()) {
371 ReportJNIFatalError(thr, fatal_class_not_a_class); 371 ReportJNIFatalError(thr, fatal_class_not_a_class);
372 } 372 }
373 373
374 klassOop k = java_lang_Class::as_klassOop(mirror); 374 Klass* k = java_lang_Class::as_Klass(mirror);
375 // Make allowances for primitive classes ... 375 // Make allowances for primitive classes ...
376 if (!(k != NULL || allow_primitive && java_lang_Class::is_primitive(mirror))) { 376 if (!(k != NULL || allow_primitive && java_lang_Class::is_primitive(mirror))) {
377 ReportJNIFatalError(thr, fatal_class_not_a_class); 377 ReportJNIFatalError(thr, fatal_class_not_a_class);
378 } 378 }
379 return k; 379 return k;
380 } 380 }
381 381
382 void jniCheck::validate_throwable_klass(JavaThread* thr, klassOop klass) { 382 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {
383 ASSERT_OOPS_ALLOWED; 383 ASSERT_OOPS_ALLOWED;
384 assert(klass != NULL, "klass argument must have a value"); 384 assert(klass != NULL, "klass argument must have a value");
385 385
386 if (!Klass::cast(klass)->oop_is_instance() || 386 if (!Klass::cast(klass)->oop_is_instance() ||
387 !instanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) { 387 !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
388 ReportJNIFatalError(thr, fatal_class_not_a_throwable_class); 388 ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
389 } 389 }
390 } 390 }
391 391
392 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) { 392 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {
538 checked_jni_ThrowNew(JNIEnv *env, 538 checked_jni_ThrowNew(JNIEnv *env,
539 jclass clazz, 539 jclass clazz,
540 const char *msg)) 540 const char *msg))
541 functionEnter(thr); 541 functionEnter(thr);
542 IN_VM( 542 IN_VM(
543 klassOop k = jniCheck::validate_class(thr, clazz, false); 543 Klass* k = jniCheck::validate_class(thr, clazz, false);
544 assert(k != NULL, "validate_class shouldn't return NULL klassOop"); 544 assert(k != NULL, "validate_class shouldn't return NULL Klass*");
545 jniCheck::validate_throwable_klass(thr, k); 545 jniCheck::validate_throwable_klass(thr, k);
546 ) 546 )
547 jint result = UNCHECKED()->ThrowNew(env, clazz, msg); 547 jint result = UNCHECKED()->ThrowNew(env, clazz, msg);
548 functionExit(env); 548 functionExit(env);
549 return result; 549 return result;