Diff 553711

lldb/docs/_static/lldb.css

This file was deleted.

	pre {
	padding: 7px;
	}

	div.document {
	width: 90%;
	}

	div.body {
	max-width: 90%;
	}

	div.note {
	padding: 20px 20px 10px 20px;
	}

	div.note p.admonition-title {
	font-size: 130%;
	}

	table.mapping {
	width: 100%;
	}

	table.mapping td {
	width: 50%;
	padding: 5px;
	}

	table.mapping td.hed {
	background: #606060;
	color: #fefefe;
	text-align: left;
	border-bottom: 2px #fefefe solid;
	font-weight: bold;
	}

	table.mapping td.header {
	background: #eeeeee;
	}

	table.mapping td.content {
	font-family: monospace;
	padding-bottom: 15px;
	}

	/* Workaround for a Safari bug that would otherwise make table cells less wide
	than the containing text. This just sets it back to the default browser
	property.*/
	td {
	-webkit-hyphens: manual !important;
	}

	div.sphinxsidebar .caption {
	font-family: Helvetica, Verdana, sans-serif;
	font-size: 10pt;
	font-weight: bold;
	color: #fefefe;
	background: #606060;
	margin-bottom: 0;
	text-transform: uppercase;
	padding: 7px;
	}

	div.sphinxsidebar a,
	div.sphinxsidebar a:hover {
	border: none;
	}

	div.sphinxsidebar li {
	padding-left: 7px;
	border-bottom: 1px solid #fefefe;
	}

	div.sphinxsidebar li:hover {
	background: #eeeeee;
	}

	div.sphinxsidebar ul {
	background: #e9e9e9;
	margin: 0px;
	padding: 0px;
	}

	div.sphinxsidebar ul a {
	font-family: Helvetica, Verdana, sans-serif;
	font-size: 8pt;
	display: block;
	padding: 5px 0;
	line-height: 14pt;
	}

	div.sphinxsidebar ul li.toctree-l1 > a {
	font-size: 100%;
	}

	div.sphinxsidebar h3 {
	/* Hide Navigation. */
	display: none;
	}

lldb/docs/conf.py

	Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines

	autodoc_default_options = {			autodoc_default_options = {
	"special-members": "__int__, __len__, __hex__, __oct__, __iter__",			"special-members": "__int__, __len__, __hex__, __oct__, __iter__",
	}			}

	# Unless we only generate the basic manpage we need the plugin for generating			# Unless we only generate the basic manpage we need the plugin for generating
	# the Python API documentation.			# the Python API documentation.
	if not building_man_page:			if not building_man_page:
	try:			try:
	import sphinx_automodapi.automodapi			import sphinx_automodapi.automodapi
	except ModuleNotFoundError:			except ModuleNotFoundError:
	print(			print(
	f"install sphinx_automodapi with {sys.executable} -m pip install sphinx_automodapi"			f"install sphinx_automodapi with {sys.executable} -m pip install sphinx_automodapi"
	)			)
				JDevlieghereUnsubmitted Done Reply Inline Actions We should do something similar for the `furo` theme. JDevlieghere: We should do something similar for the `furo` theme.
	extensions.append("sphinx_automodapi.automodapi")			extensions.append("sphinx_automodapi.automodapi")

				try:
				import furo
				except ModuleNotFoundError:
				print(
				f"install sphinx furo theme with {sys.executable} -m pip install furo"
				)
				# The theme to use for HTML and HTML Help pages. See the documentation for
				# a list of builtin themes.
				html_theme = "furo"

	# Add any paths that contain templates here, relative to this directory.			# Add any paths that contain templates here, relative to this directory.
	templates_path = ["_templates"]			templates_path = ["_templates"]

	# The suffix of source filenames.			# The suffix of source filenames.
	source_suffix = {			source_suffix = {
	".rst": "restructuredtext",			".rst": "restructuredtext",
	}			}

	▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
	# A list of ignored prefixes for module index sorting.			# A list of ignored prefixes for module index sorting.
	# modindex_common_prefix = []			# modindex_common_prefix = []


	# -- Options for HTML output ---------------------------------------------------			# -- Options for HTML output ---------------------------------------------------

	# The theme to use for HTML and HTML Help pages. See the documentation for			# The theme to use for HTML and HTML Help pages. See the documentation for
	# a list of builtin themes.			# a list of builtin themes.
	html_theme = "alabaster"			html_theme = "furo"

	# Theme options are theme-specific and customize the look and feel of a theme			# Theme options are theme-specific and customize the look and feel of a theme
	# further. For a list of options available for each theme, see the			# further. For a list of options available for each theme, see the
	# documentation.			# documentation.
	html_theme_options = {			html_theme_options = {}
	"font_size": "11pt",
	# Don't generate any links to GitHub.
	"github_button": "false",
	}

	# Add any paths that contain custom themes here, relative to this directory.			# Add any paths that contain custom themes here, relative to this directory.
	# html_theme_path = []			# html_theme_path = []

	# The name for this set of Sphinx documents. If None, it defaults to			# The name for this set of Sphinx documents. If None, it defaults to
	# "<project> v<release> documentation".			# "<project> v<release> documentation".
	html_title = "The LLDB Debugger"			html_title = "🐛 LLDB"

	# A shorter title for the navigation bar. Default is the same as html_title.			# A shorter title for the navigation bar. Default is the same as html_title.
	# html_short_title = None			# html_short_title = None

	# The name of an image file (relative to this directory) to place at the top			# The name of an image file (relative to this directory) to place at the top
	# of the sidebar.			# of the sidebar.
	# html_logo = None			# html_logo = None

	# The name of an image file (within the static path) to use as favicon of the			# The name of an image file (within the static path) to use as favicon of the
	# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32			# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
	# pixels large.			# pixels large.
	# html_favicon = None			# html_favicon = None

	# Add any paths that contain custom static files (such as style sheets) here,			# Add any paths that contain custom static files (such as style sheets) here,
	# relative to this directory. They are copied after the builtin static files,			# relative to this directory. They are copied after the builtin static files,
	# so a file named "default.css" will overwrite the builtin "default.css".			# so a file named "default.css" will overwrite the builtin "default.css".
	html_static_path = ["_static"]			html_static_path = ["_static"]

	html_context = {
	"css_files": ["_static/lldb.css"],
	}

	html_extra_path = [".htaccess"]			html_extra_path = [".htaccess"]

	# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,			# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
	# using the given strftime format.			# using the given strftime format.
	html_last_updated_fmt = "%b %d, %Y"			html_last_updated_fmt = "%b %d, %Y"

	# If true, SmartyPants will be used to convert quotes and dashes to			# If true, SmartyPants will be used to convert quotes and dashes to
	# typographically correct entities.			# typographically correct entities.
	▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

lldb/docs/resources/build.rst

	Building			Building
	========			========

	.. contents::
	:local:

	Getting the Sources			Getting the Sources
	-------------------			-------------------

	Please refer to the `LLVM Getting Started Guide			Please refer to the `LLVM Getting Started Guide
	<https://llvm.org/docs/GettingStarted.html#getting-started-with-llvm>`_ for			<https://llvm.org/docs/GettingStarted.html#getting-started-with-llvm>`_ for
	general instructions on how to check out the LLVM monorepo, which contains the			general instructions on how to check out the LLVM monorepo, which contains the
	LLDB sources.			LLDB sources.

	▲ Show 20 Lines • Show All 637 Lines • Show Last 20 Lines

lldb/docs/resources/caveats.rst

	Caveats			Caveats
	=======			=======

	.. contents::
	:local:

	.. _python_caveat:			.. _python_caveat:

	Python			Python
	------			------

	LLDB has a powerful scripting interface which is accessible through Python.			LLDB has a powerful scripting interface which is accessible through Python.
	Python is available either from within LLDB through a (interactive) script			Python is available either from within LLDB through a (interactive) script
	interpreter, or as a Python module which you can import from the Python			interpreter, or as a Python module which you can import from the Python
	▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

lldb/docs/resources/overview.rst

	Overview			Overview
	========			========

	LLDB is a large and complex codebase. This section will help you become more			LLDB is a large and complex codebase. This section will help you become more
	familiar with the pieces that make up LLDB and give a general overview of the			familiar with the pieces that make up LLDB and give a general overview of the
	general architecture.			general architecture.

	LLDB has many code groupings that makeup the source base:			LLDB has many code groupings that makeup the source base:

	.. contents::
	:local:

	API			API
	---			---

	The API folder contains the public interface to LLDB.			The API folder contains the public interface to LLDB.

	We are currently vending a C++ API. In order to be able to add methods to this			We are currently vending a C++ API. In order to be able to add methods to this
	API and allow people to link to our classes, we have certain rules that we must			API and allow people to link to our classes, we have certain rules that we must
	follow:			follow:
	▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

lldb/docs/resources/projects.rst

	Open Projects			Open Projects
	=============			=============

	The following is a mostly unordered set of the ideas for improvements to the			The following is a mostly unordered set of the ideas for improvements to the
	LLDB debugger. Some are fairly deep, some would require less effort.			LLDB debugger. Some are fairly deep, some would require less effort.

	.. contents::
	:local:

	Speed up type realization in lldb			Speed up type realization in lldb
	---------------------------------			---------------------------------

	The type of problem I'm addressing here is the situation where you are			The type of problem I'm addressing here is the situation where you are
	debugging a large program (lldb built with debug clang/swift will do) and you			debugging a large program (lldb built with debug clang/swift will do) and you
	go to print a simple expression, and lldb goes away for 30 seconds. When you			go to print a simple expression, and lldb goes away for 30 seconds. When you
	sample it, it is always busily churning through all the CU's in the world			sample it, it is always busily churning through all the CU's in the world
	looking for something. The problem isn't that looking for something in			looking for something. The problem isn't that looking for something in
	▲ Show 20 Lines • Show All 402 Lines • Show Last 20 Lines

