Introduction

not

(lldb) script
+Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
+>>> 2+3
+5
+>>> hex(12345)
+'0x3039'
+>>> 
+
(lldb) script
+Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
+>>> print lldb.debugger
+Debugger (instance: "debugger_1", id: 1)
+>>> print lldb.target
+a.out
+>>> print lldb.process
+SBProcess: pid = 59289, state = stopped, threads = 1, executable = a.out
+>>> print lldb.thread
+SBThread: tid = 0x1f03
+>>> print lldb.frame
+frame #0: 0x0000000100000bb6 a.out main + 54 at main.c:16
+
def breakpoint_function(frame, bp_loc):
+  # Your code goes here
+
(lldb) breakpoint set --func-regex=. --shlib=libfoo.dylib
+Breakpoint created: 1: regex = '.', module = libfoo.dylib, locations = 223
+(lldb) breakpoint command add --script-type python 1
+Enter your Python command(s). Type 'DONE' to end.
+> # Get the hit count of the main breakpoint
+> hit_count = bp_loc.GetBreakpoint().GetHitCount()
+> # Get the name of the function
+> name = frame.GetFunctionName()
+> # Print the order and the function name
+> print '[%i] %s' % (hit_count, name)
+> # Disable the current breakpoint location so it doesn't get hit again
+> bp_loc.SetEnabled(False)
+> # How continue the process
+> frame.GetThread().GetProcess().Continue()
+> DONE
+
def command_function(debugger, command, result, dict):
+          # Your code goes here
+        
#!/usr/bin/python
+
+import lldb
+import commands
+import optparse
+import shlex
+
+def ls(debugger, command, result, dict):
+    print commands.getoutput('/bin/ls %s' % command)
+
+# Any code that isn't in a function in python gets run when the module is loaded
+if lldb.debugger:
+    # This script is being run from LLDB in the emabedded command interpreter
+    # lets register the 'ls' command with the command interpreter automatically!
+    lldb.debugger.HandleCommand('command script add -f ls.ls ls')
+    print 'The "ls" python command has been installed and is ready for use.'
+
% lldb
+(lldb) script import ls
+The "ls" python command has been installed and is ready for use.
+(lldb) ls -l /tmp/
+total 365848
+-rw-r--r--@  1 someuser  wheel         6148 Jan 19 17:27 .DS_Store
+-rw-------   1 someuser  wheel         7331 Jan 19 15:37 crash.log
+
#!/usr/bin/python
+
+import lldb
+
+# Set the path to the executable to debug
+exe = "./a.out"
+
+# Create a new debugger instance
+debugger = lldb.SBDebugger.Create()
+
+# When we step or continue, don't return from the function until the process 
+# stops. We do this by setting the async mode to false.
+debugger.SetAsync (False)
+
+# Create a target from a file and arch
+print "Creating a target for '%s'" % exe
+
+target = debugger.CreateTargetWithFileAndArch (exe, lldb.LLDB_ARCH_DEFAULT)
+
+if target:
+    # If the target is valid set a breakpoint at main
+    main_bp = target.BreakpointCreateByName ("main", target.GetExecutable().GetFilename());
+
+    print main_bp
+
+    # Launch the process. Since we specified synchronous mode, we won't return
+    # from this function until we hit the breakpoint at main
+    process = target.LaunchSimple (None, None, os.getcwd())
+    
+    # Make sure the launch went ok
+    if process:
+        # Print some simple process info
+        state = process.GetState ()
+        print process
+        if state == lldb.eStateStopped:
+        # Get the first thread
+        thread = process.GetThreadAtIndex (0)
+        if thread:
+            # Print some simple thread info
+            print thread
+            # Get the first frame
+            frame = thread.GetFrameAtIndex (0)
+            if frame:
+                # Print some simple frame info
+                print frame
+                function = frame.GetFunction()
+                # See if we have debug info (a function)
+                if function:
+                    # We do have a function, print some info for the function
+                    print function
+                    # Now get all instructions for this function and print them
+                    insts = function.GetInstructions(target)
+                    disassemble_instructions (insts)
+                else:
+                    # See if we have a symbol in the symbol table for where we stopped
+                    symbol = frame.GetSymbol();
+                    if symbol:
+                        # We do have a symbol, print some info for the symbol
+                        print symbol
+

Variable	Type	Description
+ lldb.debugger +	+ lldb.SBDebugger +	+ A module global variable containing the current debugger object. + The type is a lldb.SBDebugger object and it contains a reference to the debegger + object that owns the command interpreter and all targets in your debug session. +
+ lldb.target +	+ lldb.SBTarget +	+ A module global variable containing the currently selected target. + The type is a lldb.SBTarget object and the object will only be valid if there is a current target. + The target select <target-index> commmand can be used to change the + currently selected target. +
+ lldb.process +	+ lldb.SBProcess +	+ A module global variable containing the current process. + The type is a lldb.SBProcess object and the object will only be + valid if there is a current target and that target has a process. +
+ lldb.thread +	+ lldb.SBThread +	+ A module global variable containing the current thread. + The type is a lldb.SBThread object and the object will only be valid if + the process has threads, and if the process has a thread selected. + A thread is always selected in the command interpreter when a target stops. + The thread select <thread-index> commmand can be used to change the + currently selected thread. +
+ lldb.frame +	+ lldb.SBFrame +	+ A module global variable containing the current stack frame. + The type is a lldb.SBFrame object and the object will only be valid if + the thread is stopped and has a frame selected. + A stack frame is always selected in the command interpreter when a target stops. + The frame select <frame-index> commmand can be used to change the + currently selected thread. +

Argument	Type	Description
+ frame +	+ lldb.SBFrame +	+ The current stack frame where the breakpoint got hit. + The type is a lldb.SBFrame object and the object will always be valid. + This frame argument might not match the currently selected stack frame found in the lldb module global variable lldb.frame. +
+ bp_loc +	+ lldb.SBBreakpointLocation +	+ The breakpoint location that just got hit. Breakpoints are represented by lldb.SBBreakpoint + objects. These breakpoint objects can have one or more locations. These locations + are represented by lldb.SBBreakpointLocation objects. +

Argument	Type	Description
+ debugger +	+ lldb.SBDebugger +	+ The current debugger object. +
+ command +	+ python string +	+ A python string containing all arguments for your command. If you need to chop up the arguments + try using the shlex module's `shlex.split(command)` to properly extract the + arguments. +
+ result +	+ lldb.SBCommandReturnObject +	+ A return object where you can indicate the success or failure of your command. You can also + provide information for the command result by printing data into it. You can also just print + data as you normally would in a python script and the outout will show up. +
+ dict +	+ python dict object +	+ The dictionary for the current embedded script session which contains all variables + and functions. +

Introduction

Embedded Python Interpreter

Running a Python script when a breakpoint gets hit

Create a new LLDB command using a python function

Using the lldb.py module in python