TSIM is distributed as a tar-file (e.g. tsim-erc32-2.0.13.tar.gz) with the following contents: doc samples iomod tsim/cygwin tsim/linux tsim/linux-x64 tsim/solaris tsim/win32 tlib/cygwin tlib/linux tlib/linux-x64 tlib/solaris tlib/win32

TSIM documentation

Sample programs

Example I/O module

TSIM binary for cygwin

TSIM binary for linux

TSIM binary for linux-x64

TSIM binary for solaris

TSIM binary for native windows

TSIM library for cygwin

TSIM library for linux

TSIM library for linux-x64

TSIM library for solaris

TSIM library for native windows

The tar-file can be installed at any location with the following command: gunzip -c tsim-erc32-2.0.21.tar.gz | tar xf -

2.2 License installation

TSIM is licensed using a HASP USB hardware key. Before use, a device driver for the key must be installed.

The latest drivers can be found at www.aladdin.com or www.gaisler.com. See appendix A for installation of device drivers under Windows and Linux platforms.

TSIM2

3 Operation

3.1 Overview

TSIM can operate in two modes: standalone and attached to gdb. In standalone mode, ERC32 or LEON applications can be loaded and simulated using a command line interface. A number of commands are available to examine data, insert breakpoints and advance simulation. When attached to gdb, TSIM acts as a remote gdb target, and applications are loaded and debugged through gdb (or a gdb front-end such as ddd).

3.2 Starting TSIM

TSIM is started as follows on a command line:

tsim-erc32 [options] [input_files]

tsim-leon [options] [input_files]

tsim-leon3 [options] [input_files]

tsim-leon4 [options] [input_files]

The following command line options are supported by TSIM:

-ahbm ahb_module

Use ahb_module as loadable AHB module rather than the default ahb.so (LEON only). If multiple -ahbm switches are specified up to 16 AHB modules can be loaded. The enviromental variable TSIM_MODULE_PATH can be set to a ‘:’ separated (‘;’ in WIN32) list of search paths.

-at697e Configure caches according to the Atmel AT697E device (LEON2 only).

-banks ram_banks

Sets how many ram banks (1 - 4) the ram is divided on. Default is 1. (LEON only).

-bopt

-bp

-c file

-cfg file

Enables idle-loop optimisation (see text).

Enables emulation of LEON3/4 branch prediction

Reads commands from file and executes them at startup.

Reads extra configuration options from file.

-cfgreg_and and_mask, -cfgreg_or or_mask

LEON2 only: Patch the Leon Configuration Register (0x80000024). The new value will be:

(reg & and_mask) | or_mask

-cpm cp_module

Use cp_module as loadable co-processor module file name (LEON). The enviromental variable TSIM_MODULE_PATH can be set to a ‘:’ separated (‘;’ in WIN32) list of search paths.

-cas

When running a VXWORKS SMP image the SPARCV9 “casa” instruction is used. The option -cas enables this instruction (LEON3/4 only).

-dcsize size Defines the set-size (kbytes) of the LEON dcache. Allowed values are 1 - 64 in binary steps.

Default is 4 kbytes.

-dlock Enable data cache line locking. Default is disabled. (LEON only).

-dlram addr size

Allocates size Kbytes of local dcache scratchpad memory at address addr. (LEON3/4)

TSIM2 9

-dlsize size Sets the line size of the LEON data cache (in bytes). Allowed values are 8, 16 or 32. Default is 16.

-drepl repl Sets the replacement algorithm for the LEON data cache. Allowed values are rnd (default) for random replacement, lru for the least-recently-used replacement algorithm and lrr for least-recently-replaced replacement algorithm.

-dsets sets Defines the number of sets in the LEON data cache. Allowed values are 1 - 4.

-fast_uart Run UARTs at infinite speed, rather than with correct (slow) baud rate.

-fpm fp_module

Use fp_module as loadable FPU module rather than the default fp.so (LEON only). The enviromental variable TSIM_MODULE_PATH can be set to a ‘:’ separated (‘;’ in WIN32) list of search paths.

-freq system_clock

