paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-16 12:59:24 +02:00
Code Issues Packages Projects Releases Wiki Activity

* clean up of assembler files not used anymore

Browse Source
This commit is contained in:
florian 2022-01-05 20:52:35 +01:00
parent e26b298885
commit 644263277f
6 changed files with 2 additions and 767 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rtl/linux/Makefile
View File

@ -367,7 +367,7 @@ endif
ifeq ($(ARCH),x86_64)
CPU_UNITS=x86 ports cpu
SYSINIT_UNITS=si_prc si_c si_g si_dll
override LOADERS+=abitag
override LOADERS=abitag
endif
ifeq ($(ARCH),powerpc64)
SYSINIT_UNITS=si_prc si_c si_g si_dll

2
rtl/linux/Makefile.fpc
View File

@ -79,7 +79,7 @@ endif
ifeq ($(ARCH),x86_64)
CPU_UNITS=x86 ports cpu
SYSINIT_UNITS=si_prc si_c si_g si_dll
override LOADERS+=abitag
override LOADERS=abitag
endif
ifeq ($(ARCH),powerpc64)

210
rtl/linux/x86_64/cprt0.as
View File

@ -1,210 +0,0 @@
/* This is the canonical entry point, usually the first thing in the text
segment. The SVR4/i386 ABI (pages 3-31, 3-32) says that when the entry
point runs, most registers' values are unspecified, except for:
%rdx Contains a function pointer to be registered with `atexit'.
This is how the dynamic linker arranges to have DT_FINI
functions called for shared libraries that have been loaded
before this code runs.
%rsp The stack contains the arguments and environment:
0(%rsp) argc
8(%rsp) argv[0]
...
(8*argc)(%rsp) NULL
(8*(argc+1))(%rsp) envp[0]
...
NULL
*/
.text
.globl _start
.type _start,@function
_start:
/* Clear the frame pointer. The ABI suggests this be done, to mark
the outermost frame obviously. */
xorq %rbp, %rbp
/* Extract the arguments as encoded on the stack and set up
the arguments for __libc_start_main (int (*main) (int, char **, char **),
int argc, char *argv,
void (*init) (void), void (*fini) (void),
void (*rtld_fini) (void), void *stack_end).
The arguments are passed via registers and on the stack:
main: %rdi
argc: %rsi
argv: %rdx
init: %rcx
fini: %r8
rtld_fini: %r9
stack_end: stack. */
movq %rdx, %r9 /* Address of the shared library termination
function. */
popq %rsi /* Pop the argument count. */
movq %rsp, %rdx /* argv starts just at the current stack top. */
movq entryinfo@GOTPCREL(%rip),%r10 /* load address of entryinfo variable */
movq %rsi,56(%r10)
movq %rsp,64(%r10) /* argv starts just at the current stack top */
leaq 8(,%rsi,8),%rax
addq %rsp,%rax
movq %rax,72(%r10)
/* Align the stack to a 16 byte boundary to follow the ABI. */
andq $~15, %rsp
pushq %rax /* Push garbage because we push 8 more bytes. */
/* Provide the highest stack address to the user code (for stacks
which grow downwards). */
pushq %rsp
/* Pass address of our own entry points to .fini and .init. */
movq __libc_csu_init@GOTPCREL(%rip), %rcx
movq __libc_csu_fini@GOTPCREL(%rip), %r8
movq main_stub@GOTPCREL(%rip), %rdi
/* Call the user's main function, and exit with its value.
But let the libc call main. */
call __libc_start_main@PLT
hlt /* Crash if somehow `exit' does return. */
/* fake main routine which will be run from libc */
.globl main_stub
.type main_stub,@function
main_stub:
/* save return address */
popq %rax
// stack alignment
pushq %rax
movq ___fpc_ret_rbp@GOTPCREL(%rip),%rcx
movq %rbp,(%rcx)
movq ___fpc_ret@GOTPCREL(%rip),%rcx
movq %rax,(%rcx)
pushq %rax
/* fill the remaining fields of the entry information */
movq entryinfo@GOTPCREL(%rip),%rdi /* load address of entryinfo variable into argument for SysEntry*/
/* Save initial stackpointer */
movq %rsp,80(%rdi)
/* store stack length */
movq __stklen@GOTPCREL(%rip),%rax
movq %rax,88(%rdi)
/* store pointer to _haltproc */
movq _haltproc@GOTPCREL(%rip),%rax
movq %rax,96(%rdi)
/* populate the table pointers */
movq INITFINAL@GOTPCREL(%rip),%rax
movq %rax,(%rdi)
movq FPC_THREADVARTABLES@GOTPCREL(%rip),%rax
movq %rax,8(%rdi)
movq FPC_RESOURCESTRINGTABLES@GOTPCREL(%rip),%rax
movq %rax,16(%rdi)
movq FPC_RESSTRINITTABLES@GOTPCREL(%rip),%rax
movq %rax,24(%rdi)
movq FPC_RESLOCATION@GOTPCREL(%rip),%rax
movq %rax,32(%rdi)
movq PASCALMAIN@GOTPCREL(%rip),%rax
movq %rax,40(%rdi)
/* valgrind_used can stay 0 */
/* start the program */
xorq %rbp,%rbp
call FPC_SysEntry@PLT
hlt
.size main_stub,.-main_stub
.globl _haltproc
.type _haltproc,@function
_haltproc:
movl %edi,%eax
/* return to libc */
movq ___fpc_ret_rbp@GOTPCREL(%rip),%rcx
movq (%rcx),%rbp
movq ___fpc_ret@GOTPCREL(%rip),%rcx
popq %rdx
movq (%rcx),%rdx
pushq %rdx
ret
.size _haltproc,.-_haltproc
/* Define a symbol for the first piece of initialized data. */
.data
.globl __data_start
__data_start:
.long 0
.weak data_start
data_start = __data_start
.globl ___fpc_brk_addr /* heap management */
.type ___fpc_brk_addr,@object
.size ___fpc_brk_addr,8
___fpc_brk_addr:
.quad 0
___fpc_ret: /* return address to libc */
.quad 0
___fpc_ret_rbp:
.quad 0
.bss
/* the entry information looks like this:
TEntryInformation = record
InitFinalTable : Pointer; // offset 0
ThreadvarTablesTable : Pointer; // offset 8
ResourceStringTables : Pointer; // offset 16
ResStrInitTables : Pointer; // offset 24
ResLocation : Pointer; // offset 32
PascalMain : Procedure; // offset 40
valgrind_used : boolean; // offset 48
OS : TEntryInformationOS; // offset 56
end;
with TEntryInformationOS being
TEntryInformationOS = record
argc: longint; // offset 56
argv: ppchar; // offset 64
envp: ppchar; // offset 72
stkptr: pointer; // offset 80
stklen: sizeuint; // offset 88
haltproc: procedure(e:longint);cdecl; // offset 96
end;
The size of TEntryInformationOS including padding is 5 * sizeof(Pointer) = 40
The size of TEntryInformation including padding without OS is 8 * sizeof(Pointer) = 64
Thus the total size of TEntryInformation including padding is 104
*/
.comm entryinfo,104
/* We need this stuff to make gdb behave itself, otherwise
gdb will chokes with SIGILL when trying to debug apps.
*/
.section ".note.ABI-tag", "a"
.align 4
.long 1f - 0f
.long 3f - 2f
.long 1
0: .asciz "GNU"
1: .align 4
2: .long 0
.long 2,4,0
3: .align 4
.section .note.GNU-stack,"",@progbits

