SoC
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
  • Arm Cortex M3
  • Contact
Reading: What is the Thumb instruction set of the ARM controller?
SUBSCRIBE
SoCSoC
Font ResizerAa
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
Search
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
Have an existing account? Sign In
Follow US
  • Looking for Something?
  • Privacy Policy
  • About Us
  • Sitemap
  • Contact Us
© S-O-C.ORG, All Rights Reserved.
Arm

What is the Thumb instruction set of the ARM controller?

Holly Lindsey
Last updated: September 13, 2023 5:48 am
Holly Lindsey 9 Min Read
Share
SHARE

The Thumb instruction set is a compressed variant of the ARM instruction set that was introduced in ARMv4T architectures. It is designed to reduce code size by using 16-bit instructions instead of 32-bit instructions. Thumb code is typically 30-40% smaller than equivalent ARM code, which helps reduce memory requirements and improve performance in embedded systems.

Contents
Overview of ThumbMain Features of Thumb16-bit Thumb Instruction Formats32-bit Thumb-2 Instruction ExtensionsInterworking Between Thumb and ARMThumb-2 Extensions in ARMv6T2 and ARMv7Benefits of Using ThumbLimitations of ThumbConclusion

Overview of Thumb

In the 32-bit ARM instruction set, all instructions are 32 bits long. This provides flexibility and power, but also results in larger code size. With Thumb, most instructions are 16 bits long, reducing code size while still providing good performance for most tasks. The processor automatically switches between ARM and Thumb instruction sets using a bit in the program counter register.

The Thumb instruction set maintains most of the features of the ARM set but with limitations on some complex instructions like conditionals and shifts. Thumb has 16 general purpose 32-bit registers like ARM but a smaller subset of available instructions. Memory access instructions, branch instructions, and basic ALU operations are present, providing ample functionality for most embedded applications.

Thumb code executes on a subset of the main ARM processing core. Some ARM processors implement a full 32-bit ALU to handle both ARM and Thumb instructions efficiently. Other designs use a 16-bit data path and barrel shifter for Thumb code. In either case, performance of Thumb code is comparable to ARM in many embedded systems.

Main Features of Thumb

Here are some of the main features of the Thumb instruction set:

  • 16-bit instruction length – Most instructions are halfword (16-bit) in size.
  • High code density – Typically provides 30-40% code size reduction compared to 32-bit ARM code.
  • Access to ARM registers – Thumb code can access all 16 ARM general purpose registers (R0-R15).
  • Load/store architecture – Uniform and systematic memory access instructions like ARM.
  • Conditional execution – Supports conditional execution of branches and moves.
  • PC-relative branches – Branch instructions use PC-relative offsets.
  • Stack operations – Push, pop, link register (LR) stacking supported.
  • ALU instructions – Provides basic arithmetic, logical, and comparison operations.
  • Shifts and rotates – Barrel shifter support, but limited shift options.
  • Interworking with ARM – Seamless switching between ARM and Thumb modes.

This core subset of instructions allows Thumb code to be very compact while still supporting most operations needed for embedded C programs and compiler output. The mix of 16-bit and 32-bit instructions strikes a good balance between size and performance.

16-bit Thumb Instruction Formats

Thumb instructions use several formats to encode operations within 16 bits:

  • Format 1 – 3-bit opcode, 3-bit Rd, 3-bit Rs, 5-bit immediate or offset.
  • Format 2 – 11-bit immediate or offset, 5-bit opcode.
  • Format 3 – 8-bit Rd, 3-bit opcode, 5-bit Rs.
  • Format 4 – 5-bit Rm, 3-bit opcode, 8-bit Rd.

Format 1 is very flexible and used for arithmetic, logical, load/store, branch instructions. The small 5-bit immediate field limits complex operations. Format 2 encodes branch offsets and larger immediates compactly. Format 3 handles register moves and ALU ops. Format 4 has a separate Rm source register.

These 16-bit formats encode Thumb opcodes and registers efficiently while providing ample capacity for immediates and offsets. Additional special case instruction formats exist for dealing with PC loads, high registers, and hint instructions.

32-bit Thumb-2 Instruction Extensions

Later revisions of the Thumb instruction set known as Thumb-2 added some 32-bit instructions to improve performance and functionality:

  • Branches – Long PC-relative branches with 24-bit offsets.
  • Load/Store – Wider load/store instructions with largerimmediate offsets.
  • ALU – 32-bit arithmetic/logical instructions with more operands.
  • Multiply – 32-bit multiply instructions for better performance.
  • Coprocessor – Improved coprocessor control instructions.

