Add functionality to trace a function within lldb

[serge-sans-paille]

LGTM with respect to Python 2/3 compat, can't tell for the functionality though.

[clayborg]

For this to actually work we need to:

• Disable skipping function prologues using "settings set target.skip-prologue false", set a breakpoint at the function we want to trace and store breakpoint in "trace_breakpoint", restore skipping function prologues
• make a local variable "tracing_function = False"
• when we stop, detect if the "trace_breakpoint" was hit and set "tracing_function = True" if it was. Calculate the the return address using the thread's backtrace and set a breakpoint there, store breakpoint in local variable "trace_return_breakpoint"
• when we continue check "tracing_function" and step if it is true, and continue it not
• When we stop check if "trace_return_breakpoint" was hit and if so, set "tracing_function = False"

examples/python/process_events.py

         '-t',
         '--event-timeout',
         type='int',
         dest='event_timeout',
         metavar='SEC',
         help='Specify the timeout in seconds to wait for process state change events.',
         default=lldb.UINT32_MAX)
     parser.add_option(
+        '-f',
+        '--trace-function',
+        type='string',
+        dest='trace_function',
+        help='Trace a function during execution, Warning: tracing is really slow.')
+    parser.add_option(
         '-e',
         '--environment',
         action='append',
         type='string',
         metavar='ENV',
         dest='env_vars',
         help='Environment variables to set in the inferior process when launching a process.')
     parser.add_option(

 
         # Set any breakpoints that were specified in the args if we are launching. We use the
         # command line command to take advantage of the shorthand breakpoint
         # creation
         if launch_info and options.breakpoints:
             for bp in options.breakpoints:
                 debugger.HandleCommand("_regexp-break %s" % (bp))
             run_commands(command_interpreter, ['breakpoint list'])
+        if launch_info and options.trace_function:
+            debugger.HandleCommand("_regexp-break &%s" % (options.trace_function))
+            run_commands(command_interpreter, ['breakpoint list'])
 
         for run_idx in range(options.run_count):
             # Launch the process. Since we specified synchronous mode, we won't return
             # from this function until we hit the breakpoint at main
             error = lldb.SBError()
 
             if launch_info:
                 if options.run_count == 1:

                                     else:
                                         if options.verbose:
                                             print "process %u stopped" % (pid)
                                         run_commands(
                                             command_interpreter, options.stop_commands)
                                     stop_idx += 1
                                     print_threads(process, options)
                                     print "continuing process %u" % (pid)
-                                    process.Continue()
+                                    if options.trace_function:
+                                        process.GetThreadAtIndex(0).StepInto()
+                                    else:
+                                        process.Continue()
                                 elif state == lldb.eStateExited:
                                     exit_desc = process.GetExitDescription()
                                     if exit_desc:
                                         print "process %u exited with status %u: %s" % (pid, process.GetExitStatus(), exit_desc)
                                     else:
                                         print "process %u exited with status %u" % (pid, process.GetExitStatus())
                                     run_commands(
                                         command_interpreter, options.exit_commands)