diff -Nru Python-2.5.1/Include/frameobject.h Python-2.5.1+dtrace/Include/frameobject.h
--- Python-2.5.1/Include/frameobject.h	2006-06-11 22:11:18.000000000 -0400
+++ Python-2.5.1+dtrace/Include/frameobject.h	2007-09-19 21:22:33.064323000 -0400
@@ -41,6 +41,7 @@
     /* As of 2.3 f_lineno is only valid when tracing is active (i.e. when
        f_trace is set) -- at other times use PyCode_Addr2Line instead. */
     int f_lineno;		/* Current line number */
+    int f_calllineno;		/* line number of call site */
     int f_iblock;		/* index in f_blockstack */
     PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
     PyObject *f_localsplus[1];	/* locals+stack, dynamically sized */
diff -Nru Python-2.5.1/Makefile.pre.in Python-2.5.1+dtrace/Makefile.pre.in
--- Python-2.5.1/Makefile.pre.in	2006-12-08 15:46:13.000000000 -0500
+++ Python-2.5.1+dtrace/Makefile.pre.in	2007-09-19 21:12:36.809125000 -0400
@@ -192,6 +192,7 @@
 GRAMMAR_C=	$(srcdir)/Python/graminit.c
 GRAMMAR_INPUT=	$(srcdir)/Grammar/Grammar
 
+DTRACE_OBJS=Python/dtrace.o Python/phelper.o
 
 ##########################################################################
 # Parser
@@ -271,6 +272,7 @@
 		Python/getopt.o \
 		Python/pystrtod.o \
 		Python/$(DYNLOADFILE) \
+		$(DTRACE_OBJS) \
 		$(MACHDEP_OBJS) \
 		$(THREADOBJ)
 
@@ -499,6 +501,17 @@
 Objects/unicodectype.o:	$(srcdir)/Objects/unicodectype.c \
 				$(srcdir)/Objects/unicodetype_db.h
 
+Python/phelper.o: $(srcdir)/Python/phelper.d
+	dtrace -o $@ -DPHELPER $(DFLAGS) $(CPPFLAGS) -C -G -s $(srcdir)/Python/phelper.d
+
+Python/python.h: $(srcdir)/Python/python.d
+	dtrace -o $@ $(DFLAGS) -C -h -s $(srcdir)/Python/python.d
+
+Python/ceval.o: Python/python.h
+
+Python/dtrace.o: $(srcdir)/Python/python.d Python/ceval.o
+	dtrace -o $@ $(DFLAGS) -C -G -s $(srcdir)/Python/python.d Python/ceval.o
+
 ############################################################################
 # Header files
 
diff -Nru Python-2.5.1/Objects/frameobject.c Python-2.5.1+dtrace/Objects/frameobject.c
--- Python-2.5.1/Objects/frameobject.c	2007-04-16 02:19:52.000000000 -0400
+++ Python-2.5.1+dtrace/Objects/frameobject.c	2007-09-19 22:18:36.084885000 -0400
@@ -670,6 +670,7 @@
 	f->f_tstate = tstate;
 
 	f->f_lasti = -1;
+ 	f->f_calllineno = code->co_firstlineno;
 	f->f_lineno = code->co_firstlineno;
 	f->f_iblock = 0;
 
