format PE64 GUI DLL
.....
section '.code' code readable executable
.....
mov rdi,qword [@Params+rbx*8]
.....
section '.bss' data writeable
@Params         dq ?
.....
section '.reloc' fixups data discardable
    

Is the fixups really needed? Obviously are needed on 32-bit but on 64-bit I think that [@Params+rbx*8] is RIP-relative and for that reason it doesn't need relocation at all.

; fasm demonstration of writing 64-bit ELF executable
; (thanks to František Gábriš)

; syscall numbers: /usr/src/linux/include/asm-x86_64/unistd.h
; parameters order:
; r9    ; 6th param
; r8    ; 5th param
; r10   ; 4th param
; rdx   ; 3rd param
; rsi   ; 2nd param
; rdi   ; 1st param
; eax   ; syscall_number
; syscall

; format ELF64 executable
format ELF64 executable at $100000000

segment readable executable

entry $

        mov     edx,msg_size    ; CPU zero extends 32-bit operation to 64-bit
                                ; we can use less bytes than in case mov rdx,...
        xor     rbx,rbx
        lea     rsi,[rbx+msg]
        mov     edi,1           ; STDOUT
        mov     eax,1           ; sys_write
        syscall

        xor     edi,edi         ; exit code 0
        mov     eax,60          ; sys_exit
        syscall

segment readable writeable

msg db 'Hello 64-bit world!',0xA
msg_size = $-msg    

I think that the bug is assembling fine that instruction just because @Params can be coded as a sdword when 64 bit relocations are not present or "(@Params shr 32) = 0".

As for the 32-bit relocations with 64-bit code - it applies to object output, but not to the relocatable PE (in case when you include the fixups directory). It is possible to generate such relocation for the PE case, however such executable needs to be marked somehow that it can be run only in low 2 GB. As I wouldn't like to make programmer unaware of that he's forced his executable to be such because of some instruction like the one discusssed in this thread, there would have to be some explicit setting to make relocatable-in-low-2GB PE file. But as this seems to be not urgent thing, I will leave it as it is for now.

format PE64 GUI 5.0 at $7fff0000
include 'win64a.inc'

        xor     rbx, rbx
        lea     rbx,[rbx+_message]

        invoke  MessageBox, 0, _caption, rbx, 0
        invoke  ExitProcess, 0

  _caption db 'Win64 assembly program',0
;  rb      $1000 ; Works with this one
  rb      $10000 ; Crashes the program
  _message db 'Hello World!',0

data import
  library kernel32,'KERNEL32.DLL',\
          user32,'USER32.DLL'

  include 'api\kernel32.inc'
  include 'api\user32.inc'
end data    

Oh, pardon I thought that this problem was messing the relocations in some way.

Whether and there is any way that commands like "mov rax,qword [Var+Reg64]" could be used? For example, to analyze, what in a command there is a reference to a variable which is being a segment of data, and to adjust reloc-section (if relocs used)? The structure of relocs allows to make it.