Cross-compilation mental model in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of cross-compiled embedded C code with different endianness

Consider this embedded C code compiled on a host machine (little-endian) but running on a target machine (big-endian). What will be the output when the program prints the integer value stored in memory?

Embedded C

#include <stdio.h>

int main() {
    unsigned int x = 0x12345678;
    unsigned char *p = (unsigned char *)&x;
    printf("%02x %02x %02x %02x\n", p[0], p[1], p[2], p[3]);
    return 0;
}

A 00 00 00 00

B 78 56 34 12

C Error: incompatible types

D 12 34 56 78

💡 Hint

The host endianness does not affect runtime memory layout; consider the target's big-endian storage.

The program executes on the big-endian target. The constant 0x12345678 is stored with most significant byte first: 12 34 56 78. Printing bytes in memory order (p[0] to p[3]) outputs 12 34 56 78. Host endianness is irrelevant at runtime.

🧠 Conceptual

intermediate

Understanding cross-compilation toolchain components

Which component in a cross-compilation toolchain is responsible for converting source code into machine code for the target architecture?

A Cross-compiler

B Target assembler

C Host linker

D Host debugger

💡 Hint

Think about which tool translates code to target machine instructions.

The cross-compiler compiles source code into machine code for the target architecture. The host linker and debugger run on the host, and the target assembler converts assembly code to machine code but is usually part of the cross-compiler toolchain.

🔧 Debug

advanced

Debugging a cross-compiled embedded program with wrong output

You cross-compiled a program for an embedded device. The program reads sensor data but always prints zero. Which of these is the most likely cause?

Embedded C

#include <stdio.h>

volatile int *sensor = (int *)0x40000000;

int main() {
    int value = *sensor;
    printf("Sensor value: %d\n", value);
    return 0;
}

A The variable 'value' is not declared volatile.

B The printf format specifier %d is wrong for int type.

C The sensor address is incorrect for the target device memory map.

D The program lacks a main function.

💡 Hint

Check if the memory address matches the target device's hardware layout.

If the sensor address is wrong, reading from it returns zero or garbage. The format specifier %d is correct for int. Declaring 'value' volatile is not necessary here. The program has a main function.

📝 Syntax

advanced

Identifying syntax error in cross-compiled embedded C code

Which option contains a syntax error that will prevent cross-compilation?

Embedded C

void setup() {
    int x = 10
    if (x > 5) {
        x = x + 1;
    }
}

A Incorrect braces placement in if statement

B Missing semicolon after 'int x = 10'

C Using 'void' as return type in setup function

D Using 'x' without declaration

💡 Hint

Look carefully at the end of each statement.

The line 'int x = 10' is missing a semicolon, causing a syntax error. Using 'void' as return type and braces placement are correct. 'x' is declared properly.

🚀 Application

expert

Determining the number of instructions generated by cross-compilation

Given this simple embedded C function, how many assembly instructions will the cross-compiler likely generate for the return statement on a typical ARM Cortex-M target?

Embedded C

int add_one(int a) {
    return a + 1;
}

A 2 instructions

B 1 instruction

C 3 instructions

D 4 instructions

💡 Hint

Consider loading the argument, adding 1, and returning the result.

Typically, the compiler generates one instruction to add 1 to the input register and one instruction to return (branch). So, about 2 instructions.

Practice

1.

What is the main purpose of cross-compilation in embedded C programming?

easy

A. To build programs on one machine that run on a different machine with another processor

B. To compile code faster on the same machine

C. To debug programs directly on the target device

D. To convert C code into assembly language for the same machine

Solution

1. Step 1: Understand cross-compilation concept

   Cross-compilation means compiling code on one machine to run on a different machine with a different processor architecture.

2. Step 2: Identify the correct purpose

   The main goal is to build programs on a host machine that will run on a target machine with different hardware.

3. Final Answer:

   To build programs on one machine that run on a different machine with another processor -> Option A

4. Quick Check:

   Cross-compilation = build on host, run on target [OK]

Hint: Cross-compilation means build on one, run on another [OK]

Common Mistakes:

