A debugger for the complexity of modern SoCs

Arm Debugger helps you get to the root of software bugs throughout your development process. From device bring-up to application debug, it can be used to develop code on virtual platforms and hardware to help you get your products to market ahead of the competition.

Try for free   Buy Development Studio


Easy multicore debugging

Arm Debugger was designed with complex SoC development in mind, so multicore debugging is as intuitive as rapid test execution on an individual core. Both symmetric (SMP) and asymmetric (AMP) multiprocessing are supported, as well as complex operating modes including heterogeneous (big.LITTLE technology) systems.


Arm Debugger is integrated into the Arm Development Studio IDE and provides a Python scripting interface for advanced users to configure each Arm CoreSight component on the SoC exactly the way they want it while keeping the debugger interface simple and intuitive for everyone.

Quicker and easier debugging

Debugging from the Command Line and Scripting

Commands View gives you a familiar way of debugging from the command line. For projects where it's necessary to drive Arm 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 Development Studio Command Prompt to give you quick access.

  • Keep Track of Data
    System Views is an easy way to see data changes when debugging your code.
  • Easy Search Function
    Quick Access search box saves time by helping you find a particular view or function
  • Contextual Help
    F1 brings up the integrated contextual help which help you solve even complex debugging problems.
  • Replicate Sessions
    Export a complete set of steps from your debug session via the history view.
  • C Expressions Everywhere
    Write C-like expressions in the content of registers, memory addresses, breakpoints and Expressions View.
  • Flash programming for MCU
    MDK compatible command flash can be used, including support for flashing devices based on the information contained in CMSIS software packs.
  • Memory Fill & Dump
    Write a pattern of bytes to memory or dump memory content by start and end addresses or expression

Jython logo

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

Command Line

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

Code on a desktop.

Command Autocompletion

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

Debugging through the product lifecycle

Arm Debugger is an ideal tool to standardize on across your whole team. From silicon bring-up through to application development, your team can benefit from increased collaboration and a uniform user experience. 

The Development Studio 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 Development Studio. This makes the majority of debugging a case of , connecting to your target board.

Models used for applications on a computer.

Virtual Platforms & Fast Models

Development Stages:

Pre-silicon,OS porting and application development

Debug Connection:


Laptop, tablet, mobile phone etc.

Android & Linux Devices

Development Stages:

Linux and Android native libraries and application

Debug Connection:

GDB Remote Protocol via ADB or Ethernet.

Supporting leading devices, and your own

Arm Development Studio ships with pre-loaded debug configurations and examples for many popular devices. However, if you are designing your own SoC or are developing software for a less popular ASIC, Arm Debugger and DSTREAM debug probe can help to create a new device configuration describing not only its processor cores but also other debug blocks such as cross-triggers, trace macrocells and trace funnels.

Comprehensive support for Arm technologies

Arm Development Studio provides support for:

  • Arm TrustZone
  • Cross Trigger Interface (CTI)
  • Virtualization extension
  • AArch32 and AArch64
  • Program / Embedded / Instrumentation / System Trace Macrocells (PTM, ETM, ITM, STM)
  • Large Physical Addressing (LPA)
  • Embedded Trace Buffers (ETB)
  • Embedded Trace Routers (ETR)
  • High-Speed Serial Trace
  • Marvell SETM

Target operating system awareness

Arm Debugger integrates in-depth visibility into popular real-time OSs (RTOS) as well as into Linux and Android. On compatible targets you can easily visualize all tasks/threads and their call frame, set task/thread-specific breakpoints, and view kernel resources such as mailboxes and semaphores as you step through your code. When debugging the Linux kernel you can also view and load symbols for dynamically loaded modules, as well as setting pending breakpoints. Supported operating systems include:

  • Linux & Android
  • FreeRTOS™
  • NXP Semiconductors MQX™
  • Micrium® μCOS (II and III)
  • Express Logic ThreadX®
  • Segger embOS™
  • Quadros RTXC™
  • Mentor Graphics® Nucleus®
  • SYSGO PikeOS™ Hypervisor
  • Wind River VxWorks®
  • eForce μC3® Standard

Software pack support

Arm Development Studio includes support for software packs based on the CMSIS-Pack standard. Development Studio includes a pack installer to find install from 5000+ publicly available software packs. Use the software pack information to construct projects, flash devices, code templates to get started, and debug the device. 

View all supported devices >>

Processor and peripheral control

Easy to follow register views

Arm Debugger offers access into banked registers, system control coprocessor (CP15) registers and peripheral registers in a way that replicates the Arm Architecture Reference Manual. 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

Utilise the MMU view to automatically complete page table walks, translate virtual to physical memory addresses and present an overview of the memory map.

Custom peripheral registers

Target Configuration Editor gives the ability to add custom peripheral registers to the view, thereby enabling tailoring it for target specific peripherals and registers.

Export custom configurations

Export the settings of the configured target in a CMSIS-SVD compatible format for further work within Keil MDK.


Breakpoints and watchpoints

Full control of Arm Debugger

With maximum control over hardware, software and conditional breakpoints, Arm 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 Development Studio 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, Development Studio allows you to set and configure trace start, stop and trigger points.

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


Debug and trace collaboratively

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

Learn more about Trace »



Get in touch

If you would like to get in contact with us about Development Studio, please do so through our online enquiry form.