<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/124091>124091</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            Linker OVERLAY feature not working properly / Loading dependent on virtual not physical address
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            new issue
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          luposmi
      </td>
    </tr>
</table>

<pre>
    # My issue
Before I explain the issue, I should start with what the problem is I try to solve:

I am working at a research institute where we are currently working on a processor where only one "management core" has access to the main memory and every other core, the processing cores, only have access to their cache "scratchpad". The loading and unloading of scratchpads and their dependencies are done at compile time and realized by the management core using a DMA at runtime.

For this, I need basically the following:
1. Have the .text section at virtual address 0x0, physical address 0x0
2. Have each other text section (e.g., *vector_program.o(.text)) at virtual address 0x0 but physical address 0x10000000 (stacking those text sections there). Those two regions are mapped to the names rom and ram.

The part with the dependencies resolution is all done at comp time before the linker script is called into action. The only thing required is that the other text sections are present in ram and that a symbol exist for their start and end. When they are needed to be copied into the scratchpad of that specific core is also managed previously.

# How it's in GCC
Disclaimer: I did this testing for x64. However, the stuff in LLVM was for riscv32.
Also, those examples do not all include the label generation, as they are trivial and not the problem.

## Option 1
For the requirements above, I have written a very basic linker script for GCC which looked like this:
```ls
.text0 0x0: AT 0x0 { *core1.o(.text)}
.text1 0x0: AT 0x10000000 { *core2.o(.text)}
```

Which worked already completely fine without any errors and did the right thing.
## Option 2
```ls
OVERLAY 0x0 : AT (0x10000000)
{
    .text0{ *core1.o(.text) }
    .text1{ *core2.o(.text) }
}
```
This does not completely do the right thing, as one text section needs to reside in rom, while all others in ram. However, this also works (you can just add another text section above at 0x0 no problems and then do all other sections in an OVERLAY)


# What I tried in LLVM
compile command:
```bash
clang-19 -target riscv32 -march=rv32imv -mabi=ilp32 -static -mcmodel=medany -fuse-ld=ld -Wno-unused-command-line-argument -g3 -fvisibility=hidden -nostdlib -nostartfiles -Wall -T lld_link.ld ./build/*.o -o out.elf```
``` 
## OVERLAY
### Variant one
```ls
    OVERLAY 0x0 : AT (0x00200000)
 {
        .text0 { *vector_program.o(.text) } 
        .text1 {
 *(.vectors)
        *management_core.o(.text) }
    }
```
Does not work, compiler output:
ld.lld: error: no memory region specified for section '.text0'
ld.lld: error: no memory region specified for section '.text1'
clang-19: error: ld.lld command failed with exit code 1 (use -v to see invocation)
error: Recipe `link` failed on line 14 with exit code 1

### Variant two
if we give it a region:
```ls
    OVERLAY 0x0 : AT (0x00200000)
    {
        .text0 { *vector_program.o(.text) } 
 .text1 {
        *(.vectors)
        *management_core.o(.text) }
    } > rom


    .rodata : {
        . = ALIGN(4);
        *(.rodata);
    } > ram
```
For any reason errors in the next line
ld.lld: error: lld_link.ld:70: : expected, but got .rodata
    .rodata : {
     ^

## Option 3
```ls
    .text0  0x0           :  AT (0x0)       { *management_core.o(.text)} > rom
    .text1  0x0 (OVERLAY) :  AT (0x10000000){ *vector_program.o(.text) } >ram
```
actually compiles, but does not add the required load commands:
ld.lld: warning: ignoring memory region assignment for non-allocatable section '.text_vector'

IDK if this behavior is wanted. But what I can definitely say is that it is very allocatable, as only the virtual address overlaps, not the physical. If i add OVERLAY to both, the other section is also not loaded.
## RAW
If we just use option 1 of gcc, aka
```ls
    .text0  0x0  :  AT (0x0)       { *management_core.o(.text)} > rom
    .text1  0x0  :  AT (0x10000000){ *vector_program.o(.text) } >ram
