Скачать или смотреть Fixing .thumb_func Directive Issues in STM32 Assembly Code

Learn how to correctly implement the `.thumb_func` directive in your STM32 assembly projects to prevent linker script errors and ensure proper function execution.
---
This video is based on the question https://stackoverflow.com/q/77060865/ asked by the user 'vbezhenar' ( https://stackoverflow.com/u/315129/ ) and on the answer https://stackoverflow.com/a/77062905/ 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: thumb_func directive is not accounted for

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 .thumb_func Directive Issues in STM32 Assembly

When developing for the STM32F103 using assembly and a linker script, you may encounter problems related to the .thumb_func directive not working as expected. This can lead to potential hard faults when loading your application onto the microcontroller. In this guide, we'll explore the issue, understand its causes, and provide a clean solution to ensure your assembly code runs flawlessly.

The Problem

In your assembly code, you're using the .thumb_func directive to specify that a function should be treated as a Thumb function, which is essential for Cortex-M processors like the STM32. However, there's a crucial detail that needs to be managed correctly:

Linker Output Addressing: The memory addresses used in the vector table generate hard faults because of an encoding issue with the reset handler address.

How It Happens

As described in the original question, your vector table was initially designed like this:

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

The problem arises because ARM encoding requires the address to be set with the least significant bit cleared to indicate it's a Thumb function. This means that reset_exception_handler should actually be encoded as 08000131 instead of 08000130.

The Solution

To address this problem effectively, we can change the structure of our linker script and assembly code. Here’s how:

1. Revise the Linker Script

Remove unnecessary sections and define memory allocation more clearly. Simplifying your linker script can help the linker handle assembly logic correctly.

Updated Linker Script

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

In this updated script, we've focused the .text section to include all text code, minimizing the chances of address misalignment.

2. Simplify the Assembly Code

Your assembly code can also be streamlined to ensure that it incorporates the vector table directly without the separation. Here's the revised assembly code:

Updated Assembly Code

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

Explanation of Changes

Directly Including Vector Table: Instead of maintaining a separate vector table structure, we've consolidated memory references directly into the text section, which clarifies how offsets are handled.

Using the .word Directive: This directive allows us simply to specify the addresses we want to set for the stack pointer and the handler.

Benefits of the New Approach

Cleaner and Simpler Structure: This approach reduces complexity, making it easier to read and understand.

Correct Address Handling: Aligning the addresses correctly mitigates the hard faults seen during code execution.

Less Reliance on Linker: Focusing on assembly for critical edge cases, instead of leaning heavily on linker scripts, improves control over function behavior.

Conclusion

When programming for STM32 with assembly, ensuring that the .thumb_func directive works in harmony with your linker script is crucial for achieving the best results. By revising your scripts and assembly code as shown, you can avoid the pitfalls of address mismanagement and enjoy a smoother programming experience.

Adopting a cleaner approach not only leads to functional correctness but also enhances maintainability in your codebase. Remember, with assembly programming, simplicity is often your best ally!