Sets the simulated system clock (MHz). Will affect UART timing and performance statistics. Default is 14 for ERC32 and 50 for LEON.

-gdb

-gr702rc

-grfpu

-hwbp

Listen for GDB connection directly at start-up.

Set cache parameters to emulate the GR702RC device.

Emulate the GRFPU floating point unit, rather then Meiko or GRFPU-lite (LEON only).

Use TSIM hardware breakpoints for gdb breakpoints.

-icsize size Defines the set-size (kbytes) of the LEON icache. Allowed values are 1 - 64 in binary steps.

-ift Generate illegal instruction trap on IFLUSH. Emulates the IFT input on the ERC32 processor.

-ilock Enable instruction cache line locking. Default is disabled.

-ilram addr size

Allocates size bytes of local icache scratchpad memory at address addr. (LEON3)

-ilsize size Sets the line size of the LEON instruction cache (in bytes). Allowed values are 8, 16 or 32.

-iom io_module

Use io_module as loadable I/O module rather than the default io.so. The enviromental variable TSIM_MODULE_PATH can be set to a ‘:’ separated (‘;’ in WIN32) list of search paths.

-irepl repl Sets the replacement algorithm for the LEON instruction cache. Allowed values are rnd

(default) for random replacement, lru for the least-recently-used replacement algorithm and lrr for least-recently-replaced replacement algorithm.

-isets sets Defines the number of sets in the LEON instruction cache. Allowed values are 1(default) -

-iwde Set the IWDE input to 1. Default is 0. (TSC695E only)

-l2wsize size Enable emulation of L2 cache (LEON3/4 only) with size Kbytes. The size must be binary aligned (e.g. 16, 32, 64 ...).

-logfile filename

Logs the console output to filename. If filename is preceded by ‘+’ output is append.

-mflat This switch should be used when the application software has been compiled with the gcc mflat option, and debugging with gdb is done.

-mmu

-nb

Adds MMU support (LEON only).

Do not break on error exeptions when debugging through GDB

TSIM2 10

-nfp Disables the FPU to emulate system without FP hardware. Any FP instruction will generate an FP disabled trap.

-nomac Disable LEON MAC instruction. (LEON only).

-noreadline Disable loading and use of libreadline.(so|dll).

-nosram Disable sram on startup. SDRAM will appear at 0x40000000 (LEON only).

-nothreads

Disable threads support.

-notimers Disable the LEON timer unit.

-nouart Disable emulation of UARTs. All access to UART registers will be routed to the I/O module.

-nov8 Disable SPARC V8 MUL/DIV instructions (LEON only).

-nrtimersval Adds upport for more than 2 timers. Value val can be in the range of 2 - 8. See also switch -

sametimerirq

. Default: 2 (LEON3/4 only).

-nwin win Defines the number of register windows in the processor. The default is 8. Only applicabale to LEON3/4.

-port portnum

Use portnum for gdb communication (port 1234 is default)

-pr

Enable profiling.

-ram ram_size

Sets the amount of simulated RAM (kbyte). Default is 4096.

-rest file_name

Restore saved state from file_name.tss. See section 3.8 - Check-pointing

-rom rom_size

Sets the amount of simulated ROM (kbyte). Default is 2048.

-rom8, -rom16

By default, the prom area at reset time is considered to be 32-bit. Specifying -rom8 or rom16 will initialise the memory width field in the memory configuration register to 8- or

16-bits. The only visible difference is in the instruction timing.

-rtems ver Override autodetected RTEMS version for thread support. ver should be 46 or 48.

-sametimerirqForce all timer irq to be 8. Works together with switch -nrtimers. Default: seperate irqs for each timer starting from 8. (LEON3 only)

-sdram sdram_size

Sets the amount of simulated SDRAM (mbyte). Default is 0. (LEON only)

-sdbanks [1|2]

Sets the sdram banks. This parameter is used to calculate the used sdram in conjunction with the mcfg2.sdramsize

field.

The actually used sdram at runtime is sdbanks*mcfg2.sdramsize. Default:1 (LEON only)

-sym file

-timer32

