kconfig: use pkg-config for ncurses detection
[akaros.git] / tools / compilers / gcc-glibc / glibc-2.19-riscv.patch
1 diff -ruN glibc-2.19/scripts/config.sub glibc-2.19-riscv/scripts/config.sub
2 --- glibc-2.19/scripts/config.sub       2014-02-07 01:04:38.000000000 -0800
3 +++ glibc-2.19-riscv/scripts/config.sub 2014-12-09 16:55:55.061008453 -0800
4 @@ -301,6 +301,7 @@
5         | pdp10 | pdp11 | pj | pjl \
6         | powerpc | powerpc64 | powerpc64le | powerpcle \
7         | pyramid \
8 +       | riscv \
9         | rl78 | rx \
10         | score \
11         | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
12 Binary files glibc-2.19/scripts/.config.sub.rej.swp and glibc-2.19-riscv/scripts/.config.sub.rej.swp differ
13 diff -ruN glibc-2.19/sysdeps/riscv/abort-instr.h glibc-2.19-riscv/sysdeps/riscv/abort-instr.h
14 --- glibc-2.19/sysdeps/riscv/abort-instr.h      1969-12-31 16:00:00.000000000 -0800
15 +++ glibc-2.19-riscv/sysdeps/riscv/abort-instr.h        2014-12-09 16:55:03.152727766 -0800
16 @@ -0,0 +1,2 @@
17 +/* An instruction which should crash any program is a breakpoint.  */
18 +#define ABORT_INSTRUCTION asm ("unimp")
19 diff -ruN glibc-2.19/sysdeps/riscv/bits/atomic.h glibc-2.19-riscv/sysdeps/riscv/bits/atomic.h
20 --- glibc-2.19/sysdeps/riscv/bits/atomic.h      1969-12-31 16:00:00.000000000 -0800
21 +++ glibc-2.19-riscv/sysdeps/riscv/bits/atomic.h        2014-12-09 16:55:03.152727766 -0800
22 @@ -0,0 +1,119 @@
23 +/* Low-level functions for atomic operations. Mips version.
24 +   Copyright (C) 2005 Free Software Foundation, Inc.
25 +   This file is part of the GNU C Library.
26 +
27 +   The GNU C Library is free software; you can redistribute it and/or
28 +   modify it under the terms of the GNU Lesser General Public
29 +   License as published by the Free Software Foundation; either
30 +   version 2.1 of the License, or (at your option) any later version.
31 +
32 +   The GNU C Library is distributed in the hope that it will be useful,
33 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
34 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
35 +   Lesser General Public License for more details.
36 +
37 +   You should have received a copy of the GNU Lesser General Public
38 +   License along with the GNU C Library; if not, write to the Free
39 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
40 +   02111-1307 USA.  */
41 +
42 +#ifndef _MIPS_BITS_ATOMIC_H
43 +#define _MIPS_BITS_ATOMIC_H 1
44 +
45 +#include <inttypes.h>
46 +#include <sgidefs.h>
47 +
48 +typedef int32_t atomic32_t;
49 +typedef uint32_t uatomic32_t;
50 +typedef int_fast32_t atomic_fast32_t;
51 +typedef uint_fast32_t uatomic_fast32_t;
52 +
53 +typedef int64_t atomic64_t;
54 +typedef uint64_t uatomic64_t;
55 +typedef int_fast64_t atomic_fast64_t;
56 +typedef uint_fast64_t uatomic_fast64_t;
57 +
58 +typedef intptr_t atomicptr_t;
59 +typedef uintptr_t uatomicptr_t;
60 +typedef intmax_t atomic_max_t;
61 +typedef uintmax_t uatomic_max_t;
62 +
63 +/* Atomic compare and exchange. */
64 +
65 +#define atomic_compare_and_exchange_val_acq(mem, newval, oldval)         \
66 +  ({ __sync_synchronize();                      \
67 +     __sync_val_compare_and_swap(mem, oldval, newval); })
68 +
69 +#define atomic_compare_and_exchange_val_rel(mem, newval, oldval)         \
70 +  ({ typeof(*mem) __prev;                       \
71 +     __prev = __sync_val_compare_and_swap(mem, value);  \
72 +     __sync_synchronize();                      \
73 +     __prev; })
74 +
75 +/* Atomic exchange (without compare).  */
76 +
77 +#define atomic_exchange_acq(mem, value)         \
78 +  ({ __sync_synchronize();                      \
79 +     __sync_lock_test_and_set(mem, value); })
80 +
81 +#define atomic_exchange_rel(mem, value)         \
82 +  ({ typeof(*mem) __prev;                       \
83 +     __prev = __sync_lock_test_and_set(mem, value);  \
84 +     __sync_synchronize();                      \
85 +     __prev; })
86 +
87 +
88 +/* Atomically add value and return the previous (unincremented) value.  */
89 +
90 +/* ??? Barrier semantics for atomic_exchange_and_add appear to be 
91 +   undefined.  Use full barrier for now, as that's safe.  */
92 +#define atomic_exchange_and_add(mem, value)             \
93 +  ({ typeof(*mem) __prev;                               \
94 +     __sync_synchronize();                              \
95 +     __prev = __sync_fetch_and_add(mem, value);         \
96 +     __sync_synchronize();                              \
97 +     __prev; })
98 +
99 +#define catomic_exchange_and_add(mem, value)           \
100 +  atomic_exchange_and_add(mem, value)
101 +
102 +#define atomic_bit_test_set(mem, bit)                   \
103 +  ({ typeof(*mem) __prev;                               \
104 +     typeof(*mem) __mask = (typeof(*mem))1 << (bit);    \
105 +     __sync_synchronize();                              \
106 +     __prev = __sync_fetch_and_or(mem, __mask);         \
107 +     __sync_synchronize();                              \
108 +     __prev & __mask; })
109 +
110 +#define asm_maxmin(which, size, res, mem, value) \
111 +  asm ("amo" which "." size "\t%0, %1, 0(%2)" : "=r"(res) : "r"(value), "r"(mem) : "memory")
112 +
113 +#define atomic_max(mem, value)                         \
114 +  ({  typeof(*mem) __prev;                             \
115 +      __sync_synchronize();                                    \
116 +      if (sizeof(*mem) == 4)                           \
117 +       asm_maxmin("maxu", "s", __prev, mem, value);    \
118 +      else if(sizeof(*mem) == 8)                       \
119 +       asm_maxmin("maxu", "d", __prev, mem, value);    \
120 +      else                                             \
121 +       abort();                                        \
122 +     __sync_synchronize();                              \
123 +     __prev; })
124 +
125 +#define catomic_max(mem, value) atomic_max(mem, value)
126 +
127 +#define atomic_min(mem, value)                         \
128 +  ({  typeof(*mem) __prev;                             \
129 +      __sync_synchronize();                                    \
130 +      if (sizeof(*mem) == 4)                           \
131 +       asm_maxmin("minu", "s", __prev, mem, value);    \
132 +      else if(sizeof(*mem) == 8)                       \
133 +       asm_maxmin("minu", "d", __prev, mem, value);    \
134 +      else                                             \
135 +       abort();                                        \
136 +     __sync_synchronize();                              \
137 +     __prev; })
138 +
139 +#define atomic_full_barrier() __sync_synchronize()
140 +
141 +#endif /* bits/atomic.h */
142 diff -ruN glibc-2.19/sysdeps/riscv/bits/dlfcn.h glibc-2.19-riscv/sysdeps/riscv/bits/dlfcn.h
143 --- glibc-2.19/sysdeps/riscv/bits/dlfcn.h       1969-12-31 16:00:00.000000000 -0800
144 +++ glibc-2.19-riscv/sysdeps/riscv/bits/dlfcn.h 2014-12-09 16:55:03.152727766 -0800
145 @@ -0,0 +1,66 @@
146 +/* System dependent definitions for run-time dynamic loading.
147 +   Copyright (C) 1996, 1997, 1999, 2000, 2001, 2004
148 +       Free Software Foundation, Inc.
149 +   This file is part of the GNU C Library.
150 +
151 +   The GNU C Library is free software; you can redistribute it and/or
152 +   modify it under the terms of the GNU Lesser General Public
153 +   License as published by the Free Software Foundation; either
154 +   version 2.1 of the License, or (at your option) any later version.
155 +
156 +   The GNU C Library is distributed in the hope that it will be useful,
157 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
158 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
159 +   Lesser General Public License for more details.
160 +
161 +   You should have received a copy of the GNU Lesser General Public
162 +   License along with the GNU C Library; if not, write to the Free
163 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
164 +   02111-1307 USA.  */
165 +
166 +#ifndef _DLFCN_H
167 +# error "Never use <bits/dlfcn.h> directly; include <dlfcn.h> instead."
168 +#endif
169 +
170 +/* The MODE argument to `dlopen' contains one of the following: */
171 +#define RTLD_LAZY      0x0001  /* Lazy function call binding.  */
172 +#define RTLD_NOW       0x0002  /* Immediate function call binding.  */
173 +#define RTLD_BINDING_MASK  0x3 /* Mask of binding time value.  */
174 +#define RTLD_NOLOAD    0x00008 /* Do not load the object.  */
175 +#define RTLD_DEEPBIND  0x00010 /* Use deep binding.  */
176 +
177 +/* If the following bit is set in the MODE argument to `dlopen',
178 +   the symbols of the loaded object and its dependencies are made
179 +   visible as if the object were linked directly into the program.  */
180 +#define RTLD_GLOBAL    0x0004
181 +
182 +/* Unix98 demands the following flag which is the inverse to RTLD_GLOBAL.
183 +   The implementation does this by default and so we can define the
184 +   value to zero.  */
185 +#define RTLD_LOCAL      0
186 +
187 +/* Do not delete object when closed.  */
188 +#define RTLD_NODELETE  0x01000
189 +
190 +#ifdef __USE_GNU
191 +/* To support profiling of shared objects it is a good idea to call
192 +   the function found using `dlsym' using the following macro since
193 +   these calls do not use the PLT.  But this would mean the dynamic
194 +   loader has no chance to find out when the function is called.  The
195 +   macro applies the necessary magic so that profiling is possible.
196 +   Rewrite
197 +       foo = (*fctp) (arg1, arg2);
198 +   into
199 +        foo = DL_CALL_FCT (fctp, (arg1, arg2));
200 +*/
201 +# define DL_CALL_FCT(fctp, args) \
202 +  (_dl_mcount_wrapper_check ((void *) (fctp)), (*(fctp)) args)
203 +
204 +__BEGIN_DECLS
205 +
206 +/* This function calls the profiling functions.  */
207 +extern void _dl_mcount_wrapper_check (void *__selfpc) __THROW;
208 +
209 +__END_DECLS
210 +
211 +#endif
212 diff -ruN glibc-2.19/sysdeps/riscv/bits/endian.h glibc-2.19-riscv/sysdeps/riscv/bits/endian.h
213 --- glibc-2.19/sysdeps/riscv/bits/endian.h      1969-12-31 16:00:00.000000000 -0800
214 +++ glibc-2.19-riscv/sysdeps/riscv/bits/endian.h        2014-12-09 16:55:03.152727766 -0800
215 @@ -0,0 +1,13 @@
216 +/* The MIPS architecture has selectable endianness.
217 +   This file is for a machine using big-endian mode.  */
218 +
219 +#ifndef _ENDIAN_H
220 +# error "Never use <bits/endian.h> directly; include <endian.h> instead."
221 +#endif
222 +
223 +#if __RISCVEB
224 +# define __BYTE_ORDER __BIG_ENDIAN
225 +#endif
226 +#if __RISCVEL
227 +# define __BYTE_ORDER __LITTLE_ENDIAN
228 +#endif
229 diff -ruN glibc-2.19/sysdeps/riscv/bits/fenv.h glibc-2.19-riscv/sysdeps/riscv/bits/fenv.h
230 --- glibc-2.19/sysdeps/riscv/bits/fenv.h        1969-12-31 16:00:00.000000000 -0800
231 +++ glibc-2.19-riscv/sysdeps/riscv/bits/fenv.h  2014-12-09 16:55:03.152727766 -0800
232 @@ -0,0 +1,77 @@
233 +/* Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
234 +   This file is part of the GNU C Library.
235 +
236 +   The GNU C Library is free software; you can redistribute it and/or
237 +   modify it under the terms of the GNU Lesser General Public
238 +   License as published by the Free Software Foundation; either
239 +   version 2.1 of the License, or (at your option) any later version.
240 +
241 +   The GNU C Library is distributed in the hope that it will be useful,
242 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
243 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
244 +   Lesser General Public License for more details.
245 +
246 +   You should have received a copy of the GNU Lesser General Public
247 +   License along with the GNU C Library; if not, write to the Free
248 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
249 +   02111-1307 USA.  */
250 +
251 +#ifndef _FENV_H
252 +# error "Never use <bits/fenv.h> directly; include <fenv.h> instead."
253 +#endif
254 +
255 +
256 +/* Define bits representing the exception.  We use the bit positions
257 +   of the appropriate bits in the FPU control word.  */
258 +enum
259 +  {
260 +    FE_INEXACT = 0x04,
261 +#define FE_INEXACT     FE_INEXACT
262 +    FE_UNDERFLOW = 0x08,
263 +#define FE_UNDERFLOW   FE_UNDERFLOW
264 +    FE_OVERFLOW = 0x10,
265 +#define FE_OVERFLOW    FE_OVERFLOW
266 +    FE_DIVBYZERO = 0x20,
267 +#define FE_DIVBYZERO   FE_DIVBYZERO
268 +    FE_INVALID = 0x40,
269 +#define FE_INVALID     FE_INVALID
270 +  };
271 +
272 +#define FE_ALL_EXCEPT \
273 +       (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)
274 +
275 +/* The MIPS FPU supports all of the four defined rounding modes.  We
276 +   use again the bit positions in the FPU control word as the values
277 +   for the appropriate macros.  */
278 +enum
279 +  {
280 +    FE_TONEAREST = 0x0,
281 +#define FE_TONEAREST   FE_TONEAREST
282 +    FE_TOWARDZERO = 0x1,
283 +#define FE_TOWARDZERO  FE_TOWARDZERO
284 +    FE_UPWARD = 0x2,
285 +#define FE_UPWARD      FE_UPWARD
286 +    FE_DOWNWARD = 0x3
287 +#define FE_DOWNWARD    FE_DOWNWARD
288 +  };
289 +
290 +
291 +/* Type representing exception flags.  */
292 +typedef unsigned short int fexcept_t;
293 +
294 +
295 +/* Type representing floating-point environment.  This function corresponds
296 +   to the layout of the block written by the `fstenv'.  */
297 +typedef struct
298 +  {
299 +    unsigned int __fp_control_register;
300 +  }
301 +fenv_t;
302 +
303 +/* If the default argument is used we use this value.  */
304 +#define FE_DFL_ENV     ((__const fenv_t *) -1)
305 +
306 +#ifdef __USE_GNU
307 +/* Floating-point environment where none of the exception is masked.  */
308 +# define FE_NOMASK_ENV  ((__const fenv_t *) -2)
309 +#endif
310 diff -ruN glibc-2.19/sysdeps/riscv/bits/ipctypes.h glibc-2.19-riscv/sysdeps/riscv/bits/ipctypes.h
311 --- glibc-2.19/sysdeps/riscv/bits/ipctypes.h    1969-12-31 16:00:00.000000000 -0800
312 +++ glibc-2.19-riscv/sysdeps/riscv/bits/ipctypes.h      2014-12-09 16:55:03.152727766 -0800
313 @@ -0,0 +1,32 @@
314 +/* bits/ipctypes.h -- Define some types used by SysV IPC/MSG/SHM.  MIPS version
315 +   Copyright (C) 2002 Free Software Foundation, Inc.
316 +   This file is part of the GNU C Library.
317 +
318 +   The GNU C Library is free software; you can redistribute it and/or
319 +   modify it under the terms of the GNU Lesser General Public
320 +   License as published by the Free Software Foundation; either
321 +   version 2.1 of the License, or (at your option) any later version.
322 +
323 +   The GNU C Library is distributed in the hope that it will be useful,
324 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
325 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
326 +   Lesser General Public License for more details.
327 +
328 +   You should have received a copy of the GNU Lesser General Public
329 +   License along with the GNU C Library; if not, write to the Free
330 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
331 +   02111-1307 USA.  */
332 +
333 +/*
334 + * Never include <bits/ipctypes.h> directly.
335 + */
336 +
337 +#ifndef _BITS_IPCTYPES_H
338 +#define _BITS_IPCTYPES_H       1
339 +
340 +#include <bits/types.h>
341 +
342 +typedef __SLONG32_TYPE __ipc_pid_t;
343 +
344 +
345 +#endif /* bits/ipctypes.h */
346 diff -ruN glibc-2.19/sysdeps/riscv/bits/link.h glibc-2.19-riscv/sysdeps/riscv/bits/link.h
347 --- glibc-2.19/sysdeps/riscv/bits/link.h        1969-12-31 16:00:00.000000000 -0800
348 +++ glibc-2.19-riscv/sysdeps/riscv/bits/link.h  2014-12-09 16:55:03.152727766 -0800
349 @@ -0,0 +1,76 @@
350 +/* Copyright (C) 2005, 2009 Free Software Foundation, Inc.
351 +   This file is part of the GNU C Library.
352 +
353 +   The GNU C Library is free software; you can redistribute it and/or
354 +   modify it under the terms of the GNU Lesser General Public
355 +   License as published by the Free Software Foundation; either
356 +   version 2.1 of the License, or (at your option) any later version.
357 +
358 +   The GNU C Library is distributed in the hope that it will be useful,
359 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
360 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
361 +   Lesser General Public License for more details.
362 +
363 +   You should have received a copy of the GNU Lesser General Public
364 +   License along with the GNU C Library; if not, write to the Free
365 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
366 +   02111-1307 USA.  */
367 +
368 +#ifndef        _LINK_H
369 +# error "Never include <bits/link.h> directly; use <link.h> instead."
370 +#endif
371 +
372 +typedef struct La_mips_64_regs
373 +{
374 +  unsigned long lr_reg[8]; /* $a0 through $a7 */
375 +  double lr_fpreg[8]; /* $f4 throgh $f11 */
376 +  unsigned long lr_ra;
377 +  unsigned long lr_sp;
378 +} La_mips_64_regs;
379 +
380 +/* Return values for calls from PLT on MIPS.  */
381 +typedef struct La_mips_64_retval
382 +{
383 +  unsigned long lrv_v0;
384 +  unsigned long lrv_v1;
385 +  double lrv_fv0;
386 +  double lrv_fv1;
387 +} La_mips_64_retval;
388 +
389 +__BEGIN_DECLS
390 +
391 +#if _RISCV_SIM == _ABI32
392 +
393 +extern Elf32_Addr la_mips_n32_gnu_pltenter (Elf32_Sym *__sym, unsigned int __ndx,
394 +                                           uintptr_t *__refcook,
395 +                                           uintptr_t *__defcook,
396 +                                           La_mips_64_regs *__regs,
397 +                                           unsigned int *__flags,
398 +                                           const char *__symname,
399 +                                           long int *__framesizep);
400 +extern unsigned int la_mips_n32_gnu_pltexit (Elf32_Sym *__sym, unsigned int __ndx,
401 +                                            uintptr_t *__refcook,
402 +                                            uintptr_t *__defcook,
403 +                                            const La_mips_64_regs *__inregs,
404 +                                            La_mips_64_retval *__outregs,
405 +                                            const char *__symname);
406 +
407 +#else
408 +
409 +extern Elf64_Addr la_mips_n64_gnu_pltenter (Elf64_Sym *__sym, unsigned int __ndx,
410 +                                           uintptr_t *__refcook,
411 +                                           uintptr_t *__defcook,
412 +                                           La_mips_64_regs *__regs,
413 +                                           unsigned int *__flags,
414 +                                           const char *__symname,
415 +                                           long int *__framesizep);
416 +extern unsigned int la_mips_n64_gnu_pltexit (Elf64_Sym *__sym, unsigned int __ndx,
417 +                                            uintptr_t *__refcook,
418 +                                            uintptr_t *__defcook,
419 +                                            const La_mips_64_regs *__inregs,
420 +                                            La_mips_64_retval *__outregs,
421 +                                            const char *__symname);
422 +
423 +#endif
424 +
425 +__END_DECLS
426 diff -ruN glibc-2.19/sysdeps/riscv/bits/linkmap.h glibc-2.19-riscv/sysdeps/riscv/bits/linkmap.h
427 --- glibc-2.19/sysdeps/riscv/bits/linkmap.h     1969-12-31 16:00:00.000000000 -0800
428 +++ glibc-2.19-riscv/sysdeps/riscv/bits/linkmap.h       2014-12-09 16:55:03.152727766 -0800
429 @@ -0,0 +1,4 @@
430 +struct link_map_machine
431 +  {
432 +    ElfW(Addr) plt; /* Address of .plt */
433 +  };
434 diff -ruN glibc-2.19/sysdeps/riscv/bits/mathdef.h glibc-2.19-riscv/sysdeps/riscv/bits/mathdef.h
435 --- glibc-2.19/sysdeps/riscv/bits/mathdef.h     1969-12-31 16:00:00.000000000 -0800
436 +++ glibc-2.19-riscv/sysdeps/riscv/bits/mathdef.h       2014-12-09 16:55:03.152727766 -0800
437 @@ -0,0 +1,45 @@
438 +/* Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2007
439 +       Free Software Foundation, Inc.
440 +   This file is part of the GNU C Library.
441 +
442 +   The GNU C Library is free software; you can redistribute it and/or
443 +   modify it under the terms of the GNU Lesser General Public
444 +   License as published by the Free Software Foundation; either
445 +   version 2.1 of the License, or (at your option) any later version.
446 +
447 +   The GNU C Library is distributed in the hope that it will be useful,
448 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
449 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
450 +   Lesser General Public License for more details.
451 +
452 +   You should have received a copy of the GNU Lesser General Public
453 +   License along with the GNU C Library; if not, write to the Free
454 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
455 +   02111-1307 USA.  */
456 +
457 +#if !defined _MATH_H && !defined _COMPLEX_H
458 +# error "Never use <bits/mathdef.h> directly; include <math.h> instead"
459 +#endif
460 +
461 +#include <sgidefs.h>
462 +
463 +#if defined  __USE_ISOC99 && defined _MATH_H && !defined _MATH_H_MATHDEF
464 +# define _MATH_H_MATHDEF       1
465 +
466 +/* MIPS has `float' and `double' operations.  */
467 +typedef float float_t;         /* `float' expressions are evaluated as
468 +                                  `float'.  */
469 +typedef double double_t;       /* `double' expressions are evaluated as
470 +                                  `double'.  */
471 +
472 +/* The values returned by `ilogb' for 0 and NaN respectively.  */
473 +# define FP_ILOGB0     (-2147483647)
474 +# define FP_ILOGBNAN   2147483647
475 +
476 +#endif /* ISO C99 */
477 +
478 +#if ! defined __NO_LONG_DOUBLE_MATH && _RISCV_SIM == _ABI32
479 +/* Signal that we do not really have a `long double'.  This disables the
480 +   declaration of all the `long double' function variants.  */
481 +# define __NO_LONG_DOUBLE_MATH 1
482 +#endif
483 diff -ruN glibc-2.19/sysdeps/riscv/bits/nan.h glibc-2.19-riscv/sysdeps/riscv/bits/nan.h
484 --- glibc-2.19/sysdeps/riscv/bits/nan.h 1969-12-31 16:00:00.000000000 -0800
485 +++ glibc-2.19-riscv/sysdeps/riscv/bits/nan.h   2014-12-09 16:55:03.156727789 -0800
486 @@ -0,0 +1,56 @@
487 +/* `NAN' constant for IEEE 754 machines.
488 +   Copyright (C) 1992, 1996, 1997, 1999, 2002, 2004
489 +   Free Software Foundation, Inc.
490 +   This file is part of the GNU C Library.
491 +
492 +   The GNU C Library is free software; you can redistribute it and/or
493 +   modify it under the terms of the GNU Lesser General Public
494 +   License as published by the Free Software Foundation; either
495 +   version 2.1 of the License, or (at your option) any later version.
496 +
497 +   The GNU C Library is distributed in the hope that it will be useful,
498 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
499 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
500 +   Lesser General Public License for more details.
501 +
502 +   You should have received a copy of the GNU Lesser General Public
503 +   License along with the GNU C Library; if not, write to the Free
504 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
505 +   02111-1307 USA.  */
506 +
507 +#ifndef _MATH_H
508 +# error "Never use <bits/nan.h> directly; include <math.h> instead."
509 +#endif
510 +
511 +
512 +/* IEEE Not A Number (QNaN). Note that MIPS has the QNaN and SNaN patterns
513 +   reversed compared to most other architectures. The IEEE spec left
514 +   the definition of this open to implementations, and for MIPS the top
515 +   bit of the mantissa must be SET to indicate a SNaN.  */
516 +
517 +#if __GNUC_PREREQ(3,3)
518 +
519 +# define NAN   (__builtin_nanf(""))
520 +
521 +#elif defined __GNUC__
522 +
523 +# define NAN \
524 +  (__extension__                                                            \
525 +   ((union { unsigned __l __attribute__((__mode__(__SI__))); float __d; })  \
526 +    { __l: 0x7fbfffffUL }).__d)
527 +
528 +#else
529 +
530 +# include <endian.h>
531 +
532 +# if __BYTE_ORDER == __BIG_ENDIAN
533 +#  define __nan_bytes          { 0x7f, 0xbf, 0xff, 0xff }
534 +# endif
535 +# if __BYTE_ORDER == __LITTLE_ENDIAN
536 +#  define __nan_bytes          { 0xff, 0xff, 0xbf, 0x7f }
537 +# endif
538 +
539 +static union { unsigned char __c[4]; float __d; } __nan_union = { __nan_bytes };
540 +# define NAN   (__nan_union.__d)
541 +
542 +#endif /* GCC.  */
543 diff -ruN glibc-2.19/sysdeps/riscv/bits/setjmp.h glibc-2.19-riscv/sysdeps/riscv/bits/setjmp.h
544 --- glibc-2.19/sysdeps/riscv/bits/setjmp.h      1969-12-31 16:00:00.000000000 -0800
545 +++ glibc-2.19-riscv/sysdeps/riscv/bits/setjmp.h        2014-12-09 16:55:03.156727789 -0800
546 @@ -0,0 +1,43 @@
547 +/* Define the machine-dependent type `jmp_buf'.  RISC-V version.
548 +   Copyright (C) 1992,1993,1995,1997,2000,2002,2003,2004,2005,2006
549 +       Free Software Foundation, Inc.
550 +   This file is part of the GNU C Library.
551 +
552 +   The GNU C Library is free software; you can redistribute it and/or
553 +   modify it under the terms of the GNU Lesser General Public
554 +   License as published by the Free Software Foundation; either
555 +   version 2.1 of the License, or (at your option) any later version.
556 +
557 +   The GNU C Library is distributed in the hope that it will be useful,
558 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
559 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
560 +   Lesser General Public License for more details.
561 +
562 +   You should have received a copy of the GNU Lesser General Public
563 +   License along with the GNU C Library; if not, write to the Free
564 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
565 +   02111-1307 USA.  */
566 +
567 +#ifndef _RISCV_BITS_SETJMP_H
568 +#define _RISCV_BITS_SETJMP_H
569 +
570 +typedef struct __jmp_buf_internal_tag
571 +  {
572 +    /* Program counter.  */
573 +    long __pc;
574 +    /* Callee-saved registers. */
575 +    long __regs[12];
576 +    /* Stack pointer.  */
577 +    long __sp;
578 +    /* Thread pointer. */
579 +    long __tp;
580 +    /* Floating point status register.  */
581 +    long __fsr;
582 +
583 +    /* Callee-saved floating point registers.
584 +       Note that there are an even number of preceding words in this struct,
585 +       so no padding will be inserted before __fpregs, even for RV32. */
586 +    double __fpregs[16];
587 +  } __jmp_buf[1];
588 +
589 +#endif /* _RISCV_BITS_SETJMP_H */
590 diff -ruN glibc-2.19/sysdeps/riscv/bits/string.h glibc-2.19-riscv/sysdeps/riscv/bits/string.h
591 --- glibc-2.19/sysdeps/riscv/bits/string.h      1969-12-31 16:00:00.000000000 -0800
592 +++ glibc-2.19-riscv/sysdeps/riscv/bits/string.h        2014-12-09 16:55:03.156727789 -0800
593 @@ -0,0 +1,47 @@
594 +/* This file should provide inline versions of string functions.
595 +
596 +   Surround GCC-specific parts with #ifdef __GNUC__, and use `__extern_inline'.
597 +
598 +   This file should define __STRING_INLINES if functions are actually defined
599 +   as inlines.  */
600 +
601 +#ifndef _BITS_STRING_H
602 +#define _BITS_STRING_H 1
603 +
604 +#if defined(__GNUC__) && !defined(__cplusplus)
605 +
606 +#define _HAVE_STRING_ARCH_memcpy 1
607 +#define __use_memcpy_align(k, d, s, n) \
608 +  (__builtin_constant_p(n) && (n) % (k) == 0 && (n) <= 64 && \
609 +   __alignof__(d) >= (k) && __alignof__(s) >= (k))
610 +#define memcpy(d, s, n) \
611 +  (__use_memcpy_align(8, d, s, n) ? __memcpy_align8(d, s, n) : \
612 +   __use_memcpy_align(4, d, s, n) ? __memcpy_align4(d, s, n) : \
613 +   __memcpy_g(d, s, n))
614 +
615 +#define __declare_memcpy_align(size, type) \
616 +  static inline void *__memcpy_align ## size(void *__restrict __dest, \
617 +                        __const void *__restrict __src, size_t __n) { \
618 +    type *__d = (type*)__dest; \
619 +    const type *__s = (const type*)__src, *__e = (const type*)(__src + __n); \
620 +    while (__s < __e) { \
621 +      type __t = *__s; \
622 +      __d++, __s++; \
623 +      *(__d-1) = __t; \
624 +    } \
625 +    return __dest; \
626 +  }
627 +__declare_memcpy_align(8, long long)
628 +__declare_memcpy_align(4, int)
629 +
630 +#ifdef _LIBC
631 +extern void *__memcpy_g (void *__restrict __dest,
632 +                         __const void *__restrict __src, size_t __n);
633 +libc_hidden_proto (__memcpy_g)
634 +#else
635 +# define __memcpy_g memcpy
636 +#endif
637 +
638 +#endif /* __GNUC__ && !__cplusplus */
639 +
640 +#endif /* bits/string.h */
641 diff -ruN glibc-2.19/sysdeps/riscv/bits/wordsize.h glibc-2.19-riscv/sysdeps/riscv/bits/wordsize.h
642 --- glibc-2.19/sysdeps/riscv/bits/wordsize.h    1969-12-31 16:00:00.000000000 -0800
643 +++ glibc-2.19-riscv/sysdeps/riscv/bits/wordsize.h      2014-12-09 16:55:03.156727789 -0800
644 @@ -0,0 +1,22 @@
645 +/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
646 +   This file is part of the GNU C Library.
647 +
648 +   The GNU C Library is free software; you can redistribute it and/or
649 +   modify it under the terms of the GNU Lesser General Public
650 +   License as published by the Free Software Foundation; either
651 +   version 2.1 of the License, or (at your option) any later version.
652 +
653 +   The GNU C Library is distributed in the hope that it will be useful,
654 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
655 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
656 +   Lesser General Public License for more details.
657 +
658 +   You should have received a copy of the GNU Lesser General Public
659 +   License along with the GNU C Library; if not, write to the Free
660 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
661 +   02111-1307 USA.  */
662 +
663 +#define __WORDSIZE     _RISCV_SZPTR
664 +#if _RISCV_SIM == _ABI64
665 +# define __WORDSIZE_COMPAT32   1
666 +#endif
667 diff -ruN glibc-2.19/sysdeps/riscv/bsd-_setjmp.c glibc-2.19-riscv/sysdeps/riscv/bsd-_setjmp.c
668 --- glibc-2.19/sysdeps/riscv/bsd-_setjmp.c      1969-12-31 16:00:00.000000000 -0800
669 +++ glibc-2.19-riscv/sysdeps/riscv/bsd-_setjmp.c        2014-12-09 16:55:03.156727789 -0800
670 @@ -0,0 +1 @@
671 +/* _setjmp is implemented in setjmp.S */
672 diff -ruN glibc-2.19/sysdeps/riscv/bsd-setjmp.c glibc-2.19-riscv/sysdeps/riscv/bsd-setjmp.c
673 --- glibc-2.19/sysdeps/riscv/bsd-setjmp.c       1969-12-31 16:00:00.000000000 -0800
674 +++ glibc-2.19-riscv/sysdeps/riscv/bsd-setjmp.c 2014-12-09 16:55:03.156727789 -0800
675 @@ -0,0 +1 @@
676 +/* setjmp is implemented in setjmp.S */
677 diff -ruN glibc-2.19/sysdeps/riscv/dl-dtprocnum.h glibc-2.19-riscv/sysdeps/riscv/dl-dtprocnum.h
678 --- glibc-2.19/sysdeps/riscv/dl-dtprocnum.h     1969-12-31 16:00:00.000000000 -0800
679 +++ glibc-2.19-riscv/sysdeps/riscv/dl-dtprocnum.h       2014-12-09 16:55:03.156727789 -0800
680 @@ -0,0 +1,22 @@
681 +/* Configuration of lookup functions.  MIPS version.
682 +   Copyright (C) 2000 Free Software Foundation, Inc.
683 +   This file is part of the GNU C Library.
684 +
685 +   The GNU C Library is free software; you can redistribute it and/or
686 +   modify it under the terms of the GNU Lesser General Public
687 +   License as published by the Free Software Foundation; either
688 +   version 2.1 of the License, or (at your option) any later version.
689 +
690 +   The GNU C Library is distributed in the hope that it will be useful,
691 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
692 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
693 +   Lesser General Public License for more details.
694 +
695 +   You should have received a copy of the GNU Lesser General Public
696 +   License along with the GNU C Library; if not, write to the Free
697 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
698 +   02111-1307 USA.  */
699 +
700 +/* Number of extra dynamic section entries for this architecture.  By
701 +   default there are none.  */
702 +#define DT_THISPROCNUM DT_MIPS_NUM
703 diff -ruN glibc-2.19/sysdeps/riscv/dl-lookup.c glibc-2.19-riscv/sysdeps/riscv/dl-lookup.c
704 --- glibc-2.19/sysdeps/riscv/dl-lookup.c        1969-12-31 16:00:00.000000000 -0800
705 +++ glibc-2.19-riscv/sysdeps/riscv/dl-lookup.c  2014-12-09 16:55:03.156727789 -0800
706 @@ -0,0 +1,1033 @@
707 +/* Look up a symbol in the loaded objects.
708 +   MIPS/Linux version - special handling of non-PIC undefined symbol rules.
709 +   Copyright (C) 1995-2005, 2006, 2007, 2009, 2010
710 +   Free Software Foundation, Inc.
711 +   This file is part of the GNU C Library.
712 +
713 +   The GNU C Library is free software; you can redistribute it and/or
714 +   modify it under the terms of the GNU Lesser General Public
715 +   License as published by the Free Software Foundation; either
716 +   version 2.1 of the License, or (at your option) any later version.
717 +
718 +   The GNU C Library is distributed in the hope that it will be useful,
719 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
720 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
721 +   Lesser General Public License for more details.
722 +
723 +   You should have received a copy of the GNU Lesser General Public
724 +   License along with the GNU C Library; if not, write to the Free
725 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
726 +   02111-1307 USA.  */
727 +
728 +#include <alloca.h>
729 +#include <libintl.h>
730 +#include <stdlib.h>
731 +#include <string.h>
732 +#include <unistd.h>
733 +#include <ldsodefs.h>
734 +#include <dl-hash.h>
735 +#include <dl-machine.h>
736 +#include <sysdep-cancel.h>
737 +#include <bits/libc-lock.h>
738 +#include <tls.h>
739 +
740 +#include <assert.h>
741 +
742 +#define VERSTAG(tag)   (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (tag))
743 +
744 +/* We need this string more than once.  */
745 +static const char undefined_msg[] = "undefined symbol: ";
746 +
747 +
748 +struct sym_val
749 +  {
750 +    const ElfW(Sym) *s;
751 +    struct link_map *m;
752 +  };
753 +
754 +
755 +#define make_string(string, rest...) \
756 +  ({                                                                         \
757 +    const char *all[] = { string, ## rest };                                 \
758 +    size_t len, cnt;                                                         \
759 +    char *result, *cp;                                                       \
760 +                                                                             \
761 +    len = 1;                                                                 \
762 +    for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt)               \
763 +      len += strlen (all[cnt]);                                                      \
764 +                                                                             \
765 +    cp = result = alloca (len);                                                      \
766 +    for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt)               \
767 +      cp = __stpcpy (cp, all[cnt]);                                          \
768 +                                                                             \
769 +    result;                                                                  \
770 +  })
771 +
772 +/* Statistics function.  */
773 +#ifdef SHARED
774 +# define bump_num_relocations() ++GL(dl_num_relocations)
775 +#else
776 +# define bump_num_relocations() ((void) 0)
777 +#endif
778 +
779 +
780 +/* Inner part of the lookup functions.  We return a value > 0 if we
781 +   found the symbol, the value 0 if nothing is found and < 0 if
782 +   something bad happened.  */
783 +static int
784 +__attribute_noinline__
785 +do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
786 +            unsigned long int *old_hash, const ElfW(Sym) *ref,
787 +            struct sym_val *result, struct r_scope_elem *scope, size_t i,
788 +            const struct r_found_version *const version, int flags,
789 +            struct link_map *skip, int type_class, struct link_map *undef_map)
790 +{
791 +  size_t n = scope->r_nlist;
792 +  /* Make sure we read the value before proceeding.  Otherwise we
793 +     might use r_list pointing to the initial scope and r_nlist being
794 +     the value after a resize.  That is the only path in dl-open.c not
795 +     protected by GSCOPE.  A read barrier here might be to expensive.  */
796 +  __asm volatile ("" : "+r" (n), "+m" (scope->r_list));
797 +  struct link_map **list = scope->r_list;
798 +
799 +  do
800 +    {
801 +      /* These variables are used in the nested function.  */
802 +      Elf_Symndx symidx;
803 +      int num_versions = 0;
804 +      const ElfW(Sym) *versioned_sym = NULL;
805 +
806 +      const struct link_map *map = list[i]->l_real;
807 +
808 +      /* Here come the extra test needed for `_dl_lookup_symbol_skip'.  */
809 +      if (map == skip)
810 +       continue;
811 +
812 +      /* Don't search the executable when resolving a copy reloc.  */
813 +      if ((type_class & ELF_RTYPE_CLASS_COPY) && map->l_type == lt_executable)
814 +       continue;
815 +
816 +      /* Do not look into objects which are going to be removed.  */
817 +      if (map->l_removed)
818 +       continue;
819 +
820 +      /* Print some debugging info if wanted.  */
821 +      if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS, 0))
822 +       _dl_debug_printf ("symbol=%s;  lookup in file=%s [%lu]\n",
823 +                         undef_name,
824 +                         map->l_name[0] ? map->l_name : rtld_progname,
825 +                         map->l_ns);
826 +
827 +      /* If the hash table is empty there is nothing to do here.  */
828 +      if (map->l_nbuckets == 0)
829 +       continue;
830 +
831 +      /* The tables for this map.  */
832 +      const ElfW(Sym) *symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
833 +      const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
834 +
835 +
836 +      /* Nested routine to check whether the symbol matches.  */
837 +      const ElfW(Sym) *
838 +      __attribute_noinline__
839 +      check_match (const ElfW(Sym) *sym)
840 +      {
841 +       unsigned int stt = ELFW(ST_TYPE) (sym->st_info);
842 +       assert (ELF_RTYPE_CLASS_PLT == 1);
843 +       /* The semantics of zero/non-zero values of undefined symbols
844 +          differs depending on whether the non-PIC ABI is in use.
845 +          Under the non-PIC ABI, a non-zero value indicates that
846 +          there is an address reference to the symbol and thus it
847 +          must always be resolved (except when resolving a jump slot
848 +          relocation) to the PLT entry whose address is provided as
849 +          the symbol's value; a zero value indicates that this
850 +          canonical-address behaviour is not required.  Yet under the
851 +          classic MIPS psABI, a zero value indicates that there is an
852 +          address reference to the function and the dynamic linker
853 +          must resolve the symbol immediately upon loading.  To avoid
854 +          conflict, symbols for which the dynamic linker must assume
855 +          the non-PIC ABI semantics are marked with the STO_MIPS_PLT
856 +          flag.  */
857 +       if (__builtin_expect ((sym->st_value == 0 /* No value.  */
858 +                              && stt != STT_TLS)
859 +                             || (sym->st_shndx == SHN_UNDEF
860 +                                 && !(sym->st_other & STO_MIPS_PLT))
861 +                             || (type_class & (sym->st_shndx == SHN_UNDEF)),
862 +                             0))
863 +         return NULL;
864 +
865 +       /* Ignore all but STT_NOTYPE, STT_OBJECT, STT_FUNC,
866 +          STT_COMMON, STT_TLS, and STT_GNU_IFUNC since these are no
867 +          code/data definitions.  */
868 +#define ALLOWED_STT \
869 +       ((1 << STT_NOTYPE) | (1 << STT_OBJECT) | (1 << STT_FUNC) \
870 +        | (1 << STT_COMMON) | (1 << STT_TLS) | (1 << STT_GNU_IFUNC))
871 +       if (__builtin_expect (((1 << stt) & ALLOWED_STT) == 0, 0))
872 +         return NULL;
873 +
874 +       if (sym != ref && strcmp (strtab + sym->st_name, undef_name))
875 +         /* Not the symbol we are looking for.  */
876 +         return NULL;
877 +
878 +       const ElfW(Half) *verstab = map->l_versyms;
879 +       if (version != NULL)
880 +         {
881 +           if (__builtin_expect (verstab == NULL, 0))
882 +             {
883 +               /* We need a versioned symbol but haven't found any.  If
884 +                  this is the object which is referenced in the verneed
885 +                  entry it is a bug in the library since a symbol must
886 +                  not simply disappear.
887 +
888 +                  It would also be a bug in the object since it means that
889 +                  the list of required versions is incomplete and so the
890 +                  tests in dl-version.c haven't found a problem.*/
891 +               assert (version->filename == NULL
892 +                       || ! _dl_name_match_p (version->filename, map));
893 +
894 +               /* Otherwise we accept the symbol.  */
895 +             }
896 +           else
897 +             {
898 +               /* We can match the version information or use the
899 +                  default one if it is not hidden.  */
900 +               ElfW(Half) ndx = verstab[symidx] & 0x7fff;
901 +               if ((map->l_versions[ndx].hash != version->hash
902 +                    || strcmp (map->l_versions[ndx].name, version->name))
903 +                   && (version->hidden || map->l_versions[ndx].hash
904 +                       || (verstab[symidx] & 0x8000)))
905 +                 /* It's not the version we want.  */
906 +                 return NULL;
907 +             }
908 +         }
909 +       else
910 +         {
911 +           /* No specific version is selected.  There are two ways we
912 +              can got here:
913 +
914 +              - a binary which does not include versioning information
915 +              is loaded
916 +
917 +              - dlsym() instead of dlvsym() is used to get a symbol which
918 +              might exist in more than one form
919 +
920 +              If the library does not provide symbol version information
921 +              there is no problem at at: we simply use the symbol if it
922 +              is defined.
923 +
924 +              These two lookups need to be handled differently if the
925 +              library defines versions.  In the case of the old
926 +              unversioned application the oldest (default) version
927 +              should be used.  In case of a dlsym() call the latest and
928 +              public interface should be returned.  */
929 +           if (verstab != NULL)
930 +             {
931 +               if ((verstab[symidx] & 0x7fff)
932 +                   >= ((flags & DL_LOOKUP_RETURN_NEWEST) ? 2 : 3))
933 +                 {
934 +                   /* Don't accept hidden symbols.  */
935 +                   if ((verstab[symidx] & 0x8000) == 0
936 +                       && num_versions++ == 0)
937 +                     /* No version so far.  */
938 +                     versioned_sym = sym;
939 +
940 +                   return NULL;
941 +                 }
942 +             }
943 +         }
944 +
945 +       /* There cannot be another entry for this symbol so stop here.  */
946 +       return sym;
947 +      }
948 +
949 +      const ElfW(Sym) *sym;
950 +      const ElfW(Addr) *bitmask = map->l_gnu_bitmask;
951 +      if (__builtin_expect (bitmask != NULL, 1))
952 +       {
953 +         ElfW(Addr) bitmask_word
954 +           = bitmask[(new_hash / __ELF_NATIVE_CLASS)
955 +                     & map->l_gnu_bitmask_idxbits];
956 +
957 +         unsigned int hashbit1 = new_hash & (__ELF_NATIVE_CLASS - 1);
958 +         unsigned int hashbit2 = ((new_hash >> map->l_gnu_shift)
959 +                                  & (__ELF_NATIVE_CLASS - 1));
960 +
961 +         if (__builtin_expect ((bitmask_word >> hashbit1)
962 +                               & (bitmask_word >> hashbit2) & 1, 0))
963 +           {
964 +             Elf32_Word bucket = map->l_gnu_buckets[new_hash
965 +                                                    % map->l_nbuckets];
966 +             if (bucket != 0)
967 +               {
968 +                 const Elf32_Word *hasharr = &map->l_gnu_chain_zero[bucket];
969 +
970 +                 do
971 +                   if (((*hasharr ^ new_hash) >> 1) == 0)
972 +                     {
973 +                       symidx = hasharr - map->l_gnu_chain_zero;
974 +                       sym = check_match (&symtab[symidx]);
975 +                       if (sym != NULL)
976 +                         goto found_it;
977 +                     }
978 +                 while ((*hasharr++ & 1u) == 0);
979 +               }
980 +           }
981 +         /* No symbol found.  */
982 +         symidx = SHN_UNDEF;
983 +       }
984 +      else
985 +       {
986 +         if (*old_hash == 0xffffffff)
987 +           *old_hash = _dl_elf_hash (undef_name);
988 +
989 +         /* Use the old SysV-style hash table.  Search the appropriate
990 +            hash bucket in this object's symbol table for a definition
991 +            for the same symbol name.  */
992 +         for (symidx = map->l_buckets[*old_hash % map->l_nbuckets];
993 +              symidx != STN_UNDEF;
994 +              symidx = map->l_chain[symidx])
995 +           {
996 +             sym = check_match (&symtab[symidx]);
997 +             if (sym != NULL)
998 +               goto found_it;
999 +           }
1000 +       }
1001 +
1002 +      /* If we have seen exactly one versioned symbol while we are
1003 +        looking for an unversioned symbol and the version is not the
1004 +        default version we still accept this symbol since there are
1005 +        no possible ambiguities.  */
1006 +      sym = num_versions == 1 ? versioned_sym : NULL;
1007 +
1008 +      if (sym != NULL)
1009 +       {
1010 +       found_it:
1011 +         switch (__builtin_expect (ELFW(ST_BIND) (sym->st_info), STB_GLOBAL))
1012 +           {
1013 +           case STB_WEAK:
1014 +             /* Weak definition.  Use this value if we don't find another.  */
1015 +             if (__builtin_expect (GLRO(dl_dynamic_weak), 0))
1016 +               {
1017 +                 if (! result->s)
1018 +                   {
1019 +                     result->s = sym;
1020 +                     result->m = (struct link_map *) map;
1021 +                   }
1022 +                 break;
1023 +               }
1024 +             /* FALLTHROUGH */
1025 +           case STB_GLOBAL:
1026 +           success:
1027 +             /* Global definition.  Just what we need.  */
1028 +             result->s = sym;
1029 +             result->m = (struct link_map *) map;
1030 +             return 1;
1031 +
1032 +           case STB_GNU_UNIQUE:;
1033 +             /* We have to determine whether we already found a
1034 +                symbol with this name before.  If not then we have to
1035 +                add it to the search table.  If we already found a
1036 +                definition we have to use it.  */
1037 +             void enter (struct unique_sym *table, size_t size,
1038 +                         unsigned int hash, const char *name,
1039 +                         const ElfW(Sym) *sym, struct link_map *map)
1040 +             {
1041 +               size_t idx = hash % size;
1042 +               size_t hash2 = 1 + hash % (size - 2);
1043 +               while (1)
1044 +                 {
1045 +                   if (table[idx].name == NULL)
1046 +                     {
1047 +                       table[idx].hashval = hash;
1048 +                       table[idx].name = name;
1049 +                       if ((type_class & ELF_RTYPE_CLASS_COPY) != 0)
1050 +                         {
1051 +                           table[idx].sym = ref;
1052 +                           table[idx].map = undef_map;
1053 +                         }
1054 +                       else
1055 +                         {
1056 +                           table[idx].sym = sym;
1057 +                           table[idx].map = map;
1058 +
1059 +                           if (map->l_type == lt_loaded)
1060 +                             /* Make sure we don't unload this object by
1061 +                                setting the appropriate flag.  */
1062 +                             map->l_flags_1 |= DF_1_NODELETE;
1063 +                         }
1064 +
1065 +                       return;
1066 +                     }
1067 +
1068 +                   idx += hash2;
1069 +                   if (idx >= size)
1070 +                     idx -= size;
1071 +                 }
1072 +             }
1073 +
1074 +             struct unique_sym_table *tab
1075 +               = &GL(dl_ns)[map->l_ns]._ns_unique_sym_table;
1076 +
1077 +             __rtld_lock_lock_recursive (tab->lock);
1078 +
1079 +             struct unique_sym *entries = tab->entries;
1080 +             size_t size = tab->size;
1081 +             if (entries != NULL)
1082 +               {
1083 +                 size_t idx = new_hash % size;
1084 +                 size_t hash2 = 1 + new_hash % (size - 2);
1085 +                 while (1)
1086 +                   {
1087 +                     if (entries[idx].hashval == new_hash
1088 +                         && strcmp (entries[idx].name, undef_name) == 0)
1089 +                       {
1090 +                         result->s = entries[idx].sym;
1091 +                         result->m = (struct link_map *) entries[idx].map;
1092 +                         __rtld_lock_unlock_recursive (tab->lock);
1093 +                         return 1;
1094 +                       }
1095 +
1096 +                     if (entries[idx].name == NULL)
1097 +                       break;
1098 +
1099 +                     idx += hash2;
1100 +                     if (idx >= size)
1101 +                       idx -= size;
1102 +                   }
1103 +
1104 +                 if (size * 3 <= tab->n_elements * 4)
1105 +                   {
1106 +                     /* Expand the table.  */
1107 +#ifdef RTLD_CHECK_FOREIGN_CALL
1108 +                     /* This must not happen during runtime relocations.  */
1109 +                     assert (!RTLD_CHECK_FOREIGN_CALL);
1110 +#endif
1111 +                     size_t newsize = _dl_higher_prime_number (size + 1);
1112 +                     struct unique_sym *newentries
1113 +                       = calloc (sizeof (struct unique_sym), newsize);
1114 +                     if (newentries == NULL)
1115 +                       {
1116 +                       nomem:
1117 +                         __rtld_lock_unlock_recursive (tab->lock);
1118 +                         _dl_fatal_printf ("out of memory\n");
1119 +                       }
1120 +
1121 +                     for (idx = 0; idx < size; ++idx)
1122 +                       if (entries[idx].name != NULL)
1123 +                         enter (newentries, newsize, entries[idx].hashval,
1124 +                                entries[idx].name, entries[idx].sym,
1125 +                                entries[idx].map);
1126 +
1127 +                     tab->free (entries);
1128 +                     tab->size = newsize;
1129 +                     size = newsize;
1130 +                     entries = tab->entries = newentries;
1131 +                     tab->free = free;
1132 +                   }
1133 +               }
1134 +             else
1135 +               {
1136 +#ifdef RTLD_CHECK_FOREIGN_CALL
1137 +                 /* This must not happen during runtime relocations.  */
1138 +                 assert (!RTLD_CHECK_FOREIGN_CALL);
1139 +#endif
1140 +
1141 +#ifdef SHARED
1142 +                 /* If tab->entries is NULL, but tab->size is not, it means
1143 +                    this is the second, conflict finding, lookup for
1144 +                    LD_TRACE_PRELINKING in _dl_debug_bindings.  Don't
1145 +                    allocate anything and don't enter anything into the
1146 +                    hash table.  */
1147 +                 if (__builtin_expect (tab->size, 0))
1148 +                   {
1149 +                     assert (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK);
1150 +                     __rtld_lock_unlock_recursive (tab->lock);
1151 +                     goto success;
1152 +                   }
1153 +#endif
1154 +
1155 +#define INITIAL_NUNIQUE_SYM_TABLE 31
1156 +                 size = INITIAL_NUNIQUE_SYM_TABLE;
1157 +                 entries = calloc (sizeof (struct unique_sym), size);
1158 +                 if (entries == NULL)
1159 +                   goto nomem;
1160 +
1161 +                 tab->entries = entries;
1162 +                 tab->size = size;
1163 +                 tab->free = free;
1164 +               }
1165 +
1166 +             enter (entries, size, new_hash, strtab + sym->st_name, sym,
1167 +                    (struct link_map *) map);
1168 +             ++tab->n_elements;
1169 +
1170 +             __rtld_lock_unlock_recursive (tab->lock);
1171 +
1172 +             goto success;
1173 +
1174 +           default:
1175 +             /* Local symbols are ignored.  */
1176 +             break;
1177 +           }
1178 +       }
1179 +
1180 +      /* If this current map is the one mentioned in the verneed entry
1181 +        and we have not found a weak entry, it is a bug.  */
1182 +      if (symidx == STN_UNDEF && version != NULL && version->filename != NULL
1183 +         && __builtin_expect (_dl_name_match_p (version->filename, map), 0))
1184 +       return -1;
1185 +    }
1186 +  while (++i < n);
1187 +
1188 +  /* We have not found anything until now.  */
1189 +  return 0;
1190 +}
1191 +
1192 +
1193 +static uint_fast32_t
1194 +dl_new_hash (const char *s)
1195 +{
1196 +  uint_fast32_t h = 5381;
1197 +  for (unsigned char c = *s; c != '\0'; c = *++s)
1198 +    h = h * 33 + c;
1199 +  return h & 0xffffffff;
1200 +}
1201 +
1202 +
1203 +/* Add extra dependency on MAP to UNDEF_MAP.  */
1204 +static int
1205 +internal_function
1206 +add_dependency (struct link_map *undef_map, struct link_map *map, int flags)
1207 +{
1208 +  struct link_map *runp;
1209 +  unsigned int i;
1210 +  int result = 0;
1211 +
1212 +  /* Avoid self-references and references to objects which cannot be
1213 +     unloaded anyway.  */
1214 +  if (undef_map == map)
1215 +    return 0;
1216 +
1217 +  /* Avoid references to objects which cannot be unloaded anyway.  */
1218 +  assert (map->l_type == lt_loaded);
1219 +  if ((map->l_flags_1 & DF_1_NODELETE) != 0)
1220 +    return 0;
1221 +
1222 +  struct link_map_reldeps *l_reldeps
1223 +    = atomic_forced_read (undef_map->l_reldeps);
1224 +
1225 +  /* Make sure l_reldeps is read before l_initfini.  */
1226 +  atomic_read_barrier ();
1227 +
1228 +  /* Determine whether UNDEF_MAP already has a reference to MAP.  First
1229 +     look in the normal dependencies.  */
1230 +  struct link_map **l_initfini = atomic_forced_read (undef_map->l_initfini);
1231 +  if (l_initfini != NULL)
1232 +    {
1233 +      for (i = 0; l_initfini[i] != NULL; ++i)
1234 +       if (l_initfini[i] == map)
1235 +         return 0;
1236 +    }
1237 +
1238 +  /* No normal dependency.  See whether we already had to add it
1239 +     to the special list of dynamic dependencies.  */
1240 +  unsigned int l_reldepsact = 0;
1241 +  if (l_reldeps != NULL)
1242 +    {
1243 +      struct link_map **list = &l_reldeps->list[0];
1244 +      l_reldepsact = l_reldeps->act;
1245 +      for (i = 0; i < l_reldepsact; ++i)
1246 +       if (list[i] == map)
1247 +         return 0;
1248 +    }
1249 +
1250 +  /* Save serial number of the target MAP.  */
1251 +  unsigned long long serial = map->l_serial;
1252 +
1253 +  /* Make sure nobody can unload the object while we are at it.  */
1254 +  if (__builtin_expect (flags & DL_LOOKUP_GSCOPE_LOCK, 0))
1255 +    {
1256 +      /* We can't just call __rtld_lock_lock_recursive (GL(dl_load_lock))
1257 +        here, that can result in ABBA deadlock.  */
1258 +      THREAD_GSCOPE_RESET_FLAG ();
1259 +      __rtld_lock_lock_recursive (GL(dl_load_lock));
1260 +      /* While MAP value won't change, after THREAD_GSCOPE_RESET_FLAG ()
1261 +        it can e.g. point to unallocated memory.  So avoid the optimizer
1262 +        treating the above read from MAP->l_serial as ensurance it
1263 +        can safely dereference it.  */
1264 +      map = atomic_forced_read (map);
1265 +
1266 +      /* From this point on it is unsafe to dereference MAP, until it
1267 +        has been found in one of the lists.  */
1268 +
1269 +      /* Redo the l_initfini check in case undef_map's l_initfini
1270 +        changed in the mean time.  */
1271 +      if (undef_map->l_initfini != l_initfini
1272 +         && undef_map->l_initfini != NULL)
1273 +       {
1274 +         l_initfini = undef_map->l_initfini;
1275 +         for (i = 0; l_initfini[i] != NULL; ++i)
1276 +           if (l_initfini[i] == map)
1277 +             goto out_check;
1278 +       }
1279 +
1280 +      /* Redo the l_reldeps check if undef_map's l_reldeps changed in
1281 +        the mean time.  */
1282 +      if (undef_map->l_reldeps != NULL)
1283 +       {
1284 +         if (undef_map->l_reldeps != l_reldeps)
1285 +           {
1286 +             struct link_map **list = &undef_map->l_reldeps->list[0];
1287 +             l_reldepsact = undef_map->l_reldeps->act;
1288 +             for (i = 0; i < l_reldepsact; ++i)
1289 +               if (list[i] == map)
1290 +                 goto out_check;
1291 +           }
1292 +         else if (undef_map->l_reldeps->act > l_reldepsact)
1293 +           {
1294 +             struct link_map **list
1295 +               = &undef_map->l_reldeps->list[0];
1296 +             i = l_reldepsact;
1297 +             l_reldepsact = undef_map->l_reldeps->act;
1298 +             for (; i < l_reldepsact; ++i)
1299 +               if (list[i] == map)
1300 +                 goto out_check;
1301 +           }
1302 +       }
1303 +    }
1304 +  else
1305 +    __rtld_lock_lock_recursive (GL(dl_load_lock));
1306 +
1307 +  /* The object is not yet in the dependency list.  Before we add
1308 +     it make sure just one more time the object we are about to
1309 +     reference is still available.  There is a brief period in
1310 +     which the object could have been removed since we found the
1311 +     definition.  */
1312 +  runp = GL(dl_ns)[undef_map->l_ns]._ns_loaded;
1313 +  while (runp != NULL && runp != map)
1314 +    runp = runp->l_next;
1315 +
1316 +  if (runp != NULL)
1317 +    {
1318 +      /* The object is still available.  */
1319 +
1320 +      /* MAP could have been dlclosed, freed and then some other dlopened
1321 +        library could have the same link_map pointer.  */
1322 +      if (map->l_serial != serial)
1323 +       goto out_check;
1324 +
1325 +      /* Redo the NODELETE check, as when dl_load_lock wasn't held
1326 +        yet this could have changed.  */
1327 +      if ((map->l_flags_1 & DF_1_NODELETE) != 0)
1328 +       goto out;
1329 +
1330 +      /* If the object with the undefined reference cannot be removed ever
1331 +        just make sure the same is true for the object which contains the
1332 +        definition.  */
1333 +      if (undef_map->l_type != lt_loaded
1334 +         || (undef_map->l_flags_1 & DF_1_NODELETE) != 0)
1335 +       {
1336 +         map->l_flags_1 |= DF_1_NODELETE;
1337 +         goto out;
1338 +       }
1339 +
1340 +      /* Add the reference now.  */
1341 +      if (__builtin_expect (l_reldepsact >= undef_map->l_reldepsmax, 0))
1342 +       {
1343 +         /* Allocate more memory for the dependency list.  Since this
1344 +            can never happen during the startup phase we can use
1345 +            `realloc'.  */
1346 +         struct link_map_reldeps *newp;
1347 +         unsigned int max
1348 +           = undef_map->l_reldepsmax ? undef_map->l_reldepsmax * 2 : 10;
1349 +
1350 +#ifdef RTLD_PREPARE_FOREIGN_CALL
1351 +         RTLD_PREPARE_FOREIGN_CALL;
1352 +#endif
1353 +
1354 +         newp = malloc (sizeof (*newp) + max * sizeof (struct link_map *));
1355 +         if (newp == NULL)
1356 +           {
1357 +             /* If we didn't manage to allocate memory for the list this is
1358 +                no fatal problem.  We simply make sure the referenced object
1359 +                cannot be unloaded.  This is semantically the correct
1360 +                behavior.  */
1361 +             map->l_flags_1 |= DF_1_NODELETE;
1362 +             goto out;
1363 +           }
1364 +         else
1365 +           {
1366 +             if (l_reldepsact)
1367 +               memcpy (&newp->list[0], &undef_map->l_reldeps->list[0],
1368 +                       l_reldepsact * sizeof (struct link_map *));
1369 +             newp->list[l_reldepsact] = map;
1370 +             newp->act = l_reldepsact + 1;
1371 +             atomic_write_barrier ();
1372 +             void *old = undef_map->l_reldeps;
1373 +             undef_map->l_reldeps = newp;
1374 +             undef_map->l_reldepsmax = max;
1375 +             if (old)
1376 +               _dl_scope_free (old);
1377 +           }
1378 +       }
1379 +      else
1380 +       {
1381 +         undef_map->l_reldeps->list[l_reldepsact] = map;
1382 +         atomic_write_barrier ();
1383 +         undef_map->l_reldeps->act = l_reldepsact + 1;
1384 +       }
1385 +
1386 +      /* Display information if we are debugging.  */
1387 +      if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
1388 +       _dl_debug_printf ("\
1389 +\nfile=%s [%lu];  needed by %s [%lu] (relocation dependency)\n\n",
1390 +                         map->l_name[0] ? map->l_name : rtld_progname,
1391 +                         map->l_ns,
1392 +                         undef_map->l_name[0]
1393 +                         ? undef_map->l_name : rtld_progname,
1394 +                         undef_map->l_ns);
1395 +    }
1396 +  else
1397 +    /* Whoa, that was bad luck.  We have to search again.  */
1398 +    result = -1;
1399 +
1400 + out:
1401 +  /* Release the lock.  */
1402 +  __rtld_lock_unlock_recursive (GL(dl_load_lock));
1403 +
1404 +  if (__builtin_expect (flags & DL_LOOKUP_GSCOPE_LOCK, 0))
1405 +    THREAD_GSCOPE_SET_FLAG ();
1406 +
1407 +  return result;
1408 +
1409 + out_check:
1410 +  if (map->l_serial != serial)
1411 +    result = -1;
1412 +  goto out;
1413 +}
1414 +
1415 +static void
1416 +internal_function
1417 +_dl_debug_bindings (const char *undef_name, struct link_map *undef_map,
1418 +                   const ElfW(Sym) **ref, struct sym_val *value,
1419 +                   const struct r_found_version *version, int type_class,
1420 +                   int protected);
1421 +
1422 +
1423 +/* Search loaded objects' symbol tables for a definition of the symbol
1424 +   UNDEF_NAME, perhaps with a requested version for the symbol.
1425 +
1426 +   We must never have calls to the audit functions inside this function
1427 +   or in any function which gets called.  If this would happen the audit
1428 +   code might create a thread which can throw off all the scope locking.  */
1429 +lookup_t
1430 +internal_function
1431 +_dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
1432 +                    const ElfW(Sym) **ref,
1433 +                    struct r_scope_elem *symbol_scope[],
1434 +                    const struct r_found_version *version,
1435 +                    int type_class, int flags, struct link_map *skip_map)
1436 +{
1437 +  const uint_fast32_t new_hash = dl_new_hash (undef_name);
1438 +  unsigned long int old_hash = 0xffffffff;
1439 +  struct sym_val current_value = { NULL, NULL };
1440 +  struct r_scope_elem **scope = symbol_scope;
1441 +
1442 +  bump_num_relocations ();
1443 +
1444 +  /* No other flag than DL_LOOKUP_ADD_DEPENDENCY or DL_LOOKUP_GSCOPE_LOCK
1445 +     is allowed if we look up a versioned symbol.  */
1446 +  assert (version == NULL
1447 +         || (flags & ~(DL_LOOKUP_ADD_DEPENDENCY | DL_LOOKUP_GSCOPE_LOCK))
1448 +            == 0);
1449 +
1450 +  size_t i = 0;
1451 +  if (__builtin_expect (skip_map != NULL, 0))
1452 +    /* Search the relevant loaded objects for a definition.  */
1453 +    while ((*scope)->r_list[i] != skip_map)
1454 +      ++i;
1455 +
1456 +  /* Search the relevant loaded objects for a definition.  */
1457 +  for (size_t start = i; *scope != NULL; start = 0, ++scope)
1458 +    {
1459 +      int res = do_lookup_x (undef_name, new_hash, &old_hash, *ref,
1460 +                            &current_value, *scope, start, version, flags,
1461 +                            skip_map, type_class, undef_map);
1462 +      if (res > 0)
1463 +       break;
1464 +
1465 +      if (__builtin_expect (res, 0) < 0 && skip_map == NULL)
1466 +       {
1467 +         /* Oh, oh.  The file named in the relocation entry does not
1468 +            contain the needed symbol.  This code is never reached
1469 +            for unversioned lookups.  */
1470 +         assert (version != NULL);
1471 +         const char *reference_name = undef_map ? undef_map->l_name : NULL;
1472 +
1473 +         /* XXX We cannot translate the message.  */
1474 +         _dl_signal_cerror (0, (reference_name[0]
1475 +                                ? reference_name
1476 +                                : (rtld_progname ?: "<main program>")),
1477 +                            N_("relocation error"),
1478 +                            make_string ("symbol ", undef_name, ", version ",
1479 +                                         version->name,
1480 +                                         " not defined in file ",
1481 +                                         version->filename,
1482 +                                         " with link time reference",
1483 +                                         res == -2
1484 +                                         ? " (no version symbols)" : ""));
1485 +         *ref = NULL;
1486 +         return 0;
1487 +       }
1488 +    }
1489 +
1490 +  if (__builtin_expect (current_value.s == NULL, 0))
1491 +    {
1492 +      if ((*ref == NULL || ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)
1493 +         && skip_map == NULL)
1494 +       {
1495 +         /* We could find no value for a strong reference.  */
1496 +         const char *reference_name = undef_map ? undef_map->l_name : "";
1497 +         const char *versionstr = version ? ", version " : "";
1498 +         const char *versionname = (version && version->name
1499 +                                    ? version->name : "");
1500 +
1501 +         /* XXX We cannot translate the message.  */
1502 +         _dl_signal_cerror (0, (reference_name[0]
1503 +                                ? reference_name
1504 +                                : (rtld_progname ?: "<main program>")),
1505 +                            N_("symbol lookup error"),
1506 +                            make_string (undefined_msg, undef_name,
1507 +                                         versionstr, versionname));
1508 +       }
1509 +      *ref = NULL;
1510 +      return 0;
1511 +    }
1512 +
1513 +  int protected = (*ref
1514 +                  && ELFW(ST_VISIBILITY) ((*ref)->st_other) == STV_PROTECTED);
1515 +  if (__builtin_expect (protected != 0, 0))
1516 +    {
1517 +      /* It is very tricky.  We need to figure out what value to
1518 +        return for the protected symbol.  */
1519 +      if (type_class == ELF_RTYPE_CLASS_PLT)
1520 +       {
1521 +         if (current_value.s != NULL && current_value.m != undef_map)
1522 +           {
1523 +             current_value.s = *ref;
1524 +             current_value.m = undef_map;
1525 +           }
1526 +       }
1527 +      else
1528 +       {
1529 +         struct sym_val protected_value = { NULL, NULL };
1530 +
1531 +         for (scope = symbol_scope; *scope != NULL; i = 0, ++scope)
1532 +           if (do_lookup_x (undef_name, new_hash, &old_hash, *ref,
1533 +                            &protected_value, *scope, i, version, flags,
1534 +                            skip_map, ELF_RTYPE_CLASS_PLT, NULL) != 0)
1535 +             break;
1536 +
1537 +         if (protected_value.s != NULL && protected_value.m != undef_map)
1538 +           {
1539 +             current_value.s = *ref;
1540 +             current_value.m = undef_map;
1541 +           }
1542 +       }
1543 +    }
1544 +
1545 +  /* We have to check whether this would bind UNDEF_MAP to an object
1546 +     in the global scope which was dynamically loaded.  In this case
1547 +     we have to prevent the latter from being unloaded unless the
1548 +     UNDEF_MAP object is also unloaded.  */
1549 +  if (__builtin_expect (current_value.m->l_type == lt_loaded, 0)
1550 +      /* Don't do this for explicit lookups as opposed to implicit
1551 +        runtime lookups.  */
1552 +      && (flags & DL_LOOKUP_ADD_DEPENDENCY) != 0
1553 +      /* Add UNDEF_MAP to the dependencies.  */
1554 +      && add_dependency (undef_map, current_value.m, flags) < 0)
1555 +      /* Something went wrong.  Perhaps the object we tried to reference
1556 +        was just removed.  Try finding another definition.  */
1557 +      return _dl_lookup_symbol_x (undef_name, undef_map, ref,
1558 +                                 (flags & DL_LOOKUP_GSCOPE_LOCK)
1559 +                                 ? undef_map->l_scope : symbol_scope,
1560 +                                 version, type_class, flags, skip_map);
1561 +
1562 +  /* The object is used.  */
1563 +  if (__builtin_expect (current_value.m->l_used == 0, 0))
1564 +    current_value.m->l_used = 1;
1565 +
1566 +  if (__builtin_expect (GLRO(dl_debug_mask)
1567 +                       & (DL_DEBUG_BINDINGS|DL_DEBUG_PRELINK), 0))
1568 +    _dl_debug_bindings (undef_name, undef_map, ref,
1569 +                       &current_value, version, type_class, protected);
1570 +
1571 +  *ref = current_value.s;
1572 +  return LOOKUP_VALUE (current_value.m);
1573 +}
1574 +
1575 +
1576 +/* Cache the location of MAP's hash table.  */
1577 +
1578 +void
1579 +internal_function
1580 +_dl_setup_hash (struct link_map *map)
1581 +{
1582 +  Elf_Symndx *hash;
1583 +  Elf_Symndx nchain;
1584 +
1585 +  if (__builtin_expect (map->l_info[DT_ADDRTAGIDX (DT_GNU_HASH) + DT_NUM
1586 +                                   + DT_THISPROCNUM + DT_VERSIONTAGNUM
1587 +                                   + DT_EXTRANUM + DT_VALNUM] != NULL, 1))
1588 +    {
1589 +      Elf32_Word *hash32
1590 +       = (void *) D_PTR (map, l_info[DT_ADDRTAGIDX (DT_GNU_HASH) + DT_NUM
1591 +                                     + DT_THISPROCNUM + DT_VERSIONTAGNUM
1592 +                                     + DT_EXTRANUM + DT_VALNUM]);
1593 +      map->l_nbuckets = *hash32++;
1594 +      Elf32_Word symbias = *hash32++;
1595 +      Elf32_Word bitmask_nwords = *hash32++;
1596 +      /* Must be a power of two.  */
1597 +      assert ((bitmask_nwords & (bitmask_nwords - 1)) == 0);
1598 +      map->l_gnu_bitmask_idxbits = bitmask_nwords - 1;
1599 +      map->l_gnu_shift = *hash32++;
1600 +
1601 +      map->l_gnu_bitmask = (ElfW(Addr) *) hash32;
1602 +      hash32 += __ELF_NATIVE_CLASS / 32 * bitmask_nwords;
1603 +
1604 +      map->l_gnu_buckets = hash32;
1605 +      hash32 += map->l_nbuckets;
1606 +      map->l_gnu_chain_zero = hash32 - symbias;
1607 +      return;
1608 +    }
1609 +
1610 +  if (!map->l_info[DT_HASH])
1611 +    return;
1612 +  hash = (void *) D_PTR (map, l_info[DT_HASH]);
1613 +
1614 +  map->l_nbuckets = *hash++;
1615 +  nchain = *hash++;
1616 +  map->l_buckets = hash;
1617 +  hash += map->l_nbuckets;
1618 +  map->l_chain = hash;
1619 +}
1620 +
1621 +
1622 +static void
1623 +internal_function
1624 +_dl_debug_bindings (const char *undef_name, struct link_map *undef_map,
1625 +                   const ElfW(Sym) **ref, struct sym_val *value,
1626 +                   const struct r_found_version *version, int type_class,
1627 +                   int protected)
1628 +{
1629 +  const char *reference_name = undef_map->l_name;
1630 +
1631 +  if (GLRO(dl_debug_mask) & DL_DEBUG_BINDINGS)
1632 +    {
1633 +      _dl_debug_printf ("binding file %s [%lu] to %s [%lu]: %s symbol `%s'",
1634 +                       (reference_name[0]
1635 +                        ? reference_name
1636 +                        : (rtld_progname ?: "<main program>")),
1637 +                       undef_map->l_ns,
1638 +                       value->m->l_name[0] ? value->m->l_name : rtld_progname,
1639 +                       value->m->l_ns,
1640 +                       protected ? "protected" : "normal", undef_name);
1641 +      if (version)
1642 +       _dl_debug_printf_c (" [%s]\n", version->name);
1643 +      else
1644 +       _dl_debug_printf_c ("\n");
1645 +    }
1646 +#ifdef SHARED
1647 +  if (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1648 +    {
1649 +      int conflict = 0;
1650 +      struct sym_val val = { NULL, NULL };
1651 +
1652 +      if ((GLRO(dl_trace_prelink_map) == NULL
1653 +          || GLRO(dl_trace_prelink_map) == GL(dl_ns)[LM_ID_BASE]._ns_loaded)
1654 +         && undef_map != GL(dl_ns)[LM_ID_BASE]._ns_loaded)
1655 +       {
1656 +         const uint_fast32_t new_hash = dl_new_hash (undef_name);
1657 +         unsigned long int old_hash = 0xffffffff;
1658 +         struct unique_sym *saved_entries
1659 +           = GL(dl_ns)[LM_ID_BASE]._ns_unique_sym_table.entries;
1660 +
1661 +         GL(dl_ns)[LM_ID_BASE]._ns_unique_sym_table.entries = NULL;
1662 +         do_lookup_x (undef_name, new_hash, &old_hash, *ref, &val,
1663 +                      undef_map->l_local_scope[0], 0, version, 0, NULL,
1664 +                      type_class, undef_map);
1665 +         if (val.s != value->s || val.m != value->m)
1666 +           conflict = 1;
1667 +         else if (__builtin_expect (undef_map->l_symbolic_in_local_scope, 0)
1668 +                  && val.s
1669 +                  && __builtin_expect (ELFW(ST_BIND) (val.s->st_info),
1670 +                                       STB_GLOBAL) == STB_GNU_UNIQUE)
1671 +           {
1672 +             /* If it is STB_GNU_UNIQUE and undef_map's l_local_scope
1673 +                contains any DT_SYMBOLIC libraries, unfortunately there
1674 +                can be conflicts even if the above is equal.  As symbol
1675 +                resolution goes from the last library to the first and
1676 +                if a STB_GNU_UNIQUE symbol is found in some late DT_SYMBOLIC
1677 +                library, it would be the one that is looked up.  */
1678 +             struct sym_val val2 = { NULL, NULL };
1679 +             size_t n;
1680 +             struct r_scope_elem *scope = undef_map->l_local_scope[0];
1681 +
1682 +             for (n = 0; n < scope->r_nlist; n++)
1683 +               if (scope->r_list[n] == val.m)
1684 +                 break;
1685 +
1686 +             for (n++; n < scope->r_nlist; n++)
1687 +               if (scope->r_list[n]->l_info[DT_SYMBOLIC] != NULL
1688 +                   && do_lookup_x (undef_name, new_hash, &old_hash, *ref,
1689 +                                   &val2,
1690 +                                   &scope->r_list[n]->l_symbolic_searchlist,
1691 +                                   0, version, 0, NULL, type_class,
1692 +                                   undef_map) > 0)
1693 +                 {
1694 +                   conflict = 1;
1695 +                   val = val2;
1696 +                   break;
1697 +                 }
1698 +           }
1699 +         GL(dl_ns)[LM_ID_BASE]._ns_unique_sym_table.entries = saved_entries;
1700 +       }
1701 +
1702 +      if (value->s)
1703 +       {
1704 +         if (__builtin_expect (ELFW(ST_TYPE) (value->s->st_info)
1705 +                               == STT_TLS, 0))
1706 +           type_class = 4;
1707 +         else if (__builtin_expect (ELFW(ST_TYPE) (value->s->st_info)
1708 +                                    == STT_GNU_IFUNC, 0))
1709 +           type_class |= 8;
1710 +       }
1711 +
1712 +      if (conflict
1713 +         || GLRO(dl_trace_prelink_map) == undef_map
1714 +         || GLRO(dl_trace_prelink_map) == NULL
1715 +         || type_class >= 4)
1716 +       {
1717 +         _dl_printf ("%s 0x%0*Zx 0x%0*Zx -> 0x%0*Zx 0x%0*Zx ",
1718 +                     conflict ? "conflict" : "lookup",
1719 +                     (int) sizeof (ElfW(Addr)) * 2,
1720 +                     (size_t) undef_map->l_map_start,
1721 +                     (int) sizeof (ElfW(Addr)) * 2,
1722 +                     (size_t) (((ElfW(Addr)) *ref) - undef_map->l_map_start),
1723 +                     (int) sizeof (ElfW(Addr)) * 2,
1724 +                     (size_t) (value->s ? value->m->l_map_start : 0),
1725 +                     (int) sizeof (ElfW(Addr)) * 2,
1726 +                     (size_t) (value->s ? value->s->st_value : 0));
1727 +
1728 +         if (conflict)
1729 +           _dl_printf ("x 0x%0*Zx 0x%0*Zx ",
1730 +                       (int) sizeof (ElfW(Addr)) * 2,
1731 +                       (size_t) (val.s ? val.m->l_map_start : 0),
1732 +                       (int) sizeof (ElfW(Addr)) * 2,
1733 +                       (size_t) (val.s ? val.s->st_value : 0));
1734 +
1735 +         _dl_printf ("/%x %s\n", type_class, undef_name);
1736 +       }
1737 +    }
1738 +#endif
1739 +}
1740 diff -ruN glibc-2.19/sysdeps/riscv/dl-machine.h glibc-2.19-riscv/sysdeps/riscv/dl-machine.h
1741 --- glibc-2.19/sysdeps/riscv/dl-machine.h       1969-12-31 16:00:00.000000000 -0800
1742 +++ glibc-2.19-riscv/sysdeps/riscv/dl-machine.h 2014-12-09 16:55:03.156727789 -0800
1743 @@ -0,0 +1,717 @@
1744 +/* Machine-dependent ELF dynamic relocation inline functions.  MIPS version.
1745 +   Copyright (C) 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007
1746 +   Free Software Foundation, Inc.
1747 +   This file is part of the GNU C Library.
1748 +   Contributed by Kazumoto Kojima <kkojima@info.kanagawa-u.ac.jp>.
1749 +
1750 +   The GNU C Library is free software; you can redistribute it and/or
1751 +   modify it under the terms of the GNU Lesser General Public
1752 +   License as published by the Free Software Foundation; either
1753 +   version 2.1 of the License, or (at your option) any later version.
1754 +
1755 +   The GNU C Library is distributed in the hope that it will be useful,
1756 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
1757 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1758 +   Lesser General Public License for more details.
1759 +
1760 +   You should have received a copy of the GNU Lesser General Public
1761 +   License along with the GNU C Library; if not, write to the Free
1762 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
1763 +   02111-1307 USA.  */
1764 +
1765 +/*  FIXME: Profiling of shared libraries is not implemented yet.  */
1766 +#ifndef dl_machine_h
1767 +#define dl_machine_h
1768 +
1769 +#define ELF_MACHINE_NAME "RISC-V"
1770 +
1771 +#include <entry.h>
1772 +
1773 +#ifndef ENTRY_POINT
1774 +#error ENTRY_POINT needs to be defined for MIPS.
1775 +#endif
1776 +
1777 +#include <sys/asm.h>
1778 +#include <dl-tls.h>
1779 +
1780 +#ifndef _RTLD_PROLOGUE
1781 +# define _RTLD_PROLOGUE(entry)                                         \
1782 +       ".globl\t" __STRING(entry) "\n\t"                               \
1783 +       ".type\t" __STRING(entry) ", @function\n"                       \
1784 +       __STRING(entry) ":\n\t"
1785 +#endif
1786 +
1787 +#ifndef _RTLD_EPILOGUE
1788 +# define _RTLD_EPILOGUE(entry)                                         \
1789 +       ".size\t" __STRING(entry) ", . - " __STRING(entry) "\n\t"
1790 +#endif
1791 +
1792 +/* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.
1793 +   This only makes sense on MIPS when using PLTs, so choose the
1794 +   PLT relocation (not encountered when not using PLTs).  */
1795 +#define ELF_MACHINE_JMP_SLOT                   R_MIPS_JUMP_SLOT
1796 +#define elf_machine_type_class(type) \
1797 +  ((((type) == ELF_MACHINE_JMP_SLOT) * ELF_RTYPE_CLASS_PLT)    \
1798 +   | (((type) == R_MIPS_COPY) * ELF_RTYPE_CLASS_COPY))
1799 +
1800 +#define ELF_MACHINE_PLT_REL 1
1801 +
1802 +/* Translate a processor specific dynamic tag to the index
1803 +   in l_info array.  */
1804 +#define DT_MIPS(x) (DT_MIPS_##x - DT_LOPROC + DT_NUM)
1805 +
1806 +/* If there is a DT_MIPS_RLD_MAP entry in the dynamic section, fill it in
1807 +   with the run-time address of the r_debug structure  */
1808 +#define ELF_MACHINE_DEBUG_SETUP(l,r) \
1809 +do { if ((l)->l_info[DT_MIPS (RLD_MAP)]) \
1810 +       *(ElfW(Addr) *)((l)->l_info[DT_MIPS (RLD_MAP)]->d_un.d_ptr) = \
1811 +       (ElfW(Addr)) (r); \
1812 +   } while (0)
1813 +
1814 +/* Return nonzero iff ELF header is compatible with the running host.  */
1815 +static inline int __attribute_used__
1816 +elf_machine_matches_host (const ElfW(Ehdr) *ehdr)
1817 +{
1818 +  return 1;
1819 +}
1820 +
1821 +static inline ElfW(Addr) *
1822 +elf_mips_got_from_gpreg (ElfW(Addr) gpreg)
1823 +{
1824 +  return (ElfW(Addr) *) gpreg;
1825 +}
1826 +
1827 +/* Return the link-time address of _DYNAMIC.  Conveniently, this is the
1828 +   first element of the GOT.  This must be inlined in a function which
1829 +   uses global data.  */
1830 +static inline ElfW(Addr)
1831 +elf_machine_dynamic (void)
1832 +{
1833 +  ElfW(Addr) load, link, got;
1834 +  asm ("   la   %0, 1f\n"
1835 +       "   la   %1, _GLOBAL_OFFSET_TABLE_\n"
1836 +       "1: rdpc %2"
1837 +       : "=r"(link), "=r"(got), "=r"(load));
1838 +
1839 +  return *elf_mips_got_from_gpreg(load - link + got);
1840 +}
1841 +
1842 +#define STRINGXP(X) __STRING(X)
1843 +#define STRINGXV(X) STRINGV_(X)
1844 +#define STRINGV_(...) # __VA_ARGS__
1845 +
1846 +/* Return the run-time load address of the shared object.  */
1847 +static inline ElfW(Addr)
1848 +elf_machine_load_address (void)
1849 +{
1850 +  ElfW(Addr) load, link;
1851 +  asm ("   la   %0, 1f\n"
1852 +       "1: rdpc %1\n"
1853 +       : "=r"(link), "=r"(load));
1854 +
1855 +  return load - link;
1856 +}
1857 +
1858 +/* The MSB of got[1] of a gnu object is set to identify gnu objects.  */
1859 +#ifdef __riscv64
1860 +# define ELF_MIPS_GNU_GOT1_MASK        0x8000000000000000L
1861 +#else
1862 +# define ELF_MIPS_GNU_GOT1_MASK        0x80000000L
1863 +#endif
1864 +
1865 +/* We can't rely on elf_machine_got_rel because _dl_object_relocation_scope
1866 +   fiddles with global data.  */
1867 +#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)                    \
1868 +do {                                                                   \
1869 +  struct link_map *map = &bootstrap_map;                               \
1870 +  ElfW(Sym) *sym;                                                      \
1871 +  ElfW(Addr) *got;                                                     \
1872 +  int i, n;                                                            \
1873 +                                                                       \
1874 +  got = (ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]);                 \
1875 +                                                                       \
1876 +  if (__builtin_expect (map->l_addr == 0, 1))                          \
1877 +    break;                                                             \
1878 +                                                                       \
1879 +  /* got[0] is reserved. got[1] is also reserved for the dynamic object        \
1880 +     generated by gnu ld. Skip these reserved entries from             \
1881 +     relocation.  */                                                   \
1882 +  i = (got[1] & ELF_MIPS_GNU_GOT1_MASK)? 2 : 1;                                \
1883 +  n = map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val;                  \
1884 +                                                                       \
1885 +  /* Add the run-time displacement to all local got entries. */                \
1886 +  while (i < n)                                                                \
1887 +    got[i++] += map->l_addr;                                           \
1888 +                                                                       \
1889 +  /* Handle global got entries. */                                     \
1890 +  got += n;                                                            \
1891 +  sym = (ElfW(Sym) *) D_PTR(map, l_info[DT_SYMTAB])                    \
1892 +       + map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;                    \
1893 +  i = (map->l_info[DT_MIPS (SYMTABNO)]->d_un.d_val                     \
1894 +       - map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val);                   \
1895 +                                                                       \
1896 +  while (i--)                                                          \
1897 +    {                                                                  \
1898 +      if (sym->st_shndx == SHN_UNDEF || sym->st_shndx == SHN_COMMON)   \
1899 +       *got = map->l_addr + sym->st_value;                             \
1900 +      else if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC                        \
1901 +              && *got != sym->st_value)                                \
1902 +       *got += map->l_addr;                                            \
1903 +      else if (ELFW(ST_TYPE) (sym->st_info) == STT_SECTION)            \
1904 +       {                                                               \
1905 +         if (sym->st_other == 0)                                       \
1906 +           *got += map->l_addr;                                        \
1907 +       }                                                               \
1908 +      else                                                             \
1909 +       *got = map->l_addr + sym->st_value;                             \
1910 +                                                                       \
1911 +      got++;                                                           \
1912 +      sym++;                                                           \
1913 +    }                                                                  \
1914 +} while(0)
1915 +
1916 +
1917 +/* Mask identifying addresses reserved for the user program,
1918 +   where the dynamic linker should not map anything.  */
1919 +#define ELF_MACHINE_USER_ADDRESS_MASK  0x80000000UL
1920 +
1921 +
1922 +/* Initial entry point code for the dynamic linker.
1923 +   The C function `_dl_start' is the real entry point;
1924 +   its return value is the user program's entry point. */
1925 +
1926 +#define RTLD_START asm (\
1927 +       ".text\n\
1928 +       " _RTLD_PROLOGUE(ENTRY_POINT) "\
1929 +       # Store &_DYNAMIC in the first entry of the GOT.\n\
1930 +       la a1, 1f\n\
1931 +       la a2, _GLOBAL_OFFSET_TABLE_\n\
1932 +       la a3, _DYNAMIC\n\
1933 +       1: rdpc a0\n\
1934 +       sub a0, a0, a1\n\
1935 +       add a0, a0, a2\n\
1936 +       " STRINGXP(REG_S) " a3, 0(a0)\n\
1937 +       move a0, sp\n\
1938 +       jal _dl_start\n\
1939 +       # Fall through to _dl_start_user \
1940 +       " _RTLD_EPILOGUE(ENTRY_POINT) "\
1941 +       \n\
1942 +       \n\
1943 +       " _RTLD_PROLOGUE(_dl_start_user) "\
1944 +       # Stash user entry point in s0.\n\
1945 +       move s0, v0\n\
1946 +       # See if we were run as a command with the executable file\n\
1947 +       # name as an extra leading argument.\n\
1948 +       la v0, _dl_skip_args\n\
1949 +       lw v0, 0(v0)\n\
1950 +       beqz v0, 1f\n\
1951 +       # Load the original argument count.\n\
1952 +       " STRINGXP(REG_L) " a0, 0(sp)\n\
1953 +       # Subtract _dl_skip_args from it.\n\
1954 +       sub a0, a0, v0\n\
1955 +       # Adjust the stack pointer to skip _dl_skip_args words.\n\
1956 +       sll v0, v0, " STRINGXP (PTRLOG) "\n\
1957 +       add sp, sp, v0\n\
1958 +       # Save back the modified argument count.\n\
1959 +       " STRINGXP(REG_S) " a0, 0(sp)\n\
1960 +1:     # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env) \n\
1961 +       la a0, _rtld_local\n\
1962 +       " STRINGXP(REG_L) " a0, 0(a0)\n\
1963 +       " STRINGXP(REG_L) " a1, 0(sp)\n\
1964 +       add a2, sp, " STRINGXP (PTRSIZE) "\n\
1965 +       sll a3, a1, " STRINGXP (PTRLOG) "\n\
1966 +       add a3, a3, a2\n\
1967 +       add a3, a3, " STRINGXP (PTRSIZE) "\n\
1968 +       # Call the function to run the initializers.\n\
1969 +       jal _dl_init_internal\n\
1970 +       # Pass our finalizer function to the user in v0 as per ELF ABI.\n\
1971 +       la v0, _dl_fini\n\
1972 +       # Jump to the user entry point.\n\
1973 +       jr s0\n\t"\
1974 +       _RTLD_EPILOGUE(_dl_start_user)\
1975 +       ".previous"\
1976 +);
1977 +
1978 +/* Names of the architecture-specific auditing callback functions.  */
1979 +# ifdef __riscv64
1980 +#  define ARCH_LA_PLTENTER mips_n64_gnu_pltenter
1981 +#  define ARCH_LA_PLTEXIT mips_n64_gnu_pltexit
1982 +# else
1983 +#  define ARCH_LA_PLTENTER mips_n32_gnu_pltenter
1984 +#  define ARCH_LA_PLTEXIT mips_n32_gnu_pltexit
1985 +# endif
1986 +
1987 +/* For a non-writable PLT, rewrite the .got.plt entry at RELOC_ADDR to
1988 +   point at the symbol with address VALUE.  For a writable PLT, rewrite
1989 +   the corresponding PLT entry instead.  */
1990 +static inline ElfW(Addr)
1991 +elf_machine_fixup_plt (struct link_map *map, lookup_t t,
1992 +                      const ElfW(Rel) *reloc,
1993 +                      ElfW(Addr) *reloc_addr, ElfW(Addr) value)
1994 +{
1995 +  return *reloc_addr = value;
1996 +}
1997 +
1998 +static inline ElfW(Addr)
1999 +elf_machine_plt_value (struct link_map *map, const ElfW(Rel) *reloc,
2000 +                      ElfW(Addr) value)
2001 +{
2002 +  return value;
2003 +}
2004 +
2005 +#endif /* !dl_machine_h */
2006 +
2007 +#ifdef RESOLVE_MAP
2008 +
2009 +/* Perform a relocation described by R_INFO at the location pointed to
2010 +   by RELOC_ADDR.  SYM is the relocation symbol specified by R_INFO and
2011 +   MAP is the object containing the reloc.  */
2012 +
2013 +auto inline void
2014 +__attribute__ ((always_inline))
2015 +elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
2016 +                  const ElfW(Sym) *sym, const struct r_found_version *version,
2017 +                  void *reloc_addr, ElfW(Addr) r_addend, int inplace_p)
2018 +{
2019 +  const unsigned long int r_type = ELFW(R_TYPE) (r_info);
2020 +  ElfW(Addr) *addr_field = (ElfW(Addr) *) reloc_addr;
2021 +
2022 +#if !defined RTLD_BOOTSTRAP && !defined SHARED
2023 +  /* This is defined in rtld.c, but nowhere in the static libc.a;
2024 +     make the reference weak so static programs can still link.  This
2025 +     declaration cannot be done when compiling rtld.c (i.e.  #ifdef
2026 +     RTLD_BOOTSTRAP) because rtld.c contains the common defn for
2027 +     _dl_rtld_map, which is incompatible with a weak decl in the same
2028 +     file.  */
2029 +  weak_extern (GL(dl_rtld_map));
2030 +#endif
2031 +
2032 +  switch (r_type)
2033 +    {
2034 +#if defined (USE_TLS) && !defined (RTLD_BOOTSTRAP)
2035 +# if _RISCV_SIM == _ABI64
2036 +    case R_MIPS_TLS_DTPMOD64:
2037 +    case R_MIPS_TLS_DTPREL64:
2038 +    case R_MIPS_TLS_TPREL64:
2039 +# else
2040 +    case R_MIPS_TLS_DTPMOD32:
2041 +    case R_MIPS_TLS_DTPREL32:
2042 +    case R_MIPS_TLS_TPREL32:
2043 +# endif
2044 +      {
2045 +       struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
2046 +
2047 +       switch (r_type)
2048 +         {
2049 +         case R_MIPS_TLS_DTPMOD64:
2050 +         case R_MIPS_TLS_DTPMOD32:
2051 +           if (sym_map)
2052 +             *addr_field = sym_map->l_tls_modid;
2053 +           break;
2054 +
2055 +         case R_MIPS_TLS_DTPREL64:
2056 +         case R_MIPS_TLS_DTPREL32:
2057 +           if (sym)
2058 +             {
2059 +               if (inplace_p)
2060 +                 r_addend = *addr_field;
2061 +               *addr_field = r_addend + TLS_DTPREL_VALUE (sym);
2062 +             }
2063 +           break;
2064 +
2065 +         case R_MIPS_TLS_TPREL32:
2066 +         case R_MIPS_TLS_TPREL64:
2067 +           if (sym)
2068 +             {
2069 +               CHECK_STATIC_TLS (map, sym_map);
2070 +               if (inplace_p)
2071 +                 r_addend = *addr_field;
2072 +               *addr_field = r_addend + TLS_TPREL_VALUE (sym_map, sym);
2073 +             }
2074 +           break;
2075 +         }
2076 +
2077 +       break;
2078 +      }
2079 +#endif
2080 +
2081 +#if _RISCV_SIM == _ABI64
2082 +    case (R_MIPS_64 << 8) | R_MIPS_REL32:
2083 +#else
2084 +    case R_MIPS_REL32:
2085 +#endif
2086 +      {
2087 +       int symidx = ELFW(R_SYM) (r_info);
2088 +       ElfW(Addr) reloc_value;
2089 +
2090 +       if (inplace_p)
2091 +         /* Support relocations on mis-aligned offsets.  */
2092 +         __builtin_memcpy (&reloc_value, reloc_addr, sizeof (reloc_value));
2093 +       else
2094 +         reloc_value = r_addend;
2095 +
2096 +       if (symidx)
2097 +         {
2098 +           const ElfW(Word) gotsym
2099 +             = (const ElfW(Word)) map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;
2100 +
2101 +           if ((ElfW(Word))symidx < gotsym)
2102 +             {
2103 +               /* This wouldn't work for a symbol imported from other
2104 +                  libraries for which there's no GOT entry, but MIPS
2105 +                  requires every symbol referenced in a dynamic
2106 +                  relocation to have a GOT entry in the primary GOT,
2107 +                  so we only get here for locally-defined symbols.
2108 +                  For section symbols, we should *NOT* be adding
2109 +                  sym->st_value (per the definition of the meaning of
2110 +                  S in reloc expressions in the ELF64 MIPS ABI),
2111 +                  since it should have already been added to
2112 +                  reloc_value by the linker, but older versions of
2113 +                  GNU ld didn't add it, and newer versions don't emit
2114 +                  useless relocations to section symbols any more, so
2115 +                  it is safe to keep on adding sym->st_value, even
2116 +                  though it's not ABI compliant.  Some day we should
2117 +                  bite the bullet and stop doing this.  */
2118 +#ifndef RTLD_BOOTSTRAP
2119 +               if (map != &GL(dl_rtld_map))
2120 +#endif
2121 +                 reloc_value += sym->st_value + map->l_addr;
2122 +             }
2123 +           else
2124 +             {
2125 +#ifndef RTLD_BOOTSTRAP
2126 +               const ElfW(Addr) *got
2127 +                 = (const ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]);
2128 +               const ElfW(Word) local_gotno
2129 +                 = (const ElfW(Word))
2130 +                   map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val;
2131 +
2132 +               reloc_value += got[symidx + local_gotno - gotsym];
2133 +#endif
2134 +             }
2135 +         }
2136 +       else
2137 +#ifndef RTLD_BOOTSTRAP
2138 +         if (map != &GL(dl_rtld_map))
2139 +#endif
2140 +           reloc_value += map->l_addr;
2141 +
2142 +       __builtin_memcpy (reloc_addr, &reloc_value, sizeof (reloc_value));
2143 +      }
2144 +      break;
2145 +#ifndef RTLD_BOOTSTRAP
2146 +#if _RISCV_SIM == _ABI64
2147 +    case (R_MIPS_64 << 8) | R_MIPS_GLOB_DAT:
2148 +#else
2149 +    case R_MIPS_GLOB_DAT:
2150 +#endif
2151 +      {
2152 +       int symidx = ELFW(R_SYM) (r_info);
2153 +       const ElfW(Word) gotsym
2154 +         = (const ElfW(Word)) map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;
2155 +
2156 +       if (__builtin_expect ((ElfW(Word)) symidx >= gotsym, 1))
2157 +         {
2158 +           const ElfW(Addr) *got
2159 +             = (const ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]);
2160 +           const ElfW(Word) local_gotno
2161 +             = ((const ElfW(Word))
2162 +                map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val);
2163 +
2164 +           ElfW(Addr) reloc_value = got[symidx + local_gotno - gotsym];
2165 +           __builtin_memcpy (reloc_addr, &reloc_value, sizeof (reloc_value));
2166 +         }
2167 +      }
2168 +      break;
2169 +#endif
2170 +    case R_MIPS_NONE:          /* Alright, Wilbur.  */
2171 +      break;
2172 +
2173 +    case R_MIPS_JUMP_SLOT:
2174 +      {
2175 +       struct link_map *sym_map;
2176 +       ElfW(Addr) value;
2177 +
2178 +       /* The addend for a jump slot relocation must always be zero:
2179 +          calls via the PLT always branch to the symbol's address and
2180 +          not to the address plus a non-zero offset.  */
2181 +       if (r_addend != 0)
2182 +         _dl_signal_error (0, map->l_name, NULL,
2183 +                           "found jump slot relocation with non-zero addend");
2184 +
2185 +       sym_map = RESOLVE_MAP (&sym, version, r_type);
2186 +       value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
2187 +       *addr_field = value;
2188 +
2189 +       break;
2190 +      }
2191 +
2192 +    case R_MIPS_COPY:
2193 +      {
2194 +       const ElfW(Sym) *const refsym = sym;
2195 +       struct link_map *sym_map;
2196 +       ElfW(Addr) value;
2197 +
2198 +       /* Calculate the address of the symbol.  */
2199 +       sym_map = RESOLVE_MAP (&sym, version, r_type);
2200 +       value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
2201 +
2202 +       if (__builtin_expect (sym == NULL, 0))
2203 +         /* This can happen in trace mode if an object could not be
2204 +            found.  */
2205 +         break;
2206 +       if (__builtin_expect (sym->st_size > refsym->st_size, 0)
2207 +           || (__builtin_expect (sym->st_size < refsym->st_size, 0)
2208 +               && GLRO(dl_verbose)))
2209 +         {
2210 +           const char *strtab;
2211 +
2212 +           strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
2213 +           _dl_error_printf ("\
2214 +  %s: Symbol `%s' has different size in shared object, consider re-linking\n",
2215 +                             rtld_progname ?: "<program name unknown>",
2216 +                             strtab + refsym->st_name);
2217 +         }
2218 +       memcpy (reloc_addr, (void *) value,
2219 +               MIN (sym->st_size, refsym->st_size));
2220 +       break;
2221 +      }
2222 +
2223 +#if _RISCV_SIM == _ABI64
2224 +    case R_MIPS_64:
2225 +      /* For full compliance with the ELF64 ABI, one must precede the
2226 +        _REL32/_64 pair of relocations with a _64 relocation, such
2227 +        that the in-place addend is read as a 64-bit value.  IRIX
2228 +        didn't pick up on this requirement, so we treat the
2229 +        _REL32/_64 relocation as a 64-bit relocation even if it's by
2230 +        itself.  For ABI compliance, we ignore such _64 dummy
2231 +        relocations.  For RELA, this may be simply removed, since
2232 +        it's totally unnecessary.  */
2233 +      if (ELFW(R_SYM) (r_info) == 0)
2234 +       break;
2235 +      /* Fall through.  */
2236 +#endif
2237 +    default:
2238 +      _dl_reloc_bad_type (map, r_type, 0);
2239 +      break;
2240 +    }
2241 +}
2242 +
2243 +/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
2244 +   MAP is the object containing the reloc.  */
2245 +
2246 +auto inline void
2247 +__attribute__ ((always_inline))
2248 +elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
2249 +                const ElfW(Sym) *sym, const struct r_found_version *version,
2250 +                void *const reloc_addr)
2251 +{
2252 +  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr, 0, 1);
2253 +}
2254 +
2255 +auto inline void
2256 +__attribute__((always_inline))
2257 +elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
2258 +                         void *const reloc_addr)
2259 +{
2260 +  /* XXX Nothing to do.  There is no relative relocation, right?  */
2261 +}
2262 +
2263 +auto inline void
2264 +__attribute__((always_inline))
2265 +elf_machine_lazy_rel (struct link_map *map,
2266 +                     ElfW(Addr) l_addr, const ElfW(Rel) *reloc)
2267 +{
2268 +  ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
2269 +  const unsigned int r_type = ELFW(R_TYPE) (reloc->r_info);
2270 +  /* Check for unexpected PLT reloc type.  */
2271 +  if (__builtin_expect (r_type == R_MIPS_JUMP_SLOT, 1))
2272 +    {
2273 +      if (__builtin_expect (map->l_mach.plt, 0) == 0)
2274 +       {
2275 +         /* Nothing is required here since we only support lazy
2276 +            relocation in executables.  */
2277 +       }
2278 +      else
2279 +       *reloc_addr = map->l_mach.plt;
2280 +    }
2281 +  else
2282 +    _dl_reloc_bad_type (map, r_type, 1);
2283 +}
2284 +
2285 +auto inline void
2286 +__attribute__ ((always_inline))
2287 +elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
2288 +                 const ElfW(Sym) *sym, const struct r_found_version *version,
2289 +                void *const reloc_addr)
2290 +{
2291 +  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr,
2292 +                    reloc->r_addend, 0);
2293 +}
2294 +
2295 +auto inline void
2296 +__attribute__((always_inline))
2297 +elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
2298 +                          void *const reloc_addr)
2299 +{
2300 +}
2301 +
2302 +#ifndef RTLD_BOOTSTRAP
2303 +/* Relocate GOT. */
2304 +auto inline void
2305 +__attribute__((always_inline))
2306 +elf_machine_got_rel (struct link_map *map, int lazy)
2307 +{
2308 +  ElfW(Addr) *got;
2309 +  ElfW(Sym) *sym;
2310 +  const ElfW(Half) *vernum;
2311 +  int i, n, symidx;
2312 +
2313 +#define RESOLVE_GOTSYM(sym,vernum,sym_index,reloc)                       \
2314 +    ({                                                                   \
2315 +      const ElfW(Sym) *ref = sym;                                        \
2316 +      const struct r_found_version *version                              \
2317 +        = vernum ? &map->l_versions[vernum[sym_index] & 0x7fff] : NULL;          \
2318 +      struct link_map *sym_map;                                                  \
2319 +      sym_map = RESOLVE_MAP (&ref, version, reloc);                      \
2320 +      ref ? sym_map->l_addr + ref->st_value : 0;                         \
2321 +    })
2322 +
2323 +  if (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
2324 +    vernum = (const void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
2325 +  else
2326 +    vernum = NULL;
2327 +
2328 +  got = (ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]);
2329 +
2330 +  n = map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val;
2331 +  /* The dynamic linker's local got entries have already been relocated.  */
2332 +  if (map != &GL(dl_rtld_map))
2333 +    {
2334 +      /* got[0] is reserved. got[1] is also reserved for the dynamic object
2335 +        generated by gnu ld. Skip these reserved entries from relocation.  */
2336 +      i = (got[1] & ELF_MIPS_GNU_GOT1_MASK)? 2 : 1;
2337 +
2338 +      /* Add the run-time displacement to all local got entries if
2339 +         needed.  */
2340 +      if (__builtin_expect (map->l_addr != 0, 0))
2341 +       {
2342 +         while (i < n)
2343 +           got[i++] += map->l_addr;
2344 +       }
2345 +    }
2346 +
2347 +  /* Handle global got entries. */
2348 +  got += n;
2349 +  /* Keep track of the symbol index.  */
2350 +  symidx = map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;
2351 +  sym = (ElfW(Sym) *) D_PTR (map, l_info[DT_SYMTAB]) + symidx;
2352 +  i = (map->l_info[DT_MIPS (SYMTABNO)]->d_un.d_val
2353 +       - map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val);
2354 +
2355 +  /* This loop doesn't handle Quickstart.  */
2356 +  while (i--)
2357 +    {
2358 +      if (sym->st_shndx == SHN_UNDEF)
2359 +       {
2360 +         if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC && sym->st_value
2361 +             && !(sym->st_other & STO_MIPS_PLT))
2362 +           {
2363 +             if (lazy)
2364 +               *got = sym->st_value + map->l_addr;
2365 +             else
2366 +               /* This is a lazy-binding stub, so we don't need the
2367 +                  canonical address.  */
2368 +               *got = RESOLVE_GOTSYM (sym, vernum, symidx, R_MIPS_JUMP_SLOT);
2369 +           }
2370 +         else
2371 +           *got = RESOLVE_GOTSYM (sym, vernum, symidx, R_MIPS_32);
2372 +       }
2373 +      else if (sym->st_shndx == SHN_COMMON)
2374 +       *got = RESOLVE_GOTSYM (sym, vernum, symidx, R_MIPS_32);
2375 +      else if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC
2376 +              && *got != sym->st_value)
2377 +       {
2378 +         if (lazy)
2379 +           *got += map->l_addr;
2380 +         else
2381 +           /* This is a lazy-binding stub, so we don't need the
2382 +              canonical address.  */
2383 +           *got = RESOLVE_GOTSYM (sym, vernum, symidx, R_MIPS_JUMP_SLOT);
2384 +       }
2385 +      else if (ELFW(ST_TYPE) (sym->st_info) == STT_SECTION)
2386 +       {
2387 +         if (sym->st_other == 0)
2388 +           *got += map->l_addr;
2389 +       }
2390 +      else
2391 +       *got = RESOLVE_GOTSYM (sym, vernum, symidx, R_MIPS_32);
2392 +
2393 +      ++got;
2394 +      ++sym;
2395 +      ++symidx;
2396 +    }
2397 +
2398 +#undef RESOLVE_GOTSYM
2399 +}
2400 +#endif
2401 +
2402 +/* Set up the loaded object described by L so its stub function
2403 +   will jump to the on-demand fixup code __dl_runtime_resolve.  */
2404 +
2405 +auto inline int
2406 +__attribute__((always_inline))
2407 +elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
2408 +{
2409 +# ifndef RTLD_BOOTSTRAP
2410 +  ElfW(Addr) *got;
2411 +  extern void _dl_runtime_resolve (ElfW(Word));
2412 +  extern void _dl_fixup (void);
2413 +  extern int _dl_mips_gnu_objects;
2414 +
2415 +  if (lazy)
2416 +    {
2417 +      /* The GOT entries for functions have not yet been filled in.
2418 +        Their initial contents will arrange when called to put an
2419 +        offset into the .dynsym section in t8, the return address
2420 +        in t7 and then jump to _GLOBAL_OFFSET_TABLE[0].  */
2421 +      got = (ElfW(Addr) *) D_PTR (l, l_info[DT_PLTGOT]);
2422 +
2423 +      /* This function will get called to fix up the GOT entry indicated by
2424 +        the register t8, and then jump to the resolved address.  */
2425 +      got[0] = (ElfW(Addr)) &_dl_runtime_resolve;
2426 +
2427 +      /* Store l to _GLOBAL_OFFSET_TABLE[1] for gnu object. The MSB
2428 +        of got[1] of a gnu object is set to identify gnu objects.
2429 +        Where we can store l for non gnu objects? XXX  */
2430 +      if ((got[1] & ELF_MIPS_GNU_GOT1_MASK) != 0)
2431 +       got[1] = ((ElfW(Addr)) l | ELF_MIPS_GNU_GOT1_MASK);
2432 +      else
2433 +       _dl_mips_gnu_objects = 0;
2434 +    }
2435 +
2436 +  /* Relocate global offset table.  */
2437 +  elf_machine_got_rel (l, lazy);
2438 +
2439 +  /* If using PLTs, fill in the first two entries of .got.plt.  */
2440 +  if (l->l_info[DT_JMPREL] && lazy)
2441 +    {
2442 +      ElfW(Addr) *gotplt;
2443 +      gotplt = (ElfW(Addr) *) D_PTR (l, l_info[DT_MIPS (PLTGOT)]);
2444 +      /* If a library is prelinked but we have to relocate anyway,
2445 +        we have to be able to undo the prelinking of .got.plt.
2446 +        The prelinker saved the address of .plt for us here.  */
2447 +      if (gotplt[1])
2448 +       l->l_mach.plt = gotplt[1] + l->l_addr;
2449 +      gotplt[0] = (ElfW(Addr)) &_dl_fixup;
2450 +      gotplt[1] = (ElfW(Addr)) l;
2451 +      /* Relocate subsequent .got.plt entries. */
2452 +      for (gotplt += 2; *gotplt; gotplt++)
2453 +       *gotplt += l->l_addr;
2454 +    }
2455 +
2456 +# endif
2457 +  return lazy;
2458 +}
2459 +
2460 +#endif /* RESOLVE_MAP */
2461 diff -ruN glibc-2.19/sysdeps/riscv/dl-tls.h glibc-2.19-riscv/sysdeps/riscv/dl-tls.h
2462 --- glibc-2.19/sysdeps/riscv/dl-tls.h   1969-12-31 16:00:00.000000000 -0800
2463 +++ glibc-2.19-riscv/sysdeps/riscv/dl-tls.h     2014-12-09 16:55:03.156727789 -0800
2464 @@ -0,0 +1,49 @@
2465 +/* Thread-local storage handling in the ELF dynamic linker.  MIPS version.
2466 +   Copyright (C) 2005 Free Software Foundation, Inc.
2467 +   This file is part of the GNU C Library.
2468 +
2469 +   The GNU C Library is free software; you can redistribute it and/or
2470 +   modify it under the terms of the GNU Lesser General Public
2471 +   License as published by the Free Software Foundation; either
2472 +   version 2.1 of the License, or (at your option) any later version.
2473 +
2474 +   The GNU C Library is distributed in the hope that it will be useful,
2475 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
2476 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2477 +   Lesser General Public License for more details.
2478 +
2479 +   You should have received a copy of the GNU Lesser General Public
2480 +   License along with the GNU C Library; if not, write to the Free
2481 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2482 +   02111-1307 USA.  */
2483 +
2484 +
2485 +/* Type used for the representation of TLS information in the GOT.  */
2486 +typedef struct
2487 +{
2488 +  unsigned long int ti_module;
2489 +  unsigned long int ti_offset;
2490 +} tls_index;
2491 +
2492 +/* The thread pointer points 0x7000 past the first static TLS block.  */
2493 +#define TLS_TP_OFFSET          0x7000
2494 +
2495 +/* Dynamic thread vector pointers point 0x8000 past the start of each
2496 +   TLS block.  */
2497 +#define TLS_DTV_OFFSET         0x8000
2498 +
2499 +/* Compute the value for a GOTTPREL reloc.  */
2500 +#define TLS_TPREL_VALUE(sym_map, sym) \
2501 +  ((sym_map)->l_tls_offset + (sym)->st_value - TLS_TP_OFFSET)
2502 +
2503 +/* Compute the value for a DTPREL reloc.  */
2504 +#define TLS_DTPREL_VALUE(sym) \
2505 +  ((sym)->st_value - TLS_DTV_OFFSET)
2506 +
2507 +extern void *__tls_get_addr (tls_index *ti);
2508 +
2509 +# define GET_ADDR_OFFSET       (ti->ti_offset + TLS_DTV_OFFSET)
2510 +# define __TLS_GET_ADDR(__ti)  (__tls_get_addr (__ti) - TLS_DTV_OFFSET)
2511 +
2512 +/* Value used for dtv entries for which the allocation is delayed.  */
2513 +#define TLS_DTV_UNALLOCATED    ((void *) -1l)
2514 diff -ruN glibc-2.19/sysdeps/riscv/dl-trampoline.c glibc-2.19-riscv/sysdeps/riscv/dl-trampoline.c
2515 --- glibc-2.19/sysdeps/riscv/dl-trampoline.c    1969-12-31 16:00:00.000000000 -0800
2516 +++ glibc-2.19-riscv/sysdeps/riscv/dl-trampoline.c      2014-12-09 16:55:03.156727789 -0800
2517 @@ -0,0 +1,104 @@
2518 +/* PLT trampoline.  MIPS version.
2519 +   Copyright (C) 1996-2001, 2002, 2003, 2004, 2005
2520 +   Free Software Foundation, Inc.
2521 +   This file is part of the GNU C Library.
2522 +   Contributed by Kazumoto Kojima <kkojima@info.kanagawa-u.ac.jp>.
2523 +
2524 +   The GNU C Library is free software; you can redistribute it and/or
2525 +   modify it under the terms of the GNU Lesser General Public
2526 +   License as published by the Free Software Foundation; either
2527 +   version 2.1 of the License, or (at your option) any later version.
2528 +
2529 +   The GNU C Library is distributed in the hope that it will be useful,
2530 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
2531 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2532 +   Lesser General Public License for more details.
2533 +
2534 +   You should have received a copy of the GNU Lesser General Public
2535 +   License along with the GNU C Library; if not, write to the Free
2536 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2537 +   02111-1307 USA.  */
2538 +
2539 +/*  FIXME: Profiling of shared libraries is not implemented yet.  */
2540 +
2541 +#include <sysdep.h>
2542 +#include <link.h>
2543 +#include <elf.h>
2544 +#include <ldsodefs.h>
2545 +#include <dl-machine.h>
2546 +
2547 +/* The flag _dl_mips_gnu_objects is set if all dynamic objects are
2548 +   generated by the gnu linker. */
2549 +int _dl_mips_gnu_objects = 1;
2550 +
2551 +/* Get link map for callers object containing STUB_PC.  */
2552 +static inline struct link_map *
2553 +elf_machine_runtime_link_map (ElfW(Addr) gpreg, ElfW(Addr) stub_pc)
2554 +{
2555 +  /* got[1] is reserved to keep its link map address for the shared
2556 +     object generated by the gnu linker.  If all are such objects, we
2557 +     can find the link map from current GPREG simply.  If not so, get
2558 +     the link map for caller's object containing STUB_PC.  */
2559 +
2560 +  if (_dl_mips_gnu_objects)
2561 +    {
2562 +      ElfW(Addr) *got = elf_mips_got_from_gpreg (gpreg);
2563 +      ElfW(Word) g1;
2564 +
2565 +      g1 = ((ElfW(Word) *) got)[1];
2566 +
2567 +      if ((g1 & ELF_MIPS_GNU_GOT1_MASK) != 0)
2568 +       {
2569 +         struct link_map *l =
2570 +           (struct link_map *) (g1 & ~ELF_MIPS_GNU_GOT1_MASK);
2571 +         ElfW(Addr) base, limit;
2572 +         const ElfW(Phdr) *p = l->l_phdr;
2573 +         ElfW(Half) this, nent = l->l_phnum;
2574 +
2575 +         /* For the common case of a stub being called from the containing
2576 +            object, STUB_PC will point to somewhere within the object that
2577 +            is described by the link map fetched via got[1].  Otherwise we
2578 +            have to scan all maps.  */
2579 +         for (this = 0; this < nent; this++)
2580 +           {
2581 +             if (p[this].p_type == PT_LOAD)
2582 +               {
2583 +                 base = p[this].p_vaddr + l->l_addr;
2584 +                 limit = base + p[this].p_memsz;
2585 +                 if (stub_pc >= base && stub_pc < limit)
2586 +                   return l;
2587 +               }
2588 +           }
2589 +       }
2590 +    }
2591 +
2592 +    struct link_map *l;
2593 +    Lmid_t nsid;
2594 +
2595 +    for (nsid = 0; nsid < DL_NNS; ++nsid)
2596 +      for (l = GL(dl_ns)[nsid]._ns_loaded; l != NULL; l = l->l_next)
2597 +       {
2598 +         ElfW(Addr) base, limit;
2599 +         const ElfW(Phdr) *p = l->l_phdr;
2600 +         ElfW(Half) this, nent = l->l_phnum;
2601 +
2602 +         for (this = 0; this < nent; ++this)
2603 +           {
2604 +             if (p[this].p_type == PT_LOAD)
2605 +               {
2606 +                 base = p[this].p_vaddr + l->l_addr;
2607 +                 limit = base + p[this].p_memsz;
2608 +                 if (stub_pc >= base && stub_pc < limit)
2609 +                   return l;
2610 +               }
2611 +           }
2612 +       }
2613 +
2614 +  _dl_signal_error (0, NULL, NULL, "cannot find runtime link map");
2615 +  return NULL;
2616 +}
2617 +
2618 +void _dl_runtime_resolve(void)
2619 +{
2620 +  while (1);
2621 +}
2622 diff -ruN glibc-2.19/sysdeps/riscv/elf/configure glibc-2.19-riscv/sysdeps/riscv/elf/configure
2623 --- glibc-2.19/sysdeps/riscv/elf/configure      1969-12-31 16:00:00.000000000 -0800
2624 +++ glibc-2.19-riscv/sysdeps/riscv/elf/configure        2014-12-09 16:55:03.156727789 -0800
2625 @@ -0,0 +1,126 @@
2626 +
2627 +# as_fn_set_status STATUS
2628 +# -----------------------
2629 +# Set $? to STATUS, without forking.
2630 +as_fn_set_status ()
2631 +{
2632 +  return $1
2633 +} # as_fn_set_status
2634 +
2635 +# as_fn_exit STATUS
2636 +# -----------------
2637 +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
2638 +as_fn_exit ()
2639 +{
2640 +  set +e
2641 +  as_fn_set_status $1
2642 +  exit $1
2643 +} # as_fn_exit
2644 +if expr a : '\(a\)' >/dev/null 2>&1 &&
2645 +   test "X`expr 00001 : '.*\(...\)'`" = X001; then
2646 +  as_expr=expr
2647 +else
2648 +  as_expr=false
2649 +fi
2650 +
2651 +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
2652 +  as_basename=basename
2653 +else
2654 +  as_basename=false
2655 +fi
2656 +
2657 +as_me=`$as_basename -- "$0" ||
2658 +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
2659 +        X"$0" : 'X\(//\)$' \| \
2660 +        X"$0" : 'X\(/\)' \| . 2>/dev/null ||
2661 +$as_echo X/"$0" |
2662 +    sed '/^.*\/\([^/][^/]*\)\/*$/{
2663 +           s//\1/
2664 +           q
2665 +         }
2666 +         /^X\/\(\/\/\)$/{
2667 +           s//\1/
2668 +           q
2669 +         }
2670 +         /^X\/\(\/\).*/{
2671 +           s//\1/
2672 +           q
2673 +         }
2674 +         s/.*/./; q'`
2675 +
2676 +
2677 +  as_lineno_1=$LINENO as_lineno_1a=$LINENO
2678 +  as_lineno_2=$LINENO as_lineno_2a=$LINENO
2679 +  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
2680 +  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
2681 +  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
2682 +  sed -n '
2683 +    p
2684 +    /[$]LINENO/=
2685 +  ' <$as_myself |
2686 +    sed '
2687 +      s/[$]LINENO.*/&-/
2688 +      t lineno
2689 +      b
2690 +      :lineno
2691 +      N
2692 +      :loop
2693 +      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
2694 +      t loop
2695 +      s/-\n.*//
2696 +    ' >$as_me.lineno &&
2697 +  chmod +x "$as_me.lineno" ||
2698 +    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
2699 +
2700 +  # Don't try to exec as it changes $[0], causing all sort of problems
2701 +  # (the dirname of $[0] is not the place where we might find the
2702 +  # original and so on.  Autoconf is especially sensitive to this).
2703 +  . "./$as_me.lineno"
2704 +  # Exit status is that of the last command.
2705 +  exit
2706 +}
2707 +
2708 +# This file is generated from configure.in by Autoconf.  DO NOT EDIT!
2709 + # Local configure fragment for sysdeps/mips/elf.
2710 +
2711 +if test "$usetls" != no; then
2712 +# Check for support of thread-local storage handling in assembler and
2713 +# linker.
2714 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MIPS TLS support" >&5
2715 +$as_echo_n "checking for MIPS TLS support... " >&6; }
2716 +if ${libc_cv_mips_tls+:} false; then :
2717 +  $as_echo_n "(cached) " >&6
2718 +else
2719 +  cat > conftest.s <<\EOF
2720 +       .section ".tdata", "awT", %progbits
2721 +       .globl foo
2722 +foo:   .long   1
2723 +       .section ".tbss", "awT", %nobits
2724 +       .globl bar
2725 +bar:   .skip   4
2726 +       .text
2727 +
2728 +       la              v0, __tls_get_addr
2729 +       la.tls.gd       a0, x
2730 +       jalr            v0
2731 +EOF
2732 +if { ac_try='${CC-cc} -c $CFLAGS conftest.s 1>&5'
2733 +  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
2734 +  (eval $ac_try) 2>&5
2735 +  ac_status=$?
2736 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2737 +  test $ac_status = 0; }; }; then
2738 +  libc_cv_mips_tls=yes
2739 +else
2740 +  libc_cv_mips_tls=no
2741 +fi
2742 +rm -f conftest*
2743 +fi
2744 +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libc_cv_mips_tls" >&5
2745 +$as_echo "$libc_cv_mips_tls" >&6; }
2746 +if test $libc_cv_mips_tls = yes; then
2747 +  $as_echo "#define HAVE_TLS_SUPPORT 1" >>confdefs.h
2748 +
2749 +fi
2750 +fi
2751 +
2752 diff -ruN glibc-2.19/sysdeps/riscv/elf/configure.in glibc-2.19-riscv/sysdeps/riscv/elf/configure.in
2753 --- glibc-2.19/sysdeps/riscv/elf/configure.in   1969-12-31 16:00:00.000000000 -0800
2754 +++ glibc-2.19-riscv/sysdeps/riscv/elf/configure.in     2014-12-09 16:55:03.160727813 -0800
2755 @@ -0,0 +1,35 @@
2756 +GLIBC_PROVIDES dnl See aclocal.m4 in the top level source directory.
2757 +# Local configure fragment for sysdeps/mips/elf.
2758 +
2759 +if test "$usetls" != no; then
2760 +# Check for support of thread-local storage handling in assembler and
2761 +# linker.
2762 +AC_CACHE_CHECK(for MIPS TLS support, libc_cv_mips_tls, [dnl
2763 +cat > conftest.s <<\EOF
2764 +       .section ".tdata", "awT", %progbits
2765 +       .globl foo
2766 +foo:   .long   1
2767 +       .section ".tbss", "awT", %nobits
2768 +       .globl bar
2769 +bar:   .skip   4
2770 +       .text
2771 +
2772 +       la              v0, __tls_get_addr
2773 +       la.tls.gd       a0, x
2774 +       jalr            v0
2775 +EOF
2776 +dnl
2777 +if AC_TRY_COMMAND(${CC-cc} -c $CFLAGS conftest.s 1>&AS_MESSAGE_LOG_FD); then
2778 +  libc_cv_mips_tls=yes
2779 +else
2780 +  libc_cv_mips_tls=no
2781 +fi
2782 +rm -f conftest*])
2783 +if test $libc_cv_mips_tls = yes; then
2784 +  AC_DEFINE(HAVE_TLS_SUPPORT)
2785 +fi
2786 +fi
2787 +
2788 +dnl No MIPS GCC supports accessing static and hidden symbols in an
2789 +dnl position independent way.
2790 +dnl AC_DEFINE(PI_STATIC_AND_HIDDEN)
2791 diff -ruN glibc-2.19/sysdeps/riscv/elf/start.S glibc-2.19-riscv/sysdeps/riscv/elf/start.S
2792 --- glibc-2.19/sysdeps/riscv/elf/start.S        1969-12-31 16:00:00.000000000 -0800
2793 +++ glibc-2.19-riscv/sysdeps/riscv/elf/start.S  2014-12-09 16:55:03.160727813 -0800
2794 @@ -0,0 +1,98 @@
2795 +/* Startup code compliant to the ELF Mips ABI.
2796 +   Copyright (C) 1995, 1997, 2000, 2001, 2002, 2003, 2004
2797 +       Free Software Foundation, Inc.
2798 +   This file is part of the GNU C Library.
2799 +
2800 +   The GNU C Library is free software; you can redistribute it and/or
2801 +   modify it under the terms of the GNU Lesser General Public
2802 +   License as published by the Free Software Foundation; either
2803 +   version 2.1 of the License, or (at your option) any later version.
2804 +
2805 +   In addition to the permissions in the GNU Lesser General Public
2806 +   License, the Free Software Foundation gives you unlimited
2807 +   permission to link the compiled version of this file with other
2808 +   programs, and to distribute those programs without any restriction
2809 +   coming from the use of this file. (The GNU Lesser General Public
2810 +   License restrictions do apply in other respects; for example, they
2811 +   cover modification of the file, and distribution when not linked
2812 +   into another program.)
2813 +
2814 +   Note that people who make modified versions of this file are not
2815 +   obligated to grant this special exception for their modified
2816 +   versions; it is their choice whether to do so. The GNU Lesser
2817 +   General Public License gives permission to release a modified
2818 +   version without this exception; this exception also makes it
2819 +   possible to release a modified version which carries forward this
2820 +   exception.
2821 +
2822 +   The GNU C Library is distributed in the hope that it will be useful,
2823 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
2824 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2825 +   Lesser General Public License for more details.
2826 +
2827 +   You should have received a copy of the GNU Lesser General Public
2828 +   License along with the GNU C Library; if not, write to the Free
2829 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2830 +   02111-1307 USA.  */
2831 +
2832 +#define __ASSEMBLY__ 1
2833 +#include <entry.h>
2834 +#include <sgidefs.h>
2835 +#include <sys/asm.h>
2836 +
2837 +#ifndef ENTRY_POINT
2838 +#error ENTRY_POINT needs to be defined for start.S on MIPS/ELF.
2839 +#endif
2840 +
2841 +/* This is the canonical entry point, usually the first thing in the text
2842 +   segment.  The SVR4/Mips ABI (pages 3-31, 3-32) says that when the entry
2843 +   point runs, most registers' values are unspecified, except for:
2844 +
2845 +   v0 ($2)     Contains a function pointer to be registered with `atexit'.
2846 +               This is how the dynamic linker arranges to have DT_FINI
2847 +               functions called for shared libraries that have been loaded
2848 +               before this code runs.
2849 +
2850 +   sp ($29)    The stack contains the arguments and environment:
2851 +               0(%esp)                 argc
2852 +               4(%esp)                 argv[0]
2853 +               ...
2854 +               (4*argc)(%esp)          NULL
2855 +               (4*(argc+1))(%esp)      envp[0]
2856 +               ...
2857 +                                       NULL
2858 +   ra ($31)    The return address register is set to zero so that programs
2859 +               that search backword through stack frames recognize the last
2860 +               stack frame.
2861 +*/
2862 +
2863 +
2864 +/* We need to call:
2865 +   __libc_start_main (int (*main) (int, char **, char **), int argc,
2866 +                     char **argv, void (*init) (void), void (*fini) (void),
2867 +                     void (*rtld_fini) (void), void *stack_end)
2868 +*/
2869 +       
2870 +       .text
2871 +       .globl ENTRY_POINT
2872 +       .type ENTRY_POINT,@function
2873 +ENTRY_POINT:
2874 +       la    a0, main
2875 +       REG_L a1, 0(sp)      /* argc */
2876 +       addi  a2, sp, SZREG  /* argv */
2877 +       andi  sp, sp, ALMASK /* Align stack. */
2878 +       la    a3, __libc_csu_init
2879 +       la    a4, __libc_csu_fini
2880 +       move  a5, v0  /* rtld_fini */
2881 +       move  a6, sp  /* stack_end */
2882 +       
2883 +       la    v0, __libc_start_main
2884 +       jr    v0
2885 +
2886 +/* Define a symbol for the first piece of initialized data.  */
2887 +       .data
2888 +       .globl __data_start
2889 +__data_start:
2890 +       .long 0
2891 +       .weak data_start
2892 +       data_start = __data_start
2893 diff -ruN glibc-2.19/sysdeps/riscv/fpu/bits/mathinline.h glibc-2.19-riscv/sysdeps/riscv/fpu/bits/mathinline.h
2894 --- glibc-2.19/sysdeps/riscv/fpu/bits/mathinline.h      1969-12-31 16:00:00.000000000 -0800
2895 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/bits/mathinline.h        2014-12-09 16:55:03.160727813 -0800
2896 @@ -0,0 +1,52 @@
2897 +/* Inline math functions for RISC-V.
2898 +   Copyright (C) 2011
2899 +   Free Software Foundation, Inc.
2900 +   This file is part of the GNU C Library.
2901 +   Contributed by Jakub Jelinek <jakub@redhat.com>.
2902 +
2903 +   The GNU C Library is free software; you can redistribute it and/or
2904 +   modify it under the terms of the GNU Lesser General Public
2905 +   License as published by the Free Software Foundation; either
2906 +   version 2.1 of the License, or (at your option) any later version.
2907 +
2908 +   The GNU C Library is distributed in the hope that it will be useful,
2909 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
2910 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2911 +   Lesser General Public License for more details.
2912 +
2913 +   You should have received a copy of the GNU Lesser General Public
2914 +   License along with the GNU C Library; if not, write to the Free
2915 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2916 +   02111-1307 USA.  */
2917 +
2918 +#ifndef _MATH_H
2919 +# error "Never use <bits/mathinline.h> directly; include <math.h> instead."
2920 +#endif
2921 +
2922 +#include <bits/wordsize.h>
2923 +
2924 +#ifdef __GNUC__
2925 +
2926 +#if defined __USE_ISOC99
2927 +# undef isgreater
2928 +# undef isgreaterequal
2929 +# undef isless
2930 +# undef islessequal
2931 +# undef islessgreater
2932 +# undef isunordered
2933 +
2934 +# define isgreater(x, y) ((x) > (y))
2935 +# define isgreaterequal(x, y) ((x) >= (y))
2936 +# define isless(x, y) ((x) < (y))
2937 +# define islessequal(x, y) ((x) <= (y))
2938 +# define islessgreater(x, y) (!!(isless(x, y) + isgreater(x, y)))
2939 +# define isunordered(x, y) (((x) == (x)) + ((y) == (y)) < 2)
2940 +
2941 +#endif /* __USE_ISOC99 */
2942 +
2943 +#if (!defined __NO_MATH_INLINES || defined __LIBC_INTERNAL_MATH_INLINES) && defined __OPTIMIZE__
2944 +
2945 +/* Nothing yet. */
2946 +
2947 +#endif /* !__NO_MATH_INLINES && __OPTIMIZE__ */
2948 +#endif /* __GNUC__ */
2949 diff -ruN glibc-2.19/sysdeps/riscv/fpu/e_sqrt.c glibc-2.19-riscv/sysdeps/riscv/fpu/e_sqrt.c
2950 --- glibc-2.19/sysdeps/riscv/fpu/e_sqrt.c       1969-12-31 16:00:00.000000000 -0800
2951 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/e_sqrt.c 2014-12-09 16:55:03.160727813 -0800
2952 @@ -0,0 +1,26 @@
2953 +/* Copyright (C) 2002 Free Software Foundation, Inc.
2954 +   This file is part of the GNU C Library.
2955 +   Contributed by Hartvig Ekner <hartvige@mips.com>, 2002.
2956 +
2957 +   The GNU C Library is free software; you can redistribute it and/or
2958 +   modify it under the terms of the GNU Lesser General Public
2959 +   License as published by the Free Software Foundation; either
2960 +   version 2.1 of the License, or (at your option) any later version.
2961 +
2962 +   The GNU C Library is distributed in the hope that it will be useful,
2963 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
2964 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2965 +   Lesser General Public License for more details.
2966 +
2967 +   You should have received a copy of the GNU Lesser General Public
2968 +   License along with the GNU C Library; if not, write to the Free
2969 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
2970 +   02111-1307 USA.  */
2971 +
2972 +double
2973 +__ieee754_sqrt (double x)
2974 +{
2975 +  double z;
2976 +  __asm__ ("fsqrt.d %0,%1" : "=f" (z) : "f" (x));
2977 +  return z;
2978 +}
2979 diff -ruN glibc-2.19/sysdeps/riscv/fpu/e_sqrtf.c glibc-2.19-riscv/sysdeps/riscv/fpu/e_sqrtf.c
2980 --- glibc-2.19/sysdeps/riscv/fpu/e_sqrtf.c      1969-12-31 16:00:00.000000000 -0800
2981 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/e_sqrtf.c        2014-12-09 16:55:03.160727813 -0800
2982 @@ -0,0 +1,26 @@
2983 +/* Copyright (C) 2002 Free Software Foundation, Inc.
2984 +   This file is part of the GNU C Library.
2985 +   Contributed by Hartvig Ekner <hartvige@mips.com>, 2002.
2986 +
2987 +   The GNU C Library is free software; you can redistribute it and/or
2988 +   modify it under the terms of the GNU Lesser General Public
2989 +   License as published by the Free Software Foundation; either
2990 +   version 2.1 of the License, or (at your option) any later version.
2991 +
2992 +   The GNU C Library is distributed in the hope that it will be useful,
2993 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
2994 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2995 +   Lesser General Public License for more details.
2996 +
2997 +   You should have received a copy of the GNU Lesser General Public
2998 +   License along with the GNU C Library; if not, write to the Free
2999 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3000 +   02111-1307 USA.  */
3001 +
3002 +float
3003 +__ieee754_sqrtf (float x)
3004 +{
3005 +  float z;
3006 +  __asm__ ("fsqrt.s %0,%1" : "=f" (z) : "f" (x));
3007 +  return z;
3008 +}
3009 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fclrexcpt.c glibc-2.19-riscv/sysdeps/riscv/fpu/fclrexcpt.c
3010 --- glibc-2.19/sysdeps/riscv/fpu/fclrexcpt.c    1969-12-31 16:00:00.000000000 -0800
3011 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fclrexcpt.c      2014-12-09 16:55:03.160727813 -0800
3012 @@ -0,0 +1,47 @@
3013 +/* Clear given exceptions in current floating-point environment.
3014 +   Copyright (C) 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
3015 +   This file is part of the GNU C Library.
3016 +   Contributed by Andreas Jaeger <aj@suse.de>, 1998.
3017 +
3018 +   The GNU C Library is free software; you can redistribute it and/or
3019 +   modify it under the terms of the GNU Lesser General Public
3020 +   License as published by the Free Software Foundation; either
3021 +   version 2.1 of the License, or (at your option) any later version.
3022 +
3023 +   The GNU C Library is distributed in the hope that it will be useful,
3024 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3025 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3026 +   Lesser General Public License for more details.
3027 +
3028 +   You should have received a copy of the GNU Lesser General Public
3029 +   License along with the GNU C Library; if not, write to the Free
3030 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3031 +   02111-1307 USA.  */
3032 +
3033 +#include <fenv.h>
3034 +#include <fenv_libc.h>
3035 +#include <fpu_control.h>
3036 +
3037 +int
3038 +feclearexcept (int excepts)
3039 +{
3040 +  int cw;
3041 +
3042 +  /* Mask out unsupported bits/exceptions.  */
3043 +  excepts &= FE_ALL_EXCEPT;
3044 +
3045 +  /* Read the complete control word.  */
3046 +  _FPU_GETCW (cw);
3047 +
3048 +  /* Clear exception flag bits and cause bits. If the cause bit is not
3049 +     cleared, the next CTC instruction (just below) will re-generate the
3050 +     exception.  */
3051 +
3052 +  cw &= ~(excepts | (excepts << CAUSE_SHIFT));
3053 +
3054 +  /* Put the new data in effect.  */
3055 +  _FPU_SETCW (cw);
3056 +
3057 +  /* Success.  */
3058 +  return 0;
3059 +}
3060 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fedisblxcpt.c glibc-2.19-riscv/sysdeps/riscv/fpu/fedisblxcpt.c
3061 --- glibc-2.19/sysdeps/riscv/fpu/fedisblxcpt.c  1969-12-31 16:00:00.000000000 -0800
3062 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fedisblxcpt.c    2014-12-09 16:55:03.160727813 -0800
3063 @@ -0,0 +1,42 @@
3064 +/* Disable floating-point exceptions.
3065 +   Copyright (C) 2000 Free Software Foundation, Inc.
3066 +   This file is part of the GNU C Library.
3067 +   Contributed by Andreas Jaeger <aj@suse.de>, 2000.
3068 +
3069 +   The GNU C Library is free software; you can redistribute it and/or
3070 +   modify it under the terms of the GNU Lesser General Public
3071 +   License as published by the Free Software Foundation; either
3072 +   version 2.1 of the License, or (at your option) any later version.
3073 +
3074 +   The GNU C Library is distributed in the hope that it will be useful,
3075 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3076 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3077 +   Lesser General Public License for more details.
3078 +
3079 +   You should have received a copy of the GNU Lesser General Public
3080 +   License along with the GNU C Library; if not, write to the Free
3081 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3082 +   02111-1307 USA.  */
3083 +
3084 +#include <fenv.h>
3085 +#include <fenv_libc.h>
3086 +#include <fpu_control.h>
3087 +
3088 +int
3089 +fedisableexcept (int excepts)
3090 +{
3091 +  unsigned int new_exc, old_exc;
3092 +
3093 +  /* Get the current control word.  */
3094 +  _FPU_GETCW (new_exc);
3095 +
3096 +  old_exc = (new_exc & ENABLE_MASK) >> ENABLE_SHIFT;
3097 +
3098 +  excepts &= FE_ALL_EXCEPT;
3099 +
3100 +  new_exc &= ~(excepts << ENABLE_SHIFT);
3101 +  new_exc &= ~_FPU_RESERVED;
3102 +  _FPU_SETCW (new_exc);
3103 +
3104 +  return old_exc;
3105 +}
3106 diff -ruN glibc-2.19/sysdeps/riscv/fpu/feenablxcpt.c glibc-2.19-riscv/sysdeps/riscv/fpu/feenablxcpt.c
3107 --- glibc-2.19/sysdeps/riscv/fpu/feenablxcpt.c  1969-12-31 16:00:00.000000000 -0800
3108 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/feenablxcpt.c    2014-12-09 16:55:03.160727813 -0800
3109 @@ -0,0 +1,42 @@
3110 +/* Enable floating-point exceptions.
3111 +   Copyright (C) 2000 Free Software Foundation, Inc.
3112 +   This file is part of the GNU C Library.
3113 +   Contributed by Andreas Jaeger <aj@suse.de>, 2000.
3114 +
3115 +   The GNU C Library is free software; you can redistribute it and/or
3116 +   modify it under the terms of the GNU Lesser General Public
3117 +   License as published by the Free Software Foundation; either
3118 +   version 2.1 of the License, or (at your option) any later version.
3119 +
3120 +   The GNU C Library is distributed in the hope that it will be useful,
3121 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3122 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3123 +   Lesser General Public License for more details.
3124 +
3125 +   You should have received a copy of the GNU Lesser General Public
3126 +   License along with the GNU C Library; if not, write to the Free
3127 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3128 +   02111-1307 USA.  */
3129 +
3130 +#include <fenv.h>
3131 +#include <fenv_libc.h>
3132 +#include <fpu_control.h>
3133 +
3134 +int
3135 +feenableexcept (int excepts)
3136 +{
3137 +  unsigned int new_exc, old_exc;
3138 +
3139 +  /* Get the current control word.  */
3140 +  _FPU_GETCW (new_exc);
3141 +
3142 +  old_exc = (new_exc & ENABLE_MASK) >> ENABLE_SHIFT;
3143 +
3144 +  excepts &= FE_ALL_EXCEPT;
3145 +
3146 +  new_exc |= excepts << ENABLE_SHIFT;
3147 +  new_exc &= ~_FPU_RESERVED;
3148 +  _FPU_SETCW (new_exc);
3149 +
3150 +  return old_exc;
3151 +}
3152 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fegetenv.c glibc-2.19-riscv/sysdeps/riscv/fpu/fegetenv.c
3153 --- glibc-2.19/sysdeps/riscv/fpu/fegetenv.c     1969-12-31 16:00:00.000000000 -0800
3154 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fegetenv.c       2014-12-09 16:55:03.160727813 -0800
3155 @@ -0,0 +1,32 @@
3156 +/* Store current floating-point environment.
3157 +   Copyright (C) 1998, 1999, 2000, 2002, 2010 Free Software Foundation, Inc.
3158 +   This file is part of the GNU C Library.
3159 +   Contributed by Andreas Jaeger <aj@suse.de>, 1998.
3160 +
3161 +   The GNU C Library is free software; you can redistribute it and/or
3162 +   modify it under the terms of the GNU Lesser General Public
3163 +   License as published by the Free Software Foundation; either
3164 +   version 2.1 of the License, or (at your option) any later version.
3165 +
3166 +   The GNU C Library is distributed in the hope that it will be useful,
3167 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3168 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3169 +   Lesser General Public License for more details.
3170 +
3171 +   You should have received a copy of the GNU Lesser General Public
3172 +   License along with the GNU C Library; if not, write to the Free
3173 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3174 +   02111-1307 USA.  */
3175 +
3176 +#include <fenv.h>
3177 +#include <fpu_control.h>
3178 +
3179 +int
3180 +fegetenv (fenv_t *envp)
3181 +{
3182 +  _FPU_GETCW (*envp);
3183 +
3184 +  /* Success.  */
3185 +  return 0;
3186 +}
3187 +libm_hidden_def (fegetenv)
3188 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fegetexcept.c glibc-2.19-riscv/sysdeps/riscv/fpu/fegetexcept.c
3189 --- glibc-2.19/sysdeps/riscv/fpu/fegetexcept.c  1969-12-31 16:00:00.000000000 -0800
3190 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fegetexcept.c    2014-12-09 16:55:03.160727813 -0800
3191 @@ -0,0 +1,34 @@
3192 +/* Get enabled floating-point exceptions.
3193 +   Copyright (C) 2000 Free Software Foundation, Inc.
3194 +   This file is part of the GNU C Library.
3195 +   Contributed by Andreas Jaeger <aj@suse.de>, 2000.
3196 +
3197 +   The GNU C Library is free software; you can redistribute it and/or
3198 +   modify it under the terms of the GNU Lesser General Public
3199 +   License as published by the Free Software Foundation; either
3200 +   version 2.1 of the License, or (at your option) any later version.
3201 +
3202 +   The GNU C Library is distributed in the hope that it will be useful,
3203 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3204 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3205 +   Lesser General Public License for more details.
3206 +
3207 +   You should have received a copy of the GNU Lesser General Public
3208 +   License along with the GNU C Library; if not, write to the Free
3209 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3210 +   02111-1307 USA.  */
3211 +
3212 +#include <fenv.h>
3213 +#include <fenv_libc.h>
3214 +#include <fpu_control.h>
3215 +
3216 +int
3217 +fegetexcept (void)
3218 +{
3219 +  unsigned int exc;
3220 +
3221 +  /* Get the current control word.  */
3222 +  _FPU_GETCW (exc);
3223 +
3224 +  return (exc & ENABLE_MASK) >> ENABLE_SHIFT;
3225 +}
3226 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fegetround.c glibc-2.19-riscv/sysdeps/riscv/fpu/fegetround.c
3227 --- glibc-2.19/sysdeps/riscv/fpu/fegetround.c   1969-12-31 16:00:00.000000000 -0800
3228 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fegetround.c     2014-12-09 16:55:03.160727813 -0800
3229 @@ -0,0 +1,33 @@
3230 +/* Return current rounding direction.
3231 +   Copyright (C) 1998 Free Software Foundation, Inc.
3232 +   This file is part of the GNU C Library.
3233 +   Contributed by Andreas Jaeger <aj@arthur.rhein-neckar.de>, 1998.
3234 +
3235 +   The GNU C Library is free software; you can redistribute it and/or
3236 +   modify it under the terms of the GNU Lesser General Public
3237 +   License as published by the Free Software Foundation; either
3238 +   version 2.1 of the License, or (at your option) any later version.
3239 +
3240 +   The GNU C Library is distributed in the hope that it will be useful,
3241 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3242 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3243 +   Lesser General Public License for more details.
3244 +
3245 +   You should have received a copy of the GNU Lesser General Public
3246 +   License along with the GNU C Library; if not, write to the Free
3247 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3248 +   02111-1307 USA.  */
3249 +
3250 +#include <fenv.h>
3251 +#include <fpu_control.h>
3252 +
3253 +int
3254 +fegetround (void)
3255 +{
3256 +  int cw;
3257 +
3258 +  /* Get control word.  */
3259 +  _FPU_GETCW (cw);
3260 +
3261 +  return cw & 0x3;
3262 +}
3263 diff -ruN glibc-2.19/sysdeps/riscv/fpu/feholdexcpt.c glibc-2.19-riscv/sysdeps/riscv/fpu/feholdexcpt.c
3264 --- glibc-2.19/sysdeps/riscv/fpu/feholdexcpt.c  1969-12-31 16:00:00.000000000 -0800
3265 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/feholdexcpt.c    2014-12-09 16:55:03.160727813 -0800
3266 @@ -0,0 +1,40 @@
3267 +/* Store current floating-point environment and clear exceptions.
3268 +   Copyright (C) 2000 Free Software Foundation, Inc.
3269 +   This file is part of the GNU C Library.
3270 +   Contributed by Andreas Jaeger <aj@suse.de>, 2000.
3271 +
3272 +   The GNU C Library is free software; you can redistribute it and/or
3273 +   modify it under the terms of the GNU Lesser General Public
3274 +   License as published by the Free Software Foundation; either
3275 +   version 2.1 of the License, or (at your option) any later version.
3276 +
3277 +   The GNU C Library is distributed in the hope that it will be useful,
3278 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3279 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3280 +   Lesser General Public License for more details.
3281 +
3282 +   You should have received a copy of the GNU Lesser General Public
3283 +   License along with the GNU C Library; if not, write to the Free
3284 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3285 +   02111-1307 USA.  */
3286 +
3287 +#include <fenv.h>
3288 +#include <fpu_control.h>
3289 +
3290 +int
3291 +feholdexcept (fenv_t *envp)
3292 +{
3293 +  fpu_control_t cw;
3294 +
3295 +  /* Save the current state.  */
3296 +  _FPU_GETCW (cw);
3297 +  envp->__fp_control_register = cw;
3298 +
3299 +  /* Clear all exception enable bits and flags.  */
3300 +  cw &= ~(_FPU_MASK_V|_FPU_MASK_Z|_FPU_MASK_O|_FPU_MASK_U|_FPU_MASK_I|FE_ALL_EXCEPT);
3301 +  _FPU_SETCW (cw);
3302 +
3303 +  return 0;
3304 +}
3305 +
3306 +libm_hidden_def (feholdexcept)
3307 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fenv_libc.h glibc-2.19-riscv/sysdeps/riscv/fpu/fenv_libc.h
3308 --- glibc-2.19/sysdeps/riscv/fpu/fenv_libc.h    1969-12-31 16:00:00.000000000 -0800
3309 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fenv_libc.h      2014-12-09 16:55:03.160727813 -0800
3310 @@ -0,0 +1,32 @@
3311 +/* Copyright (C) 2000, 2002 Free Software Foundation, Inc.
3312 +   This file is part of the GNU C Library.
3313 +   Contributed by Andreas Jaeger <aj@suse.de>.
3314 +
3315 +   The GNU C Library is free software; you can redistribute it and/or
3316 +   modify it under the terms of the GNU Lesser General Public
3317 +   License as published by the Free Software Foundation; either
3318 +   version 2.1 of the License, or (at your option) any later version.
3319 +
3320 +   The GNU C Library is distributed in the hope that it will be useful,
3321 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3322 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3323 +   Lesser General Public License for more details.
3324 +
3325 +   You should have received a copy of the GNU Lesser General Public
3326 +   License along with the GNU C Library; if not, write to the Free
3327 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3328 +   02111-1307 USA.  */
3329 +
3330 +#ifndef _FENV_LIBC_H
3331 +#define _FENV_LIBC_H    1
3332 +
3333 +/* Mask for enabling exceptions and for the CAUSE bits.  */
3334 +#define ENABLE_MASK    0x00F80U
3335 +#define CAUSE_MASK     0x1F000U
3336 +
3337 +/* Shift for FE_* flags to get up to the ENABLE bits and the CAUSE bits.  */
3338 +#define        ENABLE_SHIFT    5
3339 +#define        CAUSE_SHIFT     10
3340 +
3341 +
3342 +#endif /* _FENV_LIBC_H */
3343 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fesetenv.c glibc-2.19-riscv/sysdeps/riscv/fpu/fesetenv.c
3344 --- glibc-2.19/sysdeps/riscv/fpu/fesetenv.c     1969-12-31 16:00:00.000000000 -0800
3345 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fesetenv.c       2014-12-09 16:55:03.160727813 -0800
3346 @@ -0,0 +1,43 @@
3347 +/* Install given floating-point environment.
3348 +   Copyright (C) 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
3349 +   This file is part of the GNU C Library.
3350 +   Contributed by Andreas Jaeger <aj@suse.de>, 1998.
3351 +
3352 +   The GNU C Library is free software; you can redistribute it and/or
3353 +   modify it under the terms of the GNU Lesser General Public
3354 +   License as published by the Free Software Foundation; either
3355 +   version 2.1 of the License, or (at your option) any later version.
3356 +
3357 +   The GNU C Library is distributed in the hope that it will be useful,
3358 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3359 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3360 +   Lesser General Public License for more details.
3361 +
3362 +   You should have received a copy of the GNU Lesser General Public
3363 +   License along with the GNU C Library; if not, write to the Free
3364 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3365 +   02111-1307 USA.  */
3366 +
3367 +#include <fenv.h>
3368 +#include <fpu_control.h>
3369 +
3370 +int
3371 +fesetenv (const fenv_t *envp)
3372 +{
3373 +  fpu_control_t cw;
3374 +
3375 +  /* Read first current state to flush fpu pipeline.  */
3376 +  _FPU_GETCW (cw);
3377 +
3378 +  if (envp == FE_DFL_ENV)
3379 +    _FPU_SETCW (_FPU_DEFAULT);
3380 +  else if (envp == FE_NOMASK_ENV)
3381 +    _FPU_SETCW (_FPU_IEEE);
3382 +  else
3383 +    _FPU_SETCW (envp->__fp_control_register);
3384 +
3385 +  /* Success.  */
3386 +  return 0;
3387 +}
3388 +
3389 +libm_hidden_def (fesetenv)
3390 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fesetround.c glibc-2.19-riscv/sysdeps/riscv/fpu/fesetround.c
3391 --- glibc-2.19/sysdeps/riscv/fpu/fesetround.c   1969-12-31 16:00:00.000000000 -0800
3392 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fesetround.c     2014-12-09 16:55:03.160727813 -0800
3393 @@ -0,0 +1,45 @@
3394 +/* Set current rounding direction.
3395 +   Copyright (C) 1998 Free Software Foundation, Inc.
3396 +   This file is part of the GNU C Library.
3397 +   Contributed by Andreas Jaeger <aj@arthur.rhein-neckar.de>, 1998.
3398 +
3399 +   The GNU C Library is free software; you can redistribute it and/or
3400 +   modify it under the terms of the GNU Lesser General Public
3401 +   License as published by the Free Software Foundation; either
3402 +   version 2.1 of the License, or (at your option) any later version.
3403 +
3404 +   The GNU C Library is distributed in the hope that it will be useful,
3405 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3406 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3407 +   Lesser General Public License for more details.
3408 +
3409 +   You should have received a copy of the GNU Lesser General Public
3410 +   License along with the GNU C Library; if not, write to the Free
3411 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3412 +   02111-1307 USA.  */
3413 +
3414 +#include <fenv.h>
3415 +#include <fpu_control.h>
3416 +
3417 +int
3418 +fesetround (int round)
3419 +{
3420 +  fpu_control_t cw;
3421 +
3422 +  if ((round & ~0x3) != 0)
3423 +    /* ROUND is no valid rounding mode.  */
3424 +    return 1;
3425 +
3426 +  /* Get current state.  */
3427 +  _FPU_GETCW (cw);
3428 +
3429 +  /* Set rounding bits.  */
3430 +  cw &= ~0x3;
3431 +  cw |= round;
3432 +  /* Set new state.  */
3433 +  _FPU_SETCW (cw);
3434 +
3435 +  return 0;
3436 +}
3437 +
3438 +libm_hidden_def (fesetround)
3439 diff -ruN glibc-2.19/sysdeps/riscv/fpu/feupdateenv.c glibc-2.19-riscv/sysdeps/riscv/fpu/feupdateenv.c
3440 --- glibc-2.19/sysdeps/riscv/fpu/feupdateenv.c  1969-12-31 16:00:00.000000000 -0800
3441 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/feupdateenv.c    2014-12-09 16:55:03.160727813 -0800
3442 @@ -0,0 +1,44 @@
3443 +/* Install given floating-point environment and raise exceptions.
3444 +   Copyright (C) 1998, 1999, 2000, 2002, 2010 Free Software Foundation, Inc.
3445 +   This file is part of the GNU C Library.
3446 +   Contributed by Andreas Jaeger <aj@suse.de>, 1998.
3447 +
3448 +   The GNU C Library is free software; you can redistribute it and/or
3449 +   modify it under the terms of the GNU Lesser General Public
3450 +   License as published by the Free Software Foundation; either
3451 +   version 2.1 of the License, or (at your option) any later version.
3452 +
3453 +   The GNU C Library is distributed in the hope that it will be useful,
3454 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3455 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3456 +   Lesser General Public License for more details.
3457 +
3458 +   You should have received a copy of the GNU Lesser General Public
3459 +   License along with the GNU C Library; if not, write to the Free
3460 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3461 +   02111-1307 USA.  */
3462 +
3463 +#include <fenv.h>
3464 +#include <fpu_control.h>
3465 +
3466 +int
3467 +feupdateenv (const fenv_t *envp)
3468 +{
3469 +  int temp;
3470 +
3471 +  /* Save current exceptions.  */
3472 +  _FPU_GETCW (temp);
3473 +  temp &= FE_ALL_EXCEPT;
3474 +
3475 +  /* Install new environment.  */
3476 +  fesetenv (envp);
3477 +
3478 +  /* Raise the safed exception.  Incidently for us the implementation
3479 +     defined format of the values in objects of type fexcept_t is the
3480 +     same as the ones specified using the FE_* constants.  */
3481 +  feraiseexcept (temp);
3482 +
3483 +  /* Success.  */
3484 +  return 0;
3485 +}
3486 +libm_hidden_def (feupdateenv)
3487 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fgetexcptflg.c glibc-2.19-riscv/sysdeps/riscv/fpu/fgetexcptflg.c
3488 --- glibc-2.19/sysdeps/riscv/fpu/fgetexcptflg.c 1969-12-31 16:00:00.000000000 -0800
3489 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fgetexcptflg.c   2014-12-09 16:55:03.160727813 -0800
3490 @@ -0,0 +1,40 @@
3491 +/* Store current representation for exceptions.
3492 +   Copyright (C) 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
3493 +   This file is part of the GNU C Library.
3494 +   Contributed by Andreas Jaeger <aj@suse.de>, 1998.
3495 +
3496 +   The GNU C Library is free software; you can redistribute it and/or
3497 +   modify it under the terms of the GNU Lesser General Public
3498 +   License as published by the Free Software Foundation; either
3499 +   version 2.1 of the License, or (at your option) any later version.
3500 +
3501 +   The GNU C Library is distributed in the hope that it will be useful,
3502 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
3503 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3504 +   Lesser General Public License for more details.
3505 +
3506 +   You should have received a copy of the GNU Lesser General Public
3507 +   License along with the GNU C Library; if not, write to the Free
3508 +   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
3509 +   02111-1307 USA.  */
3510 +
3511 +#include <fenv.h>
3512 +#include <fpu_control.h>
3513 +
3514 +int
3515 +fegetexceptflag (fexcept_t *flagp, int excepts)
3516 +{
3517 +  fpu_control_t temp;
3518 +
3519 +  /* Get the current exceptions.  */
3520 +  _FPU_GETCW (temp);
3521 +
3522 +  /* We only save the relevant bits here. In particular, care has to be 
3523 +     taken with the CAUSE bits, as an inadvertent restore later on could
3524 +     generate unexpected exceptions.  */
3525 +
3526 +  *flagp = temp & excepts & FE_ALL_EXCEPT;
3527 +
3528 +  /* Success.  */
3529 +  return 0;
3530 +}
3531 diff -ruN glibc-2.19/sysdeps/riscv/fpu/fraiseexcpt.c glibc-2.19-riscv/sysdeps/riscv/fpu/fraiseexcpt.c
3532 --- glibc-2.19/sysdeps/riscv/fpu/fraiseexcpt.c  1969-12-31 16:00:00.000000000 -0800
3533 +++ glibc-2.19-riscv/sysdeps/riscv/fpu/fraiseexcpt.c    2014-12-09 16:55:03.160727813 -0800
3534 @@ -0,0 +1,47 @@
3535 +/* Raise given exceptions.
3536 +   Copyright (C) 2000, 2002 Free Software Foundation, Inc.
3537 +   This file is part of the GNU C Library.
3538 +   Contributed by Andreas Jaeger <aj@suse.de>, 2000.