uClibc: update 0.9.32 to latest git
[openwrt.git] / toolchain / uClibc / patches-0.9.32 / 600-ubicom32-uClibc.patch
1 --- a/Rules.mak
2 +++ b/Rules.mak
3 @@ -481,6 +481,17 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@ -327,10 +327,12 @@
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 @@
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 @@
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 @@
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 */