Read symbols from file. Useful for self-extracting applications

Use 32 bit timers instead of 24 bit. (LEON2 only)

-tsc691

-tsc695e

Emulate the TSC691 device, rather than TSC695

Obsolete. TSIM/ERC32 now always emulates the TSC695 device rather that the early

ERC32 chip-set.

-uart[1,2] device

By default, UART1 is connected to stdin/stdout and UART2 is disconnected. This switch

TSIM2 11 can be used to connect the uarts to other devices. E.g., ‘-uart1 /dev/ptypc’ will attach

UART1 to ptypc. On linux ‘-uart1 /dev/ptmx‘ can be used in which case the pseudo terminal slave’s name to use will be printed. If you use minicom to connect to the uart then use minicom’s -p <pseudo terminal> option. On windows use //./com1, //./com2 etc. to access the serial ports. The serial port settings can be adjusted by doubleclicking the “Ports (COM and LPT)” entry in controlpanel->system->hardware->devicemanager. Use the “Port Setting” tab in the dialog that pops up.

-ut699 Set parameters to emulate the UT699 device.

-wdfreqfreq Specify the frequency of the watchdog clock. (ERC32 only)

input_files

Executable files to be loaded into memory. The input file is loaded into the emulated memory according to the entry point for each segment. Recognized formats are elf32, aout and srecords.

Command line options can also be specified in the file .tsimcfg in the home directory. This file will be read at startup and the contents will be appended to the command line.

3.3 Standalone mode commands

TSIM dynamically loads libreadline.so if available on the host system, this will provide command history and completion with the tab-key. If libreadline.so is not found a simpler commandline will be used with no history and poor editing capabilities.

If the file .tsimrc exists in the home directory, it will be used as a batch file and the commands in it will be executed at startup.

Below is a description of commands that are recognized by the simulator when used in standalone mode:

batch file Execute a batch file of TSIM commands.

+bp, break address

Adds an breakpoint at address.

bp, break

Prints all breakpoints and watchpoints

-bp, del[num]

Deletes breakpoint/watchpoint num. If num is omitted, all breakpoints and watchpoints are deleted.

Print backtrace

cont [count/time]

Continue execution at present position. See the go command for how to specify count or time.

coverage [enable | disable | gcc | save [file_name] | print address <len>]

Code coverage control. Coverage can be enabled, disabled, saved to a file or printed to the console.

dis [addr] [count]

Disassemble [count] instructions at address [addr]. Default values for count is 16 and addr is the program counter address.

echo string Print <string> to the simulator window.

edac [clear | cerr | merr <address>]

Insert EDAC errors, or clear EDAC checksums (ERC32 only)

event

Print events in the event queue. Only user-inserted events are printed.

TSIM2 12

flush [all | icache | dcache | addr]

Flush the LEON caches. Specifying all will flush both the icache and dcache. Specifying

icache

or dcache will flush the respective cache. Specifying addr will flush the corresponding line in both caches.

float gdb

Prints the FPU registers

Listen for gdb connection.

go [address] [count/time]

The go command will set pc to address and npc to address + 4, and resume execution. No other initialisation will be done. If address is not given, the default load address will be assumed. If a count is specified, execution will stop after the specified number of instructions. If a time is given, execution will continue until time is reached (relative to the current time). The time can be given in micro-seconds, milliseconds, seconds, minutes, hours or days by adding ‘us’, ‘ms’, ‘s’, ‘min’, ‘h’ or ‘d’ to the time expression. Example: go

0x40000000 400 ms. Note: for the go command, if the count/time parameter is given,

address

must be specified.

help

Print a small help menu for the TSIM commands.

hist [length] Enable the instruction trace buffer. The length last executed instructions will be placed in the trace buffer. A hist command without length will display the trace buffer. Specifying a zero trace length will disable the trace buffer.

icache, dcache

Dumps the contents of tag and data cache memories (LEON only).

inc time Increment simulator time without executing instructions. Time is given in the same format as for the go command. Event queue is evaluated during the advancement of time.

leon

Display LEON peripherals registers.

load files Load files into simulator memory.

