; fasm test.asm
; ld test.o -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc
; ./a.out

format ELF64
extrn fputs
extrn stdout

section '.text' writeable executable
public _start
_start:
    mov rdi, message
    mov rsi, qword [stdout]
    call fputs
    mov     rax, 60
    xor     rdi, rdi
    syscall

section '.data'
message db 'test', 10, 0
    

; fasm test.asm && ld -shared test.o -o libtest.so

format ELF64
extrn fputs
extrn stdout

section '.text' writeable executable
public f
f:
    mov    rax, something something stdout, TODO
    lea    rdi, [message]
    mov    rsi, qword [rax]
    jmp    PLT fputs

section '.data'
message db "test", 10, 0
    

; nasm -felf64 name.asm && ld -shared name.o -o name.so

extern stdout, fputs

section .text
global f
f:
    mov    rax, qword [rel stdout wrt ..gotpc]
    lea    rdi, [rel message]
    mov    rsi, qword [rax]
    jmp    fputs wrt ..plt

section .data
message db "test", 10, 0
    

# as name.s -o name.o && ld -shared name.o -o name.so

    .intel_syntax noprefix

    .section .text
    .global f
f:
    mov    rax, QWORD PTR stdout@GOTPCREL[rip]
    lea    rdi, message[rip]
    mov    rsi, QWORD PTR [rax]
    jmp    fputs@PLT

    .section .data
message:
    .string "test\n"
    .section .note.GNU-stack,"",@progbits
    

; Assemble with fasmg, with "format" and "cpu" headers sets either in the same directory or in the path provided by INCLUDE variable:
include 'format/format.inc'

format ELF64
extrn fputs
extrn stdout

; The "extrn" macro has defined symbols PLT.fputs and PLT.stdout,
; as variable terms with metadata of form PLT+index,
; where PLT is another special variable term and the constant terms is index into the symbol table.

; Let's define a similarly structured GOT.stdout:
element GOT
element GOT.stdout : 1 metadataof PLT.stdout - PLT + GOT ; replace PLT term with GOT in the metadata
; Of course we may also alter the "extrn" macro to always define such symbol

; Now override the "dword" instruction that is called by x86 encoders to generate displacement/immediate fields:
calminstruction dword? value
        check   1 elementof (1 metadataof (value + ELF.SECTION_BASE)) eq GOT
        jyes    r_gotpcrel
        ; If the argument does not contain our special symbol, just call the previous implementation of "dword":
        call    dword?, value
        exit
    r_gotpcrel:
        compute offset, $%
        emit    4
        check   $% > offset
        jno     done
        compute offset, offset - ELF.SECTION_OFFSET
        compute addend, value + ELF.SECTION_BASE + offset - 1 elementof value
        compute info, R_X86_64_GOTPCREL + (0 scaleof (1 metadataof value)) shl 32
    add_relocation:
        local   Rela
        compute Rela, ELF.RELOCATION_INDEX * sizeof Elf64_Rela
        asm     store offset at ELF.relocations : Rela + Elf64_Rela.r_offset
        asm     store addend at ELF.relocations : Rela + Elf64_Rela.r_addend
        asm     store info at ELF.relocations : Rela + Elf64_Rela.r_info
        compute ELF.RELOCATION_INDEX, ELF.RELOCATION_INDEX + 1
    done:
end calminstruction

section '.text' writeable executable

public f
f:
    mov    rax, [GOT.stdout]
    lea    rdi, [message]
    mov    rsi, qword [rax]
    jmp    PLT.fputs

section '.data'
message db "test", 10, 0    

iterate instruction, call,jmp
        calminstruction instruction? operand*
                match =PLT? operand, operand
                jyes legacy_PLT
                call instruction, operand
                exit
            legacy_PLT:
                arrange operand, =instruction =PLT.operand
                assemble operand
        end calminstruction
end iterate    

I may add this kind of GOT relocations into fasmg's distributed headers - please let me know if that would work for you.

the download page calls it "new" and I genuinely didn't realize it's almost 20 years since the initial release

Quote:

I may add this kind of GOT relocations into fasmg's distributed headers - please let me know if that would work for you.

That would be very nice.