Bit manipulation in ARM in ARM Architecture

Introduction

Bit manipulation lets you change or check individual bits in a number. This helps control hardware or optimize programs.

Turning on or off specific features in a device by setting bits.

Checking if a particular flag or status is active by reading bits.

Packing multiple small values into one number to save space.

Clearing or toggling bits to reset or change settings.

Performing fast calculations using bit shifts.

Core Concept

ARM Architecture

/* Example ARM assembly instructions for bit manipulation */

/* Set a bit */
ORR Rd, Rn, #bit_mask

/* Clear a bit */
BIC Rd, Rn, #bit_mask

/* Toggle a bit */
EOR Rd, Rn, #bit_mask

/* Check a bit (test) */
TST Rn, #bit_mask

/* Shift left */
LSL Rd, Rn, #shift_amount

/* Shift right */
LSR Rd, Rn, #shift_amount

Rd = destination register, Rn = source register, #bit_mask = bit pattern to manipulate.

These instructions work on 32-bit registers in ARM processors.

Key Points

This sets the 4th bit of R1 and saves the result in R0.

ARM Architecture

/* Set bit 3 (counting from 0) in R1 and store in R0 */
ORR R0, R1, #0x8

This clears the least significant bit of R2 and saves in R3.

ARM Architecture

/* Clear bit 0 in R2 and store in R3 */
BIC R3, R2, #0x1

This flips the 8th bit of R4 and saves in R5.

ARM Architecture

/* Toggle bit 7 in R4 and store in R5 */
EOR R5, R4, #0x80

This multiplies the value in R6 by 4 by shifting bits left.

ARM Architecture

/* Shift R6 left by 2 bits and store in R7 */
LSL R7, R6, #2

Detailed Explanation

This program starts with zero, sets and clears bit 2, toggles bit 0 twice, and shifts 1 left by 3 bits. It shows how each operation changes the bits.

ARM Architecture

/*
 * Simple ARM assembly program to demonstrate bit manipulation
 * It sets, clears, toggles bits and shows results.
 */

    AREA BitManipulation, CODE, READONLY
    ENTRY

start
    MOV R1, #0x0       ; Start with 0 in R1

    ; Set bit 2 (value 4)
    ORR R1, R1, #0x4   ; R1 = 0x4

    ; Clear bit 2
    BIC R1, R1, #0x4   ; R1 = 0x0

    ; Toggle bit 0
    EOR R1, R1, #0x1   ; R1 = 0x1

    ; Toggle bit 0 again
    EOR R1, R1, #0x1   ; R1 = 0x0

    ; Shift left by 3
    MOV R2, #1
    LSL R2, R2, #3     ; R2 = 8

    ; End program (infinite loop)
loop
    B loop

    END

Important Notes

Time complexity is constant O(1) because each instruction runs in one CPU cycle.

Space complexity is minimal; only registers are used.

Common mistake: Using wrong bit mask or forgetting bit numbering starts at 0.

Use bit manipulation when you need fast, low-level control of data or hardware flags.

Summary

Bit manipulation changes individual bits in registers using instructions like ORR, BIC, EOR, TST, LSL, and LSR.

It is useful for setting, clearing, toggling, checking bits, and shifting bits efficiently.

ARM assembly provides simple instructions to do these operations quickly and directly on registers.

Practice

1. Which ARM instruction is used to set specific bits to 1 without changing other bits?

easy

A. BIC

B. ORR

C. EOR

D. LSR

Solution

1. Step 1: Understand ORR instruction

   ORR performs a bitwise OR, setting bits to 1 where either operand has 1.

2. Step 2: Compare with other instructions

   BIC clears bits, EOR toggles bits, LSR shifts bits right. Only ORR sets bits without clearing others.

3. Final Answer:

   ORR -> Option B

4. Quick Check:

   Set bits = ORR [OK]

Hint: ORR sets bits; BIC clears bits; remember ORR for setting [OK]

Common Mistakes:

• Confusing BIC with ORR
• Thinking EOR sets bits
• Mixing shift instructions with bit setting

2. Which of the following is the correct syntax to clear bits using BIC in ARM assembly?

