SkyEye User Manual

From Skyeye_wiki

Jump to: navigation, search
Language: English  • 中文

SkyEye Users' Manual

Skyeye ¨C 1.3.2

Maintainer: Michael Kang


Translated to English by: Aditya P. Bankar


January 26, 2011



The first chapter gives introduction to the software and explains the installation process.

1.1 Introduction

SkyEye is a multi-architecture, multi-core, and highly scalable hardware simulation platform. Cur- rently it is implemented by the core library and a series of plug-ins based on the composition of the core library. SkyEye supports the system structure of ARM, Blackfin, Coldfire, PowerPC, MIPS, SPARC and x86.

SkyEye's o cial website is, currently Wangyonghao is responsible for the maintenance. SkyEye's source code is available through the svn repository for maintenance, its address is:

Michael.Kang is currently responsible for maintenance and management of SkyEye's source co de. A go ogle group is currently used as a discussion forum by the developers of SkyEye:

Topics discussed in this forum include the various problems encountered in the development and the variety of ideas related to SkyEye. Information about the latest release of SkyEye will be first published in this forum. SkyEye in total includes two packages, one for SkyEye release version of the package, and the test suite for the SkyEye package. These two packages will be released with the same version number.

1.2 Installation

Skyeye, like most other Linux utilities, can be installed using RPM, synaptic package manager or by compiling from source.

1.2.1 Installing binary package from rpm

The Skyeye RPM is available at:

For installation you need to execute following command, with super user privileges on your terminal:

rpm -ivh skyeye-1.2.9-rc1.i386.rpm

This way the software gets installed in /opt/skyeye directory.

1.2.2 Installing binary package using synaptic package manager

On a Ubuntu system you can open the synaptic package manager's graphical window and search for Skyeye. You can then choose to install it. You can also type "sudo apt-get install skyeye" on the terminal to install Skyeye.

1.2.3 Installing from source

Most of the times the most recent version would not be available in the form of any binary package. For most enthusiastic users installing by compiling the source code them self is the right choice. Download the source code from

then exe-cute the following steps on a shell:


Configures the source package according to the your system. It dumps Makefiles which are used by compilation and installation. The default prefix directory for this configure script is /opt

make lib 

This step compiles the third party libraries required by the Skyeye's source code


Compile Skyeye's source code

make install_lib
make install 

These two step compete the installation process

Remember to update your path variable.

1.3 Directory structure of SkyEye

By default Skyeye installs in /opt/skyeye directory. This directory has the following directory structure.

1.3.1 Description of each directory

The bin directory The bin directory contains binaries of the SkyEye package. This includes: 1. skyeye: This is the SkyEye command application 2. skyeye-gui: This is the graphical SkyEye application


                                               Figure 1.1: Directory structure of SkyEye

3. mknandflash: This utility is used to convert an image in nand- ash format 4. uart instance: This utility is used to display the data sent to UART as text on xterm

The conf directory The conf directory contains the address of the target board. It has a number of configuration files, for reference.

The include directory It includes directory has a catalog of header files used during development of plug-ins, these header files provide prototype of API functions provided by skyeye.

The info directory The info directory contains the info format, this is temporarily not available.

The lib directory The lib directory contains the core of the skyeye library and some other sto cks in the dynamic plug-ins.

The testutils directory The testsuite directory has got simple tests used to demonstrate some of the features of SkyEye.

Getting Started

This chapter explains how to launch SkyEye and run short programs on it.

2.1 Running the command line application

If you have exactly followed the steps described in the previous chapter for installation then running the command:

will launch the SkyEye command line application. Alternatively, you can set your path variable
to contain /opt/skyeye/bin, so just typing skyeye will invoke the command line application.
Once SkyEye starts it prints following messages:
ksh@linux-gvai:/opt/skyeye> /opt/skyeye/bin/skyeye
SkyEye is an Open Source project under GPL. All rights of di erent parts
or mo dules are reserved by their author. Any modification or redistributions
of SkyEye should note remove or modify the annoucement of SkyEye copyright.
Get more information about it, please visit the homepage
Type "help" to get command list.

