diff --git a/lldb/www/features.html b/lldb/www/features.html index 92431a3..7907723 100755 --- a/lldb/www/features.html +++ b/lldb/www/features.html @@ -1,60 +1,60 @@ LLDB Features
The LLDB Debugger

Features

LLDB supports a broad variety of basic debugging features such as reading DWARF, supporting step, next, finish, backtraces, etc. Some more interested bits are:

  • Plug-in architecture for portability and extensibility:
    • Object file parsers for executable file formats. Support currently includes Mach-O (32 and 64-bit) & ELF (32-bit).
    • Object container parsers to extract object files contained within a file. Support currently includes universal Mach-O files & BSD Archives.
    • Debug symbol file parsers to incrementally extract debug information from object files. Support currently includes DWARF & Mach-O symbol tables.
    • Symbol vendor plug-ins collect data from a variety of different sources for an executable object.
    • Disassembly plug-ins for each architecture. Support currently includes an LLVM disassembler for i386, x86-64 - , & ARM/Thumb.
    • + , ARM/Thumb, and PPC64le
    • Debugger plug-ins implement the host and target specific functions required to debug.
  • SWIG-generated script bridging allows Python to access and control the public API of the debugger library.
  • A remote protocol server, debugserver, implements Mac OS X debugging on i386 and x86-64.
  • A command line debugger - the lldb executable itself.
  • A framework API to the library.
- \ No newline at end of file + diff --git a/lldb/www/index.html b/lldb/www/index.html index 8384995..4b20c76 100755 --- a/lldb/www/index.html +++ b/lldb/www/index.html @@ -1,138 +1,138 @@ LLDB Homepage
The LLDB Debugger

What is LLDB?

LLDB is a next generation, high-performance debugger. It is built as a set of reusable components which highly leverage existing libraries in the larger LLVM Project, such as the Clang expression parser and LLVM disassembler.

LLDB is the default debugger in Xcode on Mac OS X and supports debugging C, Objective-C and C++ on the desktop and iOS devices and simulator.

All of the code in the LLDB project is available under the standard LLVM License, an open source "BSD-style" license.

Why a new debugger?

In order to achieve our goals we decided to start with a fresh architecture that would support modern multi-threaded programs, handle debugging symbols in an efficient manner, use compiler based code knowledge and have plug-in support for functionality and extensions. Additionally we want the debugger capabilities to be available to other analysis tools, be they scripts or compiled programs, without requiring them to be GPL.

Compiler Integration Benefits

LLDB currently converts debug information into clang types so that it can leverage the clang compiler infrastructure. This allows LLDB to support the latest C, C++, Objective C and Objective C++ language features and runtimes in expressions without having to reimplement any of this functionality. It also leverages the compiler to take care of all ABI details when making functions calls for expressions, when disassembling instructions and extracting instruction details, and much more.

The major benefits include:

  • Up to date language support for C, C++, Objective C
  • Multi-line expressions that can declare local variables and types
  • Utilize the JIT for expressions when supported
  • Evaluate expression Intermediate Representation (IR) when JIT can't be used

Reusability

The LLDB debugger APIs are exposed as a C++ object oriented interface in a shared library. The lldb command line tool links to, and uses this public API. On Mac OS X the shared library is exposed as a framework named LLDB.framework, and unix systems expose it as lldb.so. The entire API is also then exposed through Python script bindings which allow the API to be used within the LLDB embedded script interpreter, and also in any python script that loads the lldb.py module in standard python script files. See the Python Reference page for more details on how and where Python can be used with the LLDB API.

Sharing the LLDB API allows LLDB to not only be used for debugging, but also for symbolication, disassembly, object and symbol file introspection, and much more.

Platform Support

LLDB is known to work on the following platforms, but ports to new platforms are welcome:

  • Mac OS X desktop user space debugging for i386 and x86-64
  • iOS simulator debugging on i386
  • iOS device debugging on ARM
  • -
  • Linux local user-space debugging for i386 and x86-64
  • +
  • Linux local user-space debugging for i386, x86-64 and PPC64le
  • FreeBSD local user-space debugging for i386 and x86-64
  • Windows local user-space debugging for i386 (*)

