An In-Depth Look at the Features of DS-5 Debugger


Making the Toughest Part of Debugging Better

When your first silicon arrives from the foundry, bringing up a new device can be a costly race against time. Our tools have been used extensively within Arm and across many of our partners to make this part of device development easier.

The DS-5 IDE provides utilities such as the Platform Configuration Editor (PCE),  which uses JTAG for auto-detection of your platform. Whilst modern SoCs will usually require some extra manual configuration, the initial scan will usually uncover several of the debug and trace elements, giving you a head start.

For cross-triggers, trace generators, sinks and fabric, as well as your own custom IP, we provide an abstraction layer called the Debug and Trace Services Layer (DTSL), which allows you describe these elements with simple Jython scripts.

However, if you're using an off-the-shelf part, it is likely that there is already a pre-built debug configuration in DS-5. This makes the majority of debugging a case of simply connecting to your target board.

Processor and Peripheral Control

Easy to Follow Register Views

We have made sure that DS-5 Debugger offers access into banked registers, system control coprocessor (CP15) registers and peripheral registers in a way that replicates the Arm Architecture Reference Manual.

When using DS-5 Debugger, you can specify these registers by their names, for example R13_fiq, making it intuitive to access a variety of memory classes.


Memory Visualization

Using address modifiers, you can access a specific type of memory, for instance, if you type S:0x0, the debugger will read the memory at address 0x0 in TrustZone secure mode.

These prefixes can be used to load symbols, set breakpoints, view/modify the content of memory and report the current stopped state.

Address Modifiers in DS-5 for Armv7 and AArch32
P: Physical memory (MMU disabled)
S: TrustZone secure mode
N: TrustZone non-secure mode
H: Hypervisor mode
Debug Access Port interfaces to memory
APB: Advanced Peripheral Bus
AHB: AMBA High-Performance Bus
AXI: Advanced Extensible Interface
AArch64 address modifers
EL1N: Exception Level 0/1 non-secure mode
EL1S: Exception Level 0/1 secure mode
EL2: Exception Level 2, for hypervisor
EL3: Exception Level 3, for TrustZone monitor



MMU View and Address Translation

To perform MMU page table walks, see an overview of the virtual memory map and translate between virtual and physical addresses, you can access the MMU view in DS-5 Debugger.



Custom Peripheral Registers

To allow DS-5 Debugger to access custom peripheral register views, we provide the Target Configuration Editor. This provides a visualization of the peripheral stack, which can be useful when there is a complex set of peripherals on your device.

Export Custom Configurations

Once your target is configured, you can export your settings in a CMSIS-SVD compatible format, allowing you to work with Keil MDK.

A synchronized breakpoints, disassembly and code editor screenshot

Breakpoints and Watchpoints

Full Control of DS-5 Debugger

With maximum control over hardware, software and conditional breakpoints, DS-5 Debugger helps you to eliminate complex bugs.

Conditional breakpoints can be set to stop execution when a C-like expression evaluates to true, allow multiple hits before the breakpoint triggers or run debugger scripts, whilst thread and virtual machine-specific breakpoints can be used to stop the processor when hit from a specific thread.

The type and number of breakpoints you can set depends on the memory region, hardware support in the processor, debug interface and running state.

Similarly, you can also set watchpoints, which monitor the address or value of a data access, rather than instructions executed from a specific address.



Trace in DS-5 is extremely powerful, giving you a non-intrusive way to sort out hard-to-find bugs when it's simply not practical to stop and start a core repeatedly.

To cope with the complex trace topologies of modern systems, DS-5 allows you to set and configure trace start, stop and trigger points.

In DS-5 Debugger, tracepoints can be set from the Arm assembly editor, C/C++ editor, disassembly view, functions view, memory view or trace view.

Learn more about Trace »

Debug and Trace Collaboratively

Breakpoints, tracepoints and watchpoints can all be exported for use in a different DS-5 workspace, helping you to debug code as a team.

Making Multicore Easy

More Cores Doesn't mean Greater Complexity

DS-5 was designed with complex SoC development in mind, so multicore debugging is extremely intuitive. Either regard the system as a whole, or rapidly test execution on an individual core.

Selecting a CPU, thread or call stack frame couldn't be easier in DS-5; just click in the debug control view and watch the other debug views automatically update to reflect your choice. DS-5 supports both this standard use case (of symmetric multiprocessing), as well as more complex operating modes.

Cortex-M, Cortex-A, Custom IP and Classic Arm cores