Now instead of the bash prompt you shall see the "(skyeye)" prompt until you terminate skyeye. A small testcase lies in the skyeye installation directory. It is the popular "hello world" program. It is available in the directory testsuite/arm hello. It doesn't depend upon any operating system. It is ideal for basic learning purpose. Execute the command "skyeye -e arm hello" command, to enter the skyeye command-line interface, the output is as follows:

ksh@linux-gvai:/opt/skyeye/testsuite/arm hello> /opt/skyeye/bin/skyeye -e
arm hello
SkyEye is an Open Source project under GPL. All rights of di erent parts
or modules are reserved by their author. Any mo dification or redistributions
of SkyEye should note remove or modify the annoucement of SkyEye copyright.
Get more information about it, please visit the homepage
Type "help" to get command list.
On this new "(skyeye)" prompt type start to get started. The moment you type start the machine
that is being emulated gets initialized with some default configuration automatically loaded. You
would see the following on the screen:
arch: arm
cpu info: armv3, arm7tdmi, 41007700,  f8 00, 0
In do mach option, mach info: name at91, mach init addr 0xb68b2360
uart mod:3, desc in:, desc out:, converter:
In create uart console
SKYEYE: use arm7100 mmu ops
exec file "arm hello"'s format is elf32-i386.
load section .text: addr = 0x01000000 size = 0x00000084.
In tea write, load base=0x0,load mask=0x
load section .glue 7: addr = 0x01000084 size = 0x00000000.
load section .glue 7t: addr = 0x01000084 size = 0x00000000.
load section .data: addr = 0x01002000 size = 0x00001000.
In tea write, load base=0x0,load mask=0x
not load section .bss: addr = 0x01003000 size = 0x00000000 .
not load section .debug abbrev: addr = 0x00000000 size = 0x0000004e .
not load section .debug info: addr = 0x00000000 size = 0x00000187 .
not load section .debug line: addr = 0x00000000 size = 0x000000a9 .
not load section .debug pubnames: addr = 0x00000000 size = 0x0000001c .
not load section .debug aranges: addr = 0x00000000 size = 0x00000020 .
In SIM start, Set PC to the address 0x1000000

At the same time the host will be displayed on an xterm window, with the title as "uart instance". Screenshot of which is given below:


                                        The xterm window showing uart instance.

Now type the "run" command to start executing the hello world testcase within SkyEye. This action will produce following output: After the run command the hello world program keeps running and the prompt has changed to (running). You can enter di erent commands on this prompt. By entering "stop" at any time the operation stops, the prompt changes back to (skyeye). After stopping the execution we can type the command "info registers" to view the content of the CPU registers. Refer to the set of commands below:


                                                 Figure 2.2: Executing program
(skyeye)info registers
R0 0xf4240
R1 0x fd001c
R2 0xa
R3 0x58b0e
R4 0x0
R5 0x0
R6 0x0
R7 0x0
R8 0x0
R9 0x0
R10 0x0
R11 0x1001 c
R12 0x1000078
R13 0x1001 0
LR 0x1000018
PC 0x100004c

SkyEye also lets you disassemble the code that you are running:

(skyeye)disassemble 0x100004c
cmp r3, r0
mov r2, #0 ; 0x0
ldrb r3, [ip, r2]
add r2, r2, #1 ; 0x1
cmp r2, #9 ; 0x9
str r3, [r1]
tsteq r0, r8, ror r0

The SkyEye command list

3.1 Debugging commands

3.1.1 The break command

Syntax: break [Breakpoint address] Description: Used to insert a breakpoint at the specified address Example:

(skyeye) break 0x1000050

Insertion of a breakpoint at 0x1000050 done successfully

