usage

在使用 gdb debug 程式前,
compile 需要加 -g 產生 debug information

gcc -g

usage

在使用 gdb debug 程式前,
compile 需要加 -g 產生 debug information

gcc -g

GDB TO LLDB COMMAND
MAP

1.1. What is debugging?

Debugging allows you to run a program interactively while watching the
source code and the variables during the execution.

breakpoint in the source code specifies where the execution of the
program should stop during debugging. Once the program is stopped you
can investigate variables, change their content, etc.

To stop the execution, if a field is read or modified, you can
specify watchpoints.

 

Breakpoints and watchpoints are sometimes called stop points.

Do not print the introductory and copyright messages.

-quiet
-q “Quiet”. Do not print the introductory and copyright messages. These
messages are also suppressed in batch mode.

$ gdb a.out

GNU gdb (Ubuntu 7.7.1-0ubuntu5~14.04.2) 7.7.1
Copyright (C) 2014 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from a.out...done.
(gdb)

$ gdb -q a.out

Reading symbols from a.out...done.
(gdb)

Do not print the introductory and copyright messages.

-quiet
-q “Quiet”. Do not print the introductory and copyright messages. These
messages are also suppressed in batch mode.

$ gdb a.out

GNU gdb (Ubuntu 7.7.1-0ubuntu5~14.04.2) 7.7.1
Copyright (C) 2014 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from a.out...done.
(gdb)

$ gdb -q a.out

Reading symbols from a.out...done.
(gdb)

Below is a table of GDB commands with the LLDB counterparts. The built
in 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 set“, “br se” is also acceptable.

1.2. Debugging support in Eclipse

Eclipse allows you to start a Java program in Debug mode.

Eclipse provides a Debug perspective which gives you a
pre-configured set of views. Eclipse allows you to control the
execution flow via debug commands.

get the address of variable

(gdb) p &a

get the address of variable

(gdb) p &a

EXECUTION COMMANDS

1.3. Setting Breakpoints

To define a breakpoint in your source code, right-click in the left
margin in the Java editor and select Toggle Breakpoint. Alternatively
you can double-click on this position.

澳门金沙国际 1

For example in the following screenshot we set a breakpoint on the
line Counter counter = new Counter();.

澳门金沙国际 2

 

difference between (gdb)r with (gdb) start

break-through@breakthrough-ThinkPad-T460p:~/working_space/test/5$ gdb -q a.out
Reading symbols from a.out...done.
(gdb) r
Starting program: /home/break-through/working_space/test/5/a.out 
test.a = 1, test.b=2, test.c=3
[Inferior 1 (process 7607) exited normally]
(gdb) p &test.a
No symbol "test" in current context.

break-through@breakthrough-ThinkPad-T460p:~/working_space/test/5$ gdb -q a.out
Reading symbols from a.out...done.
(gdb) start
Temporary breakpoint 1 at 0x400535: file container_of.c, line 11.
Starting program: /home/break-through/working_space/test/5/a.out 

Temporary breakpoint 1, main () at container_of.c:11
11          test.a = 1;
(gdb) p &test.a
$1 = (int *) 0x7fffffffddb0

difference between (gdb)r with (gdb) start

break-through@breakthrough-ThinkPad-T460p:~/working_space/test/5$ gdb -q a.out
Reading symbols from a.out...done.
(gdb) r
Starting program: /home/break-through/working_space/test/5/a.out 
test.a = 1, test.b=2, test.c=3
[Inferior 1 (process 7607) exited normally]
(gdb) p &test.a
No symbol "test" in current context.

break-through@breakthrough-ThinkPad-T460p:~/working_space/test/5$ gdb -q a.out
Reading symbols from a.out...done.
(gdb) start
Temporary breakpoint 1 at 0x400535: file container_of.c, line 11.
Starting program: /home/break-through/working_space/test/5/a.out 

Temporary breakpoint 1, main () at container_of.c:11
11          test.a = 1;
(gdb) p &test.a
$1 = (int *) 0x7fffffffddb0

GDBLLDB

1.4. Starting the Debugger

To debug your application, select a Java file with a main method.
Right-click on it and select Debug As ▸ Java
Application.

澳门金沙国际 3

 

If you started an application once via the context menu, you can use the created launch configuration again via the Debug button in the Eclipse toolbar.

澳门金沙国际 4

If you have not defined any breakpoints, program as normally. To debug
the program you need to define breakpoints. Eclipse asks you if you want
to switch to the Debug perspective once a stop point is reached.
Answer Yes in the corresponding dialog. Afterwards Eclipse opens
this perspective.

