Import NetBSD/hpcmips source files from hpcmips repository.
file list:
sys/arch/hpcmips/
distrib/hpcmips/
etc/etc.hpcmips/
lib/libc/arch/mips/fplib/
lib/libc/arch/mips/fplib/Makefile.inc
lib/libc/arch/mips/fplib/environment.h
lib/libc/arch/mips/fplib/fplib_glue.c
lib/libc/arch/mips/fplib/fplib_libc.c
lib/libc/arch/mips/fplib/hpcmips-gcc.h
lib/libc/arch/mips/fplib/softfloat-macros.h
lib/libc/arch/mips/fplib/softfloat-specialize.h
lib/libc/arch/mips/fplib/softfloat.c
lib/libc/arch/mips/fplib/softfloat.h
lib/libc/arch/mips/gen/ieee.h
lib/libc/arch/mips/gen/sf_fabs.c
lib/libc/arch/mips/gen/sf_flt_rounds.c
lib/libc/arch/mips/gen/sf_fpgetmask.c
lib/libc/arch/mips/gen/sf_fpgetround.c
lib/libc/arch/mips/gen/sf_fpgetsticky.c
lib/libc/arch/mips/gen/sf_fpsetmask.c
lib/libc/arch/mips/gen/sf_fpsetround.c
lib/libc/arch/mips/gen/sf_fpsetsticky.c
lib/libc/arch/mips/gen/sf_isinf.c
lib/libc/arch/mips/gen/sf_ldexp.c
lib/libc/arch/mips/gen/sf_modf.c
This commit is contained in:
takemura
parent
f7fd8ced64
commit
2f85eb6142
5
distrib/hpcmips/Makefile
Normal file
5
distrib/hpcmips/Makefile
Normal file
@ -0,0 +1,5 @@
|
||||
# $NetBSD: Makefile,v 1.1.1.1 1999/09/16 12:13:17 takemura Exp $
|
||||
|
||||
SUBDIR=
|
||||
|
||||
.include <bsd.subdir.mk>
|
||||
4
distrib/hpcmips/Makefile.inc
Normal file
4
distrib/hpcmips/Makefile.inc
Normal file
@ -0,0 +1,4 @@
|
||||
# $NetBSD: Makefile.inc,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $
|
||||
|
||||
REV!=sh ${.CURDIR}/../../../sys/conf/osrelease.sh -s
|
||||
VER!=sh ${.CURDIR}/../../../sys/conf/osrelease.sh
|
||||
20
distrib/hpcmips/miniroot/dot.profile
Normal file
20
distrib/hpcmips/miniroot/dot.profile
Normal file
@ -0,0 +1,20 @@
|
||||
# $NetBSD: dot.profile,v 1.1.1.1 1999/09/16 12:18:27 takemura Exp $
|
||||
PATH=/sbin:/bin:/usr/bin:/usr/sbin:/
|
||||
export PATH
|
||||
|
||||
# get the terminal type
|
||||
_loop=""
|
||||
while [ "X${_loop}" = X"" ]; do
|
||||
echo "" >& 2
|
||||
echo "Setting terminal type. Options:" >& 2
|
||||
echo " rcons for graphics console" >& 2
|
||||
echo " vt100 for dumb serial terminal" >& 2
|
||||
echo " xterm for xterm." >& 2
|
||||
echo "" >& 2
|
||||
eval `tset -s -m ":?$TERM"`
|
||||
if [ "X${TERM}" != X"unknown" ]; then
|
||||
_loop="done"
|
||||
fi
|
||||
done
|
||||
|
||||
sysinst
|
||||
94
distrib/hpcmips/miniroot/list
Normal file
94
distrib/hpcmips/miniroot/list
Normal file
@ -0,0 +1,94 @@
|
||||
# $NetBSD: list,v 1.1.1.1 1999/09/16 12:18:27 takemura Exp $
|
||||
|
||||
# hpcmips extra's: mountpoint for kernfs
|
||||
SPECIAL mkdir kern
|
||||
|
||||
# extras in bin
|
||||
LINK instbin bin/csh
|
||||
LINK instbin bin/date
|
||||
LINK instbin bin/rcp
|
||||
LINK instbin bin/rcmd
|
||||
|
||||
# extras in sbin
|
||||
LINK instbin sbin/disklabel
|
||||
LINK instbin sbin/mount_ext2fs
|
||||
LINK instbin sbin/fsck_ext2fs
|
||||
LINK instbin sbin/mount_kernfs
|
||||
|
||||
# extras in /usr.bin
|
||||
SYMLINK ../../instbin usr/bin/netstat
|
||||
SYMLINK ../../instbin usr/bin/rsh
|
||||
SYMLINK ../../instbin usr/bin/tset usr/bin/reset
|
||||
SYMLINK ../../instbin usr/bin/vi
|
||||
|
||||
# OK, now do everything in /usr all over all again in usr.install,
|
||||
# in case we try and install directly into the miniroot (mounting over /usr).
|
||||
|
||||
# local usr.bin
|
||||
SPECIAL mkdir usr.install
|
||||
SPECIAL mkdir usr.install/bin
|
||||
SPECIAL mkdir usr.install/sbin
|
||||
|
||||
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/chflags
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/chgrp
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/ftp
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/gunzip
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/gzcat
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/gzip
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/netstat
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/sort
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/tar
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/tip
|
||||
SPECIAL ln -s ../../instbin usr.install/bin/vi
|
||||
|
||||
# local usr.sbin
|
||||
SPECIAL ln -s ../../instbin usr.install/sbin/chroot
|
||||
SPECIAL ln -s ../../instbin usr.install/sbin/chown
|
||||
SPECIAL ln -s ../../instbin usr.install/sbin/update
|
||||
|
||||
|
||||
# crunchgen source directory specials: progs built in nonstandard places
|
||||
CRUNCHSPECIAL vi srcdir usr.bin/vi/build
|
||||
|
||||
|
||||
|
||||
# Minimize use of MFS
|
||||
SYMLINK /tmp var/tmp
|
||||
|
||||
# copy the MAKEDEV script and make some devices
|
||||
COPY ${DESTDIR}/dev/MAKEDEV dev/MAKEDEV
|
||||
COPY ${DESTDIR}/dev/MAKEDEV.local dev/MAKEDEV.local
|
||||
SPECIAL cd dev; sh MAKEDEV all
|
||||
SPECIAL /bin/rm dev/MAKEDEV dev/MAKEDEV.local
|
||||
|
||||
# we need the contents of /usr/mdec
|
||||
COPYDIR ${DESTDIR}/usr/mdec /usr/mdec
|
||||
|
||||
|
||||
# the zoneinfo (dont use)
|
||||
#COPYDIR ${DESTDIR}/usr/share/zoneinfo usr/share/zoneinfo
|
||||
|
||||
# a subset termcap file
|
||||
COPY ${ARCHDIR}/termcap.rcons usr/share/misc/termcap
|
||||
|
||||
# copy the kernel(s)
|
||||
COPY ${CURDIR}/../../sys/arch/hpcmips/compile/GENERIC/netbsd netbsd
|
||||
|
||||
|
||||
# various files that we need in /etc for the install
|
||||
#COPY ${DESTDIR}/etc/disktab etc/disktab.shadow
|
||||
#SYMLINK /tmp/disktab.shadow etc/disktab
|
||||
#SYMLINK /tmp/fstab.shadow etc/fstab
|
||||
#SYMLINK /tmp/resolv.conf.shadow etc/resolv.conf
|
||||
#SYMLINK /tmp/hosts etc/hosts
|
||||
|
||||
# sysinst needs disktab template
|
||||
COPY ${DESTDIR}/etc/disktab etc/disktab.preinstall
|
||||
|
||||
# and the installation tools
|
||||
COPY ${ARCHDIR}/dot.profile .profile
|
||||
#LINK instbin sbin/sysinst
|
||||
|
||||
# and a spare .profile
|
||||
COPY ${DESTDIR}/.profile tmp/.hdprofile
|
||||
450
etc/etc.hpcmips/MAKEDEV
Normal file
450
etc/etc.hpcmips/MAKEDEV
Normal file
@ -0,0 +1,450 @@
|
||||
#!/bin/sh -
|
||||
#
|
||||
# $NetBSD: MAKEDEV,v 1.1.1.1 1999/09/16 12:18:27 takemura Exp $
|
||||
#
|
||||
# Copyright (c) 1990 The Regents of the University of California.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms are permitted provided
|
||||
# that: (1) source distributions retain this entire copyright notice and
|
||||
# comment, and (2) distributions including binaries display the following
|
||||
# acknowledgement: ``This product includes software developed by the
|
||||
# University of California, Berkeley and its contributors'' in the
|
||||
# documentation or other materials provided with the distribution and in
|
||||
# all advertising materials mentioning features or use of this software.
|
||||
# Neither the name of the University nor the names of its contributors may
|
||||
# be used to endorse or promote products derived from this software without
|
||||
# specific prior written permission.
|
||||
# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
#
|
||||
# @(#)MAKEDEV 5.2 (Berkeley) 6/22/90
|
||||
#
|
||||
# Device "make" file. Valid arguments:
|
||||
# all makes all known devices, including local devices.
|
||||
# Tries to make the 'standard' number of each type.
|
||||
# floppy devices to be put on install floppies
|
||||
# std standard devices
|
||||
# local configuration specific devices
|
||||
# usbs make USB devices
|
||||
#
|
||||
# Tapes:
|
||||
# st* SCSI tapes
|
||||
#
|
||||
# Disks:
|
||||
# wd* "winchester" disk drives (ST506,IDE,ESDI,RLL,...)
|
||||
# fd* "floppy" disk drives (3 1/2", 5 1/4")
|
||||
# sd* SCSI disks
|
||||
# cd* SCSI CD-ROM
|
||||
# vnd* "file" pseudo-disks
|
||||
# md* memory pseudo-disks
|
||||
# ccd* contatenated disk devices
|
||||
# raid* RAIDframe disk devices
|
||||
#
|
||||
# Console ports:
|
||||
# ttyE* wscons
|
||||
#
|
||||
# Pointing devices:
|
||||
# wsmouse* wscons mouse events
|
||||
#
|
||||
# Keyboard devices:
|
||||
# wskbd* wscons keyboard events
|
||||
#
|
||||
# Terminal ports:
|
||||
# com* standard PC COM ports (XXX)
|
||||
# tty* alias for PC COM ports, this is what the system really wants
|
||||
#
|
||||
# Pseudo terminals:
|
||||
# pty* set of 16 master and slave pseudo terminals
|
||||
#
|
||||
# Printers:
|
||||
# lpt* stock lp
|
||||
# lpa* interruptless lp
|
||||
#
|
||||
# USB devices:
|
||||
# usb* Bus control devices used by usbd for attach/detach
|
||||
# uhid* Generic HID devices
|
||||
# ulpt* Printer devices
|
||||
# ugen* Generic device
|
||||
#
|
||||
# Call units:
|
||||
#
|
||||
# Special purpose devices:
|
||||
# fd file descriptors
|
||||
# bpf* packet filter
|
||||
# ipl ip filter
|
||||
# random Random number generator
|
||||
# tun* network tunnel driver
|
||||
# scsibus* SCSI busses
|
||||
# ss* SCSI scanner
|
||||
# uk* SCSI unknown
|
||||
# ch* SCSI changer
|
||||
#
|
||||
|
||||
dialin=0
|
||||
dialout=524288 # high bit of the minor number
|
||||
|
||||
PATH=/sbin:/usr/sbin:/bin:/usr/bin
|
||||
umask 77
|
||||
|
||||
for i
|
||||
do
|
||||
|
||||
case $i in
|
||||
|
||||
all)
|
||||
sh $0 std fd fd0 fd1 wd0 wd1 wd2 wd3 sd0 sd1 sd2 sd3 sd4
|
||||
sh $0 tty0 tty1 tty2 pty0 pty1 raid0 raid1 raid2 raid3
|
||||
sh $0 st0 st1 ch0 cd0 cd1 vnd0 vnd1
|
||||
sh $0 bpf0 bpf1 bpf2 bpf3 bpf4 bpf5 bpf6 bpf7
|
||||
sh $0 lpt0 lpt1 lpt2 tun0 tun1 ipl
|
||||
sh $0 ccd0 ccd1 ccd2 ccd3 md0 ss0 ch0 uk0 uk1 random
|
||||
sh $0 usbs
|
||||
sh $0 scsibus0 scsibus1 scsibus2 scsibus3
|
||||
sh $0 wscons
|
||||
# sh $0 local
|
||||
;;
|
||||
|
||||
floppy)
|
||||
sh $0 std fd0 fd1 wd0 wd1 sd0 sd1 sd2 tty0 tty1 tty2
|
||||
sh $0 st0 st1 cd0 cd1
|
||||
;;
|
||||
|
||||
ramdisk)
|
||||
sh $0 floppy md0
|
||||
;;
|
||||
|
||||
usbs)
|
||||
sh $0 usb0 usb1
|
||||
sh $0 uhid0 uhid1 uhid2 uhid3
|
||||
sh $0 ulpt0 ulpt1
|
||||
;;
|
||||
|
||||
std)
|
||||
rm -f console drum mem kmem null zero io tty klog stdin stdout stderr
|
||||
mknod console c 2 0
|
||||
mknod drum c 1 0 ; chmod 640 drum ; chgrp kmem drum
|
||||
mknod kmem c 0 1 ; chmod 640 kmem ; chgrp kmem kmem
|
||||
mknod mem c 0 0 ; chmod 640 mem ; chgrp kmem mem
|
||||
mknod null c 0 2 ; chmod 666 null
|
||||
mknod zero c 0 12 ; chmod 666 zero
|
||||
mknod io c 0 14 ; chmod 640 io ; chgrp kmem io
|
||||
mknod tty c 3 0 ; chmod 666 tty
|
||||
mknod klog c 5 0 ; chmod 600 klog
|
||||
mknod stdin c 4 0 ; chmod 666 stdin
|
||||
mknod stdout c 4 1 ; chmod 666 stdout
|
||||
mknod stderr c 4 2 ; chmod 666 stderr
|
||||
;;
|
||||
|
||||
usb*)
|
||||
unit=${i#usb}
|
||||
usb=usb$unit
|
||||
major=23
|
||||
rm -f $usb
|
||||
mknod $usb c $major $unit
|
||||
chown root.wheel $usb
|
||||
chmod 600 $usb
|
||||
;;
|
||||
|
||||
uhid*)
|
||||
unit=${i#uhid}
|
||||
uhid=uhid$unit
|
||||
major=24
|
||||
rm -f $uhid
|
||||
mknod $uhid c $major $unit
|
||||
chown root.wheel $uhid
|
||||
chmod 666 $uhid
|
||||
;;
|
||||
|
||||
ulpt*)
|
||||
unit=${i#ulpt}
|
||||
ulpt=ulpt$unit
|
||||
major=25
|
||||
rm -f $ulpt
|
||||
mknod $ulpt c $major $unit
|
||||
chown root.wheel $ulpt
|
||||
chmod 600 $ulpt
|
||||
;;
|
||||
|
||||
ugen*)
|
||||
unit=${i#ugen}
|
||||
ugen=ugen$unit
|
||||
major=26
|
||||
for j in 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
|
||||
do
|
||||
ugenj=$ugen.$j
|
||||
rm -f $ugenj
|
||||
mknod $ugenj c $major $(($unit * 16 + $j))
|
||||
chown root.wheel $ugenj
|
||||
chmod 600 $ugenj
|
||||
done
|
||||
;;
|
||||
|
||||
wscons)
|
||||
sh $0 ttyE0 ttyE1 ttyE2 ttyE3 ttyE4 ttyE5 ttyE6 ttyE7
|
||||
sh $0 wsmouse0 wsmouse1 wsmouse2 wsmouse3
|
||||
sh $0 wskbd0 wskbd1 wskbd2 wskbd3
|
||||
sh $0 ttyEcfg
|
||||
;;
|
||||
|
||||
ttyEcfg)
|
||||
chr=30
|
||||
rm -f ttyEcfg
|
||||
mknod ttyEcfg c $chr 255
|
||||
chown root.wheel ttyEcfg
|
||||
chmod 600 ttyEcfg
|
||||
;;
|
||||
|
||||
ttyE*)
|
||||
chr=30; unit=${i#ttyE}
|
||||
rm -f ttyE$unit
|
||||
mknod ttyE$unit c $chr $unit
|
||||
chown root.wheel ttyE$unit
|
||||
;;
|
||||
|
||||
wsmouse*)
|
||||
unit=${i#wsmouse}
|
||||
wsmouse=wsmouse$unit
|
||||
major=32
|
||||
rm -f $wsmouse
|
||||
mknod $wsmouse c $major $unit
|
||||
chown root.wheel $wsmouse
|
||||
chmod 600 $wsmouse
|
||||
;;
|
||||
|
||||
wskbd*)
|
||||
unit=${i#wskbd}
|
||||
wskbd=wskbd$unit
|
||||
major=31
|
||||
rm -f $wskbd
|
||||
mknod $wskbd c $major $unit
|
||||
chown root.wheel $wskbd
|
||||
chmod 600 $wskbd
|
||||
;;
|
||||
|
||||
fd)
|
||||
rm -f fd/*
|
||||
mkdir fd > /dev/null 2>&1
|
||||
n=0
|
||||
while [ $n -lt 64 ]; do
|
||||
mknod fd/$n c 22 $n
|
||||
n=$(($n + 1))
|
||||
done
|
||||
chown -R root.wheel fd
|
||||
chmod 755 fd
|
||||
chmod 666 fd/*
|
||||
;;
|
||||
|
||||
md*)
|
||||
case $i in
|
||||
md*) name=md; unit=${i#md}; chr=12; blk=6;;
|
||||
esac
|
||||
rm -f $name$unit? r$name$unit?
|
||||
mknod ${name}${unit}a b $blk $(($unit * 8 + 0))
|
||||
mknod ${name}${unit}b b $blk $(($unit * 8 + 1))
|
||||
mknod ${name}${unit}c b $blk $(($unit * 8 + 2))
|
||||
mknod r${name}${unit}a c $chr $(($unit * 8 + 0))
|
||||
mknod r${name}${unit}b c $chr $(($unit * 8 + 1))
|
||||
mknod r${name}${unit}c c $chr $(($unit * 8 + 2))
|
||||
chgrp operator $name$unit? r$name$unit?
|
||||
chmod 640 $name$unit? r$name$unit?
|
||||
;;
|
||||
|
||||
ss*)
|
||||
case $i in
|
||||
ss*) name=ss; unit=${i#ss}; chr=22;;
|
||||
esac
|
||||
rm -f $name$unit n$name$unit en$name$unit
|
||||
mknod $name$unit c $chr $(($unit * 16 + 0))
|
||||
mknod n$name$unit c $chr $(($unit * 16 + 1))
|
||||
mknod en$name$unit c $chr $(($unit * 16 + 3))
|
||||
chgrp operator $name$unit n$name$unit en$name$unit
|
||||
chmod 640 $name$unit n$name$unit en$name$unit
|
||||
;;
|
||||
|
||||
ccd*|fd*|sd*|vnd*|wd*|raid*)
|
||||
case $i in
|
||||
ccd*) name=ccd; unit=${i#ccd}; blk=7; chr=13;;
|
||||
fd*) name=fd; unit=${i#fd}; blk=2; chr=11;;
|
||||
raid*) name=raid; unit=${i#raid}; blk=9; chr=15;;
|
||||
sd*) name=sd; unit=${i#sd}; blk=3; chr=17;;
|
||||
vnd*) name=vnd; unit=${i#vnd}; blk=8; chr=14;;
|
||||
wd*) name=wd; unit=${i#wd}; blk=1; chr=10;;
|
||||
esac
|
||||
rm -f $name$unit? r$name$unit?
|
||||
mknod ${name}${unit}a b $blk $(($unit * 8 + 0))
|
||||
mknod ${name}${unit}b b $blk $(($unit * 8 + 1))
|
||||
mknod ${name}${unit}c b $blk $(($unit * 8 + 2))
|
||||
mknod ${name}${unit}d b $blk $(($unit * 8 + 3))
|
||||
mknod ${name}${unit}e b $blk $(($unit * 8 + 4))
|
||||
mknod ${name}${unit}f b $blk $(($unit * 8 + 5))
|
||||
mknod ${name}${unit}g b $blk $(($unit * 8 + 6))
|
||||
mknod ${name}${unit}h b $blk $(($unit * 8 + 7))
|
||||
mknod r${name}${unit}a c $chr $(($unit * 8 + 0))
|
||||
mknod r${name}${unit}b c $chr $(($unit * 8 + 1))
|
||||
mknod r${name}${unit}c c $chr $(($unit * 8 + 2))
|
||||
mknod r${name}${unit}d c $chr $(($unit * 8 + 3))
|
||||
mknod r${name}${unit}e c $chr $(($unit * 8 + 4))
|
||||
mknod r${name}${unit}f c $chr $(($unit * 8 + 5))
|
||||
mknod r${name}${unit}g c $chr $(($unit * 8 + 6))
|
||||
mknod r${name}${unit}h c $chr $(($unit * 8 + 7))
|
||||
chgrp operator $name$unit? r$name$unit?
|
||||
chmod 640 $name$unit? r$name$unit?
|
||||
;;
|
||||
|
||||
com*|tty*) # (XXX -- com should die)
|
||||
unit=${i#???}
|
||||
rm -f com$unit tty0$unit dty0$unit
|
||||
mknod tty0$unit c 8 $(($unit + $dialin ))
|
||||
mknod dty0$unit c 8 $(($unit + $dialout))
|
||||
chown uucp.wheel tty0$unit dty0$unit
|
||||
;;
|
||||
|
||||
pty*)
|
||||
class=${i#pty}
|
||||
case $class in
|
||||
0) name=p;;
|
||||
1) name=q;;
|
||||
2) name=r;;
|
||||
3) name=s;;
|
||||
4) name=t;;
|
||||
5) name=u;;
|
||||
6) name=v
|
||||
echo "$0: $i: pty unit conflicts with console ttyv* devices."
|
||||
continue;;
|
||||
7) name=w;;
|
||||
8) name=x;;
|
||||
9) name=y;;
|
||||
10) name=z;;
|
||||
11) name=P;;
|
||||
12) name=Q;;
|
||||
13) name=R;;
|
||||
14) name=S;;
|
||||
15) name=T;;
|
||||
*) echo "$0: $i: pty unit must be between 0 and 15"
|
||||
continue ;;
|
||||
esac
|
||||
rm -f tty$name[0-9a-f] pty$name[0-9a-f]
|
||||
for j in 0 1 2 3 4 5 6 7 8 9 a b c d e f
|
||||
do
|
||||
case $j in
|
||||
[0-9]) jn=$j ;;
|
||||
a) jn=10 ;;
|
||||
b) jn=11 ;;
|
||||
c) jn=12 ;;
|
||||
d) jn=13 ;;
|
||||
e) jn=14 ;;
|
||||
f) jn=15 ;;
|
||||
esac
|
||||
unit=$(($class * 16 + $jn))
|
||||
mknod tty$name$j c 7 $unit
|
||||
mknod pty$name$j c 6 $unit
|
||||
done
|
||||
chgrp wheel tty$name? pty$name?
|
||||
chmod 666 tty$name? pty$name?
|
||||
;;
|
||||
|
||||
st*)
|
||||
case $i in
|
||||
st*) name=st; unit=${i#st}; chr=18; blk=4;;
|
||||
esac
|
||||
rm -f $name$unit n$name$unit e$name$unit en$name$unit \
|
||||
r$name$unit nr$name$unit er$name$unit enr$name$unit
|
||||
mknod $name$unit b $blk $(($unit * 16 + 0))
|
||||
mknod n$name$unit b $blk $(($unit * 16 + 1))
|
||||
mknod e$name$unit b $blk $(($unit * 16 + 2))
|
||||
mknod en$name$unit b $blk $(($unit * 16 + 3))
|
||||
mknod r$name$unit c $chr $(($unit * 16 + 0))
|
||||
mknod nr$name$unit c $chr $(($unit * 16 + 1))
|
||||
mknod er$name$unit c $chr $(($unit * 16 + 2))
|
||||
mknod enr$name$unit c $chr $(($unit * 16 + 3))
|
||||
chgrp operator $name$unit n$name$unit e$name$unit en$name$unit \
|
||||
r$name$unit nr$name$unit er$name$unit enr$name$unit
|
||||
chmod 660 $name$unit n$name$unit e$name$unit en$name$unit \
|
||||
r$name$unit nr$name$unit er$name$unit enr$name$unit
|
||||
;;
|
||||
|
||||
ch*|uk*)
|
||||
case $i in
|
||||
ch*) name=ch; unit=${i#ch}; chr=20;;
|
||||
uk*) name=uk; unit=${i#uk}; chr=21;;
|
||||
esac
|
||||
rm -f $name$unit
|
||||
mknod $name$unit c $chr $unit
|
||||
chgrp operator $name$unit
|
||||
chmod 640 $name$unit
|
||||
;;
|
||||
|
||||
cd*)
|
||||
case $i in
|
||||
cd*) name=cd; unit=${i#cd}; chr=19; blk=5;;
|
||||
esac
|
||||
rm -f $name$unit? r$name$unit?
|
||||
mknod ${name}${unit}a b $blk $(($unit * 8 + 0))
|
||||
mknod ${name}${unit}d b $blk $(($unit * 8 + 3))
|
||||
mknod r${name}${unit}a c $chr $(($unit * 8 + 0))
|
||||
mknod r${name}${unit}d c $chr $(($unit * 8 + 3))
|
||||
chgrp operator $name$unit? r$name$unit?
|
||||
chmod 640 $name$unit? r$name$unit?
|
||||
;;
|
||||
|
||||
lpt*)
|
||||
case $i in
|
||||
lpt*) name=lpt; unit=${i#lpt}; chr=9; flags=0;;
|
||||
esac
|
||||
rm -f $name$unit
|
||||
mknod $name$unit c $chr $(($unit + $flags))
|
||||
chown root.wheel $name$unit
|
||||
;;
|
||||
|
||||
bpf*|tun*)
|
||||
case $i in
|
||||
bpf*) name=bpf; unit=${i#bpf}; chr=29;;
|
||||
tun*) name=tun; unit=${i#tun}; chr=28;;
|
||||
esac
|
||||
rm -f $name$unit
|
||||
mknod $name$unit c $chr $unit
|
||||
chown root.wheel $name$unit
|
||||
;;
|
||||
|
||||
ipl)
|
||||
rm -f ipl ipnat ipstate ipauth
|
||||
mknod ipl c 27 0
|
||||
mknod ipnat c 27 1
|
||||
mknod ipstate c 27 2
|
||||
mknod ipauth c 27 3
|
||||
chown root.wheel ipl ipnat ipstate ipauth
|
||||
chmod 600 ipl ipnat ipstate ipauth
|
||||
;;
|
||||
|
||||
random)
|
||||
rm -f random urandom
|
||||
mknod random c 33 0
|
||||
mknod urandom c 33 1
|
||||
chown root.wheel random urandom
|
||||
chmod 444 random
|
||||
chmod 644 urandom
|
||||
;;
|
||||
|
||||
|
||||
scsibus*)
|
||||
unit=${i#scsibus};
|
||||
rm -f scsibus$unit
|
||||
mknod scsibus$unit c 16 $unit
|
||||
chown root:wheel scsibus$unit
|
||||
chmod 644 scsibus$unit
|
||||
;;
|
||||
|
||||
local)
|
||||
umask 0
|
||||
sh $0.local all
|
||||
umask 77
|
||||
;;
|
||||
|
||||
*)
|
||||
echo $i: unknown device
|
||||
;;
|
||||
|
||||
esac
|
||||
done
|
||||
39
etc/etc.hpcmips/disktab
Normal file
39
etc/etc.hpcmips/disktab
Normal file
@ -0,0 +1,39 @@
|
||||
# $NetBSD: disktab,v 1.1.1.1 1999/09/16 12:18:27 takemura Exp $
|
||||
#
|
||||
# from: @(#)disktab 8.1 (Berkeley) 6/9/93
|
||||
#
|
||||
|
||||
# Disk geometry and partition layout tables.
|
||||
# Key:
|
||||
# dt controller type
|
||||
# ty type of disk (fixed, removeable, simulated)
|
||||
# d[0-4] drive-type-dependent parameters
|
||||
# ns #sectors/track
|
||||
# nt #tracks/cylinder
|
||||
# nc #cylinders/disk
|
||||
# sc #sectors/cylinder, nc*nt default
|
||||
# su #sectors/unit, sc*nc default
|
||||
# se sector size, DEV_BSIZE default
|
||||
# rm rpm, 3600 default
|
||||
# sf supports bad144-style bad sector forwarding
|
||||
# sk sector skew per track, default 0
|
||||
# cs sector skew per cylinder, default 0
|
||||
# hs headswitch time, default 0
|
||||
# ts one-cylinder seek time, default 0
|
||||
# il sector interleave (n:1), 1 default
|
||||
# bs boot block size, default BBSIZE
|
||||
# sb superblock size, default SBSIZE
|
||||
# o[a-h] partition offsets in sectors
|
||||
# p[a-h] partition sizes in sectors
|
||||
# b[a-h] partition block sizes in bytes
|
||||
# f[a-h] partition fragment sizes in bytes
|
||||
# t[a-h] partition types (filesystem, swap, etc)
|
||||
# b[0-1] primary and secondary bootstraps, optional
|
||||
#
|
||||
# All partition sizes contain space for bad sector tables unless
|
||||
# the device drivers fail to support this. Smaller disks may
|
||||
# not have all partitions and all disks have no defaults for
|
||||
# the `h' partition. The strategy here is that `a' always
|
||||
# has the same amount for all disks (currently 65536 sectors or 32megs).
|
||||
* The `b' partition is approx 48 megs while `c' is always the entire disk. T
|
||||
# The sum of `d', `e', and `f' is equal to `g' which is everything else.
|
||||
5
etc/etc.hpcmips/fstab.wd
Normal file
5
etc/etc.hpcmips/fstab.wd
Normal file
@ -0,0 +1,5 @@
|
||||
# $NetBSD: fstab.wd,v 1.1.1.1 1999/09/16 12:18:27 takemura Exp $
|
||||
/dev/wd0a / ffs rw 1 1
|
||||
/dev/wd0b none swap sw 0 0
|
||||
kernfs /kern kernfs rw 0 0
|
||||
procfs /proc procfs rw 0 0
|
||||
41
etc/etc.hpcmips/ttys
Normal file
41
etc/etc.hpcmips/ttys
Normal file
@ -0,0 +1,41 @@
|
||||
#
|
||||
# $NetBSD: ttys,v 1.1.1.1 1999/09/16 12:18:27 takemura Exp $
|
||||
#
|
||||
# name getty type status comments
|
||||
#
|
||||
console "/usr/libexec/getty std.9600" unknown on secure
|
||||
#
|
||||
# pseudo-terminals
|
||||
#
|
||||
ttyp0 none network
|
||||
ttyp1 none network
|
||||
ttyp2 none network
|
||||
ttyp3 none network
|
||||
ttyp4 none network
|
||||
ttyp5 none network
|
||||
ttyp6 none network
|
||||
ttyp7 none network
|
||||
ttyp8 none network
|
||||
ttyp9 none network
|
||||
ttypa none network
|
||||
ttypb none network
|
||||
ttypc none network
|
||||
ttypd none network
|
||||
ttype none network
|
||||
ttypf none network
|
||||
ttyq0 none network
|
||||
ttyq1 none network
|
||||
ttyq2 none network
|
||||
ttyq3 none network
|
||||
ttyq4 none network
|
||||
ttyq5 none network
|
||||
ttyq6 none network
|
||||
ttyq7 none network
|
||||
ttyq8 none network
|
||||
ttyq9 none network
|
||||
ttyqa none network
|
||||
ttyqb none network
|
||||
ttyqc none network
|
||||
ttyqd none network
|
||||
ttyqe none network
|
||||
ttyqf none network
|
||||
16
lib/libc/arch/mips/fplib/Makefile.inc
Normal file
16
lib/libc/arch/mips/fplib/Makefile.inc
Normal file
@ -0,0 +1,16 @@
|
||||
.PATH: ${.CURDIR}/arch/mips/fplib
|
||||
|
||||
SRCS+=fplib_libc.c fplib_glue.c softfloat.c
|
||||
|
||||
softfloat.o: softfloat.c
|
||||
${COMPILE.c} -freg-struct-return -c ${.IMPSRC} -o ${.TARGET}
|
||||
@${LD} -x -r ${.TARGET}
|
||||
@mv a.out ${.TARGET}
|
||||
|
||||
softfloat.po: softfloat.c
|
||||
${COMPILE.c} -freg-struct-return -p ${.IMPSRC} -o ${.TARGET}
|
||||
@${LD} -X -r ${.TARGET}
|
||||
@mv a.out ${.TARGET}
|
||||
|
||||
softfloat.so: softfloat.c
|
||||
${COMPILE.c} -freg-struct-return -c ${.IMPSRC} -o ${.TARGET}
|
||||
52
lib/libc/arch/mips/fplib/environment.h
Normal file
52
lib/libc/arch/mips/fplib/environment.h
Normal file
@ -0,0 +1,52 @@
|
||||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEC/IEEE Floating-point
|
||||
Arithmetic Package, Release 1a.
|
||||
|
||||
Written by John R. Hauser. This work was made possible by the International
|
||||
Computer Science Institute, located at Suite 600, 1947 Center Street,
|
||||
Berkeley, California 94704. Funding was provided in part by the National
|
||||
Science Foundation under grant MIP-9311980. The original version of
|
||||
this code was written as part of a project to build a fixed-point vector
|
||||
processor in collaboration with the University of California at Berkeley,
|
||||
overseen by Profs. Nelson Morgan and John Wawrzynek. More information
|
||||
is available through the web page `http://www.cs.berkeley.edu/~jhauser/
|
||||
softfloat.html'.
|
||||
|
||||
THIS PACKAGE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has
|
||||
been made to avoid it, THIS PACKAGE MAY CONTAIN FAULTS THAT WILL AT TIMES
|
||||
RESULT IN INCORRECT BEHAVIOR. USE OF THIS PACKAGE IS RESTRICTED TO PERSONS
|
||||
AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY AND ALL
|
||||
LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these three paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Include common integer types and flags.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#include "hpcmips-gcc.h"
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The word `INLINE' appears before all routines that should be inlined. If
|
||||
a compiler does not support inlining, this macro should be defined to be
|
||||
`static'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define INLINE extern inline
|
||||
|
||||
#ifdef __lint
|
||||
#undef INLINE
|
||||
#define INLINE /* for lint */
|
||||
#endif
|
||||
|
||||
133
lib/libc/arch/mips/fplib/fplib_glue.c
Normal file
133
lib/libc/arch/mips/fplib/fplib_glue.c
Normal file
@ -0,0 +1,133 @@
|
||||
/* $NetBSD: fplib_glue.c,v 1.1.1.1 1999/09/16 12:18:25 takemura Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1997 The NetBSD Foundation, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Neil A. Carson and Mark Brinicombe
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the NetBSD
|
||||
* Foundation, Inc. and its contributors.
|
||||
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "environment.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/********************************* COMPARISONS ********************************/
|
||||
|
||||
/*
|
||||
* 'Equal' wrapper. This returns 0 if the numbers are equal, or (1 | -1)
|
||||
* otherwise. So we need to invert the output.
|
||||
*/
|
||||
|
||||
int __eqsf2(float32 a,float32 b) {
|
||||
return float32_eq(a,b)?0:1;
|
||||
}
|
||||
|
||||
int __eqdf2(float64 a,float64 b) {
|
||||
return float64_eq(a,b)?0:1;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'Not Equal' wrapper. This returns -1 or 1 (say, 1!) if the numbers are
|
||||
* not equal, 0 otherwise. However no not equal call is provided, so we have
|
||||
* to use an 'equal' call and invert the result. The result is already
|
||||
* inverted though! Confusing?!
|
||||
*/
|
||||
int __nesf2(float32 a,float32 b) {
|
||||
return float32_eq(a,b)?0:-1;
|
||||
}
|
||||
|
||||
int __nedf2(float64 a,float64 b) {
|
||||
return float64_eq(a,b)?0:-1;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'Greater Than' wrapper. This returns 1 if the number is greater, 0
|
||||
* or -1 otherwise. Unfortunately, no such function exists. We have to
|
||||
* instead compare the numbers using the 'less than' calls in order to
|
||||
* make up our mind. This means that we can call 'less than or equal' and
|
||||
* invert the result.
|
||||
*/
|
||||
int __gtsf2(float32 a,float32 b) {
|
||||
return float32_le(a,b)?0:1;
|
||||
}
|
||||
|
||||
int __gtdf2(float64 a,float64 b) {
|
||||
return float64_le(a,b)?0:1;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'Greater Than or Equal' wrapper. We emulate this by inverting the result
|
||||
* of a 'less than' call.
|
||||
*/
|
||||
int __gesf2(float32 a,float32 b) {
|
||||
return float32_lt(a,b)?-1:0;
|
||||
}
|
||||
|
||||
int __gedf2(float64 a,float64 b) {
|
||||
return float64_lt(a,b)?-1:0;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'Less Than' wrapper. A 1 from the ARM code needs to be turned into -1.
|
||||
*/
|
||||
int __ltsf2(float32 a,float32 b) {
|
||||
return float32_lt(a,b)?-1:0;
|
||||
}
|
||||
|
||||
int __ltdf2(float64 a,float64 b) {
|
||||
return float64_lt(a,b)?-1:0;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'Less Than or Equal' wrapper. A 0 must turn into a 1, and a 1 into a 0.
|
||||
*/
|
||||
int __lesf2(float32 a,float32 b) {
|
||||
return float32_le(a,b)?0:1;
|
||||
}
|
||||
|
||||
int __ledf2(float64 a,float64 b) {
|
||||
return float64_le(a,b)?0:1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Float negate... This isn't provided by the library, but it's hardly the
|
||||
* hardest function in the world to write... :) In fact, because of the
|
||||
* position in the registers of arguments, the double precision version can
|
||||
* go here too ;-)
|
||||
*/
|
||||
#define SIGN_BIT_TWIDDLE
|
||||
|
||||
float32 __negsf2(float32 a) {
|
||||
return (a ^ 0x80000000);
|
||||
}
|
||||
|
||||
float64 __negdf2(float64 a) {
|
||||
return (a ^ 0x8000000000000000LL);
|
||||
}
|
||||
86
lib/libc/arch/mips/fplib/fplib_libc.c
Normal file
86
lib/libc/arch/mips/fplib/fplib_libc.c
Normal file
@ -0,0 +1,86 @@
|
||||
/* $NetBSD: fplib_libc.c,v 1.1.1.1 1999/09/16 12:18:25 takemura Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1997 The NetBSD Foundation, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Neil A. Carson and Mark Brinicombe
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the NetBSD
|
||||
* Foundation, Inc. and its contributors.
|
||||
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include "environment.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
void sfp_setround __P((int rnd_dir));
|
||||
int sfp_getround __P((void));
|
||||
void sfp_setmask __P((int mask));
|
||||
int sfp_getmask __P((void));
|
||||
void sfp_setsticky __P((int except));
|
||||
int sfp_getsticky __P((void));
|
||||
|
||||
void
|
||||
sfp_setround(rnd_dir)
|
||||
int rnd_dir;
|
||||
{
|
||||
float_rounding_mode = rnd_dir;
|
||||
}
|
||||
|
||||
int
|
||||
sfp_getround(void)
|
||||
{
|
||||
return(float_rounding_mode);
|
||||
}
|
||||
|
||||
void
|
||||
sfp_setmask(mask)
|
||||
int mask;
|
||||
{
|
||||
}
|
||||
|
||||
int
|
||||
sfp_getmask(void)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
void
|
||||
sfp_setsticky(except)
|
||||
int except;
|
||||
{
|
||||
float_exception_flags = except;
|
||||
}
|
||||
|
||||
int
|
||||
sfp_getsticky(void)
|
||||
{
|
||||
return(float_exception_flags);
|
||||
}
|
||||
96
lib/libc/arch/mips/fplib/hpcmips-gcc.h
Normal file
96
lib/libc/arch/mips/fplib/hpcmips-gcc.h
Normal file
@ -0,0 +1,96 @@
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define LITTLEENDIAN
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The macro `BITS64' can be defined to indicate that 64-bit integer types are
|
||||
supported by the compiler.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define BITS64
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Each of the following `typedef's defines the most convenient type that holds
|
||||
integers of at least as many bits as specified. For example, `uint8' should
|
||||
be the most convenient type that can hold unsigned integers of as many as
|
||||
8 bits. The `flag' type must be able to hold either a 0 or 1. For most
|
||||
implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
|
||||
to the same as `int'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
typedef int flag;
|
||||
typedef unsigned char uint8;
|
||||
typedef signed char int8;
|
||||
typedef int uint16;
|
||||
typedef int int16;
|
||||
typedef unsigned int uint32;
|
||||
typedef signed int int32;
|
||||
#ifdef BITS64
|
||||
typedef unsigned long long int uint64;
|
||||
typedef signed long long int int64;
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Each of the following `typedef's defines a type that holds integers
|
||||
of _exactly_ the number of bits specified. For instance, for most
|
||||
implementation of C, `bits16' and `sbits16' should be `typedef'ed to
|
||||
`unsigned short int' and `signed short int' (or `short int'), respectively.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
typedef unsigned char bits8;
|
||||
typedef signed char sbits8;
|
||||
typedef unsigned short int bits16;
|
||||
typedef signed short int sbits16;
|
||||
typedef unsigned int bits32;
|
||||
typedef signed int sbits32;
|
||||
#ifdef BITS64
|
||||
typedef unsigned long long int bits64;
|
||||
typedef signed long long int sbits64;
|
||||
#endif
|
||||
|
||||
#ifdef BITS64
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The `LIT64' macro takes as its argument a textual integer literal and
|
||||
if necessary ``marks'' the literal as having a 64-bit integer type.
|
||||
For example, the GNU C Compiler (`gcc') requires that 64-bit literals be
|
||||
appended with the letters `LL' standing for `long long', which is `gcc's
|
||||
name for the 64-bit integer type. Some compilers may allow `LIT64' to be
|
||||
defined as the identity macro: `#define LIT64( a ) a'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define LIT64( a ) a##LL
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The macro `INLINE' can be used before functions that should be inlined. If
|
||||
a compiler does not support explicit inlining, this macro should be defined
|
||||
to be `static'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define INLINE extern inline
|
||||
|
||||
#define float32_add __addsf3
|
||||
#define float64_add __adddf3
|
||||
#define float32_sub __subsf3
|
||||
#define float64_sub __subdf3
|
||||
#define float32_mul __mulsf3
|
||||
#define float64_mul __muldf3
|
||||
#define float32_div __divsf3
|
||||
#define float64_div __divdf3
|
||||
#define int32_to_float32 __floatsisf
|
||||
#define int32_to_float64 __floatsidf
|
||||
#define float32_to_int32_round_to_zero __fixsfsi
|
||||
#define float64_to_int32_round_to_zero __fixdfsi
|
||||
#define float32_to_uint32_round_to_zero __fixunssfsi
|
||||
#define float64_to_uint32_round_to_zero __fixunsdfsi
|
||||
#define float32_to_float64 __extendsfdf2
|
||||
#define float64_to_float32 __truncdfsf2
|
||||
742
lib/libc/arch/mips/fplib/softfloat-macros.h
Normal file
742
lib/libc/arch/mips/fplib/softfloat-macros.h
Normal file
@ -0,0 +1,742 @@
|
||||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
|
||||
Arithmetic Package, Release 2a.
|
||||
|
||||
Written by John R. Hauser. This work was made possible in part by the
|
||||
International Computer Science Institute, located at Suite 600, 1947 Center
|
||||
Street, Berkeley, California 94704. Funding was partially provided by the
|
||||
National Science Foundation under grant MIP-9311980. The original version
|
||||
of this code was written as part of a project to build a fixed-point vector
|
||||
processor in collaboration with the University of California at Berkeley,
|
||||
overseen by Profs. Nelson Morgan and John Wawrzynek. More information
|
||||
is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
|
||||
arithmetic/SoftFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts `a' right by the number of bits given in `count'. If any nonzero
|
||||
bits are shifted off, they are ``jammed'' into the least significant bit of
|
||||
the result by setting the least significant bit to 1. The value of `count'
|
||||
can be arbitrarily large; in particular, if `count' is greater than 32, the
|
||||
result will be either 0 or 1, depending on whether `a' is zero or nonzero.
|
||||
The result is stored in the location pointed to by `zPtr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
|
||||
{
|
||||
bits32 z;
|
||||
|
||||
if ( count == 0 ) {
|
||||
z = a;
|
||||
}
|
||||
else if ( count < 32 ) {
|
||||
z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
|
||||
}
|
||||
else {
|
||||
z = ( a != 0 );
|
||||
}
|
||||
*zPtr = z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts `a' right by the number of bits given in `count'. If any nonzero
|
||||
bits are shifted off, they are ``jammed'' into the least significant bit of
|
||||
the result by setting the least significant bit to 1. The value of `count'
|
||||
can be arbitrarily large; in particular, if `count' is greater than 64, the
|
||||
result will be either 0 or 1, depending on whether `a' is zero or nonzero.
|
||||
The result is stored in the location pointed to by `zPtr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void shift64RightJamming( bits64 a, int16 count, bits64 *zPtr )
|
||||
{
|
||||
bits64 z;
|
||||
|
||||
if ( count == 0 ) {
|
||||
z = a;
|
||||
}
|
||||
else if ( count < 64 ) {
|
||||
z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );
|
||||
}
|
||||
else {
|
||||
z = ( a != 0 );
|
||||
}
|
||||
*zPtr = z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64
|
||||
_plus_ the number of bits given in `count'. The shifted result is at most
|
||||
64 nonzero bits; this is stored at the location pointed to by `z0Ptr'. The
|
||||
bits shifted off form a second 64-bit result as follows: The _last_ bit
|
||||
shifted off is the most-significant bit of the extra result, and the other
|
||||
63 bits of the extra result are all zero if and only if _all_but_the_last_
|
||||
bits shifted off were all zero. This extra result is stored in the location
|
||||
pointed to by `z1Ptr'. The value of `count' can be arbitrarily large.
|
||||
(This routine makes more sense if `a0' and `a1' are considered to form a
|
||||
fixed-point value with binary point between `a0' and `a1'. This fixed-point
|
||||
value is shifted right by the number of bits given in `count', and the
|
||||
integer part of the result is returned at the location pointed to by
|
||||
`z0Ptr'. The fractional part of the result may be slightly corrupted as
|
||||
described above, and is returned at the location pointed to by `z1Ptr'.)
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
shift64ExtraRightJamming(
|
||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
||||
{
|
||||
bits64 z0, z1;
|
||||
int8 negCount = ( - count ) & 63;
|
||||
|
||||
if ( count == 0 ) {
|
||||
z1 = a1;
|
||||
z0 = a0;
|
||||
}
|
||||
else if ( count < 64 ) {
|
||||
z1 = ( a0<<negCount ) | ( a1 != 0 );
|
||||
z0 = a0>>count;
|
||||
}
|
||||
else {
|
||||
if ( count == 64 ) {
|
||||
z1 = a0 | ( a1 != 0 );
|
||||
}
|
||||
else {
|
||||
z1 = ( ( a0 | a1 ) != 0 );
|
||||
}
|
||||
z0 = 0;
|
||||
}
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
|
||||
number of bits given in `count'. Any bits shifted off are lost. The value
|
||||
of `count' can be arbitrarily large; in particular, if `count' is greater
|
||||
than 128, the result will be 0. The result is broken into two 64-bit pieces
|
||||
which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
shift128Right(
|
||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
||||
{
|
||||
bits64 z0, z1;
|
||||
int8 negCount = ( - count ) & 63;
|
||||
|
||||
if ( count == 0 ) {
|
||||
z1 = a1;
|
||||
z0 = a0;
|
||||
}
|
||||
else if ( count < 64 ) {
|
||||
z1 = ( a0<<negCount ) | ( a1>>count );
|
||||
z0 = a0>>count;
|
||||
}
|
||||
else {
|
||||
z1 = ( count < 64 ) ? ( a0>>( count & 63 ) ) : 0;
|
||||
z0 = 0;
|
||||
}
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
|
||||
number of bits given in `count'. If any nonzero bits are shifted off, they
|
||||
are ``jammed'' into the least significant bit of the result by setting the
|
||||
least significant bit to 1. The value of `count' can be arbitrarily large;
|
||||
in particular, if `count' is greater than 128, the result will be either
|
||||
0 or 1, depending on whether the concatenation of `a0' and `a1' is zero or
|
||||
nonzero. The result is broken into two 64-bit pieces which are stored at
|
||||
the locations pointed to by `z0Ptr' and `z1Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
shift128RightJamming(
|
||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
||||
{
|
||||
bits64 z0, z1;
|
||||
int8 negCount = ( - count ) & 63;
|
||||
|
||||
if ( count == 0 ) {
|
||||
z1 = a1;
|
||||
z0 = a0;
|
||||
}
|
||||
else if ( count < 64 ) {
|
||||
z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );
|
||||
z0 = a0>>count;
|
||||
}
|
||||
else {
|
||||
if ( count == 64 ) {
|
||||
z1 = a0 | ( a1 != 0 );
|
||||
}
|
||||
else if ( count < 128 ) {
|
||||
z1 = ( a0>>( count & 63 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );
|
||||
}
|
||||
else {
|
||||
z1 = ( ( a0 | a1 ) != 0 );
|
||||
}
|
||||
z0 = 0;
|
||||
}
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right
|
||||
by 64 _plus_ the number of bits given in `count'. The shifted result is
|
||||
at most 128 nonzero bits; these are broken into two 64-bit pieces which are
|
||||
stored at the locations pointed to by `z0Ptr' and `z1Ptr'. The bits shifted
|
||||
off form a third 64-bit result as follows: The _last_ bit shifted off is
|
||||
the most-significant bit of the extra result, and the other 63 bits of the
|
||||
extra result are all zero if and only if _all_but_the_last_ bits shifted off
|
||||
were all zero. This extra result is stored in the location pointed to by
|
||||
`z2Ptr'. The value of `count' can be arbitrarily large.
|
||||
(This routine makes more sense if `a0', `a1', and `a2' are considered
|
||||
to form a fixed-point value with binary point between `a1' and `a2'. This
|
||||
fixed-point value is shifted right by the number of bits given in `count',
|
||||
and the integer part of the result is returned at the locations pointed to
|
||||
by `z0Ptr' and `z1Ptr'. The fractional part of the result may be slightly
|
||||
corrupted as described above, and is returned at the location pointed to by
|
||||
`z2Ptr'.)
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
shift128ExtraRightJamming(
|
||||
bits64 a0,
|
||||
bits64 a1,
|
||||
bits64 a2,
|
||||
int16 count,
|
||||
bits64 *z0Ptr,
|
||||
bits64 *z1Ptr,
|
||||
bits64 *z2Ptr
|
||||
)
|
||||
{
|
||||
bits64 z0, z1, z2;
|
||||
int8 negCount = ( - count ) & 63;
|
||||
|
||||
if ( count == 0 ) {
|
||||
z2 = a2;
|
||||
z1 = a1;
|
||||
z0 = a0;
|
||||
}
|
||||
else {
|
||||
if ( count < 64 ) {
|
||||
z2 = a1<<negCount;
|
||||
z1 = ( a0<<negCount ) | ( a1>>count );
|
||||
z0 = a0>>count;
|
||||
}
|
||||
else {
|
||||
if ( count == 64 ) {
|
||||
z2 = a1;
|
||||
z1 = a0;
|
||||
}
|
||||
else {
|
||||
a2 |= a1;
|
||||
if ( count < 128 ) {
|
||||
z2 = a0<<negCount;
|
||||
z1 = a0>>( count & 63 );
|
||||
}
|
||||
else {
|
||||
z2 = ( count == 128 ) ? a0 : ( a0 != 0 );
|
||||
z1 = 0;
|
||||
}
|
||||
}
|
||||
z0 = 0;
|
||||
}
|
||||
z2 |= ( a2 != 0 );
|
||||
}
|
||||
*z2Ptr = z2;
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the
|
||||
number of bits given in `count'. Any bits shifted off are lost. The value
|
||||
of `count' must be less than 64. The result is broken into two 64-bit
|
||||
pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
shortShift128Left(
|
||||
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
||||
{
|
||||
|
||||
*z1Ptr = a1<<count;
|
||||
*z0Ptr =
|
||||
( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 63 ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left
|
||||
by the number of bits given in `count'. Any bits shifted off are lost.
|
||||
The value of `count' must be less than 64. The result is broken into three
|
||||
64-bit pieces which are stored at the locations pointed to by `z0Ptr',
|
||||
`z1Ptr', and `z2Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
shortShift192Left(
|
||||
bits64 a0,
|
||||
bits64 a1,
|
||||
bits64 a2,
|
||||
int16 count,
|
||||
bits64 *z0Ptr,
|
||||
bits64 *z1Ptr,
|
||||
bits64 *z2Ptr
|
||||
)
|
||||
{
|
||||
bits64 z0, z1, z2;
|
||||
int8 negCount;
|
||||
|
||||
z2 = a2<<count;
|
||||
z1 = a1<<count;
|
||||
z0 = a0<<count;
|
||||
if ( 0 < count ) {
|
||||
negCount = ( ( - count ) & 63 );
|
||||
z1 |= a2>>negCount;
|
||||
z0 |= a1>>negCount;
|
||||
}
|
||||
*z2Ptr = z2;
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit
|
||||
value formed by concatenating `b0' and `b1'. Addition is modulo 2^128, so
|
||||
any carry out is lost. The result is broken into two 64-bit pieces which
|
||||
are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
add128(
|
||||
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )
|
||||
{
|
||||
bits64 z1;
|
||||
|
||||
z1 = a1 + b1;
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = a0 + b0 + ( z1 < a1 );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the
|
||||
192-bit value formed by concatenating `b0', `b1', and `b2'. Addition is
|
||||
modulo 2^192, so any carry out is lost. The result is broken into three
|
||||
64-bit pieces which are stored at the locations pointed to by `z0Ptr',
|
||||
`z1Ptr', and `z2Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
add192(
|
||||
bits64 a0,
|
||||
bits64 a1,
|
||||
bits64 a2,
|
||||
bits64 b0,
|
||||
bits64 b1,
|
||||
bits64 b2,
|
||||
bits64 *z0Ptr,
|
||||
bits64 *z1Ptr,
|
||||
bits64 *z2Ptr
|
||||
)
|
||||
{
|
||||
bits64 z0, z1, z2;
|
||||
int8 carry0, carry1;
|
||||
|
||||
z2 = a2 + b2;
|
||||
carry1 = ( z2 < a2 );
|
||||
z1 = a1 + b1;
|
||||
carry0 = ( z1 < a1 );
|
||||
z0 = a0 + b0;
|
||||
z1 += carry1;
|
||||
z0 += ( z1 < carry1 );
|
||||
z0 += carry0;
|
||||
*z2Ptr = z2;
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the
|
||||
128-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo
|
||||
2^128, so any borrow out (carry out) is lost. The result is broken into two
|
||||
64-bit pieces which are stored at the locations pointed to by `z0Ptr' and
|
||||
`z1Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
sub128(
|
||||
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )
|
||||
{
|
||||
|
||||
*z1Ptr = a1 - b1;
|
||||
*z0Ptr = a0 - b0 - ( a1 < b1 );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'
|
||||
from the 192-bit value formed by concatenating `a0', `a1', and `a2'.
|
||||
Subtraction is modulo 2^192, so any borrow out (carry out) is lost. The
|
||||
result is broken into three 64-bit pieces which are stored at the locations
|
||||
pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
sub192(
|
||||
bits64 a0,
|
||||
bits64 a1,
|
||||
bits64 a2,
|
||||
bits64 b0,
|
||||
bits64 b1,
|
||||
bits64 b2,
|
||||
bits64 *z0Ptr,
|
||||
bits64 *z1Ptr,
|
||||
bits64 *z2Ptr
|
||||
)
|
||||
{
|
||||
bits64 z0, z1, z2;
|
||||
int8 borrow0, borrow1;
|
||||
|
||||
z2 = a2 - b2;
|
||||
borrow1 = ( a2 < b2 );
|
||||
z1 = a1 - b1;
|
||||
borrow0 = ( a1 < b1 );
|
||||
z0 = a0 - b0;
|
||||
z0 -= ( z1 < borrow1 );
|
||||
z1 -= borrow1;
|
||||
z0 -= borrow0;
|
||||
*z2Ptr = z2;
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Multiplies `a' by `b' to obtain a 128-bit product. The product is broken
|
||||
into two 64-bit pieces which are stored at the locations pointed to by
|
||||
`z0Ptr' and `z1Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr )
|
||||
{
|
||||
bits32 aHigh, aLow, bHigh, bLow;
|
||||
bits64 z0, zMiddleA, zMiddleB, z1;
|
||||
|
||||
aLow = a;
|
||||
aHigh = a>>32;
|
||||
bLow = b;
|
||||
bHigh = b>>32;
|
||||
z1 = ( (bits64) aLow ) * bLow;
|
||||
zMiddleA = ( (bits64) aLow ) * bHigh;
|
||||
zMiddleB = ( (bits64) aHigh ) * bLow;
|
||||
z0 = ( (bits64) aHigh ) * bHigh;
|
||||
zMiddleA += zMiddleB;
|
||||
z0 += ( ( (bits64) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
|
||||
zMiddleA <<= 32;
|
||||
z1 += zMiddleA;
|
||||
z0 += ( z1 < zMiddleA );
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Multiplies the 128-bit value formed by concatenating `a0' and `a1' by
|
||||
`b' to obtain a 192-bit product. The product is broken into three 64-bit
|
||||
pieces which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
|
||||
`z2Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
mul128By64To192(
|
||||
bits64 a0,
|
||||
bits64 a1,
|
||||
bits64 b,
|
||||
bits64 *z0Ptr,
|
||||
bits64 *z1Ptr,
|
||||
bits64 *z2Ptr
|
||||
)
|
||||
{
|
||||
bits64 z0, z1, z2, more1;
|
||||
|
||||
mul64To128( a1, b, &z1, &z2 );
|
||||
mul64To128( a0, b, &z0, &more1 );
|
||||
add128( z0, more1, 0, z1, &z0, &z1 );
|
||||
*z2Ptr = z2;
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the
|
||||
128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit
|
||||
product. The product is broken into four 64-bit pieces which are stored at
|
||||
the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE void
|
||||
mul128To256(
|
||||
bits64 a0,
|
||||
bits64 a1,
|
||||
bits64 b0,
|
||||
bits64 b1,
|
||||
bits64 *z0Ptr,
|
||||
bits64 *z1Ptr,
|
||||
bits64 *z2Ptr,
|
||||
bits64 *z3Ptr
|
||||
)
|
||||
{
|
||||
bits64 z0, z1, z2, z3;
|
||||
bits64 more1, more2;
|
||||
|
||||
mul64To128( a1, b1, &z2, &z3 );
|
||||
mul64To128( a1, b0, &z1, &more2 );
|
||||
add128( z1, more2, 0, z2, &z1, &z2 );
|
||||
mul64To128( a0, b0, &z0, &more1 );
|
||||
add128( z0, more1, 0, z1, &z0, &z1 );
|
||||
mul64To128( a0, b1, &more1, &more2 );
|
||||
add128( more1, more2, 0, z2, &more1, &z2 );
|
||||
add128( z0, z1, 0, more1, &z0, &z1 );
|
||||
*z3Ptr = z3;
|
||||
*z2Ptr = z2;
|
||||
*z1Ptr = z1;
|
||||
*z0Ptr = z0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns an approximation to the 64-bit integer quotient obtained by dividing
|
||||
`b' into the 128-bit value formed by concatenating `a0' and `a1'. The
|
||||
divisor `b' must be at least 2^63. If q is the exact quotient truncated
|
||||
toward zero, the approximation returned lies between q and q + 2 inclusive.
|
||||
If the exact quotient q is larger than 64 bits, the maximum positive 64-bit
|
||||
unsigned integer is returned.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b )
|
||||
{
|
||||
bits64 b0, b1;
|
||||
bits64 rem0, rem1, term0, term1;
|
||||
bits64 z;
|
||||
|
||||
if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );
|
||||
b0 = b>>32;
|
||||
z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;
|
||||
mul64To128( b, z, &term0, &term1 );
|
||||
sub128( a0, a1, term0, term1, &rem0, &rem1 );
|
||||
while ( ( (sbits64) rem0 ) < 0 ) {
|
||||
z -= LIT64( 0x100000000 );
|
||||
b1 = b<<32;
|
||||
add128( rem0, rem1, b0, b1, &rem0, &rem1 );
|
||||
}
|
||||
rem0 = ( rem0<<32 ) | ( rem1>>32 );
|
||||
z |= ( b0<<32 <= rem0 ) ? 0xFFFFFFFF : rem0 / b0;
|
||||
return z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns an approximation to the square root of the 32-bit significand given
|
||||
by `a'. Considered as an integer, `a' must be at least 2^31. If bit 0 of
|
||||
`aExp' (the least significant bit) is 1, the integer returned approximates
|
||||
2^31*sqrt(`a'/2^31), where `a' is considered an integer. If bit 0 of `aExp'
|
||||
is 0, the integer returned approximates 2^31*sqrt(`a'/2^30). In either
|
||||
case, the approximation returned lies strictly within +/-2 of the exact
|
||||
value.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static bits32 estimateSqrt32( int16 aExp, bits32 a )
|
||||
{
|
||||
static const bits16 sqrtOddAdjustments[] = {
|
||||
0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
|
||||
0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
|
||||
};
|
||||
static const bits16 sqrtEvenAdjustments[] = {
|
||||
0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
|
||||
0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
|
||||
};
|
||||
int8 index;
|
||||
bits32 z;
|
||||
|
||||
index = ( a>>27 ) & 15;
|
||||
if ( aExp & 1 ) {
|
||||
z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];
|
||||
z = ( ( a / z )<<14 ) + ( z<<15 );
|
||||
a >>= 1;
|
||||
}
|
||||
else {
|
||||
z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];
|
||||
z = a / z + z;
|
||||
z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
|
||||
if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );
|
||||
}
|
||||
return ( (bits32) ( ( ( (bits64) a )<<31 ) / z ) ) + ( z>>1 );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the number of leading 0 bits before the most-significant 1 bit of
|
||||
`a'. If `a' is zero, 32 is returned.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static int8 countLeadingZeros32( bits32 a )
|
||||
{
|
||||
static const int8 countLeadingZerosHigh[] = {
|
||||
8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
int8 shiftCount;
|
||||
|
||||
shiftCount = 0;
|
||||
if ( a < 0x10000 ) {
|
||||
shiftCount += 16;
|
||||
a <<= 16;
|
||||
}
|
||||
if ( a < 0x1000000 ) {
|
||||
shiftCount += 8;
|
||||
a <<= 8;
|
||||
}
|
||||
shiftCount += countLeadingZerosHigh[ a>>24 ];
|
||||
return shiftCount;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the number of leading 0 bits before the most-significant 1 bit of
|
||||
`a'. If `a' is zero, 64 is returned.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static int8 countLeadingZeros64( bits64 a )
|
||||
{
|
||||
int8 shiftCount;
|
||||
|
||||
shiftCount = 0;
|
||||
if ( a < ( (bits64) 1 )<<32 ) {
|
||||
shiftCount += 32;
|
||||
}
|
||||
else {
|
||||
a >>= 32;
|
||||
}
|
||||
shiftCount += countLeadingZeros32( a );
|
||||
return shiftCount;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'
|
||||
is equal to the 128-bit value formed by concatenating `b0' and `b1'.
|
||||
Otherwise, returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
||||
{
|
||||
|
||||
return ( a0 == b0 ) && ( a1 == b1 );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
|
||||
than or equal to the 128-bit value formed by concatenating `b0' and `b1'.
|
||||
Otherwise, returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
||||
{
|
||||
|
||||
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
|
||||
than the 128-bit value formed by concatenating `b0' and `b1'. Otherwise,
|
||||
returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
||||
{
|
||||
|
||||
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is
|
||||
not equal to the 128-bit value formed by concatenating `b0' and `b1'.
|
||||
Otherwise, returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
INLINE flag ne128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
||||
{
|
||||
|
||||
return ( a0 != b0 ) || ( a1 != b1 );
|
||||
|
||||
}
|
||||
|
||||
496
lib/libc/arch/mips/fplib/softfloat-specialize.h
Normal file
496
lib/libc/arch/mips/fplib/softfloat-specialize.h
Normal file
@ -0,0 +1,496 @@
|
||||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
|
||||
Arithmetic Package, Release 2a.
|
||||
|
||||
Written by John R. Hauser. This work was made possible in part by the
|
||||
International Computer Science Institute, located at Suite 600, 1947 Center
|
||||
Street, Berkeley, California 94704. Funding was partially provided by the
|
||||
National Science Foundation under grant MIP-9311980. The original version
|
||||
of this code was written as part of a project to build a fixed-point vector
|
||||
processor in collaboration with the University of California at Berkeley,
|
||||
overseen by Profs. Nelson Morgan and John Wawrzynek. More information
|
||||
is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
|
||||
arithmetic/SoftFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Underflow tininess-detection mode, statically initialized to default value.
|
||||
(The declaration in `softfloat.h' must match the `int8' type here.)
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
int8 float_detect_tininess = float_tininess_after_rounding;
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Raises the exceptions specified by `flags'. Floating-point traps can be
|
||||
defined here if desired. It is currently not possible for such a trap
|
||||
to substitute a result value. If traps are not implemented, this routine
|
||||
should be simply `float_exception_flags |= flags;'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
void float_raise( int8 flags )
|
||||
{
|
||||
|
||||
float_exception_flags |= flags;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Internal canonical NaN format.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
typedef struct {
|
||||
flag sign;
|
||||
bits64 high, low;
|
||||
} commonNaNT;
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The pattern for a default generated single-precision NaN.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define float32_default_nan 0xFFC00000
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the single-precision floating-point value `a' is a NaN;
|
||||
otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag float32_is_nan( float32 a )
|
||||
{
|
||||
|
||||
return ( 0xFF000000 < (bits32) ( a<<1 ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the single-precision floating-point value `a' is a signaling
|
||||
NaN; otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag float32_is_signaling_nan( float32 a )
|
||||
{
|
||||
|
||||
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the single-precision floating-point NaN
|
||||
`a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
|
||||
exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static commonNaNT float32ToCommonNaN( float32 a )
|
||||
{
|
||||
commonNaNT z;
|
||||
|
||||
if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
||||
z.sign = a>>31;
|
||||
z.low = 0;
|
||||
z.high = ( (bits64) a )<<41;
|
||||
return z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the canonical NaN `a' to the single-
|
||||
precision floating-point format.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static float32 commonNaNToFloat32( commonNaNT a )
|
||||
{
|
||||
|
||||
return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Takes two single-precision floating-point values `a' and `b', one of which
|
||||
is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
|
||||
signaling NaN, the invalid exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static float32 propagateFloat32NaN( float32 a, float32 b )
|
||||
{
|
||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
||||
|
||||
aIsNaN = float32_is_nan( a );
|
||||
aIsSignalingNaN = float32_is_signaling_nan( a );
|
||||
bIsNaN = float32_is_nan( b );
|
||||
bIsSignalingNaN = float32_is_signaling_nan( b );
|
||||
a |= 0x00400000;
|
||||
b |= 0x00400000;
|
||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
||||
if ( aIsSignalingNaN ) {
|
||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
||||
return bIsNaN ? b : a;
|
||||
}
|
||||
else if ( aIsNaN ) {
|
||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
||||
returnLargerSignificand:
|
||||
if ( (bits32) ( a<<1 ) < (bits32) ( b<<1 ) ) return b;
|
||||
if ( (bits32) ( b<<1 ) < (bits32) ( a<<1 ) ) return a;
|
||||
return ( a < b ) ? a : b;
|
||||
}
|
||||
else {
|
||||
return b;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The pattern for a default generated double-precision NaN.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define float64_default_nan LIT64( 0xFFF8000000000000 )
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the double-precision floating-point value `a' is a NaN;
|
||||
otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag float64_is_nan( float64 a )
|
||||
{
|
||||
|
||||
return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the double-precision floating-point value `a' is a signaling
|
||||
NaN; otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag float64_is_signaling_nan( float64 a )
|
||||
{
|
||||
|
||||
return
|
||||
( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
|
||||
&& ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the double-precision floating-point NaN
|
||||
`a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
|
||||
exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static commonNaNT float64ToCommonNaN( float64 a )
|
||||
{
|
||||
commonNaNT z;
|
||||
|
||||
if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
||||
z.sign = a>>63;
|
||||
z.low = 0;
|
||||
z.high = a<<12;
|
||||
return z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the canonical NaN `a' to the double-
|
||||
precision floating-point format.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static float64 commonNaNToFloat64( commonNaNT a )
|
||||
{
|
||||
|
||||
return
|
||||
( ( (bits64) a.sign )<<63 )
|
||||
| LIT64( 0x7FF8000000000000 )
|
||||
| ( a.high>>12 );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Takes two double-precision floating-point values `a' and `b', one of which
|
||||
is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
|
||||
signaling NaN, the invalid exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static float64 propagateFloat64NaN( float64 a, float64 b )
|
||||
{
|
||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
||||
|
||||
aIsNaN = float64_is_nan( a );
|
||||
aIsSignalingNaN = float64_is_signaling_nan( a );
|
||||
bIsNaN = float64_is_nan( b );
|
||||
bIsSignalingNaN = float64_is_signaling_nan( b );
|
||||
a |= LIT64( 0x0008000000000000 );
|
||||
b |= LIT64( 0x0008000000000000 );
|
||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
||||
if ( aIsSignalingNaN ) {
|
||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
||||
return bIsNaN ? b : a;
|
||||
}
|
||||
else if ( aIsNaN ) {
|
||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
||||
returnLargerSignificand:
|
||||
if ( (bits64) ( a<<1 ) < (bits64) ( b<<1 ) ) return b;
|
||||
if ( (bits64) ( b<<1 ) < (bits64) ( a<<1 ) ) return a;
|
||||
return ( a < b ) ? a : b;
|
||||
}
|
||||
else {
|
||||
return b;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#ifdef FLOATX80
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The pattern for a default generated extended double-precision NaN. The
|
||||
`high' and `low' values hold the most- and least-significant bits,
|
||||
respectively.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define floatx80_default_nan_high 0xFFFF
|
||||
#define floatx80_default_nan_low LIT64( 0xC000000000000000 )
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the extended double-precision floating-point value `a' is a
|
||||
NaN; otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag floatx80_is_nan( floatx80 a )
|
||||
{
|
||||
|
||||
return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the extended double-precision floating-point value `a' is a
|
||||
signaling NaN; otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag floatx80_is_signaling_nan( floatx80 a )
|
||||
{
|
||||
bits64 aLow;
|
||||
|
||||
aLow = a.low & ~ LIT64( 0x4000000000000000 );
|
||||
return
|
||||
( ( a.high & 0x7FFF ) == 0x7FFF )
|
||||
&& (bits64) ( aLow<<1 )
|
||||
&& ( a.low == aLow );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the extended double-precision floating-
|
||||
point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
|
||||
invalid exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static commonNaNT floatx80ToCommonNaN( floatx80 a )
|
||||
{
|
||||
commonNaNT z;
|
||||
|
||||
if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
||||
z.sign = a.high>>15;
|
||||
z.low = 0;
|
||||
z.high = a.low<<1;
|
||||
return z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the canonical NaN `a' to the extended
|
||||
double-precision floating-point format.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static floatx80 commonNaNToFloatx80( commonNaNT a )
|
||||
{
|
||||
floatx80 z;
|
||||
|
||||
z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
|
||||
z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
|
||||
return z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Takes two extended double-precision floating-point values `a' and `b', one
|
||||
of which is a NaN, and returns the appropriate NaN result. If either `a' or
|
||||
`b' is a signaling NaN, the invalid exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b )
|
||||
{
|
||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
||||
|
||||
aIsNaN = floatx80_is_nan( a );
|
||||
aIsSignalingNaN = floatx80_is_signaling_nan( a );
|
||||
bIsNaN = floatx80_is_nan( b );
|
||||
bIsSignalingNaN = floatx80_is_signaling_nan( b );
|
||||
a.low |= LIT64( 0xC000000000000000 );
|
||||
b.low |= LIT64( 0xC000000000000000 );
|
||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
||||
if ( aIsSignalingNaN ) {
|
||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
||||
return bIsNaN ? b : a;
|
||||
}
|
||||
else if ( aIsNaN ) {
|
||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
||||
returnLargerSignificand:
|
||||
if ( a.low < b.low ) return b;
|
||||
if ( b.low < a.low ) return a;
|
||||
return ( a.high < b.high ) ? a : b;
|
||||
}
|
||||
else {
|
||||
return b;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef FLOAT128
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The pattern for a default generated quadruple-precision NaN. The `high' and
|
||||
`low' values hold the most- and least-significant bits, respectively.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define float128_default_nan_high LIT64( 0xFFFF800000000000 )
|
||||
#define float128_default_nan_low LIT64( 0x0000000000000000 )
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
|
||||
otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag float128_is_nan( float128 a )
|
||||
{
|
||||
|
||||
return
|
||||
( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
|
||||
&& ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns 1 if the quadruple-precision floating-point value `a' is a
|
||||
signaling NaN; otherwise returns 0.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
flag float128_is_signaling_nan( float128 a )
|
||||
{
|
||||
|
||||
return
|
||||
( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
|
||||
&& ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the quadruple-precision floating-point NaN
|
||||
`a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
|
||||
exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static commonNaNT float128ToCommonNaN( float128 a )
|
||||
{
|
||||
commonNaNT z;
|
||||
|
||||
if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
|
||||
z.sign = a.high>>63;
|
||||
shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
|
||||
return z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Returns the result of converting the canonical NaN `a' to the quadruple-
|
||||
precision floating-point format.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static float128 commonNaNToFloat128( commonNaNT a )
|
||||
{
|
||||
float128 z;
|
||||
|
||||
shift128Right( a.high, a.low, 16, &z.high, &z.low );
|
||||
z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
|
||||
return z;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Takes two quadruple-precision floating-point values `a' and `b', one of
|
||||
which is a NaN, and returns the appropriate NaN result. If either `a' or
|
||||
`b' is a signaling NaN, the invalid exception is raised.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
static float128 propagateFloat128NaN( float128 a, float128 b )
|
||||
{
|
||||
flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
|
||||
|
||||
aIsNaN = float128_is_nan( a );
|
||||
aIsSignalingNaN = float128_is_signaling_nan( a );
|
||||
bIsNaN = float128_is_nan( b );
|
||||
bIsSignalingNaN = float128_is_signaling_nan( b );
|
||||
a.high |= LIT64( 0x0000800000000000 );
|
||||
b.high |= LIT64( 0x0000800000000000 );
|
||||
if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
|
||||
if ( aIsSignalingNaN ) {
|
||||
if ( bIsSignalingNaN ) goto returnLargerSignificand;
|
||||
return bIsNaN ? b : a;
|
||||
}
|
||||
else if ( aIsNaN ) {
|
||||
if ( bIsSignalingNaN | ! bIsNaN ) return a;
|
||||
returnLargerSignificand:
|
||||
if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
|
||||
if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;
|
||||
return ( a.high < b.high ) ? a : b;
|
||||
}
|
||||
else {
|
||||
return b;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
5411
lib/libc/arch/mips/fplib/softfloat.c
Normal file
5411
lib/libc/arch/mips/fplib/softfloat.c
Normal file
File diff suppressed because it is too large
Load Diff
290
lib/libc/arch/mips/fplib/softfloat.h
Normal file
290
lib/libc/arch/mips/fplib/softfloat.h
Normal file
@ -0,0 +1,290 @@
|
||||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEC/IEEE Floating-point
|
||||
Arithmetic Package, Release 2a.
|
||||
|
||||
Written by John R. Hauser. This work was made possible in part by the
|
||||
International Computer Science Institute, located at Suite 600, 1947 Center
|
||||
Street, Berkeley, California 94704. Funding was partially provided by the
|
||||
National Science Foundation under grant MIP-9311980. The original version
|
||||
of this code was written as part of a project to build a fixed-point vector
|
||||
processor in collaboration with the University of California at Berkeley,
|
||||
overseen by Profs. Nelson Morgan and John Wawrzynek. More information
|
||||
is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
|
||||
arithmetic/SoftFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The macro `FLOATX80' must be defined to enable the extended double-precision
|
||||
floating-point format `floatx80'. If this macro is not defined, the
|
||||
`floatx80' type will not be defined, and none of the functions that either
|
||||
input or output the `floatx80' type will be defined. The same applies to
|
||||
the `FLOAT128' macro and the quadruple-precision format `float128'.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#undef FLOATX80
|
||||
#undef FLOAT128
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE floating-point types.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
typedef unsigned int float32;
|
||||
typedef unsigned long long float64;
|
||||
#ifdef FLOATX80
|
||||
typedef struct {
|
||||
unsigned long long low;
|
||||
unsigned short high;
|
||||
} floatx80;
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
typedef struct {
|
||||
unsigned long long low, high;
|
||||
} float128;
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE floating-point underflow tininess-detection mode.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
extern signed char float_detect_tininess;
|
||||
enum {
|
||||
float_tininess_after_rounding = 0,
|
||||
float_tininess_before_rounding = 1
|
||||
};
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE floating-point rounding mode.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
extern signed char float_rounding_mode;
|
||||
enum {
|
||||
float_round_nearest_even = 0,
|
||||
float_round_down = 1,
|
||||
float_round_up = 2,
|
||||
float_round_to_zero = 3
|
||||
};
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE floating-point exception flags.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
extern signed char float_exception_flags;
|
||||
enum {
|
||||
float_flag_invalid = 1,
|
||||
float_flag_divbyzero = 4,
|
||||
float_flag_overflow = 8,
|
||||
float_flag_underflow = 16,
|
||||
float_flag_inexact = 32
|
||||
};
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Routine to raise any or all of the software IEC/IEEE floating-point
|
||||
exception flags.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
void float_raise( signed char );
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE integer-to-floating-point conversion routines.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
float32 int32_to_float32( int );
|
||||
float64 int32_to_float64( int );
|
||||
#ifdef FLOATX80
|
||||
floatx80 int32_to_floatx80( int );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 int32_to_float128( int );
|
||||
#endif
|
||||
float32 int64_to_float32( long long );
|
||||
float64 int64_to_float64( long long );
|
||||
#ifdef FLOATX80
|
||||
floatx80 int64_to_floatx80( long long );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 int64_to_float128( long long );
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE single-precision conversion routines.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
int float32_to_int32( float32 );
|
||||
int float32_to_int32_round_to_zero( float32 );
|
||||
long long float32_to_int64( float32 );
|
||||
long long float32_to_int64_round_to_zero( float32 );
|
||||
float64 float32_to_float64( float32 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 float32_to_floatx80( float32 );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 float32_to_float128( float32 );
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE single-precision operations.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
float32 float32_round_to_int( float32 );
|
||||
float32 float32_add( float32, float32 );
|
||||
float32 float32_sub( float32, float32 );
|
||||
float32 float32_mul( float32, float32 );
|
||||
float32 float32_div( float32, float32 );
|
||||
float32 float32_rem( float32, float32 );
|
||||
float32 float32_sqrt( float32 );
|
||||
flag float32_eq( float32, float32 );
|
||||
flag float32_le( float32, float32 );
|
||||
flag float32_lt( float32, float32 );
|
||||
flag float32_eq_signaling( float32, float32 );
|
||||
flag float32_le_quiet( float32, float32 );
|
||||
flag float32_lt_quiet( float32, float32 );
|
||||
flag float32_is_signaling_nan( float32 );
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE double-precision conversion routines.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
int float64_to_int32( float64 );
|
||||
int float64_to_int32_round_to_zero( float64 );
|
||||
long long float64_to_int64( float64 );
|
||||
long long float64_to_int64_round_to_zero( float64 );
|
||||
float32 float64_to_float32( float64 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 float64_to_floatx80( float64 );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 float64_to_float128( float64 );
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE double-precision operations.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
float64 float64_round_to_int( float64 );
|
||||
float64 float64_add( float64, float64 );
|
||||
float64 float64_sub( float64, float64 );
|
||||
float64 float64_mul( float64, float64 );
|
||||
float64 float64_div( float64, float64 );
|
||||
float64 float64_rem( float64, float64 );
|
||||
float64 float64_sqrt( float64 );
|
||||
flag float64_eq( float64, float64 );
|
||||
flag float64_le( float64, float64 );
|
||||
flag float64_lt( float64, float64 );
|
||||
flag float64_eq_signaling( float64, float64 );
|
||||
flag float64_le_quiet( float64, float64 );
|
||||
flag float64_lt_quiet( float64, float64 );
|
||||
flag float64_is_signaling_nan( float64 );
|
||||
|
||||
#ifdef FLOATX80
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE extended double-precision conversion routines.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
int floatx80_to_int32( floatx80 );
|
||||
int floatx80_to_int32_round_to_zero( floatx80 );
|
||||
long long floatx80_to_int64( floatx80 );
|
||||
long long floatx80_to_int64_round_to_zero( floatx80 );
|
||||
float32 floatx80_to_float32( floatx80 );
|
||||
float64 floatx80_to_float64( floatx80 );
|
||||
#ifdef FLOAT128
|
||||
float128 floatx80_to_float128( floatx80 );
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE extended double-precision rounding precision. Valid
|
||||
values are 32, 64, and 80.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
extern signed flag floatx80_rounding_precision;
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE extended double-precision operations.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
floatx80 floatx80_round_to_int( floatx80 );
|
||||
floatx80 floatx80_add( floatx80, floatx80 );
|
||||
floatx80 floatx80_sub( floatx80, floatx80 );
|
||||
floatx80 floatx80_mul( floatx80, floatx80 );
|
||||
floatx80 floatx80_div( floatx80, floatx80 );
|
||||
floatx80 floatx80_rem( floatx80, floatx80 );
|
||||
floatx80 floatx80_sqrt( floatx80 );
|
||||
flag floatx80_eq( floatx80, floatx80 );
|
||||
flag floatx80_le( floatx80, floatx80 );
|
||||
flag floatx80_lt( floatx80, floatx80 );
|
||||
flag floatx80_eq_signaling( floatx80, floatx80 );
|
||||
flag floatx80_le_quiet( floatx80, floatx80 );
|
||||
flag floatx80_lt_quiet( floatx80, floatx80 );
|
||||
flag floatx80_is_signaling_nan( floatx80 );
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef FLOAT128
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE quadruple-precision conversion routines.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
int float128_to_int32( float128 );
|
||||
int float128_to_int32_round_to_zero( float128 );
|
||||
long long float128_to_int64( float128 );
|
||||
long long float128_to_int64_round_to_zero( float128 );
|
||||
float32 float128_to_float32( float128 );
|
||||
float64 float128_to_float64( float128 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 float128_to_floatx80( float128 );
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Software IEC/IEEE quadruple-precision operations.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
float128 float128_round_to_int( float128 );
|
||||
float128 float128_add( float128, float128 );
|
||||
float128 float128_sub( float128, float128 );
|
||||
float128 float128_mul( float128, float128 );
|
||||
float128 float128_div( float128, float128 );
|
||||
float128 float128_rem( float128, float128 );
|
||||
float128 float128_sqrt( float128 );
|
||||
flag float128_eq( float128, float128 );
|
||||
flag float128_le( float128, float128 );
|
||||
flag float128_lt( float128, float128 );
|
||||
flag float128_eq_signaling( float128, float128 );
|
||||
flag float128_le_quiet( float128, float128 );
|
||||
flag float128_lt_quiet( float128, float128 );
|
||||
flag float128_is_signaling_nan( float128 );
|
||||
|
||||
#endif
|
||||
|
||||
115
lib/libc/arch/mips/gen/ieee.h
Normal file
115
lib/libc/arch/mips/gen/ieee.h
Normal file
@ -0,0 +1,115 @@
|
||||
/* $NetBSD: ieee.h,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This software was developed by the Computer Systems Engineering group
|
||||
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
|
||||
* contributed to Berkeley.
|
||||
*
|
||||
* All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Lawrence Berkeley Laboratory.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#)ieee.h 8.1 (Berkeley) 6/11/93
|
||||
*/
|
||||
|
||||
/*
|
||||
* ieee.h defines the machine-dependent layout of the machine's IEEE
|
||||
* floating point.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Define the number of bits in each fraction and exponent.
|
||||
*
|
||||
* k k+1
|
||||
* Note that 1.0 x 2 == 0.1 x 2 and that denorms are represented
|
||||
*
|
||||
* (-exp_bias+1)
|
||||
* as fractions that look like 0.fffff x 2 . This means that
|
||||
*
|
||||
* -126
|
||||
* the number 0.10000 x 2 , for instance, is the same as the normalized
|
||||
*
|
||||
* -127 -128
|
||||
* float 1.0 x 2 . Thus, to represent 2 , we need one leading zero
|
||||
*
|
||||
* -129
|
||||
* in the fraction; to represent 2 , we need two, and so on. This
|
||||
*
|
||||
* (-exp_bias-fracbits+1)
|
||||
* implies that the smallest denormalized number is 2
|
||||
*
|
||||
* for whichever format we are talking about: for single precision, for
|
||||
*
|
||||
* -126 -149
|
||||
* instance, we get .00000000000000000000001 x 2 , or 1.0 x 2 , and
|
||||
*
|
||||
* -149 == -127 - 23 + 1.
|
||||
*/
|
||||
#define SNG_EXPBITS 8
|
||||
#define SNG_FRACBITS 23
|
||||
|
||||
#define DBL_EXPBITS 11
|
||||
#define DBL_FRACBITS 52
|
||||
|
||||
struct ieee_single {
|
||||
u_int sng_frac:23;
|
||||
u_int sng_exponent:8;
|
||||
u_int sng_sign:1;
|
||||
};
|
||||
|
||||
struct ieee_double {
|
||||
u_int dbl_fracl;
|
||||
u_int dbl_frach:20;
|
||||
u_int dbl_exp:11;
|
||||
u_int dbl_sign:1;
|
||||
};
|
||||
|
||||
/*
|
||||
* Floats whose exponent is in [1..INFNAN) (of whatever type) are
|
||||
* `normal'. Floats whose exponent is INFNAN are either Inf or NaN.
|
||||
* Floats whose exponent is zero are either zero (iff all fraction
|
||||
* bits are zero) or subnormal values.
|
||||
*
|
||||
* A NaN is a `signalling NaN' if its QUIETNAN bit is clear in its
|
||||
* high fraction; if the bit is set, it is a `quiet NaN'.
|
||||
*/
|
||||
#define SNG_EXP_INFNAN 255
|
||||
#define DBL_EXP_INFNAN 2047
|
||||
|
||||
/*
|
||||
* Exponent biases.
|
||||
*/
|
||||
#define SNG_EXP_BIAS 127
|
||||
#define DBL_EXP_BIAS 1023
|
||||
48
lib/libc/arch/mips/gen/sf_fabs.c
Normal file
48
lib/libc/arch/mips/gen/sf_fabs.c
Normal file
@ -0,0 +1,48 @@
|
||||
/* $NetBSD: sf_fabs.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996 Mark Brinicombe
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by Mark Brinicombe
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* fabs(x) returns the absolute value of x.
|
||||
*/
|
||||
|
||||
#ifdef __STDC__
|
||||
double fabs(double x)
|
||||
#else
|
||||
double fabs(x)
|
||||
double x;
|
||||
#endif
|
||||
{
|
||||
if (x < 0)
|
||||
x = -x;
|
||||
return(x);
|
||||
}
|
||||
76
lib/libc/arch/mips/gen/sf_flt_rounds.c
Normal file
76
lib/libc/arch/mips/gen/sf_flt_rounds.c
Normal file
@ -0,0 +1,76 @@
|
||||
/* $NetBSD: sf_flt_rounds.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996 Mark Brinicombe
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by Mark Brinicombe
|
||||
* for the NetBSD Project.
|
||||
* 4. The name of the author may not be used to endorse or promote products
|
||||
* derived from this software without specific prior written permission
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <ieeefp.h>
|
||||
|
||||
static const int map[] = {
|
||||
1, /* round to nearest */
|
||||
2, /* round to positive infinity */
|
||||
3, /* round to negative infinity */
|
||||
0 /* round to zero */
|
||||
};
|
||||
|
||||
/*
|
||||
* Return the current FP rounding mode
|
||||
*
|
||||
* Returns:
|
||||
* 0 - round to zero
|
||||
* 1 - round to nearest
|
||||
* 2 - round to postive infinity
|
||||
* 3 - round to negative infinity
|
||||
*
|
||||
* ok all we need to do is get the current FP rounding mode
|
||||
* index our map table and return the appropriate value.
|
||||
*
|
||||
* HOWEVER:
|
||||
* The ARM FPA codes the rounding mode into the actual FP instructions
|
||||
* so there is no such thing as a global rounding mode.
|
||||
* The default is round to nearest if rounding is not explictly specified.
|
||||
* FP instructions generated by GCC will not explicitly specify a rounding
|
||||
* mode.
|
||||
*
|
||||
* So the best we can do it to return the rounding mode FP instructions
|
||||
* use if rounding is not specified which is round to nearest.
|
||||
*
|
||||
* This could change in the future with new floating point emulators or
|
||||
* soft float FP libraries.
|
||||
*/
|
||||
|
||||
int __flt_rounds(void);
|
||||
|
||||
int
|
||||
__flt_rounds()
|
||||
{
|
||||
return(map[fpgetround()]);
|
||||
}
|
||||
14
lib/libc/arch/mips/gen/sf_fpgetmask.c
Normal file
14
lib/libc/arch/mips/gen/sf_fpgetmask.c
Normal file
@ -0,0 +1,14 @@
|
||||
/* $NetBSD: sf_fpgetmask.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Written by J.T. Conklin, Apr 11, 1995
|
||||
* Public domain.
|
||||
*/
|
||||
|
||||
#include <ieeefp.h>
|
||||
|
||||
fp_except
|
||||
fpgetmask()
|
||||
{
|
||||
return sfp_getmask();
|
||||
}
|
||||
64
lib/libc/arch/mips/gen/sf_fpgetround.c
Normal file
64
lib/libc/arch/mips/gen/sf_fpgetround.c
Normal file
@ -0,0 +1,64 @@
|
||||
/* $NetBSD: sf_fpgetround.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996 Mark Brinicombe
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by Mark Brinicombe
|
||||
* for the NetBSD Project.
|
||||
* 4. The name of the author may not be used to endorse or promote products
|
||||
* derived from this software without specific prior written permission
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <ieeefp.h>
|
||||
|
||||
/*
|
||||
* Return the current FP rounding mode
|
||||
*
|
||||
* ok all we need to do is return the current FP rounding mode
|
||||
*
|
||||
* HOWEVER:
|
||||
* The ARM FPA codes the rounding mode into the actual FP instructions
|
||||
* so there is no such thing as a global rounding mode.
|
||||
* The default is round to nearest if rounding is not explictly specified.
|
||||
* FP instructions generated by GCC will not explicitly specify a rounding
|
||||
* mode.
|
||||
*
|
||||
* So the best we can do it to return the rounding mode FP instructions
|
||||
* use if rounding is not specified which is round to nearest.
|
||||
*
|
||||
* This could change in the future with new floating point emulators or
|
||||
* soft float FP libraries.
|
||||
*/
|
||||
|
||||
fp_rnd
|
||||
fpgetround()
|
||||
{
|
||||
#ifdef SOFT_FLOAT
|
||||
return(sfp_getround());
|
||||
#else
|
||||
return(FP_RN);
|
||||
#endif
|
||||
}
|
||||
14
lib/libc/arch/mips/gen/sf_fpgetsticky.c
Normal file
14
lib/libc/arch/mips/gen/sf_fpgetsticky.c
Normal file
@ -0,0 +1,14 @@
|
||||
/* $NetBSD: sf_fpgetsticky.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Written by J.T. Conklin, Apr 11, 1995
|
||||
* Public domain.
|
||||
*/
|
||||
|
||||
#include <ieeefp.h>
|
||||
|
||||
fp_except
|
||||
fpgetsticky()
|
||||
{
|
||||
return sfp_getsticky();
|
||||
}
|
||||
20
lib/libc/arch/mips/gen/sf_fpsetmask.c
Normal file
20
lib/libc/arch/mips/gen/sf_fpsetmask.c
Normal file
@ -0,0 +1,20 @@
|
||||
/* $NetBSD: sf_fpsetmask.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Written by J.T. Conklin, Apr 11, 1995
|
||||
* Public domain.
|
||||
*/
|
||||
|
||||
#include <ieeefp.h>
|
||||
|
||||
fp_except
|
||||
fpsetmask(mask)
|
||||
fp_except mask;
|
||||
{
|
||||
fp_except old;
|
||||
fp_except new;
|
||||
|
||||
old = sfp_getmask();
|
||||
sfp_setmask(mask);
|
||||
return old;
|
||||
}
|
||||
71
lib/libc/arch/mips/gen/sf_fpsetround.c
Normal file
71
lib/libc/arch/mips/gen/sf_fpsetround.c
Normal file
@ -0,0 +1,71 @@
|
||||
/* $NetBSD: sf_fpsetround.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996 Mark Brinicombe
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by Mark Brinicombe
|
||||
* for the NetBSD Project.
|
||||
* 4. The name of the author may not be used to endorse or promote products
|
||||
* derived from this software without specific prior written permission
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <ieeefp.h>
|
||||
|
||||
void sfp_setround __P((fp_rnd));
|
||||
|
||||
/*
|
||||
* Return the current FP rounding mode
|
||||
*
|
||||
* ok all we need to do is return the current FP rounding mode
|
||||
*
|
||||
* HOWEVER:
|
||||
* The ARM FPA codes the rounding mode into the actual FP instructions
|
||||
* so there is no such thing as a global rounding mode.
|
||||
* The default is round to nearest if rounding is not explictly specified.
|
||||
* FP instructions generated by GCC will not explicitly specify a rounding
|
||||
* mode.
|
||||
*
|
||||
* All we can do is abort
|
||||
*
|
||||
* This could change in the future with new floating point emulators or
|
||||
* soft float FP libraries.
|
||||
*/
|
||||
|
||||
fp_rnd
|
||||
fpsetround(rnd_dir)
|
||||
fp_rnd rnd_dir;
|
||||
{
|
||||
fp_rnd old_rnd;
|
||||
|
||||
old_rnd = fpgetround();
|
||||
|
||||
#ifdef SOFTFLOAT
|
||||
sfp_setround(rnd_dir);
|
||||
#else
|
||||
abort();
|
||||
#endif
|
||||
return(old_rnd);
|
||||
}
|
||||
19
lib/libc/arch/mips/gen/sf_fpsetsticky.c
Normal file
19
lib/libc/arch/mips/gen/sf_fpsetsticky.c
Normal file
@ -0,0 +1,19 @@
|
||||
/* $NetBSD: sf_fpsetsticky.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Written by J.T. Conklin, Apr 11, 1995
|
||||
* Public domain.
|
||||
*/
|
||||
|
||||
#include <ieeefp.h>
|
||||
|
||||
fp_except
|
||||
fpsetsticky(sticky)
|
||||
fp_except sticky;
|
||||
{
|
||||
fp_except old;
|
||||
|
||||
old = sfp_getsticky();
|
||||
sfp_setsticky(sticky);
|
||||
return old;
|
||||
}
|
||||
61
lib/libc/arch/mips/gen/sf_isinf.c
Normal file
61
lib/libc/arch/mips/gen/sf_isinf.c
Normal file
@ -0,0 +1,61 @@
|
||||
/* $NetBSD: sf_isinf.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996 Mark Brinicombe
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by Mark Brinicombe
|
||||
* for the NetBSD project.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "namespace.h"
|
||||
#include <sys/types.h>
|
||||
#include "ieee.h"
|
||||
#include <math.h>
|
||||
|
||||
#ifdef __weak_alias
|
||||
__weak_alias(isnan,_isnan);
|
||||
__weak_alias(isinf,_isinf);
|
||||
#endif
|
||||
|
||||
int
|
||||
isnan(d)
|
||||
double d;
|
||||
{
|
||||
register struct ieee_double *p = (struct ieee_double *)&d;
|
||||
|
||||
return(p->dbl_exp == DBL_EXP_INFNAN && (p->dbl_frach || p->dbl_fracl));
|
||||
}
|
||||
|
||||
int
|
||||
isinf(d)
|
||||
double d;
|
||||
{
|
||||
register struct ieee_double *p = (struct ieee_double *)&d;
|
||||
|
||||
return(p->dbl_exp == DBL_EXP_INFNAN && !p->dbl_frach && !p->dbl_fracl);
|
||||
}
|
||||
155
lib/libc/arch/mips/gen/sf_ldexp.c
Normal file
155
lib/libc/arch/mips/gen/sf_ldexp.c
Normal file
@ -0,0 +1,155 @@
|
||||
/* $NetBSD: sf_ldexp.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This software was developed by the Computer Systems Engineering group
|
||||
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
|
||||
* contributed to Berkeley.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* from: ldexp.c,v 1.1 1993/10/07 00:21:36 cgd Exp $
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
#if defined(LIBC_SCCS) && !defined(lint)
|
||||
#if 0
|
||||
static const char sccsid[] = "@(#)ldexp.c 8.1 (Berkeley) 6/4/93";
|
||||
#else
|
||||
__RCSID("$NetBSD: sf_ldexp.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $");
|
||||
#endif
|
||||
#endif /* LIBC_SCCS and not lint */
|
||||
|
||||
#include <math.h>
|
||||
#include <sys/types.h>
|
||||
#include "ieee.h"
|
||||
#include <errno.h>
|
||||
|
||||
/*
|
||||
* double ldexp(double val, int exp)
|
||||
* returns: val * (2**exp)
|
||||
*/
|
||||
double
|
||||
ldexp(val, exp)
|
||||
double val;
|
||||
int exp;
|
||||
{
|
||||
register int oldexp, newexp, mulexp;
|
||||
union doub {
|
||||
double v;
|
||||
struct ieee_double s;
|
||||
} u, mul;
|
||||
|
||||
/*
|
||||
* If input is zero, or no change, just return input.
|
||||
* Likewise, if input is Inf or NaN, just return it.
|
||||
*/
|
||||
u.v = val;
|
||||
oldexp = u.s.dbl_exp;
|
||||
if (val == 0 || exp == 0 || oldexp == DBL_EXP_INFNAN)
|
||||
return (val);
|
||||
|
||||
/*
|
||||
* Compute new exponent and check for over/under flow.
|
||||
* Underflow, unfortunately, could mean switching to denormal.
|
||||
* If result out of range, set ERANGE and return 0 if too small
|
||||
* or Inf if too big, with the same sign as the input value.
|
||||
*/
|
||||
newexp = oldexp + exp;
|
||||
if (newexp >= DBL_EXP_INFNAN) {
|
||||
/* u.s.dbl_sign = val < 0; -- already set */
|
||||
u.s.dbl_exp = DBL_EXP_INFNAN;
|
||||
u.s.dbl_frach = u.s.dbl_fracl = 0;
|
||||
errno = ERANGE;
|
||||
return (u.v); /* Inf */
|
||||
}
|
||||
if (newexp <= 0) {
|
||||
/*
|
||||
* The output number is either a denormal or underflows
|
||||
* (see comments in machine/ieee.h).
|
||||
*/
|
||||
if (newexp <= -DBL_FRACBITS) {
|
||||
/* u.s.dbl_sign = val < 0; -- already set */
|
||||
u.s.dbl_exp = 0;
|
||||
u.s.dbl_frach = u.s.dbl_fracl = 0;
|
||||
errno = ERANGE;
|
||||
return (u.v); /* zero */
|
||||
}
|
||||
/*
|
||||
* We are going to produce a denorm. Our `exp' argument
|
||||
* might be as small as -2097, and we cannot compute
|
||||
* 2^-2097, so we may have to do this as many as three
|
||||
* steps (not just two, as for positive `exp's below).
|
||||
*/
|
||||
mul.v = 0;
|
||||
while (exp <= -DBL_EXP_BIAS) {
|
||||
mul.s.dbl_exp = 1;
|
||||
val *= mul.v;
|
||||
exp += DBL_EXP_BIAS - 1;
|
||||
}
|
||||
mul.s.dbl_exp = exp + DBL_EXP_BIAS;
|
||||
val *= mul.v;
|
||||
return (val);
|
||||
}
|
||||
|
||||
/*
|
||||
* Newexp is positive.
|
||||
*
|
||||
* If oldexp is zero, we are starting with a denorm, and simply
|
||||
* adjusting the exponent will produce bogus answers. We need
|
||||
* to fix that first.
|
||||
*/
|
||||
if (oldexp == 0) {
|
||||
/*
|
||||
* Multiply by 2^mulexp to make the number normalizable.
|
||||
* We cannot multiply by more than 2^1023, but `exp'
|
||||
* argument might be as large as 2046. A single
|
||||
* adjustment, however, will normalize the number even
|
||||
* for huge `exp's, and then we can use exponent
|
||||
* arithmetic just as for normal `double's.
|
||||
*/
|
||||
mulexp = exp <= DBL_EXP_BIAS ? exp : DBL_EXP_BIAS;
|
||||
mul.v = 0;
|
||||
mul.s.dbl_exp = mulexp + DBL_EXP_BIAS;
|
||||
val *= mul.v;
|
||||
if (mulexp == exp)
|
||||
return (val);
|
||||
u.v = val;
|
||||
newexp -= mulexp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Both oldexp and newexp are positive; just replace the
|
||||
* old exponent with the new one.
|
||||
*/
|
||||
u.s.dbl_exp = newexp;
|
||||
return (u.v);
|
||||
}
|
||||
104
lib/libc/arch/mips/gen/sf_modf.c
Normal file
104
lib/libc/arch/mips/gen/sf_modf.c
Normal file
@ -0,0 +1,104 @@
|
||||
/* $NetBSD: sf_modf.c,v 1.1.1.1 1999/09/16 12:18:26 takemura Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1994, 1995 Carnegie-Mellon University.
|
||||
* All rights reserved.
|
||||
*
|
||||
* Author: Chris G. Demetriou
|
||||
*
|
||||
* Permission to use, copy, modify and distribute this software and
|
||||
* its documentation is hereby granted, provided that both the copyright
|
||||
* notice and this permission notice appear in all copies of the
|
||||
* software, derivative works or modified versions, and any portions
|
||||
* thereof, and that both notices appear in supporting documentation.
|
||||
*
|
||||
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
|
||||
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
|
||||
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
|
||||
*
|
||||
* Carnegie Mellon requests users of this software to return to
|
||||
*
|
||||
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
|
||||
* School of Computer Science
|
||||
* Carnegie Mellon University
|
||||
* Pittsburgh PA 15213-3890
|
||||
*
|
||||
* any improvements or extensions that they make and grant Carnegie the
|
||||
* rights to redistribute these changes.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include "ieee.h"
|
||||
#include <errno.h>
|
||||
#include <math.h>
|
||||
|
||||
/*
|
||||
* double modf(double val, double *iptr)
|
||||
* returns: f and i such that |f| < 1.0, (f + i) = val, and
|
||||
* sign(f) == sign(i) == sign(val).
|
||||
*
|
||||
* Beware signedness when doing subtraction, and also operand size!
|
||||
*/
|
||||
double
|
||||
modf(val, iptr)
|
||||
double val, *iptr;
|
||||
{
|
||||
union doub {
|
||||
double v;
|
||||
struct ieee_double s;
|
||||
} u, v;
|
||||
u_int64_t frac;
|
||||
|
||||
/*
|
||||
* If input is Inf or NaN, return it and leave i alone.
|
||||
*/
|
||||
u.v = val;
|
||||
if (u.s.dbl_exp == DBL_EXP_INFNAN)
|
||||
return (u.v);
|
||||
|
||||
/*
|
||||
* If input can't have a fractional part, return
|
||||
* (appropriately signed) zero, and make i be the input.
|
||||
*/
|
||||
if ((int)u.s.dbl_exp - DBL_EXP_BIAS > DBL_FRACBITS - 1) {
|
||||
*iptr = u.v;
|
||||
v.v = 0.0;
|
||||
v.s.dbl_sign = u.s.dbl_sign;
|
||||
return (v.v);
|
||||
}
|
||||
|
||||
/*
|
||||
* If |input| < 1.0, return it, and set i to the appropriately
|
||||
* signed zero.
|
||||
*/
|
||||
if (u.s.dbl_exp < DBL_EXP_BIAS) {
|
||||
v.v = 0.0;
|
||||
v.s.dbl_sign = u.s.dbl_sign;
|
||||
*iptr = v.v;
|
||||
return (u.v);
|
||||
}
|
||||
|
||||
/*
|
||||
* There can be a fractional part of the input.
|
||||
* If you look at the math involved for a few seconds, it's
|
||||
* plain to see that the integral part is the input, with the
|
||||
* low (DBL_FRACBITS - (exponent - DBL_EXP_BIAS)) bits zeroed,
|
||||
* the the fractional part is the part with the rest of the
|
||||
* bits zeroed. Just zeroing the high bits to get the
|
||||
* fractional part would yield a fraction in need of
|
||||
* normalization. Therefore, we take the easy way out, and
|
||||
* just use subtraction to get the fractional part.
|
||||
*/
|
||||
v.v = u.v;
|
||||
/* Zero the low bits of the fraction, the sleazy way. */
|
||||
frac = ((u_int64_t)v.s.dbl_frach << 32) + v.s.dbl_fracl;
|
||||
frac >>= DBL_FRACBITS - (u.s.dbl_exp - DBL_EXP_BIAS);
|
||||
frac <<= DBL_FRACBITS - (u.s.dbl_exp - DBL_EXP_BIAS);
|
||||
v.s.dbl_fracl = frac & 0xffffffff;
|
||||
v.s.dbl_frach = frac >> 32;
|
||||
*iptr = v.v;
|
||||
|
||||
u.v -= v.v;
|
||||
u.s.dbl_sign = v.s.dbl_sign;
|
||||
return (u.v);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user