diff -Nru Python-2.5.1/Objects/frameobject.c~ Python-2.5.1+dtrace/Objects/frameobject.c~
--- Python-2.5.1/Objects/frameobject.c~	1969-12-31 19:00:00.000000000 -0500
+++ Python-2.5.1+dtrace/Objects/frameobject.c~	2007-09-19 21:12:36.827448000 -0400
@@ -0,0 +1,849 @@
+/* Frame object implementation */
+
+#include "Python.h"
+
+#include "code.h"
+#include "frameobject.h"
+#include "opcode.h"
+#include "structmember.h"
+
+#undef MIN
+#undef MAX
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#define OFF(x) offsetof(PyFrameObject, x)
+
+static PyMemberDef frame_memberlist[] = {
+	{"f_back",	T_OBJECT,	OFF(f_back),	RO},
+	{"f_code",	T_OBJECT,	OFF(f_code),	RO},
+	{"f_builtins",	T_OBJECT,	OFF(f_builtins),RO},
+	{"f_globals",	T_OBJECT,	OFF(f_globals),	RO},
+	{"f_lasti",	T_INT,		OFF(f_lasti),	RO},
+	{"f_exc_type",	T_OBJECT,	OFF(f_exc_type)},
+	{"f_exc_value",	T_OBJECT,	OFF(f_exc_value)},
+	{"f_exc_traceback", T_OBJECT,	OFF(f_exc_traceback)},
+	{NULL}	/* Sentinel */
+};
+
+static PyObject *
+frame_getlocals(PyFrameObject *f, void *closure)
+{
+	PyFrame_FastToLocals(f);
+	Py_INCREF(f->f_locals);
+	return f->f_locals;
+}
+
+static PyObject *
+frame_getlineno(PyFrameObject *f, void *closure)
+{
+	int lineno;
+
+	if (f->f_trace)
+		lineno = f->f_lineno;
+	else
+		lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
+
+	return PyInt_FromLong(lineno);
+}
+
+/* Setter for f_lineno - you can set f_lineno from within a trace function in
+ * order to jump to a given line of code, subject to some restrictions.  Most
+ * lines are OK to jump to because they don't make any assumptions about the
+ * state of the stack (obvious because you could remove the line and the code
+ * would still work without any stack errors), but there are some constructs
+ * that limit jumping:
+ *
+ *  o Lines with an 'except' statement on them can't be jumped to, because
+ *    they expect an exception to be on the top of the stack.
+ *  o Lines that live in a 'finally' block can't be jumped from or to, since
+ *    the END_FINALLY expects to clean up the stack after the 'try' block.
+ *  o 'try'/'for'/'while' blocks can't be jumped into because the blockstack
+ *    needs to be set up before their code runs, and for 'for' loops the
+ *    iterator needs to be on the stack.
+ */
+static int
+frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno)
+{
+	int new_lineno = 0;		/* The new value of f_lineno */
+	int new_lasti = 0;		/* The new value of f_lasti */
+	int new_iblock = 0;		/* The new value of f_iblock */
+	char *code = NULL;		/* The bytecode for the frame... */
+	Py_ssize_t code_len = 0;	/* ...and its length */
+	char *lnotab = NULL;		/* Iterating over co_lnotab */
+	Py_ssize_t lnotab_len = 0;	/* (ditto) */
+	int offset = 0;			/* (ditto) */
+	int line = 0;			/* (ditto) */
+	int addr = 0;			/* (ditto) */
+	int min_addr = 0;		/* Scanning the SETUPs and POPs */
+	int max_addr = 0;		/* (ditto) */
+	int delta_iblock = 0;		/* (ditto) */
+	int min_delta_iblock = 0;	/* (ditto) */
+	int min_iblock = 0;		/* (ditto) */
+	int f_lasti_setup_addr = 0;	/* Policing no-jump-into-finally */
+	int new_lasti_setup_addr = 0;	/* (ditto) */
+	int blockstack[CO_MAXBLOCKS];	/* Walking the 'finally' blocks */
+	int in_finally[CO_MAXBLOCKS];	/* (ditto) */
+	int blockstack_top = 0;		/* (ditto) */
+	int setup_op = 0;               /* (ditto) */
+
+	/* f_lineno must be an integer. */
+	if (!PyInt_Check(p_new_lineno)) {
+		PyErr_SetString(PyExc_ValueError,
+				"lineno must be an integer");
+		return -1;
+	}
+
+	/* You can only do this from within a trace function, not via
+	 * _getframe or similar hackery. */
+	if (!f->f_trace)
+	{
+		PyErr_Format(PyExc_ValueError,
+			     "f_lineno can only be set by a trace function");
+		return -1;
+	}
+
+	/* Fail if the line comes before the start of the code block. */
+	new_lineno = (int) PyInt_AsLong(p_new_lineno);
+	if (new_lineno < f->f_code->co_firstlineno) {
+		PyErr_Format(PyExc_ValueError,
+			     "line %d comes before the current code block",
+			     new_lineno);
+		return -1;
+	}
+
+	/* Find the bytecode offset for the start of the given line, or the
+	 * first code-owning line after it. */
+	PyString_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
+	addr = 0;
+	line = f->f_code->co_firstlineno;
+	new_lasti = -1;
+	for (offset = 0; offset < lnotab_len; offset += 2) {
+		addr += lnotab[offset];
+		line += lnotab[offset+1];
+		if (line >= new_lineno) {
+			new_lasti = addr;
+			new_lineno = line;
+			break;
+		}
+	}
+
+	/* If we didn't reach the requested line, return an error. */
+	if (new_lasti == -1) {
+		PyErr_Format(PyExc_ValueError,
+			     "line %d comes after the current code block",
+			     new_lineno);
+		return -1;
+	}
+
+	/* We're now ready to look at the bytecode. */
+	PyString_AsStringAndSize(f->f_code->co_code, &code, &code_len);
+	min_addr = MIN(new_lasti, f->f_lasti);
+	max_addr = MAX(new_lasti, f->f_lasti);
+
+	/* You can't jump onto a line with an 'except' statement on it -
+	 * they expect to have an exception on the top of the stack, which
+	 * won't be true if you jump to them.  They always start with code
+	 * that either pops the exception using POP_TOP (plain 'except:'
+	 * lines do this) or duplicates the exception on the stack using
+	 * DUP_TOP (if there's an exception type specified).  See compile.c,
+	 * 'com_try_except' for the full details.  There aren't any other
+	 * cases (AFAIK) where a line's code can start with DUP_TOP or
+	 * POP_TOP, but if any ever appear, they'll be subject to the same
+	 * restriction (but with a different error message). */
+	if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) {
+		PyErr_SetString(PyExc_ValueError,
+		    "can't jump to 'except' line as there's no exception");
+		return -1;
+	}
+
+	/* You can't jump into or out of a 'finally' block because the 'try'
+	 * block leaves something on the stack for the END_FINALLY to clean
+	 * up.  So we walk the bytecode, maintaining a simulated blockstack.
+	 * When we reach the old or new address and it's in a 'finally' block
+	 * we note the address of the corresponding SETUP_FINALLY.  The jump
+	 * is only legal if neither address is in a 'finally' block or
+	 * they're both in the same one.  'blockstack' is a stack of the
+	 * bytecode addresses of the SETUP_X opcodes, and 'in_finally' tracks
+	 * whether we're in a 'finally' block at each blockstack level. */
+	f_lasti_setup_addr = -1;
+	new_lasti_setup_addr = -1;
+	memset(blockstack, '\0', sizeof(blockstack));
+	memset(in_finally, '\0', sizeof(in_finally));
+	blockstack_top = 0;
+	for (addr = 0; addr < code_len; addr++) {
+		unsigned char op = code[addr];
+		switch (op) {
+		case SETUP_LOOP:
+		case SETUP_EXCEPT:
+		case SETUP_FINALLY:
+			blockstack[blockstack_top++] = addr;
+			in_finally[blockstack_top-1] = 0;
+			break;
+
+		case POP_BLOCK:
+			assert(blockstack_top > 0);
+			setup_op = code[blockstack[blockstack_top-1]];
+			if (setup_op == SETUP_FINALLY) {
+				in_finally[blockstack_top-1] = 1;
+			}
+			else {
+				blockstack_top--;
+			}
+			break;
+
+		case END_FINALLY:
+			/* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist
+			 * in the bytecode but don't correspond to an actual
+			 * 'finally' block.  (If blockstack_top is 0, we must
+			 * be seeing such an END_FINALLY.) */
+			if (blockstack_top > 0) {
+				setup_op = code[blockstack[blockstack_top-1]];
+				if (setup_op == SETUP_FINALLY) {
+					blockstack_top--;
+				}
+			}
+			break;
+		}
+
+		/* For the addresses we're interested in, see whether they're
+		 * within a 'finally' block and if so, remember the address
+		 * of the SETUP_FINALLY. */
+		if (addr == new_lasti || addr == f->f_lasti) {
+			int i = 0;
+			int setup_addr = -1;
+			for (i = blockstack_top-1; i >= 0; i--) {
+				if (in_finally[i]) {
+					setup_addr = blockstack[i];
+					break;
+				}
+			}
+
+			if (setup_addr != -1) {
+				if (addr == new_lasti) {
+					new_lasti_setup_addr = setup_addr;
+				}
+
+				if (addr == f->f_lasti) {
+					f_lasti_setup_addr = setup_addr;
+				}
+			}
+		}
+
+		if (op >= HAVE_ARGUMENT) {
+			addr += 2;
+		}
+	}
+
+	/* Verify that the blockstack tracking code didn't get lost. */
+	assert(blockstack_top == 0);
+
+	/* After all that, are we jumping into / out of a 'finally' block? */
+	if (new_lasti_setup_addr != f_lasti_setup_addr) {
+		PyErr_SetString(PyExc_ValueError,
+			    "can't jump into or out of a 'finally' block");
+		return -1;
+	}
+
+
+	/* Police block-jumping (you can't jump into the middle of a block)
+	 * and ensure that the blockstack finishes up in a sensible state (by
+	 * popping any blocks we're jumping out of).  We look at all the
+	 * blockstack operations between the current position and the new
+	 * one, and keep track of how many blocks we drop out of on the way.
+	 * By also keeping track of the lowest blockstack position we see, we
+	 * can tell whether the jump goes into any blocks without coming out
+	 * again - in that case we raise an exception below. */
+	delta_iblock = 0;
+	for (addr = min_addr; addr < max_addr; addr++) {
+		unsigned char op = code[addr];
+		switch (op) {
+		case SETUP_LOOP:
+		case SETUP_EXCEPT:
+		case SETUP_FINALLY:
+			delta_iblock++;
+			break;
+
+		case POP_BLOCK:
+			delta_iblock--;
+			break;
+		}
+
+		min_delta_iblock = MIN(min_delta_iblock, delta_iblock);
+
+		if (op >= HAVE_ARGUMENT) {
+			addr += 2;
+		}
+	}
+
+	/* Derive the absolute iblock values from the deltas. */
+	min_iblock = f->f_iblock + min_delta_iblock;
+	if (new_lasti > f->f_lasti) {
+		/* Forwards jump. */
+		new_iblock = f->f_iblock + delta_iblock;
+	}
+	else {
+		/* Backwards jump. */
+		new_iblock = f->f_iblock - delta_iblock;
+	}
+
+	/* Are we jumping into a block? */
+	if (new_iblock > min_iblock) {
+		PyErr_SetString(PyExc_ValueError,
+				"can't jump into the middle of a block");
+		return -1;
+	}
+
+	/* Pop any blocks that we're jumping out of. */
+	while (f->f_iblock > new_iblock) {
+		PyTryBlock *b = &f->f_blockstack[--f->f_iblock];
+		while ((f->f_stacktop - f->f_valuestack) > b->b_level) {
+			PyObject *v = (*--f->f_stacktop);
+			Py_DECREF(v);
+		}
+	}
+
+	/* Finally set the new f_lineno and f_lasti and return OK. */
+	f->f_lineno = new_lineno;
+	f->f_lasti = new_lasti;
+	return 0;
+}
+
+static PyObject *
+frame_gettrace(PyFrameObject *f, void *closure)
+{
+	PyObject* trace = f->f_trace;
+
+	if (trace == NULL)
+		trace = Py_None;
+
+	Py_INCREF(trace);
+
+	return trace;
+}
+
+static int
+frame_settrace(PyFrameObject *f, PyObject* v, void *closure)
+{
+	/* We rely on f_lineno being accurate when f_trace is set. */
+
+	PyObject* old_value = f->f_trace;
+
+	Py_XINCREF(v);
+	f->f_trace = v;
+
+	if (v != NULL)
+		f->f_lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
+
+	Py_XDECREF(old_value);
+
+	return 0;
+}
+
+static PyObject *
+frame_getrestricted(PyFrameObject *f, void *closure)
+{
+	return PyBool_FromLong(PyFrame_IsRestricted(f));
+}
+
+static PyGetSetDef frame_getsetlist[] = {
+	{"f_locals",	(getter)frame_getlocals, NULL, NULL},
+	{"f_lineno",	(getter)frame_getlineno,
+			(setter)frame_setlineno, NULL},
+	{"f_trace",	(getter)frame_gettrace, (setter)frame_settrace, NULL},
+	{"f_restricted",(getter)frame_getrestricted,NULL, NULL},
+	{0}
+};
+
+/* Stack frames are allocated and deallocated at a considerable rate.
+   In an attempt to improve the speed of function calls, we:
+
+   1. Hold a single "zombie" frame on each code object. This retains
+   the allocated and initialised frame object from an invocation of
+   the code object. The zombie is reanimated the next time we need a
+   frame object for that code object. Doing this saves the malloc/
+   realloc required when using a free_list frame that isn't the
+   correct size. It also saves some field initialisation.
+
+   In zombie mode, no field of PyFrameObject holds a reference, but
+   the following fields are still valid:
+
+     * ob_type, ob_size, f_code, f_valuestack;
+       
+     * f_locals, f_trace,
+       f_exc_type, f_exc_value, f_exc_traceback are NULL;
+
+     * f_localsplus does not require re-allocation and
+       the local variables in f_localsplus are NULL.
+
+   2. We also maintain a separate free list of stack frames (just like
+   integers are allocated in a special way -- see intobject.c).  When
+   a stack frame is on the free list, only the following members have
+   a meaning:
+	ob_type		== &Frametype
+	f_back		next item on free list, or NULL
+	f_stacksize	size of value stack
+        ob_size         size of localsplus
+   Note that the value and block stacks are preserved -- this can save
+   another malloc() call or two (and two free() calls as well!).
+   Also note that, unlike for integers, each frame object is a
+   malloc'ed object in its own right -- it is only the actual calls to
+   malloc() that we are trying to save here, not the administration.
+   After all, while a typical program may make millions of calls, a
+   call depth of more than 20 or 30 is probably already exceptional
+   unless the program contains run-away recursion.  I hope.
+
+   Later, MAXFREELIST was added to bound the # of frames saved on
+   free_list.  Else programs creating lots of cyclic trash involving
+   frames could provoke free_list into growing without bound.
+*/
+
+static PyFrameObject *free_list = NULL;
+static int numfree = 0;		/* number of frames currently in free_list */
+#define MAXFREELIST 200		/* max value for numfree */
+
+static void
+frame_dealloc(PyFrameObject *f)
+{
+	PyObject **p, **valuestack;
+	PyCodeObject *co;
+
+ 	PyObject_GC_UnTrack(f);
+	Py_TRASHCAN_SAFE_BEGIN(f)
+	/* Kill all local variables */
+        valuestack = f->f_valuestack;
+        for (p = f->f_localsplus; p < valuestack; p++)
+                Py_CLEAR(*p);
+
+	/* Free stack */
+	if (f->f_stacktop != NULL) {
+		for (p = valuestack; p < f->f_stacktop; p++)
+			Py_XDECREF(*p);
+	}
+
+	Py_XDECREF(f->f_back);
+	Py_DECREF(f->f_builtins);
+	Py_DECREF(f->f_globals);
+	Py_CLEAR(f->f_locals);
+	Py_CLEAR(f->f_trace);
+	Py_CLEAR(f->f_exc_type);
+	Py_CLEAR(f->f_exc_value);
+	Py_CLEAR(f->f_exc_traceback);
+
+        co = f->f_code;
+        if (co->co_zombieframe == NULL)
+                co->co_zombieframe = f;
+	else if (numfree < MAXFREELIST) {
+		++numfree;
+		f->f_back = free_list;
+		free_list = f;
+        }
+	else 
+		PyObject_GC_Del(f);
+
+        Py_DECREF(co);
+	Py_TRASHCAN_SAFE_END(f)
+}
+
+static int
+frame_traverse(PyFrameObject *f, visitproc visit, void *arg)
+{
+	PyObject **fastlocals, **p;
+	int i, slots;
+
+	Py_VISIT(f->f_back);
+	Py_VISIT(f->f_code);
+	Py_VISIT(f->f_builtins);
+	Py_VISIT(f->f_globals);
+	Py_VISIT(f->f_locals);
+	Py_VISIT(f->f_trace);
+	Py_VISIT(f->f_exc_type);
+	Py_VISIT(f->f_exc_value);
+	Py_VISIT(f->f_exc_traceback);
+
+	/* locals */
+	slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
+	fastlocals = f->f_localsplus;
+	for (i = slots; --i >= 0; ++fastlocals)
+		Py_VISIT(*fastlocals);
+
+	/* stack */
+	if (f->f_stacktop != NULL) {
+		for (p = f->f_valuestack; p < f->f_stacktop; p++)
+			Py_VISIT(*p);
+	}
+	return 0;
+}
+
+static void
+frame_clear(PyFrameObject *f)
+{
+	PyObject **fastlocals, **p, **oldtop;
+	int i, slots;
+
+	/* Before anything else, make sure that this frame is clearly marked
+         * as being defunct!  Else, e.g., a generator reachable from this
+         * frame may also point to this frame, believe itself to still be
+         * active, and try cleaning up this frame again.
+         */
+	oldtop = f->f_stacktop;
+        f->f_stacktop = NULL;
+
+	Py_CLEAR(f->f_exc_type);
+	Py_CLEAR(f->f_exc_value);
+	Py_CLEAR(f->f_exc_traceback);
+	Py_CLEAR(f->f_trace);
+
+	/* locals */
+	slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
+	fastlocals = f->f_localsplus;
+	for (i = slots; --i >= 0; ++fastlocals)
+		Py_CLEAR(*fastlocals);
+
+	/* stack */
+	if (oldtop != NULL) {
+		for (p = f->f_valuestack; p < oldtop; p++)
+			Py_CLEAR(*p);
+	}
+}
+
+
+PyTypeObject PyFrame_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,
+	"frame",
+	sizeof(PyFrameObject),
+	sizeof(PyObject *),
+	(destructor)frame_dealloc, 		/* tp_dealloc */
+	0,					/* tp_print */
+	0, 					/* tp_getattr */
+	0,			 		/* tp_setattr */
+	0,					/* tp_compare */
+	0,					/* tp_repr */
+	0,					/* tp_as_number */
+	0,					/* tp_as_sequence */
+	0,					/* tp_as_mapping */
+	0,					/* tp_hash */
+	0,					/* tp_call */
+	0,					/* tp_str */
+	PyObject_GenericGetAttr,		/* tp_getattro */
+	PyObject_GenericSetAttr,		/* tp_setattro */
+	0,					/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
+	0,             				/* tp_doc */
+ 	(traverseproc)frame_traverse,		/* tp_traverse */
+	(inquiry)frame_clear,			/* tp_clear */
+	0,					/* tp_richcompare */
+	0,					/* tp_weaklistoffset */
+	0,					/* tp_iter */
+	0,					/* tp_iternext */
+	0,					/* tp_methods */
+	frame_memberlist,			/* tp_members */
+	frame_getsetlist,			/* tp_getset */
+	0,					/* tp_base */
+	0,					/* tp_dict */
+};
+
+static PyObject *builtin_object;
+
+int _PyFrame_Init()
+{
+	builtin_object = PyString_InternFromString("__builtins__");
+	return (builtin_object != NULL);
+}
+
+PyFrameObject *
+PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
+	    PyObject *locals)
+{
+	PyFrameObject *back = tstate->frame;
+	PyFrameObject *f;
+	PyObject *builtins;
+	Py_ssize_t i;
+
+#ifdef Py_DEBUG
+	if (code == NULL || globals == NULL || !PyDict_Check(globals) ||
+	    (locals != NULL && !PyMapping_Check(locals))) {
+		PyErr_BadInternalCall();
+		return NULL;
+	}
+#endif
+	if (back == NULL || back->f_globals != globals) {
+		builtins = PyDict_GetItem(globals, builtin_object);
+		if (builtins) {
+			if (PyModule_Check(builtins)) {
+				builtins = PyModule_GetDict(builtins);
+				assert(!builtins || PyDict_Check(builtins));
+			}
+			else if (!PyDict_Check(builtins))
+				builtins = NULL;
+		}
+		if (builtins == NULL) {
+			/* No builtins!  Make up a minimal one
+			   Give them 'None', at least. */
+			builtins = PyDict_New();
+			if (builtins == NULL ||
+			    PyDict_SetItemString(
+				    builtins, "None", Py_None) < 0)
+				return NULL;
+		}
+		else
+			Py_INCREF(builtins);
+
+	}
+	else {
+		/* If we share the globals, we share the builtins.
+		   Save a lookup and a call. */
+		builtins = back->f_builtins;
+		assert(builtins != NULL && PyDict_Check(builtins));
+		Py_INCREF(builtins);
+	}
+	if (code->co_zombieframe != NULL) {
+                f = code->co_zombieframe;
+                code->co_zombieframe = NULL;
+                _Py_NewReference((PyObject *)f);
+                assert(f->f_code == code);
+	}
+        else {
+                Py_ssize_t extras, ncells, nfrees;
+                ncells = PyTuple_GET_SIZE(code->co_cellvars);
+                nfrees = PyTuple_GET_SIZE(code->co_freevars);
+                extras = code->co_stacksize + code->co_nlocals + ncells +
+                    nfrees;
+                if (free_list == NULL) {
+                    f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type,
+                        extras);
+                    if (f == NULL) {
+                            Py_DECREF(builtins);
+                            return NULL;
+                    }
+                }
+                else {
+                    assert(numfree > 0);
+                    --numfree;
+                    f = free_list;
+                    free_list = free_list->f_back;
+                    if (f->ob_size < extras) {
+                            f = PyObject_GC_Resize(PyFrameObject, f, extras);
+                            if (f == NULL) {
+                                    Py_DECREF(builtins);
+                                    return NULL;
+                            }
+                    }
+                    _Py_NewReference((PyObject *)f);
+                }
+
+		f->f_code = code;
+		extras = code->co_nlocals + ncells + nfrees;
+		f->f_valuestack = f->f_localsplus + extras;
+		for (i=0; i<extras; i++)
+			f->f_localsplus[i] = NULL;
+		f->f_locals = NULL;
+		f->f_trace = NULL;
+                f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL;
+	}
+	f->f_stacktop = f->f_valuestack;
+	f->f_builtins = builtins;
+	Py_XINCREF(back);
+	f->f_back = back;
+	Py_INCREF(code);
+	Py_INCREF(globals);
+	f->f_globals = globals;
+	/* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
+	if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==
+		(CO_NEWLOCALS | CO_OPTIMIZED))
+		; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */
+	else if (code->co_flags & CO_NEWLOCALS) {
+		locals = PyDict_New();
+		if (locals == NULL) {
+			Py_DECREF(f);
+			return NULL;
+		}
+                f->f_locals = locals;
+	}
+	else {
+		if (locals == NULL)
+			locals = globals;
+		Py_INCREF(locals);
+                f->f_locals = locals;
+	}
+	f->f_tstate = tstate;
+
+	f->f_lasti = -1;
+	f->f_lineno = code->co_firstlineno;
+	f->f_iblock = 0;
+
+	_PyObject_GC_TRACK(f);
+	return f;
+}
+
+/* Block management */
+
+void
+PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)
+{
+	PyTryBlock *b;
+	if (f->f_iblock >= CO_MAXBLOCKS)
+		Py_FatalError("XXX block stack overflow");
+	b = &f->f_blockstack[f->f_iblock++];
+	b->b_type = type;
+	b->b_level = level;
+	b->b_handler = handler;
+}
+
+PyTryBlock *
+PyFrame_BlockPop(PyFrameObject *f)
+{
+	PyTryBlock *b;
+	if (f->f_iblock <= 0)
+		Py_FatalError("XXX block stack underflow");
+	b = &f->f_blockstack[--f->f_iblock];
+	return b;
+}
+
+/* Convert between "fast" version of locals and dictionary version */
+
+static void
+map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
+	    Py_ssize_t deref)
+{
+	Py_ssize_t j;
+	for (j = nmap; --j >= 0; ) {
+		PyObject *key = PyTuple_GET_ITEM(map, j);
+		PyObject *value = values[j];
+		if (deref)
+			value = PyCell_GET(value);
+		if (value == NULL) {
+			if (PyObject_DelItem(dict, key) != 0)
+				PyErr_Clear();
+		}
+		else {
+			if (PyObject_SetItem(dict, key, value) != 0)
+				PyErr_Clear();
+		}
+	}
+}
+
+static void
+dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
+	    Py_ssize_t deref, int clear)
+{
+	Py_ssize_t j;
+	for (j = nmap; --j >= 0; ) {
+		PyObject *key = PyTuple_GET_ITEM(map, j);
+		PyObject *value = PyObject_GetItem(dict, key);
+		if (value == NULL)
+			PyErr_Clear();
+		if (deref) {
+			if (value || clear) {
+				if (PyCell_GET(values[j]) != value) {
+					if (PyCell_Set(values[j], value) < 0)
+						PyErr_Clear();
+				}
+			}
+		} else if (value != NULL || clear) {
+			if (values[j] != value) {
+				Py_XINCREF(value);
+				Py_XDECREF(values[j]);
+				values[j] = value;
+			}
+		}
+		Py_XDECREF(value);
+	}
+}
+
+void
+PyFrame_FastToLocals(PyFrameObject *f)
+{
+	/* Merge fast locals into f->f_locals */
+	PyObject *locals, *map;
+	PyObject **fast;
+	PyObject *error_type, *error_value, *error_traceback;
+	PyCodeObject *co;
+	Py_ssize_t j;
+        int ncells, nfreevars;
+	if (f == NULL)
+		return;
+	locals = f->f_locals;
+	if (locals == NULL) {
+		locals = f->f_locals = PyDict_New();
+		if (locals == NULL) {
+			PyErr_Clear(); /* Can't report it :-( */
+			return;
+		}
+	}
+	co = f->f_code;
+	map = co->co_varnames;
+	if (!PyTuple_Check(map))
+		return;
+	PyErr_Fetch(&error_type, &error_value, &error_traceback);
+	fast = f->f_localsplus;
+	j = PyTuple_GET_SIZE(map);
+	if (j > co->co_nlocals)
+		j = co->co_nlocals;
+	if (co->co_nlocals)
+		map_to_dict(map, j, locals, fast, 0);
+	ncells = PyTuple_GET_SIZE(co->co_cellvars);
+	nfreevars = PyTuple_GET_SIZE(co->co_freevars);
+	if (ncells || nfreevars) {
+		map_to_dict(co->co_cellvars, ncells,
+			    locals, fast + co->co_nlocals, 1);
+		map_to_dict(co->co_freevars, nfreevars,
+			    locals, fast + co->co_nlocals + ncells, 1);
+	}
+	PyErr_Restore(error_type, error_value, error_traceback);
+}
+
+void
+PyFrame_LocalsToFast(PyFrameObject *f, int clear)
+{
+	/* Merge f->f_locals into fast locals */
+	PyObject *locals, *map;
+	PyObject **fast;
+	PyObject *error_type, *error_value, *error_traceback;
+	PyCodeObject *co;
+	Py_ssize_t j;
+	int ncells, nfreevars;
+	if (f == NULL)
+		return;
+	locals = f->f_locals;
+	co = f->f_code;
+	map = co->co_varnames;
+	if (locals == NULL)
+		return;
+	if (!PyTuple_Check(map))
+		return;
+	PyErr_Fetch(&error_type, &error_value, &error_traceback);
+	fast = f->f_localsplus;
+	j = PyTuple_GET_SIZE(map);
+	if (j > co->co_nlocals)
+		j = co->co_nlocals;
+	if (co->co_nlocals)
+	    dict_to_map(co->co_varnames, j, locals, fast, 0, clear);
+	ncells = PyTuple_GET_SIZE(co->co_cellvars);
+	nfreevars = PyTuple_GET_SIZE(co->co_freevars);
+	if (ncells || nfreevars) {
+		dict_to_map(co->co_cellvars, ncells,
+			    locals, fast + co->co_nlocals, 1, clear);
+		dict_to_map(co->co_freevars, nfreevars,
+			    locals, fast + co->co_nlocals + ncells, 1, 
+ 			    clear);
+	}
+	PyErr_Restore(error_type, error_value, error_traceback);
+}
+
+/* Clear out the free list */
+
+void
+PyFrame_Fini(void)
+{
+	while (free_list != NULL) {
+		PyFrameObject *f = free_list;
+		free_list = free_list->f_back;
+		PyObject_GC_Del(f);
+		--numfree;
+	}
+	assert(numfree == 0);
+	Py_XDECREF(builtin_object);
+	builtin_object = NULL;
+}
diff -Nru Python-2.5.1/Python/ceval.c Python-2.5.1+dtrace/Python/ceval.c
--- Python-2.5.1/Python/ceval.c	2007-04-16 02:19:52.000000000 -0400
+++ Python-2.5.1+dtrace/Python/ceval.c	2007-09-19 22:16:06.040985000 -0400
@@ -19,6 +19,11 @@
 
 #include <ctype.h>
 
