Скачать или смотреть Understanding the Minimal Assembly Program Execution in ARM GNU/Linux

Learn how a minimal assembly program returns an exit status on ARM GNU/Linux. Understand the role of the C library and important assembly instructions.
---
This video is based on the question https://stackoverflow.com/q/64122252/ asked by the user 'jregalad' ( https://stackoverflow.com/u/4045358/ ) and on the answer https://stackoverflow.com/a/64123538/ provided by the user 'old_timer' ( https://stackoverflow.com/u/16007/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Minimal assembly program ARM

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Minimal Assembly Program Execution in ARM GNU/Linux

When stepping into the world of assembly programming, especially on ARM architecture with GNU/Linux, it can be quite challenging to comprehend how your programs are executed by the CPU. Many learners stumble at various stages, and one frequent point of confusion is how their assembly code interacts with system libraries. In this guide, we'll explore this topic through a simple example: a program that returns the exit status of 5.

The Problem Statement

You want to create an assembly program that, when run, will return 5 as its exit status. The code may look simple:

[[See Video to Reveal this Text or Code Snippet]]

You assemble this code into an object file, and subsequently, link it against the necessary libraries. After doing so, you can run the executable successfully and see:

[[See Video to Reveal this Text or Code Snippet]]

However, one question still looms: what role does the C standard library play in this process?

Assembly Program Execution: What Happens Behind the Scenes

Creating a successful assembly program doesn't just begin and end with the code you've written. There are several foundational steps that occur before your main() function is called:

Stack Initialization: The program’s stack and stack pointer must be established.

Data Initialization: Sections for initialized and uninitialized data are prepared.

Argument Preparation: Arguments to the program, argc and argv, are set up for the main() function call.

These setups are handled by the C library, emphasizing the necessity of linking your assembly code to it. The C library acts as a middleman that facilitates system calls and abstract resource management.

What the C Library Does

System Calls: The C library bridges your program to the operating system, allowing you to perform essential operations like reading from files or exiting the program.

Memory Management: It takes care of properly managing memory layouts, ensuring your program has the right access to segments (text, data, bss, etc.).

Argument Handling: The library processes command-line arguments and prepares them for use within main().

Why Linking is Crucial

When you link your object file with various components (e.g., crti.o, crtn.o, crt1.o, libc.so), you prepare your program to run under the constraints and capabilities of your OS. Proper linking guarantees that:

Entry Points: The operating system knows where your program begins (often indicated by the _start symbol).

Section Placement: The sections of your program are placed correctly in memory.

Exit Handling: The C library is needed to manage the exit process gracefully, making sure any necessary cleanup is done.

Minimal Assembly Implementation without Standard Libraries

If you're seeking to escape the C library's influence entirely, you could write a minimal assembly program that directly interacts with the Linux kernel using system calls. Here’s an outline of how you might go about doing this:

Define Entry Point: Use a linker script that specifies your own entry point.

Implement Exit System Call: Instead of returning to a library function, you'd use assembly instructions to directly invoke a kernel exit system call.

Here’s a skeletal example of how your assembly code could look:

[[See Video to Reveal this Text or Code Snippet]]

In this case, you directly invoke the Linux kernel, bypassing the C library altogether.

Conclusion

Navigating the ARM assembly programming landscape using GNU/Linux can be daunting due to the complex interactions between your code, the C library, and the operating system. This exploration should help clarify these essential components and provide you with insight into how they work together.

Underst