l2cache

Display contents of L2 cache

mp <1|2> Synchronize two TSIM instances. See manual for details.

mec

Display ERC32 MEC registers.

mem [addr] [count]

Display memory at addr for count bytes. Same default values as for dis. Unimplemented registers are displayed as zero.

vmem [vaddr] [count]

Same as mem but does a MMU translation on vaddr first (LEON only).

mmu quit

Display the MMU registers (LEON only).

Exits the simulator.

perf [reset] The perf command will display various execution statistics. A ‘perf reset’ command will reset the statistics. This can be used if statistics shall be calculated only over a part of the program. The run and reset command also resets the statistic information.

prof [0|1] [stime]

Enable (‘prof 1’) or disable (‘prof 0’) profiling. Without parameters, profiling information is printed. Default sampling period is 1000 clock cycles, but can be changed by specifying

stime

reg [reg_name value]

Prints and sets the IU registers in the current register window. reg without parameters prints the IU registers. reg reg_name value sets the corresponding register to value. Valid register

TSIM2 13 names are psr, tbr, wim, y, g1-g7, o0-o7 and l0-l7. To view the other register windows, use

reg wn, where n is 0 - 7.

reset

Performs a power-on reset. This command is equal to run 0.

restore file Restore simulator state from file.

run [addr] [count/time]

Resets the simulator and starts execution from address addr, the default is 0. The event queue is emptied but any set breakpoints remain. See the go command on how to specify the time or count.

save <file> Save simulator state file.

step

Equal to trace 1.

sym [file] Load symbol table from file. If file is omitted, prints current (.text) symbols.

version

Prints the TSIM version and build date.

walk address [iswrite|isid|issu]*

If the MMU is enabled printout a table walk for the given address. The flags iswrite, isid and issu are specifying the context: iswrite for a write access (default read), isid for a icache access (default dcache), issu for a supervisor access (default user).

watch address

Adds a watchpoint at address.

wmem, wmemh, wmemb<address> <value>

Write a word, half-word or byte directly to simulated memory.

xwmem <asi> address> <value>

Write a word to simulated memory using ASI=asi. Applicable to LEON3.

Typing a ‘Ctrl-C’ will interrupt a running simulator. Short forms of the commands are allowed, e.g c, co, or

con, are all interpreted as cont.

3.4 Symbolic debug information

TSIM will automatically extract (.text) symbol information from elf-files. The symbols can be used where an address is expected: tsim> bre main breakpoint 3 at 0x020012f0: main tsim> dis strcmp 5

02002c04 84120009 or %o0, %o1, %g2

02002c08 8088a003 andcc %g2, 0x3, %g0

02002c0c 3280001a bne,a 0x02002c74

02002c10 c64a0000 ldsb [%o0], %g3

02002c14 c6020000 ld [%o0], %g3

The sym command can be used to display all symbols, or to read in symbols from an alternate (elf) file: tsim> sym /opt/rtems/src/examples/samples/dhry read 234 symbols tsim> sym

0x02000000 L _text_start

0x02000000 L _trap_table

0x02000000 L text_start

0x02000000 L start

0x0200102c L _window_overflow

0x02001084 L _window_underflow

0x020010dc L _fpdis

0x02001a4c T Proc_3

TSIM2 14

Reading symbols from alternate files is necessary when debugging self-extracting applications, such as bootproms created with mkprom or linux/uClinux.

3.5 Breakpoints and watchpoints

TSIM supports execution breakpoints and write data watchpoints. In standalone mode, hardware breakpoints are always used and no instrumentation of memory is made. When using the gdb interface, the gdb ‘break’ command normally uses software breakpoints by overwriting the breakpoint address with a ‘ta 1’ instruction.

Hardware breakpoints can be inserted by using the gdb ‘hbreak’ command or by starting tsim with -hwbp, which will force the use of hardware breakpoints also for the gdb ‘break’ command. Data write watchpoints are inserted using the ‘watch’ command. A watchpoint can only cover one word address, block watchpoints are not available.

3.6 Profiling