澳门金沙国际 5

print source code

(gdb) list

print source code

(gdb) list

Launch a process no arguments.

1.5. Controlling the program execution

Eclipse provides buttons in the toolbar for controlling the execution of
the program you are debugging. Typically, it is easier to use the
corresponding keys to control this execution.

澳门金沙国际 ,You can use allow use shortcut key to step through your coding. The
meaning of these keys is explained in the following table.

Table 1. Debugging key bindings / shortcuts
Key Description

F5

Executes the currently selected line and goes to the next line in your program. If the selected line is a method call the debugger steps into the associated code.

F6

F6 steps over the call, i.e. it executes a method without stepping into it in the debugger.

F7

F7 steps out to the caller of the currently executed method. This finishes the execution of the current method and returns to the caller of this method.

F8

F8 tells the Eclipse debugger to resume the execution of the program code until is reaches the next breakpoint or watchpoint.

The following picture displays the buttons and their related keyboard
shortcuts.

澳门金沙国际 6

The call stack shows the parts of the program which are currently
executed and how they relate to each other. The current stack is
displayed in the Debug view.

澳门金沙国际 7

Display assemble code

(gdb) disassemble

Display assemble code

(gdb) disassemble

(gdb)run

1.6. Breakpoints view and deactivating breakpoints

The Breakpoints view allows you to delete and
deactivate breakpoints and watchpoints. You can also modify their
properties.

To deactivate a breakpoint, remove the corresponding checkbox in
the Breakpoints view. To delete it you can use the corresponding
buttons in the view toolbar. These options are depicted in the following
screenshot.

澳门金沙国际 8

If you want to disable all breakpoints at the same time, you can press
the Skip all breakpoints button. If you press it
again, your breakpoints are reactivated. This button is highlighted in
the following screenshot.

澳门金沙国际 9

Setting breakpoint

(gdb) b line_number

Setting breakpoint

(gdb) b line_number

(gdb)r(lldb)process launch

1.7. Evaluating variables in the debugger

The Variables view displays fields and local variables from the
current executing stack. Please note you need to run the debugger to see
the variables in this view.

澳门金沙国际 10

 

As of Eclipse 4.7 you also see the return statement of the last method call in the debugger.

Use the drop-down menu to display static variables.

澳门金沙国际 11

Via the drop-down menu of the Variables view you can customize the
displayed columns.

For example, you can show the actual type of each variable declaration.
For this select Layout ▸ Select Columns…​ ▸ Type.

澳门金沙国际 12

Clear breakpoint

(gdb) clear line_number

Clear breakpoint

(gdb) clear line_number

(lldb)run

1.8. Changing variable assignments in the debugger

The Variables view allows you to change the values assigned to your
variable at runtime. This is depicted in the following screenshot.

澳门金沙国际 13

Deleting all breakpoints

(gdb) delete

Deleting all breakpoints

(gdb) delete

gdb。(lldb)r

1.9. Controlling the display of the variables with Detail Formatter

By default the Variables view uses the toString() method to
determine how to display the variable.

You can define a Detail Formatter in which you can use Java code to
define how a variable is displayed.

For example, the toString() method in the Counter class may show
meaningless information, e.g. com.vogella.combug.first.Counter@587c94.
To make this output more readable you can right-click on the
corresponding variable and select the New Detail
Formater…​ entry from the context menu.

澳门金沙国际 14

Afterwards you can use a method of this class to determine the output.
In this example the getResult() method of this class is used. This
setup is depicted in the following screenshot.

澳门金沙国际 15

 

Continue running your program (after stopping, e.g. at a breakpoint).

(gdb) c

Continue running your program (after stopping, e.g. at a breakpoint).

(gdb) c

Launch a process with arguments.

2. Advanced Debugging

The following section shows more options you have for debugging.

Execute next program line

Execute next program line

(gdb)run

2.1. Breakpoint properties

After setting a breakpoint you can select the properties of the
breakpoint, via right-click ▸ Breakpoint Properties.
Via the breakpoint properties you can define a condition that restricts
the activation of this breakpoint.

You can for example specify that a breakpoint should only become active
after it has reached 12 or more times via the Hit Countproperty.

You can also create a conditional expression. The execution of the
program only stops at the breakpoint, if the condition evaluates to
true. This mechanism can also be used for additional logging, as the
code that specifies the condition is executed every time the program
execution reaches that point.

The following screenshot depicts this setting.

