jvmticapabilities.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 503 行 · 第 1/2 页

    /* if this is during OnLoad more capabilities are available */
    /*  if (JvmtiEnv::get_phase() == JVMTI_PHASE_ONLOAD) { */
    either(result, &globals->capabilities.onload, result);
    either(result, &globals->capabilities.onload_solo_remaining, result);
    /*  } */
}

void update()
{
    CVMJvmtiGlobals *globals = &CVMglobals.jvmti;
    jvmtiCapabilities avail;

    jboolean interp_events;

    /* all capabilities */
    either(&globals->capabilities.always, &globals->capabilities.always_solo,
	   &avail);

    interp_events = 
	avail.can_generate_field_access_events ||
	avail.can_generate_field_modification_events ||
	avail.can_generate_single_step_events ||
	avail.can_generate_frame_pop_events ||
	avail.can_generate_method_entry_events ||
	avail.can_generate_method_exit_events;

    /*
     * If can_redefine_classes is enabled in the onload phase then we know that
     * the dependency information recorded by the compiler is complete.
     */
    /*
    if ((avail.can_redefine_classes || avail.can_retransform_classes) && 
        JvmtiEnv::get_phase() == JVMTI_PHASE_ONLOAD) {
        JvmtiExport::set_all_dependencies_are_recorded(true);
    }
    */
    CVMjvmtiSetCanGetSourceDebugExtension(avail.can_get_source_debug_extension);
    CVMjvmtiSetCanExamineOrDeoptAnywhere(
	avail.can_generate_breakpoint_events ||
	interp_events || 
	avail.can_redefine_classes ||
	avail.can_retransform_classes ||
	avail.can_access_local_variables ||
	avail.can_get_owned_monitor_info ||
	avail.can_get_current_contended_monitor ||
	avail.can_get_monitor_info ||
	avail.can_get_owned_monitor_stack_depth_info);
    CVMjvmtiSetCanMaintainOriginalMethodOrder(
        avail.can_maintain_original_method_order);
    CVMjvmtiSetCanPostInterpreterEvents(interp_events);
    CVMjvmtiSetCanHotswapOrPostBreakpoint(
        avail.can_generate_breakpoint_events ||
	avail.can_redefine_classes ||
	avail.can_retransform_classes);
    CVMjvmtiSetCanModifyAnyClass(
        avail.can_generate_breakpoint_events ||
	avail.can_retransform_classes ||
	/* NOTE: remove when there is support for redefine with class sharing */
	avail.can_retransform_any_class   ||
	avail.can_redefine_classes ||
	/* NOTE: remove when there is support for redefine with class sharing */
	avail.can_redefine_any_class ||
	avail.can_generate_all_class_hook_events);
    CVMjvmtiSetCanWalkAnySpace(avail.can_tag_objects); 
        /* NOTE: remove when IterateOverReachableObjects supports class
	   sharing */
    CVMjvmtiSetCanAccessLocalVariables(
        avail.can_access_local_variables  ||
	avail.can_redefine_classes ||
	avail.can_retransform_classes);
    CVMjvmtiSetCanPostExceptions(
        avail.can_generate_exception_events ||
        avail.can_generate_frame_pop_events ||
	avail.can_generate_method_exit_events);
    CVMjvmtiSetCanPostBreakpoint(avail.can_generate_breakpoint_events);
    CVMjvmtiSetCanPostFieldAccess(avail.can_generate_field_access_events);
    CVMjvmtiSetCanPostFieldModification(
        avail.can_generate_field_modification_events);
    CVMjvmtiSetCanPostMethodEntry(avail.can_generate_method_entry_events);
    CVMjvmtiSetCanPostMethodExit(avail.can_generate_method_exit_events ||
				 avail.can_generate_frame_pop_events);
    CVMjvmtiSetCanPopFrame(avail.can_pop_frame);
    CVMjvmtiSetCanForceEarlyReturn(avail.can_force_early_return);
    CVMjvmtiSetShouldCleanUpHeapObjects(avail.can_generate_breakpoint_events);
}

jvmtiError CVMjvmtiAddCapabilities(const jvmtiCapabilities *current,
				   const jvmtiCapabilities *prohibited,
				   const jvmtiCapabilities *desired,
				   jvmtiCapabilities *result)
{
    CVMJvmtiGlobals *globals = &CVMglobals.jvmti;

    /* check that the capabilities being added are potential capabilities */
    jvmtiCapabilities temp;
    CVMjvmtiGetPotentialCapabilities(current, prohibited, &temp);
    if (hasSome(exclude(desired, &temp, &temp))) {
	return JVMTI_ERROR_NOT_AVAILABLE;
    }

    /* add to the set of ever acquired capabilities */
    either(&globals->capabilities.acquired, desired,
	   &globals->capabilities.acquired);

    /* onload capabilities that got added are now permanent - so, also remove
       from onload */
    both(&globals->capabilities.onload, desired, &temp);
    either(&globals->capabilities.always, &temp, &globals->capabilities.always);
    exclude(&globals->capabilities.onload, &temp,
	    &globals->capabilities.onload);

    /* same for solo capabilities (transferred capabilities in the remaining
       sets handled as part of standard grab - below) */
    both(&globals->capabilities.onload_solo, desired, &temp);
    either(&globals->capabilities.always_solo, &temp,
	   &globals->capabilities.always_solo);
    exclude(&globals->capabilities.onload_solo, &temp,
	    &globals->capabilities.onload_solo);

    /* remove solo capabilities that are now taken */
    exclude(&globals->capabilities.always_solo_remaining, desired,
	    &globals->capabilities.always_solo_remaining);
    exclude(&globals->capabilities.onload_solo_remaining, desired,
	    &globals->capabilities.onload_solo_remaining);

    /* return the result */
    either(current, desired, result);

    update();

    return JVMTI_ERROR_NONE;
}


