| /* |
| * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * - Neither the name of Oracle nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS |
| * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "jni.h" |
| #include "jvmti.h" |
| #include "jvmticmlr.h" |
| |
| #include "agent_util.h" |
| |
| /* Global static data */ |
| static char OUTPUT_FILE[] = "compiledMethodLoad.txt"; |
| static FILE *fp; |
| static jvmtiEnv *jvmti; |
| static jrawMonitorID lock; |
| |
| /* print a jvmtiCompiledMethodLoadDummyRecord */ |
| void |
| print_dummy_record(jvmtiCompiledMethodLoadDummyRecord* record, |
| jvmtiEnv* jvmti, FILE* fp) { |
| |
| if (record != NULL) { |
| fprintf(fp, "Dummy record detected containing message: %s\n", |
| (char *)record->message); |
| } |
| } |
| |
| /* print the specified stack frames */ |
| void |
| print_stack_frames(PCStackInfo* record, jvmtiEnv *jvmti, FILE* fp) { |
| if (record != NULL && record->methods != NULL) { |
| int i; |
| |
| for (i = 0; i < record->numstackframes; i++) { |
| jvmtiError err; |
| char* method_name = NULL; |
| char* class_name = NULL; |
| char* method_signature = NULL; |
| char* class_signature = NULL; |
| char* generic_ptr_method = NULL; |
| char* generic_ptr_class = NULL; |
| jmethodID id; |
| jclass declaringclassptr; |
| id = record->methods[i]; |
| |
| err = (*jvmti)->GetMethodDeclaringClass(jvmti, id, |
| &declaringclassptr); |
| check_jvmti_error(jvmti, err, "get method declaring class"); |
| |
| err = (*jvmti)->GetClassSignature(jvmti, declaringclassptr, |
| &class_signature, &generic_ptr_class); |
| check_jvmti_error(jvmti, err, "get class signature"); |
| |
| err = (*jvmti)->GetMethodName(jvmti, id, &method_name, |
| &method_signature, &generic_ptr_method); |
| check_jvmti_error(jvmti, err, "get method name"); |
| |
| fprintf(fp, "%s::%s %s %s @%d\n", class_signature, method_name, |
| method_signature, |
| generic_ptr_method == NULL ? "" : generic_ptr_method, |
| record->bcis[i]); |
| |
| if (method_name != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, (unsigned char*)method_name); |
| check_jvmti_error(jvmti, err, "deallocate method_name"); |
| } |
| if (method_signature != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, |
| (unsigned char*)method_signature); |
| check_jvmti_error(jvmti, err, "deallocate method_signature"); |
| } |
| if (generic_ptr_method != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, |
| (unsigned char*)generic_ptr_method); |
| check_jvmti_error(jvmti, err, "deallocate generic_ptr_method"); |
| } |
| if (class_name != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, (unsigned char*)class_name); |
| check_jvmti_error(jvmti, err, "deallocate class_name"); |
| } |
| if (class_signature != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, |
| (unsigned char*)class_signature); |
| check_jvmti_error(jvmti, err, "deallocate class_signature"); |
| } |
| if (generic_ptr_class != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, |
| (unsigned char*)generic_ptr_class); |
| check_jvmti_error(jvmti, err, "deallocate generic_ptr_class"); |
| } |
| } |
| } |
| } |
| |
| /* print a jvmtiCompiledMethodLoadInlineRecord */ |
| void |
| print_inline_info_record(jvmtiCompiledMethodLoadInlineRecord* record, |
| jvmtiEnv *jvmti, FILE* fp) { |
| |
| if (record != NULL && record->pcinfo != NULL) { |
| int numpcs = record->numpcs; |
| int i; |
| |
| for (i = 0; i < numpcs; i++) { |
| PCStackInfo pcrecord = (record->pcinfo[i]); |
| fprintf(fp, "PcDescriptor(pc=0x%lx):\n", (jint)(pcrecord.pc)); |
| print_stack_frames(&pcrecord, jvmti, fp); |
| } |
| } |
| } |
| |
| /* decode kind of CompiledMethodLoadRecord and print */ |
| void |
| print_records(jvmtiCompiledMethodLoadRecordHeader* list, jvmtiEnv *jvmti, |
| FILE* fp) |
| { |
| jvmtiCompiledMethodLoadRecordHeader* curr = list; |
| fprintf(fp, "\nPrinting PC Descriptors\n\n"); |
| while (curr != NULL) { |
| switch (curr->kind) { |
| case JVMTI_CMLR_DUMMY: |
| print_dummy_record((jvmtiCompiledMethodLoadDummyRecord *)curr, |
| jvmti, fp); |
| break; |
| |
| case JVMTI_CMLR_INLINE_INFO: |
| print_inline_info_record( |
| (jvmtiCompiledMethodLoadInlineRecord *)curr, jvmti, fp); |
| break; |
| |
| default: |
| fprintf(fp, "Warning: unrecognized record: kind=%d\n", curr->kind); |
| break; |
| } |
| |
| curr = (jvmtiCompiledMethodLoadRecordHeader *)curr->next; |
| } |
| } |
| |
| /* Callback for JVMTI_EVENT_COMPILED_METHOD_LOAD */ |
| void JNICALL |
| compiled_method_load(jvmtiEnv *jvmti, jmethodID method, jint code_size, |
| const void* code_addr, jint map_length, const jvmtiAddrLocationMap* map, |
| const void* compile_info) |
| { |
| jvmtiError err; |
| char* name = NULL; |
| char* signature = NULL; |
| char* generic_ptr = NULL; |
| jvmtiCompiledMethodLoadRecordHeader* pcs; |
| |
| err = (*jvmti)->RawMonitorEnter(jvmti, lock); |
| check_jvmti_error(jvmti, err, "raw monitor enter"); |
| |
| err = (*jvmti)->GetMethodName(jvmti, method, &name, &signature, |
| &generic_ptr); |
| check_jvmti_error(jvmti, err, "get method name"); |
| |
| fprintf(fp, "\nCompiled method load event\n"); |
| fprintf(fp, "Method name %s %s %s\n\n", name, signature, |
| generic_ptr == NULL ? "" : generic_ptr); |
| pcs = (jvmtiCompiledMethodLoadRecordHeader *)compile_info; |
| if (pcs != NULL) { |
| print_records(pcs, jvmti, fp); |
| } |
| |
| if (name != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, (unsigned char*)name); |
| check_jvmti_error(jvmti, err, "deallocate name"); |
| } |
| if (signature != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, (unsigned char*)signature); |
| check_jvmti_error(jvmti, err, "deallocate signature"); |
| } |
| if (generic_ptr != NULL) { |
| err = (*jvmti)->Deallocate(jvmti, (unsigned char*)generic_ptr); |
| check_jvmti_error(jvmti, err, "deallocate generic_ptr"); |
| } |
| |
| err = (*jvmti)->RawMonitorExit(jvmti, lock); |
| check_jvmti_error(jvmti, err, "raw monitor exit"); |
| } |
| |
| /* Agent_OnLoad() is called first, we prepare for a COMPILED_METHOD_LOAD |
| * event here. |
| */ |
| JNIEXPORT jint JNICALL |
| Agent_OnLoad(JavaVM *vm, char *options, void *reserved) |
| { |
| jint rc; |
| jvmtiError err; |
| jvmtiCapabilities capabilities; |
| jvmtiEventCallbacks callbacks; |
| |
| fp = fopen(OUTPUT_FILE, "w"); |
| if (fp == NULL) { |
| fatal_error("ERROR: %s: Unable to create output file\n", OUTPUT_FILE); |
| return -1; |
| } |
| |
| /* Get JVMTI environment */ |
| rc = (*vm)->GetEnv(vm, (void **)&jvmti, JVMTI_VERSION); |
| if (rc != JNI_OK) { |
| fatal_error( |
| "ERROR: Unable to create jvmtiEnv, GetEnv failed, error=%d\n", rc); |
| return -1; |
| } |
| |
| /* add JVMTI capabilities */ |
| memset(&capabilities,0, sizeof(capabilities)); |
| capabilities.can_generate_compiled_method_load_events = 1; |
| err = (*jvmti)->AddCapabilities(jvmti, &capabilities); |
| check_jvmti_error(jvmti, err, "add capabilities"); |
| |
| /* set JVMTI callbacks for events */ |
| memset(&callbacks, 0, sizeof(callbacks)); |
| callbacks.CompiledMethodLoad = &compiled_method_load; |
| err = (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(callbacks)); |
| check_jvmti_error(jvmti, err, "set event callbacks"); |
| |
| /* enable JVMTI events */ |
| err = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, |
| JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL); |
| check_jvmti_error(jvmti, err, "set event notify"); |
| |
| /* create coordination monitor */ |
| err = (*jvmti)->CreateRawMonitor(jvmti, "agent lock", &lock); |
| check_jvmti_error(jvmti, err, "create raw monitor"); |
| |
| return 0; |
| } |
| |
| /* Agent_OnUnload() is called last */ |
| JNIEXPORT void JNICALL |
| Agent_OnUnload(JavaVM *vm) |
| { |
| } |