3.1.2 The list-bp command

Syntax: list-bp Description: It lists all the breakpoints inserted by the break command. Example:

(skyeye) list-bp
ID Address
1 0x1000050

3.1.3 The show-step command

Syntax: show-step Description: It shows the number of currently running instruction Example:

(skyeye) show-step
steps: 5276005

3.1.4 The stepi command

Syntax: stepi [number of instructions] Description: You can specify the number of instructions to be executed. Example:

(skyeye) stepi 100
In skyeye stepi, stopped step ¡¥

3.1.5 The x command

Syntax: x [address of memory] Description: Displays the data stored at the specified physical memory address Example:

(skyeye) x 0x129f798
0x129f798 : 0xac85 f8

3.1.6 The disassemble command

Syntax: disassemble [The address of memory] Description: Disassembles the instruction at the specified physical memory location Example:

(skyeye) disassemble 0x129f798
stcge 15, cr15, [r5], (248)
stcge 15, cr15, [r5], (252)
strne pc, [r4, # -4078]!
andeq r0, r0, r0
stfccd f0, [r9], (42)
strcs pc, [r9, # -2044]!
teqeq r8, r3, lsr # 16
teqeq r0, r8
addeq r2, r8, r1, lsr # 32
stcge 15, cr15, [r5], (192)

3.1.7 The info registers command

Syntax: info registers Description: Displays all the CPU registers Example:

(skyeye) info registers
R0 0x0
R1 0x81560000
R2 0x87ec8000
R3 0x812d0e50
R4 0x87ec8d00
R5 0x0
R6 0x1000
R7 0x400
R8 0x0
R9 0x87ec9000
R10 0xac220000
R11 0x8f81801c
R12 0x0
R13 0x400
R14 0xa
R15 0x24217174
R16 0x819cf710
R17 0x87ec8000
R18 0x0
R19 0x819cf710
R20 0x87fdfdec
R21 0x400
R22 0x87fae420
R23 0x819cf710
R24 0x0
R25 0x2
R26 0x87febd08
R27 0x87febd08
R28 0x87fea000
R29 0x87febcc8
R30 0x87fae4cc
R31 0x81293584
PC 0x8129f798

3.2 Commands related to target board and operating environment

3.2.1 The list-options command

Syntax: list-options Description: Displays the current configuration file which includes options supported by skyeye Example:

(skyeye) list-options
Option Name Description
nand ash
cpu Processor option for arm architecture.
uart Uart settings
net Netcard settings
mach machine option
mem bank
arch support di erent architectures.
cpu Do not need to provide cpu option any more.

3.2.2 The show-map command

Syntax: show-map Description: Displays the current address distribution, as well as di erent devices that share the address space Example:

(skyeye) show-map
Start Addr Length Type
0xc0000000 0xc1000000 memory
0xc1000000 0xc1600000 memory
0xc1600000 0xc2000000 memory
0x48000000 0x68000000 IO
0x19000300 0x19000320 IO

3.2.3 The show-pref command

Syntax: show-pref Description: Displays the currently chosen options for SkyEye. These options can be specified for the command line or graphical mode of SkyEye. Example:

(skyeye) show-pref
Module search directories: /opt/skyeye/lib/skyeye/
Boot address: 0x0
Executable file: (null)
Load base for executable file: 0x0
Load mask for executable file: 0x0
SkyEye config file: skyeye.conf
Endian of exec file: Little endian

3.2.4 The list-modules command

Syntax: list-modules Description: Lists all the modules and the dynamic library (or shared objects)files loaded Example:

(skyeye) list-modules
Module Name File Name
nand ash /opt/skyeye/lib/skyeye/libnand
arm /opt/skyeye/lib/skyeye/
log-pc /opt/skyeye/lib/skyeye/
bfin /opt/skyeye/lib/skyeye/
log-pc /opt/skyeye/lib/skyeye/
uart /opt/skyeye/lib/skyeye/
disassemble /opt/skyeye/lib/skyeye/
mips /opt/skyeye/lib/skyeye/
net /opt/skyeye/lib/skyeye/
co de cov /opt/skyeye/lib/skyeye/
sparc /opt/skyeye/lib/skyeye/
ppc /opt/skyeye/lib/skyeye/
touchscreen /opt/skyeye/lib/skyeye/
coldfire /opt/skyeye/lib/skyeye/
ash /opt/skyeye/lib/skyeye/lib
lcd /opt/skyeye/lib/skyeye/
gdbserver /opt/skyeye/lib/skyeye/

3.2.5 The list-machines command

Syntax: list-machines Description: Lists all the pro cessors that the simulator can current support. Example:

(skyeye) list-machines
Machine Name
sharp lh7a400
pxa mainstone
pxa lubbock

3.3 Target board control commands

3.3.1 The start command

Syntax: start Description: Loads the configuration and initializes the environment. Example:

(skyeye) start
arch: mips
Error: Unknown cpu name "mips"
"cpu" option parameter error!
In do mach option, mach info: name gs32eb1, mach init addr 0xb7937d20
Unkonw option: log
uart mod:3, desc in:, desc out:, converter:
In create uart console
In skyeye read config, Config format is wrong.
exec file "vmlinux"'s format is elf32-i386.
load section .text: addr = 0x81200000 size = 0x000ad2a0.
In tea write, load base=0x0,load mask=0x   f
load section .fixup: addr = 0x812ad2a0 size = 0x0000107c.
In tea write, load base=0x0,load mask=0x   f
load section .kstrtab: addr = 0x812ae31c size = 0x0000217c.
In tea write, load base=0x0,load mask=0x   f
load section ex table: addr = 0x812b04a0 size = 0x00001608.
In tea write, load base=0x0,load mask=0x   f
load section dbe table: addr = 0x812b1aa8 size = 0x00000000.
load section ksymtab: addr = 0x812b1aa8 size = 0x000010c8.
In tea write, load base=0x0,load mask=0x   f
load section .data.init task: addr = 0x812b4000 size = 0x00002000.
In tea write, load base=0x0,load mask=0x   f
load section .text.init: addr = 0x812b6000 size = 0x000092f8.
In tea write, load base=0x0,load mask=0x   f
load section .data.init: addr = 0x812bf2f8 size = 0x000003b0.
In tea write, load base=0x0,load mask=0x   f
load section .setup.init: addr = 0x812bf6b0 size = 0x000000a0.
In tea write, load base=0x0,load mask=0x   f
load section .initcall.init: addr = 0x812bf750 size = 0x0000004c.
In tea write, load base=0x0,load mask=0x   f
load section .data.cacheline aligned: addr = 0x812c0000 size = 0x00001180.
In tea write, load base=0x0,load mask=0x   f
load section .reginfo: addr = 0x812c1180 size = 0x00000018.
In tea write, load base=0x0,load mask=0x   f
load section .data: addr = 0x812c2000 size = 0x00290000.
In tea write, load base=0x0,load mask=0x   f
not load section .sbss: addr = 0x81552000 size = 0x00000000 .
not load section .bss: addr = 0x81552000 size = 0x0001f4f0 .
not load section .comment: addr = 0x000101f4 size = 0x00000ed6 .
not load section .pdr: addr = 0x00000000 size = 0x00012b60 .
not load section .mdebug.abi32: addr = 0x00000000 size = 0x00000000 .
In SIM start, Set PC to the address 0x1200464
In gs32eb1 boot linux, Set PC to the address 0x81200464

3.3.2 The run command

Syntax: run Description: Starts the execution of the program. The prompt changes from (skyeye) to (running) Example:

(skyeye) run

3.3.3 The stop command

Syntax: stop Description: Stops the execution of the program. Changes the prompt back to (skyeye) from (running) Example:

(running) stop

3.3.4 The continue command

Syntax: continue Description: Restarts the execution after a stop. The new prompt would be (running) Example:

(skyeye) continue

3.3.5 The quit command

Syntax: quit Description: Used to terminate the emulator. Example:

(skyeye) quit
Destroy threads.
Unload all threads.

3.4 Other miscellaneous commands

3.4.1 The help command

Syntax: help Description: Provides help Example:

(skyeye) help
No commands match ". Possibilties are:
log-pc : record the every pc to log file.
log-pc : record the every pc to log file.
disassemble : Disassemble the given address.
list-bp : List all the breakpoint.
break : set breakpoint for an address.
show-step : Show the steps of current processor.
x : display memory value at the address.
info : show information for various objects.
load-conf : load a config file and parse it for SkyEye.
list-machines : List all the supported machines for SkyEye.
list-options : List all the available options for SkyEye.
show-map : Show the current memory map for the machine.
show-pref : Show the current preference for SkyEye.
list-modules : List all the loaded module.
start : start simulator.
stepi : step into .
continue : Continue the running of interrupted simulator.
stop : Stop the running of simulator.
run : Start the simulator.
q : Quit SkyEye
quit : Quit SkyEye
ls : Synonym for 'list'
? : Synonym for 'help'.
help : List all the category for the commands.
help : List all the category for the commands.

The SkyEye configuration file

4.1 Introduction to the skyeye.conf file

The skyeye.conf file is the SkyEye's configuration file. It is used to describe type of board to be simulated, memory distribution and SkyEye line configuration. The skyeye.conf file lets the users configure SkyEye and helps the user to make a exible choice of simulation platform functionality. Following is an example of skyeye.conf: Example:

# skyeye config file for S3C2410X
cpu: arm920t
mach: s3c2410x
# physical memory
mem bank: map=M, type=RW, addr=0x30000000, size=0x00800000
mem bank: map=M, type=RW, addr=0x30800000, size=0x00800000,
mem bank: map=M, type=RW, addr=0x31000000, size=0x01000000
# all peripherals I/O mapping area
mem bank: map=I, type=RW, addr=0x48000000, size=0x20000000
mem bank: map=I, type=RW, addr=0x19000300, size=0x00000020
net: type=cs8900a, base=0x19000300, size=0x20,int=9, mac=0:4:3:2:1:f, eth-
lcd: type=s3c2410x, mod=gtk
load addr:base=0x30000000, mask=0xFFFFFF

4.2 The file format of skyeye.conf

At present the skyeye.conf has two formats or configuration options. The first type of configuration option is for simple configuration. It has got the following format:

option name: option value For example:

arch: arm

Here "arch" is the name of the option, its value is "arm". The second type of configuration option has slightly more complicated form. It is used to set additional parameters, the format is as follows: option name: arg name = arg value, arg name = arg value,. . . Here option name is the name of the option, arg name is the parameter name for the option, arg value is the value for the specified parameter in the option. For example, lcd: type = s3c2410x, mo d = gtk Here "lcd" is the name of the option. "type" is the parameter for the option "lcd". This parameter has been assigned the value "s3c2410x". Similarly "mod" is another parameter for "lcd" option, its value is "gtk". If the configuration file starts with "#" in line, then SkyEye will ignore that line while parsing the configuration file. This "#" marks a line comment.

4.3 Dierent options of skyeye.conf in detail

4.3.1 The arch option

It specifies to SkyEye the architecture that we want to simulate. The valid values that this option can take are: arm, blackfin, coldfire, ppc, mips and sparc. Example:

arch: arm

4.3.2 The cpu option

It specifies the CPU belonging to the architecture family specified by arch option. Various values that this option can take are arm7tdmi, e500 and so on. Example: cpu: e500

4.3.3 The mach option

It specifies the machine (or SOC) that SkyEye should simulate, such as at91, mpc8572, etc. Example:

mach: at91

4.3.4 The mem bank option

It is used to describe the target machine's address space distribution, such as IO space, memory space and so on. There are many parameters associated with mem bank, they are described below:

The map parameter This is used to distinguish between memory or I/O address space. The valid values are M & I for memory and I/O space respectively. Example:


The type parameter It describes that the address space is read-write or read-only. Example:


The addr parameter It indicates the start address of the address space. The valid value depends upon the processor specified, it must be the legal address for that pro cessor. Example:


The size parameter It specifies the size of a continuous address space. Example:


Explanation of mem bank This option takes above parameters. Example:

mem bank: map = M, type = RW, addr = 0x31000000, size = 0x01000000

The statement in the example tells that the address space contains memory (not I/O), this memory is read-write type of memory, it starts at 0x31000000 and has a size of 0x01000000.

4.3.5 The Network (net ) options

This is used to describe the target system's network card configuration. Di erent parameters of this option are as follows: The type parameter It specifies the network card type. Valid values are cs8900a, rtl8019 The base parameter It specifies the base (or starting) address of the card in the address space. The size parameter It specifies the size of address space occupied by the NIC. The int parameter It specifies the interrupt number assigned to this NIC. The mac parameter It specifies the mac address of NIC. The ethmod parameter Only value it can have is tuntap. The value tuntap is a kind of point to point connection.

4.3.6 The hostip parameter

The host IP can be specified using this parameter.

4.3.7 The lcd options

These options tell SkyEye about the analog LCD controller to be simulated. It has got following paramaters: The type parameter This lets you specify the type of LCD controller to be simulated. Valid values that this parameter can take are: s3c2410x, ep7312. The mod parameter This specifies the GUI library to be used to draw the LCD screen. At present only GTK is allowed.

4.3.8 The UART options

These options describe the UART in the target system. The mod parameter This parameter describes how UART is to be emulated. Following are possible values for this parameter. 1. term: Indicates that a seperate terminal has to be opened for UART I/O 2. stdio: Indicates that stdio has to be used for UART I/O 3. net: Indicates UART I/O must be redirected to network port.

4.3.9 The load addr options

Specifies an alternate location where the elf file has to be loaded. The base parameter It contains the memory address at which elf file has to be loaded. The mask parameter It is required while loading the elf file. Following formula is used for address calculation: The real load address = base & (mask ¡ª elf load address)

4.3.10 The load file option

This option is used to load the image file system to a di erent address space. The filename parameter This parameter is used to specify the file system image to be loaded. The initrd start parameter This paramter is used to specify the address to load the base address. Its valid value is a memory address.

4.3.11 The uart 16550 option

This option is used to configure an instance of a 16550 uart type. base parameters It specifies the uart peripheral IO space base address. The length parameter It specifies the uart of the length of IO space. The irq parameter It specifies the uart peripheral interrupt number. Example:

uart 16550: base = 0xe1000000, length = 0x100, irq = 0x20

Running and debugging programs

using SkyEye

Code coverage analysis

Code coverage analysis is important in testing of a code. This includes checking how many lines were executed and how many weren't. This analysis is a way to judge the quality of the co de. This is done by checking the valid address that were executed and which were not executed.

6.1 Configuration file options

To be able to use the co de coverage features of SkyEye one needs to be have following lines in the skyeye.conf file:

code coverage:state=on,start=0x1000000, end=0x1400000, filename=./code cov

The option is called code coverage. This option has following parameters:


This parameter can hold either "on" or "o " values. When state is equal to "on" the code coverage feature is enabled.


This parameter specifies the starting address from where the code coverage statistics begin.


This parameter marks the end address at which the code coverage statistics end.


This parameter indicates the filename in which the code coverage statistics are written out.

6.2 Code Coverage Data File

The code coverage data dumped in the file consists of two parts: The file header The Profiling data Example of the header:

/* The header format of code coverage data file */
#define MAX DESC STR 32
typedef struct prof header s{
/* the version of header file */
int ver;
/* The length of header */
int header length;
int prof start;
int prof end;
/* The description info for profiling file */
char desc[MAX DESC STR];
}prof header t;

6.3 Use of SkyEye for code coverage statistics

Added configuration options In the configuration file add the following lines:

code coverage: start = 0x1000000, end = 0x1400000, filename =./codecov

Here the starting address is 0x1000000, whereas the end address 0x1400000 and the results are written in a file called code cov. After setting up the configuration file the program is run. Data file conversion The output file co de cov is a binary file, SkyEye provides a to ol to convert the code coverage results into text readable format. The utility is called as prof convert. Its usage is as follows:

1. If you run prof convert without any parameters it will display the usage:

ksh@server:/opt/testsuite/rtems/build edb7312 4.9>./prof convert

Purpose: print the header info of data file or convert raw data file to text file. Usage: ./Prof convert data file output file. Or: ./Prof convert data file 2. The code coverage information on file when supplied as an argument

ksh@server:/opt/testsuite/rtems/build edb7312 4.9>./prof convert code cov
Version: 0x1
Length of header: 0x30 bytes.
From 0x0 to 0x1400000 for code coverage.
Desc: raw data

3. Writing output to a readable text file

ksh@server:/opt/testsuite/rtems/build edb7312 4.9>./prof convert code cov /tmp/code cov.txt

After running this command, a file called /tmp/code cov.txt gets created. Display test results We can open the generated co de cov.txt file, and then open the program against and compare the two against our goals. Code coverage map on the left is the text output, figure on the right window for arm hello disassembled co de output.

The performance analysis module

7.1 Introduction

SkyEye performance analysis module is used to analyze the execution speed of SkyEye the module itself. Implementation details about it can read our <<SkyEye Internal>> the relevant section.

7.2 Use

After the start command is run in SkyEye, run "pmon" to enable performance monitoring, and then run "run" command. After the implementation of a program, quit SkyEye. Running in the current directory can generate a log file pmon.log, which recorded every second run SkyEye MIPS value, are summarized as follows:

In 10 seconds, MIPS = 6707657
In 11 seconds, MIPS = 6696640
In 12 seconds, MIPS = 6694161
In 13 seconds, MIPS = 6693102
In 14 seconds, MIPS = 6683999
In 15 seconds, MIPS = 6692131
In 16 seconds, MIPS = 6681589

Remote debugging gdb

8.1 Introduction

The gdb remote debugger module is enables debugging of arm code using gdb. 8.2 Usage 1. Suppose we want to debug the binary file name for vmlinux, then we need to do the following: Start skyeye, load the binary (elf format add-e option), open the remote-gdb:

ksh@server:$/opt/skyeye/bin/skyeye -e vmlinux
(Skyeye) start
(Skyeye) remote-gdb

With the "remote-gdb" command SkyEye will open a port numbered 12345 and gdb network services for network communication. 2. Launch gdb for appropriate processor. As an example we would demonstrate using arm. If you run the arm-linux gdb will see the words as follows:

ksh@ksh-server: /svn/skyeye/skyeye git/skyeye 1 3 1 $
/opt/toolchain/gdb arm/gdb/gdb
GNU gdb (GDB) 7.0
Copyright (C) 2009 Free Software Foundation, Inc.
License GPLv3 +: GNU GPL version 3 or later
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 "-host=x86 64-unknown-linux-gnu-
For bug reporting instructions, please see:

3. Load binary and connect to the server:

$Gdb vmlinux
(Gdb) target remote: 12345 (this step is to establish a connection
with the server-side)

If the remote connection is successful, the server-side will appear "Remote debugging using host: 12345". Can then In the client-side debugging using the gdb command, and if so print the information will appear in the server side.

Personal tools