The profiling function calculates the amount of execution time spent in each subroutine of the simulated program. This is made without intervention or instrumentation of the code by periodically sample the execution point and the associated call tree. Cycles in the call graph are properly handled, as well as sections of the code where no stack is available (e.g. trap handlers). The profiling information is printed as a list sorted on highest execution time ration. Profiling is enabled through the prof 1 command. The sampling period is by default

1000 clocks which typically provides the best compromise between accuracy and performance. Other sampling periods can also be set through the prof 1 n command. Profiling can be disabled through the prof 0 command. Below is an example profiling the dhrystone benchmark: bash$tsim-erc32 /opt/rtems/src/examples/samples/dhry tsim> pro 1 profiling enabled, sample period 1000 tsim> go resuming at 0x02000000

Execution starts, 200000 runs through Dhrystone

Stopped at time 23375862 (1.670e+00 s) tsim> pro function start

_start main

Proc_1

Func_2 strcmp

Proc_8

.div

Proc_6

Proc_3

Proc_2

.umul

Func_1

Proc_7

Proc_4

Proc_5

Func_3 printf vfprintf

453

227

_vfprintf_r 8 samples

36144

36134

10476

9885

8161

2641

2097

1412

1321

1187

1092

777

772

731 tsim> ratio(%)

100.00

99.97

28.98

27.34

22.57

7.30

5.80

3.90

3.65

3.28

3.02

2.14

2.13

2.02

1.25

0.62

0.02

TSIM2 15

3.7 Code coverage

To aid software verification, the professional version of TSIM includes support for code coverage. When enabled, code coverage keeps a record for each 32-bit word in the emulated memory and monitors whether the location has been read, written or executed. The coverage function is controlled by the coverage command:

coverage enable coverage disable

enable coverage disable coverage

coverage save [filename]

write coverage data to file (file name optional)

coverage print address [len]

print coverage data to console, starting at address

coverage gcc exec-file [src-file]print source code with back-annotated coverage information

coverage clear

reset coverage data

The coverage data for each 32-bit word of memory consists of a 5-bit field, with bit0 (lsb) indicating that the word has been executed, bit1 indicating that the word has been written, and bit2 that the word has been read.

Bit3 and bit4 indicates the presence of a branch instruction; if bit3 is set then the branch was taken while bit4 is set if the branch was not taken.

As an example, a coverage data of 0x6 would indicate that the word has been read and written, while 0x1 would indicate that the word has been executed. When the coverage data is printed to the console or save to a file, it is presented for one block of 32 words (128 bytes) per line: tsim> cov print start

02000000 : 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0

02000080 : 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

02000100 : 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

02000180 : 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

When the code coverage is saved to file, only blocks with at least one coverage field set are written to the file.

Block that have all the coverage fields set to zero are not saved in order to decrease the file size. Note that only the internally emulated memory (prom and ram) are subject for code coverage, any memory emulated in the user’s I/O module must be handled by a user-defined coverage function.

When coverage is enabled, disassembly will include an extra column after the address, indicating the coverage data. This makes it easier to analyse which instructions has not been executed: tsim> di start

02000000 1 a0100000 clr %l0

02000004 1 29008004 sethi %hi(0x2001000), %l4

02000008 1 81c52000 jmp %l4

0200000c 1 01000000 nop

02000010 0 91d02000 ta 0x0

02000014 0 01000000 nop

02000018 0 01000000 nop

The coverage data is not saved or restored during check-pointing operations. When enabled, the coverage function reduces the simulation performance of about 30%. When disabled, the coverage function does not impact simulation performance. Individual coverage fields can be read and written using the TSIM function

interface using the tsim_coverage() call (see “Function interface” on page 43). Enabling and disabling the

coverage functionality from the function interface should be done using tsim_cmd().

Coverage information can also be back-annotated to the source code of applications compiled with gcc (sparcrtems-gcc). The command ‘coverage gcc exec-file src-file’ will produce a file called src-file.cov where each executable line is either marked with the line number (if it has been executed), or ‘#####’ if it has not been executed. The exec-file is the binary file which has been executed by TSIM, while the src-file is (one of) the source files. Note that the binary file must have been compiled by sparc-rtems-gcc with debugging enabled in