Many SoCs combine an application processor with simpler Cortex-M series MCUs for functions such as power management. This setup, known as asymmetric multiprocessing allows you to achieve as much as possible with a single chip.

DS-5 Debugger can connect to them all of the cores at once, giving you a full system view and greatly speeding up your debug process. This was pioneered for the complex SoCs found in smartphones, but benefits you with off-the-shelf devices such as the Freescale Vybrid VF6xx family, which pairs up a Cortex-A5 and Cortex-M4.


You'll find comprehensive support for big.LITTLE in DS-5 Debugger. Cores are identified as big or LITTLE in the debug control view, whilst the state of individual cores is clearly marked. Switch execution between big and LITTLE cores just as you would in any other multicore system, making the most of Arm's leading technology without increasing complexity.

For users of Arm's Versatile Express or FVPs, we provide a range of debug configurations, so that you can choose to operate in big.LITTLE mode or simply as a standard multicore/multicluster application processor.

OS Awareness


DS-5 is tightly integrated with Linux, visualizing threads and processes as well as resources. From the first time you use DS-5, you can quickly launch a Linux application debug session with one of our included examples.

Many of our examples are also configured so that they can be launched via gdbserver, meaning you can experiment with the included models before moving to your own development boards.

It's easy to add new files to the filesystem of your model or development board with DS-5 using the Remote System Explorer (RSE). Just establish an SSH or FTP connection in DS-5 and you'll be able to navigate through the filesystem of your target.


As Arm-powered devices are being used more and more for server and client computing, UEFI on Arm has become a great solution to control the boot process.

It can be a daunting task to port UEFI, so we've added support in DS-5 Debugger, meaning you can debug all phases of the UEFI control flow at source level.

Learn how to set up UEFI debug in DS-5 »


With support for a range of commonly used RTOSs and the ability to add custom RTOS support, DS-5 gives you as much flexibility with real-time systems as it does with Linux and Android.

We've worked closely with each RTOS vendor to offer visibility into interrupts, semaphores and task queues.

A Smarter Workspace

Features to make debugging quicker and easier


Debugging from the Command Line and Scripting

Right at the center of the debug perspective, you'll find the Commands View, giving you a familiar way of debugging from the command line.

For projects where it's necessary to drive DS-5 Debugger purely from the command line, you can work outside of the Eclipse environment completely. We know that this is still a popular way to debug, so provide a DS-5 Command Prompt to give you quick access.


  • GDB Autocompletion

    We've included command line autocompletion to make debugging easier, just hit Ctrl + Space for GDB commands content assist.

  • Jython Scripting

    We are big fans of Jython: it gives you a great way of creating complex debug control flows, whilst abstracting away the low level implementation difficulties.

  • Command Line

    If you're regression testing your code, or working on validation, you can drive DS-5 Debugger purely from the command line to automate testing.


You'll also find Jython scripting in several other areas of DS-5, including the DTSL scripting that makes it easy to define custom target configurations.

Keep track of data as it changes

The System Views provided in DS-5 give you a simple way to see at-a-glance when data changes. Recent changes in data can be excellent clues when debugging your code, so having these to hand can significantly cut the time it takes to find difficult bugs.

Contextual Help

Hit F1 to bring up the integrated contextual help in DS-5, which will explain the functionality of a particular Eclipse view and give examples. This is great for exploring DS-5, but becomes a seriously useful tool when trying to solve complex debugging problems.

Quick Access

Newer versions of Eclipse give you the Quick Access search box, helping you find a view or function related to a particular query. This saves time, especially when you're first using DS-5.

C Expressions Everywhere

DS-5 Debugger allows you to write C-like expressions anywhere, including in the content of registers, memory addresses, breakpoints and Expressions View. With this kind of consistency, there's no need to switch your thinking to another language. This approach also gives you significant control.

The Expressions View enables you to add expressions that you use regularly or that you want to examine in more detail. You can also freeze the view to stop it from being updated by a running target.

Replicate Earlier Sessions

To help you or your colleagues recreate a particular debug session, we've made it easy to export the complete set of steps from your debug session via the history view. These are converted to a script, automating the whole process when it comes to reaching the same point in your code.

Flash Programming

For cases where you might be using an MCU as part of your SoC, you can carry out Flash programming from the DS-5 Commands view. The command flash can be used, followed by the addresses to start and stop writing to. The underlying algorithms are compatible with Keil MDK, so porting across support for a particular MCU is simple.

Memory Fill & Dump

Similarly, to write a pattern of bytes to memory, or dump memory content, you can use the commands memory fill and memory dump, where the start and end address can be entered as addresses or expressions.