lldb/docs/resources/test.rst

	Testing			Testing
	=======			=======

	.. contents::
	:local:

	Test Suite Structure			Test Suite Structure
	--------------------			--------------------

	The LLDB test suite consists of three different kinds of test:			The LLDB test suite consists of three different kinds of test:

	* Unit tests: written in C++ using the googletest unit testing library.			* Unit tests: written in C++ using the googletest unit testing library.
	* Shell tests: Integration tests that test the debugger through the command			* Shell tests: Integration tests that test the debugger through the command
	line. These tests interact with the debugger either through the command line			line. These tests interact with the debugger either through the command line
	▲ Show 20 Lines • Show All 654 Lines • Show Last 20 Lines

lldb/docs/use/formatting.rst

	Frame and Thread Format			Frame and Thread Format
	=======================			=======================

	.. contents::
	:local:

	LLDB has a facility to allow users to define the format of the information that			LLDB has a facility to allow users to define the format of the information that
	generates the descriptions for threads and stack frames. Typically when your			generates the descriptions for threads and stack frames. Typically when your
	program stops at a breakpoint you will get two lines that describes why your			program stops at a breakpoint you will get two lines that describes why your
	thread stopped and where:			thread stopped and where:

	::			::

	* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1			* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
	▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

lldb/docs/use/intel_pt.rst

	Tracing with Intel Processor Trace			Tracing with Intel Processor Trace
	==================================			==================================

	.. contents::
	:local:

	Intel PT is a technology available in modern Intel CPUs that allows efficient			Intel PT is a technology available in modern Intel CPUs that allows efficient
	tracing of all the instructions executed by a process.			tracing of all the instructions executed by a process.
	LLDB can collect traces and dump them using its symbolication stack.			LLDB can collect traces and dump them using its symbolication stack.
	You can read more here			You can read more here
	https://easyperf.net/blog/2019/08/23/Intel-Processor-Trace.			https://easyperf.net/blog/2019/08/23/Intel-Processor-Trace.

	Prerequisites			Prerequisites
	-------------			-------------
	▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

