能否通过链接脚本在运行时为变量分配指定地址？附C实现咨询

Great question—this is a super common point of confusion when you’re just starting out with linker scripts, since their static, link-time behavior feels totally disconnected from runtime dynamic values. Let’s break this down clearly, step by step:

First: Why Linker Scripts Can’t Directly Use Runtime Variables #

Linker scripts run at link time, way before your program ever executes. At this stage, there’s no way to know the value of a variable that will only be determined when the program is up and running. Linker scripts only work with fixed addresses, compile-time constants, or symbols (like functions/variables whose addresses get assigned during linking). So you can’t just plug a runtime variable into a linker script directly—they speak different "languages" at different stages of your program’s lifecycle.

But There Are Workarounds to Achieve What You Want #

If you need a section to live at an address that’s only known at runtime, you have two main approaches depending on your exact use case:

Approach 1: Manually Relocate the Section at Runtime #

This involves compiling the section to a temporary fixed address first, then copying its contents to the runtime-determined address when your program starts up.

1. Update your linker script to define the section and export its start/end addresses as symbols:

   /* Define a custom section in a temporary memory region (e.g., RAM) */
   .my_custom_section : {
       __my_sec_start = .;  // Export the section's start address
       *(.my_custom_section)  // Include all code/data marked with this section tag
       __my_sec_end = .;    // Export the section's end address
   } > RAM
   

2. In your C code, declare the exported symbols, fetch the runtime target address, and copy the section over:

   // Declare the linker-exported symbols (they're raw addresses, not pointers)
   extern char __my_sec_start[];
   extern char __my_sec_end[];
   
   int main() {
       // Calculate the size of our custom section
       size_t sec_size = __my_sec_end - __my_sec_start;
   
       // Example: Get a runtime-determined address (could be from config, malloc, hardware, etc.)
       void* target_addr = malloc(sec_size);
       if (!target_addr) {
           // Handle allocation failure (critical error!)
           return 1;
       }
   
       // Copy the section's contents to the runtime address
       memcpy(target_addr, __my_sec_start, sec_size);
   
       // Now use the relocated section: e.g., call a function stored in it
       void (*my_custom_func)() = (void (*)())target_addr;
       my_custom_func();
   
       return 0;
   }
   

   Important Notes:

   • If your section contains functions or variables with hardcoded addresses, you’ll need to compile with position-independent code (PIC) (use -fPIC with GCC) so the code works properly after being copied to a new address.
   • For embedded systems, double-check that the target address is in a memory region with the correct permissions (read/write/execute) for your section.

Approach 2: Use a Pointer to Reference the Runtime Address #

If you don’t need to physically move the section, just want your code to access a runtime-determined address, use a global pointer that you update once you know the target address.

1. Mark your section (optional) in C if you want specific code/data grouped together:

   // Mark this data to go into our custom section
   __attribute__((section(".my_custom_section")))
   char my_custom_data[] = "Hello from the custom section!";
   
   // Global pointer to hold the runtime address (starts with the link-time section address)
   extern char __my_sec_start[];
   void* my_section_ptr = __my_sec_start;
   

2. Update the pointer at runtime to point to your desired address:

   // Custom function to fetch the runtime target address (your logic here)
   void* get_runtime_target() {
       // Example: Return a dynamically allocated address or a hardware register address
       return malloc(sizeof(my_custom_data));
   }
   
   int main() {
       // Update the pointer to point to the runtime-determined address
       my_section_ptr = get_runtime_target();
   
       // Access the data via the pointer
       char* data = (char*)my_section_ptr;
       printf("Data at runtime address: %s\n", data);
   
       return 0;
   }
   

Key Takeaways #

• Linker scripts can’t use runtime variables directly, but you can work around this with runtime relocation or pointer redirection.
• For code sections, always consider PIC if you’re relocating them—this avoids hardcoded address errors after moving the section.
• The symbols exported from linker scripts are raw addresses, so declare them as extern char[] (not char*) to avoid pointer confusion.

内容的提问来源于stack exchange，提问作者Mostafa