void CVMjvmtiRelinquishCapabilities(const jvmtiCapabilities *current,
				    const jvmtiCapabilities *unwanted, 
				    jvmtiCapabilities *result)
{
    CVMJvmtiGlobals *globals = &CVMglobals.jvmti;
    jvmtiCapabilities to_trash;
    jvmtiCapabilities temp;

    /* can't give up what you don't have */
    both(current, unwanted, &to_trash);

    /* restore solo capabilities but only those that belong */
    either(&globals->capabilities.always_solo_remaining,
	   both(&globals->capabilities.always_solo, &to_trash, &temp),
	   &globals->capabilities.always_solo_remaining);
    either(&globals->capabilities.onload_solo_remaining,
	   both(&globals->capabilities.onload_solo, &to_trash, &temp),
	   &globals->capabilities.onload_solo_remaining);

    update();

    /* return the result */
    exclude(current, unwanted, result);
}



#ifdef DEBUG

void print_cr(char *s)
{
    CVMdebugPrintf(("%s\n", s));
}

void  print_capabilities(const jvmtiCapabilities* cap) {
    print_cr("----- capabilities -----");
    if (cap->can_tag_objects)
	print_cr("can_tag_objects");
    if (cap->can_generate_field_modification_events)
	print_cr("can_generate_field_modification_events");
    if (cap->can_generate_field_access_events)
	print_cr("can_generate_field_access_events");
    if (cap->can_get_bytecodes)
	print_cr("can_get_bytecodes");
    if (cap->can_get_synthetic_attribute)
	print_cr("can_get_synthetic_attribute");
    if (cap->can_get_owned_monitor_info)
	print_cr("can_get_owned_monitor_info");
    if (cap->can_get_current_contended_monitor)
	print_cr("can_get_current_contended_monitor");
    if (cap->can_get_monitor_info)
	print_cr("can_get_monitor_info");
    if (cap->can_get_constant_pool)
	print_cr("can_get_constant_pool");
    if (cap->can_pop_frame)
	print_cr("can_pop_frame");
    if (cap->can_force_early_return)
	print_cr("can_force_early_return");
    if (cap->can_redefine_classes)
	print_cr("can_redefine_classes");
    if (cap->can_retransform_classes)
	print_cr("can_retransform_classes");
    if (cap->can_signal_thread)
	print_cr("can_signal_thread");
    if (cap->can_get_source_file_name)
	print_cr("can_get_source_file_name");
    if (cap->can_get_line_numbers)
	print_cr("can_get_line_numbers");
    if (cap->can_get_source_debug_extension)
	print_cr("can_get_source_debug_extension");
    if (cap->can_access_local_variables)
	print_cr("can_access_local_variables");
    if (cap->can_maintain_original_method_order)
	print_cr("can_maintain_original_method_order");
    if (cap->can_generate_single_step_events)
	print_cr("can_generate_single_step_events");
    if (cap->can_generate_exception_events)
	print_cr("can_generate_exception_events");
    if (cap->can_generate_frame_pop_events)
	print_cr("can_generate_frame_pop_events");
    if (cap->can_generate_breakpoint_events)   
	print_cr("can_generate_breakpoint_events");
    if (cap->can_suspend)
	print_cr("can_suspend");
    if (cap->can_redefine_any_class)
	print_cr("can_redefine_any_class");
    if (cap->can_retransform_any_class)
	print_cr("can_retransform_any_class");
    if (cap->can_get_current_thread_cpu_time)
	print_cr("can_get_current_thread_cpu_time");
    if (cap->can_get_thread_cpu_time)
	print_cr("can_get_thread_cpu_time");
    if (cap->can_generate_method_entry_events)
	print_cr("can_generate_method_entry_events");
    if (cap->can_generate_method_exit_events)
	print_cr("can_generate_method_exit_events");
    if (cap->can_generate_all_class_hook_events)
	print_cr("can_generate_all_class_hook_events");
    if (cap->can_generate_compiled_method_load_events)
	print_cr("can_generate_compiled_method_load_events");
    if (cap->can_generate_monitor_events)
	print_cr("can_generate_monitor_events");
    if (cap->can_generate_vm_object_alloc_events)
	print_cr("can_generate_vm_object_alloc_events");
    if (cap->can_generate_native_method_bind_events)
	print_cr("can_generate_native_method_bind_events");
    if (cap->can_generate_garbage_collection_events)
	print_cr("can_generate_garbage_collection_events");
    if (cap->can_generate_object_free_events)
	print_cr("can_generate_object_free_events");
}

#endif