Add support for the Meta architecture

Meta cores are 32-bit, hardware multithreaded, general purpose, embedded
processors which also feature a DSP instruction set, and can be found in
many digital radios. They are capable of running different operating
systems on different hardware threads, for example a digital radio might
run RTOSes for DAB decoding and audio decoding on 3 hardware threads,
and run Linux on the 4th hardware thread to manage the user interface,
networking etc. HTPs are also capable of running SMP Linux on multiple
hardware threads.

Signed-off-by: Markos Chandras <markos.chandras@imgtec.com>
Signed-off-by: Bernhard Reutner-Fischer <rep.dot.nop@gmail.com>

Rules.mak

@@ -405,6 +405,12 @@ ifeq ($(TARGET_ARCH),arm)
 	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

extra/Configs/Config.in

@@ -24,6 +24,7 @@ choice
 	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"
@@ -81,6 +82,9 @@ config TARGET_ia64
 config TARGET_m68k
 	bool "m68k"
 
+config TARGET_metag
+	bool "metag"
+
 config TARGET_microblaze
 	bool "microblaze"
 
@@ -174,6 +178,10 @@ if TARGET_m68k
 source "extra/Configs/Config.m68k"
 endif
 
+if TARGET_metag
+source "extra/Configs/Config.metag"
+endif
+
 if TARGET_nios
 source "extra/Configs/Config.nios"
 endif
@@ -1491,7 +1499,7 @@ config UCLIBC_BUILD_MINIMAL_LOCALE
 
 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.
 

extra/Configs/Config.metag

@@ -0,0 +1,32 @@
+#
+# 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

extra/Configs/defconfigs/metag/defconfig

@@ -0,0 +1 @@
+TARGET_metag=y

ldso/ldso/metag/dl-debug.h

@@ -0,0 +1,27 @@
+/*
+ * 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",
+};

ldso/ldso/metag/dl-startup.h

@@ -0,0 +1,63 @@
+/*
+ * 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;
+	}
+}

ldso/ldso/metag/dl-syscalls.h

@@ -0,0 +1,6 @@
+/* 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.
+ */

ldso/ldso/metag/dl-sysdep.h

@@ -0,0 +1,98 @@
+/*
+ * 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

ldso/ldso/metag/elfinterp.c

@@ -0,0 +1,299 @@
+/*
+ * 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);
+}

ldso/ldso/metag/resolve.S

@@ -0,0 +1,51 @@
+/*
+ * 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

libc/string/metag/Makefile

@@ -0,0 +1,13 @@
+# Makefile for uClibc
+#
+# Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org>
+#
+# 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

libc/string/metag/memchr.S

@@ -0,0 +1,156 @@
+!    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)

libc/string/metag/memcpy.S

@@ -0,0 +1,189 @@
+!    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)

libc/string/metag/memmove.S

@@ -0,0 +1,350 @@
+!    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)

libc/string/metag/memset.S

@@ -0,0 +1,90 @@
+!    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)

libc/string/metag/strchr.S

@@ -0,0 +1,167 @@
+!    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

libc/string/metag/strcmp.S

@@ -0,0 +1,65 @@
+!    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

libc/string/metag/strcpy.S

@@ -0,0 +1,94 @@
+!    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)

libc/sysdeps/linux/metag/Makefile

@@ -0,0 +1,13 @@
+# Makefile for uClibc
+#
+# Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org>
+#
+# 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

libc/sysdeps/linux/metag/Makefile.arch

@@ -0,0 +1,10 @@
+# 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

libc/sysdeps/linux/metag/__syscall_error.c

@@ -0,0 +1,18 @@
+/* Wrapper for setting errno.
+ *
+ * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
+ *
+ * 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;
+}

libc/sysdeps/linux/metag/_longjmp.S

@@ -0,0 +1,25 @@
+!    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)

libc/sysdeps/linux/metag/bits/endian.h

@@ -0,0 +1,12 @@
+/* Meta is little endian
+ *
+ * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
+ *
+ * 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

libc/sysdeps/linux/metag/bits/fcntl.h

@@ -0,0 +1,238 @@
+/* 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
+

libc/sysdeps/linux/metag/bits/ipc.h

@@ -0,0 +1,55 @@
+/* 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;
+  };

libc/sysdeps/linux/metag/bits/kernel_types.h

@@ -0,0 +1,45 @@
+/* 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
+ *
+ * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
+ *
+ * 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 */

libc/sysdeps/linux/metag/bits/profil-counter.h

@@ -0,0 +1,17 @@
+/*
+ * 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);
+}

libc/sysdeps/linux/metag/bits/setjmp.h

@@ -0,0 +1,44 @@
+/*
+ * 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 */

libc/sysdeps/linux/metag/bits/sigcontextinfo.h

@@ -0,0 +1,14 @@
+/*
+ * 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))

libc/sysdeps/linux/metag/bits/stackinfo.h

@@ -0,0 +1,28 @@
+/* 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 */

libc/sysdeps/linux/metag/bits/syscalls.h

@@ -0,0 +1,99 @@
+/*
+ * 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 */

libc/sysdeps/linux/metag/bits/uClibc_arch_features.h

@@ -0,0 +1,46 @@
+/*
+ * Track misc arch-specific features that aren't config options
+ *
+ * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
+ *
+ * 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 */

libc/sysdeps/linux/metag/bits/wordsize.h

@@ -0,0 +1,19 @@
+/* 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

libc/sysdeps/linux/metag/brk.c

@@ -0,0 +1,38 @@
+/*
+ * 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)

libc/sysdeps/linux/metag/clone.S

@@ -0,0 +1,65 @@
+!    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

libc/sysdeps/linux/metag/crt1.S

@@ -0,0 +1,76 @@
+!    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

libc/sysdeps/linux/metag/crti.S

@@ -0,0 +1,19 @@
+!    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

libc/sysdeps/linux/metag/crtn.S

@@ -0,0 +1,19 @@
+!    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

libc/sysdeps/linux/metag/metag.c

@@ -0,0 +1,10 @@
+/*
+ * 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)

libc/sysdeps/linux/metag/setjmp.S

@@ -0,0 +1,52 @@
+/*
+ * 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

libc/sysdeps/linux/metag/sys/io.h

@@ -0,0 +1,48 @@
+/* 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 */

libc/sysdeps/linux/metag/sys/procfs.h

@@ -0,0 +1,121 @@
+/* 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 */

libc/sysdeps/linux/metag/sys/ucontext.h

@@ -0,0 +1,96 @@
+/* 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 */

libc/sysdeps/linux/metag/sys/user.h

@@ -0,0 +1,7 @@
+/*
+ * 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.
+ */

libc/sysdeps/linux/metag/syscall.c

@@ -0,0 +1,40 @@
+/* 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;
+}