OpenWrt XBurst

OpenWrt XBurst Git Source Tree

Root/toolchain/uClibc/patches-0.9.32/600-ubicom32-uClibc.patch

1	--- a/Rules.mak
2	+++ b/Rules.mak
3	@@ -477,6 +477,17 @@ ifeq ($(TARGET_ARCH),microblaze)
4	SYMBOL_PREFIX=_
5	endif
6
7	+ifeq ($(TARGET_ARCH),ubicom32)
8	+ OPTIMIZATION+=-fstrict-aliasing
9	+ CPU_CFLAGS-$(CONFIG_UBICOM32_V3)+=-march=ubicom32v3
10	+ CPU_CFLAGS-$(CONFIG_UBICOM32_V4)+=-march=ubicom32v4
11	+ifeq ($(UCLIBC_FORMAT_FDPIC_ELF),y)
12	+ CPU_CFLAGS-y:=-mfdpic
13	+ CPU_LDFLAGS-y += -Wl,-melf32ubicom32fdpic
14	+endif
15	+
16	+endif
17	+
18	ifeq ($(TARGET_ARCH),v850)
19	SYMBOL_PREFIX=_
20	endif
21	--- a/extra/Configs/Config.in
22	+++ b/extra/Configs/Config.in
23	@@ -102,6 +102,9 @@ config TARGET_sh64
24	config TARGET_sparc
25	bool "sparc"
26
27	+config TARGET_ubicom32
28	+ bool "ubicom32"
29	+
30	config TARGET_v850
31	bool "v850 (BROKEN)"
32
33	@@ -203,6 +206,10 @@ if TARGET_sparc
34	source "extra/Configs/Config.sparc"
35	endif
36
37	+if TARGET_ubicom32
38	+source "extra/Configs/Config.ubicom32"
39	+endif
40	+
41	if TARGET_v850
42	source "extra/Configs/Config.v850"
43	endif
44	--- a/extra/Configs/Config.in.arch
45	+++ b/extra/Configs/Config.in.arch
46	@@ -149,7 +149,7 @@ config UCLIBC_HAS_SOFT_FLOAT
47	config DO_C99_MATH
48	bool "Enable full C99 math library support"
49	depends on UCLIBC_HAS_FLOATS
50	- default n
51	+ default y
52	help
53	If you want the uClibc math library to contain the full set C99
54	math library features, then answer Y. If you leave this set to
55	--- /dev/null
56	+++ b/extra/Configs/Config.ubicom32
57	@@ -0,0 +1,44 @@
58	+#
59	+# For a description of the syntax of this configuration file,
60	+# see extra/config/Kconfig-language.txt
61	+#
62	+
63	+config TARGET_ARCH
64	+ string
65	+ default "ubicom32"
66	+
67	+config FORCE_OPTIONS_FOR_ARCH
68	+ bool
69	+ default y
70	+ select ARCH_BIG_ENDIAN
71	+ select ARCH_HAS_NO_MMU
72	+
73	+choice
74	+ prompt "Target Processor Architecture"
75	+ default CONFIG_UC_UBICOM32_V3
76	+ help
77	+ This selects the instruction set architecture of your Ubicom32 CPU. This
78	+ information is used for optimizing purposes. To build a library that
79	+ will run on any Ubicom32 CPU, you can specify "v3" here.
80	+ If you pick anything other than "v3," there is no
81	+ guarantee that uClibc will even run on anything other than the
82	+ selected processor type.
83	+
84	+ You should probably select the Ubicom32 ISA that best matches the
85	+ CPU you will be using on your device. uClibc will be tuned
86	+ for that architecture.
87	+
88	+ If you don't know what to do, choose "v3"
89	+
90	+config CONFIG_UC_UBICOM32_V3
91	+ bool "ISA v3"
92	+
93	+config CONFIG_UC_UBICOM32_V4
94	+ bool "ISA v4"
95	+endchoice
96	+
97	+config ARCH_CFLAGS
98	+ string
99	+
100	+config CROSS
101	+ string
102	--- a/include/elf.h
103	+++ b/include/elf.h
104	@@ -337,6 +337,8 @@ typedef struct
105
106	#define EM_XSTORMY16 0xad45
107
108	+#define EM_UBICOM32 0xde3d /* Ubicom32; no ABI */
109	+
110	/* FRV magic number - no EABI available??. */
111	#define EM_CYGNUS_FRV 0x5441
112
113	@@ -3063,6 +3065,55 @@ typedef Elf32_Addr Elf32_Conflict;
114	/* Keep this the last entry. */
115	#define R_XTENSA_NUM 50
116
117	+/* Ubicom32 ELF relocation types */
118	+#define R_UBICOM32_NONE 0
119	+#define R_UBICOM32_16 1
120	+#define R_UBICOM32_32 2
121	+#define R_UBICOM32_LO16 3
122	+#define R_UBICOM32_HI16 4
123	+#define R_UBICOM32_21_PCREL 5
124	+#define R_UBICOM32_24_PCREL 6
125	+#define R_UBICOM32_HI24 7
126	+#define R_UBICOM32_LO7_S 8
127	+#define R_UBICOM32_LO7_2_S 9
128	+#define R_UBICOM32_LO7_4_S 10
129	+#define R_UBICOM32_LO7_D 11
130	+#define R_UBICOM32_LO7_2_D 12
131	+#define R_UBICOM32_LO7_4_D 13
132	+#define R_UBICOM32_32_HARVARD 14
133	+#define R_UBICOM32_LO7_CALLI 15
134	+#define R_UBICOM32_LO16_CALLI 16
135	+#define R_UBICOM32_GOT_HI24 17
136	+#define R_UBICOM32_GOT_LO7_S 18
137	+#define R_UBICOM32_GOT_LO7_2_S 19
138	+#define R_UBICOM32_GOT_LO7_4_S 20
139	+#define R_UBICOM32_GOT_LO7_D 21
140	+#define R_UBICOM32_GOT_LO7_2_D 22
141	+#define R_UBICOM32_GOT_LO7_4_D 23
142	+#define R_UBICOM32_FUNCDESC_GOT_HI24 24
143	+#define R_UBICOM32_FUNCDESC_GOT_LO7_S 25
144	+#define R_UBICOM32_FUNCDESC_GOT_LO7_2_S 26
145	+#define R_UBICOM32_FUNCDESC_GOT_LO7_4_S 27
146	+#define R_UBICOM32_FUNCDESC_GOT_LO7_D 28
147	+#define R_UBICOM32_FUNCDESC_GOT_LO7_2_D 29
148	+#define R_UBICOM32_FUNCDESC_GOT_LO7_4_D 30
149	+#define R_UBICOM32_GOT_LO7_CALLI 31
150	+#define R_UBICOM32_FUNCDESC_GOT_LO7_CALLI 32
151	+#define R_UBICOM32_FUNCDESC_VALUE 33
152	+#define R_UBICOM32_FUNCDESC 34
153	+#define R_UBICOM32_GOTOFFSET_LO 35
154	+#define R_UBICOM32_GOTOFFSET_HI 36
155	+#define R_UBICOM32_FUNCDESC_GOTOFFSET_LO 37
156	+#define R_UBICOM32_FUNCDESC_GOTOFFSET_HI 38
157	+#define R_UBICOM32_GNU_VTINHERIT 200
158	+#define R_UBICOM32_GNU_VTENTRY 201
159	+
160	+/* Ubicom32 Flags. */
161	+#define EF_UBICOM32_V3 0x00000001 /* -fmarch=ubicom32v3 */
162	+#define EF_UBICOM32_V4 0x00000002 /* -fmarch=ubicom32v4 */
163	+#define EF_UBICOM32_PIC 0x80000000 /* -fpic */
164	+#define EF_UBICOM32_FDPIC 0x40000000 /* -mfdpic */
165	+
166	#ifdef __cplusplus
167	}
168	#endif
169	--- a/include/features.h
170	+++ b/include/features.h
171	@@ -445,4 +445,10 @@ uClibc was built without large file supp
172	# include <libc-internal.h>
173	#endif
174
175	+#ifndef libc_hidden_proto
176	+#define libc_hidden_proto(name, attrs...)
177	+#endif
178	+#ifndef libm_hidden_proto
179	+#define libm_hidden_proto(name, attrs...)
180	+#endif
181	#endif /* features.h */
182	--- a/ldso/ldso/dl-startup.c
183	+++ b/ldso/ldso/dl-startup.c
184	@@ -164,10 +164,13 @@ DL_START(unsigned long args)
185	aux_dat += 2;
186	}
187
188	+#if !defined __FDPIC__
189	/* locate the ELF header. We need this done as soon as possible
190	* (esp since SEND_STDERR() needs this on some platforms... */
191	if (!auxvt[AT_BASE].a_un.a_val)
192	auxvt[AT_BASE].a_un.a_val = elf_machine_load_address();
193	+#endif
194	+
195	DL_INIT_LOADADDR_BOOT(load_addr, auxvt[AT_BASE].a_un.a_val);
196	header = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_val;
197
198	--- a/ldso/ldso/ldso.c
199	+++ b/ldso/ldso/ldso.c
200	@@ -325,10 +325,12 @@ void _dl_get_ready_to_run(struct elf_res
201	_dl_progname = argv[0];
202	}
203
204	+#if 0 // blackfin does this, we do to avoid die during reloc
205	if (_start == (void *) auxvt[AT_ENTRY].a_un.a_val) {
206	_dl_dprintf(_dl_debug_file, "Standalone execution is not supported yet\n");
207	_dl_exit(1);
208	}
209	+#endif
210
211	/* Start to build the tables of the modules that are required for
212	* this beast to run. We start with the basic executable, and then
213	--- /dev/null
214	+++ b/ldso/ldso/ubicom32/dl-debug.h
215	@@ -0,0 +1,72 @@
216	+/* vi: set sw=4 ts=4: */
217	+/* Ubicom32 ELF shared library loader suppport
218	+ *
219	+ * Copyright (c) 2009 Ubicom Inc.
220	+ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald,
221	+ * David Engel, Hongjiu Lu and Mitch D'Souza
222	+ * Copyright (C) 2001-2004 Erik Andersen
223	+ *
224	+ * All rights reserved.
225	+ *
226	+ * Redistribution and use in source and binary forms, with or without
227	+ * modification, are permitted provided that the following conditions
228	+ * are met:
229	+ * 1. Redistributions of source code must retain the above copyright
230	+ * notice, this list of conditions and the following disclaimer.
231	+ * 2. The name of the above contributors may not be
232	+ * used to endorse or promote products derived from this software
233	+ * without specific prior written permission.
234	+ *
235	+ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
236	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
237	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
238	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
239	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
240	+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
241	+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
242	+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
243	+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
244	+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
245	+ * SUCH DAMAGE.
246	+ */
247	+
248	+static const char *_dl_reltypes_tab[] =
249	+{
250	+ "R_UBICOM32_NONE", /* 0 */
251	+ "R_UBICOM32_16",
252	+ "R_UBICOM32_32",
253	+ "R_UBICOM32_LO16",
254	+ "R_UBICOM32_HI16",
255	+ "R_UBICOM32_21_PCREL", /* 5 */
256	+ "R_UBICOM32_24_PCREL",
257	+ "R_UBICOM32_HI24",
258	+ "R_UBICOM32_LO7_S",
259	+ "R_UBICOM32_LO7_2_S",
260	+ "R_UBICOM32_LO7_4_S", /* 10 */
261	+ "R_UBICOM32_LO7_D",
262	+ "R_UBICOM32_LO7_2_D",
263	+ "R_UBICOM32_LO7_4_D",
264	+ "R_UBICOM32_32_HARVARD",
265	+ "R_UBICOM32_LO7_CALLI", /* 15 */
266	+ "R_UBICOM32_LO16_CALLI",
267	+ "R_UBICOM32_GOT_HI24",
268	+ "R_UBICOM32_GOT_LO7_S",
269	+ "R_UBICOM32_GOT_LO7_2_S"
270	+ "R_UBICOM32_GOT_LO7_4_S", /* 20 */
271	+ "R_UBICOM32_GOT_LO7_D",
272	+ "R_UBICOM32_GOT_LO7_2_D",
273	+ "R_UBICOM32_GOT_LO7_4_D",
274	+ "R_UBICOM32_FUNCDESC_GOT_HI24 24",
275	+ "R_UBICOM32_FUNCDESC_GOT_LO7_S", /* 25 */
276	+ "R_UBICOM32_FUNCDESC_GOT_LO7_2_S",
277	+ "R_UBICOM32_FUNCDESC_GOT_LO7_4_S",
278	+ "R_UBICOM32_FUNCDESC_GOT_LO7_D",
279	+ "R_UBICOM32_FUNCDESC_GOT_LO7_2_D",
280	+ "R_UBICOM32_FUNCDESC_GOT_LO7_4_D", /* 30 */
281	+ "R_UBICOM32_GOT_LO7_CALLI",
282	+ "R_UBICOM32_FUNCDESC_VALUE",
283	+ "R_UBICOM32_FUNCDESC",
284	+#if 1
285	+ [200] "R_UBICOM32_GNU_VTINHERIT" , "R_UBICOM32_GNU_VTENTRY"
286	+#endif
287	+};
288	--- /dev/null
289	+++ b/ldso/ldso/ubicom32/dl-inlines.h
290	@@ -0,0 +1,582 @@
291	+ /* Copyright (C) 2003, 2004 Red Hat, Inc.
292	+ Contributed by Alexandre Oliva <aoliva@redhat.com>
293	+
294	+This file is part of uClibc.
295	+
296	+uClibc is free software; you can redistribute it and/or modify it
297	+under the terms of the GNU Lesser General Public License as
298	+published by the Free Software Foundation; either version 2.1 of the
299	+License, or (at your option) any later version.
300	+
301	+uClibc is distributed in the hope that it will be useful, but WITHOUT
302	+ANY WARRANTY; without even the implied warranty of
303	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
304	+Library General Public License for more details.
305	+
306	+You should have received a copy of the GNU Lesser General Public
307	+License along with uClibc; see the file COPYING.LIB. If not, write to
308	+the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
309	+USA. */
310	+
311	+//#include <bfin_sram.h>
312	+#define SRAM_TEST(x) 0
313	+#ifndef _dl_assert
314	+# define _dl_assert(expr)
315	+#endif
316	+
317	+/* Initialize a DL_LOADADDR_TYPE given a got pointer and a complete
318	+ load map. */
319	+static __always_inline void
320	+__dl_init_loadaddr_map (struct elf32_fdpic_loadaddr *loadaddr, Elf32_Addr dl_boot_got_pointer,
321	+ struct elf32_fdpic_loadmap *map)
322	+{
323	+ if (map->version != 0)
324	+ {
325	+ SEND_EARLY_STDERR ("Invalid loadmap version number\n");
326	+ _dl_exit(-1);
327	+ }
328	+ if (map->nsegs == 0)
329	+ {
330	+ SEND_EARLY_STDERR ("Invalid segment count in loadmap\n");
331	+ _dl_exit(-1);
332	+ }
333	+ loadaddr->got_value = (void*)dl_boot_got_pointer;
334	+ loadaddr->map = map;
335	+}
336	+
337	+/* Figure out how many LOAD segments there are in the given headers,
338	+ and allocate a block for the load map big enough for them.
339	+ got_value will be properly initialized later on, with INIT_GOT. */
340	+static __always_inline int
341	+__dl_init_loadaddr (struct elf32_fdpic_loadaddr loadaddr, Elf32_Phdr ppnt,
342	+ int pcnt)
343	+{
344	+ int count = 0, i;
345	+ size_t size;
346	+
347	+ for (i = 0; i < pcnt; i++)
348	+ if (ppnt[i].p_type == PT_LOAD)
349	+ count++;
350	+
351	+ loadaddr->got_value = 0;
352	+
353	+ size = sizeof (struct elf32_fdpic_loadmap)
354	+ + sizeof (struct elf32_fdpic_loadseg) * count;
355	+ loadaddr->map = _dl_malloc (size);
356	+ if (! loadaddr->map)
357	+ _dl_exit (-1);
358	+
359	+ loadaddr->map->version = 0;
360	+ loadaddr->map->nsegs = 0;
361	+
362	+ return count;
363	+}
364	+
365	+#if defined (__SUPPORT_LD_DEBUG__)
366	+extern char *_dl_debug;
367	+extern int _dl_debug_file;
368	+#endif
369	+
370	+/* Incrementally initialize a load map. */
371	+static __always_inline void
372	+__dl_init_loadaddr_hdr (struct elf32_fdpic_loadaddr loadaddr, void *addr,
373	+ Elf32_Phdr *phdr, int maxsegs)
374	+{
375	+ struct elf32_fdpic_loadseg *segdata;
376	+
377	+ if (loadaddr.map->nsegs == maxsegs)
378	+ _dl_exit (-1);
379	+
380	+ segdata = &loadaddr.map->segs[loadaddr.map->nsegs++];
381	+ segdata->addr = (Elf32_Addr) addr;
382	+ segdata->p_vaddr = phdr->p_vaddr;
383	+ segdata->p_memsz = phdr->p_memsz;
384	+
385	+#if defined (__SUPPORT_LD_DEBUG__)
386	+ {
387	+ if (_dl_debug)
388	+ _dl_dprintf(_dl_debug_file, "%i: mapped %x at %x, size %x\n",
389	+ loadaddr.map->nsegs-1,
390	+ segdata->p_vaddr, segdata->addr, segdata->p_memsz);
391	+ }
392	+#endif
393	+}
394	+
395	+static __always_inline void __dl_loadaddr_unmap
396	+(struct elf32_fdpic_loadaddr loadaddr, struct funcdesc_ht *funcdesc_ht);
397	+
398	+/* Figure out whether the given address is in one of the mapped
399	+ segments. */
400	+static __always_inline int
401	+__dl_addr_in_loadaddr (void *p, struct elf32_fdpic_loadaddr loadaddr)
402	+{
403	+ struct elf32_fdpic_loadmap *map = loadaddr.map;
404	+ int c;
405	+
406	+ for (c = 0; c < map->nsegs; c++)
407	+ if ((void*)map->segs[c].addr <= p
408	+ && (char)p < (char)map->segs[c].addr + map->segs[c].p_memsz)
409	+ return 1;
410	+
411	+ return 0;
412	+}
413	+
414	+static __always_inline void * _dl_funcdesc_for (void entry_point, void got_value);
415	+
416	+/* The hashcode handling code below is heavily inspired in libiberty's
417	+ hashtab code, but with most adaptation points and support for
418	+ deleting elements removed.
419	+
420	+ Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
421	+ Contributed by Vladimir Makarov (vmakarov@cygnus.com). */
422	+
423	+static __always_inline unsigned long
424	+higher_prime_number (unsigned long n)
425	+{
426	+ /* These are primes that are near, but slightly smaller than, a
427	+ power of two. */
428	+ static const unsigned long primes[] = {
429	+ (unsigned long) 7,
430	+ (unsigned long) 13,
431	+ (unsigned long) 31,
432	+ (unsigned long) 61,
433	+ (unsigned long) 127,
434	+ (unsigned long) 251,
435	+ (unsigned long) 509,
436	+ (unsigned long) 1021,
437	+ (unsigned long) 2039,
438	+ (unsigned long) 4093,
439	+ (unsigned long) 8191,
440	+ (unsigned long) 16381,
441	+ (unsigned long) 32749,
442	+ (unsigned long) 65521,
443	+ (unsigned long) 131071,
444	+ (unsigned long) 262139,
445	+ (unsigned long) 524287,
446	+ (unsigned long) 1048573,
447	+ (unsigned long) 2097143,
448	+ (unsigned long) 4194301,
449	+ (unsigned long) 8388593,
450	+ (unsigned long) 16777213,
451	+ (unsigned long) 33554393,
452	+ (unsigned long) 67108859,
453	+ (unsigned long) 134217689,
454	+ (unsigned long) 268435399,
455	+ (unsigned long) 536870909,
456	+ (unsigned long) 1073741789,
457	+ (unsigned long) 2147483647,
458	+ /* 4294967291L */
459	+ ((unsigned long) 2147483647) + ((unsigned long) 2147483644),
460	+ };
461	+
462	+ const unsigned long *low = &primes[0];
463	+ const unsigned long *high = &primes[sizeof(primes) / sizeof(primes[0])];
464	+
465	+ while (low != high)
466	+ {
467	+ const unsigned long *mid = low + (high - low) / 2;
468	+ if (n > *mid)
469	+ low = mid + 1;
470	+ else
471	+ high = mid;
472	+ }
473	+
474	+#if 0
475	+ /* If we've run out of primes, abort. */
476	+ if (n > *low)
477	+ {
478	+ fprintf (stderr, "Cannot find prime bigger than %lu\n", n);
479	+ abort ();
480	+ }
481	+#endif
482	+
483	+ return *low;
484	+}
485	+
486	+struct funcdesc_ht
487	+{
488	+ /* Table itself. */
489	+ struct funcdesc_value **entries;
490	+
491	+ /* Current size (in entries) of the hash table */
492	+ size_t size;
493	+
494	+ /* Current number of elements. */
495	+ size_t n_elements;
496	+};
497	+
498	+static __always_inline int
499	+hash_pointer (const void *p)
500	+{
501	+ return (int) ((long)p >> 3);
502	+}
503	+
504	+static __always_inline struct funcdesc_ht *
505	+htab_create (void)
506	+{
507	+ struct funcdesc_ht *ht = _dl_malloc (sizeof (struct funcdesc_ht));
508	+
509	+ if (! ht)
510	+ return NULL;
511	+ ht->size = 3;
512	+ ht->entries = _dl_malloc (sizeof (struct funcdesc_ht_value ) ht->size);
513	+ if (! ht->entries)
514	+ return NULL;
515	+
516	+ ht->n_elements = 0;
517	+
518	+ _dl_memset (ht->entries, 0, sizeof (struct funcdesc_ht_value ) ht->size);
519	+
520	+ return ht;
521	+}
522	+
523	+/* This is only called from _dl_loadaddr_unmap, so it's safe to call
524	+ _dl_free(). See the discussion below. */
525	+static __always_inline void
526	+htab_delete (struct funcdesc_ht *htab)
527	+{
528	+ int i;
529	+
530	+ for (i = htab->size - 1; i >= 0; i--)
531	+ if (htab->entries[i])
532	+ _dl_free (htab->entries[i]);
533	+
534	+ _dl_free (htab->entries);
535	+ _dl_free (htab);
536	+}
537	+
538	+/* Similar to htab_find_slot, but without several unwanted side effects:
539	+ - Does not call htab->eq_f when it finds an existing entry.
540	+ - Does not change the count of elements/searches/collisions in the
541	+ hash table.
542	+ This function also assumes there are no deleted entries in the table.
543	+ HASH is the hash value for the element to be inserted. */
544	+
545	+static __always_inline struct funcdesc_value **
546	+find_empty_slot_for_expand (struct funcdesc_ht *htab, int hash)
547	+{
548	+ size_t size = htab->size;
549	+ unsigned int index = hash % size;
550	+ struct funcdesc_value **slot = htab->entries + index;
551	+ int hash2;
552	+
553	+ if (! *slot)
554	+ return slot;
555	+
556	+ hash2 = 1 + hash % (size - 2);
557	+ for (;;)
558	+ {
559	+ index += hash2;
560	+ if (index >= size)
561	+ index -= size;
562	+
563	+ slot = htab->entries + index;
564	+ if (! *slot)
565	+ return slot;
566	+ }
567	+}
568	+
569	+/* The following function changes size of memory allocated for the
570	+ entries and repeatedly inserts the table elements. The occupancy
571	+ of the table after the call will be about 50%. Naturally the hash
572	+ table must already exist. Remember also that the place of the
573	+ table entries is changed. If memory allocation failures are allowed,
574	+ this function will return zero, indicating that the table could not be
575	+ expanded. If all goes well, it will return a non-zero value. */
576	+
577	+static __always_inline int
578	+htab_expand (struct funcdesc_ht *htab)
579	+{
580	+ struct funcdesc_value **oentries;
581	+ struct funcdesc_value **olimit;
582	+ struct funcdesc_value **p;
583	+ struct funcdesc_value **nentries;
584	+ size_t nsize;
585	+
586	+ oentries = htab->entries;
587	+ olimit = oentries + htab->size;
588	+
589	+ /* Resize only when table after removal of unused elements is either
590	+ too full or too empty. */
591	+ if (htab->n_elements * 2 > htab->size)
592	+ nsize = higher_prime_number (htab->n_elements * 2);
593	+ else
594	+ nsize = htab->size;
595	+
596	+ nentries = _dl_malloc (sizeof (struct funcdesc_value ) nsize);
597	+ _dl_memset (nentries, 0, sizeof (struct funcdesc_value ) nsize);
598	+ if (nentries == NULL)
599	+ return 0;
600	+ htab->entries = nentries;
601	+ htab->size = nsize;
602	+
603	+ p = oentries;
604	+ do
605	+ {
606	+ if (*p)
607	+ find_empty_slot_for_expand (htab, hash_pointer ((p)->entry_point))
608	+ = *p;
609	+
610	+ p++;
611	+ }
612	+ while (p < olimit);
613	+
614	+#if 0 /* We can't tell whether this was allocated by the _dl_malloc()
615	+ built into ld.so or malloc() in the main executable or libc,
616	+ and calling free() for something that wasn't malloc()ed could
617	+ do Very Bad Things (TM). Take the conservative approach
618	+ here, potentially wasting as much memory as actually used by
619	+ the hash table, even if multiple growths occur. That's not
620	+ so bad as to require some overengineered solution that would
621	+ enable us to keep track of how it was allocated. */
622	+ _dl_free (oentries);
623	+#endif
624	+ return 1;
625	+}
626	+
627	+/* This function searches for a hash table slot containing an entry
628	+ equal to the given element. To delete an entry, call this with
629	+ INSERT = 0, then call htab_clear_slot on the slot returned (possibly
630	+ after doing some checks). To insert an entry, call this with
631	+ INSERT = 1, then write the value you want into the returned slot.
632	+ When inserting an entry, NULL may be returned if memory allocation
633	+ fails. */
634	+
635	+static __always_inline struct funcdesc_value **
636	+htab_find_slot (struct funcdesc_ht htab, void ptr, int insert)
637	+{
638	+ unsigned int index;
639	+ int hash, hash2;
640	+ size_t size;
641	+ struct funcdesc_value **entry;
642	+
643	+ if (htab->size * 3 <= htab->n_elements * 4
644	+ && htab_expand (htab) == 0)
645	+ return NULL;
646	+
647	+ hash = hash_pointer (ptr);
648	+
649	+ size = htab->size;
650	+ index = hash % size;
651	+
652	+ entry = &htab->entries[index];
653	+ if (!*entry)
654	+ goto empty_entry;
655	+ else if ((*entry)->entry_point == ptr)
656	+ return entry;
657	+
658	+ hash2 = 1 + hash % (size - 2);
659	+ for (;;)
660	+ {
661	+ index += hash2;
662	+ if (index >= size)
663	+ index -= size;
664	+
665	+ entry = &htab->entries[index];
666	+ if (!*entry)
667	+ goto empty_entry;
668	+ else if ((*entry)->entry_point == ptr)
669	+ return entry;
670	+ }
671	+
672	+ empty_entry:
673	+ if (!insert)
674	+ return NULL;
675	+
676	+ htab->n_elements++;
677	+ return entry;
678	+}
679	+
680	+void *
681	+_dl_funcdesc_for (void entry_point, void got_value)
682	+{
683	+ struct elf_resolve tpnt = ((void*)got_value)[2];
684	+ struct funcdesc_ht *ht = tpnt->funcdesc_ht;
685	+ struct funcdesc_value **entry;
686	+
687	+ _dl_assert (got_value == tpnt->loadaddr.got_value);
688	+
689	+ if (! ht)
690	+ {
691	+ ht = htab_create ();
692	+ if (! ht)
693	+ return (void*)-1;
694	+ tpnt->funcdesc_ht = ht;
695	+ }
696	+
697	+ entry = htab_find_slot (ht, entry_point, 1);
698	+ if (*entry)
699	+ {
700	+ _dl_assert ((*entry)->entry_point == entry_point);
701	+ return _dl_stabilize_funcdesc (*entry);
702	+ }
703	+
704	+ *entry = _dl_malloc (sizeof (struct funcdesc_value));
705	+ (*entry)->entry_point = entry_point;
706	+ (*entry)->got_value = got_value;
707	+
708	+ return _dl_stabilize_funcdesc (*entry);
709	+}
710	+
711	+static __always_inline void const *
712	+_dl_lookup_address (void const *address)
713	+{
714	+ struct elf_resolve *rpnt;
715	+ struct funcdesc_value const *fd;
716	+
717	+ /* Make sure we don't make assumptions about its alignment. */
718	+ __asm__ ("" : "+r" (address));
719	+
720	+ if ((Elf32_Addr)address & 7)
721	+ /* It's not a function descriptor. */
722	+ return address;
723	+
724	+ fd = (struct funcdesc_value const *)address;
725	+
726	+ for (rpnt = _dl_loaded_modules; rpnt; rpnt = rpnt->next)
727	+ {
728	+ if (! rpnt->funcdesc_ht)
729	+ continue;
730	+
731	+ if (fd->got_value != rpnt->loadaddr.got_value)
732	+ continue;
733	+
734	+ address = htab_find_slot (rpnt->funcdesc_ht, (void*)fd->entry_point, 0);
735	+
736	+ if (address && (struct funcdesc_value const*)address == fd)
737	+ {
738	+ address = ((struct funcdesc_value const*)address)->entry_point;
739	+ break;
740	+ }
741	+ else
742	+ address = fd;
743	+ }
744	+
745	+ return address;
746	+}
747	+
748	+void
749	+__dl_loadaddr_unmap (struct elf32_fdpic_loadaddr loadaddr,
750	+ struct funcdesc_ht *funcdesc_ht)
751	+{
752	+ int i;
753	+
754	+ for (i = 0; i < loadaddr.map->nsegs; i++)
755	+ {
756	+ struct elf32_fdpic_loadseg *segdata;
757	+ ssize_t offs;
758	+ segdata = loadaddr.map->segs + i;
759	+
760	+#if 0 /* SRAM */
761	+ /* FIXME:
762	+ A more cleaner way is to add type for struct elf32_fdpic_loadseg,
763	+ and release the memory according to the type.
764	+ Currently, we hardcode the memory address of L1 SRAM. */
765	+ if ((segdata->addr & 0xff800000) == 0xff800000)
766	+ {
767	+ _dl_sram_free ((void *)segdata->addr);
768	+ continue;
769	+ }
770	+#endif
771	+ offs = (segdata->p_vaddr & ADDR_ALIGN);
772	+ _dl_munmap ((void*)segdata->addr - offs,
773	+ segdata->p_memsz + offs);
774	+ }
775	+ /* _dl_unmap is only called for dlopen()ed libraries, for which
776	+ calling free() is safe, or before we've completed the initial
777	+ relocation, in which case calling free() is probably pointless,
778	+ but still safe. */
779	+ _dl_free (loadaddr.map);
780	+ if (funcdesc_ht)
781	+ htab_delete (funcdesc_ht);
782	+}
783	+
784	+#if 0 /* XXX TODO will look at enabling this if we decide to add support for OCM
785	+ * code/data */
786	+// OLD BLACKFIN CODE
787	+static __always_inline int
788	+__dl_is_special_segment (Elf32_Ehdr *epnt,
789	+ Elf32_Phdr *ppnt)
790	+{
791	+ if (ppnt->p_type != PT_LOAD)
792	+ return 0;
793	+
794	+ if ((epnt->e_flags & EF_BFIN_CODE_IN_L1)
795	+ && !(ppnt->p_flags & PF_W)
796	+ && (ppnt->p_flags & PF_X))
797	+ return 1;
798	+
799	+ if ((epnt->e_flags & EF_BFIN_DATA_IN_L1)
800	+ && (ppnt->p_flags & PF_W)
801	+ && !(ppnt->p_flags & PF_X))
802	+ return 1;
803	+
804	+ /* 0xff700000, 0xff800000, 0xff900000 and 0xffa00000 are also used in
805	+ GNU ld and linux kernel. They need to be keep synchronized. */
806	+ if (ppnt->p_vaddr == 0xff700000
807	+ \|\| ppnt->p_vaddr == 0xff800000
808	+ \|\| ppnt->p_vaddr == 0xff900000
809	+ \|\| ppnt->p_vaddr == 0xffa00000)
810	+ return 1;
811	+
812	+ return 0;
813	+}
814	+
815	+static __always_inline char *
816	+__dl_map_segment (Elf32_Ehdr *epnt,
817	+ Elf32_Phdr *ppnt,
818	+ int infile,
819	+ int flags)
820	+{
821	+ char status, tryaddr, *l1addr;
822	+ size_t size;
823	+
824	+
825	+ if (((epnt->e_flags & EF_BFIN_CODE_IN_L1) \|\| ppnt->p_vaddr == 0xffa00000)
826	+ && !(ppnt->p_flags & PF_W)
827	+ && (ppnt->p_flags & PF_X)) {
828	+ status = (char *) _dl_mmap
829	+ (tryaddr = 0,
830	+ size = (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_filesz,
831	+ LXFLAGS(ppnt->p_flags),
832	+ flags \| MAP_EXECUTABLE \| MAP_DENYWRITE,
833	+ infile, ppnt->p_offset & OFFS_ALIGN);
834	+ if (_dl_mmap_check_error(status)
835	+ \|\| (tryaddr && tryaddr != status))
836	+ return NULL;
837	+ l1addr = (char *) _dl_sram_alloc (ppnt->p_filesz, L1_INST_SRAM);
838	+ if (l1addr != NULL)
839	+ _dl_dma_memcpy (l1addr, status + (ppnt->p_vaddr & ADDR_ALIGN), ppnt->p_filesz);
840	+ _dl_munmap (status, size);
841	+ if (l1addr == NULL)
842	+ _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__);
843	+ return l1addr;
844	+ }
845	+
846	+ if (((epnt->e_flags & EF_BFIN_DATA_IN_L1)
847	+ \|\| ppnt->p_vaddr == 0xff700000
848	+ \|\| ppnt->p_vaddr == 0xff800000
849	+ \|\| ppnt->p_vaddr == 0xff900000)
850	+ && (ppnt->p_flags & PF_W)
851	+ && !(ppnt->p_flags & PF_X)) {
852	+ if (ppnt->p_vaddr == 0xff800000)
853	+ l1addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_A_SRAM);
854	+ else if (ppnt->p_vaddr == 0xff900000)
855	+ l1addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_B_SRAM);
856	+ else
857	+ l1addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_SRAM);
858	+ if (l1addr == NULL) {
859	+ _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__);
860	+ } else {
861	+ if (_DL_PREAD (infile, l1addr, ppnt->p_filesz, ppnt->p_offset) != ppnt->p_filesz) {
862	+ _dl_sram_free (l1addr);
863	+ return NULL;
864	+ }
865	+ if (ppnt->p_filesz < ppnt->p_memsz)
866	+ _dl_memset (l1addr + ppnt->p_filesz, 0, ppnt->p_memsz - ppnt->p_filesz);
867	+ }
868	+ return l1addr;
869	+ }
870	+ return 0;
871	+}
872	+#endif
873	--- /dev/null
874	+++ b/ldso/ldso/ubicom32/dl-startup.h
875	@@ -0,0 +1,232 @@
876	+/*
877	+ Copyright (C) 2009 Ubicom, Inc.
878	+ Copyright (C) 2003 Red Hat, Inc.
879	+ Contributed by Alexandre Oliva <aoliva@redhat.com>
880	+
881	+This file is part of uClibc.
882	+
883	+uClibc is free software; you can redistribute it and/or modify it
884	+under the terms of the GNU Lesser General Public License as
885	+published by the Free Software Foundation; either version 2.1 of the
886	+License, or (at your option) any later version.
887	+
888	+uClibc is distributed in the hope that it will be useful, but WITHOUT
889	+ANY WARRANTY; without even the implied warranty of
890	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
891	+Library General Public License for more details.
892	+
893	+You should have received a copy of the GNU Lesser General Public
894	+License along with uClibc; see the file COPYING.LIB. If not, write to
895	+the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
896	+USA. */
897	+
898	+/* Any assembly language/system dependent hacks needed to setup
899	+ * boot1.c so it will work as expected and cope with whatever platform
900	+ * specific wierdness is needed for this architecture.
901	+
902	+ * We override the default _dl_boot function, and replace it with a
903	+ * bit of asm. Then call the real _dl_boot function, which is now
904	+ * named _dl_boot2. */
905	+
906	+/* At program start-up, p0 contains a pointer to a
907	+ elf32_fdpic_loadmap that describes how the executable was loaded
908	+ into memory. p1 contains a pointer to the interpreter (our!)
909	+ loadmap, if there is an interpreter, or 0 if we're being run as an
910	+ executable. p2 holds a pointer to the interpreter's dynamic
911	+ section, if there is an interpreter, or to the executable's dynamic
912	+ section, otherwise. If the executable is not dynamic, gr18 is 0.
913	+
914	+ We rely on the fact that the linker adds a pointer to the
915	+ _GLOBAL_OFFSET_TABLE_ as the last ROFIXUP entry, and that
916	+ __self_reloc returns the relocated pointer to us, so that we can
917	+ use this value to initialize the PIC register. */
918	+
919	+
920	+/*
921	+ * _dl_boot is the entry point for ldso.
922	+ *
923	+ * The kernel leaves the main apps args on the stack (positive offsets), and
924	+ * communicates the load maps as follows
925	+ *
926	+ * - d1 is set to the exec_map_addr (struct elf32_fdpic_loadmap *), which is the
927	+ * current state of the mapped application.
928	+ *
929	+ * - d2 is set to interp_map_addr (struct elf32_fdpic_loadmap *), which is use
930	+ * by ldso to relocate itself.
931	+ *
932	+ * - d3 is dynamic_addr which as far as I can tell is the stack pointer.
933	+ *
934	+ * - a1 is set to zero and will later be initialised to ldso _dl_fini funcdesc
935	+ */
936	+
937	+__asm__(
938	+ " .text \n\t"
939	+ " .global _start \n\t"
940	+ " .type _start,@function \n\t"
941	+ "_start:\n\t"
942	+ /*
943	+ * Jump to .Lcall storing the location .Lcall in a5
944	+ */
945	+ " call a5, .Lcall \n\t"
946	+ ".Lcall: \n\t"
947	+ /*
948	+ * Reserve and Push inputs to stack.
949	+ * 32 byte stack layout as follows
950	+ * offset 0 exec_map_addr
951	+ * 4 interp_map_addr
952	+ * 8 dynamic_addr
953	+ * 12 not used
954	+ * 16 dl_main_funcdesc structure for _dl_boot
955	+ * (12 bytes sizeof funcdesc_value)
956	+ * 28 reserved
957	+ * 32 start of &original stack
958	+ */
959	+ " pdec sp, 32(sp); reserve stack space \n\t"
960	+ " move.4 0(sp), d1 ; exec_map_addr \n\t"
961	+ " move.4 4(sp), d2 ; interp_map_addr \n\t"
962	+ " move.4 8(sp), d3; dynamic_addr \n\t"
963	+
964	+ /*
965	+ * Load linker version of .Lcall in to d0
966	+ */
967	+ " moveai a3, #%hi(.Lcall) \n\t"
968	+ " lea.1 d0, %lo(.Lcall)(a3) \n\t"
969	+
970	+ /*
971	+ * Determine the offset from loaded .Lcall and put it in d0.
972	+ */
973	+ " sub.4 d0, a5, d0 \n\t"
974	+
975	+ /*
976	+ * Load linker version of __ROFIXUP_LIST__ and __ROFIXUP_END__ in to d1
977	+ * and d2.
978	+ */
979	+ " moveai a3, #%hi(__ROFIXUP_LIST__) \n\t"
980	+ " lea.1 d1, %lo(__ROFIXUP_LIST__)(a3) \n\t"
981	+ " moveai a3, #%hi(__ROFIXUP_END__) \n\t"
982	+ " lea.1 d2, %lo(__ROFIXUP_END__)(a3) \n\t"
983	+ /*
984	+ * Use offset determined above to find the loaded versions.
985	+ */
986	+ " add.4 d1, d1, d0 \n\t"
987	+ " add.4 d2, d2, d0 \n\t"
988	+
989	+ /*
990	+ * Load interp_map_addr into d0, if interp_map_addr is null use
991	+ * exec_map_addr.
992	+ */
993	+ " move.4 d0, 4(sp) ; load interp_map_addr \n\t"
994	+ " cmpi d0, #0 \n\t"
995	+ " jmpne.f 1f \n\t"
996	+ " move.4 d0, 0(sp) ; load exec_map_addr \n\t"
997	+
998	+ /*
999	+ * call __self_reloc(map, void *p, void *e)
1000	+ * it returns the the GOT in d0.
1001	+ */
1002	+ "1: call a5, __self_reloc ; returns a0 in d0 \n\t"
1003	+ " move.4 a0, d0 ; set GOT \n\t"
1004	+ " move.4 a2, d0 ; save GOT \n\t"
1005	+
1006	+ /*
1007	+ * now setup to call
1008	+ * _dl_start (Elf32_Addr dl_boot_got_pointer, (d0)
1009	+ * struct elf32_fdpic_loadmap *dl_boot_progmap, (d1)
1010	+ * struct elf32_fdpic_loadmap *dl_boot_ldsomap, (d2)
1011	+ * Elf32_Dyn *dl_boot_ldso_dyn_pointer, (d3)
1012	+ * struct funcdesc_value *dl_main_funcdesc, (d4)
1013	+ * unsigned long args (d5)
1014	+ *
1015	+ * NOTE: for dl_main_funcdesc we reserved space on the stack for this
1016	+ * structure.
1017	+ */
1018	+ " move.4 d1, 0(sp) ; d1 = exec_map_addr \n\t"
1019	+ " move.4 d2, 4(sp) ; d2 = interp_map_addr \n\t"
1020	+ " move.4 d3, 8(sp) ; d3 = dynamic_addr \n\t"
1021	+ " lea.1 d4, 16(sp) ; d4 = &dl_main_funcdesc \n\t"
1022	+ " lea.1 d5, 32(sp) ; d5 = original stack ptr (args)\n\t"
1023	+ " call a5, _dl_start \n\t"
1024	+
1025	+ /*
1026	+ * Setup to call the main entry point, starting with passing our FINI
1027	+ * ptr() to the user in a1 (remember we saved the got in a2)
1028	+ */
1029	+ " movei d15, #%got_funcdesc_lo(_dl_fini) \n\t"
1030	+ " move.4 a1, (a2, d15) \n\t"
1031	+
1032	+ /*
1033	+ * restore the load map from the kernel.
1034	+ */
1035	+ " move.4 d1, 0(sp) ; restore exec_map_addr \n\t"
1036	+ " move.4 d2, 4(sp) ; restore interp_map_addr \n\t"
1037	+ " move.4 d3, 8(sp) ; restore dynamic_addr \n\t"
1038	+
1039	+ /*
1040	+ * _dl_start returned the main apps entry point in dl_main_funcdesc,
1041	+ * load that information now.
1042	+ */
1043	+ " move.4 a5, 16(sp) ; a5 = dl_main_funcdesc.entry_point \n\t"
1044	+ " move.4 a0, 20(sp) ; a0 = dl_main_funcdesc.got_value \n\t"
1045	+ " lea.1 sp, 32(sp); restore original stack ptr (args) \n\t"
1046	+ " calli a5, 0(a5) \n\t"
1047	+ " bkpt -1; should never get here \n\t"
1048	+ " .size _start, . - _start \n\t"
1049	+);
1050	+
1051	+#undef DL_START
1052	+#define DL_START(X) \
1053	+static void __attribute__ ((used)) \
1054	+_dl_start (Elf32_Addr dl_boot_got_pointer, \
1055	+ struct elf32_fdpic_loadmap *dl_boot_progmap, \
1056	+ struct elf32_fdpic_loadmap *dl_boot_ldsomap, \
1057	+ Elf32_Dyn *dl_boot_ldso_dyn_pointer, \
1058	+ struct funcdesc_value *dl_main_funcdesc, \
1059	+ X)
1060	+
1061	+struct elf32_fdpic_loadmap;
1062	+
1063	+/*
1064	+ * Get a pointer to the argv array. On many platforms this can be just
1065	+ * the address if the first argument, on other platforms we need to
1066	+ * do something a little more subtle here.
1067	+ */
1068	+#define GET_ARGV(ARGVP, ARGS) ARGVP = (((unsigned long*) ARGS) + 1)
1069	+
1070	+/*
1071	+ * Here is a macro to perform a relocation. This is only used when
1072	+ * bootstrapping the dynamic loader. RELP is the relocation that we
1073	+ * are performing, REL is the pointer to the address we are relocating.
1074	+ * SYMBOL is the symbol involved in the relocation, and LOAD is the
1075	+ * load address.
1076	+ */
1077	+#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD,SYMTAB) \
1078	+ switch(ELF32_R_TYPE((RELP)->r_info)){ \
1079	+ case R_UBICOM32_32: \
1080	+ *(REL) += (SYMBOL); \
1081	+ break; \
1082	+ case R_UBICOM32_FUNCDESC_VALUE: \
1083	+ { \
1084	+ struct funcdesc_value fv = { \
1085	+ (void)((SYMBOL) + (REL)), \
1086	+ (LOAD).got_value \
1087	+ }; \
1088	+ (struct funcdesc_value volatile )(REL) = fv; \
1089	+ break; \
1090	+ } \
1091	+ default: \
1092	+ _dl_exit(1); \
1093	+ }
1094	+
1095	+/*
1096	+ * Transfer control to the user's application, once the dynamic loader
1097	+ * is done. We return the address of the function's entry point to
1098	+ * _dl_boot, see boot1_arch.h.
1099	+ */
1100	+#define START() do { \
1101	+ struct elf_resolve *exec_mod = _dl_loaded_modules; \
1102	+ dl_main_funcdesc->entry_point = _dl_elf_main; \
1103	+ while (exec_mod->libtype != elf_executable) \
1104	+ exec_mod = exec_mod->next; \
1105	+ dl_main_funcdesc->got_value = exec_mod->loadaddr.got_value; \
1106	+ return; \
1107	+} while (0)
1108	--- /dev/null
1109	+++ b/ldso/ldso/ubicom32/dl-syscalls.h
1110	@@ -0,0 +1,206 @@
1111	+/* Copyright (C) 2003, 2004 Red Hat, Inc.
1112	+ Contributed by Alexandre Oliva <aoliva@redhat.com>
1113	+
1114	+This file is part of uClibc.
1115	+
1116	+uClibc is free software; you can redistribute it and/or modify it
1117	+under the terms of the GNU Lesser General Public License as
1118	+published by the Free Software Foundation; either version 2.1 of the
1119	+License, or (at your option) any later version.
1120	+
1121	+uClibc is distributed in the hope that it will be useful, but WITHOUT
1122	+ANY WARRANTY; without even the implied warranty of
1123	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1124	+Library General Public License for more details.
1125	+
1126	+You should have received a copy of the GNU Lesser General Public
1127	+License along with uClibc; see the file COPYING.LIB. If not, write to
1128	+the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
1129	+USA. */
1130	+
1131	+/* We can't use the real errno in ldso, since it has not yet
1132	+ * been dynamicly linked in yet. */
1133	+#include "sys/syscall.h"
1134	+extern int _dl_errno;
1135	+#undef __set_errno
1136	+#define __set_errno(X) {(_dl_errno) = (X);}
1137	+#include <sys/mman.h>
1138	+
1139	+/* The code below is extracted from libc/sysdeps/linux/frv/_mmap.c */
1140	+
1141	+#if defined(DYNAMIC_LOADER_IN_SIMULATOR) && DYNAMIC_LOADER_IN_SIMULATOR
1142	+#define __NR___syscall_mmap2 __NR_mmap2
1143	+static __inline__ _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
1144	+ size_t, len, int, prot, int, flags, int, fd, off_t, offset);
1145	+
1146	+/* Make sure we don't get another definition of _dl_mmap from the
1147	+ machine-independent code. */
1148	+#undef __NR_mmap
1149	+#undef __NR_mmap2
1150	+
1151	+/* This is always 12, even on architectures where PAGE_SHIFT != 12. */
1152	+# ifndef MMAP2_PAGE_SHIFT
1153	+# define MMAP2_PAGE_SHIFT 12
1154	+# endif
1155	+
1156	+#include <bits/uClibc_page.h> /* for PAGE_SIZE */
1157	+static __always_inline void _dl_memset(void,int,size_t);
1158	+static __always_inline ssize_t _dl_pread(int fd, void *buf, size_t count, off_t offset);
1159	+
1160	+static __ptr_t
1161	+_dl_mmap(__ptr_t addr, size_t len, int prot, int flags, int fd, __off_t offset)
1162	+{
1163	+ size_t plen = (len + PAGE_SIZE - 1) & -PAGE_SIZE;
1164	+
1165	+/* This is a hack to enable the dynamic loader to run within a
1166	+ simulator that doesn't support mmap, with a number of very ugly
1167	+ tricks. Also, it's not as useful as it sounds, since only dynamic
1168	+ executables without DT_NEEDED dependencies can be run. AFAIK, they
1169	+ can only be created with -pie. This trick suffices to enable the
1170	+ dynamic loader to obtain a blank page that it maps early in the
1171	+ bootstrap. */
1172	+ if ((flags & MAP_FIXED) == 0)
1173	+ {
1174	+ void *_dl_mmap_base = 0;
1175	+ __ptr_t *ret = 0;
1176	+
1177	+ if (! _dl_mmap_base)
1178	+ {
1179	+ void *stack;
1180	+ __asm__ ("mov sp, %0" : "=r" (stack));
1181	+ _dl_mmap_base = (void )(((long)stack + 2 PAGE_SIZE) & -PAGE_SIZE);
1182	+ retry:
1183	+ if (((void **)_dl_mmap_base)[0] == _dl_mmap_base
1184	+ && ((void **)_dl_mmap_base)[1023] == _dl_mmap_base
1185	+ && (((void **)_dl_mmap_base)[177]
1186	+ == ((void **)_dl_mmap_base)[771]))
1187	+ {
1188	+ while (((void**)_dl_mmap_base)[177])
1189	+ {
1190	+ _dl_mmap_base = ((void**)_dl_mmap_base)[177];
1191	+ if (!(((void **)_dl_mmap_base)[0] == _dl_mmap_base
1192	+ && ((void **)_dl_mmap_base)[1023] == _dl_mmap_base
1193	+ && (((void **)_dl_mmap_base)[177]
1194	+ == ((void**)_dl_mmap_base)[771])))
1195	+ ((void(*)())0)();
1196	+ }
1197	+ }
1198	+ else
1199	+ {
1200	+ int i;
1201	+ for (i = 0; i < (int)PAGE_SIZE; i++)
1202	+ if ((char)(_dl_mmap_base + i))
1203	+ break;
1204	+ if (i != PAGE_SIZE)
1205	+ {
1206	+ _dl_mmap_base = (void*)((long)_dl_mmap_base + PAGE_SIZE);
1207	+ goto retry;
1208	+ }
1209	+ ((void**)_dl_mmap_base)[-1] =
1210	+ ((void**)_dl_mmap_base)[0] =
1211	+ ((void**)_dl_mmap_base)[1023] =
1212	+ _dl_mmap_base;
1213	+ }
1214	+ }
1215	+
1216	+ if (_dl_mmap_base)
1217	+ {
1218	+ if (!(((void **)_dl_mmap_base)[0] == _dl_mmap_base
1219	+ && ((void **)_dl_mmap_base)[1023] == _dl_mmap_base
1220	+ && (((void **)_dl_mmap_base)[177]
1221	+ == ((void**)_dl_mmap_base)[771])))
1222	+ ((void(*)())0)();
1223	+ ret = (__ptr_t)((char*)_dl_mmap_base + PAGE_SIZE);
1224	+ _dl_mmap_base =
1225	+ ((void**)_dl_mmap_base)[177] =
1226	+ ((void**)_dl_mmap_base)[771] =
1227	+ (char*)_dl_mmap_base + plen + PAGE_SIZE;
1228	+ ((void**)_dl_mmap_base)[0] =
1229	+ ((void**)_dl_mmap_base)[1023] =
1230	+ _dl_mmap_base;
1231	+ }
1232	+
1233	+ if ((flags & MAP_ANONYMOUS) != 0)
1234	+ {
1235	+ _dl_memset (ret, 0, plen);
1236	+ return ret;
1237	+ }
1238	+
1239	+ flags \|= MAP_FIXED;
1240	+ addr = ret;
1241	+ }
1242	+ if (offset & ((1 << MMAP2_PAGE_SHIFT) - 1)) {
1243	+#if 0
1244	+ __set_errno (EINVAL);
1245	+#endif
1246	+ return MAP_FAILED;
1247	+ }
1248	+ if ((flags & MAP_FIXED) != 0)
1249	+ {
1250	+ if (_dl_pread(fd, addr, len, offset) != (ssize_t)len)
1251	+ return (void*)MAP_FAILED;
1252	+ if (plen != len)
1253	+ _dl_memset (addr + len, 0, plen - len);
1254	+ return addr;
1255	+ }
1256	+ return(__syscall_mmap2(addr, len, prot, flags, fd, (off_t) (offset >> MMAP2_PAGE_SHIFT)));
1257	+}
1258	+#endif
1259	+
1260	+#ifdef __NR_pread64
1261	+#ifdef DYNAMIC_LOADER_IN_SIMULATOR
1262	+#include <unistd.h>
1263	+
1264	+#define __NR___syscall_lseek __NR_lseek
1265	+static __always_inline unsigned long _dl_read(int fd, const void *buf, unsigned long count);
1266	+
1267	+static __always_inline _syscall3(__off_t, __syscall_lseek, int, fd, __off_t, offset,
1268	+ int, whence);
1269	+static __always_inline ssize_t
1270	+_dl_pread(int fd, void *buf, size_t count, off_t offset)
1271	+{
1272	+ __off_t orig = __syscall_lseek (fd, 0, SEEK_CUR);
1273	+ ssize_t ret;
1274	+
1275	+ if (orig == -1)
1276	+ return -1;
1277	+
1278	+ if (__syscall_lseek (fd, offset, SEEK_SET) != offset)
1279	+ return -1;
1280	+
1281	+ ret = _dl_read (fd, buf, count);
1282	+
1283	+ if (__syscall_lseek (fd, orig, SEEK_SET) != orig)
1284	+ ((void(*)())0)();
1285	+
1286	+ return ret;
1287	+}
1288	+#else
1289	+#define __NR___syscall_pread __NR_pread64
1290	+static __always_inline _syscall5(ssize_t, __syscall_pread, int, fd, void *, buf,
1291	+ size_t, count, off_t, offset_hi, off_t, offset_lo);
1292	+
1293	+static __always_inline ssize_t
1294	+_dl_pread(int fd, void *buf, size_t count, off_t offset)
1295	+{
1296	+ return(__syscall_pread(fd,buf,count,__LONG_LONG_PAIR (offset >> 31, offset)));
1297	+}
1298	+#endif
1299	+#endif
1300	+
1301	+#ifdef __NR_sram_alloc
1302	+#define __NR__dl_sram_alloc __NR_sram_alloc
1303	+static __always_inline _syscall2(__ptr_t, _dl_sram_alloc,
1304	+ size_t, len, unsigned long, flags);
1305	+#endif
1306	+
1307	+#ifdef __NR_sram_free
1308	+#define __NR__dl_sram_free __NR_sram_free
1309	+static __always_inline _syscall1(int, _dl_sram_free, __ptr_t, addr);
1310	+#endif
1311	+
1312	+#ifdef __NR_dma_memcpy
1313	+#define __NR__dl_dma_memcpy __NR_dma_memcpy
1314	+static __always_inline _syscall3(__ptr_t, _dl_dma_memcpy,
1315	+ __ptr_t, dest, __ptr_t, src, size_t, len);
1316	+#endif
1317	--- /dev/null
1318	+++ b/ldso/ldso/ubicom32/dl-sysdep.h
1319	@@ -0,0 +1,243 @@
1320	+ /* Copyright (C) 2003, 2004 Red Hat, Inc.
1321	+ Contributed by Alexandre Oliva <aoliva@redhat.com>
1322	+ Based on ../i386/dl-sysdep.h
1323	+
1324	+This file is part of uClibc.
1325	+
1326	+uClibc is free software; you can redistribute it and/or modify it
1327	+under the terms of the GNU Lesser General Public License as
1328	+published by the Free Software Foundation; either version 2.1 of the
1329	+License, or (at your option) any later version.
1330	+
1331	+uClibc is distributed in the hope that it will be useful, but WITHOUT
1332	+ANY WARRANTY; without even the implied warranty of
1333	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1334	+Library General Public License for more details.
1335	+
1336	+You should have received a copy of the GNU Lesser General Public
1337	+License along with uClibc; see the file COPYING.LIB. If not, write to
1338	+the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
1339	+USA. */
1340	+
1341	+/*
1342	+ * Various assembly language/system dependent hacks that are required
1343	+ * so that we can minimize the amount of platform specific code.
1344	+ */
1345	+
1346	+/*
1347	+ * Define this if the system uses RELOCA.
1348	+ */
1349	+#undef ELF_USES_RELOCA
1350	+
1351	+/* JMPREL relocs are inside the DT_RELA table. */
1352	+#define ELF_MACHINE_PLTREL_OVERLAP
1353	+
1354	+#define DL_NO_COPY_RELOCS
1355	+
1356	+#define HAVE_DL_INLINES_H
1357	+
1358	+/*
1359	+ * Initialization sequence for a GOT. Copy the resolver function
1360	+ * descriptor and the pointer to the elf_resolve/link_map data
1361	+ * structure. Initialize the got_value in the module while at that.
1362	+ */
1363	+#define INIT_GOT(GOT_BASE,MODULE) \
1364	+{ \
1365	+ (MODULE)->loadaddr.got_value = (GOT_BASE); \
1366	+ GOT_BASE[0] = ((unsigned long *)&_dl_linux_resolve)[0]; \
1367	+ GOT_BASE[1] = ((unsigned long *)&_dl_linux_resolve)[1]; \
1368	+ GOT_BASE[2] = (unsigned long) MODULE; \
1369	+}
1370	+
1371	+/* Here we define the magic numbers that this dynamic loader should accept */
1372	+#define MAGIC1 EM_UBICOM32
1373	+#undef MAGIC2
1374	+
1375	+/* Used for error messages */
1376	+#define ELF_TARGET "UBICOM32"
1377	+
1378	+struct elf_resolve;
1379	+
1380	+struct funcdesc_value
1381	+{
1382	+ void *entry_point;
1383	+ void *got_value;
1384	+/int relocation; not sure if this required, but it does exist /
1385	+};
1386	+
1387	+extern int _dl_linux_resolve(void) __attribute__((__visibility__("hidden")));
1388	+extern struct funcdesc_value volatile *__attribute__((__visibility__("hidden")))
1389	+ _dl_linux_resolver (struct elf_resolve *tpnt, int reloc_entry);
1390	+
1391	+/* 4KiB page alignment. Should perhaps be made dynamic using
1392	+ getpagesize(), based on AT_PAGESZ from auxvt? */
1393	+#define PAGE_ALIGN 0xfffff000
1394	+#define ADDR_ALIGN 0xfff
1395	+#define OFFS_ALIGN 0x7ffff000
1396	+
1397	+struct funcdesc_ht;
1398	+
1399	+/*
1400	+ * This asm does a quick relcation of string S (which is stored in the text
1401	+ * section as thats all we can use
1402	+ */
1403	+#undef SEND_EARLY_STDERR
1404	+#define SEND_EARLY_STDERR(S) \
1405	+do { \
1406	+ static const char __attribute__((section(".text"))) __s[] = (S); \
1407	+ const char __p, __scratch; \
1408	+ __asm__ ( \
1409	+ " call a3, 1f; \n\t" \
1410	+ "1: movei %0, #%%got_lo(1b) \n\t" \
1411	+ " move.4 %0, (%3, %0) \n\t" \
1412	+ " sub.4 %1, a3, %0; \n\t" \
1413	+ " add.4 %1, %1, %2; \n\t" \
1414	+ : "=&d" (__scratch), "=&d" (__p) \
1415	+ : "d" (__s), "a" (dl_boot_got_pointer) \
1416	+ : "a3", "a4", "d15"); \
1417	+ SEND_STDERR (__p); \
1418	+ { int __t; \
1419	+ for (__t = 0; __t < 0x100000; __t++) __asm__ __volatile__ (""); } \
1420	+} while (0)
1421	+
1422	+#define DL_LOADADDR_TYPE struct elf32_fdpic_loadaddr
1423	+
1424	+#define DL_RELOC_ADDR(LOADADDR, ADDR) \
1425	+ ((ElfW(Addr))__reloc_pointer ((void*)(ADDR), (LOADADDR).map))
1426	+
1427	+#define DL_ADDR_TO_FUNC_PTR(ADDR, LOADADDR) \
1428	+ ((void()(void)) _dl_funcdesc_for ((void)(ADDR), (LOADADDR).got_value))
1429	+
1430	+#define _dl_stabilize_funcdesc(val) \
1431	+ ({ __asm__ ("" : "+m" (*(val))); (val); })
1432	+
1433	+#define DL_CALL_FUNC_AT_ADDR(ADDR, LOADADDR, SIGNATURE, ...) \
1434	+ ({ struct funcdesc_value fd = { (void*)(ADDR), (LOADADDR).got_value }; \
1435	+ void (pf)(void) = (void) _dl_stabilize_funcdesc (&fd); \
1436	+ (* SIGNATURE pf)(__VA_ARGS__); })
1437	+
1438	+#define DL_INIT_LOADADDR_BOOT(LOADADDR, BASEADDR) \
1439	+ (__dl_init_loadaddr_map (&(LOADADDR), dl_boot_got_pointer, \
1440	+ dl_boot_ldsomap ?: dl_boot_progmap))
1441	+
1442	+#define DL_INIT_LOADADDR_PROG(LOADADDR, BASEADDR) \
1443	+ (__dl_init_loadaddr_map (&(LOADADDR), 0, dl_boot_progmap))
1444	+
1445	+#define DL_INIT_LOADADDR_EXTRA_DECLS \
1446	+ int dl_init_loadaddr_load_count;
1447	+#define DL_INIT_LOADADDR(LOADADDR, BASEADDR, PHDR, PHDRCNT) \
1448	+ (dl_init_loadaddr_load_count = \
1449	+ __dl_init_loadaddr (&(LOADADDR), (PHDR), (PHDRCNT)))
1450	+#define DL_INIT_LOADADDR_HDR(LOADADDR, ADDR, PHDR) \
1451	+ (__dl_init_loadaddr_hdr ((LOADADDR), (ADDR), (PHDR), \
1452	+ dl_init_loadaddr_load_count))
1453	+#define DL_LOADADDR_UNMAP(LOADADDR, LEN) \
1454	+ (__dl_loadaddr_unmap ((LOADADDR), (NULL)))
1455	+#define DL_LIB_UNMAP(LIB, LEN) \
1456	+ (__dl_loadaddr_unmap ((LIB)->loadaddr, (LIB)->funcdesc_ht))
1457	+#define DL_LOADADDR_BASE(LOADADDR) \
1458	+ ((LOADADDR).got_value)
1459	+
1460	+/* This is called from dladdr(), such that we map a function
1461	+ descriptor's address to the function's entry point before trying to
1462	+ find in which library it's defined. */
1463	+#define DL_LOOKUP_ADDRESS(ADDRESS) (_dl_lookup_address (ADDRESS))
1464	+
1465	+#define DL_ADDR_IN_LOADADDR(ADDR, TPNT, TFROM) \
1466	+ (! (TFROM) && __dl_addr_in_loadaddr ((void*)(ADDR), (TPNT)->loadaddr))
1467	+
1468	+/*
1469	+ * Compute the GOT address. On several platforms, we use assembly
1470	+ * here. on FR-V FDPIC, there's no way to compute the GOT address,
1471	+ * since the offset between text and data is not fixed, so we arrange
1472	+ * for the assembly _dl_boot to pass this value as an argument to
1473	+ * _dl_boot. */
1474	+#define DL_BOOT_COMPUTE_GOT(got) ((got) = dl_boot_got_pointer)
1475	+
1476	+#define DL_BOOT_COMPUTE_DYN(dpnt, got, load_addr) \
1477	+ ((dpnt) = dl_boot_ldso_dyn_pointer)
1478	+
1479	+/* We only support loading FDPIC independently-relocatable shared
1480	+ libraries. It probably wouldn't be too hard to support loading
1481	+ shared libraries that require relocation by the same amount, but we
1482	+ don't know that they exist or would be useful, and the dynamic
1483	+ loader code could leak the whole-library map unless we keeping a
1484	+ bit more state for DL_LOADADDR_UNMAP and DL_LIB_UNMAP, so let's
1485	+ keep things simple for now. */
1486	+#define DL_CHECK_LIB_TYPE(epnt, piclib, _dl_progname, libname) \
1487	+do \
1488	+{ \
1489	+ if (((epnt)->e_flags & EF_UBICOM32_FDPIC) && ! ((epnt)->e_flags & EF_UBICOM32_PIC)) \
1490	+ (piclib) = 2; \
1491	+ else \
1492	+ { \
1493	+ _dl_internal_error_number = LD_ERROR_NOTDYN; \
1494	+ _dl_dprintf(2, "%s: '%s' is not an FDPIC shared library" \
1495	+ "\n", (_dl_progname), (libname)); \
1496	+ _dl_close(infile); \
1497	+ return NULL; \
1498	+ } \
1499	+\
1500	+} \
1501	+while (0)
1502	+
1503	+/* We want want to apply all relocations in the interpreter during
1504	+ bootstrap. Because of this, we have to skip the interpreter
1505	+ relocations in _dl_parse_relocation_information(), see
1506	+ elfinterp.c. */
1507	+#define DL_SKIP_BOOTSTRAP_RELOC(SYMTAB, INDEX, STRTAB) 0
1508	+
1509	+#ifdef __NR_pread64
1510	+#define _DL_PREAD(FD, BUF, SIZE, OFFSET) \
1511	+ (_dl_pread((FD), (BUF), (SIZE), (OFFSET)))
1512	+#endif
1513	+
1514	+/* We want to return to dlsym() a function descriptor if the symbol
1515	+ turns out to be a function. */
1516	+#define DL_FIND_HASH_VALUE(TPNT, TYPE_CLASS, SYM) \
1517	+ (((TYPE_CLASS) & ELF_RTYPE_CLASS_DLSYM) \
1518	+ && ELF32_ST_TYPE((SYM)->st_info) == STT_FUNC \
1519	+ ? _dl_funcdesc_for ((void *)DL_RELOC_ADDR ((TPNT)->loadaddr, (SYM)->st_value), \
1520	+ (TPNT)->loadaddr.got_value) \
1521	+ : DL_RELOC_ADDR ((TPNT)->loadaddr, (SYM)->st_value))
1522	+
1523	+#if 0 /* XXX TODO will look at enabling this if we decide to add support for OCM
1524	+ * code/data */
1525	+
1526	+#define DL_IS_SPECIAL_SEGMENT(EPNT, PPNT) \
1527	+ __dl_is_special_segment(EPNT, PPNT)
1528	+#define DL_MAP_SEGMENT(EPNT, PPNT, INFILE, FLAGS) \
1529	+ __dl_map_segment (EPNT, PPNT, INFILE, FLAGS)
1530	+
1531	+#endif
1532	+
1533	+
1534	+#define DL_GET_READY_TO_RUN_EXTRA_PARMS \
1535	+ , struct elf32_fdpic_loadmap *dl_boot_progmap, Elf32_Addr dl_boot_got_pointer
1536	+#define DL_GET_READY_TO_RUN_EXTRA_ARGS \
1537	+ , dl_boot_progmap, dl_boot_got_pointer
1538	+
1539	+
1540	+#ifdef __USE_GNU
1541	+# include <link.h>
1542	+#else
1543	+# define __USE_GNU
1544	+# include <link.h>
1545	+# undef __USE_GNU
1546	+#endif
1547	+
1548	+#include <elf.h>
1549	+static __inline__ void
1550	+elf_machine_relative (DL_LOADADDR_TYPE load_off, const Elf32_Addr rel_addr,
1551	+ Elf32_Word relative_count)
1552	+{
1553	+#if 0
1554	+ Elf32_Rel * rpnt = (void *) rel_addr;
1555	+ --rpnt;
1556	+ do {
1557	+ Elf32_Addr const reloc_addr = (void ) (load_off + (++rpnt)->r_offset);
1558	+
1559	+ reloc_addr = DL_RELOC_ADDR (load_off, reloc_addr);
1560	+ } while (--relative_count);
1561	+#endif
1562	+}
1563	--- /dev/null
1564	+++ b/ldso/ldso/ubicom32/elfinterp.c
1565	@@ -0,0 +1,366 @@
1566	+/* Blackfin ELF shared library loader suppport
1567	+ Copyright (C) 2003, 2004 Red Hat, Inc.
1568	+ Contributed by Alexandre Oliva <aoliva@redhat.com>
1569	+ Lots of code copied from ../i386/elfinterp.c, so:
1570	+ Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald,
1571	+ David Engel, Hongjiu Lu and Mitch D'Souza
1572	+ Copyright (C) 2001-2002, Erik Andersen
1573	+ All rights reserved.
1574	+
1575	+This file is part of uClibc.
1576	+
1577	+uClibc is free software; you can redistribute it and/or modify it
1578	+under the terms of the GNU Lesser General Public License as
1579	+published by the Free Software Foundation; either version 2.1 of the
1580	+License, or (at your option) any later version.
1581	+
1582	+uClibc is distributed in the hope that it will be useful, but WITHOUT
1583	+ANY WARRANTY; without even the implied warranty of
1584	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1585	+Library General Public License for more details.
1586	+
1587	+You should have received a copy of the GNU Lesser General Public
1588	+License along with uClibc; see the file COPYING.LIB. If not, write to
1589	+the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
1590	+USA. */
1591	+
1592	+#include <sys/cdefs.h> /* __attribute_used__ */
1593	+
1594	+/* Program to load an ELF binary on a linux system, and run it.
1595	+ References to symbols in sharable libraries can be resolved by either
1596	+ an ELF sharable library or a linux style of shared library. */
1597	+
1598	+/* Disclaimer: I have never seen any AT&T source code for SVr4, nor have
1599	+ I ever taken any courses on internals. This program was developed using
1600	+ information available through the book "UNIX SYSTEM V RELEASE 4,
1601	+ Programmers guide: Ansi C and Programming Support Tools", which did
1602	+ a more than adequate job of explaining everything required to get this
1603	+ working. */
1604	+extern int _dl_ubicom32_resolve_pending(void) __attribute__((__visibility__("hidden")));
1605	+
1606	+struct funcdesc_value volatile *__attribute__((__visibility__("hidden")))
1607	+_dl_linux_resolver (struct elf_resolve *tpnt, int reloc_entry)
1608	+{
1609	+ int reloc_type;
1610	+ ELF_RELOC *this_reloc;
1611	+ char *strtab;
1612	+ ElfW(Sym) *symtab;
1613	+ int symtab_index;
1614	+ char *rel_addr;
1615	+ struct elf_resolve *new_tpnt;
1616	+ char *new_addr;
1617	+ struct funcdesc_value funcval;
1618	+ struct funcdesc_value volatile *got_entry;
1619	+ char *symname;
1620	+
1621	+ rel_addr = (char *)tpnt->dynamic_info[DT_JMPREL];
1622	+
1623	+ this_reloc = (ELF_RELOC *)(intptr_t)(rel_addr + reloc_entry);
1624	+ reloc_type = ELF_R_TYPE(this_reloc->r_info);
1625	+ symtab_index = ELF_R_SYM(this_reloc->r_info);
1626	+
1627	+ symtab = (Elf32_Sym *) tpnt->dynamic_info[DT_SYMTAB];
1628	+ strtab = (char *) tpnt->dynamic_info[DT_STRTAB];
1629	+ symname= strtab + symtab[symtab_index].st_name;
1630	+
1631	+ if (reloc_type != R_UBICOM32_FUNCDESC_VALUE) {
1632	+ _dl_dprintf(2, "%s: Incorrect relocation type in jump relocations\n",
1633	+ _dl_progname);
1634	+ _dl_exit(1);
1635	+ }
1636	+
1637	+ /* Address of GOT entry fix up */
1638	+ got_entry = (struct funcdesc_value *) DL_RELOC_ADDR(tpnt->loadaddr, this_reloc->r_offset);
1639	+
1640	+ /* Get the address to be used to fill in the GOT entry. */
1641	+ new_addr = _dl_lookup_hash(symname, tpnt->symbol_scope, NULL, 0, &new_tpnt);
1642	+ if (!new_addr) {
1643	+ new_addr = _dl_lookup_hash(symname, NULL, NULL, 0, &new_tpnt);
1644	+ if (!new_addr) {
1645	+ _dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
1646	+ _dl_progname, symname);
1647	+ _dl_exit(1);
1648	+ }
1649	+ }
1650	+
1651	+ funcval.entry_point = new_addr;
1652	+ funcval.got_value = new_tpnt->loadaddr.got_value;
1653	+
1654	+#if defined (__SUPPORT_LD_DEBUG__)
1655	+ if (_dl_debug_bindings) {
1656	+ _dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
1657	+ if (_dl_debug_detail)
1658	+ _dl_dprintf(_dl_debug_file,
1659	+ "\n\tpatched (%x,%x) ==> (%x,%x) @ %x\n",
1660	+ got_entry->entry_point, got_entry->got_value,
1661	+ funcval.entry_point, funcval.got_value,
1662	+ got_entry);
1663	+ }
1664	+ if (1 \|\| !_dl_debug_nofixups) {
1665	+ got_entry->entry_point = ((unsigned long *)&_dl_ubicom32_resolve_pending)[0];
1666	+ got_entry->got_value = funcval.got_value;
1667	+ got_entry->entry_point = funcval.entry_point;
1668	+ }
1669	+#else
1670	+ /*
1671	+ * initially set the entry point to resolve pending before starting
1672	+ * the update. This has the effect of putting all other requests in a
1673	+ * holding pattern until the resolution is completed.
1674	+ */
1675	+ got_entry->entry_point = ((unsigned long *)&_dl_ubicom32_resolve_pending)[0];
1676	+ got_entry->got_value = funcval.got_value;
1677	+ got_entry->entry_point = funcval.entry_point;
1678	+#endif
1679	+
1680	+ return got_entry;
1681	+}
1682	+
1683	+static int
1684	+_dl_parse(struct elf_resolve tpnt, struct dyn_elf scope,
1685	+ unsigned long rel_addr, unsigned long rel_size,
1686	+ int (reloc_fnc) (struct elf_resolve tpnt, struct dyn_elf *scope,
1687	+ ELF_RELOC rpnt, ElfW(Sym) symtab, char *strtab))
1688	+{
1689	+ unsigned int i;
1690	+ char *strtab;
1691	+ ElfW(Sym) *symtab;
1692	+ ELF_RELOC *rpnt;
1693	+ int symtab_index;
1694	+
1695	+ /* Now parse the relocation information */
1696	+ rpnt = (ELF_RELOC *) rel_addr;
1697	+ rel_size = rel_size / sizeof(ELF_RELOC);
1698	+
1699	+ symtab = (ElfW(Sym) *) tpnt->dynamic_info[DT_SYMTAB];
1700	+ strtab = (char *) tpnt->dynamic_info[DT_STRTAB];
1701	+
1702	+ for (i = 0; i < rel_size; i++, rpnt++) {
1703	+ int res;
1704	+
1705	+ symtab_index = ELF_R_SYM(rpnt->r_info);
1706	+ debug_sym(symtab,strtab,symtab_index);
1707	+ debug_reloc(symtab,strtab,rpnt);
1708	+
1709	+ res = reloc_fnc (tpnt, scope, rpnt, symtab, strtab);
1710	+
1711	+ if (res==0) continue;
1712	+
1713	+ _dl_dprintf(2, "\n%s: ",_dl_progname);
1714	+
1715	+ if (symtab_index)
1716	+ _dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
1717	+
1718	+ if (res <0) {
1719	+ int reloc_type = ELF_R_TYPE(rpnt->r_info);
1720	+#if defined (__SUPPORT_LD_DEBUG__)
1721	+ _dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type));
1722	+#else
1723	+ _dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
1724	+#endif
1725	+ _dl_exit(-res);
1726	+ } else if (res >0) {
1727	+ _dl_dprintf(2, "can't resolve symbol\n");
1728	+ return res;
1729	+ }
1730	+ }
1731	+ return 0;
1732	+}
1733	+
1734	+static int
1735	+_dl_do_reloc (struct elf_resolve tpnt,struct dyn_elf scope,
1736	+ ELF_RELOC rpnt, ElfW(Sym) symtab, char *strtab)
1737	+{
1738	+ int reloc_type;
1739	+ int symtab_index;
1740	+ char *symname;
1741	+ unsigned long reloc_value = 0, *reloc_addr;
1742	+ struct { unsigned long v; } __attribute__((__packed__))
1743	+ *reloc_addr_packed;
1744	+ unsigned long symbol_addr;
1745	+ struct elf_resolve *symbol_tpnt;
1746	+ struct funcdesc_value funcval;
1747	+#if defined (__SUPPORT_LD_DEBUG__)
1748	+ unsigned long old_val;
1749	+#endif
1750	+
1751	+ reloc_addr = (unsigned long *) DL_RELOC_ADDR(tpnt->loadaddr, rpnt->r_offset);
1752	+ __asm__ ("" : "=r" (reloc_addr_packed) : "0" (reloc_addr));
1753	+ reloc_type = ELF_R_TYPE(rpnt->r_info);
1754	+ symtab_index = ELF_R_SYM(rpnt->r_info);
1755	+ symbol_addr = 0;
1756	+ symname = strtab + symtab[symtab_index].st_name;
1757	+
1758	+ if (ELF_ST_BIND (symtab[symtab_index].st_info) == STB_LOCAL) {
1759	+ symbol_addr = (unsigned long) DL_RELOC_ADDR(tpnt->loadaddr, symtab[symtab_index].st_value);
1760	+ symbol_tpnt = tpnt;
1761	+ } else {
1762	+
1763	+ symbol_addr = (unsigned long)
1764	+ _dl_lookup_hash(symname, scope, NULL, 0, &symbol_tpnt);
1765	+
1766	+ /*
1767	+ * We want to allow undefined references to weak symbols - this might
1768	+ * have been intentional. We should not be linking local symbols
1769	+ * here, so all bases should be covered.
1770	+ */
1771	+
1772	+ if (!symbol_addr && ELF_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK) {
1773	+ _dl_dprintf (2, "%s: can't resolve symbol '%s'\n",
1774	+ _dl_progname, strtab + symtab[symtab_index].st_name);
1775	+ _dl_exit (1);
1776	+ }
1777	+ }
1778	+
1779	+#if defined (__SUPPORT_LD_DEBUG__)
1780	+ if (_dl_debug_reloc && _dl_debug_detail)
1781	+ {
1782	+ if ((long)reloc_addr_packed & 3)
1783	+ old_val = reloc_addr_packed->v;
1784	+ else
1785	+ old_val = *reloc_addr;
1786	+ }
1787	+ else
1788	+ old_val = 0;
1789	+#endif
1790	+ switch (reloc_type) {
1791	+ case R_UBICOM32_NONE:
1792	+ break;
1793	+ case R_UBICOM32_32:
1794	+ if ((long)reloc_addr_packed & 3)
1795	+ reloc_value = reloc_addr_packed->v += symbol_addr;
1796	+ else
1797	+ reloc_value = *reloc_addr += symbol_addr;
1798	+ break;
1799	+ case R_UBICOM32_FUNCDESC_VALUE:
1800	+ funcval.entry_point = (void*)symbol_addr;
1801	+ /* The addend of FUNCDESC_VALUE
1802	+ relocations referencing global
1803	+ symbols must be ignored, because it
1804	+ may hold the address of a lazy PLT
1805	+ entry. */
1806	+ if (ELF_ST_BIND(symtab[symtab_index].st_info) == STB_LOCAL)
1807	+ funcval.entry_point += *reloc_addr;
1808	+ reloc_value = (unsigned long)funcval.entry_point;
1809	+ if (symbol_addr)
1810	+ funcval.got_value
1811	+ = symbol_tpnt->loadaddr.got_value;
1812	+ else
1813	+ funcval.got_value = 0;
1814	+
1815	+/// XXX this is my best guess as to what I should be doing, but I'm
1816	+/// putting a break-point here so I can inspect the first time this is
1817	+/// used.
1818	+ __asm__ (
1819	+ " move.4 4(%0), 4(%1) \n\t"
1820	+ " move.4 0(%0), 0(%1) \n\t" /* Must to entry_point last */
1821	+ :
1822	+ : "a" (reloc_addr), "a" (&funcval)
1823	+ : "memory" );
1824	+ break;
1825	+ case R_UBICOM32_FUNCDESC:
1826	+ if ((long)reloc_addr_packed & 3)
1827	+ reloc_value = reloc_addr_packed->v;
1828	+ else
1829	+ reloc_value = *reloc_addr;
1830	+ if (symbol_addr)
1831	+ reloc_value = (unsigned long)_dl_funcdesc_for
1832	+ ((char *)symbol_addr + reloc_value,
1833	+ symbol_tpnt->loadaddr.got_value);
1834	+ else
1835	+ reloc_value = 0;
1836	+ if ((long)reloc_addr_packed & 3)
1837	+ reloc_addr_packed->v = reloc_value;
1838	+ else
1839	+ *reloc_addr = reloc_value;
1840	+ break;
1841	+ default:
1842	+ return -1;
1843	+ }
1844	+#if defined (__SUPPORT_LD_DEBUG__)
1845	+ if (_dl_debug_reloc && _dl_debug_detail) {
1846	+ _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, reloc_value, reloc_addr);
1847	+ switch (reloc_type) {
1848	+ case R_UBICOM32_FUNCDESC_VALUE:
1849	+ _dl_dprintf(_dl_debug_file, " got %x", ((struct funcdesc_value *)reloc_value)->got_value);
1850	+ break;
1851	+ case R_UBICOM32_FUNCDESC:
1852	+ if (! reloc_value)
1853	+ break;
1854	+ _dl_dprintf(_dl_debug_file, " funcdesc (%x,%x)",
1855	+ ((struct funcdesc_value *)reloc_value)->entry_point,
1856	+ ((struct funcdesc_value *)reloc_value)->got_value);
1857	+ break;
1858	+ }
1859	+ }
1860	+#endif
1861	+
1862	+ return 0;
1863	+}
1864	+
1865	+static int
1866	+_dl_do_lazy_reloc (struct elf_resolve *tpnt,
1867	+ struct dyn_elf *scope __attribute__((unused)),
1868	+ ELF_RELOC rpnt, ElfW(Sym) symtab __attribute__((unused)),
1869	+ char *strtab __attribute__((unused)))
1870	+{
1871	+ int reloc_type;
1872	+ struct funcdesc_value volatile *reloc_addr;
1873	+ struct funcdesc_value funcval;
1874	+#if defined (__SUPPORT_LD_DEBUG__)
1875	+ unsigned long old_val;
1876	+#endif
1877	+
1878	+ reloc_addr = (struct funcdesc_value *) DL_RELOC_ADDR(tpnt->loadaddr, rpnt->r_offset);
1879	+ reloc_type = ELF_R_TYPE(rpnt->r_info);
1880	+
1881	+#if defined (__SUPPORT_LD_DEBUG__)
1882	+ old_val = (unsigned long)reloc_addr->entry_point;
1883	+#endif
1884	+ switch (reloc_type) {
1885	+ case R_UBICOM32_NONE:
1886	+ break;
1887	+ case R_UBICOM32_FUNCDESC_VALUE:
1888	+ funcval = *reloc_addr;
1889	+ funcval.entry_point = (void*)DL_RELOC_ADDR(tpnt->loadaddr, funcval.entry_point);
1890	+ funcval.got_value = tpnt->loadaddr.got_value;
1891	+ *reloc_addr = funcval;
1892	+ break;
1893	+ default:
1894	+ return -1;
1895	+ }
1896	+#if defined (__SUPPORT_LD_DEBUG__)
1897	+ if (_dl_debug_reloc && _dl_debug_detail)
1898	+ _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, reloc_addr->entry_point, reloc_addr);
1899	+#endif
1900	+ return 0;
1901	+
1902	+}
1903	+
1904	+void
1905	+_dl_parse_lazy_relocation_information
1906	+(struct dyn_elf *rpnt, unsigned long rel_addr, unsigned long rel_size)
1907	+{
1908	+ _dl_parse(rpnt->dyn, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
1909	+}
1910	+
1911	+int
1912	+_dl_parse_relocation_information
1913	+(struct dyn_elf *rpnt, unsigned long rel_addr, unsigned long rel_size)
1914	+{
1915	+ return _dl_parse(rpnt->dyn, rpnt->dyn->symbol_scope, rel_addr, rel_size, _dl_do_reloc);
1916	+}
1917	+
1918	+#if 0
1919	+/* We don't have copy relocs. */
1920	+int
1921	+_dl_parse_copy_information
1922	+(struct dyn_elf *rpnt __attribute__((unused)),
1923	+ unsigned long rel_addr __attribute__((unused)),
1924	+ unsigned long rel_size __attribute__((unused)))
1925	+{
1926	+ return 0;
1927	+}
1928	+#endif
1929	+#ifndef IS_IN_libdl
1930	+# include "../../libc/sysdeps/linux/ubicom32/crtreloc.c"
1931	+#endif
1932	--- /dev/null
1933	+++ b/ldso/ldso/ubicom32/resolve.S
1934	@@ -0,0 +1,161 @@
1935	+ /* Copyright (C) 2003 Red Hat, Inc.
1936	+ Contributed by Alexandre Oliva <aoliva@redhat.com>
1937	+
1938	+ Copyright (C) 2009 Ubicom Inc.
1939	+ Ported to Ubicom32 by Ubicom Inc.
1940	+
1941	+This file is part of uClibc.
1942	+
1943	+uClibc is free software; you can redistribute it and/or modify it
1944	+under the terms of the GNU Lesser General Public License as
1945	+published by the Free Software Foundation; either version 2.1 of the
1946	+License, or (at your option) any later version.
1947	+
1948	+uClibc is distributed in the hope that it will be useful, but WITHOUT
1949	+ANY WARRANTY; without even the implied warranty of
1950	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1951	+Library General Public License for more details.
1952	+
1953	+You should have received a copy of the GNU Lesser General Public
1954	+License along with uClibc; see the file COPYING.LIB. If not, write to
1955	+the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
1956	+USA. */
1957	+
1958	+
1959	+/*
1960	+ * The function below is tail-called by resolver stubs when a lazily-bound *
1961	+ * function is called. It must preserve all registers that could * be used to
1962	+ * pass arguments to the actual function.
1963	+ *
1964	+ * On entry to the function d0-d13 contain parameters to the actual function of
1965	+ * interest
1966	+ *
1967	+ * a5 contains the return address
1968	+ * a0 is pointing to the GOT table for the original function
1969	+ * (a0) _dl_linux_resolve
1970	+ * 4(a0) GOT for _dl_linux_resolve
1971	+ * 8(a0) is pointer to "structure elf_resolve" of the module where the call
1972	+ * originated from
1973	+ *
1974	+ * a3 is pointing to the function descriptor in the GOT table, and 8(a3) the
1975	+ * resolver lookup information.
1976	+ *
1977	+ * _dl_linux_resolve calls _dl_linux_resolver passing it pointer to
1978	+ * struct elf_resolve and the relocation entry.
1979	+ *
1980	+ * _dl_linux_resolver() figures out where the jump symbol is _really_ supposed
1981	+ * to have jumped to and returns that to us. Once we have that, we prepare to
1982	+ * tail-call the actual function, clean up after ourselves, restoring the
1983	+ * original arguments, then jump to the fixed up address.
1984	+ */
1985	+
1986	+#if 0
1987	+ /*
1988	+ * Here is what the linker will use for the PLT.
1989	+ */
1990	+sample_PLT_functionX: /* (at entry a0 contains GOT for this library) */
1991	+ movei d15, # -%lo(got_funcdescX) ; load offset for GOT
1992	+ lea.4 a3, (a0, d15) ; a4 is now the function descriptor
1993	+ move.4 a4, 0(a3) ; get entry_point
1994	+ move.4 a0, 4(a3) ; set new GOT
1995	+
1996	+ /*
1997	+ * jump to resovled function OR PLT_trampoline Nat had some code here
1998	+ * that uses the stack instead of a3 to reduces hazards.
1999	+ */
2000	+ calli a4, 0(a4)
2001	+
2002	+
2003	+sample_PLT_trampoline:
2004	+ /*
2005	+ * find the old got by undoing what was done above. An alternative
2006	+ * could have been to ‘save’ the old got in say d14 but that would add 1
2007	+ * instruction to every PLT and there is only 1 PLT trampoline per library.
2008	+ */
2009	+ ret (a0) ; jump to _dl_linux_resolve
2010	+#endif
2011	+
2012	+ .text
2013	+ .p2align 4
2014	+
2015	+ .hidden _dl_linux_resolve
2016	+ .global _dl_linux_resolve
2017	+ .type _dl_linux_resolve,@function
2018	+_dl_linux_resolve:
2019	+ /* Preserve arguments and return address */
2020	+ move.4 -4(sp)++, d0
2021	+ move.4 -4(sp)++, d1
2022	+ move.4 -4(sp)++, d2
2023	+ move.4 -4(sp)++, d3
2024	+ move.4 -4(sp)++, d4
2025	+ move.4 -4(sp)++, d5
2026	+ move.4 -4(sp)++, d6
2027	+ move.4 -4(sp)++, d7
2028	+ move.4 -4(sp)++, d8
2029	+ move.4 -4(sp)++, d9
2030	+ move.4 -4(sp)++, d10
2031	+ move.4 -4(sp)++, d11
2032	+ move.4 -4(sp)++, d12
2033	+ move.4 -4(sp)++, d13
2034	+ move.4 -4(sp)++, a5
2035	+
2036	+ /* Prepare to call _dl_linux_resolver. */
2037	+ move.4 d0, 8(a0) ; reference to elf_resolve
2038	+ /* Not aligned for space reasons. */
2039	+ move.4 d1, mac_hi ; reference to GOT table entry which
2040	+ ; contains the relocation information.
2041	+
2042	+ move.4 a0, 4(a0) ; switch to GOT for _dl_linux_resolve
2043	+ call a5, _dl_linux_resolver;
2044	+
2045	+ /* Move aside return value that contains the FUNCDESC_VALUE. */
2046	+ ;P3 = R0;
2047	+ move.4 a3, d0;
2048	+
2049	+ /* Restore arguments. */
2050	+ move.4 a5, (sp)4++
2051	+ move.4 d13, (sp)4++
2052	+ move.4 d12, (sp)4++
2053	+ move.4 d11, (sp)4++
2054	+ move.4 d10, (sp)4++
2055	+ move.4 d9, (sp)4++
2056	+ move.4 d8, (sp)4++
2057	+ move.4 d7, (sp)4++
2058	+ move.4 d6, (sp)4++
2059	+ move.4 d5, (sp)4++
2060	+ move.4 d4, (sp)4++
2061	+ move.4 d3, (sp)4++
2062	+ move.4 d2, (sp)4++
2063	+ move.4 d1, (sp)4++
2064	+ move.4 d0, (sp)4++
2065	+
2066	+ /* Now jump to the actual function. */
2067	+ /* a3 contains func_desc resolution */
2068	+ move.4 a4, 0(a3) ; address of function X
2069	+ move.4 a0, 4(a3) ; switch to GOT for function X
2070	+ calli a4, 0(a4) ; call through a4, a5 remains
2071	+
2072	+ .size _dl_linux_resolve, . - _dl_linux_resolve
2073	+
2074	+ .hidden _dl_ubicom32_resolve_pending
2075	+ .global _dl_ubicom32_resolve_pending
2076	+ .type _dl_ubicom32_resolve_pending,@function
2077	+
2078	+_dl_ubicom32_resolve_pending:
2079	+ /*
2080	+ * A special function that is used to ensure thread saftly when the fd
2081	+ * for a particular resolution is being updated.
2082	+ *
2083	+ * At entry, a3 must point to the FD. While the FD is being updated the
2084	+ * entry_point will continue to point to _dl_ubicom32_resolve_pending so
2085	+ * we will effectively spin until the resolver update is complete.
2086	+ */
2087	+
2088	+ move.4 a4, 0(a3) ; get entry_point
2089	+ move.4 a0, 4(a3) ; set new GOT
2090	+
2091	+ /*
2092	+ * jump to resovled function or back to _dl_ubicom32_resolve_pending.
2093	+ */
2094	+ calli a4, 0(a4)
2095	+ .size _dl_ubicom32_resolve_pending, . - _dl_ubicom32_resolve_pending
2096	--- a/libc/misc/Makefile.in
2097	+++ b/libc/misc/Makefile.in
2098	@@ -12,7 +12,9 @@ include $(top_srcdir)libc/misc/assert/Ma
2099	include $(top_srcdir)libc/misc/ctype/Makefile.in
2100	include $(top_srcdir)libc/misc/dirent/Makefile.in
2101	include $(top_srcdir)libc/misc/error/Makefile.in
2102	+ifneq ($(ARCH_HAS_NO_LDSO),y)
2103	include $(top_srcdir)libc/misc/elf/Makefile.in
2104	+endif
2105	include $(top_srcdir)libc/misc/file/Makefile.in
2106	include $(top_srcdir)libc/misc/fnmatch/Makefile.in
2107	include $(top_srcdir)libc/misc/ftw/Makefile.in
2108	--- a/libc/misc/elf/dl-iterate-phdr.c
2109	+++ b/libc/misc/elf/dl-iterate-phdr.c
2110	@@ -14,7 +14,7 @@
2111
2112	#include <link.h>
2113	#include <ldso.h>
2114	-
2115	+#include <memory.h>
2116	/* we want this in libc but nowhere else */
2117	#ifdef __USE_GNU
2118
2119	--- a/libc/stdlib/malloc/malloc.c
2120	+++ b/libc/stdlib/malloc/malloc.c
2121	@@ -23,7 +23,7 @@
2122
2123	/* The malloc heap. We provide a bit of initial static space so that
2124	programs can do a little mallocing without mmaping in more space. */
2125	-HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 256);
2126	+HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 32768);
2127	struct heap_free_area *__malloc_heap = HEAP_INIT_WITH_FA (initial_fa);
2128	#ifdef HEAP_USE_LOCKING
2129	malloc_mutex_t __malloc_heap_lock = PTHREAD_MUTEX_INITIALIZER;
2130	--- /dev/null
2131	+++ b/libc/string/ubicom32/Makefile
2132	@@ -0,0 +1,13 @@
2133	+# Makefile for uClibc
2134	+#
2135	+# Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org>
2136	+#
2137	+# Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
2138	+#
2139	+
2140	+top_srcdir:=../../../
2141	+top_builddir:=../../../
2142	+all: objs
2143	+include $(top_builddir)Rules.mak
2144	+include ../Makefile.in
2145	+include $(top_srcdir)Makerules
2146	--- /dev/null
2147	+++ b/libc/string/ubicom32/memcpy.c
2148	@@ -0,0 +1,152 @@
2149	+/* Copy memory to memory until the specified number of bytes
2150	+ has been copied. Overlap is NOT handled correctly.
2151	+ Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc.
2152	+ This file is part of the GNU C Library.
2153	+ Contributed by Torbjorn Granlund (tege@sics.se).
2154	+
2155	+ The GNU C Library is free software; you can redistribute it and/or
2156	+ modify it under the terms of the GNU Lesser General Public
2157	+ License as published by the Free Software Foundation; either
2158	+ version 2.1 of the License, or (at your option) any later version.
2159	+
2160	+ The GNU C Library is distributed in the hope that it will be useful,
2161	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
2162	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2163	+ Lesser General Public License for more details.
2164	+
2165	+ You should have received a copy of the GNU Lesser General Public
2166	+ License along with the GNU C Library; if not, write to the Free
2167	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2168	+ 02111-1307 USA. */
2169	+
2170	+#include <string.h>
2171	+
2172	+typedef unsigned long addr_t;
2173	+
2174	+libc_hidden_proto(memcpy)
2175	+
2176	+void memcpy (void dest, const void *src, size_t n)
2177	+{
2178	+ void *dest_ret = dest;
2179	+ void *aligned_start;
2180	+
2181	+ if (likely((((addr_t)dest ^ (addr_t)src) & 3) == 0) && likely(n > 6)) {
2182	+ size_t m;
2183	+ n -= (4 - (addr_t)dest) & 0x03;
2184	+ m = n >> 2;
2185	+ __asm__ volatile (
2186	+ " call %4, 99f \n\t" // load %4 with address of 99
2187	+ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99
2188	+ " add.4 %4, %4, d15 \n\t" // add difference
2189	+
2190	+ " sub.4 d15, #0, %2 \n\t" // set up for jump table
2191	+ " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1)
2192	+ " lea.4 %4, (%4,d15) \n\t"
2193	+
2194	+ " bfextu d15, %0, #2 \n\t" // d15 = (dest & 3)
2195	+ " jmpne.w.f 100f \n\t"
2196	+ " calli %4, 0(%4) \n\t" // 4-byte alignment
2197	+
2198	+ "100: cmpi d15, #2 \n\t"
2199	+ " jmpne.s.f 101f \n\t"
2200	+ " move.2 (%0)2++, (%1)2++ \n\t"
2201	+ " calli %4, 0(%4) \n\t" // 2-byte alignment
2202	+
2203	+ "101: move.1 (%0)1++, (%1)1++ \n\t"
2204	+ " jmpgt.s.f 102f \n\t" // 3-byte alignment
2205	+ " move.2 (%0)2++, (%1)2++ \n\t" // 1-byte alignment
2206	+ "102: calli %4, 0(%4) \n\t"
2207	+
2208	+ "200: cmpi %3, #2 \n\t"
2209	+ " jmplt.s.f 201f \n\t"
2210	+ " move.2 (%0)2++, (%1)2++ \n\t"
2211	+ " jmpeq.s.t 2f \n\t"
2212	+ "201: move.1 (%0)1++, (%1)1++ \n\t"
2213	+ " jmpt.w.t 2f \n\t"
2214	+
2215	+ "1: .rept 25 \n\t"
2216	+ " movea (%0)4++, (%1)4++ \n\t"
2217	+ " .endr \n\t"
2218	+ " .rept 7 \n\t"
2219	+ " move.4 (%0)4++, (%1)4++ \n\t"
2220	+ " .endr \n\t"
2221	+ " add.4 %2, #-32, %2 \n\t"
2222	+ " jmpgt.w.f 1b \n\t"
2223	+
2224	+ " and.4 %3, #3, %3 \n\t" // check n
2225	+ " jmpne.w.f 200b \n\t"
2226	+ "2: \n\t"
2227	+ : "+a"(dest), "+a"(src), "+d"(m), "+d"(n), "=a"(aligned_start)
2228	+ :
2229	+ : "d15", "memory", "cc"
2230	+ );
2231	+
2232	+ return dest_ret;
2233	+ }
2234	+
2235	+ if (likely((((addr_t)dest ^ (addr_t)src) & 1) == 0) && likely(n > 2)) {
2236	+ size_t m;
2237	+ n -= (addr_t)dest & 0x01;
2238	+ m = n >> 1;
2239	+ __asm__ volatile (
2240	+ " call %4, 99f \n\t" // load %4 with address of 99
2241	+ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99
2242	+ " add.4 %4, %4, d15 \n\t" // add difference
2243	+
2244	+ " sub.4 d15, #0, %2 \n\t" // set up for jump table
2245	+ " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1)
2246	+ " lea.4 %4, (%4,d15) \n\t"
2247	+
2248	+ " btst %0, #0 \n\t" // check bit 0
2249	+ " jmpne.w.f 100f \n\t"
2250	+ " calli %4, 0(%4) \n\t" // 4-byte alignment
2251	+
2252	+ "100: move.1 (%0)1++, (%1)1++ \n\t"
2253	+ " calli %4, 0(%4) \n\t"
2254	+
2255	+ "200: move.1 (%0)1++, (%1)1++ \n\t"
2256	+ " jmpt.w.t 2f \n\t"
2257	+
2258	+ "1: .rept 32 \n\t"
2259	+ " move.2 (%0)2++, (%1)2++ \n\t"
2260	+ " .endr \n\t"
2261	+ " add.4 %2, #-32, %2 \n\t"
2262	+ " jmpgt.w.f 1b \n\t"
2263	+
2264	+ " and.4 %3, #1, %3 \n\t" // check n
2265	+ " jmpne.w.f 200b \n\t"
2266	+ "2: \n\t"
2267	+
2268	+ : "+a"(dest), "+a"(src), "+d"(m), "+d"(n), "=a"(aligned_start)
2269	+ :
2270	+ : "d15", "memory", "cc"
2271	+ );
2272	+ return dest_ret;
2273	+ }
2274	+
2275	+ __asm__ volatile (
2276	+ " call %3, 99f \n\t" // load %3 with address of 99
2277	+ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99
2278	+ " add.4 %3, %3, d15 \n\t" // add difference
2279	+
2280	+ " sub.4 d15, #0, %2 \n\t"
2281	+ " jmpeq.w.f 2f \n\t"
2282	+ " and.4 d15, #(16-1), d15 \n\t" // d15 = (-n) & (16 - 1)
2283	+ " lea.4 %3, (%3,d15) \n\t"
2284	+ " calli %3, 0(%3) \n\t"
2285	+
2286	+ "1: .rept 16 \n\t"
2287	+ " move.1 (%0)1++, (%1)1++ \n\t"
2288	+ " .endr \n\t"
2289	+ " add.4 %2, #-16, %2 \n\t"
2290	+ " jmpgt.w.f 1b \n\t"
2291	+ "2: \n\t"
2292	+
2293	+ : "+a"(dest), "+a"(src), "+d"(n), "=a"(aligned_start)
2294	+ :
2295	+ : "d15", "memory", "cc"
2296	+ );
2297	+
2298	+ return dest_ret;
2299	+}
2300	+libc_hidden_def(memcpy)
2301	--- /dev/null
2302	+++ b/libc/string/ubicom32/memset.c
2303	@@ -0,0 +1,107 @@
2304	+/* Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc.
2305	+ This file is part of the GNU C Library.
2306	+
2307	+ The GNU C Library is free software; you can redistribute it and/or
2308	+ modify it under the terms of the GNU Lesser General Public
2309	+ License as published by the Free Software Foundation; either
2310	+ version 2.1 of the License, or (at your option) any later version.
2311	+
2312	+ The GNU C Library is distributed in the hope that it will be useful,
2313	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
2314	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2315	+ Lesser General Public License for more details.
2316	+
2317	+ You should have received a copy of the GNU Lesser General Public
2318	+ License along with the GNU C Library; if not, write to the Free
2319	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2320	+ 02111-1307 USA. */
2321	+
2322	+#include <string.h>
2323	+
2324	+typedef unsigned long addr_t;
2325	+
2326	+libc_hidden_proto(memset)
2327	+void memset (void s, int c, size_t n)
2328	+{
2329	+ void *s_ret = s;
2330	+ void *aligned_start;
2331	+ if (likely(n > 6)) {
2332	+ size_t m;
2333	+ n -= (4 - (addr_t)s) & 0x03;
2334	+ m = n >> 2;
2335	+ __asm__ volatile (
2336	+ " call %4, 99f \n\t" // load %4 with address of 99
2337	+ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99
2338	+ " add.4 %4, %4, d15 \n\t" // add difference
2339	+
2340	+ " sub.4 d15, #0, %2 \n\t" // set up for jump table
2341	+ " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1)
2342	+ " shmrg.1 %1, %1, %1 \n\t"
2343	+ " shmrg.2 %1, %1, %1 \n\t" // %1 = (c<<24)\|(c<<16)\|(c<<8)\|c
2344	+ " lea.4 %4, (%4,d15) \n\t"
2345	+
2346	+ " bfextu d15, %0, #2 \n\t" // d15 = (s & 3)
2347	+ " jmpne.w.f 100f \n\t"
2348	+ " calli %4, 0(%4) \n\t" // 4-byte alignment
2349	+
2350	+ "100: cmpi d15, #2 \n\t"
2351	+ " jmpne.s.f 101f \n\t"
2352	+ " move.2 (%0)2++, %1 \n\t"
2353	+ " calli %4, 0(%4) \n\t" // 2-byte alignment
2354	+
2355	+ "101: move.1 (%0)1++, %1 \n\t"
2356	+ " jmpgt.s.f 102f \n\t" // 3-byte alignment
2357	+ " move.2 (%0)2++, %1 \n\t" // 1-byte alignment
2358	+ "102: calli %4, 0(%4) \n\t"
2359	+
2360	+ "200: cmpi %3, #2 \n\t"
2361	+ " jmplt.s.f 201f \n\t"
2362	+ " move.2 (%0)2++, %1 \n\t"
2363	+ " jmpeq.s.t 2f \n\t"
2364	+ "201: move.1 (%0)1++, %1 \n\t"
2365	+ " jmpt.w.t 2f \n\t"
2366	+
2367	+ "1: .rept 25 \n\t"
2368	+ " movea (%0)4++, %1 \n\t"
2369	+ " .endr \n\t"
2370	+ " .rept 7 \n\t"
2371	+ " move.4 (%0)4++, %1 \n\t"
2372	+ " .endr \n\t"
2373	+ " add.4 %2, #-32, %2 \n\t"
2374	+ " jmpgt.w.f 1b \n\t"
2375	+
2376	+ " and.4 %3, #3, %3 \n\t" // test bit 1 of n
2377	+ " jmpne.w.f 200b \n\t"
2378	+ "2: \n\t"
2379	+ : "+a"(s), "+d"(c), "+d"(m), "+d"(n), "=a"(aligned_start)
2380	+ :
2381	+ : "d15", "memory", "cc"
2382	+ );
2383	+
2384	+ return s_ret;
2385	+ }
2386	+
2387	+ __asm__ volatile (
2388	+ " call %3, 99f \n\t" // load %3 with address of 99
2389	+ "99: movei d15, #%%lo(1f-99b) \n\t" // load d15 with offset to 1 from 99
2390	+ " add.4 %3, %3, d15 \n\t" // add difference
2391	+
2392	+ " sub.4 d15, #0, %2 \n\t"
2393	+ " jmpeq.w.f 2f \n\t"
2394	+ " and.4 d15, #(8-1), d15 \n\t" // d15 = (-%2) & (16 - 1)
2395	+ " lea.4 %3, (%3,d15) \n\t"
2396	+ " calli %3, 0(%3) \n\t"
2397	+
2398	+ "1: .rept 8 \n\t"
2399	+ " move.1 (%0)1++, %1 \n\t"
2400	+ " .endr \n\t"
2401	+ "2: \n\t"
2402	+
2403	+ : "+a"(s), "+d"(c), "+d"(n), "=a"(aligned_start)
2404	+ :
2405	+ : "d15", "memory", "cc"
2406	+ );
2407	+
2408	+ return s_ret;
2409	+}
2410	+libc_hidden_def(memset)
2411	--- /dev/null
2412	+++ b/libc/sysdeps/linux/ubicom32/Makefile
2413	@@ -0,0 +1,13 @@
2414	+# Makefile for uClibc
2415	+#
2416	+# Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
2417	+#
2418	+# Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
2419	+#
2420	+
2421	+top_srcdir=../../../../
2422	+top_builddir=../../../../
2423	+all: objs
2424	+include $(top_builddir)Rules.mak
2425	+include Makefile.arch
2426	+include $(top_srcdir)Makerules
2427	--- /dev/null
2428	+++ b/libc/sysdeps/linux/ubicom32/Makefile.arch
2429	@@ -0,0 +1,28 @@
2430	+# Makefile for uClibc
2431	+#
2432	+# Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
2433	+#
2434	+# Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
2435	+#
2436	+
2437	+#CSRC := \
2438	+# brk.c \
2439	+# crtbegin.c \
2440	+# crtend.c
2441	+#
2442	+#SSRC := \
2443	+# __longjmp.S \
2444	+# bsd-_setjmp.S \
2445	+# bsd-setjmp.S \
2446	+# setjmp.S \
2447	+# clone.S \
2448	+# vfork.S
2449	+
2450	+CSRC := \
2451	+ syscall.c __syscall_error.c
2452	+
2453	+SSRC := \
2454	+ clone.S setjmp.S vfork.S
2455	+
2456	+ARCH_CFLAGS := $(CPU_CFLAGS-y)
2457	+include $(top_srcdir)libc/sysdeps/linux/Makefile.commonarch
2458	--- /dev/null
2459	+++ b/libc/sysdeps/linux/ubicom32/__syscall_error.c
2460	@@ -0,0 +1,11 @@
2461	+#include <errno.h>
2462	+#include <features.h>
2463	+
2464	+/* This routine is jumped to by some of the syscall handlers, to stash
2465	+ * an error number into errno. */
2466	+int __syscall_error(int err_no) attribute_hidden;
2467	+int __syscall_error(int err_no)
2468	+{
2469	+ __set_errno(err_no);
2470	+ return -1;
2471	+}
2472	--- /dev/null
2473	+++ b/libc/sysdeps/linux/ubicom32/bits/elf-fdpic.h
2474	@@ -0,0 +1,115 @@
2475	+/* Copyright 2003, 2004 Free Software Foundation, Inc.
2476	+This file is part of the GNU C Library.
2477	+
2478	+The GNU C Library is free software; you can redistribute it and/or
2479	+modify it under the terms of the GNU Lesser General Public License as
2480	+published by the Free Software Foundation; either version 2.1 of the
2481	+License, or (at your option) any later version.
2482	+
2483	+In addition to the permissions in the GNU Lesser General Public
2484	+License, the Free Software Foundation gives you unlimited
2485	+permission to link the compiled version of this file with other
2486	+programs, and to distribute those programs without any restriction
2487	+coming from the use of this file. (The GNU Lesser General Public
2488	+License restrictions do apply in other respects; for example, they
2489	+cover modification of the file, and distribution when not linked
2490	+into another program.)
2491	+
2492	+The GNU C Library is distributed in the hope that it will be useful,
2493	+but WITHOUT ANY WARRANTY; without even the implied warranty of
2494	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2495	+Library General Public License for more details.
2496	+
2497	+You should have received a copy of the GNU Lesser General Public
2498	+License along with the GNU C Library; see the file COPYING.LIB. If
2499	+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
2500	+Cambridge, MA 02139, USA. */
2501	+
2502	+#ifndef _BITS_ELF_FDPIC_H
2503	+#define _BITS_ELF_FDPIC_H
2504	+
2505	+/* These data structures are described in the FDPIC ABI extension.
2506	+ The kernel passes a process a memory map, such that for every LOAD
2507	+ segment there is an elf32_fdpic_loadseg entry. A pointer to an
2508	+ elf32_fdpic_loadmap is passed in d8 at start-up, and a pointer to
2509	+ an additional such map is passed in d9 for the interpreter, when
2510	+ there is one. */
2511	+
2512	+#include <elf.h>
2513	+
2514	+/* This data structure represents a PT_LOAD segment. */
2515	+struct elf32_fdpic_loadseg
2516	+{
2517	+ /* Core address to which the segment is mapped. */
2518	+ Elf32_Addr addr;
2519	+ /* VMA recorded in the program header. */
2520	+ Elf32_Addr p_vaddr;
2521	+ /* Size of this segment in memory. */
2522	+ Elf32_Word p_memsz;
2523	+};
2524	+
2525	+struct elf32_fdpic_loadmap {
2526	+ /* Protocol version number, must be zero. */
2527	+ Elf32_Half version;
2528	+ /* Number of segments in this map. */
2529	+ Elf32_Half nsegs;
2530	+ /* The actual memory map. */
2531	+ struct elf32_fdpic_loadseg segs[/nsegs/];
2532	+};
2533	+
2534	+struct elf32_fdpic_loadaddr {
2535	+ struct elf32_fdpic_loadmap *map;
2536	+ void *got_value;
2537	+};
2538	+
2539	+/* Map a pointer's VMA to its corresponding address according to the
2540	+ load map. */
2541	+static __always_inline void *
2542	+__reloc_pointer (void *p,
2543	+ const struct elf32_fdpic_loadmap *map)
2544	+{
2545	+ int c;
2546	+
2547	+#if 0
2548	+ if (map->version != 0)
2549	+ /* Crash. */
2550	+ ((void(*)())0)();
2551	+#endif
2552	+
2553	+ /* No special provision is made for NULL. We don't want NULL
2554	+ addresses to go through relocation, so they shouldn't be in
2555	+ .rofixup sections, and, if they're present in dynamic
2556	+ relocations, they shall be mapped to the NULL address without
2557	+ undergoing relocations. */
2558	+
2559	+ for (c = 0;
2560	+ /* Take advantage of the fact that the loadmap is ordered by
2561	+ virtual addresses. In general there will only be 2 entries,
2562	+ so it's not profitable to do a binary search. */
2563	+ c < map->nsegs && p >= (void*)map->segs[c].p_vaddr;
2564	+ c++)
2565	+ {
2566	+ /* This should be computed as part of the pointer comparison
2567	+ above, but we want to use the carry in the comparison, so we
2568	+ can't convert it to an integer type beforehand. */
2569	+ unsigned long offset = p - (void*)map->segs[c].p_vaddr;
2570	+ /* We only check for one-past-the-end for the last segment,
2571	+ assumed to be the data segment, because other cases are
2572	+ ambiguous in the absence of padding between segments, and
2573	+ rofixup already serves as padding between text and data.
2574	+ Unfortunately, unless we special-case the last segment, we
2575	+ fail to relocate the _end symbol. */
2576	+ if (offset < map->segs[c].p_memsz
2577	+ \|\| (offset == map->segs[c].p_memsz && c + 1 == map->nsegs))
2578	+ return (char*)map->segs[c].addr + offset;
2579	+ }
2580	+
2581	+ /* We might want to crash instead. */
2582	+ return (void*)-1;
2583	+}
2584	+
2585	+# define __RELOC_POINTER(ptr, loadaddr) \
2586	+ (__reloc_pointer ((void*)(ptr), \
2587	+ (loadaddr).map))
2588	+
2589	+#endif /* _BITS_ELF_FDPIC_H */
2590	--- /dev/null
2591	+++ b/libc/sysdeps/linux/ubicom32/bits/endian.h
2592	@@ -0,0 +1,7 @@
2593	+/* Ubicom32 is big-endian. */
2594	+
2595	+#ifndef _ENDIAN_H
2596	+# error "Never use <bits/endian.h> directly; include <endian.h> instead."
2597	+#endif
2598	+
2599	+#define __BYTE_ORDER __BIG_ENDIAN
2600	--- /dev/null
2601	+++ b/libc/sysdeps/linux/ubicom32/bits/fcntl.h
2602	@@ -0,0 +1,226 @@
2603	+/* O_, F_, FD_* bit values for Linux.
2604	+ Copyright (C) 2000 Free Software Foundation, Inc.
2605	+ This file is part of the GNU C Library.
2606	+
2607	+ The GNU C Library is free software; you can redistribute it and/or
2608	+ modify it under the terms of the GNU Lesser General Public
2609	+ License as published by the Free Software Foundation; either
2610	+ version 2.1 of the License, or (at your option) any later version.
2611	+
2612	+ The GNU C Library is distributed in the hope that it will be useful,
2613	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
2614	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2615	+ Lesser General Public License for more details.
2616	+
2617	+ You should have received a copy of the GNU Lesser General Public
2618	+ License along with the GNU C Library; if not, write to the Free
2619	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2620	+ 02111-1307 USA. */
2621	+
2622	+#ifndef _FCNTL_H
2623	+# error "Never use <bits/fcntl.h> directly; include <fcntl.h> instead."
2624	+#endif
2625	+
2626	+
2627	+#include <sys/types.h>
2628	+#ifdef __USE_GNU
2629	+# include <bits/uio.h>
2630	+#endif
2631	+
2632	+/* open/fcntl - O_SYNC is only implemented on blocks devices and on files
2633	+ located on an ext2 file system */
2634	+#define O_ACCMODE 0003
2635	+#define O_RDONLY 00
2636	+#define O_WRONLY 01
2637	+#define O_RDWR 02
2638	+#define O_CREAT 0100 /* not fcntl */
2639	+#define O_EXCL 0200 /* not fcntl */
2640	+#define O_NOCTTY 0400 /* not fcntl */
2641	+#define O_TRUNC 01000 /* not fcntl */
2642	+#define O_APPEND 02000
2643	+#define O_NONBLOCK 04000
2644	+#define O_NDELAY O_NONBLOCK
2645	+#define O_SYNC 010000
2646	+#define O_FSYNC O_SYNC
2647	+#define O_ASYNC 020000
2648	+
2649	+#ifdef __USE_GNU
2650	+# define O_DIRECTORY 040000 /* Must be a directory. */
2651	+# define O_NOFOLLOW 0100000 /* Do not follow links. */
2652	+# define O_DIRECT 0200000 /* Direct disk access. */
2653	+# define O_NOATIME 01000000 /* Do not set atime. */
2654	+# define O_CLOEXEC 02000000 /* set close_on_exec */
2655	+# define O_STREAMING 04000000 /* streaming access */
2656	+#endif
2657	+
2658	+/* For now Linux has synchronisity options for data and read operations.
2659	+ We define the symbols here but let them do the same as O_SYNC since
2660	+ this is a superset. */
2661	+#if defined __USE_POSIX199309 \|\| defined __USE_UNIX98
2662	+# define O_DSYNC O_SYNC /* Synchronize data. */
2663	+# define O_RSYNC O_SYNC /* Synchronize read operations. */
2664	+#endif
2665	+
2666	+#ifdef __USE_LARGEFILE64
2667	+# define O_LARGEFILE 0400000
2668	+#endif
2669	+
2670	+/* Values for the second argument to `fcntl'. */
2671	+#define F_DUPFD 0 /* Duplicate file descriptor. */
2672	+#define F_GETFD 1 /* Get file descriptor flags. */
2673	+#define F_SETFD 2 /* Set file descriptor flags. */
2674	+#define F_GETFL 3 /* Get file status flags. */
2675	+#define F_SETFL 4 /* Set file status flags. */
2676	+#ifndef __USE_FILE_OFFSET64
2677	+# define F_GETLK 5 /* Get record locking info. */
2678	+# define F_SETLK 6 /* Set record locking info (non-blocking). */
2679	+# define F_SETLKW 7 /* Set record locking info (blocking). */
2680	+#else
2681	+# define F_GETLK F_GETLK64 /* Get record locking info. */
2682	+# define F_SETLK F_SETLK64 /* Set record locking info (non-blocking).*/
2683	+# define F_SETLKW F_SETLKW64 /* Set record locking info (blocking). */
2684	+#endif
2685	+#define F_GETLK64 12 /* Get record locking info. */
2686	+#define F_SETLK64 13 /* Set record locking info (non-blocking). */
2687	+#define F_SETLKW64 14 /* Set record locking info (blocking). */
2688	+
2689	+#if defined __USE_BSD \|\| defined __USE_XOPEN2K
2690	+# define F_SETOWN 8 /* Get owner of socket (receiver of SIGIO). */
2691	+# define F_GETOWN 9 /* Set owner of socket (receiver of SIGIO). */
2692	+#endif
2693	+
2694	+#ifdef __USE_GNU
2695	+# define F_SETSIG 10 /* Set number of signal to be sent. */
2696	+# define F_GETSIG 11 /* Get number of signal to be sent. */
2697	+#endif
2698	+
2699	+#ifdef __USE_GNU
2700	+# define F_SETLEASE 1024 /* Set a lease. */
2701	+# define F_GETLEASE 1025 /* Enquire what lease is active. */
2702	+# define F_NOTIFY 1026 /* Request notfications on a directory. */
2703	+#endif
2704	+
2705	+/* For F_[GET\|SET]FL. */
2706	+#define FD_CLOEXEC 1 /* actually anything with low bit set goes */
2707	+
2708	+/* For posix fcntl() and `l_type' field of a `struct flock' for lockf(). */
2709	+#define F_RDLCK 0 /* Read lock. */
2710	+#define F_WRLCK 1 /* Write lock. */
2711	+#define F_UNLCK 2 /* Remove lock. */
2712	+
2713	+/* For old implementation of bsd flock(). */
2714	+#define F_EXLCK 4 /* or 3 */
2715	+#define F_SHLCK 8 /* or 4 */
2716	+
2717	+#ifdef __USE_BSD
2718	+/* Operations for bsd flock(), also used by the kernel implementation. */
2719	+# define LOCK_SH 1 /* shared lock */
2720	+# define LOCK_EX 2 /* exclusive lock */
2721	+# define LOCK_NB 4 /* or'd with one of the above to prevent
2722	+ blocking */
2723	+# define LOCK_UN 8 /* remove lock */
2724	+#endif
2725	+
2726	+#ifdef __USE_GNU
2727	+# define LOCK_MAND 32 /* This is a mandatory flock: */
2728	+# define LOCK_READ 64 /* ... which allows concurrent read operations. */
2729	+# define LOCK_WRITE 128 /* ... which allows concurrent write operations. */
2730	+# define LOCK_RW 192 /* ... Which allows concurrent read & write operations. */
2731	+#endif
2732	+
2733	+#ifdef __USE_GNU
2734	+/* Types of directory notifications that may be requested with F_NOTIFY. */
2735	+# define DN_ACCESS 0x00000001 /* File accessed. */
2736	+# define DN_MODIFY 0x00000002 /* File modified. */
2737	+# define DN_CREATE 0x00000004 /* File created. */
2738	+# define DN_DELETE 0x00000008 /* File removed. */
2739	+# define DN_RENAME 0x00000010 /* File renamed. */
2740	+# define DN_ATTRIB 0x00000020 /* File changed attibutes. */
2741	+# define DN_MULTISHOT 0x80000000 /* Don't remove notifier. */
2742	+#endif
2743	+
2744	+struct flock
2745	+ {
2746	+ short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */
2747	+ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */
2748	+#ifndef __USE_FILE_OFFSET64
2749	+ __off_t l_start; /* Offset where the lock begins. */
2750	+ __off_t l_len; /* Size of the locked area; zero means until EOF. */
2751	+#else
2752	+ __off64_t l_start; /* Offset where the lock begins. */
2753	+ __off64_t l_len; /* Size of the locked area; zero means until EOF. */
2754	+#endif
2755	+ __pid_t l_pid; /* Process holding the lock. */
2756	+ };
2757	+
2758	+#ifdef __USE_LARGEFILE64
2759	+struct flock64
2760	+ {
2761	+ short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */
2762	+ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */
2763	+ __off64_t l_start; /* Offset where the lock begins. */
2764	+ __off64_t l_len; /* Size of the locked area; zero means until EOF. */
2765	+ __pid_t l_pid; /* Process holding the lock. */
2766	+ };
2767	+#endif
2768	+
2769	+/* Define some more compatibility macros to be backward compatible with
2770	+ BSD systems which did not managed to hide these kernel macros. */
2771	+#ifdef __USE_BSD
2772	+# define FAPPEND O_APPEND
2773	+# define FFSYNC O_FSYNC
2774	+# define FASYNC O_ASYNC
2775	+# define FNONBLOCK O_NONBLOCK
2776	+# define FNDELAY O_NDELAY
2777	+#endif /* Use BSD. */
2778	+
2779	+/* Advise to `posix_fadvise'. */
2780	+#ifdef __USE_XOPEN2K
2781	+# define POSIX_FADV_NORMAL 0 /* No further special treatment. */
2782	+# define POSIX_FADV_RANDOM 1 /* Expect random page references. */
2783	+# define POSIX_FADV_SEQUENTIAL 2 /* Expect sequential page references. */
2784	+# define POSIX_FADV_WILLNEED 3 /* Will need these pages. */
2785	+# define POSIX_FADV_DONTNEED 4 /* Don't need these pages. */
2786	+# define POSIX_FADV_NOREUSE 5 /* Data will be accessed once. */
2787	+#endif
2788	+
2789	+#ifdef __USE_GNU
2790	+# define SYNC_FILE_RANGE_WAIT_BEFORE 1 /* Wait upon writeout of all pages
2791	+ in the range before performing the
2792	+ write. */
2793	+# define SYNC_FILE_RANGE_WRITE 2 /* Initiate writeout of all those
2794	+ dirty pages in the range which are
2795	+ not presently under writeback. */
2796	+# define SYNC_FILE_RANGE_WAIT_AFTER 4 /* Wait upon writeout of all pages in
2797	+ the range after performing the
2798	+ write. */
2799	+#endif
2800	+
2801	+__BEGIN_DECLS
2802	+
2803	+#ifdef __USE_GNU
2804	+
2805	+/* Provide kernel hint to read ahead. */
2806	+extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
2807	+ __THROW;
2808	+
2809	+/* Selective file content synch'ing. */
2810	+extern int sync_file_range (int __fd, __off64_t __from, __off64_t __to,
2811	+ unsigned int __flags);
2812	+
2813	+/* Splice address range into a pipe. */
2814	+extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
2815	+ size_t __count, unsigned int __flags);
2816	+
2817	+/* Splice two files together. */
2818	+extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
2819	+ __off64_t *__offout, size_t __len,
2820	+ unsigned int __flags);
2821	+
2822	+/* In-kernel implementation of tee for pipe buffers. */
2823	+extern ssize_t tee (int __fdin, int __fdout, size_t __len,
2824	+ unsigned int __flags);
2825	+
2826	+#endif
2827	+
2828	+__END_DECLS
2829	--- /dev/null
2830	+++ b/libc/sysdeps/linux/ubicom32/bits/kernel_stat.h
2831	@@ -0,0 +1,55 @@
2832	+#ifndef _BITS_STAT_STRUCT_H
2833	+#define _BITS_STAT_STRUCT_H
2834	+
2835	+#ifndef _LIBC
2836	+#error bits/kernel_stat.h is for internal uClibc use only!
2837	+#endif
2838	+
2839	+/* This file provides whatever this particular arch's kernel thinks
2840	+ * struct kernel_stat should look like... It turns out each arch has a
2841	+ * different opinion on the subject... */
2842	+
2843	+struct kernel_stat {
2844	+ unsigned short st_dev;
2845	+ unsigned short __pad1;
2846	+ unsigned long st_ino;
2847	+ unsigned short st_mode;
2848	+ unsigned short st_nlink;
2849	+ unsigned short st_uid;
2850	+ unsigned short st_gid;
2851	+ unsigned short st_rdev;
2852	+ unsigned short __pad2;
2853	+ unsigned long st_size;
2854	+ unsigned long st_blksize;
2855	+ unsigned long st_blocks;
2856	+ struct timespec st_atim;
2857	+ struct timespec st_mtim;
2858	+ struct timespec st_ctim;
2859	+ unsigned long __unused4;
2860	+ unsigned long __unused5;
2861	+};
2862	+
2863	+struct kernel_stat64 {
2864	+ unsigned char __pad0[6];
2865	+ unsigned short st_dev;
2866	+ unsigned char __pad1[4];
2867	+#define _HAVE_STAT64___ST_INO
2868	+ unsigned long __st_ino;
2869	+ unsigned int st_mode;
2870	+ unsigned int st_nlink;
2871	+ unsigned long st_uid;
2872	+ unsigned long st_gid;
2873	+ unsigned char __pad2[6];
2874	+ unsigned short st_rdev;
2875	+ unsigned char __pad3[4];
2876	+ long long st_size;
2877	+ unsigned long st_blksize;
2878	+ unsigned long st_blocks; /* Number 512-byte blocks allocated. */
2879	+ unsigned long __pad4; /* future possible st_blocks high bits */
2880	+ struct timespec st_atim;
2881	+ struct timespec st_mtim;
2882	+ struct timespec st_ctim;
2883	+ unsigned long long st_ino;
2884	+};
2885	+
2886	+#endif /* _BITS_STAT_STRUCT_H */
2887	--- /dev/null
2888	+++ b/libc/sysdeps/linux/ubicom32/bits/kernel_types.h
2889	@@ -0,0 +1,44 @@
2890	+/* Note that we use the exact same include guard #define names
2891	+ * as asm/posix_types.h. This will avoid gratuitous conflicts
2892	+ * with the posix_types.h kernel header, and will ensure that
2893	+ * our private content, and not the kernel header, will win.
2894	+ * -Erik
2895	+ */
2896	+#ifndef __ARCH_UBICOM32_POSIX_TYPES_H
2897	+#define __ARCH_UBICOM32_POSIX_TYPES_H
2898	+
2899	+typedef unsigned long __kernel_dev_t;
2900	+typedef unsigned long __kernel_ino_t;
2901	+typedef unsigned short __kernel_mode_t;
2902	+typedef unsigned short __kernel_nlink_t;
2903	+typedef long __kernel_off_t;
2904	+typedef int __kernel_pid_t;
2905	+typedef unsigned short __kernel_ipc_pid_t;
2906	+typedef unsigned short __kernel_uid_t;
2907	+typedef unsigned short __kernel_gid_t;
2908	+typedef unsigned int __kernel_size_t;
2909	+typedef int __kernel_ssize_t;
2910	+typedef int __kernel_ptrdiff_t;
2911	+typedef long __kernel_time_t;
2912	+typedef long __kernel_suseconds_t;
2913	+typedef long __kernel_clock_t;
2914	+typedef int __kernel_daddr_t;
2915	+typedef char * __kernel_caddr_t;
2916	+typedef unsigned short __kernel_uid16_t;
2917	+typedef unsigned short __kernel_gid16_t;
2918	+typedef unsigned int __kernel_uid32_t;
2919	+typedef unsigned int __kernel_gid32_t;
2920	+typedef unsigned short __kernel_old_uid_t;
2921	+typedef unsigned short __kernel_old_gid_t;
2922	+typedef unsigned short __kernel_old_dev_t;
2923	+typedef long long __kernel_loff_t;
2924	+
2925	+typedef struct {
2926	+#ifdef __USE_ALL
2927	+ int val[2];
2928	+#else
2929	+ int __val[2];
2930	+#endif
2931	+} __kernel_fsid_t;
2932	+
2933	+#endif /* __ARCH_UBICOM32_POSIX_TYPES_H */
2934	--- /dev/null
2935	+++ b/libc/sysdeps/linux/ubicom32/bits/mman.h
2936	@@ -0,0 +1,103 @@
2937	+/* Definitions for POSIX memory map interface. Linux/m68k version.
2938	+ Copyright (C) 1997, 2000, 2003, 2005 Free Software Foundation, Inc.
2939	+ This file is part of the GNU C Library.
2940	+
2941	+ The GNU C Library is free software; you can redistribute it and/or
2942	+ modify it under the terms of the GNU Lesser General Public
2943	+ License as published by the Free Software Foundation; either
2944	+ version 2.1 of the License, or (at your option) any later version.
2945	+
2946	+ The GNU C Library is distributed in the hope that it will be useful,
2947	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
2948	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2949	+ Lesser General Public License for more details.
2950	+
2951	+ You should have received a copy of the GNU Lesser General Public
2952	+ License along with the GNU C Library; if not, write to the Free
2953	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2954	+ 02111-1307 USA. */
2955	+
2956	+#ifndef _SYS_MMAN_H
2957	+# error "Never use <bits/mman.h> directly; include <sys/mman.h> instead."
2958	+#endif
2959	+
2960	+/* The following definitions basically come from the kernel headers.
2961	+ But the kernel header is not namespace clean. */
2962	+
2963	+
2964	+/* Protections are chosen from these bits, OR'd together. The
2965	+ implementation does not necessarily support PROT_EXEC or PROT_WRITE
2966	+ without PROT_READ. The only guarantees are that no writing will be
2967	+ allowed without PROT_WRITE and no access will be allowed for PROT_NONE. */
2968	+
2969	+#define PROT_READ 0x1 /* Page can be read. */
2970	+#define PROT_WRITE 0x2 /* Page can be written. */
2971	+#define PROT_EXEC 0x4 /* Page can be executed. */
2972	+#define PROT_NONE 0x0 /* Page can not be accessed. */
2973	+#define PROT_GROWSDOWN 0x01000000 /* Extend change to start of
2974	+ growsdown vma (mprotect only). */
2975	+#define PROT_GROWSUP 0x02000000 /* Extend change to start of
2976	+ growsup vma (mprotect only). */
2977	+
2978	+/* Sharing types (must choose one and only one of these). */
2979	+#define MAP_SHARED 0x01 /* Share changes. */
2980	+#define MAP_PRIVATE 0x02 /* Changes are private. */
2981	+#ifdef __USE_MISC
2982	+# define MAP_TYPE 0x0f /* Mask for type of mapping. */
2983	+#endif
2984	+
2985	+/* Other flags. */
2986	+#define MAP_FIXED 0x10 /* Interpret addr exactly. */
2987	+#ifdef __USE_MISC
2988	+# define MAP_FILE 0
2989	+# define MAP_ANONYMOUS 0x20 /* Don't use a file. */
2990	+# define MAP_ANON MAP_ANONYMOUS
2991	+#endif
2992	+
2993	+/* These are Linux-specific. */
2994	+#ifdef __USE_MISC
2995	+# define MAP_GROWSDOWN 0x0000100 /* Stack-like segment. */
2996	+# define MAP_DENYWRITE 0x0000800 /* ETXTBSY */
2997	+# define MAP_EXECUTABLE 0x0001000 /* Mark it as an executable. */
2998	+# define MAP_LOCKED 0x0002000 /* Lock the mapping. */
2999	+# define MAP_NORESERVE 0x0004000 /* Don't check for reservations. */
3000	+# define MAP_POPULATE 0x0008000 /* Populate (prefault) pagetables. */
3001	+# define MAP_NONBLOCK 0x0010000 /* Do not block on IO. */
3002	+# define MAP_UNINITIALIZE 0x4000000 /* For anonymous mmap, memory could be uninitialized. */
3003	+#endif
3004	+
3005	+/* Flags to `msync'. */
3006	+#define MS_ASYNC 1 /* Sync memory asynchronously. */
3007	+#define MS_SYNC 4 /* Synchronous memory sync. */
3008	+#define MS_INVALIDATE 2 /* Invalidate the caches. */
3009	+
3010	+/* Flags for `mlockall'. */
3011	+#define MCL_CURRENT 1 /* Lock all currently mapped pages. */
3012	+#define MCL_FUTURE 2 /* Lock all additions to address
3013	+ space. */
3014	+
3015	+/* Flags for `mremap'. */
3016	+#ifdef __USE_GNU
3017	+# define MREMAP_MAYMOVE 1
3018	+# define MREMAP_FIXED 2
3019	+#endif
3020	+
3021	+/* Advice to `madvise'. */
3022	+#ifdef __USE_BSD
3023	+# define MADV_NORMAL 0 /* No further special treatment. */
3024	+# define MADV_RANDOM 1 /* Expect random page references. */
3025	+# define MADV_SEQUENTIAL 2 /* Expect sequential page references. */
3026	+# define MADV_WILLNEED 3 /* Will need these pages. */
3027	+# define MADV_DONTNEED 4 /* Don't need these pages. */
3028	+# define MADV_DONTFORK 10 /* Do not inherit across fork. */
3029	+# define MADV_DOFORK 11 /* Do inherit across fork. */
3030	+#endif
3031	+
3032	+/* The POSIX people had to invent similar names for the same things. */
3033	+#ifdef __USE_XOPEN2K
3034	+# define POSIX_MADV_NORMAL 0 /* No further special treatment. */
3035	+# define POSIX_MADV_RANDOM 1 /* Expect random page references. */
3036	+# define POSIX_MADV_SEQUENTIAL 2 /* Expect sequential page references. */
3037	+# define POSIX_MADV_WILLNEED 3 /* Will need these pages. */
3038	+# define POSIX_MADV_DONTNEED 4 /* Don't need these pages. */
3039	+#endif
3040	--- /dev/null
3041	+++ b/libc/sysdeps/linux/ubicom32/bits/setjmp.h
3042	@@ -0,0 +1,52 @@
3043	+/* Define the machine-dependent type `jmp_buf'. Ubicom32 version.
3044	+ Copyright (C) 1992,93,95,97,2000 Free Software Foundation, Inc.
3045	+ This file is part of the GNU C Library.
3046	+
3047	+ The GNU C Library is free software; you can redistribute it and/or
3048	+ modify it under the terms of the GNU Lesser General Public
3049	+ License as published by the Free Software Foundation; either
3050	+ version 2.1 of the License, or (at your option) any later version.
3051	+
3052	+ The GNU C Library is distributed in the hope that it will be useful,
3053	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
3054	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3055	+ Lesser General Public License for more details.
3056	+
3057	+ You should have received a copy of the GNU Lesser General Public
3058	+ License along with the GNU C Library; if not, write to the Free
3059	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3060	+ 02111-1307 USA. */
3061	+
3062	+#ifndef _BITS_SETJMP_H
3063	+#define _BITS_SETJMP_H 1
3064	+
3065	+#if !defined _SETJMP_H && !defined _PTHREAD_H
3066	+# error "Never include <bits/setjmp.h> directly; use <setjmp.h> instead."
3067	+#endif
3068	+
3069	+#ifndef _ASM
3070	+/*
3071	+ * This is the structure where we are going to save D10-D13, A0, A1, A2, A5, A6 and SP(A7).
3072	+ * A5 is the return address. Call to setjmp will save these. Call to longjmp will return
3073	+ * Control to the address in A5.
3074	+ */
3075	+typedef struct setjmp_save_struct {
3076	+ unsigned long d10; /* D10 */
3077	+ unsigned long d11; /* D11 */
3078	+ unsigned long d12; /* D12 */
3079	+ unsigned long d13; /* D13 */
3080	+ unsigned long a1; /* A1 */
3081	+ unsigned long a2; /* A2 */
3082	+ unsigned long a5; /* A5 return address. */
3083	+ unsigned long a6; /* A6 */
3084	+ unsigned long sp; /* A7 stack pointer. */
3085	+} __jmp_buf[1];
3086	+
3087	+#endif
3088	+
3089	+/* Test if longjmp to JMPBUF would unwind the frame
3090	+ containing a local variable at ADDRESS. */
3091	+#define _JMPBUF_UNWINDS(jmpbuf, address) \
3092	+ ((void ) (address) < (void)(jmpbuf)->sp)
3093	+
3094	+#endif /* bits/setjmp.h */
3095	--- /dev/null
3096	+++ b/libc/sysdeps/linux/ubicom32/bits/stackinfo.h
3097	@@ -0,0 +1,28 @@
3098	+/* Copyright (C) 1999 Free Software Foundation, Inc.
3099	+ This file is part of the GNU C Library.
3100	+
3101	+ The GNU C Library is free software; you can redistribute it and/or
3102	+ modify it under the terms of the GNU Lesser General Public
3103	+ License as published by the Free Software Foundation; either
3104	+ version 2.1 of the License, or (at your option) any later version.
3105	+
3106	+ The GNU C Library is distributed in the hope that it will be useful,
3107	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
3108	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3109	+ Lesser General Public License for more details.
3110	+
3111	+ You should have received a copy of the GNU Lesser General Public
3112	+ License along with the GNU C Library; if not, write to the Free
3113	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3114	+ 02111-1307 USA. */
3115	+
3116	+/* This file contains a bit of information about the stack allocation
3117	+ of the processor. */
3118	+
3119	+#ifndef _STACKINFO_H
3120	+#define _STACKINFO_H 1
3121	+
3122	+/* On Ubicom32 the stack grows down. */
3123	+#define _STACK_GROWS_DOWN 1
3124	+
3125	+#endif /* stackinfo.h */
3126	--- /dev/null
3127	+++ b/libc/sysdeps/linux/ubicom32/bits/syscalls.h
3128	@@ -0,0 +1,81 @@
3129	+#ifndef _BITS_SYSCALLS_H
3130	+#define _BITS_SYSCALLS_H
3131	+#ifndef _SYSCALL_H
3132	+# error "Never use <bits/syscalls.h> directly; include <sys/syscall.h> instead."
3133	+#endif
3134	+
3135	+/* m68k headers does stupid stuff with __NR_iopl / __NR_vm86:
3136	+ * #define __NR_iopl not supported
3137	+ * #define __NR_vm86 not supported
3138	+ */
3139	+#undef __NR_iopl
3140	+#undef __NR_vm86
3141	+
3142	+#ifndef __ASSEMBLER__
3143	+
3144	+#include <errno.h>
3145	+
3146	+/* Linux takes system call arguments in registers:
3147	+
3148	+ syscall number %d8
3149	+ arg 1 %d0
3150	+ arg 2 %d1
3151	+ arg 3 %d2
3152	+ arg 4 %d3
3153	+ arg 5 %d4
3154	+ arg 6 %d5
3155	+*/
3156	+
3157	+#define __loadargs_0(name, dummy) \
3158	+ d8 = (long int)name
3159	+
3160	+#define __loadargs_1(name, __arg1) \
3161	+ __loadargs_0(name, 0); \
3162	+ d0_retval = (long int) __arg1
3163	+
3164	+#define __loadargs_2(name, __arg1, __arg2) \
3165	+ __loadargs_1(name, __arg1); \
3166	+ d1 = (long int) __arg2
3167	+
3168	+#define __loadargs_3(name, __arg1, __arg2, __arg3) \
3169	+ __loadargs_2(name, __arg1, __arg2); \
3170	+ d2 = (long int) __arg3
3171	+
3172	+#define __loadargs_4(name, __arg1, __arg2, __arg3, __arg4) \
3173	+ __loadargs_3(name, __arg1, __arg2, __arg3); \
3174	+ d3 = (long int)__arg4
3175	+
3176	+#define __loadargs_5(name, __arg1, __arg2, __arg3, __arg4, __arg5) \
3177	+ __loadargs_4(name, __arg1, __arg2, __arg3, __arg4); \
3178	+ d4 = (long int)__arg5
3179	+
3180	+#define __loadargs_6(name, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
3181	+ __loadargs_5(name, __arg1, __arg2, __arg3, __arg4, __arg5); \
3182	+ d5 = (long int)__arg6
3183	+
3184	+#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
3185	+({ \
3186	+ register long int d0_retval __asm__ ("d0"); \
3187	+ register long int d1 __asm__ ("d1"); \
3188	+ register long int d2 __asm__ ("d2"); \
3189	+ register long int d3 __asm__ ("d3"); \
3190	+ register long int d4 __asm__ ("d4"); \
3191	+ register long int d5 __asm__ ("d5"); \
3192	+ register long int d8 __asm__ ("d8"); \
3193	+ __loadargs_##nr (name, args); \
3194	+ __asm__ __volatile__ ( \
3195	+ " moveai a5, #%%hi(0x40400000)\n\t" \
3196	+ " calli a5, 16(a5)\n\t" \
3197	+ : "+r" (d0_retval), "+r" (d1), "+r" (d2), "+r" (d3), \
3198	+ "+r" (d4), "+r" (d5), "+r" (d8) : \
3199	+ : "cc", "memory", \
3200	+ "acc0_lo", "acc0_hi", "acc1_lo", "acc1_hi", \
3201	+ "source3", \
3202	+ "a0", "a3", "a4", "a5", \
3203	+ "d6", "d7", "d9", "d14", "d15" \
3204	+ ); \
3205	+ d0_retval; \
3206	+})
3207	+
3208	+#endif /* __ASSEMBLER__ */
3209	+#endif /* _BITS_SYSCALLS_H */
3210	--- /dev/null
3211	+++ b/libc/sysdeps/linux/ubicom32/bits/uClibc_arch_features.h
3212	@@ -0,0 +1,45 @@
3213	+/*
3214	+ * Track misc arch-specific features that aren't config options
3215	+ */
3216	+
3217	+#ifndef _BITS_UCLIBC_ARCH_FEATURES_H
3218	+#define _BITS_UCLIBC_ARCH_FEATURES_H
3219	+
3220	+/* instruction used when calling abort() to kill yourself */
3221	+/#define __UCLIBC_ABORT_INSTRUCTION__ "asm instruction"/
3222	+#undef __UCLIBC_ABORT_INSTRUCTION__
3223	+
3224	+/* can your target use syscall6() for mmap ? */
3225	+#undef __UCLIBC_MMAP_HAS_6_ARGS__
3226	+
3227	+/* does your target use syscall4() for truncate64 ? (32bit arches only) */
3228	+#undef __UCLIBC_TRUNCATE64_HAS_4_ARGS__
3229	+
3230	+/* does your target have a broken create_module() ? */
3231	+#undef __UCLIBC_BROKEN_CREATE_MODULE__
3232	+
3233	+/* does your target have to worry about older [gs]etrlimit() ? */
3234	+#undef __UCLIBC_HANDLE_OLDER_RLIMIT__
3235	+
3236	+/* does your target prefix all symbols with an _ ? */
3237	+#define __UCLIBC_NO_UNDERSCORES__
3238	+
3239	+/* does your target have an asm .set ? */
3240	+#define __UCLIBC_HAVE_ASM_SET_DIRECTIVE__
3241	+
3242	+/* define if target doesn't like .global */
3243	+#undef __UCLIBC_ASM_GLOBAL_DIRECTIVE__
3244	+
3245	+/* define if target supports .weak */
3246	+#define __UCLIBC_HAVE_ASM_WEAK_DIRECTIVE__
3247	+
3248	+/* define if target supports .weakext */
3249	+#undef __UCLIBC_HAVE_ASM_WEAKEXT_DIRECTIVE__
3250	+
3251	+/* needed probably only for ppc64 */
3252	+#undef __UCLIBC_HAVE_ASM_GLOBAL_DOT_NAME__
3253	+
3254	+/* define if target supports IEEE signed zero floats */
3255	+#define __UCLIBC_HAVE_SIGNED_ZERO__
3256	+
3257	+#endif /* _BITS_UCLIBC_ARCH_FEATURES_H */
3258	--- /dev/null
3259	+++ b/libc/sysdeps/linux/ubicom32/bits/wordsize.h
3260	@@ -0,0 +1,19 @@
3261	+/* Copyright (C) 1999 Free Software Foundation, Inc.
3262	+ This file is part of the GNU C Library.
3263	+
3264	+ The GNU C Library is free software; you can redistribute it and/or
3265	+ modify it under the terms of the GNU Lesser General Public
3266	+ License as published by the Free Software Foundation; either
3267	+ version 2.1 of the License, or (at your option) any later version.
3268	+
3269	+ The GNU C Library is distributed in the hope that it will be useful,
3270	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
3271	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3272	+ Lesser General Public License for more details.
3273	+
3274	+ You should have received a copy of the GNU Lesser General Public
3275	+ License along with the GNU C Library; if not, write to the Free
3276	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3277	+ 02111-1307 USA. */
3278	+
3279	+#define __WORDSIZE 32
3280	--- /dev/null
3281	+++ b/libc/sysdeps/linux/ubicom32/clone.S
3282	@@ -0,0 +1,71 @@
3283	+#include <sys/syscall.h>
3284	+
3285	+ .global __syscall_error
3286	+
3287	+/* int _clone(int (fn)(void arg), void child_stack, int flags, void arg); */
3288	+ .text
3289	+ .type clone,@function
3290	+ .global clone
3291	+clone:
3292	+ /* Sanity check arguments. */
3293	+ sub.4 #0, #0, d0 /* Test if fn is zero. */
3294	+ jmpeq.f 1f /* arg bad */
3295	+ sub.4 #0, #0, d1 /* Test if child_stack is zero. */
3296	+ jmpeq.f 1f /* arg bad */
3297	+
3298	+ /* Set up child_stack frame.. arg and fn */
3299	+ move.4 a3, d1
3300	+ move.4 -4(a3)++, d3 /* push 'arg' to child stack */
3301	+ move.4 -4(a3)++, d0 /* push fn to child stack, this will become a5
3302	+ * on new child */
3303	+ move.4 d1, a3
3304	+ move.4 -4(sp)++, a5 /* push a5 to our stack */
3305	+
3306	+ /*
3307	+ * The syscall clone is clone(int flags, void *child_stack) so we set
3308	+ * that up now
3309	+ */
3310	+ move.4 d0, d2 /* Move flags to d0 */
3311	+
3312	+ /* Do Clone syscall */
3313	+ movei d8, #__NR_clone
3314	+ moveai a5, #%hi(0x40400000)
3315	+ calli a5, 0x10(a5)
3316	+ move.4 a5, (sp)4++ /* pop a5 from stack */
3317	+
3318	+ /* Clone Complete */
3319	+ cmpi d0, #0 /* Test if d0 is less than zero. If it is we
3320	+ * return the error */
3321	+ jmplt.f 2f /* If return is less than we had an error */
3322	+ jmpeq.f 3f /* If return is 0 we are in the clone, jump to
3323	+ * thread start */
3324	+ ret a5 /* d0 is pid */
3325	+
3326	+ /* Invalid Value */
3327	+1: movei d0, #-22 /* EINVAL */
3328	+
3329	+ /* Call syscall Error */
3330	+2: sub.4 d0, #0, d0 /* d0 = -d0 */
3331	+#if defined(__UBICOM32_FDPIC__)
3332	+ call a3, __syscall_error
3333	+#else
3334	+ moveai a3, #%hi(__syscall_error)
3335	+ calli a3, %lo(__syscall_error)(a3)
3336	+#endif
3337	+ /* Child Thread Start */
3338	+3:
3339	+#if defined(__UBICOM32_FDPIC__)
3340	+ /* a5 actually contains a function descriptor for fdpic */
3341	+ move.4 a0, 4(a5) /* set GOT for this function */
3342	+ move.4 a5, 0(a5) /* get address of entry point */
3343	+#endif
3344	+ move.4 d0, (sp)4++ /* pop 'arg' to stack */
3345	+ calli a5, 0(a5)
3346	+ movei d8, #__NR_exit
3347	+ moveai a3, #%hi(0x40400000)
3348	+ calli a3, 0x10(a3)
3349	+
3350	+ .size clone, . - clone
3351	+ .global __GI_clone
3352	+ .hidden __GI_clone
3353	+ .set __GI_clone,clone
3354	--- /dev/null
3355	+++ b/libc/sysdeps/linux/ubicom32/crt1.S
3356	@@ -0,0 +1,179 @@
3357	+/* Startup code compliant to the ELF m68k ABI.
3358	+ Copyright (C) 1996, 1997, 1998, 2001, 2002 Free Software Foundation, Inc.
3359	+ This file is part of the GNU C Library.
3360	+
3361	+ The GNU C Library is free software; you can redistribute it and/or
3362	+ modify it under the terms of the GNU Lesser General Public
3363	+ License as published by the Free Software Foundation; either
3364	+ version 2.1 of the License, or (at your option) any later version.
3365	+
3366	+ In addition to the permissions in the GNU Lesser General Public
3367	+ License, the Free Software Foundation gives you unlimited
3368	+ permission to link the compiled version of this file with other
3369	+ programs, and to distribute those programs without any restriction
3370	+ coming from the use of this file. (The GNU Lesser General Public
3371	+ License restrictions do apply in other respects; for example, they
3372	+ cover modification of the file, and distribution when not linked
3373	+ into another program.)
3374	+
3375	+ Note that people who make modified versions of this file are not
3376	+ obligated to grant this special exception for their modified
3377	+ versions; it is their choice whether to do so. The GNU Lesser
3378	+ General Public License gives permission to release a modified
3379	+ version without this exception; this exception also makes it
3380	+ possible to release a modified version which carries forward this
3381	+ exception.
3382	+
3383	+ The GNU C Library is distributed in the hope that it will be useful,
3384	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
3385	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3386	+ Lesser General Public License for more details.
3387	+
3388	+ You should have received a copy of the GNU Lesser General Public
3389	+ License along with the GNU C Library; if not, write to the Free
3390	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3391	+ 02111-1307 USA. */
3392	+
3393	+#include <features.h>
3394	+
3395	+/* This is the canonical entry point, usually the first thing in the text
3396	+ segment. The SVR4/m68k ABI says that when the entry point runs,
3397	+ most registers' values are unspecified, except for:
3398	+
3399	+ %a1 Contains a function pointer to be registered with `atexit'.
3400	+ This is how the dynamic linker arranges to have DT_FINI
3401	+ functions called for shared libraries that have been loaded
3402	+ before this code runs.
3403	+
3404	+ %sp The stack contains the arguments and environment:
3405	+ 0(%sp) argc
3406	+ 4(%sp) argv[0]
3407	+ ...
3408	+ (4*argc)(%sp) NULL
3409	+ (4*(argc+1))(%sp) envp[0]
3410	+ ...
3411	+ NULL
3412	+
3413	+ The uclinux conventions are different. %a1 is not defined on entry
3414	+ and the stack is laid out as follows:
3415	+
3416	+ 0(%sp) argc
3417	+ 4(%sp) argv
3418	+ 8(%sp) envp
3419	+*/
3420	+
3421	+
3422	+ .text
3423	+ .type main,@function
3424	+ .type _init,%function
3425	+ .type _fini,%function
3426	+#ifndef __UCLIBC_CTOR_DTOR__
3427	+ .weak _init
3428	+ .weak _fini
3429	+#endif
3430	+ .globl _start
3431	+ .global __uClibc_main;
3432	+ .type __uClibc_main,@function;
3433	+ .type _start,@function
3434	+_start:
3435	+
3436	+#if defined(__UBICOM32_FDPIC__) && !defined(L_Scrt1)
3437	+ /* P0 contains a pointer to the program's load map. */
3438	+ call a3, .Lcall;
3439	+.Lcall:
3440	+ move.4 d0, d1 ; load exec_map_addr
3441	+ moveai a4, #%hi(.Lcall)
3442	+ lea.1 d15, %lo(.Lcall)(a4)
3443	+ sub.4 d15, a3, d15 ; difference between .Lcall and actual address of .Lcall
3444	+ moveai a3, #%hi(__ROFIXUP_LIST__)
3445	+ lea.1 d1, %lo(__ROFIXUP_LIST__)(a3)
3446	+ moveai a3, #%hi(__ROFIXUP_END__)
3447	+ lea.1 d2, %lo(__ROFIXUP_END__)(a3)
3448	+ add.4 d1, d1, d15
3449	+ add.4 d2, d2, d15
3450	+ call a5, __self_reloc ; returns GOT in d0
3451	+ move.4 a0, d0 ; set GOT
3452	+#endif
3453	+
3454	+/*
3455	+ all this is setup to make the following call.
3456	+
3457	+ void __uClibc_main(
3458	+ d0 - int (main)(int, char , char *),
3459	+ d1 - int argc, (d1)
3460	+ d2 - char **argv,
3461	+ d3 - void (*app_init)(void),
3462	+ d4 - void (*app_fini)(void),
3463	+ d5 - void (*rtld_fini)(void),
3464	+ d6 - void *stack_end
3465	+ );
3466	+ */
3467	+
3468	+ /*
3469	+ * Load pointer to main into d0
3470	+ */
3471	+#ifdef __UBICOM32_FDPIC__
3472	+ movei d0, #%got_funcdesc_lo(main)
3473	+ move.4 d0, (a0, d0)
3474	+#else
3475	+ moveai a3, #%hi(main)
3476	+ lea.1 d0, %lo(main)(a3)
3477	+#endif
3478	+
3479	+ /*
3480	+ * Grab the environment stuff from stack and set up d1, d2 with it.
3481	+ */
3482	+ move.4 d1, (sp)
3483	+#ifdef __UBICOM32_FDPIC__
3484	+ /* For FDPIC the calling convention is different than flat */
3485	+ lea.1 d2, 4(sp)
3486	+#else
3487	+ move.4 d2, 4(sp)
3488	+#endif
3489	+
3490	+#ifdef __UCLIBC_CTOR_DTOR__
3491	+ /*
3492	+ * Load pointer to _init into d3
3493	+ */
3494	+#ifdef __UBICOM32_FDPIC__
3495	+ movei d3, #%got_funcdesc_lo(_init)
3496	+ move.4 d3, (a0, d3)
3497	+#else
3498	+ moveai a3, #%hi(_init)
3499	+ lea.1 d3, %lo(_init)(a3)
3500	+#endif
3501	+
3502	+ /*
3503	+ * Load pointer to _fini into d4
3504	+ */
3505	+#ifdef __UBICOM32_FDPIC__
3506	+ movei d4, #%got_funcdesc_lo(_fini)
3507	+ move.4 d4, (a0, d4)
3508	+#else
3509	+ moveai a3, #%hi(_fini)
3510	+ lea.1 d4, %lo(_fini)(a3)
3511	+#endif
3512	+
3513	+#else /* !__UCLIBC_CTOR_DTOR__ */
3514	+ move.4 d3, #0 ; _init
3515	+ move.4 d4, #0 ; _fini
3516	+#endif
3517	+
3518	+#ifdef __UBICOM32_FDPIC__
3519	+ move.4 d5, a1 ; ldso _fini funcdesc (see dl-startup.h)
3520	+#else
3521	+ movei d5, #0 ; rtld_fini (not used)
3522	+#endif
3523	+
3524	+ move.4 d6, sp ; Stack End.
3525	+
3526	+ /* Call the user's main function, and exit with its value. But
3527	+ let the libc call main. */
3528	+#ifdef __UBICOM32_FDPIC__
3529	+ call a5, __uClibc_main
3530	+#else
3531	+ moveai a5, #%hi(__uClibc_main)
3532	+ calli a5, %lo(__uClibc_main)(a5)
3533	+#endif
3534	+
3535	+ bkpt #-1 ; Crash if somehow `exit' does return.
3536	--- /dev/null
3537	+++ b/libc/sysdeps/linux/ubicom32/crti.S
3538	@@ -0,0 +1,54 @@
3539	+/* Specialized code needed to support construction and destruction of
3540	+ file-scope objects in C++ and Java code, and to support exception handling.
3541	+ Copyright (C) 1999 Free Software Foundation, Inc.
3542	+ Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca).
3543	+
3544	+This file is part of GCC.
3545	+
3546	+GCC is free software; you can redistribute it and/or modify
3547	+it under the terms of the GNU General Public License as published by
3548	+the Free Software Foundation; either version 2, or (at your option)
3549	+any later version.
3550	+
3551	+GCC is distributed in the hope that it will be useful,
3552	+but WITHOUT ANY WARRANTY; without even the implied warranty of
3553	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3554	+GNU General Public License for more details.
3555	+
3556	+You should have received a copy of the GNU General Public License
3557	+along with GCC; see the file COPYING. If not, write to
3558	+the Free Software Foundation, 59 Temple Place - Suite 330,
3559	+Boston, MA 02111-1307, USA. */
3560	+
3561	+/* As a special exception, if you link this library with files
3562	+ compiled with GCC to produce an executable, this does not cause
3563	+ the resulting executable to be covered by the GNU General Public License.
3564	+ This exception does not however invalidate any other reasons why
3565	+ the executable file might be covered by the GNU General Public License. */
3566	+
3567	+/*
3568	+ * This file just supplies function prologues for the .init and .fini
3569	+ * sections. It is linked in before crtbegin.o.
3570	+ */
3571	+ .file "crti.o"
3572	+ .ident "GNU C crti.o"
3573	+
3574	+ .section .init
3575	+ .align 2
3576	+ .globl _init
3577	+ .type _init, @function
3578	+_init:
3579	+ move.4 -4(sp)++, a5
3580	+#ifdef __UBICOM32_FDPIC__
3581	+ move.4 -4(sp)++, a0
3582	+#endif
3583	+
3584	+ .section .fini
3585	+ .align 2
3586	+ .globl _fini
3587	+ .type _fini, @function
3588	+_fini:
3589	+ move.4 -4(sp)++, a5
3590	+#ifdef __UBICOM32_FDPIC__
3591	+ move.4 -4(sp)++, a0
3592	+#endif
3593	--- /dev/null
3594	+++ b/libc/sysdeps/linux/ubicom32/crtn.S
3595	@@ -0,0 +1,47 @@
3596	+/* Specialized code needed to support construction and destruction of
3597	+ file-scope objects in C++ and Java code, and to support exception handling.
3598	+ Copyright (C) 1999 Free Software Foundation, Inc.
3599	+ Contributed by Charles-Antoine Gauthier (charles.gauthier@iit.nrc.ca).
3600	+
3601	+This file is part of GCC.
3602	+
3603	+GCC is free software; you can redistribute it and/or modify
3604	+it under the terms of the GNU General Public License as published by
3605	+the Free Software Foundation; either version 2, or (at your option)
3606	+any later version.
3607	+
3608	+GCC is distributed in the hope that it will be useful,
3609	+but WITHOUT ANY WARRANTY; without even the implied warranty of
3610	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3611	+GNU General Public License for more details.
3612	+
3613	+You should have received a copy of the GNU General Public License
3614	+along with GCC; see the file COPYING. If not, write to
3615	+the Free Software Foundation, 59 Temple Place - Suite 330,
3616	+Boston, MA 02111-1307, USA. */
3617	+
3618	+/* As a special exception, if you link this library with files
3619	+ compiled with GCC to produce an executable, this does not cause
3620	+ the resulting executable to be covered by the GNU General Public License.
3621	+ This exception does not however invalidate any other reasons why
3622	+ the executable file might be covered by the GNU General Public License. */
3623	+
3624	+/*
3625	+ * This file supplies function epilogues for the .init and .fini sections.
3626	+ * It is linked in after all other files.
3627	+ */
3628	+
3629	+ .file "crtn.o"
3630	+ .ident "GNU C crtn.o"
3631	+
3632	+ .section .init
3633	+#ifdef __UBICOM32_FDPIC__
3634	+ move.4 a0, (sp)4++
3635	+#endif
3636	+ ret (sp)4++
3637	+
3638	+ .section .fini
3639	+#ifdef __UBICOM32_FDPIC__
3640	+ move.4 a0, (sp)4++
3641	+#endif
3642	+ ret (sp)4++
3643	--- /dev/null
3644	+++ b/libc/sysdeps/linux/ubicom32/crtreloc.c
3645	@@ -0,0 +1,145 @@
3646	+/* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3647	+ written by Alexandre Oliva <aoliva@redhat.com>
3648	+This file is part of the GNU C Library.
3649	+
3650	+The GNU C Library is free software; you can redistribute it and/or
3651	+modify it under the terms of the GNU Lesser General Public License as
3652	+published by the Free Software Foundation; either version 2.1 of the
3653	+License, or (at your option) any later version.
3654	+
3655	+In addition to the permissions in the GNU Lesser General Public
3656	+License, the Free Software Foundation gives you unlimited
3657	+permission to link the compiled version of this file with other
3658	+programs, and to distribute those programs without any restriction
3659	+coming from the use of this file. (The GNU Lesser General Public
3660	+License restrictions do apply in other respects; for example, they
3661	+cover modification of the file, and distribution when not linked
3662	+into another program.)
3663	+
3664	+The GNU C Library is distributed in the hope that it will be useful,
3665	+but WITHOUT ANY WARRANTY; without even the implied warranty of
3666	+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3667	+Library General Public License for more details.
3668	+
3669	+You should have received a copy of the GNU Lesser General Public
3670	+License along with the GNU C Library; see the file COPYING.LIB. If
3671	+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
3672	+Cambridge, MA 02139, USA. */
3673	+
3674	+#ifdef __UBICOM32_FDPIC__
3675	+
3676	+#include <sys/types.h>
3677	+#include <link.h>
3678	+
3679	+/* This file is to be compiled into crt object files, to enable
3680	+ executables to easily self-relocate. */
3681	+
3682	+union word {
3683	+ char c[4];
3684	+ void *v;
3685	+};
3686	+
3687	+/* Compute the runtime address of pointer in the range [p,e), and then
3688	+ map the pointer pointed by it. */
3689	+static __always_inline void ***
3690	+reloc_range_indirect (void *p, void *e,
3691	+ const struct elf32_fdpic_loadmap *map)
3692	+{
3693	+ while (p < e)
3694	+ {
3695	+ if (p != (void *)-1)
3696	+ {
3697	+ void ptr = __reloc_pointer (p, map);
3698	+ if (ptr != (void *)-1)
3699	+ {
3700	+ void *pt;
3701	+ if ((long)ptr & 3)
3702	+ {
3703	+ unsigned char *c = ptr;
3704	+ int i;
3705	+ unsigned long v = 0;
3706	+ for (i = 0; i < 4; i++)
3707	+ v \|= c[i] << 8 * i;
3708	+ pt = (void *)v;
3709	+ }
3710	+ else
3711	+ pt = (void*)ptr;
3712	+ pt = __reloc_pointer (pt, map);
3713	+ if ((long)ptr & 3)
3714	+ {
3715	+ unsigned char *c = ptr;
3716	+ int i;
3717	+ unsigned long v = (unsigned long)pt;
3718	+ for (i = 0; i < 4; i++, v >>= 8)
3719	+ c[i] = v;
3720	+ }
3721	+ else
3722	+ (void*)ptr = pt;
3723	+ }
3724	+ }
3725	+ p++;
3726	+ }
3727	+ return p;
3728	+}
3729	+
3730	+/* Call __reloc_range_indirect for the given range except for the last
3731	+ entry, whose contents are only relocated. It's expected to hold
3732	+ the GOT value. */
3733	+void* attribute_hidden
3734	+__self_reloc (const struct elf32_fdpic_loadmap *map,
3735	+ void *p, void *e)
3736	+{
3737	+ p = reloc_range_indirect (p, e-1, map);
3738	+
3739	+ if (p >= e)
3740	+ return (void*)-1;
3741	+
3742	+ return __reloc_pointer (*p, map);
3743	+}
3744	+
3745	+#if 0
3746	+/* These are other functions that might be useful, but that we don't
3747	+ need. */
3748	+
3749	+/* Remap pointers in [p,e). */
3750	+static __always_inline void**
3751	+reloc_range (void p, void e,
3752	+ const struct elf32_fdpic_loadmap *map)
3753	+{
3754	+ while (p < e)
3755	+ {
3756	+ p = __reloc_pointer (p, map);
3757	+ p++;
3758	+ }
3759	+ return p;
3760	+}
3761	+
3762	+/* Remap p, adjust e by the same offset, then map the pointers in the
3763	+ range determined by them. */
3764	+void attribute_hidden
3765	+__reloc_range (const struct elf32_fdpic_loadmap *map,
3766	+ void p, void e)
3767	+{
3768	+ void **old = p;
3769	+
3770	+ p = __reloc_pointer (p, map);
3771	+ e += p - old;
3772	+ reloc_range (p, e, map);
3773	+}
3774	+
3775	+/* Remap p, adjust e by the same offset, then map pointers referenced
3776	+ by the (unadjusted) pointers in the range. Return the relocated
3777	+ value of the last pointer in the range. */
3778	+void* attribute_hidden
3779	+__reloc_range_indirect (const struct elf32_fdpic_loadmap *map,
3780	+ void *p, void *e)
3781	+{
3782	+ void ***old = p;
3783	+
3784	+ p = __reloc_pointer (p, map);
3785	+ e += p - old;
3786	+ return reloc_range_indirect (p, e, map);
3787	+}
3788	+#endif
3789	+
3790	+#endif /* __UBICOM32_FDPIC__ */
3791	--- /dev/null
3792	+++ b/libc/sysdeps/linux/ubicom32/setjmp.S
3793	@@ -0,0 +1,72 @@
3794	+/* Setjmp for Ubicom32 */
3795	+ .text
3796	+ .global _setjmp
3797	+ .type _setjmp,@function
3798	+_setjmp:
3799	+ movea a3, d0 ; A3 now holds the jmp buf that was passed in.
3800	+ move.4 (a3)4++, d10
3801	+ move.4 (a3)4++, d11
3802	+ move.4 (a3)4++, d12
3803	+ move.4 (a3)4++, d13
3804	+ move.4 (a3)4++, a1
3805	+ move.4 (a3)4++, a2
3806	+ move.4 (a3)4++, a5
3807	+ move.4 (a3)4++, a6
3808	+ move.4 (a3)4++, a7
3809	+ move.4 d0, #0
3810	+
3811	+ calli a5, 0(a5)
3812	+ .size _setjmp, . - _setjmp
3813	+
3814	+/*
3815	+ * __sigsetjmp for Ubicom32
3816	+ * d0 holds sigjmp_buf and d1 holds the savemask. We will save the frame and then just call __sigjmp_save to do the mask save.
3817	+ */
3818	+ .global __sigsetjmp
3819	+ .type __sigsetjmp,@function
3820	+__sigsetjmp:
3821	+ movea a3, d0 ; A3 now holds the jmp buf that was passed in.
3822	+ move.4 (a3)4++, d10
3823	+ move.4 (a3)4++, d11
3824	+ move.4 (a3)4++, d12
3825	+ move.4 (a3)4++, d13
3826	+ move.4 (a3)4++, a1
3827	+ move.4 (a3)4++, a2
3828	+ move.4 (a3)4++, a5
3829	+ move.4 (a3)4++, a6
3830	+ move.4 (a3)4++, a7
3831	+
3832	+ ;; The frame has been saved. Call _sigjmp_save to get sigmask saved. a5 still has the return address and it will go back to that.
3833	+#if defined(__UBICOM32_FDPIC__)
3834	+ call a3, __sigjmp_save
3835	+#else
3836	+ moveai a3, #%hi(__sigjmp_save)
3837	+ calli a3, %lo(__sigjmp_save)(a3)
3838	+#endif
3839	+ .size __sigjmp_save, . - __sigjmp_save
3840	+
3841	+ .global __longjmp
3842	+ .type __longjmp,@function
3843	+__longjmp:
3844	+ movea a3, d0 ; A3 now holds the jmp buf that was passed in.
3845	+ move.4 d10, (a3)4++
3846	+ move.4 d11, (a3)4++
3847	+ move.4 d12, (a3)4++
3848	+ move.4 d13, (a3)4++
3849	+ move.4 a1 , (a3)4++
3850	+ move.4 a2 , (a3)4++
3851	+ move.4 a5 , (a3)4++
3852	+ move.4 a6 , (a3)4++
3853	+ move.4 a7 , (a3)4++
3854	+
3855	+ sub.4 #0, #0, d1 ; Test if d1 is zero. If it is we have to return 1 other wise return content of d1
3856	+ jmpeq.t 2f
3857	+ move.4 d0, d1 ; d1 is non zero load it into d0
3858	+ jmpt.t 3f
3859	+
3860	+2: move.4 d0, #1
3861	+3: calli a5, 0(a5)
3862	+ .size __longjmp, . - __longjmp
3863	+ .global __GI___longjmp
3864	+ .hidden __GI___longjmp
3865	+ .set __GI___longjmp,__longjmp
3866	--- /dev/null
3867	+++ b/libc/sysdeps/linux/ubicom32/sys/procfs.h
3868	@@ -0,0 +1,122 @@
3869	+/* Copyright (C) 1996, 1997, 1999, 2000 Free Software Foundation, Inc.
3870	+ This file is part of the GNU C Library.
3871	+
3872	+ The GNU C Library is free software; you can redistribute it and/or
3873	+ modify it under the terms of the GNU Lesser General Public
3874	+ License as published by the Free Software Foundation; either
3875	+ version 2.1 of the License, or (at your option) any later version.
3876	+
3877	+ The GNU C Library is distributed in the hope that it will be useful,
3878	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
3879	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3880	+ Lesser General Public License for more details.
3881	+
3882	+ You should have received a copy of the GNU Lesser General Public
3883	+ License along with the GNU C Library; if not, write to the Free
3884	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3885	+ 02111-1307 USA. */
3886	+
3887	+#ifndef _SYS_PROCFS_H
3888	+#define _SYS_PROCFS_H 1
3889	+
3890	+/* This is somehow modelled after the file of the same name on SysVr4
3891	+ systems. It provides a definition of the core file format for ELF
3892	+ used on Linux. */
3893	+
3894	+#include <features.h>
3895	+#include <signal.h>
3896	+#include <sys/time.h>
3897	+#include <sys/types.h>
3898	+#include <sys/ucontext.h>
3899	+#include <bits/wordsize.h>
3900	+
3901	+__BEGIN_DECLS
3902	+
3903	+#define ELF_NGREG 38
3904	+
3905	+typedef struct
3906	+ {
3907	+ union
3908	+ {
3909	+ unsigned long pr_regs[32];
3910	+ double pr_dregs[16];
3911	+ } pr_fr;
3912	+ unsigned long __unused;
3913	+ unsigned long pr_fsr;
3914	+ unsigned char pr_qcnt;
3915	+ unsigned char pr_q_entrysize;
3916	+ unsigned char pr_en;
3917	+ unsigned int pr_q[64];
3918	+ } elf_fpregset_t;
3919	+
3920	+typedef unsigned long elf_greg_t;
3921	+typedef elf_greg_t elf_gregset_t[ELF_NGREG];
3922	+
3923	+struct elf_siginfo
3924	+ {
3925	+ int si_signo; /* Signal number. */
3926	+ int si_code; /* Extra code. */
3927	+ int si_errno; /* Errno. */
3928	+ };
3929	+
3930	+/* Definitions to generate Intel SVR4-like core files. These mostly
3931	+ have the same names as the SVR4 types with "elf_" tacked on the
3932	+ front to prevent clashes with linux definitions, and the typedef
3933	+ forms have been avoided. This is mostly like the SVR4 structure,
3934	+ but more Linuxy, with things that Linux does not support and which
3935	+ gdb doesn't really use excluded. Fields present but not used are
3936	+ marked with "XXX". */
3937	+struct elf_prstatus
3938	+ {
3939	+ struct elf_siginfo pr_info; /* Info associated with signal. */
3940	+ short int pr_cursig; /* Current signal. */
3941	+ unsigned long int pr_sigpend; /* Set of pending signals. */
3942	+ unsigned long int pr_sighold; /* Set of held signals. */
3943	+ __pid_t pr_pid;
3944	+ __pid_t pr_ppid;
3945	+ __pid_t pr_pgrp;
3946	+ __pid_t pr_sid;
3947	+ struct timeval pr_utime; /* User time. */
3948	+ struct timeval pr_stime; /* System time. */
3949	+ struct timeval pr_cutime; /* Cumulative user time. */
3950	+ struct timeval pr_cstime; /* Cumulative system time. */
3951	+ elf_gregset_t pr_reg; /* GP registers. */
3952	+ int pr_fpvalid; /* True if math copro being used. */
3953	+ };
3954	+
3955	+
3956	+#define ELF_PRARGSZ (80) /* Number of chars for args */
3957	+
3958	+struct elf_prpsinfo
3959	+ {
3960	+ char pr_state; /* Numeric process state. */
3961	+ char pr_sname; /* Char for pr_state. */
3962	+ char pr_zomb; /* Zombie. */
3963	+ char pr_nice; /* Nice val. */
3964	+ unsigned long int pr_flag; /* Flags. */
3965	+ unsigned short int pr_uid;
3966	+ unsigned short int pr_gid;
3967	+ int pr_pid, pr_ppid, pr_pgrp, pr_sid;
3968	+ /* Lots missing */
3969	+ char pr_fname[16]; /* Filename of executable. */
3970	+ char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */
3971	+ };
3972	+
3973	+/* Addresses. */
3974	+typedef void *psaddr_t;
3975	+
3976	+/* Register sets. Linux has different names. */
3977	+typedef elf_gregset_t prgregset_t;
3978	+typedef elf_fpregset_t prfpregset_t;
3979	+
3980	+/* We don't have any differences between processes and threads,
3981	+ therefore have only one PID type. */
3982	+typedef __pid_t lwpid_t;
3983	+
3984	+
3985	+typedef struct elf_prstatus prstatus_t;
3986	+typedef struct elf_prpsinfo prpsinfo_t;
3987	+
3988	+__END_DECLS
3989	+
3990	+#endif /* sys/procfs.h */
3991	--- /dev/null
3992	+++ b/libc/sysdeps/linux/ubicom32/sys/ucontext.h
3993	@@ -0,0 +1,104 @@
3994	+/* Copyright (C) 1998, 1999 Free Software Foundation, Inc.
3995	+ This file is part of the GNU C Library.
3996	+
3997	+ The GNU C Library is free software; you can redistribute it and/or
3998	+ modify it under the terms of the GNU Lesser General Public
3999	+ License as published by the Free Software Foundation; either
4000	+ version 2.1 of the License, or (at your option) any later version.
4001	+
4002	+ The GNU C Library is distributed in the hope that it will be useful,
4003	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
4004	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
4005	+ Lesser General Public License for more details.
4006	+
4007	+ You should have received a copy of the GNU Lesser General Public
4008	+ License along with the GNU C Library; if not, write to the Free
4009	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
4010	+ 02111-1307 USA. */
4011	+
4012	+#ifndef _SYS_UCONTEXT_H
4013	+#define _SYS_UCONTEXT_H 1
4014	+
4015	+#include <features.h>
4016	+#include <signal.h>
4017	+/*
4018	+ * Location of the users' stored registers relative to R0.
4019	+ * Usage is as an index into a gregset_t array or as u.u_ar0[XX].
4020	+ */
4021	+#define REG_PSR (0)
4022	+#define REG_PC (1)
4023	+#define REG_SPARE (2)
4024	+#define REG_WVALID (3)
4025	+#define REG_G1 (4)
4026	+#define REG_G2 (5)
4027	+#define REG_G3 (6)
4028	+#define REG_G4 (7)
4029	+#define REG_G5 (8)
4030	+#define REG_G6 (9)
4031	+#define REG_G7 (10)
4032	+#define REG_O0 (11)
4033	+#define REG_O1 (12)
4034	+#define REG_O2 (13)
4035	+#define REG_O3 (14)
4036	+#define REG_O4 (15)
4037	+#define REG_O5 (16)
4038	+#define REG_O6 (17)
4039	+#define REG_O7 (18)
4040	+#define REG_GLOBALS (19)
4041	+
4042	+/*
4043	+ * A gregset_t is defined as an array type for compatibility with the reference
4044	+ * source. This is important due to differences in the way the C language
4045	+ * treats arrays and structures as parameters.
4046	+ *
4047	+ * Note that NGREG is really (sizeof (struct regs) / sizeof (greg_t)),
4048	+ * but that the ABI defines it absolutely to be 21 (resp. 19).
4049	+ */
4050	+
4051	+#define NGREG 20
4052	+typedef int greg_t;
4053	+
4054	+typedef greg_t gregset_t[NGREG];
4055	+
4056	+/*
4057	+ * The following structures define how a register window can appear on the
4058	+ * stack. This structure is available (when required) through the `gwins'
4059	+ * field of an mcontext (nested within ucontext). NIOS_MAXWINDOW is the
4060	+ * maximum number of outstanding register windows defined in the NIOS
4061	+ * architecture (not implementation).
4062	+ */
4063	+#define NIOS_MAXREGWINDOW 31 /* max windows in NIOS arch. */
4064	+struct rwindow
4065	+ {
4066	+ greg_t rw_local[8]; /* locals */
4067	+ greg_t rw_in[8]; /* ins */
4068	+ };
4069	+
4070	+#define rw_fp rw_in[6] /* frame pointer */
4071	+#define rw_rtn rw_in[7] /* return address */
4072	+
4073	+typedef struct gwindows
4074	+ {
4075	+ int wbcnt;
4076	+ int *spbuf[NIOS_MAXREGWINDOW];
4077	+ struct rwindow wbuf[NIOS_MAXREGWINDOW];
4078	+ } gwindows_t;
4079	+
4080	+typedef struct
4081	+ {
4082	+ gregset_t gregs; /* general register set */
4083	+ gwindows_t gwins; / POSSIBLE pointer to register windows */
4084	+ } mcontext_t;
4085	+
4086	+
4087	+/* Userlevel context. */
4088	+typedef struct ucontext
4089	+ {
4090	+ unsigned long uc_flags;
4091	+ struct ucontext *uc_link;
4092	+ __sigset_t uc_sigmask;
4093	+ stack_t uc_stack;
4094	+ mcontext_t uc_mcontext;
4095	+ } ucontext_t;
4096	+
4097	+#endif /* sys/ucontext.h */
4098	--- /dev/null
4099	+++ b/libc/sysdeps/linux/ubicom32/syscall.c
4100	@@ -0,0 +1,32 @@
4101	+/* vi: set sw=4 ts=4: */
4102	+/* syscall for ubicom32/uClibc
4103	+ *
4104	+ * Copyright (C) 2008 by Ubicom Inc.
4105	+ * Copyright (C) 2002 by Erik Andersen <andersen@uclibc.org>
4106	+ *
4107	+ * This program is free software; you can redistribute it and/or modify it
4108	+ * under the terms of the GNU Library General Public License as published by
4109	+ * the Free Software Foundation; either version 2 of the License, or (at your
4110	+ * option) any later version.
4111	+ *
4112	+ * This program is distributed in the hope that it will be useful, but WITHOUT
4113	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4114	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License
4115	+ * for more details.
4116	+ *
4117	+ * You should have received a copy of the GNU Library General Public License
4118	+ * along with this program; if not, write to the Free Software Foundation,
4119	+ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4120	+ */
4121	+
4122	+#include <features.h>
4123	+#include <errno.h>
4124	+#include <sys/types.h>
4125	+#include <sys/syscall.h>
4126	+
4127	+extern long syscall(long sysnum, long a, long b, long c, long d, long e, long f);
4128	+long syscall(long sysnum, long a, long b, long c, long d, long e, long f)
4129	+{
4130	+ int __NR_syscall_number = sysnum;
4131	+ return (long) INLINE_SYSCALL(syscall_number, 6, a, b, c, d, e, f);
4132	+}
4133	--- /dev/null
4134	+++ b/libc/sysdeps/linux/ubicom32/vfork.S
4135	@@ -0,0 +1,35 @@
4136	+#include <sys/syscall.h>
4137	+
4138	+ .text
4139	+ .type vfork,@function
4140	+ .global vfork
4141	+vfork:
4142	+ move.4 -4(sp)++, a5 ; Save return address on the stack.
4143	+ movei d8, #__NR_vfork
4144	+ moveai a3, #%hi(0x40400000)
4145	+ calli a5, 0x10(a3)
4146	+
4147	+ /*
4148	+ * You get here only if the syscall bombed. If things had worked out the
4149	+ * parent and child would have both returned to the instruction after
4150	+ * the vfork call.
4151	+ */
4152	+ move.4 a5, (sp)4++ ; Pop the return address off the stack.
4153	+ movei d1, #-125
4154	+ sub.4 #0, d0, d1
4155	+ jmplt.t 1f
4156	+
4157	+ ;; We have an error.
4158	+ sub.4 d0, #0, d0 ; d0 = -res. Call __set_errno with that.
4159	+#if defined(__UBICOM32_FDPIC__)
4160	+ call a3, __syscall_error
4161	+#else
4162	+ moveai a3, #%hi(__syscall_error)
4163	+ calli a3, %lo(__syscall_error)(a3) ; __syscall_error will return -1 and not come back here.
4164	+#endif
4165	+1:
4166	+ calli a5, 0(a5)
4167	+ .size vfork, . - vfork
4168	+ .global __GI_vfork
4169	+ .hidden __GI_vfork
4170	+ .set __GI_vfork,vfork
4171	--- a/libpthread/linuxthreads.old/pthread.c
4172	+++ b/libpthread/linuxthreads.old/pthread.c
4173	@@ -393,6 +393,10 @@ void __pthread_initialize_minimal(void)
4174	#endif
4175
4176	__libc_multiple_threads_ptr = __libc_pthread_init (ptr_pthread_functions);
4177	+#ifndef __ARCH_USE_MMU__
4178	+ __pthread_initial_thread_tos =
4179	+ (char *)(((long)CURRENT_STACK_FRAME + getpagesize()) & ~(getpagesize() - 1));
4180	+#endif /* __ARCH_USE_MMU__ */
4181	}
4182
4183
4184	@@ -461,8 +465,11 @@ static void pthread_initialize(void)
4185	* __pthread_initial_thread_bos at address 0. These bounds are refined as we
4186	* malloc other stack frames such that they don't overlap. -StS
4187	*/
4188	- __pthread_initial_thread_tos =
4189	- (char *)(((long)CURRENT_STACK_FRAME + getpagesize()) & ~(getpagesize() - 1));
4190	+ if (__pthread_initial_thread_tos == NULL) {
4191	+ __pthread_initial_thread_tos =
4192	+ (char *)(((long)CURRENT_STACK_FRAME + getpagesize()) & ~(getpagesize() - 1));
4193	+ }
4194	+
4195	__pthread_initial_thread_bos = (char ) 1; / set it non-zero so we know we have been here */
4196	PDEBUG("initial thread stack bounds: bos=%p, tos=%p\n",
4197	__pthread_initial_thread_bos, __pthread_initial_thread_tos);
4198	--- /dev/null
4199	+++ b/libpthread/linuxthreads.old/sysdeps/ubicom32/pt-machine.h
4200	@@ -0,0 +1,68 @@
4201	+/* Machine-dependent pthreads configuration and inline functions.
4202	+
4203	+ Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004
4204	+ Free Software Foundation, Inc.
4205	+ This file is part of the GNU C Library.
4206	+ Contributed by Ralf Baechle <ralf@gnu.org>.
4207	+ Based on the Alpha version by Richard Henderson <rth@tamu.edu>.
4208	+
4209	+ The GNU C Library is free software; you can redistribute it and/or
4210	+ modify it under the terms of the GNU Lesser General Public License as
4211	+ published by the Free Software Foundation; either version 2.1 of the
4212	+ License, or (at your option) any later version.
4213	+
4214	+ The GNU C Library is distributed in the hope that it will be useful,
4215	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
4216	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
4217	+ Lesser General Public License for more details.
4218	+
4219	+ You should have received a copy of the GNU Lesser General Public
4220	+ License along with the GNU C Library; see the file COPYING.LIB. If
4221	+ not, write to the Free Software Foundation, Inc.,
4222	+ 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
4223	+
4224	+#ifndef _PT_MACHINE_H
4225	+#define _PT_MACHINE_H 1
4226	+
4227	+#include <features.h>
4228	+
4229	+/*
4230	+ * XXX try to make this inline
4231	+ */
4232	+extern long int testandset (int *spinlock);
4233	+
4234	+#ifndef PT_EI
4235	+#define PT_EI
4236	+#else
4237	+/* Spinlock implementation; required. */
4238	+
4239	+/*
4240	+ * testandset() is the basis for the pthread spin lock.
4241	+ *
4242	+ * This implementation only requires that we 'set' the state of *spinlock. As
4243	+ * bset is allows us to atomically 'testandset' a single bit define our 'set' is
4244	+ * such that we will set bit 0 (ignoring all other bits, which should also be
4245	+ * zero).
4246	+ * Return value of 1 implies that the bit was already set and is still
4247	+ * set.
4248	+ * Return value of 0 implies that the bit was not previously set but it
4249	+ * now is.
4250	+ */
4251	+long int
4252	+testandset (int *spinlock)
4253	+{
4254	+ int ret;
4255	+ __asm__ volatile (
4256	+ " move.4 %0, #0 \n\t" /* Assume that the bit is not currently set */
4257	+ " bset %1, %1, #0 \n\t" /* Attempt to 'set' bit 0 */
4258	+ " jmpeq.t 1f \n\t"
4259	+ " move.4 %0, #1 \n\t" /* Bit was already set, so return 1 */
4260	+ " 1: \n\t"
4261	+ : "=r"(ret), "+U4"(*spinlock)
4262	+ :
4263	+ : "memory", "cc"
4264	+ );
4265	+ return ret;
4266	+}
4267	+#endif
4268	+#endif /* pt-machine.h */
4269	--- /dev/null
4270	+++ b/libpthread/linuxthreads.old/sysdeps/ubicom32/tls.h
4271	@@ -0,0 +1,26 @@
4272	+/* Definitions for thread-local data handling. linuxthreads/MIPS version.
4273	+ Copyright (C) 2005 Free Software Foundation, Inc.
4274	+ This file is part of the GNU C Library.
4275	+
4276	+ The GNU C Library is free software; you can redistribute it and/or
4277	+ modify it under the terms of the GNU Lesser General Public
4278	+ License as published by the Free Software Foundation; either
4279	+ version 2.1 of the License, or (at your option) any later version.
4280	+
4281	+ The GNU C Library is distributed in the hope that it will be useful,
4282	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
4283	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
4284	+ Lesser General Public License for more details.
4285	+
4286	+ You should have received a copy of the GNU Lesser General Public
4287	+ License along with the GNU C Library; if not, write to the Free
4288	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
4289	+ 02111-1307 USA. */
4290	+
4291	+#ifndef _TLS_H
4292	+#define _TLS_H
4293	+#ifdef HAVE_TLS_SUPPORT
4294	+#warning no tls support
4295	+#undef USE_TLS
4296	+#endif
4297	+#endif /* tls.h */
4298	--- /dev/null
4299	+++ b/libc/sysdeps/linux/ubicom32/sys/user.h
4300	@@ -0,0 +1,40 @@
4301	+/* Copyright (C) 1998 Free Software Foundation, Inc.
4302	+ This file is part of the GNU C Library.
4303	+
4304	+ The GNU C Library is free software; you can redistribute it and/or
4305	+ modify it under the terms of the GNU Lesser General Public
4306	+ License as published by the Free Software Foundation; either
4307	+ version 2.1 of the License, or (at your option) any later version.
4308	+
4309	+ The GNU C Library is distributed in the hope that it will be useful,
4310	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
4311	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
4312	+ Lesser General Public License for more details.
4313	+
4314	+ You should have received a copy of the GNU Lesser General Public
4315	+ License along with the GNU C Library; if not, write to the Free
4316	+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
4317	+ 02111-1307 USA. */
4318	+
4319	+#ifndef _SYS_USER_H
4320	+#define _SYS_USER_H 1
4321	+
4322	+#include <features.h>
4323	+
4324	+#include <asm/ptrace.h>
4325	+
4326	+struct user {
4327	+ struct pt_regs regs; /* entire machine state */
4328	+ size_t u_tsize; /* text size (pages) */
4329	+ size_t u_dsize; /* data size (pages) */
4330	+ size_t u_ssize; /* stack size (pages) */
4331	+ unsigned long start_code; /* text starting address */
4332	+ unsigned long start_data; /* data starting address */
4333	+ unsigned long start_stack; /* stack starting address */
4334	+ long int signal; /* signal causing core dump */
4335	+ struct regs * u_ar0; /* help gdb find registers */
4336	+ unsigned long magic; /* identifies a core file */
4337	+ char u_comm[32]; /* user command name */
4338	+};
4339	+
4340	+#endif /* _SYS_USER_H */
4341

Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl

OpenWrt XBurst

OpenWrt XBurst Git Source Tree

Root/toolchain/uClibc/patches-0.9.32/600-ubicom32-uClibc.patch

interactive