使用“riscv-none-embed-gcc”时，如何在 main() 函数中将局部变量设置为数据内存地址？

Question

enter image description here

This picture show that I hope to do, here have two memory.

The program memory and data memory, when I want to use data, it'll go data memory get that data.

My c code here：

#define XRAM0 0x4000      // REG I/O

int b=0x35;

void main ()
{
    
    int a=0x55;        // i hope GCC compiler can initial 0x55 value into mem_data region
    
    int *address;
    
    address = XRAM0;
    address[0]=a;      // But GCC compiler always read a variable from Dbus(not initialed yet, there is no value 0x55)
    address[1]=b;
}

Have b variable and a variable, GCC compiler always read a variable from Dbus, but when not initialed yet, there is no value 0x55, so I hope GCC compiler can initial 0x55 value into mem_data region.

I use riscv-none-embed-gcc to generator code for test, and i use ld want to set up memory address.

command：

riscv-none-embed-gcc -lc -nostdlib  -O3 -march=rv32im  -T test.ld TEST.c -o TEST.o -lg -lgloss -mcmodel=medlow 
riscv-none-embed-objcopy -O verilog "TEST.o"  "TEST.vn"
riscv-none-embed-objdump --disassemble-all -S -d TEST.o > TEST.lst 

At ld file I set up program memory and data memory ORIGIN and put data in data memory.

ld：

OUTPUT_ARCH( "riscv" )

MEMORY {
  mem_text (rx) : ORIGIN = 0x00000000, LENGTH = 0x1000000   // This is program memory ORIGIN that I set.
  mem_data (rw) : ORIGIN = 0x20000000, LENGTH = 0x1000000   // This is data memory ORIGIN that I set.
}

SECTIONS
{
  . = 0x00000000;
 
  .text : { *(.text) } > mem_text  // Put code in program memory.

  . = 0x20000000;
  .data : {
    *(.sdata)
  } > mem_data   // Put data in data memory.
}

After generate I get this, the b variable at mem_data region but a is not, there different is a variable is in main function.

TEST.o:     file format elf32-littleriscv


Disassembly of section .text.startup:

00000000 <main>:
   0:   000047b7            lui a5,0x4
   4:   05500713            li  a4,85
   8:   00e7a023            sw  a4,0(a5) # 4000 <main+0x4000>
   c:   20000737            lui a4,0x20000
  10:   00072703            lw  a4,0(a4) # 20000000 <b>
  14:   00e7a223            sw  a4,4(a5)
  18:   00008067            ret

Disassembly of section .data:

20000000 <b>:
20000000:   0035                    c.nop   13   // b variable at mem_data region but a is not

I convert to machine code, we can see the same thing b variable at mem_data region but a is not.

So how can I initial 0x55 value into mem_data region?

@00000000
B7 47 00 00 13 07 50 05 23 A0 E7 00 37 07 00 20 
03 27 07 00 23 A2 E7 00 67 80 00 00 
@20000000
35 00 00 00   // b variable at mem_data region but a is not.

I change my ld but still no change at machine code.

OUTPUT_ARCH( "riscv" )

MEMORY {
  mem_text (rx) : ORIGIN = 0x00000000, LENGTH = 0x1000000   
  mem_data (rw) : ORIGIN = 0x20000000, LENGTH = 0x1000000   
}

SECTIONS
{
  . = 0x00000000;
 
  .text : { *(.text) } > mem_text  

  . = 0x20000000;
  .data : {
    *(.sdata)
  } > mem_data at > mem_text
}

TEST.o:     file format elf32-littleriscv


Disassembly of section .text.startup:

00000000 <main>:
   0:   000047b7            lui a5,0x4
   4:   05500713            li  a4,85
   8:   00e7a023            sw  a4,0(a5) # 4000 <main+0x4000>
   c:   20000737            lui a4,0x20000
  10:   00072703            lw  a4,0(a4) # 20000000 <b>
  14:   00e7a223            sw  a4,4(a5)
  18:   00008067            ret

Disassembly of section .data:

20000000 <b>:
20000000:   0035                    c.nop   13

@00000000
B7 47 00 00 13 07 50 05 23 A0 E7 00 37 07 00 20 
03 27 07 00 23 A2 E7 00 67 80 00 00 
@0000001C
35 00 00 00 

Answer 1

Your question isn't very clear, so allow me to reformulate and correct me if I am wrong :

You have a global variable b that is stored and initialised in the mem_data region, and you want your local a variable to also be stored and initialised in the mem_data region.

If we convert the assembly back to a C-like pseudocode, it looks like this :

int b = 0x35;

void main()
{
    const int *address = 0x4000;

    a5 = 0x4000;      //  0:   lui a5,0x4
    a4 = 0x55;        //  4:   li  a4,85
    address[a5] = a4; //  8:   sw  a4,0(a5)
    a4 = &b;          //  c:   lui a4,0x20000
    a4 = *a4;         // 10:   lw  a4,0(a4)
    a5[4] = a4;       // 14:   sw  a4,4(a5)
    return;           // 18:   ret
}

You can see that the variable a is never stored in memory but its value is still used. This is caused by the optimisation, and the storage class of the variable. Variables declared outside of a function are static , meaning they will always have the same address. This is the case of b . a on the other hand has an automatic storage duration .

Automatic variables are stored on the stack, and only exist for the duration of the function/scope they are declared in. Because a function can be recursively called, a new variable is created every time the function is called. This means it cannot have a fixed address and that's why it wont have a dedicated address in mem_data , instead it will have an address on the stack and will be initialised at runtime.

This explains why it doesn't have an address, but it doesn't explain why it isn't stored in memory. That is caused by optimisation. The compiler is clever enough to understand that your variable has a value that is immediately used after. So instead of wasting time to store it, load it and then use it, it will simply use the value and never declare the variable.

In short, a is not stored in memory because it an auto variable and the compiler optimise it out.

---

So your options are the following :

• If you want to ensure the variable is stored in memory, declare it with volatile . It makes sure the compiler loads the data from memory every time it needs it, and can greatly reduce performance. That's used for variables that may change in a way the compiler don't expect it, like peripheral registers in microcontrollers. You probably don't need that here.

• If you want it to have a dedicated address and have it initialised like b , but still only be visible in main() , declare it with static . That's the option you should probably chose if you want a to behave like b .

• If none of the above really matter, let the compiler optimise it for you. That's most probably what you really need.

Note that setting a to static apparently won't place it in the memory for you simple program even with optimisation at the lowest, at least with my version of riscv32-gcc. If I declare it with static volatile , it appears in mem_data :

00011a08 <b>:
   11a08:   0035                    .2byte  0x35
    ...

00011a0c <a.0>:
   11a0c:   0055                    .2byte  0x55
    ...

Only do it for testing purposes, otherwise it will impact performance.