157
rtl/linux/x86_64/dllprt0.as
View File

@ -1,157 +0,0 @@
#
# This file is part of the Free Pascal run time library.
# Copyright (c) 2006 by Florian Klaempfl
# members of the Free Pascal development team.
#
# See the file COPYING.FPC, included in this distribution,
# for details about the copyright.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY;without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
#**********************************************************************}
#
# Linux ELF startup code for Free Pascal
#
/* This is the canonical entry point, usually the first thing in the text
segment. The SVR4/i386 ABI (pages 3-31, 3-32) says that when the entry
point runs, most registers' values are unspecified, except for:
%rdx Contains a function pointer to be registered with `atexit'.
This is how the dynamic linker arranges to have DT_FINI
functions called for shared libraries that have been loaded
before this code runs.
%rsp The stack contains the arguments and environment:
0(%rsp) argc
8(%rsp) argv[0]
...
(8*argc)(%rsp) NULL
(8*(argc+1))(%rsp) envp[0]
...
NULL
*/
.section .init
.align 16
.globl FPC_SHARED_LIB_START
.type FPC_SHARED_LIB_START,@function
FPC_SHARED_LIB_START:
jmp _startlib@PLT
.text
.globl _startlib
.type _startlib,@function
_startlib:
movq entryinfo@GOTPCREL(%rip),%r10 /* load address of entryinfo variable */
movq %rdi,56(%r10)
movq %rsi,64(%r10) /* argv starts just at the current stack top */
movq %rdx,72(%r10)
/* Save initial stackpointer */
movq %rsp,80(%r10)
/* store stack length */
movq __stklen@GOTPCREL(%rip),%rax
movq %rax,88(%r10)
/* store pointer to _haltproc */
movq _haltproc@GOTPCREL(%rip),%rax
movq %rax,96(%r10)
/* populate the table pointers */
movq INITFINAL@GOTPCREL(%rip),%rax
movq %rax,(%r10)
movq FPC_THREADVARTABLES@GOTPCREL(%rip),%rax
movq %rax,8(%r10)
movq FPC_RESOURCESTRINGTABLES@GOTPCREL(%rip),%rax
movq %rax,16(%r10)
movq FPC_RESSTRINITTABLES@GOTPCREL(%rip),%rax
movq %rax,24(%r10)
movq FPC_RESLOCATION@GOTPCREL(%rip),%rax
movq %rax,32(%r10)
movq PASCALMAIN@GOTPCREL(%rip),%rax
movq %rax,40(%r10)
/* valgrind_used can stay 0 */
/* setup argument for FPC_SysEntry */
movq %r10,%rdi
movq operatingsystem_islibrary@GOTPCREL(%rip),%r10
movb $1,(%r10)
call FPC_SysEntry@PLT
ret
/* this routine is only called when the halt() routine of the RTL embedded in
the shared library is called */
.globl _haltproc
.type _haltproc,@function
_haltproc:
movl $231,%eax /* exit_group call */
movq operatingsystem_result@GOTPCREL(%rip),%rbx
movzwl (%rbx),%edi
syscall
jmp _haltproc@PLT
/* Define a symbol for the first piece of initialized data. */
.data
.globl __data_start
__data_start:
.long 0
.weak data_start
data_start = __data_start
.bss
/* the entry information looks like this:
TEntryInformation = record
InitFinalTable : Pointer; // offset 0
ThreadvarTablesTable : Pointer; // offset 8
ResourceStringTables : Pointer; // offset 16
ResStrInitTables : Pointer; // offset 24
ResLocation : Pointer; // offset 32
PascalMain : Procedure; // offset 40
valgrind_used : boolean; // offset 48
OS : TEntryInformationOS; // offset 56
end;
with TEntryInformationOS being
TEntryInformationOS = record
argc: longint; // offset 56
argv: ppchar; // offset 64
envp: ppchar; // offset 72
stkptr: pointer; // offset 80
stklen: sizeuint; // offset 88
haltproc: procedure(e:longint);cdecl; // offset 96
end;
The size of TEntryInformationOS including padding is 5 * sizeof(Pointer) = 40
The size of TEntryInformation including padding without OS is 8 * sizeof(Pointer) = 64
Thus the total size of TEntryInformation including padding is 104
*/
.comm entryinfo,104
/* We need this stuff to make gdb behave itself, otherwise
gdb will chokes with SIGILL when trying to debug apps.
Makes ld choke:
.section ".note.ABI-tag", "a"
.align 4
.long 1f - 0f
.long 3f - 2f
.long 1
0: .asciz "GNU"
1: .align 4
2: .long 0
.long 2,4,0
3: .align 4
*/
.section .note.GNU-stack,"",@progbits