澳门金沙国际 16

澳门金沙国际 17

Step into

(gdb) step

Step into

(gdb) step

(gdb)r (lldb)process launch —

2.2. Watchpoint

watchpoint is a breakpoint set on a field. The debugger will stop
whenever that field is read or changed.

You can set a watchpoint by double-clicking on the left margin, next
to the field declaration. In the properties of a watchpoint you can
configure if the execution should stop during read access (Field Access)
or during write access (Field Modification) or both.

澳门金沙国际 18

Step over

(gdb) next

Step over

(gdb) next

(lldb)r

2.3. Exception breakpoints

You can set breakpoints for thrown exceptions. To define an exception
breakpoint click on the Add Java Exception
Breakpoint button icon in the Breakpoints view toolbar.

澳门金沙国际 19

You can configure, if the debugger should stop at caught or uncaught
exceptions.

Watchpoint

Watchpoint

Launch a process for with argumentsa.out 1 2 3without having to
supply the args every time.

2.4. Method breakpoint

A method breakpoint is defined by double-clicking in the left margin of
the editor next to the method header.

You can configure if you want to stop the program before entering or
after leaving the method.

澳门金沙国际 20

Setting watchpoint

(gdb) watch variable_name

(gdb) start
(gdb) watch variable_name
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
 .....
 .....
 .....

(gdb) start
(gdb) watch variable1_name - 5 + variable2_name
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
 .....
 .....
 .....

(gdb) start
(gdb) watch *memory_address
(gdb) c
 // display the old content and new content of the memory_address if the content changes.
(gdb) c
 // display the old content and new content of the memory_address if the content changes.
(gdb) c
 // display the old content and new content of the memory_address if the content changes.
 .....
 .....
 .....

Setting watchpoint

(gdb) watch variable_name

(gdb) start
(gdb) watch variable_name
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
 .....
 .....
 .....

(gdb) start
(gdb) watch variable1_name - 5 + variable2_name
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
(gdb) c
 // display the old value and new value of the variable if the value changes.
 .....
 .....
 .....

(gdb) start
(gdb) watch *memory_address
(gdb) c
 // display the old content and new content of the memory_address if the content changes.
(gdb) c
 // display the old content and new content of the memory_address if the content changes.
(gdb) c
 // display the old content and new content of the memory_address if the content changes.
 .....
 .....
 .....

%gdb –args a.out 1 2 3

2.5. Breakpoints for loading classes

A class load breakpoint stops when the class is loaded.

To set a class load breakpoint, right-click on a class in
the Outline view and choose the Toggle Class Load Breakpoint option.

澳门金沙国际 21

Alternative you can double-click in the left border of the Java editor
beside the class definition.

Deleting all watchpoints

(gdb) delete

Deleting all watchpoints

(gdb) delete

(gdb)run

2.6. Step Filter

You can define that certain packages should be skipped in debugging.
This is for example useful if you use a framework for testing but don’t
want to step into the test framework classes. These packages can be
configured via the Window ▸ Preferences ▸ Java ▸ Debug ▸ Step Filtering menu
path.

Display register value

movl   $0x6,-0x4(%rbp)

(gdb) p $rbp-0x4

Display register value

movl   $0x6,-0x4(%rbp)

(gdb) p $rbp-0x4

2.7. Hit Count

For every breakpoint you can specify a hit count in its properties. The
application is stopped once the breakpoint has been reached the number
of times defined in the hit count.

Show both source code and assemble code split using TUI (Text User Interface) mode.

gdb -tui <your-binary>

(gdb) layout split
(gdb) start

澳门金沙国际 22


Show both source code and assemble code split using TUI (Text User Interface) mode.

gdb -tui <your-binary>

(gdb) layout split
(gdb) start

澳门金沙国际 23


(gdb)run

2.8. Remote debugging

Eclipse allows you to debug applications which runs on another Java
virtual machine or even on another machine.

To enable remote debugging you need to start your Java application with
certain flags, as demonstrated in the following code example.

java -Xdebug -Xnoagent \
-Djava.compiler=NONE \
-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005

In you Eclipse IDE you can enter the hostname and port to connect for
debugging via the Run ▸ Debug Configuration…​ menu.

Here you can create a new debug configuration of the Remote Java
Application
 type. This configuration allows you to enter the hostname
and port for the connection as depicted in the following screenshot.

澳门金沙国际 24

NOTE:Remote debugging requires that you have the source code of the
application which is debugged available in your Eclipse IDE.