easy

A. BIC R0, R1, R2

B. BIC R0, R1, #R2

C. BIC R0, #R1, R2

D. BIC R0, R1, LSR #1

Solution

1. Step 1: Review BIC syntax

   BIC syntax is BIC destination, source, operand2 (register or immediate). BIC R0, R1, R2 matches this format.

2. Step 2: Analyze other options

   Options using # before register names are invalid; the option attempting a shift lacks the required register operand, making it invalid syntax.

3. Final Answer:

   BIC R0, R1, R2 -> Option A

4. Quick Check:

   BIC syntax = BIC Rd, Rn, Operand2 [OK]

Hint: BIC clears bits: BIC Rd, Rn, Operand2 [OK]

Common Mistakes:

• Using # before register names
• Confusing immediate and register operands
• Adding unnecessary shifts in basic syntax

3. Given the ARM instruction EOR R0, R1, #0xFF and R1 contains 0x0F0F, what will be the value in R0 after execution?

medium

A. 0xF0F0

B. 0x0F00

C. 0xF0F0FF

D. 0x0FF0

Solution

1. Step 1: Understand EOR operation

   EOR performs bitwise exclusive OR between R1 and immediate 0xFF (which is 255 decimal).

2. Step 2: Calculate bitwise EOR

   R1 = 0x0F0F (binary 0000111100001111), immediate 0xFF affects only lower 8 bits (0000000011111111). XOR lower 8 bits: 00001111 XOR 11111111 = 11110000 (0xF0). Upper bits remain 0x0F. So result is 0x0F (upper) and 0xF0 (lower) combined = 0xF0F0.

3. Final Answer:

   0xF0F0 -> Option A

4. Quick Check:

   EOR 0x0F0F ^ 0x00FF = 0xF0F0 [OK]

Hint: EOR toggles bits; XOR lower byte 0x0F with 0xFF = 0xF0 [OK]

Common Mistakes:

• Applying immediate to full 16 bits
• Confusing OR with XOR
• Ignoring bitwise operation effects

4. Identify the error in this ARM assembly snippet intended to clear bit 3 of R2:
BIC R2, R2, #3

medium

A. BIC cannot use immediate values

B. Syntax error: missing comma after R2

C. Immediate value #3 clears bits 0 and 1, not bit 3

D. Should use ORR instead of BIC

Solution

1. Step 1: Understand BIC with immediate

   BIC clears bits set in the immediate value. #3 in binary is 00000011, which clears bits 0 and 1.

2. Step 2: Check which bit to clear

   Bit 3 corresponds to binary 00001000 (decimal 8). Using #3 clears wrong bits.

3. Final Answer:

   Immediate value #3 clears bits 0 and 1, not bit 3 -> Option C

4. Quick Check:

   Clear bit 3 needs #8, not #3 [OK]

Hint: Immediate #3 clears bits 0 and 1, use #8 for bit 3 [OK]

Common Mistakes:

• Using wrong immediate value for bit position
• Thinking BIC can't use immediate
• Confusing ORR and BIC roles

5. You want to toggle bits 0 and 2 of register R3 without affecting other bits. Which ARM instruction and operand should you use?

hard

A. AND R3, R3, #0x05

B. ORR R3, R3, #0x05

C. BIC R3, R3, #0x05

D. EOR R3, R3, #0x05

Solution

1. Step 1: Identify bits to toggle

   Bits 0 and 2 correspond to binary 00000101 (hex 0x05).

2. Step 2: Choose instruction for toggling bits

   EOR toggles bits where mask bits are 1. ORR sets bits, BIC clears bits, AND masks bits.

3. Step 3: Apply EOR with mask 0x05

   EOR R3, R3, #0x05 flips bits 0 and 2, leaving others unchanged.

4. Final Answer:

   EOR R3, R3, #0x05 -> Option D

5. Quick Check:

   Toggle bits = EOR with mask [OK]

Hint: Toggle bits with EOR and mask of bits to flip [OK]

Common Mistakes:

• Using ORR or AND instead of EOR for toggling
• Wrong mask value for bits 0 and 2
• Confusing clearing with toggling