Keep rodata located with the function that created it

岁酱吖の 提交于 2021-01-27 13:27:50

问题


I'm trying to make .rodata section location stay with its associated function memory location. I'm using the GNU compiler/linker, bare metal, plain-jane c, with an STM32L4A6 micro-controller.

I have a custom board using an STM32L4A6 controller with 1Meg of Flash divided into 512 - 2K pages. Each page can be individually erased and programmed from a function running in RAM. I'd like to take advantage of this fine-grained flash organization to create an embedded firmware application that can be updated on-the-fly by modifying or adding individual functions in the code. My scheme is to dedicate a separate page of flash for each function that might ever need to be changed or created. It's extremely wasteful of flash but I'll never use more than ~10% of it so I can afford to to be wasteful. I've made some progress on this and can now make significant changes to the operation of my application by uploading very small bits of binary code. These "Patches" often do not even require a system reboot.

The problem I'm having is that when a function contains any sort of constant data, such as a literal string, it winds up in the .rodata section. I need the rodata for a given function to stay in the same area as the function that created it. Does anyone know how I might be able to force the .rodata that is created in a function to stay attached to that same function in flash? Like maybe the .rodata from that function could be positioned immediately following the function itself? Maybe I need to use -ffunction-sections or something like that? I've been through the various linker manuals but still can't figure how to do this. Below is the start of my linker script. I don't know how to include function .rodata in the individual page sections.

Example function:

#define P018 __attribute__((long_call, section(".txt018")))
P018 int Function18(int A, int B){int C = A*B; return C;}

A better example that shows my problem would be the following:

#define P152 __attribute__((long_call, section(".txt152")))
P152 void TestFunc(int A){printf("%d Squared Is: %d\r\n",A,A*A);}

In this case, the binary equivalent of "%d Squared Is: %d\r\n" can be found in .rodata with all of the other literal strings in my program. I would prefer it to be located in section .txt152 .

Linker Script snippet (Mostly generated from a simple console program.)

MEMORY
{
    p000 (rx)      : ORIGIN = 0x08000000, LENGTH = 0x8000

    p016 (rx)      : ORIGIN = 0x08008000, LENGTH = 0x800
    p017 (rx)      : ORIGIN = 0x08008800, LENGTH = 0x800
    p018 (rx)      : ORIGIN = 0x08009000, LENGTH = 0x800
.
.
.
    p509 (rx)      : ORIGIN = 0x080fe800, LENGTH = 0x800
    p510 (rx)      : ORIGIN = 0x080ff000, LENGTH = 0x800
    p511 (rx)      : ORIGIN = 0x080ff800, LENGTH = 0x800

    ram (rwx)      : ORIGIN = 0x20000000, LENGTH = 256K
    ram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 64K
}

