Home Products News Company Contact Us Support Careers

JTAG and ROM Emulators

   Download Datasheets

Overview

Corelis JTAG emulators utilize the industry standard IEEE-1149.1 JTAG Test port to access the internal debug resources available on each supported processor.

Since the boundary-scan logic of the processor is separate from the core processor logic itself, this access mechanism allows complete non-intrusive access to all processor resources. Thus, no interrupts, no RAM, ROM or registers need to be assigned for debug purposes and no ROM based debugger or loader program is required. At the same time, no peripheral resources such as serial ports are needed to communicate with the emulator/debugger.

In additional to these benefits, the use of the JTAG interface also ensures that processor access is maintained even when the processor 'hangs' or otherwise runs out of control. Programs and data can be downloaded to any part of the system RAM through the JTAG port without the need for a resident loader program.

The JTAG interface is a simple, five-wire interface that connects to the target system via a flexible ribbon cable, and does not require removing the processor. The JTAG interface is controlled by one of the Corelis' high-performance JTAG controllers. These controllers are compatible with USB 2.0, LAN PCI, and PCMCIA busses.

Due to the unique nature of our emulators, the same hardware controller can be used for any of the supported processors. Thus, a developer using one processor of a family can easily migrate to newer chips as they are introduced and retain his investment in hardware tools by merely installing another version of the Corelis emulator software.

 
   

CodeRunner Debugger

Corelis JTAG emulators include the powerful CodeRunner™ source-level debugger with multiple-window support, allowing the developer to view source code, assembly code, variables (both local and global), memory, and register locations at the same time. It also supports the concurrent debugging of targets with multiple CPUs, providing the capability to display windows for each CPU on the screen simultaneously.

CodeRunner provides full source-correlated debugging, allowing the user to display the source for a particular line of assembly code and vice versa. CodeRunner has a modern “XP look and feel”, and features a very straightforward and user-friendly interface.  Anyone familiar with the usage of source-level debuggers will master CodeRunner’s powerful features quickly without much of a learning curve.

CodeRunner works with all popular C/C++ cross-compilers that generate ELF/MDEBUG, ELF/Stabs, or ELF/MDEBUG & stabs debug information.  The user has the option to automatically load all debug symbols along with the executable, and these symbols will be displayed alongside of each line of assembly code.

The debugger has the ability to adjust debug source file pathnames, facilitating the ability to use the host PC to debug executables that were compiled in Linux.

Supported functions of CodeRunner include:

  • Reset processor

  • Start and Stop program execution

  • Set breakpoints in RAM

  • Set breakpoints in ROM or Flash using hardware breakpoints

  • Single-step source or assembly code

  • Single-step into or over function calls

  • Single-step out of function calls

  • Display and modify processor registers

  • Display, modify, and fill memory

  • Display and modify all variables

  • Display current function call stack

  • Support for 32-bit virtual, 64-bit virtual, and 40-bit physical address modes

  • Internal Trace Unit support to monitor bus activity

  • Save memory, register, and Trace Unit values to a comma-delimited text file

  • Disassemble memory using processor's mnemonics

  • Download code and optionally display symbol information

  • Powerful macro and custom toolbar capabilities

  • “C”-style command file support, allowing the user to write his own emulator functions using conditional statements, loops, variables, etc.

  • Unlimited number of Watch windows for keeping track of important variables

  • “Type-over” modification in register, memory, and variable windows, where the user can simply type in a new value over the old one

  • Logging capability


CodeRunner Multi Windows


CodeRunner Source Code Window


CodeRunner Assembly Code Window

Variables

The debugger can display four types of variables:

  • Local (to a function)

  • Static (to a file)

  • Global

  • Individual variables or the heap (via pointers).

Memory locations can be displayed in hex or decimal at any address. All variables are displayed with their type (char, int, unsigned long, etc), and all arrays and structures can be broken down into individual elements.

Macros

CodeRunner provides an extensive macro and custom button capability.   Macros are a sequence of commands (start processor, halt processor, write memory, set breakpoint, etc.) that can be formed into a single user-defined command.  Macros can then be attached to Custom Toolbar buttons, allowing the user to create custom one-click buttons for the sequence of actions he uses most.

Command Files

One of CodeRunner’s most powerful features is its ability to execute Command Files, which are written by the user in a structured “C”-like language.  The “commands” used by command files consist of CodeRunner-related functions, such as reading/writing memory, starting the processor, halting the processor, reading/writing registers, etc.

Command files may also contain user-defined Macros.  Command files are most useful to perform tasks that need to be repeated by the user every time CodeRunner is invoked, such as using CodeRunner to configure certain internal registers and/or the memory controller. Since the script language contains conditional commands (such as “if”), different actions can be taken by the same script, based upon the values read out of memory or registers.  Those familiar with “C” programming will be able to create complex CodeRunner command files within minutes.

Download Datasheets