DJ Delorie
parent
4b70969a08
commit
cc55c579a3
|
|
@ -1,3 +1,9 @@
|
||||||
|
2000-10-18 DJ Delorie <dj@redhat.com>
|
||||||
|
|
||||||
|
* ssp.c: new
|
||||||
|
* ssp.txt: new
|
||||||
|
* Makefile.in: build ssp.exe
|
||||||
|
|
||||||
Wed Oct 18 18:57:46 2000 Christopher Faylor <cgf@cygnus.com>
|
Wed Oct 18 18:57:46 2000 Christopher Faylor <cgf@cygnus.com>
|
||||||
|
|
||||||
* ps.cc (main): Add some extra space to Windows pid output for
|
* ps.cc (main): Add some extra space to Windows pid output for
|
||||||
|
|
|
||||||
|
|
@ -70,7 +70,7 @@ DUMPER_LDFLAGS:=$(ALL_LDFLAGS) $(DUMPER_LIB)
|
||||||
PROGS:=mount$(EXEEXT) umount$(EXEEXT) ps$(EXEEXT) kill$(EXEEXT) \
|
PROGS:=mount$(EXEEXT) umount$(EXEEXT) ps$(EXEEXT) kill$(EXEEXT) \
|
||||||
mkpasswd$(EXEEXT) mkgroup$(EXEEXT) cygpath$(EXEEXT) cygcheck$(EXEEXT) \
|
mkpasswd$(EXEEXT) mkgroup$(EXEEXT) cygpath$(EXEEXT) cygcheck$(EXEEXT) \
|
||||||
passwd$(EXEEXT) getfacl$(EXEEXT) setfacl$(EXEEXT) strace$(EXEEXT) \
|
passwd$(EXEEXT) getfacl$(EXEEXT) setfacl$(EXEEXT) strace$(EXEEXT) \
|
||||||
regtool$(EXEEXT)
|
regtool$(EXEEXT) ssp$(EXEEXT)
|
||||||
|
|
||||||
CLEAN_PROGS:=$(PROGS)
|
CLEAN_PROGS:=$(PROGS)
|
||||||
ifdef build_dumper
|
ifdef build_dumper
|
||||||
|
|
|
||||||
|
|
@ -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);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
@ -0,0 +1,125 @@
|
||||||
|
|
||||||
|
SSP - The Single Step Profiler
|
||||||
|
|
||||||
|
Original Author: DJ Delorie <dj@redhat.com>
|
||||||
|
|
||||||
|
The SSP is a program that uses the Win32 debug API to run a program
|
||||||
|
one ASM instruction at a time. It records the location of each
|
||||||
|
instruction used, how many times that instruction is used, and all
|
||||||
|
function calls. The results are saved in a format that is usable by
|
||||||
|
the profiling program "gprof", although gprof will claim the values
|
||||||
|
are seconds, they really are instruction counts. More on that later.
|
||||||
|
|
||||||
|
Because the SSP was originally designed to profile the cygwin DLL, it
|
||||||
|
does not automatically select a block of code to report statistics on.
|
||||||
|
You must specify the range of memory addresses to keep track of
|
||||||
|
manually, but it's not hard to figure out what to specify. Use the
|
||||||
|
"objdump" program to determine the bounds of the target's ".text"
|
||||||
|
section. Let's say we're profiling cygwin1.dll. Make sure you've
|
||||||
|
built it with debug symbols (else gprof won't run) and run objdump
|
||||||
|
like this:
|
||||||
|
|
||||||
|
objdump -h cygwin1.dll
|
||||||
|
|
||||||
|
It will print a report like this:
|
||||||
|
|
||||||
|
cygwin1.dll: file format pei-i386
|
||||||
|
|
||||||
|
Sections:
|
||||||
|
Idx Name Size VMA LMA File off Algn
|
||||||
|
0 .text 0007ea00 61001000 61001000 00000400 2**2
|
||||||
|
CONTENTS, ALLOC, LOAD, READONLY, CODE, DATA
|
||||||
|
1 .data 00008000 61080000 61080000 0007ee00 2**2
|
||||||
|
CONTENTS, ALLOC, LOAD, DATA
|
||||||
|
. . .
|
||||||
|
|
||||||
|
The only information we're concerned with are the VMA of the .text
|
||||||
|
section and the VMA of the section after it (sections are usually
|
||||||
|
contiguous; you can also add the Size to the VMA to get the end
|
||||||
|
address). In this case, the VMA is 0x61001000 and the ending address
|
||||||
|
is either 0x61080000 (start of .data method) or 0x0x6107fa00 (VMA+Size
|
||||||
|
method).
|
||||||
|
|
||||||
|
There are two basic ways to use SSP - either profiling a whole
|
||||||
|
program, or selectively profiling parts of the program.
|
||||||
|
|
||||||
|
To profile a whole program, just run ssp without options. By default,
|
||||||
|
it will step the whole program. Here's a simple example, using the
|
||||||
|
numbers above:
|
||||||
|
|
||||||
|
ssp 0x61001000 0x61080000 hello.exe
|
||||||
|
|
||||||
|
This will step the whole program. It will take at least 8 minutes on
|
||||||
|
a PII/300 (yes, really). When it's done, it will create a file called
|
||||||
|
"gmon.out". You can turn this data file into a readable report with
|
||||||
|
gprof:
|
||||||
|
|
||||||
|
gprof -b cygwin1.dll
|
||||||
|
|
||||||
|
The "-b" means "skip the help pages". You can omit this until you're
|
||||||
|
familiar with the report layout. The gprof documentation explains
|
||||||
|
a lot about this report, but ssp changes a few things. For example,
|
||||||
|
the first part of the report reports the amount of time spent in each
|
||||||
|
function, like this:
|
||||||
|
|
||||||
|
Each sample counts as 0.01 seconds.
|
||||||
|
% cumulative self self total
|
||||||
|
time seconds seconds calls ms/call ms/call name
|
||||||
|
10.02 231.22 72.43 46 1574.57 1574.57 strcspn
|
||||||
|
7.95 288.70 57.48 130 442.15 442.15 strncasematch
|
||||||
|
|
||||||
|
The "seconds" columns are really CPU opcodes, 1/100 second per opcode.
|
||||||
|
So, "231.22" above means 23,122 opcodes. The ms/call values are 10x
|
||||||
|
too big; 1574.57 means 157.457 opcodes per call. Similar adjustments
|
||||||
|
need to be made for the "self" and "children" columns in the second
|
||||||
|
part of the report.
|
||||||
|
|
||||||
|
OK, so now we've got a huge report that took a long time to generate,
|
||||||
|
and we've identified a spot we want to work on optimizing. Let's say
|
||||||
|
it's the time() function. We can use SSP to selectively profile this
|
||||||
|
function by using OutputDebugString() to control SSP from within the
|
||||||
|
program. Here's a sample program:
|
||||||
|
|
||||||
|
#include <windows.h>
|
||||||
|
main()
|
||||||
|
{
|
||||||
|
time_t t;
|
||||||
|
OutputDebugString("ssp on");
|
||||||
|
time(&t);
|
||||||
|
OutputDebugString("ssp off");
|
||||||
|
}
|
||||||
|
|
||||||
|
Then, add the "-d" option to ssp to default to *disabling* profiling.
|
||||||
|
The program will run at full speed until the first OutputDebugString,
|
||||||
|
then step until the second.
|
||||||
|
|
||||||
|
ssp -d 0x61001000 0x61080000 hello.exe
|
||||||
|
|
||||||
|
You can then use gprof (as usual) to see the performance profile for
|
||||||
|
just that portion of the program's execution.
|
||||||
|
|
||||||
|
OK, now for the other ssp options, and when to use them:
|
||||||
|
|
||||||
|
"-v" - verbose. This prints messages about threads starting and
|
||||||
|
stopping, OutputDebugString calls, DLLs loading, etc.
|
||||||
|
|
||||||
|
"-t" and "-tc" - tracing. With -t, *every* step's address is written
|
||||||
|
to the file "trace.ssp". This can be used to help debug functions,
|
||||||
|
since it can trace multiple threads. Clever use of scripts can match
|
||||||
|
addresses with disassembled opcodes if needed. Warning: creates
|
||||||
|
*huge* files, very quickly. "-tc" prints each address to the console,
|
||||||
|
useful for debugging key chunks of assembler.
|
||||||
|
|
||||||
|
"-s" - subthreads. Usually, you only need to trace the main thread,
|
||||||
|
but sometimes you need to trace all threads, so this enables that.
|
||||||
|
It's also needed when you want to profile a function that only a
|
||||||
|
subthread calls. However, using OutputDebugString automatically
|
||||||
|
enables profiling on the thread that called it, not the main thread.
|
||||||
|
|
||||||
|
"-dll" - dll profiling. Generates a pretty table of how much time was
|
||||||
|
spent in each dll the program used. No sense optimizing a function in
|
||||||
|
your program if most of the time is spent in the DLL.
|
||||||
|
|
||||||
|
I usually use the -v, -s, and -dll options:
|
||||||
|
|
||||||
|
ssp -v -s -dll -d 0x61001000 0x61080000 hello.exe
|
||||||
Loading…
Reference in New Issue