• Thinking cross-compilation speeds up compilation on the same machine
• Confusing cross-compilation with debugging on target
• Assuming it only converts code to assembly

2.

Which of the following is the correct command to use a cross-compiler named arm-none-eabi-gcc to compile main.c for an ARM target?

easy

A. gcc main.c -o main

B. gcc-arm main.c -o main

C. arm-none-eabi-gcc main.c -o main

D. arm-gcc main.c -o main

Solution

1. Step 1: Identify the cross-compiler toolchain name

   The cross-compiler for ARM embedded targets is usually named arm-none-eabi-gcc.

2. Step 2: Check the command syntax

   Using arm-none-eabi-gcc main.c -o main compiles main.c for the ARM target correctly.

3. Final Answer:

   arm-none-eabi-gcc main.c -o main -> Option C

4. Quick Check:

   Use full cross-compiler name for target build [OK]

Hint: Use full cross-compiler name, not just gcc [OK]

Common Mistakes:

• Using plain gcc which compiles for host machine
• Using incomplete or incorrect compiler names
• Assuming arm-gcc is a valid command

3.

Given the following Makefile snippet for cross-compilation:

CC=arm-none-eabi-gcc
CFLAGS=-mcpu=cortex-m3 -mthumb

all:
	$(CC) $(CFLAGS) main.c -o main.elf

What is the expected output file type?

medium

A. An executable file for ARM Cortex-M3 target

B. A shared library for Linux

C. A text file with assembly code

D. An executable file for the host machine

Solution

1. Step 1: Analyze the compiler and flags

   The compiler is arm-none-eabi-gcc targeting ARM Cortex-M3 with -mcpu=cortex-m3 and -mthumb flags.

2. Step 2: Determine output type

   The output main.elf is an executable file for the ARM Cortex-M3 embedded target, not the host machine.

3. Final Answer:

   An executable file for ARM Cortex-M3 target -> Option A

4. Quick Check:

   Cross-compiler + target flags = target executable [OK]

Hint: Check compiler name and flags to find target type [OK]

Common Mistakes:

• Assuming output runs on host machine
• Confusing ELF with text or shared library
• Ignoring target CPU flags

4.

Consider this cross-compilation command:

arm-none-eabi-gcc main.c -o main.elf

After running, the file main.elf is missing. What is the most likely cause?

medium

A. The source file main.c is empty

B. The cross-compiler is not installed or not in PATH

C. The output file was created but hidden

D. The command syntax is incorrect

Solution

1. Step 1: Check command correctness

   The command syntax is correct for cross-compilation.

2. Step 2: Identify common causes for missing output

   If main.elf is missing, the most common reason is the cross-compiler is not installed or not found in the system PATH, so the command fails silently or with error.

3. Final Answer:

   The cross-compiler is not installed or not in PATH -> Option B

4. Quick Check:

   Missing output usually means compiler not found [OK]

Hint: Missing output? Check if cross-compiler is installed [OK]

Common Mistakes:

• Assuming empty source file causes no output file
• Thinking output file is hidden by default
• Blaming command syntax without error messages

5.

You want to build firmware for a new embedded device with an unknown CPU architecture. Which step is essential before starting cross-compilation?

hard

A. Use the host machine's default compiler without changes

B. Write the entire program in assembly language

C. Compile the code on the target device directly

D. Identify the target CPU architecture and select the matching cross-compiler toolchain

Solution

1. Step 1: Understand cross-compilation requirements

   Cross-compilation requires a toolchain that matches the target CPU architecture to generate compatible code.

2. Step 2: Identify the essential preparation step

   Before compiling, you must identify the target CPU architecture and select the correct cross-compiler toolchain for that architecture.

3. Final Answer:

   Identify the target CPU architecture and select the matching cross-compiler toolchain -> Option D

4. Quick Check:

   Correct toolchain = successful cross-compilation [OK]

Hint: Know your target CPU before choosing toolchain [OK]

Common Mistakes:

• Skipping CPU identification and using wrong compiler
• Thinking assembly language is always required
• Trying to compile on target device directly