STABS format (-gstabs). Also, the RCC cross-compiler must be installed on the host and in the execution path. TSIM uses the RCC tools (sparc-rtems-objdump) to exctract the debug information from the binary.

TSIM2 16

The example below shows and example of the command and annotated source code:

tsim> coverage gcc stanford stanford.c

coverage for stanford.c: 95.4% tsim> q

$ cat stanford.c.cov

642 kount = 0;

643 if (Fit (0, m))

644

else n = Place (0, m);

###### printf ("Error1 in Puzzle\n");

647 if (!Trial (n))

###### printf ("Error2 in Puzzle.\n");

649 else if (kount != 2005)

###### printf ("Error3 in Puzzle.\n");

};

The example above shows that there are three executable lines which has not been executed. Note when the code is compiled with optimisation (-O or O2), some lines which seem to have executable code might be marked as not executable. This is beacause the optimisation process has either removed them or merged them with other lines.

3.8 Check-pointing

The professional version of TSIM can save and restore its complete state, allowing to resume simulation from a saved check-point. Saving the state is done with the save command:

tsim> save file_name

The state is save to file_name.tss. To restore the state, use the restore command:

tsim> restore file_name

The state will be restored from file_name.tss. Restore directly at startup can be performed with the ‘-rest

file_name’

command line switch.

Note that TSIM command line options are not stored (such as alternate UART devices, etc.).

3.9 Performance

TSIM is highly optimised, and capable of simulating ERC32 systems faster than realtime. On high-end Athlon processors, TSIM achieves more than 1 MIPS / 100 MHz (cpu frequency of host). Enabling various debugging features such as watchpoints, profiling and code coverage can however reduce the simulation performance with up to 40%.

3.10 Backtrace

The bt command will display the current call backtrace and associated stack pointer; tsim> bt

%pc %sp

#0 0x0200190c 0x023ffcc8 Proc_1 + 0xf0

#1 0x02001520 0x023ffd38 main + 0x230

#2 0x02001208 0x023ffe00 _start + 0x60

#3 0x02001014 0x023ffe40 start + 0x1014

TSIM2 17

3.11 Connecting to gdb

TSIM can act as a remote target for gdb, allowing symbolic debugging of target applications. To initiate gdb communication, start the simulator with the -gdb switch or use the TSIM gdb command:

bash-2.04$

./tsim -gdb

TSIM/LEON - remote SPARC simulator, build 2001.01.10 (demo version) serial port A on stdin/stdout allocated 4096 K RAM memory allocated 2048 K ROM memory gdb interface: using port 1234

Then, start gdb in a different window and connect to TSIM using the extended-remote protocol:

bash-2.04$

sparc-rtems-gdb t4.exe

(gdb) tar extended-remote localhost:1234

Remote debugging using localhost:1234

0x0 in ?? ()

(gdb)

To load and start the application, use the gdb load and cont command.

(gdb) load

Loading section .text, size 0x14e50 lma 0x40000000

Start address 0x40000000 , load size 87184

Transfer rate: 697472 bits/sec, 278 bytes/write.

(gdb) cont

Continuing

To interrupt simulation, Ctrl-C can be typed in both gdb and TSIM windows. The program can be restarted using the gdb run command but a load has first to be executed to reload the program image into the simulator:

(gdb) load

Loading section .text, size 0x14e50 lma 0x40000000

Loading section .data, size 0x640 lma 0x40014e50

Start address 0x40000000 , load size 87184

Transfer rate: 697472 bits/sec, 278 bytes/write.

(gdb) run

The program being debugged has been started already.

Start it from the beginning? (y or n) y

Starting program: /home/jgais/src/gnc/t4.exe

If gdb is detached using the detach command, the simulator returns to the command prompt, and the program can be debugged using the standard TSIM commands. The simulator can also be re-attached to gdb by issuing the gdb command to the simulator (and the target command to gdb). While attached, normal TSIM commands can be executed using the gdb monitor command. Output from the TSIM commands is then displayed in the gdb console.

