Signed and unsigned integers in ARM Architecture - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an unsigned 8-bit integer in ARM assembly.

ARM Architecture

MOV [1], #255 ; Load maximum value for unsigned 8-bit integer

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

AR1

BR0

CR2

DR3

Attempts:

3 left

💡 Hint

Common Mistakes

Using a register reserved for special purposes.

Trying to load a value larger than 255 for an 8-bit integer.

R1 is commonly used as a general-purpose register. Here, it holds the maximum unsigned 8-bit value 255.

2fill in blank

medium

Complete the code to sign-extend an 8-bit signed integer to 32 bits in ARM assembly.

ARM Architecture

SXTB [1], R2 ; Sign-extend byte in R2 to 32 bits

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

AR3

BR1

CR0

DR4

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same register as source and destination, which may overwrite data.

Choosing a register reserved for special functions.

R0 is used here to store the sign-extended 32-bit value from the 8-bit value in R2.

3fill in blank

hard

Fix the error in the code to correctly compare a signed and unsigned integer in ARM assembly.

ARM Architecture

CMP R5, [1] ; Compare R5 with unsigned integer in R6

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

AR4

BR6

CR5

DR7

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing a register with itself.

Using a register that does not hold the intended value.

The comparison should be between R5 and R6 as R6 holds the unsigned integer.

4fill in blank

hard

Fill both blanks to create a mask for extracting the lower 8 bits of a 32-bit unsigned integer.

ARM Architecture

AND [1], R8, [2] ; Mask lower 8 bits

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

AR9

BR10

C#0xFF

D#0xFFFF

Attempts:

3 left

💡 Hint

Common Mistakes

Using a mask that extracts more than 8 bits.

Overwriting the source register accidentally.

R9 is used as the destination register to store the masked result. The mask #0xFF extracts the lower 8 bits.

5fill in blank

hard

Fill all three blanks to correctly perform a signed right shift by 3 bits on a 32-bit signed integer.

ARM Architecture

ASR [1], [2], [3] ; Arithmetic shift right by 3 bits

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

AR11

BR12

C#3

D#2

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same register for source and destination.

Using the wrong shift amount.

R11 is the source register holding the signed integer. R12 is the destination register. The shift amount is #3 bits.

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