+#define HAVE_DTRACE
+#ifdef HAVE_DTRACE
+#include "python.h"
+#endif
+
 #ifndef WITH_TSC
 
 #define READ_TIMESTAMP(var)
@@ -499,6 +504,55 @@
 			  NULL);
 }
 
+#ifdef HAVE_DTRACE
+static void
+dtrace_entry(PyFrameObject *f)
+{
+	const char *filename;
+	const char *fname;
+	int lineno;
+	
+	filename = PyString_AsString(f->f_code->co_filename);
+	fname = PyString_AsString(f->f_code->co_name);
+	lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
+
+	PYTHON_FUNCTION_ENTRY((char *)filename, (char *)fname, lineno);
+
+	/*
+	 * Currently a USDT tail-call will not receive the correct arguments.
+	 * Disable the tail call here.
+	 */
+#if defined(__sparc)
+	asm("nop");
+#endif
+}
+
+static void
+dtrace_return(PyFrameObject *f)
+{
+	const char *filename;
+	const char *fname;
+	int lineno;
+	
+	filename = PyString_AsString(f->f_code->co_filename);
+	fname = PyString_AsString(f->f_code->co_name);
+	lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
+	PYTHON_FUNCTION_RETURN((char *)filename, (char *)fname, lineno);
+
+	/*
+	 * Currently a USDT tail-call will not receive the correct arguments.
+	 * Disable the tail call here.
+	 */
+#if defined(__sparc)
+	asm("nop");
+#endif
+}
+#else
+#define	PYTHON_FUNCTION_ENTRY_ENABLED 0
+#define	PYTHON_FUNCTION_RETURN_ENABLED 0
+#define	dtrace_entry()
+#define	dtrace_return()
+#endif
 
 /* Interpreter main loop */
 