```
we just get:
ld.lld: error: section .text_management virtual address range overlaps with .text_vector
 .text_management range is [0x0, 0x13EF]
 .text_vector range is [0x0, 0x3CF]

# Workarounds
There are a couple of workarounds. However, they are all anything from annoying to very annoying.
1. Setting every Symbol which gets an Offset through the virtual address manually
2. Editing the resulting elf file per hand to add the required load commands.

PS:
@MaskRay I have seen you work on this issue in the past and mentioning you would like to see reasons for this, so here is one.

Also, the Overlay option 3 has already an open bug report #41351, but nothing moved in the last six years.

We need to use LLVM as the earlier stages of the project require LLVM specific tools. Compiling with LLVM and then linking with GCC has shown to, unfortunately, throw random errors.
</pre>
<img width="1" height="1" alt="" src="http://email.email.llvm.org/o/eJy0WFtv47oR_jXMy8CCLnGcPPjBiZM9QbPdYnexQZ8WtDiSeEKRKknZUX99MaTkW5I9LXqOYSCORA45M998c-HOyVojLtn8ls3XF7z3jbFL1XfGtfJiY8SwZHkBnweQzvXI0tUtVsYiPAK-dopLDb7B8WV-B4_gGtMrAc5z62EnfQO7hvuwqrNmo7AF6eARvB3AG3BGbZEVK5bS9xF4CztjX6SugXvgYNEht2UDUjsvfe8Rdg1ahB0Ctwhlby1qr4b9NqOB01ElOmfsuNpoNYDRCCzPW655jS1qD6WxyPIcGu6Al7SD7kR3bUm1FltjB-BaAG7RDmB8g3bcdTfpRNvoYHrs6Hk4rOFbPJUpLZS8bMIdXGm5L5uOC5bnCXxvEJThIqitBfR6-s9UcFjrwssoSmCHWqAuJbpgCUHqcdKp7aRC8LLFsN4iV_LfKGAzjKqd6A99uD2H9ecV7be9pq1J9MiDseAb6aJzNZIY7mTJlYrSKqOU2UldRydmCfxGmtOrxOOrB4ell-QUD1tpfc8VcCEs2SV9TUlu1wxB4snzdJWPopCXzWj5E4Esv8akTkgCy1dbLL2xPztrasvbxLD8OpzP8huW33xwOmx6_97xWRo_dIbzvAzA8o1xeHIFR2oSFm7IheHtzoDFOrwjp7S861BMoNK8RQfWtNEvvB2NTO7v9vFCK0-8a9EZ1QedpQOu1Imvo6M3MSxpr5L6BS3BRnaedpCzUIDU3gAPF4-ICzj1Delm8V-9tLSIdBrj9a3No1IdBaX2IDXpMGIyRKsb2o1RgK_SeagCdAirkQxCGGmRwHODgTaGII0wFU20QShNJ6er0hUO2KdICKe4DktZyTKCNxjEmRHUgu62laZ3ahhtS_T1m9mB9CxfOLrzp7s7lq7W0pWKyxYtK1bwCEKKAHTw6DyZhK7_enWZ0G6K_inine-riuQ8Pf34DDvuwkorXbktcjp0pZyJiwkR-MrbTqEDYUAbH9wndal6MXqLb1BBjRotJxPTTu4O5vFWbiWBU4uw_4hIDxqSkl-6gJBsH7Q4eZVC3QHfmO3I0YGbdlZ6j0SWgdpCVJ9hhxT7dHcHu0aWDShjXlCAki8YKSGy9lUav8qxdBVCLg0BXKxg9T0EGVvcUoSSv7LTwFyspz3ZyZ5D_B225u9s3R8eLfEc7kmJAAVwZZGLIcSIQo9qgEpqDDFmeoLjAGitsZFVo_8RrKwbH6MieWPc_I3CX37cf31a_TPqGa_P8uuDBnTVdMUWtyxdAUDkxPRDi0DUa78y-9AA48q3dvhOIBYGXYDLkfbCnCs4Yo3I5IRZKSRD1rLopMAQ6Kal1buGUgthOJCDGzngLEimoCRPOLLHYHoouYbfe-eJZoHrdwg9IJRojYypzQTzfdbTpML-7AMnSQ1cw-iJ0eD72H8mzqByI_JKiFqWrqYsWZq25VqcYXnDXUOLFNf1LLuBmee2Rj9FOcxaqklYsbbbIpftlh5sJCvWUnX02nnuZQmztmyNQMWKdYuCADereoczJVixVgJmz9rMet07FLPxIjMlNc64rfuQoGd1AbNqK53cSCX9wIp1I4VADTNtnBdKbuIvbn0liWZmz2Sh2XdQSvykcE6UgITlD5teKsHyB5avEgMzA6b3CarqJIam33AE_dGu0wN69oNbybUn5LyJCMLuR1GRpvlRVMAhLA6hMYX8L_I5QR_ON2aTNJavaG3c78aTxg_LV4fq5ycF1UfR9zau1lNIEaoJ5yOELBmy632EkBKJIveuIrfQD22mQjJWBlMGQxEI9lDOLEZyyBd_iqAsCppAfCIqSp_QDxWXVCGE8gNfJdGGQMjIab1DmG1DqY7EBFtTjnmKDLsX-BVL2SEQCKR-IQSNMo2mpIKQXb4Rf5y-jlHld4alK1lRjV_LLYKMnQDp_F7S-R8QFzz7_4HuFG0HYP05oANW3AeynTgsXNIawT0Pip1dH1ixhtXT46e_s_z6kg4u3rlX3H_ydn8Wb8-ATtUDcZVF7oyecuTY6WkibHLo-xA9Ih1WrBYho4cFrx2WHgXFDdXctfGTVr_Wkc3v36tyindBMDozgODwIYkHPJDFx-fR57_yzalDjrgm4iy_PiSd02OO0_9_Ca3i_q0reEkdixomrnGT_fb5nZLpUaknQhs5xbU756Qdtzq2aiBrbSzVuaeUEicCIfcQp2ijZ1wpinm-UfiGY35GtSLTUAO__hvIKpYAG2z4VhpLNfqOa48igdvex3nAY6gHBFZSy1CdOD7smw8Z2pZQlh4dvq9Wxs7zvJ8zW7SKd8FG-0p57O0SeKxABmtNTEENh_HNVNaf1BT7toLkkEVRHBWDX1fPpGrgp1DREEeasfymPqUuy3DZF_7HMP3L0PmXAHLSuMaP891kwwiQo2nDucMs1zXu3RbTwwmqJrY9FhI3SQdsfjvOD9LXrLh_YPP1YUMU8P7i4m5cO1WIxr5wa3qKl9CL2zha4lCavlNIHt0d1pw3hLFNo6KL6yF201Vs8bUZwtzAjFAeHyRxTPINfegz42TpW-ycY6dVI_VrGr5UlUMCsjV93bwL-pbrwBBxXnIvpI-jCmIE16t4gqqAikPo0EITimnzB8Qxtpb_-Dbm28v0M3cvX_kwdY8OUQOV9WQZSvIh5MMccEoVHXex6Se_SUPEM-7o1dRGxqoiZho3TgzisMkZCJ6QoT8Z73NorRG-BNwMU-AVcYg3Nn1cg-lQw6avwWJnrAeWF5dZMc8mCqUOJPCf2cbOIHbjzoOTrzAgt5MVnuOQgm5LkR76_tiiA3KrJIYJR40uzihCf_47ln6ybdyxn1t4Y5RL4C5QOt0gAD9KnRodyqH7V9SCk3KuMTsNPlig15WxvtecyDOaxJodAV6YdszZyYVYFuKmuOEXuMwWxeIqv1xk-UWznGfX_Dq7ubq6StPFPF3M51c3N1m-ueaLK36ZVRdymaf5PM3yIr0psnmeLLK05CWfX2_E1aLaXLPLFFsuVaLUtk2MrS-C75dZfpneZBdhquHCWDnPNe6mCXHO5usLu6RNs01fO3aZKum8O4jx0itcPsU5xMTVFXLfW9yX32SazpoOrRqA5Q_wNI5Lp7kZtSb7WKFd50O-i96qZeN9F3IkdUUPtfRNv0lK6nQf6D7jn9noTpY_BC0cyx9GNbfL_D8BAAD__y2ueTU">