diff options
Diffstat (limited to 'arm-riscos-gnueabi/recipes/patches/gccsdk')
15 files changed, 3433 insertions, 0 deletions
diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/01-relax-abi-matching.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/01-relax-abi-matching.p new file mode 100644 index 0000000..b1dd8cd --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/01-relax-abi-matching.p @@ -0,0 +1,100 @@ +Index: gcc/bfd.config.bfd.pp +=================================================================== +--- gcc/bfd.config.bfd.pp (revision 7698) ++++ gcc/bfd.config.bfd.pp (working copy) +@@ -4,7 +4,7 @@ + targ_defvec=arm_elf32_le_vec + targ_selvecs=arm_elf32_be_vec + ;; +-+ arm-riscos-gnueabihf) +++ arm-riscos-gnueabi*) + + targ_defvec=arm_elf32_le_vec + + targ_selvecs=arm_elf32_be_vec + + targ_cflags=-D__RISCOS_TARGET__ +Index: gcc/configure.ac.p +=================================================================== +--- gcc/configure.ac.p (revision 7698) ++++ gcc/configure.ac.p (working copy) +@@ -13,7 +13,7 @@ + esac + + +case "${target}" in +-+ arm*-*-riscos | *riscos-gnueabihf) +++ arm*-*-riscos | *riscos-gnueabi*) + + ;; + + *) + + noconfigdirs="$noconfigdirs target-libunixlib" +Index: gcc/gas.configure.tgt.pp +=================================================================== +--- gcc/gas.configure.tgt.pp (revision 7698) ++++ gcc/gas.configure.tgt.pp (working copy) +@@ -4,7 +4,7 @@ + arm-*-coff) fmt=coff ;; + arm-*-phoenix*) fmt=elf ;; + arm-*-elf) fmt=elf ;; +-+ arm-riscos-gnueabihf) fmt=elf em=riscos ;; +++ arm-riscos-gnueabi*) fmt=elf em=riscos ;; + arm-*-eabi* | arm-*-rtems*) fmt=elf em=armeabi ;; + arm-*-symbianelf*) fmt=elf em=symbian ;; + arm-*-kaos*) fmt=elf ;; +Index: gcc/gcc.config.gcc.p +=================================================================== +--- gcc/gcc.config.gcc.p (revision 7698) ++++ gcc/gcc.config.gcc.p (working copy) +@@ -13,7 +13,7 @@ + esac + tm_file="${tm_file} arm/aout.h arm/arm.h" + ;; +-+arm*-riscos-gnueabihf) +++arm*-riscos-gnueabi*) + + gas=yes + + gnu_ld=yes + + tm_file="dbxelf.h elfos.h glibc-stdint.h arm/elf.h arm/aout.h arm/arm.h arm/riscos-gnueabihf.h" +Index: gcc/ld.configure.tgt.pp +=================================================================== +--- gcc/ld.configure.tgt.pp (revision 7698) ++++ gcc/ld.configure.tgt.pp (working copy) +@@ -4,7 +4,7 @@ + arm-*-phoenix*) targ_emul=armelf ;; + armeb-*-elf | armeb-*-eabi*) + targ_emul=armelfb ;; +-+arm-riscos-gnueabihf) targ_emul=armelf_riscos_eabi ;; +++arm-riscos-gnueabi*) targ_emul=armelf_riscos_eabi ;; + arm-*-elf | arm*-*-eabi* | arm-*-rtems*) + targ_emul=armelf ;; + arm*-*-symbianelf*) targ_emul=armsymbian;; +Index: gcc/libgcc.config.host.p +=================================================================== +--- gcc/libgcc.config.host.p (revision 7698) ++++ gcc/libgcc.config.host.p (working copy) +@@ -4,7 +4,7 @@ + tmake_file="$tmake_file t-crtstuff-pic t-libgcc-pic t-eh-dw2-dip t-slibgcc t-slibgcc-fuchsia" + extra_parts="crtbegin.o crtend.o" + ;; +-+arm*-riscos-gnueabihf) +++arm*-riscos-gnueabi*) + + tmake_file="$tmake_file t-crtstuff-pic t-libgcc-pic t-eh-dw2-dip t-slibgcc t-slibgcc-gld t-slibgcc-elf-ver t-linux" + + extra_parts="crtbegin.o crtbeginS.o crtbeginT.o crtend.o crtendS.o crti.o crtn.o" + + if test x$enable_vtable_verify = xyes; then +@@ -18,7 +18,7 @@ + ;; + esac + ;; +-+arm*-riscos-gnueabihf) +++arm*-riscos-gnueabi*) + + tmake_file="${tmake_file} arm/t-arm t-fixedpoint-gnu-prefix t-crtfm" + + tmake_file="${tmake_file} arm/t-elf arm/t-bpabi arm/t-linux-eabi t-slibgcc-libgcc t-slibgcc-nolc-override" + + tm_file="$tm_file arm/bpabi-lib.h" +Index: gcc/libstdc++-v3.configure.host.p +=================================================================== +--- gcc/libstdc++-v3.configure.host.p (revision 7698) ++++ gcc/libstdc++-v3.configure.host.p (working copy) +@@ -4,7 +4,7 @@ + linux-musl*) + os_include_dir="os/generic" + ;; +-+ gnueabihf) +++ gnueabi*) + + os_include_dir="os/riscos" + + ;; + gnu* | linux* | kfreebsd*-gnu | uclinux*) diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/elf2aif-eabi-support.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/elf2aif-eabi-support.p new file mode 100644 index 0000000..afac755 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/elf2aif-eabi-support.p @@ -0,0 +1,394 @@ +Index: elf2aif/src/elf2aif.c +=================================================================== +--- elf2aif/src/elf2aif.c (revision 7698) ++++ elf2aif/src/elf2aif.c (working copy) +@@ -54,7 +54,7 @@ + typedef struct + { + uint8_t decompress[4]; /* BL to decompression code for compressed images */ +- uint8_t selfreloc[4]; /* BL to self-relocation code */ ++ uint8_t selfreloc[4]; /* BL to self-relocation code (*) */ + uint8_t zeroinit[4]; /* BL to zero init code */ + uint8_t entrypoint[4]; /* BL to image entry point (*) */ + uint8_t exitinst[4]; /* Exit instruction */ +@@ -72,47 +72,50 @@ + } aifheader_t; + + static int opt_verbose = 0; ++static int opt_eabi = 0; + + static Elf32_External_Ehdr elf_ehdr; + static phdr_list_t *elf_phdrlistP; + static const char *elf_filename; ++static uint32_t got_addr = 0; + +-static const unsigned int aifcode[] = { +- 0xE1A00000, /* NOP (BL decompress) */ +- 0xE1A00000, /* NOP (BL self-relocate) */ +- 0xEB00000C, /* BL zero-init */ +- 0xEB000000, /* BL entrypoint (*) */ +- 0xEF000011, /* SWI OS_Exit */ +- 0x00000000, /* Image R/O size (*) */ +- 0x00000000, /* Image R/W size (*) */ +- 0x00000000, /* Image debug size */ +- 0x00000000, /* Image zero-init size (*) */ +- 0x00000000, /* Image debug type */ +- 0x00000000, /* Image base (*) */ +- 0x00000000, /* Workspace size */ +- 0x00000020, /* 32-bit addressing */ +- 0x00000000, /* Data base */ +- 0x00000000, /* Reserved */ +- 0x00000000, /* Reserved */ +- 0xE1A00000, /* MOV R0, R0 */ +- 0xE04EC00F, /* SUB R12, R14, PC */ +- 0xE08FC00C, /* ADD R12, PC, R12 */ +- 0xE99C0017, /* LDMIB R12, {R0-R2, R4} */ +- 0xE24CC010, /* SUB R12, R12, #0x10 */ +- 0xE08CC000, /* ADD R12, R12, R0 */ +- 0xE08CC001, /* ADD R12, R12, R1 */ +- 0xE3A00000, /* MOV R0, #0 */ +- 0xE3A01000, /* MOV R1, #0 */ +- 0xE3A02000, /* MOV R2, #0 */ +- 0xE3A03000, /* MOV R3, #0 */ +- 0xE3540000, /* CMP R4, #0 */ ++static const uint32_t aifcode[] = { ++ 0xE1A00000, /* NOP (BL decompress) */ ++ 0xE1A00000, /* NOP (BL self-relocate) (*) */ ++ 0xEB00000C, /* BL zero-init */ ++ 0xEB000000, /* BL entrypoint (*) */ ++ 0xEF000011, /* SWI OS_Exit */ ++ 0x00000000, /* Image R/O size (*) */ ++ 0x00000000, /* Image R/W size (*) */ ++ 0x00000000, /* Image debug size */ ++ 0x00000000, /* Image zero-init size (*) */ ++ 0x00000000, /* Image debug type */ ++ 0x00000000, /* Image base (*) */ ++ 0x00000000, /* Workspace size */ ++ 0x00000020, /* 32-bit addressing */ ++ 0x00000000, /* Data base */ ++ 0x00000000, /* Reserved */ ++ 0x00000000, /* Reserved */ ++ 0xE1A00000, /* MOV R0, R0 */ ++ 0xE04EC00F, /* SUB R12, R14, PC */ ++ 0xE08FC00C, /* ADD R12, PC, R12 */ ++ 0xE99C0017, /* LDMIB R12, {R0-R2, R4} */ ++ 0xE24CC010, /* SUB R12, R12, #16 */ ++ 0xE08CC000, /* ADD R12, R12, R0 */ ++ 0xE08CC001, /* ADD R12, R12, R1 */ ++ 0xE3A00000, /* MOV R0, #0 */ ++ 0xE3A01000, /* MOV R1, #0 */ ++ 0xE3A02000, /* MOV R2, #0 */ ++ 0xE3A03000, /* MOV R3, #0 */ ++ 0xE3540000, /* CMP R4, #0 */ + /* zeroloop: */ +- 0xD1A0F00E, /* MOVLE PC, R14 */ +- 0xE8AC000F, /* STMIA R12!, {R0-R3} */ +- 0xE2544010, /* SUBS R4, R4, #16 */ +- 0xEAFFFFFB /* B zeroloop */ ++ 0xD1A0F00E, /* MOVLE PC, R14 */ ++ 0xE8AC000F, /* STMIA R12!, {R0-R3} */ ++ 0xE2544010, /* SUBS R4, R4, #16 */ ++ 0xEAFFFFFB /* B zeroloop */ + }; + ++ + /* Read a little-endian 'short' value. */ + static uint16_t + RdShort (const uint8_t sh[2]) +@@ -143,6 +146,7 @@ + fprintf (stderr, "Usage: elf2aif [options] <ELF file> [<AIF file>]\n" + "Convert static ARM ELF binary to AIF (Acorn Image Format) binary.\n" + "Options:\n" ++ " -e, --eabi source binary uses EABI\n" + " -v, --verbose prints informational messages during processing\n" + " --help display this help and exit\n" + " --version output version information and exit\n"); +@@ -201,7 +205,8 @@ + return EXIT_FAILURE; + } + +- if (elf_ehdr.e_ident[EI_OSABI] != ELFOSABI_ARM) ++ if ((!opt_eabi && elf_ehdr.e_ident[EI_OSABI] != ELFOSABI_ARM) || ++ (opt_eabi && elf_ehdr.e_ident[EI_OSABI] != ELFOSABI_NONE)) + { + fprintf (stderr, "ELF file '%s' is not for ARM\n", elf_filename); + return EXIT_FAILURE; +@@ -344,6 +349,97 @@ + } + + static int ++e2a_readshdr (FILE * elfhandle) ++{ ++ Elf32_External_Shdr shstentry; ++ uint32_t shoffset, shentrysize, shentrycount, shstrndx; ++ uint32_t shstoffset, shstsize; ++ char *shst; ++ ++ if ((shoffset = RdLong (elf_ehdr.e_shoff)) == 0 ++ || (shentrycount = RdShort (elf_ehdr.e_shnum)) == 0) ++ { ++ fprintf (stderr, "ELF file '%s' does not have section headers\n", ++ elf_filename); ++ return EXIT_FAILURE; ++ } ++ ++ if ((shentrysize = RdShort (elf_ehdr.e_shentsize)) < sizeof (Elf32_External_Shdr)) ++ { ++ fprintf (stderr, "Size section header entry is too small\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if ((shstrndx = RdShort (elf_ehdr.e_shstrndx)) >= shentrycount) { ++ fprintf (stderr, "String table index out of bounds\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if (fseek (elfhandle, shoffset + (shstrndx * shentrysize), SEEK_SET) != 0 ++ || fread (&shstentry, sizeof (Elf32_External_Shdr), 1, elfhandle) != 1) ++ { ++ fprintf (stderr, "Failed to read section header string table header\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if ((shstoffset = RdLong (shstentry.sh_offset)) == 0) ++ { ++ fprintf (stderr, "Section header string table data missing\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if ((shstsize = RdLong (shstentry.sh_size)) == 0) ++ { ++ fprintf (stderr, "Invalid section header string table size\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if ((shst = malloc (shstsize)) == NULL) ++ { ++ fprintf (stderr, "Out of memory\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if (fseek (elfhandle, shstoffset, SEEK_SET) != 0 ++ || fread (shst, 1, shstsize, elfhandle) != shstsize) ++ { ++ fprintf (stderr, "Failed to read section header string table\n"); ++ return EXIT_FAILURE; ++ } ++ ++ while (shentrycount) ++ { ++ Elf32_External_Shdr shentry; ++ uint32_t shnameoff; ++ ++ if (fseek (elfhandle, shoffset, SEEK_SET) != 0 ++ || fread (&shentry, sizeof (Elf32_External_Shdr), 1, elfhandle) != 1) ++ { ++ fprintf (stderr, "Failed to read section header entry\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if ((shnameoff = RdLong (shentry.sh_name)) >= shstsize) ++ { ++ fprintf (stderr, "Section name out of bounds\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if (strcmp ((shst + shnameoff), ".got") == 0) ++ { ++ got_addr = RdLong (shentry.sh_addr); ++ } ++ ++ shoffset += shentrysize; ++ --shentrycount; ++ } ++ ++ free (shst); ++ ++ return EXIT_SUCCESS; ++} ++ ++static int + e2a_copy (FILE * elfhandle, FILE * aifhandle) + { + const phdr_list_t *phdrP; +@@ -488,21 +584,156 @@ + } + + memcpy (&aifhdr, aifcode, sizeof (aifcode)); +- WrLong (aifhdr.entrypoint, +- RdLong (aifhdr.entrypoint) + +- ((exec_addr - load_addr - +- (offsetof (aifheader_t, entrypoint) + 8)) >> 2)); ++ if (opt_eabi) ++ { ++ /* BL to relocation code */ ++ WrLong (aifhdr.selfreloc, ++ /* Default is a NOP, so reading it is useless */ ++ 0xEB000000 + ++ ((aifend - (offsetof (aifheader_t, selfreloc) + 8)) >> 2)); ++ ++ /* BL to EABI startcode */ ++ WrLong (aifhdr.entrypoint, ++ RdLong (aifhdr.entrypoint) + ++ ((sizeof(aifcode) - (offsetof (aifheader_t, entrypoint) + 8)) >> 2)); ++ } ++ else ++ { ++ /* BL to program entrypoint */ ++ WrLong (aifhdr.entrypoint, ++ RdLong (aifhdr.entrypoint) + ++ ((exec_addr - load_addr - ++ (offsetof (aifheader_t, entrypoint) + 8)) >> 2)); ++ } + WrLong (aifhdr.rosize, rosize); + WrLong (aifhdr.rwsize, rwsize); + WrLong (aifhdr.zisize, zisize); + WrLong (aifhdr.imagebase, load_addr); +- if (fwrite (&aifhdr, sizeof (aifhdr), 1, aifhandle) != 1 +- || fseek (aifhandle, aifend, SEEK_SET) != 0) ++ if (fwrite (&aifhdr, sizeof (aifhdr), 1, aifhandle) != 1) + { + fprintf (stderr, "Failed to write aif header\n"); + return EXIT_FAILURE; + } + ++ /* In the EABI case we need to inject the code to install ++ * the ARMEABISupport abort handler */ ++ if (opt_eabi) ++ { ++ assert (128 == sizeof (aifcode)); ++ uint32_t entrycode[] = { ++ /* Space for GOTT_BASE injection (see below) */ ++ 0xE1A00000, /* MOV R0, R0 */ ++ 0xE1A00000, /* MOV R0, R0 */ ++ /* Install the abort handler */ ++ 0xE3A00002, /* MOV R0, #2 */ ++ 0xEF059D01, /* SWI ARMEABISupport_AbortOp */ ++ /* Proceed to the real program start */ ++ 0xEA000000, /* B <program_start> (*) */ ++ /* Offset of the GOT relative to the load address (or 0 if none) */ ++ 0x00000000, /* DCD <got_offset> (*) */ ++ }; ++ ++ const uint32_t reloccode[] = { ++ /* RelocCode: */ ++ 0xE1A00000, /* MOV R0, R0 */ ++ /* Dynamically compute the program load address */ ++ 0xE04EC00F, /* SUB R12, LR, PC */ ++ 0xE08FC00C, /* ADD R12, PC, R12 */ ++ 0xE24CC00C, /* SUB R12, R12, #12 */ ++ /* Prevent reentry by replacing the branch to the relocation code. */ ++ 0xE51F0018, /* LDR R0, =RelocCode */ ++ 0xE58C0004, /* STR R0, [R12, #4] */ ++ /* Relocate the GOT offset (above) to its absolute address */ ++ 0xE59C0094, /* LDR R0, [R12, #&94] */ ++ 0xE3300000, /* TEQ R0, #0 */ ++ 0x1080000C, /* ADDNE R0, R0, R12 */ ++ 0x158C0094, /* STRNE R0, [R12, #&94] */ ++ /* Fill in GOTT_BASE at load + 0x38, unless running under DDT */ ++ 0xE59C0038, /* LDR R0, [R12, #&38] */ ++ 0xE3300000, /* TEQ R0, #0 */ ++ 0x1A000002, /* BNE ddt_hack */ ++ 0xE28C0094, /* ADD R0, R12, #&94 */ ++ 0xE58C0038, /* STR R0, [R12, #&38] */ ++ 0xE1A0F00E, /* MOV PC, LR */ ++ /* Hack for DDT (which uses the reserved field at &8038 to ++ * temporarily store the address of the zero-initialisation code ++ * during program start, which is reinstated after DDT's ++ * replacement is called). In this case, modify the entrycode ++ * (above) to inject it for us. ++ * ++ * This does prevent the RO area being marked non-writeable if ++ * the modified entrycode gets executed, however (in the non-DDT ++ * case, the entrycode does not write to the AIF header, so ++ * there is no reason the RO area can't be non-writeable then). ++ * By definition the RO area must be writeable for relocations to ++ * work, so it is perfectly safe to assume that it is when this ++ * code runs. ++ */ ++ /* ddt_hack: */ ++ 0xE59F001C, /* LDR R0, =ddt_hack_data */ ++ 0xE59F101C, /* LDR R1, =ddt_hack_data+4 */ ++ 0xE58C0080, /* STR R0, [R12, #&80] */ ++ 0xE58C1084, /* STR R1, [R12, #&84] */ ++ /* Invalidate instruction cache */ ++ 0xE3A00001, /* MOV R0, #1 */ ++ 0xE28C1080, /* ADD R1, R12, #&80 */ ++ 0xE28C2088, /* ADD R2, R12, #&88 */ ++ 0xEF02006E, /* SWI XOSSynchroniseCodeAreas */ ++ 0xE1A0F00E, /* MOV PC, LR */ ++ /* Instructions to inject into entrycode. Uses PC-relative ++ * addressing, so must be kept in sync with changes to entrycode ++ * or the location of entrycode within memory. */ ++ /* ddt_hack_data: */ ++ /* Compute address of GOT field after entrycode */ ++ 0xE28F000C, /* ADR R0, got_address */ ++ /* Store computed address in GOTT_BASE (load + 0x38) */ ++ 0xE50F0054, /* STR R0, [pc, #-&54] */ ++ /* Relocation sentinel: just in case anything expects one */ ++ 0xFFFFFFFF, /* DCD -1 */ ++ }; ++ ++ /* Ensure there is sufficient space for the EABI entry code */ ++ if (opt_eabi && exec_addr - load_addr < sizeof (aifcode) + sizeof (entrycode)) ++ { ++ fprintf (stderr, "First program segment is not what we hoped to be " ++ "(not enough place before _start symbol for EABI entrycode)\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if (opt_verbose) ++ printf ("Writing EABI entry code at offset 0x%x\n", sizeof (aifcode)); ++ ++ entrycode[4] |= (exec_addr - load_addr - (sizeof (aifcode) + 4*4 + 8)) >> 2; ++ if (got_addr) ++ { ++ if (opt_verbose) ++ printf ("Found GOT at 0x%x\n", got_addr); ++ entrycode[5] = (got_addr - load_addr); ++ } ++ if (fseek (aifhandle, sizeof (aifcode), SEEK_SET) != 0 ++ || fwrite (&entrycode, sizeof (entrycode), 1, aifhandle) != 1) ++ { ++ fprintf (stderr, "Failed to write EABI entrycode\n"); ++ return EXIT_FAILURE; ++ } ++ ++ if (opt_verbose) ++ printf ("Writing relocation code at offset 0x%x\n", aifend); ++ ++ if (fseek (aifhandle, aifend, SEEK_SET) != 0 ++ || fwrite (&reloccode, sizeof (reloccode), 1, aifhandle) != 1) ++ { ++ fprintf (stderr, "Failed to write relocation code\n"); ++ return EXIT_FAILURE; ++ } ++ } ++ ++ if (fseek (aifhandle, aifend, SEEK_SET) != 0) ++ { ++ fprintf (stderr, "Failed to seek to end of file\n"); ++ return EXIT_FAILURE; ++ } ++ + return EXIT_SUCCESS; + } + +@@ -557,6 +788,7 @@ + elf_filename = elffilename; + + if (e2a_readehdr (elfhandle) == EXIT_SUCCESS ++ && e2a_readshdr (elfhandle) == EXIT_SUCCESS + && e2a_readphdr (elfhandle) == EXIT_SUCCESS + && e2a_copy (elfhandle, aifhandle) == EXIT_SUCCESS) + status = EXIT_SUCCESS; +@@ -683,6 +915,9 @@ + fprintf (stderr, "Warning: extra options/arguments ignored\n"); + return EXIT_SUCCESS; + } ++ else if (!strcmp (&argv[i][1], "-eabi") ++ || !strcmp (&argv[i][1], "e")) ++ opt_eabi = 1; + else if (!strcmp (&argv[i][1], "-verbose") + || !strcmp (&argv[i][1], "v")) + ++opt_verbose; diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-add-mhalfword-access.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-add-mhalfword-access.p new file mode 100644 index 0000000..43061b9 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-add-mhalfword-access.p @@ -0,0 +1,153 @@ +Index: gcc/gcc.config.arm.arm.h.p +=================================================================== +--- gcc/gcc.config.arm.arm.h.p (nonexistent) ++++ gcc/gcc.config.arm.arm.h.p (working copy) +@@ -0,0 +1,33 @@ ++--- gcc/config/arm/arm.h.orig 2020-07-23 07:35:17.344384552 +0100 +++++ gcc/config/arm/arm.h 2022-05-28 22:48:25.064918314 +0100 ++@@ -1338,7 +1338,9 @@ ++ : (TARGET_IWMMXT && (CLASS) == IWMMXT_REGS) \ ++ ? coproc_secondary_reload_class (MODE, X, TRUE) \ ++ : TARGET_32BIT \ ++- ? (((MODE) == HImode && ! arm_arch4 && true_regnum (X) == -1) \ +++ ? (((MODE) == HImode && \ +++ (!arm_arch4 || !halfword_access) && \ +++ true_regnum (X) == -1) \ ++ ? GENERAL_REGS : NO_REGS) \ ++ : THUMB_SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X)) ++ ++@@ -1353,7 +1355,7 @@ ++ (((CLASS) == IWMMXT_REGS || (CLASS) == IWMMXT_GR_REGS) \ ++ && CONSTANT_P (X)) \ ++ ? GENERAL_REGS : \ ++- (((MODE) == HImode && ! arm_arch4 \ +++ (((MODE) == HImode && (!arm_arch4 || !halfword_access) \ ++ && (MEM_P (X) \ ++ || ((REG_P (X) || GET_CODE (X) == SUBREG) \ ++ && true_regnum (X) == -1))) \ ++@@ -2016,7 +2018,9 @@ ++ done, UNKNOWN if none. */ ++ #define LOAD_EXTEND_OP(MODE) \ ++ (TARGET_THUMB ? ZERO_EXTEND : \ ++- ((arm_arch4 || (MODE) == QImode) ? ZERO_EXTEND \ +++ (((arm_arch4 && (halfword_access || (MODE) != HImode)) || \ +++ (MODE) == QImode) \ +++ ? ZERO_EXTEND \ ++ : ((BYTES_BIG_ENDIAN && (MODE) == HImode) ? SIGN_EXTEND : UNKNOWN))) ++ ++ /* Nonzero if access to memory by bytes is slow and undesirable. */ +Index: gcc/gcc.config.arm.arm.md.p +=================================================================== +--- gcc/gcc.config.arm.arm.md.p (revision 7698) ++++ gcc/gcc.config.arm.arm.md.p (working copy) +@@ -8,6 +8,42 @@ + (IP_REGNUM 12) ; Scratch register + (SP_REGNUM 13) ; Stack pointer + (LR_REGNUM 14) ; Return address register ++@@ -5546,7 +5547,7 @@ ++ (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand")))] ++ "TARGET_EITHER" ++ { ++- if (TARGET_ARM && !arm_arch4 && MEM_P (operands[1])) +++ if (TARGET_ARM && (!arm_arch4 || !halfword_access) && MEM_P (operands[1])) ++ { ++ emit_insn (gen_movhi_bytes (operands[0], operands[1])); ++ DONE; ++@@ -5574,7 +5575,7 @@ ++ (define_insn "*arm_zero_extendhisi2" ++ [(set (match_operand:SI 0 "s_register_operand" "=r,r") ++ (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,m")))] ++- "TARGET_ARM && arm_arch4 && !arm_arch6" +++ "TARGET_ARM && arm_arch4 && halfword_access && !arm_arch6" ++ "@ ++ # ++ ldrh%?\\t%0, %1" ++@@ -5735,7 +5736,7 @@ ++ emit_insn (gen_thumb1_extendhisi2 (operands[0], operands[1])); ++ DONE; ++ } ++- if (MEM_P (operands[1]) && TARGET_ARM && !arm_arch4) +++ if (MEM_P (operands[1]) && TARGET_ARM && (!arm_arch4 || !halfword_access)) ++ { ++ emit_insn (gen_extendhisi2_mem (operands[0], operands[1])); ++ DONE; ++@@ -5813,7 +5814,7 @@ ++ (define_insn "*arm_extendhisi2" ++ [(set (match_operand:SI 0 "s_register_operand" "=r,r") ++ (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,Uh")))] ++- "TARGET_ARM && arm_arch4 && !arm_arch6" +++ "TARGET_ARM && arm_arch4 && halfword_access && !arm_arch6" ++ "@ ++ # ++ ldrsh%?\\t%0, %1" + @@ -6693,7 +6694,7 @@ + (mem:SI (plus:SI (match_operand:SI 1 "register_operand" "r") + (unspec:SI [(match_operand:SI 2 "" "X")] +@@ -17,3 +53,49 @@ + "ldr%?\\t%0, [%1,%2]" + [(set_attr "type" "load_4")] + ) ++@@ -6845,7 +6846,7 @@ ++ (define_expand "storehi_single_op" ++ [(set (match_operand:HI 0 "memory_operand") ++ (match_operand:HI 1 "general_operand"))] ++- "TARGET_32BIT && arm_arch4" +++ "TARGET_32BIT && arm_arch4 && halfword_access" ++ " ++ if (!s_register_operand (operands[1], HImode)) ++ operands[1] = copy_to_mode_reg (HImode, operands[1]); ++@@ -6865,7 +6865,7 @@ ++ { ++ if (MEM_P (operands[0])) ++ { ++- if (arm_arch4) +++ if (arm_arch4 && halfword_access) ++ { ++ emit_insn (gen_storehi_single_op (operands[0], operands[1])); ++ DONE; ++@@ -6905,15 +6905,15 @@ ++ emit_insn (gen_movsi (reg, GEN_INT (val))); ++ operands[1] = gen_lowpart (HImode, reg); ++ } ++- else if (arm_arch4 && optimize && can_create_pseudo_p () ++- && MEM_P (operands[1])) +++ else if (arm_arch4 && halfword_access && optimize +++ && can_create_pseudo_p () && MEM_P (operands[1])) ++ { ++ rtx reg = gen_reg_rtx (SImode); ++ ++ emit_insn (gen_zero_extendhisi2 (reg, operands[1])); ++ operands[1] = gen_lowpart (HImode, reg); ++ } ++- else if (!arm_arch4) +++ else if (!arm_arch4 || !halfword_access) ++ { ++ if (MEM_P (operands[1])) ++ { ++@@ -7099,7 +7100,7 @@ ++ [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,m,r") ++ (match_operand:HI 1 "general_operand" "rIk,K,n,r,mi"))] ++ "TARGET_ARM ++- && arm_arch4 && !TARGET_HARD_FLOAT +++ && arm_arch4 && halfword_access && !TARGET_HARD_FLOAT ++ && (register_operand (operands[0], HImode) ++ || register_operand (operands[1], HImode))" ++ "@ +Index: gcc/gcc.config.arm.arm.opt.p +=================================================================== +--- gcc/gcc.config.arm.arm.opt.p (nonexistent) ++++ gcc/gcc.config.arm.arm.opt.p (working copy) +@@ -0,0 +1,13 @@ ++--- gcc/config/arm/arm.opt.orig 2020-07-23 07:35:17.344384552 +0100 +++++ gcc/config/arm/arm.opt 2022-05-28 22:39:28.543576700 +0100 ++@@ -271,6 +271,10 @@ ++ Avoid overlapping destination and address registers on LDRD instructions ++ that may trigger Cortex-M3 errata. ++ +++mhalfword-access +++Target Report Var(halfword_access) Init(1) +++Enable halfword memory accesses. +++ ++ munaligned-access ++ Target Report Var(unaligned_access) Init(2) Save ++ Enable unaligned word and halfword accesses to packed data. diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-default-no-halfword-access.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-default-no-halfword-access.p new file mode 100644 index 0000000..400341f --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-default-no-halfword-access.p @@ -0,0 +1,13 @@ +Index: gcc/gcc.config.arm.arm.opt.p +=================================================================== +--- gcc/gcc.config.arm.arm.opt.p (nonexistent) ++++ gcc/gcc.config.arm.arm.opt.p (working copy) +@@ -5,7 +5,7 @@ + that may trigger Cortex-M3 errata. + + +mhalfword-access +-+Target Report Var(halfword_access) Init(1) +++Target Report Var(halfword_access) Init(0) + +Enable halfword memory accesses. + + + munaligned-access diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-libgcc-no-linux-atomics.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-libgcc-no-linux-atomics.p new file mode 100644 index 0000000..5f93dbe --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/gcc-libgcc-no-linux-atomics.p @@ -0,0 +1,56 @@ +Index: gcc/libgcc.config.arm.t-riscos-gnueabihf +=================================================================== +--- gcc/libgcc.config.arm.t-riscos-gnueabihf (revision 7698) ++++ gcc/libgcc.config.arm.t-riscos-gnueabihf (working copy) +@@ -1,36 +1,2 @@ +-# Copyright (C) 2011-2012 Free Software Foundation, Inc. +-# Contributed by John Tytgat (John.Tytgat@aaug.net). +-# +-# This file is part of GCC. +-# +-# GCC is free software; you can redistribute it and/or modify +-# it under the terms of the GNU General Public License as published by +-# the Free Software Foundation; either version 3, or (at your option) +-# any later version. +-# +-# GCC 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 General Public License for more details. +-# +-# You should have received a copy of the GNU General Public License +-# along with GCC; see the file COPYING3. If not see +-# <http://www.gnu.org/licenses/>. +- +-# vvv Part of config/arm/t-bpabi +-LIB2ADD_ST += $(srcdir)/config/arm/fp16.c +- +-LIB2ADDEH = $(srcdir)/config/arm/unwind-arm.c \ +- $(srcdir)/config/arm/libunwind.S \ +- $(srcdir)/config/arm/pr-support.c $(srcdir)/unwind-c.c +-# ^^^ +- +-ifeq (,$(findstring mlibscl,$(CFLAGS))$(findstring mmodule,$(CFLAGS))) +-# For shared libgcc building: +-EXTRA_PARTS += crtbeginS.o crtendS.o +-gcc_s_compile += -fPIC +-SHLIB_LDFLAGS=-fPIC +-include $(srcdir)/config/t-slibgcc +-include $(srcdir)/config/t-slibgcc-nolc-override +-endif +- ++# Use a version of div0 which raises SIGFPE, and a special __clear_cache. ++LIB1ASMFUNCS := $(filter-out _dvmd_tls,$(LIB1ASMFUNCS)) _dvmd_lnx _clear_cache +Index: gcc/libgcc.config.host.p +=================================================================== +--- gcc/libgcc.config.host.p (revision 7698) ++++ gcc/libgcc.config.host.p (working copy) +@@ -20,7 +20,7 @@ + ;; + +arm*-riscos-gnueabi*) + + tmake_file="${tmake_file} arm/t-arm t-fixedpoint-gnu-prefix t-crtfm" +-+ tmake_file="${tmake_file} arm/t-elf arm/t-bpabi arm/t-linux-eabi t-slibgcc-libgcc t-slibgcc-nolc-override" +++ tmake_file="${tmake_file} arm/t-elf arm/t-bpabi arm/t-riscos-gnueabihf t-slibgcc-libgcc t-slibgcc-nolc-override" + + tm_file="$tm_file arm/bpabi-lib.h" + + unwind_header=config/arm/unwind-arm.h + + tmake_file="$tmake_file t-softfp-sfdf t-softfp-excl arm/t-softfp t-softfp" diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/ld-armv4.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/ld-armv4.p new file mode 100644 index 0000000..ae85eb0 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/ld-armv4.p @@ -0,0 +1,13 @@ +Index: ld/d-link/Makefile.am +=================================================================== +--- ld/d-link/Makefile.am (revision 7698) ++++ ld/d-link/Makefile.am (working copy) +@@ -68,7 +68,7 @@ + + ld_riscos_eabihf_so_CPPFLAGS = -I$(top_srcdir)/d-link -I$(top_srcdir)/d-link/riscos \ + -DNO_UNDERSCORE -DVERBOSE_DLINKER -D__TARGET_SOLOADER__ +-ld_riscos_eabihf_so_CFLAGS = -fPIC -O4 -Wall -std=gnu99 -march=armv7-a+fp+neon ++ld_riscos_eabihf_so_CFLAGS = -fPIC -O4 -Wall -std=gnu99 -march=armv4 + ld_riscos_eabihf_so_LDFLAGS = --shared -Wl,--no-undefined -nostdlib -nostartfiles -Wl,-e -Wl,_dl_start \ + -Wl,-soname -Wl,ld-riscos/so/2 + diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/libtool.m4.p.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/libtool.m4.p.p new file mode 100644 index 0000000..8061b92 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/libtool.m4.p.p @@ -0,0 +1,119 @@ +Index: gcc/libtool.m4.p +=================================================================== +--- gcc/libtool.m4.p (revision 7698) ++++ gcc/libtool.m4.p (working copy) +@@ -5,7 +5,7 @@ + ]) + ;; + + +-+ *riscos | *linux-gnueabihf) +++ *riscos*) + + lt_cv_dlopen="dlopen" + + lt_cv_dlopen_libs="-ldl" + + lt_cv_dlopen_self=yes +@@ -17,7 +17,7 @@ + shlibpath_var=LD_LIBRARY_PATH + ;; + +-+*riscos | linux-gnueabihf) +++*riscos*) + + version_type=linux + + library_names_spec='${libname}$versuffix.so ${libname}.so$major $libname.so' + + soname_spec='${libname}.so$major' +@@ -32,7 +32,7 @@ + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; +-+ *linux-gnueabihf) +++ riscos-gnu*) + + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' +@@ -48,7 +48,7 @@ + esac + else + case $host_os in +-+ linux-gnueabihf) +++ riscos-gnu*) + + # RISC OS + + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' +@@ -61,7 +61,7 @@ + ;; + vxworks*) + ;; +-+ *linux-gnueabihf) +++ riscos-gnu*) + + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' +@@ -78,13 +78,13 @@ + fi + ;; + +-+ *linux-gnueabihf) +++ riscos-gnu*) + + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + + ;; + + +-+ *riscos | linux-gnueabihf) +++ *riscos*) + + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' +@@ -97,7 +97,7 @@ + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in +-+ linux-gnueabihf) +++ riscos-gnu*) + + # RISC OS + + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' +@@ -110,7 +110,7 @@ + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + +-+ *linux-gnueabihf) +++ riscos-gnu*) + + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' +@@ -129,7 +129,7 @@ + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in +-+ linux-gnueabihf) +++ riscos-gnu*) + + # RISC OS + + _LT_TAGVAR(ld_shlibs, $1)=yes + + ;; +@@ -140,7 +140,7 @@ + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + +-+ *riscos | *linux-gnueabihf) +++ *riscos*) + + _LT_TAGVAR(ld_shlibs, $1)=yes + + ;; + + +@@ -151,7 +151,7 @@ + AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) + _LT_TAGVAR(ld_shlibs, $1)=yes + case $host_os in +-+ linux-gnueabihf) +++ riscos-gnu*) + + # RISC OS + + _LT_TAGVAR(ld_shlibs, $1)=yes + + ;; +@@ -162,7 +162,7 @@ + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + +-+ *riscos | *linux-gnueabihf) +++ *riscos*) + + _LT_TAGVAR(ld_shlibs, $1)=yes + + ;; + + diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/posix-extended-locale.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/posix-extended-locale.p new file mode 100644 index 0000000..e422786 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/posix-extended-locale.p @@ -0,0 +1,1920 @@ +Index: libunixlib/Makefile.am +=================================================================== +--- libunixlib/Makefile.am (revision 7698) ++++ libunixlib/Makefile.am (working copy) +@@ -583,11 +583,11 @@ + else + locale_src = \ + locale/localeconv.c \ ++ locale/newlocale.c \ + locale/nl_langinfo.c \ + locale/setlocale.c \ + locale/strcoll.c \ +- locale/strxfrm.c \ +- locale/territory.c ++ locale/strxfrm.c + endif + locale_src += \ + locale/iconv.c +@@ -1312,6 +1312,7 @@ + bits/in.h \ + bits/libc-lock.h \ + bits/locale.h \ ++ bits/locale_t.h \ + bits/mathcalls.h \ + bits/mathdef.h \ + bits/mathinline.h \ +Index: libunixlib/ctype/ctypetable.c +=================================================================== +--- libunixlib/ctype/ctypetable.c (revision 7698) ++++ libunixlib/ctype/ctypetable.c (working copy) +@@ -10,36 +10,35 @@ + #include <internal/os.h> + #include <internal/unix.h> + +-/* Note the offset 1 and depth 257 instead of 0 and 256: ISO C says we must +- support EOF. */ +-static unsigned char ctype[257]; +-const unsigned char * const __ctype = &ctype[1]; ++/* Global containing current locale settings. */ ++struct _locale __locale_global; ++/* Offset 1 as the first entry is reserved for EOF. */ ++const unsigned char * const __ctype = &__locale_global.ctype[1]; ++const short * const __ctype_upper = &__locale_global.ctype_upper[1]; ++const short * const __ctype_lower = &__locale_global.ctype_lower[1]; + +-static short ctype_upper[257]; +-const short * const __ctype_upper = &ctype_upper[1]; +- +-static short ctype_lower[257]; +-const short * const __ctype_lower = &ctype_lower[1]; +- + void +-__build_ctype_tables (int territory) ++__build_ctype_tables (locale_t locobj, int territory) + { + PTHREAD_UNSAFE + + if (territory == -2) + { +- /* Initialise the array. This is only done by __unixinit(). */ ++ /* Initialise the array. This is only done by __unixinit()/newlocale(). */ + territory = -1; +- for (int x = 0; x <= LC_ALL; x++) +- __locale_territory[x] = -1; ++ for (int x = 0; x < LC_ALL; x++) ++ locobj->locale_territory[x] = -1; ++ __localeconv_lconv_init(&locobj->lc); ++ locobj->lc_needs_refresh = 1; + } + + /* Initialise ctype_upper/ctype_lower tables. */ + for (int x = 0; x < 257; x++) + { +- /* In the C/POSIX locate, tolower(top bit set char) ++ /* In the C/POSIX locale, tolower(top bit set char) + should return the character unchanged. */ +- ctype_lower[x] = ctype_upper[x] = x - 1; ++ locobj->ctype_lower[x] = locobj->ctype_upper[x] = x - 1; ++ locobj->ctype[x] = 0; + } + + int regs[10]; +@@ -61,7 +60,7 @@ + for (int offset = 1; bits; bits = bits >> 1, offset += 1) + { + if (bits & 1) +- ctype[pos + offset] |= 1 << code; ++ locobj->ctype[pos + offset] |= 1 << code; + } + pos += 32; + } +@@ -80,7 +79,7 @@ + int y = (territory == -1) ? 128 : 256; + for (int x = 1; x <= y; x++) + { +- ctype_lower[x] = (short)*p++; +- ctype_upper[x] = (short)*q++; ++ locobj->ctype_lower[x] = (short)*p++; ++ locobj->ctype_upper[x] = (short)*q++; + } + } +Index: libunixlib/ctype/isalnum.c +=================================================================== +--- libunixlib/ctype/isalnum.c (revision 7698) ++++ libunixlib/ctype/isalnum.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isalnum) (int c) +@@ -10,3 +11,8 @@ + return isalnum (c); + } + ++int ++isalnum_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & (___ctype_alpha | ___ctype_digit)); ++} +Index: libunixlib/ctype/isalpha.c +=================================================================== +--- libunixlib/ctype/isalpha.c (revision 7698) ++++ libunixlib/ctype/isalpha.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isalpha) (int c) +@@ -10,3 +11,8 @@ + return isalpha (c); + } + ++int ++isalpha_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_alpha); ++} +Index: libunixlib/ctype/isascii.c +=================================================================== +--- libunixlib/ctype/isascii.c (revision 7698) ++++ libunixlib/ctype/isascii.c (working copy) +@@ -10,3 +10,9 @@ + return isascii (c); + } + ++int ++isascii_l (int c, locale_t locobj) ++{ ++ (void) locobj; ++ return isascii (c); ++} +Index: libunixlib/ctype/isblank.c +=================================================================== +--- libunixlib/ctype/isblank.c (revision 7698) ++++ libunixlib/ctype/isblank.c (working copy) +@@ -9,3 +9,10 @@ + { + return isblank (c); + } ++ ++int ++isblank_l (int c, locale_t locobj) ++{ ++ (void) locobj; ++ return isblank (c); ++} +Index: libunixlib/ctype/iscntrl.c +=================================================================== +--- libunixlib/ctype/iscntrl.c (revision 7698) ++++ libunixlib/ctype/iscntrl.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (iscntrl) (int c) +@@ -10,3 +11,8 @@ + return iscntrl (c); + } + ++int ++iscntrl_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_ctrl); ++} +Index: libunixlib/ctype/isdigit.c +=================================================================== +--- libunixlib/ctype/isdigit.c (revision 7698) ++++ libunixlib/ctype/isdigit.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isdigit) (int c) +@@ -10,3 +11,8 @@ + return isdigit (c); + } + ++int ++isdigit_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_digit); ++} +Index: libunixlib/ctype/isgraph.c +=================================================================== +--- libunixlib/ctype/isgraph.c (revision 7698) ++++ libunixlib/ctype/isgraph.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isgraph) (int c) +@@ -10,3 +11,8 @@ + return isgraph (c); + } + ++int ++isgraph_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ~(___ctype_white | ___ctype_ctrl)); ++} +Index: libunixlib/ctype/islower.c +=================================================================== +--- libunixlib/ctype/islower.c (revision 7698) ++++ libunixlib/ctype/islower.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (islower) (int c) +@@ -10,3 +11,8 @@ + return islower (c); + } + ++int ++islower_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_lower); ++} +Index: libunixlib/ctype/isprint.c +=================================================================== +--- libunixlib/ctype/isprint.c (revision 7698) ++++ libunixlib/ctype/isprint.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isprint) (int c) +@@ -10,3 +11,10 @@ + return isprint (c); + } + ++int ++isprint_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ++ (___ctype_upper | ___ctype_lower | ___ctype_digit | ___ctype_punc | ++ ___ctype_white)) && !((&locobj->ctype[1])[c] & ___ctype_ctrl); ++} +Index: libunixlib/ctype/ispunct.c +=================================================================== +--- libunixlib/ctype/ispunct.c (revision 7698) ++++ libunixlib/ctype/ispunct.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (ispunct) (int c) +@@ -10,3 +11,8 @@ + return ispunct (c); + } + ++int ++ispunct_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_punc); ++} +Index: libunixlib/ctype/isspace.c +=================================================================== +--- libunixlib/ctype/isspace.c (revision 7698) ++++ libunixlib/ctype/isspace.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isspace) (int c) +@@ -10,3 +11,8 @@ + return isspace (c); + } + ++int ++isspace_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_white); ++} +Index: libunixlib/ctype/isupper.c +=================================================================== +--- libunixlib/ctype/isupper.c (revision 7698) ++++ libunixlib/ctype/isupper.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isupper) (int c) +@@ -10,3 +11,8 @@ + return isupper (c); + } + ++int ++isupper_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_upper); ++} +Index: libunixlib/ctype/isxdigit.c +=================================================================== +--- libunixlib/ctype/isxdigit.c (revision 7698) ++++ libunixlib/ctype/isxdigit.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (isxdigit) (int c) +@@ -10,3 +11,8 @@ + return isxdigit (c); + } + ++int ++isxdigit_l (int c, locale_t locobj) ++{ ++ return ((&locobj->ctype[1])[c] & ___ctype_xdigit); ++} +Index: libunixlib/ctype/toascii.c +=================================================================== +--- libunixlib/ctype/toascii.c (revision 7698) ++++ libunixlib/ctype/toascii.c (working copy) +@@ -10,3 +10,9 @@ + return toascii (c); + } + ++int ++toascii_l (int c, locale_t locobj) ++{ ++ (void) locobj; ++ return toascii (c); ++} +Index: libunixlib/ctype/tolower.c +=================================================================== +--- libunixlib/ctype/tolower.c (revision 7698) ++++ libunixlib/ctype/tolower.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (tolower) (int c) +@@ -10,3 +11,8 @@ + return tolower (c); + } + ++int ++tolower_l (int c, locale_t locobj) ++{ ++ return (&locobj->ctype_lower[1])[c]; ++} +Index: libunixlib/ctype/toupper.c +=================================================================== +--- libunixlib/ctype/toupper.c (revision 7698) ++++ libunixlib/ctype/toupper.c (working copy) +@@ -3,6 +3,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + + int + (toupper) (int c) +@@ -10,3 +11,8 @@ + return toupper (c); + } + ++int ++toupper_l (int c, locale_t locobj) ++{ ++ return (&locobj->ctype_upper[1])[c]; ++} +Index: libunixlib/incl-local/locale.h +=================================================================== +--- libunixlib/incl-local/locale.h (revision 7698) ++++ libunixlib/incl-local/locale.h (working copy) +@@ -13,15 +13,36 @@ + + #ifndef __TARGET_SCL__ + +-/* Territory number for each locale. C locale is -1. */ +-extern int __locale_territory[LC_ALL + 1]; ++struct _locale { ++ /* Map from locale category to territory number. C locale is -1. */ ++ int locale_territory[LC_ALL]; + +-/* Set to 1 is setlocale has been called since the last call to +- localeconv. localeconv uses this flag to cache the lconv structure. */ +-extern int __setlocale_called; ++ /* Character type LUTs: EOF + one entry per character ++ * ++ * EOF is defined as -1, so character entries start at offset 1. ++ */ ++ short ctype_upper[257]; ++ short ctype_lower[257]; ++ unsigned char ctype[257]; + +-extern void __build_ctype_tables (int __territory) __THROW; ++ /* Set to 1 if the locale information has changed since the last time ++ * the lconv structure was updated. */ ++ int lc_needs_refresh; ++ /* Numeric formatting information for locale */ ++ struct lconv lc; ++}; + ++extern struct _locale __locale_global; ++ ++extern void __build_ctype_tables (locale_t locobj, int __territory) __THROW; ++ ++extern char *__setlocale_l (locale_t locobj, int __category, ++ const char *__locale) __THROW; ++ ++void __localeconv_lconv_init (struct lconv *lc); ++void __localeconv_lconv_fini (struct lconv *lc); ++void __localeconv_l (locale_t locobj); ++ + #endif + + __END_DECLS +Index: libunixlib/include/bits/locale_t.h +=================================================================== +--- libunixlib/include/bits/locale_t.h (nonexistent) ++++ libunixlib/include/bits/locale_t.h (working copy) +@@ -0,0 +1,10 @@ ++/* ++ * Copyright (c) 2022 UnixLib Developers ++ */ ++ ++#ifndef _BITS_LOCALE_T_H_ ++#define _BITS_LOCALE_T_H_ ++ ++typedef struct _locale *locale_t; ++ ++#endif +Index: libunixlib/include/ctype.h +=================================================================== +--- libunixlib/include/ctype.h (revision 7698) ++++ libunixlib/include/ctype.h (working copy) +@@ -51,6 +51,48 @@ + extern int isblank (int __c) __THROW; + + #ifndef __TARGET_SCL__ ++# ifdef __USE_XOPEN2K8 ++# include <bits/locale_t.h> ++ ++/* c is alphabetic or numeric. */ ++extern int isalnum_l (int __c, locale_t locobj) __THROW; ++ ++/* c is alphabetic. */ ++extern int isalpha_l (int __c, locale_t locobj) __THROW; ++ ++/* c is a control character. */ ++extern int iscntrl_l (int __c, locale_t locobj) __THROW; ++ ++/* c is a decimal digit. */ ++extern int isdigit_l (int __c, locale_t locobj) __THROW; ++ ++/* c is any printable character other than a space. */ ++extern int isgraph_l (int __c, locale_t locobj) __THROW; ++ ++/* c is a lower-case letter. */ ++extern int islower_l (int __c, locale_t locobj) __THROW; ++ ++/* c is an upper-case letter. */ ++extern int isupper_l (int __c, locale_t locobj) __THROW; ++ ++/* c is a printable character. */ ++extern int isprint_l (int __c, locale_t locobj) __THROW; ++ ++/* c is a printable character other than a space or a ++ alphanumeric character. */ ++extern int ispunct_l (int __c, locale_t locobj) __THROW; ++ ++/* c is a white space character e.g. space, newline, tab, linefeed, ++ return, vertical tab. */ ++extern int isspace_l (int __c, locale_t locobj) __THROW; ++ ++/* c is a hex digit. */ ++extern int isxdigit_l (int __c, locale_t locobj) __THROW; ++ ++/* c is tab or space. */ ++extern int isblank_l (int __c, locale_t locobj) __THROW; ++# endif ++ + /* Characteristics. */ + extern const unsigned char * const __ctype; + /* Lower case table. */ +@@ -108,6 +150,10 @@ + extern int toupper (int __c) __THROW; + #ifndef __TARGET_SCL__ + # define toupper(c) ((int) __ctype_upper[(int) (c)]) ++ ++# ifdef __USE_XOPEN2K8 ++extern int toupper_l (int __c, locale_t locobj) __THROW; ++# endif + #endif + + /* Convert c to lower case. */ +@@ -114,6 +160,10 @@ + extern int tolower (int __c) __THROW; + #ifndef __TARGET_SCL__ + # define tolower(c) ((int) __ctype_lower[(int) (c)]) ++ ++# ifdef __USE_XOPEN2K8 ++extern int tolower_l (int __c, locale_t locobj) __THROW; ++# endif + #endif + + #ifndef __TARGET_SCL__ +@@ -135,6 +185,11 @@ + /* Is c an ASCII character. */ + extern int isascii (int __c) __THROW; + # define isascii(c) ((unsigned)(c) <= 0x7f) ++ ++# ifdef __USE_XOPEN2K8 ++extern int toascii_l (int __c, locale_t locobj) __THROW; ++extern int isascii_l (int __c, locale_t locobj) __THROW; ++# endif + # endif + #endif + +Index: libunixlib/include/langinfo.h +=================================================================== +--- libunixlib/include/langinfo.h (revision 7698) ++++ libunixlib/include/langinfo.h (working copy) +@@ -580,18 +580,12 @@ + extern char *nl_langinfo (nl_item __item) __THROW; + + +-#if 0 +-#ifdef __USE_GNU +-/* This interface is for the extended locale model. See <locale.h> for +- more information. */ ++#ifdef __USE_XOPEN2K8 ++# include <bits/locale_t.h> + +-/* Get locale datatype definition. */ +-# include <xlocale.h> +- + /* Just like nl_langinfo but get the information from the locale object L. */ +-extern char *nl_langinfo_l (nl_item __item, __locale_t l); ++extern char *nl_langinfo_l (nl_item __item, locale_t __l); + #endif +-#endif + + __END_DECLS + +Index: libunixlib/include/locale.h +=================================================================== +--- libunixlib/include/locale.h (revision 7698) ++++ libunixlib/include/locale.h (working copy) +@@ -33,16 +33,16 @@ + /* Entire locale. */ + # define LC_ALL 6 + +-#define LC_COLLATE_MASK (1L << 1) +-#define LC_CTYPE_MASK (1L << 2) +-#define LC_MESSAGES_MASK (1L << 3) +-#define LC_MONETARY_MASK (1L << 4) +-#define LC_NUMERIC_MASK (1L << 5) +-#define LC_TIME_MASK (1L << 6) +-#define LC_ALL_MASK (LC_COLLATE_MASK | LC_CTYPE_MASK | LC_MESSAGES_MASK | LC_MONETARY_MASK | LC_NUMERIC_MASK | LC_TIME_MASK) ++# ifdef __USE_XOPEN2K8 ++# define LC_COLLATE_MASK (1L << 0) ++# define LC_CTYPE_MASK (1L << 1) ++# define LC_MESSAGES_MASK (1L << 2) ++# define LC_MONETARY_MASK (1L << 3) ++# define LC_NUMERIC_MASK (1L << 4) ++# define LC_TIME_MASK (1L << 5) ++# define LC_ALL_MASK (LC_COLLATE_MASK | LC_CTYPE_MASK | LC_MESSAGES_MASK | LC_MONETARY_MASK | LC_NUMERIC_MASK | LC_TIME_MASK) ++# endif + +-typedef struct _locale *locale_t; +- + #else + /* String collation (functions 'strcoll' and 'strxfrm'). */ + # define LC_COLLATE 1 +@@ -121,6 +121,9 @@ + extern struct lconv *localeconv (void) __THROW; + + #ifndef __TARGET_SCL__ ++# ifdef __USE_XOPEN2K8 ++# include <bits/locale_t.h> ++ + extern locale_t uselocale(locale_t newloc); + + extern void freelocale(locale_t locobj); +@@ -127,7 +130,11 @@ + + extern locale_t newlocale(int category_mask, const char *locale, + locale_t base); +-# define LC_GLOBAL_LOCALE ((locale_t) -1L) ++ ++extern locale_t duplocale(locale_t locobj); ++ ++# define LC_GLOBAL_LOCALE ((locale_t) -1L) ++# endif + #endif + + __END_NAMESPACE_STD +Index: libunixlib/include/string.h +=================================================================== +--- libunixlib/include/string.h (revision 7698) ++++ libunixlib/include/string.h (working copy) +@@ -93,6 +93,16 @@ + const char *__restrict __src, size_t __n) + __THROW __nonnull ((2)); + ++#ifdef __USE_XOPEN2K8 ++#include <bits/locale_t.h> ++ ++extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) ++ __THROW __attribute_pure__ __nonnull ((1, 2, 3)); ++ ++extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, ++ locale_t __l) __THROW __nonnull ((2, 4)); ++#endif ++ + /* Find the first occurrence of c in s. */ + extern char *strchr (const char *__s, int __c) + __THROW __attribute_pure__ __nonnull ((1)) __wur; +@@ -281,6 +291,17 @@ + /* Compare no more than N chars of S1 and S2, ignoring case. */ + extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + __THROW __attribute_pure__ __nonnull ((1, 2)) __wur; ++ ++# ifdef __USE_XOPEN2K8 ++# include <bits/locale_t.h> ++ ++extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) ++ __THROW __attribute_pure__ __nonnull ((1, 2, 3)); ++ ++extern int strncasecmp_l (const char *__s1, const char *__s2, ++ size_t __n, locale_t __loc) ++ __THROW __attribute_pure__ __nonnull ((1, 2, 4)); ++# endif + #endif /* Use BSD. */ + + #if defined __USE_XOPEN2K || defined __USE_MISC +@@ -289,6 +310,11 @@ + __THROW __nonnull ((2)); + #endif + ++#ifdef __USE_XOPEN2K8 ++/* Translate error number to string according to the locale L. */ ++extern char *strerror_l (int __errnum, locale_t __l) __THROW; ++#endif ++ + #ifndef __TARGET_SCL__ + # ifndef basename + /* Return the file name within directory of FILENAME. We don't +Index: libunixlib/include/strings.h +=================================================================== +--- libunixlib/include/strings.h (revision 7698) ++++ libunixlib/include/strings.h (working copy) +@@ -37,7 +37,17 @@ + /* Compare n chars of S1 and S2, ignoring case. */ + extern int strncasecmp (const char *__s1, const char *__s2, size_t __n); + ++# ifdef __USE_XOPEN2K8 ++# include <bits/locale_t.h> + ++extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) ++ __THROW __attribute_pure__ __nonnull ((1, 2, 3)); ++ ++extern int strncasecmp_l (const char *__s1, const char *__s2, ++ size_t __n, locale_t __loc) ++ __THROW __attribute_pure__ __nonnull ((1, 2, 4)); ++# endif ++ + /* Return the position of the first bit set in I, or 0 if none are set. + The least-significant bit is position 1, the most-significant 32. */ + extern int ffs (int __i); +Index: libunixlib/include/wchar.h +=================================================================== +--- libunixlib/include/wchar.h (revision 7698) ++++ libunixlib/include/wchar.h (working copy) +@@ -1,7 +1,7 @@ + /* + * File taken from glibc 2.11. + * Following changes were made: +- * - Disabled non-standard reentrant locale prototypes. ++ * - None + */ + + /* Copyright (C) 1995-2008, 2009 Free Software Foundation, Inc. +@@ -172,7 +172,6 @@ + __END_NAMESPACE_STD + #endif + +-#if 0 + #ifdef __USE_XOPEN2K8 + /* Compare S1 and S2, ignoring case. */ + extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) __THROW; +@@ -183,15 +182,14 @@ + + /* Similar to the two functions above but take the information from + the provided locale and not the global locale. */ +-# include <xlocale.h> ++# include <bits/locale_t.h> + + extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, +- __locale_t __loc) __THROW; ++ locale_t __loc) __THROW; + + extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, +- size_t __n, __locale_t __loc) __THROW; ++ size_t __n, locale_t __loc) __THROW; + #endif +-#endif + + __BEGIN_NAMESPACE_STD + /* Compare S1 and S2, both interpreted as appropriate to the +@@ -205,7 +203,6 @@ + __END_NAMESPACE_STD + + #ifdef __USE_XOPEN2K8 +-#if 0 + /* Similar to the two functions above but take the information from + the provided locale and not the global locale. */ + +@@ -212,14 +209,13 @@ + /* Compare S1 and S2, both interpreted as appropriate to the + LC_COLLATE category of the given locale. */ + extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2, +- __locale_t __loc) __THROW; ++ locale_t __loc) __THROW; + + /* Transform S2 into array pointed to by S1 such that if wcscmp is + applied to two transformed strings the result is the as applying + `wcscoll' to the original strings. */ + extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2, +- size_t __n, __locale_t __loc) __THROW; +-#endif ++ size_t __n, locale_t __loc) __THROW; + + #ifndef __TARGET_SCL__ + /* Duplicate S, returning an identical malloc'd string. */ +Index: libunixlib/include/wctype.h +=================================================================== +--- libunixlib/include/wctype.h (revision 7698) ++++ libunixlib/include/wctype.h (working copy) +@@ -3,7 +3,6 @@ + * Following changes were made: + * - Replaced "#include <bits/types.h>" into "#include <unixlib/types.h>" + * - Add wint_t typedef when it hasn't been defined in stddef.h. +- * - Disabled non-standard reentrant locale prototypes. + */ + + /* Copyright (C) 1996-2002,2005,2007,2008,2009 Free Software Foundation, Inc. +@@ -191,7 +190,6 @@ + /* Determine whether the wide-character WC has the property described by + DESC. */ + extern int iswctype (wint_t __wc, wctype_t __desc) __THROW; +-#define iswctype_l(c, d, l) iswctype(c, d) + + __END_NAMESPACE_C99 + +@@ -241,73 +239,71 @@ + extern wint_t towctrans (wint_t __wc, wctrans_t __desc) __THROW; + __END_NAMESPACE_C99 + +-#if 0 + # ifdef __USE_XOPEN2K8 +-/* Declare the interface to extended locale model. */ +-# include <xlocale.h> ++# include <bits/locale_t.h> + + /* Test for any wide character for which `iswalpha' or `iswdigit' is + true. */ +-extern int iswalnum_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswalnum_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character for which `iswupper' or 'iswlower' is + true, or any wide character that is one of a locale-specific set of + wide-characters for which none of `iswcntrl', `iswdigit', + `iswpunct', or `iswspace' is true. */ +-extern int iswalpha_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswalpha_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any control wide character. */ +-extern int iswcntrl_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswcntrl_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character that corresponds to a decimal-digit + character. */ +-extern int iswdigit_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswdigit_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character for which `iswprint' is true and + `iswspace' is false. */ +-extern int iswgraph_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswgraph_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character that corresponds to a lowercase letter + or is one of a locale-specific set of wide characters for which + none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */ +-extern int iswlower_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswlower_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any printing wide character. */ +-extern int iswprint_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswprint_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any printing wide character that is one of a + locale-specific et of wide characters for which neither `iswspace' + nor `iswalnum' is true. */ +-extern int iswpunct_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswpunct_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character that corresponds to a locale-specific + set of wide characters for which none of `iswalnum', `iswgraph', or + `iswpunct' is true. */ +-extern int iswspace_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswspace_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character that corresponds to an uppercase letter + or is one of a locale-specific set of wide character for which none + of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */ +-extern int iswupper_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswupper_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character that corresponds to a hexadecimal-digit + character equivalent to that performed be the functions described + in the previous subclause. */ +-extern int iswxdigit_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswxdigit_l (wint_t __wc, locale_t __locale) __THROW; + + /* Test for any wide character that corresponds to a standard blank + wide character or a locale-specific set of wide characters for + which `iswalnum' is false. */ +-extern int iswblank_l (wint_t __wc, __locale_t __locale) __THROW; ++extern int iswblank_l (wint_t __wc, locale_t __locale) __THROW; + + /* Construct value that describes a class of wide characters identified + by the string argument PROPERTY. */ +-extern wctype_t wctype_l (__const char *__property, __locale_t __locale) ++extern wctype_t wctype_l (__const char *__property, locale_t __locale) + __THROW; + + /* Determine whether the wide-character WC has the property described by + DESC. */ +-extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale) ++extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale) + __THROW; + + +@@ -316,22 +312,21 @@ + */ + + /* Converts an uppercase letter to the corresponding lowercase letter. */ +-extern wint_t towlower_l (wint_t __wc, __locale_t __locale) __THROW; ++extern wint_t towlower_l (wint_t __wc, locale_t __locale) __THROW; + + /* Converts an lowercase letter to the corresponding uppercase letter. */ +-extern wint_t towupper_l (wint_t __wc, __locale_t __locale) __THROW; ++extern wint_t towupper_l (wint_t __wc, locale_t __locale) __THROW; + + /* Construct value that describes a mapping between wide characters + identified by the string argument PROPERTY. */ +-extern wctrans_t wctrans_l (__const char *__property, __locale_t __locale) ++extern wctrans_t wctrans_l (__const char *__property, locale_t __locale) + __THROW; + + /* Map the wide character WC using the mapping described by DESC. */ + extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, +- __locale_t __locale) __THROW; ++ locale_t __locale) __THROW; + + # endif /* Use POSIX 2008. */ +-#endif + + __END_DECLS + +Index: libunixlib/locale/localeconv.c +=================================================================== +--- libunixlib/locale/localeconv.c (revision 7698) ++++ libunixlib/locale/localeconv.c (working copy) +@@ -14,8 +14,6 @@ + + /* #define DEBUG */ + +-int __setlocale_called = 1; +- + static int + read_symbol (int reason_code, int territory) + { +@@ -71,26 +69,44 @@ + *grouping = new_grouping; + } + +-static struct lconv lc = { NULL, NULL, NULL, NULL, NULL, +- NULL, NULL, NULL, NULL, NULL, +- CHAR_MAX, CHAR_MAX, CHAR_MAX, CHAR_MAX, +- CHAR_MAX, CHAR_MAX, CHAR_MAX, CHAR_MAX }; ++void ++__localeconv_lconv_init (struct lconv *lc) ++{ ++ memset(lc, 0, sizeof(*lc)); ++ lc->int_frac_digits = lc->frac_digits = lc->p_cs_precedes = ++ lc->p_sep_by_space = lc->n_cs_precedes = lc->n_sep_by_space = ++ lc->p_sign_posn = lc->n_sign_posn = CHAR_MAX; ++} + +-/* Defined by POSIX as not threadsafe */ +-struct lconv * +-localeconv (void) ++void ++__localeconv_lconv_fini (struct lconv *lc) + { ++ free(lc->decimal_point); ++ free(lc->thousands_sep); ++ free(lc->grouping); ++ free(lc->int_curr_symbol); ++ free(lc->currency_symbol); ++ free(lc->mon_decimal_point); ++ free(lc->mon_thousands_sep); ++ free(lc->mon_grouping); ++ free(lc->positive_sign); ++ free(lc->negative_sign); ++} ++ ++void ++__localeconv_l (locale_t locobj) ++{ + int numeric, monetary; + + /* If setlocale has not been called since the last call to + localeconv, then the lconv structure will be the same. */ +- if (!__setlocale_called) +- return &lc; ++ if (!locobj->lc_needs_refresh) ++ return; + +- __setlocale_called = 0; ++ locobj->lc_needs_refresh = 0; + +- numeric = __locale_territory[LC_NUMERIC]; +- monetary = __locale_territory[LC_MONETARY]; ++ numeric = locobj->locale_territory[LC_NUMERIC]; ++ monetary = locobj->locale_territory[LC_MONETARY]; + + /* See the PRMs regarding SWI Territory_ReadSymbols for the + meanings of the following numbers. */ +@@ -97,71 +113,80 @@ + if (numeric == -1) + { + /* We're using the 'C' locale. */ +- free (lc.decimal_point); +- lc.decimal_point = strdup ("."); +- free (lc.thousands_sep); +- lc.thousands_sep = strdup (""); +- free (lc.grouping); +- lc.grouping = strdup (""); ++ free (locobj->lc.decimal_point); ++ locobj->lc.decimal_point = strdup ("."); ++ free (locobj->lc.thousands_sep); ++ locobj->lc.thousands_sep = strdup (""); ++ free (locobj->lc.grouping); ++ locobj->lc.grouping = strdup (""); + } + else + { +- free (lc.decimal_point); +- lc.decimal_point = strdup ((char *) read_symbol (0, numeric)); +- free (lc.thousands_sep); +- lc.thousands_sep = strdup ((char *) read_symbol (1, numeric)); +- read_byte_list (2, &lc.grouping, numeric); ++ free (locobj->lc.decimal_point); ++ locobj->lc.decimal_point = strdup ((char *) read_symbol (0, numeric)); ++ free (locobj->lc.thousands_sep); ++ locobj->lc.thousands_sep = strdup ((char *) read_symbol (1, numeric)); ++ read_byte_list (2, &locobj->lc.grouping, numeric); + } + if (monetary == -1) + { + /* We using the 'C' locale. Empty strings and CHAR_MAX means + that these fields are unspecified. */ +- free (lc.mon_decimal_point); +- lc.mon_decimal_point = strdup (""); +- free (lc.mon_thousands_sep); +- lc.mon_thousands_sep = strdup (""); +- free (lc.mon_grouping); +- lc.mon_grouping = strdup (""); +- lc.int_frac_digits = CHAR_MAX; +- lc.frac_digits = CHAR_MAX; +- free (lc.currency_symbol); +- lc.currency_symbol = strdup (""); +- free (lc.int_curr_symbol); +- lc.int_curr_symbol = strdup (""); +- lc.p_cs_precedes = CHAR_MAX; +- lc.n_cs_precedes = CHAR_MAX; +- lc.p_sep_by_space = CHAR_MAX; +- lc.n_sep_by_space = CHAR_MAX; +- free (lc.positive_sign); +- lc.positive_sign = strdup (""); +- free (lc.negative_sign); +- lc.negative_sign = strdup (""); +- lc.p_sign_posn = CHAR_MAX; +- lc.n_sign_posn = CHAR_MAX; ++ free (locobj->lc.mon_decimal_point); ++ locobj->lc.mon_decimal_point = strdup (""); ++ free (locobj->lc.mon_thousands_sep); ++ locobj->lc.mon_thousands_sep = strdup (""); ++ free (locobj->lc.mon_grouping); ++ locobj->lc.mon_grouping = strdup (""); ++ locobj->lc.int_frac_digits = CHAR_MAX; ++ locobj->lc.frac_digits = CHAR_MAX; ++ free (locobj->lc.currency_symbol); ++ locobj->lc.currency_symbol = strdup (""); ++ free (locobj->lc.int_curr_symbol); ++ locobj->lc.int_curr_symbol = strdup (""); ++ locobj->lc.p_cs_precedes = CHAR_MAX; ++ locobj->lc.n_cs_precedes = CHAR_MAX; ++ locobj->lc.p_sep_by_space = CHAR_MAX; ++ locobj->lc.n_sep_by_space = CHAR_MAX; ++ free (locobj->lc.positive_sign); ++ locobj->lc.positive_sign = strdup (""); ++ free (locobj->lc.negative_sign); ++ locobj->lc.negative_sign = strdup (""); ++ locobj->lc.p_sign_posn = CHAR_MAX; ++ locobj->lc.n_sign_posn = CHAR_MAX; + } + else + { +- free (lc.int_curr_symbol); +- lc.int_curr_symbol = strdup ((char *)read_symbol (3, monetary)); +- free (lc.currency_symbol); +- lc.currency_symbol = strdup ((char *)read_symbol (4, monetary)); +- free (lc.mon_decimal_point); +- lc.mon_decimal_point = strdup ((char *)read_symbol (5, monetary)); +- free (lc.mon_thousands_sep); +- lc.mon_thousands_sep = strdup ((char *)read_symbol (6, monetary)); +- read_byte_list (7, &lc.mon_grouping, monetary); +- free (lc.positive_sign); +- lc.positive_sign = strdup ((char *)read_symbol (8, monetary)); +- free (lc.negative_sign); +- lc.negative_sign = strdup ((char *)read_symbol (9, monetary)); +- lc.int_frac_digits = (char)read_symbol (10, monetary); +- lc.frac_digits = (char)read_symbol (11, monetary); +- lc.p_cs_precedes = (char)read_symbol (12, monetary); +- lc.p_sep_by_space = (char)read_symbol (13, monetary); +- lc.n_cs_precedes = (char)read_symbol (14, monetary); +- lc.n_sep_by_space = (char)read_symbol (15, monetary); +- lc.p_sign_posn = (char)read_symbol (16, monetary); +- lc.n_sign_posn = (char)read_symbol (17, monetary); ++ free (locobj->lc.int_curr_symbol); ++ locobj->lc.int_curr_symbol = strdup ((char *)read_symbol (3, monetary)); ++ free (locobj->lc.currency_symbol); ++ locobj->lc.currency_symbol = strdup ((char *)read_symbol (4, monetary)); ++ free (locobj->lc.mon_decimal_point); ++ locobj->lc.mon_decimal_point = strdup ((char *)read_symbol (5, monetary)); ++ free (locobj->lc.mon_thousands_sep); ++ locobj->lc.mon_thousands_sep = strdup ((char *)read_symbol (6, monetary)); ++ read_byte_list (7, &locobj->lc.mon_grouping, monetary); ++ free (locobj->lc.positive_sign); ++ locobj->lc.positive_sign = strdup ((char *)read_symbol (8, monetary)); ++ free (locobj->lc.negative_sign); ++ locobj->lc.negative_sign = strdup ((char *)read_symbol (9, monetary)); ++ locobj->lc.int_frac_digits = (char)read_symbol (10, monetary); ++ locobj->lc.frac_digits = (char)read_symbol (11, monetary); ++ locobj->lc.p_cs_precedes = (char)read_symbol (12, monetary); ++ locobj->lc.p_sep_by_space = (char)read_symbol (13, monetary); ++ locobj->lc.n_cs_precedes = (char)read_symbol (14, monetary); ++ locobj->lc.n_sep_by_space = (char)read_symbol (15, monetary); ++ locobj->lc.p_sign_posn = (char)read_symbol (16, monetary); ++ locobj->lc.n_sign_posn = (char)read_symbol (17, monetary); + } +- return &lc; ++ return; + } ++ ++/* Defined by POSIX as not threadsafe */ ++struct lconv * ++localeconv (void) ++{ ++ __localeconv_l (&__locale_global); ++ ++ return &__locale_global.lc; ++} +Index: libunixlib/locale/newlocale.c +=================================================================== +--- libunixlib/locale/newlocale.c (revision 7698) ++++ libunixlib/locale/newlocale.c (working copy) +@@ -1,17 +1,17 @@ + /* Copyright (c) 2019 UnixLib Developers + */ + ++#include <ctype.h> ++#include <errno.h> ++#include <locale.h> + #include <stdlib.h> +-#include <locale.h> + #include <stdio.h> +-#include <errno.h> ++#include <string.h> + +-struct _locale { +- struct lconv lc; +-}; ++#include <internal/unix.h> + + /* This is supposed to be per-thread. */ +-static locale_t current_locale; ++static locale_t current_locale = LC_GLOBAL_LOCALE; + + locale_t uselocale(locale_t newloc) + { +@@ -27,20 +27,94 @@ + + void freelocale(locale_t locobj) + { +- if (locobj) ++ if (locobj) { ++ __localeconv_lconv_fini(&locobj->lc); + free(locobj); ++ } + } + + locale_t newlocale(int category_mask, const char *locale, + locale_t base) + { +- locale_t loc = (locale_t)malloc(sizeof(*loc)); +- if (!loc) { ++ struct _locale tmp; ++ ++ PTHREAD_UNSAFE ++ ++ if ((category_mask & ~LC_ALL_MASK) || locale == NULL) { ++ __set_errno (EINVAL); ++ return 0; ++ } ++ ++ /* The locale provided will be verified by __setlocale_l() */ ++ ++ /* Prepare the temporary locale we will modify */ ++ if (base != 0 && base != LC_GLOBAL_LOCALE) { ++ memcpy(&tmp, base, sizeof(tmp)); ++ } else { ++ if (base == LC_GLOBAL_LOCALE) { ++ /* Undefined: be helpful to client */ ++ memcpy(&tmp, &__locale_global, sizeof(tmp)); ++ } else { ++ /* Initialise to C locale */ ++ __build_ctype_tables(&tmp, -2); ++ } ++ } ++ ++ /* Now, apply the requested locale to each of the categories in the mask */ ++ if (category_mask == LC_ALL_MASK) { ++ /* Special-case LC_ALL to handle the encoded locale string */ ++ if (__setlocale_l(&tmp, LC_ALL, locale) == NULL) { ++ return 0; ++ } ++ } else { ++ int category = 0, mask = category_mask; ++ while (mask != 0) { ++ if (mask & 1) { ++ if (__setlocale_l(&tmp, category, locale) == NULL) { ++ return 0; ++ } ++ } ++ category++; ++ mask >>= 1; ++ } ++ } ++ ++ /* Allocate the result, if necessary */ ++ if (base == 0 || base == LC_GLOBAL_LOCALE) { ++ base = (locale_t)malloc(sizeof(*base)); ++ if (!base) { ++ __set_errno (ENOMEM); ++ return 0; ++ } ++ } ++ /* Fill it in */ ++ memcpy(base, &tmp, sizeof(tmp)); ++ ++ /* Mark the lconv data stale */ ++ base->lc_needs_refresh = 1; ++ ++ return base; ++} ++ ++locale_t duplocale(locale_t locobj) ++{ ++ locale_t loc; ++ ++ loc = (locale_t) malloc(sizeof(*loc)); ++ if (loc == NULL) { + __set_errno (ENOMEM); + return 0; + } + +- loc->lc = *localeconv(); ++ if (locobj == LC_GLOBAL_LOCALE) { ++ memcpy(loc, &__locale_global, sizeof(*loc)); ++ } else { ++ memcpy(loc, locobj, sizeof(*loc)); ++ } + ++ /* Invalidate lconv in the copy */ ++ __localeconv_lconv_init(&loc->lc); ++ loc->lc_needs_refresh = 1; ++ + return loc; + } +Index: libunixlib/locale/nl_langinfo.c +=================================================================== +--- libunixlib/locale/nl_langinfo.c (revision 7698) ++++ libunixlib/locale/nl_langinfo.c (working copy) +@@ -24,3 +24,10 @@ + + return (char *)value; + } ++ ++char * ++nl_langinfo_l (nl_item item, locale_t l) ++{ ++ (void) l; ++ return nl_langinfo(item); ++} +Index: libunixlib/locale/setlocale.c +=================================================================== +--- libunixlib/locale/setlocale.c (revision 7698) ++++ libunixlib/locale/setlocale.c (working copy) +@@ -195,7 +195,7 @@ + } + + static void +-do_lc_all (char *buffer, int size) ++do_lc_all (locale_t locobj, char *buffer, int size) + { + char temp[64]; + int category, same = 1; +@@ -204,13 +204,13 @@ + setlocale to set all locales. If all locales are + the same, then we can produce a very short string. */ + for (category = 1; category < LC_ALL; ++category) +- if (__locale_territory[0] != __locale_territory[category]) ++ if (locobj->locale_territory[0] != locobj->locale_territory[category]) + same = 0; + + if (same) + { + /* All locales are set to the same territory. */ +- territory_name (__locale_territory[0], buffer, size); ++ territory_name (locobj->locale_territory[0], buffer, size); + } + else + { +@@ -218,7 +218,7 @@ + LC_CATEGORY=country;LC_CATEGORY=country; ... */ + for (category = 0; category < LC_ALL; ++category) + { +- territory_name (__locale_territory[category], temp, sizeof (temp)); ++ territory_name (locobj->locale_territory[category], temp, sizeof (temp)); + buffer = stpcpy (buffer, locale_names[category]); + *buffer++ = '='; + buffer = stpcpy (buffer, temp); +@@ -230,15 +230,13 @@ + } + + char * +-setlocale (int category, const char *locale) ++__setlocale_l (locale_t locobj, int category, const char *locale) + { + int new_territory, changed; + static char old_locale[256]; + +- PTHREAD_UNSAFE +- + /* This tells localeconv to re-read data for the lconv structure. */ +- __setlocale_called = 1; ++ locobj->lc_needs_refresh = 1; + + if (locale == NULL) + { +@@ -247,11 +245,11 @@ + { + /* The locale string is specially encoded for LC_ALL so we + could restore all locales at any time. */ +- do_lc_all (old_locale, sizeof (old_locale)); ++ do_lc_all (locobj, old_locale, sizeof (old_locale)); + return old_locale; + } + +- territory_name (__locale_territory[category], old_locale, sizeof (old_locale)); ++ territory_name (locobj->locale_territory[category], old_locale, sizeof (old_locale)); + return old_locale; + } + +@@ -270,7 +268,7 @@ + /* Encode the locale string, as we will be returning this + later. Remember, setlocale returns the locale settings + that are about to be changed. */ +- do_lc_all (old_locale, sizeof (old_locale)); ++ do_lc_all (locobj, old_locale, sizeof (old_locale)); + + /* Check for an encoded (composite) name. Simply looking for + a semi-colon will verify this. */ +@@ -332,11 +330,11 @@ + + /* We now know all locales exist, so set them. */ + for (category = 0; category < LC_ALL; ++category) +- __locale_territory[category] = territory_number (newnames[category]); ++ locobj->locale_territory[category] = territory_number (newnames[category]); + + /* Re-build the character type tables according to the new + locale settings. */ +- __build_ctype_tables (__locale_territory[LC_CTYPE]); ++ __build_ctype_tables (locobj, locobj->locale_territory[LC_CTYPE]); + return old_locale; + } + } +@@ -359,9 +357,9 @@ + /* Change the locale for all categories. old_locale was created + when we previously checked for a composite string. */ + for (category = 0; category < LC_ALL; ++category) +- if (__locale_territory[category] != new_territory) ++ if (locobj->locale_territory[category] != new_territory) + { +- __locale_territory[category] = new_territory; ++ locobj->locale_territory[category] = new_territory; + changed = 1; + } + } +@@ -368,12 +366,12 @@ + else + { + /* Change the locale for just one category. */ +- territory_name (__locale_territory[category], ++ territory_name (locobj->locale_territory[category], + old_locale, sizeof (old_locale)); + +- if (__locale_territory[category] != new_territory) ++ if (locobj->locale_territory[category] != new_territory) + { +- __locale_territory[category] = new_territory; ++ locobj->locale_territory[category] = new_territory; + changed = 1; + } + } +@@ -384,7 +382,16 @@ + is changing. The GNU Java compiler is known to repeatedly call + setlocale. */ + if (changed && (category == LC_ALL || category == LC_CTYPE)) +- __build_ctype_tables (new_territory); ++ __build_ctype_tables (locobj, new_territory); + + return old_locale; + } ++ ++char * ++setlocale (int category, const char *locale) ++{ ++ ++ PTHREAD_UNSAFE ++ ++ return __setlocale_l(&__locale_global, category, locale); ++} +Index: libunixlib/locale/strcoll.c +=================================================================== +--- libunixlib/locale/strcoll.c (revision 7698) ++++ libunixlib/locale/strcoll.c (working copy) +@@ -11,9 +11,15 @@ + int + strcoll (const char *s1, const char *s2) + { ++ return strcoll_l (s1, s2, &__locale_global); ++} ++ ++int ++strcoll_l (const char *s1, const char *s2, locale_t l) ++{ + int regs[10]; + +- regs[0] = __locale_territory[LC_COLLATE]; ++ regs[0] = l->locale_territory[LC_COLLATE]; + regs[1] = (int)s1; + regs[2] = (int)s2; + regs[3] = 0; +@@ -21,3 +27,4 @@ + __os_swi (Territory_Collate, regs); + return regs[0]; + } ++ +Index: libunixlib/locale/strxfrm.c +=================================================================== +--- libunixlib/locale/strxfrm.c (revision 7698) ++++ libunixlib/locale/strxfrm.c (working copy) +@@ -11,9 +11,15 @@ + size_t + strxfrm (char *to, const char *from, size_t size) + { ++ return strxfrm_l (to, from, size, &__locale_global); ++} ++ ++size_t ++strxfrm_l (char *to, const char *from, size_t size, locale_t l) ++{ + int regs[10]; + +- regs[0] = __locale_territory[LC_COLLATE]; ++ regs[0] = l->locale_territory[LC_COLLATE]; + regs[1] = (int)to; + regs[2] = (int)from; + regs[3] = size; +Index: libunixlib/locale/territory.c +=================================================================== +--- libunixlib/locale/territory.c (revision 7698) ++++ libunixlib/locale/territory.c (nonexistent) +@@ -1,10 +0,0 @@ +-/* __locale_territory +- * Copyright (c) 2000-2006 UnixLib Developers +- */ +- +-#include <locale.h> +- +-/* Global used for all calls to the Territory module. These variable +- contain the territory number as set by setlocale. A value of +- -1 means use the C locale. */ +-int __locale_territory[LC_ALL + 1]; +Index: libunixlib/string/stricmp.c +=================================================================== +--- libunixlib/string/stricmp.c (revision 7698) ++++ libunixlib/string/stricmp.c (working copy) +@@ -4,6 +4,7 @@ + #include <string.h> + #include <strings.h> + #include <ctype.h> ++#include <locale.h> + + int + stricmp (const char *s1, const char *s2) +@@ -26,3 +27,24 @@ + return result; + } + strong_alias (stricmp, strcasecmp) ++ ++int ++strcasecmp_l (const char *s1, const char *s2, locale_t locobj) ++{ ++ const unsigned char *p1 = (const unsigned char *) s1; ++ const unsigned char *p2 = (const unsigned char *) s2; ++ int result = 0; ++ ++ if (p1 == p2) ++ return result; ++ ++ while (! result) ++ { ++ result = tolower_l (*p1, locobj) - tolower_l (*p2, locobj); ++ if (*p1++ == '\0') ++ break; ++ p2 ++; ++ } ++ ++ return result; ++} +Index: libunixlib/string/strnicmp.c +=================================================================== +--- libunixlib/string/strnicmp.c (revision 7698) ++++ libunixlib/string/strnicmp.c (working copy) +@@ -5,6 +5,7 @@ + #include <string.h> + #include <strings.h> + #include <ctype.h> ++#include <locale.h> + + int + strnicmp (const char *s1, const char *s2, size_t n) +@@ -26,3 +27,22 @@ + } + strong_alias (strnicmp, strncasecmp) + ++int ++strncasecmp_l (const char *s1, const char *s2, size_t n, locale_t locobj) ++{ ++ int i, j; ++ ++ if (!n) ++ return 0; ++ ++ do ++ { ++ i = *s1++, j = *s2++; ++ i = tolower_l (i, locobj); ++ j = tolower_l (j, locobj); ++ } ++ while (i && i == j && --n); ++ ++ return i - j; ++} ++ +Index: libunixlib/sys/errlist.c +=================================================================== +--- libunixlib/sys/errlist.c (revision 7698) ++++ libunixlib/sys/errlist.c (working copy) +@@ -211,3 +211,10 @@ + + return 0; + } ++ ++char * ++strerror_l (int errnum, locale_t l) ++{ ++ (void) l; ++ return strerror (errnum); ++} +Index: libunixlib/time/broken.c +=================================================================== +--- libunixlib/time/broken.c (revision 7698) ++++ libunixlib/time/broken.c (working copy) +@@ -49,7 +49,7 @@ + #ifdef __TARGET_SCL__ + -1, + #else +- __locale_territory[LC_TIME], ++ __locale_global.locale_territory[LC_TIME], + #endif + riscos_time, ordinals); + } +Index: libunixlib/time/gmtime_r.c +=================================================================== +--- libunixlib/time/gmtime_r.c (revision 7698) ++++ libunixlib/time/gmtime_r.c (working copy) +@@ -46,7 +46,7 @@ + #ifdef __TARGET_SCL__ + -1, + #else +- __locale_territory[LC_TIME], ++ __locale_global.locale_territory[LC_TIME], + #endif + riscos_time, ordinals)) != NULL) + { +Index: libunixlib/time/localtime_r.c +=================================================================== +--- libunixlib/time/localtime_r.c (revision 7698) ++++ libunixlib/time/localtime_r.c (working copy) +@@ -28,7 +28,7 @@ + #ifdef __TARGET_SCL__ + -1, + #else +- __locale_territory[LC_TIME], ++ __locale_global.locale_territory[LC_TIME], + #endif + riscos_time, ordinals)) != NULL) + { +Index: libunixlib/time/mktime.c +=================================================================== +--- libunixlib/time/mktime.c (revision 7698) ++++ libunixlib/time/mktime.c (working copy) +@@ -23,7 +23,7 @@ + #ifdef __TARGET_SCL__ + -1, + #else +- __locale_territory[LC_TIME], ++ __locale_global.locale_territory[LC_TIME], + #endif + riscos_time, + ordinals)) != NULL) +Index: libunixlib/time/stdtime.c +=================================================================== +--- libunixlib/time/stdtime.c (revision 7698) ++++ libunixlib/time/stdtime.c (working copy) +@@ -48,7 +48,7 @@ + #ifdef __TARGET_SCL__ + -1, + #else +- __locale_territory[LC_TIME], ++ __locale_global.locale_territory[LC_TIME], + #endif + riscos_time, + result, +Index: libunixlib/time/strftime.c +=================================================================== +--- libunixlib/time/strftime.c (revision 7698) ++++ libunixlib/time/strftime.c (working copy) +@@ -353,7 +353,7 @@ + int regs[10]; + char buffer[64]; + +- regs[0] = __locale_territory[LC_TIME]; ++ regs[0] = __locale_global.locale_territory[LC_TIME]; + regs[1] = (int)timep; + regs[2] = (int)buffer; + regs[3] = sizeof (buffer) - 1; +@@ -368,7 +368,7 @@ + int regs[10]; + char buffer[64]; + +- regs[0] = __locale_territory[LC_TIME]; ++ regs[0] = __locale_global.locale_territory[LC_TIME]; + regs[1] = (int)timep; + regs[2] = (int)buffer; + regs[3] = sizeof (buffer) - 1; +Index: libunixlib/time/tzset.c +=================================================================== +--- libunixlib/time/tzset.c (revision 7698) ++++ libunixlib/time/tzset.c (working copy) +@@ -36,7 +36,7 @@ + /* Get timezone information for current territory. */ + _kernel_swi_regs regs; + #ifndef __TARGET_SCL__ +- regs.r[0] = __locale_territory[LC_TIME]; ++ regs.r[0] = __locale_global.locale_territory[LC_TIME]; + #else + regs.r[0] = -1; /* Current territory. */ + #endif +Index: libunixlib/unix/unix.c +=================================================================== +--- libunixlib/unix/unix.c (revision 7698) ++++ libunixlib/unix/unix.c (working copy) +@@ -191,7 +191,7 @@ + __pthread_prog_init (); + __unixlib_signal_initialise (__u); + /* Initialise ctype tables to the C locale. */ +- __build_ctype_tables (-2); ++ __build_ctype_tables (&__locale_global, -2); + /* Define and initialise the Unix I/O. */ + initialise_unix_io (); + __stdioinit (); +Index: libunixlib/vscript +=================================================================== +--- libunixlib/vscript (revision 7698) ++++ libunixlib/vscript (working copy) +@@ -58,6 +58,9 @@ + __init_des_r; + __init_des; + __invalidate; ++ __locale_global; ++ __localeconv_lconv_init; ++ __localeconv_lconv_fini; + malloc_trim; + malloc_trim_unlocked; + malloc_unlocked; +@@ -80,6 +83,7 @@ + __res_vinit; + __runtime_features; + __setup_signalhandler_stack; ++ __setlocale_l; + __sdirinit; + __sfixinit; + __sfixfind; +Index: libunixlib/wchar/wctype.c +=================================================================== +--- libunixlib/wchar/wctype.c (revision 7698) ++++ libunixlib/wchar/wctype.c (working copy) +@@ -4,6 +4,7 @@ + */ + + #include <ctype.h> ++#include <locale.h> + #include <wctype.h> + + int +@@ -71,3 +72,69 @@ + { + return isxdigit (wc); + } ++ ++int ++iswalnum_l (wint_t wc, locale_t locale) ++{ ++ return isalnum_l (wc, locale); ++} ++ ++int ++iswalpha_l (wint_t wc, locale_t locale) ++{ ++ return isalpha_l (wc, locale); ++} ++ ++int ++iswcntrl_l (wint_t wc, locale_t locale) ++{ ++ return iscntrl_l (wc, locale); ++} ++ ++int ++iswdigit_l (wint_t wc, locale_t locale) ++{ ++ return isdigit_l (wc, locale); ++} ++ ++int ++iswgraph_l (wint_t wc, locale_t locale) ++{ ++ return isgraph_l (wc, locale); ++} ++ ++int ++iswprint_l (wint_t wc, locale_t locale) ++{ ++ return isprint_l (wc, locale); ++} ++ ++int ++iswpunct_l (wint_t wc, locale_t locale) ++{ ++ return ispunct_l (wc, locale); ++} ++ ++int ++iswspace_l (wint_t wc, locale_t locale) ++{ ++ return isspace_l (wc, locale); ++} ++ ++int ++iswxdigit_l (wint_t wc, locale_t locale) ++{ ++ return isxdigit_l (wc, locale); ++} ++ ++wint_t ++towlower_l (wint_t wc, locale_t locale) ++{ ++ return tolower_l (wc, locale); ++} ++ ++wint_t ++towupper_l (wint_t wc, locale_t locale) ++{ ++ return toupper_l (wc, locale); ++} +Index: libunixlib/wchar/wmissing.c +=================================================================== +--- libunixlib/wchar/wmissing.c (revision 7698) ++++ libunixlib/wchar/wmissing.c (working copy) +@@ -1,7 +1,7 @@ ++#include <locale.h> ++#include <stdio.h> + #include <stdlib.h> + #include <wctype.h> +-#include <wctype.h> +-#include <stdio.h> + + int iswupper (wint_t __wc) + { +@@ -9,13 +9,26 @@ + abort(); + } + +-unsigned long int wcstoul (__const wchar_t *__restrict __nptr, +- wchar_t **__restrict __endptr, int __base) ++int ++iswupper_l (wint_t wc, locale_t locale) + { + printf("%s: Not implemented\n", __func__); + abort(); + } + ++int iswlower (wint_t __wc) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ ++int ++iswlower_l (wint_t wc, locale_t locale) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ + int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) + { + printf("%s: Not implemented\n", __func__); +@@ -22,12 +35,47 @@ + abort(); + } + +-int iswlower (wint_t __wc) ++int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2, ++ locale_t loc) + { + printf("%s: Not implemented\n", __func__); + abort(); + } + ++int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ ++int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2, ++ size_t __n) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ ++int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, ++ locale_t __loc) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ ++int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, ++ size_t __n, locale_t __loc) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ ++unsigned long int wcstoul (__const wchar_t *__restrict __nptr, ++ wchar_t **__restrict __endptr, int __base) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ + long long int wcstoll (__const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + { +@@ -63,6 +111,13 @@ + abort(); + } + ++size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2, ++ size_t __n, locale_t __loc) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ + float wcstof (__const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) + { +@@ -83,6 +138,13 @@ + abort(); + } + ++int ++iswblank_l (wint_t __wc, locale_t __locale) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ + int iswctype (wint_t __wc, wctype_t __desc) + { + printf("%s: Not implemented\n", __func__); +@@ -89,6 +151,12 @@ + abort(); + } + ++int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ + unsigned long long int wcstoull (__const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) +@@ -116,6 +184,12 @@ + abort(); + } + ++wctype_t wctype_l (__const char *__property, locale_t __locale) ++{ ++ printf("%s: Not implemented\n", __func__); ++ abort(); ++} ++ + wint_t ungetwc(wint_t wc, FILE *stream) + { + printf("%s: Not implemented\n", __func__); diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/roinstall-objdump-name.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/roinstall-objdump-name.p new file mode 100644 index 0000000..73a9abe --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/roinstall-objdump-name.p @@ -0,0 +1,13 @@ +Index: ro-install +=================================================================== +--- ro-install (revision 7698) ++++ ro-install (working copy) +@@ -72,7 +72,7 @@ + + # Check that static libraries really do contain static objects + if grep -q "\.a\$" <<< $param || grep -q "\.a-static" <<< $param ; then +- if GCCSDK_BIN/arm-unknown-riscos-objdump -p $param | grep -q "position independent"; then ++ if GCCSDK_BIN/arm-riscos-gnueabi-objdump -p $param | grep -q "position independent"; then + echo "RISC OS Cross installer: static archive $param contains position independent code" 1>&2 + exit 1 + fi diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-armv4.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-armv4.p new file mode 100644 index 0000000..1343d13 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-armv4.p @@ -0,0 +1,80 @@ +Index: libunixlib/gcccompat/atomics.c +=================================================================== +--- libunixlib/gcccompat/atomics.c (revision 7698) ++++ libunixlib/gcccompat/atomics.c (working copy) +@@ -378,7 +378,7 @@ + ATOMIC_OP_FETCH(or,(*ptr) |= val,unsigned) + ATOMIC_OP_FETCH(nand,(*ptr) = ~((*ptr) & val),unsigned) + +-#ifdef __ARM_EABI__ ++#if defined(__ARM_EABI__) && defined(__ARM_ARCH) && (__ARM_ARCH >= 6) + + static int __cmpxchg (int oldval, int newval, volatile int *ptr) + { +Index: libunixlib/pthread/_ints.s +=================================================================== +--- libunixlib/pthread/_ints.s (revision 7698) ++++ libunixlib/pthread/_ints.s (working copy) +@@ -14,6 +14,15 @@ + .protected __pthread_enable_ints + .global __pthread_protect_unsafe + ++#if defined(__ARM_ARCH) && (__ARM_ARCH__ < 6) ++ /* Modern gas objects to our runtime-conditional use of LDREX/STREX ++ * in here. If we're building for pre-armv6 architectures, tell gas ++ * that to allow armv6 instructions, but mark the resulting object ++ * as armv4 compatible. */ ++ .arch armv6 ++ .object_arch armv4 ++#endif ++ + @ Disable context switches by incrementing the semaphore + @ May be called from USR or SVC mode + NAME __pthread_disable_ints +@@ -23,7 +32,7 @@ + LDR a1, .L0 @ =__ul_global + PICEQ "LDR a1, [a2, a1]" + LDR ip, [a1, #GBL_PTH_CALLEVERY_RMA] +-#ifdef __ARM_EABI__ ++#if defined(__ARM_EABI__) && defined(__ARM_ARCH) && (__ARM_ARCH >= 6) + ADD a1, ip, #PTHREAD_CALLEVERY_RMA_WORKSEMAPHORE + #else + LDR a4, [a1, #GBL_CPU_FLAGS] +@@ -93,7 +102,7 @@ + LDR a4, .L2 @ =__ul_global + PICEQ "LDR a4, [a1, a4]" + LDR ip, [a4, #GBL_PTH_CALLEVERY_RMA] +-#ifdef __ARM_EABI__ ++#if defined(__ARM_EABI__) && defined(__ARM_ARCH) && (__ARM_ARCH >= 6) + ADD a1, ip, #PTHREAD_CALLEVERY_RMA_WORKSEMAPHORE + #else + LDR a2, [a4, #GBL_CPU_FLAGS] +Index: libunixlib/sys/_syslib.s +=================================================================== +--- libunixlib/sys/_syslib.s (revision 7698) ++++ libunixlib/sys/_syslib.s (working copy) +@@ -49,6 +49,15 @@ + .weak __dynamic_da_max_size + .weak __stack_size + ++#if defined(__ARM_ARCH) && (__ARM_ARCH__ < 6) ++ /* Modern gas objects to our runtime-conditional use of LDREX/STREX ++ * in here. If we're building for pre-armv6 architectures, tell gas ++ * that to allow armv6 instructions, but mark the resulting object ++ * as armv4 compatible. */ ++ .arch armv6 ++ .object_arch armv4 ++#endif ++ + @ RMEnsure the minimum version of the SharedUnixLibrary we need. + @ Now check System modules first as UnixLib package is deprecated. + #if !defined(__SOFTFP__) && defined(__VFP_FP__) +@@ -1414,7 +1423,7 @@ + @ we go for a straight OS_Exit scenario. Anything better we + @ can do ? + ADD a3, a4, #GBL_PANIC_MODE +-#ifndef __ARM_EABI__ ++#if !defined(__ARM_EABI__) || !defined(__ARM_ARCH) || (__ARM_ARCH < 6) + LDR a2, [a4, #GBL_CPU_FLAGS] + TST a2, #__CPUCAP_HAVE_SWP + BEQ 0f diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-initial-sp.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-initial-sp.p new file mode 100644 index 0000000..f3309c2 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-initial-sp.p @@ -0,0 +1,31 @@ +Index: libunixlib/sys/_syslib.s +=================================================================== +--- libunixlib/sys/_syslib.s (revision 7698) ++++ libunixlib/sys/_syslib.s (working copy) +@@ -396,8 +396,9 @@ + SWI XOS_ReadVarVal @ Read value of progname$HeapMax + BVS t08 + TEQ v1, #1 @ Should be a number variable +- LDREQ v2, [sp], #4 ++ LDREQ v2, [sp] + MOVEQ v2, v2, LSL#20 @ Convert MB into bytes ++ ADD sp, sp, #4 + + @ v2 = size of DA area + t08: +@@ -512,7 +513,15 @@ + MOVCC a1, #ERR_NO_FPE + BCC __exit_with_error_num + #endif ++#else ++#ifdef __ARM_EABI__ ++ @ EABI with software FP. Burn the top of the stack to appease ++ @ ARMEABISupport (which does not consider the stack top address ++ @ as part of the stack). ++ SUB sp, sp, #4 ++ BIC sp, sp, #7 @ AAPCS wants 8 byte alignment + #endif ++#endif + + @ We need to create this now so that we have its address to give to + @ the callback handler, but we can initialise it later. diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-no-armv7-memcpy.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-no-armv7-memcpy.p new file mode 100644 index 0000000..c89d6ab --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-no-armv7-memcpy.p @@ -0,0 +1,34 @@ +Index: libunixlib/Makefile.am +=================================================================== +--- libunixlib/Makefile.am (revision 7698) ++++ libunixlib/Makefile.am (working copy) +@@ -1002,18 +1002,11 @@ + string/strtok.c \ + string/swab.c \ + string/_strcpy.s +-if ARM_EABI + string_src += \ +- string/_memcpymove-v7l.s \ +- string/_memset-v7l.s \ +- string/_strlen-v7l.s +-else +-string_src += \ + string/_memcpy.s \ + string/_memset.s \ + string/_strlen.s + endif +-endif + string_src += \ + string/memccpy.c \ + string/memchr.c \ +@@ -1029,10 +1022,8 @@ + string/strtok_r.c \ + string/_ffs.s \ + string/_ffsll.s +-if !ARM_EABI + string_src += \ + string/mempcpy.c +-endif + + if UNIXLIB_BUILDING_SCL + sys_src = diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-stdtime.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-stdtime.p new file mode 100644 index 0000000..3ad890a --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-stdtime.p @@ -0,0 +1,17 @@ +Index: libunixlib/time/stdtime.c +=================================================================== +--- libunixlib/time/stdtime.c (revision 7698) ++++ libunixlib/time/stdtime.c (working copy) +@@ -23,9 +23,11 @@ + register const char *str __asm ("r4") = __str; + register const _kernel_oserror *err __asm ("r0"); + register char *term __asm ("r1"); ++ register size_t left __asm ("r2"); ++ register const char *ostr __asm ("r3"); + __asm__ volatile ("SWI\t%[SWI_Territory_ConvertDateAndTime]\n\t" + "MOVVC\tr0, #0\n\t" +- : "=r" (err), "=r" (term) ++ : "=r" (err), "=r" (term), "=r" (left), "=r" (ostr) + : "r" (territory), "r" (ro_time), "r" (buf), "r" (size), "r" (str), + [SWI_Territory_ConvertDateAndTime] "i" (Territory_ConvertDateAndTime | (1<<17)) + : "r14", "cc", "memory"); diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-sync-and-fetch-atomics.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-sync-and-fetch-atomics.p new file mode 100644 index 0000000..f9764ba --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-sync-and-fetch-atomics.p @@ -0,0 +1,22 @@ +Index: libunixlib/gcccompat/atomics.c +=================================================================== +--- libunixlib/gcccompat/atomics.c (revision 7698) ++++ libunixlib/gcccompat/atomics.c (working copy) +@@ -146,8 +146,6 @@ + ATOMIC_COMPARE_AND_EXCHANGE(4,uint32_t) + ATOMIC_COMPARE_AND_EXCHANGE(8,uint64_t) + +-#ifndef __ARM_EABI__ +- + /* These built-in functions perform the operation suggested by the name, + * and return the value that had previously been in *ptr. That is, + * +@@ -200,8 +198,6 @@ + SYNC_FETCH_AND_OP(xor,^,8,long long) + SYNC_FETCH_AND_OP(and,&,8,long long) + +-#endif +- + /* These built-in functions perform the operation suggested by the name, + * and return the new value. That is, + * diff --git a/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-unwind.p b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-unwind.p new file mode 100644 index 0000000..9ff54c9 --- /dev/null +++ b/arm-riscos-gnueabi/recipes/patches/gccsdk/unixlib-unwind.p @@ -0,0 +1,468 @@ +Index: libunixlib/Makefile.am +=================================================================== +--- libunixlib/Makefile.am (revision 7698) ++++ libunixlib/Makefile.am (working copy) +@@ -33,7 +33,7 @@ + # arguments can not be tested for NULL in UnixLib itself. + if ARM_EABI + AM_CFLAGS = -D__GNU_LIBRARY__ -DNO_LONG_DOUBLE -D_GNU_SOURCE=1 \ +- -D__UNIXLIB_NO_NONNULL -std=c99 $(LIBM_FLAGS) ++ -D__UNIXLIB_NO_NONNULL -std=c99 -mpoke-function-name -funwind-tables $(LIBM_FLAGS) + UNIXLIB_CHUNKED_STACK=0 + else + AM_CFLAGS = -D__GNU_LIBRARY__ -DNO_LONG_DOUBLE -D_GNU_SOURCE=1 \ +Index: libunixlib/signal/_signal.s +=================================================================== +--- libunixlib/signal/_signal.s (revision 7698) ++++ libunixlib/signal/_signal.s (working copy) +@@ -352,8 +352,8 @@ + CHGMODE a1, USR_Mode @ Back to USR mode now we have a stack + + #ifdef __ARM_EABI__ +- STMFD sp!, {v1, v3} +- ADD fp, sp, #4 ++ ANDS v2, sp, #7 @ Align stack ++ SUBEQ sp, sp, #4 + #else + ADR v4, __h_error + 4*3 @ Point at handler name for backtrace + STMFD sp!, {v1, v2, v3, v4} @ Setup an APCS-32 stack frame so we +@@ -758,10 +758,9 @@ + SWINE XOS_Byte @ This calls our escape handler + + #ifdef __ARM_EABI__ +- LDR a3, [sp, #14*4 + 4] @ saved USR lr +- LDR a1, [sp, #11*4 + 4] @ saved USR fp +- STMFD sp!, {a1, a3} @ create signal frame +- MOV fp, sp @ FIXME: check this with compiler output for similar function ++ MOV a1, sp @ a1 -> register save block ++ ANDS v2, sp, #7 ++ SUBNE sp, sp, #4 @ align stack to 8 bytes + #else + @ Create an APCS-32 compilant signal stack frame + ADR a4, __h_cback + 4*3 @ point at handler name for backtrace +@@ -796,11 +795,12 @@ + STR a1, [a3, #GBL_EXECUTING_SIGNALHANDLER] + + #ifdef __ARM_EABI__ +- ADD a1, sp, #8 @ Skip signal frame (fp, lr) ++ TEQ v2, #0 ++ ADDNE a1, sp, #4 @ Undo stack alignment + #else + ADD a1, sp, #16 @ Skip signal frame (fp, sp, lr, name ptr) + #endif +- ADD sp, sp, #16+17*4 ++ ADD sp, sp, #17*4 + SWI XOS_EnterOS @ We need to be in SVC mode so reenbling IRQs + @ is atomic with returning to USR mode, + @ otherwise USR sp could be overwitten by +Index: libunixlib/signal/post.c +=================================================================== +--- libunixlib/signal/post.c (revision 7698) ++++ libunixlib/signal/post.c (working copy) +@@ -255,19 +255,230 @@ + fprintf (stderr, "\nTermination signal received: %s\n", sys_siglist[signo]); + } + ++static void ++__write_abort_block (const unsigned int *blk, int is32bit) ++{ ++ const unsigned int pcmask = is32bit ? 0xfffffffcu : 0x03fffffcu; ++ ++ fprintf (stderr, "\n Register dump at %08x:\n", (unsigned int) blk); ++ ++ if (!__valid_address (blk, blk + 17)) ++ fputs ("\n [bad register dump address]\n", stderr); ++ else ++ { ++ const char rnames[] = "a1a2a3a4v1v2v3v4v5v6slfpipsplrpc"; ++ for (int reg = 0; reg < 16; reg++) ++ { ++ if ((reg & 0x3) == 0) ++ fputs ("\n ", stderr); ++ ++ fprintf (stderr, " %c%c: %8x", ++ rnames[2*reg + 0], rnames[2*reg + 1], blk[reg + 1]); ++ } ++ ++ if (is32bit) ++ fprintf (stderr, "\n cpsr: %8x\n", blk[0]); ++ else ++ { ++ const char * const pmode[4] = { "USR", "FIQ", "IRQ", "SVC" }; ++ fprintf (stderr, "\n Mode %s, flags set: %c%c%c%c%c%c\n", ++ pmode[blk[15 + 1] & 3], ++ (blk[15 + 1] & (1<<31)) ? 'N' : 'n', ++ (blk[15 + 1] & (1<<30)) ? 'Z' : 'z', ++ (blk[15 + 1] & (1<<29)) ? 'C' : 'c', ++ (blk[15 + 1] & (1<<28)) ? 'V' : 'v', ++ (blk[15 + 1] & (1<<27)) ? 'I' : 'i', ++ (blk[15 + 1] & (1<<26)) ? 'F' : 'f'); ++ } ++ ++ unsigned int *pc = (unsigned int *) (blk[15 + 1] & pcmask); ++ ++ /* Try LR if PC invalid (e.g. with a prefetch abort). */ ++ if (pc < (unsigned int *)0x8000 || !__valid_address (pc - 5, pc + 4)) ++ pc = (unsigned int *) (blk[14 + 1] & pcmask); ++ ++ if (pc >= (unsigned int *)0x8000 && __valid_address (pc - 5, pc + 4)) ++ { ++ for (unsigned int *diss = pc - 5; diss < pc + 4; diss++) ++ { ++ const char *ins; ++ int length; ++ _swix (Debugger_Disassemble, _INR(0,1) | _OUTR(1,2), ++ *diss, diss, &ins, &length); ++ ++ const unsigned char c[4] = ++ { ++ (*diss >> 0) & 0xFF, ++ (*diss >> 8) & 0xFF, ++ (*diss >> 16) & 0xFF, ++ (*diss >> 24) ++ }; ++ fprintf (stderr, "\n %08x : %c%c%c%c : %08x : ", ++ (unsigned int) diss, ++ (c[0] >= ' ' && c[0] != 127) ? c[0] : '.', ++ (c[1] >= ' ' && c[1] != 127) ? c[1] : '.', ++ (c[2] >= ' ' && c[2] != 127) ? c[2] : '.', ++ (c[3] >= ' ' && c[3] != 127) ? c[3] : '.', ++ *diss); ++ fwrite (ins, length, 1, stderr); ++ } ++ } ++ else ++ fputs ("\n [Disassembly not available]", stderr); ++ } ++ ++ fputs ("\n\n", stderr); ++} ++ + /* Clang and GCC do not have compatible frame pointers. */ + #ifdef __clang__ + #define FP_OFFSET (0) + #define LR_OFFSET (1) +-#elif defined (__ARM_EABI__) +-#define FP_OFFSET (-1) +-#define LR_OFFSET (0) + #else + #define LR_OFFSET (-1) + #define FP_OFFSET (-3) + #endif + ++#ifdef __ARM_EABI__ ++/** ++ * AAPCS does not require the compiler to construct a backtrace structure ++ * in the stack (unlike APCS, which does). This results in FP rarely pointing ++ * at any form of valid stack frame (and, to complicate matters, at the time ++ * of writing, some frames end up with APCS-format frame records, anyway) ++ * which makes it nigh-on impossible to reliably unwind the stack without ++ * additional information). FP is thus often treated as an additional ++ * callee-saved register (i.e. v8) in AAPCS-conformant code. ++ * ++ * Additionally, where frame records are generated, AAPCS has them contain ++ * two entries: previous-FP and LR on entry. There is therefore (unlike APCS) ++ * no way of finding the function entry point from the frame record at all, ++ * even if it did exist. ++ * ++ * So, we cannot trust that FP ever points at a valid stack frame record and ++ * we cannot find function entry points to extract poked function names from. ++ * We can, however, make stack unwinding work if we have some means of ++ * identifying the function in which an arbitrary instruction lies. ++ * ++ * -funwind-tables will result in clang/GCC generating such a data structure, ++ * (an array between __exidx_start and __exidx_end) which will be consulted ++ * by _Unwind_Backtrace() when unwinding the stack. ++ */ ++ ++#include <unwind.h> ++ ++typedef struct { ++ const unsigned int *regs; ++ const unsigned int *last_fn; ++} ul_unwind_ctx; ++ ++static void __attribute__((naked)) ++__do_unwind (_Unwind_Trace_Fn fn, const void *pw) ++{ ++ __asm volatile( ++ "stmfd sp!, {fp, lr};" ++ "add fp, sp, #4;" ++ /* Registers at this point in time will be the initial state. ++ * The trace function must unwind the stack frame we just created ++ * because the personality function will be told there is nothing ++ * to do as we are declared naked. ++ */ ++ "bl _Unwind_Backtrace;" ++ "ldmfd sp!, {fp, pc};" ++ ); ++} ++ ++static _Unwind_Reason_Code ++__write_backtrace_cb (_Unwind_Context *ctx, void *pw) ++{ ++ ul_unwind_ctx *uctx = pw; ++ _Unwind_Control_Block *ucbp = NULL; ++ const unsigned int *fn; ++ ++ ucbp = (_Unwind_Control_Block *) _Unwind_GetGR(ctx, UNWIND_POINTER_REG); ++ fn = (const unsigned int *) ucbp->pr_cache.fnstart; ++ ++ uctx->last_fn = fn; ++ ++ if (fn == (const unsigned int *) __do_unwind) ++ { ++ /* First call */ ++ if (uctx->regs == NULL) ++ { ++ /* Running thread: unwind on behalf of __do_unwind */ ++ _Unwind_VRS_Pop (ctx, _UVRSC_CORE, (1<<11)|(1<<14), _UVRSD_UINT32); ++ } ++ else ++ { ++ /* Thread backtrace: replace entire VRS */ ++ int idx; ++ for (idx = 16; idx > 0; idx--) ++ _Unwind_SetGR (ctx, idx - 1, uctx->regs[idx - 1]); ++ } ++ ++ return _URC_NO_REASON; ++ } ++ ++ fprintf (stderr, " (%8x) fn: %8x pc: %8x sp: %8x ", ++ _Unwind_GetGR (ctx, 11), (unsigned int)fn, _Unwind_GetIP (ctx), ++ _Unwind_GetGR (ctx, 13)); ++ ++#if PIC ++ /* FIXME: extend this with source location when available. */ ++ const char *lib = NULL; ++ unsigned offset; ++ _swix(SOM_Location, ++ _IN(0) | _OUTR(0,1), _Unwind_GetIP (ctx), &lib, &offset); ++ if (lib) ++ fprintf(stderr, " : %8X : %s\n", offset, lib); ++ else ++#endif ++ { ++ int cplusplus_name; ++ const char *name = extract_name (fn, &cplusplus_name); ++ fprintf (stderr, (cplusplus_name) ? " %s\n" : " %s()\n", name); ++ } ++ ++ return _URC_NO_REASON; ++} ++ + static void ++__write_backtrace_thread (const unsigned int *regs) ++{ ++ ul_unwind_ctx ctx; ++ ++ /* First pass: dump trace for stack as provided */ ++ ctx.regs = regs; ++ ctx.last_fn = NULL; ++ __do_unwind (__write_backtrace_cb, &ctx); ++ ++ /* If we got here via an environment handler, there may be a saved abort ++ * block to look at. We only want to look if the first pass terminated with ++ * __unixlib_raise_signal (being the entry point to all this unwind logic ++ * from the environment handlers) -- if the first pass terminated somewhere ++ * else, then it is likely that we have been invoked directly via raise(), ++ * and so the presence or otherwise of an abort block is irrelevant. ++ * ++ * If an abort block is available, it will be pointed at by the ++ * (misnamed for EABI) __ul_callbackfp; if not __ul_callbackfp will be NULL. ++ * Additionally, we only want to consider the abort block if we're dumping ++ * the running thread, so check for regs being NULL to identify that. ++ */ ++ if (__ul_callbackfp != NULL && regs == NULL ++ && ctx.last_fn == (unsigned int *) __unixlib_raise_signal) ++ { ++ /* Abort block: cpsr, r0-r15. */ ++ __write_abort_block (__ul_callbackfp, /* is32bit= */ 1); ++ ++ /* Dump remaining trace from block (skipping over saved CPSR) */ ++ ctx.regs = __ul_callbackfp + 1; ++ ctx.last_fn = NULL; ++ __do_unwind (__write_backtrace_cb, &ctx); ++ } ++ ++ fputc ('\n', stderr); ++} ++#else ++static void + __write_backtrace_thread (const unsigned int *fp) + { + /* Running as USR26 or USR32 ? */ +@@ -306,22 +517,6 @@ + break; + } + +-#ifdef __ARM_EABI__ +- const unsigned int * const lr = (unsigned int *)fp[LR_OFFSET]; +- fprintf (stderr, " (%8x) lr: %8x", +- (unsigned int)fp, (unsigned int)lr); +-#if PIC +- /* FIXME: extend this with source location when available. */ +- const char *lib = NULL; +- unsigned offset; +- _swix(SOM_Location, +- _IN(0) | _OUTR(0,1), lr, &lib, &offset); +- if (lib) +- fprintf(stderr, " : %8X : %s\n", offset, lib); +- else +-#endif +- fputc('\n', stderr); +-#else + /* Retrieve PC counter. + PC counter has been saved using STMxx ..., { ..., PC } so it can be + 8 or 12 bytes away from the STMxx instruction depending on the ARM +@@ -347,96 +542,24 @@ + int cplusplus_name; + const char *name = extract_name (pc, &cplusplus_name); + fprintf (stderr, (cplusplus_name) ? " %s\n" : " %s()\n", name); +-#endif ++ + oldfp = fp; + fp = (const unsigned int *)fp[FP_OFFSET]; +-#ifndef __ARM_EABI__ + if (__ul_callbackfp != NULL && fp == __ul_callbackfp) + { + /* At &oldfp[1] = cpsr, a1-a4, v1-v6, sl, fp, ip, sp, lr, pc */ +- fprintf (stderr, "\n Register dump at %08x:\n", +- (unsigned int) &oldfp[1]); +- +- if (!__valid_address (oldfp + 1, oldfp + 18)) +- fputs ("\n [bad register dump address]\n", stderr); +- else +- { +- const char rnames[] = "a1a2a3a4v1v2v3v4v5v6slfpipsplrpc"; +- for (int reg = 0; reg < 16; reg++) +- { +- if ((reg & 0x3) == 0) +- fputs ("\n ", stderr); +- +- fprintf (stderr, " %c%c: %8x", +- rnames[2*reg + 0], rnames[2*reg + 1], oldfp[reg + 2]); +- } +- +- if (is32bit) +- fprintf (stderr, "\n cpsr: %8x\n", oldfp[1]); +- else +- { +- const char * const pmode[4] = { "USR", "FIQ", "IRQ", "SVC" }; +- fprintf (stderr, "\n Mode %s, flags set: %c%c%c%c%c%c\n", +- pmode[oldfp[15 + 2] & 3], +- (oldfp[15 + 2] & (1<<31)) ? 'N' : 'n', +- (oldfp[15 + 2] & (1<<30)) ? 'Z' : 'z', +- (oldfp[15 + 2] & (1<<29)) ? 'C' : 'c', +- (oldfp[15 + 2] & (1<<28)) ? 'V' : 'v', +- (oldfp[15 + 2] & (1<<27)) ? 'I' : 'i', +- (oldfp[15 + 2] & (1<<26)) ? 'F' : 'f'); +- } +- +- pc = (unsigned int *) (oldfp[17] & pcmask); +- +- /* Try LR if PC invalid (e.g. with a prefetch abort). */ +- if (pc < (unsigned int *)0x8000 || !__valid_address (pc - 5, pc + 4)) +- pc = (unsigned int *) (oldfp[16] & pcmask); +- +- if (pc >= (unsigned int *)0x8000 && __valid_address (pc - 5, pc + 4)) +- { +- for (unsigned int *diss = pc - 5; diss < pc + 4; diss++) +- { +- const char *ins; +- int length; +- _swix (Debugger_Disassemble, _INR(0,1) | _OUTR(1,2), +- *diss, diss, &ins, &length); +- +- const unsigned char c[4] = +- { +- (*diss >> 0) & 0xFF, +- (*diss >> 8) & 0xFF, +- (*diss >> 16) & 0xFF, +- (*diss >> 24) +- }; +- fprintf (stderr, "\n %08x : %c%c%c%c : %08x : ", +- (unsigned int) diss, +- (c[0] >= ' ' && c[0] != 127) ? c[0] : '.', +- (c[1] >= ' ' && c[1] != 127) ? c[1] : '.', +- (c[2] >= ' ' && c[2] != 127) ? c[2] : '.', +- (c[3] >= ' ' && c[3] != 127) ? c[3] : '.', +- *diss); +- fwrite (ins, length, 1, stderr); +- } +- } +- else +- fputs ("\n [Disassembly not available]", stderr); +- } +- +- fputs ("\n\n", stderr); ++ __write_abort_block (&oldfp[1], is32bit); + } +-#endif + } + + fputc ('\n', stderr); + } ++#endif + +- + void + __write_backtrace (int signo) + { +-#ifdef __ARM_EABI__ +- register const unsigned int *fp = __builtin_frame_address(0); +-#else ++#ifndef __ARM_EABI__ + register const unsigned int *fp __asm ("fp"); + #endif + +@@ -485,7 +608,11 @@ + /* Dump first the details of the current thread. */ + fprintf (stderr, "Stack backtrace:\n\nRunning thread %p (%s)\n", + __pthread_running_thread, __pthread_running_thread->name); ++#ifdef __ARM_EABI__ ++ __write_backtrace_thread (NULL); ++#else + __write_backtrace_thread (fp); ++#endif + + /* And then the other suspended threads if any. */ + for (pthread_t th = __pthread_thread_list; th != NULL; th = th->next) +@@ -494,7 +621,10 @@ + continue; + + fprintf (stderr, "\nThread %p (%s)\n", th, th->name); +-#ifdef __clang__ ++#ifdef __ARM_EABI__ ++ __write_backtrace_thread (&th->saved_context->r[0]); ++#else ++# ifdef __clang__ + const unsigned int fakestackframe[] = + { + (unsigned int)th->saved_context->r[11], +@@ -501,22 +631,16 @@ + (unsigned int)th->saved_context->r[14] + }; + __write_backtrace_thread (&fakestackframe[0]); +-#elif defined (__ARM_EABI__) ++# else + const unsigned int fakestackframe[] = + { + (unsigned int)th->saved_context->r[11], +- (unsigned int)th->saved_context->r[14] +- }; +- __write_backtrace_thread (&fakestackframe[1]); +-#else +- const unsigned int fakestackframe[] = +- { +- (unsigned int)th->saved_context->r[11], + (unsigned int)th->saved_context->r[13], + (unsigned int)th->saved_context->r[14], + (unsigned int)th->saved_context->r[15] + }; + __write_backtrace_thread (&fakestackframe[3]); ++# endif + #endif + } + } |