@@ -509,9 +563,84 @@
 	return PyEval_EvalFrameEx(f, 0);
 }
 
+/*
+ * These shenanigans look like utter madness, but what we're actually doing is
+ * making sure that the ustack helper will see the PyFrameObject pointer on the
+ * stack. We have two tricky cases:
+ *
+ * amd64
+ *
+ * We use up the six registers for passing arguments, meaning the call can't
+ * use a register for passing 'f', and has to push it onto the stack in a known
+ * location.
+ *
+ * And how does "throwflag" figure in to this? -PN
+ *
+ * SPARC
+ *
+ * Here the problem is that (on 32-bit) the compiler is re-using %i0 before
+ * some calls inside PyEval_EvalFrameReal(), which means that when it's saved,
+ * it's just some junk value rather than the real first argument. So, instead,
+ * we trace our proxy PyEval_EvalFrame(), where we 'know' the compiler won't
+ * decide to re-use %i0. We also need to defeat optimization of our proxy.
+ */
+
+#if defined(HAVE_DTRACE)
+
+#if defined(__amd64)
+PyObject *PyEval_EvalFrameExReal(long, long, long, long, long, long,
+    PyFrameObject *, int throwflag);
+
+
+
 PyObject *
 PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
 {
+	volatile PyObject *f2;
+	f2 = PyEval_EvalFrameReal(0, 0, 0, 0, 0, 0, f, throwflag);
+	return (PyObject *)f2;
+}
+
+PyObject *
+PyEval_EvalFrameExReal(long a1, long a2, long a3, long a4, long a5, long a6,
+    PyFrameObject *f, int throwflag)
+{
+
+#elif defined(__sparc)
+
+PyObject *PyEval_EvalFrameExReal(PyFrameObject *f, int throwflag);
+
+volatile int dummy;
+
+PyObject *
+PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
+{
+	volatile PyObject *f2;
+	f2 = PyEval_EvalFrameExReal(f, throwflag);
+	dummy = f->ob_refcnt;
+	return (PyObject *)f2;
+}
+
+PyObject *
+PyEval_EvalFrameExReal(PyFrameObject *f, int throwflag)
+{
+
+#else /* __amd64 || __sparc */
+
+PyObject *
+PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
+{
+
+#endif /* __amd64 || __sparc */
+
+#else /* don't HAVE_DTRACE */
+
+PyObject *
+PyEval_EvalFrameexEx(PyFrameObject *f, int throwflag))
+{
+
+#endif /* HAVE_DTRACE */
+
 #ifdef DXPAIRS
 	int lastopcode = 0;
 #endif
@@ -2303,6 +2432,11 @@
 		    } else
 			    Py_INCREF(func);
 		    sp = stack_pointer;
+#ifdef HAVE_DTRACE
+		    f->f_calllineno = PyCode_Addr2Line(f->f_code,
+		                                       f->f_lasti);
+#endif
+
 		    READ_TIMESTAMP(intr0);
 		    x = ext_do_call(func, &sp, flags, na, nk);
 		    READ_TIMESTAMP(intr1);
diff -Nru Python-2.5.1/Python/phelper.d Python-2.5.1+dtrace/Python/phelper.d
--- Python-2.5.1/Python/phelper.d	1969-12-31 19:00:00.000000000 -0500
+++ Python-2.5.1+dtrace/Python/phelper.d	2007-09-19 21:12:36.874777000 -0400
@@ -0,0 +1,137 @@
+
+/*
+ * Python ustack helper.  This relies on the first argument (PyFrame *) being
+ * on the stack; see Python/ceval.c for the contortions we go through to ensure
+ * this is the case.
+ *
+ * On x86, the PyFrame * is two slots up from the frame pointer; on SPARC, it's
+ * eight.
+ */
+
+/*
+ * Yes, this is as gross as it looks. DTrace cannot handle static functions,
+ * and our stat_impl.h has them in ILP32.
+ */
+#define _SYS_STAT_H
+
+#include <stdio.h>
+
+#include "pyport.h"
+#include "object.h"
+#include "pystate.h"
+#include "pythonrun.h"
+#include "compile.h"
+#include "frameobject.h"
+#include "stringobject.h"
+
+#if defined(__i386)
+#define	startframe PyEval_EvalFrame
+#define	endframe PyEval_EvalCodeEx
+#elif defined(__amd64)
+#define	PyEval_EvalFrame PyEval_EvalFrameReal
+#define	startframe PyEval_EvalFrameReal
+#define	endframe PyEval_EvalCodeEx
+#elif defined(__sparc)
+#define	startframe PyEval_EvalFrame
+#define	endframe PyEval_EvalFrameReal
+#endif
+
+#ifdef __sparcv9
+#define	STACK_BIAS (2048-1)
+#else
+#define	STACK_BIAS 0
+#endif
+
+/*
+ * Not defining PHELPER lets us test this code as a normal D script.
+ */
+#ifdef PHELPER
+
+#define	at_evalframe(addr) \
+    ((uintptr_t)addr >= ((uintptr_t)&``startframe) && \
+     (uintptr_t)addr < ((uintptr_t)&``endframe))
+#define	probe dtrace:helper:ustack:
+#define	print_result(r) (r)
+
+#if defined(__i386) || defined(__amd64)
+#define	frame_ptr_addr ((uintptr_t)arg1 + sizeof(uintptr_t) * 2)
+#elif defined(__sparc)
+#define	frame_ptr_addr ((uintptr_t)arg1 + STACK_BIAS + sizeof(uintptr_t) * 8)
+#else
+#error unknown architecture
+#endif
+
+#else /* PHELPER */
+
+#define	at_evalframe(addr) (1)
+#define	probe pid$target::PyEval_EvalFrame:entry
+#define print_result(r) (trace(r))
+
+#if defined(__i386) || defined(__amd64)
+#define	frame_ptr_addr ((uintptr_t)uregs[R_SP] + sizeof(uintptr_t))
+#elif defined(__sparc)
+/*
+ * Not implemented: we could just use R_I0, but what's the point?
+ */
+#else
+#error unknown architecture
+#endif
+
+#endif /* PHELPER */
+
+extern uintptr_t PyEval_EvalFrame;
+extern uintptr_t PyEval_EvalFrameReal;
+extern uintptr_t PyEval_EvalCodeEx;
+
+#define	copyin_obj(addr, obj) ((obj *)copyin((uintptr_t)addr, sizeof(obj)))
+#define	pystr_addr(addr) ((char *)addr + offsetof(PyStringObject, ob_sval))
+#define	copyin_str(dest, addr, obj) \
+    (copyinto((uintptr_t)pystr_addr(addr), obj->ob_size, (dest)))
+#define	add_str(addr, obj) \
+    copyin_str(this->result + this->pos, addr, obj); \
+    this->pos += obj->ob_size; \
+    this->result[this->pos] = '\0';
+#define	add_digit(nr, div) ((nr / div) ? \
+    (this->result[this->pos++] = '0' + ((nr / div) % 10)) : \
+    (this->result[this->pos] = '\0'))
+#define	add_char(c) (this->result[this->pos++] = c)
+
+probe /at_evalframe(arg0)/ 
+{
+	this->framep = *(uintptr_t *)copyin(frame_ptr_addr, sizeof(uintptr_t));
+	this->frameo = copyin_obj(this->framep, PyFrameObject);
+	this->codep = this->frameo->f_code;
+	this->lineno = this->frameo->f_calllineno;
+	this->codeo = copyin_obj(this->codep, PyCodeObject);
+	this->filenamep = this->codeo->co_filename;
+	this->fnamep = this->codeo->co_name;
+	this->filenameo = copyin_obj(this->filenamep, PyStringObject);
+	this->fnameo = copyin_obj(this->fnamep, PyStringObject);
+
+	this->len = 1 + this->filenameo->ob_size + 1 + 5 + 2 +
+	    this->fnameo->ob_size + 1 + 1;
+
+	this->result = (char *)alloca(this->len);
+	this->pos = 0;
+
+	add_char('@');
+	add_str(this->filenamep, this->filenameo);
+	add_char(':');
+	add_digit(this->lineno, 10000);
+	add_digit(this->lineno, 1000);
+	add_digit(this->lineno, 100);
+	add_digit(this->lineno, 10);
+	add_digit(this->lineno, 1);
+	add_char(' ');
+	add_char('(');
+	add_str(this->fnamep, this->fnameo);
+	add_char(')');
+	this->result[this->pos] = '\0';
+
+	print_result(stringof(this->result));
+}
+
+probe /!at_evalframe(arg0)/
+{
+	NULL;
+}
diff -Nru Python-2.5.1/Python/python.d Python-2.5.1+dtrace/Python/python.d
--- Python-2.5.1/Python/python.d	1969-12-31 19:00:00.000000000 -0500
+++ Python-2.5.1+dtrace/Python/python.d	2007-09-19 21:12:36.874963000 -0400
@@ -0,0 +1,10 @@
+provider python {
+	probe function__entry(const char *, const char *, int);
+	probe function__return(const char *, const char *, int);
+};
+
+#pragma D attributes Evolving/Evolving/Common provider python provider
+#pragma D attributes Private/Private/Common provider python module
+#pragma D attributes Private/Private/Common provider python function
+#pragma D attributes Evolving/Evolving/Common provider python name
+#pragma D attributes Evolving/Evolving/Common provider python args
