commit b6a6cd703ffefa6352249fb01f4da28d85d17306 Author: Rich Felker Date: Thu Jun 4 11:45:17 2015 -0400 fix dynamic linker regression processing R_*_NONE type relocations commit f3ddd173806fd5c60b3f034528ca24542aecc5b9 inadvertently removed the early check for "none" type relocations, causing the address dso->base+0 to be dereferenced to obtain an addend. shared libraries, (including libc.so) and PIE executables were unaffected, since their base addresses are the actual address of their mappings and are readable. non-PIE main executables, however, have a base address of 0 because their load addresses are absolute and not offset at load time. in practice none-type relocations do not arise with toolchains that are in use except on mips, and on mips it's moderately rare for a non-PIE executable to have a relocation table, since the mips-specific got processing serves in its place for most purposes. commit 585ba14df4799d50ec9682ce75825d2eafec2a6a Author: Rich Felker Date: Wed Jun 3 02:00:44 2015 -0400 add additional Makefile dependency rules for rcrt1.o PIE start file commit 2b4fcfdacf93c3dfd6ac15e31790a9e154374679 Author: Rich Felker Date: Thu May 28 23:08:12 2015 -0400 fix failure of ungetc and ungetwc to work on files in eof status these functions were written to handle clearing eof status, but failed to account for the __toread function's handling of eof. with this patch applied, __toread still returns EOF when the file is in eof status, so that read operations will fail, but it also sets up valid buffer pointers for read mode, which are set to the end of the buffer rather than the beginning in order to make the whole buffer available to ungetc/ungetwc. minor changes to __uflow were needed since it's now possible to have non-zero buffer pointers while in eof status. as made, these changes remove a 'fast path' bypassing the function call to __toread, which could be reintroduced with slightly different logic, but since ordinary files have a syscall in f->read, optimizing the code path does not seem worthwhile. the __stdio_read function is also updated not to zero the read buffer pointers on eof/error. while not necessary for correctness, this change avoids the overhead of calling __toread in ungetc after reaching eof, and it also reduces code size and increases consistency with the fmemopen read operation which does not zero the pointers. commit b6e7c664677ab7c77f183b8c41105f2be519800c Author: Rich Felker Date: Thu May 28 15:37:23 2015 -0400 add missing legacy LFS64 macros in sys/resource.h based on patch by Felix Janda, with RLIM64_SAVED_CUR and RLIM64_SAVED_MAX added for completeness. commit fc431d3f76bb9bde34a89e4a3e4d0c27de959855 Author: Shiz Date: Thu May 28 05:52:22 2015 +0200 configure: work around compilers that merely warn for unknown options some compilers (such as clang) accept unknown options without error, but then print warnings on each invocation, cluttering the build output and burying meaningful warnings. this patch makes configure's tryflag and tryldflag functions use additional options to turn the unknown-option warnings into errors, if available, but only at check time. these options are not output in config.mak to avoid the risk of spurious build breakage; if they work, they will have already done their job at configure time. commit aeeac9ca5490d7d90fe061ab72da446c01ddf746 Author: Rich Felker Date: Wed May 27 15:54:47 2015 -0400 implement fail-safe static locales for newlocale this frees applications which need to make temporary use of the C locale (via uselocale) from the possibility that newlocale might fail. the C.UTF-8 locale is also provided as a static locale. presently they behave the same, but this may change in the future. commit 11858d31aa020df3e7e7dedf49f9870ce12f31cc Author: Rich Felker Date: Wed May 27 03:32:46 2015 -0400 rename internal locale file handling locale maps since the __setlocalecat function was removed, the filename __setlocalecat.c no longer made sense. commit 61a3364d246e72b903da8b76c2e27a225a51351e Author: Rich Felker Date: Wed May 27 03:22:52 2015 -0400 overhaul locale internals to treat categories roughly uniformly previously, LC_MESSAGES was treated specially as the only category which could be set to a locale name without a definition file, in order to facilitate gettext message translations when no libc locale was available. LC_NUMERIC was completely un-settable, and LC_CTYPE stored a flag intended to be used for a possible future byte-based C locale, instead of storing a __locale_map pointer like the other categories use. this patch changes all categories to be represented by pointers to __locale_map structures, and allows locale names without definition files to be treated as valid locales with trivial definition when used in any category. outwardly visible functional changes should be minor, limited mainly to the strings read back from setlocale and the way gettext handles translations in categories other than LC_MESSAGES. various internal refactoring has also been performed, and improvements in const correctness have been made. commit 63c188ec42e76ff768e81f6b65b11c68fc43351e Author: Rich Felker Date: Wed May 27 00:22:43 2015 -0400 replace atomics with locks in locale-setting code this is part of a general program of removing direct use of atomics where they are not necessary to meet correctness or performance needs, but in this case it's also an optimization. only the global locale needs synchronization; allocated locales referenced with locale_t handles are immutable during their lifetimes, and using atomics to initialize them increases their cost of setup. commit dc031ee0b1ba11baa00cd7f0769e461a5f396c71 Author: Rich Felker Date: Tue May 26 03:37:41 2015 -0400 add rcrt1 start file for fully static-linked PIE static-linked PIE files need startup code to relocate themselves, much like the dynamic linker does. rcrt1.c reuses the code in dlstart.c, stage 1 of the dynamic linker, which in turn reuses crt_arch.h, to achieve static PIE with no new code. only relative relocations are supported. existing toolchains that don't yet support static PIE directly can be repurposed by passing "-shared -Wl,-Bstatic -Wl,-Bsymbolic" instead of "-static -pie" and substituting rcrt1.o in place of crt1.o. all libraries being linked must be built as PIC/PIE; TEXTRELs are not supported at this time. commit ed0c8249825161036356a3616e8c5247c15d0927 Author: Rich Felker Date: Tue May 26 02:31:04 2015 -0400 fix incorrect application of visibility to Scrt1.o commit de2b67f8d41e08caa56bf6540277f6561edb647f attempted to avoid having vis.h affect crt files, but the Makefile variable used, CRT_LIBS, refers to the final output copies in the lib directory, not the copies in the crt build directory, and thus the -DCRT was not applied. while unlikely to be noticed, this regression probably broke production of PIE executables whose main functions are not in the executable but rather a shared library. commit 9bbddf730f7837cf87f4c789fbb41a312e295d6c Author: Rich Felker Date: Mon May 25 23:33:59 2015 -0400 reprocess all libc/ldso symbolic relocations in dynamic linking stage 3 commit f3ddd173806fd5c60b3f034528ca24542aecc5b9 introduced early relocations and subsequent reprocessing as part of the dynamic linker bootstrap overhaul, to allow use of arbitrary libc functions before the main application and libraries are loaded, but only reprocessed GOT/PLT relocation types. commit c093e2e8201524db0d638920e76bcb6b1d925f3a added reprocessing of non-GOT/PLT relocations to fix an actual regression that was observed on powerpc, but only for RELA format tables with out-of-line addends. REL table (inline addends at the relocation address) reprocessing is trickier because the first relocation pass clobbers the addends. this patch extends symbolic relocation reprocessing for libc/ldso to support all relocation types, whether REL or RELA format tables are used. it is believed not to alter behavior on any existing archs for the current dynamic linker and libc code. the motivations for this change are consistency and future-proofing. it ensures that behavior does not differ depending on whether REL or RELA tables are used, which could lead to undetected arch-specific bugs. it also ensures that, if in the future code depending on additional relocation types is added to libc.so, either at the source level or as part of the compiler runtime that gets pulled in (for example, soft-float with TLS for fenv), the new code will work properly. the implementation concept is simple: stage 2 of the dynamic linker counts the number of symbolic relocations in the libc/ldso REL table and allocates a VLA to save their addends into; stage 3 then uses the saved addends in place of the inline ones which were clobbered. for stack safety, a hard limit (currently 4k) is imposed on the number of such addends; this should be a couple orders of magnitude larger than the actual need. this number is not a runtime variable that could break fail-safety; it is constant for a given libc.so build. commit 768b82c6de24e480267c4c251c440edfc71800e3 Author: Rich Felker Date: Mon May 25 19:15:17 2015 -0400 move call to dynamic linker stage-3 into stage-2 function this move eliminates a duplicate "by-hand" symbol lookup loop from the stage-1 code and replaces it with a call to find_sym, which can be used once we're in stage 2. it reduces the size of the stage 1 code, which is helpful because stage 1 will become the crt start file for static-PIE executables, and it will allow stage 3 to access stage 2's automatic storage, which will be important in an upcoming commit. commit 967bcbf67c3ffac587de4d79abc1e5e072d83e3e Author: Rich Felker Date: Mon May 25 16:02:49 2015 -0400 mark mips crt code as code otherwise disassemblers treat it as data. commit 7b75c4877ddf22f219f944c61d939df1dee4f6d3 Author: Rich Felker Date: Mon May 25 15:56:36 2015 -0400 mark mips cancellable syscall code as code otherwise disassemblers treat it as data. commit 0e0e49421f08cfd670975ecd3604f7f9015e1833 Author: Rich Felker Date: Mon May 25 00:32:37 2015 -0400 simplify/shrink relocation processing in dynamic linker stage 1 the outer-loop approach made sense when we were also processing DT_JMPREL, which might be in REL or RELA form, to avoid major code duplication. commit 09db855b35709aa627d7055c57a98e1e471920ab removed processing of DT_JMPREL, and in the remaining two tables, the format (REL or RELA) is known by the name of the table. simply writing two versions of the loop results in smaller and simpler code. commit 09db855b35709aa627d7055c57a98e1e471920ab Author: Rich Felker Date: Mon May 25 00:25:56 2015 -0400 remove processing of DT_JMPREL from dynamic linker stage 1 bootstrap the DT_JMPREL relocation table necessarily consists entirely of JMP_SLOT (REL_PLT in internal nomenclature) relocations, which are symbolic; they cannot be resolved in stage 1, so there is no point in processing them. commit 9f26ebded188ed78c3571a4ca1477dd6351bc647 Author: Rich Felker Date: Sun May 24 23:03:47 2015 -0400 fix stack alignment code in mips crt_arch.h the instruction used to align the stack, "and $sp, $sp, -8", does not actually exist; it's expanded to 2 instructions using the 'at' (assembler temporary) register, and thus cannot be used in a branch delay slot. since alignment mod 16 commutes with subtracting 8, simply swapping these two operations fixes the problem. crt1.o was not affected because it's still being generated from a dedicated asm source file. dlstart.lo was not affected because the stack pointer it receives is already aligned by the kernel. but Scrt1.o was affected in cases where the dynamic linker gave it a misaligned stack pointer. commit 63caf1d207d143fe405bbe0cda9aac8deca1171a Author: Rich Felker Date: Fri May 22 01:50:05 2015 -0400 add .text section directive to all crt_arch.h files missing it i386 and x86_64 versions already had the .text directive; other archs did not. normally, top-level (file scope) __asm__ starts in the .text section anyway, but problems were reported with some versions of clang, and it seems preferable to set it explicitly anyway, at least for the sake of consistency between archs. commit 3b0e83264d156f9e496ab32badd89e4447b807aa Author: Rich Felker Date: Thu May 21 17:06:28 2015 -0400 remove outdated and misleading comment in iconv.c the comment claimed that EUC/GBK/Big5 are not implemented, which has been incorrect since commit 19b4a0a20efc6b9df98b6a43536ecdd628ba4643. commit 39b8ce66f2ed9c17427ec3a48be9bda29b93b9d7 Author: Rich Felker Date: Thu May 21 17:01:23 2015 -0400 in iconv_open, accept "CHAR" and "" as aliases for "UTF-8" while not a requirement, it's common convention in other iconv implementations to accept "CHAR" as an alias for nl_langinfo(CODESET), meaning the encoding used for char[] strings in the current locale, and also "" as an alternate form. supporting this is not costly and improves compatibility. commit c648cefb27984db60474ec1747cbfde83c2856d0 Author: Rich Felker Date: Wed May 20 00:17:35 2015 -0400 fix inconsistency in a_and and a_or argument types on x86[_64] conceptually, and on other archs, these functions take a pointer to int, but in the i386, x86_64, and x32 versions of atomic.h, they took a pointer to void instead. commit 390f93ef69153bf2087fcf3baa1776ad9a6765ab Author: Bobby Bingham Date: Sun May 17 13:46:38 2015 -0500 inline llsc atomics when building for sh4a If we're building for sh4a, the compiler is already free to use instructions only available on sh4a, so we can do the same and inline the llsc atomics. If we're building for an older processor, we still do the same runtime atomics selection as before. commit c093e2e8201524db0d638920e76bcb6b1d925f3a Author: Rich Felker Date: Mon May 18 16:51:54 2015 -0400 reprocess libc/ldso RELA relocations in stage 3 of dynamic linking this fixes a regression on powerpc that was introduced in commit f3ddd173806fd5c60b3f034528ca24542aecc5b9. global data accesses on powerpc seem to be using a translation-unit-local GOT filled via R_PPC_ADDR32 relocations rather than R_PPC_GLOB_DAT. being a non-GOT relocation type, these were not reprocessed after adding the main application and its libraries to the chain, causing libc code not to see copy relocations in the main program, and therefore to use the pre-copy-relocation addresses for global data objects (like environ). the motivation for the dynamic linker only reprocessing GOT/PLT relocation types in stage 3 is that these types always have a zero addend, making them safe to process again even if the storage for the addend has been clobbered. other relocation types which can be used for address constants in initialized data objects may have non-zero addends which will be clobbered during the first pass of relocation processing if they're stored inline (REL form) rather than out-of-line (RELA form). powerpc generally uses only RELA, so this patch is sufficient to fix the regression in practice, but is not fully general, and would not suffice if an alternate toolchain generated REL for powerpc. commit 43e9f652bf4b2195b04fc14c93db591b30a7b790 Author: Rich Felker Date: Mon May 18 12:11:25 2015 -0400 fix null pointer dereference in dcngettext under specific conditions if setlocale has not been called, the current locale's messages_name may be a null pointer. the code path where it's assumed to be non-null was only reachable if bindtextdomain had already been called, which is normally not done in programs which do not call setlocale, so the omitted check went unnoticed. patch from Void Linux, with description rewritten. commit 68630b55c0c7219fe9df70dc28ffbf9efc8021d8 Author: Rich Felker Date: Sat May 16 01:53:54 2015 -0400 eliminate costly tricks to avoid TLS access for current locale state the code being removed used atomics to track whether any threads might be using a locale other than the current global locale, and whether any threads might have abstract 8-bit (non-UTF-8) LC_CTYPE active, a feature which was never committed (still pending). the motivations were to support early execution prior to setup of the thread pointer, to partially support systems (ancient kernels) where thread pointer setup is not possible, and to avoid high performance cost on archs where accessing the thread pointer may be very slow. since commit 19a1fe670acb3ab9ead0fe31859ca7d4fe40dd54, the thread pointer is always available, so these hacks are no longer needed. removing them greatly simplifies the affected code. commit 707d7c30f3379441de9b320536ddfd354f4c2143 Author: Rich Felker Date: Sat May 16 01:15:40 2015 -0400 in i386 __set_thread_area, don't assume %gs register is initially zero commit f630df09b1fd954eda16e2f779da0b5ecc9d80d3 added logic to handle the case where __set_thread_area is called more than once by reusing the GDT slot already in the %gs register, and only setting up a new GDT slot when %gs is zero. this created a hidden assumption that %gs is zero when a new process image starts, which is true in practice on Linux, but does not seem to be documented ABI, and fails to hold under qemu app-level emulation. while it would in theory be possible to zero %gs in the entry point code, this code is shared between static and dynamic binaries, and dynamic binaries must not clobber the value of %gs already setup by the dynamic linker. the alternative solution implemented in this commit simply uses global data to store the GDT index that's selected. __set_thread_area should only be called in the initial thread anyway (subsequent threads get their thread pointer setup by __clone), but even if it were called by another thread, it would simply read and write back the same GDT index that was already assigned to the initial thread, and thus (in the x86 memory model) there is no data race. commit c0f10cf06725bd0de37f3ced7954a653bf9f1049 Author: Rich Felker Date: Thu May 14 18:51:27 2015 -0400 make arm reloc.h CRTJMP macro compatible with thumb compilers targeting armv7 may be configured to produce thumb2 code instead of arm code by default, and in the future we may wish to support targets where only the thumb instruction set is available. the instructions this patch omits in thumb mode are needed only for non-thumb versions of armv4 or earlier, which are not supported by any current compilers/toolchains and thus rather pointless to have. at some point these compatibility return sequences may be removed from all asm source files, and in that case it would make sense to remove them here too and remove the ifdef. commit 83340c7a580e91b22f58321b7cf6d976af61084c Author: Rich Felker Date: Thu May 14 18:26:16 2015 -0400 make arm crt_arch.h compatible with thumb code generation compilers targeting armv7 may be configured to produce thumb2 code instead of arm code by default, and in the future we may wish to support targets where only the thumb instruction set is available. the changes made here avoid operating directly on the sp register, which is not possible in thumb code, and address an issue with the way the address of _DYNAMIC is computed. previously, the relative address of _DYNAMIC was stored with an additional offset of -8 versus the pc-relative add instruction, since on arm the pc register evaluates to ".+8". in thumb code, it instead evaluates to ".+4". both are two (normal-size) instructions beyond "." in the current execution mode, so the numbered label 2 used in the relative address expression is simply moved two instructions ahead to be compatible with both instruction sets. --- a/Makefile +++ b/Makefile @@ -44,7 +44,7 @@ ALL_INCLUDES = $(sort $(wildcard include EMPTY_LIB_NAMES = m rt pthread crypt util xnet resolv dl EMPTY_LIBS = $(EMPTY_LIB_NAMES:%=lib/lib%.a) -CRT_LIBS = lib/crt1.o lib/Scrt1.o lib/crti.o lib/crtn.o +CRT_LIBS = lib/crt1.o lib/Scrt1.o lib/rcrt1.o lib/crti.o lib/crtn.o STATIC_LIBS = lib/libc.a SHARED_LIBS = lib/libc.so TOOL_LIBS = lib/musl-gcc.specs @@ -85,11 +85,13 @@ src/internal/version.h: $(wildcard VERSI src/internal/version.lo: src/internal/version.h -src/ldso/dlstart.lo src/ldso/dynlink.lo: src/internal/dynlink.h arch/$(ARCH)/reloc.h +crt/rcrt1.o src/ldso/dlstart.lo src/ldso/dynlink.lo: src/internal/dynlink.h arch/$(ARCH)/reloc.h -crt/crt1.o crt/Scrt1.o src/ldso/dlstart.lo: $(wildcard arch/$(ARCH)/crt_arch.h) +crt/crt1.o crt/Scrt1.o crt/rcrt1.o src/ldso/dlstart.lo: $(wildcard arch/$(ARCH)/crt_arch.h) -crt/Scrt1.o: CFLAGS += -fPIC +crt/rcrt1.o: src/ldso/dlstart.c + +crt/Scrt1.o crt/rcrt1.o: CFLAGS += -fPIC OPTIMIZE_SRCS = $(wildcard $(OPTIMIZE_GLOBS:%=src/%)) $(OPTIMIZE_SRCS:%.c=%.o) $(OPTIMIZE_SRCS:%.c=%.lo): CFLAGS += -O3 @@ -104,7 +106,7 @@ NOSSP_SRCS = $(wildcard crt/*.c) \ src/ldso/dlstart.c src/ldso/dynlink.c $(NOSSP_SRCS:%.c=%.o) $(NOSSP_SRCS:%.c=%.lo): CFLAGS += $(CFLAGS_NOSSP) -$(CRT_LIBS): CFLAGS += -DCRT +$(CRT_LIBS:lib/%=crt/%): CFLAGS += -DCRT # This incantation ensures that changes to any subarch asm files will # force the corresponding object file to be rebuilt, even if the implicit --- a/arch/aarch64/crt_arch.h +++ b/arch/aarch64/crt_arch.h @@ -1,4 +1,5 @@ __asm__( +".text \n" ".global " START "\n" ".type " START ",%function\n" START ":\n" --- a/arch/arm/crt_arch.h +++ b/arch/arm/crt_arch.h @@ -1,15 +1,18 @@ __asm__( +".text \n" ".global " START " \n" ".type " START ",%function \n" START ": \n" " mov fp, #0 \n" " mov lr, #0 \n" -" mov a1, sp \n" " ldr a2, 1f \n" -"2: add a2, pc, a2 \n" -" and sp, sp, #-16 \n" +" add a2, pc, a2 \n" +" mov a1, sp \n" +"2: and ip, a1, #-16 \n" +" mov sp, ip \n" " bl " START "_c \n" ".weak _DYNAMIC \n" ".hidden _DYNAMIC \n" -"1: .word _DYNAMIC-2b-8 \n" +".align 2 \n" +"1: .word _DYNAMIC-2b \n" ); --- a/arch/arm/reloc.h +++ b/arch/arm/reloc.h @@ -28,5 +28,10 @@ #define REL_TPOFF R_ARM_TLS_TPOFF32 //#define REL_TLSDESC R_ARM_TLS_DESC +#ifdef __thumb__ +#define CRTJMP(pc,sp) __asm__ __volatile__( \ + "mov sp,%1 ; bx %0" : : "r"(pc), "r"(sp) : "memory" ) +#else #define CRTJMP(pc,sp) __asm__ __volatile__( \ "mov sp,%1 ; tst %0,#1 ; moveq pc,%0 ; bx %0" : : "r"(pc), "r"(sp) : "memory" ) +#endif --- a/arch/i386/atomic.h +++ b/arch/i386/atomic.h @@ -50,16 +50,16 @@ static inline int a_cas(volatile int *p, return t; } -static inline void a_or(volatile void *p, int v) +static inline void a_or(volatile int *p, int v) { __asm__( "lock ; orl %1, %0" - : "=m"(*(int *)p) : "r"(v) : "memory" ); + : "=m"(*p) : "r"(v) : "memory" ); } -static inline void a_and(volatile void *p, int v) +static inline void a_and(volatile int *p, int v) { __asm__( "lock ; andl %1, %0" - : "=m"(*(int *)p) : "r"(v) : "memory" ); + : "=m"(*p) : "r"(v) : "memory" ); } static inline int a_swap(volatile int *x, int v) --- a/arch/microblaze/crt_arch.h +++ b/arch/microblaze/crt_arch.h @@ -1,4 +1,5 @@ __asm__( +".text \n" ".global " START " \n" ".align 2 \n" START ": \n" --- a/arch/mips/crt_arch.h +++ b/arch/mips/crt_arch.h @@ -1,6 +1,7 @@ __asm__( ".set push\n" ".set noreorder\n" +".text \n" ".global _" START "\n" ".global " START "\n" ".type _" START ", @function\n" @@ -21,8 +22,8 @@ __asm__( " addu $5, $5, $gp \n" " lw $25, 4($ra) \n" " addu $25, $25, $gp \n" -" subu $sp, $sp, 16 \n" +" and $sp, $sp, -8 \n" " jalr $25 \n" -" and $sp, $sp, -8 \n" +" subu $sp, $sp, 16 \n" ".set pop \n" ); --- a/arch/or1k/crt_arch.h +++ b/arch/or1k/crt_arch.h @@ -1,4 +1,5 @@ __asm__( +".text \n" ".global " START " \n" ".align 4 \n" START ": \n" --- a/arch/powerpc/crt_arch.h +++ b/arch/powerpc/crt_arch.h @@ -1,4 +1,5 @@ __asm__( +".text \n" ".global " START " \n" ".type " START ", %function \n" START ": \n" --- a/arch/sh/atomic.h +++ b/arch/sh/atomic.h @@ -22,6 +22,88 @@ static inline int a_ctz_64(uint64_t x) return a_ctz_l(y); } +#define LLSC_CLOBBERS "r0", "t", "memory" +#define LLSC_START(mem) "synco\n" \ + "0: movli.l @" mem ", r0\n" +#define LLSC_END(mem) \ + "1: movco.l r0, @" mem "\n" \ + " bf 0b\n" \ + " synco\n" + +static inline int __sh_cas_llsc(volatile int *p, int t, int s) +{ + int old; + __asm__ __volatile__( + LLSC_START("%1") + " mov r0, %0\n" + " cmp/eq %0, %2\n" + " bf 1f\n" + " mov %3, r0\n" + LLSC_END("%1") + : "=&r"(old) : "r"(p), "r"(t), "r"(s) : LLSC_CLOBBERS); + return old; +} + +static inline int __sh_swap_llsc(volatile int *x, int v) +{ + int old; + __asm__ __volatile__( + LLSC_START("%1") + " mov r0, %0\n" + " mov %2, r0\n" + LLSC_END("%1") + : "=&r"(old) : "r"(x), "r"(v) : LLSC_CLOBBERS); + return old; +} + +static inline int __sh_fetch_add_llsc(volatile int *x, int v) +{ + int old; + __asm__ __volatile__( + LLSC_START("%1") + " mov r0, %0\n" + " add %2, r0\n" + LLSC_END("%1") + : "=&r"(old) : "r"(x), "r"(v) : LLSC_CLOBBERS); + return old; +} + +static inline void __sh_store_llsc(volatile int *p, int x) +{ + __asm__ __volatile__( + " synco\n" + " mov.l %1, @%0\n" + " synco\n" + : : "r"(p), "r"(x) : "memory"); +} + +static inline void __sh_and_llsc(volatile int *x, int v) +{ + __asm__ __volatile__( + LLSC_START("%0") + " and %1, r0\n" + LLSC_END("%0") + : : "r"(x), "r"(v) : LLSC_CLOBBERS); +} + +static inline void __sh_or_llsc(volatile int *x, int v) +{ + __asm__ __volatile__( + LLSC_START("%0") + " or %1, r0\n" + LLSC_END("%0") + : : "r"(x), "r"(v) : LLSC_CLOBBERS); +} + +#ifdef __SH4A__ +#define a_cas(p,t,s) __sh_cas_llsc(p,t,s) +#define a_swap(x,v) __sh_swap_llsc(x,v) +#define a_fetch_add(x,v) __sh_fetch_add_llsc(x, v) +#define a_store(x,v) __sh_store_llsc(x, v) +#define a_and(x,v) __sh_and_llsc(x, v) +#define a_or(x,v) __sh_or_llsc(x, v) +#else + int __sh_cas(volatile int *, int, int); int __sh_swap(volatile int *, int); int __sh_fetch_add(volatile int *, int); @@ -35,6 +117,7 @@ void __sh_or(volatile int *, int); #define a_store(x,v) __sh_store(x, v) #define a_and(x,v) __sh_and(x, v) #define a_or(x,v) __sh_or(x, v) +#endif static inline void *a_cas_p(volatile void *p, void *t, void *s) { --- a/arch/sh/crt_arch.h +++ b/arch/sh/crt_arch.h @@ -1,4 +1,5 @@ __asm__( +".text \n" ".global " START " \n" START ": \n" " mova 1f, r0 \n" --- a/arch/sh/src/atomic.c +++ b/arch/sh/src/atomic.c @@ -1,12 +1,7 @@ -#include "libc.h" +#ifndef __SH4A__ -#define LLSC_CLOBBERS "r0", "t", "memory" -#define LLSC_START(mem) "synco\n" \ - "0: movli.l @" mem ", r0\n" -#define LLSC_END(mem) \ - "1: movco.l r0, @" mem "\n" \ - " bf 0b\n" \ - " synco\n" +#include "atomic.h" +#include "libc.h" /* gusa is a hack in the kernel which lets you create a sequence of instructions * which will be restarted if the process is preempted in the middle of the @@ -34,114 +29,74 @@ int __sh_cas(volatile int *p, int t, int s) { + if (__hwcap & CPU_HAS_LLSC) return __sh_cas_llsc(p, t, s); + int old; - if (__hwcap & CPU_HAS_LLSC) { - __asm__ __volatile__( - LLSC_START("%1") - " mov r0, %0\n" - " cmp/eq %0, %2\n" - " bf 1f\n" - " mov %3, r0\n" - LLSC_END("%1") - : "=&r"(old) : "r"(p), "r"(t), "r"(s) : LLSC_CLOBBERS); - } else { - __asm__ __volatile__( - GUSA_START_EVEN("%1", "%0") - " cmp/eq %0, %2\n" - " bf 1f\n" - GUSA_END("%1", "%3") - : "=&r"(old) : "r"(p), "r"(t), "r"(s) : GUSA_CLOBBERS, "t"); - } + __asm__ __volatile__( + GUSA_START_EVEN("%1", "%0") + " cmp/eq %0, %2\n" + " bf 1f\n" + GUSA_END("%1", "%3") + : "=&r"(old) : "r"(p), "r"(t), "r"(s) : GUSA_CLOBBERS, "t"); return old; } int __sh_swap(volatile int *x, int v) { + if (__hwcap & CPU_HAS_LLSC) return __sh_swap_llsc(x, v); + int old; - if (__hwcap & CPU_HAS_LLSC) { - __asm__ __volatile__( - LLSC_START("%1") - " mov r0, %0\n" - " mov %2, r0\n" - LLSC_END("%1") - : "=&r"(old) : "r"(x), "r"(v) : LLSC_CLOBBERS); - } else { - __asm__ __volatile__( - GUSA_START_EVEN("%1", "%0") - GUSA_END("%1", "%2") - : "=&r"(old) : "r"(x), "r"(v) : GUSA_CLOBBERS); - } + __asm__ __volatile__( + GUSA_START_EVEN("%1", "%0") + GUSA_END("%1", "%2") + : "=&r"(old) : "r"(x), "r"(v) : GUSA_CLOBBERS); return old; } int __sh_fetch_add(volatile int *x, int v) { + if (__hwcap & CPU_HAS_LLSC) return __sh_fetch_add_llsc(x, v); + int old, dummy; - if (__hwcap & CPU_HAS_LLSC) { - __asm__ __volatile__( - LLSC_START("%1") - " mov r0, %0\n" - " add %2, r0\n" - LLSC_END("%1") - : "=&r"(old) : "r"(x), "r"(v) : LLSC_CLOBBERS); - } else { - __asm__ __volatile__( - GUSA_START_EVEN("%2", "%0") - " mov %0, %1\n" - " add %3, %1\n" - GUSA_END("%2", "%1") - : "=&r"(old), "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS); - } + __asm__ __volatile__( + GUSA_START_EVEN("%2", "%0") + " mov %0, %1\n" + " add %3, %1\n" + GUSA_END("%2", "%1") + : "=&r"(old), "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS); return old; } void __sh_store(volatile int *p, int x) { - if (__hwcap & CPU_HAS_LLSC) { - __asm__ __volatile__( - " synco\n" - " mov.l %1, @%0\n" - " synco\n" - : : "r"(p), "r"(x) : "memory"); - } else { - __asm__ __volatile__( - " mov.l %1, @%0\n" - : : "r"(p), "r"(x) : "memory"); - } + if (__hwcap & CPU_HAS_LLSC) return __sh_store_llsc(p, x); + __asm__ __volatile__( + " mov.l %1, @%0\n" + : : "r"(p), "r"(x) : "memory"); } void __sh_and(volatile int *x, int v) { + if (__hwcap & CPU_HAS_LLSC) return __sh_and_llsc(x, v); + int dummy; - if (__hwcap & CPU_HAS_LLSC) { - __asm__ __volatile__( - LLSC_START("%0") - " and %1, r0\n" - LLSC_END("%0") - : : "r"(x), "r"(v) : LLSC_CLOBBERS); - } else { - __asm__ __volatile__( - GUSA_START_ODD("%1", "%0") - " and %2, %0\n" - GUSA_END("%1", "%0") - : "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS); - } + __asm__ __volatile__( + GUSA_START_ODD("%1", "%0") + " and %2, %0\n" + GUSA_END("%1", "%0") + : "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS); } void __sh_or(volatile int *x, int v) { + if (__hwcap & CPU_HAS_LLSC) return __sh_or_llsc(x, v); + int dummy; - if (__hwcap & CPU_HAS_LLSC) { - __asm__ __volatile__( - LLSC_START("%0") - " or %1, r0\n" - LLSC_END("%0") - : : "r"(x), "r"(v) : LLSC_CLOBBERS); - } else { - __asm__ __volatile__( - GUSA_START_ODD("%1", "%0") - " or %2, %0\n" - GUSA_END("%1", "%0") - : "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS); - } + __asm__ __volatile__( + GUSA_START_ODD("%1", "%0") + " or %2, %0\n" + GUSA_END("%1", "%0") + : "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS); } + +#endif --- a/arch/x32/atomic.h +++ b/arch/x32/atomic.h @@ -47,16 +47,16 @@ static inline int a_cas(volatile int *p, return t; } -static inline void a_or(volatile void *p, int v) +static inline void a_or(volatile int *p, int v) { __asm__( "lock ; or %1, %0" - : "=m"(*(int *)p) : "r"(v) : "memory" ); + : "=m"(*p) : "r"(v) : "memory" ); } -static inline void a_and(volatile void *p, int v) +static inline void a_and(volatile int *p, int v) { __asm__( "lock ; and %1, %0" - : "=m"(*(int *)p) : "r"(v) : "memory" ); + : "=m"(*p) : "r"(v) : "memory" ); } static inline int a_swap(volatile int *x, int v) --- a/arch/x86_64/atomic.h +++ b/arch/x86_64/atomic.h @@ -47,16 +47,16 @@ static inline int a_cas(volatile int *p, return t; } -static inline void a_or(volatile void *p, int v) +static inline void a_or(volatile int *p, int v) { __asm__( "lock ; or %1, %0" - : "=m"(*(int *)p) : "r"(v) : "memory" ); + : "=m"(*p) : "r"(v) : "memory" ); } -static inline void a_and(volatile void *p, int v) +static inline void a_and(volatile int *p, int v) { __asm__( "lock ; and %1, %0" - : "=m"(*(int *)p) : "r"(v) : "memory" ); + : "=m"(*p) : "r"(v) : "memory" ); } static inline int a_swap(volatile int *x, int v) --- a/configure +++ b/configure @@ -80,7 +80,7 @@ fi tryflag () { printf "checking whether compiler accepts %s... " "$2" echo "typedef int x;" > "$tmpc" -if $CC $2 -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then +if $CC $CFLAGS_TRY $2 -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then printf "yes\n" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" @@ -94,7 +94,7 @@ fi tryldflag () { printf "checking whether linker accepts %s... " "$2" echo "typedef int x;" > "$tmpc" -if $CC -nostdlib -shared "$2" -o /dev/null "$tmpc" >/dev/null 2>&1 ; then +if $CC $LDFLAGS_TRY -nostdlib -shared "$2" -o /dev/null "$tmpc" >/dev/null 2>&1 ; then printf "yes\n" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" @@ -113,7 +113,9 @@ CFLAGS_C99FSE= CFLAGS_AUTO= CFLAGS_MEMOPS= CFLAGS_NOSSP= +CFLAGS_TRY= LDFLAGS_AUTO= +LDFLAGS_TRY= OPTIMIZE_GLOBS= prefix=/usr/local/musl exec_prefix='$(prefix)' @@ -205,6 +207,14 @@ exit 1 fi # +# Figure out options to force errors on unknown flags. +# +tryflag CFLAGS_TRY -Werror=unknown-warning-option +tryflag CFLAGS_TRY -Werror=unused-command-line-argument +tryldflag LDFLAGS_TRY -Werror=unknown-warning-option +tryldflag LDFLAGS_TRY -Werror=unused-command-line-argument + +# # Need to know if the compiler is gcc to decide whether to build the # musl-gcc wrapper, and for critical bug detection in some gcc versions. # --- a/crt/mips/crt1.s +++ b/crt/mips/crt1.s @@ -4,6 +4,8 @@ .weak _fini .global __start .global _start +.type __start,@function +.type _start,@function __start: _start: subu $fp, $fp, $fp # Zero the frame pointer. --- a/crt/mips/crti.s +++ b/crt/mips/crti.s @@ -2,6 +2,7 @@ .section .init .global _init +.type _init,@function .align 2 _init: subu $sp,$sp,32 @@ -10,6 +11,7 @@ _init: .section .fini .global _fini +.type _fini,@function .align 2 _fini: subu $sp,$sp,32 --- /dev/null +++ b/crt/rcrt1.c @@ -0,0 +1,15 @@ +#define SHARED +#define START "_start" +#define _dlstart_c _start_c +#include "../src/ldso/dlstart.c" + +int main(); +void _init() __attribute__((weak)); +void _fini() __attribute__((weak)); +_Noreturn int __libc_start_main(int (*)(), int, char **, + void (*)(), void(*)(), void(*)()); + +_Noreturn void __dls2(unsigned char *base, size_t *sp) +{ + __libc_start_main(main, *sp, (void *)(sp+1), _init, _fini, 0); +} --- a/include/sys/resource.h +++ b/include/sys/resource.h @@ -96,6 +96,9 @@ int prlimit(pid_t, int, const struct rli #define RLIM_NLIMITS RLIMIT_NLIMITS #if defined(_LARGEFILE64_SOURCE) || defined(_GNU_SOURCE) +#define RLIM64_INFINITY RLIM_INFINITY +#define RLIM64_SAVED_CUR RLIM_SAVED_CUR +#define RLIM64_SAVED_MAX RLIM_SAVED_MAX #define getrlimit64 getrlimit #define setrlimit64 setrlimit #define rlimit64 rlimit --- a/src/internal/dynlink.h +++ b/src/internal/dynlink.h @@ -51,7 +51,7 @@ enum { #define AUX_CNT 32 #define DYN_CNT 32 -typedef void (*stage2_func)(unsigned char *); +typedef void (*stage2_func)(unsigned char *, size_t *); typedef _Noreturn void (*stage3_func)(size_t *); #endif --- a/src/internal/libc.h +++ b/src/internal/libc.h @@ -8,9 +8,7 @@ struct __locale_map; struct __locale_struct { - volatile int ctype_utf8; - char *messages_name; - struct __locale_map *volatile cat[4]; + const struct __locale_map *volatile cat[6]; }; struct __libc { @@ -23,8 +21,6 @@ struct __libc { volatile int ofl_lock[2]; size_t tls_size; size_t page_size; - volatile int uselocale_cnt; - volatile int bytelocale_cnt_minus_1; struct __locale_struct global_locale; }; --- a/src/internal/locale_impl.h +++ b/src/internal/locale_impl.h @@ -9,22 +9,20 @@ struct __locale_map { const void *map; size_t map_size; char name[LOCALE_NAME_MAX+1]; - struct __locale_map *next; + const struct __locale_map *next; }; -int __setlocalecat(locale_t, int, const char *); +const struct __locale_map *__get_locale(int, const char *); const char *__mo_lookup(const void *, size_t, const char *); const char *__lctrans(const char *, const struct __locale_map *); const char *__lctrans_cur(const char *); -#define LCTRANS(msg, lc, loc) __lctrans(msg, (loc)->cat[(lc)-2]) +#define LCTRANS(msg, lc, loc) __lctrans(msg, (loc)->cat[(lc)]) #define LCTRANS_CUR(msg) __lctrans_cur(msg) -#define CURRENT_LOCALE \ - (libc.uselocale_cnt ? __pthread_self()->locale : &libc.global_locale) +#define CURRENT_LOCALE (__pthread_self()->locale) -#define CURRENT_UTF8 \ - (libc.bytelocale_cnt_minus_1<0 || __pthread_self()->locale->ctype_utf8) +#define CURRENT_UTF8 (!!__pthread_self()->locale->cat[LC_CTYPE]) #undef MB_CUR_MAX #define MB_CUR_MAX (CURRENT_UTF8 ? 4 : 1) --- a/src/ldso/dlstart.c +++ b/src/ldso/dlstart.c @@ -56,31 +56,22 @@ void _dlstart_c(size_t *sp, size_t *dynv for (i=0; irel_early_relative && IS_RELATIVE(rel[1])) continue; + if (skip_relative && IS_RELATIVE(rel[1])) continue; type = R_TYPE(rel[1]); + if (type == REL_NONE) continue; sym_index = R_SYM(rel[1]); reloc_addr = (void *)(base + rel[0]); if (sym_index) { @@ -280,12 +291,20 @@ static void do_relocs(struct dso *dso, s def.dso = dso; } - int gotplt = (type == REL_GOT || type == REL_PLT); - if (dso->rel_update_got && !gotplt) continue; - - addend = stride>2 ? rel[2] - : gotplt || type==REL_COPY ? 0 - : *reloc_addr; + if (stride > 2) { + addend = rel[2]; + } else if (type==REL_GOT || type==REL_PLT|| type==REL_COPY) { + addend = 0; + } else if (reuse_addends) { + /* Save original addend in stage 2 where the dso + * chain consists of just ldso; otherwise read back + * saved addend since the inline one was clobbered. */ + if (head==&ldso) + saved_addends[save_slot] = *reloc_addr; + addend = saved_addends[save_slot++]; + } else { + addend = *reloc_addr; + } sym_val = def.sym ? (size_t)def.dso->base+def.sym->st_value : 0; tls_val = def.sym ? def.sym->st_value : 0; @@ -879,7 +898,7 @@ static void do_mips_relocs(struct dso *p size_t i, j, rel[2]; unsigned char *base = p->base; i=0; search_vec(p->dynv, &i, DT_MIPS_LOCAL_GOTNO); - if (p->rel_early_relative) { + if (p==&ldso) { got += i; } else { while (i--) *got++ += (size_t)base; @@ -1116,7 +1135,7 @@ static void update_tls_size() * linker itself, but some of the relocations performed may need to be * replaced later due to copy relocations in the main program. */ -void __dls2(unsigned char *base) +void __dls2(unsigned char *base, size_t *sp) { Ehdr *ehdr = (void *)base; ldso.base = base; @@ -1125,15 +1144,35 @@ void __dls2(unsigned char *base) ldso.phnum = ehdr->e_phnum; ldso.phdr = (void *)(base + ehdr->e_phoff); ldso.phentsize = ehdr->e_phentsize; - ldso.rel_early_relative = 1; kernel_mapped_dso(&ldso); decode_dyn(&ldso); + /* Prepare storage for to save clobbered REL addends so they + * can be reused in stage 3. There should be very few. If + * something goes wrong and there are a huge number, abort + * instead of risking stack overflow. */ + size_t dyn[DYN_CNT]; + decode_vec(ldso.dynv, dyn, DYN_CNT); + size_t *rel = (void *)(base+dyn[DT_REL]); + size_t rel_size = dyn[DT_RELSZ]; + size_t symbolic_rel_cnt = 0; + apply_addends_to = rel; + for (; rel_size; rel+=2, rel_size-=2*sizeof(size_t)) + if (!IS_RELATIVE(rel[1])) symbolic_rel_cnt++; + if (symbolic_rel_cnt >= ADDEND_LIMIT) a_crash(); + size_t addends[symbolic_rel_cnt+1]; + saved_addends = addends; + head = &ldso; reloc_all(&ldso); ldso.relocated = 0; - ldso.rel_update_got = 1; + + /* Call dynamic linker stage-3, __dls3, looking it up + * symbolically as a barrier against moving the address + * load across the above relocation processing. */ + struct symdef dls3_def = find_sym(&ldso, "__dls3", 0); + ((stage3_func)(ldso.base+dls3_def.sym->st_value))(sp); } /* Stage 3 of the dynamic linker is called with the dynamic linker/libc --- a/src/locale/__lctrans.c +++ b/src/locale/__lctrans.c @@ -16,5 +16,5 @@ const char *__lctrans(const char *msg, c const char *__lctrans_cur(const char *msg) { - return __lctrans_impl(msg, CURRENT_LOCALE->cat[LC_MESSAGES-2]); + return __lctrans_impl(msg, CURRENT_LOCALE->cat[LC_MESSAGES]); } --- a/src/locale/__setlocalecat.c +++ /dev/null @@ -1,111 +0,0 @@ -#include -#include -#include "locale_impl.h" -#include "libc.h" -#include "atomic.h" - -const char *__lctrans_impl(const char *msg, const struct __locale_map *lm) -{ - const char *trans = 0; - if (lm) trans = __mo_lookup(lm->map, lm->map_size, msg); - return trans ? trans : msg; -} - -const unsigned char *__map_file(const char *, size_t *); -int __munmap(void *, size_t); -char *__strchrnul(const char *, int); - -static struct __locale_map *findlocale(const char *name, size_t n) -{ - static void *volatile loc_head; - struct __locale_map *p, *new, *old_head; - const char *path = 0, *z; - char buf[256]; - size_t l; - const void *map; - size_t map_size; - - for (p=loc_head; p; p=p->next) - if (!strcmp(name, p->name)) return p; - - if (!libc.secure) path = getenv("MUSL_LOCPATH"); - /* FIXME: add a default path? */ - if (!path) return 0; - - for (; *path; path=z+!!*z) { - z = __strchrnul(path, ':'); - l = z - path - !!*z; - if (l >= sizeof buf - n - 2) continue; - memcpy(buf, path, l); - buf[l] = '/'; - memcpy(buf+l+1, name, n); - buf[l+1+n] = 0; - map = __map_file(buf, &map_size); - if (map) { - new = malloc(sizeof *new); - if (!new) { - __munmap((void *)map, map_size); - return 0; - } - new->map = map; - new->map_size = map_size; - memcpy(new->name, name, n); - new->name[n] = 0; - do { - old_head = loc_head; - new->next = old_head; - } while (a_cas_p(&loc_head, old_head, new) != old_head); - return new; - } - } - return 0; -} - -static const char envvars[][12] = { - "LC_CTYPE", - "LC_NUMERIC", - "LC_TIME", - "LC_COLLATE", - "LC_MONETARY", - "LC_MESSAGES", -}; - -int __setlocalecat(locale_t loc, int cat, const char *val) -{ - if (!*val) { - (val = getenv("LC_ALL")) && *val || - (val = getenv(envvars[cat])) && *val || - (val = getenv("LANG")) && *val || - (val = "C.UTF-8"); - } - - size_t n; - for (n=0; nctype_utf8, !builtin || val[1]=='.'); - break; - case LC_MESSAGES: - if (builtin) { - loc->messages_name[0] = 0; - } else { - memcpy(loc->messages_name, val, n); - loc->messages_name[n] = 0; - } - /* fall through */ - default: - data = builtin ? 0 : findlocale(val, n); - if (data == loc->cat[cat-2]) break; - do old = loc->cat[cat-2]; - while (a_cas_p(&loc->cat[cat-2], old, data) != old); - case LC_NUMERIC: - break; - } - return 0; -} --- a/src/locale/dcngettext.c +++ b/src/locale/dcngettext.c @@ -84,13 +84,15 @@ char *bindtextdomain(const char *domainn } static const char catnames[][12] = { + "LC_CTYPE", + "LC_NUMERIC", "LC_TIME", "LC_COLLATE", "LC_MONETARY", "LC_MESSAGES", }; -static const char catlens[] = { 7, 10, 11, 11 }; +static const char catlens[] = { 8, 10, 7, 10, 11, 11 }; struct msgcat { struct msgcat *next; @@ -117,10 +119,12 @@ char *dcngettext(const char *domainname, static struct msgcat *volatile cats; struct msgcat *p; struct __locale_struct *loc = CURRENT_LOCALE; - struct __locale_map *lm; + const struct __locale_map *lm; const char *dirname, *locname, *catname; size_t dirlen, loclen, catlen, domlen; + if ((unsigned)category >= LC_ALL) goto notrans; + if (!domainname) domainname = __gettextdomain(); domlen = strlen(domainname); @@ -129,25 +133,15 @@ char *dcngettext(const char *domainname, dirname = gettextdir(domainname, &dirlen); if (!dirname) goto notrans; - switch (category) { - case LC_MESSAGES: - locname = loc->messages_name; - if (!*locname) goto notrans; - break; - case LC_TIME: - case LC_MONETARY: - case LC_COLLATE: - lm = loc->cat[category-2]; - if (!lm) goto notrans; - locname = lm->name; - break; - default: + lm = loc->cat[category]; + if (!lm) { notrans: return (char *) ((n == 1) ? msgid1 : msgid2); } + locname = lm->name; - catname = catnames[category-2]; - catlen = catlens[category-2]; + catname = catnames[category]; + catlen = catlens[category]; loclen = strlen(locname); size_t namelen = dirlen+1 + loclen+1 + catlen+1 + domlen+3; --- a/src/locale/duplocale.c +++ b/src/locale/duplocale.c @@ -5,17 +5,10 @@ locale_t __duplocale(locale_t old) { - locale_t new = calloc(1, sizeof *new + LOCALE_NAME_MAX + 1); + locale_t new = malloc(sizeof *new); if (!new) return 0; - new->messages_name = (void *)(new+1); - if (old == LC_GLOBAL_LOCALE) old = &libc.global_locale; - new->ctype_utf8 = old->ctype_utf8; - if (old->messages_name) - strcpy(new->messages_name, old->messages_name); - - for (size_t i=0; icat/sizeof new->cat[0]; i++) - new->cat[i] = old->cat[i]; + *new = *old; return new; } --- a/src/locale/freelocale.c +++ b/src/locale/freelocale.c @@ -2,9 +2,11 @@ #include "locale_impl.h" #include "libc.h" +int __loc_is_allocated(locale_t); + void freelocale(locale_t l) { - free(l); + if (__loc_is_allocated(l)) free(l); } weak_alias(freelocale, __freelocale); --- a/src/locale/iconv.c +++ b/src/locale/iconv.c @@ -23,19 +23,13 @@ #define BIG5 0340 #define EUC_KR 0350 -/* FIXME: these are not implemented yet - * EUC: A1-FE A1-FE - * GBK: 81-FE 40-7E,80-FE - * Big5: A1-FE 40-7E,A1-FE - */ - /* Definitions of charmaps. Each charmap consists of: * 1. Empty-string-terminated list of null-terminated aliases. * 2. Special type code or number of elided entries. * 3. Character table (size determined by field 2). */ static const unsigned char charmaps[] = -"utf8\0\0\310" +"utf8\0char\0\0\310" "wchart\0\0\306" "ucs2\0ucs2be\0\0\304" "ucs2le\0\0\305" @@ -90,6 +84,7 @@ static int fuzzycmp(const unsigned char static size_t find_charmap(const void *name) { const unsigned char *s; + if (!*(char *)name) name=charmaps; /* "utf8" */ for (s=charmaps; *s; ) { if (!fuzzycmp(name, s)) { for (; *s; s+=strlen((void *)s)+1); --- /dev/null +++ b/src/locale/locale_map.c @@ -0,0 +1,124 @@ +#include +#include +#include "locale_impl.h" +#include "libc.h" +#include "atomic.h" + +const char *__lctrans_impl(const char *msg, const struct __locale_map *lm) +{ + const char *trans = 0; + if (lm) trans = __mo_lookup(lm->map, lm->map_size, msg); + return trans ? trans : msg; +} + +const unsigned char *__map_file(const char *, size_t *); +int __munmap(void *, size_t); +char *__strchrnul(const char *, int); + +static const char envvars[][12] = { + "LC_CTYPE", + "LC_NUMERIC", + "LC_TIME", + "LC_COLLATE", + "LC_MONETARY", + "LC_MESSAGES", +}; + +static const uint32_t empty_mo[] = { 0x950412de, 0, -1, -1, -1 }; + +const struct __locale_map __c_dot_utf8 = { + .map = empty_mo, + .map_size = sizeof empty_mo, + .name = "C.UTF-8" +}; + +const struct __locale_map *__get_locale(int cat, const char *val) +{ + static int lock[2]; + static void *volatile loc_head; + const struct __locale_map *p; + struct __locale_map *new = 0; + const char *path = 0, *z; + char buf[256]; + size_t l, n; + + if (!*val) { + (val = getenv("LC_ALL")) && *val || + (val = getenv(envvars[cat])) && *val || + (val = getenv("LANG")) && *val || + (val = "C.UTF-8"); + } + + /* Limit name length and forbid leading dot or any slashes. */ + for (n=0; nnext) + if (!strcmp(val, p->name)) return p; + + LOCK(lock); + + for (p=loc_head; p; p=p->next) + if (!strcmp(val, p->name)) { + UNLOCK(lock); + return p; + } + + if (!libc.secure) path = getenv("MUSL_LOCPATH"); + /* FIXME: add a default path? */ + + if (path) for (; *path; path=z+!!*z) { + z = __strchrnul(path, ':'); + l = z - path - !!*z; + if (l >= sizeof buf - n - 2) continue; + memcpy(buf, path, l); + buf[l] = '/'; + memcpy(buf+l+1, val, n); + buf[l+1+n] = 0; + size_t map_size; + const void *map = __map_file(buf, &map_size); + if (map) { + new = malloc(sizeof *new); + if (!new) { + __munmap((void *)map, map_size); + break; + } + new->map = map; + new->map_size = map_size; + memcpy(new->name, val, n); + new->name[n] = 0; + new->next = loc_head; + loc_head = new; + break; + } + } + + /* If no locale definition was found, make a locale map + * object anyway to store the name, which is kept for the + * sake of being able to do message translations at the + * application level. */ + if (!new && (new = malloc(sizeof *new))) { + new->map = empty_mo; + new->map_size = sizeof empty_mo; + memcpy(new->name, val, n); + new->name[n] = 0; + new->next = loc_head; + loc_head = new; + } + + /* For LC_CTYPE, never return a null pointer unless the + * requested name was "C" or "POSIX". */ + if (!new && cat == LC_CTYPE) new = (void *)&__c_dot_utf8; + + UNLOCK(lock); + return new; +} --- a/src/locale/newlocale.c +++ b/src/locale/newlocale.c @@ -3,22 +3,52 @@ #include "locale_impl.h" #include "libc.h" +extern const struct __locale_map __c_dot_utf8; + +static const struct __locale_struct c_locale = { 0 }; +static const struct __locale_struct c_dot_utf8_locale = { + .cat[LC_CTYPE] = &__c_dot_utf8 +}; + +int __loc_is_allocated(locale_t loc) +{ + return loc && loc != &c_locale && loc != &c_dot_utf8_locale; +} + locale_t __newlocale(int mask, const char *name, locale_t loc) { - int i; + int i, j; + struct __locale_struct tmp; + const struct __locale_map *lm; - if (!loc) { - loc = calloc(1, sizeof *loc + LOCALE_NAME_MAX + 1); - if (!loc) return 0; - loc->messages_name = (void *)(loc+1); + /* For locales with allocated storage, modify in-place. */ + if (__loc_is_allocated(loc)) { for (i=0; icat[i] = __get_locale(i, name); + return loc; + } + + /* Otherwise, build a temporary locale object, which will only + * be instantiated in allocated storage if it does not match + * one of the built-in static locales. This makes the common + * usage case for newlocale, getting a C locale with predictable + * behavior, very fast, and more importantly, fail-safe. */ + for (j=i=0; icat[i]; + else + lm = __get_locale(i, mask & (1<name : "C"; +} + +char *__strchrnul(const char *, int); + +char *setlocale(int cat, const char *name) +{ + static volatile int lock[2]; if ((unsigned)cat > LC_ALL) return 0; + LOCK(lock); + /* For LC_ALL, setlocale is required to return a string which * encodes the current setting for all categories. The format of * this string is unspecified, and only the following code, which * performs both the serialization and deserialization, depends * on the format, so it can easily be changed if needed. */ if (cat == LC_ALL) { + int i; if (name) { - char part[LOCALE_NAME_MAX+1]; - if (name[0] && name[1]==';' - && strlen(name) > 2 + 3*(LOCALE_NAME_MAX+1)) { - part[0] = name[0]; - part[1] = 0; - setlocale(LC_CTYPE, part); - part[LOCALE_NAME_MAX] = 0; - for (i=LC_TIME; iname, strlen(lm->name)); + char *s = buf; + for (i=0; iname : "C"; + size_t l = strlen(part); + memcpy(s, part, l); + s[l] = ';'; + s += l+1; } + *--s = 0; + UNLOCK(lock); return buf; } - if (name) { - int adj = libc.global_locale.ctype_utf8; - __setlocalecat(&libc.global_locale, cat, name); - adj -= libc.global_locale.ctype_utf8; - if (adj) a_fetch_add(&libc.bytelocale_cnt_minus_1, adj); - } + char *ret = setlocale_one_unlocked(cat, name); - switch (cat) { - case LC_CTYPE: - return libc.global_locale.ctype_utf8 ? "C.UTF-8" : "C"; - case LC_NUMERIC: - return "C"; - case LC_MESSAGES: - return libc.global_locale.messages_name[0] - ? libc.global_locale.messages_name : "C"; - default: - lm = libc.global_locale.cat[cat-2]; - return lm ? lm->name : "C"; - } + UNLOCK(lock); + + return ret; } --- a/src/locale/uselocale.c +++ b/src/locale/uselocale.c @@ -10,15 +10,7 @@ locale_t __uselocale(locale_t new) if (new == LC_GLOBAL_LOCALE) new = global; - if (new && new != old) { - int adj = 0; - if (new == global) a_dec(&libc.uselocale_cnt); - else if (!new->ctype_utf8) adj++; - if (old == global) a_inc(&libc.uselocale_cnt); - else if (!old->ctype_utf8) adj--; - a_fetch_add(&libc.bytelocale_cnt_minus_1, adj); - self->locale = new; - } + self->locale = new; return old == global ? LC_GLOBAL_LOCALE : old; } --- a/src/stdio/__stdio_read.c +++ b/src/stdio/__stdio_read.c @@ -21,7 +21,6 @@ size_t __stdio_read(FILE *f, unsigned ch pthread_cleanup_pop(0); if (cnt <= 0) { f->flags |= F_EOF ^ ((F_ERR^F_EOF) & cnt); - f->rpos = f->rend = 0; return cnt; } if (cnt <= iov[0].iov_len) return cnt; --- a/src/stdio/__toread.c +++ b/src/stdio/__toread.c @@ -5,12 +5,12 @@ int __toread(FILE *f) f->mode |= f->mode-1; if (f->wpos > f->buf) f->write(f, 0, 0); f->wpos = f->wbase = f->wend = 0; - if (f->flags & (F_EOF|F_NORD)) { - if (f->flags & F_NORD) f->flags |= F_ERR; + if (f->flags & F_NORD) { + f->flags |= F_ERR; return EOF; } - f->rpos = f->rend = f->buf; - return 0; + f->rpos = f->rend = f->buf + f->buf_size; + return (f->flags & F_EOF) ? EOF : 0; } void __stdio_exit_needed(void); --- a/src/stdio/__uflow.c +++ b/src/stdio/__uflow.c @@ -1,11 +1,11 @@ #include "stdio_impl.h" -/* This function will never be called if there is already data - * buffered for reading. Thus we can get by with very few branches. */ +/* This function assumes it will never be called if there is already + * data buffered for reading. */ int __uflow(FILE *f) { unsigned char c; - if ((f->rend || !__toread(f)) && f->read(f, &c, 1)==1) return c; + if (!__toread(f) && f->read(f, &c, 1)==1) return c; return EOF; } --- a/src/stdio/ungetc.c +++ b/src/stdio/ungetc.c @@ -6,7 +6,8 @@ int ungetc(int c, FILE *f) FLOCK(f); - if ((!f->rend && __toread(f)) || f->rpos <= f->buf - UNGET) { + if (!f->rpos) __toread(f); + if (!f->rpos || f->rpos <= f->buf - UNGET) { FUNLOCK(f); return EOF; } --- a/src/stdio/ungetwc.c +++ b/src/stdio/ungetwc.c @@ -19,7 +19,8 @@ wint_t ungetwc(wint_t c, FILE *f) f->mode |= f->mode+1; - if ((!f->rend && __toread(f)) || f->rpos < f->buf - UNGET + l) { + if (!f->rpos) __toread(f); + if (!f->rpos || f->rpos < f->buf - UNGET + l) { FUNLOCK(f); return EOF; } --- a/src/thread/i386/__set_thread_area.s +++ b/src/thread/i386/__set_thread_area.s @@ -6,10 +6,10 @@ __set_thread_area: push $0x51 push $0xfffff push 16(%esp) - xor %edx,%edx - mov %gs,%dx - sub $3,%edx - sar $3,%edx + call 1f +1: addl $4f-1b,(%esp) + pop %ecx + mov (%ecx),%edx push %edx mov %esp,%ebx xor %eax,%eax @@ -18,6 +18,7 @@ __set_thread_area: testl %eax,%eax jnz 2f movl (%esp),%edx + movl %edx,(%ecx) leal 3(,%edx,8),%edx 3: movw %dx,%gs 1: @@ -38,3 +39,7 @@ __set_thread_area: mov $7,%dl inc %al jmp 3b + +.data + .align 4 +4: .long -1 --- a/src/thread/mips/syscall_cp.s +++ b/src/thread/mips/syscall_cp.s @@ -2,10 +2,13 @@ .global __cp_begin .hidden __cp_begin +.type __cp_begin,@function .global __cp_end .hidden __cp_end +.type __cp_end,@function .global __cp_cancel .hidden __cp_cancel +.type __cp_cancel,@function .hidden __cancel .global __syscall_cp_asm .hidden __syscall_cp_asm --- a/src/thread/pthread_create.c +++ b/src/thread/pthread_create.c @@ -67,12 +67,6 @@ _Noreturn void __pthread_exit(void *resu exit(0); } - if (self->locale != &libc.global_locale) { - a_dec(&libc.uselocale_cnt); - if (self->locale->ctype_utf8) - a_dec(&libc.bytelocale_cnt_minus_1); - } - /* Process robust list in userspace to handle non-pshared mutexes * and the detached thread case where the robust list head will * be invalid when the kernel would process it. */