Show both source code and assemble code mixed.

(gdb) disassemble /m

澳门金沙国际 25


Show both source code and assemble code mixed.

(gdb) disassemble /m

澳门金沙国际 26


2.9. Drop to frame

Eclipse allows you to select any level (frame) in the call stack during
debugging and set the JVM to restart from that point.

This allows you to rerun a part of your program. Be aware that variables
which have been modified by code that already run will remain modified.

To use this feature, select a level in your stack and press the Drop to
Frame
 button in the toolbar of the Debug view.

  Fields and external data may not be affected by the reset. For example if you write a entry to the database and afterward drop to a previous frame, this entry is still in the database.

The following screenshot depicts such a reset. If you restart
your for loop, the field result is not set to its initial value and
therefore the loop is not executed as without resetting the execution to
a previous point.

澳门金沙国际 27

Reference:

太多了!
To be continued

Reference:

太多了!
To be continued

%lldb — a.out 1 2 3

3. Exercise: Create Project for debugging

(lldb)run

3.1. Create Project

To practice debugging create a new Java project
called de.vogella.combug.first. Also create the
packagede.vogella.combug.first and create the following classes.

package de.vogella.combug.first;

public class Counter {
  private int result = 0;

  public int getResult() {
    return result;
  }

  public void count() {
    for (int i = 0; i < 100; i++) {
      result += i + 1;
    }
  }
}

package de.vogella.combug.first;

public class Main {
  /**
   * @param args
   */
  public static void main(String[] args) {
    Counter counter = new Counter();
    counter.count();
    System.out.println("We have counted "
        + counter.getResult());
  }
}

 

 

 

(lldb)run

Or:

(gdb)set args 1 2 3

(gdb)run

(gdb)run

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

(lldb)run

(lldb)run

Launch a process with arguments in new terminal window (Mac OS X only).

(lldb)process launch –tty —

(lldb)pro la -t —

Launch a process with arguments in existing terminal/dev/ttys006 (Mac OS
X only).

(lldb)process launch –tty=/dev/ttys006 —

(lldb)pro la -t/dev/ttys006 —

Set environment variables for process before launching.

(gdb)set env DEBUG 1