SECTIONS 
{
    .vectors : 
    { 
        KEEP(*(.isr_vector .isr_vector.*))
    } > p000

    .txt016 : { *(.txt016) } > p016  /* first usable 2k page following 32k p000 */ 
    .txt017 : { *(.txt017) } > p017
    .txt018 : { *(.txt018) } > p018
.
.
.
    .txt509 : { *(.txt509) } > p509
    .txt510 : { *(.txt510) } > p510
    .txt511 : { *(.txt511) } > p511

    .text :
    {
        *(.text .text.* .gnu.linkonce.t.*)        
        *(.glue_7t) *(.glue_7)                      
        *(.rodata .rodata* .gnu.linkonce.r.*)       
    } > p000      
.
.
.

In case anyone's interested, here's my RAM code for doing the erase/program operation

__attribute__((long_call, section(".data")))
void CopyPatch
(
        unsigned short Page,
        unsigned int NumberOfBytesToFlash,
        unsigned char *PatchBuf
)
{
    unsigned int            i;
    unsigned long long int  *Flash;

    __ASM volatile ("cpsid i" : : : "memory");                  //disable interrupts
    Flash = (unsigned long long int *)(FLASH_BASE + Page*2048); //set flash memory pointer to Page address
    GPIOE->BSRR = GPIO_BSRR_BS_1;                               //make PE1(LED) high
    FLASH->KEYR = 0x45670123;                                   //unlock the flash
    FLASH->KEYR = 0xCDEF89AB;                                   //unlock the flash
    while(FLASH->SR & FLASH_SR_BSY){}                           //wait while flash memory operation is in progress
    FLASH->CR = FLASH_CR_PER | (Page << 3);                     //set Page erase bit and the Page to erase
    FLASH->CR |= FLASH_CR_STRT;                                 //start erase of Page
    while(FLASH->SR & FLASH_SR_BSY){}                           //wait while Flash memory operation is in progress
    FLASH->CR = FLASH_CR_PG;                                    //set flash programming bit
    for(i=0;i<(NumberOfBytesToFlash/8+1);i++)
    {
        Flash[i] = ((unsigned long long int *)PatchBuf)[i];     //copy RAM to FLASH, 8 bytes at a time
        while(FLASH->SR & FLASH_SR_BSY){}                       //wait while flash memory operation is in progress
    }
    FLASH->CR = FLASH_CR_LOCK;                                  //lock the flash
    GPIOE->BSRR = GPIO_BSRR_BR_1;                               //make PE1(LED) low
    __ASM volatile ("cpsie i" : : : "memory");                  //enable interrupts
}

回答1:


Okay ... Sorry for the delay, but I had to think about this a bit ...

I'm not sure you can do this [completely] with a linker script alone. It might be possible, but I think there's an easier/surer way [with a bit of extra prep]

A method I've used before is to compile with -S to get a .s file. Change/mangle that. And, then, compile the modified .s

Note that you may have some trouble with a global like:

int B;

This will go to a .comm section in the asm source. This may not be ideal.

For initialized data:

int B = 23;

You may want to add a section attribute to force it to a special section. Otherwise, it will end up in a .data section

So, I might avoid .comm and/or .bss sections in favor of always using initialized data. That's because .comm has the same issue as .rodata (i.e. it ends up as one big blob).

Anyway, below is a step by step process.


I put the section name macros in a common file (e.g.) sctname.h:

#define _SCTJOIN(_pre,_sct)         _pre #_sct

#define _TXTSCT(_sct)       __attribute__((section(_SCTJOIN(".txt",_sct))))
#define _DATSCT(_sct)       __attribute__((section(_SCTJOIN(".dat",_sct))))

#ifdef SCTNO
#define TXTSCT              _TXTSCT(SCTNO)
#define DATSCT              _DATSCT(SCTNO)
#endif

Here's a slightly modified version of your .c file (e.g. module.c):

#include <stdio.h>

#ifndef SCTNO
#define SCTNO   152
#endif
#include "sctname.h"

int B DATSCT = 23;

TXTSCT void
TestFunc(int A)
{
    printf("%d Squared Is: %d\r\n", A, A * A * B);
}

To create the .s file, we do:

cc -S -Wall -Werror -O2 module.c

The actual section name/number can be specified on the command line:

cc -S -Wall -Werror -O2 -DSCTNO=152 module.c

This gives us a module.s:

    .file   "module.c"
    .text
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string "%d Squared Is: %d\r\n"
    .section    .txt152,"ax",@progbits
    .p2align 4,,15
    .globl  TestFunc
    .type   TestFunc, @function
TestFunc:
.LFB11:
    .cfi_startproc
    movl    %edi, %edx
    movl    %edi, %esi
    xorl    %eax, %eax
    imull   %edi, %edx
    movl    $.LC0, %edi
    imull   B(%rip), %edx
    jmp printf
    .cfi_endproc
.LFE11:
    .size   TestFunc, .-TestFunc
    .globl  B
    .section    .dat152,"aw"
    .align 4
    .type   B, @object
    .size   B, 4
B:
    .long   23
    .ident  "GCC: (GNU) 8.3.1 20190223 (Red Hat 8.3.1-2)"
    .section    .note.GNU-stack,"",@progbits

Now, we have to read in the .s and modify it. I've created a perl script that does this (e.g. rofix):

#!/usr/bin/perl

master(@ARGV);
exit(0);

sub master
{
    my(@argv) = @_;

    $root = shift(@argv);

    $root =~ s/[.][^.]+$//;

    $sfile = "$root.s";
    $ofile = "$root.TMP";

    open($xfsrc,"<$sfile") or
        die("rofix: unable to open '$sfile' -- $!\n");

    open($xfdst,">$ofile") or
        die("rofix: unable to open '$sfile' -- $!\n");

    $txtpre = "^[.]txt";
    $datpre = "^[.]dat";

    # find the text and data sections
    seek($xfsrc,0,0);
    while ($bf = <$xfsrc>) {
        chomp($bf);

        if ($bf =~ /^\s*[.]section\s(\S+)/) {
            $sctcur = $1;
            sctget($txtpre);
            sctget($datpre);
        }
    }

    # modify the data sections
    seek($xfsrc,0,0);
    while ($bf = <$xfsrc>) {
        chomp($bf);

        if ($bf =~ /^\s*[.]section\s(\S+)/) {
            $sctcur = $1;
            sctfix();
            print($xfdst $bf,"\n");
            next;
        }

        print($xfdst $bf,"\n");
    }

    close($xfsrc);
    close($xfdst);

    system("diff -u $sfile $ofile");

    rename($ofile,$sfile) or
        die("rofix: unable to rename '$ofile' to '$sfile' -- $!\n");
}

sub sctget
{
    my($pre) = @_;
    my($sctname,@sct);

    {
        last unless (defined($pre));

        @sct = split(",",$sctcur);

        $sctname = shift(@sct);
        last unless ($sctname =~ /$pre/);

        printf("sctget: FOUND %s\n",$sctname);

        $sct_lookup{$pre} = $sctname;
    }
}

sub sctfix
{
    my($sctname,@sct);
    my($sctnew);

    {
        last unless ($sctcur =~ /^[.]rodata/);

        $sctnew = $sct_lookup{$txtpre};
        last unless (defined($sctnew));

        @sct = split(",",$sctcur);

        $sctname = shift(@sct);
        $sctname .= $sctnew;

        unshift(@sct,$sctname);
        $sctname = join(",",@sct);

        $bf = sprintf("\t.section\t%s",$sctname);
    }
}

The difference between the old and new module.s is:

sctget: FOUND .txt152
sctget: FOUND .dat152
--- module.s    2020-04-20 19:02:23.777302484 -0400
+++ module.TMP  2020-04-20 19:06:33.631926065 -0400
@@ -1,6 +1,6 @@
    .file   "module.c"
    .text
-   .section    .rodata.str1.1,"aMS",@progbits,1
+   .section    .rodata.txt152,"aMS",@progbits,1
 .LC0:
    .string "%d Squared Is: %d\r\n"
    .section    .txt152,"ax",@progbits

So, now, create the .o with:

cc -c module.s

For a makefile, it might be something like [with some wildcards]:

module.o: module.c
    cc -S -Wall -Werror -O2 module.c
    ./rofix module.s
    cc -c module.s

Now, you can add appropriate placements in your linker script for [your original section] .txt152 and the new .rodata.txt152.

And, the initialized data section .dat152

Note that the actual naming conventions are arbitrary. If you want to change them, just modify rofix [and the linker script] appropriately


Here's the readelf -a output for module.o:

Note that there's also a .rela.txt152 section!?!?

ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              REL (Relocatable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  Entry point address:               0x0
  Start of program headers:          0 (bytes into file)
  Start of section headers:          808 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           0 (bytes)
  Number of program headers:         0
  Size of section headers:           64 (bytes)
  Number of section headers:         15
  Section header string table index: 14

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000000000  00000040
       0000000000000000  0000000000000000  AX       0     0     1
  [ 2] .data             PROGBITS         0000000000000000  00000040
       0000000000000000  0000000000000000  WA       0     0     1
  [ 3] .bss              NOBITS           0000000000000000  00000040
       0000000000000000  0000000000000000  WA       0     0     1
  [ 4] .rodata.txt152    PROGBITS         0000000000000000  00000040
       0000000000000014  0000000000000001 AMS       0     0     1
  [ 5] .txt152           PROGBITS         0000000000000000  00000060
       000000000000001a  0000000000000000  AX       0     0     16
  [ 6] .rela.txt152      RELA             0000000000000000  00000250
       0000000000000048  0000000000000018   I      12     5     8
  [ 7] .dat152           PROGBITS         0000000000000000  0000007c
       0000000000000004  0000000000000000  WA       0     0     4
  [ 8] .comment          PROGBITS         0000000000000000  00000080
       000000000000002d  0000000000000001  MS       0     0     1
  [ 9] .note.GNU-stack   PROGBITS         0000000000000000  000000ad
       0000000000000000  0000000000000000           0     0     1
  [10] .eh_frame         PROGBITS         0000000000000000  000000b0
       0000000000000030  0000000000000000   A       0     0     8
  [11] .rela.eh_frame    RELA             0000000000000000  00000298
       0000000000000018  0000000000000018   I      12    10     8
  [12] .symtab           SYMTAB           0000000000000000  000000e0
       0000000000000150  0000000000000018          13    11     8
  [13] .strtab           STRTAB           0000000000000000  00000230
       000000000000001c  0000000000000000           0     0     1
  [14] .shstrtab         STRTAB           0000000000000000  000002b0
       0000000000000078  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  l (large), p (processor specific)

There are no section groups in this file.

There are no program headers in this file.

There is no dynamic section in this file.

Relocation section '.rela.txt152' at offset 0x250 contains 3 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
00000000000a  00050000000a R_X86_64_32       0000000000000000 .rodata.txt152 + 0
000000000011  000c00000002 R_X86_64_PC32     0000000000000000 B - 4
000000000016  000d00000004 R_X86_64_PLT32    0000000000000000 printf - 4

Relocation section '.rela.eh_frame' at offset 0x298 contains 1 entry:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
000000000020  000600000002 R_X86_64_PC32     0000000000000000 .txt152 + 0

The decoding of unwind sections for machine type Advanced Micro Devices X86-64 is not currently supported.

Symbol table '.symtab' contains 14 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS module.c
     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1
     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    2
     4: 0000000000000000     0 SECTION LOCAL  DEFAULT    3
     5: 0000000000000000     0 SECTION LOCAL  DEFAULT    4
     6: 0000000000000000     0 SECTION LOCAL  DEFAULT    5
     7: 0000000000000000     0 SECTION LOCAL  DEFAULT    7
     8: 0000000000000000     0 SECTION LOCAL  DEFAULT    9
     9: 0000000000000000     0 SECTION LOCAL  DEFAULT   10
    10: 0000000000000000     0 SECTION LOCAL  DEFAULT    8
    11: 0000000000000000    26 FUNC    GLOBAL DEFAULT    5 TestFunc
    12: 0000000000000000     4 OBJECT  GLOBAL DEFAULT    7 B
    13: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND printf

No version information found in this file.


来源:https://stackoverflow.com/questions/61261865/keep-rodata-located-with-the-function-that-created-it

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!