Signed and unsigned integers in ARM Architecture

Introduction

Signed and unsigned integers help computers understand if a number can be negative or only positive. This is important for storing and calculating numbers correctly.

When you need to store only positive numbers, like ages or counts.

When you need to store numbers that can be negative, like temperatures or bank balances.

When working with hardware registers that expect unsigned values.

When performing arithmetic operations that must consider negative values.

When optimizing memory usage by choosing the smallest integer type that fits your data.

Core Concept

ARM Architecture

In ARM assembly or C for ARM:

Signed integer: uses two's complement representation.
Unsigned integer: stores only positive values.

Example in C:
int32_t signed_num;    // signed 32-bit integer
uint32_t unsigned_num; // unsigned 32-bit integer

Signed integers can represent both negative and positive numbers.

Unsigned integers represent only zero and positive numbers, allowing a larger positive range.

Key Points

Here, a can be negative, b cannot.

ARM Architecture

int8_t a = -5;    // signed 8-bit integer holding -5
uint8_t b = 250;   // unsigned 8-bit integer holding 250

Signed 16-bit max is 32767, unsigned max is 65535.

ARM Architecture

int16_t x = 32767;    // max positive signed 16-bit integer
uint16_t y = 65535;    // max unsigned 16-bit integer

Detailed Explanation

This program shows how signed and unsigned integers store values and what happens when they overflow their limits.

ARM Architecture

#include <stdio.h>
#include <stdint.h>

int main() {
    int8_t signed_val = -10;
    uint8_t unsigned_val = 250;

    printf("Signed value: %d\n", signed_val);
    printf("Unsigned value: %u\n", unsigned_val);

    // Demonstrate overflow
    signed_val = 127; // max for int8_t
    signed_val += 1;  // overflow
    unsigned_val = 255; // max for uint8_t
    unsigned_val += 1;  // overflow

    printf("Signed overflow result: %d\n", signed_val);
    printf("Unsigned overflow result: %u\n", unsigned_val);

    return 0;
}

Important Notes

Signed integers use the highest bit to indicate the sign (positive or negative).

Unsigned integers use all bits to represent the number, so they can store larger positive values than signed integers of the same size.

Overflow in signed integers can cause wrap-around to negative numbers; in unsigned integers, it wraps back to zero.

Summary

Signed integers can hold negative and positive numbers using two's complement.

Unsigned integers hold only zero and positive numbers, allowing a larger positive range.

Choosing signed or unsigned depends on whether negative values are needed.

Practice

1.

What is the main difference between signed and unsigned integers in ARM architecture?

easy

A. Signed integers use more memory than unsigned integers.

B. Signed integers can represent negative and positive numbers, unsigned only non-negative.

C. Unsigned integers can represent negative numbers, signed cannot.

D. Signed integers are faster to process than unsigned integers.

Solution

1. Step 1: Understand signed integers

   Signed integers use two's complement to represent both negative and positive numbers.

2. Step 2: Understand unsigned integers

   Unsigned integers represent only zero and positive numbers, allowing a larger positive range.

3. Final Answer:

   Signed integers can represent negative and positive numbers, unsigned only non-negative. -> Option B

4. Quick Check:

   Signed = negative and positive, Unsigned = only positive [OK]

Hint: Signed = negatives allowed, unsigned = only zero or positive [OK]

Common Mistakes:

• Thinking unsigned can represent negative numbers
• Assuming signed uses more memory
• Believing signed is always faster

2.

Which of the following is the correct way to declare an unsigned 8-bit integer in ARM assembly?

easy

A. mov r0, #255 (assuming r0 is unsigned 8-bit)

B. movs r0, #255

C. mov r0, #-1

D. mov r0, #256

Solution

1. Step 1: Understand unsigned 8-bit range

   Unsigned 8-bit integers range from 0 to 255, so 255 is valid.

2. Step 2: Check instructions

   mov r0, #255 moves the immediate value 255 into register r0 correctly.

3. Final Answer:

   mov r0, #255 (assuming r0 is unsigned 8-bit) -> Option A

4. Quick Check:

   Unsigned 8-bit max = 255, mov loads immediate [OK]

Hint: Unsigned 8-bit max is 255, use mov with that value [OK]

Common Mistakes:

• Using movs which sets flags unnecessarily
• Trying to move negative values to unsigned
• Using values above 255 for 8-bit

3.

Consider a 4-bit signed integer using two's complement. What decimal value does the binary 1101 represent?

medium

A. -3

B. 13

C. -5

D. 5

Solution

1. Step 1: Identify two's complement sign

   In 4-bit two's complement, if the leftmost bit is 1, the number is negative.

2. Step 2: Calculate decimal value

   Binary 1101: invert bits -> 0010, add 1 -> 0011 (3 decimal), so value is -3. But careful: 1101 is -3 or -5? Let's check carefully:
   1101 binary = (1x-8) + (1x4) + (0x2) + (1x1) = -8 + 4 + 0 + 1 = -3

3. Final Answer:

   -3 -> Option A

4. Quick Check:

   Two's complement 1101 = -3 decimal [OK]

Hint: If MSB is 1, subtract 2^bits from value [OK]

Common Mistakes:

• Treating binary as unsigned
• Forgetting two's complement negative calculation
• Mixing bit positions

4.

In ARM assembly, a programmer tries to store the value -1 in an unsigned 8-bit register. What is the likely result?

medium

A. The program crashes at runtime.

B. Syntax error occurs during assembly.

C. The register stores 0.

D. The register stores 255 due to wrap-around.

Solution

1. Step 1: Understand unsigned storage

   Unsigned 8-bit registers store values 0 to 255. Negative values wrap around using modulo 256.

2. Step 2: Calculate wrap-around for -1

   -1 modulo 256 equals 255, so the register stores 255.

3. Final Answer:

   The register stores 255 due to wrap-around. -> Option D

4. Quick Check:

   Unsigned wrap-around: -1 = 255 [OK]

Hint: Negative to unsigned wraps modulo max+1 [OK]

Common Mistakes:

• Expecting syntax error for negative immediate
• Assuming register stores zero
• Thinking program crashes

5.

You have a 16-bit unsigned integer register holding the value 65535. You subtract 1 from it. What is the result stored in the register?

hard

A. 65536

B. -1

C. 65534

D. 0

Solution

1. Step 1: Understand 16-bit unsigned range

   16-bit unsigned integers range from 0 to 65535.

2. Step 2: Perform subtraction

   65535 - 1 = 65534, which fits in 16 bits without wrap-around.

3. Final Answer:

   65534 -> Option C

4. Quick Check:

   65535 - 1 = 65534 within unsigned 16-bit [OK]

Hint: Subtract within range stays positive, no wrap [OK]

Common Mistakes:

• Thinking result becomes negative
• Assuming overflow to zero
• Confusing unsigned with signed behavior