(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.

(gdb)unset env DEBUG

(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.

(gdb)show args

Argument list to give program being debugged when it is started is “1 2
3”.

(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.

(lldb)process launch -v DEBUG=1

Attach to a process with process ID 123.

(gdb)attach 123(lldb)process attach –pid 123

(lldb)attach -p 123

Attach to a process named “a.out”.

(gdb)attach a.out(lldb)process attach –name a.out

(lldb)pro at -n a.out

Wait for a process named “a.out” to launch and attach.

(gdb)attach -waitfor a.out(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.

(gdb)target remote eorgadd:8000(lldb)gdb-remote eorgadd:8000

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

(gdb)target remote localhost:8000(lldb)gdb-remote 8000

Attach to a Darwin kernel in kdp mode on system “eorgadd”.

(gdb)kdp-reattach eorgadd(lldb)kdp-remote eorgadd

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

(gdb)step

(gdb)s(lldb)thread step-in

(lldb)step

(lldb)s

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

(gdb)next

(gdb)n(lldb)thread step-over

(lldb)next

(lldb)n

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

(gdb)stepi

(gdb)si(lldb)thread step-inst

(lldb)si

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

(gdb)nexti

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

(lldb)ni

Step out of the currently selected frame.

(gdb)finish

(lldb)thread step-out

(lldb)finish

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

(gdb)return

(lldb)thread return

Backtrace and disassemble every time you stop.

(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 line12or control leaves the current function.

(gdb)until 12(lldb)thread until 12

BREAKPOINT COMMANDS

GDBLLDB

Set a breakpoint at all functions namedmain.

(gdb)break main(lldb)breakpoint set –name main

(lldb)br s -n main

(lldb)b main

Set a breakpoint in filetest.cat line12.

(gdb)break test.c:12(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 ismain.

(gdb)break main

(Hope that there are no C functions
namedmain)
.(lldb)breakpoint set –method main

(lldb)br s -M main

Set a breakpoint at and object C function:-[NSString
stringWithFormat:]
.

(gdb)break -[NSString stringWithFormat:]

(lldb)breakpoint set –name “-[NSString stringWithFormat:]”

(lldb)b -[NSString stringWithFormat:]

Set a breakpoint at all Objective C methods whose selector iscount.

(gdb)break count

(Hope that there are no C or C++ functions
namedcount)
.(lldb)breakpoint set –selector count

(lldb)br s -S count

Set a breakpoint by regular expression on function name.

(gdb)rbreak regular-expression

(lldb)breakpoint set –func-regex regular-expression

(lldb)br s -r regular-expression

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

(gdb)b foo.c:12

(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.

(gdb)shell grep -e -n pattern source-file

(gdb)break source-file:CopyLineNumbers

(lldb)breakpoint set –source-pattern regular-expression –file
SourceFile

(lldb)br s -p regular-expression -f file

Set a conditional breakpoint

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

(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.

(gdb)info break

(lldb)breakpoint list

(lldb)br l

Delete a breakpoint.

(gdb)delete 1

(lldb)breakpoint delete 1

(lldb)br del 1

WATCHPOINT COMMANDS

GDBLLDB

Set a watchpoint on a variable when it is written to.

(gdb)watch global_var(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.

(gdb)watch -location g_char_ptr(lldb)watchpoint set expression
— my_ptr

(lldb)wa s e — my_ptr

Set a condition on a watchpoint.

(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

List all watchpoints.

(gdb)info break

(lldb)watchpoint list

(lldb)watch l

Delete a watchpoint.

(gdb)delete 1

(lldb)watchpoint delete 1

(lldb)watch del 1

EXAMINING VARIABLES

GDBLLDB

Show the arguments and local variables for the current frame.

(gdb)info args

and

(gdb)info locals

(lldb)frame variable

(lldb)fr v

Show the local variables for the current frame.

(gdb)info locals

(lldb)frame variable –no-args

(lldb)fr v -a

Show the contents of local variable “bar”.

(gdb)p bar

(lldb)frame variable bar

(lldb)fr v bar

(lldb)p bar

Show the contents of local variable “bar” formatted as hex.

(gdb)p/x bar

(lldb)frame variable –format x bar

(lldb)fr v -f x bar

Show the contents of global variable “baz”.

(gdb)p baz

(lldb)target variable baz

(lldb)ta v baz

Show the global/static variables defined in the current source file.

n/a

(lldb)target variable

(lldb)ta v

Display the variables “argc” and “argv” every time you stop.

(gdb)display argc

(gdb)display argv

(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 namedmain.

(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
namedMyClass.

(lldb)target stop-hook add –classname MyClass –one-liner “frame
variable *this”

(lldb)ta st a -c MyClass -o “fr v *this”

EVALUATING EXPRESSIONS

GDBLLDB

Evaluating a generalized expression in the current frame.

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

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

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

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

or using the print alias:

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

Creating and assigning a value to a convenience variable.

(gdb)set $foo = 5

(gdb)set variable $foo = 5

or using the print command

(gdb)print $foo = 5

or using the call command

(gdb)call $foo = 5

and if you want to specify the type of the variable:(gdb)set $foo =
(unsigned int) 5

In lldb you evaluate a variable declaration expression as you would
write it in C:

(lldb)expr unsigned int $foo = 5

Printing the ObjC “description” of an object.

(gdb)po [SomeClass returnAnObject]

(lldb)expr -o — [SomeClass returnAnObject]

or using the po alias:

(lldb)po [SomeClass returnAnObject]

Print the dynamic type of the result of an expression.

(gdb)set print object 1

(gdb)p someCPPObjectPtrOrReference

only works for C++ objects.

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

(lldb)expr -d 1 — someCPPObjectPtrOrReference

or set dynamic type printing to be the default:(lldb)settings set
target.prefer-dynamic run-target

Calling a function so you can stop at a breakpoint in the function.

(gdb)set unwindonsignal 0

(gdb)p function_with_a_breakpoint()

(lldb)expr -i 0 — function_with_a_breakpoint()

Calling a function that crashes, and stopping when the function crashes.

(gdb)set unwindonsignal 0

(gdb)p function_which_crashes()

(lldb)expr -u 0 — function_which_crashes()

EXAMINING THREAD STATE

GDBLLDB

Show the stack backtrace for the current thread.

(gdb)bt

(lldb)thread backtrace

(lldb)bt

Show the stack backtraces for all threads.

(gdb)thread apply all bt(lldb)thread backtrace all

(lldb)bt all

Backtrace the first five frames of the current thread.

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

(lldb)bt 5 (lldb-169 and later)

(lldb)bt -c 5 (lldb-168 and earlier)

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

(gdb)frame 12(lldb)frame select 12

(lldb)fr s 12

(lldb)f 12

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

(lldb)frame info

Select the stack frame that called the current stack frame.

(gdb)up(lldb)up

(lldb)frame select –relative=1

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

(gdb)down(lldb)down

(lldb)frame select –relative=-1

(lldb)fr s -r-1

Select a different stack frame using a relative offset.

(gdb)up 2

(gdb)down 3

(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.

(gdb)info registers

(lldb)register read

Write a new decimal value ‘123’ to the current thread register ‘rax’.

(gdb)p $rax = 123

(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.

(gdb)jump *$pc+8

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

Show the general purpose registers for the current thread formatted
assigned decimal. LLDB tries to use the same format characters
asprintf(3)when possible. Type “help format” to see the full list of
format specifiers.

(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:

(lldb)register read/d

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

(gdb)info all-registers

(lldb)register read –all

(lldb)re r -a

Show the values for the registers named “rax”, “rsp” and “rbp” in the
current thread.

(gdb)info all-registers rax rsp rbp

(lldb)register read rax rsp rbp

Show the values for the register named “rax” in the current thread
formatted asbinary.

(gdb)p/t $rax

(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:

(lldb)register read/t rax

(lldb)p/t $rax

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

(gdb)x/4xw 0xbffff3c0

(lldb)memory read –size 4 –format x –count 4 0xbffff3c0

(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:

(lldb)memory read/4xw 0xbffff3c0

(lldb)x/4xw 0xbffff3c0

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

Read memory starting at the expression “argv[0]”.

(gdb)x argv[0]

(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:*

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

Read 512 bytes of memory from address 0xbffff3c0 and save results to a
local file astext.

(gdb)set logging on

(gdb)set logging file /tmp/mem.txt

(gdb)x/512bx 0xbffff3c0

(gdb)set logging off

(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.

(gdb)dump memory /tmp/mem.bin 0x1000 0x2000(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 (available on Mac OS X
only).

(gdb)info malloc 0x10010d680(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 (available on Mac OS X only)

(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 (available on Mac OS X only).

(lldb)command script import lldb.macosx.heap

(lldb)ptr_refs EXPR

Find all heap blocks that contain a C string anywhere in the block
(available on Mac OS X only).

(lldb)command script import lldb.macosx.heap

(lldb)cstr_refs CSTRING

Disassemble the current function for the current frame.

(gdb)disassemble(lldb)disassemble –frame

(lldb)di -f

Disassemble any functions namedmain.

(gdb)disassemble main(lldb)disassemble –name main

(lldb)di -n main

Disassemble an address range.

(gdb)disassemble 0x1eb8 0x1ec3(lldb)disassemble –start-address
0x1eb8 –end-address 0x1ec3

(lldb)di -s 0x1eb8 -e 0x1ec3

Disassemble 20 instructions from a given address.

(gdb)x/20i 0x1eb8(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.

n/a(lldb)disassemble –frame –mixed

(lldb)di -f -m

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

n/a(lldb)disassemble –frame –bytes

(lldb)di -f -b

Disassemble the current source line for the current frame.

n/a(lldb)disassemble –line

(lldb)di -l

EXECUTABLE AND SHARED LIBRARY QUERY COMMANDS

GDBLLDB

List the main executable and all dependent shared libraries.

(gdb)info shared

(lldb)image list

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

(gdb)info symbol 0x1ec4

(lldb)image lookup –address 0x1ec4

(lldb)im loo -a 0x1ec4

Look up functions matching a regular expression in a binary.

(gdb)info function

This one finds debug symbols:

(lldb)image lookup -r -n

This one finds non-debug symbols:

(lldb)image lookup -r -s

Provide a list of binaries as arguments to limit the search.

Find full source line information.

(gdb)info line 0x1ec4

This one is a bit messy at present. Do:

(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 ina.outonly.

(lldb)image lookup –address 0x1ec4 a.out

(lldb)im loo -a 0x1ec4 a.out

Look up information for for a typePointby name.

(gdb)ptype Point

(lldb)image lookup –type Point

(lldb)im loo -t Point

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

(gdb)maintenance info sections

(lldb)image dump sections

Dump all sections in thea.outmodule.

(lldb)image dump sections a.out

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

(lldb)image dump symtab

Dump all symbols ina.outandliba.so.

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

MISCELLANEOUS

GDBLLDB

Echo text to the screen.

(gdb)echo Here is some text\n

(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
— maybe 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.

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

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

Supply a catchall directory to search for source files in.

(gdb)directory /my/path

(No equivalent command – use the source-map instead.)

相关文章