230
rtl/linux/x86_64/gprt0.as
View File

@ -1,230 +0,0 @@
/* This is the canonical entry point, usually the first thing in the text
segment. The SVR4/i386 ABI (pages 3-31, 3-32) says that when the entry
point runs, most registers' values are unspecified, except for:
%rdx Contains a function pointer to be registered with `atexit'.
This is how the dynamic linker arranges to have DT_FINI
functions called for shared libraries that have been loaded
before this code runs.
%rsp The stack contains the arguments and environment:
0(%rsp) argc
8(%rsp) argv[0]
...
(8*argc)(%rsp) NULL
(8*(argc+1))(%rsp) envp[0]
...
NULL
*/
.text
.globl _start
.type _start,@function
_start:
/* Clear the frame pointer. The ABI suggests this be done, to mark
the outermost frame obviously. */
xorq %rbp, %rbp
/* Extract the arguments as encoded on the stack and set up
the arguments for __libc_start_main (int (*main) (int, char **, char **),
int argc, char *argv,
void (*init) (void), void (*fini) (void),
void (*rtld_fini) (void), void *stack_end).
The arguments are passed via registers and on the stack:
main: %rdi
argc: %rsi
argv: %rdx
init: %rcx
fini: %r8
rtld_fini: %r9
stack_end: stack. */
movq %rdx, %r9 /* Address of the shared library termination
function. */
popq %rsi /* Pop the argument count. */
movq %rsp, %rdx /* argv starts just at the current stack top. */
movq entryinfo@GOTPCREL(%rip),%r10 /* load address of entryinfo variable */
movq %rsi,56(%r10)
movq %rsp,64(%r10) /* argv starts just at the current stack top */
leaq 8(,%rsi,8),%rax
addq %rsp,%rax
movq %rax,72(%r10)
/* Align the stack to a 16 byte boundary to follow the ABI. */
andq $~15, %rsp
pushq %rax /* Push garbage because we push 8 more bytes. */
/* Provide the highest stack address to the user code (for stacks
which grow downwards). */
pushq %rsp
/* Pass address of our own entry points to .fini and .init. */
movq _init_dummy@GOTPCREL(%rip), %r8
movq _fini_dummy@GOTPCREL(%rip), %rcx
movq main_stub@GOTPCREL(%rip), %rdi
/* Call the user's main function, and exit with its value.
But let the libc call main. */
call __libc_start_main@PLT
hlt /* Crash if somehow `exit' does return. */
/* fake main routine which will be run from libc */
.globl main_stub
.type main_stub,@function
main_stub:
/* save return address */
popq %rax
// stack alignment
pushq %rax
movq ___fpc_ret_rbp@GOTPCREL(%rip),%rcx
movq %rbp,(%rcx)
movq ___fpc_ret@GOTPCREL(%rip),%rcx
movq %rax,(%rcx)
pushq %rax
/* Initialize gmon */
movq _etext@GOTPCREL(%rip),%rsi
movq _start@GOTPCREL(%rip),%rdi
call monstartup@PLT
movq _mcleanup@GOTPCREL(%rip),%rdi
call atexit@PLT
/* fill the remaining fields of the entry information */
movq entryinfo@GOTPCREL(%rip),%rdi /* load address of entryinfo variable into argument for SysEntry*/
/* Save initial stackpointer */
movq %rsp,80(%rdi)
/* store stack length */
movq __stklen@GOTPCREL(%rip),%rax
movq %rax,88(%rdi)
/* store pointer to _haltproc */
movq _haltproc@GOTPCREL(%rip),%rax
movq %rax,96(%rdi)
/* populate the table pointers */
movq INITFINAL@GOTPCREL(%rip),%rax
movq %rax,(%rdi)
movq FPC_THREADVARTABLES@GOTPCREL(%rip),%rax
movq %rax,8(%rdi)
movq FPC_RESOURCESTRINGTABLES@GOTPCREL(%rip),%rax
movq %rax,16(%rdi)
movq FPC_RESSTRINITTABLES@GOTPCREL(%rip),%rax
movq %rax,24(%rdi)
movq FPC_RESLOCATION@GOTPCREL(%rip),%rax
movq %rax,32(%rdi)
movq PASCALMAIN@GOTPCREL(%rip),%rax
movq %rax,40(%rdi)
/* valgrind_used can stay 0 */
/* start the program */
xorq %rbp,%rbp
call FPC_SysEntry@PLT
hlt
.size main_stub,.-main_stub
.globl _haltproc
.type _haltproc,@function
_haltproc:
movq operatingsystem_result@GOTPCREL(%rip),%rax
movzwl (%rax),%eax
/* return to libc */
movq ___fpc_ret_rbp@GOTPCREL(%rip),%rcx
movq (%rcx),%rbp
movq ___fpc_ret@GOTPCREL(%rip),%rcx
popq %rdx
movq (%rcx),%rdx
pushq %rdx
ret
.size _haltproc,.-_haltproc
.globl _init_dummy
.type _init_dummy, @function
_init_dummy:
ret
.size _init_dummy,.-_init_dummy
.globl _fini_dummy
.type _fini_dummy, @function
_fini_dummy:
ret
.size _fini_dummy,.-_fini_dummy
/* Define a symbol for the first piece of initialized data. */
.data
.globl __data_start
__data_start:
.long 0
.weak data_start
data_start = __data_start
.globl ___fpc_brk_addr /* heap management */
.type ___fpc_brk_addr,@object
.size ___fpc_brk_addr,8
___fpc_brk_addr:
.quad 0
___fpc_ret: /* return address to libc */
.quad 0
___fpc_ret_rbp:
.quad 0
.bss
/* the entry information looks like this:
TEntryInformation = record
InitFinalTable : Pointer; // offset 0
ThreadvarTablesTable : Pointer; // offset 8
ResourceStringTables : Pointer; // offset 16
ResStrInitTables : Pointer; // offset 24
ResLocation : Pointer; // offset 32
PascalMain : Procedure; // offset 40
valgrind_used : boolean; // offset 48
OS : TEntryInformationOS; // offset 56
end;
with TEntryInformationOS being
TEntryInformationOS = record
argc: longint; // offset 56
argv: ppchar; // offset 64
envp: ppchar; // offset 72
stkptr: pointer; // offset 80
stklen: sizeuint; // offset 88
haltproc: procedure(e:longint);cdecl; // offset 96
end;
The size of TEntryInformationOS including padding is 5 * sizeof(Pointer) = 40
The size of TEntryInformation including padding without OS is 8 * sizeof(Pointer) = 64
Thus the total size of TEntryInformation including padding is 104
*/
.comm entryinfo,104
/* We need this stuff to make gdb behave itself, otherwise
gdb will chokes with SIGILL when trying to debug apps.
*/
.section ".note.ABI-tag", "a"
.align 4
.long 1f - 0f
.long 3f - 2f
.long 1
0: .asciz "GNU"
1: .align 4
2: .long 0
.long 2,4,0
3: .align 4
.section .note.GNU-stack,"",@progbits

