AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-23 13:30:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
7550717ed7
glibc/sysdeps/tile/crti.S

125 lines
3.6 KiB
ArmAsm
Raw Normal View History

tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
/* Special .init and .fini section support for tile.
Update copyright dates with scripts/update-copyrights.
2017-01-01 00:14:16 +00:00
Copyright (C) 2012-2017 Free Software Foundation, Inc.
tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
In addition to the permissions in the GNU Lesser General Public
License, the Free Software Foundation gives you unlimited
permission to link the compiled version of this file with other
programs, and to distribute those programs without any restriction
coming from the use of this file. (The GNU Lesser General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into another program.)
Note that people who make modified versions of this file are not
obligated to grant this special exception for their modified
versions; it is their choice whether to do so. The GNU Lesser
General Public License gives permission to release a modified
version without this exception; this exception also makes it
possible to release a modified version which carries forward this
exception.
The GNU C Library 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. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
/* crti.S puts a function prologue at the beginning of the .init and
.fini sections and defines global symbols for those addresses, so
they can be called as functions. The symbols _init and _fini are
magic and cause the linker to emit DT_INIT and DT_FINI. */
#include <libc-symbols.h>
#include <sysdep.h>
#ifndef PREINIT_FUNCTION
# define PREINIT_FUNCTION __gmon_start__
#endif
#ifndef PREINIT_FUNCTION_WEAK
# define PREINIT_FUNCTION_WEAK 1
#endif
#if PREINIT_FUNCTION_WEAK
weak_extern (PREINIT_FUNCTION)
#else
.hidden PREINIT_FUNCTION
#endif
.section .init,"ax",@progbits
.align 8
.globl _init
.type _init, @function
_init:
{
move r29, sp
ADDI_PTR r28, sp, -REGSIZE
ST sp, lr
}
ADDI_PTR sp, sp, -(2 * REGSIZE)
ST r28, r29
#if PREINIT_FUNCTION_WEAK
lnk r2
0:
tile: support very large shared objects With gcc 4.8 tilegx has support for -mcmodel=large, to tolerate very large shared objects. This option changes the compiler output to not include direct jump instructions, which have a range of only 2^30, i.e +/- 512MB. Instead the compiler marshalls the target PCs into registers and then uses jump- or call-to-register instructions. For glibc, the upshot is that we need to arrange for a few functions to tolerate the possibility of a large range between the PC and the target. In particular, the crti.S and start.S code needs to be able to reach from .init to the PLT, as does gmon-start.c. The elf-init.c code has the reverse problem, needing to call from libc_nonshared.a (linked at the end of shared objects) back to the _init section at the beginning. No other functions in *_nonshared.a need to be built this way, as they only call the PLT (or potentially each other), but all of that code is linked at the very end of the shared object. We don't build the standard -static archives with this option as the performance cost is high enough and the use case is rare enough that it doesn't seem worthwhile. Instead, we would encourage developers who need the -static model with huge executables to build a private copy of glibc and configure it with -mcmodel=large. Note that libc.so et al don't need any changes; the only changes are for code that is statically linked into user code built with -mcmodel=large. For the assembly code, I just rewrote it so that it unconditionally uses the large model. To be able to pass -mcmodel=large to csu/elf-init.c and csu/gmon-start.c, I need to check to see if the compiler supports that flag, since gcc 4.7 doesn't; I added the support by creating a small Makefile fragment that just runs the compiler to check.
2012-11-05 15:43:40 +00:00
# ifdef __tilegx__
moveli r1, hw2_last(_GLOBAL_OFFSET_TABLE_ - 0b)
tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
{
tile: support very large shared objects With gcc 4.8 tilegx has support for -mcmodel=large, to tolerate very large shared objects. This option changes the compiler output to not include direct jump instructions, which have a range of only 2^30, i.e +/- 512MB. Instead the compiler marshalls the target PCs into registers and then uses jump- or call-to-register instructions. For glibc, the upshot is that we need to arrange for a few functions to tolerate the possibility of a large range between the PC and the target. In particular, the crti.S and start.S code needs to be able to reach from .init to the PLT, as does gmon-start.c. The elf-init.c code has the reverse problem, needing to call from libc_nonshared.a (linked at the end of shared objects) back to the _init section at the beginning. No other functions in *_nonshared.a need to be built this way, as they only call the PLT (or potentially each other), but all of that code is linked at the very end of the shared object. We don't build the standard -static archives with this option as the performance cost is high enough and the use case is rare enough that it doesn't seem worthwhile. Instead, we would encourage developers who need the -static model with huge executables to build a private copy of glibc and configure it with -mcmodel=large. Note that libc.so et al don't need any changes; the only changes are for code that is statically linked into user code built with -mcmodel=large. For the assembly code, I just rewrote it so that it unconditionally uses the large model. To be able to pass -mcmodel=large to csu/elf-init.c and csu/gmon-start.c, I need to check to see if the compiler supports that flag, since gcc 4.7 doesn't; I added the support by creating a small Makefile fragment that just runs the compiler to check.
2012-11-05 15:43:40 +00:00
shl16insli r1, r1, hw1(_GLOBAL_OFFSET_TABLE_ - 0b)
tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
moveli r0, hw1_last_got(PREINIT_FUNCTION)
}
{
shl16insli r1, r1, hw0(_GLOBAL_OFFSET_TABLE_ - 0b)
shl16insli r0, r0, hw0_got(PREINIT_FUNCTION)
}
tile: support very large shared objects With gcc 4.8 tilegx has support for -mcmodel=large, to tolerate very large shared objects. This option changes the compiler output to not include direct jump instructions, which have a range of only 2^30, i.e +/- 512MB. Instead the compiler marshalls the target PCs into registers and then uses jump- or call-to-register instructions. For glibc, the upshot is that we need to arrange for a few functions to tolerate the possibility of a large range between the PC and the target. In particular, the crti.S and start.S code needs to be able to reach from .init to the PLT, as does gmon-start.c. The elf-init.c code has the reverse problem, needing to call from libc_nonshared.a (linked at the end of shared objects) back to the _init section at the beginning. No other functions in *_nonshared.a need to be built this way, as they only call the PLT (or potentially each other), but all of that code is linked at the very end of the shared object. We don't build the standard -static archives with this option as the performance cost is high enough and the use case is rare enough that it doesn't seem worthwhile. Instead, we would encourage developers who need the -static model with huge executables to build a private copy of glibc and configure it with -mcmodel=large. Note that libc.so et al don't need any changes; the only changes are for code that is statically linked into user code built with -mcmodel=large. For the assembly code, I just rewrote it so that it unconditionally uses the large model. To be able to pass -mcmodel=large to csu/elf-init.c and csu/gmon-start.c, I need to check to see if the compiler supports that flag, since gcc 4.7 doesn't; I added the support by creating a small Makefile fragment that just runs the compiler to check.
2012-11-05 15:43:40 +00:00
# else
tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
{
moveli r1, lo16(_GLOBAL_OFFSET_TABLE_ - 0b)
moveli r0, got_lo16(PREINIT_FUNCTION)
}
{
auli r1, r1, ha16(_GLOBAL_OFFSET_TABLE_ - 0b)
auli r0, r0, got_ha16(PREINIT_FUNCTION)
}
tile: support very large shared objects With gcc 4.8 tilegx has support for -mcmodel=large, to tolerate very large shared objects. This option changes the compiler output to not include direct jump instructions, which have a range of only 2^30, i.e +/- 512MB. Instead the compiler marshalls the target PCs into registers and then uses jump- or call-to-register instructions. For glibc, the upshot is that we need to arrange for a few functions to tolerate the possibility of a large range between the PC and the target. In particular, the crti.S and start.S code needs to be able to reach from .init to the PLT, as does gmon-start.c. The elf-init.c code has the reverse problem, needing to call from libc_nonshared.a (linked at the end of shared objects) back to the _init section at the beginning. No other functions in *_nonshared.a need to be built this way, as they only call the PLT (or potentially each other), but all of that code is linked at the very end of the shared object. We don't build the standard -static archives with this option as the performance cost is high enough and the use case is rare enough that it doesn't seem worthwhile. Instead, we would encourage developers who need the -static model with huge executables to build a private copy of glibc and configure it with -mcmodel=large. Note that libc.so et al don't need any changes; the only changes are for code that is statically linked into user code built with -mcmodel=large. For the assembly code, I just rewrote it so that it unconditionally uses the large model. To be able to pass -mcmodel=large to csu/elf-init.c and csu/gmon-start.c, I need to check to see if the compiler supports that flag, since gcc 4.7 doesn't; I added the support by creating a small Makefile fragment that just runs the compiler to check.
2012-11-05 15:43:40 +00:00
# endif
tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
ADD_PTR r0, r0, r1
ADD_PTR r0, r0, r2
LD_PTR r0, r0
BEQZ r0, .Lno_weak_fn
tile: support very large shared objects With gcc 4.8 tilegx has support for -mcmodel=large, to tolerate very large shared objects. This option changes the compiler output to not include direct jump instructions, which have a range of only 2^30, i.e +/- 512MB. Instead the compiler marshalls the target PCs into registers and then uses jump- or call-to-register instructions. For glibc, the upshot is that we need to arrange for a few functions to tolerate the possibility of a large range between the PC and the target. In particular, the crti.S and start.S code needs to be able to reach from .init to the PLT, as does gmon-start.c. The elf-init.c code has the reverse problem, needing to call from libc_nonshared.a (linked at the end of shared objects) back to the _init section at the beginning. No other functions in *_nonshared.a need to be built this way, as they only call the PLT (or potentially each other), but all of that code is linked at the very end of the shared object. We don't build the standard -static archives with this option as the performance cost is high enough and the use case is rare enough that it doesn't seem worthwhile. Instead, we would encourage developers who need the -static model with huge executables to build a private copy of glibc and configure it with -mcmodel=large. Note that libc.so et al don't need any changes; the only changes are for code that is statically linked into user code built with -mcmodel=large. For the assembly code, I just rewrote it so that it unconditionally uses the large model. To be able to pass -mcmodel=large to csu/elf-init.c and csu/gmon-start.c, I need to check to see if the compiler supports that flag, since gcc 4.7 doesn't; I added the support by creating a small Makefile fragment that just runs the compiler to check.
2012-11-05 15:43:40 +00:00
jalr r0
tile: improve detection for missing -mcmodel=large support The existing test avoided passing -mcmodel=large if the compiler didn't support it. However, we need to test not just the compiler support, but also the toolchain (as and ld) support, so make the test more complete. In addition, we have to avoid using the hwN_plt() assembly operators if that support is missing, so guard the uses with #ifdef NO_PLT_PCREL. This allows us to properly build glibc with the current community binutils, which doesn't yet have the PC-relative PLT operator support. The -mcmodel=large support is in gcc 4.8, but the toolchain support won't be present in the community until binutils 2.24.
2013-05-24 18:02:31 +00:00
#elif defined(__tilegx__) && !defined(NO_PLT_PCREL)
tile: support very large shared objects With gcc 4.8 tilegx has support for -mcmodel=large, to tolerate very large shared objects. This option changes the compiler output to not include direct jump instructions, which have a range of only 2^30, i.e +/- 512MB. Instead the compiler marshalls the target PCs into registers and then uses jump- or call-to-register instructions. For glibc, the upshot is that we need to arrange for a few functions to tolerate the possibility of a large range between the PC and the target. In particular, the crti.S and start.S code needs to be able to reach from .init to the PLT, as does gmon-start.c. The elf-init.c code has the reverse problem, needing to call from libc_nonshared.a (linked at the end of shared objects) back to the _init section at the beginning. No other functions in *_nonshared.a need to be built this way, as they only call the PLT (or potentially each other), but all of that code is linked at the very end of the shared object. We don't build the standard -static archives with this option as the performance cost is high enough and the use case is rare enough that it doesn't seem worthwhile. Instead, we would encourage developers who need the -static model with huge executables to build a private copy of glibc and configure it with -mcmodel=large. Note that libc.so et al don't need any changes; the only changes are for code that is statically linked into user code built with -mcmodel=large. For the assembly code, I just rewrote it so that it unconditionally uses the large model. To be able to pass -mcmodel=large to csu/elf-init.c and csu/gmon-start.c, I need to check to see if the compiler supports that flag, since gcc 4.7 doesn't; I added the support by creating a small Makefile fragment that just runs the compiler to check.
2012-11-05 15:43:40 +00:00
/* Since we are calling from the start of the object to the PLT,
call by loading the full address into a register. */
lnk r2
0:
moveli r0, hw2_last_plt(PREINIT_FUNCTION - 0b)
shl16insli r0, r0, hw1_plt(PREINIT_FUNCTION - 0b)
shl16insli r0, r0, hw0_plt(PREINIT_FUNCTION - 0b)
add r0, r0, r2
jalr r0
#else
tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
jal plt(PREINIT_FUNCTION)
tile: support very large shared objects With gcc 4.8 tilegx has support for -mcmodel=large, to tolerate very large shared objects. This option changes the compiler output to not include direct jump instructions, which have a range of only 2^30, i.e +/- 512MB. Instead the compiler marshalls the target PCs into registers and then uses jump- or call-to-register instructions. For glibc, the upshot is that we need to arrange for a few functions to tolerate the possibility of a large range between the PC and the target. In particular, the crti.S and start.S code needs to be able to reach from .init to the PLT, as does gmon-start.c. The elf-init.c code has the reverse problem, needing to call from libc_nonshared.a (linked at the end of shared objects) back to the _init section at the beginning. No other functions in *_nonshared.a need to be built this way, as they only call the PLT (or potentially each other), but all of that code is linked at the very end of the shared object. We don't build the standard -static archives with this option as the performance cost is high enough and the use case is rare enough that it doesn't seem worthwhile. Instead, we would encourage developers who need the -static model with huge executables to build a private copy of glibc and configure it with -mcmodel=large. Note that libc.so et al don't need any changes; the only changes are for code that is statically linked into user code built with -mcmodel=large. For the assembly code, I just rewrote it so that it unconditionally uses the large model. To be able to pass -mcmodel=large to csu/elf-init.c and csu/gmon-start.c, I need to check to see if the compiler supports that flag, since gcc 4.7 doesn't; I added the support by creating a small Makefile fragment that just runs the compiler to check.
2012-11-05 15:43:40 +00:00
#endif
tile: Remove elf/ and create crti.S/crtn.S This patches fixes up the tile startup files, moving elf/start.S up a directory level and implementing the required crti.S and crtn.S files based on the old initfini.c compiler output (hand-optimized to bum a couple of cycles).
2012-05-11 18:27:57 +00:00
.Lno_weak_fn:
.section .fini,"ax",@progbits
.align 8
.globl _fini
.type _fini, @function
_fini:
{
move r29, sp
ADDI_PTR r28, sp, -REGSIZE
ST sp, lr
}
ADDI_PTR sp, sp, -(2 * REGSIZE)
ST r28, r29
Reference in New Issue Copy Permalink