Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[lld][LoongArch] Support the R_LARCH_{ADD,SUB}_ULEB128 relocation types #81133

Merged
merged 6 commits into from
Mar 5, 2024
Merged

[lld][LoongArch] Support the R_LARCH_{ADD,SUB}_ULEB128 relocation types #81133

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
03866c8
[lld][LoongArch] Support the R_LARCH_{ADD,SUB}_ULEB128 relocation types
MQ-mengqing Feb 8, 2024
f53db4f
Address @SixWeining's comments
MQ-mengqing Feb 19, 2024
d389797
Remove useless `--noinhibit-exec`
MQ-mengqing Feb 20, 2024
7687cc3
Remove err parameter in decodeULEB128 and use 1ULL when shift
MQ-mengqing Feb 22, 2024
c860d46
Address @MaskRay's comments
MQ-mengqing Feb 29, 2024
7793126
Add elf32 test and use 64bits uleb128 value
MQ-mengqing Mar 1, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 26 additions & 0 deletions lld/ELF/Arch/LoongArch.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,7 @@
#include "Symbols.h"
#include "SyntheticSections.h"
#include "Target.h"
#include "llvm/Support/LEB128.h"

using namespace llvm;
using namespace llvm::object;
Expand Down Expand Up @@ -153,6 +154,23 @@ static bool isJirl(uint32_t insn) {
return (insn & 0xfc000000) == JIRL;
}

static void handleUleb128(uint8_t *loc, uint64_t val) {
const char *err = nullptr;
const uint32_t maxcount = 1 + (config->is64 ? 64 : 32) / 7;
uint32_t count;
uint64_t orig = decodeULEB128(loc, &count, nullptr, &err);
if (err)
fatal(getErrorLocation(loc) + "could not decode uleb128 value: " + err);
SixWeining marked this conversation as resolved.
Show resolved Hide resolved
if (count > maxcount)
errorOrWarn(getErrorLocation(loc) + "extra space for uleb128");
MaskRay marked this conversation as resolved.
Show resolved Hide resolved
uint64_t mask = config->is64 ? -1 : -1u;
Copy link
Member

@MaskRay MaskRay Feb 29, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

UINT64_MAX can be used for 32-bit as well.

Perhaps count < maxcount ? (UINT64_C(1) << 7 * count) -1 : UINT64_MAX

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

If config->is64 == false, we expect mask is 0x0000'0000'ffff'ffff so that the results will not be broken by the high-32-bits. (In 32-bits ELF file the addr size is 32bits, so the content should not be overflowed.)

Copy link
Member

@MaskRay MaskRay Feb 29, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Are the relocations defined to be 32-bit on ELF32? It looks strange.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

And there is no test checking the 32-bit behavior

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I can add the same test as a.o for 32-bit.

uleb128(-1u) == 0x0f'ff'ff'ff'ff. Assuming it reserved 5 bytes space and we executing SUB -1 on 32-bit first, then without this mask we might get 0x7f'ff'ff'ff'ff, which [35:33] is 1. These relocations is relocated address, and address should be limited in 32-bit on ELF32. So we need this mask to avoid breaking the high-space.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I've checked x86, mips and riscv ELF32 by GUN AS, they all handle uleb128 as 64bits value. So it's my misunderstanding. I'll correct it.

if (count < maxcount)
mask = (1 << 7 * count) - 1;

val = (orig + val) & mask;
SixWeining marked this conversation as resolved.
Show resolved Hide resolved
encodeULEB128(val, loc, count);
MaskRay marked this conversation as resolved.
Show resolved Hide resolved
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

encodeULEB128((orig + val) & mask, loc, count); to avoid changing val

}