(*) Support for Windows is under active development. Basic functionality is expected to work, with functionality improving rapidly.

Get it and get involved!

To check out the code, use:

  • svn co http://llvm.org/svn/llvm-project/lldb/trunk lldb

Note that LLDB generally builds from top-of-trunk

  • On Mac OS X with Xcode
  • On Linux and FreeBSD (with clang and libstdc++/libc++)
  • On NetBSD (with GCC and clang and libstdc++/libc++)
  • On Windows with VS 2012 or higher using CMake

See the LLDB Build Page for platform-specific build instructions.

Discussions about LLDB should go to the lldb-dev mailing list. Commit messages for the lldb SVN module are automatically sent to the lldb-commits mailing list, and this is also the preferred mailing list for patch submissions.

See the Projects page if you are looking for some interesting areas to contribute to lldb.

diff --git a/lldb/www/status.html b/lldb/www/status.html index 6fc7142..a14e915 100755 --- a/lldb/www/status.html +++ b/lldb/www/status.html @@ -1,227 +1,227 @@ LLDB Status
The LLDB Debugger

Mac OS X Status

LLDB has matured a lot in the last year and can be used for C, C++ and Objective C development for x86_64, i386 and ARM debugging. The entire public API is exposed though a framework on Mac OS X which is used by Xcode, the lldb command line tool, and can also be used by Python. The entire public API is exposed through script bridging which allows LLDB to use an embedded Python script interpreter, as well as having a Python module named "lldb" which can be used from Python on the command line. This allows debug sessions to be scripted. It also allows powerful debugging actions to be created and attached to a variety of debugging workflows.

Linux Status

LLDB is improving on Linux. While the debugserver has not been ported (to enable remote debugging) Linux is nearing feature completeness with Darwin to debug x86_64 programs, and is partially working with i386 programs. ARM architectures on Linux are untested. For more details, see the Features by OS section below.

FreeBSD Status

LLDB on FreeBSD lags behind the Linux implementation but is improving rapidly. For more details, see the Features by OS section below.

Windows Status

LLDB on Windows is still under development, but already useful for i386 programs (x86_64 untested) built with DWARF debug information, including postmortem analysis of minidumps. For more details, see the Features by OS section below.

Features by OS

The table below shows a summary of the features that are available on several platforms. In addition to Linux and Mac OS X, LLDB is also known to work on FreeBSD. NetBSD support is under development. - +
Feature FreeBSD
(x86_64)
Linux
(x86_64)
Linux
(x86_64 and PPC64le)
Mac OS X (i386/x86_64 and ARM/Thumb) Windows (i386)
Backtracing OK OK OK OK
Breakpoints
  • source-line
  • symbolic
  • C++ mangled names
  • module scoping
OK OK OK OK
C++11:
  • function access
  • template support
  • dynamic types
OK OK OK Unknown
Commandline lldb tool OK OK OK OK
Core file debugging OK (ELF) OK (ELF) OK (MachO) OK (Minidump)
Debugserver (remote debugging) Not ported Not ported OK Not ported
Disassembly OK OK OK OK
Expression evaluation Unknown Works with some bugs OK Works with some bugs
JIT debugging Unknown Symbolic debugging only Untested No
Objective-C 2.0:
  • printing properties
  • synthetic properties
  • expressions
  • KVO
  • dynamic types
  • dot syntax
  • runtime data
  • stepping into/over
  • printing the description of an object ("po")
Unknown Not applicable OK Not applicable
Process control
  • attach
  • continue
  • exec, execve...
  • fork
  • launch
  • status
Works, with some bugs OK (except exec*) OK OK
Public Python API OK (Python 2.7) OK (Python 2.7) OK (Python 2.7) OK (Python 3.5)
Registers (x86_64 and i386)
  • general purpose
  • floating point
  • exception state
  • SSE
  • AVX
GP and FP OK OK (except for exception state registers) OK OK (except for AVX support)
Symbol reading and object file introspection OK OK OK OK (no PDB yet)
Thread inspection and stepping OK OK OK OK
Watchpoints OK OK OK Not ported yet