These 32-bit Thumb-2 instructions augment the space-saving 16-bit Thumb instruction set with more powerful operations commonly needed for performance. They allow Thumb code to avoid having to switch to ARM mode as frequently.

Interworking Between Thumb and ARM

To allow mixing Thumb and ARM code, processors with Thumb support provide interworking capabilities to switch modes smoothly:

  • The program counter bit 0 indicates Thumb (1) or ARM (0) execution state.
  • BX register instructions can change this bit to switch modes.
  • PC-relative branches handle bit 0 automatically.
  • BLX allows calling ARM code from Thumb and vice versa.
  • Special code sequence requirements for some mode transitions.

With interworking, Thumb code can be used for compact sections like critical loops or I/O routines, with ARM code used where full power is needed. Optimizing compilers can generate optimal mixes of Thumb and ARM code within a program.

Thumb-2 Extensions in ARMv6T2 and ARMv7

The ARMv6T2 architecture introduced more instructions and changes for Thumb-2:

  • More 32-bit Thumb instructions
  • If-Then instructions for better conditional execution
  • New register naming conventions
  • Thumb instruction reordering to improve pipeline performance

ARMv7 added further enhancements:

  • Thumb-2 code density improvements
  • More conditional execution options
  • Bitfield and branch hint instructions
  • Synchronization instructions for multiprocessing

These changes made the Thumb-2 instruction set nearly as capable as ARM in many applications while retaining the code size advantage. Most ARM processors now provide full Thumb-2 support.

Benefits of Using Thumb

Here are some of the key benefits of using the Thumb instruction set:

  • Reduced code size – The main advantage of Thumb is its smaller 16-bit instructions reducing code size compared to 32-bit ARM.
  • Lower memory requirements – Less code allows embedded systems to use smaller, lower cost memory and reduce memory bandwidth needs.
  • Better performance – Smaller code fits better in caches and pipelines, improving overall performance.
  • Power efficiency – Fetching less code consumes less memory power, important in battery-powered devices.
  • Binary compatibility – Thumb binaries work on all ARMv4T+ processors with interworking.
  • Ease of use – Compilers handle Thumb code generation automatically.

For embedded operating systems, RTOS code size, and memory footprint are critical concerns. Thumb provides a compelling way to reduce overhead and improve performance across almost all ARM embedded designs.

Limitations of Thumb

Thumb also has some disadvantages and limitations to consider:

  • Reduced functionality versus full ARM instruction set.
  • Overhead to switch between Thumb and ARM states.
  • More complicated code for some operations.
  • Limited support for some DSP algorithms.
  • Not recommended for complex application processing.

For performance-sensitive code segments, ARM instructions may be preferable. Thumb is best suited for simpler high-volume code where code size matters most.

Conclusion

The Thumb instruction set has become an essential part of most ARM embedded processors. Its 16-bit compressed instructions provide much better code density compared to 32-bit ARM code while retaining good performance. The interworking capabilities allow Thumb and ARM code to be mixed cleanly within programs.

Modern Thumb-2 extensions improve performance for 32-bit operations while maintaining compact code size. As memory costs decline, the code size benefits of Thumb remain relevant for optimizing instruction caches, buses, and power efficiency.

For embedded developers, Thumb provides an easy way to reduce system cost and improve performance. ARM’s excellent support for Thumb makes it simple to utilize in new designs for significant benefits.

Newsletter Form (#3)

More ARM insights right in your inbox

 


Share This Article
Facebook Twitter Email Copy Link Print
Previous Article What is the TrustZone in the Arm Cortex?
Next Article What is the TM4C123 Microcontroller?
Leave a comment Leave a comment

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

2k Followers Like
3k Followers Follow
10.1k Followers Pin
- Sponsored-
Ad image

You Might Also Like

Staying under code size limits when simulating Cortex-M0 in ModelSim Student

The Cortex-M0 is one of ARM's most popular microcontroller cores,…

7 Min Read

Optimizing interrupt vectors and RTX task switching on Cortex-M1

The Cortex-M1 processor implements the ARMv6-M architecture, which provides a…

6 Min Read

ARM Cortex M Boot Process

The ARM Cortex M is a family of 32-bit RISC…

8 Min Read

Implementing Floating Point Math on Cortex-M3

The Cortex-M3 processor provides hardware support for single precision floating…

11 Min Read
SoCSoC
  • Looking for Something?
  • Privacy Policy
  • About Us
  • Sitemap
  • Contact Us
Welcome Back!

Sign in to your account