| //===-- ProfileObjectiveC.cpp -----------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Created by Greg Clayton on 10/4/07. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "ProfileObjectiveC.h" |
| #include "DNB.h" |
| #include <objc/objc-runtime.h> |
| #include <map> |
| |
| #if defined (__powerpc__) || defined (__ppc__) |
| #define OBJC_MSG_SEND_PPC32_COMM_PAGE_ADDR ((nub_addr_t)0xfffeff00) |
| #endif |
| |
| //---------------------------------------------------------------------- |
| // Constructor |
| //---------------------------------------------------------------------- |
| ProfileObjectiveC::ProfileObjectiveC() : |
| m_pid(INVALID_NUB_PROCESS), |
| m_objcStats(), |
| m_hit_count(0), |
| m_dump_count(0xffff) |
| { |
| memset(&m_begin_time, 0, sizeof(m_begin_time)); |
| } |
| |
| //---------------------------------------------------------------------- |
| // Destructor |
| //---------------------------------------------------------------------- |
| ProfileObjectiveC::~ProfileObjectiveC() |
| { |
| } |
| |
| //---------------------------------------------------------------------- |
| // Clear any counts that we may have had |
| //---------------------------------------------------------------------- |
| void |
| ProfileObjectiveC::Clear() |
| { |
| if (m_pid != INVALID_NUB_PROCESS) |
| { |
| DNBBreakpointClear(m_pid, m_objc_msgSend.breakID); |
| DNBBreakpointClear(m_pid, m_objc_msgSendSuper.breakID); |
| #if defined (__powerpc__) || defined (__ppc__) |
| DNBBreakpointClear(m_pid, m_objc_msgSend_rtp.breakID); |
| #endif |
| } |
| m_objc_msgSend.Clear(); |
| m_objc_msgSendSuper.Clear(); |
| #if defined (__powerpc__) || defined (__ppc__) |
| memset(m_objc_msgSend_opcode, 0, k_opcode_size); |
| m_objc_msgSend_rtp.Clear(); |
| #endif |
| memset(&m_begin_time, 0, sizeof(m_begin_time)); |
| m_objcStats.clear(); |
| } |
| |
| void |
| ProfileObjectiveC::Initialize(nub_process_t pid) |
| { |
| Clear(); |
| m_pid = pid; |
| } |
| |
| |
| void |
| ProfileObjectiveC::ProcessStateChanged(nub_state_t state) |
| { |
| //printf("ProfileObjectiveC::%s(%s)\n", __FUNCTION__, DNBStateAsString(state)); |
| switch (state) |
| { |
| case eStateInvalid: |
| case eStateUnloaded: |
| case eStateExited: |
| case eStateDetached: |
| Clear(); |
| break; |
| |
| case eStateStopped: |
| #if defined (__powerpc__) || defined (__ppc__) |
| if (NUB_BREAK_ID_IS_VALID(m_objc_msgSend.breakID) && !NUB_BREAK_ID_IS_VALID(m_objc_msgSend_rtp.breakID)) |
| { |
| nub_thread_t tid = DNBProcessGetCurrentThread(m_pid); |
| DNBRegisterValue pc_value; |
| if (DNBThreadGetRegisterValueByName(m_pid, tid, REGISTER_SET_ALL, "srr0" , &pc_value)) |
| { |
| nub_addr_t pc = pc_value.value.uint32; |
| if (pc == OBJC_MSG_SEND_PPC32_COMM_PAGE_ADDR) |
| { |
| // Restore previous first instruction to 0xfffeff00 in comm page |
| DNBProcessMemoryWrite(m_pid, OBJC_MSG_SEND_PPC32_COMM_PAGE_ADDR, k_opcode_size, m_objc_msgSend_opcode); |
| //printf("Setting breakpoint on _objc_msgSend_rtp...\n"); |
| m_objc_msgSend_rtp.breakID = DNBBreakpointSet(m_pid, OBJC_MSG_SEND_PPC32_COMM_PAGE_ADDR); |
| if (NUB_BREAK_ID_IS_VALID(m_objc_msgSend_rtp.breakID)) |
| { |
| DNBBreakpointSetCallback(m_pid, m_objc_msgSend_rtp.breakID, ProfileObjectiveC::MessageSendBreakpointCallback, this); |
| } |
| } |
| } |
| } |
| #endif |
| DumpStats(m_pid, stdout); |
| break; |
| |
| case eStateAttaching: |
| case eStateLaunching: |
| case eStateRunning: |
| case eStateStepping: |
| case eStateCrashed: |
| case eStateSuspended: |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| void |
| ProfileObjectiveC::SharedLibraryStateChanged(DNBExecutableImageInfo *image_infos, nub_size_t num_image_infos) |
| { |
| //printf("ProfileObjectiveC::%s(%p, %u)\n", __FUNCTION__, image_infos, num_image_infos); |
| if (m_objc_msgSend.IsValid() && m_objc_msgSendSuper.IsValid()) |
| return; |
| |
| if (image_infos) |
| { |
| nub_process_t pid = m_pid; |
| nub_size_t i; |
| for (i = 0; i < num_image_infos; i++) |
| { |
| if (strcmp(image_infos[i].name, "/usr/lib/libobjc.A.dylib") == 0) |
| { |
| if (!NUB_BREAK_ID_IS_VALID(m_objc_msgSend.breakID)) |
| { |
| m_objc_msgSend.addr = DNBProcessLookupAddress(pid, "_objc_msgSend", image_infos[i].name); |
| |
| if (m_objc_msgSend.addr != INVALID_NUB_ADDRESS) |
| { |
| #if defined (__powerpc__) || defined (__ppc__) |
| if (DNBProcessMemoryRead(pid, m_objc_msgSend.addr, k_opcode_size, m_objc_msgSend_opcode) != k_opcode_size) |
| memset(m_objc_msgSend_opcode, 0, sizeof(m_objc_msgSend_opcode)); |
| #endif |
| m_objc_msgSend.breakID = DNBBreakpointSet(pid, m_objc_msgSend.addr, 4, false); |
| if (NUB_BREAK_ID_IS_VALID(m_objc_msgSend.breakID)) |
| DNBBreakpointSetCallback(pid, m_objc_msgSend.breakID, ProfileObjectiveC::MessageSendBreakpointCallback, this); |
| } |
| } |
| |
| if (!NUB_BREAK_ID_IS_VALID(m_objc_msgSendSuper.breakID)) |
| { |
| m_objc_msgSendSuper.addr = DNBProcessLookupAddress(pid, "_objc_msgSendSuper", image_infos[i].name); |
| |
| if (m_objc_msgSendSuper.addr != INVALID_NUB_ADDRESS) |
| { |
| m_objc_msgSendSuper.breakID = DNBBreakpointSet(pid, m_objc_msgSendSuper.addr, 4, false); |
| if (NUB_BREAK_ID_IS_VALID(m_objc_msgSendSuper.breakID)) |
| DNBBreakpointSetCallback(pid, m_objc_msgSendSuper.breakID, ProfileObjectiveC::MessageSendSuperBreakpointCallback, this); |
| } |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| void |
| ProfileObjectiveC::SetStartTime() |
| { |
| gettimeofday(&m_begin_time, NULL); |
| } |
| |
| void |
| ProfileObjectiveC::SelectorHit(objc_class_ptr_t isa, objc_selector_t sel) |
| { |
| m_objcStats[isa][sel]++; |
| } |
| |
| nub_bool_t |
| ProfileObjectiveC::MessageSendBreakpointCallback(nub_process_t pid, nub_thread_t tid, nub_break_t breakID, void *userData) |
| { |
| ProfileObjectiveC *profile_objc = (ProfileObjectiveC*)userData; |
| uint32_t hit_count = profile_objc->IncrementHitCount(); |
| if (hit_count == 1) |
| profile_objc->SetStartTime(); |
| |
| objc_class_ptr_t objc_self = 0; |
| objc_selector_t objc_selector = 0; |
| #if defined (__i386__) |
| DNBRegisterValue esp; |
| if (DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "esp", &esp)) |
| { |
| uint32_t uval32[2]; |
| if (DNBProcessMemoryRead(pid, esp.value.uint32 + 4, 8, &uval32) == 8) |
| { |
| objc_self = uval32[0]; |
| objc_selector = uval32[1]; |
| } |
| } |
| #elif defined (__powerpc__) || defined (__ppc__) |
| DNBRegisterValue r3; |
| DNBRegisterValue r4; |
| if (DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r3", &r3) && |
| DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r4", &r4)) |
| { |
| objc_self = r3.value.uint32; |
| objc_selector = r4.value.uint32; |
| } |
| #elif defined (__arm__) |
| DNBRegisterValue r0; |
| DNBRegisterValue r1; |
| if (DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r0", &r0) && |
| DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r1", &r1)) |
| { |
| objc_self = r0.value.uint32; |
| objc_selector = r1.value.uint32; |
| } |
| #else |
| #error undefined architecture |
| #endif |
| if (objc_selector != 0) |
| { |
| uint32_t isa = 0; |
| if (objc_self == 0) |
| { |
| profile_objc->SelectorHit(0, objc_selector); |
| } |
| else |
| if (DNBProcessMemoryRead(pid, (nub_addr_t)objc_self, sizeof(isa), &isa) == sizeof(isa)) |
| { |
| if (isa) |
| { |
| profile_objc->SelectorHit(isa, objc_selector); |
| } |
| else |
| { |
| profile_objc->SelectorHit(0, objc_selector); |
| } |
| } |
| } |
| |
| |
| // Dump stats if we are supposed to |
| if (profile_objc->ShouldDumpStats()) |
| { |
| profile_objc->DumpStats(pid, stdout); |
| return true; |
| } |
| |
| // Just let the target run again by returning false; |
| return false; |
| } |
| |
| nub_bool_t |
| ProfileObjectiveC::MessageSendSuperBreakpointCallback(nub_process_t pid, nub_thread_t tid, nub_break_t breakID, void *userData) |
| { |
| ProfileObjectiveC *profile_objc = (ProfileObjectiveC*)userData; |
| |
| uint32_t hit_count = profile_objc->IncrementHitCount(); |
| if (hit_count == 1) |
| profile_objc->SetStartTime(); |
| |
| // printf("BreakID %u hit count is = %u\n", breakID, hc); |
| objc_class_ptr_t objc_super = 0; |
| objc_selector_t objc_selector = 0; |
| #if defined (__i386__) |
| DNBRegisterValue esp; |
| if (DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "esp", &esp)) |
| { |
| uint32_t uval32[2]; |
| if (DNBProcessMemoryRead(pid, esp.value.uint32 + 4, 8, &uval32) == 8) |
| { |
| objc_super = uval32[0]; |
| objc_selector = uval32[1]; |
| } |
| } |
| #elif defined (__powerpc__) || defined (__ppc__) |
| DNBRegisterValue r3; |
| DNBRegisterValue r4; |
| if (DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r3", &r3) && |
| DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r4", &r4)) |
| { |
| objc_super = r3.value.uint32; |
| objc_selector = r4.value.uint32; |
| } |
| #elif defined (__arm__) |
| DNBRegisterValue r0; |
| DNBRegisterValue r1; |
| if (DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r0", &r0) && |
| DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, "r1", &r1)) |
| { |
| objc_super = r0.value.uint32; |
| objc_selector = r1.value.uint32; |
| } |
| #else |
| #error undefined architecture |
| #endif |
| if (objc_selector != 0) |
| { |
| uint32_t isa = 0; |
| if (objc_super == 0) |
| { |
| profile_objc->SelectorHit(0, objc_selector); |
| } |
| else |
| if (DNBProcessMemoryRead(pid, (nub_addr_t)objc_super + 4, sizeof(isa), &isa) == sizeof(isa)) |
| { |
| if (isa) |
| { |
| profile_objc->SelectorHit(isa, objc_selector); |
| } |
| else |
| { |
| profile_objc->SelectorHit(0, objc_selector); |
| } |
| } |
| } |
| |
| // Dump stats if we are supposed to |
| if (profile_objc->ShouldDumpStats()) |
| { |
| profile_objc->DumpStats(pid, stdout); |
| return true; |
| } |
| |
| // Just let the target run again by returning false; |
| return false; |
| } |
| |
| void |
| ProfileObjectiveC::DumpStats(nub_process_t pid, FILE *f) |
| { |
| if (f == NULL) |
| return; |
| |
| if (m_hit_count == 0) |
| return; |
| |
| ClassStatsMap::iterator class_pos; |
| ClassStatsMap::iterator class_end = m_objcStats.end(); |
| |
| struct timeval end_time; |
| gettimeofday(&end_time, NULL); |
| int64_t elapsed_usec = ((int64_t)(1000*1000))*((int64_t)end_time.tv_sec - (int64_t)m_begin_time.tv_sec) + ((int64_t)end_time.tv_usec - (int64_t)m_begin_time.tv_usec); |
| fprintf(f, "%u probe hits for %.2f hits/sec)\n", m_hit_count, (double)m_hit_count / (((double)elapsed_usec)/(1000000.0))); |
| |
| for (class_pos = m_objcStats.begin(); class_pos != class_end; ++class_pos) |
| { |
| SelectorHitCount::iterator sel_pos; |
| SelectorHitCount::iterator sel_end = class_pos->second.end(); |
| for (sel_pos = class_pos->second.begin(); sel_pos != sel_end; ++sel_pos) |
| { |
| struct objc_class objc_class; |
| uint32_t isa = class_pos->first; |
| uint32_t sel = sel_pos->first; |
| uint32_t sel_hit_count = sel_pos->second; |
| |
| if (isa != 0 && DNBProcessMemoryRead(pid, isa, sizeof(objc_class), &objc_class) == sizeof(objc_class)) |
| { |
| /* fprintf(f, "%#.8x\n isa = %p\n super_class = %p\n name = %p\n version = %lx\n info = %lx\ninstance_size = %lx\n ivars = %p\n methodLists = %p\n cache = %p\n protocols = %p\n", |
| arg1.value.pointer, |
| objc_class.isa, |
| objc_class.super_class, |
| objc_class.name, |
| objc_class.version, |
| objc_class.info, |
| objc_class.instance_size, |
| objc_class.ivars, |
| objc_class.methodLists, |
| objc_class.cache, |
| objc_class.protocols); */ |
| |
| // Print the class name |
| fprintf(f, "%6u hits for %c[", sel_hit_count, (objc_class.super_class == objc_class.isa ? '+' : '-')); |
| DNBPrintf(pid, INVALID_NUB_THREAD, (nub_addr_t)objc_class.name, f, "%s "); |
| } |
| else |
| { |
| fprintf(f, "%6u hits for [<nil> ", sel_hit_count); |
| } |
| DNBPrintf(pid, INVALID_NUB_THREAD, sel, f, "%s]\n"); |
| } |
| } |
| } |
| |
