rela | Reinforcement Learning Assembly | Reinforcement Learning library

I managed to resolve the issue. Unknown rela relocation: 4 is an insmod error you get due to a change in the way the kernel handles PLT, more specifically the R_X86_64_PC32 and R_X86_64_PLT32. With binutils >= 2.31, the linker has decided to use R_X86_64_PLT32 relocations, which aren't supported in the older kernel.

To fix this:

1. I downloaded an older version of binutils (2.26.1) from https://ftp.gnu.org/gnu/binutils/
2. extracted the folder from the archive
3. compiled the binutils to /usr/local/binutils-2.6 by running

I think your arithmetic has gone wrong.

The first LOAD segment is loaded at address 0x400000 and has size 0x1d14, so it indeed includes the 10 bytes starting at 0x401bc0, at offset 0x401bc0 - 0x400000 = 0x1bc0 into this segment. The segment starts at offset 0 in the file, so you need to look at offset 0x1bc0 in the file, not offset 0xbc0. And 0x1bc0 is decimal 7104.

(And 0xbc0 in decimal is 3008, not 4660. A good fact to memorize for mental arithmetic is that 0x1000 = 4096 is one page. So 0x1bc0 must be between 4096 and 8192, and likewise 0xbc0 must be less than 4096. That's how I could tell at a glance that something was wrong with your math.)

Eureka! I found a solution although it's not an ideal one. As mentioned in the question, I noticed that libvdo_slam.so was not listed as a shared library when running $ readelf . So I manually added -lvdo_slam in the CMakeList.txt so it looks like:

On "mainstream" CPUs like Skylake-X and IceLake, it's only worth using 512-bit vectors at all if you use them consistently for a lot of your program's run-time, not just for an occasional memcpy. See SIMD instructions lowering CPU frequency for the details: you don't want occasional calls to memcpy to hold your CPU frequency down to a lower max turbo.

Using AVX-512 features with 256-bit vectors (AVX-512VL) can be worth it for some things, e.g. if masking is nice, or if you use YMM16..31 to avoid VZEROUPPER.

I'd guess that glibc would only resolve memcpy to __memcpy_avx512_no_vzeroupper on systems like Knight's Landing (KNL) Xeon Phi, where the CPU is designed around AVX-512, and there's no downside to using 512-bit ZMM vectors. There's no need for vzeroupper even after using ymm0..15 on KNL. In fact vzeroupper is very slow on KNL, and definitely something to avoid, hence putting no_vzeroupper in the function name.

https://code.woboq.org/userspace/glibc/sysdeps/x86_64/multiarch/memmove-avx512-no-vzeroupper.S.html is the source for that version. It uses ZMM vectors, including ZMM0..15, so if used on a Skylake/IceLake CPU it should use vzeroupper. This version looks designed for KNL.

There would be some tiny benefit to having an AVX-512VL version that used ymm16..31 to avoid vzeroupper (to speed 32 .. 64 byte copies), without ever using ZMM registers.

And it would make sense for __memcpy_avx512_no_vzeroupper to only use ZMM16..31 so avoiding vzeroupper isn't a problem on mainstream CPUs; then it would be a usable option in code that already made heavy use of AVX-512 (and thus was already paying the CPU-frequency cost.)

I just wrote and tested this code for you, I believe it can be better refactored but most important that it can achieve the same structure you wanted

You can sidestep the problem by compiling with -fno-plt so you don't have any PLT entries at all, and the associated lazy-binding machinery doesn't come into play.

GCC and clang will use call *printf@GOTPCREL(%rip) which forces early binding: resolving the GOT entries on process startup. This makes each call more efficient, and some distros (e.g. Arch GNU/Linux) are compiling their packages this way already.

TL:DR: This is generally a good option, it's just not on by default (yet) in current GCC and clang distro configs.

You're passing -s -w as flags to the linker.

According to the documentation of cmd/link:

-s: Omit the symbol table and debug information.

-w: Omit the DWARF symbol table.

In short, your build command removes the information your debugger requires for debugging.

If you remove -ldflags (or only -s -w), it should work as expected.

but none worked...

The add-symbol-file ... solution should work. I suspect you are not supplying correct .text address.

cat /proc/30622/maps | grep "r-xp" | grep "/root/test/test"

This assumes that the very first segment of /root/test/test has RX permissions.

That used to be the case, but no longer is on modern systems (see e.g. this answer).

You didn't provide output from readelf -Wl /root/test/test, but I bet it looks similar to the 4-segment example from the other answer (with the first LOAD segment having Read only permissions.

Generally you need to find the address of the first LOAD segment of the test executable in memory, and add the address of .text to that base address.

Update:

With the newly-supplied output from /proc/$pid/maps and readelf, we can see that my guess was correct: this binary has 4 LOAD segments, and the first one doesn't have r-x permissions.

The calculation then is: $address_of_the_first_PT_LOAD + $address_of_.text. That is (for the 16873 process):

Since the post is not likely to get an answer (if there is one), I'm gonna post my workaround as a solution in case someone is having the same problem.

I created a form similar to the one in Fast Reports, I export the FR file to PDF, this one works fine.