lldb/docs/use/map.rst

	GDB to LLDB command map			GDB to LLDB command map
	=======================			=======================

	Below is a table of GDB commands with their LLDB counterparts. The built in			Below is a table of GDB commands with their LLDB counterparts. The built in
	GDB-compatibility aliases in LLDB are also listed. The full lldb command names			GDB-compatibility aliases in LLDB are also listed. The full lldb command names
	are often long, but any unique short form can be used. Instead of "**breakpoint			are often long, but any unique short form can be used. Instead of "**breakpoint
	set", "br se**" is also acceptable.			set", "br se**" is also acceptable.

	.. contents::
	:local:

	Execution Commands			Execution Commands
	------------------			------------------

	.. raw:: html			Launch a process no arguments
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) run
				(gdb) r

				.. code-block:: shell

				(lldb) process launch
				(lldb) run
				(lldb) r

				Launch a process with arguments ``<args>``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) run <args>
				(gdb) r <args>


				.. code-block:: shell

				(lldb) process launch -- <args>
				(lldb) run <args>
				(lldb) r <args>

				Launch process ``a.out`` with arguments ``1 2 3`` by passing the args to the debugger
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				% gdb --args a.out 1 2 3
				(gdb) run
				...
				(gdb) run
				...

				.. code-block:: shell

				% lldb -- a.out 1 2 3
				(lldb) run
				...
				(lldb) run
				...


				Launch process a.out with arguments ``1 2 3`` by setting the args in the debugger
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) set args 1 2 3
				(gdb) run
				...
				(gdb) run
				...

				.. code-block:: shell

				(lldb) settings set target.run-args 1 2 3
				(lldb) run
				...
				(lldb) run
				...

				Launch a process with arguments in new terminal window (macOS only)
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) process launch --tty -- <args>
				(lldb) pro la -t -- <args>

				Launch a process with arguments ``<args>`` in existing terminal ``/dev/ttys006``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) process launch --tty=/dev/ttys006 -- <args>
				(lldb) pro la -t/dev/ttys006 -- <args>


				Set environment variables for process before launching
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) set env DEBUG 1

				.. code-block:: shell

				(lldb) settings set target.env-vars DEBUG=1
				(lldb) set se target.env-vars DEBUG=1
				(lldb) env DEBUG=1


				Unset environment variables for process before launching
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) unset env DEBUG

				.. code-block:: shell

				(lldb) settings remove target.env-vars DEBUG
				(lldb) set rem target.env-vars DEBUG

				Show the arguments that will be or were passed to the program when run
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) show args
				Argument list to give program being debugged when it is started is "1 2 3".

				.. code-block:: shell

				(lldb) settings show target.run-args
				target.run-args (array of strings) =
				[0]: "1"
				[1]: "2"
				[2]: "3"

				Set environment variables for process and launch process in one command
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) process launch -E DEBUG=1

				Attach to the process with process ID 123
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) attach 123

				.. code-block:: shell

				(lldb) process attach --pid 123
				(lldb) attach -p 123

				Attach to the process named ``a.out``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) attach a.out

				.. code-block:: shell

				(lldb) process attach --name a.out
				(lldb) pro at -n a.out

				Wait for a process named ``a.out`` to launch and attach
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) attach -waitfor a.out

				.. code-block:: shell

				(lldb) process attach --name a.out --waitfor
				(lldb) pro at -n a.out -w

				Attach to a remote gdb protocol server running on system ``eorgadd``, port ``8000``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	<table class="mapping" cellspacing="0">			.. code-block:: shell
	<tbody>
	<tr>
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Launch a process no arguments.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> run
	<br>
	<b>(gdb)</b> r
	</td>
	<td class="content">
	<b>(lldb)</b> process launch
	<br>
	<b>(lldb)</b> run
	<br>
	<b>(lldb)</b> r
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Launch a process with arguments <code><args></code>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> run <args>
	<br>
	<b>(gdb)</b> r <args>
	</td>
	<td class="content">
	<b>(lldb)</b> process launch -- <args>
	<br>
	<b>(lldb)</b> run <args>
	<br>
	<b>(lldb)</b> r <args>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Launch process <b><code>a.out</code></b> with arguments <b><code>1 2 3</code></b> without having to supply the args every time.</td>
	</tr>
	<tr>
	<td class="content">
	<b>%</b> gdb --args a.out 1 2 3
	<br>
	<b>(gdb)</b> run
	<br> ...
	<br>
	<b>(gdb)</b> run
	<br> ...
	<br>
	</td>
	<td class="content">
	<b>%</b> lldb -- a.out 1 2 3
	<br>
	<b>(lldb)</b> run
	<br> ...
	<br>
	<b>(lldb)</b> run
	<br> ...
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Or:</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set args 1 2 3
	<br>
	<b>(gdb)</b> run
	<br> ...
	<br>
	<b>(gdb)</b> run
	<br> ...
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> settings set target.run-args 1 2 3
	<br>
	<b>(lldb)</b> run
	<br> ...
	<br>
	<b>(lldb)</b> run
	<br> ...
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Launch a process with arguments in new terminal window (macOS only).</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> process launch --tty -- <args>
	<br>
	<b>(lldb)</b> pro la -t -- <args>
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Launch a process with arguments <code><args></code> in existing terminal <code>/dev/ttys006</code> (macOS only).</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> process launch --tty=/dev/ttys006 -- <args>
	<br>
	<b>(lldb)</b> pro la -t/dev/ttys006 -- <args>
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set environment variables for process before launching.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set env DEBUG 1
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> settings set target.env-vars DEBUG=1
	<br>
	<b>(lldb)</b> set se target.env-vars DEBUG=1
	<br>
	<b>(lldb)</b> env DEBUG=1
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Unset environment variables for process before launching.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> unset env DEBUG
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> settings remove target.env-vars DEBUG
	<br>
	<b>(lldb)</b> set rem target.env-vars DEBUG
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the arguments that will be or were passed to the program when run.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> show args
	<br> Argument list to give program being debugged when it is started is "1 2 3".
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> settings show target.run-args
	<br> target.run-args (array of strings) =
	<br> [0]: "1"
	<br> [1]: "2"
	<br> [2]: "3"
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set environment variables for process and launch process in one command.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> process launch -E DEBUG=1
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Attach to the process with process ID 123.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> attach 123
	</td>
	<td class="content">
	<b>(lldb)</b> process attach --pid 123
	<br>
	<b>(lldb)</b> attach -p 123
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Attach to the process named "a.out".</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> attach a.out
	</td>
	<td class="content">
	<b>(lldb)</b> process attach --name a.out
	<br>
	<b>(lldb)</b> pro at -n a.out
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Wait for a process named "a.out" to launch and attach.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> attach -waitfor a.out
	</td>
	<td class="content">
	<b>(lldb)</b> process attach --name a.out --waitfor
	<br>
	<b>(lldb)</b> pro at -n a.out -w
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Attach to a remote gdb protocol server running on system "eorgadd", port 8000.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> target remote eorgadd:8000
	</td>
	<td class="content">
	<b>(lldb)</b> gdb-remote eorgadd:8000
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Attach to a remote gdb protocol server running on the local system, port 8000.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> target remote localhost:8000
	</td>
	<td class="content">
	<b>(lldb)</b> gdb-remote 8000
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Attach to a Darwin kernel in kdp mode on system "eorgadd".</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> kdp-reattach eorgadd
	</td>
	<td class="content">
	<b>(lldb)</b> kdp-remote eorgadd
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Do a source level single step in the currently selected thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> step
	<br>
	<b>(gdb)</b> s
	</td>
	<td class="content">
	<b>(lldb)</b> thread step-in
	<br>
	<b>(lldb)</b> step
	<br>
	<b>(lldb)</b> s
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Do a source level single step over in the currently selected thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> next
	<br>
	<b>(gdb)</b> n
	</td>
	<td class="content">
	<b>(lldb)</b> thread step-over
	<br>
	<b>(lldb)</b> next
	<br>
	<b>(lldb)</b> n
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Do an instruction level single step in the currently selected thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> stepi
	<br>
	<b>(gdb)</b> si
	</td>
	<td class="content">
	<b>(lldb)</b> thread step-inst
	<br>
	<b>(lldb)</b> si
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Do an instruction level single step over in the currently selected thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> nexti
	<br>
	<b>(gdb)</b> ni
	</td>
	<td class="content">
	<b>(lldb)</b> thread step-inst-over
	<br>
	<b>(lldb)</b> ni
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Step out of the currently selected frame.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> finish
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> thread step-out
	<br>
	<b>(lldb)</b> finish
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Return immediately from the currently selected frame, with an optional return value.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> return <RETURN EXPRESSION>
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> thread return <RETURN EXPRESSION>
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Backtrace and disassemble every time you stop.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> target stop-hook add
	<br> Enter your stop hook command(s). Type 'DONE' to end.
	<br> > bt
	<br> > disassemble --pc
	<br> > DONE
	<br> Stop hook #1 added.
	<br>
	</td>
	</tr>
	<tr>
	<td class="header" colspan="2">Run until we hit line <b>12</b> or control leaves the current function.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> until 12
	</td>
	<td class="content">
	<b>(lldb)</b> thread until 12
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the current frame and source line.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> frame
	</td>
	<td class="content">
	<b>(lldb)</b> frame select
	<br>
	<b>(lldb)</b> f
	<br>
	<b>(lldb)</b> process status
	</td>
	</tr>

	</tbody>			(gdb) target remote eorgadd:8000
	</table>

				.. code-block:: shell

				(lldb) gdb-remote eorgadd:8000

				Attach to a remote gdb protocol server running on the local system, port ``8000``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) target remote localhost:8000

				.. code-block:: shell

				(lldb) gdb-remote 8000

				Attach to a Darwin kernel in kdp mode on system ``eorgadd``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) kdp-reattach eorgadd

				.. code-block:: shell

				(lldb) kdp-remote eorgadd

				Do a source level single step in the currently selected thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) step
				(gdb) s

				.. code-block:: shell

				(lldb) thread step-in
				(lldb) step
				(lldb) s

				Do a source level single step over in the currently selected thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) next
				(gdb) n

				.. code-block:: shell

				(lldb) thread step-over
				(lldb) next
				(lldb) n

				Do an instruction level single step in the currently selected thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) stepi
				(gdb) si

				.. code-block:: shell

				(lldb) thread step-inst
				(lldb) si

				Do an instruction level single step over in the currently selected thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) nexti
				(gdb) ni

				.. code-block:: shell

				(lldb) thread step-inst-over
				(lldb) ni

				Step out of the currently selected frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) finish

				.. code-block:: shell

				(lldb) thread step-out
				(lldb) finish

				Return immediately from the currently selected frame, with an optional return value
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) return <RETURN EXPRESSION>

				.. code-block:: shell

				(lldb) thread return <RETURN EXPRESSION>

				Backtrace and disassemble every time you stop
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) target stop-hook add
				Enter your stop hook command(s). Type 'DONE' to end.
				> bt
				> disassemble --pc
				> DONE
				Stop hook #1 added.

				Run until we hit line 12 or control leaves the current function
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) until 12

				.. code-block:: shell

				(lldb) thread until 12

				Show the current frame and source line
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) frame

				.. code-block:: shell

				(lldb) frame select
				(lldb) f
				(lldb) process status

	Breakpoint Commands			Breakpoint Commands
	-------------------			-------------------

	.. raw:: html			Set a breakpoint at all functions named main
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) break main

				.. code-block:: shell

				(lldb) breakpoint set --name main
				(lldb) br s -n main
				(lldb) b main

				Set a breakpoint in file ``test.c`` at line ``12``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) break test.c:12

				.. code-block:: shell

				(lldb) breakpoint set --file test.c --line 12
				(lldb) br s -f test.c -l 12
				(lldb) b test.c:12

				Set a breakpoint at all C++ methods whose basename is ``main``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	<table class="mapping" cellspacing="0">			.. code-block:: shell
	<tbody>
	<tr>
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a breakpoint at all functions named <b><code>main</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> break main
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --name main
	<br>
	<b>(lldb)</b> br s -n main
	<br>
	<b>(lldb)</b> b main
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a breakpoint in file <b><code>test.c</code></b> at line <b>12</b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> break test.c:12
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --file test.c --line 12
	<br>
	<b>(lldb)</b> br s -f test.c -l 12
	<br>
	<b>(lldb)</b> b test.c:12
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a breakpoint at all C++ methods whose basename is <b><code>main</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> break main
	<br>
	<i>(Hope that there are no C functions named <b>main</b>)</i>.
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --method main
	<br>
	<b>(lldb)</b> br s -M main
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a breakpoint at an Objective-C function <b><code>-[NSString stringWithFormat:]</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> break -[NSString stringWithFormat:]
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --name "-[NSString stringWithFormat:]"
	<br>
	<b>(lldb)</b> b -[NSString stringWithFormat:]
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a breakpoint at all Objective-C methods whose selector is <b><code>count</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> break count
	<br>
	<i>(Hope that there are no C or C++ functions named <b>count</b>)</i>.
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --selector count
	<br>
	<b>(lldb)</b> br s -S count
	<br>
	</td>
	</tr>
	<tr>
	<td class="header" colspan="2">Set a breakpoint by regular expression on function name.</td>
	</tr>

	<tr>
	<td class="content">
	<b>(gdb)</b> rbreak regular-expression
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --func-regex regular-expression
	<br>
	<b>(lldb)</b> br s -r regular-expression
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Ensure that breakpoints by file and line work for <code>#include</code> .c/.cpp/.m files.</td>
	</tr>

	<tr>
	<td class="content">
	<b>(gdb)</b> b foo.c:12
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> settings set target.inline-breakpoint-strategy always
	<br>
	<b>(lldb)</b> br s -f foo.c -l 12
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a breakpoint by regular expression on source file contents.</td>
	</tr>

	<tr>
	<td class="content">
	<b>(gdb)</b> shell grep -e -n pattern source-file
	<br>
	<b>(gdb)</b> break source-file:CopyLineNumbers
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --source-pattern regular-expression --file SourceFile
	<br>
	<b>(lldb)</b> br s -p regular-expression -f file
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a conditional breakpoint.</td>
	</tr>

	<tr>
	<td class="content">
	<b>(gdb)</b> break foo if strcmp(y,"hello") == 0
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint set --name foo --condition '(int)strcmp(y,"hello") == 0'
	<br>
	<b>(lldb)</b> br s -n foo -c '(int)strcmp(y,"hello") == 0'
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">List all breakpoints.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info break
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint list
	<br>
	<b>(lldb)</b> br l
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Delete a breakpoint.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> delete 1
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint delete 1
	<br>
	<b>(lldb)</b> br del 1
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Disable a breakpoint.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> disable 1
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint disable 1
	<br>
	<b>(lldb)</b> br dis 1
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Enable a breakpoint.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> enable 1
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> breakpoint enable 1
	<br>
	<b>(lldb)</b> br en 1
	<br>
	</td>
	</tr>

	</tbody>			(gdb) break main
	</table>			(Hope that there are no C functions named main)

				.. code-block:: shell

				(lldb) breakpoint set --method main
				(lldb) br s -M main

				Set a breakpoint at an Objective-C function ``-[NSString stringWithFormat:]``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) break -[NSString stringWithFormat:]

				.. code-block:: shell

				(lldb) breakpoint set --name "-[NSString stringWithFormat:]"
				(lldb) b -[NSString stringWithFormat:]

				Set a breakpoint at all Objective-C methods whose selector is ``count``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) break count
				(Hope that there are no C or C++ functions named count)

				.. code-block:: shell

				(lldb) breakpoint set --selector count
				(lldb) br s -S count

				Set a breakpoint by regular expression on function name
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) rbreak regular-expression

				.. code-block:: shell

				(lldb) breakpoint set --func-regex regular-expression
				(lldb) br s -r regular-expression

				Ensure that breakpoints by file and line work for ``#include .c/.cpp/.m`` files
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) b foo.c:12

				.. code-block:: shell

				(lldb) settings set target.inline-breakpoint-strategy always
				(lldb) br s -f foo.c -l 12

				Set a breakpoint by regular expression on source file contents
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) shell grep -e -n pattern source-file
				(gdb) break source-file:CopyLineNumbers

				.. code-block:: shell

				(lldb) breakpoint set --source-pattern regular-expression --file SourceFile
				(lldb) br s -p regular-expression -f file

				Set a conditional breakpoint
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) break foo if strcmp(y,"hello") == 0

				.. code-block:: shell

				(lldb) breakpoint set --name foo --condition '(int)strcmp(y,"hello") == 0'
				(lldb) br s -n foo -c '(int)strcmp(y,"hello") == 0'

				List all breakpoints
				~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info break

				.. code-block:: shell

				(lldb) breakpoint list
				(lldb) br l

				Delete a breakpoint
				~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) delete 1

				.. code-block:: shell

				(lldb) breakpoint delete 1
				(lldb) br del 1

				Disable a breakpoint
				~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) disable 1

				.. code-block:: shell

				(lldb) breakpoint disable 1
				(lldb) br dis 1

				Enable a breakpoint
				~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) enable 1

				.. code-block:: shell

				(lldb) breakpoint enable 1
				(lldb) br en 1


	Watchpoint Commands			Watchpoint Commands
	-------------------			-------------------

	.. raw:: html			Set a watchpoint on a variable when it is written to
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
				.. code-block:: shell

				(gdb) watch global_var

				.. code-block:: shell

				(lldb) watchpoint set variable global_var
				(lldb) wa s v global_var

				Set a watchpoint on a memory location when it is written into
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				The size of the region to watch for defaults to the pointer size if no '-x byte_size' is specified. This command takes raw input, evaluated as an expression returning an unsigned integer pointing to the start of the region, after the '--' option terminator.

				.. code-block:: shell

				(gdb) watch -location g_char_ptr

				.. code-block:: shell

				(lldb) watchpoint set expression -- my_ptr
				(lldb) wa s e -- my_ptr

				Set a condition on a watchpoint
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) watch set var global
				(lldb) watchpoint modify -c '(global==5)'
				(lldb) c
				...
				(lldb) bt
				* thread #1: tid = 0x1c03, 0x0000000100000ef5 a.out`modify + 21 at main.cpp:16, stop reason = watchpoint 1
				frame #0: 0x0000000100000ef5 a.out`modify + 21 at main.cpp:16
				frame #1: 0x0000000100000eac a.out`main + 108 at main.cpp:25
				frame #2: 0x00007fff8ac9c7e1 libdyld.dylib`start + 1
				(lldb) frame var global
				(int32_t) global = 5

	<table class="mapping" cellspacing="0">			List all watchpoints
	<tbody>			~~~~~~~~~~~~~~~~~~~~
	<tr>
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a watchpoint on a variable when it is written to.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> watch global_var
	</td>
	<td class="content">
	<b>(lldb)</b> watchpoint set variable global_var
	<br>
	<b>(lldb)</b> wa s v global_var
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a watchpoint on a memory location when it is written into. The size of the region to watch for defaults to the pointer size if no '-x byte_size' is specified. This command takes raw input, evaluated as an expression returning an unsigned integer pointing to the start of the region, after the '--' option terminator.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> watch -location g_char_ptr
	</td>
	<td class="content">
	<b>(lldb)</b> watchpoint set expression -- my_ptr
	<br>
	<b>(lldb)</b> wa s e -- my_ptr
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Set a condition on a watchpoint.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> watch set var global
	<br>
	<b>(lldb)</b> watchpoint modify -c '(global==5)'
	<br>
	<b>(lldb)</b> c
	<br> ...
	<br>
	<b>(lldb)</b> bt
	<br> * thread #1: tid = 0x1c03, 0x0000000100000ef5 a.out`modify + 21 at main.cpp:16, stop reason = watchpoint 1
	<br> frame #0: 0x0000000100000ef5 a.out`modify + 21 at main.cpp:16
	<br> frame #1: 0x0000000100000eac a.out`main + 108 at main.cpp:25
	<br> frame #2: 0x00007fff8ac9c7e1 libdyld.dylib`start + 1
	<br>
	<b>(lldb)</b> frame var global
	<br> (int32_t) global = 5
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">List all watchpoints.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info break
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> watchpoint list
	<br>
	<b>(lldb)</b> watch l
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Delete a watchpoint.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> delete 1
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> watchpoint delete 1
	<br>
	<b>(lldb)</b> watch del 1
	<br>
	</td>
	</tr>

	</tbody>			.. code-block:: shell
	</table>
				(gdb) info break

				.. code-block:: shell

				(lldb) watchpoint list
				(lldb) watch l

				Delete a watchpoint
				~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) delete 1

				.. code-block:: shell

				(lldb) watchpoint delete 1
				(lldb) watch del 1


	Examining Variables			Examining Variables
	-------------------			-------------------

	.. raw:: html			Show the arguments and local variables for the current frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info args
				(gdb) info locals

				.. code-block:: shell

				(lldb) frame variable
				(lldb) fr v

				Show the local variables for the current frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info locals

				.. code-block:: shell

				(lldb) frame variable --no-args
				(lldb) fr v -a

				Show the contents of local variable ``bar``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) p bar

				.. code-block:: shell

				(lldb) frame variable bar
				(lldb) fr v bar
				(lldb) p bar

				Show the contents of local variable ``bar`` formatted as hex
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) p/x bar

				.. code-block:: shell

				(lldb) frame variable --format x bar
				(lldb) fr v -f x bar

				Show the contents of global variable ``baz``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) p baz

				.. code-block:: shell

				(lldb) target variable baz
				(lldb) ta v baz

	<table class="mapping" cellspacing="0">			Show the global/static variables defined in the current source file
	<tbody>			~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	<tr>
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the arguments and local variables for the current frame.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info args
	<br> and
	<br>
	<b>(gdb)</b> info locals
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> frame variable
	<br>
	<b>(lldb)</b> fr v
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the local variables for the current frame.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info locals
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> frame variable --no-args
	<br>
	<b>(lldb)</b> fr v -a
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the contents of local variable "bar".</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> p bar
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> frame variable bar
	<br>
	<b>(lldb)</b> fr v bar
	<br>
	<b>(lldb)</b> p bar
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the contents of local variable "bar" formatted as hex.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> p/x bar
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> frame variable --format x bar
	<br>
	<b>(lldb)</b> fr v -f x bar
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the contents of global variable "baz".</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> p baz
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> target variable baz
	<br>
	<b>(lldb)</b> ta v baz
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the global/static variables defined in the current source file.</td>
	</tr>
	<tr>
	<td class="content">
	n/a
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> target variable
	<br>
	<b>(lldb)</b> ta v
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Display the variables "argc" and "argv" every time you stop.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> display argc
	<br>
	<b>(gdb)</b> display argv
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> target stop-hook add --one-liner "frame variable argc argv"
	<br>
	<b>(lldb)</b> ta st a -o "fr v argc argv"
	<br>
	<b>(lldb)</b> display argc
	<br>
	<b>(lldb)</b> display argv
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Display the variables "argc" and "argv" only when you stop in the function named <b><code>main</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> target stop-hook add --name main --one-liner "frame variable argc argv"
	<br>
	<b>(lldb)</b> ta st a -n main -o "fr v argc argv"
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Display the variable "*this" only when you stop in c class named <b><code>MyClass</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> target stop-hook add --classname MyClass --one-liner "frame variable *this"
	<br>
	<b>(lldb)</b> ta st a -c MyClass -o "fr v *this"
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Print an array of integers in memory, assuming we have a pointer like "int *ptr".</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> p *ptr@10
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> parray 10 ptr
	<br>
	</td>
	</tr>

	</tbody>			.. code-block:: shell
	</table>
				(lldb) target variable
				(lldb) ta v

				Display the variables ``argc`` and ``argv`` every time you stop
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) display argc
				(gdb) display argv

				.. code-block:: shell

				(lldb) target stop-hook add --one-liner "frame variable argc argv"
				(lldb) ta st a -o "fr v argc argv"
				(lldb) display argc
				(lldb) display argv

				Display the variables ``argc`` and ``argv`` only when you stop in the function named ``main``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) target stop-hook add --name main --one-liner "frame variable argc argv"
				(lldb) ta st a -n main -o "fr v argc argv"

				Display the variable ``*this`` only when you stop in c class named ``MyClass``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) target stop-hook add --classname MyClass --one-liner "frame variable *this"
				(lldb) ta st a -c MyClass -o "fr v *this"

				Print an array of integers in memory, assuming we have a pointer like ``int *ptr``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) p *ptr@10

				.. code-block:: shell

				(lldb) parray 10 ptr

	Evaluating Expressions			Evaluating Expressions
	----------------------			----------------------

	.. raw:: html			Evaluating a generalized expression in the current frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) print (int) printf ("Print nine: %d.", 4 + 5)

				or if you don't want to see void returns:

				.. code-block:: shell

				(gdb) call (int) printf ("Print nine: %d.", 4 + 5)

				.. code-block:: shell

				(lldb) expr (int) printf ("Print nine: %d.", 4 + 5)

				or using the print alias:

				.. code-block:: shell

				(lldb) print (int) printf ("Print nine: %d.", 4 + 5)

				Creating and assigning a value to a convenience variable
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) set $foo = 5
				(gdb) set variable $foo = 5

				or using the print command

	<table class="mapping" cellspacing="0">			.. code-block:: shell
	<tbody>
	<tr>			(gdb) print $foo = 5
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>			or using the call command
	</tr>
				.. code-block:: shell
	<tr>
	<td class="header" colspan="2">Evaluating a generalized expression in the current frame.</td>			(gdb) call $foo = 5
	</tr>
	<tr>			and if you want to specify the type of the variable:
	<td class="content">
	<b>(gdb)</b> print (int) printf ("Print nine: %d.", 4 + 5)			.. code-block:: shell
	<br> or if you don't want to see void returns:
	<br>			(gdb) set $foo = (unsigned int) 5
	<b>(gdb)</b> call (int) printf ("Print nine: %d.", 4 + 5)
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> expr (int) printf ("Print nine: %d.", 4 + 5)
	<br> or using the print alias:
	<br>
	<b>(lldb)</b> print (int) printf ("Print nine: %d.", 4 + 5)
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Creating and assigning a value to a convenience variable.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set $foo = 5
	<br>
	<b>(gdb)</b> set variable $foo = 5
	<br> or using the print command
	<br>
	<b>(gdb)</b> print $foo = 5
	<br> or using the call command
	<br>
	<b>(gdb)</b> call $foo = 5
	<br> and if you want to specify the type of the variable:
	<b>(gdb)</b> set $foo = (unsigned int) 5
	<br>

	</td>
	<td class="content">
	In lldb you evaluate a variable declaration expression as you would write it in C:			In lldb you evaluate a variable declaration expression as you would write it in C:
	<br>
	<b>(lldb)</b> expr unsigned int $foo = 5
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Printing the ObjC "description" of an object.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> po [SomeClass returnAnObject]
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> expr -o -- [SomeClass returnAnObject]
	<br> or using the po alias:
	<br>
	<b>(lldb)</b> po [SomeClass returnAnObject]
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Print the dynamic type of the result of an expression.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set print object 1
	<br>
	<b>(gdb)</b> p someCPPObjectPtrOrReference
	<br> only works for C++ objects.
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> expr -d 1 -- [SomeClass returnAnObject]
	<br>
	<b>(lldb)</b> expr -d 1 -- someCPPObjectPtrOrReference
	<br> or set dynamic type printing to be the default:
	<b>(lldb)</b> settings set target.prefer-dynamic run-target
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Call a function so you can stop at a breakpoint in it.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set unwindonsignal 0
	<br>
	<b>(gdb)</b> p function_with_a_breakpoint()
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> expr -i 0 -- function_with_a_breakpoint()
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Call a function that crashes, then stop when it does.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set unwindonsignal 0
	<br>
	<b>(gdb)</b> p function_which_crashes()
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> expr -u 0 -- function_which_crashes()
	<br>
	</td>
	</tr>

	</tbody>			.. code-block:: shell
	</table>
				(lldb) expr unsigned int $foo = 5

				Printing the ObjC "description" of an object
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) po [SomeClass returnAnObject]

				.. code-block:: shell

				(lldb) expr -o -- [SomeClass returnAnObject]

				or using the po alias:

				.. code-block:: shell

				(lldb) po [SomeClass returnAnObject]

				Print the dynamic type of the result of an expression
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) set print object 1
				(gdb) p someCPPObjectPtrOrReference
				(Only works for C++ objects)

				.. code-block:: shell

				(lldb) expr -d 1 -- [SomeClass returnAnObject]
				(lldb) expr -d 1 -- someCPPObjectPtrOrReference

				or set dynamic type printing to be the default:

				.. code-block:: shell

				(lldb) settings set target.prefer-dynamic run-target

				Call a function so you can stop at a breakpoint in it
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) set unwindonsignal 0
				(gdb) p function_with_a_breakpoint()

				.. code-block:: shell

				(lldb) expr -i 0 -- function_with_a_breakpoint()

				Call a function that crashes, then stop when it does
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) set unwindonsignal 0
				(gdb) p function_which_crashes()

				.. code-block:: shell

				(lldb) expr -u 0 -- function_which_crashes()

	Examining Thread State			Examining Thread State
	----------------------			----------------------

	.. raw:: html			List the threads in your program
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info threads

				.. code-block:: shell

				(lldb) thread list

				Select thread ``1`` as the default thread for subsequent commands
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) thread 1

				.. code-block:: shell

				(lldb) thread select 1
				(lldb) t 1

				Show the stack backtrace for the current thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) bt

				.. code-block:: shell

				(lldb) thread backtrace
				(lldb) bt

				Show the stack backtraces for all threads
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) thread apply all bt

				.. code-block:: shell

				(lldb) thread backtrace all
				(lldb) bt all

				Backtrace the first five frames of the current thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) bt 5

				.. code-block:: shell

				(lldb) thread backtrace -c 5
				(lldb) bt 5

				Select a different stack frame by index for the current thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) frame 12

				.. code-block:: shell

				(lldb) frame select 12
				(lldb) fr s 12
				(lldb) f 12

				List information about the currently selected frame in the current thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) frame info

				Select the stack frame that called the current stack frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) up

				.. code-block:: shell

				(lldb) up
				(lldb) frame select --relative=1

				Select the stack frame that is called by the current stack frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) down

				.. code-block:: shell

				(lldb) down
				(lldb) frame select --relative=-1
				(lldb) fr s -r-1

				Select a different stack frame using a relative offset
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) up 2
				(gdb) down 3

				.. code-block:: shell

				(lldb) frame select --relative 2
				(lldb) fr s -r2

				(lldb) frame select --relative -3
				(lldb) fr s -r-3

				show the general purpose registers for the current thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info registers

				.. code-block:: shell

				(lldb) register read

				Write a new decimal value ``123`` to the current thread register ``rax``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) p $rax = 123

				.. code-block:: shell

				(lldb) register write rax 123

				Skip 8 bytes ahead of the current program counter (instruction pointer)
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				Note that we use backticks to evaluate an expression and insert the scalar result in LLDB.


				.. code-block:: shell

				(gdb) jump *$pc+8

				.. code-block:: shell

				(lldb) register write pc `$pc+8`

				Show the general purpose registers for the current thread formatted as signed decimal
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				LLDB tries to use the same format characters as printf(3) when possible. Type "help format" to see the full list of format specifiers.

				.. code-block:: shell

				(lldb) register read --format i
				(lldb) re r -f i

				LLDB now supports the GDB shorthand format syntax but there can't be space after the command:

				.. code-block:: shell

				(lldb) register read/d

				Show all registers in all register sets for the current thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info all-registers

				.. code-block:: shell

				(lldb) register read --all
				(lldb) re r -a

				Show the values for the registers named ``rax``, ``rsp`` and ``rbp`` in the current thread
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info all-registers rax rsp rbp

				.. code-block:: shell

				(lldb) register read rax rsp rbp

				Show the values for the register named ``rax`` in the current thread formatted as binary
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) p/t $rax

				.. code-block:: shell

				(lldb) register read --format binary rax
				(lldb) re r -f b rax

				LLDB now supports the GDB shorthand format syntax but there can't be space after the command

				.. code-block:: shell

				(lldb) register read/t rax
				(lldb) p/t $rax

				Read memory from address ``0xbffff3c0`` and show 4 hex ``uint32_t`` values
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) x/4xw 0xbffff3c0

	<table class="mapping" cellspacing="0">			.. code-block:: shell
	<tbody>
	<tr>
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>
	</tr>

	<tr>
	<td class="header" colspan="2">List the threads in your program.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info threads
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> thread list
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Select thread 1 as the default thread for subsequent commands.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> thread 1
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> thread select 1
	<br>
	<b>(lldb)</b> t 1
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the stack backtrace for the current thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> bt
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> thread backtrace
	<br>
	<b>(lldb)</b> bt
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the stack backtraces for all threads.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> thread apply all bt
	</td>
	<td class="content">
	<b>(lldb)</b> thread backtrace all
	<br>
	<b>(lldb)</b> bt all
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Backtrace the first five frames of the current thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> bt 5
	</td>
	<td class="content">
	<b>(lldb)</b> thread backtrace -c 5
	<br>
	<b>(lldb)</b> bt 5 (<i>lldb-169 and later</i>)
	<br>
	<b>(lldb)</b> bt -c 5 (<i>lldb-168 and earlier</i>)
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Select a different stack frame by index for the current thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> frame 12
	</td>
	<td class="content">
	<b>(lldb)</b> frame select 12
	<br>
	<b>(lldb)</b> fr s 12
	<br>
	<b>(lldb)</b> f 12
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">List information about the currently selected frame in the current thread.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> frame info
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Select the stack frame that called the current stack frame.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> up
	</td>
	<td class="content">
	<b>(lldb)</b> up
	<br>
	<b>(lldb)</b> frame select --relative=1
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Select the stack frame that is called by the current stack frame.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> down
	</td>
	<td class="content">
	<b>(lldb)</b> down
	<br>
	<b>(lldb)</b> frame select --relative=-1
	<br>
	<b>(lldb)</b> fr s -r-1
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Select a different stack frame using a relative offset.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> up 2
	<br>
	<b>(gdb)</b> down 3
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> frame select --relative 2
	<br>
	<b>(lldb)</b> fr s -r2
	<br>
	<br>
	<b>(lldb)</b> frame select --relative -3
	<br>
	<b>(lldb)</b> fr s -r-3
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the general purpose registers for the current thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info registers
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> register read
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Write a new decimal value '123' to the current thread register 'rax'.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> p $rax = 123
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> register write rax 123
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Skip 8 bytes ahead of the current program counter (instruction pointer). Note that we use backticks to evaluate an expression and insert the scalar result in LLDB.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> jump *$pc+8
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> register write pc `$pc+8`
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the general purpose registers for the current thread formatted as <b>signed decimal</b>. LLDB tries to use the same format characters as <b><code>printf(3)</code></b> when possible. Type "help format" to see the full list of format specifiers.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> register read --format i
	<br>
	<b>(lldb)</b> re r -f i
	<br>
	<br>
	<i>LLDB now supports the GDB shorthand format syntax but there can't be space after the command:</i>
	<br>
	<b>(lldb)</b> register read/d
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show all registers in all register sets for the current thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info all-registers
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> register read --all
	<br>
	<b>(lldb)</b> re r -a
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the values for the registers named "rax", "rsp" and "rbp" in the current thread.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info all-registers rax rsp rbp
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> register read rax rsp rbp
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show the values for the register named "rax" in the current thread formatted as <b>binary</b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> p/t $rax
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> register read --format binary rax
	<br>
	<b>(lldb)</b> re r -f b rax
	<br>
	<br>
	<i>LLDB now supports the GDB shorthand format syntax but there can't be space after the command:</i>
	<br>
	<b>(lldb)</b> register read/t rax
	<br>
	<b>(lldb)</b> p/t $rax
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Read memory from address 0xbffff3c0 and show 4 hex <code>uint32_t</code> values.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> x/4xw 0xbffff3c0
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> memory read --size 4 --format x --count 4 0xbffff3c0
	<br>
	<b>(lldb)</b> me r -s4 -fx -c4 0xbffff3c0
	<br>
	<b>(lldb)</b> x -s4 -fx -c4 0xbffff3c0
	<br>
	<br>
	<i>LLDB now supports the GDB shorthand format syntax but there can't be space after the command:</i>
	<br>
	<b>(lldb)</b> memory read/4xw 0xbffff3c0
	<br>
	<b>(lldb)</b> x/4xw 0xbffff3c0
	<br>
	<b>(lldb)</b> memory read --gdb-format 4xw 0xbffff3c0
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Read memory starting at the expression "argv[0]".</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> x argv[0]
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> memory read `argv[0]`
	<br>
	<i><b>NOTE:</b> any command can inline a scalar expression result (as long as the target is stopped) using backticks around any expression:</i>
	<br>
	<b>(lldb)</b> memory read --size `sizeof(int)` `argv[0]`
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Read 512 bytes of memory from address 0xbffff3c0 and save the results to a local file as <b>text</b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set logging on
	<br>
	<b>(gdb)</b> set logging file /tmp/mem.txt
	<br>
	<b>(gdb)</b> x/512bx 0xbffff3c0
	<br>
	<b>(gdb)</b> set logging off
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> memory read --outfile /tmp/mem.txt --count 512 0xbffff3c0
	<br>
	<b>(lldb)</b> me r -o/tmp/mem.txt -c512 0xbffff3c0
	<br>
	<b>(lldb)</b> x/512bx -o/tmp/mem.txt 0xbffff3c0
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Save binary memory data starting at 0x1000 and ending at 0x2000 to a file.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> dump memory /tmp/mem.bin 0x1000 0x2000
	</td>
	<td class="content">
	<b>(lldb)</b> memory read --outfile /tmp/mem.bin --binary 0x1000 0x2000
	<br>
	<b>(lldb)</b> me r -o /tmp/mem.bin -b 0x1000 0x2000
	<br>
	</td>
	</tr>
	<tr>
	<td class="header" colspan="2">Get information about a specific heap allocation (available on macOS only).</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info malloc 0x10010d680
	</td>
	<td class="content">
	<b>(lldb)</b> command script import lldb.macosx.heap
	<br>
	<b>(lldb)</b> process launch --environment MallocStackLogging=1 -- [ARGS]
	<br>
	<b>(lldb)</b> malloc_info --stack-history 0x10010d680
	<br>
	</td>
	</tr>
	<tr>
	<td class="header" colspan="2">Get information about a specific heap allocation and cast the result to any dynamic type that can be deduced (available on macOS only)</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> command script import lldb.macosx.heap
	<br>
	<b>(lldb)</b> malloc_info --type 0x10010d680
	<br>
	</td>
	</tr>
	<tr>
	<td class="header" colspan="2">Find all heap blocks that contain a pointer specified by an expression EXPR (available on macOS only).</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> command script import lldb.macosx.heap
	<br>
	<b>(lldb)</b> ptr_refs EXPR
	<br>
	</td>
	</tr>
	<tr>
	<td class="header" colspan="2">Find all heap blocks that contain a C string anywhere in the block (available on macOS only).</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> command script import lldb.macosx.heap
	<br>
	<b>(lldb)</b> cstr_refs CSTRING
	<br>
	</td>
	</tr>
	<tr>
	<td class="header" colspan="2">Disassemble the current function for the current frame.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> disassemble
	</td>
	<td class="content">
	<b>(lldb)</b> disassemble --frame
	<br>
	<b>(lldb)</b> di -f
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Disassemble any functions named <b><code>main</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> disassemble main
	</td>
	<td class="content">
	<b>(lldb)</b> disassemble --name main
	<br>
	<b>(lldb)</b> di -n main
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Disassemble an address range.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> disassemble 0x1eb8 0x1ec3
	</td>
	<td class="content">
	<b>(lldb)</b> disassemble --start-address 0x1eb8 --end-address 0x1ec3
	<br>
	<b>(lldb)</b> di -s 0x1eb8 -e 0x1ec3
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Disassemble 20 instructions from a given address.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> x/20i 0x1eb8
	</td>
	<td class="content">
	<b>(lldb)</b> disassemble --start-address 0x1eb8 --count 20
	<br>
	<b>(lldb)</b> di -s 0x1eb8 -c 20
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Show mixed source and disassembly for the current function for the current frame.</td>
	</tr>
	<tr>
	<td class="content">
	n/a
	</td>
	<td class="content">
	<b>(lldb)</b> disassemble --frame --mixed
	<br>
	<b>(lldb)</b> di -f -m
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Disassemble the current function for the current frame and show the opcode bytes.</td>
	</tr>
	<tr>
	<td class="content">
	n/a
	</td>
	<td class="content">
	<b>(lldb)</b> disassemble --frame --bytes
	<br>
	<b>(lldb)</b> di -f -b
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Disassemble the current source line for the current frame.</td>
	</tr>
	<tr>
	<td class="content">
	n/a
	</td>
	<td class="content">
	<b>(lldb)</b> disassemble --line
	<br>
	<b>(lldb)</b> di -l
	</td>
	</tr>

	</tbody>			(lldb) memory read --size 4 --format x --count 4 0xbffff3c0
	</table>			(lldb) me r -s4 -fx -c4 0xbffff3c0
				(lldb) x -s4 -fx -c4 0xbffff3c0

				LLDB now supports the GDB shorthand format syntax but there can't be space after the command:

				.. code-block:: shell

				(lldb) memory read/4xw 0xbffff3c0
				(lldb) x/4xw 0xbffff3c0
				(lldb) memory read --gdb-format 4xw 0xbffff3c0

				Read memory starting at the expression ``argv[0]``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) x argv[0]

				.. code-block:: shell

				(lldb) memory read `argv[0]`

				NOTE: any command can inline a scalar expression result (as long as the target is stopped) using backticks around any expression:

				.. code-block:: shell

				(lldb) memory read --size `sizeof(int)` `argv[0]`

				Read ``512`` bytes of memory from address ``0xbffff3c0`` and save the results to a local file as text
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) set logging on
				(gdb) set logging file /tmp/mem.txt
				(gdb) x/512bx 0xbffff3c0
				(gdb) set logging off

				.. code-block:: shell

				(lldb) memory read --outfile /tmp/mem.txt --count 512 0xbffff3c0
				(lldb) me r -o/tmp/mem.txt -c512 0xbffff3c0
				(lldb) x/512bx -o/tmp/mem.txt 0xbffff3c0

				Save binary memory data starting at ``0x1000`` and ending at ``0x2000`` to a file
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) dump memory /tmp/mem.bin 0x1000 0x2000

				.. code-block:: shell

				(lldb) memory read --outfile /tmp/mem.bin --binary 0x1000 0x2000
				(lldb) me r -o /tmp/mem.bin -b 0x1000 0x2000

				Get information about a specific heap allocation (macOS only)
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info malloc 0x10010d680

				.. code-block:: shell

				(lldb) command script import lldb.macosx.heap
				(lldb) process launch --environment MallocStackLogging=1 -- [ARGS]
				(lldb) malloc_info --stack-history 0x10010d680

				Get information about a specific heap allocation and cast the result to any dynamic type that can be deduced (macOS only)
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) command script import lldb.macosx.heap
				(lldb) malloc_info --type 0x10010d680

				Find all heap blocks that contain a pointer specified by an expression ``EXPR`` (macOS only)
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) command script import lldb.macosx.heap
				(lldb) ptr_refs EXPR

				Find all heap blocks that contain a C string anywhere in the block (macOS only)
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) command script import lldb.macosx.heap
				(lldb) cstr_refs CSTRING

				Disassemble the current function for the current frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) disassemble

				.. code-block:: shell

				(lldb) disassemble --frame
				(lldb) di -f

				Disassemble any functions named main
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) disassemble main


				.. code-block:: shell

				(lldb) disassemble --name main
				(lldb) di -n main

				Disassemble an address range
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) disassemble 0x1eb8 0x1ec3

				.. code-block:: shell

				(lldb) disassemble --start-address 0x1eb8 --end-address 0x1ec3
				(lldb) di -s 0x1eb8 -e 0x1ec3

				Disassemble ``20`` instructions from a given address
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) x/20i 0x1eb8

				.. code-block:: shell

				(lldb) disassemble --start-address 0x1eb8 --count 20
				(lldb) di -s 0x1eb8 -c 20

				Show mixed source and disassembly for the current function for the current frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) disassemble --frame --mixed
				(lldb) di -f -m

				Disassemble the current function for the current frame and show the opcode bytes
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) disassemble --frame --bytes
				(lldb) di -f -b

				Disassemble the current source line for the current frame
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) disassemble --line
				(lldb) di -l

	Executable and Shared Library Query Commands			Executable and Shared Library Query Commands
	--------------------------------------------			--------------------------------------------

	.. raw:: html			List the main executable and all dependent shared libraries
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info shared

				.. code-block:: shell

				(lldb) image list

				Look up information for a raw address in the executable or any shared libraries
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info symbol 0x1ec4

				.. code-block:: shell

				(lldb) image lookup --address 0x1ec4
				(lldb) im loo -a 0x1ec4

				Look up functions matching a regular expression in a binary
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) info function <FUNC_REGEX>

	<table class="mapping" cellspacing="0">
	<tbody>
	<tr>
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>
	</tr>

	<tr>
	<td class="header" colspan="2">List the main executable and all dependent shared libraries.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info shared
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> image list
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Look up information for a raw address in the executable or any shared libraries.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info symbol 0x1ec4
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> image lookup --address 0x1ec4
	<br>
	<b>(lldb)</b> im loo -a 0x1ec4
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Look up functions matching a regular expression in a binary.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> info function <FUNC_REGEX>
	<br>
	</td>
	<td class="content">
	This one finds debug symbols:			This one finds debug symbols:
	<br>
	<b>(lldb)</b> image lookup -r -n <FUNC_REGEX>			.. code-block:: shell
	<br>
	<br> This one finds non-debug symbols:			(lldb) image lookup -r -n <FUNC_REGEX>
	<br>
	<b>(lldb)</b> image lookup -r -s <FUNC_REGEX>			This one finds non-debug symbols:
	<br>
	<br> Provide a list of binaries as arguments to limit the search.			.. code-block:: shell
	</td>
	</tr>			(lldb) image lookup -r -s <FUNC_REGEX>

	<tr>			Provide a list of binaries as arguments to limit the search.
	<td class="header" colspan="2">Find full source line information.</td>
	</tr>			Find full source line information
	<tr>			~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	<td class="content">
	<b>(gdb)</b> info line 0x1ec4			.. code-block:: shell
	<br>
	</td>			(gdb) info line 0x1ec4
	<td class="content">
	This one is a bit messy at present. Do:			This one is a bit messy at present. Do:
	<br>
	<br>
	<b>(lldb)</b> image lookup -v --address 0x1ec4
	<br>
	<br> and look for the LineEntry line, which will have the full source path and line range information.
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Look up information for an address in <b><code>a.out</code></b> only.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> image lookup --address 0x1ec4 a.out
	<br>
	<b>(lldb)</b> im loo -a 0x1ec4 a.out
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Look up information for for a type <code>Point</code> by name.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> ptype Point
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> image lookup --type Point
	<br>
	<b>(lldb)</b> im loo -t Point
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Dump all sections from the main executable and any shared libraries.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> maintenance info sections
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> image dump sections
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Dump all sections in the <b><code>a.out</code></b> module.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> image dump sections a.out
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Dump all symbols from the main executable and any shared libraries.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> image dump symtab
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Dump all symbols in <b><code>a.out</code></b> and <b><code>liba.so</code></b>.</td>
	</tr>
	<tr>
	<td class="content">
	</td>
	<td class="content">
	<b>(lldb)</b> image dump symtab a.out liba.so
	<br>
	</td>
	</tr>

	</tbody>			.. code-block:: shell
	</table>
				(lldb) image lookup -v --address 0x1ec4

				and look for the LineEntry line, which will have the full source path and line range information.

				Look up information for an address in ``a.out`` only
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) image lookup --address 0x1ec4 a.out
				(lldb) im loo -a 0x1ec4 a.out

				Look up information for for a type ``Point`` by name
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) ptype Point

				.. code-block:: shell

				(lldb) image lookup --type Point
				(lldb) im loo -t Point

				Dump all sections from the main executable and any shared libraries
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) maintenance info sections

				.. code-block:: shell

				(lldb) image dump sections

				Dump all sections in the ``a.out`` module
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) image dump sections a.out

				Dump all symbols from the main executable and any shared libraries
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) image dump symtab

				Dump all symbols in ``a.out`` and ``liba.so``
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(lldb) image dump symtab a.out liba.so

	Miscellaneous			Miscellaneous
	-------------			-------------

	.. raw:: html			Search command help for a keyword
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) apropos keyword

				.. code-block:: shell

				(lldb) apropos keyword

				Echo text to the screen
				~~~~~~~~~~~~~~~~~~~~~~~

				.. code-block:: shell

				(gdb) echo Here is some text\n

				.. code-block:: shell

				(lldb) script print "Here is some text"

				Remap source file pathnames for the debug session
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

				If your source files are no longer located in the same location as when the
				program was built (for example, if the program was built on a different
				computer) you need to tell the debugger how to find the sources at their local
				file path instead of the build system's file path.

				.. code-block:: shell

				(gdb) set pathname-substitutions /buildbot/path /my/path

				.. code-block:: shell

				(lldb) settings set target.source-map /buildbot/path /my/path

				Supply a catchall directory to search for source files in.

	<table class="mapping" cellspacing="0">			.. code-block:: shell
	<tbody>
	<tr>
	<td class="hed" width="50%">GDB</td>
	<td class="hed" width="50%">LLDB</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Search command help for a keyword.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> apropos keyword
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> apropos keyword
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Echo text to the screen.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> echo Here is some text\n
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> script print "Here is some text"
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Remap source file pathnames for the debug session. If your source files are no longer located in the same location as when the program was built (for example, if the program was built on a different computer) you need to tell the debugger how to find the sources at their local file path instead of the build system's file path.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> set pathname-substitutions /buildbot/path /my/path
	<br>
	</td>
	<td class="content">
	<b>(lldb)</b> settings set target.source-map /buildbot/path /my/path
	<br>
	</td>
	</tr>

	<tr>
	<td class="header" colspan="2">Supply a catchall directory to search for source files in.</td>
	</tr>
	<tr>
	<td class="content">
	<b>(gdb)</b> directory /my/path
	<br>
	</td>
	<td class="content">
	(<i>No equivalent command - use the source-map instead.</i>)
	<br>
	</td>
	</tr>

	</tbody>			(gdb) directory /my/path
	</table>

