* ssp.c: new
* ssp.txt: new * Makefile.in: build ssp.exe
This commit is contained in:
802
winsup/utils/ssp.c
Normal file
802
winsup/utils/ssp.c
Normal file
@@ -0,0 +1,802 @@
|
||||
/*
|
||||
* Copyright (c) 2000, Red Hat, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* A copy of the GNU General Public License can be found at
|
||||
* http://www.gnu.org/
|
||||
*
|
||||
* Written by DJ Delorie <dj@redhat.com>
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <fcntl.h>
|
||||
#include <time.h>
|
||||
#include <ctype.h>
|
||||
#include <windows.h>
|
||||
|
||||
#ifdef __GNUC__
|
||||
const char *help_text = "
|
||||
Usage: ssp [options] low_pc high_pc command...
|
||||
|
||||
The SSP is a `single-step profiler' - it uses the debug API to
|
||||
single-step your program, noting *everything* your program runs, not
|
||||
just random places hit by random timer interrupts. You must specify
|
||||
the range of EIP values to profile. For example, you could profile
|
||||
just a function, or just a line of code, or the whole thing.
|
||||
Use \"objdump -h\" to find the start of .text and the section following
|
||||
it; this is what you want.
|
||||
|
||||
There are many options to ssp. Since step-profiling makes your
|
||||
program run about 1,000 times slower than normal, it's best to
|
||||
understand all the options so that you can narrow down the parts
|
||||
of your program you need to single-step.
|
||||
|
||||
-v = verbose messages about debug events.
|
||||
|
||||
-d, -e = disable/enable single-stepping by default. Use
|
||||
OutputDebugString (\"ssp on\") to enable stepping, or \"ssp off\" to
|
||||
disable it. Thus, you can profile a single function call or block.
|
||||
|
||||
-t = trace every EIP value to a file TRACE.SSP. This gets big *fast*.
|
||||
Use \"addr2line -C -f -s -e foo.exe < trace.ssp > lines.ssp\" and then
|
||||
\"perl cvttrace\" to convert to symbolic traces.
|
||||
|
||||
-tc = trace every EIP value to the console. *Lots* slower.
|
||||
|
||||
-s = trace sub-threads too. Dangerous if you have race conditions.
|
||||
|
||||
-dll = enable dll profiling. A chart of relative DLL usage is
|
||||
produced after the run.
|
||||
|
||||
Examples:
|
||||
ssp 0x401000 0x403000 hello.exe
|
||||
ssp -v -d -dll 0x401000 0x440000 foo.exe
|
||||
|
||||
The output is a file \"gmon.out\" that can be read with gprof:
|
||||
gprof -b foo.exe
|
||||
|
||||
See ssp.txt in the cygwin sources for more information.
|
||||
";
|
||||
#else
|
||||
char *help_text = "Usage: get cygwin!\n";
|
||||
#endif
|
||||
|
||||
#define KERNEL_ADDR 0x77000000
|
||||
|
||||
#define TRACE_SSP 0
|
||||
|
||||
#define VERBOSE 1
|
||||
#define TIMES 1000
|
||||
|
||||
/* from winsup/gmon.h */
|
||||
struct gmonhdr {
|
||||
unsigned long lpc; /* base pc address of sample buffer */
|
||||
unsigned long hpc; /* max pc address of sampled buffer */
|
||||
int ncnt; /* size of sample buffer (plus this header) */
|
||||
int version; /* version number */
|
||||
int profrate; /* profiling clock rate */
|
||||
int spare[3]; /* reserved */
|
||||
};
|
||||
#define GMONVERSION 0x00051879
|
||||
#define HISTCOUNTER unsigned short
|
||||
|
||||
typedef struct {
|
||||
unsigned int base_address;
|
||||
int pcount;
|
||||
int scount;
|
||||
char *name;
|
||||
} DllInfo;
|
||||
|
||||
typedef struct {
|
||||
unsigned int address;
|
||||
unsigned char real_byte;
|
||||
} PendingBreakpoints;
|
||||
|
||||
int low_pc=0, high_pc=0;
|
||||
unsigned int last_pc=0, pc, last_sp=0, sp;
|
||||
int total_cycles, count;
|
||||
char *cmd_line;
|
||||
HANDLE hProcess;
|
||||
PROCESS_INFORMATION procinfo;
|
||||
STARTUPINFO startup;
|
||||
CONTEXT context;
|
||||
HISTCOUNTER *hits=0;
|
||||
struct gmonhdr hdr;
|
||||
int running = 1, profiling = 1;
|
||||
char dll_name[1024], *dll_ptr, *cp;
|
||||
int eip;
|
||||
unsigned opcode_count = 0;
|
||||
|
||||
int stepping_enabled = 1;
|
||||
int tracing_enabled = 0;
|
||||
int trace_console = 0;
|
||||
int trace_all_threads = 0;
|
||||
int dll_counts = 0;
|
||||
int verbose = 0;
|
||||
|
||||
#define MAXTHREADS 100
|
||||
int active_thread_ids[MAXTHREADS];
|
||||
HANDLE active_threads[MAXTHREADS];
|
||||
int thread_step_flags[MAXTHREADS];
|
||||
int thread_return_address[MAXTHREADS];
|
||||
int num_active_threads = 0;
|
||||
int suspended_count=0;
|
||||
|
||||
#define MAXDLLS 100
|
||||
DllInfo dll_info[MAXDLLS];
|
||||
int num_dlls=0;
|
||||
|
||||
#define MAXPENDS 100
|
||||
PendingBreakpoints pending_breakpoints[MAXPENDS];
|
||||
int num_breakpoints=0;
|
||||
|
||||
static void
|
||||
add_breakpoint (unsigned int address)
|
||||
{
|
||||
int i;
|
||||
DWORD rv;
|
||||
static char int3[] = { 0xcc };
|
||||
for (i=0; i<num_breakpoints; i++)
|
||||
{
|
||||
if (pending_breakpoints[i].address == address)
|
||||
return;
|
||||
if (pending_breakpoints[i].address == 0)
|
||||
break;
|
||||
}
|
||||
if (i == MAXPENDS)
|
||||
return;
|
||||
pending_breakpoints[i].address = address;
|
||||
ReadProcessMemory (hProcess,
|
||||
(void *)address,
|
||||
&(pending_breakpoints[i].real_byte),
|
||||
1, &rv);
|
||||
|
||||
WriteProcessMemory (hProcess,
|
||||
(void *)address,
|
||||
(LPVOID)int3, 1, &rv);
|
||||
if (i >= num_breakpoints)
|
||||
num_breakpoints = i+1;
|
||||
}
|
||||
|
||||
static int
|
||||
remove_breakpoint (unsigned int address)
|
||||
{
|
||||
int i;
|
||||
DWORD rv;
|
||||
for (i=0; i<num_breakpoints; i++)
|
||||
{
|
||||
if (pending_breakpoints[i].address == address)
|
||||
{
|
||||
pending_breakpoints[i].address = 0;
|
||||
WriteProcessMemory (hProcess,
|
||||
(void *)address,
|
||||
&(pending_breakpoints[i].real_byte),
|
||||
1, &rv);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HANDLE
|
||||
lookup_thread_id (int threadId, int *tix)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<num_active_threads; i++)
|
||||
if (active_thread_ids[i] == threadId)
|
||||
{
|
||||
if (tix) *tix = i;
|
||||
return active_threads[i];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
set_step_threads (int threadId, int trace)
|
||||
{
|
||||
int rv, tix;
|
||||
HANDLE thread = lookup_thread_id (threadId, &tix);
|
||||
|
||||
rv = GetThreadContext (thread, &context);
|
||||
if (rv != -1)
|
||||
{
|
||||
thread_step_flags[tix] = trace;
|
||||
if (trace)
|
||||
context.EFlags |= 0x100; /* TRAP (single step) flag */
|
||||
else
|
||||
context.EFlags &= ~0x100; /* TRAP (single step) flag */
|
||||
SetThreadContext (thread, &context);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
set_steps ()
|
||||
{
|
||||
int i, s;
|
||||
for (i=0; i<num_active_threads; i++)
|
||||
{
|
||||
GetThreadContext (active_threads[i], &context);
|
||||
s = context.EFlags & 0x0100;
|
||||
if (!s && thread_step_flags[i])
|
||||
{
|
||||
set_step_threads (active_thread_ids[i], 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
dll_sort (const void *va, const void *vb)
|
||||
{
|
||||
DllInfo *a = (DllInfo *)va;
|
||||
DllInfo *b = (DllInfo *)vb;
|
||||
if (a->base_address < b->base_address)
|
||||
return -1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static char *
|
||||
addr2dllname (unsigned int addr)
|
||||
{
|
||||
int i;
|
||||
for (i=num_dlls-1; i>=0; i--)
|
||||
{
|
||||
if (dll_info[i].base_address < addr)
|
||||
{
|
||||
return dll_info[i].name;
|
||||
}
|
||||
}
|
||||
return (char *)"";
|
||||
}
|
||||
|
||||
static void
|
||||
dump_registers (HANDLE thread)
|
||||
{
|
||||
context.ContextFlags = CONTEXT_FULL;
|
||||
GetThreadContext (thread, &context);
|
||||
printf ("eax %08lx ebx %08lx ecx %08lx edx %08lx eip\n",
|
||||
context.Eax, context.Ebx, context.Ecx, context.Edx);
|
||||
printf ("esi %08lx edi %08lx ebp %08lx esp %08lx %08lx\n",
|
||||
context.Esi, context.Esi, context.Ebp, context.Esp, context.Eip);
|
||||
}
|
||||
|
||||
typedef struct Edge {
|
||||
struct Edge *next;
|
||||
unsigned int from_pc;
|
||||
unsigned int to_pc;
|
||||
unsigned int count;
|
||||
} Edge;
|
||||
|
||||
Edge *edges[4096];
|
||||
|
||||
void
|
||||
store_call_edge (unsigned int from_pc, unsigned int to_pc)
|
||||
{
|
||||
Edge *e;
|
||||
unsigned int h = ((from_pc + to_pc)>>4) & 4095;
|
||||
for (e=edges[h]; e; e=e->next)
|
||||
if (e->from_pc == from_pc && e->to_pc == to_pc)
|
||||
break;
|
||||
if (!e)
|
||||
{
|
||||
e = (Edge *)malloc (sizeof (Edge));
|
||||
e->next = edges[h];
|
||||
edges[h] = e;
|
||||
e->from_pc = from_pc;
|
||||
e->to_pc = to_pc;
|
||||
e->count = 0;
|
||||
}
|
||||
e->count++;
|
||||
}
|
||||
|
||||
void
|
||||
write_call_edges (FILE *f)
|
||||
{
|
||||
int h;
|
||||
Edge *e;
|
||||
for (h=0; h<4096; h++)
|
||||
for (e=edges[h]; e; e=e->next)
|
||||
fwrite (&(e->from_pc), 1, 3*sizeof (unsigned int), f);
|
||||
}
|
||||
|
||||
char *
|
||||
wide_strdup (char *cp)
|
||||
{
|
||||
unsigned short *s = (unsigned short *)cp;
|
||||
int len;
|
||||
char *rv;
|
||||
for (len=0; s[len]; len++);
|
||||
rv = (char *)malloc (len+1);
|
||||
for (len=0; s[len]; len++)
|
||||
rv[len] = s[len];
|
||||
rv[len] = 0;
|
||||
return rv;
|
||||
}
|
||||
|
||||
void
|
||||
run_program (char *cmdline)
|
||||
{
|
||||
FILE *tracefile = 0;
|
||||
int tix, i;
|
||||
HANDLE hThread;
|
||||
char *string;
|
||||
|
||||
memset (&startup, 0, sizeof (startup));
|
||||
startup.cb = sizeof (startup);
|
||||
|
||||
if (!CreateProcess (0, cmd_line, 0, 0, 0,
|
||||
CREATE_NEW_PROCESS_GROUP
|
||||
| CREATE_SUSPENDED
|
||||
| DEBUG_PROCESS
|
||||
| DEBUG_ONLY_THIS_PROCESS,
|
||||
0, 0, &startup, &procinfo))
|
||||
{
|
||||
fprintf (stderr, "Can't create process: error %ld\n", GetLastError ());
|
||||
exit (1);
|
||||
}
|
||||
|
||||
hProcess = procinfo.hProcess;
|
||||
#if 0
|
||||
printf ("procinfo: %08x %08x %08x %08x\n",
|
||||
hProcess, procinfo.hThread, procinfo.dwProcessId, procinfo.dwThreadId);
|
||||
#endif
|
||||
|
||||
active_threads[0] = procinfo.hThread;
|
||||
active_thread_ids[0] = procinfo.dwThreadId;
|
||||
thread_step_flags[0] = stepping_enabled;
|
||||
num_active_threads = 1;
|
||||
|
||||
dll_info[0].base_address = 0;
|
||||
dll_info[0].pcount = 0;
|
||||
dll_info[0].scount = 0;
|
||||
dll_info[0].name = cmd_line;
|
||||
num_dlls = 1;
|
||||
|
||||
SetThreadPriority (procinfo.hThread, THREAD_PRIORITY_IDLE);
|
||||
|
||||
context.ContextFlags = CONTEXT_FULL;
|
||||
|
||||
ResumeThread (procinfo.hThread);
|
||||
|
||||
total_cycles = 0;
|
||||
|
||||
if (tracing_enabled)
|
||||
{
|
||||
tracefile = fopen ("trace.ssp", "w");
|
||||
if (!tracefile)
|
||||
{
|
||||
tracing_enabled = 0;
|
||||
perror ("trace.ssp");
|
||||
}
|
||||
}
|
||||
|
||||
running = 1;
|
||||
while (running)
|
||||
{
|
||||
int src, dest;
|
||||
DWORD rv;
|
||||
DEBUG_EVENT event;
|
||||
int contv = DBG_CONTINUE;
|
||||
|
||||
event.dwDebugEventCode = -1;
|
||||
if (!WaitForDebugEvent (&event, INFINITE))
|
||||
{
|
||||
printf ("idle...\n");
|
||||
}
|
||||
|
||||
hThread = lookup_thread_id (event.dwThreadId, &tix);
|
||||
|
||||
#if 0
|
||||
printf ("DE: %x/%d %d %d ",
|
||||
hThread, tix,
|
||||
event.dwDebugEventCode, num_active_threads);
|
||||
for (src=0; src<num_active_threads; src++)
|
||||
{
|
||||
int sc = SuspendThread (active_threads[src]);
|
||||
int rv = GetThreadContext (active_threads[src], &context);
|
||||
ResumeThread (active_threads[src]);
|
||||
printf (" [%x,%x,%x]",
|
||||
active_threads[src], context.Eip, active_thread_ids[src]);
|
||||
}
|
||||
printf ("\n");
|
||||
#endif
|
||||
|
||||
switch (event.dwDebugEventCode)
|
||||
{
|
||||
|
||||
case CREATE_PROCESS_DEBUG_EVENT:
|
||||
break;
|
||||
|
||||
case CREATE_THREAD_DEBUG_EVENT:
|
||||
if (verbose)
|
||||
printf ("create thread %08lx at %08x %s\n",
|
||||
event.dwThreadId,
|
||||
(int)event.u.CreateThread.lpStartAddress,
|
||||
addr2dllname ((unsigned int)event.u.CreateThread.lpStartAddress));
|
||||
|
||||
active_thread_ids[num_active_threads] = event.dwThreadId;
|
||||
active_threads[num_active_threads] = event.u.CreateThread.hThread;
|
||||
thread_return_address[num_active_threads] = 0;
|
||||
num_active_threads++;
|
||||
|
||||
if (trace_all_threads && stepping_enabled)
|
||||
{
|
||||
thread_step_flags[num_active_threads-1] = stepping_enabled;
|
||||
add_breakpoint ((int)event.u.CreateThread.lpStartAddress);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case EXIT_THREAD_DEBUG_EVENT:
|
||||
if (verbose)
|
||||
printf ("exit thread %08lx, code=%ld\n",
|
||||
event.dwThreadId,
|
||||
event.u.ExitThread.dwExitCode);
|
||||
|
||||
for (src=0, dest=0; src<num_active_threads; src++)
|
||||
if (active_thread_ids[src] != event.dwThreadId)
|
||||
{
|
||||
active_thread_ids[dest] = active_thread_ids[src];
|
||||
active_threads[dest] = active_threads[src];
|
||||
dest++;
|
||||
}
|
||||
num_active_threads = dest;
|
||||
break;
|
||||
|
||||
case EXCEPTION_DEBUG_EVENT:
|
||||
rv = GetThreadContext (hThread, &context);
|
||||
switch (event.u.Exception.ExceptionRecord.ExceptionCode)
|
||||
{
|
||||
case STATUS_BREAKPOINT:
|
||||
if (remove_breakpoint ((int)event.u.Exception.ExceptionRecord.ExceptionAddress))
|
||||
{
|
||||
context.Eip --;
|
||||
if (rv != -1)
|
||||
SetThreadContext (hThread, &context);
|
||||
if (ReadProcessMemory (hProcess, (void *)context.Esp, &rv, 4, &rv))
|
||||
thread_return_address[tix] = rv;
|
||||
}
|
||||
set_step_threads (event.dwThreadId, stepping_enabled);
|
||||
case STATUS_SINGLE_STEP:
|
||||
opcode_count++;
|
||||
pc = (unsigned int)event.u.Exception.ExceptionRecord.ExceptionAddress;
|
||||
sp = (unsigned int)context.Esp;
|
||||
if (tracing_enabled)
|
||||
fprintf (tracefile, "%08x %08lx\n", pc, event.dwThreadId);
|
||||
if (trace_console)
|
||||
{
|
||||
printf ("%d %08x\n", tix, pc);
|
||||
fflush (stdout);
|
||||
}
|
||||
|
||||
if (dll_counts)
|
||||
{
|
||||
int i;
|
||||
for (i=num_dlls-1; i>=0; i--)
|
||||
{
|
||||
if (dll_info[i].base_address < context.Eip)
|
||||
{
|
||||
if (hThread == procinfo.hThread)
|
||||
dll_info[i].pcount++;
|
||||
else
|
||||
dll_info[i].scount++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pc < last_pc || pc > last_pc+10)
|
||||
{
|
||||
static int ncalls=0;
|
||||
static int qq=0;
|
||||
if (++qq % 100 == 0)
|
||||
fprintf (stderr, " %08x %d %d \r",
|
||||
pc, ncalls, opcode_count);
|
||||
|
||||
if (sp == last_sp-4)
|
||||
{
|
||||
ncalls++;
|
||||
store_call_edge (last_pc, pc);
|
||||
if (last_pc < KERNEL_ADDR && pc > KERNEL_ADDR)
|
||||
{
|
||||
int retaddr;
|
||||
DWORD rv;
|
||||
ReadProcessMemory (hProcess,
|
||||
(void *)sp,
|
||||
(LPVOID)&(retaddr),
|
||||
4, &rv);
|
||||
#if 0
|
||||
printf ("call last_pc = %08x pc = %08x rv = %08x\n",
|
||||
last_pc, pc, retaddr);
|
||||
/* experimental - try to skip kernel calls for speed */
|
||||
add_breakpoint (retaddr);
|
||||
set_step_threads (event.dwThreadId, 0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
total_cycles++;
|
||||
last_sp = sp;
|
||||
last_pc = pc;
|
||||
if (pc >= low_pc && pc < high_pc)
|
||||
hits[(pc - low_pc)/2] ++;
|
||||
break;
|
||||
default:
|
||||
if (verbose)
|
||||
{
|
||||
printf ("exception %ld, ", event.u.Exception.dwFirstChance);
|
||||
printf ("code: %lx flags: %lx\n",
|
||||
event.u.Exception.ExceptionRecord.ExceptionCode,
|
||||
event.u.Exception.ExceptionRecord.ExceptionFlags);
|
||||
if (event.u.Exception.dwFirstChance == 1)
|
||||
dump_registers (hThread);
|
||||
}
|
||||
contv = DBG_EXCEPTION_NOT_HANDLED;
|
||||
running = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
if (rv != -1)
|
||||
{
|
||||
if (pc == thread_return_address[tix])
|
||||
{
|
||||
if (context.EFlags & 0x100)
|
||||
{
|
||||
context.EFlags &= ~0x100; /* TRAP (single step) flag */
|
||||
SetThreadContext (hThread, &context);
|
||||
}
|
||||
}
|
||||
else if (stepping_enabled)
|
||||
{
|
||||
if (!(context.EFlags & 0x100))
|
||||
{
|
||||
context.EFlags |= 0x100; /* TRAP (single step) flag */
|
||||
SetThreadContext (hThread, &context);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case OUTPUT_DEBUG_STRING_EVENT:
|
||||
string = (char *)malloc (event.u.DebugString.nDebugStringLength+1);
|
||||
i = ReadProcessMemory (hProcess,
|
||||
event.u.DebugString.lpDebugStringData,
|
||||
(LPVOID)string,
|
||||
event.u.DebugString.nDebugStringLength,
|
||||
&rv);
|
||||
if (!i)
|
||||
{
|
||||
printf ("error reading memory: %ld %ld\n", rv, GetLastError ());
|
||||
}
|
||||
if (verbose)
|
||||
printf ("ODS: %x/%d \"%s\"\n",
|
||||
(int)hThread, tix, string);
|
||||
|
||||
if (strcmp (string, "ssp on") == 0)
|
||||
{
|
||||
stepping_enabled = 1;
|
||||
set_step_threads (event.dwThreadId, 1);
|
||||
}
|
||||
|
||||
if (strcmp (string, "ssp off") == 0)
|
||||
{
|
||||
stepping_enabled = 0;
|
||||
set_step_threads (event.dwThreadId, 0);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
|
||||
case LOAD_DLL_DEBUG_EVENT:
|
||||
if (verbose)
|
||||
printf ("load dll %08x:",
|
||||
(int)event.u.LoadDll.lpBaseOfDll);
|
||||
|
||||
dll_ptr = (char *)"( u n k n o w n ) \0\0";
|
||||
if (event.u.LoadDll.lpImageName)
|
||||
{
|
||||
ReadProcessMemory (hProcess,
|
||||
event.u.LoadDll.lpImageName,
|
||||
(LPVOID)&src,
|
||||
sizeof (src),
|
||||
&rv);
|
||||
if (src)
|
||||
{
|
||||
ReadProcessMemory (hProcess,
|
||||
(void *)src,
|
||||
(LPVOID)dll_name,
|
||||
sizeof (dll_name),
|
||||
&rv);
|
||||
dll_name[rv] = 0;
|
||||
dll_ptr = dll_name;
|
||||
for (cp=dll_name; *cp; cp++)
|
||||
{
|
||||
if (*cp == '\\' || *cp == '/')
|
||||
{
|
||||
dll_ptr = cp+1;
|
||||
}
|
||||
*cp = tolower (*cp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
dll_info[num_dlls].base_address
|
||||
= (unsigned int)event.u.LoadDll.lpBaseOfDll;
|
||||
dll_info[num_dlls].pcount = 0;
|
||||
dll_info[num_dlls].scount = 0;
|
||||
dll_info[num_dlls].name = wide_strdup (dll_ptr);
|
||||
if (verbose)
|
||||
printf (" %s\n", dll_info[num_dlls].name);
|
||||
num_dlls++;
|
||||
qsort (dll_info, num_dlls, sizeof (DllInfo), dll_sort);
|
||||
|
||||
break;
|
||||
|
||||
case UNLOAD_DLL_DEBUG_EVENT:
|
||||
if (verbose)
|
||||
printf ("unload dll\n");
|
||||
break;
|
||||
|
||||
case EXIT_PROCESS_DEBUG_EVENT:
|
||||
if (verbose)
|
||||
printf ("process %08lx %08lx exit %ld\n",
|
||||
event.dwProcessId, event.dwThreadId,
|
||||
event.u.ExitProcess.dwExitCode);
|
||||
|
||||
running = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
set_steps ();
|
||||
ContinueDebugEvent (event.dwProcessId, event.dwThreadId, contv);
|
||||
}
|
||||
|
||||
count = 0;
|
||||
for (pc=low_pc; pc<high_pc; pc+=2)
|
||||
{
|
||||
count += hits[(pc - low_pc)/2];
|
||||
}
|
||||
printf ("total cycles: %d, counted cycles: %d\n", total_cycles, count);
|
||||
|
||||
if (tracing_enabled)
|
||||
fclose (tracefile);
|
||||
|
||||
}
|
||||
|
||||
#define WHITE(s) while (isspace (*s)) s++
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
int i, n;
|
||||
int total_pcount, total_scount;
|
||||
FILE *gmon;
|
||||
|
||||
setbuf (stdout, 0);
|
||||
|
||||
cmd_line = GetCommandLine ();
|
||||
|
||||
/* strip off the program part */
|
||||
n = sscanf (cmd_line, "%*s%n", &i);
|
||||
cmd_line += i;
|
||||
WHITE (cmd_line);
|
||||
|
||||
/* parse arguments. Ugly, but we need to preserve the tail of the line */
|
||||
while (*cmd_line == '-')
|
||||
{
|
||||
char opt[100];
|
||||
n = sscanf (cmd_line, " %s%n", opt, &i);
|
||||
cmd_line += i;
|
||||
WHITE (cmd_line);
|
||||
|
||||
if (strcmp (opt, "-d") == 0)
|
||||
{
|
||||
printf ("stepping disabled; enable via OutputDebugString (\"ssp on\")\n");
|
||||
stepping_enabled = 0;
|
||||
}
|
||||
if (strcmp (opt, "-e") == 0)
|
||||
{
|
||||
printf ("stepping enabled; disable via OutputDebugString (\"ssp off\")\n");
|
||||
stepping_enabled = 1;
|
||||
}
|
||||
if (strcmp (opt, "-t") == 0)
|
||||
{
|
||||
printf ("tracing all $eip to trace.ssp\n");
|
||||
tracing_enabled = 1;
|
||||
}
|
||||
if (strcmp (opt, "-tc") == 0)
|
||||
{
|
||||
printf ("tracing *all* $eip to the console\n");
|
||||
trace_console = 1;
|
||||
}
|
||||
if (strcmp (opt, "-s") == 0)
|
||||
{
|
||||
printf ("tracing all sub-threads too, not just the main one\n");
|
||||
trace_all_threads = 1;
|
||||
}
|
||||
if (strcmp (opt, "-dll") == 0)
|
||||
{
|
||||
printf ("profiling dll usage\n");
|
||||
dll_counts = 1;
|
||||
}
|
||||
if (strcmp (opt, "-v") == 0)
|
||||
{
|
||||
printf ("verbose messages enabled\n");
|
||||
verbose = 1;
|
||||
}
|
||||
}
|
||||
|
||||
n = sscanf (cmd_line, " %i %i %n", &low_pc, &high_pc, &i);
|
||||
if (n < 2)
|
||||
{
|
||||
fputs (help_text, stderr);
|
||||
exit (1);
|
||||
}
|
||||
cmd_line += i;
|
||||
|
||||
if (low_pc > high_pc-8)
|
||||
{
|
||||
fprintf (stderr, "Hey, low_pc must be lower than high_pc\n");
|
||||
exit (1);
|
||||
}
|
||||
|
||||
hits = (HISTCOUNTER *)malloc (high_pc-low_pc+4);
|
||||
memset (hits, 0, high_pc-low_pc+4);
|
||||
|
||||
fprintf (stderr, "prun: [%08x,%08x] Running `%s'\n",
|
||||
low_pc, high_pc, cmd_line);
|
||||
|
||||
run_program (cmd_line);
|
||||
|
||||
hdr.lpc = low_pc;
|
||||
hdr.hpc = high_pc;
|
||||
hdr.ncnt = high_pc-low_pc + sizeof (hdr);
|
||||
hdr.version = GMONVERSION;
|
||||
hdr.profrate = 100;
|
||||
|
||||
gmon = fopen ("gmon.out", "wb");
|
||||
fwrite (&hdr, 1, sizeof (hdr), gmon);
|
||||
fwrite (hits, 1, high_pc-low_pc, gmon);
|
||||
write_call_edges (gmon);
|
||||
fclose (gmon);
|
||||
|
||||
if (dll_counts)
|
||||
{
|
||||
/* 1234567 123% 1234567 123% 12345678 xxxxxxxxxxx */
|
||||
printf (" Main-Thread Other-Thread BaseAddr DLL Name\n");
|
||||
|
||||
total_pcount = 0;
|
||||
total_scount = 0;
|
||||
for (i=0; i<num_dlls; i++)
|
||||
{
|
||||
total_pcount += dll_info[i].pcount;
|
||||
total_scount += dll_info[i].scount;
|
||||
}
|
||||
|
||||
if (total_pcount == 0) total_pcount++;
|
||||
if (total_scount == 0) total_scount++;
|
||||
|
||||
for (i=0; i<num_dlls; i++)
|
||||
if (dll_info[i].pcount || dll_info[i].scount)
|
||||
{
|
||||
printf ("%7d %3d%% %7d %3d%% %08x %s\n",
|
||||
dll_info[i].pcount,
|
||||
(dll_info[i].pcount*100)/opcode_count,
|
||||
dll_info[i].scount,
|
||||
(dll_info[i].scount*100)/opcode_count,
|
||||
dll_info[i].base_address,
|
||||
dll_info[i].name);
|
||||
}
|
||||
}
|
||||
|
||||
exit (0);
|
||||
}
|
||||
|
Reference in New Issue
Block a user