These are roughly priortized by bang; they probably should be
prioritized by bang/hour. :)

- Kernel module support.  Perhaps GDB could treat these like shared
  libraries.  What about the case where one sets a tracepoint, but
  then the module is unloaded --- all gtp.ko has is an address, so it
  can't tell anything's wrong.

- Conditional tracepoints.

- Do tracepoints work in interrupt handlers?  Or at least some
  interrupt handlers?  If so, the docs should advertise this.

- Selecting a new tracepoint hit doesn't always seem to announce a new
  source location in a way that GDB-mode notices, so Emacs doesn't
  always pop up the right sources.

- Make logging of GDB packets via printk a module parameter, default
  off.  (Would this mean that one could change it dynamically via
  /sys/modules?)

- String access function in GDB?  If you've got char *X, then
  $string(X) would log the contents of the string X refers to,
  stopping at the null.

- User-mode access function in GDB?  That is, if we have T __user *X,
  then perhaps $user(X) would log the contents of *X from the user's
  process?  Could $string($user(X)) copy a string from userspace?

- A 'collect' item $stack, like $args or $locals, that just grabs a
  bunch of stuff at the top of the stack (in an
  architecture-independent way)

- GDB should indicate the currently selected tracepoint somehow.

- tracepoint.c (finish_tfind_command) should compare frame ID's, not
  functions and frame pointers, to decide how to report the new
  position.

- Step count support --- this is probably the easiest way (although
  not the most efficient) to be able to step backwards and forwards
  through a region of code.  We're using kprobes for our "execution
  control"; I have the feeling that's where it would make sense to add
  it.

- Measure tracepoint hit overhead.  Get code from SystemTap?

- Eclipse CDT integration?

- Replace procfs interface with sysfs/kobject interface.

- Allow multiple, independent tracing sessions simultaneously.
  (kprobes handles multiple probes at the same address already, so
  this is just moving all the module's variables into a dynamically
  allocated data structure.  I think the sysfs conversion should
  happen first.)

- Re-indent from GNU style to Linux kernel style, and submit for
  inclusion in the kernel.

- Have GCC record the __user type qualifier in DWARF, and then have
  GDB use it to properly display __user values.

- Make hit log size a module parameter.  Actually, it would be even 
  better to be able to vary this dynamically from GDB.

- Make $locals not die if some variable isn't available; just warn,
  and ignore them.

- Specifying actions in GDB shouldn't be a separate "mode."

- Support expressions whose size we can't compute ahead of time.

- In the absence of step count support, at least properly ignore all
  stepping actions, in QTDP:- packets following the one with the 'S'.

- Document in GDB manual that a QTDP: pass count of zero means
  unlimited passes.

- In GDB, don't pass packets directly through frome tracepoint.c.
  Instead, have tracepoint.c pass data structures to target entries,
  and make remote.c or linux-trace.c responsible for formatting the
  data into packets of whatever form.

- Fix lib/vsprintf.c's vsscanf's handling of %n at end of string; remove
  '$' cruft in gdb.c.

- The register model is oversimplified.  We assume we can always log
  all registers --- what about floating-point registers?  SSE
  registers?  Special-purpose hardware registers?  And what about
  registers where values get packed into them in weird ways, like Cell
  SPE registers?

- Ports to other architectures.