lldb/docs/use/ondemand.rst

	On Demand Symbols			On Demand Symbols
	=================			=================

	On demand symbols can be enabled in LLDB for projects that generate debug info			On demand symbols can be enabled in LLDB for projects that generate debug info
	for more than what is required by a normal debug session. Some build systems			for more than what is required by a normal debug session. Some build systems
	enable debug information for all binaries and can end up producing many			enable debug information for all binaries and can end up producing many
	gigabytes of debug information. This amount of debug information can greatly			gigabytes of debug information. This amount of debug information can greatly
	increase debug session load times and can slow developer productivity when the			increase debug session load times and can slow developer productivity when the
	debug information isn't indexed. It can also cause expression evaluation to			debug information isn't indexed. It can also cause expression evaluation to
	be slow when types from all of the binaries have full debug info as each module			be slow when types from all of the binaries have full debug info as each module
	is queried for very common types, or global name lookups fail due to a mistyped			is queried for very common types, or global name lookups fail due to a mistyped
	expression.			expression.

	.. contents::
	:local:

	When should I consider enabling this feature?			When should I consider enabling this feature?
	---------------------------------------------			---------------------------------------------

	Anyone that has a build system that produces debug information for many			Anyone that has a build system that produces debug information for many
	binaries that are not all required when you want to focus on debugging a few of			binaries that are not all required when you want to focus on debugging a few of
	the produced binaries. Some build systems enable debug info as a project wide			the produced binaries. Some build systems enable debug info as a project wide
	switch and the build system files that control how things are built are not			switch and the build system files that control how things are built are not
	easy to modify to produce debug info for only a small subset of the files being			easy to modify to produce debug info for only a small subset of the files being
	▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

