2716 
2717 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) {
2718   assert(_isPrivileged_offset != 0, "offsets should have been initialized");
2719   // Ensure klass is initialized
2720   InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0);
2721   // Allocate result
2722   oop result = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0);
2723   // Fill in values
2724   result->obj_field_put(_context_offset, context());
2725   result->obj_field_put(_privilegedContext_offset, privileged_context());
2726   result->bool_field_put(_isPrivileged_offset, isPrivileged);
2727   return result;
2728 }
2729 
2730 
2731 // Support for java_lang_ClassLoader
2732 
2733 bool java_lang_ClassLoader::offsets_computed = false;
2734 int  java_lang_ClassLoader::_loader_data_offset = -1;
2735 int  java_lang_ClassLoader::parallelCapable_offset = -1;

2736 
2737 ClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) {
2738     assert(loader != NULL && loader->is_oop(), "loader must be oop");
2739     return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset);
2740 }
2741 
2742 ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) {
2743   return *java_lang_ClassLoader::loader_data_addr(loader);
2744 }
2745 
2746 void java_lang_ClassLoader::compute_offsets() {
2747   assert(!offsets_computed, "offsets should be initialized only once");
2748   offsets_computed = true;
2749 
2750   // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
2751   Klass* k1 = SystemDictionary::ClassLoader_klass();
2752   compute_optional_offset(parallelCapable_offset,
2753     k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
2754 




2755   CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2756 }
2757 
2758 oop java_lang_ClassLoader::parent(oop loader) {
2759   assert(is_instance(loader), "loader must be oop");
2760   return loader->obj_field(parent_offset);
2761 }
2762 
2763 bool java_lang_ClassLoader::isAncestor(oop loader, oop cl) {
2764   assert(is_instance(loader), "loader must be oop");
2765   assert(cl == NULL || is_instance(cl), "cl argument must be oop");
2766   oop acl = loader;
2767   debug_only(jint loop_count = 0);
2768   // This loop taken verbatim from ClassLoader.java:
2769   do {
2770     acl = parent(acl);
2771     if (cl == acl) {
2772       return true;
2773     }
2774     assert(++loop_count > 0, "loop_count overflow");
2775   } while (acl != NULL);
2776   return false;
2777 }
2778 
2779 
2780 // For class loader classes, parallelCapable defined
2781 // based on non-null field
2782 // Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it
2783 bool java_lang_ClassLoader::parallelCapable(oop class_loader) {
2784   if (!JDK_Version::is_gte_jdk17x_version()
2785      || parallelCapable_offset == -1) {
2786      // Default for backward compatibility is false
2787      return false;
2788   }
2789   return (class_loader->obj_field(parallelCapable_offset) != NULL);











2790 }
2791 
2792 bool java_lang_ClassLoader::is_trusted_loader(oop loader) {
2793   // Fix for 4474172; see evaluation for more details
2794   loader = non_reflection_class_loader(loader);
2795 
2796   oop cl = SystemDictionary::java_system_loader();
2797   while(cl != NULL) {
2798     if (cl == loader) return true;
2799     cl = parent(cl);
2800   }
2801   return false;
2802 }
2803 
2804 oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) {
2805   if (loader != NULL) {
2806     // See whether this is one of the class loaders associated with
2807     // the generated bytecodes for reflection, and if so, "magically"
2808     // delegate to its parent to prevent class loading from occurring
2809     // in places where applications using reflection didn't expect it.

2716 
2717 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) {
2718   assert(_isPrivileged_offset != 0, "offsets should have been initialized");
2719   // Ensure klass is initialized
2720   InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0);
2721   // Allocate result
2722   oop result = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0);
2723   // Fill in values
2724   result->obj_field_put(_context_offset, context());
2725   result->obj_field_put(_privilegedContext_offset, privileged_context());
2726   result->bool_field_put(_isPrivileged_offset, isPrivileged);
2727   return result;
2728 }
2729 
2730 
2731 // Support for java_lang_ClassLoader
2732 
2733 bool java_lang_ClassLoader::offsets_computed = false;
2734 int  java_lang_ClassLoader::_loader_data_offset = -1;
2735 int  java_lang_ClassLoader::parallelCapable_offset = -1;
2736 int  java_lang_ClassLoader::fullyConcurrent_offset = -1;
2737 
2738 ClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) {
2739     assert(loader != NULL && loader->is_oop(), "loader must be oop");
2740     return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset);
2741 }
2742 
2743 ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) {
2744   return *java_lang_ClassLoader::loader_data_addr(loader);
2745 }
2746 
2747 void java_lang_ClassLoader::compute_offsets() {
2748   assert(!offsets_computed, "offsets should be initialized only once");
2749   offsets_computed = true;
2750 
2751   // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
2752   Klass* k1 = SystemDictionary::ClassLoader_klass();
2753   compute_optional_offset(parallelCapable_offset,
2754     k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
2755 
2756   // The field indicating fullyConcurrent is only present starting in 8
2757   compute_optional_offset(fullyConcurrent_offset,
2758     k1, vmSymbols::fullyConcurrent_name(), vmSymbols::bool_signature());
2759 
2760   CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2761 }
2762 
2763 oop java_lang_ClassLoader::parent(oop loader) {
2764   assert(is_instance(loader), "loader must be oop");
2765   return loader->obj_field(parent_offset);
2766 }
2767 
2768 bool java_lang_ClassLoader::isAncestor(oop loader, oop cl) {
2769   assert(is_instance(loader), "loader must be oop");
2770   assert(cl == NULL || is_instance(cl), "cl argument must be oop");
2771   oop acl = loader;
2772   debug_only(jint loop_count = 0);
2773   // This loop taken verbatim from ClassLoader.java:
2774   do {
2775     acl = parent(acl);
2776     if (cl == acl) {
2777       return true;
2778     }
2779     assert(++loop_count > 0, "loop_count overflow");
2780   } while (acl != NULL);
2781   return false;
2782 }
2783 
2784 
2785 // For class loader classes, parallelCapable defined
2786 // based on non-null field
2787 // Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it
2788 bool java_lang_ClassLoader::parallelCapable(oop class_loader) {
2789   if (!JDK_Version::is_gte_jdk17x_version()
2790      || parallelCapable_offset == -1) {
2791      // Default for backward compatibility is false
2792      return false;
2793   }
2794   return (class_loader->obj_field(parallelCapable_offset) != NULL);
2795 }
2796 
2797 // For class loader classes, fullConcurrent defined as boolean field
2798 // Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it
2799 bool java_lang_ClassLoader::fullyConcurrent(oop class_loader) {
2800   if (!JDK_Version::is_gte_jdk18x_version()
2801      || fullyConcurrent_offset == -1) {
2802      // Default for backward compatibility is false
2803      return false;
2804   }
2805   return (class_loader->bool_field(fullyConcurrent_offset) == 1);
2806 }
2807 
2808 bool java_lang_ClassLoader::is_trusted_loader(oop loader) {
2809   // Fix for 4474172; see evaluation for more details
2810   loader = non_reflection_class_loader(loader);
2811 
2812   oop cl = SystemDictionary::java_system_loader();
2813   while(cl != NULL) {
2814     if (cl == loader) return true;
2815     cl = parent(cl);
2816   }
2817   return false;
2818 }
2819 
2820 oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) {
2821   if (loader != NULL) {
2822     // See whether this is one of the class loaders associated with
2823     // the generated bytecodes for reflection, and if so, "magically"
2824     // delegate to its parent to prevent class loading from occurring
2825     // in places where applications using reflection didn't expect it.