168
rtl/linux/x86_64/prt0.as
View File

@ -1,168 +0,0 @@
#
# This file is part of the Free Pascal run time library.
# Copyright (c) 2002 by Florian Klaempfl
# members of the Free Pascal development team.
#
# See the file COPYING.FPC, included in this distribution,
# for details about the copyright.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY;without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
#**********************************************************************}
#
# Linux ELF startup code for Free Pascal
#
/* This is the canonical entry point, usually the first thing in the text
segment. The document "System V Application Binary Interface AMD64
Architecture Processor Supplement Version 0.99.5" pg. 30 defines that
the entry point runs, most registers' values are unspecified, except
for:
%rdx Contains a function pointer to be registered with `atexit'.
This is how the dynamic linker arranges to have DT_FINI
functions called for shared libraries that have been loaded
before this code runs.
%rsp The stack contains the arguments and environment:
0(%rsp) argc
8(%rsp) argv[0]
...
(8*argc)(%rsp) NULL
(8*(argc+1))(%rsp) envp[0]
...
NULL
*/
.text
.globl _dynamic_start
.type _dynamic_start,@function
_dynamic_start:
movq __dl_fini@GOTPCREL(%rip),%rax
movq %rdx,(%rax)
jmp _start
.text
.globl _start
.type _start,@function
_start:
movq entryinfo@GOTPCREL(%rip),%rdi /* load address of entryinfo variable into argument for SysEntry */
popq %rsi /* Pop the argument count. */
movq %rsi,56(%rdi)
movq %rsp,64(%rdi) /* argv starts just at the current stack top */
leaq 8(,%rsi,8),%rax
addq %rsp,%rax
movq %rax,72(%rdi)
andq $~15,%rsp /* Align the stack to a 16 byte boundary to follow the ABI */
/* Save initial stackpointer */
movq %rsp,80(%rdi)
/* store stack length */
movq __stklen@GOTPCREL(%rip),%rax
movq %rax,88(%rdi)
/* store pointer to _haltproc */
movq _haltproc@GOTPCREL(%rip),%rax
movq %rax,96(%rdi)
/* populate the table pointers */
movq INITFINAL@GOTPCREL(%rip),%rax
movq %rax,(%rdi)
movq FPC_THREADVARTABLES@GOTPCREL(%rip),%rax
movq %rax,8(%rdi)
movq FPC_RESOURCESTRINGTABLES@GOTPCREL(%rip),%rax
movq %rax,16(%rdi)
movq FPC_RESSTRINITTABLES@GOTPCREL(%rip),%rax
movq %rax,24(%rdi)
movq FPC_RESLOCATION@GOTPCREL(%rip),%rax
movq %rax,32(%rdi)
movq PASCALMAIN@GOTPCREL(%rip),%rax
movq %rax,40(%rdi)
/* valgrind_used can stay 0 */
xorq %rbp, %rbp
call FPC_SysEntry@PLT
jmp _haltproc
.globl _haltproc
.type _haltproc,@function
_haltproc:
movq __dl_fini@GOTPCREL(%rip),%rax
movq (%rax),%rax
testq %rax,%rax
jz .LNoDlFiniCall
call *%rax
.LNoDlFiniCall:
movq operatingsystem_result@GOTPCREL(%rip),%rax
movzwl (%rax),%edi
movl $231,%eax /* exit_group call */
syscall
jmp _haltproc
/* Define a symbol for the first piece of initialized data. */
.data
.globl __data_start
__data_start:
.long 0
.weak data_start
data_start = __data_start
.bss
.comm __dl_fini,8
/* the entry information looks like this:
TEntryInformation = record
InitFinalTable : Pointer; // offset 0
ThreadvarTablesTable : Pointer; // offset 8
ResourceStringTables : Pointer; // offset 16
ResStrInitTables : Pointer; // offset 24
ResLocation : Pointer; // offset 32
PascalMain : Procedure; // offset 40
valgrind_used : boolean; // offset 48
OS : TEntryInformationOS; // offset 56
end;
with TEntryInformationOS being
TEntryInformationOS = record
argc: longint; // offset 56
argv: ppchar; // offset 64
envp: ppchar; // offset 72
stkptr: pointer; // offset 80
stklen: sizeuint; // offset 88
haltproc: procedure(e:longint);cdecl; // offset 96
end;
The size of TEntryInformationOS including padding is 5 * sizeof(Pointer) = 40
The size of TEntryInformation including padding without OS is 8 * sizeof(Pointer) = 64
Thus the total size of TEntryInformation including padding is 104
*/
.comm entryinfo,104
/* We need this stuff to make gdb behave itself, otherwise
gdb will chokes with SIGILL when trying to debug apps.
*/
.section ".note.ABI-tag", "a"
.align 4
.long 1f - 0f
.long 3f - 2f
.long 1
0: .asciz "GNU"
1: .align 4
2: .long 0
.long 2,4,0
3: .align 4
.section .note.GNU-stack,"",@progbits