lldb/docs/use/python-reference.rst

	Python Reference			Python Reference
	================			================

	The entire LLDB API is available as Python functions through a script bridging			The entire LLDB API is available as Python functions through a script bridging
	interface. This means the LLDB API's can be used directly from python either			interface. This means the LLDB API's can be used directly from python either
	interactively or to build python apps that provide debugger features.			interactively or to build python apps that provide debugger features.

	Additionally, Python can be used as a programmatic interface within the lldb			Additionally, Python can be used as a programmatic interface within the lldb
	command interpreter (we refer to this for brevity as the embedded interpreter).			command interpreter (we refer to this for brevity as the embedded interpreter).
	Of course, in this context it has full access to the LLDB API - with some			Of course, in this context it has full access to the LLDB API - with some
	additional conveniences we will call out in the FAQ.			additional conveniences we will call out in the FAQ.

	.. contents::
	:local:

	Documentation			Documentation
	--------------			--------------

	The LLDB API is contained in a python module named lldb. A useful resource when			The LLDB API is contained in a python module named lldb. A useful resource when
	writing Python extensions is the lldb Python classes reference guide.			writing Python extensions is the lldb Python classes reference guide.

	The documentation is also accessible in an interactive debugger session with			The documentation is also accessible in an interactive debugger session with
	the following command:			the following command:
	▲ Show 20 Lines • Show All 912 Lines • Show Last 20 Lines

