CPU_CFLAGS-$(COMPILE_IN_THUMB_MODE)+=-mthumb
endif
+ifeq ($(TARGET_ARCH),metag)
+ SYMBOL_PREFIX=_
+ CPU_CFLAGS-$(CONFIG_META_1_2)+=
+ CPU_CFLAGS-$(CONFIG_META_2_1)+=-Wa,-mcpu=metac21
+endif
+
ifeq ($(TARGET_ARCH),mips)
OPTIMIZATION+=-mno-split-addresses
CPU_CFLAGS-$(CONFIG_MIPS_ISA_1)+=-mips1
default TARGET_i960 if DESIRED_TARGET_ARCH = "i960"
default TARGET_ia64 if DESIRED_TARGET_ARCH = "ia64"
default TARGET_m68k if DESIRED_TARGET_ARCH = "m68k"
+ default TARGET_metag if DESIRED_TARGET_ARCH = "metag"
default TARGET_microblaze if DESIRED_TARGET_ARCH = "microblaze"
default TARGET_mips if DESIRED_TARGET_ARCH = "mips"
default TARGET_nios if DESIRED_TARGET_ARCH = "nios"
config TARGET_m68k
bool "m68k"
+config TARGET_metag
+ bool "metag"
+
config TARGET_microblaze
bool "microblaze"
source "extra/Configs/Config.m68k"
endif
+if TARGET_metag
+source "extra/Configs/Config.metag"
+endif
+
if TARGET_nios
source "extra/Configs/Config.nios"
endif
config UCLIBC_PREGENERATED_LOCALE_DATA
bool "Use Pre-generated Locale Data"
- depends on UCLIBC_HAS_LOCALE
+ depends on UCLIBC_HAS_LOCALE && !TARGET_metag
help
Use pre-built locale data.
--- /dev/null
+#
+# For a description of the syntax of this configuration file,
+# see extra/config/Kconfig-language.txt
+#
+# Copyright (C) 2013, Imagination Technologies Ltd.
+#
+# Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+#
+
+config TARGET_ARCH
+ default "metag"
+
+config FORCE_OPTIONS_FOR_ARCH
+ bool
+ default y
+ select ARCH_LITTLE_ENDIAN
+ select ARCH_HAS_MMU
+
+choice
+ prompt "Target Processor Type"
+ default CONFIG_META_2_1
+ help
+ This is the processor type of your CPU. This information is used for
+ optimizing purposes.
+
+config CONFIG_META_1_2
+ bool "Meta 1.2"
+
+config CONFIG_META_2_1
+ bool "Meta 2.1"
+
+endchoice
--- /dev/null
+TARGET_metag=y
--- /dev/null
+/*
+ * Meta ELF shared library loader support.
+ *
+ * Program to load an elf binary on a linux system, and run it.
+ * References to symbols in sharable libraries can be resolved
+ * by either an ELF sharable library or a linux style of shared
+ * library.
+ *
+ * Copyright (C) 2013, Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+static const char *_dl_reltypes_tab[] = {
+ [0] "R_METAG_HIADDR16", "R_METAG_LOADDR16", "R_METAG_ADDR32",
+ [3] "R_METAG_NONE", "R_METAG_RELBRANCH", "R_METAG_GETSETOFF",
+ [6] "R_METAG_REG32OP1", "R_METAG_REG32OP2", "R_METAG_REG32OP3",
+ [9] "R_METAG_REG16OP1", "R_METAG_REG16OP2", "R_METAG_REG16OP3",
+ [12] "R_METAG_REG32OP4", "R_METAG_HIOG", "R_METAG_LOOG",
+ [30] "R_METAG_VTINHERIT", "R_METAG_VTENTRY",
+ [32] "R_METAG_HI16_GOTOFF", "R_METAG_LO16_GOTOFF",
+ [34] "R_METAG_GETSET_GOTOFF", "R_METAG_GETSET_GOT",
+ [36] "R_METAG_HI16_GOTPC", "R_METAG_LO16_GOTPC",
+ [38] "R_METAG_HI16_PLT", "R_METAG_LO16_PLT",
+ [40] "R_METAG_RELBRANCH_PLT", "R_METAG_GOTOFF",
+ [42] "R_METAG_PLT", "R_METAG_COPY", "R_METAG_JMP_SLOT",
+};
--- /dev/null
+/*
+ * Copyright (C) 2013 Imagination Technologies Ltd.
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+/*
+ * This code fixes the stack pointer so that the dynamic linker
+ * can find argc, argv and auxvt (Auxillary Vector Table).
+ */
+
+__asm__ (
+" .text\n"
+" .global __start\n"
+" .type __start,@function\n"
+" .hidden __start\n"
+"_start:\n"
+"__start:\n"
+" MSETL [A0StP++],D0Ar4,D0Ar2\n"
+" MOV D1Ar1,D0Ar2\n"
+" CALLR D1RtP,__dl_start\n"
+" GETL D0Ar2,D1Ar1,[A0StP+#-(1*8)]\n"
+" GETL D0Ar4,D1Ar3,[A0StP+#-(2*8)]\n"
+" SUB A0StP,A0StP,#(2*8)\n"
+" MOV PC,D0Re0\n"
+" .size __start,.-__start\n"
+" .previous\n"
+);
+
+
+/*
+ * Get a pointer to the argv array. On many platforms this can be just
+ * the address if the first argument, on other platforms we need to
+ * do something a little more subtle here.
+ */
+
+#define GET_ARGV(ARGVP, ARGS) ARGVP = (((unsigned long *) ARGS))
+
+
+/* Handle relocation of the symbols in the dynamic loader. */
+static inline
+void PERFORM_BOOTSTRAP_RELOC(ELF_RELOC *rpnt, unsigned long *reloc_addr,
+ unsigned long symbol_addr, unsigned long load_addr, Elf32_Sym *symtab)
+{
+ switch (ELF32_R_TYPE(rpnt->r_info)) {
+ case R_METAG_GLOB_DAT:
+ case R_METAG_JMP_SLOT:
+ case R_METAG_ADDR32:
+ *reloc_addr = symbol_addr;
+ break;
+ case R_METAG_RELATIVE:
+ *reloc_addr = load_addr + rpnt->r_addend;
+ break;
+ case R_METAG_RELBRANCH:
+ *reloc_addr = symbol_addr + rpnt->r_addend - *reloc_addr - 4;
+ break;
+ case R_METAG_NONE:
+ break;
+ default:
+ _dl_exit(1);
+ break;
+ }
+}
--- /dev/null
+/* stub for arch-specific syscall issues
+ *
+ * Copyright (C) 2013, Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
--- /dev/null
+/*
+ * Meta can never use Elf32_Rel relocations.
+ *
+ * Copyright (C) 2013, Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#define ELF_USES_RELOCA
+
+#include <elf.h>
+
+/* Initialization sequence for the GOT. */
+#define INIT_GOT(GOT_BASE,MODULE) \
+{ \
+ GOT_BASE[1] = (unsigned long) MODULE; \
+ GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
+}
+
+/* Maximum unsigned GOT [GS]ETD offset size, ie. 2^(11+2). */
+#define GOT_REG_OFFSET 0x2000
+
+/* Defined some magic numbers that this ld.so should accept. */
+#define MAGIC1 EM_METAG
+#undef MAGIC2
+#define ELF_TARGET "META"
+
+/* Need bootstrap relocations */
+#define ARCH_NEEDS_BOOTSTRAP_RELOCS
+
+struct elf_resolve;
+extern unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry);
+
+/* Variable page size. */
+#define ADDR_ALIGN (_dl_pagesize - 1)
+#define PAGE_ALIGN (~ADDR_ALIGN)
+#define OFFS_ALIGN (PAGE_ALIGN & ~(1ul << (sizeof(_dl_pagesize) * 8 - 1)))
+
+/* The union of reloc-type-classes where the reloc TYPE is a member.
+
+ TYPE is in the class ELF_RTYPE_CLASS_NOCOPY if it should not be allowed
+ to resolve to one of the main executable's symbols, as for a COPY
+ reloc. */
+#define elf_machine_type_class(type) \
+ (((((type) == R_METAG_JMP_SLOT)) * ELF_RTYPE_CLASS_PLT) \
+ | (((type) == R_METAG_COPY) * ELF_RTYPE_CLASS_COPY))
+
+static inline Elf32_Addr
+elf_machine_dynamic(Elf32_Ehdr *header)
+{
+ Elf32_Addr *got;
+
+ __asm__ ("MOV %0,A1LbP" : "=r" (got));
+
+ if (header->e_ident[EI_ABIVERSION] >= 1) {
+ /* GOT register offset was introduced with ABI v1 */
+ got = (Elf32_Addr*)((void*)got - GOT_REG_OFFSET);
+ }
+ return *got;
+}
+
+#define DL_BOOT_COMPUTE_GOT(GOT) \
+ ((GOT) = elf_machine_dynamic(header))
+
+static inline Elf32_Addr
+elf_machine_load_address(void)
+{
+ Elf32_Addr addr;
+ __asm__ ("MOV D1Ar1,A1LbP\n"
+ "ADDT D1Ar1,D1Ar1,#HI(__dl_start@GOTOFF)\n"
+ "ADD D1Ar1,D1Ar1,#LO(__dl_start@GOTOFF)\n"
+ "ADDT D0Ar2,D0Ar2,#HI(__dl_start_addr@GOTOFF)\n"
+ "ADD D0Ar2,D0Ar2,#LO(__dl_start_addr@GOTOFF)\n"
+ "GETD D0Ar2,[D0Ar2]\n"
+ "SUB %0,D1Ar1,D0Ar2\n"
+ ".section .data\n"
+ "__dl_start_addr: .long __dl_start\n"
+ ".previous\n"
+ : "=d" (addr) : : "D1Ar1", "D0Ar2");
+ return addr;
+}
+
+static inline void
+elf_machine_relative(Elf32_Addr load_off, const Elf32_Addr rel_addr,
+ Elf32_Word relative_count)
+{
+ Elf32_Rela *rpnt = (void *)rel_addr;
+
+ --rpnt;
+ do {
+ Elf32_Addr *const reloc_addr =
+ (void *)(load_off + (++rpnt)->r_offset);
+
+ *reloc_addr = load_off + rpnt->r_addend;
+ } while (--relative_count);
+}
+
+#define DL_MALLOC_ALIGN 8
--- /dev/null
+/*
+ * Meta ELF shared library loader support.
+ *
+ * Program to load an elf binary on a linux system, and run it.
+ * References to symbols in sharable libraries can be resolved
+ * by either an ELF sharable library or a linux style of shared
+ * library.
+ *
+ * Copyright (C) 2013, Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#include "ldso.h"
+
+/* Defined in resolve.S. */
+extern int _dl_linux_resolve(void);
+
+static inline unsigned long __get_unaligned_reloc(unsigned long *addr)
+{
+ char *rel_addr = (char *)addr;
+ unsigned long val;
+
+ val = *rel_addr++ & 0xff;
+ val |= (*rel_addr++ << 8) & 0x0000ff00;
+ val |= (*rel_addr++ << 16) & 0x00ff0000;
+ val |= (*rel_addr++ << 24) & 0xff000000;
+
+ return val;
+}
+
+static inline void __put_unaligned_reloc(unsigned long *addr,
+ unsigned long val)
+{
+ char *rel_addr = (char *)addr;
+
+ *rel_addr++ = (val & 0x000000ff);
+ *rel_addr++ = ((val & 0x0000ff00) >> 8);
+ *rel_addr++ = ((val & 0x00ff0000) >> 16);
+ *rel_addr++ = ((val & 0xff000000) >> 24);
+}
+
+unsigned long
+_dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
+{
+ int reloc_type;
+ int symtab_index;
+ char *strtab;
+ char *symname;
+ char *new_addr;
+ char *rel_addr;
+ char **got_addr;
+ Elf32_Sym *symtab;
+ ELF_RELOC *this_reloc;
+ unsigned long instr_addr;
+
+ rel_addr = (char *)tpnt->dynamic_info[DT_JMPREL];
+
+ this_reloc = (ELF_RELOC *)(intptr_t)(rel_addr + reloc_entry);
+ reloc_type = ELF32_R_TYPE(this_reloc->r_info);
+ symtab_index = ELF32_R_SYM(this_reloc->r_info);
+
+ symtab = (Elf32_Sym *)(intptr_t)tpnt->dynamic_info[DT_SYMTAB];
+ strtab = (char *)tpnt->dynamic_info[DT_STRTAB];
+ symname = strtab + symtab[symtab_index].st_name;
+
+ if (unlikely(reloc_type != R_METAG_JMP_SLOT)) {
+ _dl_dprintf(2, "%s: Incorrect relocation type in jump relocations\n",
+ _dl_progname);
+ _dl_exit(1);
+ }
+
+ /* Address of the jump instruction to fix up. */
+ instr_addr = ((unsigned long)this_reloc->r_offset +
+ (unsigned long)tpnt->loadaddr);
+ got_addr = (char **)instr_addr;
+
+ /* Get the address of the GOT entry. */
+ new_addr = _dl_find_hash(symname, tpnt->symbol_scope, tpnt,
+ ELF_RTYPE_CLASS_PLT, NULL);
+ if (unlikely(!new_addr)) {
+ _dl_dprintf(2, "%s: Can't resolve symbol '%s'\n", _dl_progname, symname);
+ _dl_exit(1);
+ }
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ if (_dl_debug_bindings) {
+ _dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
+ if (_dl_debug_detail)
+ _dl_dprintf(_dl_debug_file,
+ "\n\tpatched: %x ==> %x @ %x\n",
+ *got_addr, new_addr, got_addr);
+ }
+ if (!_dl_debug_nofixups) {
+ *got_addr = new_addr;
+ }
+#else
+ *got_addr = new_addr;
+#endif
+
+ return (unsigned long)new_addr;
+}
+
+static int
+_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
+ unsigned long rel_addr, unsigned long rel_size,
+ int (*reloc_fnc)(struct elf_resolve *tpnt, struct dyn_elf *scope,
+ ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab))
+{
+ int symtab_index;
+ unsigned int i;
+ char *strtab;
+ Elf32_Sym *symtab;
+ ELF_RELOC *rpnt;
+
+ /* Parse the relocation information. */
+ rpnt = (ELF_RELOC *)(intptr_t)rel_addr;
+ rel_size /= sizeof(ELF_RELOC);
+
+ symtab = (Elf32_Sym *)(intptr_t)tpnt->dynamic_info[DT_SYMTAB];
+ strtab = (char *)tpnt->dynamic_info[DT_STRTAB];
+
+ for (i = 0; i < rel_size; i++, rpnt++) {
+ int res;
+
+ symtab_index = ELF32_R_SYM(rpnt->r_info);
+
+ debug_sym(symtab, strtab, symtab_index);
+ debug_reloc(symtab, strtab, rpnt);
+
+ /* Pass over to actual relocation function. */
+ res = reloc_fnc(tpnt, scope, rpnt, symtab, strtab);
+
+ if (res == 0)
+ continue;
+
+ _dl_dprintf(2, "\n%s: ", _dl_progname);
+
+ if (symtab_index)
+ _dl_dprintf(2, "symbol '%s': ",
+ strtab + symtab[symtab_index].st_name);
+
+ if (unlikely(res < 0)) {
+ int reloc_type = ELF32_R_TYPE(rpnt->r_info);
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ _dl_dprintf(2, "can't handle reloc type %s\n",
+ _dl_reltypes(reloc_type));
+#else
+ _dl_dprintf(2, "can't handle reloc type %x\n",
+ reloc_type);
+#endif
+ _dl_exit(-res);
+ } else if (unlikely(res > 0)) {
+ _dl_dprintf(2, "can't resolve symbol\n");
+ return res;
+ }
+ }
+
+ return 0;
+}
+
+static int
+_dl_do_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope,
+ ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
+{
+ int reloc_type;
+ int symtab_index;
+ char *symname = NULL;
+ unsigned long *reloc_addr;
+ unsigned long symbol_addr;
+#if defined (__SUPPORT_LD_DEBUG__)
+ unsigned long old_val;
+#endif
+
+ reloc_addr = (unsigned long *)(intptr_t)(tpnt->loadaddr + (unsigned long)rpnt->r_offset);
+ reloc_type = ELF32_R_TYPE(rpnt->r_info);
+ symtab_index = ELF32_R_SYM(rpnt->r_info);
+ symbol_addr = 0;
+ symname = strtab + symtab[symtab_index].st_name;
+
+ if (symtab_index) {
+ if (symtab[symtab_index].st_shndx != SHN_UNDEF &&
+ ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_LOCAL) {
+ symbol_addr = (unsigned long)tpnt->loadaddr;
+ } else {
+ symbol_addr = (unsigned long)_dl_find_hash(symname, scope, tpnt,
+ elf_machine_type_class(reloc_type), NULL);
+ }
+
+ if (unlikely(!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK)) {
+ _dl_dprintf(2, "%s: can't resolve symbol '%s'\n", _dl_progname, symname);
+ _dl_exit(1);
+ };
+
+ symbol_addr += rpnt->r_addend;
+ }
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ if (reloc_type != R_METAG_NONE)
+ old_val = __get_unaligned_reloc(reloc_addr);
+#endif
+
+ switch (reloc_type) {
+ case R_METAG_NONE:
+ break;
+ case R_METAG_GLOB_DAT:
+ case R_METAG_JMP_SLOT:
+ case R_METAG_ADDR32:
+ __put_unaligned_reloc(reloc_addr, symbol_addr);
+ break;
+ case R_METAG_COPY:
+#if defined (__SUPPORT_LD_DEBUG__)
+ if (_dl_debug_move)
+ _dl_dprintf(_dl_debug_file,
+ "\t%s move %d bytes from %x to %x\n",
+ symname, symtab[symtab_index].st_size,
+ symbol_addr, reloc_addr);
+#endif
+
+ _dl_memcpy((char *)reloc_addr,
+ (char *)symbol_addr,
+ symtab[symtab_index].st_size);
+ break;
+ case R_METAG_RELATIVE:
+ __put_unaligned_reloc(reloc_addr,
+ (unsigned long)tpnt->loadaddr +
+ rpnt->r_addend);
+ break;
+ default:
+ return -1; /* Calls _dl_exit(1). */
+ }
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ if (_dl_debug_reloc && _dl_debug_detail &&
+ (reloc_type != R_METAG_NONE)) {
+ unsigned long new_val = __get_unaligned_reloc(reloc_addr);
+ _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x\n",
+ old_val, new_val, reloc_addr);
+ }
+#endif
+
+ return 0;
+}
+
+static int
+_dl_do_lazy_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope,
+ ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
+{
+ int reloc_type;
+ unsigned long *reloc_addr;
+#if defined (__SUPPORT_LD_DEBUG__)
+ unsigned long old_val;
+#endif
+
+ reloc_addr = (unsigned long *)(intptr_t)(tpnt->loadaddr + (unsigned long)rpnt->r_offset);
+ reloc_type = ELF32_R_TYPE(rpnt->r_info);
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ old_val = *reloc_addr;
+#endif
+
+ switch (reloc_type) {
+ case R_METAG_NONE:
+ break;
+ case R_METAG_JMP_SLOT:
+ *reloc_addr += (unsigned long)tpnt->loadaddr;
+ break;
+ default:
+ return -1; /* Calls _dl_exit(1). */
+ }
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ if (_dl_debug_reloc && _dl_debug_detail)
+ _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x\n",
+ old_val, *reloc_addr, reloc_addr);
+#endif
+
+ return 0;
+}
+
+/* External interface to the generic part of the dynamic linker. */
+
+void
+_dl_parse_lazy_relocation_information(struct dyn_elf *rpnt,
+ unsigned long rel_addr,
+ unsigned long rel_size)
+{
+ _dl_parse(rpnt->dyn, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
+}
+
+int
+_dl_parse_relocation_information(struct dyn_elf *rpnt,
+ unsigned long rel_addr,
+ unsigned long rel_size)
+{
+ return _dl_parse(rpnt->dyn, rpnt->dyn->symbol_scope, rel_addr,
+ rel_size, _dl_do_reloc);
+}
--- /dev/null
+/*
+ * Meta dynamic resolver
+ *
+ * Copyright (C) 2013 Imagination Technologies Ltd.
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ *
+ * This function is _not_ called directly. It is jumped to (so no return
+ * address is on the stack) when attempting to use a symbol that has not yet
+ * been resolved. The first time a jump symbol (such as a function call inside
+ * a shared library) is used (before it gets resolved) it will jump here to
+ * _dl_linux_resolve. When we get called the stack looks like this:
+ * reloc_entry
+ * tpnt
+ *
+ * This function saves all the registers then makes the function call
+ * _dl_linux_resolver(tpnt, reloc_entry). _dl_linux_resolver() figures out
+ * where the jump symbol is _really_ supposed to have jumped to and returns
+ * that to us. Once we have that, we overwrite tpnt with this fixed up
+ * address. We then clean up after ourselves, put all the registers back how we
+ * found them, then we jump to the fixed up address, which is where the jump
+ * symbol that got us here really wanted to jump to in the first place.
+ * -Erik Andersen
+ */
+
+ .text
+ .global __dl_linux_resolve
+ .type __dl_linux_resolve,@function
+
+__dl_linux_resolve:
+ !! Save registers on the stack. Do we need to save any more here?
+ MSETL [A0StP++],D0Ar6,D0Ar4,D0Ar2,D0FrT
+ SETL [A0StP++],A0FrP,A1LbP
+ !! Get the args for _dl_linux_resolver off the stack
+ GETL D0Re0,D1Re0,[A0StP+#-(6*8)]
+ GETD D1Ar1,[D0Re0]
+ MOV D0Ar2,D1Re0
+ !! Multiply plt_index by sizeof(Elf32_Rela)
+ MULW D0Ar2,D0Ar2,#12
+ !! Call the resolver
+ CALLR D1RtP,__dl_linux_resolver
+ !! Restore the registers from the stack
+ SUB A0.2,A0StP,#(1*8)
+ GETL A0FrP,A1LbP,[A0.2]
+ SUB A0.2,A0.2,#(4*8)
+ MGETL D0Ar6,D0Ar4,D0Ar2,D0FrT,[A0.2]
+ !! Also take into account args pushed by PLT
+ SUB A0StP,A0StP,#(6*8)
+ !! Jump to the resolved address
+ MOV PC,D0Re0
+ .size __dl_linux_resolve, .-__dl_linux_resolve
--- /dev/null
+# Makefile for uClibc
+#
+#
+# Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+#
+
+top_srcdir:=../../../
+top_builddir:=../../../
+all: objs
+include $(top_builddir)Rules.mak
+include ../Makefile.in
+include $(top_srcdir)Makerules
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+!
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+ .text
+ .global _memchr
+ .type _memchr,function
+! D0Ar6 src
+! D0Ar2 c
+! D1Ar3 n
+_memchr:
+ CMP D1Ar3, #0
+ BEQ $Lexit_fail
+ !! convert c to unsigned char
+ AND D0Ar2,D0Ar2,#0xff
+ MOV D0Ar6, D1Ar1
+ MOV D1Ar5, D0Ar6
+ !! test alignment
+ AND D1Ar5, D1Ar5, #7
+ CMP D1Ar5, #0
+ BNZ $Lunaligned_loop
+ !! length must be greater than or equal to 8 for aligned loop
+ CMP D1Ar3, #8
+ BGE $Laligned_setup
+$Lunaligned_loop:
+ !! get 1 char from s
+ GETB D0Re0, [D0Ar6++]
+ !! increase alignment counter
+ ADD D1Ar5, D1Ar5, #1
+ !! decrement n
+ SUB D1Ar3, D1Ar3, #1
+ !! exit if we have a match
+ CMP D0Re0, D0Ar2
+ BZ $Lexit_success1
+ !! exit if we have hit the end of the string
+ CMP D1Ar3, #0
+ BZ $Lexit_fail
+ !! fall through if the buffer is aligned now
+ CMP D1Ar5, #8
+ BNE $Lunaligned_loop
+ !! fall through if there is more than 8 bytes left
+ CMP D1Ar3, #8
+ BLT $Lunaligned_loop
+$Laligned_setup:
+ !! fill the c into 4 bytes
+ MOV D0Ar4, D0Ar2
+ LSL D0Ar4, D0Ar4, #8
+ ADD D0Ar4, D0Ar4, D0Ar2
+ LSL D0Ar4, D0Ar4, #8
+ ADD D0Ar4, D0Ar4, D0Ar2
+ LSL D0Ar4, D0Ar4, #8
+ ADD D0Ar4, D0Ar4, D0Ar2
+ !! divide n by 8
+ MOV D1Ar5, D1Ar3
+ LSR D1Ar5, D1Ar5, #3
+$Laligned_loop:
+ !! get 8 chars from s
+ GETL D0Re0, D1Re0, [D0Ar6++]
+ !! decrement loop counter
+ SUB D1Ar5, D1Ar5, #1
+ !! test first 4 chars
+ XOR D0Re0, D0Re0, D0Ar4
+ !! test second 4 chars
+ MOV D0Ar2, D1Re0
+ XOR D1Re0, D0Ar2, D0Ar4
+ !! check for matches in the first 4 chars
+ MOV D0Ar2, D0Re0
+ ADDT D0Re0, D0Re0, #HI(0xfefefeff)
+ ADD D0Re0, D0Re0, #LO(0xfefefeff)
+ XOR D0Ar2, D0Ar2, #-1
+ AND D0Re0, D0Re0, D0Ar2
+ ANDMT D0Re0, D0Re0, #HI(0x80808080)
+ ANDMB D0Re0, D0Re0, #LO(0x80808080)
+ CMP D0Re0, #0
+ BNZ $Lmatch_word1
+ !! check for matches in the second 4 chars
+ MOV D1Ar1, D1Re0
+ ADDT D1Re0, D1Re0, #HI(0xfefefeff)
+ ADD D1Re0, D1Re0, #LO(0xfefefeff)
+ XOR D1Ar1, D1Ar1, #-1
+ AND D1Re0, D1Re0, D1Ar1
+ ANDMT D1Re0, D1Re0, #HI(0x80808080)
+ ANDMB D1Re0, D1Re0, #LO(0x80808080)
+ CMP D1Re0, #0
+ BNZ $Lmatch_word2
+ !! check if we have reached the end of the buffer
+ CMP D1Ar5, #0
+ BNE $Laligned_loop
+ !! exit if there are no chars left to check
+ AND D1Ar3, D1Ar3, #7
+ CMP D1Ar3, #0
+ BZ $Lexit_fail
+ !! recover c
+ AND D0Ar2, D0Ar4, #0xff
+$Lbyte_loop:
+ !! get 1 char from s
+ GETB D0Re0, [D0Ar6++]
+ !! decrement n
+ SUB D1Ar3, D1Ar3, #1
+ !! exit if we have a match
+ CMP D0Re0, D0Ar2
+ BZ $Lexit_success1
+ !! fall through if we have run out of chars
+ CMP D1Ar3, #0
+ BNE $Lbyte_loop
+
+$Lexit_fail:
+ MOV D0Re0, #0
+ B $Lend
+
+$Lmatch_word1:
+ !! move the match word into D1Re0
+ MOV D1Re0, D0Re0
+ !! roll back the buffer pointer by 4 chars
+ SUB D0Ar6, D0Ar6, #4
+$Lmatch_word2:
+ !! roll back the buffer pointer by 4 chars
+ SUB D0Ar6, D0Ar6, #4
+ !! exit if lowest byte is 0
+ MOV D1Ar1, D1Re0
+ AND D1Ar1, D1Ar1, #0xff
+ CMP D1Ar1, #0
+ BNE $Lexit_success2
+ !! advance buffer pointer to the next char
+ ADD D0Ar6, D0Ar6, #1
+ !! shift in the next lowest byte
+ LSR D1Re0, D1Re0, #8
+ !! exit if lowest byte is 0
+ MOV D1Ar1, D1Re0
+ AND D1Ar1, D1Ar1, #0xff
+ CMP D1Ar1, #0
+ BNE $Lexit_success2
+ !! advance buffer pointer to the next char
+ ADD D0Ar6, D0Ar6, #1
+ !! shift in the next lowest byte
+ LSR D1Re0, D1Re0, #8
+ !! exit if lowest byte is 0
+ MOV D1Ar1, D1Re0
+ AND D1Ar1, D1Ar1, #0xff
+ CMP D1Ar1, #0
+ BNE $Lexit_success2
+ !! the match must be in the last byte, exit
+ ADD D0Ar6, D0Ar6, #1
+ B $Lexit_success2
+
+$Lexit_success1:
+ SUB D0Ar6, D0Ar6, #1
+$Lexit_success2:
+ !! return the buffer pointer
+ MOV D0Re0, D0Ar6
+$Lend:
+ MOV PC, D1RtP
+
+ .size _memchr,.-_memchr
+
+libc_hidden_def(memchr)
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+ .text
+ .global _memcpy
+ .type _memcpy,function
+! D1Ar1 dst
+! D0Ar2 src
+! D1Ar3 cnt
+! D0Re0 dst
+_memcpy:
+ CMP D1Ar3, #16
+ MOV A1.2, D0Ar2 ! source pointer
+ MOV A0.2, D1Ar1 ! destination pointer
+ MOV A0.3, D1Ar1 ! for return value
+! If there are less than 16 bytes to copy use the byte copy loop
+ BGE $Llong_copy
+
+$Lbyte_copy:
+! Simply copy a byte at a time
+ SUBS TXRPT, D1Ar3, #1
+ BLT $Lend
+$Lloop_byte:
+ GETB D1Re0, [A1.2++]
+ SETB [A0.2++], D1Re0
+ BR $Lloop_byte
+
+$Lend:
+! Finally set return value and return
+ MOV D0Re0, A0.3
+ MOV PC, D1RtP
+
+$Llong_copy:
+ ANDS D1Ar5, D1Ar1, #7 ! test destination alignment
+ BZ $Laligned_dst
+
+! The destination address is not 8 byte aligned. We will copy bytes from
+! the source to the destination until the remaining data has an 8 byte
+! destination address alignment (i.e we should never copy more than 7
+! bytes here).
+$Lalign_dst:
+ GETB D0Re0, [A1.2++]
+ ADD D1Ar5, D1Ar5, #1 ! dest is aligned when D1Ar5 reaches #8
+ SUB D1Ar3, D1Ar3, #1 ! decrement count of remaining bytes
+ SETB [A0.2++], D0Re0
+ CMP D1Ar5, #8
+ BNE $Lalign_dst
+
+! We have at least (16 - 7) = 9 bytes to copy - calculate the number of 8 byte
+! blocks, then jump to the unaligned copy loop or fall through to the aligned
+! copy loop as appropriate.
+$Laligned_dst:
+ MOV D0Ar4, A1.2
+ LSR D1Ar5, D1Ar3, #3 ! D1Ar5 = number of 8 byte blocks
+ ANDS D0Ar4, D0Ar4, #7 ! test source alignment
+ BNZ $Lunaligned_copy ! if unaligned, use unaligned copy loop
+
+! Both source and destination are 8 byte aligned - the easy case.
+$Laligned_copy:
+ LSRS D1Ar5, D1Ar3, #5 ! D1Ar5 = number of 32 byte blocks
+ BZ $Lbyte_copy
+ SUB TXRPT, D1Ar5, #1
+
+$Laligned_32:
+ GETL D0Re0, D1Re0, [A1.2++]
+ GETL D0Ar6, D1Ar5, [A1.2++]
+ SETL [A0.2++], D0Re0, D1Re0
+ SETL [A0.2++], D0Ar6, D1Ar5
+ GETL D0Re0, D1Re0, [A1.2++]
+ GETL D0Ar6, D1Ar5, [A1.2++]
+ SETL [A0.2++], D0Re0, D1Re0
+ SETL [A0.2++], D0Ar6, D1Ar5
+ BR $Laligned_32
+
+! If there are any remaining bytes use the byte copy loop, otherwise we are done
+ ANDS D1Ar3, D1Ar3, #0x1f
+ BNZ $Lbyte_copy
+ B $Lend
+
+! The destination is 8 byte aligned but the source is not, and there are 8
+! or more bytes to be copied.
+$Lunaligned_copy:
+! Adjust the source pointer (A1.2) to the 8 byte boundary before its
+! current value
+ MOV D0Ar4, A1.2
+ MOV D0Ar6, A1.2
+ ANDMB D0Ar4, D0Ar4, #0xfff8
+ MOV A1.2, D0Ar4
+! Save the number of bytes of mis-alignment in D0Ar4 for use later
+ SUBS D0Ar6, D0Ar6, D0Ar4
+ MOV D0Ar4, D0Ar6
+! if there is no mis-alignment after all, use the aligned copy loop
+ BZ $Laligned_copy
+
+! prefetch 8 bytes
+ GETL D0Re0, D1Re0, [A1.2]
+
+ SUB TXRPT, D1Ar5, #1
+
+! There are 3 mis-alignment cases to be considered. Less than 4 bytes, exactly
+! 4 bytes, and more than 4 bytes.
+ CMP D0Ar6, #4
+ BLT $Lunaligned_1_2_3 ! use 1-3 byte mis-alignment loop
+ BZ $Lunaligned_4 ! use 4 byte mis-alignment loop
+
+! The mis-alignment is more than 4 bytes
+$Lunaligned_5_6_7:
+ SUB D0Ar6, D0Ar6, #4
+! Calculate the bit offsets required for the shift operations necesssary
+! to align the data.
+! D0Ar6 = bit offset, D1Ar5 = (32 - bit offset)
+ MULW D0Ar6, D0Ar6, #8
+ MOV D1Ar5, #32
+ SUB D1Ar5, D1Ar5, D0Ar6
+! Move data 4 bytes before we enter the main loop
+ MOV D0Re0, D1Re0
+
+$Lloop_5_6_7:
+ GETL D0Ar2, D1Ar1, [++A1.2]
+! form 64-bit data in D0Re0, D1Re0
+ LSR D0Re0, D0Re0, D0Ar6
+ MOV D1Re0, D0Ar2
+ LSL D1Re0, D1Re0, D1Ar5
+ ADD D0Re0, D0Re0, D1Re0
+
+ LSR D0Ar2, D0Ar2, D0Ar6
+ LSL D1Re0, D1Ar1, D1Ar5
+ ADD D1Re0, D1Re0, D0Ar2
+
+ SETL [A0.2++], D0Re0, D1Re0
+ MOV D0Re0, D1Ar1
+ BR $Lloop_5_6_7
+
+ B $Lunaligned_end
+
+$Lunaligned_1_2_3:
+! Calculate the bit offsets required for the shift operations necesssary
+! to align the data.
+! D0Ar6 = bit offset, D1Ar5 = (32 - bit offset)
+ MULW D0Ar6, D0Ar6, #8
+ MOV D1Ar5, #32
+ SUB D1Ar5, D1Ar5, D0Ar6
+
+$Lloop_1_2_3:
+! form 64-bit data in D0Re0,D1Re0
+ LSR D0Re0, D0Re0, D0Ar6
+ LSL D1Ar1, D1Re0, D1Ar5
+ ADD D0Re0, D0Re0, D1Ar1
+ MOV D0Ar2, D1Re0
+ LSR D0FrT, D0Ar2, D0Ar6
+ GETL D0Ar2, D1Ar1, [++A1.2]
+
+ MOV D1Re0, D0Ar2
+ LSL D1Re0, D1Re0, D1Ar5
+ ADD D1Re0, D1Re0, D0FrT
+
+ SETL [A0.2++], D0Re0, D1Re0
+ MOV D0Re0, D0Ar2
+ MOV D1Re0, D1Ar1
+ BR $Lloop_1_2_3
+
+ B $Lunaligned_end
+
+! The 4 byte mis-alignment case - this does not require any shifting, just a
+! shuffling of registers.
+$Lunaligned_4:
+ MOV D0Re0, D1Re0
+$Lloop_4:
+ GETL D0Ar2, D1Ar1, [++A1.2]
+ MOV D1Re0, D0Ar2
+ SETL [A0.2++], D0Re0, D1Re0
+ MOV D0Re0, D1Ar1
+ BR $Lloop_4
+
+$Lunaligned_end:
+! If there are no remaining bytes to copy, we are done.
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lend
+! Re-adjust the source pointer (A1.2) back to the actual (unaligned) byte
+! address of the remaining bytes, and fall through to the byte copy loop.
+ MOV D0Ar6, A1.2
+ ADD D1Ar5, D0Ar4, D0Ar6
+ MOV A1.2, D1Ar5
+ B $Lbyte_copy
+
+ .size _memcpy,.-_memcpy
+
+libc_hidden_def(memcpy)
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+
+ .text
+ .global _memmove
+ .type _memmove,function
+! D1Ar1 dst
+! D0Ar2 src
+! D1Ar3 cnt
+! D0Re0 dst
+_memmove:
+ CMP D1Ar3, #0
+ MOV D0Re0, D1Ar1
+ BZ $LEND2
+ MSETL [A0StP], D0.5, D0.6, D0.7
+ MOV D1Ar5, D0Ar2
+ CMP D1Ar1, D1Ar5
+ BLT $Lforwards_copy
+ SUB D0Ar4, D1Ar1, D1Ar3
+ ADD D0Ar4, D0Ar4, #1
+ CMP D0Ar2, D0Ar4
+ BLT $Lforwards_copy
+ ! should copy backwards
+ MOV D1Re0, D0Ar2
+ ! adjust pointer to the end of mem
+ ADD D0Ar2, D1Re0, D1Ar3
+ ADD D1Ar1, D1Ar1, D1Ar3
+
+ MOV A1.2, D0Ar2
+ MOV A0.2, D1Ar1
+ CMP D1Ar3, #8
+ BLT $Lbbyte_loop
+
+ MOV D0Ar4, D0Ar2
+ MOV D1Ar5, D1Ar1
+
+ ! test 8 byte alignment
+ ANDS D1Ar5, D1Ar5, #7
+ BNE $Lbdest_unaligned
+
+ ANDS D0Ar4, D0Ar4, #7
+ BNE $Lbsrc_unaligned
+
+ LSR D1Ar5, D1Ar3, #3
+
+$Lbaligned_loop:
+ GETL D0Re0, D1Re0, [--A1.2]
+ SETL [--A0.2], D0Re0, D1Re0
+ SUBS D1Ar5, D1Ar5, #1
+ BNE $Lbaligned_loop
+
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lbbyte_loop_exit
+$Lbbyte_loop:
+ GETB D1Re0, [--A1.2]
+ SETB [--A0.2], D1Re0
+ SUBS D1Ar3, D1Ar3, #1
+ BNE $Lbbyte_loop
+$Lbbyte_loop_exit:
+ MOV D0Re0, A0.2
+$LEND:
+ SUB A0.2, A0StP, #24
+ MGETL D0.5, D0.6, D0.7, [A0.2]
+ SUB A0StP, A0StP, #24
+$LEND2:
+ MOV PC, D1RtP
+
+$Lbdest_unaligned:
+ GETB D0Re0, [--A1.2]
+ SETB [--A0.2], D0Re0
+ SUBS D1Ar5, D1Ar5, #1
+ SUB D1Ar3, D1Ar3, #1
+ BNE $Lbdest_unaligned
+ CMP D1Ar3, #8
+ BLT $Lbbyte_loop
+$Lbsrc_unaligned:
+ LSR D1Ar5, D1Ar3, #3
+ ! adjust A1.2
+ MOV D0Ar4, A1.2
+ ! save original address
+ MOV D0Ar6, A1.2
+
+ ADD D0Ar4, D0Ar4, #7
+ ANDMB D0Ar4, D0Ar4, #0xfff8
+ ! new address is the 8-byte aligned one above the original
+ MOV A1.2, D0Ar4
+
+ ! A0.2 dst 64-bit is aligned
+ ! measure the gap size
+ SUB D0Ar6, D0Ar4, D0Ar6
+ MOVS D0Ar4, D0Ar6
+ ! keep this information for the later adjustment
+ ! both aligned
+ BZ $Lbaligned_loop
+
+ ! prefetch
+ GETL D0Re0, D1Re0, [--A1.2]
+
+ CMP D0Ar6, #4
+ BLT $Lbunaligned_1_2_3
+ ! 32-bit aligned
+ BZ $Lbaligned_4
+
+ SUB D0Ar6, D0Ar6, #4
+ ! D1.6 stores the gap size in bits
+ MULW D1.6, D0Ar6, #8
+ MOV D0.6, #32
+ ! D0.6 stores the complement of the gap size
+ SUB D0.6, D0.6, D1.6
+
+$Lbunaligned_5_6_7:
+ GETL D0.7, D1.7, [--A1.2]
+ ! form 64-bit data in D0Re0, D1Re0
+ MOV D1Re0, D0Re0
+ ! D1Re0 << gap-size
+ LSL D1Re0, D1Re0, D1.6
+ MOV D0Re0, D1.7
+ ! D0Re0 >> complement
+ LSR D0Re0, D0Re0, D0.6
+ MOV D1.5, D0Re0
+ ! combine the both
+ ADD D1Re0, D1Re0, D1.5
+
+ MOV D1.5, D1.7
+ LSL D1.5, D1.5, D1.6
+ MOV D0Re0, D0.7
+ LSR D0Re0, D0Re0, D0.6
+ MOV D0.5, D1.5
+ ADD D0Re0, D0Re0, D0.5
+
+ SETL [--A0.2], D0Re0, D1Re0
+ MOV D0Re0, D0.7
+ MOV D1Re0, D1.7
+ SUBS D1Ar5, D1Ar5, #1
+ BNE $Lbunaligned_5_6_7
+
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lbbyte_loop_exit
+ ! Adjust A1.2
+ ! A1.2 <- A1.2 +8 - gapsize
+ ADD A1.2, A1.2, #8
+ SUB A1.2, A1.2, D0Ar4
+ B $Lbbyte_loop
+
+$Lbunaligned_1_2_3:
+ MULW D1.6, D0Ar6, #8
+ MOV D0.6, #32
+ SUB D0.6, D0.6, D1.6
+
+$Lbunaligned_1_2_3_loop:
+ GETL D0.7, D1.7, [--A1.2]
+ ! form 64-bit data in D0Re0, D1Re0
+ LSL D1Re0, D1Re0, D1.6
+ ! save D0Re0 for later use
+ MOV D0.5, D0Re0
+ LSR D0Re0, D0Re0, D0.6
+ MOV D1.5, D0Re0
+ ADD D1Re0, D1Re0, D1.5
+
+ ! orignal data in D0Re0
+ MOV D1.5, D0.5
+ LSL D1.5, D1.5, D1.6
+ MOV D0Re0, D1.7
+ LSR D0Re0, D0Re0, D0.6
+ MOV D0.5, D1.5
+ ADD D0Re0, D0Re0, D0.5
+
+ SETL [--A0.2], D0Re0, D1Re0
+ MOV D0Re0, D0.7
+ MOV D1Re0, D1.7
+ SUBS D1Ar5, D1Ar5, #1
+ BNE $Lbunaligned_1_2_3_loop
+
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lbbyte_loop_exit
+ ! Adjust A1.2
+ ADD A1.2, A1.2, #8
+ SUB A1.2, A1.2, D0Ar4
+ B $Lbbyte_loop
+
+$Lbaligned_4:
+ GETL D0.7, D1.7, [--A1.2]
+ MOV D1Re0, D0Re0
+ MOV D0Re0, D1.7
+ SETL [--A0.2], D0Re0, D1Re0
+ MOV D0Re0, D0.7
+ MOV D1Re0, D1.7
+ SUBS D1Ar5, D1Ar5, #1
+ BNE $Lbaligned_4
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lbbyte_loop_exit
+ ! Adjust A1.2
+ ADD A1.2, A1.2, #8
+ SUB A1.2, A1.2, D0Ar4
+ B $Lbbyte_loop
+
+$Lforwards_copy:
+ MOV A1.2, D0Ar2
+ MOV A0.2, D1Ar1
+ CMP D1Ar3, #8
+ BLT $Lfbyte_loop
+
+ MOV D0Ar4, D0Ar2
+ MOV D1Ar5, D1Ar1
+
+ ANDS D1Ar5, D1Ar5, #7
+ BNE $Lfdest_unaligned
+
+ ANDS D0Ar4, D0Ar4, #7
+ BNE $Lfsrc_unaligned
+
+ LSR D1Ar5, D1Ar3, #3
+
+$Lfaligned_loop:
+ GETL D0Re0, D1Re0, [A1.2++]
+ SUBS D1Ar5, D1Ar5, #1
+ SETL [A0.2++], D0Re0, D1Re0
+ BNE $Lfaligned_loop
+
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lfbyte_loop_exit
+$Lfbyte_loop:
+ GETB D1Re0, [A1.2++]
+ SETB [A0.2++], D1Re0
+ SUBS D1Ar3, D1Ar3, #1
+ BNE $Lfbyte_loop
+$Lfbyte_loop_exit:
+ MOV D0Re0, D1Ar1
+ B $LEND
+
+$Lfdest_unaligned:
+ GETB D0Re0, [A1.2++]
+ ADD D1Ar5, D1Ar5, #1
+ SUB D1Ar3, D1Ar3, #1
+ SETB [A0.2++], D0Re0
+ CMP D1Ar5, #8
+ BNE $Lfdest_unaligned
+ CMP D1Ar3, #8
+ BLT $Lfbyte_loop
+$Lfsrc_unaligned:
+ ! adjust A1.2
+ LSR D1Ar5, D1Ar3, #3
+
+ MOV D0Ar4, A1.2
+ MOV D0Ar6, A1.2
+ ANDMB D0Ar4, D0Ar4, #0xfff8
+ MOV A1.2, D0Ar4
+
+ ! A0.2 dst 64-bit is aligned
+ SUB D0Ar6, D0Ar6, D0Ar4
+ ! keep the information for the later adjustment
+ MOVS D0Ar4, D0Ar6
+
+ ! both aligned
+ BZ $Lfaligned_loop
+
+ ! prefetch
+ GETL D0Re0, D1Re0, [A1.2]
+
+ CMP D0Ar6, #4
+ BLT $Lfunaligned_1_2_3
+ BZ $Lfaligned_4
+
+ SUB D0Ar6, D0Ar6, #4
+ MULW D0.6, D0Ar6, #8
+ MOV D1.6, #32
+ SUB D1.6, D1.6, D0.6
+
+$Lfunaligned_5_6_7:
+ GETL D0.7, D1.7, [++A1.2]
+ ! form 64-bit data in D0Re0, D1Re0
+ MOV D0Re0, D1Re0
+ LSR D0Re0, D0Re0, D0.6
+ MOV D1Re0, D0.7
+ LSL D1Re0, D1Re0, D1.6
+ MOV D0.5, D1Re0
+ ADD D0Re0, D0Re0, D0.5
+
+ MOV D0.5, D0.7
+ LSR D0.5, D0.5, D0.6
+ MOV D1Re0, D1.7
+ LSL D1Re0, D1Re0, D1.6
+ MOV D1.5, D0.5
+ ADD D1Re0, D1Re0, D1.5
+
+ SETL [A0.2++], D0Re0, D1Re0
+ MOV D0Re0, D0.7
+ MOV D1Re0, D1.7
+ SUBS D1Ar5, D1Ar5, #1
+ BNE $Lfunaligned_5_6_7
+
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lfbyte_loop_exit
+ ! Adjust A1.2
+ ADD A1.2, A1.2, D0Ar4
+ B $Lfbyte_loop
+
+$Lfunaligned_1_2_3:
+ MULW D0.6, D0Ar6, #8
+ MOV D1.6, #32
+ SUB D1.6, D1.6, D0.6
+
+$Lfunaligned_1_2_3_loop:
+ GETL D0.7, D1.7, [++A1.2]
+ ! form 64-bit data in D0Re0, D1Re0
+ LSR D0Re0, D0Re0, D0.6
+ MOV D1.5, D1Re0
+ LSL D1Re0, D1Re0, D1.6
+ MOV D0.5, D1Re0
+ ADD D0Re0, D0Re0, D0.5
+
+ MOV D0.5, D1.5
+ LSR D0.5, D0.5, D0.6
+ MOV D1Re0, D0.7
+ LSL D1Re0, D1Re0, D1.6
+ MOV D1.5, D0.5
+ ADD D1Re0, D1Re0, D1.5
+
+ SETL [A0.2++], D0Re0, D1Re0
+ MOV D0Re0, D0.7
+ MOV D1Re0, D1.7
+ SUBS D1Ar5, D1Ar5, #1
+ BNE $Lfunaligned_1_2_3_loop
+
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lfbyte_loop_exit
+ ! Adjust A1.2
+ ADD A1.2, A1.2, D0Ar4
+ B $Lfbyte_loop
+
+$Lfaligned_4:
+ GETL D0.7, D1.7, [++A1.2]
+ MOV D0Re0, D1Re0
+ MOV D1Re0, D0.7
+ SETL [A0.2++], D0Re0, D1Re0
+ MOV D0Re0, D0.7
+ MOV D1Re0, D1.7
+ SUBS D1Ar5, D1Ar5, #1
+ BNE $Lfaligned_4
+ ANDS D1Ar3, D1Ar3, #7
+ BZ $Lfbyte_loop_exit
+ ! Adjust A1.2
+ ADD A1.2, A1.2, D0Ar4
+ B $Lfbyte_loop
+
+ .size _memmove,.-_memmove
+
+libc_hidden_def(memmove)
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+
+ .text
+ .global _memset
+ .type _memset,function
+! D1Ar1 dst
+! D0Ar2 c
+! D1Ar3 cnt
+! D0Re0 dst
+_memset:
+ AND D0Ar2,D0Ar2,#0xFF ! Ensure a byte input value
+ MULW D0Ar2,D0Ar2,#0x0101 ! Duplicate byte value into 0-15
+ ANDS D0Ar4,D1Ar1,#7 ! Extract bottom LSBs of dst
+ LSL D0Re0,D0Ar2,#16 ! Duplicate byte value into 16-31
+ ADD A0.2,D0Ar2,D0Re0 ! Duplicate byte value into 4 (A0.2)
+ MOV D0Re0,D1Ar1 ! Return dst
+ BZ $LLongStub ! if start address is aligned
+ ! start address is not aligned on an 8 byte boundary, so we
+ ! need the number of bytes up to the next 8 byte address
+ ! boundary, or the length of the string if less than 8, in D1Ar5
+ MOV D0Ar2,#8 ! Need 8 - N in D1Ar5 ...
+ SUB D1Ar5,D0Ar2,D0Ar4 ! ... subtract N
+ CMP D1Ar3,D1Ar5
+ MOVMI D1Ar5,D1Ar3
+ B $LByteStub ! dst is mis-aligned, do $LByteStub
+
+!
+! Preamble to LongLoop which generates 4*8 bytes per interation (5 cycles)
+!
+$LLongStub:
+ LSRS D0Ar2,D1Ar3,#5
+ AND D1Ar3,D1Ar3,#0x1F
+ MOV A1.2,A0.2
+ BEQ $LLongishStub
+ SUB TXRPT,D0Ar2,#1
+ CMP D1Ar3,#0
+$LLongLoop:
+ SETL [D1Ar1++],A0.2,A1.2
+ SETL [D1Ar1++],A0.2,A1.2
+ SETL [D1Ar1++],A0.2,A1.2
+ SETL [D1Ar1++],A0.2,A1.2
+ BR $LLongLoop
+ BZ $Lexit
+!
+! Preamble to LongishLoop which generates 1*8 bytes per interation (2 cycles)
+!
+$LLongishStub:
+ LSRS D0Ar2,D1Ar3,#3
+ AND D1Ar3,D1Ar3,#0x7
+ MOV D1Ar5,D1Ar3
+ BEQ $LByteStub
+ SUB TXRPT,D0Ar2,#1
+ CMP D1Ar3,#0
+$LLongishLoop:
+ SETL [D1Ar1++],A0.2,A1.2
+ BR $LLongishLoop
+ BZ $Lexit
+!
+! This does a byte structured burst of up to 7 bytes
+!
+! D1Ar1 should point to the location required
+! D1Ar3 should be the remaining total byte count
+! D1Ar5 should be burst size (<= D1Ar3)
+!
+$LByteStub:
+ SUBS D1Ar3,D1Ar3,D1Ar5 ! Reduce count
+ ADD D1Ar1,D1Ar1,D1Ar5 ! Advance pointer to end of area
+ MULW D1Ar5,D1Ar5,#4 ! Scale to (1*4), (2*4), (3*4)
+ SUB D1Ar5,D1Ar5,#(8*4) ! Rebase to -(7*4), -(6*4), -(5*4), ...
+ MOV A1.2,D1Ar5
+ SUB PC,CPC1,A1.2 ! Jump into table below
+ SETB [D1Ar1+#(-7)],A0.2
+ SETB [D1Ar1+#(-6)],A0.2
+ SETB [D1Ar1+#(-5)],A0.2
+ SETB [D1Ar1+#(-4)],A0.2
+ SETB [D1Ar1+#(-3)],A0.2
+ SETB [D1Ar1+#(-2)],A0.2
+ SETB [D1Ar1+#(-1)],A0.2
+!
+! Return if all data has been output, otherwise do $LLongStub
+!
+ BNZ $LLongStub
+$Lexit:
+ MOV PC,D1RtP
+ .size _memset,.-_memset
+
+libc_hidden_def(memset)
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+
+#include <features.h>
+
+ .text
+ .global _strchr
+ .type _strchr, function
+! D1Ar1 src
+! D0Ar2 c
+_strchr:
+ AND D0Ar2,D0Ar2,#0xff ! Drop all but 8 bits of c
+ MOV D1Ar5, D1Ar1 ! Copy src to D1Ar5
+ AND D1Ar5, D1Ar5, #7 ! Check 64 bit alignment
+ CMP D1Ar5, #0
+ BZ $Laligned64bit ! Jump to 64 bit aligned strchr
+$Lalign64bit:
+ GETB D0Re0, [D1Ar1++] ! Get the next character
+ ADD D1Ar5, D1Ar5, #1 ! Increment alignment counter
+ CMP D0Re0, D0Ar2 ! Is the char c
+ BZ $Lcharatprevious ! If so exit returning position
+ CMP D0Re0, #0 ! End of string?
+ BZ $Lnotfound ! If so exit
+ CMP D1Ar5, #8 ! Are we aligned 64bit yet?
+ BNZ $Lalign64bit ! If not keep aligning
+$Laligned64bit: ! src is 64bit aligned
+ MOV D0Ar4, D0Ar2 ! put c into D0Ar4
+ LSL D0Ar4, D0Ar4, #8 ! Shift it up
+ ADD D0Ar4, D0Ar4, D0Ar2 ! another c
+ LSL D0Ar4, D0Ar4, #8 ! shift
+ ADD D0Ar4, D0Ar4, D0Ar2 ! another c
+ LSL D0Ar4, D0Ar4, #8 ! shift
+ ADD D0Ar4, D0Ar4, D0Ar2 ! 4 copies of c
+$Lcheck8bytes:
+ GETL D0Re0, D1Re0, [D1Ar1++] ! grab 16 bytes
+ MOV A0.3, D0Re0 ! save for later use
+ ! first word
+ ! check for \0
+ MOV D0Ar2, D0Re0 ! D0Ar2 is a scratch now
+ ADDT D0Re0, D0Re0, #HI(0xfefefeff) ! Do 4 1-byte compares
+ ADD D0Re0, D0Re0, #LO(0xfefefeff)
+ XOR D0Ar2, D0Ar2, #-1
+ AND D0Re0, D0Re0, D0Ar2
+ ANDMT D0Re0, D0Re0, #HI(0x80808080)
+ ANDMB D0Re0, D0Re0, #LO(0x80808080)
+ CMP D0Re0, #0
+ BNZ $Lnullinword1 ! found \0 (or c if c==\0)
+
+ ! Check for c
+ MOV D0Re0, A0.3 ! restore the first word
+ XOR D0Re0, D0Re0, D0Ar4
+ MOV D0Ar2, D0Re0 ! DO 4 1-byte compares
+ ADDT D0Re0, D0Re0, #HI(0xfefefeff)
+ ADD D0Re0, D0Re0, #LO(0xfefefeff)
+ XOR D0Ar2, D0Ar2, #-1
+ AND D0Re0, D0Re0, D0Ar2
+ ANDMT D0Re0, D0Re0, #HI(0x80808080)
+ ANDMB D0Re0, D0Re0, #LO(0x80808080)
+ CMP D0Re0, #0
+ BNZ $Lcharinword1 ! found c
+
+ ! second word
+ ! check for \0
+ MOV A0.3, D1Re0 ! save for later use
+ MOV D1Ar3, D1Re0
+ ADDT D1Re0, D1Re0, #HI(0xfefefeff) ! Do 4 1-byte compares
+ ADD D1Re0, D1Re0, #LO(0xfefefeff)
+ XOR D1Ar3, D1Ar3, #-1
+ AND D1Re0, D1Re0, D1Ar3
+ ANDMT D1Re0, D1Re0, #HI(0x80808080)
+ ANDMB D1Re0, D1Re0, #LO(0x80808080)
+ CMP D1Re0, #0
+ BNZ $Lnullinword2 ! Found \0 (or c if c==\0)
+
+ MOV D0.4, A0.3 ! restore the second word
+ XOR D1Re0, D0.4, D0Ar4 ! test c
+
+ MOV D1Ar3, D1Re0
+ ADDT D1Re0, D1Re0, #HI(0xfefefeff) ! Do 4 1-byte compares
+ ADD D1Re0, D1Re0, #LO(0xfefefeff)
+ XOR D1Ar3, D1Ar3, #-1
+ AND D1Re0, D1Re0, D1Ar3
+ ANDMT D1Re0, D1Re0, #HI(0x80808080)
+ ANDMB D1Re0, D1Re0, #LO(0x80808080)
+ CMP D1Re0, #0
+ BNZ $Lcharinword2 ! found c
+
+ B $Lcheck8bytes ! Keep checking
+
+$Lnullinword1: ! found \0 somewhere, check for c too
+ SUB D1Ar1, D1Ar1, #4
+$Lnullinword2:
+ SUB D1Ar1, D1Ar1, #4
+ AND D0Ar2, D0Ar4, #0xff ! restore c
+ MOV D0Re0, A0.3 ! restore the word
+ MOV D0.4, D0Re0 ! for shifting later
+ AND D0Re0, D0Re0, #0xff ! take first byte of word
+ CMP D0Re0, D0Ar2
+ BZ $Lcharatcurrent ! found c
+ CMP D0Re0, #0!
+ BZ $Lnotfound ! found \0
+
+ ADD D1Ar1, D1Ar1, #1
+ LSR D0.4, D0.4, #8
+ MOV D0Re0, D0.4
+ AND D0Re0, D0Re0, #0xff ! take second byte of word
+ CMP D0Re0, D0Ar2
+ BZ $Lcharatcurrent ! found c
+ CMP D0Re0, #0
+ BZ $Lnotfound ! found \0
+
+ ADD D1Ar1, D1Ar1, #1
+ LSR D0.4, D0.4, #8
+ MOV D0Re0, D0.4
+ AND D0Re0, D0Re0, #0xff ! take third byte of word
+ CMP D0Re0, D0Ar2
+ BZ $Lcharatcurrent ! found c
+ CMP D0Re0, #0
+ BZ $Lnotfound ! found \0
+
+ ADD D1Ar1, D1Ar1, #1 ! move to 4th byte
+ CMP D0Ar2, #0 ! If c was \0
+ BZ $Lcharatcurrent ! c has been found!
+
+$Lnotfound:
+ MOV D0Re0, #0 ! End of string c not found
+ B $Lend
+
+$Lcharinword1: ! found c in first word
+ MOV D1Re0, D0Re0
+ SUB D1Ar1, D1Ar1, #4
+$Lcharinword2: ! found c in second word
+ SUB D1Ar1, D1Ar1, #4
+
+ AND D0Re0, D1Re0, #0xff ! First byte
+ CMP D0Re0, #0 ! Test c (zero indicates c due
+ ! to the 4 1-byte compare code)
+ BNE $Lcharatcurrent
+ ADD D1Ar1, D1Ar1, #1
+
+ LSR D1Re0, D1Re0, #8
+ AND D0Re0, D1Re0, #0xff ! Second byte
+ CMP D0Re0, #0 ! Test c (indicated by zero)
+ BNE $Lcharatcurrent
+ ADD D1Ar1, D1Ar1, #1
+
+ LSR D1Re0, D1Re0, #8
+ AND D0Re0, D1Re0, #0xff ! Third byte
+ CMP D0Re0, #0 ! Test c (indicated by zero)
+ BNE $Lcharatcurrent
+ ADD D1Ar1, D1Ar1, #1 ! Must be the fourth byte
+ B $Lcharatcurrent
+
+$Lcharatprevious:
+ SUB D1Ar1, D1Ar1, #1 ! Fix-up pointer
+$Lcharatcurrent:
+ MOV D0Re0, D1Ar1 ! Return the string pointer
+$Lend:
+ MOV PC, D1RtP
+ .size _strchr,.-_strchr
+
+libc_hidden_def(strchr)
+#ifdef __UCLIBC_SUSV3_LEGACY__
+strong_alias(strchr,index)
+#endif
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+
+#include <features.h>
+
+ .text
+ .global _strcmp
+ .type _strcmp,function
+!D1Ar1 s1
+!D0Ar2 s2
+_strcmp:
+ TST D1Ar1,#3
+ TSTZ D0Ar2,#3
+ MOVT D1Re0,#0x0101
+ ADD D1Re0,D1Re0,#0x0101
+ BNZ $Lstrcmp_slow
+ GETD D1Ar3,[D1Ar1+#4++] ! Load 32-bits from s1
+ GETD D1Ar5,[D0Ar2+#4++] ! Load 32-bits from s2
+ LSL D0FrT,D1Re0,#7 ! D0FrT = 0x80808080
+$Lstrcmp4_loop:
+ SUB D0Re0,D1Ar3,D1Re0 ! D1Re0 = 0x01010101
+ MOV D0Ar6,D1Ar3
+ SUBS D0Ar4,D1Ar3,D1Ar5 ! Calculate difference
+ XOR D0Ar6,D0Ar6,#-1
+ GETD D1Ar3,[D1Ar1+#4++] ! Load 32-bits from s1
+ AND D0Re0,D0Re0,D0Ar6
+ ANDSZ D0Ar6,D0Re0,D0FrT ! D0FrT = 0x80808080
+ GETD D1Ar5,[D0Ar2+#4++] ! Load 32-bits from s2
+ BZ $Lstrcmp4_loop
+ AND D0Ar6, D0Re0, D0FrT ! D0FrT = 0x80808080
+!
+! Either they are different or they both contain a NULL + junk
+!
+$Lstrcmp4_end:
+ LSLS D0Re0,D0Ar4,#24 ! Was Byte[0] the same?
+ LSLSZ D0Ar2,D0Ar6,#24 ! Yes: AND they where not zero?
+ LSLSZ D0Re0,D0Ar4,#16 ! Yes: Was Byte[1] the same?
+ LSLSZ D0Ar2,D0Ar6,#16 ! Yes: AND they where not zero?
+ LSLSZ D0Re0,D0Ar4,#8 ! Tes: Was Byte[2] the same?
+ LSLSZ D0Ar2,D0Ar6,#8 ! Yes: AND they where not zero?
+ MOVZ D0Re0,D0Ar4 ! Yes: Must by Byte[3] thats the result
+ ASR D0Re0,D0Re0,#24 ! Sign extend result to integer
+ MOV PC,D1RtP
+!
+! Misaligned case, byte at a time
+!
+$Lstrcmp_slow:
+ GETB D1Ar3,[D1Ar1++] ! Load char from s1
+ GETB D1Ar5,[D0Ar2++] ! Load char from s2
+ CMP D1Ar3,#1 ! Null -> C and NZ, rest -> NC (\1->Z)
+ CMPNC D1Ar3,D1Ar5 ! NOT Null: Same -> Z, else -> NZ
+ BZ $Lstrcmp_slow ! NOT Null and Same: Loop
+ SUB D0Re0,D1Ar3,D1Ar5 ! Generate result
+ MOV PC,D1RtP
+
+ .size _strcmp,.-_strcmp
+
+
+libc_hidden_def(strcmp)
+#ifndef __UCLIBC_HAS_LOCALE__
+strong_alias(strcmp,strcoll)
+libc_hidden_def(strcoll)
+#endif
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+
+ .text
+ .global _strcpy
+ .type _strcpy,function
+! D1Ar1 dst
+! D0Ar2 src
+
+_strcpy:
+ MOV A1.2, D1Ar1
+
+ ! test 4 byte alignment of src
+ ANDS D0Ar4, D0Ar2, #3
+ BNZ $Lbyteloop
+
+ ! test 4 byte alignment of dest
+ ANDS D1Ar5, D1Ar1, #3
+ BNZ $Lbyteloop
+
+ ! load mask values for aligned loops
+ MOVT D1Ar3, #HI(0xfefefeff)
+ ADD D1Ar3, D1Ar3, #LO(0xfefefeff)
+ MOVT D0FrT, #HI(0x80808080)
+ ADD D0FrT, D0FrT, #LO(0x80808080)
+
+ ! test 8 byte alignment of src
+ ANDS D0Ar4, D0Ar2, #7
+ BNZ $Lwordloop
+
+ ! test 8 byte alignment of dest
+ ANDS D1Ar5, D1Ar1, #7
+ BNZ $Lwordloop
+
+$L8byteloop:
+ GETL D1Ar5, D0Ar6, [D0Ar2++]
+ MOV D1Re0, D1Ar5
+ MOV D0Re0, D1Ar5
+ ADD D1Re0, D1Re0, D1Ar3
+ XOR D0Re0, D0Re0, #-1
+ AND D1Re0, D1Re0, D0Re0
+ ANDS D1Re0, D1Re0, D0FrT
+ BNZ $Lnullfound ! NULL in first word
+
+ MOV D1Re0, D0Ar6
+ MOV D0Re0, D0Ar6
+ ADD D1Re0, D1Re0, D1Ar3
+ XOR D0Re0, D0Re0, #-1
+ AND D1Re0, D1Re0, D0Re0
+ ANDS D1Re0, D1Re0, D0FrT
+ BNZ $Lnullfound2 ! NULL in the second word
+
+ SETL [A1.2++], D1Ar5, D0Ar6
+ B $L8byteloop
+
+$Lwordloop:
+ GETD D0Ar6, [D0Ar2++]
+ MOV D1Re0, D0Ar6
+ MOV D0Re0, D0Ar6
+ ADD D1Re0, D1Re0, D1Ar3
+ XOR D0Re0, D0Re0, #-1
+ AND D1Re0, D1Re0, D0Re0
+ ANDS D1Re0, D1Re0, D0FrT
+ MOV D1Ar5, D0Ar6
+ BNZ $Lnullfound
+ SETD [A1.2++], D0Ar6
+ B $Lwordloop
+
+$Lnullfound2:
+ SETD [A1.2++], D1Ar5
+ MOV D1Ar5, D0Ar6
+
+$Lnullfound:
+ SETB [A1.2++], D1Ar5
+ ANDS D0Ar6, D1Ar5, #0xff
+ LSR D1Ar5, D1Ar5, #8
+ BNZ $Lnullfound
+ B $Lend
+
+$Lbyteloop:
+ GETB D0Ar6, [D0Ar2++]
+ SETB [A1.2++], D0Ar6
+ CMP D0Ar6, #0
+ BNZ $Lbyteloop
+
+$Lend:
+ MOV D0Re0, D1Ar1
+ MOV PC, D1RtP
+
+ .size _strcpy,.-_strcpy
+
+libc_hidden_def(strcpy)
--- /dev/null
+# Makefile for uClibc
+#
+#
+# Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+#
+
+top_srcdir=../../../../
+top_builddir=../../../../
+all: objs
+include $(top_builddir)Rules.mak
+include Makefile.arch
+include $(top_srcdir)Makerules
--- /dev/null
+# Makefile for uClibc
+#
+# Copyright (C) 2013 Imagination Technologies Ltd.
+#
+# Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+#
+
+CSRC-y := brk.c syscall.c metag.c __syscall_error.c
+
+SSRC-y := _longjmp.S clone.S setjmp.S
--- /dev/null
+/* Wrapper for setting errno.
+ *
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#include <errno.h>
+#include <features.h>
+
+/* This routine is jumped to by all the syscall handlers, to stash
+ * an error number into errno. */
+int __syscall_error(int err_no) attribute_hidden;
+int __syscall_error(int err_no)
+{
+ __set_errno(-err_no);
+ return -1;
+}
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+
+ .text
+ .global ___longjmp
+ .type ___longjmp,function
+
+___longjmp:
+ !! If val is 0, set it to 1
+ CMP D0Ar2,#0
+ ADDZ D0Ar2,D0Ar2,#1
+
+ !! Restore A0/A1 regs
+ MGETL A0.0,A0.1,[D1Ar1++]
+ !! Restore D0/D1 regs
+ MOV A0.3,D1Ar1
+ MGETL D0FrT,D0.5,D0.6,D0.7,[A0.3++]
+ !! Move 2nd argument to return value
+ MOV D0Re0,D0Ar2
+ MOV PC,D1RtP
+ .size ___longjmp,.-___longjmp
+
+libc_hidden_def(__longjmp)
--- /dev/null
+/* Meta is little endian
+ *
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#ifndef _ENDIAN_H
+# error "Never use <bits/endian.h> directly; include <endian.h> instead."
+#endif
+
+#define __BYTE_ORDER __LITTLE_ENDIAN
--- /dev/null
+/* O_*, F_*, FD_* bit values for Linux.
+ Copyright (C) 1995-1998, 2000, 2004, 2006, 2007, 2008
+ Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _FCNTL_H
+# error "Never use <bits/fcntl.h> directly; include <fcntl.h> instead."
+#endif
+
+#include <sys/types.h>
+#ifdef __USE_GNU
+# include <bits/uio.h>
+#endif
+
+
+/* open/fcntl - O_SYNC is only implemented on blocks devices and on files
+ located on an ext2 file system */
+#define O_ACCMODE 0003
+#define O_RDONLY 00
+#define O_WRONLY 01
+#define O_RDWR 02
+#define O_CREAT 0100 /* not fcntl */
+#define O_EXCL 0200 /* not fcntl */
+#define O_NOCTTY 0400 /* not fcntl */
+#define O_TRUNC 01000 /* not fcntl */
+#define O_APPEND 02000
+#define O_NONBLOCK 04000
+#define O_NDELAY O_NONBLOCK
+#define O_SYNC 010000
+#define O_FSYNC O_SYNC
+#define O_ASYNC 020000
+
+#ifdef __USE_GNU
+# define O_DIRECT 040000 /* Direct disk access. */
+# define O_DIRECTORY 0200000 /* Must be a directory. */
+# define O_NOFOLLOW 0400000 /* Do not follow links. */
+# define O_NOATIME 01000000 /* Do not set atime. */
+# define O_CLOEXEC 02000000 /* Set close_on_exec. */
+#endif
+
+/* For now Linux has synchronisity options for data and read operations.
+ We define the symbols here but let them do the same as O_SYNC since
+ this is a superset. */
+#if defined __USE_POSIX199309 || defined __USE_UNIX98
+# define O_DSYNC O_SYNC /* Synchronize data. */
+# define O_RSYNC O_SYNC /* Synchronize read operations. */
+#endif
+
+#ifdef __USE_LARGEFILE64
+# define O_LARGEFILE 0100000
+#endif
+
+/* Values for the second argument to `fcntl'. */
+#define F_DUPFD 0 /* Duplicate file descriptor. */
+#define F_GETFD 1 /* Get file descriptor flags. */
+#define F_SETFD 2 /* Set file descriptor flags. */
+#define F_GETFL 3 /* Get file status flags. */
+#define F_SETFL 4 /* Set file status flags. */
+#ifndef __USE_FILE_OFFSET64
+# define F_GETLK 5 /* Get record locking info. */
+# define F_SETLK 6 /* Set record locking info (non-blocking). */
+# define F_SETLKW 7 /* Set record locking info (blocking). */
+#else
+# define F_GETLK F_GETLK64 /* Get record locking info. */
+# define F_SETLK F_SETLK64 /* Set record locking info (non-blocking).*/
+# define F_SETLKW F_SETLKW64 /* Set record locking info (blocking). */
+#endif
+#define F_GETLK64 12 /* Get record locking info. */
+#define F_SETLK64 13 /* Set record locking info (non-blocking). */
+#define F_SETLKW64 14 /* Set record locking info (blocking). */
+
+#if defined __USE_BSD || defined __USE_UNIX98
+# define F_SETOWN 8 /* Get owner of socket (receiver of SIGIO). */
+# define F_GETOWN 9 /* Set owner of socket (receiver of SIGIO). */
+#endif
+
+#ifdef __USE_GNU
+# define F_SETSIG 10 /* Set number of signal to be sent. */
+# define F_GETSIG 11 /* Get number of signal to be sent. */
+#endif
+
+#ifdef __USE_GNU
+# define F_SETLEASE 1024 /* Set a lease. */
+# define F_GETLEASE 1025 /* Enquire what lease is active. */
+# define F_NOTIFY 1026 /* Request notfications on a directory. */
+# define F_DUPFD_CLOEXEC 1030 /* Duplicate file descriptor with
+ close-on-exit set on new fd. */
+#endif
+
+/* For F_[GET|SET]FD. */
+#define FD_CLOEXEC 1 /* actually anything with low bit set goes */
+
+/* For posix fcntl() and `l_type' field of a `struct flock' for lockf(). */
+#define F_RDLCK 0 /* Read lock. */
+#define F_WRLCK 1 /* Write lock. */
+#define F_UNLCK 2 /* Remove lock. */
+
+/* For old implementation of bsd flock(). */
+#define F_EXLCK 4 /* or 3 */
+#define F_SHLCK 8 /* or 4 */
+
+#ifdef __USE_BSD
+/* Operations for bsd flock(), also used by the kernel implementation. */
+# define LOCK_SH 1 /* shared lock */
+# define LOCK_EX 2 /* exclusive lock */
+# define LOCK_NB 4 /* or'd with one of the above to prevent
+ blocking */
+# define LOCK_UN 8 /* remove lock */
+#endif
+
+#ifdef __USE_GNU
+# define LOCK_MAND 32 /* This is a mandatory flock: */
+# define LOCK_READ 64 /* ... which allows concurrent read operations. */
+# define LOCK_WRITE 128 /* ... which allows concurrent write operations. */
+# define LOCK_RW 192 /* ... Which allows concurrent read & write operations. */
+#endif
+
+#ifdef __USE_GNU
+/* Types of directory notifications that may be requested with F_NOTIFY. */
+# define DN_ACCESS 0x00000001 /* File accessed. */
+# define DN_MODIFY 0x00000002 /* File modified. */
+# define DN_CREATE 0x00000004 /* File created. */
+# define DN_DELETE 0x00000008 /* File removed. */
+# define DN_RENAME 0x00000010 /* File renamed. */
+# define DN_ATTRIB 0x00000020 /* File changed attibutes. */
+# define DN_MULTISHOT 0x80000000 /* Don't remove notifier. */
+#endif
+
+struct flock
+ {
+ short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */
+ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */
+#ifndef __USE_FILE_OFFSET64
+ __off_t l_start; /* Offset where the lock begins. */
+ __off_t l_len; /* Size of the locked area; zero means until EOF. */
+#else
+ __off64_t l_start; /* Offset where the lock begins. */
+ __off64_t l_len; /* Size of the locked area; zero means until EOF. */
+#endif
+ __pid_t l_pid; /* Process holding the lock. */
+ };
+
+#ifdef __USE_LARGEFILE64
+struct flock64
+ {
+ short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */
+ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */
+ __off64_t l_start; /* Offset where the lock begins. */
+ __off64_t l_len; /* Size of the locked area; zero means until EOF. */
+ __pid_t l_pid; /* Process holding the lock. */
+ };
+#endif
+
+/* Define some more compatibility macros to be backward compatible with
+ BSD systems which did not managed to hide these kernel macros. */
+#ifdef __USE_BSD
+# define FAPPEND O_APPEND
+# define FFSYNC O_FSYNC
+# define FASYNC O_ASYNC
+# define FNONBLOCK O_NONBLOCK
+# define FNDELAY O_NDELAY
+#endif /* Use BSD. */
+
+/* Advise to `posix_fadvise'. */
+#ifdef __USE_XOPEN2K
+# define POSIX_FADV_NORMAL 0 /* No further special treatment. */
+# define POSIX_FADV_RANDOM 1 /* Expect random page references. */
+# define POSIX_FADV_SEQUENTIAL 2 /* Expect sequential page references. */
+# define POSIX_FADV_WILLNEED 3 /* Will need these pages. */
+# define POSIX_FADV_DONTNEED 4 /* Don't need these pages. */
+# define POSIX_FADV_NOREUSE 5 /* Data will be accessed once. */
+#endif
+
+
+#if defined __USE_GNU && defined __UCLIBC_LINUX_SPECIFIC__
+/* Flags for SYNC_FILE_RANGE. */
+# define SYNC_FILE_RANGE_WAIT_BEFORE 1 /* Wait upon writeout of all pages
+ in the range before performing the
+ write. */
+# define SYNC_FILE_RANGE_WRITE 2 /* Initiate writeout of all those
+ dirty pages in the range which are
+ not presently under writeback. */
+# define SYNC_FILE_RANGE_WAIT_AFTER 4 /* Wait upon writeout of all pages in
+ the range after performing the
+ write. */
+
+/* Flags for SPLICE and VMSPLICE. */
+# define SPLICE_F_MOVE 1 /* Move pages instead of copying. */
+# define SPLICE_F_NONBLOCK 2 /* Don't block on the pipe splicing
+ (but we may still block on the fd
+ we splice from/to). */
+# define SPLICE_F_MORE 4 /* Expect more data. */
+# define SPLICE_F_GIFT 8 /* Pages passed in are a gift. */
+#endif
+
+__BEGIN_DECLS
+
+#if defined __USE_GNU && defined __UCLIBC_LINUX_SPECIFIC__
+
+/* Provide kernel hint to read ahead. */
+extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
+ __THROW;
+
+/* Selective file content synch'ing. */
+extern int sync_file_range (int __fd, __off64_t __from, __off64_t __to,
+ unsigned int __flags);
+
+/* Splice address range into a pipe. */
+extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
+ size_t __count, unsigned int __flags);
+
+/* Splice two files together. */
+extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
+ __off64_t *__offout, size_t __len,
+ unsigned int __flags);
+
+/* In-kernel implementation of tee for pipe buffers. */
+extern ssize_t tee (int __fdin, int __fdout, size_t __len,
+ unsigned int __flags);
+
+#endif
+__END_DECLS
+
--- /dev/null
+/* Copyright (C) 1995-1999, 2000, 2005, 2007 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
+ Boston, MA 02110-1301, USA. */
+
+#ifndef _SYS_IPC_H
+# error "Never use <bits/ipc.h> directly; include <sys/ipc.h> instead."
+#endif
+
+#include <bits/types.h>
+
+/* Mode bits for `msgget', `semget', and `shmget'. */
+#define IPC_CREAT 01000 /* Create key if key does not exist. */
+#define IPC_EXCL 02000 /* Fail if key exists. */
+#define IPC_NOWAIT 04000 /* Return error on wait. */
+
+/* Control commands for `msgctl', `semctl', and `shmctl'. */
+#define IPC_RMID 0 /* Remove identifier. */
+#define IPC_SET 1 /* Set `ipc_perm' options. */
+#define IPC_STAT 2 /* Get `ipc_perm' options. */
+#ifdef __USE_GNU
+# define IPC_INFO 3 /* See ipcs. */
+#endif
+
+/* Special key values. */
+#define IPC_PRIVATE ((__key_t) 0) /* Private key. */
+
+
+/* Data structure used to pass permission information to IPC operations. */
+struct ipc_perm
+ {
+ __key_t __key; /* Key. */
+ __uid_t uid; /* Owner's user ID. */
+ __gid_t gid; /* Owner's group ID. */
+ __uid_t cuid; /* Creator's user ID. */
+ __gid_t cgid; /* Creator's group ID. */
+ unsigned int mode; /* Read/write permission. */
+ unsigned short __seq; /* Sequence number. */
+ unsigned short __pad1;
+ unsigned long __unused1;
+ unsigned long __unused2;
+ };
--- /dev/null
+/* Note that we use the exact same include guard #define names
+ * as asm/posix_types.h. This will avoid gratuitous conflicts
+ * with the posix_types.h kernel header, and will ensure that
+ * our private content, and not the kernel header, will win.
+ * -Erik
+ *
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#ifndef __ASM_GENERIC_POSIX_TYPES_H
+#define __ASM_GENERIC_POSIX_TYPES_H
+
+typedef unsigned int __kernel_dev_t;
+typedef unsigned int __kernel_ino_t;
+typedef unsigned int __kernel_mode_t;
+typedef unsigned long __kernel_nlink_t;
+typedef long __kernel_off_t;
+typedef int __kernel_pid_t;
+typedef unsigned int __kernel_uid_t;
+typedef unsigned int __kernel_gid_t;
+typedef unsigned int __kernel_size_t;
+typedef int __kernel_ssize_t;
+typedef long __kernel_ptrdiff_t;
+typedef long __kernel_time_t;
+typedef long __kernel_suseconds_t;
+typedef long __kernel_clock_t;
+typedef int __kernel_daddr_t;
+typedef char * __kernel_caddr_t;
+typedef int __kernel_ipc_pid_t;
+typedef unsigned short __kernel_uid16_t;
+typedef unsigned short __kernel_gid16_t;
+typedef unsigned int __kernel_uid32_t;
+typedef unsigned int __kernel_gid32_t;
+typedef unsigned int __kernel_old_uid_t;
+typedef unsigned int __kernel_old_gid_t;
+typedef __kernel_dev_t __kernel_old_dev_t;
+typedef long long __kernel_loff_t;
+
+typedef struct {
+ int val[2];
+} __kernel_fsid_t;
+
+#endif /* __ASM_GENERIC_POSIX_TYPES_H */
--- /dev/null
+/*
+ * Low-level statistical profiling support function. Linux/Meta version.
+ *
+ * Copyright (C) 2013, Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ *
+ * Based on the SH version from the GNU C Library.
+ */
+
+#include <signal.h>
+
+static void
+profil_counter (int signo, struct sigcontext sc)
+{
+ profil_count (sc.cbuf.ctx.CurrPC);
+}
--- /dev/null
+/*
+ * Copyright (C) 2013, Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+/* Define the machine-dependent type `jmp_buf' */
+#ifndef _BITS_SETJMP_H
+#define _BITS_SETJMP_H 1
+
+#if !defined _SETJMP_H && !defined _PTHREAD_H
+# error "Never include <bits/setjmp.h> directly; use <setjmp.h> instead."
+#endif
+
+/*
+ jmp_buf[0] - A0StP
+ jmp_buf[1] - A1GbP
+ jmp_buf[2] - A0FrP
+ jmp_buf[3] - A1LbP
+ jmp_buf[4] - D0FrT
+ jmp_buf[5] - D1RtP
+ jmp_buf[6] - D0.5
+ jmp_buf[7] - D1.5
+ jmp_buf[8] - D0.6
+ jmp_buf[9] - D1.6
+ jmp_buf[10] - D0.7
+ jmp_buf[11] - D1.7
+ */
+
+#define _JBLEN 24
+#if defined (__USE_MISC) || defined (_ASM)
+#define JB_SP 0
+#endif
+
+#ifndef _ASM
+typedef int __jmp_buf[_JBLEN] __attribute__((aligned (8)));
+#endif
+
+/* Test if longjmp to JMPBUF would unwind the frame
+ containing a local variable at ADDRESS. */
+#define _JMPBUF_UNWINDS(jmpbuf, address) \
+ ((void *) (address) > (void *) (jmpbuf)[JB_SP])
+
+#endif /* bits/setjmp.h */
--- /dev/null
+/*
+ * Copyright (C) 2013, Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ *
+ */
+
+#define SIGCONTEXT struct sigcontext
+#define SIGCONTEXT_EXTRA_ARGS
+#define GET_PC(ctx) ((void *) ctx.cbuf.ctx.CurrPC)
+#define GET_FRAME(ctx) ((void *) ctx.cbuf.ctx.AX[1].U0)
+#define GET_STACK(ctx) ((void *) ctx.cbuf.ctx.AX[0].U0)
+#define CALL_SIGHANDLER(handler, signo, ctx) \
+ (handler)((signo), SIGCONTEXT_EXTRA_ARGS (ctx))
--- /dev/null
+/* Copyright (C) 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* This file contains a bit of information about the stack allocation
+ of the processor. */
+
+#ifndef _STACKINFO_H
+#define _STACKINFO_H 1
+
+/* On Meta the stack grows up. */
+#define _STACK_GROWS_UP 1
+
+#endif /* stackinfo.h */
--- /dev/null
+/*
+ * Copyright (C) 2013 Imagination Technologies Ltd.
+ *
+ * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ *
+ */
+
+#ifndef _BITS_SYSCALLS_H
+#define _BITS_SYSCALLS_H
+#ifndef _SYSCALL_H
+# error "Never use <bits/syscalls.h> directly; include <sys/syscall.h> instead."
+#endif
+
+/*
+ Meta version adapted from the ARM version.
+*/
+
+#define SYS_ify(syscall_name) (__NR_##syscall_name)
+
+#ifdef __ASSEMBLER__
+
+/* Call a given syscall, with arguments loaded. */
+#undef DO_CALL
+#define DO_CALL(syscall_name, args) \
+ MOV D1Re0, #SYS_ify (syscall_name); \
+ SWITCH #0x440001
+
+#else
+
+#include <errno.h>
+
+#undef INLINE_SYSCALL_NCS
+#define INLINE_SYSCALL_NCS(name, nr, args...) \
+(__extension__ \
+ ({ unsigned int _inline_sys_result = INTERNAL_SYSCALL_NCS (name, , nr, args); \
+ if (unlikely(INTERNAL_SYSCALL_ERROR_P (_inline_sys_result, ))) \
+ { \
+ __set_errno (INTERNAL_SYSCALL_ERRNO (_inline_sys_result, )); \
+ _inline_sys_result = (unsigned int) -1; \
+ } \
+ (int) _inline_sys_result; }) \
+)
+
+#undef INTERNAL_SYSCALL_DECL
+#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
+
+#undef INTERNAL_SYSCALL_NCS
+#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
+(__extension__ \
+ ({unsigned int __sys_result; \
+ { \
+ register int _result __asm__ ("D0Re0"), _nr __asm__ ("D1Re0"); \
+ LOAD_ARGS_##nr (args); \
+ _nr = (name); \
+ __asm__ volatile ("SWITCH #0x440001 ! syscall " #name \
+ : "=r" (_result) \
+ : "d" (_nr) ASM_ARGS_##nr \
+ : "memory"); \
+ __sys_result = _result; \
+ } \
+ (int) __sys_result; }) \
+)
+
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val, err) \
+ ((unsigned int) (val) >= 0xfffff001u)
+
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
+
+#define LOAD_ARGS_0()
+#define ASM_ARGS_0
+#define LOAD_ARGS_1(a1) \
+ register int _a1 __asm__ ("D1Ar1") = (int) (a1); \
+ LOAD_ARGS_0 ()
+#define ASM_ARGS_1 ASM_ARGS_0, "d" (_a1)
+#define LOAD_ARGS_2(a1, a2) \
+ register int _a2 __asm__ ("D0Ar2") = (int) (a2); \
+ LOAD_ARGS_1 (a1)
+#define ASM_ARGS_2 ASM_ARGS_1, "d" (_a2)
+#define LOAD_ARGS_3(a1, a2, a3) \
+ register int _a3 __asm__ ("D1Ar3") = (int) (a3); \
+ LOAD_ARGS_2 (a1, a2)
+#define ASM_ARGS_3 ASM_ARGS_2, "d" (_a3)
+#define LOAD_ARGS_4(a1, a2, a3, a4) \
+ register int _a4 __asm__ ("D0Ar4") = (int) (a4); \
+ LOAD_ARGS_3 (a1, a2, a3)
+#define ASM_ARGS_4 ASM_ARGS_3, "d" (_a4)
+#define LOAD_ARGS_5(a1, a2, a3, a4, a5) \
+ register int _a5 __asm__ ("D1Ar5") = (int) (a5); \
+ LOAD_ARGS_4 (a1, a2, a3, a4)
+#define ASM_ARGS_5 ASM_ARGS_4, "d" (_a5)
+#define LOAD_ARGS_6(a1, a2, a3, a4, a5, a6) \
+ register int _a6 __asm__ ("D0Ar6") = (int) (a6); \
+ LOAD_ARGS_5 (a1, a2, a3, a4, a5)
+#define ASM_ARGS_6 ASM_ARGS_5, "d" (_a6)
+
+#endif /* __ASSEMBLER__ */
+#endif /* _BITS_SYSCALLS_H */
--- /dev/null
+/*
+ * Track misc arch-specific features that aren't config options
+ *
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#ifndef _BITS_UCLIBC_ARCH_FEATURES_H
+#define _BITS_UCLIBC_ARCH_FEATURES_H
+
+/* instruction used when calling abort() to kill yourself */
+/*#define __UCLIBC_ABORT_INSTRUCTION__ "asm instruction"*/
+#undef __UCLIBC_ABORT_INSTRUCTION__
+
+/* can your target use syscall6() for mmap ? */
+#define __UCLIBC_MMAP_HAS_6_ARGS__
+
+/* does your target use syscall4() for truncate64 ? (32bit arches only) */
+#undef __UCLIBC_TRUNCATE64_HAS_4_ARGS__
+
+/* does your target have a broken create_module() ? */
+#undef __UCLIBC_BROKEN_CREATE_MODULE__
+
+/* does your target have to worry about older [gs]etrlimit() ? */
+#undef __UCLIBC_HANDLE_OLDER_RLIMIT__
+
+/* does your target have an asm .set ? */
+#define __UCLIBC_HAVE_ASM_SET_DIRECTIVE__
+
+/* define if target doesn't like .global */
+#undef __UCLIBC_ASM_GLOBAL_DIRECTIVE__
+
+/* define if target supports .weak */
+#define __UCLIBC_HAVE_ASM_WEAK_DIRECTIVE__
+
+/* define if target supports .weakext */
+#undef __UCLIBC_HAVE_ASM_WEAKEXT_DIRECTIVE__
+
+/* needed probably only for ppc64 */
+#undef __UCLIBC_HAVE_ASM_GLOBAL_DOT_NAME__
+
+/* define if target supports IEEE signed zero floats */
+#define __UCLIBC_HAVE_SIGNED_ZERO__
+
+#endif /* _BITS_UCLIBC_ARCH_FEATURES_H */
--- /dev/null
+/* Copyright (C) 1999 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#define __WORDSIZE 32
--- /dev/null
+/*
+ * Copyright (C) 2013 Imagination Technologies Ltd.
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#include <errno.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+
+libc_hidden_proto(brk)
+
+/* This must be initialized data because commons can't have aliases. */
+void * __curbrk attribute_hidden = 0;
+
+int brk (void *addr)
+{
+ void *newbrk;
+
+ __asm__ __volatile__ ("MOV D1Re0,%2\n\t"
+ "MOV D1Ar1,%1\n\t"
+ "SWITCH #0x440001\n\t"
+ "MOV %0,D0Re0"
+ : "=r" (newbrk)
+ : "r" (addr), "K" (__NR_brk)
+ : "D0Re0", "D1Re0", "D1Ar1");
+
+ __curbrk = newbrk;
+
+ if (newbrk < addr)
+ {
+ __set_errno (ENOMEM);
+ return -1;
+ }
+
+ return 0;
+}
+libc_hidden_def(brk)
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+! clone() is even more special than fork() as it mucks with stacks
+! and invokes a function in the right context after its all over.
+
+#include <asm/errno.h>
+#include <asm/unistd.h>
+
+/* int clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg); */
+
+ .text
+ .global __clone
+ .type __clone,function
+__clone:
+ ! sanity check args
+ MOV D0Re0, #-EINVAL
+ CMP D1Ar1, #0
+ BEQ ___error
+ CMP D0Ar2, #0
+ BEQ ___error
+
+ ! save function pointer
+ MOV D0FrT, D1Ar1
+
+ ! do the system call
+ ! get flags
+ MOV D1Ar1, D1Ar3
+ ! new sp is already in D0Ar2
+ MOV D1Re0, #__NR_clone
+ SWITCH #0x440001
+ CMP D0Re0,#0
+ ! Error on -1
+ BLT ___error
+ ! If non-zero we are the parent
+ MOVNE PC, D1RtP
+ ! BRKPNT
+
+ ! We are the child
+ ! pick the function arg and call address off the stack and execute
+ MOV D0Ar2, D0FrT
+ MOV D1Ar1, D0Ar4
+ MOV D1RtP, PC
+ ADD D1RtP, D1RtP, #8
+ MOV PC, D0Ar2
+
+ ! and we are done, passing the return value through D0Re0
+#ifdef __PIC__
+ B _exit@PLT
+#else
+ B _exit
+#endif
+
+___error:
+ MOV D1Ar1, D0Re0
+#ifdef __PIC__
+ B ___syscall_error@PLT
+#else
+ B ___syscall_error
+#endif
+ .size __clone, .-__clone
+
+.weak _clone
+_clone = __clone
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+
+#include <asm/unistd.h>
+
+ .text
+ .global __start
+ .type __start,function
+__start:
+ MOV D0FrT,A0StP
+ MOV A0FrP,A0StP
+
+ MOV A0.2,#0
+ MOV A0.3,#0
+
+ MOV A1.1,#0
+ MOV A1.2,#0
+ MOV A1.3,#0
+
+ MOV D0.5,#0
+ MOV D0.6,#0
+ MOV D0.7,#0
+
+ MOV D1.5,#0
+ MOV D1.6,#0
+ MOV D1.7,#0
+
+ MOV D1Ar3,D0Ar2 ! argv
+ MOV D0Ar2,D1Ar1 ! argc
+
+#ifdef __PIC__
+ ADDT A1LbP,CPC1,#HI(__GLOBAL_OFFSET_TABLE__)
+ ADD A1LbP,A1LbP,#LO(__GLOBAL_OFFSET_TABLE__+4)
+
+ MOV D1Ar1,A1LbP
+ ADDT D1Ar1,D1Ar1,#HI(_main@GOTOFF)
+ ADD D1Ar1,D1Ar1,#LO(_main@GOTOFF)
+
+ MOV D0Ar4,A1LbP
+ ADDT D0Ar4,D0Ar4,#HI(__init@GOTOFF)
+ ADD D0Ar4,D0Ar4,#LO(__init@GOTOFF)
+
+ MOV D1Ar5,A1LbP
+ ADDT D1Ar5,D1Ar5,#HI(__fini@GOTOFF)
+ ADD D1Ar5,D1Ar5,#LO(__fini@GOTOFF)
+#else
+ MOVT D1Ar1,#HI(_main)
+ ADD D1Ar1,D1Ar1,#LO(_main)
+ MOVT D0Ar4,#HI(__init)
+ ADD D0Ar4,D0Ar4,#LO(__init)
+ MOVT D1Ar5,#HI(__fini)
+ ADD D1Ar5,D1Ar5,#LO(__fini)
+#endif
+
+ MOV D0Ar6,#0 ! rtld_fini
+
+ MOVT D1Re0,#0x80
+
+ SETL [A0StP++],D0Re0,D1Re0 ! stack_end (8Mb)
+
+ MOV D1Re0,#0
+ MOV D0Re0,#0
+
+#ifdef __PIC__
+ CALLR D1RtP, ___uClibc_main@PLT
+#else
+ CALLR D1RtP, ___uClibc_main
+#endif
+
+ MOV D1Re0,#__NR_exit
+ MOV D1Ar1,#0x1
+ SWITCH #0x440001 ! exit syscall
+
+ .size __start,.-__start
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+ .section .init
+ .global __init
+ .type __init,function
+__init:
+ MOV D0FrT, A0FrP
+ ADD A0FrP, A0StP, #0
+ SETL [A0StP++], D0.4, D1RtP
+
+ .section .fini
+ .global __fini
+ .type __fini,function
+__fini:
+ MOV D0FrT, A0FrP
+ ADD A0FrP, A0StP, #0
+ SETL [A0StP++], D0.4, D1RtP
--- /dev/null
+! Copyright (C) 2013 Imagination Technologies Ltd.
+
+! Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+
+ .section .init
+ .global __init
+ .type __init,function
+ GETL D0.4, D1RtP, [A0FrP+#8++]
+ SUB A0StP, A0FrP, #8
+ MOV A0FrP, D0.4
+ MOV PC, D1RtP
+
+ .section .fini
+ .global __fini
+ .type __fini,function
+ GETL D0.4, D1RtP, [A0FrP+#8++]
+ SUB A0StP, A0FrP, #8
+ MOV A0FrP, D0.4
+ MOV PC, D1RtP
--- /dev/null
+/*
+ * Copyright (C) 2013 Imagination Technologies Ltd.
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#include <errno.h>
+#include <sys/syscall.h>
+
+_syscall2(int,metag_setglobalbit,char *,addr,int,mask)
--- /dev/null
+/*
+ * Copyright (C) 2013 Imagination Technologies Ltd.
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+!!! setjmp and variants
+ .text
+
+!! int _setjmp (jmp_buf __env)
+!! Store the calling environment in ENV, not saving the signal mask.
+!! Return 0. */
+ .global __setjmp
+ .type __setjmp,function
+__setjmp:
+ MOV D0Ar2,#0
+ B ___sigsetjmp1
+ .size __setjmp,.-__setjmp
+
+!! int setjmp (jmp_buf __env)
+!! Store the calling environment in ENV, also saving the signal mask.
+!! Return 0. */
+ .global _setjmp
+ .type _setjmp,function
+_setjmp:
+ MOV D0Ar2,#1
+ !! fall through to __sigsetjmp
+ .size _setjmp,.-_setjmp
+
+!! int __sigsetjmp (jmp_buf __env, int __savemask)
+!! Store the calling environment in ENV, also saving the
+!! signal mask if SAVEMASK is nonzero. Return 0.
+!! This is the internal name for `sigsetjmp'.
+ .global ___sigsetjmp
+ .type ___sigsetjmp,function
+___sigsetjmp:
+___sigsetjmp1:
+ !! Save A0/A1 regs
+ MSETL [D1Ar1++],A0.0,A0.1
+ !! Use A0.3 as temp
+ MOV A0.3,D1Ar1
+ !! Rewind D1Ar1 that was modified above
+ SUB D1Ar1,D1Ar1,#(2*8)
+ !! Save D0/D1 regs
+ MSETL [A0.3++],D0FrT,D0.5,D0.6,D0.7
+ !! Tail call __sigjmp_save
+#ifdef __PIC__
+ B ___sigjmp_save@PLT
+#else
+ B ___sigjmp_save
+#endif
+ .size ___sigsetjmp,.-___sigsetjmp
--- /dev/null
+/* Copyright (C) 1996, 1998, 1999, 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _SYS_IO_H
+
+#define _SYS_IO_H 1
+#include <features.h>
+
+__BEGIN_DECLS
+
+/* If TURN_ON is TRUE, request for permission to do direct i/o on the
+ port numbers in the range [FROM,FROM+NUM-1]. Otherwise, turn I/O
+ permission off for that range. This call requires root privileges. */
+extern int ioperm (unsigned long int __from, unsigned long int __num,
+ int __turn_on) __THROW;
+
+/* Set the I/O privilege level to LEVEL. If LEVEL is nonzero,
+ permission to access any I/O port is granted. This call requires
+ root privileges. */
+extern int iopl (int __level) __THROW;
+
+/* The functions that actually perform reads and writes. */
+extern unsigned char inb (unsigned long int port) __THROW;
+extern unsigned short int inw (unsigned long int port) __THROW;
+extern unsigned long int inl (unsigned long int port) __THROW;
+
+extern void outb (unsigned char value, unsigned long int port) __THROW;
+extern void outw (unsigned short value, unsigned long int port) __THROW;
+extern void outl (unsigned long value, unsigned long int port) __THROW;
+
+__END_DECLS
+
+#endif /* _SYS_IO_H */
--- /dev/null
+/* Copyright (C) 1996, 1997, 1999, 2007 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
+ Boston, MA 02110-1301, USA. */
+
+#ifndef _SYS_PROCFS_H
+#define _SYS_PROCFS_H 1
+
+/* This is somewhat modelled after the file of the same name on SVR4
+ systems. It provides a definition of the core file format for ELF
+ used on Linux. It doesn't have anything to do with the /proc file
+ system, even though Linux has one.
+
+ Anyway, the whole purpose of this file is for GDB and GDB only.
+ Don't read too much into it. Don't use it for anything other than
+ GDB unless you know what you are doing. */
+
+#include <features.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/user.h>
+
+__BEGIN_DECLS
+
+/* Type for a general-purpose register. */
+typedef unsigned long elf_greg_t;
+
+#define ELF_NGREG 30
+typedef elf_greg_t elf_gregset_t[ELF_NGREG];
+
+/* Register set for the floating-point registers. */
+#define ELF_NFPREG 18
+typedef unsigned long elf_fpreg_t;
+typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
+
+/* Signal info. */
+struct elf_siginfo
+ {
+ int si_signo; /* Signal number. */
+ int si_code; /* Extra code. */
+ int si_errno; /* Errno. */
+ };
+
+/* Definitions to generate Intel SVR4-like core files. These mostly
+ have the same names as the SVR4 types with "elf_" tacked on the
+ front to prevent clashes with Linux definitions, and the typedef
+ forms have been avoided. This is mostly like the SVR4 structure,
+ but more Linuxy, with things that Linux does not support and which
+ GDB doesn't really use excluded. */
+
+struct elf_prstatus
+ {
+ struct elf_siginfo pr_info; /* Info associated with signal. */
+ short int pr_cursig; /* Current signal. */
+ unsigned long int pr_sigpend; /* Set of pending signals. */
+ unsigned long int pr_sighold; /* Set of held signals. */
+ __pid_t pr_pid;
+ __pid_t pr_ppid;
+ __pid_t pr_pgrp;
+ __pid_t pr_sid;
+ struct timeval pr_utime; /* User time. */
+ struct timeval pr_stime; /* System time. */
+ struct timeval pr_cutime; /* Cumulative user time. */
+ struct timeval pr_cstime; /* Cumulative system time. */
+ elf_gregset_t pr_reg; /* GP registers. */
+ int pr_fpvalid; /* True if math copro being used. */
+ };
+
+
+#define ELF_PRARGSZ (80) /* Number of chars for args. */
+
+struct elf_prpsinfo
+ {
+ char pr_state; /* Numeric process state. */
+ char pr_sname; /* Char for pr_state. */
+ char pr_zomb; /* Zombie. */
+ char pr_nice; /* Nice val. */
+ unsigned long int pr_flag; /* Flags. */
+ unsigned short int pr_uid;
+ unsigned short int pr_gid;
+ int pr_pid, pr_ppid, pr_pgrp, pr_sid;
+ /* Lots missing */
+ char pr_fname[16]; /* Filename of executable. */
+ char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */
+ };
+
+/* The rest of this file provides the types for emulation of the
+ Solaris <proc_service.h> interfaces that should be implemented by
+ users of libthread_db. */
+
+/* Addresses. */
+typedef void *psaddr_t;
+
+/* Register sets. Linux has different names. */
+typedef elf_gregset_t prgregset_t;
+typedef elf_fpregset_t prfpregset_t;
+
+/* We don't have any differences between processes and threads,
+ therefore have only one PID type. */
+typedef __pid_t lwpid_t;
+
+/* Process status and info. In the end we do provide typedefs for them. */
+typedef struct elf_prstatus prstatus_t;
+typedef struct elf_prpsinfo prpsinfo_t;
+
+__END_DECLS
+
+#endif /* sys/procfs.h */
--- /dev/null
+/* Copyright (C) 1998, 1999, 2001, 2006 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* Meta ABI compliant context switching support. */
+
+#ifndef _SYS_UCONTEXT_H
+#define _SYS_UCONTEXT_H 1
+
+#include <features.h>
+#include <signal.h>
+#include <sys/procfs.h>
+
+/* We need the signal context definitions even if they are not used
+ included in <signal.h>. */
+#include <bits/sigcontext.h>
+
+typedef int greg_t;
+
+/* Number of general registers. */
+#define NGREG 18
+
+/* Container for all general registers. */
+typedef elf_gregset_t gregset_t;
+
+/* Number of each register is the `gregset_t' array. */
+enum
+{
+ R0 = 0,
+#define R0 R0
+ R1 = 1,
+#define R1 R1
+ R2 = 2,
+#define R2 R2
+ R3 = 3,
+#define R3 R3
+ R4 = 4,
+#define R4 R4
+ R5 = 5,
+#define R5 R5
+ R6 = 6,
+#define R6 R6
+ R7 = 7,
+#define R7 R7
+ R8 = 8,
+#define R8 R8
+ R9 = 9,
+#define R9 R9
+ R10 = 10,
+#define R10 R10
+ R11 = 11,
+#define R11 R11
+ R12 = 12,
+#define R12 R12
+ R13 = 13,
+#define R13 R13
+ R14 = 14,
+#define R14 R14
+ R15 = 15
+#define R15 R15
+};
+
+/* Structure to describe FPU registers. */
+typedef elf_fpregset_t fpregset_t;
+
+/* Context to describe whole processor state. This only describes
+ the core registers; coprocessor registers get saved elsewhere
+ (e.g. in uc_regspace, or somewhere unspecified on the stack
+ during non-RT signal handlers). */
+typedef struct sigcontext mcontext_t;
+
+/* Userlevel context. */
+typedef struct ucontext
+ {
+ unsigned long uc_flags;
+ struct ucontext *uc_link;
+ stack_t uc_stack;
+ mcontext_t uc_mcontext;
+ __sigset_t uc_sigmask;
+ } ucontext_t;
+
+#endif /* sys/ucontext.h */
--- /dev/null
+/*
+ * This file is not needed, but in practice gdb might try to include it.
+ *
+ * Copyright (C) 2013 Imagination Technologies Ltd.
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
--- /dev/null
+/* syscall for META/uClibc
+ *
+ * Copyright (C) 2013 Imagination Technologies
+ *
+ * Licensed under the LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
+ */
+
+#include <features.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/syscall.h>
+
+long syscall(long sysnum,
+ long arg1, long arg2, long arg3,
+ long arg4, long arg5, long arg6)
+{
+
+ register long __call __asm__ ("D1Re0") = sysnum;
+ register long __res __asm__ ("D0Re0");
+ register long __a __asm__ ("D1Ar1") = arg1;
+ register long __b __asm__ ("D0Ar2") = arg2;
+ register long __c __asm__ ("D1Ar3") = arg3;
+ register long __d __asm__ ("D0Ar4") = arg4;
+ register long __e __asm__ ("D1Ar5") = arg5;
+ register long __f __asm__ ("D0Ar6") = arg6;
+
+
+ __asm__ __volatile__ ("SWITCH #0x440001"
+ : "=d" (__res)
+ : "d" (__call), "d" (__a), "d" (__b),
+ "d" (__c), "d" (__d), "d" (__e) , "d" (__f)
+ : "memory");
+
+ if(__res >= (unsigned long) -4095) {
+ long err = __res;
+ (*__errno_location()) = (-err);
+ __res = (unsigned long) -1;
+ }
+ return (long) __res;
+}
projects / uclibc-ng.git / commitdiff