LoongArch::LoongArch() {
// The LoongArch ISA itself does not have a limit on page sizes. According to
// the ISA manual, the PS (page size) field in MTLB entries and CSR.STLBPS is
Expand Down Expand Up @@ -394,11 +412,13 @@ RelExpr LoongArch::getRelExpr(const RelType type, const Symbol &s,
case R_LARCH_ADD16:
case R_LARCH_ADD32:
case R_LARCH_ADD64:
case R_LARCH_ADD_ULEB128:
case R_LARCH_SUB6:
case R_LARCH_SUB8:
case R_LARCH_SUB16:
case R_LARCH_SUB32:
case R_LARCH_SUB64:
case R_LARCH_SUB_ULEB128:
// The LoongArch add/sub relocs behave like the RISCV counterparts; reuse
// the RelExpr to avoid code duplication.
return R_RISCV_ADD;
Expand Down Expand Up @@ -633,6 +653,9 @@ void LoongArch::relocate(uint8_t *loc, const Relocation &rel,
case R_LARCH_ADD64:
write64le(loc, read64le(loc) + val);
return;
case R_LARCH_ADD_ULEB128:
handleUleb128(loc, val);
return;
case R_LARCH_SUB6:
*loc = (*loc & 0xc0) | ((*loc - val) & 0x3f);
return;
Expand All @@ -648,6 +671,9 @@ void LoongArch::relocate(uint8_t *loc, const Relocation &rel,
case R_LARCH_SUB64:
write64le(loc, read64le(loc) - val);
return;
case R_LARCH_SUB_ULEB128:
handleUleb128(loc, -val);
return;

case R_LARCH_MARK_LA:
case R_LARCH_MARK_PCREL:
Expand Down
100 changes: 100 additions & 0 deletions lld/test/ELF/loongarch-reloc-leb128.s
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,100 @@
# REQUIRES: loongarch
# RUN: rm -rf %t && split-file %s %t && cd %t

# RUN: llvm-mc --filetype=obj --triple=loongarch64 --mattr=+relax a.s -o a.o
# RUN: llvm-readobj -r -x .gcc_except_table -x .debug_rnglists -x .debug_loclists a.o | FileCheck %s --check-prefix=REL
# RUN: ld.lld -shared --gc-sections --noinhibit-exec a.o -o a.so
SixWeining marked this conversation as resolved.
Show resolved Hide resolved
# RUN: llvm-readelf -x .gcc_except_table -x .debug_rnglists -x .debug_loclists a.so | FileCheck %s

# RUN: llvm-mc --filetype=obj --triple=loongarch32 --mattr=+relax extraspace.s -o extraspace32.o
# RUN: llvm-mc --filetype=obj --triple=loongarch64 --mattr=+relax extraspace.s -o extraspace64.o --defsym=size64=1
# RUN: not ld.lld -shared extraspace32.o 2>&1 | FileCheck %s --check-prefix=ERROR
# RUN: not ld.lld -shared extraspace64.o 2>&1 | FileCheck %s --check-prefix=ERROR
# ERROR: error: {{.*}}.o:(.rodata+0x0): extra space for uleb128
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

a.o since the filename is determined


#--- a.s
.cfi_startproc
.cfi_lsda 0x1b,.LLSDA0
.cfi_endproc

.section .text.w,"axR"
break 0; break 0; break 0; w1:
.p2align 4 # 4 bytes after relaxation
w2: break 0

.section .text.x,"ax"
break 0; break 0; break 0; x1:
.p2align 4 # 4 bytes after relaxation
x2: break 0

.section .gcc_except_table,"a"
.LLSDA0:
.uleb128 w2-w1+116 # initial value: 0x0080
.uleb128 w1-w2+141 # initial value: 0x0080
.uleb128 w2-w1+16372 # initial value: 0x008080
.uleb128 w1-w2+16397 # initial value: 0x008080
.uleb128 w2-w1+2097140 # initial value: 0x00808080
.uleb128 w1-w2+2097165 # initial value: 0x00808080

.section .debug_rnglists
.uleb128 w2-w1+116 # initial value: 0x0080
.uleb128 w1-w2+141 # initial value: 0x0080
.uleb128 w2-w1+16372 # initial value: 0x008080
.uleb128 w1-w2+16397 # initial value: 0x008080
.uleb128 w2-w1+2097140 # initial value: 0x00808080
.uleb128 w1-w2+2097165 # initial value: 0x00808080

.section .debug_loclists
.uleb128 x2-x1 # references discarded symbols

# REL: Section ({{.*}}) .rela.debug_rnglists {
# REL-NEXT: 0x0 R_LARCH_ADD_ULEB128 w2 0x74
# REL-NEXT: 0x0 R_LARCH_SUB_ULEB128 w1 0x0
# REL-NEXT: 0x2 R_LARCH_ADD_ULEB128 w1 0x8D
# REL-NEXT: 0x2 R_LARCH_SUB_ULEB128 w2 0x0
# REL-NEXT: 0x4 R_LARCH_ADD_ULEB128 w2 0x3FF4
# REL-NEXT: 0x4 R_LARCH_SUB_ULEB128 w1 0x0
# REL-NEXT: 0x7 R_LARCH_ADD_ULEB128 w1 0x400D
# REL-NEXT: 0x7 R_LARCH_SUB_ULEB128 w2 0x0
# REL-NEXT: 0xA R_LARCH_ADD_ULEB128 w2 0x1FFFF4
# REL-NEXT: 0xA R_LARCH_SUB_ULEB128 w1 0x0
# REL-NEXT: 0xE R_LARCH_ADD_ULEB128 w1 0x20000D
# REL-NEXT: 0xE R_LARCH_SUB_ULEB128 w2 0x0
# REL-NEXT: }
# REL: Section ({{.*}}) .rela.debug_loclists {
# REL-NEXT: 0x0 R_LARCH_ADD_ULEB128 x2 0x0
# REL-NEXT: 0x0 R_LARCH_SUB_ULEB128 x1 0x0
# REL-NEXT: }

# REL: Hex dump of section '.gcc_except_table':
# REL-NEXT: 0x00000000 80008000 80800080 80008080 80008080 .
# REL-NEXT: 0x00000010 8000 .
# REL: Hex dump of section '.debug_rnglists':
# REL-NEXT: 0x00000000 80008000 80800080 80008080 80008080 .
# REL-NEXT: 0x00000010 8000 .
# REL: Hex dump of section '.debug_loclists':
# REL-NEXT: 0x00000000 00 .

# CHECK: Hex dump of section '.gcc_except_table':
# CHECK-NEXT: 0x[[#%x,]] f8008901 f8ff0089 8001f8ff ff008980 .
# CHECK-NEXT: 0x[[#%x,]] 8001 .
# CHECK: Hex dump of section '.debug_rnglists':
# CHECK-NEXT: 0x00000000 f8008901 f8ff0089 8001f8ff ff008980 .
# CHECK-NEXT: 0x00000010 8001 .
# CHECK: Hex dump of section '.debug_loclists':
# CHECK-NEXT: 0x00000000 00 .

#--- extraspace.s
.text
w1:
la.pcrel $t0, w1
w2:

.rodata
.reloc ., R_LARCH_ADD_ULEB128, w2
.reloc ., R_LARCH_SUB_ULEB128, w1
.fill 5, 1, 0x80
.ifdef size64
.fill 5, 1, 0x80
.endif
.byte 0
Loading