1996-09-18 05:35:50 +00:00
|
|
|
|
/* More subroutines needed by GCC output code on some machines. */
|
|
|
|
|
/* Compile this one with gcc. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
2002-10-10 04:50:29 +00:00
|
|
|
|
2000, 2001, 2002 Free Software Foundation, Inc.
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
|
Software Foundation; either version 2, or (at your option) any later
|
|
|
|
|
version.
|
|
|
|
|
|
|
|
|
|
In addition to the permissions in the GNU General Public License, the
|
|
|
|
|
Free Software Foundation gives you unlimited permission to link the
|
|
|
|
|
compiled version of this file into combinations with other programs,
|
|
|
|
|
and to distribute those combinations without any restriction coming
|
|
|
|
|
from the use of this file. (The General Public License restrictions
|
|
|
|
|
do apply in other respects; for example, they cover modification of
|
|
|
|
|
the file, and distribution when not linked into a combine
|
|
|
|
|
executable.)
|
|
|
|
|
|
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
|
for more details.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2002-02-06 04:49:08 +00:00
|
|
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
|
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
|
|
|
02111-1307, USA. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
/* $FreeBSD$ */
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
/* It is incorrect to include config.h here, because this file is being
|
|
|
|
|
compiled for the target, and hence definitions concerning only the host
|
|
|
|
|
do not apply. */
|
|
|
|
|
|
|
|
|
|
#include "tconfig.h"
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#include "tsystem.h"
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
/* Don't use `fancy_abort' here even if config.h says to use it. */
|
|
|
|
|
#ifdef abort
|
|
|
|
|
#undef abort
|
|
|
|
|
#endif
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#include "libgcc2.h"
|
|
|
|
|
|
|
|
|
|
#if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
|
|
|
|
|
#if defined (L_divdi3) || defined (L_moddi3)
|
|
|
|
|
static inline
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__negdi2 (DWtype u)
|
|
|
|
|
{
|
|
|
|
|
DWunion w;
|
|
|
|
|
DWunion uu;
|
|
|
|
|
|
|
|
|
|
uu.ll = u;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w.s.low = -uu.s.low;
|
|
|
|
|
w.s.high = -uu.s.high - ((UWtype) w.s.low > 0);
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w.ll;
|
|
|
|
|
}
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef L_addvsi3
|
|
|
|
|
Wtype
|
|
|
|
|
__addvsi3 (Wtype a, Wtype b)
|
|
|
|
|
{
|
|
|
|
|
Wtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w = a + b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (b >= 0 ? w < a : w > a)
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
return w;
|
|
|
|
|
}
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
#ifdef L_addvdi3
|
|
|
|
|
DWtype
|
|
|
|
|
__addvdi3 (DWtype a, DWtype b)
|
|
|
|
|
{
|
|
|
|
|
DWtype w;
|
|
|
|
|
|
|
|
|
|
w = a + b;
|
|
|
|
|
|
|
|
|
|
if (b >= 0 ? w < a : w > a)
|
|
|
|
|
abort ();
|
1999-10-27 09:45:47 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_subvsi3
|
|
|
|
|
Wtype
|
|
|
|
|
__subvsi3 (Wtype a, Wtype b)
|
|
|
|
|
{
|
|
|
|
|
#ifdef L_addvsi3
|
|
|
|
|
return __addvsi3 (a, (-b));
|
|
|
|
|
#else
|
|
|
|
|
DWtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w = a - b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (b >= 0 ? w > a : w < a)
|
|
|
|
|
abort ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
#ifdef L_subvdi3
|
|
|
|
|
DWtype
|
|
|
|
|
__subvdi3 (DWtype a, DWtype b)
|
|
|
|
|
{
|
|
|
|
|
#ifdef L_addvdi3
|
|
|
|
|
return (a, (-b));
|
|
|
|
|
#else
|
|
|
|
|
DWtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w = a - b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (b >= 0 ? w > a : w < a)
|
|
|
|
|
abort ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_mulvsi3
|
|
|
|
|
Wtype
|
|
|
|
|
__mulvsi3 (Wtype a, Wtype b)
|
|
|
|
|
{
|
|
|
|
|
DWtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w = a * b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (((a >= 0) == (b >= 0)) ? w < 0 : w > 0)
|
|
|
|
|
abort ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
#ifdef L_negvsi2
|
|
|
|
|
Wtype
|
|
|
|
|
__negvsi2 (Wtype a)
|
|
|
|
|
{
|
|
|
|
|
Wtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w = -a;
|
|
|
|
|
|
|
|
|
|
if (a >= 0 ? w > 0 : w < 0)
|
|
|
|
|
abort ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_negvdi2
|
|
|
|
|
DWtype
|
|
|
|
|
__negvdi2 (DWtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype w;
|
|
|
|
|
|
|
|
|
|
w = -a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (a >= 0 ? w > 0 : w < 0)
|
|
|
|
|
abort ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_absvsi2
|
|
|
|
|
Wtype
|
|
|
|
|
__absvsi2 (Wtype a)
|
|
|
|
|
{
|
|
|
|
|
Wtype w = a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (a < 0)
|
|
|
|
|
#ifdef L_negvsi2
|
|
|
|
|
w = __negvsi2 (a);
|
|
|
|
|
#else
|
|
|
|
|
w = -a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (w < 0)
|
|
|
|
|
abort ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
return w;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef L_absvdi2
|
|
|
|
|
DWtype
|
|
|
|
|
__absvdi2 (DWtype a)
|
|
|
|
|
{
|
|
|
|
|
DWtype w = a;
|
|
|
|
|
|
|
|
|
|
if (a < 0)
|
|
|
|
|
#ifdef L_negvsi2
|
|
|
|
|
w = __negvsi2 (a);
|
|
|
|
|
#else
|
|
|
|
|
w = -a;
|
|
|
|
|
|
|
|
|
|
if (w < 0)
|
|
|
|
|
abort ();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return w;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
#ifdef L_mulvdi3
|
|
|
|
|
DWtype
|
|
|
|
|
__mulvdi3 (DWtype u, DWtype v)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w = u * v;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (((u >= 0) == (v >= 0)) ? w < 0 : w > 0)
|
|
|
|
|
abort ();
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
/* Unless shift functions are defined whith full ANSI prototypes,
|
|
|
|
|
parameter b will be promoted to int if word_type is smaller than an int. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#ifdef L_lshrdi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__lshrdi3 (DWtype u, word_type b)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
word_type bm;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion uu;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (b == 0)
|
|
|
|
|
return u;
|
|
|
|
|
|
|
|
|
|
uu.ll = u;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (bm <= 0)
|
|
|
|
|
{
|
|
|
|
|
w.s.high = 0;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w.s.low = (UWtype) uu.s.high >> -bm;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype carries = (UWtype) uu.s.high << bm;
|
|
|
|
|
|
|
|
|
|
w.s.high = (UWtype) uu.s.high >> b;
|
|
|
|
|
w.s.low = ((UWtype) uu.s.low >> b) | carries;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return w.ll;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_ashldi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__ashldi3 (DWtype u, word_type b)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
word_type bm;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion uu;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (b == 0)
|
|
|
|
|
return u;
|
|
|
|
|
|
|
|
|
|
uu.ll = u;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (bm <= 0)
|
|
|
|
|
{
|
|
|
|
|
w.s.low = 0;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w.s.high = (UWtype) uu.s.low << -bm;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype carries = (UWtype) uu.s.low >> bm;
|
|
|
|
|
|
|
|
|
|
w.s.low = (UWtype) uu.s.low << b;
|
|
|
|
|
w.s.high = ((UWtype) uu.s.high << b) | carries;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return w.ll;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_ashrdi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__ashrdi3 (DWtype u, word_type b)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
word_type bm;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion uu;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (b == 0)
|
|
|
|
|
return u;
|
|
|
|
|
|
|
|
|
|
uu.ll = u;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (bm <= 0)
|
|
|
|
|
{
|
|
|
|
|
/* w.s.high = 1..1 or 0..0 */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
w.s.low = uu.s.high >> -bm;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype carries = (UWtype) uu.s.high << bm;
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
w.s.high = uu.s.high >> b;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w.s.low = ((UWtype) uu.s.low >> b) | carries;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return w.ll;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_ffsdi2
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__ffsdi2 (DWtype u)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion uu;
|
|
|
|
|
UWtype word, count, add;
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
uu.ll = u;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (uu.s.low != 0)
|
|
|
|
|
word = uu.s.low, add = 0;
|
|
|
|
|
else if (uu.s.high != 0)
|
|
|
|
|
word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
count_trailing_zeros (count, word);
|
|
|
|
|
return count + add + 1;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_muldi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__muldi3 (DWtype u, DWtype v)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion w;
|
|
|
|
|
DWunion uu, vv;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
uu.ll = u,
|
|
|
|
|
vv.ll = v;
|
|
|
|
|
|
|
|
|
|
w.ll = __umulsidi3 (uu.s.low, vv.s.low);
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
|
|
|
|
|
+ (UWtype) uu.s.high * (UWtype) vv.s.low);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
return w.ll;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_udiv_w_sdiv
|
|
|
|
|
#if defined (sdiv_qrnnd)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype
|
|
|
|
|
__udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype q, r;
|
|
|
|
|
UWtype c0, c1, b1;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if ((Wtype) d >= 0)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
/* dividend, divisor, and quotient are nonnegative */
|
|
|
|
|
sdiv_qrnnd (q, r, a1, a0, d);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
/* Divide (c1*2^32 + c0) by d */
|
|
|
|
|
sdiv_qrnnd (q, r, c1, c0, d);
|
|
|
|
|
/* Add 2^31 to quotient */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
q += (UWtype) 1 << (W_TYPE_SIZE - 1);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
|
|
|
|
|
c1 = a1 >> 1; /* A/2 */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
|
|
|
|
|
{
|
|
|
|
|
sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
|
|
|
|
|
|
|
|
|
|
r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
|
|
|
|
|
if ((d & 1) != 0)
|
|
|
|
|
{
|
|
|
|
|
if (r >= q)
|
|
|
|
|
r = r - q;
|
|
|
|
|
else if (q - r <= d)
|
|
|
|
|
{
|
|
|
|
|
r = r - q + d;
|
|
|
|
|
q--;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
r = r - q + 2*d;
|
|
|
|
|
q -= 2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
|
|
|
|
|
{
|
|
|
|
|
c1 = (b1 - 1) - c1;
|
|
|
|
|
c0 = ~c0; /* logical NOT */
|
|
|
|
|
|
|
|
|
|
sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
|
|
|
|
|
|
|
|
|
|
q = ~q; /* (A/2)/b1 */
|
|
|
|
|
r = (b1 - 1) - r;
|
|
|
|
|
|
|
|
|
|
r = 2*r + (a0 & 1); /* A/(2*b1) */
|
|
|
|
|
|
|
|
|
|
if ((d & 1) != 0)
|
|
|
|
|
{
|
|
|
|
|
if (r >= q)
|
|
|
|
|
r = r - q;
|
|
|
|
|
else if (q - r <= d)
|
|
|
|
|
{
|
|
|
|
|
r = r - q + d;
|
|
|
|
|
q--;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
r = r - q + 2*d;
|
|
|
|
|
q -= 2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else /* Implies c1 = b1 */
|
|
|
|
|
{ /* Hence a1 = d - 1 = 2*b1 - 1 */
|
|
|
|
|
if (a0 >= -d)
|
|
|
|
|
{
|
|
|
|
|
q = -1;
|
|
|
|
|
r = a0 + d;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
q = -2;
|
|
|
|
|
r = a0 + 2*d;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*rp = r;
|
|
|
|
|
return q;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
/* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype
|
|
|
|
|
__udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
|
|
|
|
|
UWtype a1 __attribute__ ((__unused__)),
|
|
|
|
|
UWtype a0 __attribute__ ((__unused__)),
|
|
|
|
|
UWtype d __attribute__ ((__unused__)))
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if (defined (L_udivdi3) || defined (L_divdi3) || \
|
|
|
|
|
defined (L_umoddi3) || defined (L_moddi3))
|
|
|
|
|
#define L_udivmoddi4
|
|
|
|
|
#endif
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef L_clz
|
|
|
|
|
const UQItype __clz_tab[] =
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
|
|
|
|
|
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
|
|
|
|
|
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
|
|
|
|
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
|
|
|
|
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
|
|
|
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
|
|
|
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
|
|
|
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
|
|
|
};
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_udivmoddi4
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
#if (defined (L_udivdi3) || defined (L_divdi3) || \
|
|
|
|
|
defined (L_umoddi3) || defined (L_moddi3))
|
|
|
|
|
static inline
|
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype
|
|
|
|
|
__udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion ww;
|
|
|
|
|
DWunion nn, dd;
|
|
|
|
|
DWunion rr;
|
|
|
|
|
UWtype d0, d1, n0, n1, n2;
|
|
|
|
|
UWtype q0, q1;
|
|
|
|
|
UWtype b, bm;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
nn.ll = n;
|
|
|
|
|
dd.ll = d;
|
|
|
|
|
|
|
|
|
|
d0 = dd.s.low;
|
|
|
|
|
d1 = dd.s.high;
|
|
|
|
|
n0 = nn.s.low;
|
|
|
|
|
n1 = nn.s.high;
|
|
|
|
|
|
|
|
|
|
#if !UDIV_NEEDS_NORMALIZATION
|
|
|
|
|
if (d1 == 0)
|
|
|
|
|
{
|
|
|
|
|
if (d0 > n1)
|
|
|
|
|
{
|
|
|
|
|
/* 0q = nn / 0D */
|
|
|
|
|
|
|
|
|
|
udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
|
|
q1 = 0;
|
|
|
|
|
|
|
|
|
|
/* Remainder in n0. */
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* qq = NN / 0d */
|
|
|
|
|
|
|
|
|
|
if (d0 == 0)
|
|
|
|
|
d0 = 1 / d0; /* Divide intentionally by zero. */
|
|
|
|
|
|
|
|
|
|
udiv_qrnnd (q1, n1, 0, n1, d0);
|
|
|
|
|
udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
|
|
|
|
|
|
|
/* Remainder in n0. */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (rp != 0)
|
|
|
|
|
{
|
|
|
|
|
rr.s.low = n0;
|
|
|
|
|
rr.s.high = 0;
|
|
|
|
|
*rp = rr.ll;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else /* UDIV_NEEDS_NORMALIZATION */
|
|
|
|
|
|
|
|
|
|
if (d1 == 0)
|
|
|
|
|
{
|
|
|
|
|
if (d0 > n1)
|
|
|
|
|
{
|
|
|
|
|
/* 0q = nn / 0D */
|
|
|
|
|
|
|
|
|
|
count_leading_zeros (bm, d0);
|
|
|
|
|
|
|
|
|
|
if (bm != 0)
|
|
|
|
|
{
|
|
|
|
|
/* Normalize, i.e. make the most significant bit of the
|
|
|
|
|
denominator set. */
|
|
|
|
|
|
|
|
|
|
d0 = d0 << bm;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
n0 = n0 << bm;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
|
|
q1 = 0;
|
|
|
|
|
|
|
|
|
|
/* Remainder in n0 >> bm. */
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* qq = NN / 0d */
|
|
|
|
|
|
|
|
|
|
if (d0 == 0)
|
|
|
|
|
d0 = 1 / d0; /* Divide intentionally by zero. */
|
|
|
|
|
|
|
|
|
|
count_leading_zeros (bm, d0);
|
|
|
|
|
|
|
|
|
|
if (bm == 0)
|
|
|
|
|
{
|
|
|
|
|
/* From (n1 >= d0) /\ (the most significant bit of d0 is set),
|
|
|
|
|
conclude (the most significant bit of n1 is set) /\ (the
|
|
|
|
|
leading quotient digit q1 = 1).
|
|
|
|
|
|
|
|
|
|
This special case is necessary, not an optimization.
|
2002-02-06 04:49:08 +00:00
|
|
|
|
(Shifts counts of W_TYPE_SIZE are undefined.) */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
n1 -= d0;
|
|
|
|
|
q1 = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Normalize. */
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
b = W_TYPE_SIZE - bm;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
d0 = d0 << bm;
|
|
|
|
|
n2 = n1 >> b;
|
|
|
|
|
n1 = (n1 << bm) | (n0 >> b);
|
|
|
|
|
n0 = n0 << bm;
|
|
|
|
|
|
|
|
|
|
udiv_qrnnd (q1, n1, n2, n1, d0);
|
|
|
|
|
}
|
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
/* n1 != d0... */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
|
|
|
|
|
|
|
/* Remainder in n0 >> bm. */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (rp != 0)
|
|
|
|
|
{
|
|
|
|
|
rr.s.low = n0 >> bm;
|
|
|
|
|
rr.s.high = 0;
|
|
|
|
|
*rp = rr.ll;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif /* UDIV_NEEDS_NORMALIZATION */
|
|
|
|
|
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (d1 > n1)
|
|
|
|
|
{
|
|
|
|
|
/* 00 = nn / DD */
|
|
|
|
|
|
|
|
|
|
q0 = 0;
|
|
|
|
|
q1 = 0;
|
|
|
|
|
|
|
|
|
|
/* Remainder in n1n0. */
|
|
|
|
|
if (rp != 0)
|
|
|
|
|
{
|
|
|
|
|
rr.s.low = n0;
|
|
|
|
|
rr.s.high = n1;
|
|
|
|
|
*rp = rr.ll;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* 0q = NN / dd */
|
|
|
|
|
|
|
|
|
|
count_leading_zeros (bm, d1);
|
|
|
|
|
if (bm == 0)
|
|
|
|
|
{
|
|
|
|
|
/* From (n1 >= d1) /\ (the most significant bit of d1 is set),
|
|
|
|
|
conclude (the most significant bit of n1 is set) /\ (the
|
|
|
|
|
quotient digit q0 = 0 or 1).
|
|
|
|
|
|
|
|
|
|
This special case is necessary, not an optimization. */
|
|
|
|
|
|
|
|
|
|
/* The condition on the next line takes advantage of that
|
|
|
|
|
n1 >= d1 (true due to program flow). */
|
|
|
|
|
if (n1 > d1 || n0 >= d0)
|
|
|
|
|
{
|
|
|
|
|
q0 = 1;
|
|
|
|
|
sub_ddmmss (n1, n0, n1, n0, d1, d0);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
q0 = 0;
|
|
|
|
|
|
|
|
|
|
q1 = 0;
|
|
|
|
|
|
|
|
|
|
if (rp != 0)
|
|
|
|
|
{
|
|
|
|
|
rr.s.low = n0;
|
|
|
|
|
rr.s.high = n1;
|
|
|
|
|
*rp = rr.ll;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype m1, m0;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
/* Normalize. */
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
b = W_TYPE_SIZE - bm;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
d1 = (d1 << bm) | (d0 >> b);
|
|
|
|
|
d0 = d0 << bm;
|
|
|
|
|
n2 = n1 >> b;
|
|
|
|
|
n1 = (n1 << bm) | (n0 >> b);
|
|
|
|
|
n0 = n0 << bm;
|
|
|
|
|
|
|
|
|
|
udiv_qrnnd (q0, n1, n2, n1, d1);
|
|
|
|
|
umul_ppmm (m1, m0, q0, d0);
|
|
|
|
|
|
|
|
|
|
if (m1 > n1 || (m1 == n1 && m0 > n0))
|
|
|
|
|
{
|
|
|
|
|
q0--;
|
|
|
|
|
sub_ddmmss (m1, m0, m1, m0, d1, d0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
q1 = 0;
|
|
|
|
|
|
|
|
|
|
/* Remainder in (n1n0 - m1m0) >> bm. */
|
|
|
|
|
if (rp != 0)
|
|
|
|
|
{
|
|
|
|
|
sub_ddmmss (n1, n0, n1, n0, m1, m0);
|
|
|
|
|
rr.s.low = (n1 << b) | (n0 >> bm);
|
|
|
|
|
rr.s.high = n1 >> bm;
|
|
|
|
|
*rp = rr.ll;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ww.s.low = q0;
|
|
|
|
|
ww.s.high = q1;
|
|
|
|
|
return ww.ll;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_divdi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__divdi3 (DWtype u, DWtype v)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
word_type c = 0;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion uu, vv;
|
|
|
|
|
DWtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
uu.ll = u;
|
|
|
|
|
vv.ll = v;
|
|
|
|
|
|
|
|
|
|
if (uu.s.high < 0)
|
|
|
|
|
c = ~c,
|
|
|
|
|
uu.ll = __negdi2 (uu.ll);
|
|
|
|
|
if (vv.s.high < 0)
|
|
|
|
|
c = ~c,
|
|
|
|
|
vv.ll = __negdi2 (vv.ll);
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
if (c)
|
|
|
|
|
w = __negdi2 (w);
|
|
|
|
|
|
|
|
|
|
return w;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_moddi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__moddi3 (DWtype u, DWtype v)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
word_type c = 0;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion uu, vv;
|
|
|
|
|
DWtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
uu.ll = u;
|
|
|
|
|
vv.ll = v;
|
|
|
|
|
|
|
|
|
|
if (uu.s.high < 0)
|
|
|
|
|
c = ~c,
|
|
|
|
|
uu.ll = __negdi2 (uu.ll);
|
|
|
|
|
if (vv.s.high < 0)
|
|
|
|
|
vv.ll = __negdi2 (vv.ll);
|
|
|
|
|
|
|
|
|
|
(void) __udivmoddi4 (uu.ll, vv.ll, &w);
|
|
|
|
|
if (c)
|
|
|
|
|
w = __negdi2 (w);
|
|
|
|
|
|
|
|
|
|
return w;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_umoddi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype
|
|
|
|
|
__umoddi3 (UDWtype u, UDWtype v)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype w;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
(void) __udivmoddi4 (u, v, &w);
|
|
|
|
|
|
|
|
|
|
return w;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_udivdi3
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype
|
|
|
|
|
__udivdi3 (UDWtype n, UDWtype d)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return __udivmoddi4 (n, d, (UDWtype *) 0);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_cmpdi2
|
|
|
|
|
word_type
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__cmpdi2 (DWtype a, DWtype b)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion au, bu;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
au.ll = a, bu.ll = b;
|
|
|
|
|
|
|
|
|
|
if (au.s.high < bu.s.high)
|
|
|
|
|
return 0;
|
|
|
|
|
else if (au.s.high > bu.s.high)
|
|
|
|
|
return 2;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if ((UWtype) au.s.low < (UWtype) bu.s.low)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return 0;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
else if ((UWtype) au.s.low > (UWtype) bu.s.low)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return 2;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_ucmpdi2
|
|
|
|
|
word_type
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__ucmpdi2 (DWtype a, DWtype b)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWunion au, bu;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
au.ll = a, bu.ll = b;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if ((UWtype) au.s.high < (UWtype) bu.s.high)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return 0;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
else if ((UWtype) au.s.high > (UWtype) bu.s.high)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return 2;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if ((UWtype) au.s.low < (UWtype) bu.s.low)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return 0;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
else if ((UWtype) au.s.low > (UWtype) bu.s.low)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return 2;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__fixunstfDI (TFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
TFtype b;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype v;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (a < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* Compute high word of result, as a flonum. */
|
|
|
|
|
b = (a / HIGH_WORD_COEFF);
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Convert that to fixed (but not to DWtype!),
|
1996-09-18 05:35:50 +00:00
|
|
|
|
and shift it into the high word. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v = (UWtype) b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
v <<= WORD_SIZE;
|
|
|
|
|
/* Remove high part from the TFtype, leaving the low part as flonum. */
|
|
|
|
|
a -= (TFtype)v;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Convert that to fixed (but not to DWtype!) and add it in.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
Sometimes A comes out negative. This is significant, since
|
|
|
|
|
A has more bits than a long int does. */
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v -= (UWtype) (- a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v += (UWtype) a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
1999-08-30 00:01:36 +00:00
|
|
|
|
__fixtfdi (TFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return - __fixunstfDI (-a);
|
|
|
|
|
return __fixunstfDI (a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__fixunsxfDI (XFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
XFtype b;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype v;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (a < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* Compute high word of result, as a flonum. */
|
|
|
|
|
b = (a / HIGH_WORD_COEFF);
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Convert that to fixed (but not to DWtype!),
|
1996-09-18 05:35:50 +00:00
|
|
|
|
and shift it into the high word. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v = (UWtype) b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
v <<= WORD_SIZE;
|
|
|
|
|
/* Remove high part from the XFtype, leaving the low part as flonum. */
|
|
|
|
|
a -= (XFtype)v;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Convert that to fixed (but not to DWtype!) and add it in.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
Sometimes A comes out negative. This is significant, since
|
|
|
|
|
A has more bits than a long int does. */
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v -= (UWtype) (- a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v += (UWtype) a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
1999-08-30 00:01:36 +00:00
|
|
|
|
__fixxfdi (XFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return - __fixunsxfDI (-a);
|
|
|
|
|
return __fixunsxfDI (a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_fixunsdfdi
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__fixunsdfDI (DFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
DFtype b;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype v;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (a < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* Compute high word of result, as a flonum. */
|
|
|
|
|
b = (a / HIGH_WORD_COEFF);
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Convert that to fixed (but not to DWtype!),
|
1996-09-18 05:35:50 +00:00
|
|
|
|
and shift it into the high word. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v = (UWtype) b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
v <<= WORD_SIZE;
|
|
|
|
|
/* Remove high part from the DFtype, leaving the low part as flonum. */
|
|
|
|
|
a -= (DFtype)v;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Convert that to fixed (but not to DWtype!) and add it in.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
Sometimes A comes out negative. This is significant, since
|
|
|
|
|
A has more bits than a long int does. */
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v -= (UWtype) (- a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v += (UWtype) a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_fixdfdi
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
1999-08-30 00:01:36 +00:00
|
|
|
|
__fixdfdi (DFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return - __fixunsdfDI (-a);
|
|
|
|
|
return __fixunsdfDI (a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_fixunssfdi
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
|
|
|
|
__fixunssfDI (SFtype original_a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
/* Convert the SFtype to a DFtype, because that is surely not going
|
|
|
|
|
to lose any bits. Some day someone else can write a faster version
|
|
|
|
|
that avoids converting to DFtype, and verify it really works right. */
|
|
|
|
|
DFtype a = original_a;
|
|
|
|
|
DFtype b;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UDWtype v;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (a < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* Compute high word of result, as a flonum. */
|
|
|
|
|
b = (a / HIGH_WORD_COEFF);
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Convert that to fixed (but not to DWtype!),
|
1996-09-18 05:35:50 +00:00
|
|
|
|
and shift it into the high word. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v = (UWtype) b;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
v <<= WORD_SIZE;
|
|
|
|
|
/* Remove high part from the DFtype, leaving the low part as flonum. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
a -= (DFtype) v;
|
|
|
|
|
/* Convert that to fixed (but not to DWtype!) and add it in.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
Sometimes A comes out negative. This is significant, since
|
|
|
|
|
A has more bits than a long int does. */
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v -= (UWtype) (- a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
else
|
2002-02-06 04:49:08 +00:00
|
|
|
|
v += (UWtype) a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_fixsfdi
|
2002-02-06 04:49:08 +00:00
|
|
|
|
DWtype
|
1996-09-18 05:35:50 +00:00
|
|
|
|
__fixsfdi (SFtype a)
|
|
|
|
|
{
|
|
|
|
|
if (a < 0)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return - __fixunssfDI (-a);
|
|
|
|
|
return __fixunssfDI (a);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
XFtype
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__floatdixf (DWtype u)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
XFtype d;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
d = (Wtype) (u >> WORD_SIZE);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
d *= HIGH_HALFWORD_COEFF;
|
|
|
|
|
d *= HIGH_HALFWORD_COEFF;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
return d;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
TFtype
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__floatditf (DWtype u)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
TFtype d;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
d = (Wtype) (u >> WORD_SIZE);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
d *= HIGH_HALFWORD_COEFF;
|
|
|
|
|
d *= HIGH_HALFWORD_COEFF;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
return d;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_floatdidf
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
DFtype
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__floatdidf (DWtype u)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
DFtype d;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
d = (Wtype) (u >> WORD_SIZE);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
d *= HIGH_HALFWORD_COEFF;
|
|
|
|
|
d *= HIGH_HALFWORD_COEFF;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
return d;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_floatdisf
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
|
|
|
|
|
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
|
|
|
|
|
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
|
|
|
|
|
#define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
/* Define codes for all the float formats that we know of. Note
|
|
|
|
|
that this is copied from real.h. */
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#define UNKNOWN_FLOAT_FORMAT 0
|
|
|
|
|
#define IEEE_FLOAT_FORMAT 1
|
|
|
|
|
#define VAX_FLOAT_FORMAT 2
|
|
|
|
|
#define IBM_FLOAT_FORMAT 3
|
|
|
|
|
|
|
|
|
|
/* Default to IEEE float if not specified. Nearly all machines use it. */
|
|
|
|
|
#ifndef HOST_FLOAT_FORMAT
|
|
|
|
|
#define HOST_FLOAT_FORMAT IEEE_FLOAT_FORMAT
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
|
|
|
|
|
#define DF_SIZE 53
|
|
|
|
|
#define SF_SIZE 24
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
|
|
|
|
|
#define DF_SIZE 56
|
|
|
|
|
#define SF_SIZE 24
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
|
|
|
|
|
#define DF_SIZE 56
|
|
|
|
|
#define SF_SIZE 24
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
SFtype
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__floatdisf (DWtype u)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
/* Do the calculation in DFmode
|
|
|
|
|
so that we don't lose any of the precision of the high word
|
|
|
|
|
while multiplying it. */
|
|
|
|
|
DFtype f;
|
|
|
|
|
|
|
|
|
|
/* Protect against double-rounding error.
|
|
|
|
|
Represent any low-order bits, that might be truncated in DFmode,
|
|
|
|
|
by a bit that won't be lost. The bit can go in anywhere below the
|
|
|
|
|
rounding position of the SFmode. A fixed mask and bit position
|
|
|
|
|
handles all usual configurations. It doesn't handle the case
|
|
|
|
|
of 128-bit DImode, however. */
|
|
|
|
|
if (DF_SIZE < DI_SIZE
|
|
|
|
|
&& DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
|
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
|
|
|
|
|
if (! (- ((DWtype) 1 << DF_SIZE) < u
|
|
|
|
|
&& u < ((DWtype) 1 << DF_SIZE)))
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if ((UDWtype) u & (REP_BIT - 1))
|
2002-10-10 04:50:29 +00:00
|
|
|
|
{
|
|
|
|
|
u &= ~ (REP_BIT - 1);
|
|
|
|
|
u |= REP_BIT;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2002-02-06 04:49:08 +00:00
|
|
|
|
f = (Wtype) (u >> WORD_SIZE);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
f *= HIGH_HALFWORD_COEFF;
|
|
|
|
|
f *= HIGH_HALFWORD_COEFF;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
return (SFtype) f;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
|
1996-09-18 05:35:50 +00:00
|
|
|
|
/* Reenable the normal types, in case limits.h needs them. */
|
|
|
|
|
#undef char
|
|
|
|
|
#undef short
|
|
|
|
|
#undef int
|
|
|
|
|
#undef long
|
|
|
|
|
#undef unsigned
|
|
|
|
|
#undef float
|
|
|
|
|
#undef double
|
|
|
|
|
#undef MIN
|
|
|
|
|
#undef MAX
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype
|
|
|
|
|
__fixunsxfSI (XFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (a >= - (DFtype) Wtype_MIN)
|
|
|
|
|
return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
|
|
|
|
|
return (Wtype) a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_fixunsdfsi
|
|
|
|
|
/* Reenable the normal types, in case limits.h needs them. */
|
|
|
|
|
#undef char
|
|
|
|
|
#undef short
|
|
|
|
|
#undef int
|
|
|
|
|
#undef long
|
|
|
|
|
#undef unsigned
|
|
|
|
|
#undef float
|
|
|
|
|
#undef double
|
|
|
|
|
#undef MIN
|
|
|
|
|
#undef MAX
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype
|
|
|
|
|
__fixunsdfSI (DFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (a >= - (DFtype) Wtype_MIN)
|
|
|
|
|
return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
|
|
|
|
|
return (Wtype) a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_fixunssfsi
|
|
|
|
|
/* Reenable the normal types, in case limits.h needs them. */
|
|
|
|
|
#undef char
|
|
|
|
|
#undef short
|
|
|
|
|
#undef int
|
|
|
|
|
#undef long
|
|
|
|
|
#undef unsigned
|
|
|
|
|
#undef float
|
|
|
|
|
#undef double
|
|
|
|
|
#undef MIN
|
|
|
|
|
#undef MAX
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
UWtype
|
|
|
|
|
__fixunssfSI (SFtype a)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (a >= - (SFtype) Wtype_MIN)
|
|
|
|
|
return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
|
|
|
|
|
return (Wtype) a;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* From here on down, the routines use normal data types. */
|
|
|
|
|
|
|
|
|
|
#define SItype bogus_type
|
|
|
|
|
#define USItype bogus_type
|
|
|
|
|
#define DItype bogus_type
|
|
|
|
|
#define UDItype bogus_type
|
|
|
|
|
#define SFtype bogus_type
|
|
|
|
|
#define DFtype bogus_type
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#undef Wtype
|
|
|
|
|
#undef UWtype
|
|
|
|
|
#undef HWtype
|
|
|
|
|
#undef UHWtype
|
|
|
|
|
#undef DWtype
|
|
|
|
|
#undef UDWtype
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
#undef char
|
|
|
|
|
#undef short
|
|
|
|
|
#undef int
|
|
|
|
|
#undef long
|
|
|
|
|
#undef unsigned
|
|
|
|
|
#undef float
|
|
|
|
|
#undef double
|
|
|
|
|
|
|
|
|
|
#ifdef L__gcc_bcmp
|
|
|
|
|
|
|
|
|
|
/* Like bcmp except the sign is meaningful.
|
|
|
|
|
Result is negative if S1 is less than S2,
|
|
|
|
|
positive if S1 is greater, 0 if S1 and S2 are equal. */
|
|
|
|
|
|
|
|
|
|
int
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
while (size > 0)
|
|
|
|
|
{
|
|
|
|
|
unsigned char c1 = *s1++, c2 = *s2++;
|
|
|
|
|
if (c1 != c2)
|
|
|
|
|
return c1 - c2;
|
|
|
|
|
size--;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* __eprintf used to be used by GCC's private version of <assert.h>.
|
|
|
|
|
We no longer provide that header, but this routine remains in libgcc.a
|
|
|
|
|
for binary backward compatibility. Note that it is not included in
|
|
|
|
|
the shared version of libgcc. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#ifdef L_eprintf
|
|
|
|
|
#ifndef inhibit_libc
|
|
|
|
|
|
|
|
|
|
#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
|
|
|
|
|
#include <stdio.h>
|
1999-10-27 09:45:47 +00:00
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
void
|
1999-08-30 00:01:36 +00:00
|
|
|
|
__eprintf (const char *string, const char *expression,
|
|
|
|
|
unsigned int line, const char *filename)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
|
|
|
|
fprintf (stderr, string, expression, line, filename);
|
|
|
|
|
fflush (stderr);
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef L_bb
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#if LONG_TYPE_SIZE == GCOV_TYPE_SIZE
|
|
|
|
|
typedef long gcov_type;
|
|
|
|
|
#else
|
|
|
|
|
typedef long long gcov_type;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
1996-09-18 05:35:50 +00:00
|
|
|
|
/* Structure emitted by -a */
|
|
|
|
|
struct bb
|
|
|
|
|
{
|
|
|
|
|
long zero_word;
|
|
|
|
|
const char *filename;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
gcov_type *counts;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
long ncounts;
|
|
|
|
|
struct bb *next;
|
|
|
|
|
const unsigned long *addresses;
|
|
|
|
|
|
|
|
|
|
/* Older GCC's did not emit these fields. */
|
|
|
|
|
long nwords;
|
|
|
|
|
const char **functions;
|
|
|
|
|
const long *line_nums;
|
|
|
|
|
const char **filenames;
|
1999-08-30 00:01:36 +00:00
|
|
|
|
char *flags;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#ifndef inhibit_libc
|
|
|
|
|
|
|
|
|
|
/* Simple minded basic block profiling output dumper for
|
|
|
|
|
systems that don't provide tcov support. At present,
|
|
|
|
|
it requires atexit and stdio. */
|
|
|
|
|
|
|
|
|
|
#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#include "gbl-ctors.h"
|
|
|
|
|
#include "gcov-io.h"
|
|
|
|
|
#include <string.h>
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef TARGET_HAS_F_SETLKW
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#endif
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
static struct bb *bb_head;
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
__bb_exit_func (void)
|
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
FILE *da_file;
|
1999-08-30 00:01:36 +00:00
|
|
|
|
int i;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
struct bb *ptr;
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
|
|
|
|
if (bb_head == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
i = strlen (bb_head->filename) - 3;
|
|
|
|
|
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
|
|
|
|
|
{
|
|
|
|
|
int firstchar;
|
|
|
|
|
|
|
|
|
|
/* Make sure the output file exists -
|
|
|
|
|
but don't clobber exiting data. */
|
|
|
|
|
if ((da_file = fopen (ptr->filename, "a")) != 0)
|
|
|
|
|
fclose (da_file);
|
|
|
|
|
|
|
|
|
|
/* Need to re-open in order to be able to write from the start. */
|
|
|
|
|
da_file = fopen (ptr->filename, "r+b");
|
|
|
|
|
/* Some old systems might not allow the 'b' mode modifier.
|
|
|
|
|
Therefore, try to open without it. This can lead to a race
|
|
|
|
|
condition so that when you delete and re-create the file, the
|
|
|
|
|
file might be opened in text mode, but then, you shouldn't
|
|
|
|
|
delete the file in the first place. */
|
|
|
|
|
if (da_file == 0)
|
|
|
|
|
da_file = fopen (ptr->filename, "r+");
|
|
|
|
|
if (da_file == 0)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
fprintf (stderr, "arc profiling: Can't open output file %s.\n",
|
|
|
|
|
ptr->filename);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* After a fork, another process might try to read and/or write
|
|
|
|
|
the same file simultanously. So if we can, lock the file to
|
|
|
|
|
avoid race conditions. */
|
|
|
|
|
#if defined (TARGET_HAS_F_SETLKW)
|
|
|
|
|
{
|
|
|
|
|
struct flock s_flock;
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
s_flock.l_type = F_WRLCK;
|
|
|
|
|
s_flock.l_whence = SEEK_SET;
|
|
|
|
|
s_flock.l_start = 0;
|
|
|
|
|
s_flock.l_len = 1;
|
|
|
|
|
s_flock.l_pid = getpid ();
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
|
|
|
|
|
&& errno == EINTR);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* If the file is not empty, and the number of counts in it is the
|
|
|
|
|
same, then merge them in. */
|
|
|
|
|
firstchar = fgetc (da_file);
|
|
|
|
|
if (firstchar == EOF)
|
|
|
|
|
{
|
|
|
|
|
if (ferror (da_file))
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
fprintf (stderr, "arc profiling: Can't read output file ");
|
|
|
|
|
perror (ptr->filename);
|
1999-08-30 00:01:36 +00:00
|
|
|
|
}
|
2002-02-06 04:49:08 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
long n_counts = 0;
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (ungetc (firstchar, da_file) == EOF)
|
|
|
|
|
rewind (da_file);
|
|
|
|
|
if (__read_long (&n_counts, da_file, 8) != 0)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
fprintf (stderr, "arc profiling: Can't read output file %s.\n",
|
1999-08-30 00:01:36 +00:00
|
|
|
|
ptr->filename);
|
2002-02-06 04:49:08 +00:00
|
|
|
|
continue;
|
1999-08-30 00:01:36 +00:00
|
|
|
|
}
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
if (n_counts == ptr->ncounts)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < n_counts; i++)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
gcov_type v = 0;
|
|
|
|
|
|
|
|
|
|
if (__read_gcov_type (&v, da_file, 8) != 0)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
fprintf (stderr,
|
|
|
|
|
"arc profiling: Can't read output file %s.\n",
|
|
|
|
|
ptr->filename);
|
1999-08-30 00:01:36 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2002-02-06 04:49:08 +00:00
|
|
|
|
ptr->counts[i] += v;
|
1999-08-30 00:01:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
rewind (da_file);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* ??? Should first write a header to the file. Preferably, a 4 byte
|
|
|
|
|
magic number, 4 bytes containing the time the program was
|
|
|
|
|
compiled, 4 bytes containing the last modification time of the
|
|
|
|
|
source file, and 4 bytes indicating the compiler options used.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
That way we can easily verify that the proper source/executable/
|
|
|
|
|
data file combination is being used from gcov. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (__write_gcov_type (ptr->ncounts, da_file, 8) != 0)
|
|
|
|
|
{
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
fprintf (stderr, "arc profiling: Error writing output file %s.\n",
|
|
|
|
|
ptr->filename);
|
|
|
|
|
}
|
|
|
|
|
else
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
int j;
|
|
|
|
|
gcov_type *count_ptr = ptr->counts;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
for (j = ptr->ncounts; j > 0; j--)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (__write_gcov_type (*count_ptr, da_file, 8) != 0)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
ret = 1;
|
|
|
|
|
break;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2002-02-06 04:49:08 +00:00
|
|
|
|
count_ptr++;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (ret)
|
|
|
|
|
fprintf (stderr, "arc profiling: Error writing output file %s.\n",
|
|
|
|
|
ptr->filename);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (fclose (da_file) == EOF)
|
|
|
|
|
fprintf (stderr, "arc profiling: Error closing output file %s.\n",
|
|
|
|
|
ptr->filename);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
return;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
__bb_init_func (struct bb *blocks)
|
|
|
|
|
{
|
|
|
|
|
/* User is supposed to check whether the first word is non-0,
|
1999-08-30 00:01:36 +00:00
|
|
|
|
but just in case.... */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
if (blocks->zero_word)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Initialize destructor. */
|
|
|
|
|
if (!bb_head)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
atexit (__bb_exit_func);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
|
|
|
|
/* Set up linked list. */
|
|
|
|
|
blocks->zero_word = 1;
|
|
|
|
|
blocks->next = bb_head;
|
|
|
|
|
bb_head = blocks;
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Called before fork or exec - write out profile information gathered so
|
|
|
|
|
far and reset it to zero. This avoids duplication or loss of the
|
|
|
|
|
profile information gathered so far. */
|
|
|
|
|
void
|
|
|
|
|
__bb_fork_func (void)
|
|
|
|
|
{
|
|
|
|
|
struct bb *ptr;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__bb_exit_func ();
|
|
|
|
|
for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
|
|
|
|
|
{
|
|
|
|
|
long i;
|
|
|
|
|
for (i = ptr->ncounts - 1; i >= 0; i--)
|
|
|
|
|
ptr->counts[i] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#endif /* not inhibit_libc */
|
|
|
|
|
#endif /* L_bb */
|
|
|
|
|
|
|
|
|
|
#ifdef L_clear_cache
|
|
|
|
|
/* Clear part of an instruction cache. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
void
|
|
|
|
|
__clear_cache (char *beg __attribute__((__unused__)),
|
|
|
|
|
char *end __attribute__((__unused__)))
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef CLEAR_INSN_CACHE
|
|
|
|
|
CLEAR_INSN_CACHE (beg, end);
|
|
|
|
|
#else
|
|
|
|
|
#ifdef INSN_CACHE_SIZE
|
|
|
|
|
static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
|
|
|
|
|
static int initialized;
|
|
|
|
|
int offset;
|
|
|
|
|
void *start_addr
|
|
|
|
|
void *end_addr;
|
|
|
|
|
typedef (*function_ptr) (void);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
|
|
|
|
|
/* It's cheaper to clear the whole cache.
|
|
|
|
|
Put in a series of jump instructions so that calling the beginning
|
|
|
|
|
of the cache will clear the whole thing. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (! initialized)
|
|
|
|
|
{
|
|
|
|
|
int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
|
|
|
|
|
& -INSN_CACHE_LINE_WIDTH);
|
|
|
|
|
int end_ptr = ptr + INSN_CACHE_SIZE;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
while (ptr < end_ptr)
|
|
|
|
|
{
|
|
|
|
|
*(INSTRUCTION_TYPE *)ptr
|
|
|
|
|
= JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
|
|
|
|
|
ptr += INSN_CACHE_LINE_WIDTH;
|
|
|
|
|
}
|
|
|
|
|
*(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
initialized = 1;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Call the beginning of the sequence. */
|
|
|
|
|
(((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
|
|
|
|
|
& -INSN_CACHE_LINE_WIDTH))
|
|
|
|
|
());
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#else /* Cache is large. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
if (! initialized)
|
|
|
|
|
{
|
|
|
|
|
int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
|
|
|
|
|
& -INSN_CACHE_LINE_WIDTH);
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
while (ptr < (int) array + sizeof array)
|
|
|
|
|
{
|
|
|
|
|
*(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
|
|
|
|
|
ptr += INSN_CACHE_LINE_WIDTH;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
initialized = 1;
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Find the location in array that occupies the same cache line as BEG. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
|
|
|
|
|
start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
|
|
|
|
|
& -INSN_CACHE_PLANE_SIZE)
|
|
|
|
|
+ offset);
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
|
|
|
|
/* Compute the cache alignment of the place to stop clearing. */
|
|
|
|
|
#if 0 /* This is not needed for gcc's purposes. */
|
|
|
|
|
/* If the block to clear is bigger than a cache plane,
|
2002-02-06 04:49:08 +00:00
|
|
|
|
we clear the entire cache, and OFFSET is already correct. */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
if (end < beg + INSN_CACHE_PLANE_SIZE)
|
|
|
|
|
#endif
|
|
|
|
|
offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
|
|
|
|
|
& -INSN_CACHE_LINE_WIDTH)
|
|
|
|
|
& (INSN_CACHE_PLANE_SIZE - 1));
|
|
|
|
|
|
|
|
|
|
#if INSN_CACHE_DEPTH > 1
|
|
|
|
|
end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
|
|
|
|
|
if (end_addr <= start_addr)
|
|
|
|
|
end_addr += INSN_CACHE_PLANE_SIZE;
|
|
|
|
|
|
|
|
|
|
for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
|
|
|
|
|
{
|
|
|
|
|
int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
|
|
|
|
|
int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
|
|
|
|
|
|
|
|
|
|
while (addr != stop)
|
|
|
|
|
{
|
|
|
|
|
/* Call the return instruction at ADDR. */
|
|
|
|
|
((function_ptr) addr) ();
|
|
|
|
|
|
|
|
|
|
addr += INSN_CACHE_LINE_WIDTH;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#else /* just one plane */
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
/* Call the return instruction at START_ADDR. */
|
|
|
|
|
((function_ptr) start_addr) ();
|
|
|
|
|
|
|
|
|
|
start_addr += INSN_CACHE_LINE_WIDTH;
|
|
|
|
|
}
|
|
|
|
|
while ((start_addr % INSN_CACHE_SIZE) != offset);
|
|
|
|
|
#endif /* just one plane */
|
|
|
|
|
#endif /* Cache is large */
|
|
|
|
|
#endif /* Cache exists */
|
|
|
|
|
#endif /* CLEAR_INSN_CACHE */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* L_clear_cache */
|
|
|
|
|
|
|
|
|
|
#ifdef L_trampoline
|
|
|
|
|
|
|
|
|
|
/* Jump to a trampoline, loading the static chain address. */
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
long
|
|
|
|
|
getpagesize (void)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#ifdef _ALPHA_
|
|
|
|
|
return 8192;
|
|
|
|
|
#else
|
1999-08-30 00:01:36 +00:00
|
|
|
|
return 4096;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef __i386__
|
1999-08-30 00:01:36 +00:00
|
|
|
|
extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
mprotect (char *addr, int len, int prot)
|
|
|
|
|
{
|
|
|
|
|
int np, op;
|
|
|
|
|
|
|
|
|
|
if (prot == 7)
|
|
|
|
|
np = 0x40;
|
|
|
|
|
else if (prot == 5)
|
|
|
|
|
np = 0x20;
|
|
|
|
|
else if (prot == 4)
|
|
|
|
|
np = 0x10;
|
|
|
|
|
else if (prot == 3)
|
|
|
|
|
np = 0x04;
|
|
|
|
|
else if (prot == 1)
|
|
|
|
|
np = 0x02;
|
|
|
|
|
else if (prot == 0)
|
|
|
|
|
np = 0x01;
|
|
|
|
|
|
|
|
|
|
if (VirtualProtect (addr, len, np, &op))
|
|
|
|
|
return 0;
|
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef TRANSFER_FROM_TRAMPOLINE
|
|
|
|
|
TRANSFER_FROM_TRAMPOLINE
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if defined (NeXT) && defined (__MACH__)
|
|
|
|
|
|
|
|
|
|
/* Make stack executable so we can call trampolines on stack.
|
|
|
|
|
This is called from INITIALIZE_TRAMPOLINE in next.h. */
|
|
|
|
|
#ifdef NeXTStep21
|
|
|
|
|
#include <mach.h>
|
|
|
|
|
#else
|
|
|
|
|
#include <mach/mach.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
__enable_execute_stack (char *addr)
|
|
|
|
|
{
|
|
|
|
|
kern_return_t r;
|
|
|
|
|
char *eaddr = addr + TRAMPOLINE_SIZE;
|
|
|
|
|
vm_address_t a = (vm_address_t) addr;
|
|
|
|
|
|
|
|
|
|
/* turn on execute access on stack */
|
|
|
|
|
r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
|
|
|
|
|
if (r != KERN_SUCCESS)
|
|
|
|
|
{
|
|
|
|
|
mach_error("vm_protect VM_PROT_ALL", r);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We inline the i-cache invalidation for speed */
|
|
|
|
|
|
|
|
|
|
#ifdef CLEAR_INSN_CACHE
|
|
|
|
|
CLEAR_INSN_CACHE (addr, eaddr);
|
|
|
|
|
#else
|
|
|
|
|
__clear_cache ((int) addr, (int) eaddr);
|
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
}
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
|
|
|
|
#endif /* defined (NeXT) && defined (__MACH__) */
|
|
|
|
|
|
|
|
|
|
#ifdef __convex__
|
|
|
|
|
|
|
|
|
|
/* Make stack executable so we can call trampolines on stack.
|
|
|
|
|
This is called from INITIALIZE_TRAMPOLINE in convex.h. */
|
|
|
|
|
|
|
|
|
|
#include <sys/mman.h>
|
|
|
|
|
#include <sys/vmparam.h>
|
|
|
|
|
#include <machine/machparam.h>
|
|
|
|
|
|
|
|
|
|
void
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__enable_execute_stack (void)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
|
|
|
|
int fp;
|
|
|
|
|
static unsigned lowest = USRSTACK;
|
|
|
|
|
unsigned current = (unsigned) &fp & -NBPG;
|
|
|
|
|
|
|
|
|
|
if (lowest > current)
|
|
|
|
|
{
|
|
|
|
|
unsigned len = lowest - current;
|
|
|
|
|
mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
|
|
|
|
|
lowest = current;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Clear instruction cache in case an old trampoline is in it. */
|
|
|
|
|
asm ("pich");
|
|
|
|
|
}
|
|
|
|
|
#endif /* __convex__ */
|
|
|
|
|
|
|
|
|
|
#ifdef __sysV88__
|
|
|
|
|
|
|
|
|
|
/* Modified from the convex -code above. */
|
|
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#include <sys/m88kbcs.h>
|
|
|
|
|
|
|
|
|
|
void
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__enable_execute_stack (void)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
|
|
|
|
int save_errno;
|
|
|
|
|
static unsigned long lowest = USRSTACK;
|
|
|
|
|
unsigned long current = (unsigned long) &save_errno & -NBPC;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
/* Ignore errno being set. memctl sets errno to EINVAL whenever the
|
2002-02-06 04:49:08 +00:00
|
|
|
|
address is seen as 'negative'. That is the case with the stack. */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
|
|
|
|
save_errno=errno;
|
|
|
|
|
if (lowest > current)
|
|
|
|
|
{
|
|
|
|
|
unsigned len=lowest-current;
|
|
|
|
|
memctl(current,len,MCT_TEXT);
|
|
|
|
|
lowest = current;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
memctl(current,NBPC,MCT_TEXT);
|
|
|
|
|
errno=save_errno;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* __sysV88__ */
|
|
|
|
|
|
|
|
|
|
#ifdef __sysV68__
|
|
|
|
|
|
|
|
|
|
#include <sys/signal.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
|
|
/* Motorola forgot to put memctl.o in the libp version of libc881.a,
|
|
|
|
|
so define it here, because we need it in __clear_insn_cache below */
|
|
|
|
|
/* On older versions of this OS, no memctl or MCT_TEXT are defined;
|
|
|
|
|
hence we enable this stuff only if MCT_TEXT is #define'd. */
|
|
|
|
|
|
|
|
|
|
#ifdef MCT_TEXT
|
|
|
|
|
asm("\n\
|
|
|
|
|
global memctl\n\
|
|
|
|
|
memctl:\n\
|
|
|
|
|
movq &75,%d0\n\
|
|
|
|
|
trap &0\n\
|
|
|
|
|
bcc.b noerror\n\
|
|
|
|
|
jmp cerror%\n\
|
|
|
|
|
noerror:\n\
|
|
|
|
|
movq &0,%d0\n\
|
|
|
|
|
rts");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Clear instruction cache so we can call trampolines on stack.
|
|
|
|
|
This is called from FINALIZE_TRAMPOLINE in mot3300.h. */
|
|
|
|
|
|
|
|
|
|
void
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__clear_insn_cache (void)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
|
|
|
|
#ifdef MCT_TEXT
|
|
|
|
|
int save_errno;
|
|
|
|
|
|
|
|
|
|
/* Preserve errno, because users would be surprised to have
|
2002-02-06 04:49:08 +00:00
|
|
|
|
errno changing without explicitly calling any system-call. */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
save_errno = errno;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
|
|
|
|
|
No need to use an address derived from _start or %sp, as 0 works also. */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
memctl(0, 4096, MCT_TEXT);
|
|
|
|
|
errno = save_errno;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* __sysV68__ */
|
|
|
|
|
|
|
|
|
|
#ifdef __pyr__
|
|
|
|
|
|
|
|
|
|
#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <sys/mman.h>
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/vmmac.h>
|
|
|
|
|
|
|
|
|
|
/* Modified from the convex -code above.
|
|
|
|
|
mremap promises to clear the i-cache. */
|
|
|
|
|
|
|
|
|
|
void
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__enable_execute_stack (void)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
|
|
|
|
int fp;
|
|
|
|
|
if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
|
|
|
|
|
PROT_READ|PROT_WRITE|PROT_EXEC))
|
|
|
|
|
{
|
|
|
|
|
perror ("mprotect in __enable_execute_stack");
|
|
|
|
|
fflush (stderr);
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif /* __pyr__ */
|
|
|
|
|
|
|
|
|
|
#if defined (sony_news) && defined (SYSTYPE_BSD)
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <syscall.h>
|
|
|
|
|
#include <machine/sysnews.h>
|
|
|
|
|
|
|
|
|
|
/* cacheflush function for NEWS-OS 4.2.
|
|
|
|
|
This function is called from trampoline-initialize code
|
|
|
|
|
defined in config/mips/mips.h. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
cacheflush (char *beg, int size, int flag)
|
|
|
|
|
{
|
|
|
|
|
if (syscall (SYS_sysnews, NEWS_CACHEFLUSH, beg, size, FLUSH_BCACHE))
|
|
|
|
|
{
|
|
|
|
|
perror ("cache_flush");
|
|
|
|
|
fflush (stderr);
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* sony_news */
|
|
|
|
|
#endif /* L_trampoline */
|
|
|
|
|
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#ifndef __CYGWIN__
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#ifdef L__main
|
|
|
|
|
|
|
|
|
|
#include "gbl-ctors.h"
|
|
|
|
|
/* Some systems use __main in a way incompatible with its use in gcc, in these
|
|
|
|
|
cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
|
|
|
|
|
give the same symbol without quotes for an alternative entry point. You
|
|
|
|
|
must define both, or neither. */
|
|
|
|
|
#ifndef NAME__MAIN
|
|
|
|
|
#define NAME__MAIN "__main"
|
|
|
|
|
#define SYMBOL__MAIN __main
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef INIT_SECTION_ASM_OP
|
|
|
|
|
#undef HAS_INIT_SECTION
|
|
|
|
|
#define HAS_INIT_SECTION
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
|
|
|
|
|
/* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
|
|
|
|
|
code to run constructors. In that case, we need to handle EH here, too. */
|
|
|
|
|
|
|
|
|
|
#ifdef EH_FRAME_SECTION_NAME
|
|
|
|
|
#include "unwind-dw2-fde.h"
|
|
|
|
|
extern unsigned char __EH_FRAME_BEGIN__[];
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
/* Run all the global destructors on exit from the program. */
|
|
|
|
|
|
|
|
|
|
void
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__do_global_dtors (void)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
|
|
|
|
#ifdef DO_GLOBAL_DTORS_BODY
|
|
|
|
|
DO_GLOBAL_DTORS_BODY;
|
|
|
|
|
#else
|
|
|
|
|
static func_ptr *p = __DTOR_LIST__ + 1;
|
|
|
|
|
while (*p)
|
|
|
|
|
{
|
|
|
|
|
p++;
|
|
|
|
|
(*(p-1)) ();
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
|
|
|
|
|
{
|
|
|
|
|
static int completed = 0;
|
|
|
|
|
if (! completed)
|
|
|
|
|
{
|
|
|
|
|
completed = 1;
|
|
|
|
|
__deregister_frame_info (__EH_FRAME_BEGIN__);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef HAS_INIT_SECTION
|
|
|
|
|
/* Run all the global constructors on entry to the program. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
void
|
2002-02-06 04:49:08 +00:00
|
|
|
|
__do_global_ctors (void)
|
1996-09-18 05:35:50 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#ifdef EH_FRAME_SECTION_NAME
|
|
|
|
|
{
|
|
|
|
|
static struct object object;
|
|
|
|
|
__register_frame_info (__EH_FRAME_BEGIN__, &object);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
1999-08-30 00:01:36 +00:00
|
|
|
|
DO_GLOBAL_CTORS_BODY;
|
2002-02-06 04:49:08 +00:00
|
|
|
|
atexit (__do_global_dtors);
|
1999-08-30 00:01:36 +00:00
|
|
|
|
}
|
|
|
|
|
#endif /* no HAS_INIT_SECTION */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
|
|
|
|
|
/* Subroutine called automatically by `main'.
|
|
|
|
|
Compiling a global function named `main'
|
|
|
|
|
produces an automatic call to this function at the beginning.
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
For many systems, this routine calls __do_global_ctors.
|
|
|
|
|
For systems which support a .init section we use the .init section
|
|
|
|
|
to run __do_global_ctors, so we need not do anything here. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
SYMBOL__MAIN ()
|
|
|
|
|
{
|
|
|
|
|
/* Support recursive calls to `main': run initializers just once. */
|
|
|
|
|
static int initialized;
|
|
|
|
|
if (! initialized)
|
|
|
|
|
{
|
|
|
|
|
initialized = 1;
|
|
|
|
|
__do_global_ctors ();
|
|
|
|
|
}
|
1996-09-18 05:35:50 +00:00
|
|
|
|
}
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#endif /* no HAS_INIT_SECTION or INVOKE__main */
|
|
|
|
|
|
|
|
|
|
#endif /* L__main */
|
1999-10-27 09:45:47 +00:00
|
|
|
|
#endif /* __CYGWIN__ */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
|
|
|
|
#ifdef L_ctors
|
|
|
|
|
|
|
|
|
|
#include "gbl-ctors.h"
|
|
|
|
|
|
|
|
|
|
/* Provide default definitions for the lists of constructors and
|
|
|
|
|
destructors, so that we don't get linker errors. These symbols are
|
|
|
|
|
intentionally bss symbols, so that gld and/or collect will provide
|
|
|
|
|
the right values. */
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
/* We declare the lists here with two elements each,
|
1999-10-27 09:45:47 +00:00
|
|
|
|
so that they are valid empty lists if no other definition is loaded.
|
|
|
|
|
|
|
|
|
|
If we are using the old "set" extensions to have the gnu linker
|
|
|
|
|
collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
|
|
|
|
|
must be in the bss/common section.
|
|
|
|
|
|
|
|
|
|
Long term no port should use those extensions. But many still do. */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
func_ptr __CTOR_LIST__[2] = {0, 0};
|
|
|
|
|
func_ptr __DTOR_LIST__[2] = {0, 0};
|
|
|
|
|
#else
|
|
|
|
|
func_ptr __CTOR_LIST__[2];
|
|
|
|
|
func_ptr __DTOR_LIST__[2];
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#endif
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
|
|
|
|
|
#endif /* L_ctors */
|
|
|
|
|
|
|
|
|
|
#ifdef L_exit
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#include "gbl-ctors.h"
|
|
|
|
|
|
|
|
|
|
#ifdef NEED_ATEXIT
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
#ifndef ON_EXIT
|
1996-09-18 05:35:50 +00:00
|
|
|
|
|
1999-08-30 00:01:36 +00:00
|
|
|
|
# include <errno.h>
|
|
|
|
|
|
|
|
|
|
static func_ptr *atexit_chain = 0;
|
|
|
|
|
static long atexit_chain_length = 0;
|
|
|
|
|
static volatile long last_atexit_chain_slot = -1;
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
int
|
|
|
|
|
atexit (func_ptr func)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
|
|
|
|
if (++last_atexit_chain_slot == atexit_chain_length)
|
|
|
|
|
{
|
|
|
|
|
atexit_chain_length += 32;
|
|
|
|
|
if (atexit_chain)
|
|
|
|
|
atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
|
|
|
|
|
* sizeof (func_ptr));
|
|
|
|
|
else
|
|
|
|
|
atexit_chain = (func_ptr *) malloc (atexit_chain_length
|
|
|
|
|
* sizeof (func_ptr));
|
|
|
|
|
if (! atexit_chain)
|
|
|
|
|
{
|
|
|
|
|
atexit_chain_length = 0;
|
|
|
|
|
last_atexit_chain_slot = -1;
|
|
|
|
|
errno = ENOMEM;
|
|
|
|
|
return (-1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
atexit_chain[last_atexit_chain_slot] = func;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
extern void _cleanup (void);
|
|
|
|
|
extern void _exit (int) __attribute__ ((__noreturn__));
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
void
|
1999-08-30 00:01:36 +00:00
|
|
|
|
exit (int status)
|
|
|
|
|
{
|
|
|
|
|
if (atexit_chain)
|
|
|
|
|
{
|
|
|
|
|
for ( ; last_atexit_chain_slot-- >= 0; )
|
|
|
|
|
{
|
|
|
|
|
(*atexit_chain[last_atexit_chain_slot + 1]) ();
|
|
|
|
|
atexit_chain[last_atexit_chain_slot + 1] = 0;
|
|
|
|
|
}
|
|
|
|
|
free (atexit_chain);
|
|
|
|
|
atexit_chain = 0;
|
|
|
|
|
}
|
|
|
|
|
#ifdef EXIT_BODY
|
|
|
|
|
EXIT_BODY;
|
1996-09-18 05:35:50 +00:00
|
|
|
|
#else
|
1999-08-30 00:01:36 +00:00
|
|
|
|
_cleanup ();
|
|
|
|
|
#endif
|
|
|
|
|
_exit (status);
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#else /* ON_EXIT */
|
1999-08-30 00:01:36 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
/* Simple; we just need a wrapper for ON_EXIT. */
|
|
|
|
|
int
|
|
|
|
|
atexit (func_ptr func)
|
1999-08-30 00:01:36 +00:00
|
|
|
|
{
|
2002-02-06 04:49:08 +00:00
|
|
|
|
return ON_EXIT (func);
|
1999-08-30 00:01:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#endif /* ON_EXIT */
|
|
|
|
|
#endif /* NEED_ATEXIT */
|
1999-10-27 09:45:47 +00:00
|
|
|
|
|
2002-02-06 04:49:08 +00:00
|
|
|
|
#endif /* L_exit */
|