Why number representation matters in ARM in ARM Architecture - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to represent a signed 8-bit number in ARM assembly.

ARM Architecture

MOV R0, #[1]

Drag options to blanks, or click blank then click option'

A0xFF

B0x7F

C0x80

D0x00

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0xFF which is -1, not the smallest negative number.

Using 0x7F which is the largest positive number.

0x80 represents -128 in signed 8-bit two's complement, which is important for correct negative number representation in ARM.

2fill in blank

medium

Complete the code to load an unsigned 16-bit number into register R1 in ARM assembly.

ARM Architecture

MOVW R1, #[1]

Drag options to blanks, or click blank then click option'

A0xFFFF

B0x7FFF

C0x8000

D0x0000

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0x7FFF which is max signed 16-bit positive number.

Using 0x8000 which is a signed negative boundary.

0xFFFF is the maximum value for an unsigned 16-bit number, important for correct unsigned number handling in ARM.

3fill in blank

hard

Fix the error in the ARM assembly code that incorrectly interprets a signed number.

ARM Architecture

CMP R2, #[1]

Drag options to blanks, or click blank then click option'

A0xFF

B0x7F

C-128

D128

Attempts:

3 left

💡 Hint

Common Mistakes

Using negative numbers directly in immediate values.

Using 0xFF which is -1 in signed 8-bit.

0x7F (127) is the correct positive boundary for signed 8-bit comparison; using 0xFF or negative literals directly can cause errors in ARM immediate values.

4fill in blank

hard

Fill both blanks to correctly create a mask for extracting the lower 4 bits in ARM assembly.

ARM Architecture

AND R3, R4, #[1] ; mask lower bits
LSR R5, R3, #[2] ; shift right

Drag options to blanks, or click blank then click option'

A0x0F

B4

C8

D0xF0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0xF0 which masks upper bits.

Shifting by 8 which is too much for 4 bits.

0x0F masks the lower 4 bits, and shifting right by 4 moves those bits to the lowest position for processing.

5fill in blank

hard

Fill all three blanks to correctly sign-extend an 8-bit signed number in ARM assembly.

ARM Architecture

UXTB R6, R7
MOV R8, R6, ASR #[1]
ORR R9, R8, R6, LSL #[2]
MOV R10, R9, ASR #[3]

Drag options to blanks, or click blank then click option'

A7

B24

C31

D8

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect shift amounts that do not preserve sign.

Using logical shift right instead of arithmetic shift right.

Shift right arithmetic by 8, then shift left by 24, then shift right arithmetic by 31 bits correctly sign-extends an 8-bit number to 32 bits in ARM.

Practice

1. Why is number representation important in ARM processors?

easy

A. It changes the physical size of the ARM chip

B. It decides the color of the processor casing

C. It controls the speed of the internet connection

D. It determines how data is stored and calculations are performed

Solution

1. Step 1: Understand the role of number representation

   Number representation defines how the processor interprets bits as values, affecting storage and calculations.

2. Step 2: Connect to ARM processing

   ARM uses specific number formats like two's complement to handle signed numbers efficiently, impacting operations.

3. Final Answer:

   It determines how data is stored and calculations are performed -> Option D

4. Quick Check:

   Number representation = Data handling [OK]

Hint: Number representation affects data and math in ARM [OK]

Common Mistakes:

• Confusing number representation with hardware color or size
• Thinking it affects internet speed
• Assuming it changes physical chip dimensions

2. Which number representation does ARM commonly use for signed integers?

easy

A. Excess-127

B. Sign-magnitude

C. Two's complement

D. Binary-coded decimal

Solution

1. Step 1: Identify common signed integer format in ARM

   ARM processors use two's complement to represent signed integers for efficient arithmetic and simplicity.

2. Step 2: Compare with other formats

   Sign-magnitude and excess-127 are less common in ARM; binary-coded decimal is for decimal digits, not signed integers.

3. Final Answer:

   Two's complement -> Option C

4. Quick Check:

   ARM signed integers = Two's complement [OK]

Hint: ARM uses two's complement for signed numbers [OK]

Common Mistakes:

• Choosing sign-magnitude which is less efficient
• Confusing with excess-127 used in floating point
• Selecting binary-coded decimal which is unrelated

3. Consider an ARM processor using 8-bit two's complement. What decimal value does the binary 11111010 represent?

medium

A. -6

B. 250

C. -22

D. 22

Solution

1. Step 1: Recognize two's complement format

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

2. Step 2: Calculate the decimal value

   Invert bits of 11111010 to 00000101, add 1 to get 00000110 which is 6, so original number is -6.

3. Final Answer:

   -6 -> Option A

4. Quick Check:

   Two's complement 11111010 = -6 [OK]

Hint: Invert bits +1 for negative two's complement [OK]

Common Mistakes:

• Reading binary as unsigned (250)
• Miscomputing two's complement conversion
• Confusing negative and positive values

4. An ARM assembly instruction expects a signed 8-bit number, but the programmer provides 0xFF assuming it is 255. What is the actual decimal value interpreted by ARM?

medium

A. -1

B. 255

C. 0

D. 1

Solution

1. Step 1: Understand 8-bit two's complement interpretation

   0xFF in binary is 11111111, which in two's complement represents -1.

2. Step 2: Explain why 255 is incorrect

   255 is unsigned; ARM treats the value as signed, so 0xFF is -1, not 255.

3. Final Answer:

   -1 -> Option A

4. Quick Check:

   0xFF signed 8-bit = -1 [OK]

Hint: 0xFF in signed 8-bit is -1, not 255 [OK]

Common Mistakes:

• Assuming 0xFF is always 255
• Ignoring signed vs unsigned difference
• Confusing hex with decimal directly

5. You want to store the number -128 in an 8-bit ARM register using two's complement. Which binary value should you use?

hard

A. 11111111

B. 10000000

C. 01111111

D. 00000000

Solution

1. Step 1: Identify two's complement range for 8-bit

   8-bit two's complement ranges from -128 (10000000) to 127 (01111111).

2. Step 2: Match -128 to its binary form

   The binary for -128 is 10000000, the smallest negative number representable.

3. Final Answer:

   10000000 -> Option B

4. Quick Check:

   -128 in 8-bit two's complement = 10000000 [OK]

Hint: Smallest 8-bit signed number is 10000000 [OK]

Common Mistakes:

• Choosing 01111111 which is +127
• Selecting 11111111 which is -1
• Using 00000000 which is zero