lldb/docs/use/python.rst

	Python Scripting			Python Scripting
	================			================

	LLDB has been structured from the beginning to be scriptable in two			LLDB has been structured from the beginning to be scriptable in two
	ways -- a Unix Python session can initiate/run a debug session			ways -- a Unix Python session can initiate/run a debug session
	non-interactively using LLDB; and within the LLDB debugger tool, Python			non-interactively using LLDB; and within the LLDB debugger tool, Python
	scripts can be used to help with many tasks, including inspecting			scripts can be used to help with many tasks, including inspecting
	program data, iterating over containers and determining if a breakpoint			program data, iterating over containers and determining if a breakpoint
	should stop execution or continue. This document will show how to do			should stop execution or continue. This document will show how to do
	some of these things by going through an example, explaining how to use			some of these things by going through an example, explaining how to use
	Python scripting to find a bug in a program that searches for text in a			Python scripting to find a bug in a program that searches for text in a
	large binary tree.			large binary tree.

	.. contents::
	:local:

	The Test Program and Input			The Test Program and Input
	--------------------------			--------------------------

	We have a simple C program (dictionary.c) that reads in a text file,			We have a simple C program (dictionary.c) that reads in a text file,
	and stores all the words from the file in a Binary Search Tree, sorted			and stores all the words from the file in a Binary Search Tree, sorted
	alphabetically. It then enters a loop prompting the user for a word,			alphabetically. It then enters a loop prompting the user for a word,
	searching for the word in the tree (using Binary Search), and reporting			searching for the word in the tree (using Binary Search), and reporting
	to the user whether or not it found the word in the tree.			to the user whether or not it found the word in the tree.
	▲ Show 20 Lines • Show All 775 Lines • Show Last 20 Lines