TSIM translates SPARC traps into (unix) signals which are properly communicated to gdb. If the application encounters a fatal trap, simulation will be stopped exactly on the failing instruction. The target memory and register values can then be examined in gdb to determine the error cause.

Profiling an application executed from gdb is possible if the symbol table is loaded in TSIM before execution is started. gdb does not download the symbol information to TSIM, so the symbol table should be loaded using the monitor command:

(gdb) monitor sym t4.exe

read 158 symbols

When an application that has been compiled using the gcc -mflat option is debugged through gdb, TSIM should be started with -mflat in order to generate the correct stack frames to gdb.

TSIM2 18

3.12 Thread support

TSIM has thread support for the RTEMS operating system. Additional OS support will be added to future versions. The GDB interface of TSIM is also thread aware and the related GDB commands are described later.

3.12.1 TSIM thread commands

thread info - lists all known threads. The currently running thread is marked with an asterisk.

grlib> thread info

-----------------------------------------------------------------------------------------------------------------------------

Int. | internal | 0x09010001 | 255 | 138 | _CPU_Thread_Idle_body | 0x4002f760 _Thread_Dispatch + 0x11c | READY

----------------------------------------------------------------------------------------------------------------------------

UI1 | classic | 0x0a010001 | 120 | 290 | Init | 0x4002f760 _Thread_Dispatch + 0x11c | READY

-----------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------------

thread bt <id> - do a backtrace of a thread.

Backtrace of inactive thread: grlib> thread bt 0x0a010003

%pc

#0 0x4002f760 _Thread_Dispatch + 0x11c

#1 0x40013ed8 rtems_event_receive + 0x88

#2 0x40027824 rtems_bsdnet_event_receive + 0x18

#3 0x4000b664 websFooter + 0x484

#4 0x40027708 rtems_bsdnet_schednetisr + 0x158

A backtrace of the current thread (equivalent to normal bt command): grlib> thread bt 0x0a010007

%pc %sp

#0 0x40001b60 0x43fea130 console_outbyte_polled + 0x34

#1 0x400017fc 0x43fea130 console_write_support + 0x18

#2 0x4002dde8 0x43fea198 rtems_termios_puts + 0x128

#3 0x4002df60 0x43fea200 rtems_termios_puts + 0x2a0

#4 0x4002dfe8 0x43fea270 rtems_termios_write + 0x70

#5 0x400180a4 0x43fea2d8 rtems_io_write + 0x48

#6 0x4004eb98 0x43fea340 device_write + 0x2c

#7 0x40036ee4 0x43fea3c0 write + 0x90

#8 0x4001118c 0x43fea428 trace + 0x38

#9 0x4000518c 0x43fea498 websOpenListen + 0x108

#10 0x40004fb4 0x43fea500 websOpenServer + 0xc0

#11 0x40004b0c 0x43fea578 rtems_initialize_webserver + 0x204

#12 0x40004978 0x43fea770 rtems_initialize_webserver + 0x70

#13 0x40053380 0x43fea7d8 _Thread_Handler + 0x10c

#14 0x40053268 0x43fea840 __res_mkquery + 0x2c8

TSIM2 19

3.12.2 GDB thread commands

TSIM needs the symbolic information of the image that is being debugged to be able to check for thread information. Therefore the symbols needs to be read from the image using the sym command before issuing the

gdb command.

When a program running in GDB stops TSIM reports which thread it is in. The command info threads can be used in GDB to list all known threads.

Program received signal SIGINT, Interrupt.

[Switching to Thread 167837703]

0x40001b5c in console_outbyte_polled (port=0, ch=113 ’q’) at ../../../../../../../../../rtems-

4.6.5/c/src/lib/libbsp/sparc/leon3/console/debugputs.c:38

== 0 ); while ( (LEON3_Console_Uart[LEON3_Cpu_Index+port]->status & LEON_REG_UART_STATUS_THE)

(gdb) info threads

8 Thread 167837702 (FTPD Wevnt) 0x4002f760 in _Thread_Dispatch () at ../../../../../../rtems-