lldb/docs/use/qemu-testing.rst

	Testing LLDB using QEMU			Testing LLDB using QEMU
	=======================			=======================

	.. contents::
	:local:

	QEMU system mode emulation			QEMU system mode emulation
	--------------------------			--------------------------

	QEMU can be used to test LLDB in an emulation environment in the absence of			QEMU can be used to test LLDB in an emulation environment in the absence of
	actual hardware. This page describes instructions to help setup a QEMU emulation			actual hardware. This page describes instructions to help setup a QEMU emulation
	environment for testing LLDB.			environment for testing LLDB.

	The scripts under llvm-project/lldb/scripts/lldb-test-qemu can quickly help			The scripts under llvm-project/lldb/scripts/lldb-test-qemu can quickly help
	▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

lldb/docs/use/remote.rst

	Show All 17 Lines

	In order to reduce code complexity and improve remote debugging experience LLDB			In order to reduce code complexity and improve remote debugging experience LLDB
	on Linux and macOS uses the remote debugging stub even when debugging a process			on Linux and macOS uses the remote debugging stub even when debugging a process
	locally. This is achieved by spawning a remote stub process locally and			locally. This is achieved by spawning a remote stub process locally and
	communicating with it over the loopback interface. In the case of local			communicating with it over the loopback interface. In the case of local
	debugging this whole process is transparent to the user. The platform binary is			debugging this whole process is transparent to the user. The platform binary is
	not used in this case, since no file transfers are needed.			not used in this case, since no file transfers are needed.

	.. contents::
	:local:

	Preparation for Remote Debugging			Preparation for Remote Debugging
	---------------------------------			---------------------------------

	While the process of actual debugging (stepping, backtraces, evaluating			While the process of actual debugging (stepping, backtraces, evaluating
	expressions) is same as in the local case, in the case of remote debugging,			expressions) is same as in the local case, in the case of remote debugging,
	more preparation is needed as the required binaries cannot started on the			more preparation is needed as the required binaries cannot started on the
	remote system automatically. Also, if the remote system runs a different OS or			remote system automatically. Also, if the remote system runs a different OS or
	architecture, the server component needs to be compiled separately.			architecture, the server component needs to be compiled separately.
	▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

lldb/docs/use/symbolication.rst

	Symbolication			Symbolication
	=============			=============

	.. contents::
	:local:


	LLDB is separated into a shared library that contains the core of the debugger,			LLDB is separated into a shared library that contains the core of the debugger,
	and a driver that implements debugging and a command interpreter. LLDB can be			and a driver that implements debugging and a command interpreter. LLDB can be
	used to symbolicate your crash logs and can often provide more information than			used to symbolicate your crash logs and can often provide more information than
	other symbolication programs:			other symbolication programs:

	- Inlined functions			- Inlined functions
	- Variables that are in scope for an address, along with their locations			- Variables that are in scope for an address, along with their locations

	▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

lldb/docs/use/symbols.rst

	Symbols on macOS			Symbols on macOS
	================			================

	.. contents::
	:local:

	On macOS, debug symbols are often in stand alone bundles called dSYM files.			On macOS, debug symbols are often in stand alone bundles called dSYM files.
	These are bundles that contain DWARF debug information and other resources			These are bundles that contain DWARF debug information and other resources
	related to builds and debug info.			related to builds and debug info.

	The DebugSymbols.framework framework helps locate dSYM files when given a UUID.			The DebugSymbols.framework framework helps locate dSYM files when given a UUID.
	It can locate the symbols using a variety of methods:			It can locate the symbols using a variety of methods:

	- Spotlight			- Spotlight
	▲ Show 20 Lines • Show All 303 Lines • Show Last 20 Lines

lldb/docs/use/troubleshooting.rst

	Troubleshooting			Troubleshooting
	===============			===============

	.. contents::
	:local:

	File and Line Breakpoints Are Not Getting Hit			File and Line Breakpoints Are Not Getting Hit
	---------------------------------------------			---------------------------------------------

	First you must make sure that your source files were compiled with debug			First you must make sure that your source files were compiled with debug
	information. Typically this means passing -g to the compiler when compiling			information. Typically this means passing -g to the compiler when compiling
	your source file.			your source file.

	When setting breakpoints in implementation source files (.c, cpp, cxx, .m, .mm,			When setting breakpoints in implementation source files (.c, cpp, cxx, .m, .mm,
	▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

lldb/docs/use/tutorial.rst

	Tutorial			Tutorial
	========			========

	Here's a short precis of how to run lldb if you are familiar with the gdb			Here's a short precis of how to run lldb if you are familiar with the gdb
	command set. We will start with some details on lldb command structure and			command set. We will start with some details on lldb command structure and
	syntax to help orient you.			syntax to help orient you.

	.. contents::
	:local:

	Command Structure			Command Structure
	-----------------			-----------------

	Unlike gdb's command set, which is rather free-form, we tried to make the lldb command syntax fairly structured. The commands are all of the form:			Unlike gdb's command set, which is rather free-form, we tried to make the lldb command syntax fairly structured. The commands are all of the form:

	::			::

	<noun> <verb> [-options [option-value]] [argument [argument...]]			<noun> <verb> [-options [option-value]] [argument [argument...]]
	▲ Show 20 Lines • Show All 668 Lines • Show Last 20 Lines

lldb/docs/use/variable.rst

	Variable Formatting			Variable Formatting
	===================			===================

	.. contents::
	:local:

	LLDB has a data formatters subsystem that allows users to define custom display			LLDB has a data formatters subsystem that allows users to define custom display
	options for their variables.			options for their variables.

	Usually, when you type ``frame variable`` or run some expression LLDB will			Usually, when you type ``frame variable`` or run some expression LLDB will
	automatically choose the way to display your results on a per-type basis, as in			automatically choose the way to display your results on a per-type basis, as in
	the following example:			the following example:

	::			::
	▲ Show 20 Lines • Show All 1,283 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[lldb/infrastructure] Revamp lldb.llvm.org
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 553711

lldb/docs/_static/lldb.css

lldb/docs/conf.py

lldb/docs/resources/build.rst

lldb/docs/resources/caveats.rst

lldb/docs/resources/overview.rst

lldb/docs/resources/projects.rst

lldb/docs/resources/test.rst

lldb/docs/use/formatting.rst

lldb/docs/use/intel_pt.rst

lldb/docs/use/map.rst

lldb/docs/use/ondemand.rst

lldb/docs/use/python-reference.rst

lldb/docs/use/python.rst

lldb/docs/use/qemu-testing.rst

lldb/docs/use/remote.rst

lldb/docs/use/symbolication.rst

lldb/docs/use/symbols.rst

lldb/docs/use/troubleshooting.rst

lldb/docs/use/tutorial.rst

lldb/docs/use/variable.rst

This is an archive of the discontinued LLVM Phabricator instance.

[lldb/infrastructure] Revamp lldb.llvm.orgClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 553711

lldb/docs/_static/lldb.css

lldb/docs/conf.py

lldb/docs/resources/build.rst

lldb/docs/resources/caveats.rst

lldb/docs/resources/overview.rst

lldb/docs/resources/projects.rst

lldb/docs/resources/test.rst

lldb/docs/use/formatting.rst

lldb/docs/use/intel_pt.rst

lldb/docs/use/map.rst

lldb/docs/use/ondemand.rst

lldb/docs/use/python-reference.rst

lldb/docs/use/python.rst

lldb/docs/use/qemu-testing.rst

lldb/docs/use/remote.rst

lldb/docs/use/symbolication.rst

lldb/docs/use/symbols.rst

lldb/docs/use/troubleshooting.rst

lldb/docs/use/tutorial.rst

lldb/docs/use/variable.rst

[lldb/infrastructure] Revamp lldb.llvm.org
ClosedPublic