diff options
493 files changed, 27793 insertions, 901 deletions
diff --git a/.clang-tidy b/.clang-tidy index dba2e15d..a06e38d7 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -1,10 +1,12 @@ --- -Checks: 'clang-diagnostic-*,clang-analyzer-*' -WarningsAsErrors: '' +Checks: "clang-diagnostic-*,clang-analyzer-*,-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling" +WarningsAsErrors: "" HeaderFileExtensions: - h ImplementationFileExtensions: - c -SystemHeaders: false +SystemHeaders: false +CheckOptions: + - key: clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling + value: "0" ... - @@ -1,2 +1,4 @@ -obj-y += true/ +obj-y += echo/ obj-y += false/ +obj-y += gzip/ +obj-y += true/ diff --git a/bin/echo/Kbuild b/bin/echo/Kbuild new file mode 100644 index 00000000..919423fd --- /dev/null +++ b/bin/echo/Kbuild @@ -0,0 +1,5 @@ +bin-y := echo + +libs-y += $(srctree)/lib/libc/libc.a + +obj-y += echo.o diff --git a/bin/echo/echo b/bin/echo/echo Binary files differnew file mode 100755 index 00000000..c9bbb0df --- /dev/null +++ b/bin/echo/echo diff --git a/bin/echo/echo.c b/bin/echo/echo.c new file mode 100644 index 00000000..b8e5bbe0 --- /dev/null +++ b/bin/echo/echo.c @@ -0,0 +1,30 @@ +#include <string.h> +#include <unistd.h> +#include <sys/uio.h> + +int main(int argc, char **argv) +{ + if (argc <= 1) + return 0; + + struct iovec iov[2 * argc - 2]; + int iovcnt = 0; + + for (int i = 1; i < argc; i++) { + iov[iovcnt].iov_base = argv[i]; + iov[iovcnt].iov_len = strlen(argv[i]); + iovcnt++; + + if (i < argc - 1) { + iov[iovcnt].iov_base = " "; + iov[iovcnt].iov_len = 1; + iovcnt++; + } + } + + iov[iovcnt].iov_base = "\n"; + iov[iovcnt].iov_len = 1; + iovcnt++; + + return writev(STDOUT_FILENO, iov, iovcnt) < 0 ? 1 : 0; +} diff --git a/bin/gzip/.gitignore b/bin/gzip/.gitignore new file mode 100644 index 00000000..b665e3f0 --- /dev/null +++ b/bin/gzip/.gitignore @@ -0,0 +1,3 @@ +gunzip +gzip +zcat diff --git a/bin/gzip/COPYING b/bin/gzip/COPYING new file mode 100644 index 00000000..a43ea212 --- /dev/null +++ b/bin/gzip/COPYING @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 675 Mass Ave, Cambridge, MA 02139, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) 19yy <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/bin/gzip/Kbuild b/bin/gzip/Kbuild new file mode 100644 index 00000000..561b198a --- /dev/null +++ b/bin/gzip/Kbuild @@ -0,0 +1,8 @@ +bin-y := gzip +obj-y := gzip.o util.o unzip.o inflate.o + +libs-y += $(srctree)/lib/libc/libc.a +libs-y += $(srctree)/lib/libm/libm.a + +obj-$(CONFIG_ZIP) += zip.o deflate.o trees.o bits.o +cflags-$(CONFIG_ZIP) += -DSUPPORT_ZIP diff --git a/bin/gzip/README b/bin/gzip/README new file mode 100644 index 00000000..fdd73114 --- /dev/null +++ b/bin/gzip/README @@ -0,0 +1,144 @@ +This is the file README for the gzip distribution, version 1.2.4. + +gzip (GNU zip) is a compression utility designed to be a replacement +for 'compress'. Its main advantages over compress are much better +compression and freedom from patented algorithms. The GNU Project +uses it as the standard compression program for its system. + +gzip currently uses by default the LZ77 algorithm used in zip 1.9 (the +portable pkzip compatible archiver). The gzip format was however +designed to accommodate several compression algorithms. See below +for a comparison of zip and gzip. + +gunzip can currently decompress files created by gzip, compress or +pack. The detection of the input format is automatic. For the +gzip format, gunzip checks a 32 bit CRC. For pack, gunzip checks the +uncompressed length. The 'compress' format was not designed to allow +consistency checks. However gunzip is sometimes able to detect a bad +.Z file because there is some redundancy in the .Z compression format. +If you get an error when uncompressing a .Z file, do not assume that +the .Z file is correct simply because the standard uncompress does not +complain. This generally means that the standard uncompress does not +check its input, and happily generates garbage output. + +gzip produces files with a .gz extension. Previous versions of gzip +used the .z extension, which was already used by the 'pack' +Huffman encoder. gunzip is able to decompress .z files (packed +or gzip'ed). + +Several planned features are not yet supported (see the file TODO). +See the file NEWS for a summary of changes since 0.5. See the file +INSTALL for installation instructions. Some answers to frequently +asked questions are given in the file INSTALL, please read it. (In +particular, please don't ask me once more for an /etc/magic entry.) + +WARNING: on several systems, compiler bugs cause gzip to fail, in +particular when optimization options are on. See the section "Special +targets" at the end of the INSTALL file for a list of known problems. +For all machines, use "make check" to check that gzip was compiled +correctly. Try compiling gzip without any optimization if you have a +problem. + +Please send all comments and bug reports by electronic mail to: + Jean-loup Gailly <jloup@chorus.fr> + +or, if this fails, to bug-gnu-utils@prep.ai.mit.edu. +Bug reports should ideally include: + + * The complete output of "gzip -V" (or the contents of revision.h + if you can't get gzip to compile) + * The hardware and operating system (try "uname -a") + * The compiler used to compile (if it is gcc, use "gcc -v") + * A description of the bug behavior + * The input to gzip, that triggered the bug + +If you send me patches for machines I don't have access to, please test them +very carefully. gzip is used for backups, it must be extremely reliable. + +The package crypt++.el is highly recommended to manipulate gzip'ed +file from emacs. It recognizes automatically encrypted and compressed +files when they are first visited or written. It is available via +anonymous ftp to roebling.poly.edu [128.238.5.31] in /pub/crypt++.el. +The same directory contains also patches to dired, ange-ftp and info. +GNU tar 1.11.2 has a -z option to invoke directly gzip, so you don't have to +patch it. The package ftp.uu.net:/languages/emacs-lisp/misc/jka-compr19.el.Z +also supports gzip'ed files. + +The znew and gzexe shell scripts provided with gzip benefit from +(but do not require) the cpmod utility to transfer file attributes. +It is available by anonymous ftp on gatekeeper.dec.com in +/.0/usenet/comp.sources.unix/volume11/cpmod.Z. + +The sample programs zread.c, sub.c and add.c in subdirectory sample +are provided as examples of useful complements to gzip. Read the +comments inside each source file. The perl script ztouch is also +provided as example (not installed by default since it relies on perl). + + +gzip is free software, you can redistribute it and/or modify it under +the terms of the GNU General Public License, a copy of which is +provided under the name COPYING. The latest version of gzip are always +available by ftp in prep.ai.mit.edu:/pub/gnu, or in any of the prep +mirror sites: + +- sources in gzip-*.tar (or .shar or .tar.gz). +- Solaris 2 executables in sparc-sun-solaris2/gzip-binaries-*.tar +- MSDOS lha self-extracting exe in gzip-msdos-*.exe. Once extracted, + copy gzip.exe to gunzip.exe and zcat.exe, or use "gzip -d" to decompress. + gzip386.exe runs much faster but only on 386 and above; it is compiled with + djgpp 1.10 available in directory omnigate.clarkson.edu:/pub/msdos/djgpp. + +A VMS executable is available in ftp.spc.edu:[.macro32.savesets]gzip-1-*.zip +(use [.macro32]unzip.exe to extract). A PRIMOS executable is available +in ftp.lysator.liu.se:/pub/primos/run/gzip.run. +OS/2 executables (16 and 32 bits versions) are available in +ftp.tu-muenchen.de:/pub/comp/os/os2/archiver/gz*-[16,32].zip + +Some ftp servers can automatically make a tar.Z from a tar file. If +you are getting gzip for the first time, you can ask for a tar.Z file +instead of the much larger tar file. + +Many thanks to those who provided me with bug reports and feedback. +See the files THANKS and ChangeLog for more details. + + + Note about zip vs. gzip: + +The name 'gzip' was a very unfortunate choice, because zip and gzip +are two really different programs, although the actual compression and +decompression sources were written by the same persons. A different +name should have been used for gzip, but it is too late to change now. + +zip is an archiver: it compresses several files into a single archive +file. gzip is a simple compressor: each file is compressed separately. +Both share the same compression and decompression code for the +'deflate' method. unzip can also decompress old zip archives +(implode, shrink and reduce methods). gunzip can also decompress files +created by compress and pack. zip 1.9 and gzip do not support +compression methods other than deflation. (zip 1.0 supports shrink and +implode). Better compression methods may be added in future versions +of gzip. zip will always stick to absolute compatibility with pkzip, +it is thus constrained by PKWare, which is a commercial company. The +gzip header format is deliberately different from that of pkzip to +avoid such a constraint. + +On Unix, gzip is mostly useful in combination with tar. GNU tar +1.11.2 has a -z option to invoke gzip automatically. "tar -z" +compresses better than zip, since gzip can then take advantage of +redundancy between distinct files. The drawback is that you must +scan the whole tar.gz file in order to extract a single file near +the end; unzip can directly seek to the end of the zip file. There +is no overhead when you extract the whole archive anyway. +If a member of a .zip archive is damaged, other files can still +be recovered. If a .tar.gz file is damaged, files beyond the failure +point cannot be recovered. (Future versions of gzip will have +error recovery features.) + +gzip and gunzip are distributed as a single program. zip and unzip +are, for historical reasons, two separate programs, although the +authors of these two programs work closely together in the info-zip +team. zip and unzip are not associated with the GNU project. +The sources are available by ftp in + + oak.oakland.edu:/pub/misc/unix/zip19p1.zip + oak.oakland.edu:/pub/misc/unix/unz50p1.tar-z diff --git a/bin/gzip/bits.c b/bin/gzip/bits.c new file mode 100644 index 00000000..a3d31fbd --- /dev/null +++ b/bin/gzip/bits.c @@ -0,0 +1,197 @@ +/* bits.c -- output variable-length bit strings + * Copyright (C) 1992-1993 Jean-loup Gailly + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +/* + * PURPOSE + * + * Output variable-length bit strings. Compression can be done + * to a file or to memory. (The latter is not supported in this version.) + * + * DISCUSSION + * + * The PKZIP "deflate" file format interprets compressed file data + * as a sequence of bits. Multi-bit strings in the file may cross + * byte boundaries without restriction. + * + * The first bit of each byte is the low-order bit. + * + * The routines in this file allow a variable-length bit value to + * be output right-to-left (useful for literal values). For + * left-to-right output (useful for code strings from the tree routines), + * the bits must have been reversed first with bi_reverse(). + * + * For in-memory compression, the compressed bit stream goes directly + * into the requested output buffer. The input data is read in blocks + * by the mem_read() function. The buffer is limited to 64K on 16 bit + * machines. + * + * INTERFACE + * + * void bi_init (FILE *zipfile) + * Initialize the bit string routines. + * + * void send_bits (int value, int length) + * Write out a bit string, taking the source bits right to + * left. + * + * int bi_reverse (int value, int length) + * Reverse the bits of a bit string, taking the source bits left to + * right and emitting them right to left. + * + * void bi_windup (void) + * Write out any remaining bits in an incomplete byte. + * + * void copy_block(char *buf, unsigned len, int header) + * Copy a stored block to the zip file, storing first the length and + * its one's complement if requested. + * + */ + +#include "tailor.h" +#include "gzip.h" + +#ifdef DEBUG +#include <stdio.h> +#endif + +#ifdef RCSID +static char rcsid[] = "$Id: bits.c,v 1.1 2002/08/18 00:59:21 hpa Exp $"; +#endif + +/* =========================================================================== + * Local data used by the "bit string" routines. + */ + +local file_t zfile; /* output gzip file */ + +local unsigned short bi_buf; +/* Output buffer. bits are inserted starting at the bottom (least significant + * bits). + */ + +#define Buf_size (8 * 2 * sizeof(char)) +/* Number of bits used within bi_buf. (bi_buf might be implemented on + * more than 16 bits on some systems.) + */ + +local int bi_valid; +/* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + +int(*read_buf) OF((char *buf, unsigned size)); +/* Current input function. Set to mem_read for in-memory compression */ + +#ifdef DEBUG +ulg bits_sent; /* bit length of the compressed data */ +#endif + +/* =========================================================================== + * Initialize the bit string routines. + */ +void bi_init(zipfile) file_t zipfile; /* output zip file, NO_FILE for in-memory + compression */ +{ + zfile = zipfile; + bi_buf = 0; + bi_valid = 0; +#ifdef DEBUG + bits_sent = 0L; +#endif + + /* Set the defaults for file compression. They are set by memcompress + * for in-memory compression. + */ + if (zfile != NO_FILE) { + read_buf = file_read; + } +} + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +void send_bits(value, length) int value; /* value to send */ +int length; /* number of bits */ +{ +#ifdef DEBUG + Tracev((stderr, " l %2d v %4x ", length, value)); + Assert(length > 0 && length <= 15, "invalid length"); + bits_sent += (ulg)length; +#endif + /* If not enough room in bi_buf, use (valid) bits from bi_buf and + * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) + * unused bits in value. + */ + if (bi_valid > (int)Buf_size - length) { + bi_buf |= (value << bi_valid); + put_short(bi_buf); + bi_buf = (ush)value >> (Buf_size - bi_valid); + bi_valid += length - Buf_size; + } else { + bi_buf |= value << bi_valid; + bi_valid += length; + } +} + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +unsigned bi_reverse(code, len) +unsigned code; /* the value to invert */ +int len; /* its bit length */ +{ + register unsigned res = 0; + do { + res |= code & 1; + code >>= 1, res <<= 1; + } while (--len > 0); + return res >> 1; +} + +/* =========================================================================== + * Write out any remaining bits in an incomplete byte. + */ +void bi_windup() +{ + if (bi_valid > 8) { + put_short(bi_buf); + } else if (bi_valid > 0) { + put_byte(bi_buf); + } + bi_buf = 0; + bi_valid = 0; +#ifdef DEBUG + bits_sent = (bits_sent + 7) & ~7; +#endif +} + +/* =========================================================================== + * Copy a stored block to the zip file, storing first the length and its + * one's complement if requested. + */ +void copy_block(buf, len, header) char *buf; /* the input data */ +unsigned len; /* its length */ +int header; /* true if block header must be written */ +{ + bi_windup(); /* align on byte boundary */ + + if (header) { + put_short((ush)len); + put_short((ush)~len); +#ifdef DEBUG + bits_sent += 2 * 16; +#endif + } +#ifdef DEBUG + bits_sent += (ulg)len << 3; +#endif + while (len--) { + put_byte(*buf++); + } +} diff --git a/bin/gzip/deflate.c b/bin/gzip/deflate.c new file mode 100644 index 00000000..61e4d92b --- /dev/null +++ b/bin/gzip/deflate.c @@ -0,0 +1,797 @@ +/* deflate.c -- compress data using the deflation algorithm + * Copyright (C) 1992-1993 Jean-loup Gailly + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +/* + * PURPOSE + * + * Identify new text as repetitions of old text within a fixed- + * length sliding window trailing behind the new text. + * + * DISCUSSION + * + * The "deflation" process depends on being able to identify portions + * of the input text which are identical to earlier input (within a + * sliding window trailing behind the input currently being processed). + * + * The most straightforward technique turns out to be the fastest for + * most input files: try all possible matches and select the longest. + * The key feature of this algorithm is that insertions into the string + * dictionary are very simple and thus fast, and deletions are avoided + * completely. Insertions are performed at each input character, whereas + * string matches are performed only when the previous match ends. So it + * is preferable to spend more time in matches to allow very fast string + * insertions and avoid deletions. The matching algorithm for small + * strings is inspired from that of Rabin & Karp. A brute force approach + * is used to find longer strings when a small match has been found. + * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze + * (by Leonid Broukhis). + * A previous version of this file used a more sophisticated algorithm + * (by Fiala and Greene) which is guaranteed to run in linear amortized + * time, but has a larger average cost, uses more memory and is patented. + * However the F&G algorithm may be faster for some highly redundant + * files if the parameter max_chain_length (described below) is too large. + * + * ACKNOWLEDGEMENTS + * + * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and + * I found it in 'freeze' written by Leonid Broukhis. + * Thanks to many info-zippers for bug reports and testing. + * + * REFERENCES + * + * APPNOTE.TXT documentation file in PKZIP 1.93a distribution. + * + * A description of the Rabin and Karp algorithm is given in the book + * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. + * + * Fiala,E.R., and Greene,D.H. + * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 + * + * INTERFACE + * + * void lm_init (int pack_level, ush *flags) + * Initialize the "longest match" routines for a new file + * + * ulg deflate (void) + * Processes a new input file and return its compressed length. Sets + * the compressed length, crc, deflate flags and internal file + * attributes. + */ + +#include <stdio.h> + +#include "tailor.h" +#include "gzip.h" + +#ifdef RCSID +static char rcsid[] = "$Id: deflate.c,v 1.1 2002/08/18 00:59:21 hpa Exp $"; +#endif + +/* =========================================================================== + * Configuration parameters + */ + +/* Compile with MEDIUM_MEM to reduce the memory requirements or + * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the + * entire input file can be held in memory (not possible on 16 bit systems). + * Warning: defining these symbols affects HASH_BITS (see below) and thus + * affects the compression ratio. The compressed output + * is still correct, and might even be smaller in some cases. + */ + +#ifdef SMALL_MEM +#define HASH_BITS 13 /* Number of bits used to hash strings */ +#endif +#ifdef MEDIUM_MEM +#define HASH_BITS 14 +#endif +#ifndef HASH_BITS +#define HASH_BITS 15 +/* For portability to 16 bit machines, do not use values above 15. */ +#endif + +/* To save space (see unlzw.c), we overlay prev+head with tab_prefix and + * window with tab_suffix. Check that we can do this: + */ +#if (WSIZE << 1) > (1 << BITS) +error : cannot overlay window with tab_suffix and prev with tab_prefix0 +#endif +#if HASH_BITS > BITS - 1 + error + : cannot overlay head with tab_prefix1 +#endif + +#define HASH_SIZE (unsigned)(1 << HASH_BITS) +#define HASH_MASK (HASH_SIZE - 1) +#define WMASK (WSIZE - 1) +/* HASH_SIZE and WSIZE must be powers of two */ + +#define NIL 0 +/* Tail of hash chains */ + +#define FAST 4 +#define SLOW 2 +/* speed options for the general purpose bit flag */ + +#ifndef TOO_FAR +#define TOO_FAR 4096 +#endif + /* Matches of length 3 are discarded if their distance exceeds TOO_FAR + */ + + /* =========================================================================== + * Local data used by the "longest match" routines. + */ + + typedef ush Pos; +typedef unsigned IPos; +/* A Pos is an index in the character window. We use short instead of int to + * save space in the various tables. IPos is used only for parameter passing. + */ + +/* DECLARE(uch, window, 2L*WSIZE); */ +/* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least WSIZE + * bytes. With this organization, matches are limited to a distance of + * WSIZE-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. Also, it limits + * the window size to 64K, which is quite useful on MSDOS. + * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would + * be less efficient). + */ + +/* DECLARE(Pos, prev, WSIZE); */ +/* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + +/* DECLARE(Pos, head, 1<<HASH_BITS); */ +/* Heads of the hash chains or NIL. */ + +ulg window_size = (ulg)2 * WSIZE; +/* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the + * input file length plus MIN_LOOKAHEAD. + */ + +long block_start; +/* window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + +local unsigned ins_h; /* hash index of string to be inserted */ + +#define H_SHIFT ((HASH_BITS + MIN_MATCH - 1) / MIN_MATCH) +/* Number of bits by which ins_h and del_h must be shifted at each + * input step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * H_SHIFT * MIN_MATCH >= HASH_BITS + */ + +unsigned int prev_length; +/* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + +unsigned strstart; /* start of string to insert */ +unsigned match_start; /* start of matching string */ +local int eofile; /* flag set at end of input file */ +local unsigned lookahead; /* number of valid bytes ahead in window */ + +unsigned max_chain_length; +/* To speed up deflation, hash chains are never searched beyond this length. + * A higher limit improves compression ratio but degrades the speed. + */ + +local unsigned int max_lazy_match; +/* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ +#define max_insert_length max_lazy_match +/* Insert new strings in the hash table only if the match length + * is not greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + +local int compr_level; +/* compression level (1..9) */ + +unsigned good_match; +/* Use a faster search when the previous match is longer than this */ + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ + +typedef struct config { + ush good_length; /* reduce lazy search above this match length */ + ush max_lazy; /* do not perform lazy search above this match length */ + ush nice_length; /* quit search above this match length */ + ush max_chain; +} config; + +#ifdef FULL_SEARCH +#define nice_match MAX_MATCH +#else +int nice_match; /* Stop searching when current match exceeds this */ +#endif + +local config configuration_table[10] = { + /* good lazy nice chain */ + /* 0 */ { 0, 0, 0, 0 }, /* store only */ + /* 1 */ { 4, 4, 8, 4 }, /* maximum speed, no lazy matches */ + /* 2 */ { 4, 5, 16, 8 }, + /* 3 */ { 4, 6, 32, 32 }, + + /* 4 */ { 4, 4, 16, 16 }, /* lazy matches */ + /* 5 */ { 8, 16, 32, 32 }, + /* 6 */ { 8, 16, 128, 128 }, + /* 7 */ { 8, 32, 128, 256 }, + /* 8 */ { 32, 128, 258, 1024 }, + /* 9 */ { 32, 258, 258, 4096 } +}; /* maximum compression */ + +/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 + * For deflate_fast() (levels <= 3) good is ignored and lazy has a different + * meaning. + */ + +#define EQUAL 0 +/* result of memcmp for equal strings */ + +/* =========================================================================== + * Prototypes for local functions. + */ +local void fill_window OF((void)); +local ulg deflate_fast OF((void)); + +int longest_match OF((IPos cur_match)); +#ifdef ASMV +void match_init OF((void)); /* asm code initialization */ +#endif + +#ifdef DEBUG +local void check_match OF((IPos start, IPos match, int length)); +#endif + +/* =========================================================================== + * Update a hash value with the given input byte + * IN assertion: all calls to to UPDATE_HASH are made with consecutive + * input characters, so that a running hash key can be computed from the + * previous key instead of complete recalculation each time. + */ +#define UPDATE_HASH(h, c) (h = (((h) << H_SHIFT) ^ (c)) & HASH_MASK) + +/* =========================================================================== + * Insert string s in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + * IN assertion: all calls to to INSERT_STRING are made with consecutive + * input characters and the first MIN_MATCH bytes of s are valid + * (except for the last MIN_MATCH-1 bytes of the input file). + */ +#define INSERT_STRING(s, match_head) \ + (UPDATE_HASH(ins_h, window[(s) + MIN_MATCH - 1]), \ + prev[(s) & WMASK] = match_head = head[ins_h], head[ins_h] = (s)) + +/* =========================================================================== + * Initialize the "longest match" routines for a new file + */ +void lm_init(pack_level, flags) int pack_level; /* 0: store, 1: best speed, 9: + best compression */ +ush *flags; /* general purpose bit flag */ +{ + register unsigned j; + + if (pack_level < 1 || pack_level > 9) + error("bad pack level"); + compr_level = pack_level; + + /* Initialize the hash table. */ + memzero((char *)head, HASH_SIZE * sizeof(*head)); + + /* prev will be initialized on the fly */ + + /* Set the default configuration parameters: + */ + max_lazy_match = configuration_table[pack_level].max_lazy; + good_match = configuration_table[pack_level].good_length; +#ifndef FULL_SEARCH + nice_match = configuration_table[pack_level].nice_length; +#endif + max_chain_length = configuration_table[pack_level].max_chain; + if (pack_level == 1) { + *flags |= FAST; + } else if (pack_level == 9) { + *flags |= SLOW; + } + /* ??? reduce max_chain_length for binary files */ + + strstart = 0; + block_start = 0L; +#ifdef ASMV + match_init(); /* initialize the asm code */ +#endif + + lookahead = read_buf((char *)window, + sizeof(int) <= 2 ? (unsigned)WSIZE : 2 * WSIZE); + + if (lookahead == 0 || lookahead == (unsigned)EOF) { + eofile = 1, lookahead = 0; + return; + } + eofile = 0; + /* Make sure that we always have enough lookahead. This is important + * if input comes from a device such as a tty. + */ + while (lookahead < MIN_LOOKAHEAD && !eofile) + fill_window(); + + ins_h = 0; + for (j = 0; j < MIN_MATCH - 1; j++) + UPDATE_HASH(ins_h, window[j]); + /* If lookahead < MIN_MATCH, ins_h is garbage, but this is + * not important since only literal bytes will be emitted. + */ +} + +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + */ +#ifndef ASMV +/* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or + * match.s. The code is functionally equivalent, so you can use the C version + * if desired. + */ +int longest_match(cur_match) +IPos cur_match; /* current match */ +{ + unsigned chain_length = max_chain_length; /* max hash chain length */ + register uch *scan = window + strstart; /* current string */ + register uch *match; /* matched string */ + register int len; /* length of current match */ + int best_len = prev_length; /* best match length so far */ + IPos limit = strstart > (IPos)MAX_DIST ? strstart - (IPos)MAX_DIST : + NIL; + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + +/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ +#if HASH_BITS < 8 || MAX_MATCH != 258 +error: + Code too clever +#endif + +#ifdef UNALIGNED_OK + /* Compare two bytes at a time. Note: this is not always + * beneficial. Try with and without -DUNALIGNED_OK to check. + */ + register uch *strend = window + strstart + MAX_MATCH - 1; + register ush scan_start = *(ush *)scan; + register ush scan_end = *(ush *)(scan + best_len - 1); +#else + register uch *strend = window + strstart + MAX_MATCH; + register uch scan_end1 = scan[best_len - 1]; + register uch scan_end = scan[best_len]; +#endif + + /* Do not waste too much time if we already have a good match: */ + if (prev_length >= good_match) { + chain_length >>= 2; + } + Assert(strstart <= window_size - MIN_LOOKAHEAD, + "insufficient lookahead"); + + do { + Assert(cur_match < strstart, "no future"); + match = window + cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2: + */ +#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) + /* This code assumes sizeof(unsigned short) == 2. Do not use + * UNALIGNED_OK if your compiler uses a different size. + */ + if (*(ush *)(match + best_len - 1) != scan_end || + *(ush *)match != scan_start) + continue; + + /* It is not necessary to compare scan[2] and match[2] since + * they are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. Compare 2 + * bytes at a time at strstart+3, +5, ... up to strstart+257. We + * check for insufficient lookahead only every 4th comparison; + * the 128th check will be made at strstart+257. If MAX_MATCH-2 + * is not a multiple of 8, it is necessary to put more guard + * bytes at the end of the window, or to check more often for + * insufficient lookahead. + */ + scan++, match++; + do { + } while (*(ush *)(scan += 2) == *(ush *)(match += 2) && + *(ush *)(scan += 2) == *(ush *)(match += 2) && + *(ush *)(scan += 2) == *(ush *)(match += 2) && + *(ush *)(scan += 2) == *(ush *)(match += 2) && + scan < strend); + /* The funny "do {}" generates better code on most compilers */ + + /* Here, scan <= window+strstart+257 */ + Assert(scan <= window + (unsigned)(window_size - 1), + "wild scan"); + if (*scan == *match) + scan++; + + len = (MAX_MATCH - 1) - (int)(strend - scan); + scan = strend - (MAX_MATCH - 1); + +#else /* UNALIGNED_OK */ + + if (match[best_len] != scan_end || + match[best_len - 1] != scan_end1 || *match != *scan || + *++match != scan[1]) + continue; + + /* The check at best_len-1 can be removed because it will be + * made again later. (This heuristic is not always a win.) It is + * not necessary to compare scan[2] and match[2] since they are + * always equal when the other bytes match, given that the hash + * keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match++; + + /* We check for insufficient lookahead only every 8th + * comparison; the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + len = MAX_MATCH - (int)(strend - scan); + scan = strend - MAX_MATCH; + +#endif /* UNALIGNED_OK */ + + if (len > best_len) { + match_start = cur_match; + best_len = len; + if (len >= nice_match) + break; +#ifdef UNALIGNED_OK + scan_end = *(ush *)(scan + best_len - 1); +#else + scan_end1 = scan[best_len - 1]; + scan_end = scan[best_len]; +#endif + } + } while ((cur_match = prev[cur_match & WMASK]) > limit && + --chain_length != 0); + + return best_len; +} +#endif /* ASMV */ + +#ifdef DEBUG +/* =========================================================================== + * Check that the match at match_start is indeed a match. + */ +local void check_match(start, match, length) IPos start, match; +int length; +{ + /* check that the match is indeed a match */ + if (memcmp((char *)window + match, (char *)window + start, length) != + EQUAL) { + fprintf(stderr, " start %d, match %d, length %d\n", start, + match, length); + error("invalid match"); + } + if (verbose > 1) { + fprintf(stderr, "\\[%d,%d]", start - match, length); + do { + putc(window[start++], stderr); + } while (--length != 0); + } +} +#else +#define check_match(start, match, length) +#endif + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead, and sets eofile if end of input file. + * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0 + * OUT assertions: at least one byte has been read, or eofile is set; + * file reads are performed for at least two bytes (required for the + * translate_eol option). + */ +local void fill_window() +{ + register unsigned n, m; + unsigned more = + (unsigned)(window_size - (ulg)lookahead - (ulg)strstart); + /* Amount of free space at the end of the window. */ + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (more == (unsigned)EOF) { + /* Very unlikely, but possible on 16 bit machine if strstart == + * 0 and lookahead == 1 (input done one byte at time) + */ + more--; + } else if (strstart >= WSIZE + MAX_DIST) { + /* By the IN assertion, the window is not empty so we can't + * confuse more == 0 with more == 64K on a 16 bit machine. + */ + Assert(window_size == (ulg)2 * WSIZE, + "no sliding with BIG_MEM"); + + memcpy((char *)window, (char *)window + WSIZE, (unsigned)WSIZE); + match_start -= WSIZE; + strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ + + block_start -= (long)WSIZE; + + for (n = 0; n < HASH_SIZE; n++) { + m = head[n]; + head[n] = (Pos)(m >= WSIZE ? m - WSIZE : NIL); + } + for (n = 0; n < WSIZE; n++) { + m = prev[n]; + prev[n] = (Pos)(m >= WSIZE ? m - WSIZE : NIL); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } + more += WSIZE; + } + /* At this point, more >= 2 */ + if (!eofile) { + n = read_buf((char *)window + strstart + lookahead, more); + if (n == 0 || n == (unsigned)EOF) { + eofile = 1; + } else { + lookahead += n; + } + } +} + +/* =========================================================================== + * Flush the current block, with given end-of-file flag. + * IN assertion: strstart is set to the end of the current match. + */ +#define FLUSH_BLOCK(eof) \ + flush_block(block_start >= 0L ? \ + (char *)&window[(unsigned)block_start] : \ + (char *)NULL, \ + (long)strstart - block_start, (eof)) + +/* =========================================================================== + * Processes a new input file and return its compressed length. This + * function does not perform lazy evaluationof matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +local ulg deflate_fast() +{ + IPos hash_head; /* head of the hash chain */ + int flush; /* set if current block must be flushed */ + unsigned match_length = 0; /* length of best match */ + + prev_length = MIN_MATCH - 1; + while (lookahead != 0) { + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + INSERT_STRING(strstart, hash_head); + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head != NIL && strstart - hash_head <= MAX_DIST) { + /* To simplify the code, we prevent matches with the + * string of window index 0 (in particular we have to + * avoid a match of the string with itself at the start + * of the input file). + */ + match_length = longest_match(hash_head); + /* longest_match() sets match_start */ + if (match_length > lookahead) + match_length = lookahead; + } + if (match_length >= MIN_MATCH) { + check_match(strstart, match_start, match_length); + + flush = ct_tally(strstart - match_start, + match_length - MIN_MATCH); + + lookahead -= match_length; + + /* Insert new strings in the hash table only if the + * match length is not too large. This saves time but + * degrades compression. + */ + if (match_length <= max_insert_length) { + match_length--; /* string at strstart already in + hash table */ + do { + strstart++; + INSERT_STRING(strstart, hash_head); + /* strstart never exceeds + * WSIZE-MAX_MATCH, so there are always + * MIN_MATCH bytes ahead. If lookahead < + * MIN_MATCH these bytes are garbage, + * but it does not matter since the next + * lookahead bytes will be emitted as + * literals. + */ + } while (--match_length != 0); + strstart++; + } else { + strstart += match_length; + match_length = 0; + ins_h = window[strstart]; + UPDATE_HASH(ins_h, window[strstart + 1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH - 3 more times +#endif + } + } else { + /* No match, output a literal byte */ + Tracevv((stderr, "%c", window[strstart])); + flush = ct_tally(0, window[strstart]); + lookahead--; + strstart++; + } + if (flush) + FLUSH_BLOCK(0), block_start = strstart; + + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + while (lookahead < MIN_LOOKAHEAD && !eofile) + fill_window(); + } + return FLUSH_BLOCK(1); /* eof */ +} + +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +ulg deflate() +{ + IPos hash_head; /* head of hash chain */ + IPos prev_match; /* previous match */ + int flush; /* set if current block must be flushed */ + int match_available = 0; /* set if previous match exists */ + register unsigned match_length = MIN_MATCH - 1; /* length of best match + */ +#ifdef DEBUG + extern long isize; /* byte length of input file, for debug only */ +#endif + + if (compr_level <= 3) + return deflate_fast(); /* optimized for speed */ + + /* Process the input block. */ + while (lookahead != 0) { + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + INSERT_STRING(strstart, hash_head); + + /* Find the longest match, discarding those <= prev_length. + */ + prev_length = match_length, prev_match = match_start; + match_length = MIN_MATCH - 1; + + if (hash_head != NIL && prev_length < max_lazy_match && + strstart - hash_head <= MAX_DIST) { + /* To simplify the code, we prevent matches with the + * string of window index 0 (in particular we have to + * avoid a match of the string with itself at the start + * of the input file). + */ + match_length = longest_match(hash_head); + /* longest_match() sets match_start */ + if (match_length > lookahead) + match_length = lookahead; + + /* Ignore a length 3 match if it is too distant: */ + if (match_length == MIN_MATCH && + strstart - match_start > TOO_FAR) { + /* If prev_match is also MIN_MATCH, match_start + * is garbage but we will ignore the current + * match anyway. + */ + match_length--; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (prev_length >= MIN_MATCH && match_length <= prev_length) { + check_match(strstart - 1, prev_match, prev_length); + + flush = ct_tally(strstart - 1 - prev_match, + prev_length - MIN_MATCH); + + /* Insert in hash table all strings up to the end of the + * match. strstart-1 and strstart are already inserted. + */ + lookahead -= prev_length - 1; + prev_length -= 2; + do { + strstart++; + INSERT_STRING(strstart, hash_head); + /* strstart never exceeds WSIZE-MAX_MATCH, so + * there are always MIN_MATCH bytes ahead. If + * lookahead < MIN_MATCH these bytes are + * garbage, but it does not matter since the + * next lookahead bytes will always be emitted + * as literals. + */ + } while (--prev_length != 0); + match_available = 0; + match_length = MIN_MATCH - 1; + strstart++; + if (flush) + FLUSH_BLOCK(0), block_start = strstart; + + } else if (match_available) { + /* If there was no match at the previous position, + * output a single literal. If there was a match but the + * current match is longer, truncate the previous match + * to a single literal. + */ + Tracevv((stderr, "%c", window[strstart - 1])); + if (ct_tally(0, window[strstart - 1])) { + FLUSH_BLOCK(0), block_start = strstart; + } + strstart++; + lookahead--; + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + match_available = 1; + strstart++; + lookahead--; + } + Assert(strstart <= isize && lookahead <= isize, + "a bit too far"); + + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + while (lookahead < MIN_LOOKAHEAD && !eofile) + fill_window(); + } + if (match_available) + ct_tally(0, window[strstart - 1]); + + return FLUSH_BLOCK(1); /* eof */ +} diff --git a/bin/gzip/gzip.c b/bin/gzip/gzip.c new file mode 100644 index 00000000..ddafcade --- /dev/null +++ b/bin/gzip/gzip.c @@ -0,0 +1,1300 @@ +/* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface + * Copyright (C) 1992-1993 Jean-loup Gailly + * The unzip code was written and put in the public domain by Mark Adler. + * Portions of the lzw code are derived from the public domain 'compress' + * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies, + * Ken Turkowski, Dave Mack and Peter Jannesen. + * + * See the license_msg below and the file COPYING for the software license. + * See the file algorithm.doc for the compression algorithms and file formats. + */ + +static char *license_msg[] = { + " Copyright (C) 1992-1993 Jean-loup Gailly", + " This program is free software; you can redistribute it and/or modify", + " it under the terms of the GNU General Public License as published by", + " the Free Software Foundation; either version 2, or (at your option)", + " any later version.", + "", + " This program is distributed in the hope that it will be useful,", + " but WITHOUT ANY WARRANTY; without even the implied warranty of", + " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the", + " GNU General Public License for more details.", + "", + " You should have received a copy of the GNU General Public License", + " along with this program; if not, write to the Free Software", + " Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.", + 0 +}; + +/* Compress files with zip algorithm and 'compress' interface. + * See usage() and help() functions below for all options. + * Outputs: + * file.gz: compressed file with same mode, owner, and utimes + * or stdout with -c option or if stdin used as input. + * If the output file name had to be truncated, the original name is kept + * in the compressed file. + * On MSDOS, file.tmp -> file.tmz. On VMS, file.tmp -> file.tmp-gz. + * + * Using gz on MSDOS would create too many file name conflicts. For + * example, foo.txt -> foo.tgz (.tgz must be reserved as shorthand for + * tar.gz). Similarly, foo.dir and foo.doc would both be mapped to foo.dgz. + * I also considered 12345678.txt -> 12345txt.gz but this truncates the name + * too heavily. There is no ideal solution given the MSDOS 8+3 limitation. + * + * For the meaning of all compilation flags, see comments in Makefile.in. + */ + +#ifdef RCSID +static char rcsid[] = "$Id: gzip.c,v 1.3 2005/02/12 21:03:28 olh Exp $"; +#endif + +#include <ctype.h> +#include <sys/types.h> +#include <signal.h> +#include <sys/stat.h> +#include <errno.h> + +#include "tailor.h" +#include "gzip.h" +#include "revision.h" + +#include <time.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdlib.h> + +#include <utime.h> + +typedef void(*sig_type) OF((int)); + +#define RW_USER (S_IRUSR | S_IWUSR) /* creation mode for open() */ + +#ifndef MAX_PATH_LEN +#define MAX_PATH_LEN 1024 /* max pathname length */ +#endif + +/* global buffers */ + +DECLARE(uch, inbuf, INBUFSIZ + INBUF_EXTRA); +DECLARE(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA); +DECLARE(ush, d_buf, DIST_BUFSIZE); +DECLARE(uch, window, 2L * WSIZE); +DECLARE(ush, tab_prefix, 1L << BITS); + +/* local variables */ + +#ifndef SUPPORT_ZIP +#define decompress 1 +#else +int level = 6; /* compression level */ +#endif + +int to_stdout; /* output to stdout (-c) */ +#ifdef decompress +int decompress_wanted; +#else +int decompress; /* decompress (-d) */ +#define decompress_wanted decompress +#endif +int force; /* don't ask questions, compress links (-f) */ +int no_name = -1; /* don't save or restore the original file name */ +int no_time = -1; /* don't save or restore the original file time */ +int verbose; /* be verbose (-v) */ +int quiet; /* be very quiet (-q) */ +int test; /* test .gz file integrity */ +int foreground; /* set if program run in foreground */ +char *progname; /* program name */ +int method = DEFLATED; /* compression method */ +int exit_code = OK; /* program exit code */ +int save_orig_name; /* set if original name must be saved */ +int last_member; /* set for .zip and .Z files */ +int part_nb; /* number of parts in .gz file */ +time_t time_stamp; /* original time stamp (modification time) */ +long ifile_size; /* input file size, -1 for devices (debug only) */ +char *env; /* contents of GZIP env variable */ +char **args = NULL; /* argv pointer if GZIP env variable defined */ +char z_suffix[MAX_SUFFIX + 1]; /* default suffix (can be set with --suffix) */ +int z_len; /* strlen(z_suffix) */ + +long header_bytes; /* number of bytes in gzip header */ +long bytes_in; /* number of input bytes */ +long bytes_out; /* number of output bytes */ +long total_in; /* input bytes for all files */ +long total_out; /* output bytes for all files */ +char ifname[MAX_PATH_LEN]; /* input file name */ +char ofname[MAX_PATH_LEN]; /* output file name */ +int remove_ofname; /* remove output file on error */ +struct stat istat; /* status for input file */ +int ifd; /* input file descriptor */ +int ofd; /* output file descriptor */ +unsigned insize; /* valid bytes in inbuf */ +unsigned inptr; /* index of next byte to be processed in inbuf */ +unsigned outcnt; /* bytes in output buffer */ + +/* local functions */ + +local void usage OF((void)); +local void help OF((void)); +local void license OF((void)); +local void version OF((void)); +local void treat_stdin OF((void)); +local void treat_file OF((char *iname)); +local int create_outfile OF((void)); +local int do_stat OF((char *name, struct stat *sbuf)); +local char *get_suffix OF((char *name)); +local int get_istat OF((char *iname, struct stat *sbuf)); +local int make_ofname OF((void)); +local int same_file OF((struct stat * stat1, struct stat *stat2)); +local int name_too_long OF((char *name, struct stat *statb)); +local void shorten_name OF((char *name)); +local int get_method OF((void)); +local int check_ofname OF((void)); +local void copy_stat OF((struct stat * ifstat)); +local void do_exit OF((int exitcode)); +int main OF((int argc, char **argv)); +int(*work) OF((int infile, int outfile)) +#ifdef SUPPORT_ZIP + = zip; /* function to call */ +#else + = unzip; +#endif +local void reset_times OF((char *name, struct stat *statb)); + +#define strequ(s1, s2) (strcmp((s1), (s2)) == 0) + +/* ======================================================================== */ +local void usage() +{ + fprintf(stderr, "usage: %s [-cdfhlLnNtvV19] [-S suffix] [file ...]\n", + progname); +} + +/* ======================================================================== */ +local void help() +{ + static char *help_msg[] = { + " -c --stdout write on standard output, keep original files unchanged", + " -d --decompress decompress", + " -f --force force overwrite of output file and compress links", + " -h --help give this help", + " -L --license display software license", +#ifdef UNDOCUMENTED + " -m --no-time do not save or restore the original modification time", + " -M --time save or restore the original modification time", +#endif + " -n --no-name do not save or restore the original name and time stamp", + " -N --name save or restore the original name and time stamp", + " -q --quiet suppress all warnings", + " -S .suf --suffix .suf use suffix .suf on compressed files", + " -t --test test compressed file integrity", + " -v --verbose verbose mode", + " -V --version display version number", +#ifdef SUPPORT_ZIP + " -1 --fast compress faster", + " -9 --best compress better", + " file... files to (de)compress. If none given, use standard input.", +#else + " file... files to decompress. If none given, use standard input.", +#endif + 0 + }; + char **p = help_msg; + + fprintf(stderr, "%s %s (%s)\n", progname, VERSION, REVDATE); + usage(); + while (*p) + fprintf(stderr, "%s\n", *p++); +} + +/* ======================================================================== */ +local void license() +{ + char **p = license_msg; + + fprintf(stderr, "%s %s (%s)\n", progname, VERSION, REVDATE); + while (*p) + fprintf(stderr, "%s\n", *p++); +} + +/* ======================================================================== */ +local void version() +{ + fprintf(stderr, "%s %s (%s)\n", progname, VERSION, REVDATE); + + fprintf(stderr, "Compilation options: UTIME STDC_HEADERS" +#ifndef SUPPORT_ZIP + " DECOMPRESS_ONLY" +#endif + "\n"); +} + +/* ======================================================================== */ +int main(argc, argv) +int argc; +char **argv; +{ + int file_count; /* number of files to precess */ + int optc; /* current option */ + + progname = basename(argv[0]); + + /* Add options in GZIP environment variable if there is one */ + env = add_envopt(&argc, &argv, OPTIONS_VAR); + if (env != NULL) + args = argv; + + foreground = sysv_signal(SIGINT, SIG_IGN) != SIG_IGN; + if (foreground) { + (void)sysv_signal(SIGINT, (sig_type)abort_gzip); + } +#ifdef SIGTERM + if (sysv_signal(SIGTERM, SIG_IGN) != SIG_IGN) { + (void)sysv_signal(SIGTERM, (sig_type)abort_gzip); + } +#endif +#ifdef SIGHUP + if (sysv_signal(SIGHUP, SIG_IGN) != SIG_IGN) { + (void)sysv_signal(SIGHUP, (sig_type)abort_gzip); + } +#endif + +#ifndef GNU_STANDARD + /* For compatibility with old compress, use program name as an option. + * If you compile with -DGNU_STANDARD, this program will behave as + * gzip even if it is invoked under the name gunzip or zcat. + * + * Systems which do not support links can still use -d or -dc. + * Ignore an .exe extension for MSDOS, OS/2 and VMS. + */ + if (strncmp(progname, "un", 2) == 0 /* ungzip, uncompress */ + || strncmp(progname, "gun", 3) == 0) { /* gunzip */ + decompress_wanted = 1; + } + if (strequ(progname + 1, "cat") /* zcat, pcat, gcat */ + || strequ(progname, "gzcat")) { /* gzcat */ + decompress_wanted = 1; + to_stdout = 1; + } +#endif + + strncpy(z_suffix, Z_SUFFIX, sizeof(z_suffix) - 1); + z_len = strlen(z_suffix); + + while ((optc = getopt(argc, argv, "cdfhH?LmMnNqrS:tvV123456789")) != + EOF) { + switch (optc) { + case 'c': + to_stdout = 1; + break; + case 'd': + decompress_wanted = 1; + break; + case 'f': + force++; + break; + case 'h': + case 'H': + case '?': + help(); + do_exit(OK); + break; + case 'L': + license(); + do_exit(OK); + break; + case 'm': /* undocumented, may change later */ + no_time = 1; + break; + case 'M': /* undocumented, may change later */ + no_time = 0; + break; + case 'n': + no_name = no_time = 1; + break; + case 'N': + no_name = no_time = 0; + break; + case 'q': + quiet = 1; + verbose = 0; + break; + case 'S': + z_len = strlen(optarg); + strcpy(z_suffix, optarg); + break; + case 't': + test = to_stdout = 1; + decompress_wanted = 1; + break; + case 'v': + verbose++; + quiet = 0; + break; + case 'V': + version(); + do_exit(OK); + break; +#ifdef SUPPORT_ZIP + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + level = optc - '0'; + break; +#endif + default: + /* Error message already emitted by getopt_long. */ + usage(); + do_exit(ERROR); + } + } /* loop on all arguments */ + +#ifndef SUPPORT_ZIP + if (!decompress_wanted) { + fprintf(stderr, + "%s: this version does not support compression\n", + progname); + do_exit(ERROR); + } +#endif + + /* By default, save name and timestamp on compression but do not + * restore them on decompression. + */ + if (no_time < 0) + no_time = decompress; + if (no_name < 0) + no_name = decompress; + + file_count = argc - optind; + + if ((z_len == 0 && !decompress) || z_len > MAX_SUFFIX) { + fprintf(stderr, "%s: incorrect suffix '%s'\n", progname, + optarg); + do_exit(ERROR); + } + + /* Allocate all global buffers (for DYN_ALLOC option) */ + ALLOC(uch, inbuf, INBUFSIZ + INBUF_EXTRA); + ALLOC(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA); + ALLOC(ush, d_buf, DIST_BUFSIZE); + ALLOC(uch, window, 2L * WSIZE); + ALLOC(ush, tab_prefix, 1L << BITS); + + /* And get to work */ + if (file_count != 0) { + while (optind < argc) { + treat_file(argv[optind++]); + } + } else { /* Standard input */ + treat_stdin(); + } + do_exit(exit_code); + return exit_code; /* just to avoid lint warning */ +} + +/* ======================================================================== + * Compress or decompress stdin + */ +local void treat_stdin() +{ + if (!force && isatty(fileno((FILE *)(decompress ? stdin : stdout)))) { + /* Do not send compressed data to the terminal or read it from + * the terminal. We get here when user invoked the program + * without parameters, so be helpful. According to the GNU + * standards: + * + * If there is one behavior you think is most useful when the + * output is to a terminal, and another that you think is most + * useful when the output is a file or a pipe, then it is + * usually best to make the default behavior the one that is + * useful with output to a terminal, and have an option for the + * other behavior. + * + * Here we use the --force option to get the other behavior. + */ + fprintf(stderr, + "%s: compressed data not %s a terminal. Use -f to force %scompression.\n", + progname, decompress ? "read from" : "written to", + decompress ? "de" : ""); + fprintf(stderr, "For help, type: %s -h\n", progname); + do_exit(ERROR); + } + + strcpy(ifname, "stdin"); + strcpy(ofname, "stdout"); + + /* Get the time stamp on the input file. */ + time_stamp = 0; /* time unknown by default */ + + if (!no_time) { + if (fstat(fileno(stdin), &istat) != 0) { + error("fstat(stdin)"); + } + time_stamp = istat.st_mtime; + } + ifile_size = -1L; /* convention for unknown size */ + + clear_bufs(); /* clear input and output buffers */ + to_stdout = 1; + part_nb = 0; + + if (decompress) { + method = get_method(); + if (method < 0) { + do_exit(exit_code); /* error message already emitted */ + } + } + + /* Actually do the compression/decompression. Loop over zipped members. + */ + for (;;) { + if ((*work)(fileno(stdin), fileno(stdout)) != OK) + return; + + if (!decompress || last_member || inptr == insize) + break; + /* end of file */ + + method = get_method(); + if (method < 0) + return; /* error message already emitted */ + bytes_out = 0; /* required for length check */ + } + + if (verbose) { + if (test) { + fprintf(stderr, " OK\n"); + + } else if (!decompress) { + display_ratio(bytes_in - (bytes_out - header_bytes), + bytes_in, stderr); + fprintf(stderr, "\n"); +#ifdef DISPLAY_STDIN_RATIO + } else { + display_ratio(bytes_out - (bytes_in - header_bytes), + bytes_out, stderr); + fprintf(stderr, "\n"); +#endif + } + } +} + +/* ======================================================================== + * Compress or decompress the given file + */ +local void treat_file(iname) char *iname; +{ + /* Accept "-" as synonym for stdin */ + if (strequ(iname, "-")) { + int cflag = to_stdout; + treat_stdin(); + to_stdout = cflag; + return; + } + + /* Check if the input file is present, set ifname and istat: */ + if (get_istat(iname, &istat) != OK) + return; + + /* If the input name is that of a directory, recurse or ignore: */ + if (S_ISDIR(istat.st_mode)) { + WARN((stderr, "%s: %s is a directory -- ignored\n", progname, + ifname)); + return; + } + if (!S_ISREG(istat.st_mode)) { + WARN((stderr, + "%s: %s is not a directory or a regular file - ignored\n", + progname, ifname)); + return; + } + if (istat.st_nlink > 1 && !to_stdout && !force) { + WARN((stderr, "%s: %s has %d other link%c -- unchanged\n", + progname, ifname, (int)istat.st_nlink - 1, + istat.st_nlink > 2 ? 's' : ' ')); + return; + } + + ifile_size = istat.st_size; + time_stamp = no_time ? 0 : istat.st_mtime; + + /* Generate output file name. For -r and (-t or -l), skip files + * without a valid gzip suffix (check done in make_ofname). + */ + if (to_stdout && !test) { + strcpy(ofname, "stdout"); + + } else if (make_ofname() != OK) { + return; + } + + /* Open the input file and determine compression method. The mode + * parameter is ignored but required by some systems (VMS) and forbidden + * on other systems (MacOS). + */ + ifd = open(ifname, !decompress ? O_RDONLY : O_RDONLY, RW_USER); + if (ifd == -1) { + fprintf(stderr, "%s: ", progname); + perror(ifname); + exit_code = ERROR; + return; + } + clear_bufs(); /* clear input and output buffers */ + part_nb = 0; + + if (decompress) { + method = get_method(); /* updates ofname if original given */ + if (method < 0) { + close(ifd); + return; /* error message already emitted */ + } + } + + /* If compressing to a file, check if ofname is not ambiguous + * because the operating system truncates names. Otherwise, generate + * a new ofname and save the original name in the compressed file. + */ + if (to_stdout) { + ofd = fileno(stdout); + /* keep remove_ofname as zero */ + } else { + if (create_outfile() != OK) + return; + + if (!decompress && save_orig_name && !verbose && !quiet) { + fprintf(stderr, "%s: %s compressed to %s\n", progname, + ifname, ofname); + } + } + /* Keep the name even if not truncated except with --no-name: */ + if (!save_orig_name) + save_orig_name = !no_name; + + if (verbose) { + fprintf(stderr, "%s:\t%s", ifname, + (int)strlen(ifname) >= 15 ? + "" : + ((int)strlen(ifname) >= 7 ? "\t" : "\t\t")); + } + + /* Actually do the compression/decompression. Loop over zipped members. + */ + for (;;) { + if ((*work)(ifd, ofd) != OK) { + method = -1; /* force cleanup */ + break; + } + if (!decompress || last_member || inptr == insize) + break; + /* end of file */ + + method = get_method(); + if (method < 0) + break; /* error message already emitted */ + bytes_out = 0; /* required for length check */ + } + + close(ifd); + if (!to_stdout && close(ofd)) { + write_error(); + } + if (method == -1) { + if (!to_stdout) + unlink(ofname); + return; + } + /* Display statistics */ + if (verbose) { + if (test) { + fprintf(stderr, " OK"); + } else if (decompress) { + display_ratio(bytes_out - (bytes_in - header_bytes), + bytes_out, stderr); + } else { + display_ratio(bytes_in - (bytes_out - header_bytes), + bytes_in, stderr); + } + if (!test && !to_stdout) { + fprintf(stderr, " -- replaced with %s", ofname); + } + fprintf(stderr, "\n"); + } + /* Copy modes, times, ownership, and remove the input file */ + if (!to_stdout) { + copy_stat(&istat); + } +} + +/* ======================================================================== + * Create the output file. Return OK or ERROR. + * Try several times if necessary to avoid truncating the z_suffix. For + * example, do not create a compressed file of name "1234567890123." + * Sets save_orig_name to true if the file name has been truncated. + * IN assertions: the input file has already been open (ifd is set) and + * ofname has already been updated if there was an original name. + * OUT assertions: ifd and ofd are closed in case of error. + */ +local int create_outfile() +{ + struct stat ostat; /* stat for ofname */ + int flags = O_WRONLY | O_CREAT | O_EXCL; + + for (;;) { + /* Make sure that ofname is not an existing file */ + if (check_ofname() != OK) { + close(ifd); + return ERROR; + } + /* Create the output file */ + remove_ofname = 1; + ofd = open(ofname, flags, RW_USER); + if (ofd == -1) { + perror(ofname); + close(ifd); + exit_code = ERROR; + return ERROR; + } + + /* Check for name truncation on new file (1234567890123.gz) */ + if (fstat(ofd, &ostat) != 0) { + fprintf(stderr, "%s: ", progname); + perror(ofname); + close(ifd); + close(ofd); + unlink(ofname); + exit_code = ERROR; + return ERROR; + } + if (!name_too_long(ofname, &ostat)) + return OK; + + if (decompress) { + /* name might be too long if an original name was saved + */ + WARN((stderr, "%s: %s: warning, name truncated\n", + progname, ofname)); + return OK; + } + close(ofd); + unlink(ofname); + shorten_name(ofname); + } +} + +/* ======================================================================== + * Use lstat if available, except for -c or -f. Use stat otherwise. + * This allows links when not removing the original file. + */ +local int do_stat(name, sbuf) +char *name; +struct stat *sbuf; +{ + errno = 0; + if (!to_stdout && !force) { + return lstat(name, sbuf); + } + return stat(name, sbuf); +} + +/* ======================================================================== + * Return a pointer to the 'z' suffix of a file name, or NULL. For all + * systems, ".gz", ".z", ".Z", ".taz", ".tgz", "-gz", "-z" and "_z" are + * accepted suffixes, in addition to the value of the --suffix option. + * ".tgz" is a useful convention for tar.z files on systems limited + * to 3 characters extensions. On such systems, ".?z" and ".??z" are + * also accepted suffixes. For Unix, we do not want to accept any + * .??z suffix as indicating a compressed file; some people use .xyz + * to denote volume data. + * On systems allowing multiple versions of the same file (such as VMS), + * this function removes any version suffix in the given name. + */ +local char *get_suffix(name) +char *name; +{ + int nlen, slen; + char suffix[MAX_SUFFIX + 3]; /* last chars of name, forced to lower case + */ + static char *known_suffixes[] = { z_suffix, ".gz", ".z", ".taz", ".tgz", + "-gz", "-z", "_z", NULL }; + char **suf = known_suffixes; + + if (strequ(z_suffix, "z")) + suf++; /* check long suffixes first */ + + nlen = strlen(name); + if (nlen <= MAX_SUFFIX + 2) { + strcpy(suffix, name); + } else { + strcpy(suffix, name + nlen - MAX_SUFFIX - 2); + } + strlwr(suffix); + slen = strlen(suffix); + do { + int s = strlen(*suf); + if (slen > s && suffix[slen - s - 1] != PATH_SEP && + strequ(suffix + slen - s, *suf)) { + return name + nlen - s; + } + } while (*++suf != NULL); + + return NULL; +} + +/* ======================================================================== + * Set ifname to the input file name (with a suffix appended if necessary) + * and istat to its stats. For decompression, if no file exists with the + * original name, try adding successively z_suffix, .gz, .z, -z and .Z. + * For MSDOS, we try only z_suffix and z. + * Return OK or ERROR. + */ +local int get_istat(iname, sbuf) +char *iname; +struct stat *sbuf; +{ + int ilen; /* strlen(ifname) */ + static char *suffixes[] = { z_suffix, ".gz", ".z", "-z", ".Z", NULL }; + char **suf = suffixes; + char *s; + + strcpy(ifname, iname); + + /* If input file exists, return OK. */ + if (do_stat(ifname, sbuf) == 0) + return OK; + + if (!decompress || errno != ENOENT) { + perror(ifname); + exit_code = ERROR; + return ERROR; + } + /* file.ext doesn't exist, try adding a suffix (after removing any + * version number for VMS). + */ + s = get_suffix(ifname); + if (s != NULL) { + perror(ifname); /* ifname already has z suffix and does not + exist */ + exit_code = ERROR; + return ERROR; + } + ilen = strlen(ifname); + if (strequ(z_suffix, ".gz")) + suf++; + + /* Search for all suffixes */ + do { + s = *suf; + strcat(ifname, s); + if (do_stat(ifname, sbuf) == 0) + return OK; + ifname[ilen] = '\0'; + } while (*++suf != NULL); + + /* No suffix found, complain using z_suffix: */ + strcat(ifname, z_suffix); + perror(ifname); + exit_code = ERROR; + return ERROR; +} + +/* ======================================================================== + * Generate ofname given ifname. Return OK, or WARNING if file must be skipped. + * Sets save_orig_name to true if the file name has been truncated. + */ +local int make_ofname() +{ + char *suff; /* ofname z suffix */ + + strcpy(ofname, ifname); + /* strip a version number if any and get the gzip suffix if present: */ + suff = get_suffix(ofname); + + if (decompress) { + if (suff == NULL) { + /* Whith -t or -l, try all files (even without .gz + * suffix) except with -r (behave as with just -dr). + */ + if (test) + return OK; + + /* Avoid annoying messages with -r */ + if (verbose || !quiet) { + WARN((stderr, + "%s: %s: unknown suffix -- ignored\n", + progname, ifname)); + } + return WARNING; + } + /* Make a special case for .tgz and .taz: */ + strlwr(suff); + if (strequ(suff, ".tgz") || strequ(suff, ".taz")) { + strcpy(suff, ".tar"); + } else { + *suff = '\0'; /* strip the z suffix */ + } + /* ofname might be changed later if infile contains an original + * name */ + + } else if (suff != NULL) { + /* Avoid annoying messages with -r (see treat_dir()) */ + if (verbose || !quiet) { + fprintf(stderr, + "%s: %s already has %s suffix -- unchanged\n", + progname, ifname, suff); + } + if (exit_code == OK) + exit_code = WARNING; + return WARNING; + } else { + save_orig_name = 0; + strcat(ofname, z_suffix); + + } /* decompress ? */ + return OK; +} + +/* ======================================================================== + * Check the magic number of the input file and update ofname if an + * original name was given and to_stdout is not set. + * Return the compression method, -1 for error, -2 for warning. + * Set inptr to the offset of the next byte to be processed. + * Updates time_stamp if there is one and --no-time is not used. + * This function may be called repeatedly for an input file consisting + * of several contiguous gzip'ed members. + * IN assertions: there is at least one remaining compressed member. + * If the member is a zip file, it must be the only one. + */ +local int get_method() +{ + uch flags; /* compression flags */ + char magic[2]; /* magic header */ + ulg stamp; /* time stamp */ + + /* If --force and --stdout, zcat == cat, so do not complain about + * premature end of file: use try_byte instead of get_byte. + */ + if (force && to_stdout) { + magic[0] = (char)try_byte(); + magic[1] = (char)try_byte(); + /* If try_byte returned EOF, magic[1] == 0xff */ + } else { + magic[0] = (char)get_byte(); + magic[1] = (char)get_byte(); + } + method = -1; /* unknown yet */ + part_nb++; /* number of parts in gzip file */ + header_bytes = 0; + last_member = RECORD_IO; + /* assume multiple members in gzip file except for record oriented I/O + */ + + if (memcmp(magic, GZIP_MAGIC, 2) == 0 || + memcmp(magic, OLD_GZIP_MAGIC, 2) == 0) { + method = (int)get_byte(); + if (method != DEFLATED) { + fprintf(stderr, + "%s: %s: unknown method %d -- get newer version of gzip\n", + progname, ifname, method); + exit_code = ERROR; + return -1; + } + work = unzip; + flags = (uch)get_byte(); + + if ((flags & ENCRYPTED) != 0) { + fprintf(stderr, + "%s: %s is encrypted -- get newer version of gzip\n", + progname, ifname); + exit_code = ERROR; + return -1; + } + if ((flags & CONTINUATION) != 0) { + fprintf(stderr, + "%s: %s is a a multi-part gzip file -- get newer version of gzip\n", + progname, ifname); + exit_code = ERROR; + if (force <= 1) + return -1; + } + if ((flags & RESERVED) != 0) { + fprintf(stderr, + "%s: %s has flags 0x%x -- get newer version of gzip\n", + progname, ifname, flags); + exit_code = ERROR; + if (force <= 1) + return -1; + } + stamp = (ulg)get_byte(); + stamp |= ((ulg)get_byte()) << 8; + stamp |= ((ulg)get_byte()) << 16; + stamp |= ((ulg)get_byte()) << 24; + if (stamp != 0 && !no_time) + time_stamp = stamp; + + (void)get_byte(); /* Ignore extra flags for the moment */ + (void)get_byte(); /* Ignore OS type for the moment */ + + if ((flags & CONTINUATION) != 0) { + unsigned part = (unsigned)get_byte(); + part |= ((unsigned)get_byte()) << 8; + if (verbose) { + fprintf(stderr, "%s: %s: part number %u\n", + progname, ifname, part); + } + } + if ((flags & EXTRA_FIELD) != 0) { + unsigned len = (unsigned)get_byte(); + len |= ((unsigned)get_byte()) << 8; + if (verbose) { + fprintf(stderr, + "%s: %s: extra field of %u bytes ignored\n", + progname, ifname, len); + } + while (len--) + (void)get_byte(); + } + + /* Get original file name if it was truncated */ + if ((flags & ORIG_NAME) != 0) { + if (no_name || to_stdout || part_nb > 1) { + /* Discard the old name */ + char c; /* dummy used for NeXTstep 3.0 cc + optimizer bug */ + do { + c = get_byte(); + } while (c != 0); + } else { + /* Copy the base name. Keep a directory prefix + * intact. */ + char *p = basename(ofname); + for (;;) { + *p = (char)get_char(); + if (*p++ == '\0') + break; + if (p >= ofname + sizeof(ofname)) { + error("corrupted input -- file name too large"); + } + } + } /* no_name || to_stdout */ + } /* ORIG_NAME */ + + /* Discard file comment if any */ + if ((flags & COMMENT) != 0) { + while (get_char() != 0) /* null */ + ; + } + if (part_nb == 1) { + header_bytes = inptr + 2 * sizeof(long); /* include crc + and size */ + } + } else if (force && to_stdout) { /* pass input unchanged */ + method = STORED; + work = copy; + inptr = 0; + last_member = 1; + } + if (method >= 0) + return method; + + if (part_nb == 1) { + fprintf(stderr, "\n%s: %s: not in gzip format\n", progname, + ifname); + exit_code = ERROR; + return -1; + } else { + WARN((stderr, + "\n%s: %s: decompression OK, trailing garbage ignored\n", + progname, ifname)); + return -2; + } +} + +/* ======================================================================== + * Return true if the two stat structures correspond to the same file. + */ +local int same_file(stat1, stat2) +struct stat *stat1; +struct stat *stat2; +{ + return stat1->st_ino == stat2->st_ino && + stat1->st_dev == stat2->st_dev +#ifdef NO_ST_INO + /* Can't rely on st_ino and st_dev, use other fields: */ + && stat1->st_mode == stat2->st_mode && + stat1->st_uid == stat2->st_uid && + stat1->st_gid == stat2->st_gid && + stat1->st_size == stat2->st_size && + stat1->st_atime == stat2->st_atime && + stat1->st_mtime == stat2->st_mtime && + stat1->st_ctime == stat2->st_ctime +#endif + ; +} + +/* ======================================================================== + * Return true if a file name is ambiguous because the operating system + * truncates file names. + */ +local int name_too_long(name, statb) +char *name; /* file name to check */ +struct stat *statb; /* stat buf for this file name */ +{ + int s = strlen(name); + char c = name[s - 1]; + struct stat tstat; /* stat for truncated name */ + int res; + + tstat = *statb; /* Just in case OS does not fill all fields */ + name[s - 1] = '\0'; + res = stat(name, &tstat) == 0 && same_file(statb, &tstat); + name[s - 1] = c; + Trace((stderr, " too_long(%s) => %d\n", name, res)); + return res; +} + +/* ======================================================================== + * Shorten the given name by one character, or replace a .tar extension + * with .tgz. Truncate the last part of the name which is longer than + * MIN_PART characters: 1234.678.012.gz -> 123.678.012.gz. If the name + * has only parts shorter than MIN_PART truncate the longest part. + * For decompression, just remove the last character of the name. + * + * IN assertion: for compression, the suffix of the given name is z_suffix. + */ +local void shorten_name(name) char *name; +{ + int len; /* length of name without z_suffix */ + char *trunc = NULL; /* character to be truncated */ + int plen; /* current part length */ + int min_part = MIN_PART; /* current minimum part length */ + char *p; + + len = strlen(name); + if (decompress) { + if (len <= 1) + error("name too short"); + name[len - 1] = '\0'; + return; + } + p = get_suffix(name); + if (p == NULL) + error("can't recover suffix\n"); + *p = '\0'; + save_orig_name = 1; + + /* compress 1234567890.tar to 1234567890.tgz */ + if (len > 4 && strequ(p - 4, ".tar")) { + strcpy(p - 4, ".tgz"); + return; + } + /* Try keeping short extensions intact: + * 1234.678.012.gz -> 123.678.012.gz + */ + do { + p = strrchr(name, PATH_SEP); + p = p ? p + 1 : name; + while (*p) { + plen = strcspn(p, "."); + p += plen; + if (plen > min_part) + trunc = p - 1; + if (*p) + p++; + } + } while (trunc == NULL && --min_part != 0); + + if (trunc != NULL) { + do { + trunc[0] = trunc[1]; + } while (*trunc++); + trunc--; + } else { + trunc = strrchr(name, '.'); + if (trunc == NULL) + error("internal error in shorten_name"); + if (trunc[1] == '\0') + trunc--; /* force truncation */ + } + strcpy(trunc, z_suffix); +} + +/* ======================================================================== + * If compressing to a file, check if ofname is not ambiguous + * because the operating system truncates names. Otherwise, generate + * a new ofname and save the original name in the compressed file. + * If the compressed file already exists, ask for confirmation. + * The check for name truncation is made dynamically, because different + * file systems on the same OS might use different truncation rules (on SVR4 + * s5 truncates to 14 chars and ufs does not truncate). + * This function returns -1 if the file must be skipped, and + * updates save_orig_name if necessary. + * IN assertions: save_orig_name is already set if ofname has been + * already truncated because of NO_MULTIPLE_DOTS. The input file has + * already been open and istat is set. + */ +local int check_ofname() +{ + struct stat ostat; /* stat for ofname */ + +#ifdef ENAMETOOLONG + /* Check for strictly conforming Posix systems (which return + * ENAMETOOLONG instead of silently truncating filenames). + */ + errno = 0; + while (stat(ofname, &ostat) != 0) { + if (errno != ENAMETOOLONG) + return 0; /* ofname does not exist */ + shorten_name(ofname); + } +#else + if (stat(ofname, &ostat) != 0) + return 0; +#endif + /* Check for name truncation on existing file. Do this even on systems + * defining ENAMETOOLONG, because on most systems the strict Posix + * behavior is disabled by default (silent name truncation allowed). + */ + if (!decompress && name_too_long(ofname, &ostat)) { + shorten_name(ofname); + if (stat(ofname, &ostat) != 0) + return 0; + } + + /* Check that the input and output files are different (could be + * the same by name truncation or links). + */ + if (same_file(&istat, &ostat)) { + if (strequ(ifname, ofname)) { + fprintf(stderr, + "%s: %s: cannot %scompress onto itself\n", + progname, ifname, decompress ? "de" : ""); + } else { + fprintf(stderr, "%s: %s and %s are the same file\n", + progname, ifname, ofname); + } + exit_code = ERROR; + return ERROR; + } + /* Ask permission to overwrite the existing file */ + if (!force) { +#if 0 + char response[80]; + strcpy(response,"n"); + fprintf(stderr, "%s: %s already exists;", progname, ofname); + if (foreground && isatty(fileno(stdin))) { + fprintf(stderr, " do you wish to overwrite (y or n)? "); + (void)fgets(response, sizeof(response)-1, stdin); + } + if (tolow(*response) != 'y') { + fprintf(stderr, "\tnot overwritten\n"); +#endif + if (exit_code == OK) + exit_code = WARNING; + return ERROR; +#if 0 + } +#endif + } + (void)chmod(ofname, 0777); + if (unlink(ofname)) { + fprintf(stderr, "%s: ", progname); + perror(ofname); + exit_code = ERROR; + return ERROR; + } + return OK; +} + +/* ======================================================================== + * Set the access and modification times from the given stat buffer. + */ +local void reset_times(name, statb) char *name; +struct stat *statb; +{ + struct utimbuf timep; + + /* Copy the time stamp */ + timep.actime = statb->st_atime; + timep.modtime = statb->st_mtime; + + /* Some systems (at least OS/2) do not support utime on directories */ + if (utime(name, &timep) && !S_ISDIR(statb->st_mode)) { + WARN((stderr, "%s: ", progname)); + if (!quiet) + perror(ofname); + } +} + +/* ======================================================================== + * Copy modes, times, ownership from input file to output file. + * IN assertion: to_stdout is false. + */ +local void copy_stat(ifstat) struct stat *ifstat; +{ + if (decompress && time_stamp != 0 && ifstat->st_mtime != time_stamp) { + ifstat->st_mtime = time_stamp; + if (verbose > 1) { + fprintf(stderr, "%s: time stamp restored\n", ofname); + } + } + reset_times(ofname, ifstat); + + /* Copy the protection modes */ + if (chmod(ofname, ifstat->st_mode & 07777)) { + WARN((stderr, "%s: ", progname)); + if (!quiet) + perror(ofname); + } + + chown(ofname, ifstat->st_uid, ifstat->st_gid); /* Copy ownership */ + + remove_ofname = 0; + /* It's now safe to remove the input file: */ + (void)chmod(ifname, 0777); + if (unlink(ifname)) { + WARN((stderr, "%s: ", progname)); + if (!quiet) + perror(ifname); + } +} + +/* ======================================================================== + * Free all dynamically allocated variables and exit with the given code. + */ +local void do_exit(exitcode) int exitcode; +{ + static int in_exit = 0; + + if (in_exit) + exit(exitcode); + in_exit = 1; + if (env != NULL) + free(env), env = NULL; + if (args != NULL) + free((char *)args), args = NULL; + FREE(inbuf); + FREE(outbuf); + FREE(d_buf); + FREE(window); + FREE(tab_prefix); + exit(exitcode); +} + +/* ======================================================================== + * Signal and error handler. + */ +void abort_gzip() +{ + if (remove_ofname) { + close(ofd); + unlink(ofname); + } + do_exit(ERROR); +} diff --git a/bin/gzip/gzip.h b/bin/gzip/gzip.h new file mode 100644 index 00000000..e2dcddfc --- /dev/null +++ b/bin/gzip/gzip.h @@ -0,0 +1,344 @@ +/* gzip.h -- common declarations for all gzip modules + * Copyright (C) 1992-1993 Jean-loup Gailly. + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +#if defined(__STDC__) || defined(PROTO) +#define OF(args) args +#else +#define OF(args) () +#endif + +#ifdef __STDC__ +typedef void *voidp; +#else +typedef char *voidp; +#endif + +/* I don't like nested includes, but the string and io functions are used + * too often + */ +#include <stdio.h> +#include <string.h> +#include <time.h> +#define memzero(s, n) memset((voidp)(s), 0, (n)) + +#define local static + +typedef unsigned char uch; +typedef unsigned short ush; +typedef unsigned long ulg; + +/* Return codes from gzip */ +#define OK 0 +#define ERROR 1 +#define WARNING 2 + +/* Compression methods (see algorithm.doc) */ +#define STORED 0 +#define COMPRESSED 1 +#define PACKED 2 +#define LZHED 3 +/* methods 4 to 7 reserved */ +#define DEFLATED 8 +#define MAX_METHODS 9 +extern int method; /* compression method */ + +/* To save memory for 16 bit systems, some arrays are overlaid between + * the various modules: + * deflate: prev+head window d_buf l_buf outbuf + * unlzw: tab_prefix tab_suffix stack inbuf outbuf + * inflate: window inbuf + * unpack: window inbuf prefix_len + * unlzh: left+right window c_table inbuf c_len + * For compression, input is done in window[]. For decompression, output + * is done in window except for unlzw. + */ + +#ifndef INBUFSIZ +#ifdef SMALL_MEM +#define INBUFSIZ 0x2000 /* input buffer size */ +#else +#define INBUFSIZ 0x8000 /* input buffer size */ +#endif +#endif +#define INBUF_EXTRA 64 /* required by unlzw() */ + +#ifndef OUTBUFSIZ +#ifdef SMALL_MEM +#define OUTBUFSIZ 8192 /* output buffer size */ +#else +#define OUTBUFSIZ 16384 /* output buffer size */ +#endif +#endif +#define OUTBUF_EXTRA 2048 /* required by unlzw() */ + +#ifndef DIST_BUFSIZE +#ifdef SMALL_MEM +#define DIST_BUFSIZE 0x2000 /* buffer for distances, see trees.c */ +#else +#define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */ +#endif +#endif + +#ifdef DYN_ALLOC +#define EXTERN(type, array) extern type *near array +#define DECLARE(type, array, size) type *near array +#define ALLOC(type, array, size) \ + { \ + array = (type *)fcalloc((size_t)(((size) + 1L) / 2), \ + 2 * sizeof(type)); \ + if (array == NULL) \ + error("insufficient memory"); \ + } +#define FREE(array) \ + { \ + if (array != NULL) \ + fcfree(array), array = NULL; \ + } +#else +#define EXTERN(type, array) extern type array[] +#define DECLARE(type, array, size) type array[size] +#define ALLOC(type, array, size) +#define FREE(array) +#endif + +EXTERN(uch, inbuf); /* input buffer */ +EXTERN(uch, outbuf); /* output buffer */ +EXTERN(ush, d_buf); /* buffer for distances, see trees.c */ +EXTERN(uch, window); /* Sliding window and suffix table (unlzw) */ +#define tab_suffix window +#ifndef MAXSEG_64K +#define tab_prefix prev /* hash link (see deflate.c) */ +#define head (prev + WSIZE) /* hash head (see deflate.c) */ +EXTERN(ush, tab_prefix); /* prefix code (see unlzw.c) */ +#else +#define tab_prefix0 prev +#define head tab_prefix1 +EXTERN(ush, tab_prefix0); /* prefix for even codes */ +EXTERN(ush, tab_prefix1); /* prefix for odd codes */ +#endif + +extern unsigned insize; /* valid bytes in inbuf */ +extern unsigned inptr; /* index of next byte to be processed in inbuf */ +extern unsigned outcnt; /* bytes in output buffer */ + +extern long bytes_in; /* number of input bytes */ +extern long bytes_out; /* number of output bytes */ +extern long header_bytes; /* number of bytes in gzip header */ + +#define isize bytes_in +/* for compatibility with old zip sources (to be cleaned) */ + +extern int ifd; /* input file descriptor */ +extern int ofd; /* output file descriptor */ +extern char ifname[]; /* input file name or "stdin" */ +extern char ofname[]; /* output file name or "stdout" */ +extern char *progname; /* program name */ + +extern time_t time_stamp; /* original time stamp (modification time) */ +extern long ifile_size; /* input file size, -1 for devices (debug only) */ + +typedef int file_t; /* Do not use stdio */ +#define NO_FILE (-1) /* in memory compression */ + +#define PACK_MAGIC "\037\036" /* Magic header for packed files */ +#define GZIP_MAGIC "\037\213" /* Magic header for gzip files, 1F 8B */ +#define OLD_GZIP_MAGIC "\037\236" /* Magic header for gzip 0.5 = freeze 1.x */ +#define LZH_MAGIC "\037\240" /* Magic header for SCO LZH Compress files*/ +#define PKZIP_MAGIC "\120\113\003\004" /* Magic header for pkzip files */ + +/* gzip flag byte */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +#define CONTINUATION \ + 0x02 /* bit 1 set: continuation of multi-part gzip file \ + */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ +#define RESERVED 0xC0 /* bit 6,7: reserved */ + +/* internal file attribute */ +#define UNKNOWN 0xffff +#define BINARY 0 +#define ASCII 1 + +#ifndef WSIZE +#define WSIZE 0x8000 /* window size--must be a power of two, and */ +#endif /* at least 32K for zip's deflate method */ + +#define MIN_MATCH 3 +#define MAX_MATCH 258 +/* The minimum and maximum match lengths */ + +#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +#define MAX_DIST (WSIZE - MIN_LOOKAHEAD) +/* In order to simplify the code, particularly on 16 bit machines, match + * distances are limited to MAX_DIST instead of WSIZE. + */ + +extern int decrypt; /* flag to turn on decryption */ +extern int exit_code; /* program exit code */ +extern int verbose; /* be verbose (-v) */ +extern int quiet; /* be quiet (-q) */ +extern int level; /* compression level */ +extern int test; /* check .z file integrity */ +extern int to_stdout; /* output to stdout (-c) */ +extern int save_orig_name; /* set if original name must be saved */ + +#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf(0)) +#define try_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf(1)) + +/* put_byte is used for the compressed output, put_ubyte for the + * uncompressed output. However unlzw() uses window for its + * suffix table instead of its output buffer, so it does not use put_ubyte + * (to be cleaned up). + */ +#define put_byte(c) \ + { \ + outbuf[outcnt++] = (uch)(c); \ + if (outcnt == OUTBUFSIZ) \ + flush_outbuf(); \ + } +#define put_ubyte(c) \ + { \ + window[outcnt++] = (uch)(c); \ + if (outcnt == WSIZE) \ + flush_window(); \ + } + +/* Output a 16 bit value, lsb first */ +#define put_short(w) \ + { \ + if (outcnt < OUTBUFSIZ - 2) { \ + outbuf[outcnt++] = (uch)((w) & 0xff); \ + outbuf[outcnt++] = (uch)((ush)(w) >> 8); \ + } else { \ + put_byte((uch)((w) & 0xff)); \ + put_byte((uch)((ush)(w) >> 8)); \ + } \ + } + +/* Output a 32 bit value to the bit stream, lsb first */ +#define put_long(n) \ + { \ + put_short((n) & 0xffff); \ + put_short(((ulg)(n)) >> 16); \ + } + +#define seekable() 0 /* force sequential output */ +#define translate_eol 0 /* no option -a yet */ + +#define tolow(c) \ + (isupper(c) ? (c) - 'A' + 'a' : (c)) /* force to lower case \ + */ + +/* Macros for getting two-byte and four-byte header values */ +#define SH(p) ((ush)(uch)((p)[0]) | ((ush)(uch)((p)[1]) << 8)) +#define LG(p) ((ulg)(SH(p)) | ((ulg)(SH((p) + 2)) << 16)) + +/* Diagnostic functions */ +#ifdef DEBUG +#define Assert(cond, msg) \ + { \ + if (!(cond)) \ + error(msg); \ + } +#define Trace(x) fprintf x +#define Tracev(x) \ + { \ + if (verbose) \ + fprintf x; \ + } +#define Tracevv(x) \ + { \ + if (verbose > 1) \ + fprintf x; \ + } +#define Tracec(c, x) \ + { \ + if (verbose && (c)) \ + fprintf x; \ + } +#define Tracecv(c, x) \ + { \ + if (verbose > 1 && (c)) \ + fprintf x; \ + } +#else +#define Assert(cond, msg) +#define Trace(x) +#define Tracev(x) +#define Tracevv(x) +#define Tracec(c, x) +#define Tracecv(c, x) +#endif + +#define WARN(msg) \ + { \ + if (!quiet) \ + fprintf msg; \ + if (exit_code == OK) \ + exit_code = WARNING; \ + } + +/* in zip.c: */ +extern int zip OF((int in, int out)); +extern int file_read OF((char *buf, unsigned size)); + +/* in unzip.c */ +extern int unzip OF((int in, int out)); +extern int check_zipfile OF((int in)); + +/* in gzip.c */ +void abort_gzip OF((void)); + +/* in deflate.c */ +void lm_init OF((int pack_level, ush *flags)); +ulg deflate OF((void)); + +/* in trees.c */ +void ct_init OF((ush * attr, int *method)); +int ct_tally OF((int dist, int lc)); +ulg flush_block OF((char *buf, ulg stored_len, int eof)); + +/* in bits.c */ +void bi_init OF((file_t zipfile)); +void send_bits OF((int value, int length)); +unsigned bi_reverse OF((unsigned value, int length)); +void bi_windup OF((void)); +void copy_block OF((char *buf, unsigned len, int header)); +extern int(*read_buf) OF((char *buf, unsigned size)); + +/* in util.c: */ +extern int copy OF((int in, int out)); +extern ulg updcrc OF((uch * s, unsigned n)); +extern void clear_bufs OF((void)); +extern int fill_inbuf OF((int eof_ok)); +extern void flush_outbuf OF((void)); +extern void flush_window OF((void)); +extern void write_buf OF((int fd, voidp buf, unsigned cnt)); +extern char *strlwr OF((char *s)); +extern char *basename OF((char *fname)); +extern void make_simple_name OF((char *name)); +extern char *add_envopt OF((int *argcp, char ***argvp, char *env)); +extern void error OF((char *m)); +extern void warn OF((char *a, char *b)); +extern void read_error OF((void)); +extern void write_error OF((void)); +extern void display_ratio OF((long num, long den, FILE *file)); +extern voidp xmalloc OF((unsigned int size)); + +/* in inflate.c */ +extern int inflate OF((void)); + +/* stuff from lzw.h */ +#ifndef BITS +#define BITS 16 +#endif diff --git a/bin/gzip/inflate.c b/bin/gzip/inflate.c new file mode 100644 index 00000000..a2235515 --- /dev/null +++ b/bin/gzip/inflate.c @@ -0,0 +1,916 @@ +/* inflate.c -- Not copyrighted 1992 by Mark Adler + version c10p1, 10 January 1993 */ + +/* You can do whatever you like with this source file, though I would + prefer that if you modify it and redistribute it that you include + comments to that effect with your name and the date. Thank you. + [The history has been moved to the file ChangeLog.] + */ + +/* + Inflate deflated (PKZIP's method 8 compressed) data. The compression + method searches for as much of the current string of bytes (up to a + length of 258) in the previous 32K bytes. If it doesn't find any + matches (of at least length 3), it codes the next byte. Otherwise, it + codes the length of the matched string and its distance backwards from + the current position. There is a single Huffman code that codes both + single bytes (called "literals") and match lengths. A second Huffman + code codes the distance information, which follows a length code. Each + length or distance code actually represents a base value and a number + of "extra" (sometimes zero) bits to get to add to the base value. At + the end of each deflated block is a special end-of-block (EOB) literal/ + length code. The decoding process is basically: get a literal/length + code; if EOB then done; if a literal, emit the decoded byte; if a + length then get the distance and emit the referred-to bytes from the + sliding window of previously emitted data. + + There are (currently) three kinds of inflate blocks: stored, fixed, and + dynamic. The compressor deals with some chunk of data at a time, and + decides which method to use on a chunk-by-chunk basis. A chunk might + typically be 32K or 64K. If the chunk is uncompressible, then the + "stored" method is used. In this case, the bytes are simply stored as + is, eight bits per byte, with none of the above coding. The bytes are + preceded by a count, since there is no longer an EOB code. + + If the data is compressible, then either the fixed or dynamic methods + are used. In the dynamic method, the compressed data is preceded by + an encoding of the literal/length and distance Huffman codes that are + to be used to decode this block. The representation is itself Huffman + coded, and so is preceded by a description of that code. These code + descriptions take up a little space, and so for small blocks, there is + a predefined set of codes, called the fixed codes. The fixed method is + used if the block codes up smaller that way (usually for quite small + chunks), otherwise the dynamic method is used. In the latter case, the + codes are customized to the probabilities in the current block, and so + can code it much better than the pre-determined fixed codes. + + The Huffman codes themselves are decoded using a mutli-level table + lookup, in order to maximize the speed of decoding plus the speed of + building the decoding tables. See the comments below that precede the + lbits and dbits tuning parameters. + */ + +/* + Notes beyond the 1.93a appnote.txt: + + 1. Distance pointers never point before the beginning of the output + stream. + 2. Distance pointers can point back across blocks, up to 32k away. + 3. There is an implied maximum of 7 bits for the bit length table and + 15 bits for the actual data. + 4. If only one code exists, then it is encoded using one bit. (Zero + would be more efficient, but perhaps a little confusing.) If two + codes exist, they are coded using one bit each (0 and 1). + 5. There is no way of sending zero distance codes--a dummy must be + sent if there are none. (History: a pre 2.0 version of PKZIP would + store blocks with no distance codes, but this was discovered to be + too harsh a criterion.) Valid only for 1.93a. 2.04c does allow + zero distance codes, which is sent as one code of zero bits in + length. + 6. There are up to 286 literal/length codes. Code 256 represents the + end-of-block. Note however that the static length tree defines + 288 codes just to fill out the Huffman codes. Codes 286 and 287 + cannot be used though, since there is no length base or extra bits + defined for them. Similarly, there are up to 30 distance codes. + However, static trees define 32 codes (all 5 bits) to fill out the + Huffman codes, but the last two had better not show up in the data. + 7. Unzip can check dynamic Huffman blocks for complete code sets. + The exception is that a single code would not be complete (see #4). + 8. The five bits following the block type is really the number of + literal codes sent minus 257. + 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits + (1+6+6). Therefore, to output three times the length, you output + three codes (1+1+1), whereas to output four times the same length, + you only need two codes (1+3). Hmm. + 10. In the tree reconstruction algorithm, Code = Code + Increment + only if BitLength(i) is not zero. (Pretty obvious.) + 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19) + 12. Note: length code 284 can represent 227-258, but length code 285 + really is 258. The last length deserves its own, short code + since it gets used a lot in very redundant files. The length + 258 is special since 258 - 3 (the min match length) is 255. + 13. The literal/length and distance code bit lengths are read as a + single stream of lengths. It is possible (and advantageous) for + a repeat code (16, 17, or 18) to go across the boundary between + the two sets of lengths. + */ + +#ifdef RCSID +static char rcsid[] = "$Id: inflate.c,v 1.1 2002/08/18 00:59:21 hpa Exp $"; +#endif + +#include <sys/types.h> +#include <stdlib.h> + +#include "tailor.h" +#include "gzip.h" +#define slide window + +/* Huffman code lookup table entry--this entry is four bytes for machines + that have 16-bit pointers (e.g. PC's in the small or medium model). + Valid extra bits are 0..13. e == 15 is EOB (end of block), e == 16 + means that v is a literal, 16 < e < 32 means that v is a pointer to + the next table, which codes e - 16 bits, and lastly e == 99 indicates + an unused code. If a code with e == 99 is looked up, this implies an + error in the data. */ +struct huft { + uch e; /* number of extra bits or operation */ + uch b; /* number of bits in this code or subcode */ + union { + ush n; /* literal, length base, or distance base */ + struct huft *t; /* pointer to next level of table */ + } v; +}; + +/* Function prototypes */ +int huft_build OF((unsigned *, unsigned, unsigned, ush *, ush *, struct huft **, + int *)); +int huft_free OF((struct huft *)); +int inflate_codes OF((struct huft *, struct huft *, int, int)); +int inflate_stored OF((void)); +int inflate_fixed OF((void)); +int inflate_dynamic OF((void)); +int inflate_block OF((int *)); +int inflate OF((void)); + +/* The inflate algorithm uses a sliding 32K byte window on the uncompressed + stream to find repeated byte strings. This is implemented here as a + circular buffer. The index is updated simply by incrementing and then + and'ing with 0x7fff (32K-1). */ +/* It is left to other modules to supply the 32K area. It is assumed + to be usable as if it were declared "uch slide[32768];" or as just + "uch *slide;" and then malloc'ed in the latter case. The definition + must be in unzip.h, included above. */ +/* unsigned wp; current position in slide */ +#define wp outcnt +#define flush_output(w) (wp = (w), flush_window()) + +/* Tables for deflate from PKZIP's appnote.txt. */ +static unsigned border[] = { /* Order of the bit length code lengths */ + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, + 11, 4, 12, 3, 13, 2, 14, 1, 15 +}; +static ush cplens[] = { /* Copy lengths for literal codes 257..285 */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, + 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, + 99, 115, 131, 163, 195, 227, 258, 0, 0 +}; +/* note: see note #13 above about the 258 in this list. */ +static ush cplext[] = { /* Extra bits for literal codes 257..285 */ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, + 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99 +}; /* 99==invalid */ +static ush cpdist[] = { /* Copy offsets for distance codes 0..29 */ + 1, 2, 3, 4, 5, 7, 9, 13, + 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, + 4097, 6145, 8193, 12289, 16385, 24577 +}; +static ush cpdext[] = { /* Extra bits for distance codes */ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, + 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 +}; + +/* Macros for inflate() bit peeking and grabbing. + The usage is: + + NEEDBITS(j) + x = b & mask_bits[j]; + DUMPBITS(j) + + where NEEDBITS makes sure that b has at least j bits in it, and + DUMPBITS removes the bits from b. The macros use the variable k + for the number of bits in b. Normally, b and k are register + variables for speed, and are initialized at the beginning of a + routine that uses these macros from a global bit buffer and count. + + If we assume that EOB will be the longest code, then we will never + ask for bits with NEEDBITS that are beyond the end of the stream. + So, NEEDBITS should not read any more bytes than are needed to + meet the request. Then no bytes need to be "returned" to the buffer + at the end of the last block. + + However, this assumption is not true for fixed blocks--the EOB code + is 7 bits, but the other literal/length codes can be 8 or 9 bits. + (The EOB code is shorter than other codes because fixed blocks are + generally short. So, while a block always has an EOB, many other + literal/length codes have a significantly lower probability of + showing up at all.) However, by making the first table have a + lookup of seven bits, the EOB code will be found in that first + lookup, and so will not require that too many bits be pulled from + the stream. + */ + +ulg bb; /* bit buffer */ +unsigned bk; /* bits in bit buffer */ + +ush mask_bits[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, + 0x003f, 0x007f, 0x00ff, 0x01ff, 0x03ff, 0x07ff, + 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff }; + +#ifdef CRYPT +uch cc; +#define NEXTBYTE() (decrypt ? (cc = get_byte(), cc) : get_byte()) +#else +#define NEXTBYTE() (uch) get_byte() +#endif +#define NEEDBITS(n) \ + { \ + while (k < (n)) { \ + b |= ((ulg)NEXTBYTE()) << k; \ + k += 8; \ + } \ + } +#define DUMPBITS(n) \ + { \ + b >>= (n); \ + k -= (n); \ + } + +/* + Huffman code decoding is performed using a multi-level table lookup. + The fastest way to decode is to simply build a lookup table whose + size is determined by the longest code. However, the time it takes + to build this table can also be a factor if the data being decoded + is not very long. The most common codes are necessarily the + shortest codes, so those codes dominate the decoding time, and hence + the speed. The idea is you can have a shorter table that decodes the + shorter, more probable codes, and then point to subsidiary tables for + the longer codes. The time it costs to decode the longer codes is + then traded against the time it takes to make longer tables. + + This results of this trade are in the variables lbits and dbits + below. lbits is the number of bits the first level table for literal/ + length codes can decode in one step, and dbits is the same thing for + the distance codes. Subsequent tables are also less than or equal to + those sizes. These values may be adjusted either when all of the + codes are shorter than that, in which case the longest code length in + bits is used, or when the shortest code is *longer* than the requested + table size, in which case the length of the shortest code in bits is + used. + + There are two different values for the two tables, since they code a + different number of possibilities each. The literal/length table + codes 286 possible values, or in a flat code, a little over eight + bits. The distance table codes 30 possible values, or a little less + than five bits, flat. The optimum values for speed end up being + about one bit more than those, so lbits is 8+1 and dbits is 5+1. + The optimum values may differ though from machine to machine, and + possibly even between compilers. Your mileage may vary. + */ + +int lbits = 9; /* bits in base literal/length lookup table */ +int dbits = 6; /* bits in base distance lookup table */ + +/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */ +#define BMAX 16 /* maximum bit length of any code (16 for explode) */ +#define N_MAX 288 /* maximum number of codes in any set */ + +unsigned hufts; /* track memory usage */ + +int huft_build(b, n, s, d, e, t, m) +unsigned *b; /* code lengths in bits (all assumed <= BMAX) */ +unsigned n; /* number of codes (assumed <= N_MAX) */ +unsigned s; /* number of simple-valued codes (0..s-1) */ +ush *d; /* list of base values for non-simple codes */ +ush *e; /* list of extra bits for non-simple codes */ +struct huft **t; /* result: starting table */ +int *m; /* maximum lookup bits, returns actual */ +/* Given a list of code lengths and a maximum table size, make a set of + tables to decode that set of codes. Return zero on success, one if + the given code set is incomplete (the tables are still built in this + case), two if the input is invalid (all zero length codes or an + oversubscribed set of lengths), and three if not enough memory. */ +{ + unsigned a; /* counter for codes of length k */ + unsigned c[BMAX + 1]; /* bit length count table */ + unsigned f; /* i repeats in table every f entries */ + int g; /* maximum code length */ + int h; /* table level */ + register unsigned i; /* counter, current code */ + register unsigned j; /* counter */ + register int k; /* number of bits in current code */ + int l; /* bits per table (returned in m) */ + register unsigned *p; /* pointer into c[], b[], or v[] */ + register struct huft *q; /* points to current table */ + struct huft r; /* table entry for structure assignment */ + struct huft *u[BMAX]; /* table stack */ + unsigned v[N_MAX]; /* values in order of bit length */ + register int w; /* bits before this table == (l * h) */ + unsigned x[BMAX + 1]; /* bit offsets, then code stack */ + unsigned *xp; /* pointer into x */ + int y; /* number of dummy codes added */ + unsigned z; /* number of entries in current table */ + + /* Generate counts for each bit length */ + memzero(c, sizeof(c)); + p = b; + i = n; + do { + Tracecv(*p, (stderr, + (n - i >= ' ' && n - i <= '~' ? "%c %d\n" : + "0x%x %d\n"), + n - i, *p)); + c[*p]++; /* assume all entries <= BMAX */ + p++; /* Can't combine with above line (Solaris bug) */ + } while (--i); + if (c[0] == n) /* null input--all zero length codes */ + { + *t = (struct huft *)NULL; + *m = 0; + return 0; + } + + /* Find minimum and maximum length, bound *m by those */ + l = *m; + for (j = 1; j <= BMAX; j++) + if (c[j]) + break; + k = j; /* minimum code length */ + if ((unsigned)l < j) + l = j; + for (i = BMAX; i; i--) + if (c[i]) + break; + g = i; /* maximum code length */ + if ((unsigned)l > i) + l = i; + *m = l; + + /* Adjust last length count to fill out codes, if needed */ + for (y = 1 << j; j < i; j++, y <<= 1) + if ((y -= c[j]) < 0) + return 2; /* bad input: more codes than bits */ + if ((y -= c[i]) < 0) + return 2; + c[i] += y; + + /* Generate starting offsets into the value table for each length */ + x[1] = j = 0; + p = c + 1; + xp = x + 2; + while (--i) { /* note that i == g from above */ + *xp++ = (j += *p++); + } + + /* Make a table of values in order of bit lengths */ + p = b; + i = 0; + do { + if ((j = *p++) != 0) + v[x[j]++] = i; + } while (++i < n); + + /* Generate the Huffman codes and for each, make the table entries */ + x[0] = i = 0; /* first Huffman code is zero */ + p = v; /* grab values in bit order */ + h = -1; /* no tables yet--level -1 */ + w = -l; /* bits decoded == (l * h) */ + u[0] = (struct huft *)NULL; /* just to keep compilers happy */ + q = (struct huft *)NULL; /* ditto */ + z = 0; /* ditto */ + + /* go through the bit lengths (k already is bits in shortest code) */ + for (; k <= g; k++) { + a = c[k]; + while (a--) { + /* here i is the Huffman code of length k bits for value + * *p */ + /* make tables up to required level */ + while (k > w + l) { + h++; + w += l; /* previous table always l bits */ + + /* compute minimum size table less than or equal + * to l bits */ + z = (z = g - w) > (unsigned)l ? + (unsigned)l : + z; /* upper limit on table size */ + if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w + bit table + */ + { /* too few codes for k-w bit table */ + f -= a + 1; /* deduct codes from + patterns left */ + xp = c + k; + while (++j < z) /* try smaller tables up + to z bits */ + { + if ((f <<= 1) <= *++xp) + break; /* enough codes + to use up j + bits */ + f -= *xp; /* else deduct codes + from patterns */ + } + } + z = 1 << j; /* table entries for j-bit table */ + + /* allocate and link in new table */ + if ((q = (struct huft *)malloc( + (z + 1) * sizeof(struct huft))) == + (struct huft *)NULL) { + if (h) + huft_free(u[0]); + return 3; /* not enough memory */ + } + hufts += z + 1; /* track memory usage */ + *t = q + 1; /* link to list for huft_free() */ + *(t = &(q->v.t)) = (struct huft *)NULL; + u[h] = ++q; /* table starts after link */ + + /* connect to last table, if there is one */ + if (h) { + x[h] = i; /* save pattern for backing up + */ + r.b = (uch)l; /* bits to dump before + this table */ + r.e = (uch)(16 + j); /* bits in this + table */ + r.v.t = q; /* pointer to this table */ + j = i >> (w - l); /* (get around Turbo C + bug) */ + u[h - 1][j] = r; /* connect to last + table */ + } + } + + /* set up table entry in r */ + r.b = (uch)(k - w); + if (p >= v + n) + r.e = 99; /* out of values--invalid code */ + else if (*p < s) { + r.e = (uch)(*p < 256 ? 16 : 15); /* 256 is + end-of-block + code */ + r.v.n = (ush)(*p); /* simple code is just the + value */ + p++; /* one compiler does not like *p++ */ + } else { + r.e = (uch)e[*p - s]; /* non-simple--look up in + lists */ + r.v.n = d[*p++ - s]; + } + + /* fill code-like entries with r */ + f = 1 << (k - w); + for (j = i >> w; j < z; j += f) + q[j] = r; + + /* backwards increment the k-bit code i */ + for (j = 1 << (k - 1); i & j; j >>= 1) + i ^= j; + i ^= j; + + /* backup over finished tables */ + while ((i & ((1 << w) - 1)) != x[h]) { + h--; /* don't need to update q */ + w -= l; + } + } + } + + /* Return true (1) if we were given an incomplete table */ + return y != 0 && g != 1; +} + +int huft_free(t) +struct huft *t; /* table to free */ +/* Free the malloc'ed tables built by huft_build(), which makes a linked + list of the tables it made, with the links in a dummy first entry of + each table. */ +{ + register struct huft *p, *q; + + /* Go through linked list, freeing from the malloced (t[-1]) address. */ + p = t; + while (p != (struct huft *)NULL) { + q = (--p)->v.t; + free((char *)p); + p = q; + } + return 0; +} + +int inflate_codes(tl, td, bl, bd) +struct huft *tl, *td; /* literal/length and distance decoder tables */ +int bl, bd; /* number of bits decoded by tl[] and td[] */ +/* inflate (decompress) the codes in a deflated (compressed) block. + Return an error code or zero if it all goes ok. */ +{ + register unsigned e; /* table entry flag/number of extra bits */ + unsigned n, d; /* length and index for copy */ + unsigned w; /* current window position */ + struct huft *t; /* pointer to table entry */ + unsigned ml, md; /* masks for bl and bd bits */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + /* make local copies of globals */ + b = bb; /* initialize bit buffer */ + k = bk; + w = wp; /* initialize window position */ + + /* inflate the coded data */ + ml = mask_bits[bl]; /* precompute masks for speed */ + md = mask_bits[bd]; + for (;;) /* do until end of block */ + { + NEEDBITS((unsigned)bl) + if ((e = (t = tl + ((unsigned)b & ml))->e) > 16) + do { + if (e == 99) + return 1; + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ( + (e = (t = t->v.t + ((unsigned)b & mask_bits[e])) + ->e) > 16); + DUMPBITS(t->b) + if (e == 16) /* then it's a literal */ + { + slide[w++] = (uch)t->v.n; + Tracevv((stderr, "%c", slide[w - 1])); + if (w == WSIZE) { + flush_output(w); + w = 0; + } + } else /* it's an EOB or a length */ + { + /* exit if end of block */ + if (e == 15) + break; + + /* get length of block to copy */ + NEEDBITS(e) + n = t->v.n + ((unsigned)b & mask_bits[e]); + DUMPBITS(e); + + /* decode distance of block to copy */ + NEEDBITS((unsigned)bd) + if ((e = (t = td + ((unsigned)b & md))->e) > 16) + do { + if (e == 99) + return 1; + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ((e = (t = t->v.t + + ((unsigned)b & mask_bits[e])) + ->e) > 16); + DUMPBITS(t->b) + NEEDBITS(e) + d = w - t->v.n - ((unsigned)b & mask_bits[e]); + DUMPBITS(e) + Tracevv((stderr, "\\[%d,%d]", w - d, n)); + + /* do the copy */ + do { + n -= (e = (e = WSIZE - + ((d &= WSIZE - 1) > w ? d : w)) > + n ? + n : + e); +#if !defined(NOMEMCPY) && !defined(DEBUG) + if (w - d >= e) /* (this test assumes unsigned + comparison) */ + { + memcpy(slide + w, slide + d, e); + w += e; + d += e; + } else /* do it slow to avoid memcpy() overlap + */ +#endif /* !NOMEMCPY */ + do { + slide[w++] = slide[d++]; + Tracevv((stderr, "%c", + slide[w - 1])); + } while (--e); + if (w == WSIZE) { + flush_output(w); + w = 0; + } + } while (n); + } + } + + /* restore the globals from the locals */ + wp = w; /* restore global window pointer */ + bb = b; /* restore global bit buffer */ + bk = k; + + /* done */ + return 0; +} + +int inflate_stored() +/* "decompress" an inflated type 0 (stored) block. */ +{ + unsigned n; /* number of bytes in block */ + unsigned w; /* current window position */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + /* make local copies of globals */ + b = bb; /* initialize bit buffer */ + k = bk; + w = wp; /* initialize window position */ + + /* go to byte boundary */ + n = k & 7; + DUMPBITS(n); + + /* get the length and its complement */ + NEEDBITS(16) + n = ((unsigned)b & 0xffff); + DUMPBITS(16) + NEEDBITS(16) + if (n != (unsigned)((~b) & 0xffff)) + return 1; /* error in compressed data */ + DUMPBITS(16) + + /* read and output the compressed data */ + while (n--) { + NEEDBITS(8) + slide[w++] = (uch)b; + if (w == WSIZE) { + flush_output(w); + w = 0; + } + DUMPBITS(8) + } + + /* restore the globals from the locals */ + wp = w; /* restore global window pointer */ + bb = b; /* restore global bit buffer */ + bk = k; + return 0; +} + +int inflate_fixed() +/* decompress an inflated type 1 (fixed Huffman codes) block. We should + either replace this with a custom decoder, or at least precompute the + Huffman tables. */ +{ + int i; /* temporary variable */ + struct huft *tl; /* literal/length code table */ + struct huft *td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + unsigned l[288]; /* length list for huft_build */ + + /* set up literal table */ + for (i = 0; i < 144; i++) + l[i] = 8; + for (; i < 256; i++) + l[i] = 9; + for (; i < 280; i++) + l[i] = 7; + for (; i < 288; i++) /* make a complete, but wrong code set */ + l[i] = 8; + bl = 7; + if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) + return i; + + /* set up distance table */ + for (i = 0; i < 30; i++) /* make an incomplete code set */ + l[i] = 5; + bd = 5; + if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) { + huft_free(tl); + return i; + } + + /* decompress until an end-of-block code */ + if (inflate_codes(tl, td, bl, bd)) + return 1; + + /* free the decoding tables, return */ + huft_free(tl); + huft_free(td); + return 0; +} + +int inflate_dynamic() +/* decompress an inflated type 2 (dynamic Huffman codes) block. */ +{ + int i; /* temporary variables */ + unsigned j; + unsigned l; /* last length */ + unsigned m; /* mask for bit lengths table */ + unsigned n; /* number of lengths to get */ + struct huft *tl; /* literal/length code table */ + struct huft *td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + unsigned nb; /* number of bit length codes */ + unsigned nl; /* number of literal/length codes */ + unsigned nd; /* number of distance codes */ +#ifdef PKZIP_BUG_WORKAROUND + unsigned ll[288 + 32]; /* literal/length and distance code lengths */ +#else + unsigned ll[286 + 30]; /* literal/length and distance code lengths */ +#endif + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + /* make local bit buffer */ + b = bb; + k = bk; + + /* read in table lengths */ + NEEDBITS(5) + nl = 257 + ((unsigned)b & 0x1f); /* number of literal/length codes */ + DUMPBITS(5) + NEEDBITS(5) + nd = 1 + ((unsigned)b & 0x1f); /* number of distance codes */ + DUMPBITS(5) + NEEDBITS(4) + nb = 4 + ((unsigned)b & 0xf); /* number of bit length codes */ + DUMPBITS(4) +#ifdef PKZIP_BUG_WORKAROUND + if (nl > 288 || nd > 32) +#else + if (nl > 286 || nd > 30) +#endif + return 1; /* bad lengths */ + + /* read in bit-length-code lengths */ + for (j = 0; j < nb; j++) { + NEEDBITS(3) + ll[border[j]] = (unsigned)b & 7; + DUMPBITS(3) + } + for (; j < 19; j++) + ll[border[j]] = 0; + + /* build decoding table for trees--single level, 7 bit lookup */ + bl = 7; + if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0) { + if (i == 1) + huft_free(tl); + return i; /* incomplete code set */ + } + + /* read in literal and distance code lengths */ + n = nl + nd; + m = mask_bits[bl]; + i = l = 0; + while ((unsigned)i < n) { + NEEDBITS((unsigned)bl) + j = (td = tl + ((unsigned)b & m))->b; + DUMPBITS(j) + j = td->v.n; + if (j < 16) /* length of code in bits (0..15) */ + ll[i++] = l = j; /* save last length in l */ + else if (j == 16) /* repeat last length 3 to 6 times */ + { + NEEDBITS(2) + j = 3 + ((unsigned)b & 3); + DUMPBITS(2) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = l; + } else if (j == 17) /* 3 to 10 zero length codes */ + { + NEEDBITS(3) + j = 3 + ((unsigned)b & 7); + DUMPBITS(3) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = 0; + l = 0; + } else /* j == 18: 11 to 138 zero length codes */ + { + NEEDBITS(7) + j = 11 + ((unsigned)b & 0x7f); + DUMPBITS(7) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = 0; + l = 0; + } + } + + /* free decoding table for trees */ + huft_free(tl); + + /* restore the global bit buffer */ + bb = b; + bk = k; + + /* build the decoding tables for literal/length and distance codes */ + bl = lbits; + if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) { + if (i == 1) { + fprintf(stderr, " incomplete literal tree\n"); + huft_free(tl); + } + return i; /* incomplete code set */ + } + bd = dbits; + if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) { + if (i == 1) { + fprintf(stderr, " incomplete distance tree\n"); +#ifdef PKZIP_BUG_WORKAROUND + i = 0; + } +#else + huft_free(td); + } + huft_free(tl); + return i; /* incomplete code set */ +#endif + } + + /* decompress until an end-of-block code */ + if (inflate_codes(tl, td, bl, bd)) + return 1; + + /* free the decoding tables, return */ + huft_free(tl); + huft_free(td); + return 0; +} + +int inflate_block(e) +int *e; /* last block flag */ +/* decompress an inflated block */ +{ + unsigned t; /* block type */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + /* make local bit buffer */ + b = bb; + k = bk; + + /* read in last block bit */ + NEEDBITS(1) + *e = (int)b & 1; + DUMPBITS(1) + + /* read in block type */ + NEEDBITS(2) + t = (unsigned)b & 3; + DUMPBITS(2) + + /* restore the global bit buffer */ + bb = b; + bk = k; + + /* inflate that block type */ + if (t == 2) + return inflate_dynamic(); + if (t == 0) + return inflate_stored(); + if (t == 1) + return inflate_fixed(); + + /* bad block type */ + return 2; +} + +int inflate() +/* decompress an inflated entry */ +{ + int e; /* last block flag */ + int r; /* result code */ + unsigned h; /* maximum struct huft's malloc'ed */ + + /* initialize window, bit buffer */ + wp = 0; + bk = 0; + bb = 0; + + /* decompress until the last block */ + h = 0; + do { + hufts = 0; + if ((r = inflate_block(&e)) != 0) + return r; + if (hufts > h) + h = hufts; + } while (!e); + + /* Undo too much lookahead. The next read will be byte aligned so we + * can discard unused bits in the last meaningful byte. + */ + while (bk >= 8) { + bk -= 8; + inptr--; + } + + /* flush out slide */ + flush_output(wp); + + /* return success */ +#ifdef DEBUG + fprintf(stderr, "<%u> ", h); +#endif /* DEBUG */ + return 0; +} diff --git a/bin/gzip/revision.h b/bin/gzip/revision.h new file mode 100644 index 00000000..f248f92a --- /dev/null +++ b/bin/gzip/revision.h @@ -0,0 +1,11 @@ +/* revision.h -- define the version number + * Copyright (C) 1992-1993 Jean-loup Gailly. + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +#define VERSION "1.2.4" +#define PATCHLEVEL 0 +#define REVDATE "18 Aug 93" + +/* $Id: revision.h,v 1.1 2002/08/18 00:59:21 hpa Exp $ */ diff --git a/bin/gzip/tailor.h b/bin/gzip/tailor.h new file mode 100644 index 00000000..77129591 --- /dev/null +++ b/bin/gzip/tailor.h @@ -0,0 +1,50 @@ +/* tailor.h -- target dependent definitions + * Copyright (C) 1992-1993 Jean-loup Gailly. + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +/* The target dependent definitions should be defined here only. + * The target dependent functions should be defined in tailor.c. + */ + +/* $Id: tailor.h,v 1.1 2002/08/18 00:59:21 hpa Exp $ */ + +/* Common defaults */ + +#ifndef OS_CODE +#define OS_CODE 0x03 /* assume Unix */ +#endif + +#define PATH_SEP '/' + +#ifndef casemap +#define casemap(c) (c) +#endif + +#ifndef OPTIONS_VAR +#define OPTIONS_VAR "GZIP" +#endif + +#ifndef Z_SUFFIX +#define Z_SUFFIX ".gz" +#endif + +#define MAX_SUFFIX 30 + +#ifndef MIN_PART +#define MIN_PART 3 +/* keep at least MIN_PART chars between dots in a file name. */ +#endif + +#ifndef RECORD_IO +#define RECORD_IO 0 +#endif + +#ifndef get_char +#define get_char() get_byte() +#endif + +#ifndef put_char +#define put_char(c) put_byte(c) +#endif diff --git a/bin/gzip/trees.c b/bin/gzip/trees.c new file mode 100644 index 00000000..28d2e236 --- /dev/null +++ b/bin/gzip/trees.c @@ -0,0 +1,1147 @@ +/* trees.c -- output deflated data using Huffman coding + * Copyright (C) 1992-1993 Jean-loup Gailly + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +/* + * PURPOSE + * + * Encode various sets of source values using variable-length + * binary code trees. + * + * DISCUSSION + * + * The PKZIP "deflation" process uses several Huffman trees. The more + * common source values are represented by shorter bit sequences. + * + * Each code tree is stored in the ZIP file in a compressed form + * which is itself a Huffman encoding of the lengths of + * all the code strings (in ascending order by source values). + * The actual code strings are reconstructed from the lengths in + * the UNZIP process, as described in the "application note" + * (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program. + * + * REFERENCES + * + * Lynch, Thomas J. + * Data Compression: Techniques and Applications, pp. 53-55. + * Lifetime Learning Publications, 1985. ISBN 0-534-03418-7. + * + * Storer, James A. + * Data Compression: Methods and Theory, pp. 49-50. + * Computer Science Press, 1988. ISBN 0-7167-8156-5. + * + * Sedgewick, R. + * Algorithms, p290. + * Addison-Wesley, 1983. ISBN 0-201-06672-6. + * + * INTERFACE + * + * void ct_init (ush *attr, int *methodp) + * Allocate the match buffer, initialize the various tables and save + * the location of the internal file attribute (ascii/binary) and + * method (DEFLATE/STORE) + * + * void ct_tally (int dist, int lc); + * Save the match info and tally the frequency counts. + * + * long flush_block (char *buf, ulg stored_len, int eof) + * Determine the best encoding for the current block: dynamic trees, + * static trees or store, and output the encoded block to the zip + * file. Returns the total compressed length for the file so far. + * + */ + +#include <ctype.h> + +#include "tailor.h" +#include "gzip.h" + +#ifdef RCSID +static char rcsid[] = "$Id: trees.c,v 1.1 2002/08/18 00:59:21 hpa Exp $"; +#endif + +/* =========================================================================== + * Constants + */ + +#define MAX_BITS 15 +/* All codes must not exceed MAX_BITS bits */ + +#define MAX_BL_BITS 7 +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +#define LENGTH_CODES 29 +/* number of length codes, not counting the special END_BLOCK code */ + +#define LITERALS 256 +/* number of literal bytes 0..255 */ + +#define END_BLOCK 256 +/* end of block literal code */ + +#define L_CODES (LITERALS + 1 + LENGTH_CODES) +/* number of Literal or Length codes, including the END_BLOCK code */ + +#define D_CODES 30 +/* number of distance codes */ + +#define BL_CODES 19 +/* number of codes used to transfer the bit lengths */ + +local int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ + = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, + 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; + +local int extra_dbits[D_CODES] /* extra bits for each distance code */ + = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, + 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 }; + +local int extra_blbits[BL_CODES] /* extra bits for each bit length code */ + = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 }; + +#define STORED_BLOCK 0 +#define STATIC_TREES 1 +#define DYN_TREES 2 +/* The three kinds of block type */ + +#ifndef LIT_BUFSIZE +#ifdef SMALL_MEM +#define LIT_BUFSIZE 0x2000 +#else +#ifdef MEDIUM_MEM +#define LIT_BUFSIZE 0x4000 +#else +#define LIT_BUFSIZE 0x8000 +#endif +#endif +#endif +#ifndef DIST_BUFSIZE +#define DIST_BUFSIZE LIT_BUFSIZE +#endif +/* Sizes of match buffers for literals/lengths and distances. There are + * 4 reasons for limiting LIT_BUFSIZE to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input data is + * still in the window so we can still emit a stored block even when input + * comes from standard input. (This can also be done for all blocks if + * LIT_BUFSIZE is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting trees + * more frequently. + * - I can't count above 4 + * The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save + * memory at the expense of compression). Some optimizations would be possible + * if we rely on DIST_BUFSIZE == LIT_BUFSIZE. + */ +#if LIT_BUFSIZE > INBUFSIZ +error cannot overlay l_buf and inbuf +#endif + +#define REP_3_6 16 +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +#define REPZ_3_10 17 +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +#define REPZ_11_138 18 + /* repeat a zero length 11-138 times (7 bits of repeat count) */ + + /* =========================================================================== + * Local data + */ + + /* Data structure describing a single value and its code string. */ + typedef struct ct_data { + union { + ush freq; /* frequency count */ + ush code; /* bit string */ + } fc; + union { + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ + } dl; +} ct_data; + +#define Freq fc.freq +#define Code fc.code +#define Dad dl.dad +#define Len dl.len + +#define HEAP_SIZE (2 * L_CODES + 1) +/* maximum heap size */ + +local ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */ +local ct_data dyn_dtree[2 * D_CODES + 1]; /* distance tree */ + +local ct_data static_ltree[L_CODES + 2]; +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see ct_init + * below). + */ + +local ct_data static_dtree[D_CODES]; +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +local ct_data bl_tree[2 * BL_CODES + 1]; +/* Huffman tree for the bit lengths */ + +typedef struct tree_desc { + ct_data *dyn_tree; /* the dynamic tree */ + ct_data *static_tree; /* corresponding static tree or NULL */ + int *extra_bits; /* extra bits for each code or NULL */ + int extra_base; /* base index for extra_bits */ + int elems; /* max number of elements in the tree */ + int max_length; /* max bit length for the codes */ + int max_code; /* largest code with non zero frequency */ +} tree_desc; + +local tree_desc l_desc = { + dyn_ltree, static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS, 0 +}; + +local tree_desc d_desc = { dyn_dtree, static_dtree, extra_dbits, + 0, D_CODES, MAX_BITS, + 0 }; + +local tree_desc bl_desc = { bl_tree, (ct_data *)0, extra_blbits, + 0, BL_CODES, MAX_BL_BITS, + 0 }; + +local ush bl_count[MAX_BITS + 1]; +/* number of codes at each bit length for an optimal tree */ + +local uch bl_order[BL_CODES] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, + 11, 4, 12, 3, 13, 2, 14, 1, 15 }; +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +local int heap[2 * L_CODES + 1]; /* heap used to build the Huffman trees */ +local int heap_len; /* number of elements in the heap */ +local int heap_max; /* element of largest frequency */ +/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + +local uch depth[2 * L_CODES + 1]; +/* Depth of each subtree used as tie breaker for trees of equal frequency */ + +local uch length_code[MAX_MATCH - MIN_MATCH + 1]; +/* length code for each normalized match length (0 == MIN_MATCH) */ + +local uch dist_code[512]; +/* distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +local int base_length[LENGTH_CODES]; +/* First normalized length for each code (0 = MIN_MATCH) */ + +local int base_dist[D_CODES]; +/* First normalized distance for each code (0 = distance of 1) */ + +#define l_buf inbuf +/* DECLARE(uch, l_buf, LIT_BUFSIZE); buffer for literals or lengths */ + +/* DECLARE(ush, d_buf, DIST_BUFSIZE); buffer for distances */ + +local uch flag_buf[(LIT_BUFSIZE / 8)]; +/* flag_buf is a bit array distinguishing literals from lengths in + * l_buf, thus indicating the presence or absence of a distance. + */ + +local unsigned last_lit; /* running index in l_buf */ +local unsigned last_dist; /* running index in d_buf */ +local unsigned last_flags; /* running index in flag_buf */ +local uch flags; /* current flags not yet saved in flag_buf */ +local uch flag_bit; /* current bit used in flags */ +/* bits are filled in flags starting at bit 0 (least significant). + * Note: these flags are overkill in the current code since we don't + * take advantage of DIST_BUFSIZE == LIT_BUFSIZE. + */ + +local ulg opt_len; /* bit length of current block with optimal trees */ +local ulg static_len; /* bit length of current block with static trees */ + +local ulg compressed_len; /* total bit length of compressed file */ + +local ulg input_len; /* total byte length of input file */ +/* input_len is for debugging only since we can get it by other means. */ + +ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */ +int *file_method; /* pointer to DEFLATE or STORE */ + +#ifdef DEBUG +extern ulg bits_sent; /* bit length of the compressed data */ +extern long isize; /* byte length of input file */ +#endif + +extern long block_start; /* window offset of current block */ +extern unsigned strstart; /* window offset of current string */ + +/* =========================================================================== + * Local (static) routines in this file. + */ + +local void init_block OF((void)); +local void pqdownheap OF((ct_data * tree, int k)); +local void gen_bitlen OF((tree_desc * desc)); +local void gen_codes OF((ct_data * tree, int max_code)); +local void build_tree OF((tree_desc * desc)); +local void scan_tree OF((ct_data * tree, int max_code)); +local void send_tree OF((ct_data * tree, int max_code)); +local int build_bl_tree OF((void)); +local void send_all_trees OF((int lcodes, int dcodes, int blcodes)); +local void compress_block OF((ct_data * ltree, ct_data *dtree)); +local void set_file_type OF((void)); + +#ifndef DEBUG +#define send_code(c, tree) send_bits(tree[c].Code, tree[c].Len) +/* Send a code of the given tree. c and tree must not have side effects */ + +#else /* DEBUG */ +#define send_code(c, tree) \ + { \ + if (verbose > 1) \ + fprintf(stderr, "\ncd %3d ", (c)); \ + send_bits(tree[c].Code, tree[c].Len); \ + } +#endif + +#define d_code(dist) \ + ((dist) < 256 ? dist_code[dist] : dist_code[256 + ((dist) >> 7)]) +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. dist_code[256] and dist_code[257] are never + * used. + */ + +#define MAX(a, b) (a >= b ? a : b) +/* the arguments must not have side effects */ + +/* =========================================================================== + * Allocate the match buffer, initialize the various tables and save the + * location of the internal file attribute (ascii/binary) and method + * (DEFLATE/STORE). + */ +void ct_init(attr, methodp) ush *attr; /* pointer to internal file attribute */ +int *methodp; /* pointer to compression method */ +{ + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ + + file_type = attr; + file_method = methodp; + compressed_len = input_len = 0L; + + if (static_dtree[0].Len != 0) + return; /* ct_init already called */ + + /* Initialize the mapping length (0..255) -> length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES - 1; code++) { + base_length[code] = length; + for (n = 0; n < (1 << extra_lbits[code]); n++) { + length_code[length++] = (uch)code; + } + } + Assert(length == 256, "ct_init: length != 256"); + /* Note that the length 255 (match length 258) can be represented + * in two different ways: code 284 + 5 bits or code 285, so we + * overwrite length_code[255] to use the best encoding: + */ + length_code[length - 1] = (uch)code; + + /* Initialize the mapping dist (0..32K) -> dist code (0..29) */ + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1 << extra_dbits[code]); n++) { + dist_code[dist++] = (uch)code; + } + } + Assert(dist == 256, "ct_init: dist != 256"); + dist >>= 7; /* from now on, all distances are divided by 128 */ + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { + dist_code[256 + dist++] = (uch)code; + } + } + Assert(dist == 256, "ct_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) + bl_count[bits] = 0; + n = 0; + while (n <= 143) + static_ltree[n++].Len = 8, bl_count[8]++; + while (n <= 255) + static_ltree[n++].Len = 9, bl_count[9]++; + while (n <= 279) + static_ltree[n++].Len = 7, bl_count[7]++; + while (n <= 287) + static_ltree[n++].Len = 8, bl_count[8]++; + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes((ct_data *)static_ltree, L_CODES + 1); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n].Len = 5; + static_dtree[n].Code = bi_reverse(n, 5); + } + + /* Initialize the first block of the first file: */ + init_block(); +} + +/* =========================================================================== + * Initialize a new block. + */ +local void init_block() +{ + int n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) + dyn_ltree[n].Freq = 0; + for (n = 0; n < D_CODES; n++) + dyn_dtree[n].Freq = 0; + for (n = 0; n < BL_CODES; n++) + bl_tree[n].Freq = 0; + + dyn_ltree[END_BLOCK].Freq = 1; + opt_len = static_len = 0L; + last_lit = last_dist = last_flags = 0; + flags = 0; + flag_bit = 1; +} + +#define SMALLEST 1 +/* Index within the heap array of least frequent node in the Huffman tree */ + +/* =========================================================================== + * Remove the smallest element from the heap and recreate the heap with + * one less element. Updates heap and heap_len. + */ +#define pqremove(tree, top) \ + { \ + top = heap[SMALLEST]; \ + heap[SMALLEST] = heap[heap_len--]; \ + pqdownheap(tree, SMALLEST); \ + } + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +#define smaller(tree, n, m) \ + (tree[n].Freq < tree[m].Freq || \ + (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +local void pqdownheap(tree, k) ct_data *tree; /* the tree to restore */ +int k; /* node to move down */ +{ + int v = heap[k]; + int j = k << 1; /* left son of k */ + while (j <= heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < heap_len && smaller(tree, heap[j + 1], heap[j])) + j++; + + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, heap[j])) + break; + + /* Exchange v with the smallest son */ + heap[k] = heap[j]; + k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + heap[k] = v; +} + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +local void gen_bitlen(desc) tree_desc *desc; /* the tree descriptor */ +{ + ct_data *tree = desc->dyn_tree; + int *extra = desc->extra_bits; + int base = desc->extra_base; + int max_code = desc->max_code; + int max_length = desc->max_length; + ct_data *stree = desc->static_tree; + int h; /* heap index */ + int n, m; /* iterate over the tree elements */ + int bits; /* bit length */ + int xbits; /* extra bits */ + ush f; /* frequency */ + int overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) + bl_count[bits] = 0; + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[heap[heap_max]].Len = 0; /* root of the heap */ + + for (h = heap_max + 1; h < HEAP_SIZE; h++) { + n = heap[h]; + bits = tree[tree[n].Dad].Len + 1; + if (bits > max_length) + bits = max_length, overflow++; + tree[n].Len = (ush)bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) + continue; /* not a leaf node */ + + bl_count[bits]++; + xbits = 0; + if (n >= base) + xbits = extra[n - base]; + f = tree[n].Freq; + opt_len += (ulg)f * (bits + xbits); + if (stree) + static_len += (ulg)f * (stree[n].Len + xbits); + } + if (overflow == 0) + return; + + Trace((stderr, "\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length - 1; + while (bl_count[bits] == 0) + bits--; + bl_count[bits]--; /* move one leaf down the tree */ + bl_count[bits + 1] += 2; /* move one overflow item as its + brother */ + bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits != 0; bits--) { + n = bl_count[bits]; + while (n != 0) { + m = heap[--h]; + if (m > max_code) + continue; + if (tree[m].Len != (unsigned)bits) { + Trace((stderr, "code %d bits %d->%d\n", m, + tree[m].Len, bits)); + opt_len += ((long)bits - (long)tree[m].Len) * + (long)tree[m].Freq; + tree[m].Len = (ush)bits; + } + n--; + } + } +} + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +local void gen_codes(tree, max_code) ct_data *tree; /* the tree to decorate */ +int max_code; /* largest code with non zero frequency */ +{ + ush next_code[MAX_BITS + 1]; /* next code value for each bit length */ + ush code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits - 1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + Assert(code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1, + "inconsistent bit counts"); + Tracev((stderr, "\ngen_codes: max_code %d ", max_code)); + + for (n = 0; n <= max_code; n++) { + int len = tree[n].Len; + if (len == 0) + continue; + /* Now reverse the bits */ + tree[n].Code = bi_reverse(next_code[len]++, len); + + Tracec(tree != static_ltree, + (stderr, "\nn %3d %c l %2d c %4x (%x) ", n, + (isgraph(n) ? n : ' '), len, tree[n].Code, + next_code[len] - 1)); + } +} + +/* =========================================================================== + * Construct one Huffman tree and assigns the code bit strings and lengths. + * Update the total bit length for the current block. + * IN assertion: the field freq is set for all tree elements. + * OUT assertions: the fields len and code are set to the optimal bit length + * and corresponding code. The length opt_len is updated; static_len is + * also updated if stree is not null. The field max_code is set. + */ +local void build_tree(desc) tree_desc *desc; /* the tree descriptor */ +{ + ct_data *tree = desc->dyn_tree; + ct_data *stree = desc->static_tree; + int elems = desc->elems; + int n, m; /* iterate over heap elements */ + int max_code = -1; /* largest code with non zero frequency */ + int node = elems; /* next internal node of the tree */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + heap_len = 0, heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n].Freq != 0) { + heap[++heap_len] = max_code = n; + depth[n] = 0; + } else { + tree[n].Len = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (heap_len < 2) { + int new = heap[++heap_len] = (max_code < 2 ? ++max_code : 0); + tree[new].Freq = 1; + depth[new] = 0; + opt_len--; + if (stree) + static_len -= stree[new].Len; + /* new is 0 or 1 so it does not have extra bits */ + } + desc->max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = heap_len / 2; n >= 1; n--) + pqdownheap(tree, n); + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + do { + pqremove(tree, n); /* n = node of least frequency */ + m = heap[SMALLEST]; /* m = node of next least frequency */ + + heap[--heap_max] = n; /* keep the nodes sorted by frequency */ + heap[--heap_max] = m; + + /* Create a new node father of n and m */ + tree[node].Freq = tree[n].Freq + tree[m].Freq; + depth[node] = (uch)(MAX(depth[n], depth[m]) + 1); + tree[n].Dad = tree[m].Dad = (ush)node; +#ifdef DUMP_BL_TREE + if (tree == bl_tree) { + fprintf(stderr, "\nnode %d(%d), sons %d(%d) %d(%d)", + node, tree[node].Freq, n, tree[n].Freq, m, + tree[m].Freq); + } +#endif + /* and insert the new node in the heap */ + heap[SMALLEST] = node++; + pqdownheap(tree, SMALLEST); + + } while (heap_len >= 2); + + heap[--heap_max] = heap[SMALLEST]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen((tree_desc *)desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes((ct_data *)tree, max_code); +} + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. Updates opt_len to take into account the repeat + * counts. (The contribution of the bit length codes will be added later + * during the construction of bl_tree.) + */ +local void scan_tree(tree, max_code) ct_data *tree; /* the tree to be scanned */ +int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + if (nextlen == 0) + max_count = 138, min_count = 3; + tree[max_code + 1].Len = (ush)0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[n + 1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + bl_tree[curlen].Freq += count; + } else if (curlen != 0) { + if (curlen != prevlen) + bl_tree[curlen].Freq++; + bl_tree[REP_3_6].Freq++; + } else if (count <= 10) { + bl_tree[REPZ_3_10].Freq++; + } else { + bl_tree[REPZ_11_138].Freq++; + } + count = 0; + prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +local void send_tree(tree, max_code) ct_data *tree; /* the tree to be scanned */ +int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen == 0) + max_count = 138, min_count = 3; + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[n + 1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + do { + send_code(curlen, bl_tree); + } while (--count != 0); + + } else if (curlen != 0) { + if (curlen != prevlen) { + send_code(curlen, bl_tree); + count--; + } + Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(REP_3_6, bl_tree); + send_bits(count - 3, 2); + + } else if (count <= 10) { + send_code(REPZ_3_10, bl_tree); + send_bits(count - 3, 3); + + } else { + send_code(REPZ_11_138, bl_tree); + send_bits(count - 11, 7); + } + count = 0; + prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +local int build_bl_tree() +{ + int max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees + */ + scan_tree((ct_data *)dyn_ltree, l_desc.max_code); + scan_tree((ct_data *)dyn_dtree, d_desc.max_code); + + /* Build the bit length tree: */ + build_tree((tree_desc *)(&bl_desc)); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the + * counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (bl_tree[bl_order[max_blindex]].Len != 0) + break; + } + /* Update opt_len to include the bit length tree and counts */ + opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, static_len)); + + return max_blindex; +} + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +local void send_all_trees(lcodes, dcodes, blcodes) int lcodes, dcodes, + blcodes; /* number of codes for each tree */ +{ + int rank; /* index in bl_order */ + + Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, + "not enough codes"); + Assert(lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + "too many codes"); + Tracev((stderr, "\nbl counts: ")); + send_bits(lcodes - 257, 5); /* not +255 as stated in appnote.txt */ + send_bits(dcodes - 1, 5); + send_bits(blcodes - 4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(bl_tree[bl_order[rank]].Len, 3); + } + Tracev((stderr, "\nbl tree: sent %ld", bits_sent)); + + send_tree((ct_data *)dyn_ltree, lcodes - 1); /* send the literal tree */ + Tracev((stderr, "\nlit tree: sent %ld", bits_sent)); + + send_tree((ct_data *)dyn_dtree, dcodes - 1); /* send the distance tree + */ + Tracev((stderr, "\ndist tree: sent %ld", bits_sent)); +} + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. This function + * returns the total compressed length for the file so far. + */ +ulg flush_block(buf, stored_len, eof) +char *buf; /* input block, or NULL if too old */ +ulg stored_len; /* length of input block */ +int eof; /* true if this is the last block for a file */ +{ + ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + int max_blindex; /* index of last bit length code of non zero freq */ + + flag_buf[last_flags] = flags; /* Save the flags for the last 8 items */ + + /* Check if the file is ascii or binary */ + if (*file_type == (ush)UNKNOWN) + set_file_type(); + + /* Construct the literal and distance trees */ + build_tree((tree_desc *)(&l_desc)); + Tracev((stderr, "\nlit data: dyn %ld, stat %ld", opt_len, static_len)); + + build_tree((tree_desc *)(&d_desc)); + Tracev((stderr, "\ndist data: dyn %ld, stat %ld", opt_len, static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(); + + /* Determine the best encoding. Compute first the block length in bytes + */ + opt_lenb = (opt_len + 3 + 7) >> 3; + static_lenb = (static_len + 3 + 7) >> 3; + input_len += stored_len; /* for debugging only */ + + Trace((stderr, + "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ", + opt_lenb, opt_len, static_lenb, static_len, stored_len, last_lit, + last_dist)); + + if (static_lenb <= opt_lenb) + opt_lenb = static_lenb; + + /* If compression failed and this is the first and last block, + * and if the zip file can be seeked (to rewrite the local header), + * the whole file is transformed into a stored file: + */ +#ifdef FORCE_METHOD + if (level == 1 && eof && compressed_len == 0L) { /* force stored file */ +#else + if (stored_len <= opt_lenb && eof && compressed_len == 0L && + seekable()) { +#endif + /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: + */ + if (buf == (char *)0) + error("block vanished"); + + copy_block(buf, (unsigned)stored_len, 0); /* without header */ + compressed_len = stored_len << 3; + *file_method = STORED; + +#ifdef FORCE_METHOD + } else if (level == 2 && buf != (char *)0) { /* force stored block */ +#else + } else if (stored_len + 4 <= opt_lenb && buf != (char *)0) { + /* 4: two words for the lengths */ +#endif + /* The test buf != NULL is only necessary if LIT_BUFSIZE > + * WSIZE. Otherwise we can't have processed more than WSIZE + * input bytes since the last block flush, because compression + * would have been successful. If LIT_BUFSIZE <= WSIZE, it is + * never too late to transform a block into a stored block. + */ + send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */ + compressed_len = (compressed_len + 3 + 7) & ~7L; + compressed_len += (stored_len + 4) << 3; + + copy_block(buf, (unsigned)stored_len, 1); /* with header */ + +#ifdef FORCE_METHOD + } else if (level == 3) { /* force static trees */ +#else + } else if (static_lenb == opt_lenb) { +#endif + send_bits((STATIC_TREES << 1) + eof, 3); + compress_block((ct_data *)static_ltree, + (ct_data *)static_dtree); + compressed_len += 3 + static_len; + } else { + send_bits((DYN_TREES << 1) + eof, 3); + send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, + max_blindex + 1); + compress_block((ct_data *)dyn_ltree, (ct_data *)dyn_dtree); + compressed_len += 3 + opt_len; + } + Assert(compressed_len == bits_sent, "bad compressed size"); + init_block(); + + if (eof) { + Assert(input_len == isize, "bad input size"); + bi_windup(); + compressed_len += 7; /* align on byte boundary */ + } + Tracev((stderr, "\ncomprlen %lu(%lu) ", compressed_len >> 3, + compressed_len - 7 * eof)); + + return compressed_len >> 3; +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +int ct_tally(dist, lc) +int dist; /* distance of matched string */ +int lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + l_buf[last_lit++] = (uch)lc; + if (dist == 0) { + /* lc is the unmatched char */ + dyn_ltree[lc].Freq++; + } else { + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + Assert((ush)dist < (ush)MAX_DIST && + (ush)lc <= (ush)(MAX_MATCH - MIN_MATCH) && + (ush)d_code(dist) < (ush)D_CODES, + "ct_tally: bad match"); + + dyn_ltree[length_code[lc] + LITERALS + 1].Freq++; + dyn_dtree[d_code(dist)].Freq++; + + d_buf[last_dist++] = (ush)dist; + flags |= flag_bit; + } + flag_bit <<= 1; + + /* Output the flags if they fill a byte: */ + if ((last_lit & 7) == 0) { + flag_buf[last_flags++] = flags; + flags = 0, flag_bit = 1; + } + /* Try to guess if it is profitable to stop the current block here */ + if (level > 2 && (last_lit & 0xfff) == 0) { + /* Compute an upper bound for the compressed length */ + ulg out_length = (ulg)last_lit * 8L; + ulg in_length = (ulg)strstart - block_start; + int dcode; + for (dcode = 0; dcode < D_CODES; dcode++) { + out_length += (ulg)dyn_dtree[dcode].Freq * + (5L + extra_dbits[dcode]); + } + out_length >>= 3; + Trace((stderr, + "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ", + last_lit, last_dist, in_length, out_length, + 100L - out_length * 100L / in_length)); + if (last_dist < last_lit / 2 && out_length < in_length / 2) + return 1; + } + return (last_lit == LIT_BUFSIZE - 1 || last_dist == DIST_BUFSIZE); + /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +local void compress_block(ltree, dtree) ct_data *ltree; /* literal tree */ +ct_data *dtree; /* distance tree */ +{ + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned lx = 0; /* running index in l_buf */ + unsigned dx = 0; /* running index in d_buf */ + unsigned fx = 0; /* running index in flag_buf */ + uch flag = 0; /* current flags */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ + + if (last_lit != 0) + do { + if ((lx & 7) == 0) + flag = flag_buf[fx++]; + lc = l_buf[lx++]; + if ((flag & 1) == 0) { + send_code(lc, ltree); /* send a literal byte */ + Tracecv(isgraph(lc), (stderr, " '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = length_code[lc]; + send_code(code + LITERALS + 1, ltree); /* send + the + length + code + */ + extra = extra_lbits[code]; + if (extra != 0) { + lc -= base_length[code]; + send_bits(lc, extra); /* send the extra + length bits */ + } + dist = d_buf[dx++]; + /* Here, dist is the match distance - 1 */ + code = d_code(dist); + Assert(code < D_CODES, "bad d_code"); + + send_code(code, dtree); /* send the distance + code */ + extra = extra_dbits[code]; + if (extra != 0) { + dist -= base_dist[code]; + send_bits(dist, extra); /* send the + extra + distance bits + */ + } + } /* literal or match pair ? */ + flag >>= 1; + } while (lx < last_lit); + + send_code(END_BLOCK, ltree); +} + +/* =========================================================================== + * Set the file type to ASCII or BINARY, using a crude approximation: + * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise. + * IN assertion: the fields freq of dyn_ltree are set and the total of all + * frequencies does not exceed 64K (to fit in an int on 16 bit machines). + */ +local void set_file_type() +{ + int n = 0; + unsigned ascii_freq = 0; + unsigned bin_freq = 0; + while (n < 7) + bin_freq += dyn_ltree[n++].Freq; + while (n < 128) + ascii_freq += dyn_ltree[n++].Freq; + while (n < LITERALS) + bin_freq += dyn_ltree[n++].Freq; + *file_type = bin_freq > (ascii_freq >> 2) ? BINARY : ASCII; + if (*file_type == BINARY && translate_eol) { + warn("-l used on binary file", ""); + } +} diff --git a/bin/gzip/unzip.c b/bin/gzip/unzip.c new file mode 100644 index 00000000..72855f8b --- /dev/null +++ b/bin/gzip/unzip.c @@ -0,0 +1,76 @@ +/* unzip.c -- decompress files in gzip or pkzip format. + * Copyright (C) 1992-1993 Jean-loup Gailly + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + * + * The code in this file is derived from the file funzip.c written + * and put in the public domain by Mark Adler. + */ + +/* + This version can extract files in gzip format. + Only the first entry is extracted, and it has to be + either deflated or stored. + */ + +#ifdef RCSID +static char rcsid[] = "$Id: unzip.c,v 1.1 2002/08/18 00:59:21 hpa Exp $"; +#endif + +#include "tailor.h" +#include "gzip.h" + +/* =========================================================================== + * Unzip in to out. This routine works on gzip files only. + * + * IN assertions: the buffer inbuf contains already the beginning of + * the compressed data, from offsets inptr to insize-1 included. + * The magic header has already been checked. The output buffer is cleared. + */ +int unzip(in, out) +int in, out; /* input and output file descriptors */ +{ + ulg orig_crc = 0; /* original crc */ + ulg orig_len = 0; /* original uncompressed length */ + int n; + uch buf[8]; /* extended local header */ + + ifd = in; + ofd = out; + + updcrc(NULL, 0); /* initialize crc */ + + /* Decompress */ + if (method == DEFLATED) { + int res = inflate(); + + if (res == 3) { + error("out of memory"); + } else if (res != 0) { + error("invalid compressed data--format violated"); + } + + } else { + error("internal error, invalid method"); + } + + /* Get the crc and original length */ + /* crc32 (see algorithm.doc) + * uncompressed input size modulo 2^32 + */ + for (n = 0; n < 8; n++) { + buf[n] = (uch)get_byte(); /* may cause an error if EOF */ + } + orig_crc = LG(buf); + orig_len = LG(buf + 4); + + /* Validate decompression */ + if (orig_crc != updcrc(outbuf, 0)) { + error("invalid compressed data--crc error"); + } + if (orig_len != (ulg)bytes_out) { + error("invalid compressed data--length error"); + } + + return OK; +} diff --git a/bin/gzip/util.c b/bin/gzip/util.c new file mode 100644 index 00000000..841a0ce7 --- /dev/null +++ b/bin/gzip/util.c @@ -0,0 +1,384 @@ +/* util.c -- utility functions for gzip support + * Copyright (C) 1992-1993 Jean-loup Gailly + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +#ifdef RCSID +static char rcsid[] = "$Id: util.c,v 1.1 2002/08/18 00:59:21 hpa Exp $"; +#endif + +#include <ctype.h> +#include <errno.h> +#include <sys/types.h> + +#include "tailor.h" + +#include <unistd.h> +#include <fcntl.h> +#include <stdlib.h> + +#include "gzip.h" + +extern ulg crc_32_tab[]; /* crc table, defined below */ + +/* =========================================================================== + * Copy input to output unchanged: zcat == cat with --force. + * IN assertion: insize bytes have already been read in inbuf. + */ +int copy(in, out) +int in, out; /* input and output file descriptors */ +{ + errno = 0; + while (insize != 0 && (int)insize != EOF) { + write_buf(out, (char *)inbuf, insize); + bytes_out += insize; + insize = read(in, (char *)inbuf, INBUFSIZ); + } + if ((int)insize == EOF && errno != 0) { + read_error(); + } + bytes_in = bytes_out; + return OK; +} + +/* =========================================================================== + * Run a set of bytes through the crc shift register. If s is a NULL + * pointer, then initialize the crc shift register contents instead. + * Return the current crc in either case. + */ +ulg updcrc(s, n) +uch *s; /* pointer to bytes to pump through */ +unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) + do { + c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ + (c >> 8); + } while (--n); + } + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} + +/* =========================================================================== + * Clear input and output buffers + */ +void clear_bufs() +{ + outcnt = 0; + insize = inptr = 0; + bytes_in = bytes_out = 0L; +} + +/* =========================================================================== + * Fill the input buffer. This is called only when the buffer is empty. + */ +int fill_inbuf(eof_ok) +int eof_ok; /* set if EOF acceptable as a result */ +{ + int len; + + /* Read as much as possible */ + insize = 0; + errno = 0; + do { + len = read(ifd, (char *)inbuf + insize, INBUFSIZ - insize); + if (len == 0 || len == EOF) + break; + insize += len; + } while (insize < INBUFSIZ); + + if (insize == 0) { + if (eof_ok) + return EOF; + read_error(); + } + bytes_in += (ulg)insize; + inptr = 1; + return inbuf[0]; +} + +/* =========================================================================== + * Write the output buffer outbuf[0..outcnt-1] and update bytes_out. + * (used for the compressed data only) + */ +void flush_outbuf() +{ + if (outcnt == 0) + return; + + write_buf(ofd, (char *)outbuf, outcnt); + bytes_out += (ulg)outcnt; + outcnt = 0; +} + +/* =========================================================================== + * Write the output window window[0..outcnt-1] and update crc and bytes_out. + * (Used for the decompressed data only.) + */ +void flush_window() +{ + if (outcnt == 0) + return; + updcrc(window, outcnt); + + if (!test) { + write_buf(ofd, (char *)window, outcnt); + } + bytes_out += (ulg)outcnt; + outcnt = 0; +} + +/* =========================================================================== + * Does the same as write(), but also handles partial pipe writes and checks + * for error return. + */ +void write_buf(fd, buf, cnt) int fd; +voidp buf; +unsigned cnt; +{ + unsigned n; + + while ((n = write(fd, buf, cnt)) != cnt) { + if (n == (unsigned)(-1)) { + write_error(); + } + cnt -= n; + buf = (voidp)((char *)buf + n); + } +} + +/* ======================================================================== + * Put string s in lower case, return s. + */ +char *strlwr(s) +char *s; +{ + char *t; + for (t = s; *t; t++) + *t = tolow(*t); + return s; +} + +/* ======================================================================== + * Return the base name of a file (remove any directory prefix and + * any version suffix). For systems with file names that are not + * case sensitive, force the base name to lower case. + */ +char *basename(fname) +char *fname; +{ + char *p; + + if ((p = strrchr(fname, PATH_SEP)) != NULL) + fname = p + 1; + if (casemap('A') == 'a') + strlwr(fname); + return fname; +} + +/* ======================================================================== + * Add an environment variable (if any) before argv, and update argc. + * Return the expanded environment variable to be freed later, or NULL + * if no options were added to argv. + */ +#define SEPARATOR " \t" /* separators in env variable */ + +char *add_envopt(argcp, argvp, env) +int *argcp; /* pointer to argc */ +char ***argvp; /* pointer to argv */ +char *env; /* name of environment variable */ +{ + char *p; /* running pointer through env variable */ + char **oargv; /* runs through old argv array */ + char **nargv; /* runs through new argv array */ + int oargc = *argcp; /* old argc */ + int nargc = 0; /* number of arguments in env variable */ + + env = (char *)getenv(env); + if (env == NULL) + return NULL; + + p = (char *)xmalloc(strlen(env) + 1); + env = strcpy(p, env); /* keep env variable intact */ + + for (p = env; *p; nargc++) { /* move through env */ + p += strspn(p, SEPARATOR); /* skip leading separators */ + if (*p == '\0') + break; + + p += strcspn(p, SEPARATOR); /* find end of word */ + if (*p) + *p++ = '\0'; /* mark it */ + } + if (nargc == 0) { + free(env); + return NULL; + } + *argcp += nargc; + /* Allocate the new argv array, with an extra element just in case + * the original arg list did not end with a NULL. + */ + nargv = (char **)calloc(*argcp + 1, sizeof(char *)); + if (nargv == NULL) + error("out of memory"); + oargv = *argvp; + *argvp = nargv; + + /* Copy the program name first */ + if (oargc-- < 0) + error("argc<=0"); + *(nargv++) = *(oargv++); + + /* Then copy the environment args */ + for (p = env; nargc > 0; nargc--) { + p += strspn(p, SEPARATOR); /* skip separators */ + *(nargv++) = p; /* store start */ + while (*p++) + ; /* skip over word */ + } + + /* Finally copy the old args and add a NULL (usual convention) */ + while (oargc--) + *(nargv++) = *(oargv++); + *nargv = NULL; + return env; +} + +/* ======================================================================== + * Error handlers. + */ +void error(m) char *m; +{ + fprintf(stderr, "\n%s: %s: %s\n", progname, ifname, m); + abort_gzip(); +} + +void warn(a, b) char *a, *b; /* message strings juxtaposed in output */ +{ + WARN((stderr, "%s: %s: warning: %s%s\n", progname, ifname, a, b)); +} + +void read_error() +{ + fprintf(stderr, "\n%s: ", progname); + if (errno != 0) { + perror(ifname); + } else { + fprintf(stderr, "%s: unexpected end of file\n", ifname); + } + abort_gzip(); +} + +void write_error() +{ + fprintf(stderr, "\n%s: ", progname); + perror(ofname); + abort_gzip(); +} + +/* ======================================================================== + * Display compression ratio on the given stream on 6 characters. + */ +void display_ratio(num, den, file) long num; +long den; +FILE *file; +{ + long ratio; /* 1000 times the compression ratio */ + char sign; + + if (den == 0) { + ratio = 0; /* no compression */ + } else if (den < 2147483L) { /* (2**31 -1)/1000 */ + ratio = 1000L * num / den; + } else { + ratio = num / (den / 1000L); + } + if (ratio < 0) { + sign = '-'; + ratio = -ratio; + } else { + sign = ' '; + } + fprintf(file, "%c%2ld.%1ld%%", sign, ratio / 10L, ratio % 10L); +} + +/* ======================================================================== + * Semi-safe malloc -- never returns NULL. + */ +voidp xmalloc(size) +unsigned size; +{ + voidp cp = (voidp)malloc(size); + + if (cp == NULL) + error("out of memory"); + return cp; +} + +/* ======================================================================== + * Table of CRC-32's of all single-byte values (made by makecrc.c) + */ +ulg crc_32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; diff --git a/bin/gzip/zip.c b/bin/gzip/zip.c new file mode 100644 index 00000000..919be412 --- /dev/null +++ b/bin/gzip/zip.c @@ -0,0 +1,112 @@ +/* zip.c -- compress files to the gzip or pkzip format + * Copyright (C) 1992-1993 Jean-loup Gailly + * This is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License, see the file COPYING. + */ + +#ifdef RCSID +static char rcsid[] = "$Id: zip.c,v 1.1 2002/08/18 00:59:21 hpa Exp $"; +#endif + +#include <ctype.h> +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> + +#include "tailor.h" +#include "gzip.h" + +local ulg crc; /* crc on uncompressed file data */ + +/* =========================================================================== + * Deflate in to out. + * IN assertions: the input and output buffers are cleared. + * The variables time_stamp and save_orig_name are initialized. + */ +int zip(in, out) +int in, out; /* input and output file descriptors */ +{ + uch flags = 0; /* general purpose bit flags */ + ush attr = 0; /* ascii/binary flag */ + ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */ + + ifd = in; + ofd = out; + outcnt = 0; + + /* Write the header to the gzip file. See algorithm.doc for the format + */ + + method = DEFLATED; + put_byte(GZIP_MAGIC[0]); /* magic header */ + put_byte(GZIP_MAGIC[1]); + put_byte(DEFLATED); /* compression method */ + + if (save_orig_name) { + flags |= ORIG_NAME; + } + put_byte(flags); /* general flags */ + put_long(time_stamp); + + /* Write deflated file to zip file */ + crc = updcrc(0, 0); + + bi_init(out); + ct_init(&attr, &method); + lm_init(level, &deflate_flags); + + put_byte((uch)deflate_flags); /* extra flags */ + put_byte(OS_CODE); /* OS identifier */ + + if (save_orig_name) { + char *p = basename(ifname); /* Don't save the directory part. */ + do { + put_char(*p); + } while (*p++); + } + header_bytes = (long)outcnt; + + (void)deflate(); + +#if !defined(NO_SIZE_CHECK) && !defined(RECORD_IO) + /* Check input size (but not in VMS -- variable record lengths mess it + * up) and not on MSDOS -- diet in TSR mode reports an incorrect file + * size) + */ + if (ifile_size != -1L && isize != (ulg)ifile_size) { + Trace((stderr, " actual=%ld, read=%ld ", ifile_size, isize)); + fprintf(stderr, "%s: %s: file size changed while zipping\n", + progname, ifname); + } +#endif + + /* Write the crc and uncompressed size */ + put_long(crc); + put_long(isize); + header_bytes += 2 * sizeof(long); + + flush_outbuf(); + return OK; +} + +/* =========================================================================== + * Read a new buffer from the current input file, perform end-of-line + * translation, and update the crc and input file size. + * IN assertion: size >= 2 (for end-of-line translation) + */ +int file_read(buf, size) +char *buf; +unsigned size; +{ + unsigned len; + + Assert(insize == 0, "inbuf not empty"); + + len = read(ifd, buf, size); + if (len == (unsigned)(-1) || len == 0) + return (int)len; + + crc = updcrc((uch *)buf, len); + isize += (ulg)len; + return (int)len; +} diff --git a/bin/true/arch/x86_64/true.s b/bin/true/arch/x86_64/true.s index 782ef00d..9e5ab682 100644 --- a/bin/true/arch/x86_64/true.s +++ b/bin/true/arch/x86_64/true.s @@ -4,4 +4,3 @@ _start: mov 60, %rax xor %rdi, %rdi syscall - diff --git a/bin/true/true b/bin/true/true Binary files differindex 49700c41..107f7f2d 100755 --- a/bin/true/true +++ b/bin/true/true diff --git a/include/alloca.h b/include/alloca.h new file mode 100644 index 00000000..b70f6572 --- /dev/null +++ b/include/alloca.h @@ -0,0 +1,6 @@ +#ifndef __ALLOCA_H +#define __ALLOCA_H + +#define alloca(__size) __builtin_alloca(__size) + +#endif diff --git a/include/arch/x86_64/asm-generic/mman-common.h b/include/arch/x86_64/asm-generic/mman-common.h index 2c258a78..cbcba366 100644 --- a/include/arch/x86_64/asm-generic/mman-common.h +++ b/include/arch/x86_64/asm-generic/mman-common.h @@ -32,8 +32,9 @@ 0x020000 /* give out an address that is best suited for process/thread \ stacks */ #define MAP_HUGETLB 0x040000 /* create a huge page mapping */ -#define MAP_SYNC 0x080000 /* perform synchronous page faults for the mapping \ - */ +#define MAP_SYNC \ + 0x080000 /* perform synchronous page faults for the mapping \ + */ #define MAP_FIXED_NOREPLACE \ 0x100000 /* MAP_FIXED which doesn't unmap underlying mapping */ diff --git a/include/arch/x86_64/asm/kvm.h b/include/arch/x86_64/asm/kvm.h index cac27ba0..f37ee487 100644 --- a/include/arch/x86_64/asm/kvm.h +++ b/include/arch/x86_64/asm/kvm.h @@ -912,7 +912,8 @@ struct kvm_hyperv_eventfd { #define KVM_PMU_MASKED_ENTRY_UMASK_MASK_SHIFT (56) /* for KVM_{GET,SET,HAS}_DEVICE_ATTR */ -#define KVM_VCPU_TSC_CTRL 0 /* control group for the timestamp counter (TSC) \ +#define KVM_VCPU_TSC_CTRL \ + 0 /* control group for the timestamp counter (TSC) \ */ #define KVM_VCPU_TSC_OFFSET 0 /* attribute for the TSC offset */ diff --git a/include/arch/x86_64/drm/drm.h b/include/arch/x86_64/drm/drm.h index ebd6ebb5..a928f61f 100644 --- a/include/arch/x86_64/drm/drm.h +++ b/include/arch/x86_64/drm/drm.h @@ -253,7 +253,7 @@ enum drm_stat_type { _DRM_STAT_DMA, /**< DMA */ _DRM_STAT_SPECIAL, /**< Special DMA (e.g., priority or polled) */ _DRM_STAT_MISSED /**< Missed DMA opportunity */ - /* Add to the *END* of the list */ + /* Add to the *END* of the list */ }; /* diff --git a/include/arch/x86_64/drm/drm_mode.h b/include/arch/x86_64/drm/drm_mode.h index 8b6da7da..8517ff0c 100644 --- a/include/arch/x86_64/drm/drm_mode.h +++ b/include/arch/x86_64/drm/drm_mode.h @@ -48,9 +48,10 @@ extern "C" { #define DRM_MODE_TYPE_BUILTIN (1 << 0) /* deprecated */ #define DRM_MODE_TYPE_CLOCK_C \ - ((1 << 1) | DRM_MODE_TYPE_BUILTIN) /* deprecated */ -#define DRM_MODE_TYPE_CRTC_C ((1 << 2) | DRM_MODE_TYPE_BUILTIN) /* deprecated \ - */ + ((1 << 1) | DRM_MODE_TYPE_BUILTIN) /* deprecated */ +#define DRM_MODE_TYPE_CRTC_C \ + ((1 << 2) | DRM_MODE_TYPE_BUILTIN) /* deprecated \ + */ #define DRM_MODE_TYPE_PREFERRED (1 << 3) #define DRM_MODE_TYPE_DEFAULT (1 << 4) /* deprecated */ #define DRM_MODE_TYPE_USERDEF (1 << 5) diff --git a/include/arch/x86_64/drm/i915_drm.h b/include/arch/x86_64/drm/i915_drm.h index 68f08e16..e0403cb6 100644 --- a/include/arch/x86_64/drm/i915_drm.h +++ b/include/arch/x86_64/drm/i915_drm.h @@ -2115,10 +2115,10 @@ struct drm_i915_gem_context_param { #define I915_CONTEXT_MAX_USER_PRIORITY 1023 /* inclusive */ #define I915_CONTEXT_DEFAULT_PRIORITY 0 #define I915_CONTEXT_MIN_USER_PRIORITY -1023 /* inclusive */ - /* - * When using the following param, value should be a pointer to - * drm_i915_gem_context_param_sseu. - */ + /* + * When using the following param, value should be a pointer to + * drm_i915_gem_context_param_sseu. + */ #define I915_CONTEXT_PARAM_SSEU 0x7 /* diff --git a/include/arch/x86_64/drm/msm_drm.h b/include/arch/x86_64/drm/msm_drm.h index 762aef57..efc01123 100644 --- a/include/arch/x86_64/drm/msm_drm.h +++ b/include/arch/x86_64/drm/msm_drm.h @@ -306,8 +306,9 @@ struct drm_msm_gem_submit_bo { #define MSM_SUBMIT_SUDO 0x10000000 /* run submitted cmds from RB */ #define MSM_SUBMIT_SYNCOBJ_IN 0x08000000 /* enable input syncobj */ #define MSM_SUBMIT_SYNCOBJ_OUT 0x04000000 /* enable output syncobj */ -#define MSM_SUBMIT_FENCE_SN_IN 0x02000000 /* userspace passes in seqno fence \ - */ +#define MSM_SUBMIT_FENCE_SN_IN \ + 0x02000000 /* userspace passes in seqno fence \ + */ #define MSM_SUBMIT_FLAGS \ (MSM_SUBMIT_NO_IMPLICIT | MSM_SUBMIT_FENCE_FD_IN | \ MSM_SUBMIT_FENCE_FD_OUT | MSM_SUBMIT_SUDO | MSM_SUBMIT_SYNCOBJ_IN | \ diff --git a/include/arch/x86_64/drm/radeon_drm.h b/include/arch/x86_64/drm/radeon_drm.h index 825b8919..6ac625ab 100644 --- a/include/arch/x86_64/drm/radeon_drm.h +++ b/include/arch/x86_64/drm/radeon_drm.h @@ -1055,9 +1055,10 @@ struct drm_radeon_cs { #define RADEON_INFO_WANT_HYPERZ 0x07 #define RADEON_INFO_WANT_CMASK 0x08 /* get access to CMASK on r300 */ #define RADEON_INFO_CLOCK_CRYSTAL_FREQ 0x09 /* clock crystal frequency */ -#define RADEON_INFO_NUM_BACKENDS 0x0a /* DB/backends for r600+ - need for OQ \ - */ -#define RADEON_INFO_NUM_TILE_PIPES 0x0b /* tile pipes for r600+ */ +#define RADEON_INFO_NUM_BACKENDS \ + 0x0a /* DB/backends for r600+ - need for OQ \ + */ +#define RADEON_INFO_NUM_TILE_PIPES 0x0b /* tile pipes for r600+ */ #define RADEON_INFO_FUSION_GART_WORKING \ 0x0c /* fusion writes to GTT were broken before this */ #define RADEON_INFO_BACKEND_MAP 0x0d /* pipe to backend map, needed by mesa */ diff --git a/include/arch/x86_64/drm/virtgpu_drm.h b/include/arch/x86_64/drm/virtgpu_drm.h index 4f9458d6..77b8c034 100644 --- a/include/arch/x86_64/drm/virtgpu_drm.h +++ b/include/arch/x86_64/drm/virtgpu_drm.h @@ -92,9 +92,10 @@ struct drm_virtgpu_execbuffer { #define VIRTGPU_PARAM_CAPSET_QUERY_FIX 2 /* do we have the capset fix */ #define VIRTGPU_PARAM_RESOURCE_BLOB 3 /* DRM_VIRTGPU_RESOURCE_CREATE_BLOB */ #define VIRTGPU_PARAM_HOST_VISIBLE 4 /* Host blob resources are mappable */ -#define VIRTGPU_PARAM_CROSS_DEVICE 5 /* Cross virtio-device resource sharing \ - */ -#define VIRTGPU_PARAM_CONTEXT_INIT 6 /* DRM_VIRTGPU_CONTEXT_INIT */ +#define VIRTGPU_PARAM_CROSS_DEVICE \ + 5 /* Cross virtio-device resource sharing \ + */ +#define VIRTGPU_PARAM_CONTEXT_INIT 6 /* DRM_VIRTGPU_CONTEXT_INIT */ #define VIRTGPU_PARAM_SUPPORTED_CAPSET_IDs \ 7 /* Bitmask of supported capability set ids */ #define VIRTGPU_PARAM_EXPLICIT_DEBUG_NAME \ diff --git a/include/arch/x86_64/linux/acct.h b/include/arch/x86_64/linux/acct.h index 28772df2..6f27a6a2 100644 --- a/include/arch/x86_64/linux/acct.h +++ b/include/arch/x86_64/linux/acct.h @@ -49,17 +49,17 @@ struct acct { __u16 ac_gid16; /* LSB of Real Group ID */ __u16 ac_tty; /* Control Terminal */ /* __u32 range means times from 1970 to 2106 */ - __u32 ac_btime; /* Process Creation Time */ - comp_t ac_utime; /* User Time */ - comp_t ac_stime; /* System Time */ - comp_t ac_etime; /* Elapsed Time */ - comp_t ac_mem; /* Average Memory Usage */ - comp_t ac_io; /* Chars Transferred */ - comp_t ac_rw; /* Blocks Read or Written */ - comp_t ac_minflt; /* Minor Pagefaults */ - comp_t ac_majflt; /* Major Pagefaults */ - comp_t ac_swaps; /* Number of Swaps */ - /* m68k had no padding here. */ + __u32 ac_btime; /* Process Creation Time */ + comp_t ac_utime; /* User Time */ + comp_t ac_stime; /* System Time */ + comp_t ac_etime; /* Elapsed Time */ + comp_t ac_mem; /* Average Memory Usage */ + comp_t ac_io; /* Chars Transferred */ + comp_t ac_rw; /* Blocks Read or Written */ + comp_t ac_minflt; /* Minor Pagefaults */ + comp_t ac_majflt; /* Major Pagefaults */ + comp_t ac_swaps; /* Number of Swaps */ + /* m68k had no padding here. */ __u16 ac_ahz; /* AHZ */ __u32 ac_exitcode; /* Exitcode */ char ac_comm[ACCT_COMM + 1]; /* Command Name */ diff --git a/include/arch/x86_64/linux/atmlec.h b/include/arch/x86_64/linux/atmlec.h index 366b53fb..0dd3cf37 100644 --- a/include/arch/x86_64/linux/atmlec.h +++ b/include/arch/x86_64/linux/atmlec.h @@ -75,7 +75,7 @@ struct atmlec_msg { struct { __u16 lec_id; /* requestor lec_id */ __u32 tran_id; /* transaction id */ - unsigned char mac_addr[ETH_ALEN]; /* dst mac addr */ + unsigned char mac_addr[ETH_ALEN]; /* dst mac addr */ unsigned char atm_addr[ATM_ESA_LEN]; /* reqestor ATM addr */ } proxy; /* diff --git a/include/arch/x86_64/linux/audit.h b/include/arch/x86_64/linux/audit.h index cbee3511..76ca9e66 100644 --- a/include/arch/x86_64/linux/audit.h +++ b/include/arch/x86_64/linux/audit.h @@ -175,8 +175,9 @@ #define AUDIT_FILTER_WATCH 0x03 /* Apply rule to file system watches */ #define AUDIT_FILTER_EXIT 0x04 /* Apply rule at syscall exit */ #define AUDIT_FILTER_EXCLUDE 0x05 /* Apply rule before record creation */ -#define AUDIT_FILTER_TYPE AUDIT_FILTER_EXCLUDE /* obsolete misleading naming \ - */ +#define AUDIT_FILTER_TYPE \ + AUDIT_FILTER_EXCLUDE /* obsolete misleading naming \ + */ #define AUDIT_FILTER_FS 0x06 /* Apply rule at __audit_inode_child */ #define AUDIT_FILTER_URING_EXIT 0x07 /* Apply rule at io_uring op exit */ diff --git a/include/arch/x86_64/linux/can/error.h b/include/arch/x86_64/linux/can/error.h index e2fe2400..e4ed236e 100644 --- a/include/arch/x86_64/linux/can/error.h +++ b/include/arch/x86_64/linux/can/error.h @@ -63,7 +63,7 @@ /* arbitration lost in bit ... / data[0] */ #define CAN_ERR_LOSTARB_UNSPEC 0x00 /* unspecified */ - /* else bit number in bitstream */ +/* else bit number in bitstream */ /* error status of CAN-controller / data[1] */ #define CAN_ERR_CRTL_UNSPEC 0x00 /* unspecified */ diff --git a/include/arch/x86_64/linux/can/isotp.h b/include/arch/x86_64/linux/can/isotp.h index 7d46f53b..d986173d 100644 --- a/include/arch/x86_64/linux/can/isotp.h +++ b/include/arch/x86_64/linux/can/isotp.h @@ -59,12 +59,12 @@ /* sockopts to force stmin timer values for protocol regression tests */ #define CAN_ISOTP_TX_STMIN 3 /* pass __u32 value in nano secs */ - /* use this time instead of value */ - /* provided in FC from the receiver */ +/* use this time instead of value */ +/* provided in FC from the receiver */ #define CAN_ISOTP_RX_STMIN 4 /* pass __u32 value in nano secs */ - /* ignore received CF frames which */ - /* timestamps differ less than val */ +/* ignore received CF frames which */ +/* timestamps differ less than val */ #define CAN_ISOTP_LL_OPTS 5 /* pass struct can_isotp_ll_options */ @@ -85,7 +85,7 @@ struct can_isotp_options { /* __u8 value : content on rx path */ __u8 rx_ext_address; /* set address for extended addressing */ - /* __u8 value : extended address (rx) */ + /* __u8 value : extended address (rx) */ }; struct can_isotp_fc_options { diff --git a/include/arch/x86_64/linux/cramfs_fs.h b/include/arch/x86_64/linux/cramfs_fs.h index f340f3b9..08d399f9 100644 --- a/include/arch/x86_64/linux/cramfs_fs.h +++ b/include/arch/x86_64/linux/cramfs_fs.h @@ -74,8 +74,9 @@ struct cramfs_super { #define CRAMFS_FLAG_HOLES 0x00000100 /* support for holes */ #define CRAMFS_FLAG_WRONG_SIGNATURE 0x00000200 /* reserved */ #define CRAMFS_FLAG_SHIFTED_ROOT_OFFSET 0x00000400 /* shifted root fs */ -#define CRAMFS_FLAG_EXT_BLOCK_POINTERS 0x00000800 /* block pointer extensions \ - */ +#define CRAMFS_FLAG_EXT_BLOCK_POINTERS \ + 0x00000800 /* block pointer extensions \ + */ /* * Valid values in super.flags. Currently we refuse to mount diff --git a/include/arch/x86_64/linux/dqblk_xfs.h b/include/arch/x86_64/linux/dqblk_xfs.h index ee0eb805..e1c5b142 100644 --- a/include/arch/x86_64/linux/dqblk_xfs.h +++ b/include/arch/x86_64/linux/dqblk_xfs.h @@ -24,9 +24,10 @@ * Disk quota - quotactl(2) commands for the XFS Quota Manager (XQM). */ -#define XQM_CMD(x) (('X' << 8) + (x)) /* note: forms first QCMD argument */ -#define XQM_COMMAND(x) (((x) & (0xff << 8)) == ('X' << 8)) /* test if for XFS \ - */ +#define XQM_CMD(x) (('X' << 8) + (x)) /* note: forms first QCMD argument */ +#define XQM_COMMAND(x) \ + (((x) & (0xff << 8)) == ('X' << 8)) /* test if for XFS \ + */ #define XQM_USRQUOTA 0 /* system call user quota type */ #define XQM_GRPQUOTA 1 /* system call group quota type */ diff --git a/include/arch/x86_64/linux/elf.h b/include/arch/x86_64/linux/elf.h index 0265ed9a..77e3e2d3 100644 --- a/include/arch/x86_64/linux/elf.h +++ b/include/arch/x86_64/linux/elf.h @@ -445,8 +445,9 @@ typedef struct elf64_shdr { #define NN_PPC_TM_CPPR "LINUX" #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ #define NN_PPC_TM_CDSCR "LINUX" -#define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register \ - */ +#define NT_PPC_TM_CDSCR \ + 0x10f /* TM checkpointed Data Stream Control Register \ + */ #define NN_PPC_PKEY "LINUX" #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ #define NN_PPC_DEXCR "LINUX" @@ -552,8 +553,9 @@ typedef struct elf64_shdr { #define NN_LOONGARCH_CSR "LINUX" #define NT_LOONGARCH_CSR 0xa01 /* LoongArch control and status registers */ #define NN_LOONGARCH_LSX "LINUX" -#define NT_LOONGARCH_LSX 0xa02 /* LoongArch Loongson SIMD Extension registers \ - */ +#define NT_LOONGARCH_LSX \ + 0xa02 /* LoongArch Loongson SIMD Extension registers \ + */ #define NN_LOONGARCH_LASX "LINUX" #define NT_LOONGARCH_LASX \ 0xa03 /* LoongArch Loongson Advanced SIMD Extension registers */ diff --git a/include/arch/x86_64/linux/fb.h b/include/arch/x86_64/linux/fb.h index 205917bd..a0ac9036 100644 --- a/include/arch/x86_64/linux/fb.h +++ b/include/arch/x86_64/linux/fb.h @@ -196,9 +196,10 @@ struct fb_bitfield { /* right */ }; -#define FB_NONSTD_HAM 1 /* Hold-And-Modify (HAM) */ -#define FB_NONSTD_REV_PIX_IN_B 2 /* order of pixels in each byte is reversed \ - */ +#define FB_NONSTD_HAM 1 /* Hold-And-Modify (HAM) */ +#define FB_NONSTD_REV_PIX_IN_B \ + 2 /* order of pixels in each byte is reversed \ + */ #define FB_ACTIVATE_NOW 0 /* set values immediately (or vbl)*/ #define FB_ACTIVATE_NXTOPEN 1 /* activate on next open */ diff --git a/include/arch/x86_64/linux/fcntl.h b/include/arch/x86_64/linux/fcntl.h index ad6752fb..6339c5f1 100644 --- a/include/arch/x86_64/linux/fcntl.h +++ b/include/arch/x86_64/linux/fcntl.h @@ -112,8 +112,9 @@ #define PIDFD_SELF_THREAD_GROUP -10001 /* Current thread group leader. */ #define FD_PIDFS_ROOT -10002 /* Root of the pidfs filesystem */ -#define FD_INVALID -10009 /* Invalid file descriptor: -10000 - EBADF = -10009 \ - */ +#define FD_INVALID \ + -10009 /* Invalid file descriptor: -10000 - EBADF = -10009 \ + */ /* Generic flags for the *at(2) family of syscalls. */ @@ -139,8 +140,9 @@ #define AT_STATX_SYNC_AS_STAT 0x0000 /* - Do whatever stat() does */ #define AT_STATX_FORCE_SYNC \ 0x2000 /* - Force the attributes to be sync'd with the server */ -#define AT_STATX_DONT_SYNC 0x4000 /* - Don't sync attributes with the server \ - */ +#define AT_STATX_DONT_SYNC \ + 0x4000 /* - Don't sync attributes with the server \ + */ #define AT_RECURSIVE 0x8000 /* Apply to the entire subtree */ diff --git a/include/arch/x86_64/linux/fd.h b/include/arch/x86_64/linux/fd.h index d2841051..bdebcc4f 100644 --- a/include/arch/x86_64/linux/fd.h +++ b/include/arch/x86_64/linux/fd.h @@ -144,11 +144,11 @@ struct floppy_drive_params { struct floppy_max_errors max_errors; char flags; /* various flags, including ftd_msg */ - /* - * Announce successful media type detection and media information loss - * after disk changes. Also used to enable/disable printing of overrun - * warnings. - */ + /* + * Announce successful media type detection and media information loss + * after disk changes. Also used to enable/disable printing of overrun + * warnings. + */ #define FTD_MSG 0x10 #define FD_BROKEN_DCL 0x20 diff --git a/include/arch/x86_64/linux/fs.h b/include/arch/x86_64/linux/fs.h index 23114c88..86ead53c 100644 --- a/include/arch/x86_64/linux/fs.h +++ b/include/arch/x86_64/linux/fs.h @@ -253,17 +253,19 @@ struct file_attr { /* the read-only stuff doesn't really belong here, but any other place is probably as bad and I don't want to create yet another include file. */ -#define BLKROSET _IO(0x12, 93) /* set device read-only (0 = read-write) */ -#define BLKROGET _IO(0x12, 94) /* get read-only status (0 = read_write) */ -#define BLKRRPART _IO(0x12, 95) /* re-read partition table */ -#define BLKGETSIZE _IO(0x12, 96) /* return device size /512 (long *arg) */ -#define BLKFLSBUF _IO(0x12, 97) /* flush buffer cache */ -#define BLKRASET _IO(0x12, 98) /* set read ahead for block device */ -#define BLKRAGET _IO(0x12, 99) /* get current read ahead setting */ -#define BLKFRASET _IO(0x12, 100) /* set filesystem (mm/filemap.c) read-ahead \ - */ -#define BLKFRAGET _IO(0x12, 101) /* get filesystem (mm/filemap.c) read-ahead \ - */ +#define BLKROSET _IO(0x12, 93) /* set device read-only (0 = read-write) */ +#define BLKROGET _IO(0x12, 94) /* get read-only status (0 = read_write) */ +#define BLKRRPART _IO(0x12, 95) /* re-read partition table */ +#define BLKGETSIZE _IO(0x12, 96) /* return device size /512 (long *arg) */ +#define BLKFLSBUF _IO(0x12, 97) /* flush buffer cache */ +#define BLKRASET _IO(0x12, 98) /* set read ahead for block device */ +#define BLKRAGET _IO(0x12, 99) /* get current read ahead setting */ +#define BLKFRASET \ + _IO(0x12, 100) /* set filesystem (mm/filemap.c) read-ahead \ + */ +#define BLKFRAGET \ + _IO(0x12, 101) /* get filesystem (mm/filemap.c) read-ahead \ + */ #define BLKSECTSET \ _IO(0x12, 102) /* set max sectors per request (ll_rw_blk.c) */ #define BLKSECTGET \ diff --git a/include/arch/x86_64/linux/hdlcdrv.h b/include/arch/x86_64/linux/hdlcdrv.h index 0d3f0ba7..784d1dcf 100644 --- a/include/arch/x86_64/linux/hdlcdrv.h +++ b/include/arch/x86_64/linux/hdlcdrv.h @@ -29,7 +29,7 @@ struct hdlcdrv_channel_params { int slottime; /* the slottime in 10ms; usually 10 = 100ms */ int ppersist; /* the p-persistence 0..255 */ int fulldup; /* some driver do not support full duplex, setting */ - /* this just makes them send even if DCD is on */ + /* this just makes them send even if DCD is on */ }; struct hdlcdrv_old_channel_state { diff --git a/include/arch/x86_64/linux/hdreg.h b/include/arch/x86_64/linux/hdreg.h index 070ae119..ce171ac3 100644 --- a/include/arch/x86_64/linux/hdreg.h +++ b/include/arch/x86_64/linux/hdreg.h @@ -201,21 +201,22 @@ typedef struct hd_drive_hob_hdr { /* * 0x9A VENDOR */ -#define WIN_PACKETCMD 0xA0 /* Send a packet command. */ -#define WIN_PIDENTIFY 0xA1 /* identify ATAPI device */ -#define WIN_QUEUED_SERVICE 0xA2 -#define WIN_SMART 0xB0 /* self-monitoring and reporting */ -#define CFA_ERASE_SECTORS 0xC0 -#define WIN_MULTREAD 0xC4 /* read sectors using multiple mode*/ -#define WIN_MULTWRITE 0xC5 /* write sectors using multiple mode */ -#define WIN_SETMULT 0xC6 /* enable/disable multiple mode */ -#define WIN_READDMA_QUEUED 0xC7 /* read sectors using Queued DMA transfers */ -#define WIN_READDMA 0xC8 /* read sectors using DMA transfers */ -#define WIN_READDMA_ONCE 0xC9 /* 28-Bit - without retries */ -#define WIN_WRITEDMA 0xCA /* write sectors using DMA transfers */ -#define WIN_WRITEDMA_ONCE 0xCB /* 28-Bit - without retries */ -#define WIN_WRITEDMA_QUEUED 0xCC /* write sectors using Queued DMA transfers \ - */ +#define WIN_PACKETCMD 0xA0 /* Send a packet command. */ +#define WIN_PIDENTIFY 0xA1 /* identify ATAPI device */ +#define WIN_QUEUED_SERVICE 0xA2 +#define WIN_SMART 0xB0 /* self-monitoring and reporting */ +#define CFA_ERASE_SECTORS 0xC0 +#define WIN_MULTREAD 0xC4 /* read sectors using multiple mode*/ +#define WIN_MULTWRITE 0xC5 /* write sectors using multiple mode */ +#define WIN_SETMULT 0xC6 /* enable/disable multiple mode */ +#define WIN_READDMA_QUEUED 0xC7 /* read sectors using Queued DMA transfers */ +#define WIN_READDMA 0xC8 /* read sectors using DMA transfers */ +#define WIN_READDMA_ONCE 0xC9 /* 28-Bit - without retries */ +#define WIN_WRITEDMA 0xCA /* write sectors using DMA transfers */ +#define WIN_WRITEDMA_ONCE 0xCB /* 28-Bit - without retries */ +#define WIN_WRITEDMA_QUEUED \ + 0xCC /* write sectors using Queued DMA transfers \ + */ #define CFA_WRITE_MULTI_WO_ERASE 0xCD /* CFA Write multiple without erase */ #define WIN_GETMEDIASTATUS 0xDA #define WIN_ACKMEDIACHANGE 0xDB /* ATA-1, ATA-2 vendor */ diff --git a/include/arch/x86_64/linux/icmpv6.h b/include/arch/x86_64/linux/icmpv6.h index e86a513a..f5645526 100644 --- a/include/arch/x86_64/linux/icmpv6.h +++ b/include/arch/x86_64/linux/icmpv6.h @@ -159,8 +159,8 @@ struct icmp6_filter { #define MLD2_ALLOW_NEW_SOURCES 5 #define MLD2_BLOCK_OLD_SOURCES 6 -#define MLD2_ALL_MCR_INIT \ - { \ +#define MLD2_ALL_MCR_INIT \ + { \ { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x16 } } \ } diff --git a/include/arch/x86_64/linux/if_bridge.h b/include/arch/x86_64/linux/if_bridge.h index 141b1bdb..8650d78e 100644 --- a/include/arch/x86_64/linux/if_bridge.h +++ b/include/arch/x86_64/linux/if_bridge.h @@ -127,15 +127,17 @@ enum { }; #define IFLA_BRIDGE_MAX (__IFLA_BRIDGE_MAX - 1) -#define BRIDGE_VLAN_INFO_MASTER (1 << 0) /* Operate on Bridge device as well \ - */ -#define BRIDGE_VLAN_INFO_PVID (1 << 1) /* VLAN is PVID, ingress untagged */ -#define BRIDGE_VLAN_INFO_UNTAGGED (1 << 2) /* VLAN egresses untagged */ -#define BRIDGE_VLAN_INFO_RANGE_BEGIN (1 << 3) /* VLAN is start of vlan range \ - */ -#define BRIDGE_VLAN_INFO_RANGE_END (1 << 4) /* VLAN is end of vlan range */ -#define BRIDGE_VLAN_INFO_BRENTRY (1 << 5) /* Global bridge VLAN entry */ -#define BRIDGE_VLAN_INFO_ONLY_OPTS (1 << 6) /* Skip create/delete/flags */ +#define BRIDGE_VLAN_INFO_MASTER \ + (1 << 0) /* Operate on Bridge device as well \ + */ +#define BRIDGE_VLAN_INFO_PVID (1 << 1) /* VLAN is PVID, ingress untagged */ +#define BRIDGE_VLAN_INFO_UNTAGGED (1 << 2) /* VLAN egresses untagged */ +#define BRIDGE_VLAN_INFO_RANGE_BEGIN \ + (1 << 3) /* VLAN is start of vlan range \ + */ +#define BRIDGE_VLAN_INFO_RANGE_END (1 << 4) /* VLAN is end of vlan range */ +#define BRIDGE_VLAN_INFO_BRENTRY (1 << 5) /* Global bridge VLAN entry */ +#define BRIDGE_VLAN_INFO_ONLY_OPTS (1 << 6) /* Skip create/delete/flags */ struct bridge_vlan_info { __u16 flags; @@ -498,9 +500,10 @@ enum { #define BRIDGE_VLANDB_DUMP_MAX (__BRIDGE_VLANDB_DUMP_MAX - 1) /* flags used in BRIDGE_VLANDB_DUMP_FLAGS attribute to affect dumps */ -#define BRIDGE_VLANDB_DUMPF_STATS (1 << 0) /* Include stats in the dump */ -#define BRIDGE_VLANDB_DUMPF_GLOBAL (1 << 1) /* Dump global vlan options only \ - */ +#define BRIDGE_VLANDB_DUMPF_STATS (1 << 0) /* Include stats in the dump */ +#define BRIDGE_VLANDB_DUMPF_GLOBAL \ + (1 << 1) /* Dump global vlan options only \ + */ /* Bridge vlan RTM attributes * [BRIDGE_VLANDB_ENTRY] = { diff --git a/include/arch/x86_64/linux/if_ether.h b/include/arch/x86_64/linux/if_ether.h index 0f5a904a..6ead4a8d 100644 --- a/include/arch/x86_64/linux/if_ether.h +++ b/include/arch/x86_64/linux/if_ether.h @@ -113,8 +113,9 @@ #define ETH_P_IBOE 0x8915 /* Infiniband over Ethernet */ #define ETH_P_TDLS 0x890D /* TDLS */ #define ETH_P_FIP 0x8914 /* FCoE Initialization Protocol */ -#define ETH_P_80221 0x8917 /* IEEE 802.21 Media Independent Handover Protocol \ - */ +#define ETH_P_80221 \ + 0x8917 /* IEEE 802.21 Media Independent Handover Protocol \ + */ #define ETH_P_HSR 0x892F /* IEC 62439-3 HSRv1 */ #define ETH_P_NSH 0x894F /* Network Service Header */ #define ETH_P_LOOPBACK 0x9000 /* Ethernet loopback packet, per IEEE 802.3 */ diff --git a/include/arch/x86_64/linux/if_packet.h b/include/arch/x86_64/linux/if_packet.h index baf93764..2bd0e81b 100644 --- a/include/arch/x86_64/linux/if_packet.h +++ b/include/arch/x86_64/linux/if_packet.h @@ -107,15 +107,16 @@ struct tpacket_auxdata { }; /* Rx ring - header status */ -#define TP_STATUS_KERNEL 0 -#define TP_STATUS_USER (1 << 0) -#define TP_STATUS_COPY (1 << 1) -#define TP_STATUS_LOSING (1 << 2) -#define TP_STATUS_CSUMNOTREADY (1 << 3) -#define TP_STATUS_VLAN_VALID (1 << 4) /* auxdata has valid tp_vlan_tci */ -#define TP_STATUS_BLK_TMO (1 << 5) -#define TP_STATUS_VLAN_TPID_VALID (1 << 6) /* auxdata has valid tp_vlan_tpid \ - */ +#define TP_STATUS_KERNEL 0 +#define TP_STATUS_USER (1 << 0) +#define TP_STATUS_COPY (1 << 1) +#define TP_STATUS_LOSING (1 << 2) +#define TP_STATUS_CSUMNOTREADY (1 << 3) +#define TP_STATUS_VLAN_VALID (1 << 4) /* auxdata has valid tp_vlan_tci */ +#define TP_STATUS_BLK_TMO (1 << 5) +#define TP_STATUS_VLAN_TPID_VALID \ + (1 << 6) /* auxdata has valid tp_vlan_tpid \ + */ #define TP_STATUS_CSUM_VALID (1 << 7) #define TP_STATUS_GSO_TCP (1 << 8) diff --git a/include/arch/x86_64/linux/in.h b/include/arch/x86_64/linux/in.h index f818f0b2..9ada02e3 100644 --- a/include/arch/x86_64/linux/in.h +++ b/include/arch/x86_64/linux/in.h @@ -225,11 +225,12 @@ struct group_filter { union { struct { __u32 gf_interface_aux; /* interface index */ - struct __kernel_sockaddr_storage gf_group_aux; /* multicast - address - */ - __u32 gf_fmode_aux; /* filter mode */ - __u32 gf_numsrc_aux; /* number of sources */ + struct __kernel_sockaddr_storage + gf_group_aux; /* multicast + address + */ + __u32 gf_fmode_aux; /* filter mode */ + __u32 gf_numsrc_aux; /* number of sources */ struct __kernel_sockaddr_storage gf_slist[1]; /* interface index */ @@ -240,9 +241,10 @@ struct group_filter { address */ __u32 gf_fmode; /* filter mode */ __u32 gf_numsrc; /* number of sources */ - struct __kernel_sockaddr_storage gf_slist_flex[]; /* interface - index - */ + struct __kernel_sockaddr_storage + gf_slist_flex[]; /* interface + index + */ }; }; }; diff --git a/include/arch/x86_64/linux/input-event-codes.h b/include/arch/x86_64/linux/input-event-codes.h index 94c6e4c6..e357a68e 100644 --- a/include/arch/x86_64/linux/input-event-codes.h +++ b/include/arch/x86_64/linux/input-event-codes.h @@ -622,8 +622,9 @@ #define KEY_ASSISTANT 0x247 /* AL Context-aware desktop assistant */ #define KEY_KBD_LAYOUT_NEXT 0x248 /* AC Next Keyboard Layout Select */ #define KEY_EMOJI_PICKER 0x249 /* Show/hide emoji picker (HUTRR101) */ -#define KEY_DICTATE 0x24a /* Start or Stop Voice Dictation Session (HUTRR99) \ - */ +#define KEY_DICTATE \ + 0x24a /* Start or Stop Voice Dictation Session (HUTRR99) \ + */ #define KEY_CAMERA_ACCESS_ENABLE \ 0x24b /* Enables programmatic access to camera devices. (HUTRR72) */ #define KEY_CAMERA_ACCESS_DISABLE \ diff --git a/include/arch/x86_64/linux/ioam6.h b/include/arch/x86_64/linux/ioam6.h index 80f23d2d..4f47fe83 100644 --- a/include/arch/x86_64/linux/ioam6.h +++ b/include/arch/x86_64/linux/ioam6.h @@ -51,8 +51,9 @@ struct ioam6_trace_hdr { struct { __u32 bit7 : 1, bit6 : 1, bit5 : 1, bit4 : 1, bit3 : 1, - bit2 : 1, bit1 : 1, bit0 : 1, bit15 : 1, /* unused - */ + bit2 : 1, bit1 : 1, bit0 : 1, + bit15 : 1, /* unused + */ bit14 : 1, /* unused */ bit13 : 1, /* unused */ bit12 : 1, /* unused */ @@ -82,8 +83,9 @@ struct ioam6_trace_hdr { struct { __u32 bit0 : 1, bit1 : 1, bit2 : 1, bit3 : 1, bit4 : 1, bit5 : 1, bit6 : 1, bit7 : 1, bit8 : 1, - bit9 : 1, bit10 : 1, bit11 : 1, bit12 : 1, /* unused - */ + bit9 : 1, bit10 : 1, bit11 : 1, + bit12 : 1, /* unused + */ bit13 : 1, /* unused */ bit14 : 1, /* unused */ bit15 : 1, /* unused */ diff --git a/include/arch/x86_64/linux/keyctl.h b/include/arch/x86_64/linux/keyctl.h index c9280bbe..eb9750e9 100644 --- a/include/arch/x86_64/linux/keyctl.h +++ b/include/arch/x86_64/linux/keyctl.h @@ -16,15 +16,18 @@ #include <linux/types.h> /* special process keyring shortcut IDs */ -#define KEY_SPEC_THREAD_KEYRING -1 /* - key ID for thread-specific keyring */ -#define KEY_SPEC_PROCESS_KEYRING -2 /* - key ID for process-specific keyring \ - */ -#define KEY_SPEC_SESSION_KEYRING -3 /* - key ID for session-specific keyring \ - */ -#define KEY_SPEC_USER_KEYRING -4 /* - key ID for UID-specific keyring */ -#define KEY_SPEC_USER_SESSION_KEYRING -5 /* - key ID for UID-session keyring \ - */ -#define KEY_SPEC_GROUP_KEYRING -6 /* - key ID for GID-specific keyring */ +#define KEY_SPEC_THREAD_KEYRING -1 /* - key ID for thread-specific keyring */ +#define KEY_SPEC_PROCESS_KEYRING \ + -2 /* - key ID for process-specific keyring \ + */ +#define KEY_SPEC_SESSION_KEYRING \ + -3 /* - key ID for session-specific keyring \ + */ +#define KEY_SPEC_USER_KEYRING -4 /* - key ID for UID-specific keyring */ +#define KEY_SPEC_USER_SESSION_KEYRING \ + -5 /* - key ID for UID-session keyring \ + */ +#define KEY_SPEC_GROUP_KEYRING -6 /* - key ID for GID-specific keyring */ #define KEY_SPEC_REQKEY_AUTH_KEY \ -7 /* - key ID for assumed request_key auth key */ #define KEY_SPEC_REQUESTOR_KEYRING \ @@ -42,19 +45,20 @@ #define KEY_REQKEY_DEFL_REQUESTOR_KEYRING 7 /* keyctl commands */ -#define KEYCTL_GET_KEYRING_ID 0 /* ask for a keyring's ID */ -#define KEYCTL_JOIN_SESSION_KEYRING 1 /* join or start named session keyring \ - */ -#define KEYCTL_UPDATE 2 /* update a key */ -#define KEYCTL_REVOKE 3 /* revoke a key */ -#define KEYCTL_CHOWN 4 /* set ownership of a key */ -#define KEYCTL_SETPERM 5 /* set perms on a key */ -#define KEYCTL_DESCRIBE 6 /* describe a key */ -#define KEYCTL_CLEAR 7 /* clear contents of a keyring */ -#define KEYCTL_LINK 8 /* link a key into a keyring */ -#define KEYCTL_UNLINK 9 /* unlink a key from a keyring */ -#define KEYCTL_SEARCH 10 /* search for a key in a keyring */ -#define KEYCTL_READ 11 /* read a key or keyring's contents */ +#define KEYCTL_GET_KEYRING_ID 0 /* ask for a keyring's ID */ +#define KEYCTL_JOIN_SESSION_KEYRING \ + 1 /* join or start named session keyring \ + */ +#define KEYCTL_UPDATE 2 /* update a key */ +#define KEYCTL_REVOKE 3 /* revoke a key */ +#define KEYCTL_CHOWN 4 /* set ownership of a key */ +#define KEYCTL_SETPERM 5 /* set perms on a key */ +#define KEYCTL_DESCRIBE 6 /* describe a key */ +#define KEYCTL_CLEAR 7 /* clear contents of a keyring */ +#define KEYCTL_LINK 8 /* link a key into a keyring */ +#define KEYCTL_UNLINK 9 /* unlink a key from a keyring */ +#define KEYCTL_SEARCH 10 /* search for a key in a keyring */ +#define KEYCTL_READ 11 /* read a key or keyring's contents */ #define KEYCTL_INSTANTIATE 12 /* instantiate a partially constructed key */ #define KEYCTL_NEGATE 13 /* negate a partially constructed key */ #define KEYCTL_SET_REQKEY_KEYRING 14 /* set default request-key keyring */ @@ -62,18 +66,19 @@ #define KEYCTL_ASSUME_AUTHORITY 16 /* assume request_key() authorisation */ #define KEYCTL_GET_SECURITY 17 /* get key security label */ #define KEYCTL_SESSION_TO_PARENT \ - 18 /* apply session keyring to parent process */ -#define KEYCTL_REJECT 19 /* reject a partially constructed key */ -#define KEYCTL_INSTANTIATE_IOV 20 /* instantiate a partially constructed key \ - */ -#define KEYCTL_INVALIDATE 21 /* invalidate a key */ -#define KEYCTL_GET_PERSISTENT 22 /* get a user's persistent keyring */ -#define KEYCTL_DH_COMPUTE 23 /* Compute Diffie-Hellman values */ -#define KEYCTL_PKEY_QUERY 24 /* Query public key parameters */ -#define KEYCTL_PKEY_ENCRYPT 25 /* Encrypt a blob using a public key */ -#define KEYCTL_PKEY_DECRYPT 26 /* Decrypt a blob using a public key */ -#define KEYCTL_PKEY_SIGN 27 /* Create a public key signature */ -#define KEYCTL_PKEY_VERIFY 28 /* Verify a public key signature */ + 18 /* apply session keyring to parent process */ +#define KEYCTL_REJECT 19 /* reject a partially constructed key */ +#define KEYCTL_INSTANTIATE_IOV \ + 20 /* instantiate a partially constructed key \ + */ +#define KEYCTL_INVALIDATE 21 /* invalidate a key */ +#define KEYCTL_GET_PERSISTENT 22 /* get a user's persistent keyring */ +#define KEYCTL_DH_COMPUTE 23 /* Compute Diffie-Hellman values */ +#define KEYCTL_PKEY_QUERY 24 /* Query public key parameters */ +#define KEYCTL_PKEY_ENCRYPT 25 /* Encrypt a blob using a public key */ +#define KEYCTL_PKEY_DECRYPT 26 /* Decrypt a blob using a public key */ +#define KEYCTL_PKEY_SIGN 27 /* Create a public key signature */ +#define KEYCTL_PKEY_VERIFY 28 /* Verify a public key signature */ #define KEYCTL_RESTRICT_KEYRING \ 29 /* Restrict keys allowed to link to a keyring */ #define KEYCTL_MOVE 30 /* Move keys between keyrings */ @@ -130,9 +135,10 @@ struct keyctl_pkey_params { * Capabilities flags. The capabilities list is an array of 8-bit integers; * each integer can carry up to 8 flags. */ -#define KEYCTL_CAPS0_CAPABILITIES 0x01 /* KEYCTL_CAPABILITIES supported */ -#define KEYCTL_CAPS0_PERSISTENT_KEYRINGS 0x02 /* Persistent keyrings enabled \ - */ +#define KEYCTL_CAPS0_CAPABILITIES 0x01 /* KEYCTL_CAPABILITIES supported */ +#define KEYCTL_CAPS0_PERSISTENT_KEYRINGS \ + 0x02 /* Persistent keyrings enabled \ + */ #define KEYCTL_CAPS0_DIFFIE_HELLMAN \ 0x04 /* Diffie-Hellman computation enabled */ #define KEYCTL_CAPS0_PUBLIC_KEY 0x08 /* Public key ops enabled */ diff --git a/include/arch/x86_64/linux/magic.h b/include/arch/x86_64/linux/magic.h index 6ef2a2b2..fe3f04ac 100644 --- a/include/arch/x86_64/linux/magic.h +++ b/include/arch/x86_64/linux/magic.h @@ -9,8 +9,9 @@ #define CEPH_SUPER_MAGIC 0x00c36400 #define CODA_SUPER_MAGIC 0x73757245 #define CRAMFS_MAGIC 0x28cd3d45 /* some random number */ -#define CRAMFS_MAGIC_WEND 0x453dcd28 /* magic number with the wrong endianess \ - */ +#define CRAMFS_MAGIC_WEND \ + 0x453dcd28 /* magic number with the wrong endianess \ + */ #define DEBUGFS_MAGIC 0x64626720 #define SECURITYFS_MAGIC 0x73636673 #define SELINUX_MAGIC 0xf97cff8c diff --git a/include/arch/x86_64/linux/mdio.h b/include/arch/x86_64/linux/mdio.h index 77c5bc00..a05b1eac 100644 --- a/include/arch/x86_64/linux/mdio.h +++ b/include/arch/x86_64/linux/mdio.h @@ -354,15 +354,17 @@ /* BASE-T1 auto-negotiation advertisement register [15:0] */ #define MDIO_AN_T1_ADV_L_PAUSE_CAP ADVERTISE_PAUSE_CAP #define MDIO_AN_T1_ADV_L_PAUSE_ASYM ADVERTISE_PAUSE_ASYM -#define MDIO_AN_T1_ADV_L_FORCE_MS 0x1000 /* Force Master/slave Configuration \ - */ +#define MDIO_AN_T1_ADV_L_FORCE_MS \ + 0x1000 /* Force Master/slave Configuration \ + */ #define MDIO_AN_T1_ADV_L_REMOTE_FAULT ADVERTISE_RFAULT #define MDIO_AN_T1_ADV_L_ACK ADVERTISE_LPACK #define MDIO_AN_T1_ADV_L_NEXT_PAGE_REQ ADVERTISE_NPAGE /* BASE-T1 auto-negotiation advertisement register [31:16] */ -#define MDIO_AN_T1_ADV_M_B10L 0x4000 /* device is compatible with 10BASE-T1L \ - */ +#define MDIO_AN_T1_ADV_M_B10L \ + 0x4000 /* device is compatible with 10BASE-T1L \ + */ #define MDIO_AN_T1_ADV_M_1000BT1 0x0080 /* advertise 1000BASE-T1 */ #define MDIO_AN_T1_ADV_M_100BT1 0x0020 /* advertise 100BASE-T1 */ #define MDIO_AN_T1_ADV_M_MST 0x0010 /* advertise master preference */ diff --git a/include/arch/x86_64/linux/mount.h b/include/arch/x86_64/linux/mount.h index 8e6ac41d..4baac606 100644 --- a/include/arch/x86_64/linux/mount.h +++ b/include/arch/x86_64/linux/mount.h @@ -68,8 +68,9 @@ /* * move_mount() flags. */ -#define MOVE_MOUNT_F_SYMLINKS 0x00000001 /* Follow symlinks on from path */ -#define MOVE_MOUNT_F_AUTOMOUNTS 0x00000002 /* Follow automounts on from path \ +#define MOVE_MOUNT_F_SYMLINKS 0x00000001 /* Follow symlinks on from path */ +#define MOVE_MOUNT_F_AUTOMOUNTS \ + 0x00000002 /* Follow automounts on from path \ */ #define MOVE_MOUNT_F_EMPTY_PATH 0x00000004 /* Empty from path permitted */ #define MOVE_MOUNT_T_SYMLINKS 0x00000010 /* Follow symlinks on to path */ @@ -234,10 +235,11 @@ struct mnt_id_req { #define STATMOUNT_SB_SOURCE 0x00000200U /* Want/got sb_source */ #define STATMOUNT_OPT_ARRAY 0x00000400U /* Want/got opt_... */ #define STATMOUNT_OPT_SEC_ARRAY 0x00000800U /* Want/got opt_sec... */ -#define STATMOUNT_SUPPORTED_MASK 0x00001000U /* Want/got supported mask flags \ - */ -#define STATMOUNT_MNT_UIDMAP 0x00002000U /* Want/got uidmap... */ -#define STATMOUNT_MNT_GIDMAP 0x00004000U /* Want/got gidmap... */ +#define STATMOUNT_SUPPORTED_MASK \ + 0x00001000U /* Want/got supported mask flags \ + */ +#define STATMOUNT_MNT_UIDMAP 0x00002000U /* Want/got uidmap... */ +#define STATMOUNT_MNT_GIDMAP 0x00004000U /* Want/got gidmap... */ /* * Special @mnt_id values that can be passed to listmount diff --git a/include/arch/x86_64/linux/mroute.h b/include/arch/x86_64/linux/mroute.h index 40bd575e..df833684 100644 --- a/include/arch/x86_64/linux/mroute.h +++ b/include/arch/x86_64/linux/mroute.h @@ -19,11 +19,13 @@ #define MRT_INIT (MRT_BASE) /* Activate the kernel mroute code */ #define MRT_DONE (MRT_BASE + 1) /* Shutdown the kernel mroute */ #define MRT_ADD_VIF (MRT_BASE + 2) /* Add a virtual interface */ -#define MRT_DEL_VIF (MRT_BASE + 3) /* Delete a virtual interface \ +#define MRT_DEL_VIF \ + (MRT_BASE + 3) /* Delete a virtual interface \ */ #define MRT_ADD_MFC (MRT_BASE + 4) /* Add a multicast forwarding entry */ -#define MRT_DEL_MFC (MRT_BASE + 5) /* Delete a multicast forwarding entry \ - */ +#define MRT_DEL_MFC \ + (MRT_BASE + 5) /* Delete a multicast forwarding entry \ + */ #define MRT_VERSION (MRT_BASE + 6) /* Get the kernel multicast version */ #define MRT_ASSERT (MRT_BASE + 7) /* Activate PIM assert mode */ #define MRT_PIM (MRT_BASE + 8) /* enable PIM code */ diff --git a/include/arch/x86_64/linux/mroute6.h b/include/arch/x86_64/linux/mroute6.h index 195627c5..262f1e10 100644 --- a/include/arch/x86_64/linux/mroute6.h +++ b/include/arch/x86_64/linux/mroute6.h @@ -22,21 +22,26 @@ #define MRT6_INIT (MRT6_BASE) /* Activate the kernel mroute code */ #define MRT6_DONE (MRT6_BASE + 1) /* Shutdown the kernel mroute */ #define MRT6_ADD_MIF (MRT6_BASE + 2) /* Add a virtual interface */ -#define MRT6_DEL_MIF (MRT6_BASE + 3) /* Delete a virtual interface \ - */ -#define MRT6_ADD_MFC (MRT6_BASE + 4) /* Add a multicast forwarding entry \ - */ -#define MRT6_DEL_MFC (MRT6_BASE + 5) /* Delete a multicast forwarding entry \ - */ -#define MRT6_VERSION (MRT6_BASE + 6) /* Get the kernel multicast version \ - */ -#define MRT6_ASSERT (MRT6_BASE + 7) /* Activate PIM assert mode */ -#define MRT6_PIM (MRT6_BASE + 8) /* enable PIM code */ -#define MRT6_TABLE (MRT6_BASE + 9) /* Specify mroute table ID */ +#define MRT6_DEL_MIF \ + (MRT6_BASE + 3) /* Delete a virtual interface \ + */ +#define MRT6_ADD_MFC \ + (MRT6_BASE + 4) /* Add a multicast forwarding entry \ + */ +#define MRT6_DEL_MFC \ + (MRT6_BASE + 5) /* Delete a multicast forwarding entry \ + */ +#define MRT6_VERSION \ + (MRT6_BASE + 6) /* Get the kernel multicast version \ + */ +#define MRT6_ASSERT (MRT6_BASE + 7) /* Activate PIM assert mode */ +#define MRT6_PIM (MRT6_BASE + 8) /* enable PIM code */ +#define MRT6_TABLE (MRT6_BASE + 9) /* Specify mroute table ID */ #define MRT6_ADD_MFC_PROXY (MRT6_BASE + 10) /* Add a (*,*|G) mfc entry */ #define MRT6_DEL_MFC_PROXY (MRT6_BASE + 11) /* Del a (*,*|G) mfc entry */ -#define MRT6_FLUSH (MRT6_BASE + 12) /* Flush all mfc entries and/or vifs \ - */ +#define MRT6_FLUSH \ + (MRT6_BASE + 12) /* Flush all mfc entries and/or vifs \ + */ #define MRT6_MAX (MRT6_BASE + 12) #define SIOCGETMIFCNT_IN6 SIOCPROTOPRIVATE /* IP protocol privates */ diff --git a/include/arch/x86_64/linux/msg.h b/include/arch/x86_64/linux/msg.h index f82b27eb..11769746 100644 --- a/include/arch/x86_64/linux/msg.h +++ b/include/arch/x86_64/linux/msg.h @@ -74,10 +74,11 @@ struct msginfo { * the queue. This is also an arbitrary choice (since 2.6.0). */ -#define MSGMNI 32000 /* <= IPCMNI */ /* max # of msg queue identifiers */ -#define MSGMAX 8192 /* <= INT_MAX */ /* max size of message (bytes) */ -#define MSGMNB 16384 /* <= INT_MAX */ /* default max size of a message queue \ - */ +#define MSGMNI 32000 /* <= IPCMNI */ /* max # of msg queue identifiers */ +#define MSGMAX 8192 /* <= INT_MAX */ /* max size of message (bytes) */ +#define MSGMNB \ + 16384 /* <= INT_MAX */ /* default max size of a message queue \ + */ /* unused */ #define MSGPOOL (MSGMNI * MSGMNB / 1024) /* size in kbytes of message pool */ diff --git a/include/arch/x86_64/linux/netfilter_bridge/ebt_log.h b/include/arch/x86_64/linux/netfilter_bridge/ebt_log.h index 9d225848..6f3ad507 100644 --- a/include/arch/x86_64/linux/netfilter_bridge/ebt_log.h +++ b/include/arch/x86_64/linux/netfilter_bridge/ebt_log.h @@ -4,8 +4,9 @@ #include <linux/types.h> -#define EBT_LOG_IP 0x01 /* if the frame is made by ip, log the ip information \ - */ +#define EBT_LOG_IP \ + 0x01 /* if the frame is made by ip, log the ip information \ + */ #define EBT_LOG_ARP 0x02 #define EBT_LOG_NFLOG 0x04 #define EBT_LOG_IP6 0x08 diff --git a/include/arch/x86_64/linux/netlink.h b/include/arch/x86_64/linux/netlink.h index ccf100fa..a740fb7c 100644 --- a/include/arch/x86_64/linux/netlink.h +++ b/include/arch/x86_64/linux/netlink.h @@ -6,11 +6,12 @@ #include <linux/socket.h> /* for __kernel_sa_family_t */ #include <linux/types.h> -#define NETLINK_ROUTE 0 /* Routing/device hook */ -#define NETLINK_UNUSED 1 /* Unused number */ -#define NETLINK_USERSOCK 2 /* Reserved for user mode socket protocols */ -#define NETLINK_FIREWALL 3 /* Unused number, formerly ip_queue */ -#define NETLINK_SOCK_DIAG 4 /* socket monitoring \ +#define NETLINK_ROUTE 0 /* Routing/device hook */ +#define NETLINK_UNUSED 1 /* Unused number */ +#define NETLINK_USERSOCK 2 /* Reserved for user mode socket protocols */ +#define NETLINK_FIREWALL 3 /* Unused number, formerly ip_queue */ +#define NETLINK_SOCK_DIAG \ + 4 /* socket monitoring \ */ #define NETLINK_NFLOG 5 /* netfilter/iptables ULOG */ #define NETLINK_XFRM 6 /* ipsec */ @@ -60,12 +61,13 @@ struct nlmsghdr { /* Flags values */ -#define NLM_F_REQUEST 0x01 /* It is request message. */ -#define NLM_F_MULTI 0x02 /* Multipart message, terminated by NLMSG_DONE */ -#define NLM_F_ACK 0x04 /* Reply with ack, with zero or error code */ -#define NLM_F_ECHO 0x08 /* Receive resulting notifications */ -#define NLM_F_DUMP_INTR 0x10 /* Dump was inconsistent due to sequence change \ - */ +#define NLM_F_REQUEST 0x01 /* It is request message. */ +#define NLM_F_MULTI 0x02 /* Multipart message, terminated by NLMSG_DONE */ +#define NLM_F_ACK 0x04 /* Reply with ack, with zero or error code */ +#define NLM_F_ECHO 0x08 /* Receive resulting notifications */ +#define NLM_F_DUMP_INTR \ + 0x10 /* Dump was inconsistent due to sequence change \ + */ #define NLM_F_DUMP_FILTERED 0x20 /* Dump was filtered as requested */ /* Modifiers to GET request */ diff --git a/include/arch/x86_64/linux/pci_regs.h b/include/arch/x86_64/linux/pci_regs.h index b584007f..69e48abb 100644 --- a/include/arch/x86_64/linux/pci_regs.h +++ b/include/arch/x86_64/linux/pci_regs.h @@ -150,8 +150,9 @@ #define PCI_PREF_RANGE_TYPE_32 0x00 #define PCI_PREF_RANGE_TYPE_64 0x01 #define PCI_PREF_RANGE_MASK (~0x0fUL) -#define PCI_PREF_BASE_UPPER32 0x28 /* Upper half of prefetchable memory range \ - */ +#define PCI_PREF_BASE_UPPER32 \ + 0x28 /* Upper half of prefetchable memory range \ + */ #define PCI_PREF_LIMIT_UPPER32 0x2c #define PCI_IO_BASE_UPPER16 0x30 /* Upper half of I/O addresses */ #define PCI_IO_LIMIT_UPPER16 0x32 @@ -200,8 +201,9 @@ #define PCI_CB_BRIDGE_CTL_VGA 0x08 #define PCI_CB_BRIDGE_CTL_MASTER_ABORT 0x20 #define PCI_CB_BRIDGE_CTL_CB_RESET 0x40 /* CardBus reset */ -#define PCI_CB_BRIDGE_CTL_16BIT_INT 0x80 /* Enable interrupt for 16-bit cards \ - */ +#define PCI_CB_BRIDGE_CTL_16BIT_INT \ + 0x80 /* Enable interrupt for 16-bit cards \ + */ #define PCI_CB_BRIDGE_CTL_PREFETCH_MEM0 \ 0x100 /* Prefetch enable for both memory regions */ #define PCI_CB_BRIDGE_CTL_PREFETCH_MEM1 0x200 @@ -285,10 +287,11 @@ #define PCI_AGP_STATUS_RATE1 0x0001 /* 1x transfer rate supported */ #define PCI_AGP_COMMAND 8 /* Control register */ #define PCI_AGP_COMMAND_RQ_MASK \ - 0xff000000 /* Master: Maximum number of requests */ -#define PCI_AGP_COMMAND_SBA 0x0200 /* Sideband addressing enabled */ -#define PCI_AGP_COMMAND_AGP 0x0100 /* Allow processing of AGP transactions */ -#define PCI_AGP_COMMAND_64BIT 0x0020 /* Allow processing of 64-bit addresses \ + 0xff000000 /* Master: Maximum number of requests */ +#define PCI_AGP_COMMAND_SBA 0x0200 /* Sideband addressing enabled */ +#define PCI_AGP_COMMAND_AGP 0x0100 /* Allow processing of AGP transactions */ +#define PCI_AGP_COMMAND_64BIT \ + 0x0020 /* Allow processing of 64-bit addresses \ */ #define PCI_AGP_COMMAND_FW 0x0010 /* Force FW transfers */ #define PCI_AGP_COMMAND_RATE4 0x0004 /* Use 4x rate */ @@ -321,14 +324,15 @@ #define PCI_MSI_FLAGS_MASKBIT 0x0100 /* Per-vector masking capable */ #define PCI_MSI_RFU 3 /* Rest of capability flags */ #define PCI_MSI_ADDRESS_LO 0x04 /* Lower 32 bits */ -#define PCI_MSI_ADDRESS_HI 0x08 /* Upper 32 bits (if PCI_MSI_FLAGS_64BIT set) \ - */ -#define PCI_MSI_DATA_32 0x08 /* 16 bits of data for 32-bit devices */ -#define PCI_MSI_MASK_32 0x0c /* Mask bits register for 32-bit devices */ -#define PCI_MSI_PENDING_32 0x10 /* Pending intrs for 32-bit devices */ -#define PCI_MSI_DATA_64 0x0c /* 16 bits of data for 64-bit devices */ -#define PCI_MSI_MASK_64 0x10 /* Mask bits register for 64-bit devices */ -#define PCI_MSI_PENDING_64 0x14 /* Pending intrs for 64-bit devices */ +#define PCI_MSI_ADDRESS_HI \ + 0x08 /* Upper 32 bits (if PCI_MSI_FLAGS_64BIT set) \ + */ +#define PCI_MSI_DATA_32 0x08 /* 16 bits of data for 32-bit devices */ +#define PCI_MSI_MASK_32 0x0c /* Mask bits register for 32-bit devices */ +#define PCI_MSI_PENDING_32 0x10 /* Pending intrs for 32-bit devices */ +#define PCI_MSI_DATA_64 0x0c /* 16 bits of data for 64-bit devices */ +#define PCI_MSI_MASK_64 0x10 /* Mask bits register for 64-bit devices */ +#define PCI_MSI_PENDING_64 0x14 /* Pending intrs for 64-bit devices */ /* MSI-X registers (in MSI-X capability) */ #define PCI_MSIX_FLAGS 2 /* Message Control */ @@ -454,7 +458,8 @@ #define PCI_X_STATUS_MAX_READ 0x00600000 /* Designed Max Memory Read Count */ #define PCI_X_STATUS_MAX_SPLIT \ 0x03800000 /* Designed Max Outstanding Split Transactions */ -#define PCI_X_STATUS_MAX_CUM 0x1c000000 /* Designed Max Cumulative Read Size \ +#define PCI_X_STATUS_MAX_CUM \ + 0x1c000000 /* Designed Max Cumulative Read Size \ */ #define PCI_X_STATUS_SPL_ERR 0x20000000 /* Rcvd Split Completion Error Msg */ #define PCI_X_STATUS_266MHZ 0x40000000 /* 266 MHz capable */ @@ -585,39 +590,41 @@ 0x0400 /* Link Bandwidth Management Interrupt Enable */ #define PCI_EXP_LNKCTL_LABIE \ 0x0800 /* Link Autonomous Bandwidth Interrupt Enable */ -#define PCI_EXP_LNKSTA 0x12 /* Link Status */ -#define PCI_EXP_LNKSTA_CLS 0x000f /* Current Link Speed */ -#define PCI_EXP_LNKSTA_CLS_2_5GB 0x0001 /* Current Link Speed 2.5GT/s */ -#define PCI_EXP_LNKSTA_CLS_5_0GB 0x0002 /* Current Link Speed 5.0GT/s */ -#define PCI_EXP_LNKSTA_CLS_8_0GB 0x0003 /* Current Link Speed 8.0GT/s */ -#define PCI_EXP_LNKSTA_CLS_16_0GB 0x0004 /* Current Link Speed 16.0GT/s */ -#define PCI_EXP_LNKSTA_CLS_32_0GB 0x0005 /* Current Link Speed 32.0GT/s */ -#define PCI_EXP_LNKSTA_CLS_64_0GB 0x0006 /* Current Link Speed 64.0GT/s */ -#define PCI_EXP_LNKSTA_NLW 0x03f0 /* Negotiated Link Width */ -#define PCI_EXP_LNKSTA_NLW_X1 0x0010 /* Current Link Width x1 */ -#define PCI_EXP_LNKSTA_NLW_X2 0x0020 /* Current Link Width x2 */ -#define PCI_EXP_LNKSTA_NLW_X4 0x0040 /* Current Link Width x4 */ -#define PCI_EXP_LNKSTA_NLW_X8 0x0080 /* Current Link Width x8 */ -#define PCI_EXP_LNKSTA_NLW_SHIFT 4 /* start of NLW mask in link status */ -#define PCI_EXP_LNKSTA_LT 0x0800 /* Link Training */ -#define PCI_EXP_LNKSTA_SLC 0x1000 /* Slot Clock Configuration */ -#define PCI_EXP_LNKSTA_DLLLA 0x2000 /* Data Link Layer Link Active */ -#define PCI_EXP_LNKSTA_LBMS 0x4000 /* Link Bandwidth Management Status */ -#define PCI_EXP_LNKSTA_LABS 0x8000 /* Link Autonomous Bandwidth Status */ -#define PCI_CAP_EXP_ENDPOINT_SIZEOF_V1 20 /* v1 endpoints with link end here \ - */ -#define PCI_EXP_SLTCAP 0x14 /* Slot Capabilities */ -#define PCI_EXP_SLTCAP_ABP 0x00000001 /* Attention Button Present */ -#define PCI_EXP_SLTCAP_PCP 0x00000002 /* Power Controller Present */ -#define PCI_EXP_SLTCAP_MRLSP 0x00000004 /* MRL Sensor Present */ -#define PCI_EXP_SLTCAP_AIP 0x00000008 /* Attention Indicator Present */ -#define PCI_EXP_SLTCAP_PIP 0x00000010 /* Power Indicator Present */ -#define PCI_EXP_SLTCAP_HPS 0x00000020 /* Hot-Plug Surprise */ -#define PCI_EXP_SLTCAP_HPC 0x00000040 /* Hot-Plug Capable */ -#define PCI_EXP_SLTCAP_SPLV 0x00007f80 /* Slot Power Limit Value */ -#define PCI_EXP_SLTCAP_SPLS 0x00018000 /* Slot Power Limit Scale */ -#define PCI_EXP_SLTCAP_EIP 0x00020000 /* Electromechanical Interlock Present \ +#define PCI_EXP_LNKSTA 0x12 /* Link Status */ +#define PCI_EXP_LNKSTA_CLS 0x000f /* Current Link Speed */ +#define PCI_EXP_LNKSTA_CLS_2_5GB 0x0001 /* Current Link Speed 2.5GT/s */ +#define PCI_EXP_LNKSTA_CLS_5_0GB 0x0002 /* Current Link Speed 5.0GT/s */ +#define PCI_EXP_LNKSTA_CLS_8_0GB 0x0003 /* Current Link Speed 8.0GT/s */ +#define PCI_EXP_LNKSTA_CLS_16_0GB 0x0004 /* Current Link Speed 16.0GT/s */ +#define PCI_EXP_LNKSTA_CLS_32_0GB 0x0005 /* Current Link Speed 32.0GT/s */ +#define PCI_EXP_LNKSTA_CLS_64_0GB 0x0006 /* Current Link Speed 64.0GT/s */ +#define PCI_EXP_LNKSTA_NLW 0x03f0 /* Negotiated Link Width */ +#define PCI_EXP_LNKSTA_NLW_X1 0x0010 /* Current Link Width x1 */ +#define PCI_EXP_LNKSTA_NLW_X2 0x0020 /* Current Link Width x2 */ +#define PCI_EXP_LNKSTA_NLW_X4 0x0040 /* Current Link Width x4 */ +#define PCI_EXP_LNKSTA_NLW_X8 0x0080 /* Current Link Width x8 */ +#define PCI_EXP_LNKSTA_NLW_SHIFT 4 /* start of NLW mask in link status */ +#define PCI_EXP_LNKSTA_LT 0x0800 /* Link Training */ +#define PCI_EXP_LNKSTA_SLC 0x1000 /* Slot Clock Configuration */ +#define PCI_EXP_LNKSTA_DLLLA 0x2000 /* Data Link Layer Link Active */ +#define PCI_EXP_LNKSTA_LBMS 0x4000 /* Link Bandwidth Management Status */ +#define PCI_EXP_LNKSTA_LABS 0x8000 /* Link Autonomous Bandwidth Status */ +#define PCI_CAP_EXP_ENDPOINT_SIZEOF_V1 \ + 20 /* v1 endpoints with link end here \ */ +#define PCI_EXP_SLTCAP 0x14 /* Slot Capabilities */ +#define PCI_EXP_SLTCAP_ABP 0x00000001 /* Attention Button Present */ +#define PCI_EXP_SLTCAP_PCP 0x00000002 /* Power Controller Present */ +#define PCI_EXP_SLTCAP_MRLSP 0x00000004 /* MRL Sensor Present */ +#define PCI_EXP_SLTCAP_AIP 0x00000008 /* Attention Indicator Present */ +#define PCI_EXP_SLTCAP_PIP 0x00000010 /* Power Indicator Present */ +#define PCI_EXP_SLTCAP_HPS 0x00000020 /* Hot-Plug Surprise */ +#define PCI_EXP_SLTCAP_HPC 0x00000040 /* Hot-Plug Capable */ +#define PCI_EXP_SLTCAP_SPLV 0x00007f80 /* Slot Power Limit Value */ +#define PCI_EXP_SLTCAP_SPLS 0x00018000 /* Slot Power Limit Scale */ +#define PCI_EXP_SLTCAP_EIP \ + 0x00020000 /* Electromechanical Interlock Present \ + */ #define PCI_EXP_SLTCAP_NCCS 0x00040000 /* No Command Completed Support */ #define PCI_EXP_SLTCAP_PSN 0xfff80000 /* Physical Slot Number */ #define PCI_EXP_SLTCTL 0x18 /* Slot Control */ @@ -630,19 +637,21 @@ #define PCI_EXP_SLTCTL_AIC 0x00c0 /* Attention Indicator Control */ #define PCI_EXP_SLTCTL_ATTN_IND_SHIFT 6 /* Attention Indicator shift */ #define PCI_EXP_SLTCTL_ATTN_IND_ON 0x0040 /* Attention Indicator on */ -#define PCI_EXP_SLTCTL_ATTN_IND_BLINK 0x0080 /* Attention Indicator blinking \ - */ -#define PCI_EXP_SLTCTL_ATTN_IND_OFF 0x00c0 /* Attention Indicator off */ -#define PCI_EXP_SLTCTL_PIC 0x0300 /* Power Indicator Control */ -#define PCI_EXP_SLTCTL_PWR_IND_ON 0x0100 /* Power Indicator on */ -#define PCI_EXP_SLTCTL_PWR_IND_BLINK 0x0200 /* Power Indicator blinking */ -#define PCI_EXP_SLTCTL_PWR_IND_OFF 0x0300 /* Power Indicator off */ -#define PCI_EXP_SLTCTL_PCC 0x0400 /* Power Controller Control */ -#define PCI_EXP_SLTCTL_PWR_ON 0x0000 /* Power On */ -#define PCI_EXP_SLTCTL_PWR_OFF 0x0400 /* Power Off */ -#define PCI_EXP_SLTCTL_EIC 0x0800 /* Electromechanical Interlock Control */ -#define PCI_EXP_SLTCTL_DLLSCE 0x1000 /* Data Link Layer State Changed Enable \ +#define PCI_EXP_SLTCTL_ATTN_IND_BLINK \ + 0x0080 /* Attention Indicator blinking \ */ +#define PCI_EXP_SLTCTL_ATTN_IND_OFF 0x00c0 /* Attention Indicator off */ +#define PCI_EXP_SLTCTL_PIC 0x0300 /* Power Indicator Control */ +#define PCI_EXP_SLTCTL_PWR_IND_ON 0x0100 /* Power Indicator on */ +#define PCI_EXP_SLTCTL_PWR_IND_BLINK 0x0200 /* Power Indicator blinking */ +#define PCI_EXP_SLTCTL_PWR_IND_OFF 0x0300 /* Power Indicator off */ +#define PCI_EXP_SLTCTL_PCC 0x0400 /* Power Controller Control */ +#define PCI_EXP_SLTCTL_PWR_ON 0x0000 /* Power On */ +#define PCI_EXP_SLTCTL_PWR_OFF 0x0400 /* Power Off */ +#define PCI_EXP_SLTCTL_EIC 0x0800 /* Electromechanical Interlock Control */ +#define PCI_EXP_SLTCTL_DLLSCE \ + 0x1000 /* Data Link Layer State Changed Enable \ + */ #define PCI_EXP_SLTCTL_ASPL_DISABLE 0x2000 /* Auto Slot Power Limit Disable */ #define PCI_EXP_SLTCTL_IBPD_DISABLE 0x4000 /* In-band PD disable */ #define PCI_EXP_SLTSTA 0x1a /* Slot Status */ @@ -660,8 +669,9 @@ #define PCI_EXP_RTCTL_SENFEE 0x0002 /* System Error on Non-Fatal Error */ #define PCI_EXP_RTCTL_SEFEE 0x0004 /* System Error on Fatal Error */ #define PCI_EXP_RTCTL_PMEIE 0x0008 /* PME Interrupt Enable */ -#define PCI_EXP_RTCTL_RRS_SVE 0x0010 /* Config RRS Software Visibility Enable \ - */ +#define PCI_EXP_RTCTL_RRS_SVE \ + 0x0010 /* Config RRS Software Visibility Enable \ + */ #define PCI_EXP_RTCTL_CRSSVE PCI_EXP_RTCTL_RRS_SVE /* compatibility */ #define PCI_EXP_RTCAP 0x1e /* Root Capabilities */ #define PCI_EXP_RTCAP_RRS_SV 0x0001 /* Config RRS Software Visibility */ @@ -681,19 +691,21 @@ #define PCI_EXP_DEVCAP2 0x24 /* Device Capabilities 2 */ #define PCI_EXP_DEVCAP2_COMP_TMOUT_DIS \ 0x00000010 /* Completion Timeout Disable supported */ -#define PCI_EXP_DEVCAP2_ARI 0x00000020 /* Alternative Routing-ID */ -#define PCI_EXP_DEVCAP2_ATOMIC_ROUTE 0x00000040 /* Atomic Op routing */ -#define PCI_EXP_DEVCAP2_ATOMIC_COMP32 0x00000080 /* 32b AtomicOp completion */ -#define PCI_EXP_DEVCAP2_ATOMIC_COMP64 0x00000100 /* 64b AtomicOp completion */ -#define PCI_EXP_DEVCAP2_ATOMIC_COMP128 0x00000200 /* 128b AtomicOp completion \ - */ +#define PCI_EXP_DEVCAP2_ARI 0x00000020 /* Alternative Routing-ID */ +#define PCI_EXP_DEVCAP2_ATOMIC_ROUTE 0x00000040 /* Atomic Op routing */ +#define PCI_EXP_DEVCAP2_ATOMIC_COMP32 0x00000080 /* 32b AtomicOp completion */ +#define PCI_EXP_DEVCAP2_ATOMIC_COMP64 0x00000100 /* 64b AtomicOp completion */ +#define PCI_EXP_DEVCAP2_ATOMIC_COMP128 \ + 0x00000200 /* 128b AtomicOp completion \ + */ #define PCI_EXP_DEVCAP2_LTR 0x00000800 /* Latency tolerance reporting */ -#define PCI_EXP_DEVCAP2_TPH_COMP_MASK 0x00003000 /* TPH completer support */ -#define PCI_EXP_DEVCAP2_OBFF_MASK 0x000c0000 /* OBFF support mechanism */ -#define PCI_EXP_DEVCAP2_OBFF_MSG 0x00040000 /* New message signaling */ -#define PCI_EXP_DEVCAP2_OBFF_WAKE 0x00080000 /* Re-use WAKE# for OBFF */ -#define PCI_EXP_DEVCAP2_EE_PREFIX 0x00200000 /* End-End TLP Prefix */ -#define PCI_EXP_DEVCAP2_EE_PREFIX_MAX 0x00c00000 /* Max End-End TLP Prefixes \ +#define PCI_EXP_DEVCAP2_TPH_COMP_MASK 0x00003000 /* TPH completer support */ +#define PCI_EXP_DEVCAP2_OBFF_MASK 0x000c0000 /* OBFF support mechanism */ +#define PCI_EXP_DEVCAP2_OBFF_MSG 0x00040000 /* New message signaling */ +#define PCI_EXP_DEVCAP2_OBFF_WAKE 0x00080000 /* Re-use WAKE# for OBFF */ +#define PCI_EXP_DEVCAP2_EE_PREFIX 0x00200000 /* End-End TLP Prefix */ +#define PCI_EXP_DEVCAP2_EE_PREFIX_MAX \ + 0x00c00000 /* Max End-End TLP Prefixes \ */ #define PCI_EXP_DEVCTL2 0x28 /* Device Control 2 */ #define PCI_EXP_DEVCTL2_COMP_TIMEOUT 0x000f /* Completion Timeout Value */ @@ -1157,24 +1169,27 @@ #define PCI_L1SS_CAP_L1_PM_SS 0x00000010 /* L1 PM Substates Supported */ #define PCI_L1SS_CAP_CM_RESTORE_TIME \ 0x0000ff00 /* Port Common_Mode_Restore_Time */ -#define PCI_L1SS_CAP_P_PWR_ON_SCALE 0x00030000 /* Port T_POWER_ON scale */ -#define PCI_L1SS_CAP_P_PWR_ON_VALUE 0x00f80000 /* Port T_POWER_ON value */ -#define PCI_L1SS_CTL1 0x08 /* Control 1 Register */ -#define PCI_L1SS_CTL1_PCIPM_L1_2 0x00000001 /* PCI-PM L1.2 Enable */ -#define PCI_L1SS_CTL1_PCIPM_L1_1 0x00000002 /* PCI-PM L1.1 Enable */ -#define PCI_L1SS_CTL1_ASPM_L1_2 0x00000004 /* ASPM L1.2 Enable */ -#define PCI_L1SS_CTL1_ASPM_L1_1 0x00000008 /* ASPM L1.1 Enable */ -#define PCI_L1SS_CTL1_L1_2_MASK 0x00000005 -#define PCI_L1SS_CTL1_L1SS_MASK 0x0000000f -#define PCI_L1SS_CTL1_CM_RESTORE_TIME 0x0000ff00 /* Common_Mode_Restore_Time \ - */ -#define PCI_L1SS_CTL1_LTR_L12_TH_VALUE 0x03ff0000 /* LTR_L1.2_THRESHOLD_Value \ - */ -#define PCI_L1SS_CTL1_LTR_L12_TH_SCALE 0xe0000000 /* LTR_L1.2_THRESHOLD_Scale \ - */ -#define PCI_L1SS_CTL2 0x0c /* Control 2 Register */ -#define PCI_L1SS_CTL2_T_PWR_ON_SCALE 0x00000003 /* T_POWER_ON Scale */ -#define PCI_L1SS_CTL2_T_PWR_ON_VALUE 0x000000f8 /* T_POWER_ON Value */ +#define PCI_L1SS_CAP_P_PWR_ON_SCALE 0x00030000 /* Port T_POWER_ON scale */ +#define PCI_L1SS_CAP_P_PWR_ON_VALUE 0x00f80000 /* Port T_POWER_ON value */ +#define PCI_L1SS_CTL1 0x08 /* Control 1 Register */ +#define PCI_L1SS_CTL1_PCIPM_L1_2 0x00000001 /* PCI-PM L1.2 Enable */ +#define PCI_L1SS_CTL1_PCIPM_L1_1 0x00000002 /* PCI-PM L1.1 Enable */ +#define PCI_L1SS_CTL1_ASPM_L1_2 0x00000004 /* ASPM L1.2 Enable */ +#define PCI_L1SS_CTL1_ASPM_L1_1 0x00000008 /* ASPM L1.1 Enable */ +#define PCI_L1SS_CTL1_L1_2_MASK 0x00000005 +#define PCI_L1SS_CTL1_L1SS_MASK 0x0000000f +#define PCI_L1SS_CTL1_CM_RESTORE_TIME \ + 0x0000ff00 /* Common_Mode_Restore_Time \ + */ +#define PCI_L1SS_CTL1_LTR_L12_TH_VALUE \ + 0x03ff0000 /* LTR_L1.2_THRESHOLD_Value \ + */ +#define PCI_L1SS_CTL1_LTR_L12_TH_SCALE \ + 0xe0000000 /* LTR_L1.2_THRESHOLD_Scale \ + */ +#define PCI_L1SS_CTL2 0x0c /* Control 2 Register */ +#define PCI_L1SS_CTL2_T_PWR_ON_SCALE 0x00000003 /* T_POWER_ON Scale */ +#define PCI_L1SS_CTL2_T_PWR_ON_VALUE 0x000000f8 /* T_POWER_ON Value */ /* Designated Vendor-Specific (DVSEC, PCI_EXT_CAP_ID_DVSEC) */ #define PCI_DVSEC_HEADER1 0x4 /* Designated Vendor-Specific Header1 */ diff --git a/include/arch/x86_64/linux/perf_event.h b/include/arch/x86_64/linux/perf_event.h index 92785018..8711e65f 100644 --- a/include/arch/x86_64/linux/perf_event.h +++ b/include/arch/x86_64/linux/perf_event.h @@ -1309,8 +1309,9 @@ enum perf_callchain_context { /* CoreSight PMU AUX buffer formats */ #define PERF_AUX_FLAG_CORESIGHT_FORMAT_CORESIGHT \ 0x0000 /* Default for backward compatibility */ -#define PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW 0x0100 /* Raw format of the source \ - */ +#define PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW \ + 0x0100 /* Raw format of the source \ + */ #define PERF_FLAG_FD_NO_GROUP (1UL << 0) #define PERF_FLAG_FD_OUTPUT (1UL << 1) diff --git a/include/arch/x86_64/linux/pidfd.h b/include/arch/x86_64/linux/pidfd.h index cb92c2a3..0f91b663 100644 --- a/include/arch/x86_64/linux/pidfd.h +++ b/include/arch/x86_64/linux/pidfd.h @@ -17,9 +17,10 @@ #define PIDFD_SIGNAL_PROCESS_GROUP (1UL << 2) /* Flags for pidfd_info. */ -#define PIDFD_INFO_PID (1UL << 0) /* Always returned, even if not requested */ -#define PIDFD_INFO_CREDS (1UL << 1) /* Always returned, even if not requested \ - */ +#define PIDFD_INFO_PID (1UL << 0) /* Always returned, even if not requested */ +#define PIDFD_INFO_CREDS \ + (1UL << 1) /* Always returned, even if not requested \ + */ #define PIDFD_INFO_CGROUPID \ (1UL << 2) /* Always returned if available, even if not requested */ #define PIDFD_INFO_EXIT (1UL << 3) /* Only returned if requested. */ @@ -35,8 +36,9 @@ * coredump should be treated as sensitive and access should only be * granted to privileged users. */ -#define PIDFD_COREDUMPED (1U << 0) /* Did crash and... */ -#define PIDFD_COREDUMP_SKIP (1U << 1) /* coredumping generation was skipped. \ +#define PIDFD_COREDUMPED (1U << 0) /* Did crash and... */ +#define PIDFD_COREDUMP_SKIP \ + (1U << 1) /* coredumping generation was skipped. \ */ #define PIDFD_COREDUMP_USER (1U << 2) /* coredump was done as the user. */ #define PIDFD_COREDUMP_ROOT (1U << 3) /* coredump was done as root. */ diff --git a/include/arch/x86_64/linux/ppp-ioctl.h b/include/arch/x86_64/linux/ppp-ioctl.h index 2b69f2a6..06d7c1f5 100644 --- a/include/arch/x86_64/linux/ppp-ioctl.h +++ b/include/arch/x86_64/linux/ppp-ioctl.h @@ -116,9 +116,10 @@ struct pppol2tp_ioc_stats { #define PPPIOCATTCHAN _IOW('t', 56, int) /* attach to ppp channel */ #define PPPIOCGCHAN _IOR('t', 55, int) /* get ppp channel number */ #define PPPIOCGL2TPSTATS _IOR('t', 54, struct pppol2tp_ioc_stats) -#define PPPIOCBRIDGECHAN _IOW('t', 53, int) /* bridge one channel to another \ - */ -#define PPPIOCUNBRIDGECHAN _IO('t', 52) /* unbridge channel */ +#define PPPIOCBRIDGECHAN \ + _IOW('t', 53, int) /* bridge one channel to another \ + */ +#define PPPIOCUNBRIDGECHAN _IO('t', 52) /* unbridge channel */ #define SIOCGPPPSTATS (SIOCDEVPRIVATE + 0) #define SIOCGPPPVER (SIOCDEVPRIVATE + 1) /* NEVER change this!! */ diff --git a/include/arch/x86_64/linux/prctl.h b/include/arch/x86_64/linux/prctl.h index 9981f034..2c2e38fc 100644 --- a/include/arch/x86_64/linux/prctl.h +++ b/include/arch/x86_64/linux/prctl.h @@ -28,8 +28,9 @@ #define PR_GET_FPEMU 9 #define PR_SET_FPEMU 10 #define PR_FPEMU_NOPRINT 1 /* silently emulate fp operations accesses */ -#define PR_FPEMU_SIGFPE 2 /* don't emulate fp operations, send SIGFPE instead \ - */ +#define PR_FPEMU_SIGFPE \ + 2 /* don't emulate fp operations, send SIGFPE instead \ + */ /* Get/set floating-point exception mode (if meaningful) */ #define PR_GET_FPEXC 11 @@ -332,7 +333,8 @@ struct prctl_mm_map { #define PR_PPC_DEXCR_SBHE 0 /* Speculative branch hint enable */ #define PR_PPC_DEXCR_IBRTPD \ 1 /* Indirect branch recurrent target prediction disable */ -#define PR_PPC_DEXCR_SRAPD 2 /* Subroutine return address prediction disable \ +#define PR_PPC_DEXCR_SRAPD \ + 2 /* Subroutine return address prediction disable \ */ #define PR_PPC_DEXCR_NPHIE 3 /* Non-privileged hash instruction enable */ /* Action to apply / return */ diff --git a/include/arch/x86_64/linux/rtc.h b/include/arch/x86_64/linux/rtc.h index 4c30e4be..0f9c0d99 100644 --- a/include/arch/x86_64/linux/rtc.h +++ b/include/arch/x86_64/linux/rtc.h @@ -112,7 +112,8 @@ struct rtc_param { #define RTC_PARAM_GET _IOW('p', 0x13, struct rtc_param) /* Get parameter */ #define RTC_PARAM_SET _IOW('p', 0x14, struct rtc_param) /* Set parameter */ -#define RTC_VL_DATA_INVALID _BITUL(0) /* Voltage too low, RTC data is invalid \ +#define RTC_VL_DATA_INVALID \ + _BITUL(0) /* Voltage too low, RTC data is invalid \ */ #define RTC_VL_BACKUP_LOW _BITUL(1) /* Backup voltage is low */ #define RTC_VL_BACKUP_EMPTY _BITUL(2) /* Backup empty or not present */ diff --git a/include/arch/x86_64/linux/rxrpc.h b/include/arch/x86_64/linux/rxrpc.h index b09d56d7..dda19740 100644 --- a/include/arch/x86_64/linux/rxrpc.h +++ b/include/arch/x86_64/linux/rxrpc.h @@ -36,9 +36,10 @@ struct sockaddr_rxrpc { 3 /* Deprecated; use RXRPC_EXCLUSIVE_CALL instead */ #define RXRPC_MIN_SECURITY_LEVEL 4 /* minimum security level */ #define RXRPC_UPGRADEABLE_SERVICE 5 /* Upgrade service[0] -> service[1] */ -#define RXRPC_SUPPORTED_CMSG 6 /* Get highest supported control message type \ - */ -#define RXRPC_MANAGE_RESPONSE 7 /* [clnt] Want to manage RESPONSE packets */ +#define RXRPC_SUPPORTED_CMSG \ + 6 /* Get highest supported control message type \ + */ +#define RXRPC_MANAGE_RESPONSE 7 /* [clnt] Want to manage RESPONSE packets */ /* * RxRPC control messages @@ -118,9 +119,11 @@ enum rxrpc_cmsg_type { * like "unsupported security", so we have to use these instead and hope the * other side understands */ -#define RXKADINCONSISTENCY 19270400 /* security module structure inconsistent \ - */ -#define RXKADPACKETSHORT 19270401 /* packet too short for security challenge \ +#define RXKADINCONSISTENCY \ + 19270400 /* security module structure inconsistent \ + */ +#define RXKADPACKETSHORT \ + 19270401 /* packet too short for security challenge \ */ #define RXKADLEVELFAIL 19270402 /* security level negotiation failed */ #define RXKADTICKETLEN 19270403 /* ticket length too short or too long */ @@ -145,8 +148,9 @@ enum rxrpc_cmsg_type { #define RXGK_PACKETSHORT \ 1233242881 /* Packet too short for security challenge */ #define RXGK_BADCHALLENGE 1233242882 /* Invalid security challenge */ -#define RXGK_BADETYPE 1233242883 /* Invalid or impermissible encryption type \ - */ +#define RXGK_BADETYPE \ + 1233242883 /* Invalid or impermissible encryption type \ + */ #define RXGK_BADLEVEL 1233242884 /* Invalid or impermissible security level */ #define RXGK_BADKEYNO 1233242885 /* Key version number not found */ #define RXGK_EXPIRED 1233242886 /* Token has expired */ @@ -154,9 +158,10 @@ enum rxrpc_cmsg_type { #define RXGK_BAD_TOKEN 1233242888 /* Security object was passed a bad token */ #define RXGK_SEALED_INCON 1233242889 /* Sealed data inconsistent */ #define RXGK_DATA_LEN 1233242890 /* User data too long */ -#define RXGK_BAD_QOP 1233242891 /* Inadequate quality of protection available \ - */ -#else /* Revised standard abort codes (used by YFS) */ +#define RXGK_BAD_QOP \ + 1233242891 /* Inadequate quality of protection available \ + */ +#else /* Revised standard abort codes (used by YFS) */ #define RXGK_INCONSISTENCY \ 1233242880 /* Security module structure inconsistent */ #define RXGK_PACKETSHORT \ diff --git a/include/arch/x86_64/linux/scc.h b/include/arch/x86_64/linux/scc.h index ac19e3ef..ce9c783b 100644 --- a/include/arch/x86_64/linux/scc.h +++ b/include/arch/x86_64/linux/scc.h @@ -87,7 +87,7 @@ enum CLOCK_sources { CLK_DIVIDER, /* Rx = DPLL, Tx = divider (fullduplex with */ /* modems without clock regeneration */ CLK_BRG /* experimental fullduplex mode with DPLL/BRG for */ - /* MODEMs without clock recovery */ + /* MODEMs without clock recovery */ }; /* Tx state */ diff --git a/include/arch/x86_64/linux/sched.h b/include/arch/x86_64/linux/sched.h index 975f4a1d..8d0aaa11 100644 --- a/include/arch/x86_64/linux/sched.h +++ b/include/arch/x86_64/linux/sched.h @@ -7,11 +7,12 @@ /* * cloning flags: */ -#define CSIGNAL 0x000000ff /* signal mask to be sent at exit */ -#define CLONE_VM 0x00000100 /* set if VM shared between processes */ -#define CLONE_FS 0x00000200 /* set if fs info shared between processes */ -#define CLONE_FILES 0x00000400 /* set if open files shared between processes \ - */ +#define CSIGNAL 0x000000ff /* signal mask to be sent at exit */ +#define CLONE_VM 0x00000100 /* set if VM shared between processes */ +#define CLONE_FS 0x00000200 /* set if fs info shared between processes */ +#define CLONE_FILES \ + 0x00000400 /* set if open files shared between processes \ + */ #define CLONE_SIGHAND \ 0x00000800 /* set if signal handlers and blocked signals shared */ #define CLONE_PIDFD 0x00001000 /* set if a pidfd should be placed in parent */ diff --git a/include/arch/x86_64/linux/seccomp.h b/include/arch/x86_64/linux/seccomp.h index 521798dc..fea448f5 100644 --- a/include/arch/x86_64/linux/seccomp.h +++ b/include/arch/x86_64/linux/seccomp.h @@ -118,8 +118,9 @@ struct seccomp_notif_resp { /* valid flags for seccomp_notif_addfd */ #define SECCOMP_ADDFD_FLAG_SETFD (1UL << 0) /* Specify remote fd */ -#define SECCOMP_ADDFD_FLAG_SEND (1UL << 1) /* Addfd and return it, atomically \ - */ +#define SECCOMP_ADDFD_FLAG_SEND \ + (1UL << 1) /* Addfd and return it, atomically \ + */ /** * struct seccomp_notif_addfd diff --git a/include/arch/x86_64/linux/sem.h b/include/arch/x86_64/linux/sem.h index a555806f..38685e75 100644 --- a/include/arch/x86_64/linux/sem.h +++ b/include/arch/x86_64/linux/sem.h @@ -76,13 +76,14 @@ struct seminfo { * allocating the sop array. */ -#define SEMMNI 32000 /* <= IPCMNI max # of semaphore identifiers */ -#define SEMMSL 32000 /* <= INT_MAX max num of semaphores per id */ -#define SEMMNS (SEMMNI * SEMMSL) /* <= INT_MAX max # of semaphores in system \ - */ -#define SEMOPM 500 /* <= 1 000 max num of ops per semop call */ -#define SEMVMX 32767 /* <= 32767 semaphore maximum value */ -#define SEMAEM SEMVMX /* adjust on exit max value */ +#define SEMMNI 32000 /* <= IPCMNI max # of semaphore identifiers */ +#define SEMMSL 32000 /* <= INT_MAX max num of semaphores per id */ +#define SEMMNS \ + (SEMMNI * SEMMSL) /* <= INT_MAX max # of semaphores in system \ + */ +#define SEMOPM 500 /* <= 1 000 max num of ops per semop call */ +#define SEMVMX 32767 /* <= 32767 semaphore maximum value */ +#define SEMAEM SEMVMX /* adjust on exit max value */ /* unused */ #define SEMUME SEMOPM /* max num of undo entries per process */ diff --git a/include/arch/x86_64/linux/serial_reg.h b/include/arch/x86_64/linux/serial_reg.h index 0740d860..981d703b 100644 --- a/include/arch/x86_64/linux/serial_reg.h +++ b/include/arch/x86_64/linux/serial_reg.h @@ -300,14 +300,16 @@ #define UART_RSA_MSR ((UART_RSA_BASE) + 0) /* I/O: Mode Select Register */ -#define UART_RSA_MSR_SWAP (1 << 0) /* Swap low/high 8 bytes in I/O port addr \ +#define UART_RSA_MSR_SWAP \ + (1 << 0) /* Swap low/high 8 bytes in I/O port addr \ */ #define UART_RSA_MSR_FIFO (1 << 2) /* Enable the external FIFO */ #define UART_RSA_MSR_FLOW (1 << 3) /* Enable the auto RTS/CTS flow control */ #define UART_RSA_MSR_ITYP (1 << 4) /* Level (1) / Edge triger (0) */ -#define UART_RSA_IER ((UART_RSA_BASE) + 1) /* I/O: Interrupt Enable Register \ - */ +#define UART_RSA_IER \ + ((UART_RSA_BASE) + 1) /* I/O: Interrupt Enable Register \ + */ #define UART_RSA_IER_Rx_FIFO_H (1 << 0) /* Enable Rx FIFO half full int. */ #define UART_RSA_IER_Tx_FIFO_H (1 << 1) /* Enable Tx FIFO half full int. */ diff --git a/include/arch/x86_64/linux/sonet.h b/include/arch/x86_64/linux/sonet.h index 239435bf..98828b2e 100644 --- a/include/arch/x86_64/linux/sonet.h +++ b/include/arch/x86_64/linux/sonet.h @@ -37,12 +37,13 @@ struct sonet_stats { /* set framing mode (SONET/SDH) */ #define SONET_GETFRAMING _IOR('a', ATMIOC_PHYTYP + 6, int) /* get framing mode */ -#define SONET_GETFRSENSE \ - _IOR('a', ATMIOC_PHYTYP + 7, unsigned char[SONET_FRSENSE_SIZE]) /* get \ - framing \ - sense \ - information \ - */ +#define SONET_GETFRSENSE \ + _IOR('a', ATMIOC_PHYTYP + 7, \ + unsigned char[SONET_FRSENSE_SIZE]) /* get \ + framing \ + sense \ + information \ + */ #define SONET_INS_SBIP 1 /* section BIP */ #define SONET_INS_LBIP 2 /* line BIP */ diff --git a/include/arch/x86_64/linux/soundcard.h b/include/arch/x86_64/linux/soundcard.h index d291c9b0..d204e873 100644 --- a/include/arch/x86_64/linux/soundcard.h +++ b/include/arch/x86_64/linux/soundcard.h @@ -225,16 +225,17 @@ struct patch_info { * The least significant byte has the same format than the GUS .PAT * files */ -#define WAVE_16_BITS 0x01 /* bit 0 = 8 or 16 bit wave data. */ -#define WAVE_UNSIGNED 0x02 /* bit 1 = Signed - Unsigned data. */ -#define WAVE_LOOPING 0x04 /* bit 2 = looping enabled-1. */ -#define WAVE_BIDIR_LOOP 0x08 /* bit 3 = Set is bidirectional looping. */ -#define WAVE_LOOP_BACK 0x10 /* bit 4 = Set is looping backward. */ -#define WAVE_SUSTAIN_ON 0x20 /* bit 5 = Turn sustaining on. (Env. pts. 3)*/ -#define WAVE_ENVELOPES 0x40 /* bit 6 = Enable envelopes - 1 */ -#define WAVE_FAST_RELEASE 0x80 /* bit 7 = Shut off immediately after note off \ - */ - /* (use the env_rate/env_offs fields). */ +#define WAVE_16_BITS 0x01 /* bit 0 = 8 or 16 bit wave data. */ +#define WAVE_UNSIGNED 0x02 /* bit 1 = Signed - Unsigned data. */ +#define WAVE_LOOPING 0x04 /* bit 2 = looping enabled-1. */ +#define WAVE_BIDIR_LOOP 0x08 /* bit 3 = Set is bidirectional looping. */ +#define WAVE_LOOP_BACK 0x10 /* bit 4 = Set is looping backward. */ +#define WAVE_SUSTAIN_ON 0x20 /* bit 5 = Turn sustaining on. (Env. pts. 3)*/ +#define WAVE_ENVELOPES 0x40 /* bit 6 = Enable envelopes - 1 */ +#define WAVE_FAST_RELEASE \ + 0x80 /* bit 7 = Shut off immediately after note off \ + */ + /* (use the env_rate/env_offs fields). */ /* Linux specific bits */ #define WAVE_VIBRATO 0x00010000 /* The vibrato info is valid */ #define WAVE_TREMOLO 0x00020000 /* The tremolo info is valid */ @@ -243,7 +244,7 @@ struct patch_info { /* Reserved bits */ #define WAVE_ROM 0x40000000 /* For future use */ #define WAVE_MULAW 0x20000000 /* For future use */ - /* Other bits must be zeroed */ + /* Other bits must be zeroed */ int len; /* Size of the wave data in bytes */ int loop_start, loop_end; /* Byte offsets from the beginning */ @@ -666,8 +667,9 @@ typedef struct buffmem_desc { #define SNDCTL_DSP_PROFILE _SIOW('P', 23, int) #define APF_NORMAL 0 /* Normal applications */ #define APF_NETWORK 1 /* Underruns probably caused by an "external" delay */ -#define APF_CPUINTENS 2 /* Underruns probably caused by "overheating" the CPU \ - */ +#define APF_CPUINTENS \ + 2 /* Underruns probably caused by "overheating" the CPU \ + */ #define SOUND_PCM_READ_RATE _SIOR('P', 2, int) #define SOUND_PCM_READ_CHANNELS _SIOR('P', 6, int) diff --git a/include/arch/x86_64/linux/stat.h b/include/arch/x86_64/linux/stat.h index 05d09f99..f324012a 100644 --- a/include/arch/x86_64/linux/stat.h +++ b/include/arch/x86_64/linux/stat.h @@ -200,27 +200,29 @@ struct statx { * These bits should be set in the mask argument of statx() to request * particular items when calling statx(). */ -#define STATX_TYPE 0x00000001U /* Want/got stx_mode & S_IFMT */ -#define STATX_MODE 0x00000002U /* Want/got stx_mode & ~S_IFMT */ -#define STATX_NLINK 0x00000004U /* Want/got stx_nlink */ -#define STATX_UID 0x00000008U /* Want/got stx_uid */ -#define STATX_GID 0x00000010U /* Want/got stx_gid */ -#define STATX_ATIME 0x00000020U /* Want/got stx_atime */ -#define STATX_MTIME 0x00000040U /* Want/got stx_mtime */ -#define STATX_CTIME 0x00000080U /* Want/got stx_ctime */ -#define STATX_INO 0x00000100U /* Want/got stx_ino */ -#define STATX_SIZE 0x00000200U /* Want/got stx_size */ -#define STATX_BLOCKS 0x00000400U /* Want/got stx_blocks */ -#define STATX_BASIC_STATS 0x000007ffU /* The stuff in the normal stat struct \ - */ -#define STATX_BTIME 0x00000800U /* Want/got stx_btime */ -#define STATX_MNT_ID 0x00001000U /* Got stx_mnt_id */ -#define STATX_DIOALIGN 0x00002000U /* Want/got direct I/O alignment info */ -#define STATX_MNT_ID_UNIQUE 0x00004000U /* Want/got extended stx_mount_id */ -#define STATX_SUBVOL 0x00008000U /* Want/got stx_subvol */ -#define STATX_WRITE_ATOMIC 0x00010000U /* Want/got atomic_write_* fields */ -#define STATX_DIO_READ_ALIGN 0x00020000U /* Want/got dio read alignment info \ - */ +#define STATX_TYPE 0x00000001U /* Want/got stx_mode & S_IFMT */ +#define STATX_MODE 0x00000002U /* Want/got stx_mode & ~S_IFMT */ +#define STATX_NLINK 0x00000004U /* Want/got stx_nlink */ +#define STATX_UID 0x00000008U /* Want/got stx_uid */ +#define STATX_GID 0x00000010U /* Want/got stx_gid */ +#define STATX_ATIME 0x00000020U /* Want/got stx_atime */ +#define STATX_MTIME 0x00000040U /* Want/got stx_mtime */ +#define STATX_CTIME 0x00000080U /* Want/got stx_ctime */ +#define STATX_INO 0x00000100U /* Want/got stx_ino */ +#define STATX_SIZE 0x00000200U /* Want/got stx_size */ +#define STATX_BLOCKS 0x00000400U /* Want/got stx_blocks */ +#define STATX_BASIC_STATS \ + 0x000007ffU /* The stuff in the normal stat struct \ + */ +#define STATX_BTIME 0x00000800U /* Want/got stx_btime */ +#define STATX_MNT_ID 0x00001000U /* Got stx_mnt_id */ +#define STATX_DIOALIGN 0x00002000U /* Want/got direct I/O alignment info */ +#define STATX_MNT_ID_UNIQUE 0x00004000U /* Want/got extended stx_mount_id */ +#define STATX_SUBVOL 0x00008000U /* Want/got stx_subvol */ +#define STATX_WRITE_ATOMIC 0x00010000U /* Want/got atomic_write_* fields */ +#define STATX_DIO_READ_ALIGN \ + 0x00020000U /* Want/got dio read alignment info \ + */ #define STATX__RESERVED \ 0x80000000U /* Reserved for future struct statx expansion */ @@ -246,11 +248,12 @@ struct statx { * some filesystems support. * */ -#define STATX_ATTR_COMPRESSED 0x00000004 /* [I] File is compressed by the fs \ - */ -#define STATX_ATTR_IMMUTABLE 0x00000010 /* [I] File is marked immutable */ -#define STATX_ATTR_APPEND 0x00000020 /* [I] File is append-only */ -#define STATX_ATTR_NODUMP 0x00000040 /* [I] File is not to be dumped */ +#define STATX_ATTR_COMPRESSED \ + 0x00000004 /* [I] File is compressed by the fs \ + */ +#define STATX_ATTR_IMMUTABLE 0x00000010 /* [I] File is marked immutable */ +#define STATX_ATTR_APPEND 0x00000020 /* [I] File is append-only */ +#define STATX_ATTR_NODUMP 0x00000040 /* [I] File is not to be dumped */ #define STATX_ATTR_ENCRYPTED \ 0x00000800 /* [I] File requires key to decrypt in fs */ #define STATX_ATTR_AUTOMOUNT 0x00001000 /* Dir: Automount trigger */ diff --git a/include/arch/x86_64/linux/tee.h b/include/arch/x86_64/linux/tee.h index 7d19733a..6576abad 100644 --- a/include/arch/x86_64/linux/tee.h +++ b/include/arch/x86_64/linux/tee.h @@ -44,8 +44,9 @@ #define TEE_MAX_ARG_SIZE 1024 -#define TEE_GEN_CAP_GP (1 << 0) /* GlobalPlatform compliant TEE */ -#define TEE_GEN_CAP_PRIVILEGED (1 << 1) /* Privileged device (for supplicant) \ +#define TEE_GEN_CAP_GP (1 << 0) /* GlobalPlatform compliant TEE */ +#define TEE_GEN_CAP_PRIVILEGED \ + (1 << 1) /* Privileged device (for supplicant) \ */ #define TEE_GEN_CAP_REG_MEM (1 << 2) /* Supports registering shared memory */ #define TEE_GEN_CAP_MEMREF_NULL (1 << 3) /* NULL MemRef support */ diff --git a/include/arch/x86_64/linux/tipc_config.h b/include/arch/x86_64/linux/tipc_config.h index 0a2a8d3d..c19eda61 100644 --- a/include/arch/x86_64/linux/tipc_config.h +++ b/include/arch/x86_64/linux/tipc_config.h @@ -74,11 +74,12 @@ #define TIPC_CMD_GET_MEDIA_NAMES 0x0002 /* tx none, rx media_name(s) */ #define TIPC_CMD_GET_BEARER_NAMES 0x0003 /* tx none, rx bearer_name(s) */ #define TIPC_CMD_GET_LINKS 0x0004 /* tx net_addr, rx link_info(s) */ -#define TIPC_CMD_SHOW_NAME_TABLE 0x0005 /* tx name_tbl_query, rx ultra_string \ - */ -#define TIPC_CMD_SHOW_PORTS 0x0006 /* tx none, rx ultra_string */ -#define TIPC_CMD_SHOW_LINK_STATS 0x000B /* tx link_name, rx ultra_string */ -#define TIPC_CMD_SHOW_STATS 0x000F /* tx unsigned, rx ultra_string */ +#define TIPC_CMD_SHOW_NAME_TABLE \ + 0x0005 /* tx name_tbl_query, rx ultra_string \ + */ +#define TIPC_CMD_SHOW_PORTS 0x0006 /* tx none, rx ultra_string */ +#define TIPC_CMD_SHOW_LINK_STATS 0x000B /* tx link_name, rx ultra_string */ +#define TIPC_CMD_SHOW_STATS 0x000F /* tx unsigned, rx ultra_string */ /* * Protected commands: diff --git a/include/arch/x86_64/linux/un.h b/include/arch/x86_64/linux/un.h index 84bf357b..e9e96f2d 100644 --- a/include/arch/x86_64/linux/un.h +++ b/include/arch/x86_64/linux/un.h @@ -11,7 +11,8 @@ struct sockaddr_un { char sun_path[UNIX_PATH_MAX]; /* pathname */ }; -#define SIOCUNIXFILE (SIOCPROTOPRIVATE + 0) /* open a socket file with O_PATH \ - */ +#define SIOCUNIXFILE \ + (SIOCPROTOPRIVATE + 0) /* open a socket file with O_PATH \ + */ #endif /* _LINUX_UN_H */ diff --git a/include/arch/x86_64/linux/vfio_zdev.h b/include/arch/x86_64/linux/vfio_zdev.h index 594538fb..60d915d3 100644 --- a/include/arch/x86_64/linux/vfio_zdev.h +++ b/include/arch/x86_64/linux/vfio_zdev.h @@ -45,8 +45,9 @@ struct vfio_device_info_cap_zpci_group { __u64 dasm; /* DMA Address space mask */ __u64 msi_addr; /* MSI address */ __u64 flags; -#define VFIO_DEVICE_INFO_ZPCI_FLAG_REFRESH 1 /* Program-specified TLB refresh \ - */ +#define VFIO_DEVICE_INFO_ZPCI_FLAG_REFRESH \ + 1 /* Program-specified TLB refresh \ + */ __u16 mui; /* Measurement Block Update Interval */ __u16 noi; /* Maximum number of MSIs */ __u16 maxstbl; /* Maximum Store Block Length */ diff --git a/include/arch/x86_64/linux/videodev2.h b/include/arch/x86_64/linux/videodev2.h index d3eb32d3..e0643d14 100644 --- a/include/arch/x86_64/linux/videodev2.h +++ b/include/arch/x86_64/linux/videodev2.h @@ -919,8 +919,9 @@ struct v4l2_pix_format { v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ -#define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 \ - */ +#define V4L2_PIX_FMT_RV40 \ + v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 \ + */ /* Vendor-specific formats */ #define V4L2_PIX_FMT_CPIA1 v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */ @@ -930,18 +931,23 @@ struct v4l2_pix_format { v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */ #define V4L2_PIX_FMT_SN9C20X_I420 \ v4l2_fourcc('S', '9', '2', '0') /* SN9C20x YUV 4:2:0 */ -#define V4L2_PIX_FMT_PWC1 v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam \ - */ -#define V4L2_PIX_FMT_PWC2 v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam \ - */ +#define V4L2_PIX_FMT_PWC1 \ + v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam \ + */ +#define V4L2_PIX_FMT_PWC2 \ + v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam \ + */ #define V4L2_PIX_FMT_ET61X251 \ v4l2_fourcc('E', '6', '2', '5') /* ET61X251 compression */ -#define V4L2_PIX_FMT_SPCA501 v4l2_fourcc('S', '5', '0', '1') /* YUYV per line \ - */ -#define V4L2_PIX_FMT_SPCA505 v4l2_fourcc('S', '5', '0', '5') /* YYUV per line \ - */ -#define V4L2_PIX_FMT_SPCA508 v4l2_fourcc('S', '5', '0', '8') /* YUVY per line \ - */ +#define V4L2_PIX_FMT_SPCA501 \ + v4l2_fourcc('S', '5', '0', '1') /* YUYV per line \ + */ +#define V4L2_PIX_FMT_SPCA505 \ + v4l2_fourcc('S', '5', '0', '5') /* YYUV per line \ + */ +#define V4L2_PIX_FMT_SPCA508 \ + v4l2_fourcc('S', '5', '0', '8') /* YUVY per line \ + */ #define V4L2_PIX_FMT_SPCA561 \ v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */ #define V4L2_PIX_FMT_PAC207 \ @@ -954,14 +960,17 @@ struct v4l2_pix_format { v4l2_fourcc('S', 'O', 'N', 'X') /* compressed GBRG bayer */ #define V4L2_PIX_FMT_SQ905C \ v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */ -#define V4L2_PIX_FMT_PJPG v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG \ - */ -#define V4L2_PIX_FMT_OV511 v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */ -#define V4L2_PIX_FMT_OV518 v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */ -#define V4L2_PIX_FMT_STV0680 v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer \ - */ -#define V4L2_PIX_FMT_TM6000 v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 \ - */ +#define V4L2_PIX_FMT_PJPG \ + v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG \ + */ +#define V4L2_PIX_FMT_OV511 v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */ +#define V4L2_PIX_FMT_OV518 v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */ +#define V4L2_PIX_FMT_STV0680 \ + v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer \ + */ +#define V4L2_PIX_FMT_TM6000 \ + v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 \ + */ #define V4L2_PIX_FMT_CIT_YYVYUY \ v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY \ */ @@ -979,8 +988,9 @@ struct v4l2_pix_format { v4l2_fourcc('Y', '1', '2', 'I') /* Greyscale 12-bit L/R interleaved */ #define V4L2_PIX_FMT_Y16I \ v4l2_fourcc('Y', '1', '6', 'I') /* Greyscale 16-bit L/R interleaved */ -#define V4L2_PIX_FMT_Z16 v4l2_fourcc('Z', '1', '6', ' ') /* Depth data 16-bit \ - */ +#define V4L2_PIX_FMT_Z16 \ + v4l2_fourcc('Z', '1', '6', ' ') /* Depth data 16-bit \ + */ #define V4L2_PIX_FMT_MT21C \ v4l2_fourcc('M', 'T', '2', '1') /* Mediatek compressed block mode */ #define V4L2_PIX_FMT_MM21 \ @@ -1059,7 +1069,8 @@ struct v4l2_pix_format { #define V4L2_SDR_FMT_CU8 v4l2_fourcc('C', 'U', '0', '8') /* IQ u8 */ #define V4L2_SDR_FMT_CU16LE v4l2_fourcc('C', 'U', '1', '6') /* IQ u16le */ #define V4L2_SDR_FMT_CS8 v4l2_fourcc('C', 'S', '0', '8') /* complex s8 */ -#define V4L2_SDR_FMT_CS14LE v4l2_fourcc('C', 'S', '1', '4') /* complex s14le \ +#define V4L2_SDR_FMT_CS14LE \ + v4l2_fourcc('C', 'S', '1', '4') /* complex s14le \ */ #define V4L2_SDR_FMT_RU12LE v4l2_fourcc('R', 'U', '1', '2') /* real u12le */ #define V4L2_SDR_FMT_PCU16BE \ @@ -1090,8 +1101,9 @@ struct v4l2_pix_format { v4l2_fourcc('D', '4', 'X', 'X') /* D4XX Payload Header metadata */ #define V4L2_META_FMT_UVC_MSXU_1_5 \ v4l2_fourcc('U', 'V', 'C', 'M') /* UVC MSXU metadata */ -#define V4L2_META_FMT_VIVID v4l2_fourcc('V', 'I', 'V', 'D') /* Vivid Metadata \ - */ +#define V4L2_META_FMT_VIVID \ + v4l2_fourcc('V', 'I', 'V', 'D') /* Vivid Metadata \ + */ /* Vendor specific - used for RK_ISP1 camera sub-system */ #define V4L2_META_FMT_RK_ISP1_PARAMS \ @@ -2674,13 +2686,15 @@ struct v4l2_format { __u32 type; union { struct v4l2_pix_format pix; /* V4L2_BUF_TYPE_VIDEO_CAPTURE */ - struct v4l2_pix_format_mplane pix_mp; /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE - */ - struct v4l2_window win; /* V4L2_BUF_TYPE_VIDEO_OVERLAY */ + struct v4l2_pix_format_mplane + pix_mp; /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE + */ + struct v4l2_window win; /* V4L2_BUF_TYPE_VIDEO_OVERLAY */ struct v4l2_vbi_format vbi; /* V4L2_BUF_TYPE_VBI_CAPTURE */ - struct v4l2_sliced_vbi_format sliced; /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE - */ - struct v4l2_sdr_format sdr; /* V4L2_BUF_TYPE_SDR_CAPTURE */ + struct v4l2_sliced_vbi_format + sliced; /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE + */ + struct v4l2_sdr_format sdr; /* V4L2_BUF_TYPE_SDR_CAPTURE */ struct v4l2_meta_format meta; /* V4L2_BUF_TYPE_META_CAPTURE */ __u8 raw_data[200]; /* user-defined */ } fmt; diff --git a/include/arch/x86_64/linux/virtio_balloon.h b/include/arch/x86_64/linux/virtio_balloon.h index c899a13a..20e877d5 100644 --- a/include/arch/x86_64/linux/virtio_balloon.h +++ b/include/arch/x86_64/linux/virtio_balloon.h @@ -75,8 +75,9 @@ struct virtio_balloon_config { #define VIRTIO_BALLOON_S_ALLOC_STALL 11 /* Stall count of memory allocatoin */ #define VIRTIO_BALLOON_S_ASYNC_SCAN \ 12 /* Amount of memory scanned asynchronously */ -#define VIRTIO_BALLOON_S_DIRECT_SCAN 13 /* Amount of memory scanned directly \ - */ +#define VIRTIO_BALLOON_S_DIRECT_SCAN \ + 13 /* Amount of memory scanned directly \ + */ #define VIRTIO_BALLOON_S_ASYNC_RECLAIM \ 14 /* Amount of memory reclaimed asynchronously */ #define VIRTIO_BALLOON_S_DIRECT_RECLAIM \ diff --git a/include/arch/x86_64/linux/virtio_console.h b/include/arch/x86_64/linux/virtio_console.h index 9d1eb43b..a5c78eda 100644 --- a/include/arch/x86_64/linux/virtio_console.h +++ b/include/arch/x86_64/linux/virtio_console.h @@ -37,10 +37,11 @@ #include <linux/virtio_config.h> /* Feature bits */ -#define VIRTIO_CONSOLE_F_SIZE 0 /* Does host provide console size? */ -#define VIRTIO_CONSOLE_F_MULTIPORT 1 /* Does host provide multiple ports? */ -#define VIRTIO_CONSOLE_F_EMERG_WRITE 2 /* Does host support emergency write? \ - */ +#define VIRTIO_CONSOLE_F_SIZE 0 /* Does host provide console size? */ +#define VIRTIO_CONSOLE_F_MULTIPORT 1 /* Does host provide multiple ports? */ +#define VIRTIO_CONSOLE_F_EMERG_WRITE \ + 2 /* Does host support emergency write? \ + */ #define VIRTIO_CONSOLE_BAD_ID (~(__u32)0) diff --git a/include/arch/x86_64/linux/virtio_net.h b/include/arch/x86_64/linux/virtio_net.h index db6398f3..a74191c2 100644 --- a/include/arch/x86_64/linux/virtio_net.h +++ b/include/arch/x86_64/linux/virtio_net.h @@ -32,14 +32,15 @@ #include <linux/if_ether.h> /* The feature bitmap for virtio net */ -#define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */ -#define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */ -#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2 /* Dynamic offload configuration. \ - */ -#define VIRTIO_NET_F_MTU 3 /* Initial MTU advice */ -#define VIRTIO_NET_F_MAC 5 /* Host has given MAC address. */ -#define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in. */ -#define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in. */ +#define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */ +#define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */ +#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS \ + 2 /* Dynamic offload configuration. \ + */ +#define VIRTIO_NET_F_MTU 3 /* Initial MTU advice */ +#define VIRTIO_NET_F_MAC 5 /* Host has given MAC address. */ +#define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in. */ +#define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in. */ #define VIRTIO_NET_F_GUEST_ECN 9 /* Guest can handle TSO[6] w/ ECN in. */ #define VIRTIO_NET_F_GUEST_UFO 10 /* Guest can handle UFO in. */ #define VIRTIO_NET_F_HOST_TSO4 11 /* Host can handle TSOv4 in. */ @@ -63,8 +64,9 @@ 50 /* Device can provide device-level statistics. */ #define VIRTIO_NET_F_VQ_NOTF_COAL \ 52 /* Device supports virtqueue notification coalescing */ -#define VIRTIO_NET_F_NOTF_COAL 53 /* Device supports notifications coalescing \ - */ +#define VIRTIO_NET_F_NOTF_COAL \ + 53 /* Device supports notifications coalescing \ + */ #define VIRTIO_NET_F_GUEST_USO4 54 /* Guest can handle USOv4 in. */ #define VIRTIO_NET_F_GUEST_USO6 55 /* Guest can handle USOv6 in. */ #define VIRTIO_NET_F_HOST_USO 56 /* Host can handle USO in. */ diff --git a/include/arch/x86_64/misc/ocxl.h b/include/arch/x86_64/misc/ocxl.h index 046d7079..9ba66e01 100644 --- a/include/arch/x86_64/misc/ocxl.h +++ b/include/arch/x86_64/misc/ocxl.h @@ -10,8 +10,9 @@ enum ocxl_event_type { OCXL_AFU_EVENT_XSL_FAULT_ERROR = 0, }; -#define OCXL_KERNEL_EVENT_FLAG_LAST 0x0001 /* This is the last event pending \ - */ +#define OCXL_KERNEL_EVENT_FLAG_LAST \ + 0x0001 /* This is the last event pending \ + */ struct ocxl_kernel_event_header { __u16 type; diff --git a/include/arch/x86_64/mtd/mtd-abi.h b/include/arch/x86_64/mtd/mtd-abi.h index dc98d120..a239dac9 100644 --- a/include/arch/x86_64/mtd/mtd-abi.h +++ b/include/arch/x86_64/mtd/mtd-abi.h @@ -147,12 +147,13 @@ struct mtd_read_req { #define MTD_UBIVOLUME 7 #define MTD_MLCNANDFLASH 8 /* MLC NAND (including TLC) */ -#define MTD_WRITEABLE 0x400 /* Device is writeable */ -#define MTD_BIT_WRITEABLE 0x800 /* Single bits can be flipped */ -#define MTD_NO_ERASE 0x1000 /* No erase necessary */ -#define MTD_POWERUP_LOCK 0x2000 /* Always locked after reset */ -#define MTD_SLC_ON_MLC_EMULATION 0x4000 /* Emulate SLC behavior on MLC NANDs \ - */ +#define MTD_WRITEABLE 0x400 /* Device is writeable */ +#define MTD_BIT_WRITEABLE 0x800 /* Single bits can be flipped */ +#define MTD_NO_ERASE 0x1000 /* No erase necessary */ +#define MTD_POWERUP_LOCK 0x2000 /* Always locked after reset */ +#define MTD_SLC_ON_MLC_EMULATION \ + 0x4000 /* Emulate SLC behavior on MLC NANDs \ + */ /* Some common devices / combinations of capabilities */ #define MTD_CAP_ROM 0 diff --git a/include/arch/x86_64/rdma/hfi/hfi1_user.h b/include/arch/x86_64/rdma/hfi/hfi1_user.h index d28848b1..31e9eb3c 100644 --- a/include/arch/x86_64/rdma/hfi/hfi1_user.h +++ b/include/arch/x86_64/rdma/hfi/hfi1_user.h @@ -91,24 +91,26 @@ * driver features. The same set of bits are communicated to user * space. */ -#define HFI1_CAP_DMA_RTAIL (1UL << 0) /* Use DMA'ed RTail value */ -#define HFI1_CAP_SDMA (1UL << 1) /* Enable SDMA support */ -#define HFI1_CAP_SDMA_AHG (1UL << 2) /* Enable SDMA AHG support */ -#define HFI1_CAP_EXTENDED_PSN (1UL << 3) /* Enable Extended PSN support */ -#define HFI1_CAP_HDRSUPP (1UL << 4) /* Enable Header Suppression */ -#define HFI1_CAP_TID_RDMA (1UL << 5) /* Enable TID RDMA operations */ -#define HFI1_CAP_USE_SDMA_HEAD (1UL << 6) /* DMA Hdr Q tail vs. use CSR */ -#define HFI1_CAP_MULTI_PKT_EGR (1UL << 7) /* Enable multi-packet Egr buffs*/ -#define HFI1_CAP_NODROP_RHQ_FULL (1UL << 8) /* Don't drop on Hdr Q full */ -#define HFI1_CAP_NODROP_EGR_FULL (1UL << 9) /* Don't drop on EGR buffs full */ -#define HFI1_CAP_TID_UNMAP (1UL << 10) /* Disable Expected TID caching */ -#define HFI1_CAP_PRINT_UNIMPL (1UL << 11) /* Show for unimplemented feats */ -#define HFI1_CAP_ALLOW_PERM_JKEY (1UL << 12) /* Allow use of permissive JKEY \ - */ -#define HFI1_CAP_NO_INTEGRITY (1UL << 13) /* Enable ctxt integrity checks */ -#define HFI1_CAP_PKEY_CHECK (1UL << 14) /* Enable ctxt PKey checking */ -#define HFI1_CAP_STATIC_RATE_CTRL (1UL << 15) /* Allow PBC.StaticRateControl \ - */ +#define HFI1_CAP_DMA_RTAIL (1UL << 0) /* Use DMA'ed RTail value */ +#define HFI1_CAP_SDMA (1UL << 1) /* Enable SDMA support */ +#define HFI1_CAP_SDMA_AHG (1UL << 2) /* Enable SDMA AHG support */ +#define HFI1_CAP_EXTENDED_PSN (1UL << 3) /* Enable Extended PSN support */ +#define HFI1_CAP_HDRSUPP (1UL << 4) /* Enable Header Suppression */ +#define HFI1_CAP_TID_RDMA (1UL << 5) /* Enable TID RDMA operations */ +#define HFI1_CAP_USE_SDMA_HEAD (1UL << 6) /* DMA Hdr Q tail vs. use CSR */ +#define HFI1_CAP_MULTI_PKT_EGR (1UL << 7) /* Enable multi-packet Egr buffs*/ +#define HFI1_CAP_NODROP_RHQ_FULL (1UL << 8) /* Don't drop on Hdr Q full */ +#define HFI1_CAP_NODROP_EGR_FULL (1UL << 9) /* Don't drop on EGR buffs full */ +#define HFI1_CAP_TID_UNMAP (1UL << 10) /* Disable Expected TID caching */ +#define HFI1_CAP_PRINT_UNIMPL (1UL << 11) /* Show for unimplemented feats */ +#define HFI1_CAP_ALLOW_PERM_JKEY \ + (1UL << 12) /* Allow use of permissive JKEY \ + */ +#define HFI1_CAP_NO_INTEGRITY (1UL << 13) /* Enable ctxt integrity checks */ +#define HFI1_CAP_PKEY_CHECK (1UL << 14) /* Enable ctxt PKey checking */ +#define HFI1_CAP_STATIC_RATE_CTRL \ + (1UL << 15) /* Allow PBC.StaticRateControl \ + */ #define HFI1_CAP_OPFN (1UL << 16) /* Enable the OPFN protocol */ #define HFI1_CAP_SDMA_HEAD_CHECK (1UL << 17) /* SDMA head checking */ #define HFI1_CAP_EARLY_CREDIT_RETURN (1UL << 18) /* early credit return */ diff --git a/include/arch/x86_64/sound/asequencer.h b/include/arch/x86_64/sound/asequencer.h index e5332cd9..61e31e42 100644 --- a/include/arch/x86_64/sound/asequencer.h +++ b/include/arch/x86_64/sound/asequencer.h @@ -121,7 +121,8 @@ * event data type = snd_seq_ev_ext * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set) */ -#define SNDRV_SEQ_EVENT_SYSEX 130 /* system exclusive data (variable length) \ +#define SNDRV_SEQ_EVENT_SYSEX \ + 130 /* system exclusive data (variable length) \ */ #define SNDRV_SEQ_EVENT_BOUNCE 131 /* error event */ /* 132-134: reserved */ diff --git a/include/arch/x86_64/sound/asoc.h b/include/arch/x86_64/sound/asoc.h index 38c6d428..5a48620a 100644 --- a/include/arch/x86_64/sound/asoc.h +++ b/include/arch/x86_64/sound/asoc.h @@ -520,11 +520,12 @@ struct snd_soc_tplg_pcm { __le32 playback; /* supports playback mode */ __le32 capture; /* supports capture mode */ __le32 compress; /* 1 = compressed; 0 = PCM */ - struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for - DAI - link - */ - __le32 num_streams; /* number of streams */ + struct snd_soc_tplg_stream + stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for + DAI + link + */ + __le32 num_streams; /* number of streams */ struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */ __le32 flag_mask; /* bitmask of flags to configure */ @@ -548,13 +549,14 @@ struct snd_soc_tplg_link_config { char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */ char stream_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* stream name - used to match */ - struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported - configs - playback - and - captrure - */ - __le32 num_streams; /* number of streams */ + struct snd_soc_tplg_stream + stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported + configs + playback + and + captrure + */ + __le32 num_streams; /* number of streams */ struct snd_soc_tplg_hw_config hw_config[SND_SOC_TPLG_HW_CONFIG_MAX]; /* hw configs */ __le32 num_hw_configs; /* number of hw configs */ diff --git a/include/arch/x86_64/sound/asound.h b/include/arch/x86_64/sound/asound.h index ae70988c..46a4e3fa 100644 --- a/include/arch/x86_64/sound/asound.h +++ b/include/arch/x86_64/sound/asound.h @@ -178,9 +178,10 @@ typedef int __bitwise snd_pcm_access_t; ((snd_pcm_access_t)0) /* interleaved mmap */ #define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED \ ((snd_pcm_access_t)1) /* noninterleaved mmap */ -#define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((snd_pcm_access_t)2) /* complex mmap */ -#define SNDRV_PCM_ACCESS_RW_INTERLEAVED ((snd_pcm_access_t)3) /* readi/writei \ - */ +#define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((snd_pcm_access_t)2) /* complex mmap */ +#define SNDRV_PCM_ACCESS_RW_INTERLEAVED \ + ((snd_pcm_access_t)3) /* readi/writei \ + */ #define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED \ ((snd_pcm_access_t)4) /* readn/writen */ #define SNDRV_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_RW_NONINTERLEAVED @@ -632,8 +633,9 @@ struct __snd_pcm_mmap_control { }; #define SNDRV_PCM_SYNC_PTR_HWSYNC (1 << 0) /* execute hwsync */ -#define SNDRV_PCM_SYNC_PTR_APPL (1 << 1) /* get appl_ptr from driver (r/w op) \ - */ +#define SNDRV_PCM_SYNC_PTR_APPL \ + (1 << 1) /* get appl_ptr from driver (r/w op) \ + */ #define SNDRV_PCM_SYNC_PTR_AVAIL_MIN (1 << 2) /* get avail_min from driver */ struct __snd_pcm_sync_ptr { @@ -1174,11 +1176,13 @@ struct snd_ctl_card_info { }; typedef int __bitwise snd_ctl_elem_type_t; -#define SNDRV_CTL_ELEM_TYPE_NONE ((snd_ctl_elem_type_t)0) /* invalid */ -#define SNDRV_CTL_ELEM_TYPE_BOOLEAN ((snd_ctl_elem_type_t)1) /* boolean type \ - */ -#define SNDRV_CTL_ELEM_TYPE_INTEGER ((snd_ctl_elem_type_t)2) /* integer type \ - */ +#define SNDRV_CTL_ELEM_TYPE_NONE ((snd_ctl_elem_type_t)0) /* invalid */ +#define SNDRV_CTL_ELEM_TYPE_BOOLEAN \ + ((snd_ctl_elem_type_t)1) /* boolean type \ + */ +#define SNDRV_CTL_ELEM_TYPE_INTEGER \ + ((snd_ctl_elem_type_t)2) /* integer type \ + */ #define SNDRV_CTL_ELEM_TYPE_ENUMERATED \ ((snd_ctl_elem_type_t)3) /* enumerated type */ #define SNDRV_CTL_ELEM_TYPE_BYTES ((snd_ctl_elem_type_t)4) /* byte array */ @@ -1189,8 +1193,9 @@ typedef int __bitwise snd_ctl_elem_type_t; #define SNDRV_CTL_ELEM_TYPE_LAST SNDRV_CTL_ELEM_TYPE_INTEGER64 typedef int __bitwise snd_ctl_elem_iface_t; -#define SNDRV_CTL_ELEM_IFACE_CARD ((snd_ctl_elem_iface_t)0) /* global control \ - */ +#define SNDRV_CTL_ELEM_IFACE_CARD \ + ((snd_ctl_elem_iface_t)0) /* global control \ + */ #define SNDRV_CTL_ELEM_IFACE_HWDEP \ ((snd_ctl_elem_iface_t)1) /* hardware dependent device */ #define SNDRV_CTL_ELEM_IFACE_MIXER \ @@ -1198,8 +1203,9 @@ typedef int __bitwise snd_ctl_elem_iface_t; #define SNDRV_CTL_ELEM_IFACE_PCM ((snd_ctl_elem_iface_t)3) /* PCM device */ #define SNDRV_CTL_ELEM_IFACE_RAWMIDI \ ((snd_ctl_elem_iface_t)4) /* RawMidi device */ -#define SNDRV_CTL_ELEM_IFACE_TIMER ((snd_ctl_elem_iface_t)5) /* timer device \ - */ +#define SNDRV_CTL_ELEM_IFACE_TIMER \ + ((snd_ctl_elem_iface_t)5) /* timer device \ + */ #define SNDRV_CTL_ELEM_IFACE_SEQUENCER \ ((snd_ctl_elem_iface_t)6) /* sequencer client */ #define SNDRV_CTL_ELEM_IFACE_LAST SNDRV_CTL_ELEM_IFACE_SEQUENCER @@ -1215,8 +1221,9 @@ typedef int __bitwise snd_ctl_elem_iface_t; #define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE (1 << 5) /* TLV write is possible */ #define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE \ (SNDRV_CTL_ELEM_ACCESS_TLV_READ | SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) -#define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND (1 << 6) /* TLV command is possible \ - */ +#define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND \ + (1 << 6) /* TLV command is possible \ + */ #define SNDRV_CTL_ELEM_ACCESS_INACTIVE \ (1 << 8) /* control does actually nothing, but may be updated */ #define SNDRV_CTL_ELEM_ACCESS_LOCK (1 << 9) /* write lock */ diff --git a/include/arch/x86_64/sound/compress_offload.h b/include/arch/x86_64/sound/compress_offload.h index 435fbbd8..7f7c6747 100644 --- a/include/arch/x86_64/sound/compress_offload.h +++ b/include/arch/x86_64/sound/compress_offload.h @@ -128,8 +128,9 @@ struct snd_compr_metadata { } __attribute__((packed, aligned(4))); /* flags for struct snd_compr_task */ -#define SND_COMPRESS_TFLG_NEW_STREAM (1 << 0) /* mark for the new stream data \ - */ +#define SND_COMPRESS_TFLG_NEW_STREAM \ + (1 << 0) /* mark for the new stream data \ + */ /** * struct snd_compr_task - task primitive for non-realtime operation diff --git a/include/arch/x86_64/sound/emu10k1.h b/include/arch/x86_64/sound/emu10k1.h index 144b2449..99b2a976 100644 --- a/include/arch/x86_64/sound/emu10k1.h +++ b/include/arch/x86_64/sound/emu10k1.h @@ -154,9 +154,10 @@ /* Each FX general purpose register is 32 bits in length, all bits are used */ -#define FXGPREGBASE 0x100 /* FX general purpose registers base */ -#define A_FXGPREGBASE 0x400 /* Audigy GPRs, 0x400 to 0x5ff \ - */ +#define FXGPREGBASE 0x100 /* FX general purpose registers base */ +#define A_FXGPREGBASE \ + 0x400 /* Audigy GPRs, 0x400 to 0x5ff \ + */ #define A_TANKMEMCTLREGBASE \ 0x100 /* Tank memory control registers base - only for Audigy */ @@ -194,19 +195,25 @@ #define ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */ #define ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */ -#define A_GPR(x) (A_FXGPREGBASE + (x)) -#define A_ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf \ - */ -#define A_ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f \ - */ -#define A_ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf \ - */ -#define A_ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f \ - */ -#define A_ITRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf \ - */ -#define A_ETRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f \ - */ +#define A_GPR(x) (A_FXGPREGBASE + (x)) +#define A_ITRAM_DATA(x) \ + (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf \ + */ +#define A_ETRAM_DATA(x) \ + (TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f \ + */ +#define A_ITRAM_ADDR(x) \ + (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf \ + */ +#define A_ETRAM_ADDR(x) \ + (TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f \ + */ +#define A_ITRAM_CTL(x) \ + (A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf \ + */ +#define A_ETRAM_CTL(x) \ + (A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f \ + */ /* cc_reg constants */ #define CC_REG_NORMALIZED C_00000001 diff --git a/include/bits/rsize.h b/include/bits/rsize.h new file mode 100644 index 00000000..1a552fa3 --- /dev/null +++ b/include/bits/rsize.h @@ -0,0 +1,12 @@ +#ifndef __BITS_RSIZE_H +#define __BITS_RSIZE_H + +#ifndef __BITS_RSIZE_H_ +#error "Internal header — include the public API header instead." +#else +#undef __BITS_RSIZE_H_ +#endif + +typedef __SIZE_TYPE__ rsize_t; + +#endif diff --git a/include/bits/select.h b/include/bits/select.h index f1f952ab..f5b63ccc 100644 --- a/include/bits/select.h +++ b/include/bits/select.h @@ -3,28 +3,25 @@ #ifndef __BITS_SELECT_H_ #error "Internal header — include the public API header instead." +#else +#undef __BITS_SELECT_H_ #endif #define FD_SETSIZE 1024 -#define FD_ZERO(set) \ - do { \ - for (size_t i = 0; \ - i < sizeof((set)->fds_bits) / sizeof(fd_mask); i++) \ - (set)->fds_bits[i] = 0; \ - } while (0) +#define FD_ZERO(set) __builtin_memset((set), 0, sizeof(*(set))) -#define FD_SET(fd, set) \ - ((set)->fds_bits[(fd) / (8 * sizeof(fd_mask))] |= \ - (1UL << ((fd) % (8 * sizeof(fd_mask))))) +#define FD_SET(fd, set) \ + ((set)->fds_bits[(fd) / (8 * sizeof(unsigned long))] |= \ + 1UL << ((fd) % (8 * sizeof(unsigned long)))) -#define FD_CLR(fd, set) \ - ((set)->fds_bits[(fd) / (8 * sizeof(fd_mask))] &= \ - ~(1UL << ((fd) % (8 * sizeof(fd_mask))))) +#define FD_CLR(fd, set) \ + ((set)->fds_bits[(fd) / (8 * sizeof(unsigned long))] &= \ + ~(1UL << ((fd) % (8 * sizeof(unsigned long))))) -#define FD_ISSET(fd, set) \ - (((set)->fds_bits[(fd) / (8 * sizeof(fd_mask))] & \ - (1UL << ((fd) % (8 * sizeof(fd_mask))))) != 0) +#define FD_ISSET(fd, set) \ + ((set)->fds_bits[(fd) / (8 * sizeof(unsigned long))] & \ + (1UL << ((fd) % (8 * sizeof(unsigned long))))) typedef __INT64_TYPE__ time_t; typedef __INT64_TYPE__ suseconds_t; diff --git a/include/bits/siginfo.h b/include/bits/siginfo.h new file mode 100644 index 00000000..6a254596 --- /dev/null +++ b/include/bits/siginfo.h @@ -0,0 +1,28 @@ +#ifndef __BITS_SIGINFO_H +#define __BITS_SIGINFO_H + +#ifndef __BITS_SIGINFO_H_ +#error "Internal header — include the public API header instead." +#else +#undef __BITS_SIGINFO_H_ +#endif + +#define __BITS_SIGEVENT_H_ +#include <bits/sigevent.h> + +typedef __UINT32_TYPE__ id_t; +typedef __INT64_TYPE__ pid_t; +typedef __UINT32_TYPE__ uid_t; + +typedef struct { + int si_signo; + int si_code; + int si_errno; + pid_t si_pid; + uid_t si_uid; + void *si_addr; + int si_status; + union sigval si_value; +} siginfo_t; + +#endif diff --git a/include/bits/stat.h b/include/bits/stat.h index faa23771..ba43e695 100644 --- a/include/bits/stat.h +++ b/include/bits/stat.h @@ -35,4 +35,8 @@ struct stat { blkcnt_t st_blocks; }; +#define st_atime st_atim.tv_sec +#define st_mtime st_mtim.tv_sec +#define st_ctime st_ctim.tv_sec + #endif diff --git a/include/signal.h b/include/signal.h index a4f41c96..6b7f2a4a 100644 --- a/include/signal.h +++ b/include/signal.h @@ -3,7 +3,9 @@ #define __BITS_SIGEVENT_H_ #include <bits/sigevent.h> -#undef __BITS_SIGEVENT_H_ + +#define __BITS_SIGINFO_H_ +#include <bits/siginfo.h> #define SIG_DFL ((void (*)(int))0) #define SIG_ERR ((void (*)(int)) - 1) @@ -76,18 +78,11 @@ typedef __UINT64_TYPE__ sigset_t; typedef __SIZE_TYPE__ size_t; typedef struct __thread_self pthread_t; -struct timespec; +typedef void (*sighandler_t)(int); -typedef struct { - int si_signo; - int si_code; - int si_errno; - pid_t si_pid; - uid_t si_uid; - void *si_addr; - int si_status; - union sigval si_value; -} siginfo_t; +typedef _Atomic int sig_atomic_t; + +struct timespec; typedef struct { void *ss_sp; @@ -102,6 +97,9 @@ struct sigaction { void (*sa_sigaction)(int, siginfo_t *, void *); }; +extern const char *const sys_siglist[64]; +extern const char *const sys_sigabbrev[64]; + int kill(pid_t, int); int killpg(pid_t, int); void psiginfo(const siginfo_t *, const char *); @@ -129,4 +127,6 @@ int sigwait(const sigset_t *restrict, int *restrict); int sigwaitinfo(const sigset_t *restrict, siginfo_t *restrict); int str2sig(const char *restrict, int *restrict); +sighandler_t sysv_signal(int signum, sighandler_t handler); + #endif diff --git a/include/stddef.h b/include/stddef.h index dfae9a12..ba40122a 100644 --- a/include/stddef.h +++ b/include/stddef.h @@ -19,6 +19,8 @@ typedef void *nullptr_t; #define offsetof(__type, __member) __builtin_offsetof(__type, __member) #endif +#define unreachable() __builtin_unreachable() + typedef __WCHAR_TYPE__ wchar_t; typedef __SIZE_TYPE__ ptrdiff_t; typedef __SIZE_TYPE__ size_t; diff --git a/include/stdlib.h b/include/stdlib.h index a9480d38..e9686678 100644 --- a/include/stdlib.h +++ b/include/stdlib.h @@ -19,7 +19,6 @@ #define RAND_MAX (0x7fffffff) typedef __SIZE_TYPE__ size_t; -typedef __WCHAR_TYPE__ wchar_t; typedef struct { int quot; @@ -69,8 +68,6 @@ lldiv_t lldiv(long long, long long); long lrand48(void); void *malloc(size_t); int mblen(const char *, size_t); -size_t mbstowcs(wchar_t *restrict, const char *restrict, size_t); -int mbtowc(wchar_t *restrict, const char *restrict, size_t); char *mkdtemp(char *); int mkostemp(char *, int); int mkstemp(char *); @@ -108,7 +105,5 @@ unsigned long long strtoull(const char *restrict, char **restrict, int); int system(const char *); int unlockpt(int); int unsetenv(const char *); -size_t wcstombs(char *restrict, const wchar_t *restrict, size_t); -int wctomb(char *, wchar_t); #endif diff --git a/include/string.h b/include/string.h index 17ad87e5..707d9eeb 100644 --- a/include/string.h +++ b/include/string.h @@ -4,6 +4,9 @@ #define __BITS_ERRNO_H_ #include <bits/errno.h> +#define __BITS_RSIZE_H_ +#include <bits/rsize.h> + #ifndef NULL #define NULL ((void *)0) #endif @@ -15,6 +18,7 @@ void *memccpy(void *restrict, const void *restrict, int, size_t); void *memchr(const void *, int, size_t); int memcmp(const void *, const void *, size_t); void *memcpy(void *restrict, const void *restrict, size_t); +errno_t memcpy_s(void *restrict, rsize_t, const void *restrict, rsize_t); void *memmem(const void *, size_t, const void *, size_t); void *memmove(void *, const void *, size_t); void *memset(void *, int, size_t); diff --git a/include/sys/cdefs.h b/include/sys/cdefs.h index 0ef66647..c3bb51c1 100644 --- a/include/sys/cdefs.h +++ b/include/sys/cdefs.h @@ -4,4 +4,16 @@ #define __BEGIN_DECLS extern "C" { #define __END_DECLS } +#define __dead __attribute__((__noreturn__)) + +#define __used __attribute__((__used__)) +#define __unused __attribute__((__unused__)) + +#define __packed __attribute__((__packed__)) +#define __aligned(x) __attribute__((__aligned__(x))) + +#define __malloc __attribute__((__malloc__)) + +#define __pure __attribute__((__pure__)) + #endif diff --git a/include/sys/resource.h b/include/sys/resource.h new file mode 100644 index 00000000..79fcf235 --- /dev/null +++ b/include/sys/resource.h @@ -0,0 +1,47 @@ +#ifndef __SYS_RESOURCE_H +#define __SYS_RESOURCE_H + +typedef __INT64_TYPE__ time_t; +typedef __INT64_TYPE__ suseconds_t; + +struct __timeval { + time_t tv_sec; + suseconds_t tv_usec; +}; + +#define RUSAGE_SELF 0 +#define RUSAGE_CHILDREN (-1) +#define RUSAGE_BOTH (-2) +#define RUSAGE_THREAD 1 + +struct rusage { + struct __timeval ru_utime; + struct __timeval ru_stime; + long ru_maxrss; + long ru_ixrss; + long ru_idrss; + long ru_isrss; + long ru_minflt; + long ru_majflt; + long ru_nswap; + long ru_inblock; + long ru_oublock; + long ru_msgsnd; + long ru_msgrcv; + long ru_nsignals; + long ru_nvcsw; + long ru_nivcsw; +}; + +#define PRIO_MIN (-20) +#define PRIO_MAX 20 + +#define PRIO_PROCESS 0 +#define PRIO_PGRP 1 +#define PRIO_USER 2 + +int getpriority(int, int); +int setpriority(int, int, int); +int getrusage(int, struct rusage *); + +#endif diff --git a/include/sys/select.h b/include/sys/select.h index 44abc2e1..13c48dda 100644 --- a/include/sys/select.h +++ b/include/sys/select.h @@ -3,13 +3,11 @@ #define __BITS_SELECT_H_ #include <bits/select.h> -#undef __BITS_SELECT_H_ #define __BITS_TIMESPEC_H_ #include <bits/timespec.h> -#undef __BITS_TIMESPEC_H_ -typedef __INT32_TYPE__ sigset_t; +typedef __UINT64_TYPE__ sigset_t; int pselect(int, fd_set *restrict, fd_set *restrict, fd_set *restrict, const struct timespec *restrict, const sigset_t *restrict); diff --git a/include/sys/time.h b/include/sys/time.h index 5f34e744..0746f411 100644 --- a/include/sys/time.h +++ b/include/sys/time.h @@ -3,10 +3,13 @@ #define __BITS_SELECT_H_ #include <bits/select.h> -#undef __BITS_SELECT_H_ + +struct timezone; int select(int, fd_set *restrict, fd_set *restrict, fd_set *restrict, struct timeval *restrict); +int gettimeofday(struct timeval *, struct timezone *); +char *strtotimeval(const char *, struct timeval *); int utimes(const char *, const struct timeval[2]); #endif diff --git a/include/sys/wait.h b/include/sys/wait.h index 2a7438d7..ad935dc8 100644 --- a/include/sys/wait.h +++ b/include/sys/wait.h @@ -4,34 +4,20 @@ #define __BITS_WAIT_H_ #include <bits/wait.h> +#define __BITS_SIGINFO_H_ +#include <bits/siginfo.h> + +struct rusage; + #define WCONTINUED 0x00000008 #define WEXITED 0x00000004 #define WNOWAIT 0x01000000 #define WSTOPPED WUNTRACED -typedef __UINT32_TYPE__ id_t; -typedef __INT64_TYPE__ pid_t; -typedef __UINT32_TYPE__ uid_t; - -union sigval { - int sival_int; - void *sival_ptr; -}; - -typedef struct { - int si_signo; - int si_code; - int si_errno; - pid_t si_pid; - uid_t si_uid; - void *si_addr; - int si_status; - union sigval si_value; -} siginfo_t; - typedef enum { P_ALL = 0, P_PID = 1, P_PGID = 2 } idtype_t; pid_t wait(int *); +pid_t wait3(int *, int, struct rusage *); int waitid(idtype_t, id_t, siginfo_t *, int); pid_t waitpid(pid_t, int *, int); diff --git a/include/unistd.h b/include/unistd.h index d271809a..21822aed 100644 --- a/include/unistd.h +++ b/include/unistd.h @@ -14,6 +14,11 @@ #define STDOUT_FILENO 1 #define STDERR_FILENO 2 +#define F_OK 0 +#define X_OK 1 +#define W_OK 2 +#define R_OK 4 + typedef __SIZE_TYPE__ size_t; typedef __INT64_TYPE__ ssize_t; typedef __UINT32_TYPE__ uid_t; diff --git a/include/utime.h b/include/utime.h new file mode 100644 index 00000000..404d7003 --- /dev/null +++ b/include/utime.h @@ -0,0 +1,11 @@ +#ifndef __UTIME_H +#define __UTIME_H + +struct utimbuf { + long actime; + long modtime; +}; + +int utime(const char *, const struct utimbuf *); + +#endif @@ -1 +1,2 @@ obj-y += libc/ +obj-y += libm/ diff --git a/lib/libc/Kbuild b/lib/libc/Kbuild index dc0538a6..638e79cc 100644 --- a/lib/libc/Kbuild +++ b/lib/libc/Kbuild @@ -38,6 +38,7 @@ obj-y += time/ obj-y += times/ obj-y += uio/ obj-y += unistd/ +obj-y += utime/ obj-y += utsname/ obj-y += wait/ obj-y += wchar/ diff --git a/lib/libc/arch/x86_64/crt0.c b/lib/libc/arch/x86_64/crt0.c index 2c7943ff..546d9c8a 100644 --- a/lib/libc/arch/x86_64/crt0.c +++ b/lib/libc/arch/x86_64/crt0.c @@ -12,8 +12,6 @@ extern int main(int, char *[]); char **environ; -static struct __thread_self thread = { .tid = 0, ._errno = 0 }; - struct __attribute__((packed)) auxv_t { uintptr_t a_type; uintptr_t a_val; @@ -47,8 +45,6 @@ __attribute__((used)) void __libc_start(uintptr_t *sp) __auxv++; } - __asm__ volatile("wrfsbase %0" ::"r"(thread)); - exit(main(argc, argv)); } diff --git a/lib/libc/include/__alpha.h b/lib/libc/include/__alpha.h deleted file mode 100644 index f2e8bfb1..00000000 --- a/lib/libc/include/__alpha.h +++ /dev/null @@ -1,233 +0,0 @@ -/* Alpha ISO8859-1 font data */ -18, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 17, 34, 35, - 36, 17, 37, 38, 39, 40, 41, 42, 43, 44, 17, 45, 46, 47, 16, 16, 48, 16, - 16, 16, 16, 16, 16, 16, 49, 50, 51, 16, 52, 53, 16, 16, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 54, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 55, 17, 17, 17, 17, - 56, 17, 57, 58, 59, 60, 61, 62, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 63, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 64, 65, 17, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 17, 75, 76, 77, 78, 79, 80, 81, 16, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 16, 94, 95, 96, 16, 17, 17, - 17, 97, 98, 99, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, - 100, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, - 101, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, - 102, 103, 16, 16, 104, 105, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 106, 17, 17, 107, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - 17, 108, 109, 16, 16, 16, 16, 16, 16, 16, 16, 16, 110, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 111, 112, 113, 114, 16, 16, 16, 16, 16, 16, 16, 16, 115, 116, 117, - 16, 16, 16, 16, 16, 118, 119, 16, 16, 16, 16, 120, 16, 16, 121, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 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, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 7, 254, 255, - 255, 7, 0, 0, 0, 0, 0, 4, 32, 4, 255, 255, 127, 255, 255, 255, 127, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 195, 255, 3, 0, 31, - 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 223, 188, 64, 215, - 255, 255, 251, 255, 255, 255, 255, 255, 255, 255, 255, 255, 191, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 3, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 127, 2, - 255, 255, 255, 255, 255, 1, 0, 0, 0, 0, 255, 191, 182, 0, 255, 255, 255, - 135, 7, 0, 0, 0, 255, 7, 255, 255, 255, 255, 255, 255, 255, 254, 255, - 195, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 239, - 31, 254, 225, 255, 159, 0, 0, 255, 255, 255, 255, 255, 255, 0, 224, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 3, 0, 255, 255, - 255, 255, 255, 7, 48, 4, 255, 255, 255, 252, 255, 31, 0, 0, 255, 255, - 255, 1, 255, 7, 0, 0, 0, 0, 0, 0, 255, 255, 223, 63, 0, 0, 240, 255, - 248, 3, 255, 255, 255, 255, 255, 255, 255, 255, 255, 239, 255, 223, 225, - 255, 207, 255, 254, 255, 239, 159, 249, 255, 255, 253, 197, 227, 159, - 89, 128, 176, 207, 255, 3, 16, 238, 135, 249, 255, 255, 253, 109, 195, - 135, 25, 2, 94, 192, 255, 63, 0, 238, 191, 251, 255, 255, 253, 237, 227, - 191, 27, 1, 0, 207, 255, 0, 30, 238, 159, 249, 255, 255, 253, 237, 227, - 159, 25, 192, 176, 207, 255, 2, 0, 236, 199, 61, 214, 24, 199, 255, 195, - 199, 29, 129, 0, 192, 255, 0, 0, 239, 223, 253, 255, 255, 253, 255, 227, - 223, 29, 96, 7, 207, 255, 0, 0, 239, 223, 253, 255, 255, 253, 239, 227, - 223, 29, 96, 64, 207, 255, 6, 0, 239, 223, 253, 255, 255, 255, 255, 231, - 223, 93, 240, 128, 207, 255, 0, 252, 236, 255, 127, 252, 255, 255, 251, - 47, 127, 128, 95, 255, 192, 255, 12, 0, 254, 255, 255, 255, 255, 127, - 255, 7, 63, 32, 255, 3, 0, 0, 0, 0, 214, 247, 255, 255, 175, 255, 255, - 59, 95, 32, 255, 243, 0, 0, 0, 0, 1, 0, 0, 0, 255, 3, 0, 0, 255, 254, - 255, 255, 255, 31, 254, 255, 3, 255, 255, 254, 255, 255, 255, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 127, 249, 255, 3, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 63, 255, 255, 255, 255, 191, 32, - 255, 255, 255, 255, 255, 247, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 61, 127, 61, 255, 255, 255, 255, 255, 61, 255, 255, 255, 255, 61, - 127, 61, 255, 127, 255, 255, 255, 255, 255, 255, 255, 61, 255, 255, 255, - 255, 255, 255, 255, 255, 7, 0, 0, 0, 0, 255, 255, 0, 0, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 63, 63, 254, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 159, 255, 255, - 254, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 255, 255, 199, 255, - 1, 255, 223, 15, 0, 255, 255, 15, 0, 255, 255, 15, 0, 255, 223, 13, 0, - 255, 255, 255, 255, 255, 255, 207, 255, 255, 1, 128, 16, 255, 3, 0, 0, - 0, 0, 255, 3, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, - 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 255, 63, - 0, 255, 255, 255, 127, 255, 15, 255, 1, 192, 255, 255, 255, 255, 63, 31, - 0, 255, 255, 255, 255, 255, 15, 255, 255, 255, 3, 255, 3, 0, 0, 0, 0, - 255, 255, 255, 15, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 31, - 0, 255, 3, 255, 3, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, - 255, 255, 255, 239, 255, 239, 15, 255, 3, 0, 0, 0, 0, 255, 255, 255, - 255, 255, 243, 255, 255, 255, 255, 255, 255, 191, 255, 3, 0, 255, 255, - 255, 255, 255, 255, 127, 0, 255, 227, 255, 255, 255, 255, 255, 63, 255, - 1, 255, 255, 255, 255, 255, 231, 0, 0, 0, 0, 0, 222, 111, 4, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 128, 255, 31, 0, - 255, 255, 63, 63, 255, 255, 255, 255, 63, 63, 255, 170, 255, 255, 255, - 63, 255, 255, 255, 255, 255, 255, 223, 95, 220, 31, 207, 15, 255, 31, - 220, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 128, 0, 0, 255, - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 132, 252, 47, 62, 80, 189, 255, - 243, 224, 67, 0, 0, 255, 255, 255, 255, 255, 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, 192, 255, 255, 255, 255, 255, 255, 3, 0, 0, 255, 255, 255, - 255, 255, 127, 255, 255, 255, 255, 255, 127, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 31, 120, 12, 0, - 255, 255, 255, 255, 191, 32, 255, 255, 255, 255, 255, 255, 255, 128, 0, - 0, 255, 255, 127, 0, 127, 127, 127, 127, 127, 127, 127, 127, 255, 255, - 255, 255, 0, 0, 0, 0, 0, 128, 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, 224, 0, 0, 0, 254, 3, 62, 31, 254, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 224, 254, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 247, 224, 255, 255, 255, 255, - 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 0, 0, - 255, 255, 255, 7, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 31, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 63, 255, 31, - 255, 255, 255, 15, 0, 0, 255, 255, 255, 255, 255, 127, 240, 143, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, - 0, 0, 128, 255, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 249, 255, 255, 255, 255, 255, 255, 124, 0, 0, 0, 0, 0, 128, - 255, 191, 255, 255, 255, 255, 0, 0, 0, 255, 255, 255, 255, 255, 255, 15, - 0, 255, 255, 255, 255, 255, 255, 255, 255, 47, 0, 255, 3, 0, 0, 252, - 232, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 7, 0, 255, 255, - 255, 31, 255, 255, 255, 255, 255, 255, 247, 255, 0, 128, 255, 3, 255, - 255, 255, 127, 255, 255, 255, 255, 255, 255, 127, 0, 255, 63, 255, 3, - 255, 255, 127, 252, 255, 255, 255, 255, 255, 255, 255, 127, 5, 0, 0, 56, - 255, 255, 60, 0, 126, 126, 126, 0, 127, 127, 255, 255, 255, 255, 255, - 247, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 7, 255, 3, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 0, 255, 255, - 127, 248, 255, 255, 255, 255, 255, 15, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 63, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 3, 0, 0, 0, 0, 127, 0, 248, 224, 255, - 253, 127, 95, 219, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 3, 0, 0, 0, 248, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 63, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, - 252, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 255, 15, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 223, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 31, 0, 0, 255, 3, 254, 255, - 255, 7, 254, 255, 255, 7, 192, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 127, 252, 252, 252, 28, 0, 0, 0, 0, 255, 239, 255, 255, 127, - 255, 255, 183, 255, 63, 255, 63, 0, 0, 0, 0, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 0, 0, 0, 0, 0, 0, - 0, 0, 255, 255, 255, 255, 255, 255, 31, 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, 255, - 255, 255, 31, 255, 255, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 255, 255, - 255, 255, 0, 224, 255, 255, 255, 7, 255, 255, 255, 255, 255, 7, 255, - 255, 255, 63, 255, 255, 255, 255, 15, 255, 62, 0, 0, 0, 0, 0, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 63, 255, 3, 255, 255, 255, 255, 15, 255, 255, 255, 255, - 15, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 15, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, - 255, 255, 127, 0, 255, 255, 63, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 63, 253, 255, 255, 255, 255, 191, 145, 255, 255, - 63, 0, 255, 255, 127, 0, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, - 255, 255, 55, 0, 255, 255, 63, 0, 255, 255, 255, 3, 0, 0, 0, 0, 0, 0, 0, - 0, 255, 255, 255, 255, 255, 255, 255, 192, 0, 0, 0, 0, 0, 0, 0, 0, 111, - 240, 239, 254, 255, 255, 63, 0, 0, 0, 0, 0, 255, 255, 255, 31, 255, 255, - 255, 31, 0, 0, 0, 0, 255, 254, 255, 255, 31, 0, 0, 0, 255, 255, 255, - 255, 255, 255, 63, 0, 255, 255, 63, 0, 255, 255, 7, 0, 255, 255, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 1, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 7, 0, 255, - 255, 255, 255, 255, 255, 7, 0, 255, 255, 255, 255, 255, 0, 255, 3, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, - 255, 255, 31, 128, 0, 255, 255, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 255, 255, 127, 0, 255, 255, 255, 255, 255, 255, - 255, 255, 63, 0, 0, 0, 192, 255, 0, 0, 252, 255, 255, 255, 255, 255, - 255, 1, 0, 0, 255, 255, 255, 1, 255, 3, 255, 255, 255, 255, 255, 255, - 199, 255, 112, 0, 255, 255, 255, 255, 71, 0, 255, 255, 255, 255, 255, - 255, 255, 255, 30, 0, 255, 23, 0, 0, 0, 0, 255, 255, 251, 255, 255, 255, - 159, 64, 0, 0, 0, 0, 0, 0, 0, 0, 127, 189, 255, 191, 255, 1, 255, 255, - 255, 255, 255, 255, 255, 1, 255, 3, 239, 159, 249, 255, 255, 253, 237, - 227, 159, 25, 129, 224, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 187, 7, 255, 131, 0, - 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 179, 0, 255, 3, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, - 255, 255, 255, 63, 127, 0, 0, 0, 63, 0, 0, 0, 0, 255, 255, 255, 255, - 255, 255, 255, 127, 17, 0, 255, 3, 0, 0, 0, 0, 255, 255, 255, 255, 255, - 255, 63, 1, 255, 3, 0, 0, 0, 0, 0, 0, 255, 255, 255, 231, 255, 7, 255, - 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 255, 255, 255, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 3, 0, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 252, 255, 255, - 255, 255, 255, 252, 26, 0, 0, 0, 255, 255, 255, 255, 255, 255, 231, 127, - 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 32, 0, 0, 0, 0, 255, - 255, 255, 255, 255, 255, 255, 1, 255, 253, 255, 255, 255, 255, 127, 127, - 1, 0, 255, 3, 0, 0, 252, 255, 255, 255, 252, 255, 255, 254, 127, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 127, 251, 255, 255, 255, 255, 127, 180, 203, 0, - 255, 3, 191, 253, 255, 255, 255, 127, 123, 1, 255, 3, 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, 255, 255, 127, 0, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 3, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 127, 0, 0, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 127, 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, 255, 255, 255, 255, - 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 1, 255, 255, - 255, 127, 255, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 63, - 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 15, 0, 255, 3, 248, 255, 255, - 224, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 135, 255, 255, 255, 255, 255, 255, 255, 128, 255, 255, 0, 0, 0, 0, 0, 0, - 0, 0, 11, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 0, 255, 255, 255, 127, - 0, 0, 0, 0, 0, 0, 7, 0, 240, 0, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 15, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, - 31, 255, 1, 255, 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 223, 255, 255, 255, 255, 255, 255, - 255, 255, 223, 100, 222, 255, 235, 239, 255, 255, 255, 255, 255, 255, - 255, 191, 231, 223, 223, 255, 255, 255, 123, 95, 252, 253, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 63, 255, 255, - 255, 253, 255, 255, 247, 255, 255, 255, 247, 255, 255, 223, 255, 255, - 255, 223, 255, 255, 127, 255, 255, 255, 127, 255, 255, 255, 253, 255, - 255, 255, 253, 255, 255, 247, 207, 255, 255, 255, 255, 255, 255, 127, - 255, 255, 249, 219, 7, 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, 255, 255, 255, 255, 255, 31, 128, 63, 255, - 67, 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, - 255, 255, 255, 255, 255, 15, 255, 3, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 31, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, - 255, 255, 143, 8, 255, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 239, 255, 255, 255, 150, 254, 247, 10, 132, 234, 150, - 170, 150, 247, 247, 94, 255, 251, 255, 15, 238, 251, 255, 15, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 3, 255, 255, 255, 3, - 255, 255, 255, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, diff --git a/lib/libc/include/libc.h b/lib/libc/include/libc.h index d59c2b3c..7faee4b7 100644 --- a/lib/libc/include/libc.h +++ b/lib/libc/include/libc.h @@ -2,12 +2,12 @@ #define __LIBC_LIBC_H #include <stdatomic.h> +#include <features.h> #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #define __unused __attribute__((unused)) #define aligned(type) __attribute__((aligned(__alignof__(type)))) -#define __weak __attribute__((__weak__)) #define weak_reference(old, new) \ extern __typeof(old) new __attribute__((__weak__, __alias__(#old))) diff --git a/lib/libc/libc.a b/lib/libc/libc.a Binary files differindex 4f874074..49fadae3 100644 --- a/lib/libc/libc.a +++ b/lib/libc/libc.a diff --git a/lib/libc/signal/Kbuild b/lib/libc/signal/Kbuild index b8881c92..f8122caf 100644 --- a/lib/libc/signal/Kbuild +++ b/lib/libc/signal/Kbuild @@ -19,3 +19,4 @@ obj-y += sigtimedwait.o obj-y += sigwait.o obj-y += sigwaitinfo.o obj-y += str2sig.o +obj-y += sysv_signal.o diff --git a/lib/libc/signal/sig2str.c b/lib/libc/signal/sig2str.c index 209cb4c3..2532d539 100644 --- a/lib/libc/signal/sig2str.c +++ b/lib/libc/signal/sig2str.c @@ -6,25 +6,28 @@ int sig2str(int signum, char *str) { if (signum >= SIGHUP && signum <= SIGSYS) { - strcpy(str, __sys_signame[signum - SIGHUP]); + strlcpy(str, __sys_signame[signum - SIGHUP], + sizeof(__sys_signame[signum - SIGHUP])); return 0; } if (signum == SIGRTMIN) { - strcpy(str, "SIGRTMIN"); + strlcpy(str, "SIGRTMIN", sizeof("SIGRTMIN")); return 0; } if (signum == SIGRTMAX) { - strcpy(str, "RTMAX"); + strlcpy(str, "SIGRTMAX", sizeof("SIGRTMAX")); return 0; } if (signum > SIGRTMIN && signum < SIGRTMAX) { if (signum - SIGRTMIN <= SIGRTMAX - signum) { - sprintf(str, "RTMIN+%d", signum - SIGRTMIN); + snprintf(str, sizeof("RTMIN+") + 1, "RTMIN+%d", + signum - SIGRTMIN); } else { - sprintf(str, "RTMAX-%d", SIGRTMAX - signum); + snprintf(str, sizeof("RTMAX-") + 1, "RTMAX-%d", + SIGRTMAX - signum); } return 0; } diff --git a/lib/libc/signal/sigabbrev.h b/lib/libc/signal/sigabbrev.h new file mode 100644 index 00000000..fa0ef1ce --- /dev/null +++ b/lib/libc/signal/sigabbrev.h @@ -0,0 +1,22 @@ +#include <signal.h> +#include <unistd.h> + +const char *const sys_sigabbrev[64] = { + [SIGABRT] = "ABRT", [SIGALRM] = "ALRM", [SIGBUS] = "BUS", + [SIGCHLD] = "CHLD", [SIGFPE] = "FPE", [SIGHUP] = "HUP", + [SIGILL] = "ILL", [SIGINT] = "INT", [SIGIO] = "IO", +#if defined(SIGIOT) && (SIGIOT != SIGABRT) + [SIGIOT] = "IOT", +#endif + [SIGKILL] = "KILL", [SIGPIPE] = "PIPE", +#if defined(SIGPOLL) && (SIGPOLL != SIGIO) + [SIGPOLL] = "POLL", +#endif + [SIGPROF] = "PROF", [SIGPWR] = "PWR", [SIGQUIT] = "QUIT", + [SIGSEGV] = "SEGV", [SIGSTKFLT] = "STKFLT", [SIGSTOP] = "STOP", + [SIGSYS] = "SYS", [SIGTERM] = "TERM", [SIGTSTP] = "TSTP", + [SIGTTIN] = "TTIN", [SIGTTOU] = "TTOU", [SIGURG] = "URG", + [SIGUSR1] = "USR1", [SIGUSR2] = "USR2", [SIGVTALRM] = "VTALRM", + [SIGWINCH] = "WINCH", [SIGXCPU] = "XCPU", [SIGXFSZ] = "XFSZ", + [SIGCONT] = "CONT", [SIGTRAP] = "TRAP", +}; diff --git a/lib/libc/signal/siglist.c b/lib/libc/signal/siglist.c new file mode 100644 index 00000000..ba9ec746 --- /dev/null +++ b/lib/libc/signal/siglist.c @@ -0,0 +1,47 @@ +#include <signal.h> +#include <unistd.h> + +const char *const sys_siglist[64] = { + [SIGABRT] = "Aborted", + [SIGALRM] = "Alarm clock", + [SIGBUS] = "Bus error", + [SIGCHLD] = "Child exited", +#if defined(SIGCLD) && (SIGCHLD != SIGCLD) + [SIGCLD] = "Child exited", +#endif + [SIGHUP] = "Hangup", + [SIGILL] = "Illegal instruction", + [SIGINT] = "Interrupt", + [SIGIO] = "I/O possible", +#if defined(SIGIOT) && (SIGIOT != SIGABRT) + [SIGIOT] = "I/O trap", +#endif + [SIGKILL] = "Killed", +#if defined(SIGLOST) && (SIGLOST != SIGIO) && (SIGLOST != SIGPWR) + [SIGLOST] = "Lock lost", +#endif + [SIGPIPE] = "Broken pipe", +#if defined(SIGPOLL) && (SIGPOLL != SIGIO) + [SIGPOLL] = "Pollable event", +#endif + [SIGPROF] = "Profiling timer expired", + [SIGPWR] = "Power failure", + [SIGQUIT] = "Quit", + [SIGSEGV] = "Segment violation", + [SIGSTKFLT] = "Stack fault", + [SIGSTOP] = "Stopped (signal)", + [SIGSYS] = "Bad system call", + [SIGTERM] = "Terminated", + [SIGTSTP] = "Stopped", + [SIGTTIN] = "Stopped (tty input)", + [SIGTTOU] = "Stopped (tty output)", + [SIGURG] = "Urgent I/O condition", + [SIGUSR1] = "User signal 1", + [SIGUSR2] = "User signal 2", + [SIGVTALRM] = "Virtual timer expired", + [SIGWINCH] = "Window size changed", + [SIGXCPU] = "CPU time limit exceeded", + [SIGXFSZ] = "File size limit exceeded", + [SIGTRAP] = "Trace/breakpoint trap", + [SIGCONT] = "Continue", +}; diff --git a/lib/libc/signal/sysv_signal.c b/lib/libc/signal/sysv_signal.c new file mode 100644 index 00000000..2aa0221a --- /dev/null +++ b/lib/libc/signal/sysv_signal.c @@ -0,0 +1,15 @@ +#include <signal.h> + +sighandler_t sysv_signal(int signum, sighandler_t handler) +{ + struct sigaction new_action, old_action; + + new_action.sa_handler = handler; + sigemptyset(&new_action.sa_mask); + new_action.sa_flags = 0; + + if (sigaction(signum, &new_action, &old_action) < 0) + return SIG_ERR; + + return old_action.sa_handler; +} diff --git a/lib/libc/stat/futimens.c b/lib/libc/stat/futimens.c index 974d2eb7..38c6876f 100644 --- a/lib/libc/stat/futimens.c +++ b/lib/libc/stat/futimens.c @@ -1,7 +1,6 @@ -#include <stddef.h> #include <sys/stat.h> int futimens(int fd, const struct timespec times[2]) { - return utimensat(fd, NULL, times, 0); + return utimensat(fd, "", times, 0); } diff --git a/lib/libc/statvfs/fstatvfs.c b/lib/libc/statvfs/fstatvfs.c index 8bf78d35..048db737 100644 --- a/lib/libc/statvfs/fstatvfs.c +++ b/lib/libc/statvfs/fstatvfs.c @@ -4,7 +4,7 @@ int fstatvfs(int fildes, struct __statvfs *buf) { - struct statfs statfs; + struct statfs statfs = { 0 }; if (syscall(fstatfs, fildes, &statfs) < 0) return -1; diff --git a/lib/libc/statvfs/statvfs.c b/lib/libc/statvfs/statvfs.c index df8c9544..3a7c1f3e 100644 --- a/lib/libc/statvfs/statvfs.c +++ b/lib/libc/statvfs/statvfs.c @@ -4,7 +4,7 @@ int statvfs(const char *restrict path, struct __statvfs *restrict buf) { - struct statfs statfs; + struct statfs statfs = { 0 }; if (syscall(statfs, path, &statfs) < 0) return -1; diff --git a/lib/libc/stdio/fmemopen.c b/lib/libc/stdio/fmemopen.c index 6830dcbe..b1fa0f8a 100644 --- a/lib/libc/stdio/fmemopen.c +++ b/lib/libc/stdio/fmemopen.c @@ -30,6 +30,7 @@ FILE *fmemopen(void *restrict buf, size_t max_size, const char *restrict mode) } else if (mode[0] == 'a') { flags = O_WRONLY | O_CREAT | O_APPEND; } else { + free(f); errno = EINVAL; return NULL; } diff --git a/lib/libc/stdio/vfprintf.c b/lib/libc/stdio/vfprintf.c index 495fb9ea..90e60f7f 100644 --- a/lib/libc/stdio/vfprintf.c +++ b/lib/libc/stdio/vfprintf.c @@ -325,11 +325,12 @@ int vfprintf(FILE *restrict stream, const char *restrict format, va_list ap) int pos = 0; if (isnan(val)) { - strcpy(buf, - (*ptr == 'F' || *ptr == 'E' || - *ptr == 'G') ? - "NAN" : - "nan"); + strlcpy(buf, + (*ptr == 'F' || *ptr == 'E' || + *ptr == 'G') ? + "NAN" : + "nan", + sizeof(buf)); l = 3; break; } @@ -341,11 +342,12 @@ int vfprintf(FILE *restrict stream, const char *restrict format, va_list ap) } else if (flags & FLAG_SPACE) { buf[pos++] = ' '; } - strcpy(buf + pos, - (*ptr == 'F' || *ptr == 'E' || - *ptr == 'G') ? - "INF" : - "inf"); + strlcpy(buf + pos, + (*ptr == 'F' || *ptr == 'E' || + *ptr == 'G') ? + "INF" : + "inf", + sizeof(buf) - pos); l = pos + 3; break; } @@ -607,8 +609,9 @@ int vfprintf(FILE *restrict stream, const char *restrict format, va_list ap) } if (val == 0.0) { - strcpy(buf + pos, - upper ? "0X0P+0" : "0x0p+0"); + strlcpy(buf + pos, + upper ? "0X0P+0" : "0x0p+0", + sizeof(buf) - pos); l = pos + 6; break; } diff --git a/lib/libc/stdlib/Kbuild b/lib/libc/stdlib/Kbuild new file mode 100644 index 00000000..6d7efef7 --- /dev/null +++ b/lib/libc/stdlib/Kbuild @@ -0,0 +1,34 @@ +obj-y += _Exit.o +obj-y += abort.o +obj-y += abs.o +obj-y += aligned_alloc.o +obj-y += atexit.o +obj-y += atof.o +obj-y += atoi.o +obj-y += atol.o +obj-y += atoll.o +obj-y += bsearch.o +obj-y += calloc.o +obj-y += div.o +obj-y += exit.o +obj-y += free.o +obj-y += getenv.o +obj-y += heapsort_r.o +obj-y += heapsort.o +obj-y += labs.o +obj-y += ldiv.o +obj-y += llabs.o +obj-y += lldiv.o +obj-y += malloc.o +obj-y += posix_memalign.o +obj-y += putenv.o +obj-y += qsort_r.o +obj-y += qsort.o +obj-y += quick_exit.o +obj-y += rand.o +obj-y += realloc.o +obj-y += reallocarray.o +obj-y += setenv.o +obj-y += strtox.o +obj-y += system.o +obj-y += unsetenv.o diff --git a/lib/libc/stdlib/__mb_cur_max.c b/lib/libc/stdlib/__mb_cur_max.c deleted file mode 100644 index 2f8affa2..00000000 --- a/lib/libc/stdlib/__mb_cur_max.c +++ /dev/null @@ -1,6 +0,0 @@ -int __mb_cur_max(void) -{ - // TODO: if locale (c/utf8) will be implemented - // then return the correct value here if c then 1 else if utf8 then 4 - return 1; -} diff --git a/lib/libc/stdlib/qsort_r.c b/lib/libc/stdlib/qsort_r.c index 2fc39a6f..646eeaff 100644 --- a/lib/libc/stdlib/qsort_r.c +++ b/lib/libc/stdlib/qsort_r.c @@ -22,7 +22,8 @@ /* Minor changes by Rich Felker for integration in musl, 2011-04-27. */ /* Smoothsort, an adaptive variant of Heapsort. Memory usage: O(1). - Run time: Worst case O(n log n), close to O(n) in the mostly-sorted case. */ + Run time: Worst case O(n log n), close to O(n) in the + mostly-sorted case. */ #define _BSD_SOURCE #include <stdlib.h> @@ -68,13 +69,15 @@ static void cycle(size_t width, unsigned char *ar[], int n) /* shl() and shr() need n > 0 */ static inline void shl(size_t p[2], int n) { - if (n >= 8 * sizeof(size_t)) { - n -= 8 * sizeof(size_t); + size_t bits = sizeof(size_t) * 8; + + if (n >= (int)bits) { + n -= (int)bits; p[1] = p[0]; p[0] = 0; } p[1] <<= n; - p[1] |= (n < sizeof(size_t) * 8) ? p[0] >> (sizeof(size_t) * 8 - n) : 0; + p[1] |= (n < (int)bits) ? p[0] >> (bits - n) : 0; p[0] <<= n; } @@ -82,19 +85,19 @@ static inline void shr(size_t p[2], int n) { size_t bits = sizeof(size_t) * 8; - if (n >= 8 * sizeof(size_t)) { - n -= 8 * sizeof(size_t); + if (n >= (int)bits) { + n -= (int)bits; p[0] = p[1]; p[1] = 0; } p[0] >>= n; - p[0] |= (n > 0 && n < bits) ? p[1] << (bits - n) : 0; + p[0] |= (n > 0 && n < (int)bits) ? p[1] << (bits - n) : 0; p[1] >>= n; } static void sift(unsigned char *head, size_t width, cmpfun cmp, void *arg, - int pshift, size_t lp[]) + int pshift, size_t lp[], int max_lp_index) { unsigned char *rt, *lf; unsigned char *ar[14 * sizeof(size_t) + 1]; @@ -102,6 +105,9 @@ static void sift(unsigned char *head, size_t width, cmpfun cmp, void *arg, ar[0] = head; while (pshift > 1) { + if (pshift - 2 < 0 || pshift - 2 > max_lp_index) + break; + rt = head - width; lf = head - width - lp[pshift - 2]; @@ -162,7 +168,7 @@ static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg, } if (!trusty) { cycle(width, ar, i); - sift(head, width, cmp, arg, pshift, lp); + sift(head, width, cmp, arg, pshift, lp, max_lp_index); } } @@ -190,16 +196,17 @@ void qsort_r(void *base, size_t nel, size_t width, cmpfun cmp, void *arg) while (head < high) { if ((p[0] & 3) == 3) { - sift(head, width, cmp, arg, pshift, lp); + sift(head, width, cmp, arg, pshift, lp, max_lp_index); shr(p, 2); pshift += 2; } else { if (pshift - 1 >= 0 && pshift - 1 <= max_lp_index && - lp[pshift - 1] >= high - head) { + lp[pshift - 1] >= (size_t)(high - head)) { trinkle(head, width, cmp, arg, p, pshift, 0, lp, max_lp_index); } else { - sift(head, width, cmp, arg, pshift, lp); + sift(head, width, cmp, arg, pshift, lp, + max_lp_index); } if (pshift == 1) { diff --git a/lib/libc/stdlib/strtox.c b/lib/libc/stdlib/strtox.c index 9d72954a..e924e5e6 100644 --- a/lib/libc/stdlib/strtox.c +++ b/lib/libc/stdlib/strtox.c @@ -66,7 +66,6 @@ __scanint(const char *s, int base, unsigned long long lim, int *neg, char **end) static long double __scanfloat(const char *s, char **end) { long double value = 0.0; - long double frac = 0.0; long double sign = 1.0; long double scale = 1.0; int exp_sign = 1; diff --git a/lib/libc/stdlib/system.c b/lib/libc/stdlib/system.c index 4f560ce1..95f8d732 100644 --- a/lib/libc/stdlib/system.c +++ b/lib/libc/stdlib/system.c @@ -2,6 +2,7 @@ int system(const char *command) { + (void)command; // TODO return 0; } diff --git a/lib/libc/string/memcpy.c b/lib/libc/string/memcpy.c index ecdbd602..05586b55 100644 --- a/lib/libc/string/memcpy.c +++ b/lib/libc/string/memcpy.c @@ -1,3 +1,4 @@ +#include <errno.h> #include <string.h> #include <features.h> @@ -14,3 +15,41 @@ void *memcpy(void *restrict s1, const void *restrict s2, size_t n) return s1; } + +errno_t memcpy_s(void *restrict dest, rsize_t destsz, const void *restrict src, + rsize_t count) +{ + if (dest == NULL || src == NULL) { + if (dest != NULL && destsz > 0) { + unsigned char *d = dest; + for (rsize_t i = 0; i < destsz; i++) { + d[i] = 0; + } + } + + return EINVAL; + } + + const unsigned char *s = src; + unsigned char *d = dest; + + if ((d > s && d < s + count) || (s > d && s < d + count)) { + for (rsize_t i = 0; i < destsz; i++) { + d[i] = 0; + } + return EINVAL; + } + + if (count > destsz) { + for (rsize_t i = 0; i < destsz; i++) { + d[i] = 0; + } + return ERANGE; + } + + for (rsize_t i = 0; i < count; i++) { + d[i] = s[i]; + } + + return 0; +} diff --git a/lib/libc/string/strxfrm.c b/lib/libc/string/strxfrm.c index 123ebfe8..d216733b 100644 --- a/lib/libc/string/strxfrm.c +++ b/lib/libc/string/strxfrm.c @@ -6,13 +6,13 @@ size_t strxfrm(char *restrict s1, const char *restrict s2, size_t n) size_t len = strlen(s2); if (n > len) - strcpy(s1, s2); + strlcpy(s1, s2, n); return len; } __weak size_t strxfrm_l(char *restrict s1, const char *restrict s2, size_t n, - locale_t __unused locale) + locale_t __unused locale) { return strxfrm(s1, s2, n); } diff --git a/lib/libc/strings/strncasecmp.c b/lib/libc/strings/strncasecmp.c index f2f4c22c..7c2c9717 100644 --- a/lib/libc/strings/strncasecmp.c +++ b/lib/libc/strings/strncasecmp.c @@ -26,7 +26,7 @@ int strncasecmp(const char *s1, const char *s2, size_t n) } __weak int strncasecmp_l(const char *s1, const char *s2, size_t n, - locale_t __unused locale) + locale_t __unused locale) { return strncasecmp(s1, s2, n); } diff --git a/lib/libc/termios/tcsendbreak.c b/lib/libc/termios/tcsendbreak.c index a6ed420d..65f1d5b0 100644 --- a/lib/libc/termios/tcsendbreak.c +++ b/lib/libc/termios/tcsendbreak.c @@ -1,8 +1,9 @@ +#include <libc.h> #include <termios.h> #include <syscall.h> #include <asm-generic/ioctls.h> -int tcsendbreak(int fildes, int duration) +int tcsendbreak(int fildes, int __unused duration) { // IEEE Std 1003.1-2024 // If duration is not 0, it shall send zero-valued diff --git a/lib/libc/thread/Kbuild b/lib/libc/thread/Kbuild new file mode 100644 index 00000000..3e28ece3 --- /dev/null +++ b/lib/libc/thread/Kbuild @@ -0,0 +1 @@ +obj-y += thrd_current.o diff --git a/lib/libc/time/Kbuild b/lib/libc/time/Kbuild new file mode 100644 index 00000000..6b9e00cc --- /dev/null +++ b/lib/libc/time/Kbuild @@ -0,0 +1,15 @@ +obj-y += asctime.o +obj-y += clock_getcpuclockid.o +obj-y += clock_getres.o +obj-y += clock_nanosleep.o +obj-y += clock.o +obj-y += ctime.o +obj-y += difftime.o +obj-y += gmtime_r.o +obj-y += localtime_r.o +obj-y += localtime.o +obj-y += nanosleep.o +obj-y += strftime.o +obj-y += time.o +obj-y += tzset.o +obj-y += utimes.o diff --git a/lib/libc/time/asctime.c b/lib/libc/time/asctime.c index 54729a77..ab5ff096 100644 --- a/lib/libc/time/asctime.c +++ b/lib/libc/time/asctime.c @@ -3,11 +3,10 @@ char *asctime(const struct tm *timeptr) { - static char wday_name[7][3] = { "Sun", "Mon", "Tue", "Wed", - "Thu", "Fri", "Sat" }; - static char mon_name[12][3] = { "Jan", "Feb", "Mar", "Apr", - "May", "Jun", "Jul", "Aug", - "Sep", "Oct", "Nov", "Dec" }; + static char wday_name[][4] = { "Sun", "Mon", "Tue", "Wed", + "Thu", "Fri", "Sat" }; + static char mon_name[][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; static char result[26]; snprintf(result, sizeof(result), "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n", diff --git a/lib/libc/time/gmtime_r.c b/lib/libc/time/gmtime_r.c index 8d441549..2c741127 100644 --- a/lib/libc/time/gmtime_r.c +++ b/lib/libc/time/gmtime_r.c @@ -4,7 +4,7 @@ struct tm *gmtime_r(const time_t *timer, struct tm *result) { time_t t = *timer; int days, rem; - int year, month; + int year; rem = t % 86400; days = t / 86400; diff --git a/lib/libc/time/strftime.c b/lib/libc/time/strftime.c index f0881eb1..3f54961b 100644 --- a/lib/libc/time/strftime.c +++ b/lib/libc/time/strftime.c @@ -9,7 +9,7 @@ static size_t append_string(char *restrict *s, size_t *remaining, if (len >= *remaining) { return 0; } - strcpy(*s, str); + strlcpy(*s, str, *remaining); *s += len; *remaining -= len; return len; @@ -73,26 +73,10 @@ static const char *month_full[] = { "January", "February", "March", "July", "August", "September", "October", "November", "December" }; -static int day_of_year(const struct tm *tm) -{ - static const int days_to_month[] = { 0, 31, 59, 90, 120, 151, - 181, 212, 243, 273, 304, 334 }; - int days = days_to_month[tm->tm_mon] + tm->tm_mday; - - if (tm->tm_mon > 1) { - int year = tm->tm_year + 1900; - if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) { - days++; - } - } - return days; -} - static int iso_week_number(const struct tm *tm, int *week_year) { int year = tm->tm_year + 1900; int yday = tm->tm_yday + 1; - int wday; int jan4_wday = (4 + year + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400) % @@ -554,9 +538,9 @@ size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, } __weak size_t strftime_l(char *restrict s, size_t maxsize, - const char *restrict format, - const struct tm *restrict timeptr, - locale_t __unused locale) + const char *restrict format, + const struct tm *restrict timeptr, + locale_t __unused locale) { return strftime(s, maxsize, format, timeptr); } diff --git a/lib/libc/time/utimes.c b/lib/libc/time/utimes.c index d6448c76..7b928e7a 100644 --- a/lib/libc/time/utimes.c +++ b/lib/libc/time/utimes.c @@ -9,8 +9,8 @@ int utimes(const char *path, const struct timeval times[2]) struct timespec ts[2]; if (times) { - if (times[0].tv_usec >= 1000000ULL || - times[1].tv_usec >= 1000000ULL) { + if (times[0].tv_usec >= 1000000L || + times[1].tv_usec >= 1000000L) { errno = EINVAL; return -1; } diff --git a/lib/libc/uio/readv.c b/lib/libc/uio/readv.c index 8a2d9216..baca678d 100644 --- a/lib/libc/uio/readv.c +++ b/lib/libc/uio/readv.c @@ -45,7 +45,6 @@ ssize_t readv(int fd, const struct iovec *iov, int iovcnt) tmp.iov_base = (char *)tmp.iov_base + remaining; tmp.iov_len -= remaining; memcpy(local, &tmp, sizeof(tmp)); - remaining = 0; break; } } diff --git a/lib/libc/uio/writev.c b/lib/libc/uio/writev.c index 4e304336..6f629ba0 100644 --- a/lib/libc/uio/writev.c +++ b/lib/libc/uio/writev.c @@ -39,7 +39,6 @@ ssize_t writev(int fd, const struct iovec *iov, int iovcnt) tmp.iov_base = (char *)tmp.iov_base + remaining; tmp.iov_len -= remaining; memcpy(local, &tmp, sizeof(tmp)); - remaining = 0; break; } } diff --git a/lib/libc/unistd/execvp.c b/lib/libc/unistd/execvp.c index ae8ecdb9..c678ed36 100644 --- a/lib/libc/unistd/execvp.c +++ b/lib/libc/unistd/execvp.c @@ -34,7 +34,12 @@ int execvp(const char *file, char *const argv[]) return -1; } - execv(buf, argv); + /* Validate path doesn't contain dangerous + * characters */ + if (strstr(buf, "..") == NULL && + strchr(buf, '\0') == buf + strlen(buf)) { + execv(buf, argv); + } break; } @@ -45,7 +50,12 @@ int execvp(const char *file, char *const argv[]) return -1; } - execv(buf, argv); + /* Validate path doesn't contain dangerous characters */ + if (strstr(buf, "..") == NULL && + strchr(buf, '\0') == buf + strlen(buf)) { + execv(buf, argv); + } + path = ptr + 1; } while (*ptr != '\0'); errno = ENOENT; diff --git a/lib/libc/utime/Kbuild b/lib/libc/utime/Kbuild new file mode 100644 index 00000000..b1976215 --- /dev/null +++ b/lib/libc/utime/Kbuild @@ -0,0 +1 @@ +obj-y += utime.o diff --git a/lib/libc/utime/utime.c b/lib/libc/utime/utime.c new file mode 100644 index 00000000..8d6b91c6 --- /dev/null +++ b/lib/libc/utime/utime.c @@ -0,0 +1,14 @@ +#include <utime.h> +#include <sys/time.h> + +int utime(const char *filename, const struct utimbuf *buf) +{ + struct timeval tvp[2]; + + tvp[0].tv_sec = buf->actime; + tvp[0].tv_usec = 0; + tvp[1].tv_sec = buf->modtime; + tvp[1].tv_usec = 0; + + return utimes(filename, tvp); +} diff --git a/lib/libm/Kbuild b/lib/libm/Kbuild new file mode 100644 index 00000000..6d3074cb --- /dev/null +++ b/lib/libm/Kbuild @@ -0,0 +1,307 @@ +lib-y := libm.a + +obj-y += __cos.o +obj-y += __cosdf.o +obj-y += __cosl.o +obj-y += __expo2.o +obj-y += __expo2f.o +obj-y += __fpclassify.o +obj-y += __fpclassifyf.o +obj-y += __fpclassifyl.o +obj-y += __invtrigl.o +obj-y += __math_divzero.o +obj-y += __math_divzerof.o +obj-y += __math_invalid.o +obj-y += __math_invalidf.o +obj-y += __math_invalidl.o +obj-y += __math_oflow.o +obj-y += __math_oflowf.o +obj-y += __math_uflow.o +obj-y += __math_uflowf.o +obj-y += __math_xflow.o +obj-y += __math_xflowf.o +obj-y += __polevll.o +obj-y += __rem_pio2_large.o +obj-y += __rem_pio2.o +obj-y += __rem_pio2f.o +obj-y += __rem_pio2l.o +obj-y += __signbit.o +obj-y += __signbitf.o +obj-y += __signbitl.o +obj-y += __sin.o +obj-y += __sindf.o +obj-y += __sinl.o +obj-y += __tan.o +obj-y += __tandf.o +obj-y += __tanl.o +obj-y += aarch64 +obj-y += acos.o +obj-y += acosf.o +obj-y += acosh.o +obj-y += acoshf.o +obj-y += acoshl.o +obj-y += acosl.o +obj-y += asin.o +obj-y += asinf.o +obj-y += asinh.o +obj-y += asinhf.o +obj-y += asinhl.o +obj-y += asinl.o +obj-y += atan.o +obj-y += atan2.o +obj-y += atan2f.o +obj-y += atan2l.o +obj-y += atanf.o +obj-y += atanh.o +obj-y += atanhf.o +obj-y += atanhl.o +obj-y += atanl.o +obj-y += cabs.o +obj-y += cabsf.o +obj-y += cabsl.o +obj-y += cacos.o +obj-y += cacosf.o +obj-y += cacosh.o +obj-y += cacoshf.o +obj-y += cacoshl.o +obj-y += cacosl.o +obj-y += carg.o +obj-y += cargf.o +obj-y += cargl.o +obj-y += casin.o +obj-y += casinf.o +obj-y += casinh.o +obj-y += casinhf.o +obj-y += casinhl.o +obj-y += casinl.o +obj-y += catan.o +obj-y += catanf.o +obj-y += catanh.o +obj-y += catanhf.o +obj-y += catanhl.o +obj-y += catanl.o +obj-y += cbrt.o +obj-y += cbrtf.o +obj-y += cbrtl.o +obj-y += ccos.o +obj-y += ccosf.o +obj-y += ccosh.o +obj-y += ccoshf.o +obj-y += ccoshl.o +obj-y += ccosl.o +obj-y += ceil.o +obj-y += ceilf.o +obj-y += ceill.o +obj-y += cexp.o +obj-y += cexpl.o +obj-y += cexprf.o +obj-y += cimag.o +obj-y += cimagf.o +obj-y += cimagl.o +obj-y += clog.o +obj-y += clog10.o +obj-y += clog10f.o +obj-y += clog10l.o +obj-y += clogf.o +obj-y += clogl.o +obj-y += conj.o +obj-y += conjf.o +obj-y += conjl.o +obj-y += copysign.o +obj-y += copysignf.o +obj-y += copysignl.o +obj-y += cos.o +obj-y += cosf.o +obj-y += cosh.o +obj-y += coshf.o +obj-y += coshl.o +obj-y += cosl.o +obj-y += cpow.o +obj-y += cpowf.o +obj-y += cpowl.o +obj-y += cproj.o +obj-y += cprojl.o +obj-y += creal.o +obj-y += crealf.o +obj-y += creall.o +obj-y += csin.o +obj-y += csinf.o +obj-y += csinh.o +obj-y += csinhf.o +obj-y += csinhl.o +obj-y += csinl.o +obj-y += csqrt.o +obj-y += csqrtf.o +obj-y += csqrtl.o +obj-y += ctan.o +obj-y += ctanf.o +obj-y += ctanh.o +obj-y += ctanhf.o +obj-y += ctanhl.o +obj-y += ctanl.o +obj-y += erf.o +obj-y += erff.o +obj-y += erfl.o +obj-y += exp_data.o +obj-y += exp.o +obj-y += exp10.o +obj-y += exp10f.o +obj-y += exp10l.o +obj-y += exp2.o +obj-y += exp2f_data.o +obj-y += exp2f.o +obj-y += exp2l.o +obj-y += expf.o +obj-y += expl.o +obj-y += expm1.o +obj-y += expm1f.o +obj-y += expm1l.o +obj-y += fabs.o +obj-y += fabsf.o +obj-y += fabsl.o +obj-y += fdim.o +obj-y += fdimf.o +obj-y += fdiml.o +obj-y += finite.o +obj-y += finitef.o +obj-y += floor.o +obj-y += floorf.o +obj-y += floorl.o +obj-y += fma.o +obj-y += fmaf.o +obj-y += fmal.o +obj-y += fmax.o +obj-y += fmaxf.o +obj-y += fmaxl.o +obj-y += fmin.o +obj-y += fminf.o +obj-y += fminl.o +obj-y += fmod.o +obj-y += fmodf.o +obj-y += fmodl.o +obj-y += fpclassifyf.o +obj-y += frexp.o +obj-y += frexpf.o +obj-y += frexpl.o +obj-y += hypot.o +obj-y += hypotf.o +obj-y += hypotl.o +obj-y += ilogb.o +obj-y += ilogbf.o +obj-y += ilogbl.o +obj-y += isfinitef.o +obj-y += isinf.o +obj-y += j0.o +obj-y += j0f.o +obj-y += j1.o +obj-y += j1f.o +obj-y += jn.o +obj-y += Kbuild +obj-y += ldexp.o +obj-y += ldexpf.o +obj-y += ldexpl.o +obj-y += lgamma_r.o +obj-y += lgamma.o +obj-y += lgammaf_r.o +obj-y += lgammaf.o +obj-y += lgammal.o +obj-y += llrint.o +obj-y += llrintf.o +obj-y += llrintl.o +obj-y += llround.o +obj-y += llroundf.o +obj-y += llroundl.o +obj-y += log_data.o +obj-y += log.o +obj-y += log10.o +obj-y += log10f.o +obj-y += log10l.o +obj-y += log1p.o +obj-y += log1pf.o +obj-y += log1pl.o +obj-y += log2_data.o +obj-y += log2.o +obj-y += log2f_data.o +obj-y += log2f.o +obj-y += log2l.o +obj-y += logb.o +obj-y += logbf.o +obj-y += logbl.o +obj-y += logf_data.o +obj-y += logf.o +obj-y += logl.o +obj-y += lrint.o +obj-y += lrintf.o +obj-y += lrintl.o +obj-y += lround.o +obj-y += lroundf.o +obj-y += lroundl.o +obj-y += modf.o +obj-y += modff.o +obj-y += modfl.o +obj-y += nan.o +obj-y += nanf.o +obj-y += nanl.o +obj-y += nearbyint.o +obj-y += nearbyintf.o +obj-y += nearbyintl.o +obj-y += nextafter.o +obj-y += nextafterf.o +obj-y += nextafterl.o +obj-y += nexttoward.o +obj-y += nexttowardf.o +obj-y += nexttowardl.o +obj-y += pow_data.o +obj-y += pow.o +obj-y += powf_data.o +obj-y += powf.o +obj-y += powl.o +obj-y += projf.o +obj-y += remainder.o +obj-y += remainderf.o +obj-y += remainderl.o +obj-y += remquo.o +obj-y += remquof.o +obj-y += remquol.o +obj-y += rint.o +obj-y += rintf.o +obj-y += rintl.o +obj-y += round.o +obj-y += roundf.o +obj-y += roundl.o +obj-y += scalb.o +obj-y += scalbf.o +obj-y += scalbln.o +obj-y += scalblnf.o +obj-y += scalblnl.o +obj-y += scalbn.o +obj-y += scalbnf.o +obj-y += scalbnl.o +obj-y += signgam.o +obj-y += significand.o +obj-y += significandf.o +obj-y += sin.o +obj-y += sincos.o +obj-y += sincosf.o +obj-y += sincosl.o +obj-y += sinf.o +obj-y += sinh.o +obj-y += sinhf.o +obj-y += sinhl.o +obj-y += sinl.o +obj-y += sqrt_data.o +obj-y += sqrt.o +obj-y += sqrtf.o +obj-y += sqrtl.o +obj-y += tan.o +obj-y += tanf.o +obj-y += tanh.o +obj-y += tanhf.o +obj-y += tanhl.o +obj-y += tanl.o +obj-y += tgamma.o +obj-y += tgammaf.o +obj-y += tgammal.o +obj-y += trunc.o +obj-y += truncf.o +obj-y += truncl.o diff --git a/lib/libm/__complex.h b/lib/libm/__complex.h new file mode 100644 index 00000000..10b22df9 --- /dev/null +++ b/lib/libm/__complex.h @@ -0,0 +1,188 @@ +#ifndef __LIBC_COMPLEX_H__ +#define __LIBC_COMPLEX_H__ + +#include <math.h> +#include <complex.h> + +typedef union { + float complex z; + struct { + float x, y; + } parts; +} float_complex; + +typedef union { + double complex z; + struct { + double x, y; + } parts; +} double_complex; + +typedef union { + long double complex z; + struct { + long double x, y; + } parts; +} long_double_complex; + +#define M_IVLN10 (4.34294481903251816668e-01) +#define M_PIL (3.14159265358979323846264338327950280e+00L) + +#define REAL_PART(z) ((z).parts.x) +#define IMAG_PART(z) ((z).parts.y) + +static const long double DP1 = 3.14159265358979323829596852490908531763125L; +static const long double DP2 = 1.6667485837041756656403424829301998703007e-19L; + +#define MACHEP 1.1e-16 +#define MACHEPF 3.0e-8f + +#ifndef __vax__ +static const long double DP3 = 1.8830410776607851167459095484560349402753e-39L; +#define MACHEPL 1.1e-38L +#else +static const long double DP3 = 0L; +#define MACHEPL 1.1e-19L +#endif + +static void cchsh(double x, double *c, double *s) +{ + double e, ei; + + if (fabs(x) <= 0.5) { + *c = cosh(x); + *s = sinh(x); + } else { + e = exp(x); + ei = 0.5 / e; + e = 0.5 * e; + *s = e - ei; + *c = e + ei; + } +} + +static void cchshl(long double x, long double *c, long double *s) +{ + long double e, ei; + + if (fabsl(x) <= 0.5L) { + *c = coshl(x); + *s = sinhl(x); + } else { + e = expl(x); + ei = 0.5L / e; + e = 0.5L * e; + *s = e - ei; + *c = e + ei; + } +} + +static void cchshf(float x, float *c, float *s) +{ + float e, ei; + + if (fabsf(x) <= 0.5f) { + *c = coshf(x); + *s = sinhf(x); + } else { + e = expf(x); + ei = 0.5f / e; + e = 0.5f * e; + *s = e - ei; + *c = e + ei; + } +} + +static double redupi(double x) +{ + double t; + long i; + + t = x / M_PI; + if (t >= 0.0) + t += 0.5; + else + t -= 0.5; + + i = t; + t = i; + t = ((x - t * DP1) - t * DP2) - t * DP3; + return t; +} + +static float redupif(float x) +{ + float t; + long i; + + t = x / (float)M_PI; + if (t >= 0.0f) + t += 0.5f; + else + t -= 0.5f; + + i = t; + t = i; + t = ((x - t * DP1) - t * DP2) - t * DP3; + return t; +} + +static long double redupil(long double x) +{ + long double t; + long long i; + + t = x / M_PIL; + if (t >= 0.0L) + t += 0.5L; + else + t -= 0.5L; + + i = t; + t = i; + return ((x - t * DP1) - t * DP2) - t * DP3; +} + +static long double ctansl(long double complex z) +{ + long double f, x, x2, y, y2, rn, t; + long double d; + + x = fabsl(2.0L * creall(z)); + y = fabsl(2.0L * cimagl(z)); + + x = redupil(x); + + x = x * x; + y = y * y; + x2 = 1.0L; + y2 = 1.0L; + f = 1.0L; + rn = 0.0L; + d = 0.0L; + do { + rn += 1.0L; + f *= rn; + rn += 1.0L; + f *= rn; + x2 *= x; + y2 *= y; + t = y2 + x2; + t /= f; + d += t; + + rn += 1.0L; + f *= rn; + rn += 1.0L; + f *= rn; + x2 *= x; + y2 *= y; + t = y2 - x2; + t /= f; + d += t; + } while (fabsl(t / d) > MACHEPL); + + return d; +} + +#endif diff --git a/lib/libm/__cos.c b/lib/libm/__cos.c new file mode 100644 index 00000000..5e4665e2 --- /dev/null +++ b/lib/libm/__cos.c @@ -0,0 +1,71 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/k_cos.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * __cos( x, y ) + * kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * + * Algorithm + * 1. Since cos(-x) = cos(x), we need only to consider positive x. + * 2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0. + * 3. cos(x) is approximated by a polynomial of degree 14 on + * [0,pi/4] + * 4 14 + * cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x + * where the remez error is + * + * | 2 4 6 8 10 12 14 | -58 + * |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x +C6*x )| <= 2 + * | | + * + * 4 6 8 10 12 14 + * 4. let r = C1*x +C2*x +C3*x +C4*x +C5*x +C6*x , then + * cos(x) ~ 1 - x*x/2 + r + * since cos(x+y) ~ cos(x) - sin(x)*y + * ~ cos(x) - x*y, + * a correction term is necessary in cos(x) and hence + * cos(x+y) = 1 - (x*x/2 - (r - x*y)) + * For better accuracy, rearrange to + * cos(x+y) ~ w + (tmp + (r-x*y)) + * where w = 1 - x*x/2 and tmp is a tiny correction term + * (1 - x*x/2 == w + tmp exactly in infinite precision). + * The exactness of w + tmp in infinite precision depends on w + * and tmp having the same precision as x. If they have extra + * precision due to compiler bugs, then the extra precision is + * only good provided it is retained in all terms of the final + * expression for cos(). Retention happens in all cases tested + * under FreeBSD, so don't pessimize things by forcibly clipping + * any extra precision in w. + */ + +#include "libm.h" + +static const double C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C + */ + C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */ + C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */ + C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */ + C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */ + C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */ + +double __cos(double x, double y) +{ + double_t hz, z, r, w; + + z = x * x; + w = z * z; + r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6)); + hz = 0.5 * z; + w = 1.0 - hz; + return w + (((1.0 - w) - hz) + (z * r - x * y)); +} diff --git a/lib/libm/__cosdf.c b/lib/libm/__cosdf.c new file mode 100644 index 00000000..cda7195c --- /dev/null +++ b/lib/libm/__cosdf.c @@ -0,0 +1,34 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/k_cosf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Debugged and optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +/* |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]). */ +static const double C0 = -0x1ffffffd0c5e81.0p-54, /* -0.499999997251031003120 */ + C1 = 0x155553e1053a42.0p-57, /* 0.0416666233237390631894 */ + C2 = -0x16c087e80f1e27.0p-62, /* -0.00138867637746099294692 */ + C3 = 0x199342e0ee5069.0p-68; /* 0.0000243904487962774090654 */ + +float __cosdf(double x) +{ + double_t r, w, z; + + /* Try to optimize for parallel evaluation as in __tandf.c. */ + z = x * x; + w = z * z; + r = C2 + z * C3; + return ((1.0 + z * C0) + w * C1) + (w * z) * r; +} diff --git a/lib/libm/__cosl.c b/lib/libm/__cosl.c new file mode 100644 index 00000000..09d42d6b --- /dev/null +++ b/lib/libm/__cosl.c @@ -0,0 +1,104 @@ +/* origin: FreeBSD /usr/src/lib/msun/ld80/k_cosl.c */ +/* origin: FreeBSD /usr/src/lib/msun/ld128/k_cosl.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * Copyright (c) 2008 Steven G. Kargl, David Schultz, Bruce D. Evans. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +#if (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#if LDBL_MANT_DIG == 64 +/* + * ld80 version of __cos.c. See __cos.c for most comments. + */ +/* + * Domain [-0.7854, 0.7854], range ~[-2.43e-23, 2.425e-23]: + * |cos(x) - c(x)| < 2**-75.1 + * + * The coefficients of c(x) were generated by a pari-gp script using + * a Remez algorithm that searches for the best higher coefficients + * after rounding leading coefficients to a specified precision. + * + * Simpler methods like Chebyshev or basic Remez barely suffice for + * cos() in 64-bit precision, because we want the coefficient of x^2 + * to be precisely -0.5 so that multiplying by it is exact, and plain + * rounding of the coefficients of a good polynomial approximation only + * gives this up to about 64-bit precision. Plain rounding also gives + * a mediocre approximation for the coefficient of x^4, but a rounding + * error of 0.5 ulps for this coefficient would only contribute ~0.01 + * ulps to the final error, so this is unimportant. Rounding errors in + * higher coefficients are even less important. + * + * In fact, coefficients above the x^4 one only need to have 53-bit + * precision, and this is more efficient. We get this optimization + * almost for free from the complications needed to search for the best + * higher coefficients. + */ +static const long double C1 = 0.0416666666666666666136L; /* 0xaaaaaaaaaaaaaa9b.0p-68 + */ +static const double C2 = -0.0013888888888888874, /* -0x16c16c16c16c10.0p-62 */ + C3 = 0.000024801587301571716, /* 0x1a01a01a018e22.0p-68 */ + C4 = -0.00000027557319215507120, /* -0x127e4fb7602f22.0p-74 */ + C5 = 0.0000000020876754400407278, /* 0x11eed8caaeccf1.0p-81 */ + C6 = -1.1470297442401303e-11, /* -0x19393412bd1529.0p-89 */ + C7 = 4.7383039476436467e-14; /* 0x1aac9d9af5c43e.0p-97 */ +#define POLY(z) \ + (z * \ + (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * (C6 + z * C7))))))) +#elif LDBL_MANT_DIG == 113 +/* + * ld128 version of __cos.c. See __cos.c for most comments. + */ +/* + * Domain [-0.7854, 0.7854], range ~[-1.80e-37, 1.79e-37]: + * |cos(x) - c(x))| < 2**-122.0 + * + * 113-bit precision requires more care than 64-bit precision, since + * simple methods give a minimax polynomial with coefficient for x^2 + * that is 1 ulp below 0.5, but we want it to be precisely 0.5. See + * above for more details. + */ +static const long double C1 = 0.04166666666666666666666666666666658424671L, + C2 = -0.001388888888888888888888888888863490893732L, + C3 = 0.00002480158730158730158730158600795304914210L, + C4 = -0.2755731922398589065255474947078934284324e-6L, + C5 = 0.2087675698786809897659225313136400793948e-8L, + C6 = -0.1147074559772972315817149986812031204775e-10L, + C7 = 0.4779477332386808976875457937252120293400e-13L; +static const double C8 = -0.1561920696721507929516718307820958119868e-15, + C9 = 0.4110317413744594971475941557607804508039e-18, + C10 = -0.8896592467191938803288521958313920156409e-21, + C11 = 0.1601061435794535138244346256065192782581e-23; +#define POLY(z) \ + (z * \ + (C1 + \ + z * (C2 + \ + z * (C3 + \ + z * (C4 + \ + z * (C5 + \ + z * (C6 + \ + z * (C7 + \ + z * (C8 + \ + z * (C9 + z * (C10 + \ + z * C11))))))))))) +#endif + +long double __cosl(long double x, long double y) +{ + long double hz, z, r, w; + + z = x * x; + r = POLY(z); + hz = 0.5 * z; + w = 1.0 - hz; + return w + (((1.0 - w) - hz) + (z * r - x * y)); +} +#endif diff --git a/lib/libm/__expo2.c b/lib/libm/__expo2.c new file mode 100644 index 00000000..0d025457 --- /dev/null +++ b/lib/libm/__expo2.c @@ -0,0 +1,19 @@ +#include "libm.h" + +/* k is such that k*ln2 has minimal relative error and x - kln2 > log(DBL_MIN) + */ +static const int k = 2043; +static const double kln2 = 0x1.62066151add8bp+10; + +/* exp(x)/2 for x >= log(DBL_MAX), slightly better than 0.5*exp(x/2)*exp(x/2) */ +double __expo2(double x, double sign) +{ + double scale; + + /* note that k is odd and scale*scale overflows */ + INSERT_WORDS(scale, (uint32_t)(0x3ff + k / 2) << 20, 0); + /* exp(x - k ln2) * 2**(k-1) */ + /* in directed rounding correct sign before rounding or overflow is + * important */ + return exp(x - kln2) * (sign * scale) * scale; +} diff --git a/lib/libm/__expo2f.c b/lib/libm/__expo2f.c new file mode 100644 index 00000000..524be700 --- /dev/null +++ b/lib/libm/__expo2f.c @@ -0,0 +1,20 @@ +#include "libm.h" + +/* k is such that k*ln2 has minimal relative error and x - kln2 > log(FLT_MIN) + */ +static const int k = 235; +static const float kln2 = 0x1.45c778p+7f; + +/* expf(x)/2 for x >= log(FLT_MAX), slightly better than + * 0.5f*expf(x/2)*expf(x/2) */ +float __expo2f(float x, float sign) +{ + float scale; + + /* note that k is odd and scale*scale overflows */ + SET_FLOAT_WORD(scale, (uint32_t)(0x7f + k / 2) << 23); + /* exp(x - k ln2) * 2**(k-1) */ + /* in directed rounding correct sign before rounding or overflow is + * important */ + return expf(x - kln2) * (sign * scale) * scale; +} diff --git a/lib/libm/__fpclassify.c b/lib/libm/__fpclassify.c new file mode 100644 index 00000000..41332adf --- /dev/null +++ b/lib/libm/__fpclassify.c @@ -0,0 +1,16 @@ +#include <math.h> +#include <stdint.h> + +int __fpclassify(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + int e = u.i >> 52 & 0x7ff; + if (!e) + return u.i << 1 ? FP_SUBNORMAL : FP_ZERO; + if (e == 0x7ff) + return u.i << 12 ? FP_NAN : FP_INFINITE; + return FP_NORMAL; +} diff --git a/lib/libm/__fpclassifyf.c b/lib/libm/__fpclassifyf.c new file mode 100644 index 00000000..c8fc7585 --- /dev/null +++ b/lib/libm/__fpclassifyf.c @@ -0,0 +1,16 @@ +#include <math.h> +#include <stdint.h> + +int __fpclassifyf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + int e = u.i >> 23 & 0xff; + if (!e) + return u.i << 1 ? FP_SUBNORMAL : FP_ZERO; + if (e == 0xff) + return u.i << 9 ? FP_NAN : FP_INFINITE; + return FP_NORMAL; +} diff --git a/lib/libm/__fpclassifyl.c b/lib/libm/__fpclassifyl.c new file mode 100644 index 00000000..2c293803 --- /dev/null +++ b/lib/libm/__fpclassifyl.c @@ -0,0 +1,42 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +int __fpclassifyl(long double x) +{ + return __fpclassify(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +int __fpclassifyl(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + int msb = u.i.m >> 63; + if (!e && !msb) + return u.i.m ? FP_SUBNORMAL : FP_ZERO; + if (e == 0x7fff) { + /* The x86 variant of 80-bit extended precision only admits + * one representation of each infinity, with the mantissa msb + * necessarily set. The version with it clear is invalid/nan. + * The m68k variant, however, allows either, and tooling uses + * the version with it clear. */ + if (__BYTE_ORDER == __LITTLE_ENDIAN && !msb) + return FP_NAN; + return u.i.m << 1 ? FP_NAN : FP_INFINITE; + } + if (!msb) + return FP_NAN; + return FP_NORMAL; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +int __fpclassifyl(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + u.i.se = 0; + if (!e) + return u.i2.lo | u.i2.hi ? FP_SUBNORMAL : FP_ZERO; + if (e == 0x7fff) + return u.i2.lo | u.i2.hi ? FP_NAN : FP_INFINITE; + return FP_NORMAL; +} +#endif diff --git a/lib/libm/__invtrigl.c b/lib/libm/__invtrigl.c new file mode 100644 index 00000000..66e4c7eb --- /dev/null +++ b/lib/libm/__invtrigl.c @@ -0,0 +1,78 @@ +#include <float.h> +#include "__invtrigl.h" + +#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +static const long double pS0 = 1.66666666666666666631e-01L, + pS1 = -4.16313987993683104320e-01L, + pS2 = 3.69068046323246813704e-01L, + pS3 = -1.36213932016738603108e-01L, + pS4 = 1.78324189708471965733e-02L, + pS5 = -2.19216428382605211588e-04L, + pS6 = -7.10526623669075243183e-06L, + qS1 = -2.94788392796209867269e+00L, + qS2 = 3.27309890266528636716e+00L, + qS3 = -1.68285799854822427013e+00L, + qS4 = 3.90699412641738801874e-01L, + qS5 = -3.14365703596053263322e-02L; + +const long double pio2_hi = 1.57079632679489661926L; +const long double pio2_lo = -2.50827880633416601173e-20L; + +/* used in asinl() and acosl() */ +/* R(x^2) is a rational approximation of (asin(x)-x)/x^3 with Remez algorithm */ +long double __invtrigl_R(long double z) +{ + long double p, q; + p = z * (pS0 + + z * (pS1 + + z * (pS2 + z * (pS3 + z * (pS4 + z * (pS5 + z * pS6)))))); + q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * (qS4 + z * qS5)))); + return p / q; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +static const long double pS0 = 1.66666666666666666666666666666700314e-01L, + pS1 = -7.32816946414566252574527475428622708e-01L, + pS2 = 1.34215708714992334609030036562143589e+00L, + pS3 = -1.32483151677116409805070261790752040e+00L, + pS4 = 7.61206183613632558824485341162121989e-01L, + pS5 = -2.56165783329023486777386833928147375e-01L, + pS6 = 4.80718586374448793411019434585413855e-02L, + pS7 = -4.42523267167024279410230886239774718e-03L, + pS8 = 1.44551535183911458253205638280410064e-04L, + pS9 = -2.10558957916600254061591040482706179e-07L, + qS1 = -4.84690167848739751544716485245697428e+00L, + qS2 = 9.96619113536172610135016921140206980e+00L, + qS3 = -1.13177895428973036660836798461641458e+01L, + qS4 = 7.74004374389488266169304117714658761e+00L, + qS5 = -3.25871986053534084709023539900339905e+00L, + qS6 = 8.27830318881232209752469022352928864e-01L, + qS7 = -1.18768052702942805423330715206348004e-01L, + qS8 = 8.32600764660522313269101537926539470e-03L, + qS9 = -1.99407384882605586705979504567947007e-04L; + +const long double pio2_hi = 1.57079632679489661923132169163975140L; +const long double pio2_lo = 4.33590506506189051239852201302167613e-35L; + +long double __invtrigl_R(long double z) +{ + long double p, q; + p = z * (pS0 + + z * (pS1 + + z * (pS2 + + z * (pS3 + + z * (pS4 + + z * (pS5 + + z * (pS6 + + z * (pS7 + + z * (pS8 + z * pS9))))))))); + q = 1.0 + + z * (qS1 + + z * (qS2 + + z * (qS3 + + z * (qS4 + + z * (qS5 + + z * (qS6 + + z * (qS7 + z * (qS8 + z * qS9)))))))); + return p / q; +} +#endif diff --git a/lib/libm/__invtrigl.h b/lib/libm/__invtrigl.h new file mode 100644 index 00000000..17f4e3d0 --- /dev/null +++ b/lib/libm/__invtrigl.h @@ -0,0 +1,8 @@ +#define hidden __attribute__((visibility("hidden"))) + +/* shared by acosl, asinl and atan2l */ +#define pio2_hi __pio2_hi +#define pio2_lo __pio2_lo +hidden extern const long double pio2_hi, pio2_lo; + +hidden long double __invtrigl_R(long double z); diff --git a/lib/libm/__math_divzero.c b/lib/libm/__math_divzero.c new file mode 100644 index 00000000..59d21350 --- /dev/null +++ b/lib/libm/__math_divzero.c @@ -0,0 +1,6 @@ +#include "libm.h" + +double __math_divzero(uint32_t sign) +{ + return fp_barrier(sign ? -1.0 : 1.0) / 0.0; +} diff --git a/lib/libm/__math_divzerof.c b/lib/libm/__math_divzerof.c new file mode 100644 index 00000000..ce046f3e --- /dev/null +++ b/lib/libm/__math_divzerof.c @@ -0,0 +1,6 @@ +#include "libm.h" + +float __math_divzerof(uint32_t sign) +{ + return fp_barrierf(sign ? -1.0f : 1.0f) / 0.0f; +} diff --git a/lib/libm/__math_invalid.c b/lib/libm/__math_invalid.c new file mode 100644 index 00000000..17740490 --- /dev/null +++ b/lib/libm/__math_invalid.c @@ -0,0 +1,6 @@ +#include "libm.h" + +double __math_invalid(double x) +{ + return (x - x) / (x - x); +} diff --git a/lib/libm/__math_invalidf.c b/lib/libm/__math_invalidf.c new file mode 100644 index 00000000..357d4b12 --- /dev/null +++ b/lib/libm/__math_invalidf.c @@ -0,0 +1,6 @@ +#include "libm.h" + +float __math_invalidf(float x) +{ + return (x - x) / (x - x); +} diff --git a/lib/libm/__math_invalidl.c b/lib/libm/__math_invalidl.c new file mode 100644 index 00000000..1fca99de --- /dev/null +++ b/lib/libm/__math_invalidl.c @@ -0,0 +1,9 @@ +#include <float.h> +#include "libm.h" + +#if LDBL_MANT_DIG != DBL_MANT_DIG +long double __math_invalidl(long double x) +{ + return (x - x) / (x - x); +} +#endif diff --git a/lib/libm/__math_oflow.c b/lib/libm/__math_oflow.c new file mode 100644 index 00000000..c85dbf98 --- /dev/null +++ b/lib/libm/__math_oflow.c @@ -0,0 +1,6 @@ +#include "libm.h" + +double __math_oflow(uint32_t sign) +{ + return __math_xflow(sign, 0x1p769); +} diff --git a/lib/libm/__math_oflowf.c b/lib/libm/__math_oflowf.c new file mode 100644 index 00000000..fa7d0620 --- /dev/null +++ b/lib/libm/__math_oflowf.c @@ -0,0 +1,6 @@ +#include "libm.h" + +float __math_oflowf(uint32_t sign) +{ + return __math_xflowf(sign, 0x1p97f); +} diff --git a/lib/libm/__math_uflow.c b/lib/libm/__math_uflow.c new file mode 100644 index 00000000..b90594ae --- /dev/null +++ b/lib/libm/__math_uflow.c @@ -0,0 +1,6 @@ +#include "libm.h" + +double __math_uflow(uint32_t sign) +{ + return __math_xflow(sign, 0x1p-767); +} diff --git a/lib/libm/__math_uflowf.c b/lib/libm/__math_uflowf.c new file mode 100644 index 00000000..94d50f2b --- /dev/null +++ b/lib/libm/__math_uflowf.c @@ -0,0 +1,6 @@ +#include "libm.h" + +float __math_uflowf(uint32_t sign) +{ + return __math_xflowf(sign, 0x1p-95f); +} diff --git a/lib/libm/__math_xflow.c b/lib/libm/__math_xflow.c new file mode 100644 index 00000000..744203c4 --- /dev/null +++ b/lib/libm/__math_xflow.c @@ -0,0 +1,6 @@ +#include "libm.h" + +double __math_xflow(uint32_t sign, double y) +{ + return eval_as_double(fp_barrier(sign ? -y : y) * y); +} diff --git a/lib/libm/__math_xflowf.c b/lib/libm/__math_xflowf.c new file mode 100644 index 00000000..f2c84784 --- /dev/null +++ b/lib/libm/__math_xflowf.c @@ -0,0 +1,6 @@ +#include "libm.h" + +float __math_xflowf(uint32_t sign, float y) +{ + return eval_as_float(fp_barrierf(sign ? -y : y) * y); +} diff --git a/lib/libm/__polevll.c b/lib/libm/__polevll.c new file mode 100644 index 00000000..ce1a8404 --- /dev/null +++ b/lib/libm/__polevll.c @@ -0,0 +1,93 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/polevll.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Evaluate polynomial + * + * + * SYNOPSIS: + * + * int N; + * long double x, y, coef[N+1], polevl[]; + * + * y = polevll( x, coef, N ); + * + * + * DESCRIPTION: + * + * Evaluates polynomial of degree N: + * + * 2 N + * y = C + C x + C x +...+ C x + * 0 1 2 N + * + * Coefficients are stored in reverse order: + * + * coef[0] = C , ..., coef[N] = C . + * N 0 + * + * The function p1evll() assumes that coef[N] = 1.0 and is + * omitted from the array. Its calling arguments are + * otherwise the same as polevll(). + * + * + * SPEED: + * + * In the interest of speed, there are no checks for out + * of bounds arithmetic. This routine is used by most of + * the functions in the library. Depending on available + * equipment features, the user may wish to rewrite the + * program in microcode or assembly language. + * + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +#else +/* + * Polynomial evaluator: + * P[0] x^n + P[1] x^(n-1) + ... + P[n] + */ +long double __polevll(long double x, const long double *P, int n) +{ + long double y; + + y = *P++; + do { + y = y * x + *P++; + } while (--n); + + return y; +} + +/* + * Polynomial evaluator: + * x^n + P[0] x^(n-1) + P[1] x^(n-2) + ... + P[n] + */ +long double __p1evll(long double x, const long double *P, int n) +{ + long double y; + + n -= 1; + y = x + *P++; + do { + y = y * x + *P++; + } while (--n); + + return y; +} +#endif diff --git a/lib/libm/__rem_pio2.c b/lib/libm/__rem_pio2.c new file mode 100644 index 00000000..d01bc23b --- /dev/null +++ b/lib/libm/__rem_pio2.c @@ -0,0 +1,193 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_rem_pio2.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + * Optimized by Bruce D. Evans. + */ +/* __rem_pio2(x,y) + * + * return the remainder of x rem pi/2 in y[0]+y[1] + * use __rem_pio2_large() for large x + */ + +#include "libm.h" + +#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif + +/* + * invpio2: 53 bits of 2/pi + * pio2_1: first 33 bit of pi/2 + * pio2_1t: pi/2 - pio2_1 + * pio2_2: second 33 bit of pi/2 + * pio2_2t: pi/2 - (pio2_1+pio2_2) + * pio2_3: third 33 bit of pi/2 + * pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3) + */ +static const double toint = 1.5 / EPS, pio4 = 0x1.921fb54442d18p-1, + invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, + 0x6DC9C883 */ + pio2_1 = 1.57079632673412561417e+00, /* 0x3FF921FB, 0x54400000 */ + pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */ + pio2_2 = 6.07710050630396597660e-11, /* 0x3DD0B461, 0x1A600000 */ + pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */ + pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */ + pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */ + +/* caller must handle the case when reduction is not needed: |x| ~<= pi/4 */ +int __rem_pio2(double x, double *y) +{ + union { + double f; + uint64_t i; + } u = { x }; + double_t z, w, t, r, fn; + double tx[3], ty[2]; + uint32_t ix; + int sign, n, ex, ey, i; + + sign = u.i >> 63; + ix = u.i >> 32 & 0x7fffffff; + if (ix <= 0x400f6a7a) { /* |x| ~<= 5pi/4 */ + if ((ix & 0xfffff) == 0x921fb) /* |x| ~= pi/2 or 2pi/2 */ + goto medium; /* cancellation -- use medium case */ + if (ix <= 0x4002d97c) { /* |x| ~<= 3pi/4 */ + if (!sign) { + z = x - pio2_1; /* one round good to 85 bits */ + y[0] = z - pio2_1t; + y[1] = (z - y[0]) - pio2_1t; + return 1; + } else { + z = x + pio2_1; + y[0] = z + pio2_1t; + y[1] = (z - y[0]) + pio2_1t; + return -1; + } + } else { + if (!sign) { + z = x - 2 * pio2_1; + y[0] = z - 2 * pio2_1t; + y[1] = (z - y[0]) - 2 * pio2_1t; + return 2; + } else { + z = x + 2 * pio2_1; + y[0] = z + 2 * pio2_1t; + y[1] = (z - y[0]) + 2 * pio2_1t; + return -2; + } + } + } + if (ix <= 0x401c463b) { /* |x| ~<= 9pi/4 */ + if (ix <= 0x4015fdbc) { /* |x| ~<= 7pi/4 */ + if (ix == 0x4012d97c) /* |x| ~= 3pi/2 */ + goto medium; + if (!sign) { + z = x - 3 * pio2_1; + y[0] = z - 3 * pio2_1t; + y[1] = (z - y[0]) - 3 * pio2_1t; + return 3; + } else { + z = x + 3 * pio2_1; + y[0] = z + 3 * pio2_1t; + y[1] = (z - y[0]) + 3 * pio2_1t; + return -3; + } + } else { + if (ix == 0x401921fb) /* |x| ~= 4pi/2 */ + goto medium; + if (!sign) { + z = x - 4 * pio2_1; + y[0] = z - 4 * pio2_1t; + y[1] = (z - y[0]) - 4 * pio2_1t; + return 4; + } else { + z = x + 4 * pio2_1; + y[0] = z + 4 * pio2_1t; + y[1] = (z - y[0]) + 4 * pio2_1t; + return -4; + } + } + } + if (ix < 0x413921fb) { /* |x| ~< 2^20*(pi/2), medium size */ +medium: + /* rint(x/(pi/2)) */ + fn = (double_t)x * invpio2 + toint - toint; + n = (int32_t)fn; + r = x - fn * pio2_1; + w = fn * pio2_1t; /* 1st round, good to 85 bits */ + /* Matters with directed rounding. */ + if (predict_false(r - w < -pio4)) { + n--; + fn--; + r = x - fn * pio2_1; + w = fn * pio2_1t; + } else if (predict_false(r - w > pio4)) { + n++; + fn++; + r = x - fn * pio2_1; + w = fn * pio2_1t; + } + y[0] = r - w; + u.f = y[0]; + ey = u.i >> 52 & 0x7ff; + ex = ix >> 20; + if (ex - ey > 16) { /* 2nd round, good to 118 bits */ + t = r; + w = fn * pio2_2; + r = t - w; + w = fn * pio2_2t - ((t - r) - w); + y[0] = r - w; + u.f = y[0]; + ey = u.i >> 52 & 0x7ff; + if (ex - ey > 49) { /* 3rd round, good to 151 bits, + covers all cases */ + t = r; + w = fn * pio2_3; + r = t - w; + w = fn * pio2_3t - ((t - r) - w); + y[0] = r - w; + } + } + y[1] = (r - y[0]) - w; + return n; + } + /* + * all other (large) arguments + */ + if (ix >= 0x7ff00000) { /* x is inf or NaN */ + y[0] = y[1] = x - x; + return 0; + } + /* set z = scalbn(|x|,-ilogb(x)+23) */ + u.f = x; + u.i &= (uint64_t)-1 >> 12; + u.i |= (uint64_t)(0x3ff + 23) << 52; + z = u.f; + for (i = 0; i < 2; i++) { + tx[i] = (double)(int32_t)z; + z = (z - tx[i]) * 0x1p24; + } + tx[i] = z; + /* skip zero terms, first term is non-zero */ + while (tx[i] == 0.0) + i--; + n = __rem_pio2_large(tx, ty, (int)(ix >> 20) - (0x3ff + 23), i + 1, 1); + if (sign) { + y[0] = -ty[0]; + y[1] = -ty[1]; + return -n; + } + y[0] = ty[0]; + y[1] = ty[1]; + return n; +} diff --git a/lib/libm/__rem_pio2_large.c b/lib/libm/__rem_pio2_large.c new file mode 100644 index 00000000..58defa09 --- /dev/null +++ b/lib/libm/__rem_pio2_large.c @@ -0,0 +1,442 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/k_rem_pio2.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * __rem_pio2_large(x,y,e0,nx,prec) + * double x[],y[]; int e0,nx,prec; + * + * __rem_pio2_large return the last three digits of N with + * y = x - N*pi/2 + * so that |y| < pi/2. + * + * The method is to compute the integer (mod 8) and fraction parts of + * (2/pi)*x without doing the full multiplication. In general we + * skip the part of the product that are known to be a huge integer ( + * more accurately, = 0 mod 8 ). Thus the number of operations are + * independent of the exponent of the input. + * + * (2/pi) is represented by an array of 24-bit integers in ipio2[]. + * + * Input parameters: + * x[] The input value (must be positive) is broken into nx + * pieces of 24-bit integers in double precision format. + * x[i] will be the i-th 24 bit of x. The scaled exponent + * of x[0] is given in input parameter e0 (i.e., x[0]*2^e0 + * match x's up to 24 bits. + * + * Example of breaking a double positive z into x[0]+x[1]+x[2]: + * e0 = ilogb(z)-23 + * z = scalbn(z,-e0) + * for i = 0,1,2 + * x[i] = floor(z) + * z = (z-x[i])*2**24 + * + * + * y[] ouput result in an array of double precision numbers. + * The dimension of y[] is: + * 24-bit precision 1 + * 53-bit precision 2 + * 64-bit precision 2 + * 113-bit precision 3 + * The actual value is the sum of them. Thus for 113-bit + * precison, one may have to do something like: + * + * long double t,w,r_head, r_tail; + * t = (long double)y[2] + (long double)y[1]; + * w = (long double)y[0]; + * r_head = t+w; + * r_tail = w - (r_head - t); + * + * e0 The exponent of x[0]. Must be <= 16360 or you need to + * expand the ipio2 table. + * + * nx dimension of x[] + * + * prec an integer indicating the precision: + * 0 24 bits (single) + * 1 53 bits (double) + * 2 64 bits (extended) + * 3 113 bits (quad) + * + * External function: + * double scalbn(), floor(); + * + * + * Here is the description of some local variables: + * + * jk jk+1 is the initial number of terms of ipio2[] needed + * in the computation. The minimum and recommended value + * for jk is 3,4,4,6 for single, double, extended, and quad. + * jk+1 must be 2 larger than you might expect so that our + * recomputation test works. (Up to 24 bits in the integer + * part (the 24 bits of it that we compute) and 23 bits in + * the fraction part may be lost to cancelation before we + * recompute.) + * + * jz local integer variable indicating the number of + * terms of ipio2[] used. + * + * jx nx - 1 + * + * jv index for pointing to the suitable ipio2[] for the + * computation. In general, we want + * ( 2^e0*x[0] * ipio2[jv-1]*2^(-24jv) )/8 + * is an integer. Thus + * e0-3-24*jv >= 0 or (e0-3)/24 >= jv + * Hence jv = max(0,(e0-3)/24). + * + * jp jp+1 is the number of terms in PIo2[] needed, jp = jk. + * + * q[] double array with integral value, representing the + * 24-bits chunk of the product of x and 2/pi. + * + * q0 the corresponding exponent of q[0]. Note that the + * exponent for q[i] would be q0-24*i. + * + * PIo2[] double precision array, obtained by cutting pi/2 + * into 24 bits chunks. + * + * f[] ipio2[] in floating point + * + * iq[] integer array by breaking up q[] in 24-bits chunk. + * + * fq[] final product of x*(2/pi) in fq[0],..,fq[jk] + * + * ih integer. If >0 it indicates q[] is >= 0.5, hence + * it also indicates the *sign* of the result. + * + */ +/* + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "libm.h" + +static const int init_jk[] = { 3, 4, 4, 6 }; /* initial value for jk */ + +/* + * Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi + * + * integer array, contains the (24*i)-th to (24*i+23)-th + * bit of 2/pi after binary point. The corresponding + * floating value is + * + * ipio2[i] * 2^(-24(i+1)). + * + * NB: This table must have at least (e0-3)/24 + jk terms. + * For quad precision (e0 <= 16360, jk = 6), this is 686. + */ +static const int32_t ipio2[] = { + 0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, 0x95993C, + 0x439041, 0xFE5163, 0xABDEBB, 0xC561B7, 0x246E3A, 0x424DD2, 0xE00649, + 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129, 0xA73EE8, 0x8235F5, 0x2EBB44, + 0x84E99C, 0x7026B4, 0x5F7E41, 0x3991D6, 0x398353, 0x39F49C, 0x845F8B, + 0xBDF928, 0x3B1FF8, 0x97FFDE, 0x05980F, 0xEF2F11, 0x8B5A0A, 0x6D1F6D, + 0x367ECF, 0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D, 0x7527BA, 0xC7EBE5, + 0xF17B3D, 0x0739F7, 0x8A5292, 0xEA6BFB, 0x5FB11F, 0x8D5D08, 0x560330, + 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3, 0x91615E, 0xE61B08, + 0x659985, 0x5F14A0, 0x68408D, 0xFFD880, 0x4D7327, 0x310606, 0x1556CA, + 0x73A8C9, 0x60E27B, 0xC08C6B, + +#if LDBL_MAX_EXP > 1024 + 0x47C419, 0xC367CD, 0xDCE809, 0x2A8359, 0xC4768B, 0x961CA6, 0xDDAF44, + 0xD15719, 0x053EA5, 0xFF0705, 0x3F7E33, 0xE832C2, 0xDE4F98, 0x327DBB, + 0xC33D26, 0xEF6B1E, 0x5EF89F, 0x3A1F35, 0xCAF27F, 0x1D87F1, 0x21907C, + 0x7C246A, 0xFA6ED5, 0x772D30, 0x433B15, 0xC614B5, 0x9D19C3, 0xC2C4AD, + 0x414D2C, 0x5D000C, 0x467D86, 0x2D71E3, 0x9AC69B, 0x006233, 0x7CD2B4, + 0x97A7B4, 0xD55537, 0xF63ED7, 0x1810A3, 0xFC764D, 0x2A9D64, 0xABD770, + 0xF87C63, 0x57B07A, 0xE71517, 0x5649C0, 0xD9D63B, 0x3884A7, 0xCB2324, + 0x778AD6, 0x23545A, 0xB91F00, 0x1B0AF1, 0xDFCE19, 0xFF319F, 0x6A1E66, + 0x615799, 0x47FBAC, 0xD87F7E, 0xB76522, 0x89E832, 0x60BFE6, 0xCDC4EF, + 0x09366C, 0xD43F5D, 0xD7DE16, 0xDE3B58, 0x929BDE, 0x2822D2, 0xE88628, + 0x4D58E2, 0x32CAC6, 0x16E308, 0xCB7DE0, 0x50C017, 0xA71DF3, 0x5BE018, + 0x34132E, 0x621283, 0x014883, 0x5B8EF5, 0x7FB0AD, 0xF2E91E, 0x434A48, + 0xD36710, 0xD8DDAA, 0x425FAE, 0xCE616A, 0xA4280A, 0xB499D3, 0xF2A606, + 0x7F775C, 0x83C2A3, 0x883C61, 0x78738A, 0x5A8CAF, 0xBDD76F, 0x63A62D, + 0xCBBFF4, 0xEF818D, 0x67C126, 0x45CA55, 0x36D9CA, 0xD2A828, 0x8D61C2, + 0x77C912, 0x142604, 0x9B4612, 0xC459C4, 0x44C5C8, 0x91B24D, 0xF31700, + 0xAD43D4, 0xE54929, 0x10D5FD, 0xFCBE00, 0xCC941E, 0xEECE70, 0xF53E13, + 0x80F1EC, 0xC3E7B3, 0x28F8C7, 0x940593, 0x3E71C1, 0xB3092E, 0xF3450B, + 0x9C1288, 0x7B20AB, 0x9FB52E, 0xC29247, 0x2F327B, 0x6D550C, 0x90A772, + 0x1FE76B, 0x96CB31, 0x4A1679, 0xE27941, 0x89DFF4, 0x9794E8, 0x84E6E2, + 0x973199, 0x6BED88, 0x365F5F, 0x0EFDBB, 0xB49A48, 0x6CA467, 0x427271, + 0x325D8D, 0xB8159F, 0x09E5BC, 0x25318D, 0x3974F7, 0x1C0530, 0x010C0D, + 0x68084B, 0x58EE2C, 0x90AA47, 0x02E774, 0x24D6BD, 0xA67DF7, 0x72486E, + 0xEF169F, 0xA6948E, 0xF691B4, 0x5153D1, 0xF20ACF, 0x339820, 0x7E4BF5, + 0x6863B2, 0x5F3EDD, 0x035D40, 0x7F8985, 0x295255, 0xC06437, 0x10D86D, + 0x324832, 0x754C5B, 0xD4714E, 0x6E5445, 0xC1090B, 0x69F52A, 0xD56614, + 0x9D0727, 0x50045D, 0xDB3BB4, 0xC576EA, 0x17F987, 0x7D6B49, 0xBA271D, + 0x296996, 0xACCCC6, 0x5414AD, 0x6AE290, 0x89D988, 0x50722C, 0xBEA404, + 0x940777, 0x7030F3, 0x27FC00, 0xA871EA, 0x49C266, 0x3DE064, 0x83DD97, + 0x973FA3, 0xFD9443, 0x8C860D, 0xDE4131, 0x9D3992, 0x8C70DD, 0xE7B717, + 0x3BDF08, 0x2B3715, 0xA0805C, 0x93805A, 0x921110, 0xD8E80F, 0xAF806C, + 0x4BFFDB, 0x0F9038, 0x761859, 0x15A562, 0xBBCB61, 0xB989C7, 0xBD4010, + 0x04F2D2, 0x277549, 0xF6B6EB, 0xBB22DB, 0xAA140A, 0x2F2689, 0x768364, + 0x333B09, 0x1A940E, 0xAA3A51, 0xC2A31D, 0xAEEDAF, 0x12265C, 0x4DC26D, + 0x9C7A2D, 0x9756C0, 0x833F03, 0xF6F009, 0x8C402B, 0x99316D, 0x07B439, + 0x15200C, 0x5BC3D8, 0xC492F5, 0x4BADC6, 0xA5CA4E, 0xCD37A7, 0x36A9E6, + 0x9492AB, 0x6842DD, 0xDE6319, 0xEF8C76, 0x528B68, 0x37DBFC, 0xABA1AE, + 0x3115DF, 0xA1AE00, 0xDAFB0C, 0x664D64, 0xB705ED, 0x306529, 0xBF5657, + 0x3AFF47, 0xB9F96A, 0xF3BE75, 0xDF9328, 0x3080AB, 0xF68C66, 0x15CB04, + 0x0622FA, 0x1DE4D9, 0xA4B33D, 0x8F1B57, 0x09CD36, 0xE9424E, 0xA4BE13, + 0xB52333, 0x1AAAF0, 0xA8654F, 0xA5C1D2, 0x0F3F0B, 0xCD785B, 0x76F923, + 0x048B7B, 0x721789, 0x53A6C6, 0xE26E6F, 0x00EBEF, 0x584A9B, 0xB7DAC4, + 0xBA66AA, 0xCFCF76, 0x1D02D1, 0x2DF1B1, 0xC1998C, 0x77ADC3, 0xDA4886, + 0xA05DF7, 0xF480C6, 0x2FF0AC, 0x9AECDD, 0xBC5C3F, 0x6DDED0, 0x1FC790, + 0xB6DB2A, 0x3A25A3, 0x9AAF00, 0x9353AD, 0x0457B6, 0xB42D29, 0x7E804B, + 0xA707DA, 0x0EAA76, 0xA1597B, 0x2A1216, 0x2DB7DC, 0xFDE5FA, 0xFEDB89, + 0xFDBE89, 0x6C76E4, 0xFCA906, 0x70803E, 0x156E85, 0xFF87FD, 0x073E28, + 0x336761, 0x86182A, 0xEABD4D, 0xAFE7B3, 0x6E6D8F, 0x396795, 0x5BBF31, + 0x48D784, 0x16DF30, 0x432DC7, 0x356125, 0xCE70C9, 0xB8CB30, 0xFD6CBF, + 0xA200A4, 0xE46C05, 0xA0DD5A, 0x476F21, 0xD21262, 0x845CB9, 0x496170, + 0xE0566B, 0x015299, 0x375550, 0xB7D51E, 0xC4F133, 0x5F6E13, 0xE4305D, + 0xA92E85, 0xC3B21D, 0x3632A1, 0xA4B708, 0xD4B1EA, 0x21F716, 0xE4698F, + 0x77FF27, 0x80030C, 0x2D408D, 0xA0CD4F, 0x99A520, 0xD3A2B3, 0x0A5D2F, + 0x42F9B4, 0xCBDA11, 0xD0BE7D, 0xC1DB9B, 0xBD17AB, 0x81A2CA, 0x5C6A08, + 0x17552E, 0x550027, 0xF0147F, 0x8607E1, 0x640B14, 0x8D4196, 0xDEBE87, + 0x2AFDDA, 0xB6256B, 0x34897B, 0xFEF305, 0x9EBFB9, 0x4F6A68, 0xA82A4A, + 0x5AC44F, 0xBCF82D, 0x985AD7, 0x95C7F4, 0x8D4D0D, 0xA63A20, 0x5F57A4, + 0xB13F14, 0x953880, 0x0120CC, 0x86DD71, 0xB6DEC9, 0xF560BF, 0x11654D, + 0x6B0701, 0xACB08C, 0xD0C0B2, 0x485551, 0x0EFB1E, 0xC37295, 0x3B06A3, + 0x3540C0, 0x7BDC06, 0xCC45E0, 0xFA294E, 0xC8CAD6, 0x41F3E8, 0xDE647C, + 0xD8649B, 0x31BED9, 0xC397A4, 0xD45877, 0xC5E369, 0x13DAF0, 0x3C3ABA, + 0x461846, 0x5F7555, 0xF5BDD2, 0xC6926E, 0x5D2EAC, 0xED440E, 0x423E1C, + 0x87C461, 0xE9FD29, 0xF3D6E7, 0xCA7C22, 0x35916F, 0xC5E008, 0x8DD7FF, + 0xE26A6E, 0xC6FDB0, 0xC10893, 0x745D7C, 0xB2AD6B, 0x9D6ECD, 0x7B723E, + 0x6A11C6, 0xA9CFF7, 0xDF7329, 0xBAC9B5, 0x5100B7, 0x0DB2E2, 0x24BA74, + 0x607DE5, 0x8AD874, 0x2C150D, 0x0C1881, 0x94667E, 0x162901, 0x767A9F, + 0xBEFDFD, 0xEF4556, 0x367ED9, 0x13D9EC, 0xB9BA8B, 0xFC97C4, 0x27A831, + 0xC36EF1, 0x36C594, 0x56A8D8, 0xB5A8B4, 0x0ECCCF, 0x2D8912, 0x34576F, + 0x89562C, 0xE3CE99, 0xB920D6, 0xAA5E6B, 0x9C2A3E, 0xCC5F11, 0x4A0BFD, + 0xFBF4E1, 0x6D3B8E, 0x2C86E2, 0x84D4E9, 0xA9B4FC, 0xD1EEEF, 0xC9352E, + 0x61392F, 0x442138, 0xC8D91B, 0x0AFC81, 0x6A4AFB, 0xD81C2F, 0x84B453, + 0x8C994E, 0xCC2254, 0xDC552A, 0xD6C6C0, 0x96190B, 0xB8701A, 0x649569, + 0x605A26, 0xEE523F, 0x0F117F, 0x11B5F4, 0xF5CBFC, 0x2DBC34, 0xEEBC34, + 0xCC5DE8, 0x605EDD, 0x9B8E67, 0xEF3392, 0xB817C9, 0x9B5861, 0xBC57E1, + 0xC68351, 0x103ED8, 0x4871DD, 0xDD1C2D, 0xA118AF, 0x462C21, 0xD7F359, + 0x987AD9, 0xC0549E, 0xFA864F, 0xFC0656, 0xAE79E5, 0x362289, 0x22AD38, + 0xDC9367, 0xAAE855, 0x382682, 0x9BE7CA, 0xA40D51, 0xB13399, 0x0ED7A9, + 0x480569, 0xF0B265, 0xA7887F, 0x974C88, 0x36D1F9, 0xB39221, 0x4A827B, + 0x21CF98, 0xDC9F40, 0x5547DC, 0x3A74E1, 0x42EB67, 0xDF9DFE, 0x5FD45E, + 0xA4677B, 0x7AACBA, 0xA2F655, 0x23882B, 0x55BA41, 0x086E59, 0x862A21, + 0x834739, 0xE6E389, 0xD49EE5, 0x40FB49, 0xE956FF, 0xCA0F1C, 0x8A59C5, + 0x2BFA94, 0xC5C1D3, 0xCFC50F, 0xAE5ADB, 0x86C547, 0x624385, 0x3B8621, + 0x94792C, 0x876110, 0x7B4C2A, 0x1A2C80, 0x12BF43, 0x902688, 0x893C78, + 0xE4C4A8, 0x7BDBE5, 0xC23AC4, 0xEAF426, 0x8A67F7, 0xBF920D, 0x2BA365, + 0xB1933D, 0x0B7CBD, 0xDC51A4, 0x63DD27, 0xDDE169, 0x19949A, 0x9529A8, + 0x28CE68, 0xB4ED09, 0x209F44, 0xCA984E, 0x638270, 0x237C7E, 0x32B90F, + 0x8EF5A7, 0xE75614, 0x08F121, 0x2A9DB5, 0x4D7E6F, 0x5119A5, 0xABF9B5, + 0xD6DF82, 0x61DD96, 0x023616, 0x9F3AC4, 0xA1A283, 0x6DED72, 0x7A8D39, + 0xA9B882, 0x5C326B, 0x5B2746, 0xED3400, 0x7700D2, 0x55F4FC, 0x4D5901, + 0x8071E0, +#endif +}; + +static const double PIo2[] = { + 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */ + 7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */ + 5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */ + 3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */ + 1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */ + 1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */ + 2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */ + 2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */ +}; + +int __rem_pio2_large(double *x, double *y, int e0, int nx, int prec) +{ + int32_t jz, jx, jv, jp, jk, carry, n, iq[20], i, j, k, m, q0, ih; + double z, fw, f[20], fq[20], q[20]; + + /* initialize jk*/ + jk = init_jk[prec]; + jp = jk; + + /* determine jx,jv,q0, note that 3>q0 */ + jx = nx - 1; + jv = (e0 - 3) / 24; + if (jv < 0) + jv = 0; + q0 = e0 - 24 * (jv + 1); + + /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */ + j = jv - jx; + m = jx + jk; + for (i = 0; i <= m; i++, j++) + f[i] = j < 0 ? 0.0 : (double)ipio2[j]; + + /* compute q[0],q[1],...q[jk] */ + for (i = 0; i <= jk; i++) { + for (j = 0, fw = 0.0; j <= jx; j++) + fw += x[j] * f[jx + i - j]; + q[i] = fw; + } + + jz = jk; +recompute: + /* distill q[] into iq[] reversingly */ + for (i = 0, j = jz, z = q[jz]; j > 0; i++, j--) { + fw = (double)(int32_t)(0x1p-24 * z); + iq[i] = (int32_t)(z - 0x1p24 * fw); + z = q[j - 1] + fw; + } + + /* compute n */ + z = scalbn(z, q0); /* actual value of z */ + z -= 8.0 * floor(z * 0.125); /* trim off integer >= 8 */ + n = (int32_t)z; + z -= (double)n; + ih = 0; + if (q0 > 0) { /* need iq[jz-1] to determine n */ + i = iq[jz - 1] >> (24 - q0); + n += i; + iq[jz - 1] -= i << (24 - q0); + ih = iq[jz - 1] >> (23 - q0); + } else if (q0 == 0) + ih = iq[jz - 1] >> 23; + else if (z >= 0.5) + ih = 2; + + if (ih > 0) { /* q > 0.5 */ + n += 1; + carry = 0; + for (i = 0; i < jz; i++) { /* compute 1-q */ + j = iq[i]; + if (carry == 0) { + if (j != 0) { + carry = 1; + iq[i] = 0x1000000 - j; + } + } else + iq[i] = 0xffffff - j; + } + if (q0 > 0) { /* rare case: chance is 1 in 12 */ + switch (q0) { + case 1: + iq[jz - 1] &= 0x7fffff; + break; + case 2: + iq[jz - 1] &= 0x3fffff; + break; + } + } + if (ih == 2) { + z = 1.0 - z; + if (carry != 0) + z -= scalbn(1.0, q0); + } + } + + /* check if recomputation is needed */ + if (z == 0.0) { + j = 0; + for (i = jz - 1; i >= jk; i--) + j |= iq[i]; + if (j == 0) { /* need recomputation */ + for (k = 1; iq[jk - k] == 0; k++) + ; /* k = no. of terms needed */ + + for (i = jz + 1; i <= jz + k; i++) { /* add q[jz+1] to + q[jz+k] */ + f[jx + i] = (double)ipio2[jv + i]; + for (j = 0, fw = 0.0; j <= jx; j++) + fw += x[j] * f[jx + i - j]; + q[i] = fw; + } + jz += k; + goto recompute; + } + } + + /* chop off zero terms */ + if (z == 0.0) { + jz -= 1; + q0 -= 24; + while (iq[jz] == 0) { + jz--; + q0 -= 24; + } + } else { /* break z into 24-bit if necessary */ + z = scalbn(z, -q0); + if (z >= 0x1p24) { + fw = (double)(int32_t)(0x1p-24 * z); + iq[jz] = (int32_t)(z - 0x1p24 * fw); + jz += 1; + q0 += 24; + iq[jz] = (int32_t)fw; + } else + iq[jz] = (int32_t)z; + } + + /* convert integer "bit" chunk to floating-point value */ + fw = scalbn(1.0, q0); + for (i = jz; i >= 0; i--) { + q[i] = fw * (double)iq[i]; + fw *= 0x1p-24; + } + + /* compute PIo2[0,...,jp]*q[jz,...,0] */ + for (i = jz; i >= 0; i--) { + for (fw = 0.0, k = 0; k <= jp && k <= jz - i; k++) + fw += PIo2[k] * q[i + k]; + fq[jz - i] = fw; + } + + /* compress fq[] into y[] */ + switch (prec) { + case 0: + fw = 0.0; + for (i = jz; i >= 0; i--) + fw += fq[i]; + y[0] = ih == 0 ? fw : -fw; + break; + case 1: + case 2: + fw = 0.0; + for (i = jz; i >= 0; i--) + fw += fq[i]; + // TODO: drop excess precision here once double_t is used + fw = (double)fw; + y[0] = ih == 0 ? fw : -fw; + fw = fq[0] - fw; + for (i = 1; i <= jz; i++) + fw += fq[i]; + y[1] = ih == 0 ? fw : -fw; + break; + case 3: /* painful */ + for (i = jz; i > 0; i--) { + fw = fq[i - 1] + fq[i]; + fq[i] += fq[i - 1] - fw; + fq[i - 1] = fw; + } + for (i = jz; i > 1; i--) { + fw = fq[i - 1] + fq[i]; + fq[i] += fq[i - 1] - fw; + fq[i - 1] = fw; + } + for (fw = 0.0, i = jz; i >= 2; i--) + fw += fq[i]; + if (ih == 0) { + y[0] = fq[0]; + y[1] = fq[1]; + y[2] = fw; + } else { + y[0] = -fq[0]; + y[1] = -fq[1]; + y[2] = -fw; + } + } + return n & 7; +} diff --git a/lib/libm/__rem_pio2f.c b/lib/libm/__rem_pio2f.c new file mode 100644 index 00000000..8d58b491 --- /dev/null +++ b/lib/libm/__rem_pio2f.c @@ -0,0 +1,88 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_rem_pio2f.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Debugged and optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* __rem_pio2f(x,y) + * + * return the remainder of x rem pi/2 in *y + * use double precision for everything except passing x + * use __rem_pio2_large() for large x + */ + +#include "libm.h" + +#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif + +/* + * invpio2: 53 bits of 2/pi + * pio2_1: first 25 bits of pi/2 + * pio2_1t: pi/2 - pio2_1 + */ +static const double toint = 1.5 / EPS, pio4 = 0x1.921fb6p-1, + invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, + 0x6DC9C883 */ + pio2_1 = 1.57079631090164184570e+00, /* 0x3FF921FB, 0x50000000 */ + pio2_1t = 1.58932547735281966916e-08; /* 0x3E5110b4, 0x611A6263 */ + +int __rem_pio2f(float x, double *y) +{ + union { + float f; + uint32_t i; + } u = { x }; + double tx[1], ty[1]; + double_t fn; + uint32_t ix; + int n, sign, e0; + + ix = u.i & 0x7fffffff; + /* 25+53 bit pi is good enough for medium size */ + if (ix < 0x4dc90fdb) { /* |x| ~< 2^28*(pi/2), medium size */ + /* Use a specialized rint() to get fn. */ + fn = (double_t)x * invpio2 + toint - toint; + n = (int32_t)fn; + *y = x - fn * pio2_1 - fn * pio2_1t; + /* Matters with directed rounding. */ + if (predict_false(*y < -pio4)) { + n--; + fn--; + *y = x - fn * pio2_1 - fn * pio2_1t; + } else if (predict_false(*y > pio4)) { + n++; + fn++; + *y = x - fn * pio2_1 - fn * pio2_1t; + } + return n; + } + if (ix >= 0x7f800000) { /* x is inf or NaN */ + *y = x - x; + return 0; + } + /* scale x into [2^23, 2^24-1] */ + sign = u.i >> 31; + e0 = (ix >> 23) - (0x7f + 23); /* e0 = ilogb(|x|)-23, positive */ + u.i = ix - (e0 << 23); + tx[0] = u.f; + n = __rem_pio2_large(tx, ty, e0, 1, 0); + if (sign) { + *y = -ty[0]; + return -n; + } + *y = ty[0]; + return n; +} diff --git a/lib/libm/__rem_pio2l.c b/lib/libm/__rem_pio2l.c new file mode 100644 index 00000000..6576ade1 --- /dev/null +++ b/lib/libm/__rem_pio2l.c @@ -0,0 +1,170 @@ +/* origin: FreeBSD /usr/src/lib/msun/ld80/e_rem_pio2.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * Copyright (c) 2008 Steven G. Kargl, David Schultz, Bruce D. Evans. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + * Optimized by Bruce D. Evans. + */ +#include "libm.h" +#if (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +/* ld80 and ld128 version of __rem_pio2(x,y) + * + * return the remainder of x rem pi/2 in y[0]+y[1] + * use __rem_pio2_large() for large x + */ + +static const long double toint = 1.5 / LDBL_EPSILON; + +#if LDBL_MANT_DIG == 64 +/* u ~< 0x1p25*pi/2 */ +#define SMALL(u) \ + (((u.i.se & 0x7fffU) << 16 | u.i.m >> 48) < \ + ((0x3fff + 25) << 16 | 0x921f >> 1 | 0x8000)) +#define QUOBITS(x) ((uint32_t)(int32_t)x & 0x7fffffff) +#define ROUND1 22 +#define ROUND2 61 +#define NX 3 +#define NY 2 +/* + * invpio2: 64 bits of 2/pi + * pio2_1: first 39 bits of pi/2 + * pio2_1t: pi/2 - pio2_1 + * pio2_2: second 39 bits of pi/2 + * pio2_2t: pi/2 - (pio2_1+pio2_2) + * pio2_3: third 39 bits of pi/2 + * pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3) + */ +static const double pio2_1 = 1.57079632679597125389e+00, /* 0x3FF921FB, + 0x54444000 */ + pio2_2 = -1.07463465549783099519e-12, /* -0x12e7b967674000.0p-92 */ + pio2_3 = 6.36831716351370313614e-25; /* 0x18a2e037074000.0p-133 */ +static const long double pio4 = 0x1.921fb54442d1846ap-1L, + invpio2 = 6.36619772367581343076e-01L, /* 0xa2f9836e4e44152a.0p-64 + */ + pio2_1t = -1.07463465549719416346e-12L, /* -0x973dcb3b399d747f.0p-103 */ + pio2_2t = 6.36831716351095013979e-25L, /* 0xc51701b839a25205.0p-144 */ + pio2_3t = -2.75299651904407171810e-37L; /* -0xbb5bf6c7ddd660ce.0p-185 */ +#elif LDBL_MANT_DIG == 113 +/* u ~< 0x1p45*pi/2 */ +#define SMALL(u) \ + (((u.i.se & 0x7fffU) << 16 | u.i.top) < ((0x3fff + 45) << 16 | 0x921f)) +#define QUOBITS(x) ((uint32_t)(int64_t)x & 0x7fffffff) +#define ROUND1 51 +#define ROUND2 119 +#define NX 5 +#define NY 3 +static const long double pio4 = 0x1.921fb54442d18469898cc51701b8p-1L, + invpio2 = + 6.3661977236758134307553505349005747e-01L, /* 0x145f306dc9c882a53f84eafa3ea6a.0p-113 + */ + pio2_1 = 1.5707963267948966192292994253909555e+00L, /* 0x1921fb54442d18469800000000000.0p-112 + */ + pio2_1t = 2.0222662487959507323996846200947577e-21L, /* 0x13198a2e03707344a4093822299f3.0p-181 + */ + pio2_2 = 2.0222662487959507323994779168837751e-21L, /* 0x13198a2e03707344a400000000000.0p-181 + */ + pio2_2t = 2.0670321098263988236496903051604844e-43L, /* 0x127044533e63a0105df531d89cd91.0p-254 + */ + pio2_3 = 2.0670321098263988236499468110329591e-43L, /* 0x127044533e63a0105e00000000000.0p-254 + */ + pio2_3t = -2.5650587247459238361625433492959285e-65L; /* -0x159c4ec64ddaeb5f78671cbfb2210.0p-327 + */ +#endif + +int __rem_pio2l(long double x, long double *y) +{ + union ldshape u, uz; + long double z, w, t, r, fn; + double tx[NX], ty[NY]; + int ex, ey, n, i; + + u.f = x; + ex = u.i.se & 0x7fff; + if (SMALL(u)) { + /* rint(x/(pi/2)) */ + fn = x * invpio2 + toint - toint; + n = QUOBITS(fn); + r = x - fn * pio2_1; + w = fn * pio2_1t; /* 1st round good to 102/180 bits (ld80/ld128) + */ + /* Matters with directed rounding. */ + if (predict_false(r - w < -pio4)) { + n--; + fn--; + r = x - fn * pio2_1; + w = fn * pio2_1t; + } else if (predict_false(r - w > pio4)) { + n++; + fn++; + r = x - fn * pio2_1; + w = fn * pio2_1t; + } + y[0] = r - w; + u.f = y[0]; + ey = u.i.se & 0x7fff; + if (ex - ey > ROUND1) { /* 2nd iteration needed, good to 141/248 + (ld80/ld128) */ + t = r; + w = fn * pio2_2; + r = t - w; + w = fn * pio2_2t - ((t - r) - w); + y[0] = r - w; + u.f = y[0]; + ey = u.i.se & 0x7fff; + if (ex - ey > ROUND2) { /* 3rd iteration, good to + 180/316 bits */ + t = r; /* will cover all possible cases (not + verified for ld128) */ + w = fn * pio2_3; + r = t - w; + w = fn * pio2_3t - ((t - r) - w); + y[0] = r - w; + } + } + y[1] = (r - y[0]) - w; + return n; + } + /* + * all other (large) arguments + */ + if (ex == 0x7fff) { /* x is inf or NaN */ + y[0] = y[1] = x - x; + return 0; + } + /* set z = scalbn(|x|,-ilogb(x)+23) */ + uz.f = x; + uz.i.se = 0x3fff + 23; + z = uz.f; + for (i = 0; i < NX - 1; i++) { + tx[i] = (double)(int32_t)z; + z = (z - tx[i]) * 0x1p24; + } + tx[i] = z; + while (tx[i] == 0) + i--; + n = __rem_pio2_large(tx, ty, ex - 0x3fff - 23, i + 1, NY); + w = ty[1]; + if (NY == 3) + w += ty[2]; + r = ty[0] + w; + /* TODO: for ld128 this does not follow the recommendation of the + comments of __rem_pio2_large which seem wrong if |ty[0]| > |ty[1]+ty[2]| + */ + w -= r - ty[0]; + if (u.i.se >> 15) { + y[0] = -r; + y[1] = -w; + return -n; + } + y[0] = r; + y[1] = w; + return n; +} +#endif diff --git a/lib/libm/__signbit.c b/lib/libm/__signbit.c new file mode 100644 index 00000000..5d145b63 --- /dev/null +++ b/lib/libm/__signbit.c @@ -0,0 +1,11 @@ +#include "libm.h" + +// FIXME: macro in math.h +int __signbit(double x) +{ + union { + double d; + uint64_t i; + } y = { x }; + return y.i >> 63; +} diff --git a/lib/libm/__signbitf.c b/lib/libm/__signbitf.c new file mode 100644 index 00000000..3e6c4466 --- /dev/null +++ b/lib/libm/__signbitf.c @@ -0,0 +1,11 @@ +#include "libm.h" + +// FIXME: macro in math.h +int __signbitf(float x) +{ + union { + float f; + uint32_t i; + } y = { x }; + return y.i >> 31; +} diff --git a/lib/libm/__signbitl.c b/lib/libm/__signbitl.c new file mode 100644 index 00000000..b66d419f --- /dev/null +++ b/lib/libm/__signbitl.c @@ -0,0 +1,14 @@ +#include "libm.h" + +#if (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +int __signbitl(long double x) +{ + union ldshape u = { x }; + return u.i.se >> 15; +} +#elif LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +int __signbitl(long double x) +{ + return __signbit(x); +} +#endif diff --git a/lib/libm/__sin.c b/lib/libm/__sin.c new file mode 100644 index 00000000..c8b8cad8 --- /dev/null +++ b/lib/libm/__sin.c @@ -0,0 +1,64 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/k_sin.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* __sin( x, y, iy) + * kernel sin function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input iy indicates whether y is 0. (if iy=0, y assume to be 0). + * + * Algorithm + * 1. Since sin(-x) = -sin(x), we need only to consider positive x. + * 2. Callers must return sin(-0) = -0 without calling here since our + * odd polynomial is not evaluated in a way that preserves -0. + * Callers may do the optimization sin(x) ~ x for tiny x. + * 3. sin(x) is approximated by a polynomial of degree 13 on + * [0,pi/4] + * 3 13 + * sin(x) ~ x + S1*x + ... + S6*x + * where + * + * |sin(x) 2 4 6 8 10 12 | -58 + * |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x +S6*x )| <= 2 + * | x | + * + * 4. sin(x+y) = sin(x) + sin'(x')*y + * ~ sin(x) + (1-x*x/2)*y + * For better accuracy, let + * 3 2 2 2 2 + * r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6)))) + * then 3 2 + * sin(x) = x + (S1*x + (x *(r-y/2)+y)) + */ + +#include "libm.h" + +static const double S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 + */ + S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */ + S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */ + S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */ + S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */ + S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */ + +double __sin(double x, double y, int iy) +{ + double_t z, r, v, w; + + z = x * x; + w = z * z; + r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6); + v = z * x; + if (iy == 0) + return x + v * (S1 + z * r); + else + return x - ((z * (0.5 * y - v * r) - y) - v * S1); +} diff --git a/lib/libm/__sindf.c b/lib/libm/__sindf.c new file mode 100644 index 00000000..cf16370d --- /dev/null +++ b/lib/libm/__sindf.c @@ -0,0 +1,35 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/k_sinf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +/* |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]). */ +static const double S1 = -0x15555554cbac77.0p-55, /* -0.166666666416265235595 */ + S2 = 0x111110896efbb2.0p-59, /* 0.0083333293858894631756 */ + S3 = -0x1a00f9e2cae774.0p-65, /* -0.000198393348360966317347 */ + S4 = 0x16cd878c3b46a7.0p-71; /* 0.0000027183114939898219064 */ + +float __sindf(double x) +{ + double_t r, s, w, z; + + /* Try to optimize for parallel evaluation as in __tandf.c. */ + z = x * x; + w = z * z; + r = S3 + z * S4; + s = z * x; + return (x + s * (S1 + z * S2)) + s * w * r; +} diff --git a/lib/libm/__sinl.c b/lib/libm/__sinl.c new file mode 100644 index 00000000..afd36211 --- /dev/null +++ b/lib/libm/__sinl.c @@ -0,0 +1,87 @@ +/* origin: FreeBSD /usr/src/lib/msun/ld80/k_sinl.c */ +/* origin: FreeBSD /usr/src/lib/msun/ld128/k_sinl.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * Copyright (c) 2008 Steven G. Kargl, David Schultz, Bruce D. Evans. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +#if (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#if LDBL_MANT_DIG == 64 +/* + * ld80 version of __sin.c. See __sin.c for most comments. + */ +/* + * Domain [-0.7854, 0.7854], range ~[-1.89e-22, 1.915e-22] + * |sin(x)/x - s(x)| < 2**-72.1 + * + * See __cosl.c for more details about the polynomial. + */ +static const long double S1 = -0.166666666666666666671L; /* -0xaaaaaaaaaaaaaaab.0p-66 + */ +static const double S2 = 0.0083333333333333332, /* 0x11111111111111.0p-59 */ + S3 = -0.00019841269841269427, /* -0x1a01a01a019f81.0p-65 */ + S4 = 0.0000027557319223597490, /* 0x171de3a55560f7.0p-71 */ + S5 = -0.000000025052108218074604, /* -0x1ae64564f16cad.0p-78 */ + S6 = 1.6059006598854211e-10, /* 0x161242b90243b5.0p-85 */ + S7 = -7.6429779983024564e-13, /* -0x1ae42ebd1b2e00.0p-93 */ + S8 = 2.6174587166648325e-15; /* 0x179372ea0b3f64.0p-101 */ +#define POLY(z) \ + (S2 + z * (S3 + z * (S4 + z * (S5 + z * (S6 + z * (S7 + z * S8)))))) +#elif LDBL_MANT_DIG == 113 +/* + * ld128 version of __sin.c. See __sin.c for most comments. + */ +/* + * Domain [-0.7854, 0.7854], range ~[-1.53e-37, 1.659e-37] + * |sin(x)/x - s(x)| < 2**-122.1 + * + * See __cosl.c for more details about the polynomial. + */ +static const long double + S1 = -0.16666666666666666666666666666666666606732416116558L, + S2 = 0.0083333333333333333333333333333331135404851288270047L, + S3 = -0.00019841269841269841269841269839935785325638310428717L, + S4 = 0.27557319223985890652557316053039946268333231205686e-5L, + S5 = -0.25052108385441718775048214826384312253862930064745e-7L, + S6 = 0.16059043836821614596571832194524392581082444805729e-9L, + S7 = -0.76471637318198151807063387954939213287488216303768e-12L, + S8 = 0.28114572543451292625024967174638477283187397621303e-14L; +static const double + S9 = -0.82206352458348947812512122163446202498005154296863e-17, + S10 = 0.19572940011906109418080609928334380560135358385256e-19, + S11 = -0.38680813379701966970673724299207480965452616911420e-22, + S12 = 0.64038150078671872796678569586315881020659912139412e-25; +#define POLY(z) \ + (S2 + \ + z * (S3 + \ + z * (S4 + \ + z * (S5 + \ + z * (S6 + \ + z * (S7 + \ + z * (S8 + \ + z * (S9 + \ + z * (S10 + \ + z * (S11 + z * S12)))))))))) +#endif + +long double __sinl(long double x, long double y, int iy) +{ + long double z, r, v; + + z = x * x; + v = z * x; + r = POLY(z); + if (iy == 0) + return x + v * (S1 + z * r); + return x - ((z * (0.5 * y - v * r) - y) - v * S1); +} +#endif diff --git a/lib/libm/__tan.c b/lib/libm/__tan.c new file mode 100644 index 00000000..9fd6c41a --- /dev/null +++ b/lib/libm/__tan.c @@ -0,0 +1,114 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/k_tan.c */ +/* + * ==================================================== + * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved. + * + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* __tan( x, y, k ) + * kernel tan function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input odd indicates whether tan (if odd = 0) or -1/tan (if odd = 1) is + * returned. + * + * Algorithm + * 1. Since tan(-x) = -tan(x), we need only to consider positive x. + * 2. Callers must return tan(-0) = -0 without calling here since our + * odd polynomial is not evaluated in a way that preserves -0. + * Callers may do the optimization tan(x) ~ x for tiny x. + * 3. tan(x) is approximated by a odd polynomial of degree 27 on + * [0,0.67434] + * 3 27 + * tan(x) ~ x + T1*x + ... + T13*x + * where + * + * |tan(x) 2 4 26 | -59.2 + * |----- - (1+T1*x +T2*x +.... +T13*x )| <= 2 + * | x | + * + * Note: tan(x+y) = tan(x) + tan'(x)*y + * ~ tan(x) + (1+x*x)*y + * Therefore, for better accuracy in computing tan(x+y), let + * 3 2 2 2 2 + * r = x *(T2+x *(T3+x *(...+x *(T12+x *T13)))) + * then + * 3 2 + * tan(x+y) = x + (T1*x + (x *(r+y)+y)) + * + * 4. For x in [0.67434,pi/4], let y = pi/4 - x, then + * tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y)) + * = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y))) + */ + +#include "libm.h" + +static const double T[] = { + 3.33333333333334091986e-01, /* 3FD55555, 55555563 */ + 1.33333333333201242699e-01, /* 3FC11111, 1110FE7A */ + 5.39682539762260521377e-02, /* 3FABA1BA, 1BB341FE */ + 2.18694882948595424599e-02, /* 3F9664F4, 8406D637 */ + 8.86323982359930005737e-03, /* 3F8226E3, E96E8493 */ + 3.59207910759131235356e-03, /* 3F6D6D22, C9560328 */ + 1.45620945432529025516e-03, /* 3F57DBC8, FEE08315 */ + 5.88041240820264096874e-04, /* 3F4344D8, F2F26501 */ + 2.46463134818469906812e-04, /* 3F3026F7, 1A8D1068 */ + 7.81794442939557092300e-05, /* 3F147E88, A03792A6 */ + 7.14072491382608190305e-05, /* 3F12B80F, 32F0A7E9 */ + -1.85586374855275456654e-05, /* BEF375CB, DB605373 */ + 2.59073051863633712884e-05, /* 3EFB2A70, 74BF7AD4 */ +}, +pio4 = 7.85398163397448278999e-01, /* 3FE921FB, 54442D18 */ +pio4lo = 3.06161699786838301793e-17; /* 3C81A626, 33145C07 */ + +double __tan(double x, double y, int odd) +{ + double_t z, r, v, w, s, a; + double w0, a0; + uint32_t hx; + int big, sign; + + GET_HIGH_WORD(hx, x); + big = (hx & 0x7fffffff) >= 0x3FE59428; /* |x| >= 0.6744 */ + if (big) { + sign = hx >> 31; + if (sign) { + x = -x; + y = -y; + } + x = (pio4 - x) + (pio4lo - y); + y = 0.0; + } + z = x * x; + w = z * z; + /* + * Break x^5*(T[1]+x^2*T[2]+...) into + * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) + + * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12])) + */ + r = T[1] + + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11])))); + v = z * + (T[2] + + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12]))))); + s = z * x; + r = y + z * (s * (r + v) + y) + s * T[0]; + w = x + r; + if (big) { + s = 1 - 2 * odd; + v = s - 2.0 * (x + (r - w * w / (w + s))); + return sign ? -v : v; + } + if (!odd) + return w; + /* -1.0/(x+r) has up to 2ulp error, so compute it accurately */ + w0 = w; + SET_LOW_WORD(w0, 0); + v = r - (w0 - x); /* w0+v = r+x */ + a0 = a = -1.0 / w; + SET_LOW_WORD(a0, 0); + return a0 + a * (1.0 + a0 * w0 + a0 * v); +} diff --git a/lib/libm/__tandf.c b/lib/libm/__tandf.c new file mode 100644 index 00000000..7219ed33 --- /dev/null +++ b/lib/libm/__tandf.c @@ -0,0 +1,54 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/k_tanf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved. + * + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +/* |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]). */ +static const double T[] = { + 0x15554d3418c99f.0p-54, /* 0.333331395030791399758 */ + 0x1112fd38999f72.0p-55, /* 0.133392002712976742718 */ + 0x1b54c91d865afe.0p-57, /* 0.0533812378445670393523 */ + 0x191df3908c33ce.0p-58, /* 0.0245283181166547278873 */ + 0x185dadfcecf44e.0p-61, /* 0.00297435743359967304927 */ + 0x1362b9bf971bcd.0p-59, /* 0.00946564784943673166728 */ +}; + +float __tandf(double x, int odd) +{ + double_t z, r, w, s, t, u; + + z = x * x; + /* + * Split up the polynomial into small independent terms to give + * opportunities for parallel evaluation. The chosen splitting is + * micro-optimized for Athlons (XP, X64). It costs 2 multiplications + * relative to Horner's method on sequential machines. + * + * We add the small terms from lowest degree up for efficiency on + * non-sequential machines (the lowest degree terms tend to be ready + * earlier). Apart from this, we don't care about order of + * operations, and don't need to to care since we have precision to + * spare. However, the chosen splitting is good for accuracy too, + * and would give results as accurate as Horner's method if the + * small terms were added from highest degree down. + */ + r = T[4] + z * T[5]; + t = T[2] + z * T[3]; + w = z * z; + s = z * x; + u = T[0] + z * T[1]; + r = (x + s * u) + (s * w) * (t + w * r); + return odd ? -1.0 / r : r; +} diff --git a/lib/libm/__tanl.c b/lib/libm/__tanl.c new file mode 100644 index 00000000..b279051f --- /dev/null +++ b/lib/libm/__tanl.c @@ -0,0 +1,169 @@ +/* origin: FreeBSD /usr/src/lib/msun/ld80/k_tanl.c */ +/* origin: FreeBSD /usr/src/lib/msun/ld128/k_tanl.c */ +/* + * ==================================================== + * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2008 Steven G. Kargl, David Schultz, Bruce D. Evans. + * + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +#if (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#if LDBL_MANT_DIG == 64 +/* + * ld80 version of __tan.c. See __tan.c for most comments. + */ +/* + * Domain [-0.67434, 0.67434], range ~[-2.25e-22, 1.921e-22] + * |tan(x)/x - t(x)| < 2**-71.9 + * + * See __cosl.c for more details about the polynomial. + */ +static const long double T3 = 0.333333333333333333180L, /* 0xaaaaaaaaaaaaaaa5.0p-65 + */ + T5 = 0.133333333333333372290L, /* 0x88888888888893c3.0p-66 */ + T7 = 0.0539682539682504975744L, /* 0xdd0dd0dd0dc13ba2.0p-68 */ + pio4 = 0.785398163397448309628L, /* 0xc90fdaa22168c235.0p-64 */ + pio4lo = -1.25413940316708300586e-20L; /* -0xece675d1fc8f8cbb.0p-130 */ +static const double T9 = 0.021869488536312216, /* 0x1664f4882cc1c2.0p-58 */ + T11 = 0.0088632355256619590, /* 0x1226e355c17612.0p-59 */ + T13 = 0.0035921281113786528, /* 0x1d6d3d185d7ff8.0p-61 */ + T15 = 0.0014558334756312418, /* 0x17da354aa3f96b.0p-62 */ + T17 = 0.00059003538700862256, /* 0x13559358685b83.0p-63 */ + T19 = 0.00023907843576635544, /* 0x1f56242026b5be.0p-65 */ + T21 = 0.000097154625656538905, /* 0x1977efc26806f4.0p-66 */ + T23 = 0.000038440165747303162, /* 0x14275a09b3ceac.0p-67 */ + T25 = 0.000018082171885432524, /* 0x12f5e563e5487e.0p-68 */ + T27 = 0.0000024196006108814377, /* 0x144c0d80cc6896.0p-71 */ + T29 = 0.0000078293456938132840, /* 0x106b59141a6cb3.0p-69 */ + T31 = -0.0000032609076735050182, /* -0x1b5abef3ba4b59.0p-71 */ + T33 = 0.0000023261313142559411; /* 0x13835436c0c87f.0p-71 */ +#define RPOLY(w) \ + (T5 + \ + w * (T9 + \ + w * (T13 + \ + w * (T17 + w * (T21 + w * (T25 + w * (T29 + w * T33))))))) +#define VPOLY(w) \ + (T7 + \ + w * (T11 + w * (T15 + w * (T19 + w * (T23 + w * (T27 + w * T31)))))) +#elif LDBL_MANT_DIG == 113 +/* + * ld128 version of __tan.c. See __tan.c for most comments. + */ +/* + * Domain [-0.67434, 0.67434], range ~[-3.37e-36, 1.982e-37] + * |tan(x)/x - t(x)| < 2**-117.8 (XXX should be ~1e-37) + * + * See __cosl.c for more details about the polynomial. + */ +static const long double T3 = 0x1.5555555555555555555555555553p-2L, + T5 = 0x1.1111111111111111111111111eb5p-3L, + T7 = 0x1.ba1ba1ba1ba1ba1ba1ba1b694cd6p-5L, + T9 = 0x1.664f4882c10f9f32d6bbe09d8bcdp-6L, + T11 = 0x1.226e355e6c23c8f5b4f5762322eep-7L, + T13 = 0x1.d6d3d0e157ddfb5fed8e84e27b37p-9L, + T15 = 0x1.7da36452b75e2b5fce9ee7c2c92ep-10L, + T17 = 0x1.355824803674477dfcf726649efep-11L, + T19 = 0x1.f57d7734d1656e0aceb716f614c2p-13L, + T21 = 0x1.967e18afcb180ed942dfdc518d6cp-14L, + T23 = 0x1.497d8eea21e95bc7e2aa79b9f2cdp-15L, + T25 = 0x1.0b132d39f055c81be49eff7afd50p-16L, + T27 = 0x1.b0f72d33eff7bfa2fbc1059d90b6p-18L, + T29 = 0x1.5ef2daf21d1113df38d0fbc00267p-19L, + T31 = 0x1.1c77d6eac0234988cdaa04c96626p-20L, + T33 = 0x1.cd2a5a292b180e0bdd701057dfe3p-22L, + T35 = 0x1.75c7357d0298c01a31d0a6f7d518p-23L, + T37 = 0x1.2f3190f4718a9a520f98f50081fcp-24L, + pio4 = 0x1.921fb54442d18469898cc51701b8p-1L, + pio4lo = 0x1.cd129024e088a67cc74020bbea60p-116L; +static const double T39 = 0.000000028443389121318352, /* 0x1e8a7592977938.0p-78 + */ + T41 = 0.000000011981013102001973, /* 0x19baa1b1223219.0p-79 */ + T43 = 0.0000000038303578044958070, /* 0x107385dfb24529.0p-80 */ + T45 = 0.0000000034664378216909893, /* 0x1dc6c702a05262.0p-81 */ + T47 = -0.0000000015090641701997785, /* -0x19ecef3569ebb6.0p-82 */ + T49 = 0.0000000029449552300483952, /* 0x194c0668da786a.0p-81 */ + T51 = -0.0000000022006995706097711, /* -0x12e763b8845268.0p-81 */ + T53 = 0.0000000015468200913196612, /* 0x1a92fc98c29554.0p-82 */ + T55 = -0.00000000061311613386849674, /* -0x151106cbc779a9.0p-83 */ + T57 = 1.4912469681508012e-10; /* 0x147edbdba6f43a.0p-85 */ +#define RPOLY(w) \ + (T5 + \ + w * (T9 + \ + w * (T13 + \ + w * (T17 + \ + w * (T21 + \ + w * (T25 + \ + w * (T29 + \ + w * (T33 + \ + w * (T37 + \ + w * (T41 + \ + w * (T45 + \ + w * (T49 + \ + w * (T53 + \ + w * T57))))))))))))) +#define VPOLY(w) \ + (T7 + \ + w * (T11 + \ + w * (T15 + \ + w * (T19 + \ + w * (T23 + \ + w * (T27 + \ + w * (T31 + \ + w * (T35 + \ + w * (T39 + \ + w * (T43 + \ + w * (T47 + \ + w * (T51 + \ + w * T55)))))))))))) +#endif + +long double __tanl(long double x, long double y, int odd) +{ + long double z, r, v, w, s, a, t; + int big, sign; + + big = fabsl(x) >= 0.67434; + if (big) { + sign = 0; + if (x < 0) { + sign = 1; + x = -x; + y = -y; + } + x = (pio4 - x) + (pio4lo - y); + y = 0.0; + } + z = x * x; + w = z * z; + r = RPOLY(w); + v = z * VPOLY(w); + s = z * x; + r = y + z * (s * (r + v) + y) + T3 * s; + w = x + r; + if (big) { + s = 1 - 2 * odd; + v = s - 2.0 * (x + (r - w * w / (w + s))); + return sign ? -v : v; + } + if (!odd) + return w; + /* + * if allow error up to 2 ulp, simply return + * -1.0 / (x+r) here + */ + /* compute -1.0 / (x+r) accurately */ + z = w; + z = z + 0x1p32 - 0x1p32; + v = r - (z - x); /* z+v = r+x */ + t = a = -1.0 / w; /* a = -1.0/w */ + t = t + 0x1p32 - 0x1p32; + s = 1.0 + t * z; + return t + a * (s + t * v); +} +#endif diff --git a/lib/libm/aarch64/ceil.c b/lib/libm/aarch64/ceil.c new file mode 100644 index 00000000..44f4cc19 --- /dev/null +++ b/lib/libm/aarch64/ceil.c @@ -0,0 +1,7 @@ +#include <math.h> + +double ceil(double x) +{ + __asm__("frintp %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/ceilf.c b/lib/libm/aarch64/ceilf.c new file mode 100644 index 00000000..a449bf7b --- /dev/null +++ b/lib/libm/aarch64/ceilf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float ceilf(float x) +{ + __asm__("frintp %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/fabs.c b/lib/libm/aarch64/fabs.c new file mode 100644 index 00000000..96c336dd --- /dev/null +++ b/lib/libm/aarch64/fabs.c @@ -0,0 +1,7 @@ +#include <math.h> + +double fabs(double x) +{ + __asm__("fabs %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/fabsf.c b/lib/libm/aarch64/fabsf.c new file mode 100644 index 00000000..dd652781 --- /dev/null +++ b/lib/libm/aarch64/fabsf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float fabsf(float x) +{ + __asm__("fabs %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/floor.c b/lib/libm/aarch64/floor.c new file mode 100644 index 00000000..53170a83 --- /dev/null +++ b/lib/libm/aarch64/floor.c @@ -0,0 +1,7 @@ +#include <math.h> + +double floor(double x) +{ + __asm__("frintm %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/floorf.c b/lib/libm/aarch64/floorf.c new file mode 100644 index 00000000..633fd2a2 --- /dev/null +++ b/lib/libm/aarch64/floorf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float floorf(float x) +{ + __asm__("frintm %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/fma.c b/lib/libm/aarch64/fma.c new file mode 100644 index 00000000..858a6f04 --- /dev/null +++ b/lib/libm/aarch64/fma.c @@ -0,0 +1,7 @@ +#include <math.h> + +double fma(double x, double y, double z) +{ + __asm__("fmadd %d0, %d1, %d2, %d3" : "=w"(x) : "w"(x), "w"(y), "w"(z)); + return x; +} diff --git a/lib/libm/aarch64/fmaf.c b/lib/libm/aarch64/fmaf.c new file mode 100644 index 00000000..9f80e065 --- /dev/null +++ b/lib/libm/aarch64/fmaf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float fmaf(float x, float y, float z) +{ + __asm__("fmadd %s0, %s1, %s2, %s3" : "=w"(x) : "w"(x), "w"(y), "w"(z)); + return x; +} diff --git a/lib/libm/aarch64/fmax.c b/lib/libm/aarch64/fmax.c new file mode 100644 index 00000000..4d094507 --- /dev/null +++ b/lib/libm/aarch64/fmax.c @@ -0,0 +1,7 @@ +#include <math.h> + +double fmax(double x, double y) +{ + __asm__("fmaxnm %d0, %d1, %d2" : "=w"(x) : "w"(x), "w"(y)); + return x; +} diff --git a/lib/libm/aarch64/fmaxf.c b/lib/libm/aarch64/fmaxf.c new file mode 100644 index 00000000..34779718 --- /dev/null +++ b/lib/libm/aarch64/fmaxf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float fmaxf(float x, float y) +{ + __asm__("fmaxnm %s0, %s1, %s2" : "=w"(x) : "w"(x), "w"(y)); + return x; +} diff --git a/lib/libm/aarch64/fmin.c b/lib/libm/aarch64/fmin.c new file mode 100644 index 00000000..d49d80cc --- /dev/null +++ b/lib/libm/aarch64/fmin.c @@ -0,0 +1,7 @@ +#include <math.h> + +double fmin(double x, double y) +{ + __asm__("fminnm %d0, %d1, %d2" : "=w"(x) : "w"(x), "w"(y)); + return x; +} diff --git a/lib/libm/aarch64/fminf.c b/lib/libm/aarch64/fminf.c new file mode 100644 index 00000000..8a7166c4 --- /dev/null +++ b/lib/libm/aarch64/fminf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float fminf(float x, float y) +{ + __asm__("fminnm %s0, %s1, %s2" : "=w"(x) : "w"(x), "w"(y)); + return x; +} diff --git a/lib/libm/aarch64/llrint.c b/lib/libm/aarch64/llrint.c new file mode 100644 index 00000000..a1862927 --- /dev/null +++ b/lib/libm/aarch64/llrint.c @@ -0,0 +1,10 @@ +#include <math.h> + +long long llrint(double x) +{ + long long n; + __asm__("frintx %d1, %d1\n" + "fcvtzs %x0, %d1\n" + : "=r"(n), "+w"(x)); + return n; +} diff --git a/lib/libm/aarch64/llrintf.c b/lib/libm/aarch64/llrintf.c new file mode 100644 index 00000000..6a3d5068 --- /dev/null +++ b/lib/libm/aarch64/llrintf.c @@ -0,0 +1,10 @@ +#include <math.h> + +long long llrintf(float x) +{ + long long n; + __asm__("frintx %s1, %s1\n" + "fcvtzs %x0, %s1\n" + : "=r"(n), "+w"(x)); + return n; +} diff --git a/lib/libm/aarch64/llround.c b/lib/libm/aarch64/llround.c new file mode 100644 index 00000000..ae5972d3 --- /dev/null +++ b/lib/libm/aarch64/llround.c @@ -0,0 +1,8 @@ +#include <math.h> + +long long llround(double x) +{ + long long n; + __asm__("fcvtas %x0, %d1" : "=r"(n) : "w"(x)); + return n; +} diff --git a/lib/libm/aarch64/llroundf.c b/lib/libm/aarch64/llroundf.c new file mode 100644 index 00000000..8c2d391d --- /dev/null +++ b/lib/libm/aarch64/llroundf.c @@ -0,0 +1,8 @@ +#include <math.h> + +long long llroundf(float x) +{ + long long n; + __asm__("fcvtas %x0, %s1" : "=r"(n) : "w"(x)); + return n; +} diff --git a/lib/libm/aarch64/lrint.c b/lib/libm/aarch64/lrint.c new file mode 100644 index 00000000..70c5cebd --- /dev/null +++ b/lib/libm/aarch64/lrint.c @@ -0,0 +1,10 @@ +#include <math.h> + +long lrint(double x) +{ + long n; + __asm__("frintx %d1, %d1\n" + "fcvtzs %x0, %d1\n" + : "=r"(n), "+w"(x)); + return n; +} diff --git a/lib/libm/aarch64/lrintf.c b/lib/libm/aarch64/lrintf.c new file mode 100644 index 00000000..aee60614 --- /dev/null +++ b/lib/libm/aarch64/lrintf.c @@ -0,0 +1,10 @@ +#include <math.h> + +long lrintf(float x) +{ + long n; + __asm__("frintx %s1, %s1\n" + "fcvtzs %x0, %s1\n" + : "=r"(n), "+w"(x)); + return n; +} diff --git a/lib/libm/aarch64/lround.c b/lib/libm/aarch64/lround.c new file mode 100644 index 00000000..a22e0970 --- /dev/null +++ b/lib/libm/aarch64/lround.c @@ -0,0 +1,8 @@ +#include <math.h> + +long lround(double x) +{ + long n; + __asm__("fcvtas %x0, %d1" : "=r"(n) : "w"(x)); + return n; +} diff --git a/lib/libm/aarch64/lroundf.c b/lib/libm/aarch64/lroundf.c new file mode 100644 index 00000000..a823024b --- /dev/null +++ b/lib/libm/aarch64/lroundf.c @@ -0,0 +1,8 @@ +#include <math.h> + +long lroundf(float x) +{ + long n; + __asm__("fcvtas %x0, %s1" : "=r"(n) : "w"(x)); + return n; +} diff --git a/lib/libm/aarch64/nearbyint.c b/lib/libm/aarch64/nearbyint.c new file mode 100644 index 00000000..6a186039 --- /dev/null +++ b/lib/libm/aarch64/nearbyint.c @@ -0,0 +1,7 @@ +#include <math.h> + +double nearbyint(double x) +{ + __asm__("frinti %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/nearbyintf.c b/lib/libm/aarch64/nearbyintf.c new file mode 100644 index 00000000..d61b07b8 --- /dev/null +++ b/lib/libm/aarch64/nearbyintf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float nearbyintf(float x) +{ + __asm__("frinti %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/rint.c b/lib/libm/aarch64/rint.c new file mode 100644 index 00000000..2cf91f05 --- /dev/null +++ b/lib/libm/aarch64/rint.c @@ -0,0 +1,7 @@ +#include <math.h> + +double rint(double x) +{ + __asm__("frintx %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/rintf.c b/lib/libm/aarch64/rintf.c new file mode 100644 index 00000000..e1d92fa8 --- /dev/null +++ b/lib/libm/aarch64/rintf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float rintf(float x) +{ + __asm__("frintx %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/round.c b/lib/libm/aarch64/round.c new file mode 100644 index 00000000..27b8e63f --- /dev/null +++ b/lib/libm/aarch64/round.c @@ -0,0 +1,7 @@ +#include <math.h> + +double round(double x) +{ + __asm__("frinta %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/roundf.c b/lib/libm/aarch64/roundf.c new file mode 100644 index 00000000..155aaba1 --- /dev/null +++ b/lib/libm/aarch64/roundf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float roundf(float x) +{ + __asm__("frinta %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/sqrt.c b/lib/libm/aarch64/sqrt.c new file mode 100644 index 00000000..33c32ddb --- /dev/null +++ b/lib/libm/aarch64/sqrt.c @@ -0,0 +1,7 @@ +#include <math.h> + +double sqrt(double x) +{ + __asm__("fsqrt %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/sqrtf.c b/lib/libm/aarch64/sqrtf.c new file mode 100644 index 00000000..8a7961d3 --- /dev/null +++ b/lib/libm/aarch64/sqrtf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float sqrtf(float x) +{ + __asm__("fsqrt %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/trunc.c b/lib/libm/aarch64/trunc.c new file mode 100644 index 00000000..e5aa908d --- /dev/null +++ b/lib/libm/aarch64/trunc.c @@ -0,0 +1,7 @@ +#include <math.h> + +double trunc(double x) +{ + __asm__("frintz %d0, %d1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/aarch64/truncf.c b/lib/libm/aarch64/truncf.c new file mode 100644 index 00000000..10389ca0 --- /dev/null +++ b/lib/libm/aarch64/truncf.c @@ -0,0 +1,7 @@ +#include <math.h> + +float truncf(float x) +{ + __asm__("frintz %s0, %s1" : "=w"(x) : "w"(x)); + return x; +} diff --git a/lib/libm/acos.c b/lib/libm/acos.c new file mode 100644 index 00000000..cc798159 --- /dev/null +++ b/lib/libm/acos.c @@ -0,0 +1,101 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_acos.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* acos(x) + * Method : + * acos(x) = pi/2 - asin(x) + * acos(-x) = pi/2 + asin(x) + * For |x|<=0.5 + * acos(x) = pi/2 - (x + x*x^2*R(x^2)) (see asin.c) + * For x>0.5 + * acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2))) + * = 2asin(sqrt((1-x)/2)) + * = 2s + 2s*z*R(z) ...z=(1-x)/2, s=sqrt(z) + * = 2f + (2c + 2s*z*R(z)) + * where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term + * for f so that f+c ~ sqrt(z). + * For x<-0.5 + * acos(x) = pi - 2asin(sqrt((1-|x|)/2)) + * = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z) + * + * Special cases: + * if x is NaN, return x itself; + * if |x|>1, return NaN with invalid signal. + * + * Function needed: sqrt + */ + +#include "libm.h" + +static const double pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, + 0x54442D18 */ + pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */ + pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */ + pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */ + pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */ + pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */ + pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */ + pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */ + qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */ + qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */ + qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */ + qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */ + +static double R(double z) +{ + double_t p, q; + p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5))))); + q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4))); + return p / q; +} + +double acos(double x) +{ + double z, w, s, c, df; + uint32_t hx, ix; + + GET_HIGH_WORD(hx, x); + ix = hx & 0x7fffffff; + /* |x| >= 1 or nan */ + if (ix >= 0x3ff00000) { + uint32_t lx; + + GET_LOW_WORD(lx, x); + if ((ix - 0x3ff00000 | lx) == 0) { + /* acos(1)=0, acos(-1)=pi */ + if (hx >> 31) + return 2 * pio2_hi + 0x1p-120f; + return 0; + } + return 0 / (x - x); + } + /* |x| < 0.5 */ + if (ix < 0x3fe00000) { + if (ix <= 0x3c600000) /* |x| < 2**-57 */ + return pio2_hi + 0x1p-120f; + return pio2_hi - (x - (pio2_lo - x * R(x * x))); + } + /* x < -0.5 */ + if (hx >> 31) { + z = (1.0 + x) * 0.5; + s = sqrt(z); + w = R(z) * s - pio2_lo; + return 2 * (pio2_hi - (s + w)); + } + /* x > 0.5 */ + z = (1.0 - x) * 0.5; + s = sqrt(z); + df = s; + SET_LOW_WORD(df, 0); + c = (z - df * df) / (s + df); + w = R(z) * s + c; + return 2 * (df + w); +} diff --git a/lib/libm/acosf.c b/lib/libm/acosf.c new file mode 100644 index 00000000..a428e8d6 --- /dev/null +++ b/lib/libm/acosf.c @@ -0,0 +1,68 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_acosf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +static const float pio2_hi = 1.5707962513e+00, /* 0x3fc90fda */ + pio2_lo = 7.5497894159e-08, /* 0x33a22168 */ + pS0 = 1.6666586697e-01, pS1 = -4.2743422091e-02, + pS2 = -8.6563630030e-03, qS1 = -7.0662963390e-01; + +static float R(float z) +{ + float_t p, q; + p = z * (pS0 + z * (pS1 + z * pS2)); + q = 1.0f + z * qS1; + return p / q; +} + +float acosf(float x) +{ + float z, w, s, c, df; + uint32_t hx, ix; + + GET_FLOAT_WORD(hx, x); + ix = hx & 0x7fffffff; + /* |x| >= 1 or nan */ + if (ix >= 0x3f800000) { + if (ix == 0x3f800000) { + if (hx >> 31) + return 2 * pio2_hi + 0x1p-120f; + return 0; + } + return 0 / (x - x); + } + /* |x| < 0.5 */ + if (ix < 0x3f000000) { + if (ix <= 0x32800000) /* |x| < 2**-26 */ + return pio2_hi + 0x1p-120f; + return pio2_hi - (x - (pio2_lo - x * R(x * x))); + } + /* x < -0.5 */ + if (hx >> 31) { + z = (1 + x) * 0.5f; + s = sqrtf(z); + w = R(z) * s - pio2_lo; + return 2 * (pio2_hi - (s + w)); + } + /* x > 0.5 */ + z = (1 - x) * 0.5f; + s = sqrtf(z); + GET_FLOAT_WORD(hx, s); + SET_FLOAT_WORD(df, hx & 0xfffff000); + c = (z - df * df) / (s + df); + w = R(z) * s + c; + return 2 * (df + w); +} diff --git a/lib/libm/acosh.c b/lib/libm/acosh.c new file mode 100644 index 00000000..a53e01ed --- /dev/null +++ b/lib/libm/acosh.c @@ -0,0 +1,27 @@ +#include "libm.h" + +#if FLT_EVAL_METHOD == 2 +#undef sqrt +#define sqrt sqrtl +#endif + +/* acosh(x) = log(x + sqrt(x*x-1)) */ +double acosh(double x) +{ + union { + double f; + uint64_t i; + } u = { .f = x }; + unsigned e = u.i >> 52 & 0x7ff; + + /* x < 1 domain error is handled in the called functions */ + + if (e < 0x3ff + 1) + /* |x| < 2, up to 2ulp error in [1,1.125] */ + return log1p(x - 1 + sqrt((x - 1) * (x - 1) + 2 * (x - 1))); + if (e < 0x3ff + 26) + /* |x| < 0x1p26 */ + return log(2 * x - 1 / (x + sqrt(x * x - 1))); + /* |x| >= 0x1p26 or nan */ + return log(x) + 0.693147180559945309417232121458176568; +} diff --git a/lib/libm/acoshf.c b/lib/libm/acoshf.c new file mode 100644 index 00000000..515ca313 --- /dev/null +++ b/lib/libm/acoshf.c @@ -0,0 +1,29 @@ +#include "libm.h" + +#if FLT_EVAL_METHOD == 2 +#undef sqrtf +#define sqrtf sqrtl +#elif FLT_EVAL_METHOD == 1 +#undef sqrtf +#define sqrtf sqrt +#endif + +/* acosh(x) = log(x + sqrt(x*x-1)) */ +float acoshf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + uint32_t a = u.i & 0x7fffffff; + + if (a < 0x3f800000 + (1 << 23)) + /* |x| < 2, invalid if x < 1 */ + /* up to 2ulp error in [1,1.125] */ + return log1pf(x - 1 + sqrtf((x - 1) * (x - 1) + 2 * (x - 1))); + if (u.i < 0x3f800000 + (12 << 23)) + /* 2 <= x < 0x1p12 */ + return logf(2 * x - 1 / (x + sqrtf(x * x - 1))); + /* x >= 0x1p12 or x <= -2 or nan */ + return logf(x) + 0.693147180559945309417232121458176568f; +} diff --git a/lib/libm/acoshl.c b/lib/libm/acoshl.c new file mode 100644 index 00000000..f76c5b44 --- /dev/null +++ b/lib/libm/acoshl.c @@ -0,0 +1,33 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double acoshl(long double x) +{ + return acosh(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +/* acosh(x) = log(x + sqrt(x*x-1)) */ +long double acoshl(long double x) +{ + union ldshape u = { x }; + int e = u.i.se; + + if (e < 0x3fff + 1) + /* 0 <= x < 2, invalid if x < 1 */ + return log1pl(x - 1 + sqrtl((x - 1) * (x - 1) + 2 * (x - 1))); + if (e < 0x3fff + 32) + /* 2 <= x < 0x1p32 */ + return logl(2 * x - 1 / (x + sqrtl(x * x - 1))); + if (e & 0x8000) + /* x < 0 or x = -0, invalid */ + return (x - x) / (x - x); + /* 0x1p32 <= x or nan */ + return logl(x) + 0.693147180559945309417232121458176568L; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double acoshl(long double x) +{ + return acosh(x); +} +#endif diff --git a/lib/libm/acosl.c b/lib/libm/acosl.c new file mode 100644 index 00000000..f508a552 --- /dev/null +++ b/lib/libm/acosl.c @@ -0,0 +1,67 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_acosl.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * See comments in acos.c. + * Converted to long double by David Schultz <das@FreeBSD.ORG>. + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double acosl(long double x) +{ + return acos(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#include "__invtrigl.h" +#if LDBL_MANT_DIG == 64 +#define CLEARBOTTOM(u) (u.i.m &= -1ULL << 32) +#elif LDBL_MANT_DIG == 113 +#define CLEARBOTTOM(u) (u.i.lo = 0) +#endif + +long double acosl(long double x) +{ + union ldshape u = { x }; + long double z, s, c, f; + uint16_t e = u.i.se & 0x7fff; + + /* |x| >= 1 or nan */ + if (e >= 0x3fff) { + if (x == 1) + return 0; + if (x == -1) + return 2 * pio2_hi + 0x1p-120f; + return 0 / (x - x); + } + /* |x| < 0.5 */ + if (e < 0x3fff - 1) { + if (e < 0x3fff - LDBL_MANT_DIG - 1) + return pio2_hi + 0x1p-120f; + return pio2_hi - (__invtrigl_R(x * x) * x - pio2_lo + x); + } + /* x < -0.5 */ + if (u.i.se >> 15) { + z = (1 + x) * 0.5; + s = sqrtl(z); + return 2 * (pio2_hi - (__invtrigl_R(z) * s - pio2_lo + s)); + } + /* x > 0.5 */ + z = (1 - x) * 0.5; + s = sqrtl(z); + u.f = s; + CLEARBOTTOM(u); + f = u.f; + c = (z - f * f) / (s + f); + return 2 * (__invtrigl_R(z) * s + c + f); +} +#endif diff --git a/lib/libm/asin.c b/lib/libm/asin.c new file mode 100644 index 00000000..a7632829 --- /dev/null +++ b/lib/libm/asin.c @@ -0,0 +1,108 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_asin.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* asin(x) + * Method : + * Since asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ... + * we approximate asin(x) on [0,0.5] by + * asin(x) = x + x*x^2*R(x^2) + * where + * R(x^2) is a rational approximation of (asin(x)-x)/x^3 + * and its remez error is bounded by + * |(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75) + * + * For x in [0.5,1] + * asin(x) = pi/2-2*asin(sqrt((1-x)/2)) + * Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2; + * then for x>0.98 + * asin(x) = pi/2 - 2*(s+s*z*R(z)) + * = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo) + * For x<=0.98, let pio4_hi = pio2_hi/2, then + * f = hi part of s; + * c = sqrt(z) - f = (z-f*f)/(s+f) ...f+c=sqrt(z) + * and + * asin(x) = pi/2 - 2*(s+s*z*R(z)) + * = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo) + * = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c)) + * + * Special cases: + * if x is NaN, return x itself; + * if |x|>1, return NaN with invalid signal. + * + */ + +#include "libm.h" + +static const double pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, + 0x54442D18 */ + pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */ + /* coefficients for R(x^2) */ + pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */ + pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */ + pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */ + pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */ + pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */ + pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */ + qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */ + qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */ + qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */ + qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */ + +static double R(double z) +{ + double_t p, q; + p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5))))); + q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4))); + return p / q; +} + +double asin(double x) +{ + double z, r, s; + uint32_t hx, ix; + + GET_HIGH_WORD(hx, x); + ix = hx & 0x7fffffff; + /* |x| >= 1 or nan */ + if (ix >= 0x3ff00000) { + uint32_t lx; + GET_LOW_WORD(lx, x); + if ((ix - 0x3ff00000 | lx) == 0) + /* asin(1) = +-pi/2 with inexact */ + return x * pio2_hi + 0x1p-120f; + return 0 / (x - x); + } + /* |x| < 0.5 */ + if (ix < 0x3fe00000) { + /* if 0x1p-1022 <= |x| < 0x1p-26, avoid raising underflow */ + if (ix < 0x3e500000 && ix >= 0x00100000) + return x; + return x + x * R(x * x); + } + /* 1 > |x| >= 0.5 */ + z = (1 - fabs(x)) * 0.5; + s = sqrt(z); + r = R(z); + if (ix >= 0x3fef3333) { /* if |x| > 0.975 */ + x = pio2_hi - (2 * (s + s * r) - pio2_lo); + } else { + double f, c; + /* f+c = sqrt(z) */ + f = s; + SET_LOW_WORD(f, 0); + c = (z - f * f) / (s + f); + x = 0.5 * pio2_hi - + (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f)); + } + if (hx >> 31) + return -x; + return x; +} diff --git a/lib/libm/asinf.c b/lib/libm/asinf.c new file mode 100644 index 00000000..65ee2ae7 --- /dev/null +++ b/lib/libm/asinf.c @@ -0,0 +1,60 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_asinf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +#include "libm.h" + +static const double pio2 = 1.570796326794896558e+00; + +static const float + /* coefficients for R(x^2) */ + pS0 = 1.6666586697e-01, + pS1 = -4.2743422091e-02, pS2 = -8.6563630030e-03, + qS1 = -7.0662963390e-01; + +static float R(float z) +{ + float_t p, q; + p = z * (pS0 + z * (pS1 + z * pS2)); + q = 1.0f + z * qS1; + return p / q; +} + +float asinf(float x) +{ + double s; + float z; + uint32_t hx, ix; + + GET_FLOAT_WORD(hx, x); + ix = hx & 0x7fffffff; + if (ix >= 0x3f800000) { /* |x| >= 1 */ + if (ix == 0x3f800000) /* |x| == 1 */ + return x * pio2 + 0x1p-120f; /* asin(+-1) = +-pi/2 with + inexact */ + return 0 / (x - x); /* asin(|x|>1) is NaN */ + } + if (ix < 0x3f000000) { /* |x| < 0.5 */ + /* if 0x1p-126 <= |x| < 0x1p-12, avoid raising underflow */ + if (ix < 0x39800000 && ix >= 0x00800000) + return x; + return x + x * R(x * x); + } + /* 1 > |x| >= 0.5 */ + z = (1 - fabsf(x)) * 0.5f; + s = sqrt(z); + x = pio2 - 2 * (s + s * R(z)); + if (hx >> 31) + return -x; + return x; +} diff --git a/lib/libm/asinh.c b/lib/libm/asinh.c new file mode 100644 index 00000000..196a81ef --- /dev/null +++ b/lib/libm/asinh.c @@ -0,0 +1,31 @@ +#include "libm.h" + +/* asinh(x) = sign(x)*log(|x|+sqrt(x*x+1)) ~= x - x^3/6 + o(x^5) */ +double asinh(double x) +{ + union { + double f; + uint64_t i; + } u = { .f = x }; + unsigned e = u.i >> 52 & 0x7ff; + unsigned s = u.i >> 63; + + /* |x| */ + u.i &= (uint64_t)-1 / 2; + x = u.f; + + if (e >= 0x3ff + 26) { + /* |x| >= 0x1p26 or inf or nan */ + x = log(x) + 0.693147180559945309417232121458176568; + } else if (e >= 0x3ff + 1) { + /* |x| >= 2 */ + x = log(2 * x + 1 / (sqrt(x * x + 1) + x)); + } else if (e >= 0x3ff - 26) { + /* |x| >= 0x1p-26, up to 1.6ulp error in [0.125,0.5] */ + x = log1p(x + x * x / (sqrt(x * x + 1) + 1)); + } else { + /* |x| < 0x1p-26, raise inexact if x != 0 */ + FORCE_EVAL(x + 0x1p120f); + } + return s ? -x : x; +} diff --git a/lib/libm/asinhf.c b/lib/libm/asinhf.c new file mode 100644 index 00000000..2f6c585b --- /dev/null +++ b/lib/libm/asinhf.c @@ -0,0 +1,31 @@ +#include "libm.h" + +/* asinh(x) = sign(x)*log(|x|+sqrt(x*x+1)) ~= x - x^3/6 + o(x^5) */ +float asinhf(float x) +{ + union { + float f; + uint32_t i; + } u = { .f = x }; + uint32_t i = u.i & 0x7fffffff; + unsigned s = u.i >> 31; + + /* |x| */ + u.i = i; + x = u.f; + + if (i >= 0x3f800000 + (12 << 23)) { + /* |x| >= 0x1p12 or inf or nan */ + x = logf(x) + 0.693147180559945309417232121458176568f; + } else if (i >= 0x3f800000 + (1 << 23)) { + /* |x| >= 2 */ + x = logf(2 * x + 1 / (sqrtf(x * x + 1) + x)); + } else if (i >= 0x3f800000 - (12 << 23)) { + /* |x| >= 0x1p-12, up to 1.6ulp error in [0.125,0.5] */ + x = log1pf(x + x * x / (sqrtf(x * x + 1) + 1)); + } else { + /* |x| < 0x1p-12, raise inexact if x!=0 */ + FORCE_EVAL(x + 0x1p120f); + } + return s ? -x : x; +} diff --git a/lib/libm/asinhl.c b/lib/libm/asinhl.c new file mode 100644 index 00000000..321f2a0f --- /dev/null +++ b/lib/libm/asinhl.c @@ -0,0 +1,41 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double asinhl(long double x) +{ + return asinh(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +/* asinh(x) = sign(x)*log(|x|+sqrt(x*x+1)) ~= x - x^3/6 + o(x^5) */ +long double asinhl(long double x) +{ + union ldshape u = { x }; + unsigned e = u.i.se & 0x7fff; + unsigned s = u.i.se >> 15; + + /* |x| */ + u.i.se = e; + x = u.f; + + if (e >= 0x3fff + 32) { + /* |x| >= 0x1p32 or inf or nan */ + x = logl(x) + 0.693147180559945309417232121458176568L; + } else if (e >= 0x3fff + 1) { + /* |x| >= 2 */ + x = logl(2 * x + 1 / (sqrtl(x * x + 1) + x)); + } else if (e >= 0x3fff - 32) { + /* |x| >= 0x1p-32 */ + x = log1pl(x + x * x / (sqrtl(x * x + 1) + 1)); + } else { + /* |x| < 0x1p-32, raise inexact if x!=0 */ + FORCE_EVAL(x + 0x1p120f); + } + return s ? -x : x; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double asinhl(long double x) +{ + return asinh(x); +} +#endif diff --git a/lib/libm/asinl.c b/lib/libm/asinl.c new file mode 100644 index 00000000..8dd0268c --- /dev/null +++ b/lib/libm/asinl.c @@ -0,0 +1,72 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_asinl.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * See comments in asin.c. + * Converted to long double by David Schultz <das@FreeBSD.ORG>. + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double asinl(long double x) +{ + return asin(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#include "__invtrigl.h" +#if LDBL_MANT_DIG == 64 +#define CLOSETO1(u) (u.i.m >> 56 >= 0xf7) +#define CLEARBOTTOM(u) (u.i.m &= -1ULL << 32) +#elif LDBL_MANT_DIG == 113 +#define CLOSETO1(u) (u.i.top >= 0xee00) +#define CLEARBOTTOM(u) (u.i.lo = 0) +#endif + +long double asinl(long double x) +{ + union ldshape u = { x }; + long double z, r, s; + uint16_t e = u.i.se & 0x7fff; + int sign = u.i.se >> 15; + + if (e >= 0x3fff) { /* |x| >= 1 or nan */ + /* asin(+-1)=+-pi/2 with inexact */ + if (x == 1 || x == -1) + return x * pio2_hi + 0x1p-120f; + return 0 / (x - x); + } + if (e < 0x3fff - 1) { /* |x| < 0.5 */ + if (e < 0x3fff - (LDBL_MANT_DIG + 1) / 2) { + /* return x with inexact if x!=0 */ + FORCE_EVAL(x + 0x1p120f); + return x; + } + return x + x * __invtrigl_R(x * x); + } + /* 1 > |x| >= 0.5 */ + z = (1.0 - fabsl(x)) * 0.5; + s = sqrtl(z); + r = __invtrigl_R(z); + if (CLOSETO1(u)) { + x = pio2_hi - (2 * (s + s * r) - pio2_lo); + } else { + long double f, c; + u.f = s; + CLEARBOTTOM(u); + f = u.f; + c = (z - f * f) / (s + f); + x = 0.5 * pio2_hi - + (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f)); + } + return sign ? -x : x; +} +#endif diff --git a/lib/libm/atan.c b/lib/libm/atan.c new file mode 100644 index 00000000..6793af93 --- /dev/null +++ b/lib/libm/atan.c @@ -0,0 +1,117 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_atan.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* atan(x) + * Method + * 1. Reduce x to positive by atan(x) = -atan(-x). + * 2. According to the integer k=4t+0.25 chopped, t=x, the argument + * is further reduced to one of the following intervals and the + * arctangent of t is evaluated by the corresponding formula: + * + * [0,7/16] atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...) + * [7/16,11/16] atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) ) + * [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) ) + * [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) ) + * [39/16,INF] atan(x) = atan(INF) + atan( -1/t ) + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "libm.h" + +static const double atanhi[] = { + 4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */ + 7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */ + 9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */ + 1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */ +}; + +static const double atanlo[] = { + 2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */ + 3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */ + 1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */ + 6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */ +}; + +static const double aT[] = { + 3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */ + -1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */ + 1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */ + -1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */ + 9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */ + -7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */ + 6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */ + -5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */ + 4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */ + -3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */ + 1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */ +}; + +double atan(double x) +{ + double_t w, s1, s2, z; + uint32_t ix, sign; + int id; + + GET_HIGH_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x44100000) { /* if |x| >= 2^66 */ + if (isnan(x)) + return x; + z = atanhi[3] + 0x1p-120f; + return sign ? -z : z; + } + if (ix < 0x3fdc0000) { /* |x| < 0.4375 */ + if (ix < 0x3e400000) { /* |x| < 2^-27 */ + if (ix < 0x00100000) + /* raise underflow for subnormal x */ + FORCE_EVAL((float)x); + return x; + } + id = -1; + } else { + x = fabs(x); + if (ix < 0x3ff30000) { /* |x| < 1.1875 */ + if (ix < 0x3fe60000) { /* 7/16 <= |x| < 11/16 */ + id = 0; + x = (2.0 * x - 1.0) / (2.0 + x); + } else { /* 11/16 <= |x| < 19/16 */ + id = 1; + x = (x - 1.0) / (x + 1.0); + } + } else { + if (ix < 0x40038000) { /* |x| < 2.4375 */ + id = 2; + x = (x - 1.5) / (1.0 + 1.5 * x); + } else { /* 2.4375 <= |x| < 2^66 */ + id = 3; + x = -1.0 / x; + } + } + } + /* end of argument reduction */ + z = x * x; + w = z * z; + /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ + s1 = z * (aT[0] + + w * (aT[2] + + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10]))))); + s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9])))); + if (id < 0) + return x - x * (s1 + s2); + z = atanhi[id] - (x * (s1 + s2) - atanlo[id] - x); + return sign ? -z : z; +} diff --git a/lib/libm/atan2.c b/lib/libm/atan2.c new file mode 100644 index 00000000..3298b6c4 --- /dev/null +++ b/lib/libm/atan2.c @@ -0,0 +1,120 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_atan2.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ +/* atan2(y,x) + * Method : + * 1. Reduce y to positive by atan2(y,x)=-atan2(-y,x). + * 2. Reduce x to positive by (if x and y are unexceptional): + * ARG (x+iy) = arctan(y/x) ... if x > 0, + * ARG (x+iy) = pi - arctan[y/(-x)] ... if x < 0, + * + * Special cases: + * + * ATAN2((anything), NaN ) is NaN; + * ATAN2(NAN , (anything) ) is NaN; + * ATAN2(+-0, +(anything but NaN)) is +-0 ; + * ATAN2(+-0, -(anything but NaN)) is +-pi ; + * ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2; + * ATAN2(+-(anything but INF and NaN), +INF) is +-0 ; + * ATAN2(+-(anything but INF and NaN), -INF) is +-pi; + * ATAN2(+-INF,+INF ) is +-pi/4 ; + * ATAN2(+-INF,-INF ) is +-3pi/4; + * ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2; + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "libm.h" + +static const double pi = 3.1415926535897931160E+00, /* 0x400921FB, 0x54442D18 */ + pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */ + +double atan2(double y, double x) +{ + double z; + uint32_t m, lx, ly, ix, iy; + + if (isnan(x) || isnan(y)) + return x + y; + EXTRACT_WORDS(ix, lx, x); + EXTRACT_WORDS(iy, ly, y); + if ((ix - 0x3ff00000 | lx) == 0) /* x = 1.0 */ + return atan(y); + m = ((iy >> 31) & 1) | ((ix >> 30) & 2); /* 2*sign(x)+sign(y) */ + ix = ix & 0x7fffffff; + iy = iy & 0x7fffffff; + + /* when y = 0 */ + if ((iy | ly) == 0) { + switch (m) { + case 0: + case 1: + return y; /* atan(+-0,+anything)=+-0 */ + case 2: + return pi; /* atan(+0,-anything) = pi */ + case 3: + return -pi; /* atan(-0,-anything) =-pi */ + } + } + /* when x = 0 */ + if ((ix | lx) == 0) + return m & 1 ? -pi / 2 : pi / 2; + /* when x is INF */ + if (ix == 0x7ff00000) { + if (iy == 0x7ff00000) { + switch (m) { + case 0: + return pi / 4; /* atan(+INF,+INF) */ + case 1: + return -pi / 4; /* atan(-INF,+INF) */ + case 2: + return 3 * pi / 4; /* atan(+INF,-INF) */ + case 3: + return -3 * pi / 4; /* atan(-INF,-INF) */ + } + } else { + switch (m) { + case 0: + return 0.0; /* atan(+...,+INF) */ + case 1: + return -0.0; /* atan(-...,+INF) */ + case 2: + return pi; /* atan(+...,-INF) */ + case 3: + return -pi; /* atan(-...,-INF) */ + } + } + } + /* |y/x| > 0x1p64 */ + if (ix + (64 << 20) < iy || iy == 0x7ff00000) + return m & 1 ? -pi / 2 : pi / 2; + + /* z = atan(|y/x|) without spurious underflow */ + if ((m & 2) && iy + (64 << 20) < ix) /* |y/x| < 0x1p-64, x<0 */ + z = 0; + else + z = atan(fabs(y / x)); + switch (m) { + case 0: + return z; /* atan(+,+) */ + case 1: + return -z; /* atan(-,+) */ + case 2: + return pi - (z - pi_lo); /* atan(+,-) */ + default: /* case 3 */ + return (z - pi_lo) - pi; /* atan(-,-) */ + } +} diff --git a/lib/libm/atan2f.c b/lib/libm/atan2f.c new file mode 100644 index 00000000..01f32d20 --- /dev/null +++ b/lib/libm/atan2f.c @@ -0,0 +1,96 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_atan2f.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +static const float pi = 3.1415927410e+00, /* 0x40490fdb */ + pi_lo = -8.7422776573e-08; /* 0xb3bbbd2e */ + +float atan2f(float y, float x) +{ + float z; + uint32_t m, ix, iy; + + if (isnan(x) || isnan(y)) + return x + y; + GET_FLOAT_WORD(ix, x); + GET_FLOAT_WORD(iy, y); + if (ix == 0x3f800000) /* x=1.0 */ + return atanf(y); + m = ((iy >> 31) & 1) | ((ix >> 30) & 2); /* 2*sign(x)+sign(y) */ + ix &= 0x7fffffff; + iy &= 0x7fffffff; + + /* when y = 0 */ + if (iy == 0) { + switch (m) { + case 0: + case 1: + return y; /* atan(+-0,+anything)=+-0 */ + case 2: + return pi; /* atan(+0,-anything) = pi */ + case 3: + return -pi; /* atan(-0,-anything) =-pi */ + } + } + /* when x = 0 */ + if (ix == 0) + return m & 1 ? -pi / 2 : pi / 2; + /* when x is INF */ + if (ix == 0x7f800000) { + if (iy == 0x7f800000) { + switch (m) { + case 0: + return pi / 4; /* atan(+INF,+INF) */ + case 1: + return -pi / 4; /* atan(-INF,+INF) */ + case 2: + return 3 * pi / 4; /*atan(+INF,-INF)*/ + case 3: + return -3 * pi / 4; /*atan(-INF,-INF)*/ + } + } else { + switch (m) { + case 0: + return 0.0f; /* atan(+...,+INF) */ + case 1: + return -0.0f; /* atan(-...,+INF) */ + case 2: + return pi; /* atan(+...,-INF) */ + case 3: + return -pi; /* atan(-...,-INF) */ + } + } + } + /* |y/x| > 0x1p26 */ + if (ix + (26 << 23) < iy || iy == 0x7f800000) + return m & 1 ? -pi / 2 : pi / 2; + + /* z = atan(|y/x|) with correct underflow */ + if ((m & 2) && iy + (26 << 23) < ix) /*|y/x| < 0x1p-26, x < 0 */ + z = 0.0; + else + z = atanf(fabsf(y / x)); + switch (m) { + case 0: + return z; /* atan(+,+) */ + case 1: + return -z; /* atan(-,+) */ + case 2: + return pi - (z - pi_lo); /* atan(+,-) */ + default: /* case 3 */ + return (z - pi_lo) - pi; /* atan(-,-) */ + } +} diff --git a/lib/libm/atan2l.c b/lib/libm/atan2l.c new file mode 100644 index 00000000..f2f60986 --- /dev/null +++ b/lib/libm/atan2l.c @@ -0,0 +1,99 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_atan2l.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ +/* + * See comments in atan2.c. + * Converted to long double by David Schultz <das@FreeBSD.ORG>. + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double atan2l(long double y, long double x) +{ + return atan2(y, x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#include "__invtrigl.h" + +long double atan2l(long double y, long double x) +{ + union ldshape ux, uy; + long double z; + int m, ex, ey; + + if (isnan(x) || isnan(y)) + return x + y; + if (x == 1) + return atanl(y); + ux.f = x; + uy.f = y; + ex = ux.i.se & 0x7fff; + ey = uy.i.se & 0x7fff; + m = 2 * (ux.i.se >> 15) | uy.i.se >> 15; + if (y == 0) { + switch (m) { + case 0: + case 1: + return y; /* atan(+-0,+anything)=+-0 */ + case 2: + return 2 * pio2_hi; /* atan(+0,-anything) = pi */ + case 3: + return -2 * pio2_hi; /* atan(-0,-anything) =-pi */ + } + } + if (x == 0) + return m & 1 ? -pio2_hi : pio2_hi; + if (ex == 0x7fff) { + if (ey == 0x7fff) { + switch (m) { + case 0: + return pio2_hi / 2; /* atan(+INF,+INF) */ + case 1: + return -pio2_hi / 2; /* atan(-INF,+INF) */ + case 2: + return 1.5 * pio2_hi; /* atan(+INF,-INF) */ + case 3: + return -1.5 * pio2_hi; /* atan(-INF,-INF) */ + } + } else { + switch (m) { + case 0: + return 0.0; /* atan(+...,+INF) */ + case 1: + return -0.0; /* atan(-...,+INF) */ + case 2: + return 2 * pio2_hi; /* atan(+...,-INF) */ + case 3: + return -2 * pio2_hi; /* atan(-...,-INF) */ + } + } + } + if (ex + 120 < ey || ey == 0x7fff) + return m & 1 ? -pio2_hi : pio2_hi; + /* z = atan(|y/x|) without spurious underflow */ + if ((m & 2) && ey + 120 < ex) /* |y/x| < 0x1p-120, x<0 */ + z = 0.0; + else + z = atanl(fabsl(y / x)); + switch (m) { + case 0: + return z; /* atan(+,+) */ + case 1: + return -z; /* atan(-,+) */ + case 2: + return 2 * pio2_hi - (z - 2 * pio2_lo); /* atan(+,-) */ + default: /* case 3 */ + return (z - 2 * pio2_lo) - 2 * pio2_hi; /* atan(-,-) */ + } +} +#endif diff --git a/lib/libm/atanf.c b/lib/libm/atanf.c new file mode 100644 index 00000000..48f18e30 --- /dev/null +++ b/lib/libm/atanf.c @@ -0,0 +1,90 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_atanf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +static const float atanhi[] = { + 4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */ + 7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */ + 9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */ + 1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */ +}; + +static const float atanlo[] = { + 5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */ + 3.7748947079e-08, /* atan(1.0)lo 0x33222168 */ + 3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */ + 7.5497894159e-08, /* atan(inf)lo 0x33a22168 */ +}; + +static const float aT[] = { + 3.3333328366e-01, -1.9999158382e-01, 1.4253635705e-01, + -1.0648017377e-01, 6.1687607318e-02, +}; + +float atanf(float x) +{ + float_t w, s1, s2, z; + uint32_t ix, sign; + int id; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x4c800000) { /* if |x| >= 2**26 */ + if (isnan(x)) + return x; + z = atanhi[3] + 0x1p-120f; + return sign ? -z : z; + } + if (ix < 0x3ee00000) { /* |x| < 0.4375 */ + if (ix < 0x39800000) { /* |x| < 2**-12 */ + if (ix < 0x00800000) + /* raise underflow for subnormal x */ + FORCE_EVAL(x * x); + return x; + } + id = -1; + } else { + x = fabsf(x); + if (ix < 0x3f980000) { /* |x| < 1.1875 */ + if (ix < 0x3f300000) { /* 7/16 <= |x| < 11/16 */ + id = 0; + x = (2.0f * x - 1.0f) / (2.0f + x); + } else { /* 11/16 <= |x| < 19/16 */ + id = 1; + x = (x - 1.0f) / (x + 1.0f); + } + } else { + if (ix < 0x401c0000) { /* |x| < 2.4375 */ + id = 2; + x = (x - 1.5f) / (1.0f + 1.5f * x); + } else { /* 2.4375 <= |x| < 2**26 */ + id = 3; + x = -1.0f / x; + } + } + } + /* end of argument reduction */ + z = x * x; + w = z * z; + /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ + s1 = z * (aT[0] + w * (aT[2] + w * aT[4])); + s2 = w * (aT[1] + w * aT[3]); + if (id < 0) + return x - x * (s1 + s2); + z = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x); + return sign ? -z : z; +} diff --git a/lib/libm/atanh.c b/lib/libm/atanh.c new file mode 100644 index 00000000..08a34d7e --- /dev/null +++ b/lib/libm/atanh.c @@ -0,0 +1,32 @@ +#include "libm.h" + +/* atanh(x) = log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2 ~= x + x^3/3 + o(x^5) */ +double atanh(double x) +{ + union { + double f; + uint64_t i; + } u = { .f = x }; + unsigned e = u.i >> 52 & 0x7ff; + unsigned s = u.i >> 63; + double_t y; + + /* |x| */ + u.i &= (uint64_t)-1 / 2; + y = u.f; + + if (e < 0x3ff - 1) { + if (e < 0x3ff - 32) { + /* handle underflow */ + if (e == 0) + FORCE_EVAL((float)y); + } else { + /* |x| < 0.5, up to 1.7ulp error */ + y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y)); + } + } else { + /* avoid overflow */ + y = 0.5 * log1p(2 * (y / (1 - y))); + } + return s ? -y : y; +} diff --git a/lib/libm/atanhf.c b/lib/libm/atanhf.c new file mode 100644 index 00000000..d1026974 --- /dev/null +++ b/lib/libm/atanhf.c @@ -0,0 +1,31 @@ +#include "libm.h" + +/* atanh(x) = log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2 ~= x + x^3/3 + o(x^5) */ +float atanhf(float x) +{ + union { + float f; + uint32_t i; + } u = { .f = x }; + unsigned s = u.i >> 31; + float_t y; + + /* |x| */ + u.i &= 0x7fffffff; + y = u.f; + + if (u.i < 0x3f800000 - (1 << 23)) { + if (u.i < 0x3f800000 - (32 << 23)) { + /* handle underflow */ + if (u.i < (1 << 23)) + FORCE_EVAL((float)(y * y)); + } else { + /* |x| < 0.5, up to 1.7ulp error */ + y = 0.5f * log1pf(2 * y + 2 * y * y / (1 - y)); + } + } else { + /* avoid overflow */ + y = 0.5f * log1pf(2 * (y / (1 - y))); + } + return s ? -y : y; +} diff --git a/lib/libm/atanhl.c b/lib/libm/atanhl.c new file mode 100644 index 00000000..8afd5a03 --- /dev/null +++ b/lib/libm/atanhl.c @@ -0,0 +1,35 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double atanhl(long double x) +{ + return atanh(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +/* atanh(x) = log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2 ~= x + x^3/3 + o(x^5) */ +long double atanhl(long double x) +{ + union ldshape u = { x }; + unsigned e = u.i.se & 0x7fff; + unsigned s = u.i.se >> 15; + + /* |x| */ + u.i.se = e; + x = u.f; + + if (e < 0x3ff - 1) { + if (e < 0x3ff - LDBL_MANT_DIG / 2) { + /* handle underflow */ + if (e == 0) + FORCE_EVAL((float)x); + } else { + /* |x| < 0.5, up to 1.7ulp error */ + x = 0.5 * log1pl(2 * x + 2 * x * x / (1 - x)); + } + } else { + /* avoid overflow */ + x = 0.5 * log1pl(2 * (x / (1 - x))); + } + return s ? -x : x; +} +#endif diff --git a/lib/libm/atanl.c b/lib/libm/atanl.c new file mode 100644 index 00000000..c1c75c94 --- /dev/null +++ b/lib/libm/atanl.c @@ -0,0 +1,205 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_atanl.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * See comments in atan.c. + * Converted to long double by David Schultz <das@FreeBSD.ORG>. + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double atanl(long double x) +{ + return atan(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 + +#if LDBL_MANT_DIG == 64 +#define EXPMAN(u) ((u.i.se & 0x7fff) << 8 | (u.i.m >> 55 & 0xff)) + +static const long double atanhi[] = { + 4.63647609000806116202e-01L, + 7.85398163397448309628e-01L, + 9.82793723247329067960e-01L, + 1.57079632679489661926e+00L, +}; + +static const long double atanlo[] = { + 1.18469937025062860669e-20L, + -1.25413940316708300586e-20L, + 2.55232234165405176172e-20L, + -2.50827880633416601173e-20L, +}; + +static const long double aT[] = { + 3.33333333333333333017e-01L, -1.99999999999999632011e-01L, + 1.42857142857046531280e-01L, -1.11111111100562372733e-01L, + 9.09090902935647302252e-02L, -7.69230552476207730353e-02L, + 6.66661718042406260546e-02L, -5.88158892835030888692e-02L, + 5.25499891539726639379e-02L, -4.70119845393155721494e-02L, + 4.03539201366454414072e-02L, -2.91303858419364158725e-02L, + 1.24822046299269234080e-02L, +}; + +static long double T_even(long double x) +{ + return aT[0] + + x * (aT[2] + + x * (aT[4] + x * (aT[6] + x * (aT[8] + x * (aT[10] + + x * aT[12]))))); +} + +static long double T_odd(long double x) +{ + return aT[1] + + x * (aT[3] + + x * (aT[5] + x * (aT[7] + x * (aT[9] + x * aT[11])))); +} +#elif LDBL_MANT_DIG == 113 +#define EXPMAN(u) ((u.i.se & 0x7fff) << 8 | u.i.top >> 8) + +static const long double atanhi[] = { + 4.63647609000806116214256231461214397e-01L, + 7.85398163397448309615660845819875699e-01L, + 9.82793723247329067985710611014666038e-01L, + 1.57079632679489661923132169163975140e+00L, +}; + +static const long double atanlo[] = { + 4.89509642257333492668618435220297706e-36L, + 2.16795253253094525619926100651083806e-35L, + -2.31288434538183565909319952098066272e-35L, + 4.33590506506189051239852201302167613e-35L, +}; + +static const long double aT[] = { + 3.33333333333333333333333333333333125e-01L, + -1.99999999999999999999999999999180430e-01L, + 1.42857142857142857142857142125269827e-01L, + -1.11111111111111111111110834490810169e-01L, + 9.09090909090909090908522355708623681e-02L, + -7.69230769230769230696553844935357021e-02L, + 6.66666666666666660390096773046256096e-02L, + -5.88235294117646671706582985209643694e-02L, + 5.26315789473666478515847092020327506e-02L, + -4.76190476189855517021024424991436144e-02L, + 4.34782608678695085948531993458097026e-02L, + -3.99999999632663469330634215991142368e-02L, + 3.70370363987423702891250829918659723e-02L, + -3.44827496515048090726669907612335954e-02L, + 3.22579620681420149871973710852268528e-02L, + -3.03020767654269261041647570626778067e-02L, + 2.85641979882534783223403715930946138e-02L, + -2.69824879726738568189929461383741323e-02L, + 2.54194698498808542954187110873675769e-02L, + -2.35083879708189059926183138130183215e-02L, + 2.04832358998165364349957325067131428e-02L, + -1.54489555488544397858507248612362957e-02L, + 8.64492360989278761493037861575248038e-03L, + -2.58521121597609872727919154569765469e-03L, +}; + +static long double T_even(long double x) +{ + return (aT[0] + + x * (aT[2] + + x * (aT[4] + + x * (aT[6] + + x * (aT[8] + + x * (aT[10] + + x * (aT[12] + + x * (aT[14] + + x * (aT[16] + + x * (aT[18] + + x * (aT[20] + + x * aT[22]))))))))))); +} + +static long double T_odd(long double x) +{ + return (aT[1] + + x * (aT[3] + + x * (aT[5] + + x * (aT[7] + + x * (aT[9] + + x * (aT[11] + + x * (aT[13] + + x * (aT[15] + + x * (aT[17] + + x * (aT[19] + + x * (aT[21] + + x * aT[23]))))))))))); +} +#endif + +long double atanl(long double x) +{ + union ldshape u = { x }; + long double w, s1, s2, z; + int id; + unsigned e = u.i.se & 0x7fff; + unsigned sign = u.i.se >> 15; + unsigned expman; + + if (e >= 0x3fff + LDBL_MANT_DIG + 1) { /* if |x| is large, atan(x)~=pi/2 + */ + if (isnan(x)) + return x; + return sign ? -atanhi[3] : atanhi[3]; + } + /* Extract the exponent and the first few bits of the mantissa. */ + expman = EXPMAN(u); + if (expman < ((0x3fff - 2) << 8) + 0xc0) { /* |x| < 0.4375 */ + if (e < 0x3fff - (LDBL_MANT_DIG + 1) / 2) { /* if |x| is small, + atanl(x)~=x */ + /* raise underflow if subnormal */ + if (e == 0) + FORCE_EVAL((float)x); + return x; + } + id = -1; + } else { + x = fabsl(x); + if (expman < (0x3fff << 8) + 0x30) { /* |x| < 1.1875 */ + if (expman < ((0x3fff - 1) << 8) + 0x60) { /* 7/16 <= + |x| < + 11/16 */ + id = 0; + x = (2.0 * x - 1.0) / (2.0 + x); + } else { /* 11/16 <= |x| < 19/16 */ + id = 1; + x = (x - 1.0) / (x + 1.0); + } + } else { + if (expman < ((0x3fff + 1) << 8) + 0x38) { /* |x| + < 2.4375 + */ + id = 2; + x = (x - 1.5) / (1.0 + 1.5 * x); + } else { /* 2.4375 <= |x| */ + id = 3; + x = -1.0 / x; + } + } + } + /* end of argument reduction */ + z = x * x; + w = z * z; + /* break sum aT[i]z**(i+1) into odd and even poly */ + s1 = z * T_even(w); + s2 = w * T_odd(w); + if (id < 0) + return x - x * (s1 + s2); + z = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x); + return sign ? -z : z; +} +#endif diff --git a/lib/libm/atomic.h b/lib/libm/atomic.h new file mode 100644 index 00000000..44d659b7 --- /dev/null +++ b/lib/libm/atomic.h @@ -0,0 +1,371 @@ +#ifndef _ATOMIC_H +#define _ATOMIC_H + +#include <stdint.h> + +#include <asm/atomic.h> + +#ifdef a_ll + +#ifndef a_pre_llsc +#define a_pre_llsc() +#endif + +#ifndef a_post_llsc +#define a_post_llsc() +#endif + +#ifndef a_cas +#define a_cas a_cas +static inline int a_cas(volatile int *p, int t, int s) +{ + int old; + a_pre_llsc(); + do + old = a_ll(p); + while (old == t && !a_sc(p, s)); + a_post_llsc(); + return old; +} +#endif + +#ifndef a_swap +#define a_swap a_swap +static inline int a_swap(volatile int *p, int v) +{ + int old; + a_pre_llsc(); + do + old = a_ll(p); + while (!a_sc(p, v)); + a_post_llsc(); + return old; +} +#endif + +#ifndef a_fetch_add +#define a_fetch_add a_fetch_add +static inline int a_fetch_add(volatile int *p, int v) +{ + int old; + a_pre_llsc(); + do + old = a_ll(p); + while (!a_sc(p, (unsigned)old + v)); + a_post_llsc(); + return old; +} +#endif + +#ifndef a_fetch_and +#define a_fetch_and a_fetch_and +static inline int a_fetch_and(volatile int *p, int v) +{ + int old; + a_pre_llsc(); + do + old = a_ll(p); + while (!a_sc(p, old & v)); + a_post_llsc(); + return old; +} +#endif + +#ifndef a_fetch_or +#define a_fetch_or a_fetch_or +static inline int a_fetch_or(volatile int *p, int v) +{ + int old; + a_pre_llsc(); + do + old = a_ll(p); + while (!a_sc(p, old | v)); + a_post_llsc(); + return old; +} +#endif + +#endif + +#ifdef a_ll_p + +#ifndef a_cas_p +#define a_cas_p a_cas_p +static inline void *a_cas_p(volatile void *p, void *t, void *s) +{ + void *old; + a_pre_llsc(); + do + old = a_ll_p(p); + while (old == t && !a_sc_p(p, s)); + a_post_llsc(); + return old; +} +#endif + +#endif + +#ifndef a_cas +#error missing definition of a_cas +#endif + +#ifndef a_swap +#define a_swap a_swap +static inline int a_swap(volatile int *p, int v) +{ + int old; + do + old = *p; + while (a_cas(p, old, v) != old); + return old; +} +#endif + +#ifndef a_fetch_add +#define a_fetch_add a_fetch_add +static inline int a_fetch_add(volatile int *p, int v) +{ + int old; + do + old = *p; + while (a_cas(p, old, (unsigned)old + v) != old); + return old; +} +#endif + +#ifndef a_fetch_and +#define a_fetch_and a_fetch_and +static inline int a_fetch_and(volatile int *p, int v) +{ + int old; + do + old = *p; + while (a_cas(p, old, old & v) != old); + return old; +} +#endif +#ifndef a_fetch_or +#define a_fetch_or a_fetch_or +static inline int a_fetch_or(volatile int *p, int v) +{ + int old; + do + old = *p; + while (a_cas(p, old, old | v) != old); + return old; +} +#endif + +#ifndef a_and +#define a_and a_and +static inline void a_and(volatile int *p, int v) +{ + a_fetch_and(p, v); +} +#endif + +#ifndef a_or +#define a_or a_or +static inline void a_or(volatile int *p, int v) +{ + a_fetch_or(p, v); +} +#endif + +#ifndef a_inc +#define a_inc a_inc +static inline void a_inc(volatile int *p) +{ + a_fetch_add(p, 1); +} +#endif + +#ifndef a_dec +#define a_dec a_dec +static inline void a_dec(volatile int *p) +{ + a_fetch_add(p, -1); +} +#endif + +#ifndef a_store +#define a_store a_store +static inline void a_store(volatile int *p, int v) +{ +#ifdef a_barrier + a_barrier(); + *p = v; + a_barrier(); +#else + a_swap(p, v); +#endif +} +#endif + +#ifndef a_barrier +#define a_barrier a_barrier +static inline void a_barrier() +{ + volatile int tmp = 0; + a_cas(&tmp, 0, 0); +} +#endif + +#ifndef a_spin +#define a_spin a_barrier +#endif + +#ifndef a_and_64 +#define a_and_64 a_and_64 +static inline void a_and_64(volatile uint64_t *p, uint64_t v) +{ + union { + uint64_t v; + uint32_t r[2]; + } u = { v }; + if (u.r[0] + 1) + a_and((int *)p, u.r[0]); + if (u.r[1] + 1) + a_and((int *)p + 1, u.r[1]); +} +#endif + +#ifndef a_or_64 +#define a_or_64 a_or_64 +static inline void a_or_64(volatile uint64_t *p, uint64_t v) +{ + union { + uint64_t v; + uint32_t r[2]; + } u = { v }; + if (u.r[0]) + a_or((int *)p, u.r[0]); + if (u.r[1]) + a_or((int *)p + 1, u.r[1]); +} +#endif + +#ifndef a_cas_p +typedef char a_cas_p_undefined_but_pointer_not_32bit + [-sizeof(char) == 0xffffffff ? 1 : -1]; +#define a_cas_p a_cas_p +static inline void *a_cas_p(volatile void *p, void *t, void *s) +{ + return (void *)a_cas((volatile int *)p, (int)t, (int)s); +} +#endif + +#ifndef a_or_l +#define a_or_l a_or_l +static inline void a_or_l(volatile void *p, long v) +{ + if (sizeof(long) == sizeof(int)) + a_or(p, v); + else + a_or_64(p, v); +} +#endif + +#ifndef a_crash +#define a_crash a_crash +static inline void a_crash() +{ + *(volatile char *)0 = 0; +} +#endif + +#ifndef a_ctz_32 +#define a_ctz_32 a_ctz_32 +static inline int a_ctz_32(uint32_t x) +{ +#ifdef a_clz_32 + return 31 - a_clz_32(x & -x); +#else + static const char debruijn32[32] = { 0, 1, 23, 2, 29, 24, 19, 3, + 30, 27, 25, 11, 20, 8, 4, 13, + 31, 22, 28, 18, 26, 10, 7, 12, + 21, 17, 9, 6, 16, 5, 15, 14 }; + return debruijn32[(x & -x) * 0x076be629 >> 27]; +#endif +} +#endif + +#ifndef a_ctz_64 +#define a_ctz_64 a_ctz_64 +static inline int a_ctz_64(uint64_t x) +{ + static const char debruijn64[64] = { + 0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28, + 62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11, + 63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10, + 51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12 + }; + if (sizeof(long) < 8) { + uint32_t y = x; + if (!y) { + y = x >> 32; + return 32 + a_ctz_32(y); + } + return a_ctz_32(y); + } + return debruijn64[(x & -x) * 0x022fdd63cc95386dull >> 58]; +} +#endif + +static inline int a_ctz_l(unsigned long x) +{ + return (sizeof(long) < 8) ? a_ctz_32(x) : a_ctz_64(x); +} + +#ifndef a_clz_64 +#define a_clz_64 a_clz_64 +static inline int a_clz_64(uint64_t x) +{ +#ifdef a_clz_32 + if (x >> 32) + return a_clz_32(x >> 32); + return a_clz_32(x) + 32; +#else + uint32_t y; + int r; + if (x >> 32) + y = x >> 32, r = 0; + else + y = x, r = 32; + if (y >> 16) + y >>= 16; + else + r |= 16; + if (y >> 8) + y >>= 8; + else + r |= 8; + if (y >> 4) + y >>= 4; + else + r |= 4; + if (y >> 2) + y >>= 2; + else + r |= 2; + return r | !(y >> 1); +#endif +} +#endif + +#ifndef a_clz_32 +#define a_clz_32 a_clz_32 +static inline int a_clz_32(uint32_t x) +{ + x >>= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + x++; + return 31 - a_ctz_32(x); +} +#endif + +#endif diff --git a/lib/libm/cabs.c b/lib/libm/cabs.c new file mode 100644 index 00000000..6bbcd878 --- /dev/null +++ b/lib/libm/cabs.c @@ -0,0 +1,7 @@ +#include <math.h> +#include <complex.h> + +double cabs(double complex z) +{ + return hypot(creal(z), cimag(z)); +} diff --git a/lib/libm/cabsf.c b/lib/libm/cabsf.c new file mode 100644 index 00000000..667ba935 --- /dev/null +++ b/lib/libm/cabsf.c @@ -0,0 +1,7 @@ +#include <math.h> +#include <complex.h> + +float cabsf(float complex z) +{ + return hypotf(crealf(z), cimagf(z)); +} diff --git a/lib/libm/cabsl.c b/lib/libm/cabsl.c new file mode 100644 index 00000000..42d11909 --- /dev/null +++ b/lib/libm/cabsl.c @@ -0,0 +1,14 @@ +#include <math.h> +#include <complex.h> + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double cabsl(long double complex z) +{ + return cabs(z); +} +#else +long double cabsl(long double complex z) +{ + return hypotl(creall(z), cimagl(z)); +} +#endif diff --git a/lib/libm/cacos.c b/lib/libm/cacos.c new file mode 100644 index 00000000..1248e72f --- /dev/null +++ b/lib/libm/cacos.c @@ -0,0 +1,8 @@ +#include <math.h> +#include <complex.h> + +double complex cacos(double complex z) +{ + double complex w = casin(z); + return (M_PI_2 - creal(w)) - cimag(w) * I; +} diff --git a/lib/libm/cacosf.c b/lib/libm/cacosf.c new file mode 100644 index 00000000..f44f0067 --- /dev/null +++ b/lib/libm/cacosf.c @@ -0,0 +1,9 @@ +#include <math.h> +#include <complex.h> + +float complex cacosf(float complex z) +{ + float complex w = casinf(z); + + return ((float)M_PI_2 - crealf(w)) - cimagf(w) * I; +} diff --git a/lib/libm/cacosh.c b/lib/libm/cacosh.c new file mode 100644 index 00000000..00f0e736 --- /dev/null +++ b/lib/libm/cacosh.c @@ -0,0 +1,6 @@ +#include <complex.h> + +double complex cacosh(double complex z) +{ + return clog(z + csqrt(z + 1) * csqrt(z - 1)); +} diff --git a/lib/libm/cacoshf.c b/lib/libm/cacoshf.c new file mode 100644 index 00000000..67c9258b --- /dev/null +++ b/lib/libm/cacoshf.c @@ -0,0 +1,8 @@ +#include <complex.h> + +float complex cacoshf(float complex z) +{ + float complex w; + + return clogf(z + csqrtf(z + 1) * csqrtf(z - 1)); +} diff --git a/lib/libm/cacoshl.c b/lib/libm/cacoshl.c new file mode 100644 index 00000000..abe906ef --- /dev/null +++ b/lib/libm/cacoshl.c @@ -0,0 +1,6 @@ +#include <complex.h> + +long double complex cacoshl(long double complex z) +{ + return clogl(z + csqrtl(z + 1) * csqrtl(z - 1)); +} diff --git a/lib/libm/cacosl.c b/lib/libm/cacosl.c new file mode 100644 index 00000000..c56076b3 --- /dev/null +++ b/lib/libm/cacosl.c @@ -0,0 +1,8 @@ +#include <math.h> +#include <complex.h> + +long double complex cacosl(long double complex z) +{ + long double complex w = casinl(z); + return (M_PI_2 - creall(w)) - cimagl(w) * I; +} diff --git a/lib/libm/carg.c b/lib/libm/carg.c new file mode 100644 index 00000000..634ace3d --- /dev/null +++ b/lib/libm/carg.c @@ -0,0 +1,7 @@ +#include <math.h> +#include <complex.h> + +double carg(double complex z) +{ + return atan2(__imag__ z, __real__ z); +} diff --git a/lib/libm/cargf.c b/lib/libm/cargf.c new file mode 100644 index 00000000..138f19c3 --- /dev/null +++ b/lib/libm/cargf.c @@ -0,0 +1,7 @@ +#include <math.h> +#include <complex.h> + +float cargf(float complex z) +{ + return atan2f(__imag__ z, __real__ z); +} diff --git a/lib/libm/cargl.c b/lib/libm/cargl.c new file mode 100644 index 00000000..9469bf3b --- /dev/null +++ b/lib/libm/cargl.c @@ -0,0 +1,7 @@ +#include <math.h> +#include <complex.h> + +long double cargl(long double complex z) +{ + return atan2l(__imag__ z, __real__ z); +} diff --git a/lib/libm/casin.c b/lib/libm/casin.c new file mode 100644 index 00000000..e23cdd15 --- /dev/null +++ b/lib/libm/casin.c @@ -0,0 +1,23 @@ +#include <complex.h> + +double complex casin(double complex z) +{ + double complex ca, ct, zz, z2; + double x, y; + + x = creal(z); + y = cimag(z); + + ca = x + y * I; + ct = ca * I; + + zz = (x - y) * (x + y) + (2.0 * x * y) * I; + + zz = 1.0 - creal(zz) - cimag(zz) * I; + z2 = csqrt(zz); + + zz = ct + z2; + zz = clog(zz); + + return zz * (-1.0 * I); +} diff --git a/lib/libm/casinf.c b/lib/libm/casinf.c new file mode 100644 index 00000000..b0887029 --- /dev/null +++ b/lib/libm/casinf.c @@ -0,0 +1,21 @@ +#include <complex.h> + +float complex casinf(float complex z) +{ + float complex ca, ct, zz, z2; + float x, y; + + x = crealf(z); + y = cimagf(z); + ca = x + y * I; + ct = ca * I; + zz = (x - y) * (x + y) + (2.0f * x * y) * I; + + zz = 1.0f - crealf(zz) - cimagf(zz) * I; + z2 = csqrtf(zz); + + zz = ct + z2; + zz = clogf(zz); + + return zz * (-1.0f * I); +} diff --git a/lib/libm/casinh.c b/lib/libm/casinh.c new file mode 100644 index 00000000..75b1b5c9 --- /dev/null +++ b/lib/libm/casinh.c @@ -0,0 +1,6 @@ +#include <complex.h> + +double complex casinh(double complex z) +{ + return -1.0 * I * casin(z * I); +} diff --git a/lib/libm/casinhf.c b/lib/libm/casinhf.c new file mode 100644 index 00000000..b35ea8a2 --- /dev/null +++ b/lib/libm/casinhf.c @@ -0,0 +1,6 @@ +#include <complex.h> + +float complex casinhf(float complex z) +{ + return -1.0f * I * casinf(z * I); +} diff --git a/lib/libm/casinhl.c b/lib/libm/casinhl.c new file mode 100644 index 00000000..73c80203 --- /dev/null +++ b/lib/libm/casinhl.c @@ -0,0 +1,6 @@ +#include <complex.h> + +long double complex casinhl(long double complex z) +{ + return -1.0L * I * casinl(z * I); +} diff --git a/lib/libm/casinl.c b/lib/libm/casinl.c new file mode 100644 index 00000000..45c19582 --- /dev/null +++ b/lib/libm/casinl.c @@ -0,0 +1,21 @@ +#include <complex.h> + +long double complex casinl(long double complex z) +{ + long double complex ca, ct, zz, z2; + long double x, y; + + x = creall(z); + y = cimagl(z); + ca = x + y * I; + ct = ca * I; + zz = (x - y) * (x + y) + (2.0L * x * y) * I; + + zz = 1.0L - creall(zz) - cimagl(zz) * I; + z2 = csqrtl(zz); + + zz = ct + z2; + zz = clogl(zz); + + return zz * (-1.0L * I); +} diff --git a/lib/libm/catan.c b/lib/libm/catan.c new file mode 100644 index 00000000..b6880811 --- /dev/null +++ b/lib/libm/catan.c @@ -0,0 +1,35 @@ +#include <float.h> +#include "__complex.h" + +double complex catan(double complex z) +{ + double complex w; + double a, t, x, x2, y; + + x = creal(z); + y = cimag(z); + + if ((x == 0.0) && (y > 1.0)) + goto overflow; + + x2 = x * x; + a = 1.0 - x2 - (y * y); + if (a == 0.0) + goto overflow; + + t = 0.5 * atan2(2.0 * x, a); + w = redupi(t); + + t = y - 1.0; + a = x2 + (t * t); + if (a == 0.0) + goto overflow; + + t = y + 1.0; + a = (x2 + (t * t)) / a; + + return w + (0.25 * log(a)) * I; + +overflow: + return DBL_MAX + DBL_MAX * I; +} diff --git a/lib/libm/catanf.c b/lib/libm/catanf.c new file mode 100644 index 00000000..16d480e0 --- /dev/null +++ b/lib/libm/catanf.c @@ -0,0 +1,35 @@ +#include <float.h> +#include "__complex.h" + +float complex catanf(float complex z) +{ + float complex w; + float a, t, x, x2, y; + + x = crealf(z); + y = cimagf(z); + + if ((x == 0.0f) && (y > 1.0f)) + goto overflow; + + x2 = x * x; + a = 1.0f - x2 - (y * y); + if (a == 0.0f) + goto overflow; + + t = 0.5f * atan2f(2.0f * x, a); + w = redupif(t); + + t = y - 1.0f; + a = x2 + (t * t); + if (a == 0.0f) + goto overflow; + + t = y + 1.0f; + a = (x2 + (t * t)) / a; + + return w + (0.25f * logf(a)) * I; + +overflow: + return FLT_MAX + FLT_MAX * I; +} diff --git a/lib/libm/catanh.c b/lib/libm/catanh.c new file mode 100644 index 00000000..5cfc4fc0 --- /dev/null +++ b/lib/libm/catanh.c @@ -0,0 +1,6 @@ +#include <complex.h> + +double complex catanh(double complex z) +{ + return -1.0 * I * catan(z * I); +} diff --git a/lib/libm/catanhf.c b/lib/libm/catanhf.c new file mode 100644 index 00000000..0f16fc25 --- /dev/null +++ b/lib/libm/catanhf.c @@ -0,0 +1,6 @@ +#include <complex.h> + +float complex catanhf(float complex z) +{ + return -I * catanf(z * I); +} diff --git a/lib/libm/catanhl.c b/lib/libm/catanhl.c new file mode 100644 index 00000000..1fd4275b --- /dev/null +++ b/lib/libm/catanhl.c @@ -0,0 +1,6 @@ +#include <complex.h> + +long double complex catanhl(long double complex z) +{ + return -I * catanl(z * I); +} diff --git a/lib/libm/catanl.c b/lib/libm/catanl.c new file mode 100644 index 00000000..949dc3d9 --- /dev/null +++ b/lib/libm/catanl.c @@ -0,0 +1,34 @@ +#include <float.h> +#include "__complex.h" + +long double complex catanl(long double complex z) +{ + long double complex w; + long double a, t, x, x2, y; + + x = creall(z); + y = cimagl(z); + + if ((x == 0.0L) && (y > 1.0L)) + goto overflow; + + x2 = x * x; + a = 1.0L - x2 - (y * y); + if (a == 0.0) + goto overflow; + + t = 0.5L * atan2l(2.0L * x, a); + w = redupil(t); + + t = y - 1.0L; + a = x2 + (t * t); + if (a == 0.0L) + goto overflow; + + t = y + 1.0L; + a = (x2 + (t * t)) / a; + return w + (0.25L * logl(a)) * I; + +overflow: + return LDBL_MAX + LDBL_MAX * I; +} diff --git a/lib/libm/cbrt.c b/lib/libm/cbrt.c new file mode 100644 index 00000000..9f54517d --- /dev/null +++ b/lib/libm/cbrt.c @@ -0,0 +1,105 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrt.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + * Optimized by Bruce D. Evans. + */ +/* cbrt(x) + * Return cube root of x + */ + +#include <math.h> +#include <stdint.h> + +static const uint32_t B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 + */ + B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */ + +/* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */ +static const double P0 = 1.87595182427177009643, /* 0x3ffe03e6, 0x0f61e692 */ + P1 = -1.88497979543377169875, /* 0xbffe28e0, 0x92f02420 */ + P2 = 1.621429720105354466140, /* 0x3ff9f160, 0x4a49d6c2 */ + P3 = -0.758397934778766047437, /* 0xbfe844cb, 0xbee751d9 */ + P4 = 0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */ + +double cbrt(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + double_t r, s, t, w; + uint32_t hx = u.i >> 32 & 0x7fffffff; + + if (hx >= 0x7ff00000) /* cbrt(NaN,INF) is itself */ + return x + x; + + /* + * Rough cbrt to 5 bits: + * cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3) + * where e is integral and >= 0, m is real and in [0, 1), and "/" and + * "%" are integer division and modulus with rounding towards minus + * infinity. The RHS is always >= the LHS and has a maximum relative + * error of about 1 in 16. Adding a bias of -0.03306235651 to the + * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE + * floating point representation, for finite positive normal values, + * ordinary integer divison of the value in bits magically gives + * almost exactly the RHS of the above provided we first subtract the + * exponent bias (1023 for doubles) and later add it back. We do the + * subtraction virtually to keep e >= 0 so that ordinary integer + * division rounds towards minus infinity; this is also efficient. + */ + if (hx < 0x00100000) { /* zero or subnormal? */ + u.f = x * 0x1p54; + hx = u.i >> 32 & 0x7fffffff; + if (hx == 0) + return x; /* cbrt(0) is itself */ + hx = hx / 3 + B2; + } else + hx = hx / 3 + B1; + u.i &= 1ULL << 63; + u.i |= (uint64_t)hx << 32; + t = u.f; + + /* + * New cbrt to 23 bits: + * cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x) + * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r) + * to within 2**-23.5 when |r - 1| < 1/10. The rough approximation + * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this + * gives us bounds for r = t**3/x. + * + * Try to optimize for parallel evaluation as in __tanf.c. + */ + r = (t * t) * (t / x); + t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4)); + + /* + * Round t away from zero to 23 bits (sloppily except for ensuring that + * the result is larger in magnitude than cbrt(x) but not much more than + * 2 23-bit ulps larger). With rounding towards zero, the error bound + * would be ~5/6 instead of ~4/6. With a maximum error of 2 23-bit ulps + * in the rounded t, the infinite-precision error in the Newton + * approximation barely affects third digit in the final error + * 0.667; the error in the rounded t can be up to about 3 23-bit ulps + * before the final error is larger than 0.667 ulps. + */ + u.f = t; + u.i = (u.i + 0x80000000) & 0xffffffffc0000000ULL; + t = u.f; + + /* one step Newton iteration to 53 bits with error < 0.667 ulps */ + s = t * t; /* t*t is exact */ + r = x / s; /* error <= 0.5 ulps; |r| < |t| */ + w = t + t; /* t+t is exact */ + r = (r - t) / (w + r); /* r-t is exact; w+r ~= 3*t */ + t = t + t * r; /* error <= 0.5 + 0.5/3 + epsilon */ + return t; +} diff --git a/lib/libm/cbrtf.c b/lib/libm/cbrtf.c new file mode 100644 index 00000000..c394310d --- /dev/null +++ b/lib/libm/cbrtf.c @@ -0,0 +1,69 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrtf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Debugged and optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* cbrtf(x) + * Return cube root of x + */ + +#include <math.h> +#include <stdint.h> + +static const unsigned B1 = 709958130, /* B1 = (127-127.0/3-0.03306235651)*2**23 + */ + B2 = 642849266; /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */ + +float cbrtf(float x) +{ + double_t r, T; + union { + float f; + uint32_t i; + } u = { x }; + uint32_t hx = u.i & 0x7fffffff; + + if (hx >= 0x7f800000) /* cbrt(NaN,INF) is itself */ + return x + x; + + /* rough cbrt to 5 bits */ + if (hx < 0x00800000) { /* zero or subnormal? */ + if (hx == 0) + return x; /* cbrt(+-0) is itself */ + u.f = x * 0x1p24f; + hx = u.i & 0x7fffffff; + hx = hx / 3 + B2; + } else + hx = hx / 3 + B1; + u.i &= 0x80000000; + u.i |= hx; + + /* + * First step Newton iteration (solving t*t-x/t == 0) to 16 bits. In + * double precision so that its terms can be arranged for efficiency + * without causing overflow or underflow. + */ + T = u.f; + r = T * T * T; + T = T * ((double_t)x + x + r) / (x + r + r); + + /* + * Second step Newton iteration to 47 bits. In double precision for + * efficiency and accuracy. + */ + r = T * T * T; + T = T * ((double_t)x + x + r) / (x + r + r); + + /* rounding to 24 bits is perfect in round-to-nearest mode */ + return T; +} diff --git a/lib/libm/cbrtl.c b/lib/libm/cbrtl.c new file mode 100644 index 00000000..12c82f03 --- /dev/null +++ b/lib/libm/cbrtl.c @@ -0,0 +1,128 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrtl.c */ +/*- + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * Copyright (c) 2009-2011, Bruce D. Evans, Steven G. Kargl, David Schultz. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + * The argument reduction and testing for exceptional cases was + * written by Steven G. Kargl with input from Bruce D. Evans + * and David A. Schultz. + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double cbrtl(long double x) +{ + return cbrt(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +static const unsigned B1 = 709958130; /* B1 = (127-127.0/3-0.03306235651)*2**23 + */ + +long double cbrtl(long double x) +{ + union ldshape u = { x }, v; + union { + float f; + uint32_t i; + } uft; + long double r, s, t, w; + double_t dr, dt, dx; + float_t ft; + int e = u.i.se & 0x7fff; + int sign = u.i.se & 0x8000; + + /* + * If x = +-Inf, then cbrt(x) = +-Inf. + * If x = NaN, then cbrt(x) = NaN. + */ + if (e == 0x7fff) + return x + x; + if (e == 0) { + /* Adjust subnormal numbers. */ + u.f *= 0x1p120; + e = u.i.se & 0x7fff; + /* If x = +-0, then cbrt(x) = +-0. */ + if (e == 0) + return x; + e -= 120; + } + e -= 0x3fff; + u.i.se = 0x3fff; + x = u.f; + switch (e % 3) { + case 1: + case -2: + x *= 2; + e--; + break; + case 2: + case -1: + x *= 4; + e -= 2; + break; + } + v.f = 1.0; + v.i.se = sign | (0x3fff + e / 3); + + /* + * The following is the guts of s_cbrtf, with the handling of + * special values removed and extra care for accuracy not taken, + * but with most of the extra accuracy not discarded. + */ + + /* ~5-bit estimate: */ + uft.f = x; + uft.i = (uft.i & 0x7fffffff) / 3 + B1; + ft = uft.f; + + /* ~16-bit estimate: */ + dx = x; + dt = ft; + dr = dt * dt * dt; + dt = dt * (dx + dx + dr) / (dx + dr + dr); + + /* ~47-bit estimate: */ + dr = dt * dt * dt; + dt = dt * (dx + dx + dr) / (dx + dr + dr); + +#if LDBL_MANT_DIG == 64 + /* + * dt is cbrtl(x) to ~47 bits (after x has been reduced to 1 <= x < 8). + * Round it away from zero to 32 bits (32 so that t*t is exact, and + * away from zero for technical reasons). + */ + t = dt + (0x1.0p32L + 0x1.0p-31L) - 0x1.0p32; +#elif LDBL_MANT_DIG == 113 + /* + * Round dt away from zero to 47 bits. Since we don't trust the 47, + * add 2 47-bit ulps instead of 1 to round up. Rounding is slow and + * might be avoidable in this case, since on most machines dt will + * have been evaluated in 53-bit precision and the technical reasons + * for rounding up might not apply to either case in cbrtl() since + * dt is much more accurate than needed. + */ + t = dt + 0x2.0p-46 + 0x1.0p60L - 0x1.0p60; +#endif + + /* + * Final step Newton iteration to 64 or 113 bits with + * error < 0.667 ulps + */ + s = t * t; /* t*t is exact */ + r = x / s; /* error <= 0.5 ulps; |r| < |t| */ + w = t + t; /* t+t is exact */ + r = (r - t) / (w + r); /* r-t is exact; w+r ~= 3*t */ + t = t + t * r; /* error <= 0.5 + 0.5/3 + epsilon */ + + t *= v.f; + return t; +} +#endif diff --git a/lib/libm/ccos.c b/lib/libm/ccos.c new file mode 100644 index 00000000..d5a8600d --- /dev/null +++ b/lib/libm/ccos.c @@ -0,0 +1,12 @@ +#include <math.h> +#include <complex.h> +#include "__complex.h" + +double complex ccos(double complex z) +{ + double ch, sh; + + cchsh(cimag(z), &ch, &sh); + + return cos(creal(z)) * ch - (sin(creal(z)) * sh) * I; +} diff --git a/lib/libm/ccosf.c b/lib/libm/ccosf.c new file mode 100644 index 00000000..8d4a8761 --- /dev/null +++ b/lib/libm/ccosf.c @@ -0,0 +1,10 @@ +#include "__complex.h" + +double complex ccos(double complex z) +{ + double ch, sh; + + cchsh(cimag(z), &ch, &sh); + + return cos(creal(z)) * ch - (sin(creal(z)) * sh) * I; +} diff --git a/lib/libm/ccosh.c b/lib/libm/ccosh.c new file mode 100644 index 00000000..9cfff54a --- /dev/null +++ b/lib/libm/ccosh.c @@ -0,0 +1,12 @@ +#include <math.h> +#include <complex.h> + +double complex ccosh(double complex z) +{ + double x, y; + + x = creal(z); + y = cimag(z); + + return cosh(x) * cos(y) + (sinh(x) * sin(y)) * I; +} diff --git a/lib/libm/ccoshf.c b/lib/libm/ccoshf.c new file mode 100644 index 00000000..12fc7e6d --- /dev/null +++ b/lib/libm/ccoshf.c @@ -0,0 +1,12 @@ +#include <math.h> +#include <complex.h> + +float complex ccoshf(float complex z) +{ + float x, y; + + x = crealf(z); + y = cimagf(z); + + return coshf(x) * cosf(y) + (sinhf(x) * sinf(y)) * I; +} diff --git a/lib/libm/ccoshl.c b/lib/libm/ccoshl.c new file mode 100644 index 00000000..ba680068 --- /dev/null +++ b/lib/libm/ccoshl.c @@ -0,0 +1,12 @@ +#include <math.h> +#include <complex.h> + +long double complex ccoshl(long double complex z) +{ + long double x, y; + + x = creall(z); + y = cimagl(z); + + return coshl(x) * cosl(y) + (sinhl(x) * sinl(y)) * I; +} diff --git a/lib/libm/ccosl.c b/lib/libm/ccosl.c new file mode 100644 index 00000000..ee2a3fc0 --- /dev/null +++ b/lib/libm/ccosl.c @@ -0,0 +1,8 @@ +#include "__complex.h" + +long double complex ccosl(long double complex z) +{ + long double ch, sh; + cchshl(cimagl(z), &ch, &sh); + return cosl(creall(z)) * ch - (sinl(creall(z)) * sh) * I; +} diff --git a/lib/libm/ceil.c b/lib/libm/ceil.c new file mode 100644 index 00000000..fdf502ed --- /dev/null +++ b/lib/libm/ceil.c @@ -0,0 +1,34 @@ +#include "libm.h" + +#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif +static const double_t toint = 1 / EPS; + +double ceil(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + int e = u.i >> 52 & 0x7ff; + double_t y; + + if (e >= 0x3ff + 52 || x == 0) + return x; + /* y = int(x) - x, where int(x) is an integer neighbor of x */ + if (u.i >> 63) + y = x - toint + toint - x; + else + y = x + toint - toint - x; + /* special case because of non-nearest rounding modes */ + if (e <= 0x3ff - 1) { + FORCE_EVAL(y); + return u.i >> 63 ? -0.0 : 1; + } + if (y < 0) + return x + y + 1; + return x + y; +} diff --git a/lib/libm/ceilf.c b/lib/libm/ceilf.c new file mode 100644 index 00000000..1d9ffd14 --- /dev/null +++ b/lib/libm/ceilf.c @@ -0,0 +1,30 @@ +#include "libm.h" + +float ceilf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + int e = (int)(u.i >> 23 & 0xff) - 0x7f; + uint32_t m; + + if (e >= 23) + return x; + if (e >= 0) { + m = 0x007fffff >> e; + if ((u.i & m) == 0) + return x; + FORCE_EVAL(x + 0x1p120f); + if (u.i >> 31 == 0) + u.i += m; + u.i &= ~m; + } else { + FORCE_EVAL(x + 0x1p120f); + if (u.i >> 31) + u.f = -0.0; + else if (u.i << 1) + u.f = 1.0; + } + return u.f; +} diff --git a/lib/libm/ceill.c b/lib/libm/ceill.c new file mode 100644 index 00000000..a9e8f28f --- /dev/null +++ b/lib/libm/ceill.c @@ -0,0 +1,34 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double ceill(long double x) +{ + return ceil(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 + +static const long double toint = 1 / LDBL_EPSILON; + +long double ceill(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + long double y; + + if (e >= 0x3fff + LDBL_MANT_DIG - 1 || x == 0) + return x; + /* y = int(x) - x, where int(x) is an integer neighbor of x */ + if (u.i.se >> 15) + y = x - toint + toint - x; + else + y = x + toint - toint - x; + /* special case because of non-nearest rounding modes */ + if (e <= 0x3fff - 1) { + FORCE_EVAL(y); + return u.i.se >> 15 ? -0.0 : 1; + } + if (y < 0) + return x + y + 1; + return x + y; +} +#endif diff --git a/lib/libm/cexp.c b/lib/libm/cexp.c new file mode 100644 index 00000000..b8a4b903 --- /dev/null +++ b/lib/libm/cexp.c @@ -0,0 +1,13 @@ +#include <math.h> +#include <complex.h> + +double complex cexp(double complex z) +{ + double r, x, y; + + x = creal(z); + y = cimag(z); + r = exp(x); + + return r * cos(y) + r * sin(y) * I; +} diff --git a/lib/libm/cexpl.c b/lib/libm/cexpl.c new file mode 100644 index 00000000..0d3bdfb6 --- /dev/null +++ b/lib/libm/cexpl.c @@ -0,0 +1,13 @@ +#include <math.h> +#include <complex.h> + +long double complex cexpl(long double complex z) +{ + long double r, x, y; + + x = creall(z); + y = cimagl(z); + r = expl(x); + + return r * cosl(y) + r * sinl(y) * I; +} diff --git a/lib/libm/cexprf.c b/lib/libm/cexprf.c new file mode 100644 index 00000000..27c5048d --- /dev/null +++ b/lib/libm/cexprf.c @@ -0,0 +1,13 @@ +#include <math.h> +#include <complex.h> + +float complex cexpf(float complex z) +{ + float r, x, y; + + x = crealf(z); + y = cimagf(z); + r = expf(x); + + return r * cosf(y) + r * sinf(y) * I; +} diff --git a/lib/libm/cimag.c b/lib/libm/cimag.c new file mode 100644 index 00000000..88b5fd58 --- /dev/null +++ b/lib/libm/cimag.c @@ -0,0 +1,8 @@ +#include <complex.h> +#include "__complex.h" + +double cimag(double complex z) +{ + double_complex w = { .z = z }; + return (IMAG_PART(w)); +} diff --git a/lib/libm/cimagf.c b/lib/libm/cimagf.c new file mode 100644 index 00000000..465dce6f --- /dev/null +++ b/lib/libm/cimagf.c @@ -0,0 +1,7 @@ +#include "__complex.h" + +float cimagf(float complex z) +{ + float_complex w = { .z = z }; + return (IMAG_PART(w)); +} diff --git a/lib/libm/cimagl.c b/lib/libm/cimagl.c new file mode 100644 index 00000000..5e63ab5d --- /dev/null +++ b/lib/libm/cimagl.c @@ -0,0 +1,7 @@ +#include "__complex.h" + +long double cimagl(long double complex z) +{ + long_double_complex w = { .z = z }; + return IMAG_PART(w); +} diff --git a/lib/libm/clog.c b/lib/libm/clog.c new file mode 100644 index 00000000..a119934b --- /dev/null +++ b/lib/libm/clog.c @@ -0,0 +1,10 @@ +#include "__complex.h" + +double complex clog(double complex z) +{ + double p, rr; + rr = cabs(z); + p = log(rr); + rr = atan2(cimag(z), creal(z)); + return p + rr * (double complex)I; +} diff --git a/lib/libm/clog10.c b/lib/libm/clog10.c new file mode 100644 index 00000000..a1db1663 --- /dev/null +++ b/lib/libm/clog10.c @@ -0,0 +1,11 @@ +#include <math.h> +#include "__complex.h" + +double complex clog10(double complex z) +{ + double p, rr; + rr = cabs(z); + p = log10(rr); + rr = atan2(cimag(z), creal(z)) * M_IVLN10; + return p + rr * (double complex)I; +} diff --git a/lib/libm/clog10f.c b/lib/libm/clog10f.c new file mode 100644 index 00000000..d2994b0d --- /dev/null +++ b/lib/libm/clog10f.c @@ -0,0 +1,12 @@ +#include "__complex.h" + +float complex clog10f(float complex z) +{ + float p, rr; + + rr = cabsf(z); + p = log10f(rr); + rr = atan2f(cimagf(z), crealf(z)) * (float)M_IVLN10; + + return p + rr * I; +} diff --git a/lib/libm/clog10l.c b/lib/libm/clog10l.c new file mode 100644 index 00000000..dde228e2 --- /dev/null +++ b/lib/libm/clog10l.c @@ -0,0 +1,11 @@ +#include "__complex.h" + +long double complex clog10l(long double complex z) +{ + long double p, rr; + rr = cabsl(z); + p = log10l(rr); + rr = atan2l(cimagl(z), creall(z)) * + 0.43429448190325182765112891891660508229439700580366656611445378316586464920887L; + return p + rr * (long double complex)I; +} diff --git a/lib/libm/clogf.c b/lib/libm/clogf.c new file mode 100644 index 00000000..f669c7a4 --- /dev/null +++ b/lib/libm/clogf.c @@ -0,0 +1,12 @@ +#include "__complex.h" + +float complex clogf(float complex z) +{ + float p, rr; + + rr = cabsf(z); + p = logf(rr); + rr = atan2f(cimagf(z), crealf(z)); + + return p + rr * I; +} diff --git a/lib/libm/clogl.c b/lib/libm/clogl.c new file mode 100644 index 00000000..f7e0bf0b --- /dev/null +++ b/lib/libm/clogl.c @@ -0,0 +1,12 @@ +#include "__complex.h" + +long double complex clogl(long double complex z) +{ + long double p, rr; + + rr = cabsl(z); + p = logl(rr); + rr = atan2l(cimagl(z), creall(z)); + + return p + rr * (long double complex)I; +} diff --git a/lib/libm/conj.c b/lib/libm/conj.c new file mode 100644 index 00000000..5982db3f --- /dev/null +++ b/lib/libm/conj.c @@ -0,0 +1,8 @@ +#include "__complex.h" + +double complex conj(double complex z) +{ + double_complex w = { .z = z }; + IMAG_PART(w) = -IMAG_PART(w); + return (w.z); +} diff --git a/lib/libm/conjf.c b/lib/libm/conjf.c new file mode 100644 index 00000000..d7c6f4cd --- /dev/null +++ b/lib/libm/conjf.c @@ -0,0 +1,8 @@ +#include "__complex.h" + +float complex conjf(float complex z) +{ + float_complex w = { .z = z }; + IMAG_PART(w) = -IMAG_PART(w); + return (w.z); +} diff --git a/lib/libm/conjl.c b/lib/libm/conjl.c new file mode 100644 index 00000000..4e633057 --- /dev/null +++ b/lib/libm/conjl.c @@ -0,0 +1,8 @@ +#include "__complex.h" + +long double complex conjl(long double complex z) +{ + long_double_complex w = { .z = z }; + IMAG_PART(w) = -IMAG_PART(w); + return (w.z); +} diff --git a/lib/libm/copysign.c b/lib/libm/copysign.c new file mode 100644 index 00000000..26982cea --- /dev/null +++ b/lib/libm/copysign.c @@ -0,0 +1,12 @@ +#include "libm.h" + +double copysign(double x, double y) +{ + union { + double f; + uint64_t i; + } ux = { x }, uy = { y }; + ux.i &= -1ULL / 2; + ux.i |= uy.i & 1ULL << 63; + return ux.f; +} diff --git a/lib/libm/copysignf.c b/lib/libm/copysignf.c new file mode 100644 index 00000000..d71c9a5f --- /dev/null +++ b/lib/libm/copysignf.c @@ -0,0 +1,13 @@ +#include <math.h> +#include <stdint.h> + +float copysignf(float x, float y) +{ + union { + float f; + uint32_t i; + } ux = { x }, uy = { y }; + ux.i &= 0x7fffffff; + ux.i |= uy.i & 0x80000000; + return ux.f; +} diff --git a/lib/libm/copysignl.c b/lib/libm/copysignl.c new file mode 100644 index 00000000..e5e40285 --- /dev/null +++ b/lib/libm/copysignl.c @@ -0,0 +1,16 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double copysignl(long double x, long double y) +{ + return copysign(x, y); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double copysignl(long double x, long double y) +{ + union ldshape ux = { x }, uy = { y }; + ux.i.se &= 0x7fff; + ux.i.se |= uy.i.se & 0x8000; + return ux.f; +} +#endif diff --git a/lib/libm/cos.c b/lib/libm/cos.c new file mode 100644 index 00000000..e3b3a6fe --- /dev/null +++ b/lib/libm/cos.c @@ -0,0 +1,80 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_cos.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* cos(x) + * Return cosine function of x. + * + * kernel function: + * __sin ... sine function on [-pi/4,pi/4] + * __cos ... cosine function on [-pi/4,pi/4] + * __rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "libm.h" + +double cos(double x) +{ + double y[2]; + uint32_t ix; + unsigned n; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + + /* |x| ~< pi/4 */ + if (ix <= 0x3fe921fb) { + if (ix < 0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ + /* raise inexact if x!=0 */ + FORCE_EVAL(x + 0x1p120f); + return 1.0; + } + return __cos(x, 0); + } + + /* cos(Inf or NaN) is NaN */ + if (ix >= 0x7ff00000) + return x - x; + + /* argument reduction */ + n = __rem_pio2(x, y); + switch (n & 3) { + case 0: + return __cos(y[0], y[1]); + case 1: + return -__sin(y[0], y[1], 1); + case 2: + return -__cos(y[0], y[1]); + default: + return __sin(y[0], y[1], 1); + } +} diff --git a/lib/libm/cosf.c b/lib/libm/cosf.c new file mode 100644 index 00000000..d49dc0ac --- /dev/null +++ b/lib/libm/cosf.c @@ -0,0 +1,80 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_cosf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +/* Small multiples of pi/2 rounded to double precision. */ +static const double c1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */ + c2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */ + c3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */ + c4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */ + +float cosf(float x) +{ + double y; + uint32_t ix; + unsigned n, sign; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + + if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */ + if (ix < 0x39800000) { /* |x| < 2**-12 */ + /* raise inexact if x != 0 */ + FORCE_EVAL(x + 0x1p120f); + return 1.0f; + } + return __cosdf(x); + } + if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */ + if (ix > 0x4016cbe3) /* |x| ~> 3*pi/4 */ + return -__cosdf(sign ? x + c2pio2 : x - c2pio2); + else { + if (sign) + return __sindf(x + c1pio2); + else + return __sindf(c1pio2 - x); + } + } + if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */ + if (ix > 0x40afeddf) /* |x| ~> 7*pi/4 */ + return __cosdf(sign ? x + c4pio2 : x - c4pio2); + else { + if (sign) + return __sindf(-x - c3pio2); + else + return __sindf(x - c3pio2); + } + } + + /* cos(Inf or NaN) is NaN */ + if (ix >= 0x7f800000) + return x - x; + + /* general argument reduction needed */ + n = __rem_pio2f(x, &y); + switch (n & 3) { + case 0: + return __cosdf(y); + case 1: + return __sindf(-y); + case 2: + return -__cosdf(y); + default: + return __sindf(y); + } +} diff --git a/lib/libm/cosh.c b/lib/libm/cosh.c new file mode 100644 index 00000000..7684d2fa --- /dev/null +++ b/lib/libm/cosh.c @@ -0,0 +1,43 @@ +#include "libm.h" + +/* cosh(x) = (exp(x) + 1/exp(x))/2 + * = 1 + 0.5*(exp(x)-1)*(exp(x)-1)/exp(x) + * = 1 + x*x/2 + o(x^4) + */ +double cosh(double x) +{ + union { + double f; + uint64_t i; + } u = { .f = x }; + uint32_t w; + double t; + + /* |x| */ + u.i &= (uint64_t)-1 / 2; + x = u.f; + w = u.i >> 32; + + /* |x| < log(2) */ + if (w < 0x3fe62e42) { + if (w < 0x3ff00000 - (26 << 20)) { + /* raise inexact if x!=0 */ + FORCE_EVAL(x + 0x1p120f); + return 1; + } + t = expm1(x); + return 1 + t * t / (2 * (1 + t)); + } + + /* |x| < log(DBL_MAX) */ + if (w < 0x40862e42) { + t = exp(x); + /* note: if x>log(0x1p26) then the 1/t is not needed */ + return 0.5 * (t + 1 / t); + } + + /* |x| > log(DBL_MAX) or nan */ + /* note: the result is stored to handle overflow */ + t = __expo2(x, 1.0); + return t; +} diff --git a/lib/libm/coshf.c b/lib/libm/coshf.c new file mode 100644 index 00000000..451e6928 --- /dev/null +++ b/lib/libm/coshf.c @@ -0,0 +1,36 @@ +#include "libm.h" + +float coshf(float x) +{ + union { + float f; + uint32_t i; + } u = { .f = x }; + uint32_t w; + float t; + + /* |x| */ + u.i &= 0x7fffffff; + x = u.f; + w = u.i; + + /* |x| < log(2) */ + if (w < 0x3f317217) { + if (w < 0x3f800000 - (12 << 23)) { + FORCE_EVAL(x + 0x1p120f); + return 1; + } + t = expm1f(x); + return 1 + t * t / (2 * (1 + t)); + } + + /* |x| < log(FLT_MAX) */ + if (w < 0x42b17217) { + t = expf(x); + return 0.5f * (t + 1 / t); + } + + /* |x| > log(FLT_MAX) or nan */ + t = __expo2f(x, 1.0f); + return t; +} diff --git a/lib/libm/coshl.c b/lib/libm/coshl.c new file mode 100644 index 00000000..d1eb74ae --- /dev/null +++ b/lib/libm/coshl.c @@ -0,0 +1,47 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double coshl(long double x) +{ + return cosh(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +long double coshl(long double x) +{ + union ldshape u = { x }; + unsigned ex = u.i.se & 0x7fff; + uint32_t w; + long double t; + + /* |x| */ + u.i.se = ex; + x = u.f; + w = u.i.m >> 32; + + /* |x| < log(2) */ + if (ex < 0x3fff - 1 || (ex == 0x3fff - 1 && w < 0xb17217f7)) { + if (ex < 0x3fff - 32) { + FORCE_EVAL(x + 0x1p120f); + return 1; + } + t = expm1l(x); + return 1 + t * t / (2 * (1 + t)); + } + + /* |x| < log(LDBL_MAX) */ + if (ex < 0x3fff + 13 || (ex == 0x3fff + 13 && w < 0xb17217f7)) { + t = expl(x); + return 0.5 * (t + 1 / t); + } + + /* |x| > log(LDBL_MAX) or nan */ + t = expl(0.5 * x); + return 0.5 * t * t; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double coshl(long double x) +{ + return cosh(x); +} +#endif diff --git a/lib/libm/cosl.c b/lib/libm/cosl.c new file mode 100644 index 00000000..08e0d997 --- /dev/null +++ b/lib/libm/cosl.c @@ -0,0 +1,40 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double cosl(long double x) +{ + return cos(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double cosl(long double x) +{ + union ldshape u = { x }; + unsigned n; + long double y[2], hi, lo; + + u.i.se &= 0x7fff; + if (u.i.se == 0x7fff) + return x - x; + x = u.f; + if (x < M_PI_4) { + if (u.i.se < 0x3fff - LDBL_MANT_DIG) + /* raise inexact if x!=0 */ + return 1.0 + x; + return __cosl(x, 0); + } + n = __rem_pio2l(x, y); + hi = y[0]; + lo = y[1]; + switch (n & 3) { + case 0: + return __cosl(hi, lo); + case 1: + return -__sinl(hi, lo, 1); + case 2: + return -__cosl(hi, lo); + case 3: + default: + return __sinl(hi, lo, 1); + } +} +#endif diff --git a/lib/libm/cpow.c b/lib/libm/cpow.c new file mode 100644 index 00000000..d4aff129 --- /dev/null +++ b/lib/libm/cpow.c @@ -0,0 +1,20 @@ +#include "__complex.h" + +double complex cpow(double complex a, double complex z) +{ + double x, y, r, theta, absa, arga; + x = creal(z); + y = cimag(z); + absa = cabs(a); + if (absa == 0.0) { + return (0.0 + 0.0 * (double complex)I); + } + arga = carg(a); + r = pow(absa, x); + theta = x * arga; + if (y != 0.0) { + r = r * exp(-y * arga); + theta = theta + y * log(absa); + } + return r * cos(theta) + (r * sin(theta)) * (double complex)I; +} diff --git a/lib/libm/cpowf.c b/lib/libm/cpowf.c new file mode 100644 index 00000000..9bab4e8e --- /dev/null +++ b/lib/libm/cpowf.c @@ -0,0 +1,20 @@ +#include "__complex.h" + +float complex cpowf(float complex a, float complex z) +{ + float x, y, r, theta, absa, arga; + x = crealf(z); + y = cimagf(z); + absa = cabsf(a); + if (absa == 0.0f) { + return (0.0f + 0.0f * I); + } + arga = cargf(a); + r = powf(absa, x); + theta = x * arga; + if (y != 0.0f) { + r = r * expf(-y * arga); + theta = theta + y * logf(absa); + } + return r * cosf(theta) + (r * sinf(theta)) * I; +} diff --git a/lib/libm/cpowl.c b/lib/libm/cpowl.c new file mode 100644 index 00000000..b7471f0a --- /dev/null +++ b/lib/libm/cpowl.c @@ -0,0 +1,20 @@ +#include "__complex.h" + +long double complex cpowl(long double complex a, long double complex z) +{ + long double x, y, r, theta, absa, arga; + x = creall(z); + y = cimagl(z); + absa = cabsl(a); + if (absa == 0.0L) { + return (0.0L + 0.0L * (long double complex)I); + } + arga = cargl(a); + r = powl(absa, x); + theta = x * arga; + if (y != 0.0L) { + r = r * expl(-y * arga); + theta = theta + y * logl(absa); + } + return r * cosl(theta) + (r * sinl(theta)) * (long double complex)I; +} diff --git a/lib/libm/cproj.c b/lib/libm/cproj.c new file mode 100644 index 00000000..db16721f --- /dev/null +++ b/lib/libm/cproj.c @@ -0,0 +1,11 @@ +#include "__complex.h" + +double complex cproj(double complex z) +{ + double_complex w = { .z = z }; + if (isinf(creal(z)) || isinf(cimag(z))) { + REAL_PART(w) = (double)INFINITY; + IMAG_PART(w) = copysign(0.0, cimag(z)); + } + return (w.z); +} diff --git a/lib/libm/cprojl.c b/lib/libm/cprojl.c new file mode 100644 index 00000000..80c675ca --- /dev/null +++ b/lib/libm/cprojl.c @@ -0,0 +1,13 @@ +#include "__complex.h" + +long double complex cprojl(long double complex z) +{ + long_double_complex w = { .z = z }; + + if (isinf(creall(z)) || isinf(cimagl(z))) { + REAL_PART(w) = (long double)INFINITY; + IMAG_PART(w) = copysignl(0.0L, cimagl(z)); + } + + return (w.z); +} diff --git a/lib/libm/creal.c b/lib/libm/creal.c new file mode 100644 index 00000000..03ec4c28 --- /dev/null +++ b/lib/libm/creal.c @@ -0,0 +1,7 @@ +#include "__complex.h" + +double creal(double complex z) +{ + double_complex w = { .z = z }; + return (REAL_PART(w)); +} diff --git a/lib/libm/crealf.c b/lib/libm/crealf.c new file mode 100644 index 00000000..e9b07f57 --- /dev/null +++ b/lib/libm/crealf.c @@ -0,0 +1,7 @@ +#include "__complex.h" + +float crealf(float complex z) +{ + float_complex w = { .z = z }; + return (REAL_PART(w)); +} diff --git a/lib/libm/creall.c b/lib/libm/creall.c new file mode 100644 index 00000000..4a340485 --- /dev/null +++ b/lib/libm/creall.c @@ -0,0 +1,7 @@ +#include "__complex.h" + +long double creall(long double complex z) +{ + long_double_complex w = { .z = z }; + return (REAL_PART(w)); +} diff --git a/lib/libm/csin.c b/lib/libm/csin.c new file mode 100644 index 00000000..1299f10a --- /dev/null +++ b/lib/libm/csin.c @@ -0,0 +1,8 @@ +#include "__complex.h" + +double complex csin(double complex z) +{ + double ch, sh; + cchsh(cimag(z), &ch, &sh); + return sin(creal(z)) * ch + (cos(creal(z)) * sh) * (double complex)I; +} diff --git a/lib/libm/csinf.c b/lib/libm/csinf.c new file mode 100644 index 00000000..34d072b8 --- /dev/null +++ b/lib/libm/csinf.c @@ -0,0 +1,8 @@ +#include "__complex.h" + +float complex csinf(float complex z) +{ + float ch, sh; + cchshf(cimagf(z), &ch, &sh); + return sinf(crealf(z)) * ch + (cosf(crealf(z)) * sh) * I; +} diff --git a/lib/libm/csinh.c b/lib/libm/csinh.c new file mode 100644 index 00000000..f03b61c0 --- /dev/null +++ b/lib/libm/csinh.c @@ -0,0 +1,11 @@ +#include "__complex.h" + +double complex csinh(double complex z) +{ + double x, y; + + x = creal(z); + y = cimag(z); + + return sinh(x) * cos(y) + (cosh(x) * sin(y)) * (double complex)I; +} diff --git a/lib/libm/csinhf.c b/lib/libm/csinhf.c new file mode 100644 index 00000000..695f170e --- /dev/null +++ b/lib/libm/csinhf.c @@ -0,0 +1,11 @@ +#include "__complex.h" + +float complex csinhf(float complex z) +{ + float x, y; + + x = crealf(z); + y = cimagf(z); + + return sinhf(x) * cosf(y) + (coshf(x) * sinf(y)) * I; +} diff --git a/lib/libm/csinhl.c b/lib/libm/csinhl.c new file mode 100644 index 00000000..3b840339 --- /dev/null +++ b/lib/libm/csinhl.c @@ -0,0 +1,12 @@ +#include "__complex.h" + +long double complex csinhl(long double complex z) +{ + long double x, y; + + x = creall(z); + y = cimagl(z); + + return sinhl(x) * cosl(y) + + (coshl(x) * sinl(y)) * (long double complex)I; +} diff --git a/lib/libm/csinl.c b/lib/libm/csinl.c new file mode 100644 index 00000000..df049bcc --- /dev/null +++ b/lib/libm/csinl.c @@ -0,0 +1,9 @@ +#include "__complex.h" + +long double complex csinl(long double complex z) +{ + long double ch, sh; + cchshl(cimagl(z), &ch, &sh); + return sinl(creall(z)) * ch + + (cosl(creall(z)) * sh) * (long double complex)I; +} diff --git a/lib/libm/csqrt.c b/lib/libm/csqrt.c new file mode 100644 index 00000000..e98cb7c6 --- /dev/null +++ b/lib/libm/csqrt.c @@ -0,0 +1,60 @@ +#include "__complex.h" + +double complex csqrt(double complex z) +{ + double complex w; + double x, y, r, t, scale; + + x = creal(z); + y = cimag(z); + if (y == 0.0) { + if (x == 0.0) { + return 0.0 + y * (double complex)I; + } else { + r = fabs(x); + r = sqrt(r); + if (x < 0.0) { + return 0.0 + r * (double complex)I; + } else { + return r + y * (double complex)I; + } + } + } + + if (x == 0.0) { + r = fabs(y); + r = sqrt(0.5 * r); + + if (y > 0) + return r + r * (double complex)I; + else + return r - r * (double complex)I; + } + + if ((fabs(x) > 4.0) || (fabs(y) > 4.0)) { + x *= 0.25; + y *= 0.25; + scale = 2.0; + } else { + x *= 1.8014398509481984e16; /* 2^54 */ + y *= 1.8014398509481984e16; + scale = 7.450580596923828125e-9; /* 2^-27 */ + } + + w = x + y * (double complex)I; + r = cabs(w); + if (x > 0) { + t = sqrt(0.5 * r + 0.5 * x); + r = scale * fabs((0.5 * y) / t); + t *= scale; + } else { + r = sqrt(0.5 * r - 0.5 * x); + t = scale * fabs((0.5 * y) / r); + r *= scale; + } + + if (y < 0) + return t - r * (double complex)I; + else + return t + r * (double complex)I; +} diff --git a/lib/libm/csqrtf.c b/lib/libm/csqrtf.c new file mode 100644 index 00000000..4ea894ab --- /dev/null +++ b/lib/libm/csqrtf.c @@ -0,0 +1,55 @@ +#include "__complex.h" + +float complex csqrtf(float complex z) +{ + float complex w; + float x, y, r, t, scale; + + x = crealf(z); + y = cimagf(z); + if (y == 0.0f) { + if (x < 0.0f) { + return 0.0f + sqrtf(-x) * I; + } else if (x == 0.0f) { + return (0.0f + y * I); + } else { + return sqrtf(x) + y * I; + } + } + + if (x == 0.0f) { + r = fabsf(y); + r = sqrtf(0.5f * r); + if (y > 0) + return r + r * I; + else + return r - r * I; + } + + if ((fabsf(x) > 4.0f) || (fabsf(y) > 4.0f)) { + x *= 0.25f; + y *= 0.25f; + scale = 2.0f; + } else { + x *= 6.7108864e7f; /* 2^26 */ + y *= 6.7108864e7f; + scale = 1.220703125e-4f; /* 2^-13 */ + } + + w = x + y * I; + r = cabsf(w); + if (x > 0) { + t = sqrtf(0.5f * r + 0.5f * x); + r = scale * fabsf((0.5f * y) / t); + t *= scale; + } else { + r = sqrtf(0.5f * r - 0.5f * x); + t = scale * fabsf((0.5f * y) / r); + r *= scale; + } + + if (y < 0) + return t - r * I; + else + return t + r * I; +} diff --git a/lib/libm/csqrtl.c b/lib/libm/csqrtl.c new file mode 100644 index 00000000..335e51d6 --- /dev/null +++ b/lib/libm/csqrtl.c @@ -0,0 +1,62 @@ +#include <stdbool.h> +#include <float.h> +#include "__complex.h" + +#define THRESH (LDBL_MAX / 2.414213562373095048801688724209698L) +#define cpackl(r, i) ((r) + (i) * (long double complex)I) + +long double complex csqrtl(long double complex z) +{ + long double complex result; + long double a, b; + long double t; + bool scale; + a = creall(z); + b = cimagl(z); + /* Handle special cases. */ + if (z == 0.0L) + return (cpackl((long double)0.0L, b)); + if (isinf(b)) + return (cpackl((long double)INFINITY, b)); + if (isnan(a)) { + t = (b - b) / (b - b); /* raise invalid if b is not a NaN */ + return (cpackl(a, t)); /* return NaN + NaN i */ + } + if (isinf(a)) { + /* + * csqrt(inf + NaN i) = inf + NaN i + * csqrt(inf + y i) = inf + 0 i + * csqrt(-inf + NaN i) = NaN +- inf i + * csqrt(-inf + y i) = 0 + inf i + */ + if (signbit(a)) + return (cpackl(fabsl(b - b), copysignl(a, b))); + else + return (cpackl(a, copysignl(b - b, b))); + } + /* + * The remaining special case (b is NaN) is handled just fine by + * the normal code path below. + */ + /* Scale to avoid overflow. */ + if (fabsl(a) >= THRESH || fabsl(b) >= THRESH) { + a *= 0.25L; + b *= 0.25L; + scale = true; + } else { + scale = false; + } + /* Algorithm 312, CACM vol 10, Oct 1967. */ + if (a >= 0L) { + t = sqrtl((a + hypotl(a, b)) * 0.5L); + result = cpackl(t, b / (2.0L * t)); + } else { + t = sqrtl((-a + hypotl(a, b)) * 0.5L); + result = cpackl(fabsl(b) / (2.0L * t), copysignl(t, b)); + } + /* Rescale. */ + if (scale) + return (result * 2.0L); + else + return (result); +} diff --git a/lib/libm/ctan.c b/lib/libm/ctan.c new file mode 100644 index 00000000..2bc6156c --- /dev/null +++ b/lib/libm/ctan.c @@ -0,0 +1,53 @@ +#include "__complex.h" + +double _ctans(double complex z) +{ + double f, x, x2, y, y2, rn, t; + double d; + x = fabs(2.0 * creal(z)); + y = fabs(2.0 * cimag(z)); + x = redupi(x); + x = x * x; + y = y * y; + x2 = 1.0; + y2 = 1.0; + f = 1.0; + rn = 0.0; + d = 0.0; + do { + rn += 1.0; + f *= rn; + rn += 1.0; + f *= rn; + x2 *= x; + y2 *= y; + t = y2 + x2; + t /= f; + d += t; + rn += 1.0; + f *= rn; + rn += 1.0; + f *= rn; + x2 *= x; + y2 *= y; + t = y2 - x2; + t /= f; + d += t; + } while (fabs(t / d) > MACHEP); + return d; +} + +double complex ctan(double complex z) +{ + double d = cos(2.0 * creal(z)) + cosh(2.0 * cimag(z)); + + if (fabs(d) < 0.25) + d = _ctans(z); + + if (d == 0.0) { + return HUGE_VAL + HUGE_VAL * (double complex)I; + } + + return sin(2.0 * creal(z)) / d + + (sinh(2.0 * cimag(z)) / d) * (double complex)I; +} diff --git a/lib/libm/ctanf.c b/lib/libm/ctanf.c new file mode 100644 index 00000000..fe117d7a --- /dev/null +++ b/lib/libm/ctanf.c @@ -0,0 +1,56 @@ +#include "__complex.h" + +static float _ctansf(float complex z) +{ + float f, x, x2, y, y2, rn, t, d; + + x = fabsf(2.0f * crealf(z)); + y = fabsf(2.0f * cimagf(z)); + x = redupif(x); + x = x * x; + y = y * y; + + x2 = 1.0f; + y2 = 1.0f; + f = 1.0f; + rn = 0.0f; + d = 0.0f; + + do { + rn += 1.0f; + f *= rn; + rn += 1.0f; + f *= rn; + x2 *= x; + y2 *= y; + t = y2 + x2; + t /= f; + d += t; + + rn += 1.0f; + f *= rn; + rn += 1.0f; + f *= rn; + x2 *= x; + y2 *= y; + t = y2 - x2; + t /= f; + d += t; + } while (fabsf(t / d) > MACHEPF); + + return d; +} + +float complex ctanf(float complex z) +{ + float f = cosf(2.0f * crealf(z)) + coshf(2.0f * cimagf(z)); + + if (fabsf(f) < 0.25f) + f = _ctansf(z); + + if (f == 0.0f) { + return HUGE_VALF + HUGE_VALF * I; + } + + return sinf(2.0f * crealf(z)) / f + (sinhf(2.0f * cimagf(z)) / f) * I; +} diff --git a/lib/libm/ctanh.c b/lib/libm/ctanh.c new file mode 100644 index 00000000..a99e1496 --- /dev/null +++ b/lib/libm/ctanh.c @@ -0,0 +1,13 @@ +#include <math.h> +#include <complex.h> + +double complex ctanh(double complex z) +{ + double x, y, d; + + x = creal(z); + y = cimag(z); + d = cosh(2.0 * x) + cos(2.0 * y); + + return sinh(2.0 * x) / d + (sin(2.0 * y) / d) * (double complex)I; +} diff --git a/lib/libm/ctanhf.c b/lib/libm/ctanhf.c new file mode 100644 index 00000000..6574e2c5 --- /dev/null +++ b/lib/libm/ctanhf.c @@ -0,0 +1,13 @@ +#include <math.h> +#include <complex.h> + +float complex ctanhf(float complex z) +{ + float x, y, d; + + x = crealf(z); + y = cimagf(z); + d = coshf(2.0f * x) + cosf(2.0f * y); + + return sinhf(2.0f * x) / d + (sinf(2.0f * y) / d) * I; +} diff --git a/lib/libm/ctanhl.c b/lib/libm/ctanhl.c new file mode 100644 index 00000000..9b798080 --- /dev/null +++ b/lib/libm/ctanhl.c @@ -0,0 +1,14 @@ +#include <math.h> +#include <complex.h> + +long double complex ctanhl(long double complex z) +{ + long double x, y, d; + + x = creall(z); + y = cimagl(z); + d = coshl(2.0L * x) + cosl(2.0L * y); + + return sinhl(2.0L * x) / d + + (sinl(2.0L * y) / d) * (long double complex)I; +} diff --git a/lib/libm/ctanl.c b/lib/libm/ctanl.c new file mode 100644 index 00000000..a410db0e --- /dev/null +++ b/lib/libm/ctanl.c @@ -0,0 +1,17 @@ +#include "__complex.h" + +long double complex ctanl(long double complex z) +{ + long double d = cosl(2.0L * creall(z)) + coshl(2.0L * cimagl(z)); + + if (fabsl(d) < 0.25L) { + d = ctansl(z); + } + + if (d == 0.0L) { + return HUGE_VALL + HUGE_VALL * (long double complex)I; + } + + return sinl(2.0L * creall(z)) / d + + (sinhl(2.0L * cimagl(z)) / d) * (long double complex)I; +} diff --git a/lib/libm/erf.c b/lib/libm/erf.c new file mode 100644 index 00000000..4a096387 --- /dev/null +++ b/lib/libm/erf.c @@ -0,0 +1,293 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_erf.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* double erf(double x) + * double erfc(double x) + * x + * 2 |\ + * erf(x) = --------- | exp(-t*t)dt + * sqrt(pi) \| + * 0 + * + * erfc(x) = 1-erf(x) + * Note that + * erf(-x) = -erf(x) + * erfc(-x) = 2 - erfc(x) + * + * Method: + * 1. For |x| in [0, 0.84375] + * erf(x) = x + x*R(x^2) + * erfc(x) = 1 - erf(x) if x in [-.84375,0.25] + * = 0.5 + ((0.5-x)-x*R) if x in [0.25,0.84375] + * where R = P/Q where P is an odd poly of degree 8 and + * Q is an odd poly of degree 10. + * -57.90 + * | R - (erf(x)-x)/x | <= 2 + * + * + * Remark. The formula is derived by noting + * erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....) + * and that + * 2/sqrt(pi) = 1.128379167095512573896158903121545171688 + * is close to one. The interval is chosen because the fix + * point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is + * near 0.6174), and by some experiment, 0.84375 is chosen to + * guarantee the error is less than one ulp for erf. + * + * 2. For |x| in [0.84375,1.25], let s = |x| - 1, and + * c = 0.84506291151 rounded to single (24 bits) + * erf(x) = sign(x) * (c + P1(s)/Q1(s)) + * erfc(x) = (1-c) - P1(s)/Q1(s) if x > 0 + * 1+(c+P1(s)/Q1(s)) if x < 0 + * |P1/Q1 - (erf(|x|)-c)| <= 2**-59.06 + * Remark: here we use the taylor series expansion at x=1. + * erf(1+s) = erf(1) + s*Poly(s) + * = 0.845.. + P1(s)/Q1(s) + * That is, we use rational approximation to approximate + * erf(1+s) - (c = (single)0.84506291151) + * Note that |P1/Q1|< 0.078 for x in [0.84375,1.25] + * where + * P1(s) = degree 6 poly in s + * Q1(s) = degree 6 poly in s + * + * 3. For x in [1.25,1/0.35(~2.857143)], + * erfc(x) = (1/x)*exp(-x*x-0.5625+R1/S1) + * erf(x) = 1 - erfc(x) + * where + * R1(z) = degree 7 poly in z, (z=1/x^2) + * S1(z) = degree 8 poly in z + * + * 4. For x in [1/0.35,28] + * erfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0 + * = 2.0 - (1/x)*exp(-x*x-0.5625+R2/S2) if -6<x<0 + * = 2.0 - tiny (if x <= -6) + * erf(x) = sign(x)*(1.0 - erfc(x)) if x < 6, else + * erf(x) = sign(x)*(1.0 - tiny) + * where + * R2(z) = degree 6 poly in z, (z=1/x^2) + * S2(z) = degree 7 poly in z + * + * Note1: + * To compute exp(-x*x-0.5625+R/S), let s be a single + * precision number and s := x; then + * -x*x = -s*s + (s-x)*(s+x) + * exp(-x*x-0.5626+R/S) = + * exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S); + * Note2: + * Here 4 and 5 make use of the asymptotic series + * exp(-x*x) + * erfc(x) ~ ---------- * ( 1 + Poly(1/x^2) ) + * x*sqrt(pi) + * We use rational approximation to approximate + * g(s)=f(1/x^2) = log(erfc(x)*x) - x*x + 0.5625 + * Here is the error bound for R1/S1 and R2/S2 + * |R1/S1 - f(x)| < 2**(-62.57) + * |R2/S2 - f(x)| < 2**(-61.52) + * + * 5. For inf > x >= 28 + * erf(x) = sign(x) *(1 - tiny) (raise inexact) + * erfc(x) = tiny*tiny (raise underflow) if x > 0 + * = 2 - tiny if x<0 + * + * 7. Special case: + * erf(0) = 0, erf(inf) = 1, erf(-inf) = -1, + * erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2, + * erfc/erf(NaN) is NaN + */ + +#include "libm.h" + +static const double erx = 8.45062911510467529297e-01, /* 0x3FEB0AC1, 0x60000000 + */ + /* + * Coefficients for approximation to erf on [0,0.84375] + */ + efx8 = 1.02703333676410069053e+00, /* 0x3FF06EBA, 0x8214DB69 */ + pp0 = 1.28379167095512558561e-01, /* 0x3FC06EBA, 0x8214DB68 */ + pp1 = -3.25042107247001499370e-01, /* 0xBFD4CD7D, 0x691CB913 */ + pp2 = -2.84817495755985104766e-02, /* 0xBF9D2A51, 0xDBD7194F */ + pp3 = -5.77027029648944159157e-03, /* 0xBF77A291, 0x236668E4 */ + pp4 = -2.37630166566501626084e-05, /* 0xBEF8EAD6, 0x120016AC */ + qq1 = 3.97917223959155352819e-01, /* 0x3FD97779, 0xCDDADC09 */ + qq2 = 6.50222499887672944485e-02, /* 0x3FB0A54C, 0x5536CEBA */ + qq3 = 5.08130628187576562776e-03, /* 0x3F74D022, 0xC4D36B0F */ + qq4 = 1.32494738004321644526e-04, /* 0x3F215DC9, 0x221C1A10 */ + qq5 = -3.96022827877536812320e-06, /* 0xBED09C43, 0x42A26120 */ + /* + * Coefficients for approximation to erf in [0.84375,1.25] + */ + pa0 = -2.36211856075265944077e-03, /* 0xBF6359B8, 0xBEF77538 */ + pa1 = 4.14856118683748331666e-01, /* 0x3FDA8D00, 0xAD92B34D */ + pa2 = -3.72207876035701323847e-01, /* 0xBFD7D240, 0xFBB8C3F1 */ + pa3 = 3.18346619901161753674e-01, /* 0x3FD45FCA, 0x805120E4 */ + pa4 = -1.10894694282396677476e-01, /* 0xBFBC6398, 0x3D3E28EC */ + pa5 = 3.54783043256182359371e-02, /* 0x3FA22A36, 0x599795EB */ + pa6 = -2.16637559486879084300e-03, /* 0xBF61BF38, 0x0A96073F */ + qa1 = 1.06420880400844228286e-01, /* 0x3FBB3E66, 0x18EEE323 */ + qa2 = 5.40397917702171048937e-01, /* 0x3FE14AF0, 0x92EB6F33 */ + qa3 = 7.18286544141962662868e-02, /* 0x3FB2635C, 0xD99FE9A7 */ + qa4 = 1.26171219808761642112e-01, /* 0x3FC02660, 0xE763351F */ + qa5 = 1.36370839120290507362e-02, /* 0x3F8BEDC2, 0x6B51DD1C */ + qa6 = 1.19844998467991074170e-02, /* 0x3F888B54, 0x5735151D */ + /* + * Coefficients for approximation to erfc in [1.25,1/0.35] + */ + ra0 = -9.86494403484714822705e-03, /* 0xBF843412, 0x600D6435 */ + ra1 = -6.93858572707181764372e-01, /* 0xBFE63416, 0xE4BA7360 */ + ra2 = -1.05586262253232909814e+01, /* 0xC0251E04, 0x41B0E726 */ + ra3 = -6.23753324503260060396e+01, /* 0xC04F300A, 0xE4CBA38D */ + ra4 = -1.62396669462573470355e+02, /* 0xC0644CB1, 0x84282266 */ + ra5 = -1.84605092906711035994e+02, /* 0xC067135C, 0xEBCCABB2 */ + ra6 = -8.12874355063065934246e+01, /* 0xC0545265, 0x57E4D2F2 */ + ra7 = -9.81432934416914548592e+00, /* 0xC023A0EF, 0xC69AC25C */ + sa1 = 1.96512716674392571292e+01, /* 0x4033A6B9, 0xBD707687 */ + sa2 = 1.37657754143519042600e+02, /* 0x4061350C, 0x526AE721 */ + sa3 = 4.34565877475229228821e+02, /* 0x407B290D, 0xD58A1A71 */ + sa4 = 6.45387271733267880336e+02, /* 0x40842B19, 0x21EC2868 */ + sa5 = 4.29008140027567833386e+02, /* 0x407AD021, 0x57700314 */ + sa6 = 1.08635005541779435134e+02, /* 0x405B28A3, 0xEE48AE2C */ + sa7 = 6.57024977031928170135e+00, /* 0x401A47EF, 0x8E484A93 */ + sa8 = -6.04244152148580987438e-02, /* 0xBFAEEFF2, 0xEE749A62 */ + /* + * Coefficients for approximation to erfc in [1/.35,28] + */ + rb0 = -9.86494292470009928597e-03, /* 0xBF843412, 0x39E86F4A */ + rb1 = -7.99283237680523006574e-01, /* 0xBFE993BA, 0x70C285DE */ + rb2 = -1.77579549177547519889e+01, /* 0xC031C209, 0x555F995A */ + rb3 = -1.60636384855821916062e+02, /* 0xC064145D, 0x43C5ED98 */ + rb4 = -6.37566443368389627722e+02, /* 0xC083EC88, 0x1375F228 */ + rb5 = -1.02509513161107724954e+03, /* 0xC0900461, 0x6A2E5992 */ + rb6 = -4.83519191608651397019e+02, /* 0xC07E384E, 0x9BDC383F */ + sb1 = 3.03380607434824582924e+01, /* 0x403E568B, 0x261D5190 */ + sb2 = 3.25792512996573918826e+02, /* 0x40745CAE, 0x221B9F0A */ + sb3 = 1.53672958608443695994e+03, /* 0x409802EB, 0x189D5118 */ + sb4 = 3.19985821950859553908e+03, /* 0x40A8FFB7, 0x688C246A */ + sb5 = 2.55305040643316442583e+03, /* 0x40A3F219, 0xCEDF3BE6 */ + sb6 = 4.74528541206955367215e+02, /* 0x407DA874, 0xE79FE763 */ + sb7 = -2.24409524465858183362e+01; /* 0xC03670E2, 0x42712D62 */ + +static double erfc1(double x) +{ + double_t s, P, Q; + + s = fabs(x) - 1; + P = pa0 + + s * (pa1 + s * (pa2 + s * (pa3 + s * (pa4 + s * (pa5 + s * pa6))))); + Q = 1 + + s * (qa1 + s * (qa2 + s * (qa3 + s * (qa4 + s * (qa5 + s * qa6))))); + return 1 - erx - P / Q; +} + +static double erfc2(uint32_t ix, double x) +{ + double_t s, R, S; + double z; + + if (ix < 0x3ff40000) /* |x| < 1.25 */ + return erfc1(x); + + x = fabs(x); + s = 1 / (x * x); + if (ix < 0x4006db6d) { /* |x| < 1/.35 ~ 2.85714 */ + R = ra0 + + s * (ra1 + + s * (ra2 + + s * (ra3 + + s * (ra4 + + s * (ra5 + s * (ra6 + s * ra7)))))); + S = 1.0 + + s * (sa1 + + s * (sa2 + + s * (sa3 + + s * (sa4 + + s * (sa5 + + s * (sa6 + + s * (sa7 + s * sa8))))))); + } else { /* |x| > 1/.35 */ + R = rb0 + + s * (rb1 + + s * (rb2 + + s * (rb3 + s * (rb4 + s * (rb5 + s * rb6))))); + S = 1.0 + + s * (sb1 + + s * (sb2 + + s * (sb3 + + s * (sb4 + + s * (sb5 + s * (sb6 + s * sb7)))))); + } + z = x; + SET_LOW_WORD(z, 0); + return exp(-z * z - 0.5625) * exp((z - x) * (z + x) + R / S) / x; +} + +double erf(double x) +{ + double r, s, z, y; + uint32_t ix; + int sign; + + GET_HIGH_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x7ff00000) { + /* erf(nan)=nan, erf(+-inf)=+-1 */ + return 1 - 2 * sign + 1 / x; + } + if (ix < 0x3feb0000) { /* |x| < 0.84375 */ + if (ix < 0x3e300000) { /* |x| < 2**-28 */ + /* avoid underflow */ + return 0.125 * (8 * x + efx8 * x); + } + z = x * x; + r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4))); + s = 1.0 + + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5)))); + y = r / s; + return x + x * y; + } + if (ix < 0x40180000) /* 0.84375 <= |x| < 6 */ + y = 1 - erfc2(ix, x); + else + y = 1 - 0x1p-1022; + return sign ? -y : y; +} + +double erfc(double x) +{ + double r, s, z, y; + uint32_t ix; + int sign; + + GET_HIGH_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x7ff00000) { + /* erfc(nan)=nan, erfc(+-inf)=0,2 */ + return 2 * sign + 1 / x; + } + if (ix < 0x3feb0000) { /* |x| < 0.84375 */ + if (ix < 0x3c700000) /* |x| < 2**-56 */ + return 1.0 - x; + z = x * x; + r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4))); + s = 1.0 + + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5)))); + y = r / s; + if (sign || ix < 0x3fd00000) { /* x < 1/4 */ + return 1.0 - (x + x * y); + } + return 0.5 - (x - 0.5 + x * y); + } + if (ix < 0x403c0000) { /* 0.84375 <= |x| < 28 */ + return sign ? 2 - erfc2(ix, x) : erfc2(ix, x); + } + return sign ? 2 - 0x1p-1022 : 0x1p-1022 * 0x1p-1022; +} diff --git a/lib/libm/erff.c b/lib/libm/erff.c new file mode 100644 index 00000000..26170f62 --- /dev/null +++ b/lib/libm/erff.c @@ -0,0 +1,201 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_erff.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +static const float erx = 8.4506291151e-01, /* 0x3f58560b */ + /* + * Coefficients for approximation to erf on [0,0.84375] + */ + efx8 = 1.0270333290e+00, /* 0x3f8375d4 */ + pp0 = 1.2837916613e-01, /* 0x3e0375d4 */ + pp1 = -3.2504209876e-01, /* 0xbea66beb */ + pp2 = -2.8481749818e-02, /* 0xbce9528f */ + pp3 = -5.7702702470e-03, /* 0xbbbd1489 */ + pp4 = -2.3763017452e-05, /* 0xb7c756b1 */ + qq1 = 3.9791721106e-01, /* 0x3ecbbbce */ + qq2 = 6.5022252500e-02, /* 0x3d852a63 */ + qq3 = 5.0813062117e-03, /* 0x3ba68116 */ + qq4 = 1.3249473704e-04, /* 0x390aee49 */ + qq5 = -3.9602282413e-06, /* 0xb684e21a */ + /* + * Coefficients for approximation to erf in [0.84375,1.25] + */ + pa0 = -2.3621185683e-03, /* 0xbb1acdc6 */ + pa1 = 4.1485610604e-01, /* 0x3ed46805 */ + pa2 = -3.7220788002e-01, /* 0xbebe9208 */ + pa3 = 3.1834661961e-01, /* 0x3ea2fe54 */ + pa4 = -1.1089469492e-01, /* 0xbde31cc2 */ + pa5 = 3.5478305072e-02, /* 0x3d1151b3 */ + pa6 = -2.1663755178e-03, /* 0xbb0df9c0 */ + qa1 = 1.0642088205e-01, /* 0x3dd9f331 */ + qa2 = 5.4039794207e-01, /* 0x3f0a5785 */ + qa3 = 7.1828655899e-02, /* 0x3d931ae7 */ + qa4 = 1.2617121637e-01, /* 0x3e013307 */ + qa5 = 1.3637083583e-02, /* 0x3c5f6e13 */ + qa6 = 1.1984500103e-02, /* 0x3c445aa3 */ + /* + * Coefficients for approximation to erfc in [1.25,1/0.35] + */ + ra0 = -9.8649440333e-03, /* 0xbc21a093 */ + ra1 = -6.9385856390e-01, /* 0xbf31a0b7 */ + ra2 = -1.0558626175e+01, /* 0xc128f022 */ + ra3 = -6.2375331879e+01, /* 0xc2798057 */ + ra4 = -1.6239666748e+02, /* 0xc322658c */ + ra5 = -1.8460508728e+02, /* 0xc3389ae7 */ + ra6 = -8.1287437439e+01, /* 0xc2a2932b */ + ra7 = -9.8143291473e+00, /* 0xc11d077e */ + sa1 = 1.9651271820e+01, /* 0x419d35ce */ + sa2 = 1.3765776062e+02, /* 0x4309a863 */ + sa3 = 4.3456588745e+02, /* 0x43d9486f */ + sa4 = 6.4538726807e+02, /* 0x442158c9 */ + sa5 = 4.2900814819e+02, /* 0x43d6810b */ + sa6 = 1.0863500214e+02, /* 0x42d9451f */ + sa7 = 6.5702495575e+00, /* 0x40d23f7c */ + sa8 = -6.0424413532e-02, /* 0xbd777f97 */ + /* + * Coefficients for approximation to erfc in [1/.35,28] + */ + rb0 = -9.8649431020e-03, /* 0xbc21a092 */ + rb1 = -7.9928326607e-01, /* 0xbf4c9dd4 */ + rb2 = -1.7757955551e+01, /* 0xc18e104b */ + rb3 = -1.6063638306e+02, /* 0xc320a2ea */ + rb4 = -6.3756646729e+02, /* 0xc41f6441 */ + rb5 = -1.0250950928e+03, /* 0xc480230b */ + rb6 = -4.8351919556e+02, /* 0xc3f1c275 */ + sb1 = 3.0338060379e+01, /* 0x41f2b459 */ + sb2 = 3.2579251099e+02, /* 0x43a2e571 */ + sb3 = 1.5367296143e+03, /* 0x44c01759 */ + sb4 = 3.1998581543e+03, /* 0x4547fdbb */ + sb5 = 2.5530502930e+03, /* 0x451f90ce */ + sb6 = 4.7452853394e+02, /* 0x43ed43a7 */ + sb7 = -2.2440952301e+01; /* 0xc1b38712 */ + +static float erfc1(float x) +{ + float_t s, P, Q; + + s = fabsf(x) - 1; + P = pa0 + + s * (pa1 + s * (pa2 + s * (pa3 + s * (pa4 + s * (pa5 + s * pa6))))); + Q = 1 + + s * (qa1 + s * (qa2 + s * (qa3 + s * (qa4 + s * (qa5 + s * qa6))))); + return 1 - erx - P / Q; +} + +static float erfc2(uint32_t ix, float x) +{ + float_t s, R, S; + float z; + + if (ix < 0x3fa00000) /* |x| < 1.25 */ + return erfc1(x); + + x = fabsf(x); + s = 1 / (x * x); + if (ix < 0x4036db6d) { /* |x| < 1/0.35 */ + R = ra0 + + s * (ra1 + + s * (ra2 + + s * (ra3 + + s * (ra4 + + s * (ra5 + s * (ra6 + s * ra7)))))); + S = 1.0f + + s * (sa1 + + s * (sa2 + + s * (sa3 + + s * (sa4 + + s * (sa5 + + s * (sa6 + + s * (sa7 + s * sa8))))))); + } else { /* |x| >= 1/0.35 */ + R = rb0 + + s * (rb1 + + s * (rb2 + + s * (rb3 + s * (rb4 + s * (rb5 + s * rb6))))); + S = 1.0f + + s * (sb1 + + s * (sb2 + + s * (sb3 + + s * (sb4 + + s * (sb5 + s * (sb6 + s * sb7)))))); + } + GET_FLOAT_WORD(ix, x); + SET_FLOAT_WORD(z, ix & 0xffffe000); + return expf(-z * z - 0.5625f) * expf((z - x) * (z + x) + R / S) / x; +} + +float erff(float x) +{ + float r, s, z, y; + uint32_t ix; + int sign; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x7f800000) { + /* erf(nan)=nan, erf(+-inf)=+-1 */ + return 1 - 2 * sign + 1 / x; + } + if (ix < 0x3f580000) { /* |x| < 0.84375 */ + if (ix < 0x31800000) { /* |x| < 2**-28 */ + /*avoid underflow */ + return 0.125f * (8 * x + efx8 * x); + } + z = x * x; + r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4))); + s = 1 + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5)))); + y = r / s; + return x + x * y; + } + if (ix < 0x40c00000) /* |x| < 6 */ + y = 1 - erfc2(ix, x); + else + y = 1 - 0x1p-120f; + return sign ? -y : y; +} + +float erfcf(float x) +{ + float r, s, z, y; + uint32_t ix; + int sign; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x7f800000) { + /* erfc(nan)=nan, erfc(+-inf)=0,2 */ + return 2 * sign + 1 / x; + } + + if (ix < 0x3f580000) { /* |x| < 0.84375 */ + if (ix < 0x23800000) /* |x| < 2**-56 */ + return 1.0f - x; + z = x * x; + r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4))); + s = 1.0f + + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5)))); + y = r / s; + if (sign || ix < 0x3e800000) /* x < 1/4 */ + return 1.0f - (x + x * y); + return 0.5f - (x - 0.5f + x * y); + } + if (ix < 0x41e00000) { /* |x| < 28 */ + return sign ? 2 - erfc2(ix, x) : erfc2(ix, x); + } + return sign ? 2 - 0x1p-120f : 0x1p-120f * 0x1p-120f; +} diff --git a/lib/libm/erfl.c b/lib/libm/erfl.c new file mode 100644 index 00000000..d75acb24 --- /dev/null +++ b/lib/libm/erfl.c @@ -0,0 +1,388 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_erfl.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* double erf(double x) + * double erfc(double x) + * x + * 2 |\ + * erf(x) = --------- | exp(-t*t)dt + * sqrt(pi) \| + * 0 + * + * erfc(x) = 1-erf(x) + * Note that + * erf(-x) = -erf(x) + * erfc(-x) = 2 - erfc(x) + * + * Method: + * 1. For |x| in [0, 0.84375] + * erf(x) = x + x*R(x^2) + * erfc(x) = 1 - erf(x) if x in [-.84375,0.25] + * = 0.5 + ((0.5-x)-x*R) if x in [0.25,0.84375] + * Remark. The formula is derived by noting + * erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....) + * and that + * 2/sqrt(pi) = 1.128379167095512573896158903121545171688 + * is close to one. The interval is chosen because the fix + * point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is + * near 0.6174), and by some experiment, 0.84375 is chosen to + * guarantee the error is less than one ulp for erf. + * + * 2. For |x| in [0.84375,1.25], let s = |x| - 1, and + * c = 0.84506291151 rounded to single (24 bits) + * erf(x) = sign(x) * (c + P1(s)/Q1(s)) + * erfc(x) = (1-c) - P1(s)/Q1(s) if x > 0 + * 1+(c+P1(s)/Q1(s)) if x < 0 + * Remark: here we use the taylor series expansion at x=1. + * erf(1+s) = erf(1) + s*Poly(s) + * = 0.845.. + P1(s)/Q1(s) + * Note that |P1/Q1|< 0.078 for x in [0.84375,1.25] + * + * 3. For x in [1.25,1/0.35(~2.857143)], + * erfc(x) = (1/x)*exp(-x*x-0.5625+R1(z)/S1(z)) + * z=1/x^2 + * erf(x) = 1 - erfc(x) + * + * 4. For x in [1/0.35,107] + * erfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0 + * = 2.0 - (1/x)*exp(-x*x-0.5625+R2(z)/S2(z)) + * if -6.666<x<0 + * = 2.0 - tiny (if x <= -6.666) + * z=1/x^2 + * erf(x) = sign(x)*(1.0 - erfc(x)) if x < 6.666, else + * erf(x) = sign(x)*(1.0 - tiny) + * Note1: + * To compute exp(-x*x-0.5625+R/S), let s be a single + * precision number and s := x; then + * -x*x = -s*s + (s-x)*(s+x) + * exp(-x*x-0.5626+R/S) = + * exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S); + * Note2: + * Here 4 and 5 make use of the asymptotic series + * exp(-x*x) + * erfc(x) ~ ---------- * ( 1 + Poly(1/x^2) ) + * x*sqrt(pi) + * + * 5. For inf > x >= 107 + * erf(x) = sign(x) *(1 - tiny) (raise inexact) + * erfc(x) = tiny*tiny (raise underflow) if x > 0 + * = 2 - tiny if x<0 + * + * 7. Special case: + * erf(0) = 0, erf(inf) = 1, erf(-inf) = -1, + * erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2, + * erfc/erf(NaN) is NaN + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double erfl(long double x) +{ + return erf(x); +} +long double erfcl(long double x) +{ + return erfc(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +static const long double +erx = 0.845062911510467529296875L, + +/* + * Coefficients for approximation to erf on [0,0.84375] + */ +/* 8 * (2/sqrt(pi) - 1) */ +efx8 = 1.0270333367641005911692712249723613735048E0L, +pp[6] = { + 1.122751350964552113068262337278335028553E6L, + -2.808533301997696164408397079650699163276E6L, + -3.314325479115357458197119660818768924100E5L, + -6.848684465326256109712135497895525446398E4L, + -2.657817695110739185591505062971929859314E3L, + -1.655310302737837556654146291646499062882E2L, +}, +qq[6] = { + 8.745588372054466262548908189000448124232E6L, + 3.746038264792471129367533128637019611485E6L, + 7.066358783162407559861156173539693900031E5L, + 7.448928604824620999413120955705448117056E4L, + 4.511583986730994111992253980546131408924E3L, + 1.368902937933296323345610240009071254014E2L, + /* 1.000000000000000000000000000000000000000E0 */ +}, + +/* + * Coefficients for approximation to erf in [0.84375,1.25] + */ +/* erf(x+1) = 0.845062911510467529296875 + pa(x)/qa(x) + -0.15625 <= x <= +.25 + Peak relative error 8.5e-22 */ +pa[8] = { + -1.076952146179812072156734957705102256059E0L, + 1.884814957770385593365179835059971587220E2L, + -5.339153975012804282890066622962070115606E1L, + 4.435910679869176625928504532109635632618E1L, + 1.683219516032328828278557309642929135179E1L, + -2.360236618396952560064259585299045804293E0L, + 1.852230047861891953244413872297940938041E0L, + 9.394994446747752308256773044667843200719E-2L, +}, +qa[7] = { + 4.559263722294508998149925774781887811255E2L, + 3.289248982200800575749795055149780689738E2L, + 2.846070965875643009598627918383314457912E2L, + 1.398715859064535039433275722017479994465E2L, + 6.060190733759793706299079050985358190726E1L, + 2.078695677795422351040502569964299664233E1L, + 4.641271134150895940966798357442234498546E0L, + /* 1.000000000000000000000000000000000000000E0 */ +}, + +/* + * Coefficients for approximation to erfc in [1.25,1/0.35] + */ +/* erfc(1/x) = x exp (-1/x^2 - 0.5625 + ra(x^2)/sa(x^2)) + 1/2.85711669921875 < 1/x < 1/1.25 + Peak relative error 3.1e-21 */ +ra[] = { + 1.363566591833846324191000679620738857234E-1L, + 1.018203167219873573808450274314658434507E1L, + 1.862359362334248675526472871224778045594E2L, + 1.411622588180721285284945138667933330348E3L, + 5.088538459741511988784440103218342840478E3L, + 8.928251553922176506858267311750789273656E3L, + 7.264436000148052545243018622742770549982E3L, + 2.387492459664548651671894725748959751119E3L, + 2.220916652813908085449221282808458466556E2L, +}, +sa[] = { + -1.382234625202480685182526402169222331847E1L, + -3.315638835627950255832519203687435946482E2L, + -2.949124863912936259747237164260785326692E3L, + -1.246622099070875940506391433635999693661E4L, + -2.673079795851665428695842853070996219632E4L, + -2.880269786660559337358397106518918220991E4L, + -1.450600228493968044773354186390390823713E4L, + -2.874539731125893533960680525192064277816E3L, + -1.402241261419067750237395034116942296027E2L, + /* 1.000000000000000000000000000000000000000E0 */ +}, + +/* + * Coefficients for approximation to erfc in [1/.35,107] + */ +/* erfc(1/x) = x exp (-1/x^2 - 0.5625 + rb(x^2)/sb(x^2)) + 1/6.6666259765625 < 1/x < 1/2.85711669921875 + Peak relative error 4.2e-22 */ +rb[] = { + -4.869587348270494309550558460786501252369E-5L, + -4.030199390527997378549161722412466959403E-3L, + -9.434425866377037610206443566288917589122E-2L, + -9.319032754357658601200655161585539404155E-1L, + -4.273788174307459947350256581445442062291E0L, + -8.842289940696150508373541814064198259278E0L, + -7.069215249419887403187988144752613025255E0L, + -1.401228723639514787920274427443330704764E0L, +}, +sb[] = { + 4.936254964107175160157544545879293019085E-3L, + 1.583457624037795744377163924895349412015E-1L, + 1.850647991850328356622940552450636420484E0L, + 9.927611557279019463768050710008450625415E0L, + 2.531667257649436709617165336779212114570E1L, + 2.869752886406743386458304052862814690045E1L, + 1.182059497870819562441683560749192539345E1L, + /* 1.000000000000000000000000000000000000000E0 */ +}, +/* erfc(1/x) = x exp (-1/x^2 - 0.5625 + rc(x^2)/sc(x^2)) + 1/107 <= 1/x <= 1/6.6666259765625 + Peak relative error 1.1e-21 */ +rc[] = { + -8.299617545269701963973537248996670806850E-5L, + -6.243845685115818513578933902532056244108E-3L, + -1.141667210620380223113693474478394397230E-1L, + -7.521343797212024245375240432734425789409E-1L, + -1.765321928311155824664963633786967602934E0L, + -1.029403473103215800456761180695263439188E0L, +}, +sc[] = { + 8.413244363014929493035952542677768808601E-3L, + 2.065114333816877479753334599639158060979E-1L, + 1.639064941530797583766364412782135680148E0L, + 4.936788463787115555582319302981666347450E0L, + 5.005177727208955487404729933261347679090E0L, + /* 1.000000000000000000000000000000000000000E0 */ +}; + +static long double erfc1(long double x) +{ + long double s, P, Q; + + s = fabsl(x) - 1; + P = pa[0] + + s * (pa[1] + + s * (pa[2] + + s * (pa[3] + + s * (pa[4] + + s * (pa[5] + s * (pa[6] + s * pa[7])))))); + Q = qa[0] + + s * (qa[1] + + s * (qa[2] + + s * (qa[3] + + s * (qa[4] + s * (qa[5] + s * (qa[6] + s)))))); + return 1 - erx - P / Q; +} + +static long double erfc2(uint32_t ix, long double x) +{ + union ldshape u; + long double s, z, R, S; + + if (ix < 0x3fffa000) /* 0.84375 <= |x| < 1.25 */ + return erfc1(x); + + x = fabsl(x); + s = 1 / (x * x); + if (ix < 0x4000b6db) { /* 1.25 <= |x| < 2.857 ~ 1/.35 */ + R = ra[0] + + s * (ra[1] + + s * (ra[2] + + s * (ra[3] + + s * (ra[4] + + s * (ra[5] + + s * (ra[6] + + s * (ra[7] + s * ra[8]))))))); + S = sa[0] + + s * (sa[1] + + s * (sa[2] + + s * (sa[3] + + s * (sa[4] + + s * (sa[5] + + s * (sa[6] + + s * (sa[7] + + s * (sa[8] + s)))))))); + } else if (ix < 0x4001d555) { /* 2.857 <= |x| < 6.6666259765625 */ + R = rb[0] + + s * (rb[1] + + s * (rb[2] + + s * (rb[3] + + s * (rb[4] + + s * (rb[5] + + s * (rb[6] + s * rb[7])))))); + S = sb[0] + + s * (sb[1] + + s * (sb[2] + + s * (sb[3] + + s * (sb[4] + + s * (sb[5] + s * (sb[6] + s)))))); + } else { /* 6.666 <= |x| < 107 (erfc only) */ + R = rc[0] + + s * (rc[1] + + s * (rc[2] + s * (rc[3] + s * (rc[4] + s * rc[5])))); + S = sc[0] + + s * (sc[1] + s * (sc[2] + s * (sc[3] + s * (sc[4] + s)))); + } + u.f = x; + u.i.m &= -1ULL << 40; + z = u.f; + return expl(-z * z - 0.5625) * expl((z - x) * (z + x) + R / S) / x; +} + +long double erfl(long double x) +{ + long double r, s, z, y; + union ldshape u = { x }; + uint32_t ix = (u.i.se & 0x7fffU) << 16 | u.i.m >> 48; + int sign = u.i.se >> 15; + + if (ix >= 0x7fff0000) + /* erf(nan)=nan, erf(+-inf)=+-1 */ + return 1 - 2 * sign + 1 / x; + if (ix < 0x3ffed800) { /* |x| < 0.84375 */ + if (ix < 0x3fde8000) { /* |x| < 2**-33 */ + return 0.125 * (8 * x + efx8 * x); /* avoid underflow */ + } + z = x * x; + r = pp[0] + + z * (pp[1] + + z * (pp[2] + z * (pp[3] + z * (pp[4] + z * pp[5])))); + s = qq[0] + + z * (qq[1] + + z * (qq[2] + + z * (qq[3] + z * (qq[4] + z * (qq[5] + z))))); + y = r / s; + return x + x * y; + } + if (ix < 0x4001d555) /* |x| < 6.6666259765625 */ + y = 1 - erfc2(ix, x); + else + y = 1 - 0x1p-16382L; + return sign ? -y : y; +} + +long double erfcl(long double x) +{ + long double r, s, z, y; + union ldshape u = { x }; + uint32_t ix = (u.i.se & 0x7fffU) << 16 | u.i.m >> 48; + int sign = u.i.se >> 15; + + if (ix >= 0x7fff0000) + /* erfc(nan) = nan, erfc(+-inf) = 0,2 */ + return 2 * sign + 1 / x; + if (ix < 0x3ffed800) { /* |x| < 0.84375 */ + if (ix < 0x3fbe0000) /* |x| < 2**-65 */ + return 1.0 - x; + z = x * x; + r = pp[0] + + z * (pp[1] + + z * (pp[2] + z * (pp[3] + z * (pp[4] + z * pp[5])))); + s = qq[0] + + z * (qq[1] + + z * (qq[2] + + z * (qq[3] + z * (qq[4] + z * (qq[5] + z))))); + y = r / s; + if (ix < 0x3ffd8000) /* x < 1/4 */ + return 1.0 - (x + x * y); + return 0.5 - (x - 0.5 + x * y); + } + if (ix < 0x4005d600) /* |x| < 107 */ + return sign ? 2 - erfc2(ix, x) : erfc2(ix, x); + y = 0x1p-16382L; + return sign ? 2 - y : y * y; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double erfl(long double x) +{ + return erf(x); +} +long double erfcl(long double x) +{ + return erfc(x); +} +#endif diff --git a/lib/libm/exp.c b/lib/libm/exp.c new file mode 100644 index 00000000..cbcd7623 --- /dev/null +++ b/lib/libm/exp.c @@ -0,0 +1,138 @@ +/* + * Double-precision e^x function. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "exp_data.h" + +#define N (1 << EXP_TABLE_BITS) +#define InvLn2N __exp_data.invln2N +#define NegLn2hiN __exp_data.negln2hiN +#define NegLn2loN __exp_data.negln2loN +#define Shift __exp_data.shift +#define T __exp_data.tab +#define C2 __exp_data.poly[5 - EXP_POLY_ORDER] +#define C3 __exp_data.poly[6 - EXP_POLY_ORDER] +#define C4 __exp_data.poly[7 - EXP_POLY_ORDER] +#define C5 __exp_data.poly[8 - EXP_POLY_ORDER] + +/* Handle cases that may overflow or underflow when computing the result that + is scale*(1+TMP) without intermediate rounding. The bit representation of + scale is in SBITS, however it has a computed exponent that may have + overflown into the sign bit so that needs to be adjusted before using it as + a double. (int32_t)KI is the k used in the argument reduction and exponent + adjustment of scale, positive k here means the result may overflow and + negative k means the result may underflow. */ +static inline double specialcase(double_t tmp, uint64_t sbits, uint64_t ki) +{ + double_t scale, y; + + if ((ki & 0x80000000) == 0) { + /* k > 0, the exponent of scale might have overflowed by <= 460. + */ + sbits -= 1009ull << 52; + scale = asdouble(sbits); + y = 0x1p1009 * (scale + scale * tmp); + return eval_as_double(y); + } + /* k < 0, need special care in the subnormal range. */ + sbits += 1022ull << 52; + scale = asdouble(sbits); + y = scale + scale * tmp; + if (y < 1.0) { + /* Round y to the right precision before scaling it into the + subnormal range to avoid double rounding that can cause 0.5+E/2 + ulp error where E is the worst-case ulp error outside the + subnormal range. So this is only useful if the goal is better + than 1 ulp worst-case error. */ + double_t hi, lo; + lo = scale - y + scale * tmp; + hi = 1.0 + y; + lo = 1.0 - hi + y + lo; + y = eval_as_double(hi + lo) - 1.0; + /* Avoid -0.0 with downward rounding. */ + if (WANT_ROUNDING && y == 0.0) + y = 0.0; + /* The underflow exception needs to be signaled explicitly. */ + fp_force_eval(fp_barrier(0x1p-1022) * 0x1p-1022); + } + y = 0x1p-1022 * y; + return eval_as_double(y); +} + +/* Top 12 bits of a double (sign and exponent bits). */ +static inline uint32_t top12(double x) +{ + return asuint64(x) >> 52; +} + +double exp(double x) +{ + uint32_t abstop; + uint64_t ki, idx, top, sbits; + double_t kd, z, r, r2, scale, tail, tmp; + + abstop = top12(x) & 0x7ff; + if (predict_false(abstop - top12(0x1p-54) >= + top12(512.0) - top12(0x1p-54))) { + if (abstop - top12(0x1p-54) >= 0x80000000) + /* Avoid spurious underflow for tiny x. */ + /* Note: 0 is common input. */ + return WANT_ROUNDING ? 1.0 + x : 1.0; + if (abstop >= top12(1024.0)) { + if (asuint64(x) == asuint64(-INFINITY)) + return 0.0; + if (abstop >= top12(INFINITY)) + return 1.0 + x; + if (asuint64(x) >> 63) + return __math_uflow(0); + else + return __math_oflow(0); + } + /* Large x is special cased below. */ + abstop = 0; + } + + /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ + /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ + z = InvLn2N * x; +#if TOINT_INTRINSICS + kd = roundtoint(z); + ki = converttoint(z); +#elif EXP_USE_TOINT_NARROW + /* z - kd is in [-0.5-2^-16, 0.5] in all rounding modes. */ + kd = eval_as_double(z + Shift); + ki = asuint64(kd) >> 16; + kd = (double_t)(int32_t)ki; +#else + /* z - kd is in [-1, 1] in non-nearest rounding modes. */ + kd = eval_as_double(z + Shift); + ki = asuint64(kd); + kd -= Shift; +#endif + r = x + kd * NegLn2hiN + kd * NegLn2loN; + /* 2^(k/N) ~= scale * (1 + tail). */ + idx = 2 * (ki % N); + top = ki << (52 - EXP_TABLE_BITS); + tail = asdouble(T[idx]); + /* This is only a valid scale when -1023*N < k < 1024*N. */ + sbits = T[idx + 1] + top; + /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; + /* Without fma the worst case error is 0.25/N ulp larger. */ + /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. + */ + tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5); + if (predict_false(abstop == 0)) + return specialcase(tmp, sbits, ki); + scale = asdouble(sbits); + /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there + is no spurious underflow here even without fma. */ + return eval_as_double(scale + scale * tmp); +} diff --git a/lib/libm/exp10.c b/lib/libm/exp10.c new file mode 100644 index 00000000..fd3747a9 --- /dev/null +++ b/lib/libm/exp10.c @@ -0,0 +1,30 @@ +#define _GNU_SOURCE +#include "libm.h" + +#include <math.h> +#include <stdint.h> + +double exp10(double x) +{ + static const double p10[] = { 1e-15, 1e-14, 1e-13, 1e-12, 1e-11, 1e-10, + 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, + 1e-3, 1e-2, 1e-1, 1, 1e1, 1e2, + 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, + 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, + 1e15 }; + double n, y = modf(x, &n); + union { + double f; + uint64_t i; + } u = { n }; + /* fabs(n) < 16 without raising invalid on nan */ + if ((u.i >> 52 & 0x7ff) < 0x3ff + 4) { + if (!y) + return p10[(int)n + 15]; + y = exp2(3.32192809488736234787031942948939 * y); + return y * p10[(int)n + 15]; + } + return pow(10.0, x); +} + +weak_alias(exp10, pow10); diff --git a/lib/libm/exp10f.c b/lib/libm/exp10f.c new file mode 100644 index 00000000..64883569 --- /dev/null +++ b/lib/libm/exp10f.c @@ -0,0 +1,27 @@ +#define _GNU_SOURCE +#include "libm.h" + +#include <math.h> +#include <stdint.h> + +float exp10f(float x) +{ + static const float p10[] = { 1e-7f, 1e-6f, 1e-5f, 1e-4f, 1e-3f, + 1e-2f, 1e-1f, 1, 1e1, 1e2, + 1e3, 1e4, 1e5, 1e6, 1e7 }; + float n, y = modff(x, &n); + union { + float f; + uint32_t i; + } u = { n }; + /* fabsf(n) < 8 without raising invalid on nan */ + if ((u.i >> 23 & 0xff) < 0x7f + 3) { + if (!y) + return p10[(int)n + 7]; + y = exp2f(3.32192809488736234787031942948939f * y); + return y * p10[(int)n + 7]; + } + return exp2(3.32192809488736234787031942948939 * x); +} + +weak_alias(exp10f, pow10f); diff --git a/lib/libm/exp10l.c b/lib/libm/exp10l.c new file mode 100644 index 00000000..53915621 --- /dev/null +++ b/lib/libm/exp10l.c @@ -0,0 +1,33 @@ +#define _GNU_SOURCE +#include <float.h> +#include <math.h> +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double exp10l(long double x) +{ + return exp10(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double exp10l(long double x) +{ + static const long double p10[] = { + 1e-15L, 1e-14L, 1e-13L, 1e-12L, 1e-11L, 1e-10L, 1e-9L, 1e-8L, + 1e-7L, 1e-6L, 1e-5L, 1e-4L, 1e-3L, 1e-2L, 1e-1L, 1, + 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, + 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15 + }; + long double n, y = modfl(x, &n); + union ldshape u = { n }; + /* fabsl(n) < 16 without raising invalid on nan */ + if ((u.i.se & 0x7fff) < 0x3fff + 4) { + if (!y) + return p10[(int)n + 15]; + y = exp2l(3.32192809488736234787031942948939L * y); + return y * p10[(int)n + 15]; + } + return powl(10.0, x); +} +#endif + +weak_alias(exp10l, pow10l); diff --git a/lib/libm/exp2.c b/lib/libm/exp2.c new file mode 100644 index 00000000..1a4be99d --- /dev/null +++ b/lib/libm/exp2.c @@ -0,0 +1,124 @@ +/* + * Double-precision 2^x function. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "exp_data.h" + +#define N (1 << EXP_TABLE_BITS) +#define Shift __exp_data.exp2_shift +#define T __exp_data.tab +#define C1 __exp_data.exp2_poly[0] +#define C2 __exp_data.exp2_poly[1] +#define C3 __exp_data.exp2_poly[2] +#define C4 __exp_data.exp2_poly[3] +#define C5 __exp_data.exp2_poly[4] + +/* Handle cases that may overflow or underflow when computing the result that + is scale*(1+TMP) without intermediate rounding. The bit representation of + scale is in SBITS, however it has a computed exponent that may have + overflown into the sign bit so that needs to be adjusted before using it as + a double. (int32_t)KI is the k used in the argument reduction and exponent + adjustment of scale, positive k here means the result may overflow and + negative k means the result may underflow. */ +static inline double specialcase(double_t tmp, uint64_t sbits, uint64_t ki) +{ + double_t scale, y; + + if ((ki & 0x80000000) == 0) { + /* k > 0, the exponent of scale might have overflowed by 1. */ + sbits -= 1ull << 52; + scale = asdouble(sbits); + y = 2 * (scale + scale * tmp); + return eval_as_double(y); + } + /* k < 0, need special care in the subnormal range. */ + sbits += 1022ull << 52; + scale = asdouble(sbits); + y = scale + scale * tmp; + if (y < 1.0) { + /* Round y to the right precision before scaling it into the + subnormal range to avoid double rounding that can cause + 0.5+E/2 ulp error where E is the worst-case ulp error outside + the subnormal range. So this is only useful if the goal is + better than 1 ulp worst-case error. */ + double_t hi, lo; + lo = scale - y + scale * tmp; + hi = 1.0 + y; + lo = 1.0 - hi + y + lo; + y = eval_as_double(hi + lo) - 1.0; + /* Avoid -0.0 with downward rounding. */ + if (WANT_ROUNDING && y == 0.0) + y = 0.0; + /* The underflow exception needs to be signaled explicitly. */ + fp_force_eval(fp_barrier(0x1p-1022) * 0x1p-1022); + } + y = 0x1p-1022 * y; + return eval_as_double(y); +} + +/* Top 12 bits of a double (sign and exponent bits). */ +static inline uint32_t top12(double x) +{ + return asuint64(x) >> 52; +} + +double exp2(double x) +{ + uint32_t abstop; + uint64_t ki, idx, top, sbits; + double_t kd, r, r2, scale, tail, tmp; + + abstop = top12(x) & 0x7ff; + if (predict_false(abstop - top12(0x1p-54) >= + top12(512.0) - top12(0x1p-54))) { + if (abstop - top12(0x1p-54) >= 0x80000000) + /* Avoid spurious underflow for tiny x. */ + /* Note: 0 is common input. */ + return WANT_ROUNDING ? 1.0 + x : 1.0; + if (abstop >= top12(1024.0)) { + if (asuint64(x) == asuint64(-INFINITY)) + return 0.0; + if (abstop >= top12(INFINITY)) + return 1.0 + x; + if (!(asuint64(x) >> 63)) + return __math_oflow(0); + else if (asuint64(x) >= asuint64(-1075.0)) + return __math_uflow(0); + } + if (2 * asuint64(x) > 2 * asuint64(928.0)) + /* Large x is special cased below. */ + abstop = 0; + } + + /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ + /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ + kd = eval_as_double(x + Shift); + ki = asuint64(kd); /* k. */ + kd -= Shift; /* k/N for int k. */ + r = x - kd; + /* 2^(k/N) ~= scale * (1 + tail). */ + idx = 2 * (ki % N); + top = ki << (52 - EXP_TABLE_BITS); + tail = asdouble(T[idx]); + /* This is only a valid scale when -1023*N < k < 1024*N. */ + sbits = T[idx + 1] + top; + /* exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; + /* Without fma the worst case error is 0.5/N ulp larger. */ + /* Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp. + */ + tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5); + if (predict_false(abstop == 0)) + return specialcase(tmp, sbits, ki); + scale = asdouble(sbits); + /* Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there + is no spurious underflow here even without fma. */ + return eval_as_double(scale + scale * tmp); +} diff --git a/lib/libm/exp2f.c b/lib/libm/exp2f.c new file mode 100644 index 00000000..8892cf8f --- /dev/null +++ b/lib/libm/exp2f.c @@ -0,0 +1,69 @@ +/* + * Single-precision 2^x function. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "exp2f_data.h" + +/* +EXP2F_TABLE_BITS = 5 +EXP2F_POLY_ORDER = 3 + +ULP error: 0.502 (nearest rounding.) +Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.) +Wrong count: 168353 (all nearest rounding wrong results with fma.) +Non-nearest ULP error: 1 (rounded ULP error) +*/ + +#define N (1 << EXP2F_TABLE_BITS) +#define T __exp2f_data.tab +#define C __exp2f_data.poly +#define SHIFT __exp2f_data.shift_scaled + +static inline uint32_t top12(float x) +{ + return asuint(x) >> 20; +} + +float exp2f(float x) +{ + uint32_t abstop; + uint64_t ki, t; + double_t kd, xd, z, r, r2, y, s; + + xd = (double_t)x; + abstop = top12(x) & 0x7ff; + if (predict_false(abstop >= top12(128.0f))) { + /* |x| >= 128 or x is nan. */ + if (asuint(x) == asuint(-INFINITY)) + return 0.0f; + if (abstop >= top12(INFINITY)) + return x + x; + if (x > 0.0f) + return __math_oflowf(0); + if (x <= -150.0f) + return __math_uflowf(0); + } + + /* x = k/N + r with r in [-1/(2N), 1/(2N)] and int k. */ + kd = eval_as_double(xd + SHIFT); + ki = asuint64(kd); + kd -= SHIFT; /* k/N for int k. */ + r = xd - kd; + + /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ + t = T[ki % N]; + t += ki << (52 - EXP2F_TABLE_BITS); + s = asdouble(t); + z = C[0] * r + C[1]; + r2 = r * r; + y = C[2] * r + 1; + y = z * r2 + y; + y = y * s; + return eval_as_float(y); +} diff --git a/lib/libm/exp2f_data.c b/lib/libm/exp2f_data.c new file mode 100644 index 00000000..be324727 --- /dev/null +++ b/lib/libm/exp2f_data.c @@ -0,0 +1,35 @@ +/* + * Shared data between expf, exp2f and powf. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "exp2f_data.h" + +#define N (1 << EXP2F_TABLE_BITS) + +const struct exp2f_data __exp2f_data = { + /* tab[i] = uint(2^(i/N)) - (i << 52-BITS) + used for computing 2^(k/N) for an int |k| < 150 N as + double(tab[k%N] + (k << 52-BITS)) */ + .tab = { +0x3ff0000000000000, 0x3fefd9b0d3158574, 0x3fefb5586cf9890f, 0x3fef9301d0125b51, +0x3fef72b83c7d517b, 0x3fef54873168b9aa, 0x3fef387a6e756238, 0x3fef1e9df51fdee1, +0x3fef06fe0a31b715, 0x3feef1a7373aa9cb, 0x3feedea64c123422, 0x3feece086061892d, +0x3feebfdad5362a27, 0x3feeb42b569d4f82, 0x3feeab07dd485429, 0x3feea47eb03a5585, +0x3feea09e667f3bcd, 0x3fee9f75e8ec5f74, 0x3feea11473eb0187, 0x3feea589994cce13, +0x3feeace5422aa0db, 0x3feeb737b0cdc5e5, 0x3feec49182a3f090, 0x3feed503b23e255d, +0x3feee89f995ad3ad, 0x3feeff76f2fb5e47, 0x3fef199bdd85529c, 0x3fef3720dcef9069, +0x3fef5818dcfba487, 0x3fef7c97337b9b5f, 0x3fefa4afa2a490da, 0x3fefd0765b6e4540, + }, + .shift_scaled = 0x1.8p+52 / N, + .poly = { + 0x1.c6af84b912394p-5, 0x1.ebfce50fac4f3p-3, 0x1.62e42ff0c52d6p-1, + }, + .shift = 0x1.8p+52, + .invln2_scaled = 0x1.71547652b82fep+0 * N, + .poly_scaled = { + 0x1.c6af84b912394p-5/N/N/N, 0x1.ebfce50fac4f3p-3/N/N, 0x1.62e42ff0c52d6p-1/N, + }, +}; diff --git a/lib/libm/exp2f_data.h b/lib/libm/exp2f_data.h new file mode 100644 index 00000000..af31f629 --- /dev/null +++ b/lib/libm/exp2f_data.h @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _EXP2F_DATA_H +#define _EXP2F_DATA_H + +#include <stdint.h> + +#define hidden __attribute__((visibility("hidden"))) + +/* Shared between expf, exp2f and powf. */ +#define EXP2F_TABLE_BITS 5 +#define EXP2F_POLY_ORDER 3 +extern hidden const struct exp2f_data { + uint64_t tab[1 << EXP2F_TABLE_BITS]; + double shift_scaled; + double poly[EXP2F_POLY_ORDER]; + double shift; + double invln2_scaled; + double poly_scaled[EXP2F_POLY_ORDER]; +} __exp2f_data; + +#endif diff --git a/lib/libm/exp2l.c b/lib/libm/exp2l.c new file mode 100644 index 00000000..6d21d590 --- /dev/null +++ b/lib/libm/exp2l.c @@ -0,0 +1,661 @@ +/* origin: FreeBSD /usr/src/lib/msun/ld80/s_exp2l.c and + * /usr/src/lib/msun/ld128/s_exp2l.c */ +/*- + * Copyright (c) 2005-2008 David Schultz <das@FreeBSD.ORG> + * 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. + * + * 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 "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double exp2l(long double x) +{ + return exp2(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +#define TBLBITS 7 +#define TBLSIZE (1 << TBLBITS) + +static const double redux = 0x1.8p63 / TBLSIZE, P1 = 0x1.62e42fefa39efp-1, + P2 = 0x1.ebfbdff82c58fp-3, P3 = 0x1.c6b08d7049fap-5, + P4 = 0x1.3b2ab6fba4da5p-7, P5 = 0x1.5d8804780a736p-10, + P6 = 0x1.430918835e33dp-13; + +static const double tbl[TBLSIZE * 2] = { + 0x1.6a09e667f3bcdp-1, + -0x1.bdd3413b2648p-55, + 0x1.6c012750bdabfp-1, + -0x1.2895667ff0cp-57, + 0x1.6dfb23c651a2fp-1, + -0x1.bbe3a683c88p-58, + 0x1.6ff7df9519484p-1, + -0x1.83c0f25860fp-56, + 0x1.71f75e8ec5f74p-1, + -0x1.16e4786887bp-56, + 0x1.73f9a48a58174p-1, + -0x1.0a8d96c65d5p-55, + 0x1.75feb564267c9p-1, + -0x1.0245957316ep-55, + 0x1.780694fde5d3fp-1, + 0x1.866b80a0216p-55, + 0x1.7a11473eb0187p-1, + -0x1.41577ee0499p-56, + 0x1.7c1ed0130c132p-1, + 0x1.f124cd1164ep-55, + 0x1.7e2f336cf4e62p-1, + 0x1.05d02ba157ap-57, + 0x1.80427543e1a12p-1, + -0x1.27c86626d97p-55, + 0x1.82589994cce13p-1, + -0x1.d4c1dd41533p-55, + 0x1.8471a4623c7adp-1, + -0x1.8d684a341cep-56, + 0x1.868d99b4492edp-1, + -0x1.fc6f89bd4f68p-55, + 0x1.88ac7d98a6699p-1, + 0x1.994c2f37cb5p-55, + 0x1.8ace5422aa0dbp-1, + 0x1.6e9f156864bp-55, + 0x1.8cf3216b5448cp-1, + -0x1.0d55e32e9e4p-57, + 0x1.8f1ae99157736p-1, + 0x1.5cc13a2e397p-56, + 0x1.9145b0b91ffc6p-1, + -0x1.dd6792e5825p-55, + 0x1.93737b0cdc5e5p-1, + -0x1.75fc781b58p-58, + 0x1.95a44cbc8520fp-1, + -0x1.64b7c96a5fp-57, + 0x1.97d829fde4e5p-1, + -0x1.d185b7c1b86p-55, + 0x1.9a0f170ca07bap-1, + -0x1.173bd91cee6p-55, + 0x1.9c49182a3f09p-1, + 0x1.c7c46b071f2p-57, + 0x1.9e86319e32323p-1, + 0x1.824ca78e64cp-57, + 0x1.a0c667b5de565p-1, + -0x1.359495d1cd5p-55, + 0x1.a309bec4a2d33p-1, + 0x1.6305c7ddc368p-55, + 0x1.a5503b23e255dp-1, + -0x1.d2f6edb8d42p-55, + 0x1.a799e1330b358p-1, + 0x1.bcb7ecac564p-55, + 0x1.a9e6b5579fdbfp-1, + 0x1.0fac90ef7fdp-55, + 0x1.ac36bbfd3f37ap-1, + -0x1.f9234cae76dp-56, + 0x1.ae89f995ad3adp-1, + 0x1.7a1cd345dcc8p-55, + 0x1.b0e07298db666p-1, + -0x1.bdef54c80e4p-55, + 0x1.b33a2b84f15fbp-1, + -0x1.2805e3084d8p-58, + 0x1.b59728de5593ap-1, + -0x1.c71dfbbba6ep-55, + 0x1.b7f76f2fb5e47p-1, + -0x1.5584f7e54acp-57, + 0x1.ba5b030a1064ap-1, + -0x1.efcd30e5429p-55, + 0x1.bcc1e904bc1d2p-1, + 0x1.23dd07a2d9fp-56, + 0x1.bf2c25bd71e09p-1, + -0x1.efdca3f6b9c8p-55, + 0x1.c199bdd85529cp-1, + 0x1.11065895049p-56, + 0x1.c40ab5fffd07ap-1, + 0x1.b4537e083c6p-55, + 0x1.c67f12e57d14bp-1, + 0x1.2884dff483c8p-55, + 0x1.c8f6d9406e7b5p-1, + 0x1.1acbc48805cp-57, + 0x1.cb720dcef9069p-1, + 0x1.503cbd1e94ap-57, + 0x1.cdf0b555dc3fap-1, + -0x1.dd83b53829dp-56, + 0x1.d072d4a07897cp-1, + -0x1.cbc3743797a8p-55, + 0x1.d2f87080d89f2p-1, + -0x1.d487b719d858p-55, + 0x1.d5818dcfba487p-1, + 0x1.2ed02d75b37p-56, + 0x1.d80e316c98398p-1, + -0x1.11ec18bedep-55, + 0x1.da9e603db3285p-1, + 0x1.c2300696db5p-55, + 0x1.dd321f301b46p-1, + 0x1.2da5778f019p-55, + 0x1.dfc97337b9b5fp-1, + -0x1.1a5cd4f184b8p-55, + 0x1.e264614f5a129p-1, + -0x1.7b627817a148p-55, + 0x1.e502ee78b3ff6p-1, + 0x1.39e8980a9cdp-56, + 0x1.e7a51fbc74c83p-1, + 0x1.2d522ca0c8ep-55, + 0x1.ea4afa2a490dap-1, + -0x1.e9c23179c288p-55, + 0x1.ecf482d8e67f1p-1, + -0x1.c93f3b411ad8p-55, + 0x1.efa1bee615a27p-1, + 0x1.dc7f486a4b68p-55, + 0x1.f252b376bba97p-1, + 0x1.3a1a5bf0d8e8p-55, + 0x1.f50765b6e454p-1, + 0x1.9d3e12dd8a18p-55, + 0x1.f7bfdad9cbe14p-1, + -0x1.dbb12d00635p-55, + 0x1.fa7c1819e90d8p-1, + 0x1.74853f3a593p-56, + 0x1.fd3c22b8f71f1p-1, + 0x1.2eb74966578p-58, + 0x1p+0, + 0x0p+0, + 0x1.0163da9fb3335p+0, + 0x1.b61299ab8cd8p-54, + 0x1.02c9a3e778061p+0, + -0x1.19083535b08p-56, + 0x1.04315e86e7f85p+0, + -0x1.0a31c1977c98p-54, + 0x1.059b0d3158574p+0, + 0x1.d73e2a475b4p-55, + 0x1.0706b29ddf6dep+0, + -0x1.c91dfe2b13cp-55, + 0x1.0874518759bc8p+0, + 0x1.186be4bb284p-57, + 0x1.09e3ecac6f383p+0, + 0x1.14878183161p-54, + 0x1.0b5586cf9890fp+0, + 0x1.8a62e4adc61p-54, + 0x1.0cc922b7247f7p+0, + 0x1.01edc16e24f8p-54, + 0x1.0e3ec32d3d1a2p+0, + 0x1.03a1727c58p-59, + 0x1.0fb66affed31bp+0, + -0x1.b9bedc44ebcp-57, + 0x1.11301d0125b51p+0, + -0x1.6c51039449bp-54, + 0x1.12abdc06c31ccp+0, + -0x1.1b514b36ca8p-58, + 0x1.1429aaea92dep+0, + -0x1.32fbf9af1368p-54, + 0x1.15a98c8a58e51p+0, + 0x1.2406ab9eeabp-55, + 0x1.172b83c7d517bp+0, + -0x1.19041b9d78ap-55, + 0x1.18af9388c8deap+0, + -0x1.11023d1970f8p-54, + 0x1.1a35beb6fcb75p+0, + 0x1.e5b4c7b4969p-55, + 0x1.1bbe084045cd4p+0, + -0x1.95386352ef6p-54, + 0x1.1d4873168b9aap+0, + 0x1.e016e00a264p-54, + 0x1.1ed5022fcd91dp+0, + -0x1.1df98027bb78p-54, + 0x1.2063b88628cd6p+0, + 0x1.dc775814a85p-55, + 0x1.21f49917ddc96p+0, + 0x1.2a97e9494a6p-55, + 0x1.2387a6e756238p+0, + 0x1.9b07eb6c7058p-54, + 0x1.251ce4fb2a63fp+0, + 0x1.ac155bef4f5p-55, + 0x1.26b4565e27cddp+0, + 0x1.2bd339940eap-55, + 0x1.284dfe1f56381p+0, + -0x1.a4c3a8c3f0d8p-54, + 0x1.29e9df51fdee1p+0, + 0x1.612e8afad12p-55, + 0x1.2b87fd0dad99p+0, + -0x1.10adcd6382p-59, + 0x1.2d285a6e4030bp+0, + 0x1.0024754db42p-54, + 0x1.2ecafa93e2f56p+0, + 0x1.1ca0f45d524p-56, + 0x1.306fe0a31b715p+0, + 0x1.6f46ad23183p-55, + 0x1.32170fc4cd831p+0, + 0x1.a9ce78e1804p-55, + 0x1.33c08b26416ffp+0, + 0x1.327218436598p-54, + 0x1.356c55f929ff1p+0, + -0x1.b5cee5c4e46p-55, + 0x1.371a7373aa9cbp+0, + -0x1.63aeabf42ebp-54, + 0x1.38cae6d05d866p+0, + -0x1.e958d3c99048p-54, + 0x1.3a7db34e59ff7p+0, + -0x1.5e436d661f6p-56, + 0x1.3c32dc313a8e5p+0, + -0x1.efff8375d2ap-54, + 0x1.3dea64c123422p+0, + 0x1.ada0911f09fp-55, + 0x1.3fa4504ac801cp+0, + -0x1.7d023f956fap-54, + 0x1.4160a21f72e2ap+0, + -0x1.ef3691c309p-58, + 0x1.431f5d950a897p+0, + -0x1.1c7dde35f7ap-55, + 0x1.44e086061892dp+0, + 0x1.89b7a04ef8p-59, + 0x1.46a41ed1d0057p+0, + 0x1.c944bd1648a8p-54, + 0x1.486a2b5c13cdp+0, + 0x1.3c1a3b69062p-56, + 0x1.4a32af0d7d3dep+0, + 0x1.9cb62f3d1be8p-54, + 0x1.4bfdad5362a27p+0, + 0x1.d4397afec42p-56, + 0x1.4dcb299fddd0dp+0, + 0x1.8ecdbbc6a78p-54, + 0x1.4f9b2769d2ca7p+0, + -0x1.4b309d25958p-54, + 0x1.516daa2cf6642p+0, + -0x1.f768569bd94p-55, + 0x1.5342b569d4f82p+0, + -0x1.07abe1db13dp-55, + 0x1.551a4ca5d920fp+0, + -0x1.d689cefede6p-55, + 0x1.56f4736b527dap+0, + 0x1.9bb2c011d938p-54, + 0x1.58d12d497c7fdp+0, + 0x1.295e15b9a1ep-55, + 0x1.5ab07dd485429p+0, + 0x1.6324c0546478p-54, + 0x1.5c9268a5946b7p+0, + 0x1.c4b1b81698p-60, + 0x1.5e76f15ad2148p+0, + 0x1.ba6f93080e68p-54, + 0x1.605e1b976dc09p+0, + -0x1.3e2429b56de8p-54, + 0x1.6247eb03a5585p+0, + -0x1.383c17e40b48p-54, + 0x1.6434634ccc32p+0, + -0x1.c483c759d89p-55, + 0x1.6623882552225p+0, + -0x1.bb60987591cp-54, + 0x1.68155d44ca973p+0, + 0x1.038ae44f74p-57, +}; + +/* + * exp2l(x): compute the base 2 exponential of x + * + * Accuracy: Peak error < 0.511 ulp. + * + * Method: (equally-spaced tables) + * + * Reduce x: + * x = 2**k + y, for integer k and |y| <= 1/2. + * Thus we have exp2l(x) = 2**k * exp2(y). + * + * Reduce y: + * y = i/TBLSIZE + z for integer i near y * TBLSIZE. + * Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z), + * with |z| <= 2**-(TBLBITS+1). + * + * We compute exp2(i/TBLSIZE) via table lookup and exp2(z) via a + * degree-6 minimax polynomial with maximum error under 2**-69. + * The table entries each have 104 bits of accuracy, encoded as + * a pair of double precision values. + */ +long double exp2l(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + long double r, z; + uint32_t i0; + union { + uint32_t u; + int32_t i; + } k; + + /* Filter out exceptional cases. */ + if (e >= 0x3fff + 13) { /* |x| >= 8192 or x is NaN */ + if (u.i.se >= 0x3fff + 14 && u.i.se >> 15 == 0) + /* overflow */ + return x * 0x1p16383L; + if (e == 0x7fff) /* -inf or -nan */ + return -1 / x; + if (x < -16382) { + if (x <= -16446 || x - 0x1p63 + 0x1p63 != x) + /* underflow */ + FORCE_EVAL((float)(-0x1p-149 / x)); + if (x <= -16446) + return 0; + } + } else if (e < 0x3fff - 64) { + return 1 + x; + } + + /* + * Reduce x, computing z, i0, and k. The low bits of x + redux + * contain the 16-bit integer part of the exponent (k) followed by + * TBLBITS fractional bits (i0). We use bit tricks to extract these + * as integers, then set z to the remainder. + * + * Example: Suppose x is 0xabc.123456p0 and TBLBITS is 8. + * Then the low-order word of x + redux is 0x000abc12, + * We split this into k = 0xabc and i0 = 0x12 (adjusted to + * index into the table), then we compute z = 0x0.003456p0. + */ + u.f = x + redux; + i0 = u.i.m + TBLSIZE / 2; + k.u = i0 / TBLSIZE * TBLSIZE; + k.i /= TBLSIZE; + i0 %= TBLSIZE; + u.f -= redux; + z = x - u.f; + + /* Compute r = exp2l(y) = exp2lt[i0] * p(z). */ + long double t_hi = tbl[2 * i0]; + long double t_lo = tbl[2 * i0 + 1]; + /* XXX This gives > 1 ulp errors outside of FE_TONEAREST mode */ + r = t_lo + + (t_hi + t_lo) * z * + (P1 + z * (P2 + z * (P3 + z * (P4 + z * (P5 + z * P6))))) + + t_hi; + + return scalbnl(r, k.i); +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +#define TBLBITS 7 +#define TBLSIZE (1 << TBLBITS) + +static const long double P1 = 0x1.62e42fefa39ef35793c7673007e6p-1L, + P2 = 0x1.ebfbdff82c58ea86f16b06ec9736p-3L, + P3 = 0x1.c6b08d704a0bf8b33a762bad3459p-5L, + P4 = 0x1.3b2ab6fba4e7729ccbbe0b4f3fc2p-7L, + P5 = 0x1.5d87fe78a67311071dee13fd11d9p-10L, + P6 = 0x1.430912f86c7876f4b663b23c5fe5p-13L; + +static const double P7 = 0x1.ffcbfc588b041p-17, P8 = 0x1.62c0223a5c7c7p-20, + P9 = 0x1.b52541ff59713p-24, P10 = 0x1.e4cf56a391e22p-28, + redux = 0x1.8p112 / TBLSIZE; + +static const long double tbl[TBLSIZE] = { + 0x1.6a09e667f3bcc908b2fb1366dfeap-1L, + 0x1.6c012750bdabeed76a99800f4edep-1L, + 0x1.6dfb23c651a2ef220e2cbe1bc0d4p-1L, + 0x1.6ff7df9519483cf87e1b4f3e1e98p-1L, + 0x1.71f75e8ec5f73dd2370f2ef0b148p-1L, + 0x1.73f9a48a58173bd5c9a4e68ab074p-1L, + 0x1.75feb564267c8bf6e9aa33a489a8p-1L, + 0x1.780694fde5d3f619ae02808592a4p-1L, + 0x1.7a11473eb0186d7d51023f6ccb1ap-1L, + 0x1.7c1ed0130c1327c49334459378dep-1L, + 0x1.7e2f336cf4e62105d02ba1579756p-1L, + 0x1.80427543e1a11b60de67649a3842p-1L, + 0x1.82589994cce128acf88afab34928p-1L, + 0x1.8471a4623c7acce52f6b97c6444cp-1L, + 0x1.868d99b4492ec80e41d90ac2556ap-1L, + 0x1.88ac7d98a669966530bcdf2d4cc0p-1L, + 0x1.8ace5422aa0db5ba7c55a192c648p-1L, + 0x1.8cf3216b5448bef2aa1cd161c57ap-1L, + 0x1.8f1ae991577362b982745c72eddap-1L, + 0x1.9145b0b91ffc588a61b469f6b6a0p-1L, + 0x1.93737b0cdc5e4f4501c3f2540ae8p-1L, + 0x1.95a44cbc8520ee9b483695a0e7fep-1L, + 0x1.97d829fde4e4f8b9e920f91e8eb6p-1L, + 0x1.9a0f170ca07b9ba3109b8c467844p-1L, + 0x1.9c49182a3f0901c7c46b071f28dep-1L, + 0x1.9e86319e323231824ca78e64c462p-1L, + 0x1.a0c667b5de564b29ada8b8cabbacp-1L, + 0x1.a309bec4a2d3358c171f770db1f4p-1L, + 0x1.a5503b23e255c8b424491caf88ccp-1L, + 0x1.a799e1330b3586f2dfb2b158f31ep-1L, + 0x1.a9e6b5579fdbf43eb243bdff53a2p-1L, + 0x1.ac36bbfd3f379c0db966a3126988p-1L, + 0x1.ae89f995ad3ad5e8734d17731c80p-1L, + 0x1.b0e07298db66590842acdfc6fb4ep-1L, + 0x1.b33a2b84f15faf6bfd0e7bd941b0p-1L, + 0x1.b59728de559398e3881111648738p-1L, + 0x1.b7f76f2fb5e46eaa7b081ab53ff6p-1L, + 0x1.ba5b030a10649840cb3c6af5b74cp-1L, + 0x1.bcc1e904bc1d2247ba0f45b3d06cp-1L, + 0x1.bf2c25bd71e088408d7025190cd0p-1L, + 0x1.c199bdd85529c2220cb12a0916bap-1L, + 0x1.c40ab5fffd07a6d14df820f17deap-1L, + 0x1.c67f12e57d14b4a2137fd20f2a26p-1L, + 0x1.c8f6d9406e7b511acbc48805c3f6p-1L, + 0x1.cb720dcef90691503cbd1e949d0ap-1L, + 0x1.cdf0b555dc3f9c44f8958fac4f12p-1L, + 0x1.d072d4a07897b8d0f22f21a13792p-1L, + 0x1.d2f87080d89f18ade123989ea50ep-1L, + 0x1.d5818dcfba48725da05aeb66dff8p-1L, + 0x1.d80e316c98397bb84f9d048807a0p-1L, + 0x1.da9e603db3285708c01a5b6d480cp-1L, + 0x1.dd321f301b4604b695de3c0630c0p-1L, + 0x1.dfc97337b9b5eb968cac39ed284cp-1L, + 0x1.e264614f5a128a12761fa17adc74p-1L, + 0x1.e502ee78b3ff6273d130153992d0p-1L, + 0x1.e7a51fbc74c834b548b2832378a4p-1L, + 0x1.ea4afa2a490d9858f73a18f5dab4p-1L, + 0x1.ecf482d8e67f08db0312fb949d50p-1L, + 0x1.efa1bee615a27771fd21a92dabb6p-1L, + 0x1.f252b376bba974e8696fc3638f24p-1L, + 0x1.f50765b6e4540674f84b762861a6p-1L, + 0x1.f7bfdad9cbe138913b4bfe72bd78p-1L, + 0x1.fa7c1819e90d82e90a7e74b26360p-1L, + 0x1.fd3c22b8f71f10975ba4b32bd006p-1L, + 0x1.0000000000000000000000000000p+0L, + 0x1.0163da9fb33356d84a66ae336e98p+0L, + 0x1.02c9a3e778060ee6f7caca4f7a18p+0L, + 0x1.04315e86e7f84bd738f9a20da442p+0L, + 0x1.059b0d31585743ae7c548eb68c6ap+0L, + 0x1.0706b29ddf6ddc6dc403a9d87b1ep+0L, + 0x1.0874518759bc808c35f25d942856p+0L, + 0x1.09e3ecac6f3834521e060c584d5cp+0L, + 0x1.0b5586cf9890f6298b92b7184200p+0L, + 0x1.0cc922b7247f7407b705b893dbdep+0L, + 0x1.0e3ec32d3d1a2020742e4f8af794p+0L, + 0x1.0fb66affed31af232091dd8a169ep+0L, + 0x1.11301d0125b50a4ebbf1aed9321cp+0L, + 0x1.12abdc06c31cbfb92bad324d6f84p+0L, + 0x1.1429aaea92ddfb34101943b2588ep+0L, + 0x1.15a98c8a58e512480d573dd562aep+0L, + 0x1.172b83c7d517adcdf7c8c50eb162p+0L, + 0x1.18af9388c8de9bbbf70b9a3c269cp+0L, + 0x1.1a35beb6fcb753cb698f692d2038p+0L, + 0x1.1bbe084045cd39ab1e72b442810ep+0L, + 0x1.1d4873168b9aa7805b8028990be8p+0L, + 0x1.1ed5022fcd91cb8819ff61121fbep+0L, + 0x1.2063b88628cd63b8eeb0295093f6p+0L, + 0x1.21f49917ddc962552fd29294bc20p+0L, + 0x1.2387a6e75623866c1fadb1c159c0p+0L, + 0x1.251ce4fb2a63f3582ab7de9e9562p+0L, + 0x1.26b4565e27cdd257a673281d3068p+0L, + 0x1.284dfe1f5638096cf15cf03c9fa0p+0L, + 0x1.29e9df51fdee12c25d15f5a25022p+0L, + 0x1.2b87fd0dad98ffddea46538fca24p+0L, + 0x1.2d285a6e4030b40091d536d0733ep+0L, + 0x1.2ecafa93e2f5611ca0f45d5239a4p+0L, + 0x1.306fe0a31b7152de8d5a463063bep+0L, + 0x1.32170fc4cd8313539cf1c3009330p+0L, + 0x1.33c08b26416ff4c9c8610d96680ep+0L, + 0x1.356c55f929ff0c94623476373be4p+0L, + 0x1.371a7373aa9caa7145502f45452ap+0L, + 0x1.38cae6d05d86585a9cb0d9bed530p+0L, + 0x1.3a7db34e59ff6ea1bc9299e0a1fep+0L, + 0x1.3c32dc313a8e484001f228b58cf0p+0L, + 0x1.3dea64c12342235b41223e13d7eep+0L, + 0x1.3fa4504ac801ba0bf701aa417b9cp+0L, + 0x1.4160a21f72e29f84325b8f3dbacap+0L, + 0x1.431f5d950a896dc704439410b628p+0L, + 0x1.44e086061892d03136f409df0724p+0L, + 0x1.46a41ed1d005772512f459229f0ap+0L, + 0x1.486a2b5c13cd013c1a3b69062f26p+0L, + 0x1.4a32af0d7d3de672d8bcf46f99b4p+0L, + 0x1.4bfdad5362a271d4397afec42e36p+0L, + 0x1.4dcb299fddd0d63b36ef1a9e19dep+0L, + 0x1.4f9b2769d2ca6ad33d8b69aa0b8cp+0L, + 0x1.516daa2cf6641c112f52c84d6066p+0L, + 0x1.5342b569d4f81df0a83c49d86bf4p+0L, + 0x1.551a4ca5d920ec52ec620243540cp+0L, + 0x1.56f4736b527da66ecb004764e61ep+0L, + 0x1.58d12d497c7fd252bc2b7343d554p+0L, + 0x1.5ab07dd48542958c93015191e9a8p+0L, + 0x1.5c9268a5946b701c4b1b81697ed4p+0L, + 0x1.5e76f15ad21486e9be4c20399d12p+0L, + 0x1.605e1b976dc08b076f592a487066p+0L, + 0x1.6247eb03a5584b1f0fa06fd2d9eap+0L, + 0x1.6434634ccc31fc76f8714c4ee122p+0L, + 0x1.66238825522249127d9e29b92ea2p+0L, + 0x1.68155d44ca973081c57227b9f69ep+0L, +}; + +static const float eps[TBLSIZE] = { + -0x1.5c50p-101, -0x1.5d00p-106, 0x1.8e90p-102, -0x1.5340p-103, + 0x1.1bd0p-102, -0x1.4600p-105, -0x1.7a40p-104, 0x1.d590p-102, + -0x1.d590p-101, 0x1.b100p-103, -0x1.0d80p-105, 0x1.6b00p-103, + -0x1.9f00p-105, 0x1.c400p-103, 0x1.e120p-103, -0x1.c100p-104, + -0x1.9d20p-103, 0x1.a800p-108, 0x1.4c00p-106, -0x1.9500p-106, + 0x1.6900p-105, -0x1.29d0p-100, 0x1.4c60p-103, 0x1.13a0p-102, + -0x1.5b60p-103, -0x1.1c40p-103, 0x1.db80p-102, 0x1.91a0p-102, + 0x1.dc00p-105, 0x1.44c0p-104, 0x1.9710p-102, 0x1.8760p-103, + -0x1.a720p-103, 0x1.ed20p-103, -0x1.49c0p-102, -0x1.e000p-111, + 0x1.86a0p-103, 0x1.2b40p-103, -0x1.b400p-108, 0x1.1280p-99, + -0x1.02d8p-102, -0x1.e3d0p-103, -0x1.b080p-105, -0x1.f100p-107, + -0x1.16c0p-105, -0x1.1190p-103, -0x1.a7d2p-100, 0x1.3450p-103, + -0x1.67c0p-105, 0x1.4b80p-104, -0x1.c4e0p-103, 0x1.6000p-108, + -0x1.3f60p-105, 0x1.93f0p-104, 0x1.5fe0p-105, 0x1.6f80p-107, + -0x1.7600p-106, 0x1.21e0p-106, -0x1.3a40p-106, -0x1.40c0p-104, + -0x1.9860p-105, -0x1.5d40p-108, -0x1.1d70p-106, 0x1.2760p-105, + 0x0.0000p+0, 0x1.21e2p-104, -0x1.9520p-108, -0x1.5720p-106, + -0x1.4810p-106, -0x1.be00p-109, 0x1.0080p-105, -0x1.5780p-108, + -0x1.d460p-105, -0x1.6140p-105, 0x1.4630p-104, 0x1.ad50p-103, + 0x1.82e0p-105, 0x1.1d3cp-101, 0x1.6100p-107, 0x1.ec30p-104, + 0x1.f200p-108, 0x1.0b40p-103, 0x1.3660p-102, 0x1.d9d0p-103, + -0x1.02d0p-102, 0x1.b070p-103, 0x1.b9c0p-104, -0x1.01c0p-103, + -0x1.dfe0p-103, 0x1.1b60p-104, -0x1.ae94p-101, -0x1.3340p-104, + 0x1.b3d8p-102, -0x1.6e40p-105, -0x1.3670p-103, 0x1.c140p-104, + 0x1.1840p-101, 0x1.1ab0p-102, -0x1.a400p-104, 0x1.1f00p-104, + -0x1.7180p-103, 0x1.4ce0p-102, 0x1.9200p-107, -0x1.54c0p-103, + 0x1.1b80p-105, -0x1.1828p-101, 0x1.5720p-102, -0x1.a060p-100, + 0x1.9160p-102, 0x1.a280p-104, 0x1.3400p-107, 0x1.2b20p-102, + 0x1.7800p-108, 0x1.cfd0p-101, 0x1.2ef0p-102, -0x1.2760p-99, + 0x1.b380p-104, 0x1.0048p-101, -0x1.60b0p-102, 0x1.a1ccp-100, + -0x1.a640p-104, -0x1.08a0p-101, 0x1.7e60p-102, 0x1.22c0p-103, + -0x1.7200p-106, 0x1.f0f0p-102, 0x1.eb4ep-99, 0x1.c6e0p-103, +}; + +/* + * exp2l(x): compute the base 2 exponential of x + * + * Accuracy: Peak error < 0.502 ulp. + * + * Method: (accurate tables) + * + * Reduce x: + * x = 2**k + y, for integer k and |y| <= 1/2. + * Thus we have exp2(x) = 2**k * exp2(y). + * + * Reduce y: + * y = i/TBLSIZE + z - eps[i] for integer i near y * TBLSIZE. + * Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z - eps[i]), + * with |z - eps[i]| <= 2**-8 + 2**-98 for the table used. + * + * We compute exp2(i/TBLSIZE) via table lookup and exp2(z - eps[i]) via + * a degree-10 minimax polynomial with maximum error under 2**-120. + * The values in exp2t[] and eps[] are chosen such that + * exp2t[i] = exp2(i/TBLSIZE + eps[i]), and eps[i] is a small offset such + * that exp2t[i] is accurate to 2**-122. + * + * Note that the range of i is +-TBLSIZE/2, so we actually index the tables + * by i0 = i + TBLSIZE/2. + * + * This method is due to Gal, with many details due to Gal and Bachelis: + * + * Gal, S. and Bachelis, B. An Accurate Elementary Mathematical Library + * for the IEEE Floating Point Standard. TOMS 17(1), 26-46 (1991). + */ +long double exp2l(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + long double r, z, t; + uint32_t i0; + union { + uint32_t u; + int32_t i; + } k; + + /* Filter out exceptional cases. */ + if (e >= 0x3fff + 14) { /* |x| >= 16384 or x is NaN */ + if (u.i.se >= 0x3fff + 15 && u.i.se >> 15 == 0) + /* overflow */ + return x * 0x1p16383L; + if (e == 0x7fff) /* -inf or -nan */ + return -1 / x; + if (x < -16382) { + if (x <= -16495 || x - 0x1p112 + 0x1p112 != x) + /* underflow */ + FORCE_EVAL((float)(-0x1p-149 / x)); + if (x <= -16446) + return 0; + } + } else if (e < 0x3fff - 114) { + return 1 + x; + } + + /* + * Reduce x, computing z, i0, and k. The low bits of x + redux + * contain the 16-bit integer part of the exponent (k) followed by + * TBLBITS fractional bits (i0). We use bit tricks to extract these + * as integers, then set z to the remainder. + * + * Example: Suppose x is 0xabc.123456p0 and TBLBITS is 8. + * Then the low-order word of x + redux is 0x000abc12, + * We split this into k = 0xabc and i0 = 0x12 (adjusted to + * index into the table), then we compute z = 0x0.003456p0. + */ + u.f = x + redux; + i0 = u.i2.lo + TBLSIZE / 2; + k.u = i0 / TBLSIZE * TBLSIZE; + k.i /= TBLSIZE; + i0 %= TBLSIZE; + u.f -= redux; + z = x - u.f; + + /* Compute r = exp2(y) = exp2t[i0] * p(z - eps[i]). */ + t = tbl[i0]; + z -= eps[i0]; + r = t + + t * z * + (P1 + + z * (P2 + + z * (P3 + + z * (P4 + + z * (P5 + + z * (P6 + + z * (P7 + + z * (P8 + + z * (P9 + + z * P10))))))))); + + return scalbnl(r, k.i); +} +#endif diff --git a/lib/libm/exp_data.c b/lib/libm/exp_data.c new file mode 100644 index 00000000..21be0146 --- /dev/null +++ b/lib/libm/exp_data.c @@ -0,0 +1,182 @@ +/* + * Shared data between exp, exp2 and pow. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "exp_data.h" + +#define N (1 << EXP_TABLE_BITS) + +const struct exp_data __exp_data = { +// N/ln2 +.invln2N = 0x1.71547652b82fep0 * N, +// -ln2/N +.negln2hiN = -0x1.62e42fefa0000p-8, +.negln2loN = -0x1.cf79abc9e3b3ap-47, +// Used for rounding when !TOINT_INTRINSICS +#if EXP_USE_TOINT_NARROW +.shift = 0x1800000000.8p0, +#else +.shift = 0x1.8p52, +#endif +// exp polynomial coefficients. +.poly = { +// abs error: 1.555*2^-66 +// ulp error: 0.509 (0.511 without fma) +// if |x| < ln2/256+eps +// abs error if |x| < ln2/256+0x1p-15: 1.09*2^-65 +// abs error if |x| < ln2/128: 1.7145*2^-56 +0x1.ffffffffffdbdp-2, +0x1.555555555543cp-3, +0x1.55555cf172b91p-5, +0x1.1111167a4d017p-7, +}, +.exp2_shift = 0x1.8p52 / N, +// exp2 polynomial coefficients. +.exp2_poly = { +// abs error: 1.2195*2^-65 +// ulp error: 0.507 (0.511 without fma) +// if |x| < 1/256 +// abs error if |x| < 1/128: 1.9941*2^-56 +0x1.62e42fefa39efp-1, +0x1.ebfbdff82c424p-3, +0x1.c6b08d70cf4b5p-5, +0x1.3b2abd24650ccp-7, +0x1.5d7e09b4e3a84p-10, +}, +// 2^(k/N) ~= H[k]*(1 + T[k]) for int k in [0,N) +// tab[2*k] = asuint64(T[k]) +// tab[2*k+1] = asuint64(H[k]) - (k << 52)/N +.tab = { +0x0, 0x3ff0000000000000, +0x3c9b3b4f1a88bf6e, 0x3feff63da9fb3335, +0xbc7160139cd8dc5d, 0x3fefec9a3e778061, +0xbc905e7a108766d1, 0x3fefe315e86e7f85, +0x3c8cd2523567f613, 0x3fefd9b0d3158574, +0xbc8bce8023f98efa, 0x3fefd06b29ddf6de, +0x3c60f74e61e6c861, 0x3fefc74518759bc8, +0x3c90a3e45b33d399, 0x3fefbe3ecac6f383, +0x3c979aa65d837b6d, 0x3fefb5586cf9890f, +0x3c8eb51a92fdeffc, 0x3fefac922b7247f7, +0x3c3ebe3d702f9cd1, 0x3fefa3ec32d3d1a2, +0xbc6a033489906e0b, 0x3fef9b66affed31b, +0xbc9556522a2fbd0e, 0x3fef9301d0125b51, +0xbc5080ef8c4eea55, 0x3fef8abdc06c31cc, +0xbc91c923b9d5f416, 0x3fef829aaea92de0, +0x3c80d3e3e95c55af, 0x3fef7a98c8a58e51, +0xbc801b15eaa59348, 0x3fef72b83c7d517b, +0xbc8f1ff055de323d, 0x3fef6af9388c8dea, +0x3c8b898c3f1353bf, 0x3fef635beb6fcb75, +0xbc96d99c7611eb26, 0x3fef5be084045cd4, +0x3c9aecf73e3a2f60, 0x3fef54873168b9aa, +0xbc8fe782cb86389d, 0x3fef4d5022fcd91d, +0x3c8a6f4144a6c38d, 0x3fef463b88628cd6, +0x3c807a05b0e4047d, 0x3fef3f49917ddc96, +0x3c968efde3a8a894, 0x3fef387a6e756238, +0x3c875e18f274487d, 0x3fef31ce4fb2a63f, +0x3c80472b981fe7f2, 0x3fef2b4565e27cdd, +0xbc96b87b3f71085e, 0x3fef24dfe1f56381, +0x3c82f7e16d09ab31, 0x3fef1e9df51fdee1, +0xbc3d219b1a6fbffa, 0x3fef187fd0dad990, +0x3c8b3782720c0ab4, 0x3fef1285a6e4030b, +0x3c6e149289cecb8f, 0x3fef0cafa93e2f56, +0x3c834d754db0abb6, 0x3fef06fe0a31b715, +0x3c864201e2ac744c, 0x3fef0170fc4cd831, +0x3c8fdd395dd3f84a, 0x3feefc08b26416ff, +0xbc86a3803b8e5b04, 0x3feef6c55f929ff1, +0xbc924aedcc4b5068, 0x3feef1a7373aa9cb, +0xbc9907f81b512d8e, 0x3feeecae6d05d866, +0xbc71d1e83e9436d2, 0x3feee7db34e59ff7, +0xbc991919b3ce1b15, 0x3feee32dc313a8e5, +0x3c859f48a72a4c6d, 0x3feedea64c123422, +0xbc9312607a28698a, 0x3feeda4504ac801c, +0xbc58a78f4817895b, 0x3feed60a21f72e2a, +0xbc7c2c9b67499a1b, 0x3feed1f5d950a897, +0x3c4363ed60c2ac11, 0x3feece086061892d, +0x3c9666093b0664ef, 0x3feeca41ed1d0057, +0x3c6ecce1daa10379, 0x3feec6a2b5c13cd0, +0x3c93ff8e3f0f1230, 0x3feec32af0d7d3de, +0x3c7690cebb7aafb0, 0x3feebfdad5362a27, +0x3c931dbdeb54e077, 0x3feebcb299fddd0d, +0xbc8f94340071a38e, 0x3feeb9b2769d2ca7, +0xbc87deccdc93a349, 0x3feeb6daa2cf6642, +0xbc78dec6bd0f385f, 0x3feeb42b569d4f82, +0xbc861246ec7b5cf6, 0x3feeb1a4ca5d920f, +0x3c93350518fdd78e, 0x3feeaf4736b527da, +0x3c7b98b72f8a9b05, 0x3feead12d497c7fd, +0x3c9063e1e21c5409, 0x3feeab07dd485429, +0x3c34c7855019c6ea, 0x3feea9268a5946b7, +0x3c9432e62b64c035, 0x3feea76f15ad2148, +0xbc8ce44a6199769f, 0x3feea5e1b976dc09, +0xbc8c33c53bef4da8, 0x3feea47eb03a5585, +0xbc845378892be9ae, 0x3feea34634ccc320, +0xbc93cedd78565858, 0x3feea23882552225, +0x3c5710aa807e1964, 0x3feea155d44ca973, +0xbc93b3efbf5e2228, 0x3feea09e667f3bcd, +0xbc6a12ad8734b982, 0x3feea012750bdabf, +0xbc6367efb86da9ee, 0x3fee9fb23c651a2f, +0xbc80dc3d54e08851, 0x3fee9f7df9519484, +0xbc781f647e5a3ecf, 0x3fee9f75e8ec5f74, +0xbc86ee4ac08b7db0, 0x3fee9f9a48a58174, +0xbc8619321e55e68a, 0x3fee9feb564267c9, +0x3c909ccb5e09d4d3, 0x3feea0694fde5d3f, +0xbc7b32dcb94da51d, 0x3feea11473eb0187, +0x3c94ecfd5467c06b, 0x3feea1ed0130c132, +0x3c65ebe1abd66c55, 0x3feea2f336cf4e62, +0xbc88a1c52fb3cf42, 0x3feea427543e1a12, +0xbc9369b6f13b3734, 0x3feea589994cce13, +0xbc805e843a19ff1e, 0x3feea71a4623c7ad, +0xbc94d450d872576e, 0x3feea8d99b4492ed, +0x3c90ad675b0e8a00, 0x3feeaac7d98a6699, +0x3c8db72fc1f0eab4, 0x3feeace5422aa0db, +0xbc65b6609cc5e7ff, 0x3feeaf3216b5448c, +0x3c7bf68359f35f44, 0x3feeb1ae99157736, +0xbc93091fa71e3d83, 0x3feeb45b0b91ffc6, +0xbc5da9b88b6c1e29, 0x3feeb737b0cdc5e5, +0xbc6c23f97c90b959, 0x3feeba44cbc8520f, +0xbc92434322f4f9aa, 0x3feebd829fde4e50, +0xbc85ca6cd7668e4b, 0x3feec0f170ca07ba, +0x3c71affc2b91ce27, 0x3feec49182a3f090, +0x3c6dd235e10a73bb, 0x3feec86319e32323, +0xbc87c50422622263, 0x3feecc667b5de565, +0x3c8b1c86e3e231d5, 0x3feed09bec4a2d33, +0xbc91bbd1d3bcbb15, 0x3feed503b23e255d, +0x3c90cc319cee31d2, 0x3feed99e1330b358, +0x3c8469846e735ab3, 0x3feede6b5579fdbf, +0xbc82dfcd978e9db4, 0x3feee36bbfd3f37a, +0x3c8c1a7792cb3387, 0x3feee89f995ad3ad, +0xbc907b8f4ad1d9fa, 0x3feeee07298db666, +0xbc55c3d956dcaeba, 0x3feef3a2b84f15fb, +0xbc90a40e3da6f640, 0x3feef9728de5593a, +0xbc68d6f438ad9334, 0x3feeff76f2fb5e47, +0xbc91eee26b588a35, 0x3fef05b030a1064a, +0x3c74ffd70a5fddcd, 0x3fef0c1e904bc1d2, +0xbc91bdfbfa9298ac, 0x3fef12c25bd71e09, +0x3c736eae30af0cb3, 0x3fef199bdd85529c, +0x3c8ee3325c9ffd94, 0x3fef20ab5fffd07a, +0x3c84e08fd10959ac, 0x3fef27f12e57d14b, +0x3c63cdaf384e1a67, 0x3fef2f6d9406e7b5, +0x3c676b2c6c921968, 0x3fef3720dcef9069, +0xbc808a1883ccb5d2, 0x3fef3f0b555dc3fa, +0xbc8fad5d3ffffa6f, 0x3fef472d4a07897c, +0xbc900dae3875a949, 0x3fef4f87080d89f2, +0x3c74a385a63d07a7, 0x3fef5818dcfba487, +0xbc82919e2040220f, 0x3fef60e316c98398, +0x3c8e5a50d5c192ac, 0x3fef69e603db3285, +0x3c843a59ac016b4b, 0x3fef7321f301b460, +0xbc82d52107b43e1f, 0x3fef7c97337b9b5f, +0xbc892ab93b470dc9, 0x3fef864614f5a129, +0x3c74b604603a88d3, 0x3fef902ee78b3ff6, +0x3c83c5ec519d7271, 0x3fef9a51fbc74c83, +0xbc8ff7128fd391f0, 0x3fefa4afa2a490da, +0xbc8dae98e223747d, 0x3fefaf482d8e67f1, +0x3c8ec3bc41aa2008, 0x3fefba1bee615a27, +0x3c842b94c3a9eb32, 0x3fefc52b376bba97, +0x3c8a64a931d185ee, 0x3fefd0765b6e4540, +0xbc8e37bae43be3ed, 0x3fefdbfdad9cbe14, +0x3c77893b4d91cd9d, 0x3fefe7c1819e90d8, +0x3c5305c14160cc89, 0x3feff3c22b8f71f1, +}, +}; diff --git a/lib/libm/exp_data.h b/lib/libm/exp_data.h new file mode 100644 index 00000000..76f016ad --- /dev/null +++ b/lib/libm/exp_data.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _EXP_DATA_H +#define _EXP_DATA_H + +#include <stdint.h> + +#define hidden __attribute__((visibility("hidden"))) + +#define EXP_TABLE_BITS 7 +#define EXP_POLY_ORDER 5 +#define EXP_USE_TOINT_NARROW 0 +#define EXP2_POLY_ORDER 5 +extern hidden const struct exp_data { + double invln2N; + double shift; + double negln2hiN; + double negln2loN; + double poly[4]; /* Last four coefficients. */ + double exp2_shift; + double exp2_poly[EXP2_POLY_ORDER]; + uint64_t tab[2 * (1 << EXP_TABLE_BITS)]; +} __exp_data; + +#endif diff --git a/lib/libm/expf.c b/lib/libm/expf.c new file mode 100644 index 00000000..53108c44 --- /dev/null +++ b/lib/libm/expf.c @@ -0,0 +1,80 @@ +/* + * Single-precision e^x function. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "exp2f_data.h" + +/* +EXP2F_TABLE_BITS = 5 +EXP2F_POLY_ORDER = 3 + +ULP error: 0.502 (nearest rounding.) +Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.) +Wrong count: 170635 (all nearest rounding wrong results with fma.) +Non-nearest ULP error: 1 (rounded ULP error) +*/ + +#define N (1 << EXP2F_TABLE_BITS) +#define InvLn2N __exp2f_data.invln2_scaled +#define T __exp2f_data.tab +#define C __exp2f_data.poly_scaled + +static inline uint32_t top12(float x) +{ + return asuint(x) >> 20; +} + +float expf(float x) +{ + uint32_t abstop; + uint64_t ki, t; + double_t kd, xd, z, r, r2, y, s; + + xd = (double_t)x; + abstop = top12(x) & 0x7ff; + if (predict_false(abstop >= top12(88.0f))) { + /* |x| >= 88 or x is nan. */ + if (asuint(x) == asuint(-INFINITY)) + return 0.0f; + if (abstop >= top12(INFINITY)) + return x + x; + if (x > 0x1.62e42ep6f) /* x > log(0x1p128) ~= 88.72 */ + return __math_oflowf(0); + if (x < -0x1.9fe368p6f) /* x < log(0x1p-150) ~= -103.97 */ + return __math_uflowf(0); + } + + /* x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k. */ + z = InvLn2N * xd; + + /* Round and convert z to int, the result is in [-150*N, 128*N] and + ideally ties-to-even rule is used, otherwise the magnitude of r + can be bigger which gives larger approximation error. */ +#if TOINT_INTRINSICS + kd = roundtoint(z); + ki = converttoint(z); +#else +#define SHIFT __exp2f_data.shift + kd = eval_as_double(z + SHIFT); + ki = asuint64(kd); + kd -= SHIFT; +#endif + r = z - kd; + + /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ + t = T[ki % N]; + t += ki << (52 - EXP2F_TABLE_BITS); + s = asdouble(t); + z = C[0] * r + C[1]; + r2 = r * r; + y = C[2] * r + 1; + y = z * r2 + y; + y = y * s; + return eval_as_float(y); +} diff --git a/lib/libm/expl.c b/lib/libm/expl.c new file mode 100644 index 00000000..85ac4f10 --- /dev/null +++ b/lib/libm/expl.c @@ -0,0 +1,127 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_expl.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Exponential function, long double precision + * + * + * SYNOPSIS: + * + * long double x, y, expl(); + * + * y = expl( x ); + * + * + * DESCRIPTION: + * + * Returns e (2.71828...) raised to the x power. + * + * Range reduction is accomplished by separating the argument + * into an integer k and fraction f such that + * + * x k f + * e = 2 e. + * + * A Pade' form of degree 5/6 is used to approximate exp(f) - 1 + * in the basic range [-0.5 ln 2, 0.5 ln 2]. + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE +-10000 50000 1.12e-19 2.81e-20 + * + * + * Error amplification in the exponential function can be + * a serious matter. The error propagation involves + * exp( X(1+delta) ) = exp(X) ( 1 + X*delta + ... ), + * which shows that a 1 lsb error in representing X produces + * a relative error of X times 1 lsb in the function. + * While the routine gives an accurate result for arguments + * that are exactly represented by a long double precision + * computer number, the result contains amplified roundoff + * error for large arguments not exactly represented. + * + * + * ERROR MESSAGES: + * + * message condition value returned + * exp underflow x < MINLOG 0.0 + * exp overflow x > MAXLOG MAXNUM + * + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double expl(long double x) +{ + return exp(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 + +static const long double P[3] = { + 1.2617719307481059087798E-4L, + 3.0299440770744196129956E-2L, + 9.9999999999999999991025E-1L, +}; +static const long double Q[4] = { + 3.0019850513866445504159E-6L, + 2.5244834034968410419224E-3L, + 2.2726554820815502876593E-1L, + 2.0000000000000000000897E0L, +}; +static const long double LN2HI = 6.9314575195312500000000E-1L, + LN2LO = 1.4286068203094172321215E-6L, + LOG2E = 1.4426950408889634073599E0L; + +long double expl(long double x) +{ + long double px, xx; + int k; + + if (isnan(x)) + return x; + if (x > 11356.5234062941439488L) /* x > ln(2^16384 - 0.5) */ + return x * 0x1p16383L; + if (x < -11399.4985314888605581L) /* x < ln(2^-16446) */ + return -0x1p-16445L / x; + + /* Express e**x = e**f 2**k + * = e**(f + k ln(2)) + */ + px = floorl(LOG2E * x + 0.5); + k = px; + x -= px * LN2HI; + x -= px * LN2LO; + + /* rational approximation of the fractional part: + * e**x = 1 + 2x P(x**2)/(Q(x**2) - x P(x**2)) + */ + xx = x * x; + px = x * __polevll(xx, P, 2); + x = px / (__polevll(xx, Q, 3) - px); + x = 1.0 + 2.0 * x; + return scalbnl(x, k); +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double expl(long double x) +{ + return exp(x); +} +#endif diff --git a/lib/libm/expm1.c b/lib/libm/expm1.c new file mode 100644 index 00000000..4ce99a4d --- /dev/null +++ b/lib/libm/expm1.c @@ -0,0 +1,205 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_expm1.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* expm1(x) + * Returns exp(x)-1, the exponential of x minus 1. + * + * Method + * 1. Argument reduction: + * Given x, find r and integer k such that + * + * x = k*ln2 + r, |r| <= 0.5*ln2 ~ 0.34658 + * + * Here a correction term c will be computed to compensate + * the error in r when rounded to a floating-point number. + * + * 2. Approximating expm1(r) by a special rational function on + * the interval [0,0.34658]: + * Since + * r*(exp(r)+1)/(exp(r)-1) = 2+ r^2/6 - r^4/360 + ... + * we define R1(r*r) by + * r*(exp(r)+1)/(exp(r)-1) = 2+ r^2/6 * R1(r*r) + * That is, + * R1(r**2) = 6/r *((exp(r)+1)/(exp(r)-1) - 2/r) + * = 6/r * ( 1 + 2.0*(1/(exp(r)-1) - 1/r)) + * = 1 - r^2/60 + r^4/2520 - r^6/100800 + ... + * We use a special Remez algorithm on [0,0.347] to generate + * a polynomial of degree 5 in r*r to approximate R1. The + * maximum error of this polynomial approximation is bounded + * by 2**-61. In other words, + * R1(z) ~ 1.0 + Q1*z + Q2*z**2 + Q3*z**3 + Q4*z**4 + Q5*z**5 + * where Q1 = -1.6666666666666567384E-2, + * Q2 = 3.9682539681370365873E-4, + * Q3 = -9.9206344733435987357E-6, + * Q4 = 2.5051361420808517002E-7, + * Q5 = -6.2843505682382617102E-9; + * z = r*r, + * with error bounded by + * | 5 | -61 + * | 1.0+Q1*z+...+Q5*z - R1(z) | <= 2 + * | | + * + * expm1(r) = exp(r)-1 is then computed by the following + * specific way which minimize the accumulation rounding error: + * 2 3 + * r r [ 3 - (R1 + R1*r/2) ] + * expm1(r) = r + --- + --- * [--------------------] + * 2 2 [ 6 - r*(3 - R1*r/2) ] + * + * To compensate the error in the argument reduction, we use + * expm1(r+c) = expm1(r) + c + expm1(r)*c + * ~ expm1(r) + c + r*c + * Thus c+r*c will be added in as the correction terms for + * expm1(r+c). Now rearrange the term to avoid optimization + * screw up: + * ( 2 2 ) + * ({ ( r [ R1 - (3 - R1*r/2) ] ) } r ) + * expm1(r+c)~r - ({r*(--- * [--------------------]-c)-c} - --- ) + * ({ ( 2 [ 6 - r*(3 - R1*r/2) ] ) } 2 ) + * ( ) + * + * = r - E + * 3. Scale back to obtain expm1(x): + * From step 1, we have + * expm1(x) = either 2^k*[expm1(r)+1] - 1 + * = or 2^k*[expm1(r) + (1-2^-k)] + * 4. Implementation notes: + * (A). To save one multiplication, we scale the coefficient Qi + * to Qi*2^i, and replace z by (x^2)/2. + * (B). To achieve maximum accuracy, we compute expm1(x) by + * (i) if x < -56*ln2, return -1.0, (raise inexact if x!=inf) + * (ii) if k=0, return r-E + * (iii) if k=-1, return 0.5*(r-E)-0.5 + * (iv) if k=1 if r < -0.25, return 2*((r+0.5)- E) + * else return 1.0+2.0*(r-E); + * (v) if (k<-2||k>56) return 2^k(1-(E-r)) - 1 (or exp(x)-1) + * (vi) if k <= 20, return 2^k((1-2^-k)-(E-r)), else + * (vii) return 2^k(1-((E+2^-k)-r)) + * + * Special cases: + * expm1(INF) is INF, expm1(NaN) is NaN; + * expm1(-INF) is -1, and + * for finite argument, only expm1(0)=0 is exact. + * + * Accuracy: + * according to an error analysis, the error is always less than + * 1 ulp (unit in the last place). + * + * Misc. info. + * For IEEE double + * if x > 7.09782712893383973096e+02 then expm1(x) overflow + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "libm.h" + +static const double o_threshold = 7.09782712893383973096e+02, /* 0x40862E42, + 0xFEFA39EF */ + ln2_hi = 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */ + ln2_lo = 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */ + invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */ + /* Scaled Q's: Qn_here = 2**n * Qn_above, for R(2*z) where z = hxs = + x*x/2: */ + Q1 = -3.33333333333331316428e-02, /* BFA11111 111110F4 */ + Q2 = 1.58730158725481460165e-03, /* 3F5A01A0 19FE5585 */ + Q3 = -7.93650757867487942473e-05, /* BF14CE19 9EAADBB7 */ + Q4 = 4.00821782732936239552e-06, /* 3ED0CFCA 86E65239 */ + Q5 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */ + +double expm1(double x) +{ + double_t y, hi, lo, c, t, e, hxs, hfx, r1, twopk; + union { + double f; + uint64_t i; + } u = { x }; + uint32_t hx = u.i >> 32 & 0x7fffffff; + int k, sign = u.i >> 63; + + /* filter out huge and non-finite argument */ + if (hx >= 0x4043687A) { /* if |x|>=56*ln2 */ + if (isnan(x)) + return x; + if (sign) + return -1; + if (x > o_threshold) { + x *= 0x1p1023; + return x; + } + } + + /* argument reduction */ + if (hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */ + if (hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */ + if (!sign) { + hi = x - ln2_hi; + lo = ln2_lo; + k = 1; + } else { + hi = x + ln2_hi; + lo = -ln2_lo; + k = -1; + } + } else { + k = invln2 * x + (sign ? -0.5 : 0.5); + t = k; + hi = x - t * ln2_hi; /* t*ln2_hi is exact here */ + lo = t * ln2_lo; + } + x = hi - lo; + c = (hi - x) - lo; + } else if (hx < 0x3c900000) { /* |x| < 2**-54, return x */ + if (hx < 0x00100000) + FORCE_EVAL((float)x); + return x; + } else + k = 0; + + /* x is now in primary range */ + hfx = 0.5 * x; + hxs = x * hfx; + r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5)))); + t = 3.0 - r1 * hfx; + e = hxs * ((r1 - t) / (6.0 - x * t)); + if (k == 0) /* c is 0 */ + return x - (x * e - hxs); + e = x * (e - c) - c; + e -= hxs; + /* exp(x) ~ 2^k (x_reduced - e + 1) */ + if (k == -1) + return 0.5 * (x - e) - 0.5; + if (k == 1) { + if (x < -0.25) + return -2.0 * (e - (x + 0.5)); + return 1.0 + 2.0 * (x - e); + } + u.i = (uint64_t)(0x3ff + k) << 52; /* 2^k */ + twopk = u.f; + if (k < 0 || k > 56) { /* suffice to return exp(x)-1 */ + y = x - e + 1.0; + if (k == 1024) + y = y * 2.0 * 0x1p1023; + else + y = y * twopk; + return y - 1.0; + } + u.i = (uint64_t)(0x3ff - k) << 52; /* 2^-k */ + if (k < 20) + y = (x - e + (1 - u.f)) * twopk; + else + y = (x - (e + u.f) + 1) * twopk; + return y; +} diff --git a/lib/libm/expm1f.c b/lib/libm/expm1f.c new file mode 100644 index 00000000..7cc13b91 --- /dev/null +++ b/lib/libm/expm1f.c @@ -0,0 +1,112 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_expm1f.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +static const float ln2_hi = 6.9313812256e-01, /* 0x3f317180 */ + ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */ + invln2 = 1.4426950216e+00, /* 0x3fb8aa3b */ + /* + * Domain [-0.34568, 0.34568], range ~[-6.694e-10, 6.696e-10]: + * |6 / x * (1 + 2 * (1 / (exp(x) - 1) - 1 / x)) - q(x)| < 2**-30.04 + * Scaled coefficients: Qn_here = 2**n * Qn_for_q (see s_expm1.c): + */ + Q1 = -3.3333212137e-2, /* -0x888868.0p-28 */ + Q2 = 1.5807170421e-3; /* 0xcf3010.0p-33 */ + +float expm1f(float x) +{ + float_t y, hi, lo, c, t, e, hxs, hfx, r1, twopk; + union { + float f; + uint32_t i; + } u = { x }; + uint32_t hx = u.i & 0x7fffffff; + int k, sign = u.i >> 31; + + /* filter out huge and non-finite argument */ + if (hx >= 0x4195b844) { /* if |x|>=27*ln2 */ + if (hx > 0x7f800000) /* NaN */ + return x; + if (sign) + return -1; + if (hx > 0x42b17217) { /* x > log(FLT_MAX) */ + x *= 0x1p127f; + return x; + } + } + + /* argument reduction */ + if (hx > 0x3eb17218) { /* if |x| > 0.5 ln2 */ + if (hx < 0x3F851592) { /* and |x| < 1.5 ln2 */ + if (!sign) { + hi = x - ln2_hi; + lo = ln2_lo; + k = 1; + } else { + hi = x + ln2_hi; + lo = -ln2_lo; + k = -1; + } + } else { + k = invln2 * x + (sign ? -0.5f : 0.5f); + t = k; + hi = x - t * ln2_hi; /* t*ln2_hi is exact here */ + lo = t * ln2_lo; + } + x = hi - lo; + c = (hi - x) - lo; + } else if (hx < 0x33000000) { /* when |x|<2**-25, return x */ + if (hx < 0x00800000) + FORCE_EVAL(x * x); + return x; + } else + k = 0; + + /* x is now in primary range */ + hfx = 0.5f * x; + hxs = x * hfx; + r1 = 1.0f + hxs * (Q1 + hxs * Q2); + t = 3.0f - r1 * hfx; + e = hxs * ((r1 - t) / (6.0f - x * t)); + if (k == 0) /* c is 0 */ + return x - (x * e - hxs); + e = x * (e - c) - c; + e -= hxs; + /* exp(x) ~ 2^k (x_reduced - e + 1) */ + if (k == -1) + return 0.5f * (x - e) - 0.5f; + if (k == 1) { + if (x < -0.25f) + return -2.0f * (e - (x + 0.5f)); + return 1.0f + 2.0f * (x - e); + } + u.i = (0x7f + k) << 23; /* 2^k */ + twopk = u.f; + if (k < 0 || k > 56) { /* suffice to return exp(x)-1 */ + y = x - e + 1.0f; + if (k == 128) + y = y * 2.0f * 0x1p127f; + else + y = y * twopk; + return y - 1.0f; + } + u.i = (0x7f - k) << 23; /* 2^-k */ + if (k < 23) + y = (x - e + (1 - u.f)) * twopk; + else + y = (x - (e + u.f) + 1) * twopk; + return y; +} diff --git a/lib/libm/expm1l.c b/lib/libm/expm1l.c new file mode 100644 index 00000000..959751bf --- /dev/null +++ b/lib/libm/expm1l.c @@ -0,0 +1,122 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_expm1l.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Exponential function, minus 1 + * Long double precision + * + * + * SYNOPSIS: + * + * long double x, y, expm1l(); + * + * y = expm1l( x ); + * + * + * DESCRIPTION: + * + * Returns e (2.71828...) raised to the x power, minus 1. + * + * Range reduction is accomplished by separating the argument + * into an integer k and fraction f such that + * + * x k f + * e = 2 e. + * + * An expansion x + .5 x^2 + x^3 R(x) approximates exp(f) - 1 + * in the basic range [-0.5 ln 2, 0.5 ln 2]. + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE -45,+maxarg 200,000 1.2e-19 2.5e-20 + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double expm1l(long double x) +{ + return expm1(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 + +/* exp(x) - 1 = x + 0.5 x^2 + x^3 P(x)/Q(x) + -.5 ln 2 < x < .5 ln 2 + Theoretical peak relative error = 3.4e-22 */ +static const long double P0 = -1.586135578666346600772998894928250240826E4L, + P1 = 2.642771505685952966904660652518429479531E3L, + P2 = -3.423199068835684263987132888286791620673E2L, + P3 = 1.800826371455042224581246202420972737840E1L, + P4 = -5.238523121205561042771939008061958820811E-1L, + Q0 = -9.516813471998079611319047060563358064497E4L, + Q1 = 3.964866271411091674556850458227710004570E4L, + Q2 = -7.207678383830091850230366618190187434796E3L, + Q3 = 7.206038318724600171970199625081491823079E2L, + Q4 = -4.002027679107076077238836622982900945173E1L, + /* Q5 = 1.000000000000000000000000000000000000000E0 */ + /* C1 + C2 = ln 2 */ + C1 = 6.93145751953125E-1L, + C2 = 1.428606820309417232121458176568075500134E-6L, + /* ln 2^-65 */ + minarg = -4.5054566736396445112120088E1L, + /* ln 2^16384 */ + maxarg = 1.1356523406294143949492E4L; + +long double expm1l(long double x) +{ + long double px, qx, xx; + int k; + + if (isnan(x)) + return x; + if (x > maxarg) + return x * 0x1p16383L; /* overflow, unless x==inf */ + if (x == 0.0) + return x; + if (x < minarg) + return -1.0; + + xx = C1 + C2; + /* Express x = ln 2 (k + remainder), remainder not exceeding 1/2. */ + px = floorl(0.5 + x / xx); + k = px; + /* remainder times ln 2 */ + x -= px * C1; + x -= px * C2; + + /* Approximate exp(remainder ln 2).*/ + px = ((((P4 * x + P3) * x + P2) * x + P1) * x + P0) * x; + qx = ((((x + Q4) * x + Q3) * x + Q2) * x + Q1) * x + Q0; + xx = x * x; + qx = x + (0.5 * xx + xx * px / qx); + + /* exp(x) = exp(k ln 2) exp(remainder ln 2) = 2^k exp(remainder ln 2). + We have qx = exp(remainder ln 2) - 1, so + exp(x) - 1 = 2^k (qx + 1) - 1 = 2^k qx + 2^k - 1. */ + px = scalbnl(1.0, k); + x = px * qx + (px - 1.0); + return x; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double expm1l(long double x) +{ + return expm1(x); +} +#endif diff --git a/lib/libm/fabs.c b/lib/libm/fabs.c new file mode 100644 index 00000000..deb2dc42 --- /dev/null +++ b/lib/libm/fabs.c @@ -0,0 +1,12 @@ +#include <math.h> +#include <stdint.h> + +double fabs(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + u.i &= -1ULL / 2; + return u.f; +} diff --git a/lib/libm/fabsf.c b/lib/libm/fabsf.c new file mode 100644 index 00000000..712dab65 --- /dev/null +++ b/lib/libm/fabsf.c @@ -0,0 +1,12 @@ +#include <math.h> +#include <stdint.h> + +float fabsf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + u.i &= 0x7fffffff; + return u.f; +} diff --git a/lib/libm/fabsl.c b/lib/libm/fabsl.c new file mode 100644 index 00000000..9ffe8bbf --- /dev/null +++ b/lib/libm/fabsl.c @@ -0,0 +1,15 @@ +#include "libm.h" +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double fabsl(long double x) +{ + return fabs(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double fabsl(long double x) +{ + union ldshape u = { x }; + + u.i.se &= 0x7fff; + return u.f; +} +#endif diff --git a/lib/libm/fdim.c b/lib/libm/fdim.c new file mode 100644 index 00000000..95854606 --- /dev/null +++ b/lib/libm/fdim.c @@ -0,0 +1,10 @@ +#include <math.h> + +double fdim(double x, double y) +{ + if (isnan(x)) + return x; + if (isnan(y)) + return y; + return x > y ? x - y : 0; +} diff --git a/lib/libm/fdimf.c b/lib/libm/fdimf.c new file mode 100644 index 00000000..543c3648 --- /dev/null +++ b/lib/libm/fdimf.c @@ -0,0 +1,10 @@ +#include <math.h> + +float fdimf(float x, float y) +{ + if (isnan(x)) + return x; + if (isnan(y)) + return y; + return x > y ? x - y : 0; +} diff --git a/lib/libm/fdiml.c b/lib/libm/fdiml.c new file mode 100644 index 00000000..62e29b7d --- /dev/null +++ b/lib/libm/fdiml.c @@ -0,0 +1,18 @@ +#include <math.h> +#include <float.h> + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double fdiml(long double x, long double y) +{ + return fdim(x, y); +} +#else +long double fdiml(long double x, long double y) +{ + if (isnan(x)) + return x; + if (isnan(y)) + return y; + return x > y ? x - y : 0; +} +#endif diff --git a/lib/libm/finite.c b/lib/libm/finite.c new file mode 100644 index 00000000..25a0575f --- /dev/null +++ b/lib/libm/finite.c @@ -0,0 +1,7 @@ +#define _GNU_SOURCE +#include <math.h> + +int finite(double x) +{ + return isfinite(x); +} diff --git a/lib/libm/finitef.c b/lib/libm/finitef.c new file mode 100644 index 00000000..2c4c7714 --- /dev/null +++ b/lib/libm/finitef.c @@ -0,0 +1,7 @@ +#define _GNU_SOURCE +#include <math.h> + +int finitef(float x) +{ + return isfinite(x); +} diff --git a/lib/libm/floor.c b/lib/libm/floor.c new file mode 100644 index 00000000..9972a974 --- /dev/null +++ b/lib/libm/floor.c @@ -0,0 +1,34 @@ +#include "libm.h" + +#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif +static const double_t toint = 1 / EPS; + +double floor(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + int e = u.i >> 52 & 0x7ff; + double_t y; + + if (e >= 0x3ff + 52 || x == 0) + return x; + /* y = int(x) - x, where int(x) is an integer neighbor of x */ + if (u.i >> 63) + y = x - toint + toint - x; + else + y = x + toint - toint - x; + /* special case because of non-nearest rounding modes */ + if (e <= 0x3ff - 1) { + FORCE_EVAL(y); + return u.i >> 63 ? -1 : 0; + } + if (y > 0) + return x + y - 1; + return x + y; +} diff --git a/lib/libm/floorf.c b/lib/libm/floorf.c new file mode 100644 index 00000000..cd9e99bc --- /dev/null +++ b/lib/libm/floorf.c @@ -0,0 +1,30 @@ +#include "libm.h" + +float floorf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + int e = (int)(u.i >> 23 & 0xff) - 0x7f; + uint32_t m; + + if (e >= 23) + return x; + if (e >= 0) { + m = 0x007fffff >> e; + if ((u.i & m) == 0) + return x; + FORCE_EVAL(x + 0x1p120f); + if (u.i >> 31) + u.i += m; + u.i &= ~m; + } else { + FORCE_EVAL(x + 0x1p120f); + if (u.i >> 31 == 0) + u.i = 0; + else if (u.i << 1) + u.f = -1.0; + } + return u.f; +} diff --git a/lib/libm/floorl.c b/lib/libm/floorl.c new file mode 100644 index 00000000..a1e49c69 --- /dev/null +++ b/lib/libm/floorl.c @@ -0,0 +1,34 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double floorl(long double x) +{ + return floor(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 + +static const long double toint = 1 / LDBL_EPSILON; + +long double floorl(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + long double y; + + if (e >= 0x3fff + LDBL_MANT_DIG - 1 || x == 0) + return x; + /* y = int(x) - x, where int(x) is an integer neighbor of x */ + if (u.i.se >> 15) + y = x - toint + toint - x; + else + y = x + toint - toint - x; + /* special case because of non-nearest rounding modes */ + if (e <= 0x3fff - 1) { + FORCE_EVAL(y); + return u.i.se >> 15 ? -1 : 0; + } + if (y > 0) + return x + y - 1; + return x + y; +} +#endif diff --git a/lib/libm/fma.c b/lib/libm/fma.c new file mode 100644 index 00000000..b657b02a --- /dev/null +++ b/lib/libm/fma.c @@ -0,0 +1,193 @@ +#include <stdint.h> +#include <float.h> +#include <math.h> +#include "atomic.h" + +#define ASUINT64(x) \ + ((union { \ + double f; \ + uint64_t i; \ + }){ x }) \ + .i +#define ZEROINFNAN (0x7ff - 0x3ff - 52 - 1) + +struct num { + uint64_t m; + int e; + int sign; +}; + +static struct num normalize(double x) +{ + uint64_t ix = ASUINT64(x); + int e = ix >> 52; + int sign = e & 0x800; + e &= 0x7ff; + if (!e) { + ix = ASUINT64(x * 0x1p63); + e = ix >> 52 & 0x7ff; + e = e ? e - 63 : 0x800; + } + ix &= (1ull << 52) - 1; + ix |= 1ull << 52; + ix <<= 1; + e -= 0x3ff + 52 + 1; + return (struct num){ ix, e, sign }; +} + +static void mul(uint64_t *hi, uint64_t *lo, uint64_t x, uint64_t y) +{ + uint64_t t1, t2, t3; + uint64_t xlo = (uint32_t)x, xhi = x >> 32; + uint64_t ylo = (uint32_t)y, yhi = y >> 32; + + t1 = xlo * ylo; + t2 = xlo * yhi + xhi * ylo; + t3 = xhi * yhi; + *lo = t1 + (t2 << 32); + *hi = t3 + (t2 >> 32) + (t1 > *lo); +} + +double fma(double x, double y, double z) +{ +#pragma STDC FENV_ACCESS ON + + /* normalize so top 10bits and last bit are 0 */ + struct num nx, ny, nz; + nx = normalize(x); + ny = normalize(y); + nz = normalize(z); + + if (nx.e >= ZEROINFNAN || ny.e >= ZEROINFNAN) + return x * y + z; + if (nz.e >= ZEROINFNAN) { + if (nz.e > ZEROINFNAN) /* z==0 */ + return x * y; + return z; + } + + /* mul: r = x*y */ + uint64_t rhi, rlo, zhi, zlo; + mul(&rhi, &rlo, nx.m, ny.m); + /* either top 20 or 21 bits of rhi and last 2 bits of rlo are 0 */ + + /* align exponents */ + int e = nx.e + ny.e; + int d = nz.e - e; + /* shift bits z<<=kz, r>>=kr, so kz+kr == d, set e = e+kr (== ez-kz) */ + if (d > 0) { + if (d < 64) { + zlo = nz.m << d; + zhi = nz.m >> (64 - d); + } else { + zlo = 0; + zhi = nz.m; + e = nz.e - 64; + d -= 64; + if (d == 0) { + } else if (d < 64) { + rlo = rhi << (64 - d) | rlo >> d | + !!(rlo << (64 - d)); + rhi = rhi >> d; + } else { + rlo = 1; + rhi = 0; + } + } + } else { + zhi = 0; + d = -d; + if (d == 0) { + zlo = nz.m; + } else if (d < 64) { + zlo = nz.m >> d | !!(nz.m << (64 - d)); + } else { + zlo = 1; + } + } + + /* add */ + int sign = nx.sign ^ ny.sign; + int samesign = !(sign ^ nz.sign); + int nonzero = 1; + if (samesign) { + /* r += z */ + rlo += zlo; + rhi += zhi + (rlo < zlo); + } else { + /* r -= z */ + uint64_t t = rlo; + rlo -= zlo; + rhi = rhi - zhi - (t < rlo); + if (rhi >> 63) { + rlo = -rlo; + rhi = -rhi - !!rlo; + sign = !sign; + } + nonzero = !!rhi; + } + + /* set rhi to top 63bit of the result (last bit is sticky) */ + if (nonzero) { + e += 64; + d = a_clz_64(rhi) - 1; + /* note: d > 0 */ + rhi = rhi << d | rlo >> (64 - d) | !!(rlo << d); + } else if (rlo) { + d = a_clz_64(rlo) - 1; + if (d < 0) + rhi = rlo >> 1 | (rlo & 1); + else + rhi = rlo << d; + } else { + /* exact +-0 */ + return x * y + z; + } + e -= d; + + /* convert to double */ + int64_t i = rhi; /* i is in [1<<62,(1<<63)-1] */ + if (sign) + i = -i; + double r = i; /* |r| is in [0x1p62,0x1p63] */ + + if (e < -1022 - 62) { + /* result is subnormal before rounding */ + if (e == -1022 - 63) { + double c = 0x1p63; + if (sign) + c = -c; + if (r == c) { + /* min normal after rounding, underflow depends + on arch behaviour which can be imitated by + a double to float conversion */ + float fltmin = 0x0.ffffff8p-63 * FLT_MIN * r; + return DBL_MIN / FLT_MIN * fltmin; + } + /* one bit is lost when scaled, add another top bit to + only round once at conversion if it is inexact */ + if (rhi << 53) { + i = rhi >> 1 | (rhi & 1) | 1ull << 62; + if (sign) + i = -i; + r = i; + r = 2 * r - c; /* remove top bit */ + + /* raise underflow portably, such that it + cannot be optimized away */ + { + double_t tiny = DBL_MIN / FLT_MIN * r; + r += (double)(tiny * tiny) * (r - r); + } + } + } else { + /* only round once when scaled */ + d = 10; + i = (rhi >> d | !!(rhi << (64 - d))) << d; + if (sign) + i = -i; + r = i; + } + } + return scalbn(r, e); +} diff --git a/lib/libm/fmaf.c b/lib/libm/fmaf.c new file mode 100644 index 00000000..1952b210 --- /dev/null +++ b/lib/libm/fmaf.c @@ -0,0 +1,96 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_fmaf.c */ +/*- + * Copyright (c) 2005-2011 David Schultz <das@FreeBSD.ORG> + * 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. + * + * 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 <fenv.h> +#include <math.h> +#include <stdint.h> + +/* + * Fused multiply-add: Compute x * y + z with a single rounding error. + * + * A double has more than twice as much precision than a float, so + * direct double-precision arithmetic suffices, except where double + * rounding occurs. + */ +float fmaf(float x, float y, float z) +{ +#pragma STDC FENV_ACCESS ON + double xy, result; + union { + double f; + uint64_t i; + } u; + int e; + + xy = (double)x * y; + result = xy + z; + u.f = result; + e = u.i >> 52 & 0x7ff; + /* Common case: The double precision result is fine. */ + if ((u.i & 0x1fffffff) != 0x10000000 || /* not a halfway case */ + e == 0x7ff || /* NaN */ + (result - xy == z && result - z == xy) || /* exact */ + fegetround() != FE_TONEAREST) /* not round-to-nearest */ + { + /* + underflow may not be raised correctly, example: + fmaf(0x1p-120f, 0x1p-120f, 0x1p-149f) + */ +#if defined(FE_INEXACT) && defined(FE_UNDERFLOW) + if (e < 0x3ff - 126 && e >= 0x3ff - 149 && + fetestexcept(FE_INEXACT)) { + feclearexcept(FE_INEXACT); + /* TODO: gcc and clang bug workaround */ + volatile float vz = z; + result = xy + vz; + if (fetestexcept(FE_INEXACT)) + feraiseexcept(FE_UNDERFLOW); + else + feraiseexcept(FE_INEXACT); + } +#endif + z = result; + return z; + } + + /* + * If result is inexact, and exactly halfway between two float values, + * we need to adjust the low-order bit in the direction of the error. + */ + double err; + int neg = u.i >> 63; + if (neg == (z > xy)) + err = xy - result + z; + else + err = z - result + xy; + if (neg == (err < 0)) + u.i++; + else + u.i--; + z = u.f; + return z; +} diff --git a/lib/libm/fmal.c b/lib/libm/fmal.c new file mode 100644 index 00000000..1eceafd4 --- /dev/null +++ b/lib/libm/fmal.c @@ -0,0 +1,294 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_fmal.c */ +/*- + * Copyright (c) 2005-2011 David Schultz <das@FreeBSD.ORG> + * 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. + * + * 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 "libm.h" +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double fmal(long double x, long double y, long double z) +{ + return fma(x, y, z); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#include <fenv.h> +#if LDBL_MANT_DIG == 64 +#define LASTBIT(u) (u.i.m & 1) +#define SPLIT (0x1p32L + 1) +#elif LDBL_MANT_DIG == 113 +#define LASTBIT(u) (u.i.lo & 1) +#define SPLIT (0x1p57L + 1) +#endif + +/* + * A struct dd represents a floating-point number with twice the precision + * of a long double. We maintain the invariant that "hi" stores the high-order + * bits of the result. + */ +struct dd { + long double hi; + long double lo; +}; + +/* + * Compute a+b exactly, returning the exact result in a struct dd. We assume + * that both a and b are finite, but make no assumptions about their relative + * magnitudes. + */ +static inline struct dd dd_add(long double a, long double b) +{ + struct dd ret; + long double s; + + ret.hi = a + b; + s = ret.hi - a; + ret.lo = (a - (ret.hi - s)) + (b - s); + return (ret); +} + +/* + * Compute a+b, with a small tweak: The least significant bit of the + * result is adjusted into a sticky bit summarizing all the bits that + * were lost to rounding. This adjustment negates the effects of double + * rounding when the result is added to another number with a higher + * exponent. For an explanation of round and sticky bits, see any reference + * on FPU design, e.g., + * + * J. Coonen. An Implementation Guide to a Proposed Standard for + * Floating-Point Arithmetic. Computer, vol. 13, no. 1, Jan 1980. + */ +static inline long double add_adjusted(long double a, long double b) +{ + struct dd sum; + union ldshape u; + + sum = dd_add(a, b); + if (sum.lo != 0) { + u.f = sum.hi; + if (!LASTBIT(u)) + sum.hi = nextafterl(sum.hi, INFINITY * sum.lo); + } + return (sum.hi); +} + +/* + * Compute ldexp(a+b, scale) with a single rounding error. It is assumed + * that the result will be subnormal, and care is taken to ensure that + * double rounding does not occur. + */ +static inline long double add_and_denormalize(long double a, long double b, + int scale) +{ + struct dd sum; + int bits_lost; + union ldshape u; + + sum = dd_add(a, b); + + /* + * If we are losing at least two bits of accuracy to denormalization, + * then the first lost bit becomes a round bit, and we adjust the + * lowest bit of sum.hi to make it a sticky bit summarizing all the + * bits in sum.lo. With the sticky bit adjusted, the hardware will + * break any ties in the correct direction. + * + * If we are losing only one bit to denormalization, however, we must + * break the ties manually. + */ + if (sum.lo != 0) { + u.f = sum.hi; + bits_lost = -u.i.se - scale + 1; + if ((bits_lost != 1) ^ LASTBIT(u)) + sum.hi = nextafterl(sum.hi, INFINITY * sum.lo); + } + return scalbnl(sum.hi, scale); +} + +/* + * Compute a*b exactly, returning the exact result in a struct dd. We assume + * that both a and b are normalized, so no underflow or overflow will occur. + * The current rounding mode must be round-to-nearest. + */ +static inline struct dd dd_mul(long double a, long double b) +{ + struct dd ret; + long double ha, hb, la, lb, p, q; + + p = a * SPLIT; + ha = a - p; + ha += p; + la = a - ha; + + p = b * SPLIT; + hb = b - p; + hb += p; + lb = b - hb; + + p = ha * hb; + q = ha * lb + la * hb; + + ret.hi = p + q; + ret.lo = p - ret.hi + q + la * lb; + return (ret); +} + +/* + * Fused multiply-add: Compute x * y + z with a single rounding error. + * + * We use scaling to avoid overflow/underflow, along with the + * canonical precision-doubling technique adapted from: + * + * Dekker, T. A Floating-Point Technique for Extending the + * Available Precision. Numer. Math. 18, 224-242 (1971). + */ +long double fmal(long double x, long double y, long double z) +{ +#pragma STDC FENV_ACCESS ON + long double xs, ys, zs, adj; + struct dd xy, r; + int oround; + int ex, ey, ez; + int spread; + + /* + * Handle special cases. The order of operations and the particular + * return values here are crucial in handling special cases involving + * infinities, NaNs, overflows, and signed zeroes correctly. + */ + if (!isfinite(x) || !isfinite(y)) + return (x * y + z); + if (!isfinite(z)) + return (z); + if (x == 0.0 || y == 0.0) + return (x * y + z); + if (z == 0.0) + return (x * y); + + xs = frexpl(x, &ex); + ys = frexpl(y, &ey); + zs = frexpl(z, &ez); + oround = fegetround(); + spread = ex + ey - ez; + + /* + * If x * y and z are many orders of magnitude apart, the scaling + * will overflow, so we handle these cases specially. Rounding + * modes other than FE_TONEAREST are painful. + */ + if (spread < -LDBL_MANT_DIG) { +#ifdef FE_INEXACT + feraiseexcept(FE_INEXACT); +#endif +#ifdef FE_UNDERFLOW + if (!isnormal(z)) + feraiseexcept(FE_UNDERFLOW); +#endif + switch (oround) { + default: /* FE_TONEAREST */ + return (z); +#ifdef FE_TOWARDZERO + case FE_TOWARDZERO: + if (x > 0.0 ^ y < 0.0 ^ z < 0.0) + return (z); + else + return (nextafterl(z, 0)); +#endif +#ifdef FE_DOWNWARD + case FE_DOWNWARD: + if (x > 0.0 ^ y < 0.0) + return (z); + else + return (nextafterl(z, -INFINITY)); +#endif +#ifdef FE_UPWARD + case FE_UPWARD: + if (x > 0.0 ^ y < 0.0) + return (nextafterl(z, INFINITY)); + else + return (z); +#endif + } + } + if (spread <= LDBL_MANT_DIG * 2) + zs = scalbnl(zs, -spread); + else + zs = copysignl(LDBL_MIN, zs); + + fesetround(FE_TONEAREST); + + /* + * Basic approach for round-to-nearest: + * + * (xy.hi, xy.lo) = x * y (exact) + * (r.hi, r.lo) = xy.hi + z (exact) + * adj = xy.lo + r.lo (inexact; low bit is sticky) + * result = r.hi + adj (correctly rounded) + */ + xy = dd_mul(xs, ys); + r = dd_add(xy.hi, zs); + + spread = ex + ey; + + if (r.hi == 0.0) { + /* + * When the addends cancel to 0, ensure that the result has + * the correct sign. + */ + fesetround(oround); + volatile long double vzs = zs; /* XXX gcc CSE bug workaround */ + return xy.hi + vzs + scalbnl(xy.lo, spread); + } + + if (oround != FE_TONEAREST) { + /* + * There is no need to worry about double rounding in directed + * rounding modes. + * But underflow may not be raised correctly, example in + * downward rounding: fmal(0x1.0000000001p-16000L, + * 0x1.0000000001p-400L, -0x1p-16440L) + */ + long double ret; +#if defined(FE_INEXACT) && defined(FE_UNDERFLOW) + int e = fetestexcept(FE_INEXACT); + feclearexcept(FE_INEXACT); +#endif + fesetround(oround); + adj = r.lo + xy.lo; + ret = scalbnl(r.hi + adj, spread); +#if defined(FE_INEXACT) && defined(FE_UNDERFLOW) + if (ilogbl(ret) < -16382 && fetestexcept(FE_INEXACT)) + feraiseexcept(FE_UNDERFLOW); + else if (e) + feraiseexcept(FE_INEXACT); +#endif + return ret; + } + + adj = add_adjusted(r.lo, xy.lo); + if (spread + ilogbl(r.hi) > -16383) + return scalbnl(r.hi + adj, spread); + else + return add_and_denormalize(r.hi, adj, spread); +} +#endif diff --git a/lib/libm/fmax.c b/lib/libm/fmax.c new file mode 100644 index 00000000..94f0caa1 --- /dev/null +++ b/lib/libm/fmax.c @@ -0,0 +1,13 @@ +#include <math.h> + +double fmax(double x, double y) +{ + if (isnan(x)) + return y; + if (isnan(y)) + return x; + /* handle signed zeros, see C99 Annex F.9.9.2 */ + if (signbit(x) != signbit(y)) + return signbit(x) ? y : x; + return x < y ? y : x; +} diff --git a/lib/libm/fmaxf.c b/lib/libm/fmaxf.c new file mode 100644 index 00000000..695d8179 --- /dev/null +++ b/lib/libm/fmaxf.c @@ -0,0 +1,13 @@ +#include <math.h> + +float fmaxf(float x, float y) +{ + if (isnan(x)) + return y; + if (isnan(y)) + return x; + /* handle signed zeroes, see C99 Annex F.9.9.2 */ + if (signbit(x) != signbit(y)) + return signbit(x) ? y : x; + return x < y ? y : x; +} diff --git a/lib/libm/fmaxl.c b/lib/libm/fmaxl.c new file mode 100644 index 00000000..4b03158e --- /dev/null +++ b/lib/libm/fmaxl.c @@ -0,0 +1,21 @@ +#include <math.h> +#include <float.h> + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double fmaxl(long double x, long double y) +{ + return fmax(x, y); +} +#else +long double fmaxl(long double x, long double y) +{ + if (isnan(x)) + return y; + if (isnan(y)) + return x; + /* handle signed zeros, see C99 Annex F.9.9.2 */ + if (signbit(x) != signbit(y)) + return signbit(x) ? y : x; + return x < y ? y : x; +} +#endif diff --git a/lib/libm/fmin.c b/lib/libm/fmin.c new file mode 100644 index 00000000..08a8fd17 --- /dev/null +++ b/lib/libm/fmin.c @@ -0,0 +1,13 @@ +#include <math.h> + +double fmin(double x, double y) +{ + if (isnan(x)) + return y; + if (isnan(y)) + return x; + /* handle signed zeros, see C99 Annex F.9.9.2 */ + if (signbit(x) != signbit(y)) + return signbit(x) ? x : y; + return x < y ? x : y; +} diff --git a/lib/libm/fminf.c b/lib/libm/fminf.c new file mode 100644 index 00000000..3573c7de --- /dev/null +++ b/lib/libm/fminf.c @@ -0,0 +1,13 @@ +#include <math.h> + +float fminf(float x, float y) +{ + if (isnan(x)) + return y; + if (isnan(y)) + return x; + /* handle signed zeros, see C99 Annex F.9.9.2 */ + if (signbit(x) != signbit(y)) + return signbit(x) ? x : y; + return x < y ? x : y; +} diff --git a/lib/libm/fminl.c b/lib/libm/fminl.c new file mode 100644 index 00000000..69bc24a7 --- /dev/null +++ b/lib/libm/fminl.c @@ -0,0 +1,21 @@ +#include <math.h> +#include <float.h> + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double fminl(long double x, long double y) +{ + return fmin(x, y); +} +#else +long double fminl(long double x, long double y) +{ + if (isnan(x)) + return y; + if (isnan(y)) + return x; + /* handle signed zeros, see C99 Annex F.9.9.2 */ + if (signbit(x) != signbit(y)) + return signbit(x) ? x : y; + return x < y ? x : y; +} +#endif diff --git a/lib/libm/fmod.c b/lib/libm/fmod.c new file mode 100644 index 00000000..21607a63 --- /dev/null +++ b/lib/libm/fmod.c @@ -0,0 +1,74 @@ +#include <math.h> +#include <stdint.h> + +double fmod(double x, double y) +{ + union { + double f; + uint64_t i; + } ux = { x }, uy = { y }; + int ex = ux.i >> 52 & 0x7ff; + int ey = uy.i >> 52 & 0x7ff; + int sx = ux.i >> 63; + uint64_t i; + + /* in the followings uxi should be ux.i, but then gcc wrongly adds */ + /* float load/store to inner loops ruining performance and code size */ + uint64_t uxi = ux.i; + + if (uy.i << 1 == 0 || isnan(y) || ex == 0x7ff) + return (x * y) / (x * y); + if (uxi << 1 <= uy.i << 1) { + if (uxi << 1 == uy.i << 1) + return 0 * x; + return x; + } + + /* normalize x and y */ + if (!ex) { + for (i = uxi << 12; i >> 63 == 0; ex--, i <<= 1) + ; + uxi <<= -ex + 1; + } else { + uxi &= -1ULL >> 12; + uxi |= 1ULL << 52; + } + if (!ey) { + for (i = uy.i << 12; i >> 63 == 0; ey--, i <<= 1) + ; + uy.i <<= -ey + 1; + } else { + uy.i &= -1ULL >> 12; + uy.i |= 1ULL << 52; + } + + /* x mod y */ + for (; ex > ey; ex--) { + i = uxi - uy.i; + if (i >> 63 == 0) { + if (i == 0) + return 0 * x; + uxi = i; + } + uxi <<= 1; + } + i = uxi - uy.i; + if (i >> 63 == 0) { + if (i == 0) + return 0 * x; + uxi = i; + } + for (; uxi >> 52 == 0; uxi <<= 1, ex--) + ; + + /* scale result */ + if (ex > 0) { + uxi -= 1ULL << 52; + uxi |= (uint64_t)ex << 52; + } else { + uxi >>= -ex + 1; + } + uxi |= (uint64_t)sx << 63; + ux.i = uxi; + return ux.f; +} diff --git a/lib/libm/fmodf.c b/lib/libm/fmodf.c new file mode 100644 index 00000000..6bcd398c --- /dev/null +++ b/lib/libm/fmodf.c @@ -0,0 +1,71 @@ +#include <math.h> +#include <stdint.h> + +float fmodf(float x, float y) +{ + union { + float f; + uint32_t i; + } ux = { x }, uy = { y }; + int ex = ux.i >> 23 & 0xff; + int ey = uy.i >> 23 & 0xff; + uint32_t sx = ux.i & 0x80000000; + uint32_t i; + uint32_t uxi = ux.i; + + if (uy.i << 1 == 0 || isnan(y) || ex == 0xff) + return (x * y) / (x * y); + if (uxi << 1 <= uy.i << 1) { + if (uxi << 1 == uy.i << 1) + return 0 * x; + return x; + } + + /* normalize x and y */ + if (!ex) { + for (i = uxi << 9; i >> 31 == 0; ex--, i <<= 1) + ; + uxi <<= -ex + 1; + } else { + uxi &= -1U >> 9; + uxi |= 1U << 23; + } + if (!ey) { + for (i = uy.i << 9; i >> 31 == 0; ey--, i <<= 1) + ; + uy.i <<= -ey + 1; + } else { + uy.i &= -1U >> 9; + uy.i |= 1U << 23; + } + + /* x mod y */ + for (; ex > ey; ex--) { + i = uxi - uy.i; + if (i >> 31 == 0) { + if (i == 0) + return 0 * x; + uxi = i; + } + uxi <<= 1; + } + i = uxi - uy.i; + if (i >> 31 == 0) { + if (i == 0) + return 0 * x; + uxi = i; + } + for (; uxi >> 23 == 0; uxi <<= 1, ex--) + ; + + /* scale result up */ + if (ex > 0) { + uxi -= 1U << 23; + uxi |= (uint32_t)ex << 23; + } else { + uxi >>= -ex + 1; + } + uxi |= sx; + ux.i = uxi; + return ux.f; +} diff --git a/lib/libm/fmodl.c b/lib/libm/fmodl.c new file mode 100644 index 00000000..72111dc1 --- /dev/null +++ b/lib/libm/fmodl.c @@ -0,0 +1,107 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double fmodl(long double x, long double y) +{ + return fmod(x, y); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double fmodl(long double x, long double y) +{ + union ldshape ux = { x }, uy = { y }; + int ex = ux.i.se & 0x7fff; + int ey = uy.i.se & 0x7fff; + int sx = ux.i.se & 0x8000; + + if (y == 0 || isnan(y) || ex == 0x7fff) + return (x * y) / (x * y); + ux.i.se = ex; + uy.i.se = ey; + if (ux.f <= uy.f) { + if (ux.f == uy.f) + return 0 * x; + return x; + } + + /* normalize x and y */ + if (!ex) { + ux.f *= 0x1p120f; + ex = ux.i.se - 120; + } + if (!ey) { + uy.f *= 0x1p120f; + ey = uy.i.se - 120; + } + + /* x mod y */ +#if LDBL_MANT_DIG == 64 + uint64_t i, mx, my; + mx = ux.i.m; + my = uy.i.m; + for (; ex > ey; ex--) { + i = mx - my; + if (mx >= my) { + if (i == 0) + return 0 * x; + mx = 2 * i; + } else if (2 * mx < mx) { + mx = 2 * mx - my; + } else { + mx = 2 * mx; + } + } + i = mx - my; + if (mx >= my) { + if (i == 0) + return 0 * x; + mx = i; + } + for (; mx >> 63 == 0; mx *= 2, ex--) + ; + ux.i.m = mx; +#elif LDBL_MANT_DIG == 113 + uint64_t hi, lo, xhi, xlo, yhi, ylo; + xhi = (ux.i2.hi & -1ULL >> 16) | 1ULL << 48; + yhi = (uy.i2.hi & -1ULL >> 16) | 1ULL << 48; + xlo = ux.i2.lo; + ylo = uy.i2.lo; + for (; ex > ey; ex--) { + hi = xhi - yhi; + lo = xlo - ylo; + if (xlo < ylo) + hi -= 1; + if (hi >> 63 == 0) { + if ((hi | lo) == 0) + return 0 * x; + xhi = 2 * hi + (lo >> 63); + xlo = 2 * lo; + } else { + xhi = 2 * xhi + (xlo >> 63); + xlo = 2 * xlo; + } + } + hi = xhi - yhi; + lo = xlo - ylo; + if (xlo < ylo) + hi -= 1; + if (hi >> 63 == 0) { + if ((hi | lo) == 0) + return 0 * x; + xhi = hi; + xlo = lo; + } + for (; xhi >> 48 == 0; xhi = 2 * xhi + (xlo >> 63), xlo = 2 * xlo, ex--) + ; + ux.i2.hi = xhi; + ux.i2.lo = xlo; +#endif + + /* scale result */ + if (ex <= 0) { + ux.i.se = (ex + 120) | sx; + ux.f *= 0x1p-120f; + } else + ux.i.se = ex | sx; + return ux.f; +} +#endif diff --git a/lib/libm/fpclassifyf.c b/lib/libm/fpclassifyf.c new file mode 100644 index 00000000..943f6963 --- /dev/null +++ b/lib/libm/fpclassifyf.c @@ -0,0 +1,3 @@ +// TODO +// __fpclassifyf +// __fpclassifyd __fpclassifyl diff --git a/lib/libm/frexp.c b/lib/libm/frexp.c new file mode 100644 index 00000000..1148c7e9 --- /dev/null +++ b/lib/libm/frexp.c @@ -0,0 +1,27 @@ +#include <math.h> +#include <stdint.h> + +double frexp(double x, int *e) +{ + union { + double d; + uint64_t i; + } y = { x }; + int ee = y.i >> 52 & 0x7ff; + + if (!ee) { + if (x) { + x = frexp(x * 0x1p64, e); + *e -= 64; + } else + *e = 0; + return x; + } else if (ee == 0x7ff) { + return x; + } + + *e = ee - 0x3fe; + y.i &= 0x800fffffffffffffull; + y.i |= 0x3fe0000000000000ull; + return y.d; +} diff --git a/lib/libm/frexpf.c b/lib/libm/frexpf.c new file mode 100644 index 00000000..711129fb --- /dev/null +++ b/lib/libm/frexpf.c @@ -0,0 +1,27 @@ +#include <math.h> +#include <stdint.h> + +float frexpf(float x, int *e) +{ + union { + float f; + uint32_t i; + } y = { x }; + int ee = y.i >> 23 & 0xff; + + if (!ee) { + if (x) { + x = frexpf(x * 0x1p64, e); + *e -= 64; + } else + *e = 0; + return x; + } else if (ee == 0xff) { + return x; + } + + *e = ee - 0x7e; + y.i &= 0x807ffffful; + y.i |= 0x3f000000ul; + return y.f; +} diff --git a/lib/libm/frexpl.c b/lib/libm/frexpl.c new file mode 100644 index 00000000..102ade25 --- /dev/null +++ b/lib/libm/frexpl.c @@ -0,0 +1,30 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double frexpl(long double x, int *e) +{ + return frexp(x, e); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double frexpl(long double x, int *e) +{ + union ldshape u = { x }; + int ee = u.i.se & 0x7fff; + + if (!ee) { + if (x) { + x = frexpl(x * 0x1p120, e); + *e -= 120; + } else + *e = 0; + return x; + } else if (ee == 0x7fff) { + return x; + } + + *e = ee - 0x3ffe; + u.i.se &= 0x8000; + u.i.se |= 0x3ffe; + return u.f; +} +#endif diff --git a/lib/libm/hypot.c b/lib/libm/hypot.c new file mode 100644 index 00000000..5cee8345 --- /dev/null +++ b/lib/libm/hypot.c @@ -0,0 +1,70 @@ +#include <math.h> +#include <stdint.h> +#include <float.h> + +#if FLT_EVAL_METHOD > 1U && LDBL_MANT_DIG == 64 +#define SPLIT (0x1p32 + 1) +#else +#define SPLIT (0x1p27 + 1) +#endif + +static void sq(double_t *hi, double_t *lo, double x) +{ + double_t xh, xl, xc; + + xc = (double_t)x * SPLIT; + xh = x - xc + xc; + xl = x - xh; + *hi = (double_t)x * x; + *lo = xh * xh - *hi + 2 * xh * xl + xl * xl; +} + +double hypot(double x, double y) +{ + union { + double f; + uint64_t i; + } ux = { x }, uy = { y }, ut; + int ex, ey; + double_t hx, lx, hy, ly, z; + + /* arrange |x| >= |y| */ + ux.i &= -1ULL >> 1; + uy.i &= -1ULL >> 1; + if (ux.i < uy.i) { + ut = ux; + ux = uy; + uy = ut; + } + + /* special cases */ + ex = ux.i >> 52; + ey = uy.i >> 52; + x = ux.f; + y = uy.f; + /* note: hypot(inf,nan) == inf */ + if (ey == 0x7ff) + return y; + if (ex == 0x7ff || uy.i == 0) + return x; + /* note: hypot(x,y) ~= x + y*y/x/2 with inexact for small y/x */ + /* 64 difference is enough for ld80 double_t */ + if (ex - ey > 64) + return x + y; + + /* precise sqrt argument in nearest rounding mode without overflow */ + /* xh*xh must not overflow and xl*xl must not underflow in sq */ + z = 1; + if (ex > 0x3ff + 510) { + z = 0x1p700; + x *= 0x1p-700; + y *= 0x1p-700; + } else if (ey < 0x3ff - 450) { + z = 0x1p-700; + x *= 0x1p700; + y *= 0x1p700; + } + sq(&hx, &lx, x); + sq(&hy, &ly, y); + return z * sqrt(ly + lx + hy + hx); +} diff --git a/lib/libm/hypotf.c b/lib/libm/hypotf.c new file mode 100644 index 00000000..60186e9e --- /dev/null +++ b/lib/libm/hypotf.c @@ -0,0 +1,38 @@ +#include <math.h> +#include <stdint.h> + +float hypotf(float x, float y) +{ + union { + float f; + uint32_t i; + } ux = { x }, uy = { y }, ut; + float_t z; + + ux.i &= -1U >> 1; + uy.i &= -1U >> 1; + if (ux.i < uy.i) { + ut = ux; + ux = uy; + uy = ut; + } + + x = ux.f; + y = uy.f; + if (uy.i == 0xff << 23) + return y; + if (ux.i >= 0xff << 23 || uy.i == 0 || ux.i - uy.i >= 25 << 23) + return x + y; + + z = 1; + if (ux.i >= (0x7f + 60) << 23) { + z = 0x1p90f; + x *= 0x1p-90f; + y *= 0x1p-90f; + } else if (uy.i < (0x7f - 60) << 23) { + z = 0x1p-90f; + x *= 0x1p90f; + y *= 0x1p90f; + } + return z * sqrtf((double)x * x + (double)y * y); +} diff --git a/lib/libm/hypotl.c b/lib/libm/hypotl.c new file mode 100644 index 00000000..fb59067c --- /dev/null +++ b/lib/libm/hypotl.c @@ -0,0 +1,66 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double hypotl(long double x, long double y) +{ + return hypot(x, y); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +#if LDBL_MANT_DIG == 64 +#define SPLIT (0x1p32L + 1) +#elif LDBL_MANT_DIG == 113 +#define SPLIT (0x1p57L + 1) +#endif + +static void sq(long double *hi, long double *lo, long double x) +{ + long double xh, xl, xc; + xc = x * SPLIT; + xh = x - xc + xc; + xl = x - xh; + *hi = x * x; + *lo = xh * xh - *hi + 2 * xh * xl + xl * xl; +} + +long double hypotl(long double x, long double y) +{ + union ldshape ux = { x }, uy = { y }; + int ex, ey; + long double hx, lx, hy, ly, z; + + ux.i.se &= 0x7fff; + uy.i.se &= 0x7fff; + if (ux.i.se < uy.i.se) { + ex = uy.i.se; + ey = ux.i.se; + x = uy.f; + y = ux.f; + } else { + ex = ux.i.se; + ey = uy.i.se; + x = ux.f; + y = uy.f; + } + + if (ex == 0x7fff && isinf(y)) + return y; + if (ex == 0x7fff || y == 0) + return x; + if (ex - ey > LDBL_MANT_DIG) + return x + y; + + z = 1; + if (ex > 0x3fff + 8000) { + z = 0x1p10000L; + x *= 0x1p-10000L; + y *= 0x1p-10000L; + } else if (ey < 0x3fff - 8000) { + z = 0x1p-10000L; + x *= 0x1p10000L; + y *= 0x1p10000L; + } + sq(&hx, &lx, x); + sq(&hy, &ly, y); + return z * sqrtl(ly + lx + hy + hx); +} +#endif diff --git a/lib/libm/ilogb.c b/lib/libm/ilogb.c new file mode 100644 index 00000000..3487d460 --- /dev/null +++ b/lib/libm/ilogb.c @@ -0,0 +1,30 @@ +#include <limits.h> +#include "libm.h" + +int ilogb(double x) +{ +#pragma STDC FENV_ACCESS ON + union { + double f; + uint64_t i; + } u = { x }; + uint64_t i = u.i; + int e = i >> 52 & 0x7ff; + + if (!e) { + i <<= 12; + if (i == 0) { + FORCE_EVAL(0 / 0.0f); + return FP_ILOGB0; + } + /* subnormal x */ + for (e = -0x3ff; i >> 63 == 0; e--, i <<= 1) + ; + return e; + } + if (e == 0x7ff) { + FORCE_EVAL(0 / 0.0f); + return i << 12 ? FP_ILOGBNAN : INT_MAX; + } + return e - 0x3ff; +} diff --git a/lib/libm/ilogbf.c b/lib/libm/ilogbf.c new file mode 100644 index 00000000..07599896 --- /dev/null +++ b/lib/libm/ilogbf.c @@ -0,0 +1,30 @@ +#include <limits.h> +#include "libm.h" + +int ilogbf(float x) +{ +#pragma STDC FENV_ACCESS ON + union { + float f; + uint32_t i; + } u = { x }; + uint32_t i = u.i; + int e = i >> 23 & 0xff; + + if (!e) { + i <<= 9; + if (i == 0) { + FORCE_EVAL(0 / 0.0f); + return FP_ILOGB0; + } + /* subnormal x */ + for (e = -0x7f; i >> 31 == 0; e--, i <<= 1) + ; + return e; + } + if (e == 0xff) { + FORCE_EVAL(0 / 0.0f); + return i << 9 ? FP_ILOGBNAN : INT_MAX; + } + return e - 0x7f; +} diff --git a/lib/libm/ilogbl.c b/lib/libm/ilogbl.c new file mode 100644 index 00000000..3ddf29ca --- /dev/null +++ b/lib/libm/ilogbl.c @@ -0,0 +1,56 @@ +#include <limits.h> +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +int ilogbl(long double x) +{ + return ilogb(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +int ilogbl(long double x) +{ +#pragma STDC FENV_ACCESS ON + union ldshape u = { x }; + uint64_t m = u.i.m; + int e = u.i.se & 0x7fff; + + if (!e) { + if (m == 0) { + FORCE_EVAL(0 / 0.0f); + return FP_ILOGB0; + } + /* subnormal x */ + for (e = -0x3fff + 1; m >> 63 == 0; e--, m <<= 1) + ; + return e; + } + if (e == 0x7fff) { + FORCE_EVAL(0 / 0.0f); + return m << 1 ? FP_ILOGBNAN : INT_MAX; + } + return e - 0x3fff; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +int ilogbl(long double x) +{ +#pragma STDC FENV_ACCESS ON + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + + if (!e) { + if (x == 0) { + FORCE_EVAL(0 / 0.0f); + return FP_ILOGB0; + } + /* subnormal x */ + x *= 0x1p120; + return ilogbl(x) - 120; + } + if (e == 0x7fff) { + FORCE_EVAL(0 / 0.0f); + u.i.se = 0; + return u.f ? FP_ILOGBNAN : INT_MAX; + } + return e - 0x3fff; +} +#endif diff --git a/lib/libm/isfinitef.c b/lib/libm/isfinitef.c new file mode 100644 index 00000000..d73848be --- /dev/null +++ b/lib/libm/isfinitef.c @@ -0,0 +1,4 @@ +// TODO: +// __isfinitef +// __isfinite +// __isfinitel diff --git a/lib/libm/isinf.c b/lib/libm/isinf.c new file mode 100644 index 00000000..61f2df4d --- /dev/null +++ b/lib/libm/isinf.c @@ -0,0 +1,3 @@ +// __isinff +// isinf +// __isinfl diff --git a/lib/libm/j0.c b/lib/libm/j0.c new file mode 100644 index 00000000..be5df8ce --- /dev/null +++ b/lib/libm/j0.c @@ -0,0 +1,405 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_j0.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* j0(x), y0(x) + * Bessel function of the first and second kinds of order zero. + * Method -- j0(x): + * 1. For tiny x, we use j0(x) = 1 - x^2/4 + x^4/64 - ... + * 2. Reduce x to |x| since j0(x)=j0(-x), and + * for x in (0,2) + * j0(x) = 1-z/4+ z^2*R0/S0, where z = x*x; + * (precision: |j0-1+z/4-z^2R0/S0 |<2**-63.67 ) + * for x in (2,inf) + * j0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x0)-q0(x)*sin(x0)) + * where x0 = x-pi/4. It is better to compute sin(x0),cos(x0) + * as follow: + * cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4) + * = 1/sqrt(2) * (cos(x) + sin(x)) + * sin(x0) = sin(x)cos(pi/4)-cos(x)sin(pi/4) + * = 1/sqrt(2) * (sin(x) - cos(x)) + * (To avoid cancellation, use + * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) + * to compute the worse one.) + * + * 3 Special cases + * j0(nan)= nan + * j0(0) = 1 + * j0(inf) = 0 + * + * Method -- y0(x): + * 1. For x<2. + * Since + * y0(x) = 2/pi*(j0(x)*(ln(x/2)+Euler) + x^2/4 - ...) + * therefore y0(x)-2/pi*j0(x)*ln(x) is an even function. + * We use the following function to approximate y0, + * y0(x) = U(z)/V(z) + (2/pi)*(j0(x)*ln(x)), z= x^2 + * where + * U(z) = u00 + u01*z + ... + u06*z^6 + * V(z) = 1 + v01*z + ... + v04*z^4 + * with absolute approximation error bounded by 2**-72. + * Note: For tiny x, U/V = u0 and j0(x)~1, hence + * y0(tiny) = u0 + (2/pi)*ln(tiny), (choose tiny<2**-27) + * 2. For x>=2. + * y0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x0)+q0(x)*sin(x0)) + * where x0 = x-pi/4. It is better to compute sin(x0),cos(x0) + * by the method mentioned above. + * 3. Special cases: y0(0)=-inf, y0(x<0)=NaN, y0(inf)=0. + */ + +#include "libm.h" + +static double pzero(double), qzero(double); + +static const double invsqrtpi = 5.64189583547756279280e-01, /* 0x3FE20DD7, + 0x50429B6D */ + tpi = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */ + +/* common method when |x|>=2 */ +static double common(uint32_t ix, double x, int y0) +{ + double s, c, ss, cc, z; + + /* + * j0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x-pi/4)-q0(x)*sin(x-pi/4)) + * y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x-pi/4)+q0(x)*cos(x-pi/4)) + * + * sin(x-pi/4) = (sin(x) - cos(x))/sqrt(2) + * cos(x-pi/4) = (sin(x) + cos(x))/sqrt(2) + * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) + */ + s = sin(x); + c = cos(x); + if (y0) + c = -c; + cc = s + c; + /* avoid overflow in 2*x, big ulp error when x>=0x1p1023 */ + if (ix < 0x7fe00000) { + ss = s - c; + z = -cos(2 * x); + if (s * c < 0) + cc = z / ss; + else + ss = z / cc; + if (ix < 0x48000000) { + if (y0) + ss = -ss; + cc = pzero(x) * cc - qzero(x) * ss; + } + } + return invsqrtpi * cc / sqrt(x); +} + +/* R0/S0 on [0, 2.00] */ +static const double R02 = 1.56249999999999947958e-02, /* 0x3F8FFFFF, 0xFFFFFFFD + */ + R03 = -1.89979294238854721751e-04, /* 0xBF28E6A5, 0xB61AC6E9 */ + R04 = 1.82954049532700665670e-06, /* 0x3EBEB1D1, 0x0C503919 */ + R05 = -4.61832688532103189199e-09, /* 0xBE33D5E7, 0x73D63FCE */ + S01 = 1.56191029464890010492e-02, /* 0x3F8FFCE8, 0x82C8C2A4 */ + S02 = 1.16926784663337450260e-04, /* 0x3F1EA6D2, 0xDD57DBF4 */ + S03 = 5.13546550207318111446e-07, /* 0x3EA13B54, 0xCE84D5A9 */ + S04 = 1.16614003333790000205e-09; /* 0x3E1408BC, 0xF4745D8F */ + +double j0(double x) +{ + double z, r, s; + uint32_t ix; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + + /* j0(+-inf)=0, j0(nan)=nan */ + if (ix >= 0x7ff00000) + return 1 / (x * x); + x = fabs(x); + + if (ix >= 0x40000000) { /* |x| >= 2 */ + /* large ulp error near zeros: 2.4, 5.52, 8.6537,.. */ + return common(ix, x, 0); + } + + /* 1 - x*x/4 + x*x*R(x^2)/S(x^2) */ + if (ix >= 0x3f200000) { /* |x| >= 2**-13 */ + /* up to 4ulp error close to 2 */ + z = x * x; + r = z * (R02 + z * (R03 + z * (R04 + z * R05))); + s = 1 + z * (S01 + z * (S02 + z * (S03 + z * S04))); + return (1 + x / 2) * (1 - x / 2) + z * (r / s); + } + + /* 1 - x*x/4 */ + /* prevent underflow */ + /* inexact should be raised when x!=0, this is not done correctly */ + if (ix >= 0x38000000) /* |x| >= 2**-127 */ + x = 0.25 * x * x; + return 1 - x; +} + +static const double u00 = -7.38042951086872317523e-02, /* 0xBFB2E4D6, 0x99CBD01F + */ + u01 = 1.76666452509181115538e-01, /* 0x3FC69D01, 0x9DE9E3FC */ + u02 = -1.38185671945596898896e-02, /* 0xBF8C4CE8, 0xB16CFA97 */ + u03 = 3.47453432093683650238e-04, /* 0x3F36C54D, 0x20B29B6B */ + u04 = -3.81407053724364161125e-06, /* 0xBECFFEA7, 0x73D25CAD */ + u05 = 1.95590137035022920206e-08, /* 0x3E550057, 0x3B4EABD4 */ + u06 = -3.98205194132103398453e-11, /* 0xBDC5E43D, 0x693FB3C8 */ + v01 = 1.27304834834123699328e-02, /* 0x3F8A1270, 0x91C9C71A */ + v02 = 7.60068627350353253702e-05, /* 0x3F13ECBB, 0xF578C6C1 */ + v03 = 2.59150851840457805467e-07, /* 0x3E91642D, 0x7FF202FD */ + v04 = 4.41110311332675467403e-10; /* 0x3DFE5018, 0x3BD6D9EF */ + +double y0(double x) +{ + double z, u, v; + uint32_t ix, lx; + + EXTRACT_WORDS(ix, lx, x); + + /* y0(nan)=nan, y0(<0)=nan, y0(0)=-inf, y0(inf)=0 */ + if ((ix << 1 | lx) == 0) + return -1 / 0.0; + if (ix >> 31) + return 0 / 0.0; + if (ix >= 0x7ff00000) + return 1 / x; + + if (ix >= 0x40000000) { /* x >= 2 */ + /* large ulp errors near zeros: 3.958, 7.086,.. */ + return common(ix, x, 1); + } + + /* U(x^2)/V(x^2) + (2/pi)*j0(x)*log(x) */ + if (ix >= 0x3e400000) { /* x >= 2**-27 */ + /* large ulp error near the first zero, x ~= 0.89 */ + z = x * x; + u = u00 + + z * (u01 + + z * (u02 + + z * (u03 + z * (u04 + z * (u05 + z * u06))))); + v = 1.0 + z * (v01 + z * (v02 + z * (v03 + z * v04))); + return u / v + tpi * (j0(x) * log(x)); + } + return u00 + tpi * log(x); +} + +/* The asymptotic expansions of pzero is + * 1 - 9/128 s^2 + 11025/98304 s^4 - ..., where s = 1/x. + * For x >= 2, We approximate pzero by + * pzero(x) = 1 + (R/S) + * where R = pR0 + pR1*s^2 + pR2*s^4 + ... + pR5*s^10 + * S = 1 + pS0*s^2 + ... + pS4*s^10 + * and + * | pzero(x)-1-R/S | <= 2 ** ( -60.26) + */ +static const double pR8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */ + -7.03124999999900357484e-02, /* 0xBFB1FFFF, 0xFFFFFD32 */ + -8.08167041275349795626e+00, /* 0xC02029D0, 0xB44FA779 */ + -2.57063105679704847262e+02, /* 0xC0701102, 0x7B19E863 */ + -2.48521641009428822144e+03, /* 0xC0A36A6E, 0xCD4DCAFC */ + -5.25304380490729545272e+03, /* 0xC0B4850B, 0x36CC643D */ +}; +static const double pS8[5] = { + 1.16534364619668181717e+02, /* 0x405D2233, 0x07A96751 */ + 3.83374475364121826715e+03, /* 0x40ADF37D, 0x50596938 */ + 4.05978572648472545552e+04, /* 0x40E3D2BB, 0x6EB6B05F */ + 1.16752972564375915681e+05, /* 0x40FC810F, 0x8F9FA9BD */ + 4.76277284146730962675e+04, /* 0x40E74177, 0x4F2C49DC */ +}; + +static const double pR5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + -1.14125464691894502584e-11, /* 0xBDA918B1, 0x47E495CC */ + -7.03124940873599280078e-02, /* 0xBFB1FFFF, 0xE69AFBC6 */ + -4.15961064470587782438e+00, /* 0xC010A370, 0xF90C6BBF */ + -6.76747652265167261021e+01, /* 0xC050EB2F, 0x5A7D1783 */ + -3.31231299649172967747e+02, /* 0xC074B3B3, 0x6742CC63 */ + -3.46433388365604912451e+02, /* 0xC075A6EF, 0x28A38BD7 */ +}; +static const double pS5[5] = { + 6.07539382692300335975e+01, /* 0x404E6081, 0x0C98C5DE */ + 1.05125230595704579173e+03, /* 0x40906D02, 0x5C7E2864 */ + 5.97897094333855784498e+03, /* 0x40B75AF8, 0x8FBE1D60 */ + 9.62544514357774460223e+03, /* 0x40C2CCB8, 0xFA76FA38 */ + 2.40605815922939109441e+03, /* 0x40A2CC1D, 0xC70BE864 */ +}; + +static const double pR3[6] = { + /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */ + -2.54704601771951915620e-09, /* 0xBE25E103, 0x6FE1AA86 */ + -7.03119616381481654654e-02, /* 0xBFB1FFF6, 0xF7C0E24B */ + -2.40903221549529611423e+00, /* 0xC00345B2, 0xAEA48074 */ + -2.19659774734883086467e+01, /* 0xC035F74A, 0x4CB94E14 */ + -5.80791704701737572236e+01, /* 0xC04D0A22, 0x420A1A45 */ + -3.14479470594888503854e+01, /* 0xC03F72AC, 0xA892D80F */ +}; +static const double pS3[5] = { + 3.58560338055209726349e+01, /* 0x4041ED92, 0x84077DD3 */ + 3.61513983050303863820e+02, /* 0x40769839, 0x464A7C0E */ + 1.19360783792111533330e+03, /* 0x4092A66E, 0x6D1061D6 */ + 1.12799679856907414432e+03, /* 0x40919FFC, 0xB8C39B7E */ + 1.73580930813335754692e+02, /* 0x4065B296, 0xFC379081 */ +}; + +static const double pR2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + -8.87534333032526411254e-08, /* 0xBE77D316, 0xE927026D */ + -7.03030995483624743247e-02, /* 0xBFB1FF62, 0x495E1E42 */ + -1.45073846780952986357e+00, /* 0xBFF73639, 0x8A24A843 */ + -7.63569613823527770791e+00, /* 0xC01E8AF3, 0xEDAFA7F3 */ + -1.11931668860356747786e+01, /* 0xC02662E6, 0xC5246303 */ + -3.23364579351335335033e+00, /* 0xC009DE81, 0xAF8FE70F */ +}; +static const double pS2[5] = { + 2.22202997532088808441e+01, /* 0x40363865, 0x908B5959 */ + 1.36206794218215208048e+02, /* 0x4061069E, 0x0EE8878F */ + 2.70470278658083486789e+02, /* 0x4070E786, 0x42EA079B */ + 1.53875394208320329881e+02, /* 0x40633C03, 0x3AB6FAFF */ + 1.46576176948256193810e+01, /* 0x402D50B3, 0x44391809 */ +}; + +static double pzero(double x) +{ + const double *p, *q; + double_t z, r, s; + uint32_t ix; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x40200000) { + p = pR8; + q = pS8; + } else if (ix >= 0x40122E8B) { + p = pR5; + q = pS5; + } else if (ix >= 0x4006DB6D) { + p = pR3; + q = pS3; + } else /*ix >= 0x40000000*/ { + p = pR2; + q = pS2; + } + z = 1.0 / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0 + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4])))); + return 1.0 + r / s; +} + +/* For x >= 8, the asymptotic expansions of qzero is + * -1/8 s + 75/1024 s^3 - ..., where s = 1/x. + * We approximate pzero by + * qzero(x) = s*(-1.25 + (R/S)) + * where R = qR0 + qR1*s^2 + qR2*s^4 + ... + qR5*s^10 + * S = 1 + qS0*s^2 + ... + qS5*s^12 + * and + * | qzero(x)/s +1.25-R/S | <= 2 ** ( -61.22) + */ +static const double qR8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */ + 7.32421874999935051953e-02, /* 0x3FB2BFFF, 0xFFFFFE2C */ + 1.17682064682252693899e+01, /* 0x40278952, 0x5BB334D6 */ + 5.57673380256401856059e+02, /* 0x40816D63, 0x15301825 */ + 8.85919720756468632317e+03, /* 0x40C14D99, 0x3E18F46D */ + 3.70146267776887834771e+04, /* 0x40E212D4, 0x0E901566 */ +}; +static const double qS8[6] = { + 1.63776026895689824414e+02, /* 0x406478D5, 0x365B39BC */ + 8.09834494656449805916e+03, /* 0x40BFA258, 0x4E6B0563 */ + 1.42538291419120476348e+05, /* 0x41016652, 0x54D38C3F */ + 8.03309257119514397345e+05, /* 0x412883DA, 0x83A52B43 */ + 8.40501579819060512818e+05, /* 0x4129A66B, 0x28DE0B3D */ + -3.43899293537866615225e+05, /* 0xC114FD6D, 0x2C9530C5 */ +}; + +static const double qR5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + 1.84085963594515531381e-11, /* 0x3DB43D8F, 0x29CC8CD9 */ + 7.32421766612684765896e-02, /* 0x3FB2BFFF, 0xD172B04C */ + 5.83563508962056953777e+00, /* 0x401757B0, 0xB9953DD3 */ + 1.35111577286449829671e+02, /* 0x4060E392, 0x0A8788E9 */ + 1.02724376596164097464e+03, /* 0x40900CF9, 0x9DC8C481 */ + 1.98997785864605384631e+03, /* 0x409F17E9, 0x53C6E3A6 */ +}; +static const double qS5[6] = { + 8.27766102236537761883e+01, /* 0x4054B1B3, 0xFB5E1543 */ + 2.07781416421392987104e+03, /* 0x40A03BA0, 0xDA21C0CE */ + 1.88472887785718085070e+04, /* 0x40D267D2, 0x7B591E6D */ + 5.67511122894947329769e+04, /* 0x40EBB5E3, 0x97E02372 */ + 3.59767538425114471465e+04, /* 0x40E19118, 0x1F7A54A0 */ + -5.35434275601944773371e+03, /* 0xC0B4EA57, 0xBEDBC609 */ +}; + +static const double qR3[6] = { + /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */ + 4.37741014089738620906e-09, /* 0x3E32CD03, 0x6ADECB82 */ + 7.32411180042911447163e-02, /* 0x3FB2BFEE, 0x0E8D0842 */ + 3.34423137516170720929e+00, /* 0x400AC0FC, 0x61149CF5 */ + 4.26218440745412650017e+01, /* 0x40454F98, 0x962DAEDD */ + 1.70808091340565596283e+02, /* 0x406559DB, 0xE25EFD1F */ + 1.66733948696651168575e+02, /* 0x4064D77C, 0x81FA21E0 */ +}; +static const double qS3[6] = { + 4.87588729724587182091e+01, /* 0x40486122, 0xBFE343A6 */ + 7.09689221056606015736e+02, /* 0x40862D83, 0x86544EB3 */ + 3.70414822620111362994e+03, /* 0x40ACF04B, 0xE44DFC63 */ + 6.46042516752568917582e+03, /* 0x40B93C6C, 0xD7C76A28 */ + 2.51633368920368957333e+03, /* 0x40A3A8AA, 0xD94FB1C0 */ + -1.49247451836156386662e+02, /* 0xC062A7EB, 0x201CF40F */ +}; + +static const double qR2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + 1.50444444886983272379e-07, /* 0x3E84313B, 0x54F76BDB */ + 7.32234265963079278272e-02, /* 0x3FB2BEC5, 0x3E883E34 */ + 1.99819174093815998816e+00, /* 0x3FFFF897, 0xE727779C */ + 1.44956029347885735348e+01, /* 0x402CFDBF, 0xAAF96FE5 */ + 3.16662317504781540833e+01, /* 0x403FAA8E, 0x29FBDC4A */ + 1.62527075710929267416e+01, /* 0x403040B1, 0x71814BB4 */ +}; +static const double qS2[6] = { + 3.03655848355219184498e+01, /* 0x403E5D96, 0xF7C07AED */ + 2.69348118608049844624e+02, /* 0x4070D591, 0xE4D14B40 */ + 8.44783757595320139444e+02, /* 0x408A6645, 0x22B3BF22 */ + 8.82935845112488550512e+02, /* 0x408B977C, 0x9C5CC214 */ + 2.12666388511798828631e+02, /* 0x406A9553, 0x0E001365 */ + -5.31095493882666946917e+00, /* 0xC0153E6A, 0xF8B32931 */ +}; + +static double qzero(double x) +{ + const double *p, *q; + double_t s, r, z; + uint32_t ix; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x40200000) { + p = qR8; + q = qS8; + } else if (ix >= 0x40122E8B) { + p = qR5; + q = qS5; + } else if (ix >= 0x4006DB6D) { + p = qR3; + q = qS3; + } else /*ix >= 0x40000000*/ { + p = qR2; + q = qS2; + } + z = 1.0 / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0 + + z * (q[0] + + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5]))))); + return (-.125 + r / s) / x; +} diff --git a/lib/libm/j0f.c b/lib/libm/j0f.c new file mode 100644 index 00000000..5c7ffcbc --- /dev/null +++ b/lib/libm/j0f.c @@ -0,0 +1,341 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_j0f.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#define _GNU_SOURCE +#include "libm.h" + +static float pzerof(float), qzerof(float); + +static const float invsqrtpi = 5.6418961287e-01, /* 0x3f106ebb */ + tpi = 6.3661974669e-01; /* 0x3f22f983 */ + +static float common(uint32_t ix, float x, int y0) +{ + float z, s, c, ss, cc; + /* + * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x) + * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x) + */ + s = sinf(x); + c = cosf(x); + if (y0) + c = -c; + cc = s + c; + if (ix < 0x7f000000) { + ss = s - c; + z = -cosf(2 * x); + if (s * c < 0) + cc = z / ss; + else + ss = z / cc; + if (ix < 0x58800000) { + if (y0) + ss = -ss; + cc = pzerof(x) * cc - qzerof(x) * ss; + } + } + return invsqrtpi * cc / sqrtf(x); +} + +/* R0/S0 on [0, 2.00] */ +static const float R02 = 1.5625000000e-02, /* 0x3c800000 */ + R03 = -1.8997929874e-04, /* 0xb947352e */ + R04 = 1.8295404516e-06, /* 0x35f58e88 */ + R05 = -4.6183270541e-09, /* 0xb19eaf3c */ + S01 = 1.5619102865e-02, /* 0x3c7fe744 */ + S02 = 1.1692678527e-04, /* 0x38f53697 */ + S03 = 5.1354652442e-07, /* 0x3509daa6 */ + S04 = 1.1661400734e-09; /* 0x30a045e8 */ + +float j0f(float x) +{ + float z, r, s; + uint32_t ix; + + GET_FLOAT_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x7f800000) + return 1 / (x * x); + x = fabsf(x); + + if (ix >= 0x40000000) { /* |x| >= 2 */ + /* large ulp error near zeros */ + return common(ix, x, 0); + } + if (ix >= 0x3a000000) { /* |x| >= 2**-11 */ + /* up to 4ulp error near 2 */ + z = x * x; + r = z * (R02 + z * (R03 + z * (R04 + z * R05))); + s = 1 + z * (S01 + z * (S02 + z * (S03 + z * S04))); + return (1 + x / 2) * (1 - x / 2) + z * (r / s); + } + if (ix >= 0x21800000) /* |x| >= 2**-60 */ + x = 0.25f * x * x; + return 1 - x; +} + +static const float u00 = -7.3804296553e-02, /* 0xbd9726b5 */ + u01 = 1.7666645348e-01, /* 0x3e34e80d */ + u02 = -1.3818567619e-02, /* 0xbc626746 */ + u03 = 3.4745343146e-04, /* 0x39b62a69 */ + u04 = -3.8140706238e-06, /* 0xb67ff53c */ + u05 = 1.9559013964e-08, /* 0x32a802ba */ + u06 = -3.9820518410e-11, /* 0xae2f21eb */ + v01 = 1.2730483897e-02, /* 0x3c509385 */ + v02 = 7.6006865129e-05, /* 0x389f65e0 */ + v03 = 2.5915085189e-07, /* 0x348b216c */ + v04 = 4.4111031494e-10; /* 0x2ff280c2 */ + +float y0f(float x) +{ + float z, u, v; + uint32_t ix; + + GET_FLOAT_WORD(ix, x); + if ((ix & 0x7fffffff) == 0) + return -1 / 0.0f; + if (ix >> 31) + return 0 / 0.0f; + if (ix >= 0x7f800000) + return 1 / x; + if (ix >= 0x40000000) { /* |x| >= 2.0 */ + /* large ulp error near zeros */ + return common(ix, x, 1); + } + if (ix >= 0x39000000) { /* x >= 2**-13 */ + /* large ulp error at x ~= 0.89 */ + z = x * x; + u = u00 + + z * (u01 + + z * (u02 + + z * (u03 + z * (u04 + z * (u05 + z * u06))))); + v = 1 + z * (v01 + z * (v02 + z * (v03 + z * v04))); + return u / v + tpi * (j0f(x) * logf(x)); + } + return u00 + tpi * logf(x); +} + +/* The asymptotic expansions of pzero is + * 1 - 9/128 s^2 + 11025/98304 s^4 - ..., where s = 1/x. + * For x >= 2, We approximate pzero by + * pzero(x) = 1 + (R/S) + * where R = pR0 + pR1*s^2 + pR2*s^4 + ... + pR5*s^10 + * S = 1 + pS0*s^2 + ... + pS4*s^10 + * and + * | pzero(x)-1-R/S | <= 2 ** ( -60.26) + */ +static const float pR8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.0000000000e+00, /* 0x00000000 */ + -7.0312500000e-02, /* 0xbd900000 */ + -8.0816707611e+00, /* 0xc1014e86 */ + -2.5706311035e+02, /* 0xc3808814 */ + -2.4852163086e+03, /* 0xc51b5376 */ + -5.2530439453e+03, /* 0xc5a4285a */ +}; +static const float pS8[5] = { + 1.1653436279e+02, /* 0x42e91198 */ + 3.8337448730e+03, /* 0x456f9beb */ + 4.0597855469e+04, /* 0x471e95db */ + 1.1675296875e+05, /* 0x47e4087c */ + 4.7627726562e+04, /* 0x473a0bba */ +}; +static const float pR5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + -1.1412546255e-11, /* 0xad48c58a */ + -7.0312492549e-02, /* 0xbd8fffff */ + -4.1596107483e+00, /* 0xc0851b88 */ + -6.7674766541e+01, /* 0xc287597b */ + -3.3123129272e+02, /* 0xc3a59d9b */ + -3.4643338013e+02, /* 0xc3ad3779 */ +}; +static const float pS5[5] = { + 6.0753936768e+01, /* 0x42730408 */ + 1.0512523193e+03, /* 0x44836813 */ + 5.9789707031e+03, /* 0x45bad7c4 */ + 9.6254453125e+03, /* 0x461665c8 */ + 2.4060581055e+03, /* 0x451660ee */ +}; + +static const float pR3[6] = { + /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */ + -2.5470459075e-09, /* 0xb12f081b */ + -7.0311963558e-02, /* 0xbd8fffb8 */ + -2.4090321064e+00, /* 0xc01a2d95 */ + -2.1965976715e+01, /* 0xc1afba52 */ + -5.8079170227e+01, /* 0xc2685112 */ + -3.1447946548e+01, /* 0xc1fb9565 */ +}; +static const float pS3[5] = { + 3.5856033325e+01, /* 0x420f6c94 */ + 3.6151397705e+02, /* 0x43b4c1ca */ + 1.1936077881e+03, /* 0x44953373 */ + 1.1279968262e+03, /* 0x448cffe6 */ + 1.7358093262e+02, /* 0x432d94b8 */ +}; + +static const float pR2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + -8.8753431271e-08, /* 0xb3be98b7 */ + -7.0303097367e-02, /* 0xbd8ffb12 */ + -1.4507384300e+00, /* 0xbfb9b1cc */ + -7.6356959343e+00, /* 0xc0f4579f */ + -1.1193166733e+01, /* 0xc1331736 */ + -3.2336456776e+00, /* 0xc04ef40d */ +}; +static const float pS2[5] = { + 2.2220300674e+01, /* 0x41b1c32d */ + 1.3620678711e+02, /* 0x430834f0 */ + 2.7047027588e+02, /* 0x43873c32 */ + 1.5387539673e+02, /* 0x4319e01a */ + 1.4657617569e+01, /* 0x416a859a */ +}; + +static float pzerof(float x) +{ + const float *p, *q; + float_t z, r, s; + uint32_t ix; + + GET_FLOAT_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x41000000) { + p = pR8; + q = pS8; + } else if (ix >= 0x409173eb) { + p = pR5; + q = pS5; + } else if (ix >= 0x4036d917) { + p = pR3; + q = pS3; + } else /*ix >= 0x40000000*/ { + p = pR2; + q = pS2; + } + z = 1.0f / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0f + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4])))); + return 1.0f + r / s; +} + +/* For x >= 8, the asymptotic expansions of qzero is + * -1/8 s + 75/1024 s^3 - ..., where s = 1/x. + * We approximate pzero by + * qzero(x) = s*(-1.25 + (R/S)) + * where R = qR0 + qR1*s^2 + qR2*s^4 + ... + qR5*s^10 + * S = 1 + qS0*s^2 + ... + qS5*s^12 + * and + * | qzero(x)/s +1.25-R/S | <= 2 ** ( -61.22) + */ +static const float qR8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.0000000000e+00, /* 0x00000000 */ + 7.3242187500e-02, /* 0x3d960000 */ + 1.1768206596e+01, /* 0x413c4a93 */ + 5.5767340088e+02, /* 0x440b6b19 */ + 8.8591972656e+03, /* 0x460a6cca */ + 3.7014625000e+04, /* 0x471096a0 */ +}; +static const float qS8[6] = { + 1.6377603149e+02, /* 0x4323c6aa */ + 8.0983447266e+03, /* 0x45fd12c2 */ + 1.4253829688e+05, /* 0x480b3293 */ + 8.0330925000e+05, /* 0x49441ed4 */ + 8.4050156250e+05, /* 0x494d3359 */ + -3.4389928125e+05, /* 0xc8a7eb69 */ +}; + +static const float qR5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + 1.8408595828e-11, /* 0x2da1ec79 */ + 7.3242180049e-02, /* 0x3d95ffff */ + 5.8356351852e+00, /* 0x40babd86 */ + 1.3511157227e+02, /* 0x43071c90 */ + 1.0272437744e+03, /* 0x448067cd */ + 1.9899779053e+03, /* 0x44f8bf4b */ +}; +static const float qS5[6] = { + 8.2776611328e+01, /* 0x42a58da0 */ + 2.0778142090e+03, /* 0x4501dd07 */ + 1.8847289062e+04, /* 0x46933e94 */ + 5.6751113281e+04, /* 0x475daf1d */ + 3.5976753906e+04, /* 0x470c88c1 */ + -5.3543427734e+03, /* 0xc5a752be */ +}; + +static const float qR3[6] = { + /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */ + 4.3774099900e-09, /* 0x3196681b */ + 7.3241114616e-02, /* 0x3d95ff70 */ + 3.3442313671e+00, /* 0x405607e3 */ + 4.2621845245e+01, /* 0x422a7cc5 */ + 1.7080809021e+02, /* 0x432acedf */ + 1.6673394775e+02, /* 0x4326bbe4 */ +}; +static const float qS3[6] = { + 4.8758872986e+01, /* 0x42430916 */ + 7.0968920898e+02, /* 0x44316c1c */ + 3.7041481934e+03, /* 0x4567825f */ + 6.4604252930e+03, /* 0x45c9e367 */ + 2.5163337402e+03, /* 0x451d4557 */ + -1.4924745178e+02, /* 0xc3153f59 */ +}; + +static const float qR2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + 1.5044444979e-07, /* 0x342189db */ + 7.3223426938e-02, /* 0x3d95f62a */ + 1.9981917143e+00, /* 0x3fffc4bf */ + 1.4495602608e+01, /* 0x4167edfd */ + 3.1666231155e+01, /* 0x41fd5471 */ + 1.6252708435e+01, /* 0x4182058c */ +}; +static const float qS2[6] = { + 3.0365585327e+01, /* 0x41f2ecb8 */ + 2.6934811401e+02, /* 0x4386ac8f */ + 8.4478375244e+02, /* 0x44533229 */ + 8.8293585205e+02, /* 0x445cbbe5 */ + 2.1266638184e+02, /* 0x4354aa98 */ + -5.3109550476e+00, /* 0xc0a9f358 */ +}; + +static float qzerof(float x) +{ + const float *p, *q; + float_t s, r, z; + uint32_t ix; + + GET_FLOAT_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x41000000) { + p = qR8; + q = qS8; + } else if (ix >= 0x409173eb) { + p = qR5; + q = qS5; + } else if (ix >= 0x4036d917) { + p = qR3; + q = qS3; + } else /*ix >= 0x40000000*/ { + p = qR2; + q = qS2; + } + z = 1.0f / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0f + + z * (q[0] + + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5]))))); + return (-.125f + r / s) / x; +} diff --git a/lib/libm/j1.c b/lib/libm/j1.c new file mode 100644 index 00000000..0762e739 --- /dev/null +++ b/lib/libm/j1.c @@ -0,0 +1,389 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_j1.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* j1(x), y1(x) + * Bessel function of the first and second kinds of order zero. + * Method -- j1(x): + * 1. For tiny x, we use j1(x) = x/2 - x^3/16 + x^5/384 - ... + * 2. Reduce x to |x| since j1(x)=-j1(-x), and + * for x in (0,2) + * j1(x) = x/2 + x*z*R0/S0, where z = x*x; + * (precision: |j1/x - 1/2 - R0/S0 |<2**-61.51 ) + * for x in (2,inf) + * j1(x) = sqrt(2/(pi*x))*(p1(x)*cos(x1)-q1(x)*sin(x1)) + * y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x1)+q1(x)*cos(x1)) + * where x1 = x-3*pi/4. It is better to compute sin(x1),cos(x1) + * as follow: + * cos(x1) = cos(x)cos(3pi/4)+sin(x)sin(3pi/4) + * = 1/sqrt(2) * (sin(x) - cos(x)) + * sin(x1) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4) + * = -1/sqrt(2) * (sin(x) + cos(x)) + * (To avoid cancellation, use + * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) + * to compute the worse one.) + * + * 3 Special cases + * j1(nan)= nan + * j1(0) = 0 + * j1(inf) = 0 + * + * Method -- y1(x): + * 1. screen out x<=0 cases: y1(0)=-inf, y1(x<0)=NaN + * 2. For x<2. + * Since + * y1(x) = 2/pi*(j1(x)*(ln(x/2)+Euler)-1/x-x/2+5/64*x^3-...) + * therefore y1(x)-2/pi*j1(x)*ln(x)-1/x is an odd function. + * We use the following function to approximate y1, + * y1(x) = x*U(z)/V(z) + (2/pi)*(j1(x)*ln(x)-1/x), z= x^2 + * where for x in [0,2] (abs err less than 2**-65.89) + * U(z) = U0[0] + U0[1]*z + ... + U0[4]*z^4 + * V(z) = 1 + v0[0]*z + ... + v0[4]*z^5 + * Note: For tiny x, 1/x dominate y1 and hence + * y1(tiny) = -2/pi/tiny, (choose tiny<2**-54) + * 3. For x>=2. + * y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x1)+q1(x)*cos(x1)) + * where x1 = x-3*pi/4. It is better to compute sin(x1),cos(x1) + * by method mentioned above. + */ + +#include "libm.h" + +static double pone(double), qone(double); + +static const double invsqrtpi = 5.64189583547756279280e-01, /* 0x3FE20DD7, + 0x50429B6D */ + tpi = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */ + +static double common(uint32_t ix, double x, int y1, int sign) +{ + double z, s, c, ss, cc; + + /* + * j1(x) = sqrt(2/(pi*x))*(p1(x)*cos(x-3pi/4)-q1(x)*sin(x-3pi/4)) + * y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x-3pi/4)+q1(x)*cos(x-3pi/4)) + * + * sin(x-3pi/4) = -(sin(x) + cos(x))/sqrt(2) + * cos(x-3pi/4) = (sin(x) - cos(x))/sqrt(2) + * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) + */ + s = sin(x); + if (y1) + s = -s; + c = cos(x); + cc = s - c; + if (ix < 0x7fe00000) { + /* avoid overflow in 2*x */ + ss = -s - c; + z = cos(2 * x); + if (s * c > 0) + cc = z / ss; + else + ss = z / cc; + if (ix < 0x48000000) { + if (y1) + ss = -ss; + cc = pone(x) * cc - qone(x) * ss; + } + } + if (sign) + cc = -cc; + return invsqrtpi * cc / sqrt(x); +} + +/* R0/S0 on [0,2] */ +static const double r00 = -6.25000000000000000000e-02, /* 0xBFB00000, 0x00000000 + */ + r01 = 1.40705666955189706048e-03, /* 0x3F570D9F, 0x98472C61 */ + r02 = -1.59955631084035597520e-05, /* 0xBEF0C5C6, 0xBA169668 */ + r03 = 4.96727999609584448412e-08, /* 0x3E6AAAFA, 0x46CA0BD9 */ + s01 = 1.91537599538363460805e-02, /* 0x3F939D0B, 0x12637E53 */ + s02 = 1.85946785588630915560e-04, /* 0x3F285F56, 0xB9CDF664 */ + s03 = 1.17718464042623683263e-06, /* 0x3EB3BFF8, 0x333F8498 */ + s04 = 5.04636257076217042715e-09, /* 0x3E35AC88, 0xC97DFF2C */ + s05 = 1.23542274426137913908e-11; /* 0x3DAB2ACF, 0xCFB97ED8 */ + +double j1(double x) +{ + double z, r, s; + uint32_t ix; + int sign; + + GET_HIGH_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x7ff00000) + return 1 / (x * x); + if (ix >= 0x40000000) /* |x| >= 2 */ + return common(ix, fabs(x), 0, sign); + if (ix >= 0x38000000) { /* |x| >= 2**-127 */ + z = x * x; + r = z * (r00 + z * (r01 + z * (r02 + z * r03))); + s = 1 + z * (s01 + z * (s02 + z * (s03 + z * (s04 + z * s05)))); + z = r / s; + } else + /* avoid underflow, raise inexact if x!=0 */ + z = x; + return (0.5 + z) * x; +} + +static const double U0[5] = { + -1.96057090646238940668e-01, /* 0xBFC91866, 0x143CBC8A */ + 5.04438716639811282616e-02, /* 0x3FA9D3C7, 0x76292CD1 */ + -1.91256895875763547298e-03, /* 0xBF5F55E5, 0x4844F50F */ + 2.35252600561610495928e-05, /* 0x3EF8AB03, 0x8FA6B88E */ + -9.19099158039878874504e-08, /* 0xBE78AC00, 0x569105B8 */ +}; +static const double V0[5] = { + 1.99167318236649903973e-02, /* 0x3F94650D, 0x3F4DA9F0 */ + 2.02552581025135171496e-04, /* 0x3F2A8C89, 0x6C257764 */ + 1.35608801097516229404e-06, /* 0x3EB6C05A, 0x894E8CA6 */ + 6.22741452364621501295e-09, /* 0x3E3ABF1D, 0x5BA69A86 */ + 1.66559246207992079114e-11, /* 0x3DB25039, 0xDACA772A */ +}; + +double y1(double x) +{ + double z, u, v; + uint32_t ix, lx; + + EXTRACT_WORDS(ix, lx, x); + /* y1(nan)=nan, y1(<0)=nan, y1(0)=-inf, y1(inf)=0 */ + if ((ix << 1 | lx) == 0) + return -1 / 0.0; + if (ix >> 31) + return 0 / 0.0; + if (ix >= 0x7ff00000) + return 1 / x; + + if (ix >= 0x40000000) /* x >= 2 */ + return common(ix, x, 1, 0); + if (ix < 0x3c900000) /* x < 2**-54 */ + return -tpi / x; + z = x * x; + u = U0[0] + z * (U0[1] + z * (U0[2] + z * (U0[3] + z * U0[4]))); + v = 1 + + z * (V0[0] + z * (V0[1] + z * (V0[2] + z * (V0[3] + z * V0[4])))); + return x * (u / v) + tpi * (j1(x) * log(x) - 1 / x); +} + +/* For x >= 8, the asymptotic expansions of pone is + * 1 + 15/128 s^2 - 4725/2^15 s^4 - ..., where s = 1/x. + * We approximate pone by + * pone(x) = 1 + (R/S) + * where R = pr0 + pr1*s^2 + pr2*s^4 + ... + pr5*s^10 + * S = 1 + ps0*s^2 + ... + ps4*s^10 + * and + * | pone(x)-1-R/S | <= 2 ** ( -60.06) + */ + +static const double pr8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */ + 1.17187499999988647970e-01, /* 0x3FBDFFFF, 0xFFFFFCCE */ + 1.32394806593073575129e+01, /* 0x402A7A9D, 0x357F7FCE */ + 4.12051854307378562225e+02, /* 0x4079C0D4, 0x652EA590 */ + 3.87474538913960532227e+03, /* 0x40AE457D, 0xA3A532CC */ + 7.91447954031891731574e+03, /* 0x40BEEA7A, 0xC32782DD */ +}; +static const double ps8[5] = { + 1.14207370375678408436e+02, /* 0x405C8D45, 0x8E656CAC */ + 3.65093083420853463394e+03, /* 0x40AC85DC, 0x964D274F */ + 3.69562060269033463555e+04, /* 0x40E20B86, 0x97C5BB7F */ + 9.76027935934950801311e+04, /* 0x40F7D42C, 0xB28F17BB */ + 3.08042720627888811578e+04, /* 0x40DE1511, 0x697A0B2D */ +}; + +static const double pr5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + 1.31990519556243522749e-11, /* 0x3DAD0667, 0xDAE1CA7D */ + 1.17187493190614097638e-01, /* 0x3FBDFFFF, 0xE2C10043 */ + 6.80275127868432871736e+00, /* 0x401B3604, 0x6E6315E3 */ + 1.08308182990189109773e+02, /* 0x405B13B9, 0x452602ED */ + 5.17636139533199752805e+02, /* 0x40802D16, 0xD052D649 */ + 5.28715201363337541807e+02, /* 0x408085B8, 0xBB7E0CB7 */ +}; +static const double ps5[5] = { + 5.92805987221131331921e+01, /* 0x404DA3EA, 0xA8AF633D */ + 9.91401418733614377743e+02, /* 0x408EFB36, 0x1B066701 */ + 5.35326695291487976647e+03, /* 0x40B4E944, 0x5706B6FB */ + 7.84469031749551231769e+03, /* 0x40BEA4B0, 0xB8A5BB15 */ + 1.50404688810361062679e+03, /* 0x40978030, 0x036F5E51 */ +}; + +static const double pr3[6] = { + 3.02503916137373618024e-09, /* 0x3E29FC21, 0xA7AD9EDD */ + 1.17186865567253592491e-01, /* 0x3FBDFFF5, 0x5B21D17B */ + 3.93297750033315640650e+00, /* 0x400F76BC, 0xE85EAD8A */ + 3.51194035591636932736e+01, /* 0x40418F48, 0x9DA6D129 */ + 9.10550110750781271918e+01, /* 0x4056C385, 0x4D2C1837 */ + 4.85590685197364919645e+01, /* 0x4048478F, 0x8EA83EE5 */ +}; +static const double ps3[5] = { + 3.47913095001251519989e+01, /* 0x40416549, 0xA134069C */ + 3.36762458747825746741e+02, /* 0x40750C33, 0x07F1A75F */ + 1.04687139975775130551e+03, /* 0x40905B7C, 0x5037D523 */ + 8.90811346398256432622e+02, /* 0x408BD67D, 0xA32E31E9 */ + 1.03787932439639277504e+02, /* 0x4059F26D, 0x7C2EED53 */ +}; + +static const double pr2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + 1.07710830106873743082e-07, /* 0x3E7CE9D4, 0xF65544F4 */ + 1.17176219462683348094e-01, /* 0x3FBDFF42, 0xBE760D83 */ + 2.36851496667608785174e+00, /* 0x4002F2B7, 0xF98FAEC0 */ + 1.22426109148261232917e+01, /* 0x40287C37, 0x7F71A964 */ + 1.76939711271687727390e+01, /* 0x4031B1A8, 0x177F8EE2 */ + 5.07352312588818499250e+00, /* 0x40144B49, 0xA574C1FE */ +}; +static const double ps2[5] = { + 2.14364859363821409488e+01, /* 0x40356FBD, 0x8AD5ECDC */ + 1.25290227168402751090e+02, /* 0x405F5293, 0x14F92CD5 */ + 2.32276469057162813669e+02, /* 0x406D08D8, 0xD5A2DBD9 */ + 1.17679373287147100768e+02, /* 0x405D6B7A, 0xDA1884A9 */ + 8.36463893371618283368e+00, /* 0x4020BAB1, 0xF44E5192 */ +}; + +static double pone(double x) +{ + const double *p, *q; + double_t z, r, s; + uint32_t ix; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x40200000) { + p = pr8; + q = ps8; + } else if (ix >= 0x40122E8B) { + p = pr5; + q = ps5; + } else if (ix >= 0x4006DB6D) { + p = pr3; + q = ps3; + } else /*ix >= 0x40000000*/ { + p = pr2; + q = ps2; + } + z = 1.0 / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0 + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4])))); + return 1.0 + r / s; +} + +/* For x >= 8, the asymptotic expansions of qone is + * 3/8 s - 105/1024 s^3 - ..., where s = 1/x. + * We approximate pone by + * qone(x) = s*(0.375 + (R/S)) + * where R = qr1*s^2 + qr2*s^4 + ... + qr5*s^10 + * S = 1 + qs1*s^2 + ... + qs6*s^12 + * and + * | qone(x)/s -0.375-R/S | <= 2 ** ( -61.13) + */ + +static const double qr8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */ + -1.02539062499992714161e-01, /* 0xBFBA3FFF, 0xFFFFFDF3 */ + -1.62717534544589987888e+01, /* 0xC0304591, 0xA26779F7 */ + -7.59601722513950107896e+02, /* 0xC087BCD0, 0x53E4B576 */ + -1.18498066702429587167e+04, /* 0xC0C724E7, 0x40F87415 */ + -4.84385124285750353010e+04, /* 0xC0E7A6D0, 0x65D09C6A */ +}; +static const double qs8[6] = { + 1.61395369700722909556e+02, /* 0x40642CA6, 0xDE5BCDE5 */ + 7.82538599923348465381e+03, /* 0x40BE9162, 0xD0D88419 */ + 1.33875336287249578163e+05, /* 0x4100579A, 0xB0B75E98 */ + 7.19657723683240939863e+05, /* 0x4125F653, 0x72869C19 */ + 6.66601232617776375264e+05, /* 0x412457D2, 0x7719AD5C */ + -2.94490264303834643215e+05, /* 0xC111F969, 0x0EA5AA18 */ +}; + +static const double qr5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + -2.08979931141764104297e-11, /* 0xBDB6FA43, 0x1AA1A098 */ + -1.02539050241375426231e-01, /* 0xBFBA3FFF, 0xCB597FEF */ + -8.05644828123936029840e+00, /* 0xC0201CE6, 0xCA03AD4B */ + -1.83669607474888380239e+02, /* 0xC066F56D, 0x6CA7B9B0 */ + -1.37319376065508163265e+03, /* 0xC09574C6, 0x6931734F */ + -2.61244440453215656817e+03, /* 0xC0A468E3, 0x88FDA79D */ +}; +static const double qs5[6] = { + 8.12765501384335777857e+01, /* 0x405451B2, 0xFF5A11B2 */ + 1.99179873460485964642e+03, /* 0x409F1F31, 0xE77BF839 */ + 1.74684851924908907677e+04, /* 0x40D10F1F, 0x0D64CE29 */ + 4.98514270910352279316e+04, /* 0x40E8576D, 0xAABAD197 */ + 2.79480751638918118260e+04, /* 0x40DB4B04, 0xCF7C364B */ + -4.71918354795128470869e+03, /* 0xC0B26F2E, 0xFCFFA004 */ +}; + +static const double qr3[6] = { + -5.07831226461766561369e-09, /* 0xBE35CFA9, 0xD38FC84F */ + -1.02537829820837089745e-01, /* 0xBFBA3FEB, 0x51AEED54 */ + -4.61011581139473403113e+00, /* 0xC01270C2, 0x3302D9FF */ + -5.78472216562783643212e+01, /* 0xC04CEC71, 0xC25D16DA */ + -2.28244540737631695038e+02, /* 0xC06C87D3, 0x4718D55F */ + -2.19210128478909325622e+02, /* 0xC06B66B9, 0x5F5C1BF6 */ +}; +static const double qs3[6] = { + 4.76651550323729509273e+01, /* 0x4047D523, 0xCCD367E4 */ + 6.73865112676699709482e+02, /* 0x40850EEB, 0xC031EE3E */ + 3.38015286679526343505e+03, /* 0x40AA684E, 0x448E7C9A */ + 5.54772909720722782367e+03, /* 0x40B5ABBA, 0xA61D54A6 */ + 1.90311919338810798763e+03, /* 0x409DBC7A, 0x0DD4DF4B */ + -1.35201191444307340817e+02, /* 0xC060E670, 0x290A311F */ +}; + +static const double qr2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + -1.78381727510958865572e-07, /* 0xBE87F126, 0x44C626D2 */ + -1.02517042607985553460e-01, /* 0xBFBA3E8E, 0x9148B010 */ + -2.75220568278187460720e+00, /* 0xC0060484, 0x69BB4EDA */ + -1.96636162643703720221e+01, /* 0xC033A9E2, 0xC168907F */ + -4.23253133372830490089e+01, /* 0xC04529A3, 0xDE104AAA */ + -2.13719211703704061733e+01, /* 0xC0355F36, 0x39CF6E52 */ +}; +static const double qs2[6] = { + 2.95333629060523854548e+01, /* 0x403D888A, 0x78AE64FF */ + 2.52981549982190529136e+02, /* 0x406F9F68, 0xDB821CBA */ + 7.57502834868645436472e+02, /* 0x4087AC05, 0xCE49A0F7 */ + 7.39393205320467245656e+02, /* 0x40871B25, 0x48D4C029 */ + 1.55949003336666123687e+02, /* 0x40637E5E, 0x3C3ED8D4 */ + -4.95949898822628210127e+00, /* 0xC013D686, 0xE71BE86B */ +}; + +static double qone(double x) +{ + const double *p, *q; + double_t s, r, z; + uint32_t ix; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x40200000) { + p = qr8; + q = qs8; + } else if (ix >= 0x40122E8B) { + p = qr5; + q = qs5; + } else if (ix >= 0x4006DB6D) { + p = qr3; + q = qs3; + } else /*ix >= 0x40000000*/ { + p = qr2; + q = qs2; + } + z = 1.0 / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0 + + z * (q[0] + + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5]))))); + return (.375 + r / s) / x; +} diff --git a/lib/libm/j1f.c b/lib/libm/j1f.c new file mode 100644 index 00000000..1fec2690 --- /dev/null +++ b/lib/libm/j1f.c @@ -0,0 +1,335 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_j1f.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#define _GNU_SOURCE +#include "libm.h" + +static float ponef(float), qonef(float); + +static const float invsqrtpi = 5.6418961287e-01, /* 0x3f106ebb */ + tpi = 6.3661974669e-01; /* 0x3f22f983 */ + +static float common(uint32_t ix, float x, int y1, int sign) +{ + double z, s, c, ss, cc; + + s = sinf(x); + if (y1) + s = -s; + c = cosf(x); + cc = s - c; + if (ix < 0x7f000000) { + ss = -s - c; + z = cosf(2 * x); + if (s * c > 0) + cc = z / ss; + else + ss = z / cc; + if (ix < 0x58800000) { + if (y1) + ss = -ss; + cc = ponef(x) * cc - qonef(x) * ss; + } + } + if (sign) + cc = -cc; + return invsqrtpi * cc / sqrtf(x); +} + +/* R0/S0 on [0,2] */ +static const float r00 = -6.2500000000e-02, /* 0xbd800000 */ + r01 = 1.4070566976e-03, /* 0x3ab86cfd */ + r02 = -1.5995563444e-05, /* 0xb7862e36 */ + r03 = 4.9672799207e-08, /* 0x335557d2 */ + s01 = 1.9153760746e-02, /* 0x3c9ce859 */ + s02 = 1.8594678841e-04, /* 0x3942fab6 */ + s03 = 1.1771846857e-06, /* 0x359dffc2 */ + s04 = 5.0463624390e-09, /* 0x31ad6446 */ + s05 = 1.2354227016e-11; /* 0x2d59567e */ + +float j1f(float x) +{ + float z, r, s; + uint32_t ix; + int sign; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + if (ix >= 0x7f800000) + return 1 / (x * x); + if (ix >= 0x40000000) /* |x| >= 2 */ + return common(ix, fabsf(x), 0, sign); + if (ix >= 0x39000000) { /* |x| >= 2**-13 */ + z = x * x; + r = z * (r00 + z * (r01 + z * (r02 + z * r03))); + s = 1 + z * (s01 + z * (s02 + z * (s03 + z * (s04 + z * s05)))); + z = 0.5f + r / s; + } else + z = 0.5f; + return z * x; +} + +static const float U0[5] = { + -1.9605709612e-01, /* 0xbe48c331 */ + 5.0443872809e-02, /* 0x3d4e9e3c */ + -1.9125689287e-03, /* 0xbafaaf2a */ + 2.3525259166e-05, /* 0x37c5581c */ + -9.1909917899e-08, /* 0xb3c56003 */ +}; +static const float V0[5] = { + 1.9916731864e-02, /* 0x3ca3286a */ + 2.0255257550e-04, /* 0x3954644b */ + 1.3560879779e-06, /* 0x35b602d4 */ + 6.2274145840e-09, /* 0x31d5f8eb */ + 1.6655924903e-11, /* 0x2d9281cf */ +}; + +float y1f(float x) +{ + float z, u, v; + uint32_t ix; + + GET_FLOAT_WORD(ix, x); + if ((ix & 0x7fffffff) == 0) + return -1 / 0.0f; + if (ix >> 31) + return 0 / 0.0f; + if (ix >= 0x7f800000) + return 1 / x; + if (ix >= 0x40000000) /* |x| >= 2.0 */ + return common(ix, x, 1, 0); + if (ix < 0x33000000) /* x < 2**-25 */ + return -tpi / x; + z = x * x; + u = U0[0] + z * (U0[1] + z * (U0[2] + z * (U0[3] + z * U0[4]))); + v = 1.0f + + z * (V0[0] + z * (V0[1] + z * (V0[2] + z * (V0[3] + z * V0[4])))); + return x * (u / v) + tpi * (j1f(x) * logf(x) - 1.0f / x); +} + +/* For x >= 8, the asymptotic expansions of pone is + * 1 + 15/128 s^2 - 4725/2^15 s^4 - ..., where s = 1/x. + * We approximate pone by + * pone(x) = 1 + (R/S) + * where R = pr0 + pr1*s^2 + pr2*s^4 + ... + pr5*s^10 + * S = 1 + ps0*s^2 + ... + ps4*s^10 + * and + * | pone(x)-1-R/S | <= 2 ** ( -60.06) + */ + +static const float pr8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.0000000000e+00, /* 0x00000000 */ + 1.1718750000e-01, /* 0x3df00000 */ + 1.3239480972e+01, /* 0x4153d4ea */ + 4.1205184937e+02, /* 0x43ce06a3 */ + 3.8747453613e+03, /* 0x45722bed */ + 7.9144794922e+03, /* 0x45f753d6 */ +}; +static const float ps8[5] = { + 1.1420736694e+02, /* 0x42e46a2c */ + 3.6509309082e+03, /* 0x45642ee5 */ + 3.6956207031e+04, /* 0x47105c35 */ + 9.7602796875e+04, /* 0x47bea166 */ + 3.0804271484e+04, /* 0x46f0a88b */ +}; + +static const float pr5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + 1.3199052094e-11, /* 0x2d68333f */ + 1.1718749255e-01, /* 0x3defffff */ + 6.8027510643e+00, /* 0x40d9b023 */ + 1.0830818176e+02, /* 0x42d89dca */ + 5.1763616943e+02, /* 0x440168b7 */ + 5.2871520996e+02, /* 0x44042dc6 */ +}; +static const float ps5[5] = { + 5.9280597687e+01, /* 0x426d1f55 */ + 9.9140142822e+02, /* 0x4477d9b1 */ + 5.3532670898e+03, /* 0x45a74a23 */ + 7.8446904297e+03, /* 0x45f52586 */ + 1.5040468750e+03, /* 0x44bc0180 */ +}; + +static const float pr3[6] = { + 3.0250391081e-09, /* 0x314fe10d */ + 1.1718686670e-01, /* 0x3defffab */ + 3.9329774380e+00, /* 0x407bb5e7 */ + 3.5119403839e+01, /* 0x420c7a45 */ + 9.1055007935e+01, /* 0x42b61c2a */ + 4.8559066772e+01, /* 0x42423c7c */ +}; +static const float ps3[5] = { + 3.4791309357e+01, /* 0x420b2a4d */ + 3.3676245117e+02, /* 0x43a86198 */ + 1.0468714600e+03, /* 0x4482dbe3 */ + 8.9081134033e+02, /* 0x445eb3ed */ + 1.0378793335e+02, /* 0x42cf936c */ +}; + +static const float pr2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + 1.0771083225e-07, /* 0x33e74ea8 */ + 1.1717621982e-01, /* 0x3deffa16 */ + 2.3685150146e+00, /* 0x401795c0 */ + 1.2242610931e+01, /* 0x4143e1bc */ + 1.7693971634e+01, /* 0x418d8d41 */ + 5.0735230446e+00, /* 0x40a25a4d */ +}; +static const float ps2[5] = { + 2.1436485291e+01, /* 0x41ab7dec */ + 1.2529022980e+02, /* 0x42fa9499 */ + 2.3227647400e+02, /* 0x436846c7 */ + 1.1767937469e+02, /* 0x42eb5bd7 */ + 8.3646392822e+00, /* 0x4105d590 */ +}; + +static float ponef(float x) +{ + const float *p, *q; + float_t z, r, s; + uint32_t ix; + + GET_FLOAT_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x41000000) { + p = pr8; + q = ps8; + } else if (ix >= 0x409173eb) { + p = pr5; + q = ps5; + } else if (ix >= 0x4036d917) { + p = pr3; + q = ps3; + } else /*ix >= 0x40000000*/ { + p = pr2; + q = ps2; + } + z = 1.0f / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0f + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4])))); + return 1.0f + r / s; +} + +/* For x >= 8, the asymptotic expansions of qone is + * 3/8 s - 105/1024 s^3 - ..., where s = 1/x. + * We approximate pone by + * qone(x) = s*(0.375 + (R/S)) + * where R = qr1*s^2 + qr2*s^4 + ... + qr5*s^10 + * S = 1 + qs1*s^2 + ... + qs6*s^12 + * and + * | qone(x)/s -0.375-R/S | <= 2 ** ( -61.13) + */ + +static const float qr8[6] = { + /* for x in [inf, 8]=1/[0,0.125] */ + 0.0000000000e+00, /* 0x00000000 */ + -1.0253906250e-01, /* 0xbdd20000 */ + -1.6271753311e+01, /* 0xc1822c8d */ + -7.5960174561e+02, /* 0xc43de683 */ + -1.1849806641e+04, /* 0xc639273a */ + -4.8438511719e+04, /* 0xc73d3683 */ +}; +static const float qs8[6] = { + 1.6139537048e+02, /* 0x43216537 */ + 7.8253862305e+03, /* 0x45f48b17 */ + 1.3387534375e+05, /* 0x4802bcd6 */ + 7.1965775000e+05, /* 0x492fb29c */ + 6.6660125000e+05, /* 0x4922be94 */ + -2.9449025000e+05, /* 0xc88fcb48 */ +}; + +static const float qr5[6] = { + /* for x in [8,4.5454]=1/[0.125,0.22001] */ + -2.0897993405e-11, /* 0xadb7d219 */ + -1.0253904760e-01, /* 0xbdd1fffe */ + -8.0564479828e+00, /* 0xc100e736 */ + -1.8366960144e+02, /* 0xc337ab6b */ + -1.3731937256e+03, /* 0xc4aba633 */ + -2.6124443359e+03, /* 0xc523471c */ +}; +static const float qs5[6] = { + 8.1276550293e+01, /* 0x42a28d98 */ + 1.9917987061e+03, /* 0x44f8f98f */ + 1.7468484375e+04, /* 0x468878f8 */ + 4.9851425781e+04, /* 0x4742bb6d */ + 2.7948074219e+04, /* 0x46da5826 */ + -4.7191835938e+03, /* 0xc5937978 */ +}; + +static const float qr3[6] = { + -5.0783124372e-09, /* 0xb1ae7d4f */ + -1.0253783315e-01, /* 0xbdd1ff5b */ + -4.6101160049e+00, /* 0xc0938612 */ + -5.7847221375e+01, /* 0xc267638e */ + -2.2824453735e+02, /* 0xc3643e9a */ + -2.1921012878e+02, /* 0xc35b35cb */ +}; +static const float qs3[6] = { + 4.7665153503e+01, /* 0x423ea91e */ + 6.7386511230e+02, /* 0x4428775e */ + 3.3801528320e+03, /* 0x45534272 */ + 5.5477290039e+03, /* 0x45ad5dd5 */ + 1.9031191406e+03, /* 0x44ede3d0 */ + -1.3520118713e+02, /* 0xc3073381 */ +}; + +static const float qr2[6] = { + /* for x in [2.8570,2]=1/[0.3499,0.5] */ + -1.7838172539e-07, /* 0xb43f8932 */ + -1.0251704603e-01, /* 0xbdd1f475 */ + -2.7522056103e+00, /* 0xc0302423 */ + -1.9663616180e+01, /* 0xc19d4f16 */ + -4.2325313568e+01, /* 0xc2294d1f */ + -2.1371921539e+01, /* 0xc1aaf9b2 */ +}; +static const float qs2[6] = { + 2.9533363342e+01, /* 0x41ec4454 */ + 2.5298155212e+02, /* 0x437cfb47 */ + 7.5750280762e+02, /* 0x443d602e */ + 7.3939318848e+02, /* 0x4438d92a */ + 1.5594900513e+02, /* 0x431bf2f2 */ + -4.9594988823e+00, /* 0xc09eb437 */ +}; + +static float qonef(float x) +{ + const float *p, *q; + float_t s, r, z; + uint32_t ix; + + GET_FLOAT_WORD(ix, x); + ix &= 0x7fffffff; + if (ix >= 0x41000000) { + p = qr8; + q = qs8; + } else if (ix >= 0x409173eb) { + p = qr5; + q = qs5; + } else if (ix >= 0x4036d917) { + p = qr3; + q = qs3; + } else /*ix >= 0x40000000*/ { + p = qr2; + q = qs2; + } + z = 1.0f / (x * x); + r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5])))); + s = 1.0f + + z * (q[0] + + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5]))))); + return (.375f + r / s) / x; +} diff --git a/lib/libm/jn.c b/lib/libm/jn.c new file mode 100644 index 00000000..a8515278 --- /dev/null +++ b/lib/libm/jn.c @@ -0,0 +1,297 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_jn.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * jn(n, x), yn(n, x) + * floating point Bessel's function of the 1st and 2nd kind + * of order n + * + * Special cases: + * y0(0)=y1(0)=yn(n,0) = -inf with division by zero signal; + * y0(-ve)=y1(-ve)=yn(n,-ve) are NaN with invalid signal. + * Note 2. About jn(n,x), yn(n,x) + * For n=0, j0(x) is called, + * for n=1, j1(x) is called, + * for n<=x, forward recursion is used starting + * from values of j0(x) and j1(x). + * for n>x, a continued fraction approximation to + * j(n,x)/j(n-1,x) is evaluated and then backward + * recursion is used starting from a supposed value + * for j(n,x). The resulting value of j(0,x) is + * compared with the actual value to correct the + * supposed value of j(n,x). + * + * yn(n,x) is similar in all respects, except + * that forward recursion is used for all + * values of n>1. + */ + +#include "libm.h" + +static const double invsqrtpi = 5.64189583547756279280e-01; /* 0x3FE20DD7, + 0x50429B6D */ + +double jn(int n, double x) +{ + uint32_t ix, lx; + int nm1, i, sign; + double a, b, temp; + + EXTRACT_WORDS(ix, lx, x); + sign = ix >> 31; + ix &= 0x7fffffff; + + if ((ix | (lx | -lx) >> 31) > 0x7ff00000) /* nan */ + return x; + + /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x) + * Thus, J(-n,x) = J(n,-x) + */ + /* nm1 = |n|-1 is used instead of |n| to handle n==INT_MIN */ + if (n == 0) + return j0(x); + if (n < 0) { + nm1 = -(n + 1); + x = -x; + sign ^= 1; + } else + nm1 = n - 1; + if (nm1 == 0) + return j1(x); + + sign &= n; /* even n: 0, odd n: signbit(x) */ + x = fabs(x); + if ((ix | lx) == 0 || ix == 0x7ff00000) /* if x is 0 or inf */ + b = 0.0; + else if (nm1 < x) { + /* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */ + if (ix >= 0x52d00000) { /* x > 2**302 */ + /* (x >> n**2) + * Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi) + * Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi) + * Let s=sin(x), c=cos(x), + * xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then + * + * n sin(xn)*sqt2 cos(xn)*sqt2 + * ---------------------------------- + * 0 s-c c+s + * 1 -s-c -c+s + * 2 -s+c -c-s + * 3 s+c c-s + */ + switch (nm1 & 3) { + case 0: + temp = -cos(x) + sin(x); + break; + case 1: + temp = -cos(x) - sin(x); + break; + case 2: + temp = cos(x) - sin(x); + break; + default: + case 3: + temp = cos(x) + sin(x); + break; + } + b = invsqrtpi * temp / sqrt(x); + } else { + a = j0(x); + b = j1(x); + for (i = 0; i < nm1;) { + i++; + temp = b; + b = b * (2.0 * i / x) - a; /* avoid underflow */ + a = temp; + } + } + } else { + if (ix < 0x3e100000) { /* x < 2**-29 */ + /* x is tiny, return the first Taylor expansion of + * J(n,x) J(n,x) = 1/n!*(x/2)^n - ... + */ + if (nm1 > 32) /* underflow */ + b = 0.0; + else { + temp = x * 0.5; + b = temp; + a = 1.0; + for (i = 2; i <= nm1 + 1; i++) { + a *= (double)i; /* a = n! */ + b *= temp; /* b = (x/2)^n */ + } + b = b / a; + } + } else { + /* use backward recurrence */ + /* x x^2 x^2 + * J(n,x)/J(n-1,x) = ---- ------ ------ ..... + * 2n - 2(n+1) - 2(n+2) + * + * 1 1 1 + * (for large x) = ---- ------ ------ ..... + * 2n 2(n+1) 2(n+2) + * -- - ------ - ------ - + * x x x + * + * Let w = 2n/x and h=2/x, then the above quotient + * is equal to the continued fraction: + * 1 + * = ----------------------- + * 1 + * w - ----------------- + * 1 + * w+h - --------- + * w+2h - ... + * + * To determine how many terms needed, let + * Q(0) = w, Q(1) = w(w+h) - 1, + * Q(k) = (w+k*h)*Q(k-1) - Q(k-2), + * When Q(k) > 1e4 good for single + * When Q(k) > 1e9 good for double + * When Q(k) > 1e17 good for quadruple + */ + /* determine k */ + double t, q0, q1, w, h, z, tmp, nf; + int k; + + nf = nm1 + 1.0; + w = 2 * nf / x; + h = 2 / x; + z = w + h; + q0 = w; + q1 = w * z - 1.0; + k = 1; + while (q1 < 1.0e9) { + k += 1; + z += h; + tmp = z * q1 - q0; + q0 = q1; + q1 = tmp; + } + for (t = 0.0, i = k; i >= 0; i--) + t = 1 / (2 * (i + nf) / x - t); + a = t; + b = 1.0; + /* estimate log((2/x)^n*n!) = n*log(2/x)+n*ln(n) + * Hence, if n*(log(2n/x)) > ... + * single 8.8722839355e+01 + * double 7.09782712893383973096e+02 + * long + * double 1.1356523406294143949491931077970765006170e+04 + * then recurrent value may overflow and the result is + * likely underflow to zero + */ + tmp = nf * log(fabs(w)); + if (tmp < 7.09782712893383973096e+02) { + for (i = nm1; i > 0; i--) { + temp = b; + b = b * (2.0 * i) / x - a; + a = temp; + } + } else { + for (i = nm1; i > 0; i--) { + temp = b; + b = b * (2.0 * i) / x - a; + a = temp; + /* scale b to avoid spurious overflow */ + if (b > 0x1p500) { + a /= b; + t /= b; + b = 1.0; + } + } + } + z = j0(x); + w = j1(x); + if (fabs(z) >= fabs(w)) + b = t * z / b; + else + b = t * w / a; + } + } + return sign ? -b : b; +} + +double yn(int n, double x) +{ + uint32_t ix, lx, ib; + int nm1, sign, i; + double a, b, temp; + + EXTRACT_WORDS(ix, lx, x); + sign = ix >> 31; + ix &= 0x7fffffff; + + if ((ix | (lx | -lx) >> 31) > 0x7ff00000) /* nan */ + return x; + if (sign && (ix | lx) != 0) /* x < 0 */ + return 0 / 0.0; + if (ix == 0x7ff00000) + return 0.0; + + if (n == 0) + return y0(x); + if (n < 0) { + nm1 = -(n + 1); + sign = n & 1; + } else { + nm1 = n - 1; + sign = 0; + } + if (nm1 == 0) + return sign ? -y1(x) : y1(x); + + if (ix >= 0x52d00000) { /* x > 2**302 */ + /* (x >> n**2) + * Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi) + * Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi) + * Let s=sin(x), c=cos(x), + * xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then + * + * n sin(xn)*sqt2 cos(xn)*sqt2 + * ---------------------------------- + * 0 s-c c+s + * 1 -s-c -c+s + * 2 -s+c -c-s + * 3 s+c c-s + */ + switch (nm1 & 3) { + case 0: + temp = -sin(x) - cos(x); + break; + case 1: + temp = -sin(x) + cos(x); + break; + case 2: + temp = sin(x) + cos(x); + break; + default: + case 3: + temp = sin(x) - cos(x); + break; + } + b = invsqrtpi * temp / sqrt(x); + } else { + a = y0(x); + b = y1(x); + /* quit if b is -inf */ + GET_HIGH_WORD(ib, b); + for (i = 0; i < nm1 && ib != 0xfff00000;) { + i++; + temp = b; + b = (2.0 * i / x) * b - a; + GET_HIGH_WORD(ib, b); + a = temp; + } + } + return sign ? -b : b; +} diff --git a/lib/libm/ldexp.c b/lib/libm/ldexp.c new file mode 100644 index 00000000..f4d1cd6a --- /dev/null +++ b/lib/libm/ldexp.c @@ -0,0 +1,6 @@ +#include <math.h> + +double ldexp(double x, int n) +{ + return scalbn(x, n); +} diff --git a/lib/libm/ldexpf.c b/lib/libm/ldexpf.c new file mode 100644 index 00000000..3bad5f39 --- /dev/null +++ b/lib/libm/ldexpf.c @@ -0,0 +1,6 @@ +#include <math.h> + +float ldexpf(float x, int n) +{ + return scalbnf(x, n); +} diff --git a/lib/libm/ldexpl.c b/lib/libm/ldexpl.c new file mode 100644 index 00000000..fd145ccc --- /dev/null +++ b/lib/libm/ldexpl.c @@ -0,0 +1,6 @@ +#include <math.h> + +long double ldexpl(long double x, int n) +{ + return scalbnl(x, n); +} diff --git a/lib/libm/lgamma.c b/lib/libm/lgamma.c new file mode 100644 index 00000000..2fc9b478 --- /dev/null +++ b/lib/libm/lgamma.c @@ -0,0 +1,7 @@ +#include <math.h> +#include "libm.h" + +double lgamma(double x) +{ + return __lgamma_r(x, &__signgam); +} diff --git a/lib/libm/lgamma_r.c b/lib/libm/lgamma_r.c new file mode 100644 index 00000000..00eeb27b --- /dev/null +++ b/lib/libm/lgamma_r.c @@ -0,0 +1,314 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_lgamma_r.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ +/* lgamma_r(x, signgamp) + * Reentrant version of the logarithm of the Gamma function + * with user provide pointer for the sign of Gamma(x). + * + * Method: + * 1. Argument Reduction for 0 < x <= 8 + * Since gamma(1+s)=s*gamma(s), for x in [0,8], we may + * reduce x to a number in [1.5,2.5] by + * lgamma(1+s) = log(s) + lgamma(s) + * for example, + * lgamma(7.3) = log(6.3) + lgamma(6.3) + * = log(6.3*5.3) + lgamma(5.3) + * = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3) + * 2. Polynomial approximation of lgamma around its + * minimun ymin=1.461632144968362245 to maintain monotonicity. + * On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use + * Let z = x-ymin; + * lgamma(x) = -1.214862905358496078218 + z^2*poly(z) + * where + * poly(z) is a 14 degree polynomial. + * 2. Rational approximation in the primary interval [2,3] + * We use the following approximation: + * s = x-2.0; + * lgamma(x) = 0.5*s + s*P(s)/Q(s) + * with accuracy + * |P/Q - (lgamma(x)-0.5s)| < 2**-61.71 + * Our algorithms are based on the following observation + * + * zeta(2)-1 2 zeta(3)-1 3 + * lgamma(2+s) = s*(1-Euler) + --------- * s - --------- * s + ... + * 2 3 + * + * where Euler = 0.5771... is the Euler constant, which is very + * close to 0.5. + * + * 3. For x>=8, we have + * lgamma(x)~(x-0.5)log(x)-x+0.5*log(2pi)+1/(12x)-1/(360x**3)+.... + * (better formula: + * lgamma(x)~(x-0.5)*(log(x)-1)-.5*(log(2pi)-1) + ...) + * Let z = 1/x, then we approximation + * f(z) = lgamma(x) - (x-0.5)(log(x)-1) + * by + * 3 5 11 + * w = w0 + w1*z + w2*z + w3*z + ... + w6*z + * where + * |w - f(z)| < 2**-58.74 + * + * 4. For negative x, since (G is gamma function) + * -x*G(-x)*G(x) = pi/sin(pi*x), + * we have + * G(x) = pi/(sin(pi*x)*(-x)*G(-x)) + * since G(-x) is positive, sign(G(x)) = sign(sin(pi*x)) for x<0 + * Hence, for x<0, signgam = sign(sin(pi*x)) and + * lgamma(x) = log(|Gamma(x)|) + * = log(pi/(|x*sin(pi*x)|)) - lgamma(-x); + * Note: one should avoid compute pi*(-x) directly in the + * computation of sin(pi*(-x)). + * + * 5. Special Cases + * lgamma(2+s) ~ s*(1-Euler) for tiny s + * lgamma(1) = lgamma(2) = 0 + * lgamma(x) ~ -log(|x|) for tiny x + * lgamma(0) = lgamma(neg.integer) = inf and raise divide-by-zero + * lgamma(inf) = inf + * lgamma(-inf) = inf (bug for bug compatible with C99!?) + * + */ + +#include "libm.h" + +static const double pi = 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 + */ + a0 = 7.72156649015328655494e-02, /* 0x3FB3C467, 0xE37DB0C8 */ + a1 = 3.22467033424113591611e-01, /* 0x3FD4A34C, 0xC4A60FAD */ + a2 = 6.73523010531292681824e-02, /* 0x3FB13E00, 0x1A5562A7 */ + a3 = 2.05808084325167332806e-02, /* 0x3F951322, 0xAC92547B */ + a4 = 7.38555086081402883957e-03, /* 0x3F7E404F, 0xB68FEFE8 */ + a5 = 2.89051383673415629091e-03, /* 0x3F67ADD8, 0xCCB7926B */ + a6 = 1.19270763183362067845e-03, /* 0x3F538A94, 0x116F3F5D */ + a7 = 5.10069792153511336608e-04, /* 0x3F40B6C6, 0x89B99C00 */ + a8 = 2.20862790713908385557e-04, /* 0x3F2CF2EC, 0xED10E54D */ + a9 = 1.08011567247583939954e-04, /* 0x3F1C5088, 0x987DFB07 */ + a10 = 2.52144565451257326939e-05, /* 0x3EFA7074, 0x428CFA52 */ + a11 = 4.48640949618915160150e-05, /* 0x3F07858E, 0x90A45837 */ + tc = 1.46163214496836224576e+00, /* 0x3FF762D8, 0x6356BE3F */ + tf = -1.21486290535849611461e-01, /* 0xBFBF19B9, 0xBCC38A42 */ + /* tt = -(tail of tf) */ + tt = -3.63867699703950536541e-18, /* 0xBC50C7CA, 0xA48A971F */ + t0 = 4.83836122723810047042e-01, /* 0x3FDEF72B, 0xC8EE38A2 */ + t1 = -1.47587722994593911752e-01, /* 0xBFC2E427, 0x8DC6C509 */ + t2 = 6.46249402391333854778e-02, /* 0x3FB08B42, 0x94D5419B */ + t3 = -3.27885410759859649565e-02, /* 0xBFA0C9A8, 0xDF35B713 */ + t4 = 1.79706750811820387126e-02, /* 0x3F9266E7, 0x970AF9EC */ + t5 = -1.03142241298341437450e-02, /* 0xBF851F9F, 0xBA91EC6A */ + t6 = 6.10053870246291332635e-03, /* 0x3F78FCE0, 0xE370E344 */ + t7 = -3.68452016781138256760e-03, /* 0xBF6E2EFF, 0xB3E914D7 */ + t8 = 2.25964780900612472250e-03, /* 0x3F6282D3, 0x2E15C915 */ + t9 = -1.40346469989232843813e-03, /* 0xBF56FE8E, 0xBF2D1AF1 */ + t10 = 8.81081882437654011382e-04, /* 0x3F4CDF0C, 0xEF61A8E9 */ + t11 = -5.38595305356740546715e-04, /* 0xBF41A610, 0x9C73E0EC */ + t12 = 3.15632070903625950361e-04, /* 0x3F34AF6D, 0x6C0EBBF7 */ + t13 = -3.12754168375120860518e-04, /* 0xBF347F24, 0xECC38C38 */ + t14 = 3.35529192635519073543e-04, /* 0x3F35FD3E, 0xE8C2D3F4 */ + u0 = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */ + u1 = 6.32827064025093366517e-01, /* 0x3FE4401E, 0x8B005DFF */ + u2 = 1.45492250137234768737e+00, /* 0x3FF7475C, 0xD119BD6F */ + u3 = 9.77717527963372745603e-01, /* 0x3FEF4976, 0x44EA8450 */ + u4 = 2.28963728064692451092e-01, /* 0x3FCD4EAE, 0xF6010924 */ + u5 = 1.33810918536787660377e-02, /* 0x3F8B678B, 0xBF2BAB09 */ + v1 = 2.45597793713041134822e+00, /* 0x4003A5D7, 0xC2BD619C */ + v2 = 2.12848976379893395361e+00, /* 0x40010725, 0xA42B18F5 */ + v3 = 7.69285150456672783825e-01, /* 0x3FE89DFB, 0xE45050AF */ + v4 = 1.04222645593369134254e-01, /* 0x3FBAAE55, 0xD6537C88 */ + v5 = 3.21709242282423911810e-03, /* 0x3F6A5ABB, 0x57D0CF61 */ + s0 = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */ + s1 = 2.14982415960608852501e-01, /* 0x3FCB848B, 0x36E20878 */ + s2 = 3.25778796408930981787e-01, /* 0x3FD4D98F, 0x4F139F59 */ + s3 = 1.46350472652464452805e-01, /* 0x3FC2BB9C, 0xBEE5F2F7 */ + s4 = 2.66422703033638609560e-02, /* 0x3F9B481C, 0x7E939961 */ + s5 = 1.84028451407337715652e-03, /* 0x3F5E26B6, 0x7368F239 */ + s6 = 3.19475326584100867617e-05, /* 0x3F00BFEC, 0xDD17E945 */ + r1 = 1.39200533467621045958e+00, /* 0x3FF645A7, 0x62C4AB74 */ + r2 = 7.21935547567138069525e-01, /* 0x3FE71A18, 0x93D3DCDC */ + r3 = 1.71933865632803078993e-01, /* 0x3FC601ED, 0xCCFBDF27 */ + r4 = 1.86459191715652901344e-02, /* 0x3F9317EA, 0x742ED475 */ + r5 = 7.77942496381893596434e-04, /* 0x3F497DDA, 0xCA41A95B */ + r6 = 7.32668430744625636189e-06, /* 0x3EDEBAF7, 0xA5B38140 */ + w0 = 4.18938533204672725052e-01, /* 0x3FDACFE3, 0x90C97D69 */ + w1 = 8.33333333333329678849e-02, /* 0x3FB55555, 0x5555553B */ + w2 = -2.77777777728775536470e-03, /* 0xBF66C16C, 0x16B02E5C */ + w3 = 7.93650558643019558500e-04, /* 0x3F4A019F, 0x98CF38B6 */ + w4 = -5.95187557450339963135e-04, /* 0xBF4380CB, 0x8C0FE741 */ + w5 = 8.36339918996282139126e-04, /* 0x3F4B67BA, 0x4CDAD5D1 */ + w6 = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */ + +/* sin(pi*x) assuming x > 2^-100, if sin(pi*x)==0 the sign is arbitrary */ +static double sin_pi(double x) +{ + int n; + + /* spurious inexact if odd int */ + x = 2.0 * (x * 0.5 - floor(x * 0.5)); /* x mod 2.0 */ + + n = (int)(x * 4.0); + n = (n + 1) / 2; + x -= n * 0.5f; + x *= pi; + + switch (n) { + default: /* case 4: */ + case 0: + return __sin(x, 0.0, 0); + case 1: + return __cos(x, 0.0); + case 2: + return __sin(-x, 0.0, 0); + case 3: + return -__cos(x, 0.0); + } +} + +double __lgamma_r(double x, int *signgamp) +{ + union { + double f; + uint64_t i; + } u = { x }; + double_t t, y, z, nadj, p, p1, p2, p3, q, r, w; + uint32_t ix; + int sign, i; + + /* purge off +-inf, NaN, +-0, tiny and negative arguments */ + *signgamp = 1; + sign = u.i >> 63; + ix = u.i >> 32 & 0x7fffffff; + if (ix >= 0x7ff00000) + return x * x; + if (ix < (0x3ff - 70) << 20) { /* |x|<2**-70, return -log(|x|) */ + if (sign) { + x = -x; + *signgamp = -1; + } + return -log(x); + } + if (sign) { + x = -x; + t = sin_pi(x); + if (t == 0.0) /* -integer */ + return 1.0 / (x - x); + if (t > 0.0) + *signgamp = -1; + else + t = -t; + nadj = log(pi / (t * x)); + } + + /* purge off 1 and 2 */ + if ((ix == 0x3ff00000 || ix == 0x40000000) && (uint32_t)u.i == 0) + r = 0; + /* for x < 2.0 */ + else if (ix < 0x40000000) { + if (ix <= 0x3feccccc) { /* lgamma(x) = lgamma(x+1)-log(x) */ + r = -log(x); + if (ix >= 0x3FE76944) { + y = 1.0 - x; + i = 0; + } else if (ix >= 0x3FCDA661) { + y = x - (tc - 1.0); + i = 1; + } else { + y = x; + i = 2; + } + } else { + r = 0.0; + if (ix >= 0x3FFBB4C3) { /* [1.7316,2] */ + y = 2.0 - x; + i = 0; + } else if (ix >= 0x3FF3B4C4) { /* [1.23,1.73] */ + y = x - tc; + i = 1; + } else { + y = x - 1.0; + i = 2; + } + } + switch (i) { + case 0: + z = y * y; + p1 = a0 + + z * (a2 + + z * (a4 + z * (a6 + z * (a8 + z * a10)))); + p2 = z * + (a1 + + z * (a3 + + z * (a5 + z * (a7 + z * (a9 + z * a11))))); + p = y * p1 + p2; + r += (p - 0.5 * y); + break; + case 1: + z = y * y; + w = z * y; + p1 = t0 + + w * (t3 + w * (t6 + w * (t9 + w * t12))); /* parallel + comp + */ + p2 = t1 + w * (t4 + w * (t7 + w * (t10 + w * t13))); + p3 = t2 + w * (t5 + w * (t8 + w * (t11 + w * t14))); + p = z * p1 - (tt - w * (p2 + y * p3)); + r += tf + p; + break; + case 2: + p1 = y * + (u0 + + y * (u1 + + y * (u2 + y * (u3 + y * (u4 + y * u5))))); + p2 = 1.0 + + y * (v1 + y * (v2 + y * (v3 + y * (v4 + y * v5)))); + r += -0.5 * y + p1 / p2; + } + } else if (ix < 0x40200000) { /* x < 8.0 */ + i = (int)x; + y = x - (double)i; + p = y * + (s0 + + y * (s1 + + y * (s2 + y * (s3 + y * (s4 + y * (s5 + y * s6)))))); + q = 1.0 + + y * (r1 + + y * (r2 + y * (r3 + y * (r4 + y * (r5 + y * r6))))); + r = 0.5 * y + p / q; + z = 1.0; /* lgamma(1+s) = log(s) + lgamma(s) */ + switch (i) { + case 7: + z *= y + 6.0; /* FALLTHRU */ + case 6: + z *= y + 5.0; /* FALLTHRU */ + case 5: + z *= y + 4.0; /* FALLTHRU */ + case 4: + z *= y + 3.0; /* FALLTHRU */ + case 3: + z *= y + 2.0; /* FALLTHRU */ + r += log(z); + break; + } + } else if (ix < 0x43900000) { /* 8.0 <= x < 2**58 */ + t = log(x); + z = 1.0 / x; + y = z * z; + w = w0 + + z * (w1 + + y * (w2 + y * (w3 + y * (w4 + y * (w5 + y * w6))))); + r = (x - 0.5) * (t - 1.0) + w; + } else /* 2**58 <= x <= inf */ + r = x * (log(x) - 1.0); + if (sign) + r = nadj - r; + return r; +} + +weak_alias(__lgamma_r, lgamma_r); diff --git a/lib/libm/lgammaf.c b/lib/libm/lgammaf.c new file mode 100644 index 00000000..2ae051d0 --- /dev/null +++ b/lib/libm/lgammaf.c @@ -0,0 +1,7 @@ +#include <math.h> +#include "libm.h" + +float lgammaf(float x) +{ + return __lgammaf_r(x, &__signgam); +} diff --git a/lib/libm/lgammaf_r.c b/lib/libm/lgammaf_r.c new file mode 100644 index 00000000..4b63298e --- /dev/null +++ b/lib/libm/lgammaf_r.c @@ -0,0 +1,248 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_lgammaf_r.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +static const float pi = 3.1415927410e+00, /* 0x40490fdb */ + a0 = 7.7215664089e-02, /* 0x3d9e233f */ + a1 = 3.2246702909e-01, /* 0x3ea51a66 */ + a2 = 6.7352302372e-02, /* 0x3d89f001 */ + a3 = 2.0580807701e-02, /* 0x3ca89915 */ + a4 = 7.3855509982e-03, /* 0x3bf2027e */ + a5 = 2.8905137442e-03, /* 0x3b3d6ec6 */ + a6 = 1.1927076848e-03, /* 0x3a9c54a1 */ + a7 = 5.1006977446e-04, /* 0x3a05b634 */ + a8 = 2.2086278477e-04, /* 0x39679767 */ + a9 = 1.0801156895e-04, /* 0x38e28445 */ + a10 = 2.5214456400e-05, /* 0x37d383a2 */ + a11 = 4.4864096708e-05, /* 0x383c2c75 */ + tc = 1.4616321325e+00, /* 0x3fbb16c3 */ + tf = -1.2148628384e-01, /* 0xbdf8cdcd */ + /* tt = -(tail of tf) */ + tt = 6.6971006518e-09, /* 0x31e61c52 */ + t0 = 4.8383611441e-01, /* 0x3ef7b95e */ + t1 = -1.4758771658e-01, /* 0xbe17213c */ + t2 = 6.4624942839e-02, /* 0x3d845a15 */ + t3 = -3.2788541168e-02, /* 0xbd064d47 */ + t4 = 1.7970675603e-02, /* 0x3c93373d */ + t5 = -1.0314224288e-02, /* 0xbc28fcfe */ + t6 = 6.1005386524e-03, /* 0x3bc7e707 */ + t7 = -3.6845202558e-03, /* 0xbb7177fe */ + t8 = 2.2596477065e-03, /* 0x3b141699 */ + t9 = -1.4034647029e-03, /* 0xbab7f476 */ + t10 = 8.8108185446e-04, /* 0x3a66f867 */ + t11 = -5.3859531181e-04, /* 0xba0d3085 */ + t12 = 3.1563205994e-04, /* 0x39a57b6b */ + t13 = -3.1275415677e-04, /* 0xb9a3f927 */ + t14 = 3.3552918467e-04, /* 0x39afe9f7 */ + u0 = -7.7215664089e-02, /* 0xbd9e233f */ + u1 = 6.3282704353e-01, /* 0x3f2200f4 */ + u2 = 1.4549225569e+00, /* 0x3fba3ae7 */ + u3 = 9.7771751881e-01, /* 0x3f7a4bb2 */ + u4 = 2.2896373272e-01, /* 0x3e6a7578 */ + u5 = 1.3381091878e-02, /* 0x3c5b3c5e */ + v1 = 2.4559779167e+00, /* 0x401d2ebe */ + v2 = 2.1284897327e+00, /* 0x4008392d */ + v3 = 7.6928514242e-01, /* 0x3f44efdf */ + v4 = 1.0422264785e-01, /* 0x3dd572af */ + v5 = 3.2170924824e-03, /* 0x3b52d5db */ + s0 = -7.7215664089e-02, /* 0xbd9e233f */ + s1 = 2.1498242021e-01, /* 0x3e5c245a */ + s2 = 3.2577878237e-01, /* 0x3ea6cc7a */ + s3 = 1.4635047317e-01, /* 0x3e15dce6 */ + s4 = 2.6642270386e-02, /* 0x3cda40e4 */ + s5 = 1.8402845599e-03, /* 0x3af135b4 */ + s6 = 3.1947532989e-05, /* 0x3805ff67 */ + r1 = 1.3920053244e+00, /* 0x3fb22d3b */ + r2 = 7.2193557024e-01, /* 0x3f38d0c5 */ + r3 = 1.7193385959e-01, /* 0x3e300f6e */ + r4 = 1.8645919859e-02, /* 0x3c98bf54 */ + r5 = 7.7794247773e-04, /* 0x3a4beed6 */ + r6 = 7.3266842264e-06, /* 0x36f5d7bd */ + w0 = 4.1893854737e-01, /* 0x3ed67f1d */ + w1 = 8.3333335817e-02, /* 0x3daaaaab */ + w2 = -2.7777778450e-03, /* 0xbb360b61 */ + w3 = 7.9365057172e-04, /* 0x3a500cfd */ + w4 = -5.9518753551e-04, /* 0xba1c065c */ + w5 = 8.3633989561e-04, /* 0x3a5b3dd2 */ + w6 = -1.6309292987e-03; /* 0xbad5c4e8 */ + +/* sin(pi*x) assuming x > 2^-100, if sin(pi*x)==0 the sign is arbitrary */ +static float sin_pi(float x) +{ + double_t y; + int n; + + /* spurious inexact if odd int */ + x = 2 * (x * 0.5f - floorf(x * 0.5f)); /* x mod 2.0 */ + + n = (int)(x * 4); + n = (n + 1) / 2; + y = x - n * 0.5f; + y *= 3.14159265358979323846; + switch (n) { + default: /* case 4: */ + case 0: + return __sindf(y); + case 1: + return __cosdf(y); + case 2: + return __sindf(-y); + case 3: + return -__cosdf(y); + } +} + +float __lgammaf_r(float x, int *signgamp) +{ + union { + float f; + uint32_t i; + } u = { x }; + float t, y, z, nadj, p, p1, p2, p3, q, r, w; + uint32_t ix; + int i, sign; + + /* purge off +-inf, NaN, +-0, tiny and negative arguments */ + *signgamp = 1; + sign = u.i >> 31; + ix = u.i & 0x7fffffff; + if (ix >= 0x7f800000) + return x * x; + if (ix < 0x35000000) { /* |x| < 2**-21, return -log(|x|) */ + if (sign) { + *signgamp = -1; + x = -x; + } + return -logf(x); + } + if (sign) { + x = -x; + t = sin_pi(x); + if (t == 0.0f) /* -integer */ + return 1.0f / (x - x); + if (t > 0.0f) + *signgamp = -1; + else + t = -t; + nadj = logf(pi / (t * x)); + } + + /* purge off 1 and 2 */ + if (ix == 0x3f800000 || ix == 0x40000000) + r = 0; + /* for x < 2.0 */ + else if (ix < 0x40000000) { + if (ix <= 0x3f666666) { /* lgamma(x) = lgamma(x+1)-log(x) */ + r = -logf(x); + if (ix >= 0x3f3b4a20) { + y = 1.0f - x; + i = 0; + } else if (ix >= 0x3e6d3308) { + y = x - (tc - 1.0f); + i = 1; + } else { + y = x; + i = 2; + } + } else { + r = 0.0f; + if (ix >= 0x3fdda618) { /* [1.7316,2] */ + y = 2.0f - x; + i = 0; + } else if (ix >= 0x3F9da620) { /* [1.23,1.73] */ + y = x - tc; + i = 1; + } else { + y = x - 1.0f; + i = 2; + } + } + switch (i) { + case 0: + z = y * y; + p1 = a0 + + z * (a2 + + z * (a4 + z * (a6 + z * (a8 + z * a10)))); + p2 = z * + (a1 + + z * (a3 + + z * (a5 + z * (a7 + z * (a9 + z * a11))))); + p = y * p1 + p2; + r += p - 0.5f * y; + break; + case 1: + z = y * y; + w = z * y; + p1 = t0 + + w * (t3 + w * (t6 + w * (t9 + w * t12))); /* parallel + comp + */ + p2 = t1 + w * (t4 + w * (t7 + w * (t10 + w * t13))); + p3 = t2 + w * (t5 + w * (t8 + w * (t11 + w * t14))); + p = z * p1 - (tt - w * (p2 + y * p3)); + r += (tf + p); + break; + case 2: + p1 = y * + (u0 + + y * (u1 + + y * (u2 + y * (u3 + y * (u4 + y * u5))))); + p2 = 1.0f + + y * (v1 + y * (v2 + y * (v3 + y * (v4 + y * v5)))); + r += -0.5f * y + p1 / p2; + } + } else if (ix < 0x41000000) { /* x < 8.0 */ + i = (int)x; + y = x - (float)i; + p = y * + (s0 + + y * (s1 + + y * (s2 + y * (s3 + y * (s4 + y * (s5 + y * s6)))))); + q = 1.0f + + y * (r1 + + y * (r2 + y * (r3 + y * (r4 + y * (r5 + y * r6))))); + r = 0.5f * y + p / q; + z = 1.0f; /* lgamma(1+s) = log(s) + lgamma(s) */ + switch (i) { + case 7: + z *= y + 6.0f; /* FALLTHRU */ + case 6: + z *= y + 5.0f; /* FALLTHRU */ + case 5: + z *= y + 4.0f; /* FALLTHRU */ + case 4: + z *= y + 3.0f; /* FALLTHRU */ + case 3: + z *= y + 2.0f; /* FALLTHRU */ + r += logf(z); + break; + } + } else if (ix < 0x5c800000) { /* 8.0 <= x < 2**58 */ + t = logf(x); + z = 1.0f / x; + y = z * z; + w = w0 + + z * (w1 + + y * (w2 + y * (w3 + y * (w4 + y * (w5 + y * w6))))); + r = (x - 0.5f) * (t - 1.0f) + w; + } else /* 2**58 <= x <= inf */ + r = x * (logf(x) - 1.0f); + if (sign) + r = nadj - r; + return r; +} + +weak_alias(__lgammaf_r, lgammaf_r); diff --git a/lib/libm/lgammal.c b/lib/libm/lgammal.c new file mode 100644 index 00000000..08835693 --- /dev/null +++ b/lib/libm/lgammal.c @@ -0,0 +1,377 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_lgammal.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* lgammal(x) + * Reentrant version of the logarithm of the Gamma function + * with user provide pointer for the sign of Gamma(x). + * + * Method: + * 1. Argument Reduction for 0 < x <= 8 + * Since gamma(1+s)=s*gamma(s), for x in [0,8], we may + * reduce x to a number in [1.5,2.5] by + * lgamma(1+s) = log(s) + lgamma(s) + * for example, + * lgamma(7.3) = log(6.3) + lgamma(6.3) + * = log(6.3*5.3) + lgamma(5.3) + * = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3) + * 2. Polynomial approximation of lgamma around its + * minimun ymin=1.461632144968362245 to maintain monotonicity. + * On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use + * Let z = x-ymin; + * lgamma(x) = -1.214862905358496078218 + z^2*poly(z) + * 2. Rational approximation in the primary interval [2,3] + * We use the following approximation: + * s = x-2.0; + * lgamma(x) = 0.5*s + s*P(s)/Q(s) + * Our algorithms are based on the following observation + * + * zeta(2)-1 2 zeta(3)-1 3 + * lgamma(2+s) = s*(1-Euler) + --------- * s - --------- * s + ... + * 2 3 + * + * where Euler = 0.5771... is the Euler constant, which is very + * close to 0.5. + * + * 3. For x>=8, we have + * lgamma(x)~(x-0.5)log(x)-x+0.5*log(2pi)+1/(12x)-1/(360x**3)+.... + * (better formula: + * lgamma(x)~(x-0.5)*(log(x)-1)-.5*(log(2pi)-1) + ...) + * Let z = 1/x, then we approximation + * f(z) = lgamma(x) - (x-0.5)(log(x)-1) + * by + * 3 5 11 + * w = w0 + w1*z + w2*z + w3*z + ... + w6*z + * + * 4. For negative x, since (G is gamma function) + * -x*G(-x)*G(x) = pi/sin(pi*x), + * we have + * G(x) = pi/(sin(pi*x)*(-x)*G(-x)) + * since G(-x) is positive, sign(G(x)) = sign(sin(pi*x)) for x<0 + * Hence, for x<0, signgam = sign(sin(pi*x)) and + * lgamma(x) = log(|Gamma(x)|) + * = log(pi/(|x*sin(pi*x)|)) - lgamma(-x); + * Note: one should avoid compute pi*(-x) directly in the + * computation of sin(pi*(-x)). + * + * 5. Special Cases + * lgamma(2+s) ~ s*(1-Euler) for tiny s + * lgamma(1)=lgamma(2)=0 + * lgamma(x) ~ -log(x) for tiny x + * lgamma(0) = lgamma(inf) = inf + * lgamma(-integer) = +-inf + * + */ + +#define _GNU_SOURCE +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double __lgammal_r(long double x, int *sg) +{ + return __lgamma_r(x, sg); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +static const long double + pi = 3.14159265358979323846264L, + + /* lgam(1+x) = 0.5 x + x a(x)/b(x) + -0.268402099609375 <= x <= 0 + peak relative error 6.6e-22 */ + a0 = -6.343246574721079391729402781192128239938E2L, + a1 = 1.856560238672465796768677717168371401378E3L, + a2 = 2.404733102163746263689288466865843408429E3L, + a3 = 8.804188795790383497379532868917517596322E2L, + a4 = 1.135361354097447729740103745999661157426E2L, + a5 = 3.766956539107615557608581581190400021285E0L, + + b0 = 8.214973713960928795704317259806842490498E3L, + b1 = 1.026343508841367384879065363925870888012E4L, + b2 = 4.553337477045763320522762343132210919277E3L, + b3 = 8.506975785032585797446253359230031874803E2L, + b4 = 6.042447899703295436820744186992189445813E1L, + /* b5 = 1.000000000000000000000000000000000000000E0 */ + + tc = 1.4616321449683623412626595423257213284682E0L, + tf = -1.2148629053584961146050602565082954242826E-1, /* double precision + */ + /* tt = (tail of tf), i.e. tf + tt has extended precision. */ + tt = 3.3649914684731379602768989080467587736363E-18L, + /* lgam ( 1.4616321449683623412626595423257213284682E0 ) = +-1.2148629053584960809551455717769158215135617312999903886372437313313530E-1 */ + + /* lgam (x + tc) = tf + tt + x g(x)/h(x) + -0.230003726999612341262659542325721328468 <= x + <= 0.2699962730003876587373404576742786715318 + peak relative error 2.1e-21 */ + g0 = 3.645529916721223331888305293534095553827E-18L, + g1 = 5.126654642791082497002594216163574795690E3L, + g2 = 8.828603575854624811911631336122070070327E3L, + g3 = 5.464186426932117031234820886525701595203E3L, + g4 = 1.455427403530884193180776558102868592293E3L, + g5 = 1.541735456969245924860307497029155838446E2L, + g6 = 4.335498275274822298341872707453445815118E0L, + + h0 = 1.059584930106085509696730443974495979641E4L, + h1 = 2.147921653490043010629481226937850618860E4L, + h2 = 1.643014770044524804175197151958100656728E4L, + h3 = 5.869021995186925517228323497501767586078E3L, + h4 = 9.764244777714344488787381271643502742293E2L, + h5 = 6.442485441570592541741092969581997002349E1L, + /* h6 = 1.000000000000000000000000000000000000000E0 */ + + /* lgam (x+1) = -0.5 x + x u(x)/v(x) + -0.100006103515625 <= x <= 0.231639862060546875 + peak relative error 1.3e-21 */ + u0 = -8.886217500092090678492242071879342025627E1L, + u1 = 6.840109978129177639438792958320783599310E2L, + u2 = 2.042626104514127267855588786511809932433E3L, + u3 = 1.911723903442667422201651063009856064275E3L, + u4 = 7.447065275665887457628865263491667767695E2L, + u5 = 1.132256494121790736268471016493103952637E2L, + u6 = 4.484398885516614191003094714505960972894E0L, + + v0 = 1.150830924194461522996462401210374632929E3L, + v1 = 3.399692260848747447377972081399737098610E3L, + v2 = 3.786631705644460255229513563657226008015E3L, + v3 = 1.966450123004478374557778781564114347876E3L, + v4 = 4.741359068914069299837355438370682773122E2L, + v5 = 4.508989649747184050907206782117647852364E1L, + /* v6 = 1.000000000000000000000000000000000000000E0 */ + + /* lgam (x+2) = .5 x + x s(x)/r(x) + 0 <= x <= 1 + peak relative error 7.2e-22 */ + s0 = 1.454726263410661942989109455292824853344E6L, + s1 = -3.901428390086348447890408306153378922752E6L, + s2 = -6.573568698209374121847873064292963089438E6L, + s3 = -3.319055881485044417245964508099095984643E6L, + s4 = -7.094891568758439227560184618114707107977E5L, + s5 = -6.263426646464505837422314539808112478303E4L, + s6 = -1.684926520999477529949915657519454051529E3L, + + r0 = -1.883978160734303518163008696712983134698E7L, + r1 = -2.815206082812062064902202753264922306830E7L, + r2 = -1.600245495251915899081846093343626358398E7L, + r3 = -4.310526301881305003489257052083370058799E6L, + r4 = -5.563807682263923279438235987186184968542E5L, + r5 = -3.027734654434169996032905158145259713083E4L, + r6 = -4.501995652861105629217250715790764371267E2L, + /* r6 = 1.000000000000000000000000000000000000000E0 */ + + /* lgam(x) = ( x - 0.5 ) * log(x) - x + LS2PI + 1/x w(1/x^2) + x >= 8 + Peak relative error 1.51e-21 +w0 = LS2PI - 0.5 */ + w0 = 4.189385332046727417803e-1L, w1 = 8.333333333333331447505E-2L, + w2 = -2.777777777750349603440E-3L, w3 = 7.936507795855070755671E-4L, + w4 = -5.952345851765688514613E-4L, w5 = 8.412723297322498080632E-4L, + w6 = -1.880801938119376907179E-3L, w7 = 4.885026142432270781165E-3L; + +/* sin(pi*x) assuming x > 2^-1000, if sin(pi*x)==0 the sign is arbitrary */ +static long double sin_pi(long double x) +{ + int n; + + /* spurious inexact if odd int */ + x *= 0.5; + x = 2.0 * (x - floorl(x)); /* x mod 2.0 */ + + n = (int)(x * 4.0); + n = (n + 1) / 2; + x -= n * 0.5f; + x *= pi; + + switch (n) { + default: /* case 4: */ + case 0: + return __sinl(x, 0.0, 0); + case 1: + return __cosl(x, 0.0); + case 2: + return __sinl(-x, 0.0, 0); + case 3: + return -__cosl(x, 0.0); + } +} + +long double __lgammal_r(long double x, int *sg) +{ + long double t, y, z, nadj, p, p1, p2, q, r, w; + union ldshape u = { x }; + uint32_t ix = (u.i.se & 0x7fffU) << 16 | u.i.m >> 48; + int sign = u.i.se >> 15; + int i; + + *sg = 1; + + /* purge off +-inf, NaN, +-0, tiny and negative arguments */ + if (ix >= 0x7fff0000) + return x * x; + if (ix < 0x3fc08000) { /* |x|<2**-63, return -log(|x|) */ + if (sign) { + *sg = -1; + x = -x; + } + return -logl(x); + } + if (sign) { + x = -x; + t = sin_pi(x); + if (t == 0.0) + return 1.0 / (x - x); /* -integer */ + if (t > 0.0) + *sg = -1; + else + t = -t; + nadj = logl(pi / (t * x)); + } + + /* purge off 1 and 2 (so the sign is ok with downward rounding) */ + if ((ix == 0x3fff8000 || ix == 0x40008000) && u.i.m == 0) { + r = 0; + } else if (ix < 0x40008000) { /* x < 2.0 */ + if (ix <= 0x3ffee666) { /* 8.99993896484375e-1 */ + /* lgamma(x) = lgamma(x+1) - log(x) */ + r = -logl(x); + if (ix >= 0x3ffebb4a) { /* 7.31597900390625e-1 */ + y = x - 1.0; + i = 0; + } else if (ix >= 0x3ffced33) { /* 2.31639862060546875e-1 + */ + y = x - (tc - 1.0); + i = 1; + } else { /* x < 0.23 */ + y = x; + i = 2; + } + } else { + r = 0.0; + if (ix >= 0x3fffdda6) { /* 1.73162841796875 */ + /* [1.7316,2] */ + y = x - 2.0; + i = 0; + } else if (ix >= 0x3fff9da6) { /* 1.23162841796875 */ + /* [1.23,1.73] */ + y = x - tc; + i = 1; + } else { + /* [0.9, 1.23] */ + y = x - 1.0; + i = 2; + } + } + switch (i) { + case 0: + p1 = a0 + + y * (a1 + y * (a2 + y * (a3 + y * (a4 + y * a5)))); + p2 = b0 + y * (b1 + y * (b2 + y * (b3 + y * (b4 + y)))); + r += 0.5 * y + y * p1 / p2; + break; + case 1: + p1 = g0 + + y * (g1 + + y * (g2 + + y * (g3 + y * (g4 + y * (g5 + y * g6))))); + p2 = h0 + + y * (h1 + + y * (h2 + + y * (h3 + y * (h4 + y * (h5 + y))))); + p = tt + y * p1 / p2; + r += (tf + p); + break; + case 2: + p1 = y * + (u0 + + y * (u1 + + y * (u2 + + y * (u3 + + y * (u4 + y * (u5 + y * u6)))))); + p2 = v0 + + y * (v1 + + y * (v2 + + y * (v3 + y * (v4 + y * (v5 + y))))); + r += (-0.5 * y + p1 / p2); + } + } else if (ix < 0x40028000) { /* 8.0 */ + /* x < 8.0 */ + i = (int)x; + y = x - (double)i; + p = y * + (s0 + + y * (s1 + + y * (s2 + y * (s3 + y * (s4 + y * (s5 + y * s6)))))); + q = r0 + + y * (r1 + + y * (r2 + + y * (r3 + y * (r4 + y * (r5 + y * (r6 + y)))))); + r = 0.5 * y + p / q; + z = 1.0; + /* lgamma(1+s) = log(s) + lgamma(s) */ + switch (i) { + case 7: + z *= (y + 6.0); /* FALLTHRU */ + case 6: + z *= (y + 5.0); /* FALLTHRU */ + case 5: + z *= (y + 4.0); /* FALLTHRU */ + case 4: + z *= (y + 3.0); /* FALLTHRU */ + case 3: + z *= (y + 2.0); /* FALLTHRU */ + r += logl(z); + break; + } + } else if (ix < 0x40418000) { /* 2^66 */ + /* 8.0 <= x < 2**66 */ + t = logl(x); + z = 1.0 / x; + y = z * z; + w = w0 + + z * (w1 + + y * (w2 + + y * (w3 + + y * (w4 + y * (w5 + y * (w6 + y * w7)))))); + r = (x - 0.5) * (t - 1.0) + w; + } else /* 2**66 <= x <= inf */ + r = x * (logl(x) - 1.0); + if (sign) + r = nadj - r; + return r; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double __lgammal_r(long double x, int *sg) +{ + return __lgamma_r(x, sg); +} +#endif + +long double lgammal(long double x) +{ + return __lgammal_r(x, &__signgam); +} + +weak_alias(__lgammal_r, lgammal_r); diff --git a/lib/libm/libm.a b/lib/libm/libm.a Binary files differnew file mode 100644 index 00000000..6a4a03c3 --- /dev/null +++ b/lib/libm/libm.a diff --git a/lib/libm/libm.h b/lib/libm/libm.h new file mode 100644 index 00000000..6f57c128 --- /dev/null +++ b/lib/libm/libm.h @@ -0,0 +1,351 @@ +#ifndef _LIBM_H +#define _LIBM_H + +#include <asm/fpmath.h> +#include <float.h> +#include <math.h> +#include <stdint.h> + +#define hidden __attribute__((visibility("hidden"))) + +#define __PDP_ENDIAN 3412 + +#define BIG_ENDIAN __ORDER_BIG_ENDIAN__ +#define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__ +#define PDP_ENDIAN __ORDER_PDP_ENDIAN +#define BYTE_ORDER __BYTE_ORDER__ +#define __BYTE_ORDER __BYTE_ORDER__ +#define __LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__ + +static __inline uint16_t __bswap16(uint16_t __x) +{ + return __x << 8 | __x >> 8; +} + +static __inline uint32_t __bswap32(uint32_t __x) +{ + return __x >> 24 | (__x >> 8 & 0xff00) | (__x << 8 & 0xff0000) | + __x << 24; +} + +static __inline uint64_t __bswap64(uint64_t __x) +{ + return (__bswap32(__x) + 0ULL) << 32 | __bswap32(__x >> 32); +} + +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +#define htobe16(x) __bswap16(x) +#define be16toh(x) __bswap16(x) +#define htobe32(x) __bswap32(x) +#define be32toh(x) __bswap32(x) +#define htobe64(x) __bswap64(x) +#define be64toh(x) __bswap64(x) +#define htole16(x) (uint16_t)(x) +#define le16toh(x) (uint16_t)(x) +#define htole32(x) (uint32_t)(x) +#define le32toh(x) (uint32_t)(x) +#define htole64(x) (uint64_t)(x) +#define le64toh(x) (uint64_t)(x) +#else +#define htobe16(x) (uint16_t)(x) +#define be16toh(x) (uint16_t)(x) +#define htobe32(x) (uint32_t)(x) +#define be32toh(x) (uint32_t)(x) +#define htobe64(x) (uint64_t)(x) +#define be64toh(x) (uint64_t)(x) +#define htole16(x) __bswap16(x) +#define le16toh(x) __bswap16(x) +#define htole32(x) __bswap32(x) +#define le32toh(x) __bswap32(x) +#define htole64(x) __bswap64(x) +#define le64toh(x) __bswap64(x) +#endif + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && \ + __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +union ldshape { + long double f; + struct { + uint64_t m; + uint16_t se; + } i; +}; +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && \ + __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +/* This is the m68k variant of 80-bit long double, and this definition only + * works on archs where the alignment requirement of uint64_t is <= 4. */ +union ldshape { + long double f; + struct { + uint16_t se; + uint16_t pad; + uint64_t m; + } i; +}; +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 && \ + __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +union ldshape { + long double f; + struct { + uint64_t lo; + uint32_t mid; + uint16_t top; + uint16_t se; + } i; + struct { + uint64_t lo; + uint64_t hi; + } i2; +}; +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 && \ + __BYTE_ORDER == __BIG_ENDIAN +union ldshape { + long double f; + struct { + uint16_t se; + uint16_t top; + uint32_t mid; + uint64_t lo; + } i; + struct { + uint64_t hi; + uint64_t lo; + } i2; +}; +#else +#error Unsupported long double representation +#endif + +/* Support non-nearest rounding mode. */ +#define WANT_ROUNDING 1 +/* Support signaling NaNs. */ +#define WANT_SNAN 0 + +#if WANT_SNAN +#error SNaN is unsupported +#else +#define issignalingf_inline(x) 0 +#define issignaling_inline(x) 0 +#endif + +#ifndef TOINT_INTRINSICS +#define TOINT_INTRINSICS 0 +#endif + +#if TOINT_INTRINSICS +/* Round x to nearest int in all rounding modes, ties have to be rounded + consistently with converttoint so the results match. If the result + would be outside of [-2^31, 2^31-1] then the semantics is unspecified. */ +static double_t roundtoint(double_t); + +/* Convert x to nearest int in all rounding modes, ties have to be rounded + consistently with roundtoint. If the result is not representible in an + int32_t then the semantics is unspecified. */ +static int32_t converttoint(double_t); +#endif + +/* Helps static branch prediction so hot path can be better optimized. */ +#ifdef __GNUC__ +#define predict_true(x) __builtin_expect(!!(x), 1) +#define predict_false(x) __builtin_expect(x, 0) +#else +#define predict_true(x) (x) +#define predict_false(x) (x) +#endif + +/* Evaluate an expression as the specified type. With standard excess + precision handling a type cast or assignment is enough (with + -ffloat-store an assignment is required, in old compilers argument + passing and return statement may not drop excess precision). */ + +static inline float eval_as_float(float x) +{ + float y = x; + return y; +} + +static inline double eval_as_double(double x) +{ + double y = x; + return y; +} + +/* fp_barrier returns its input, but limits code transformations + as if it had a side-effect (e.g. observable io) and returned + an arbitrary value. */ + +#ifndef fp_barrierf +#define fp_barrierf fp_barrierf +static inline float fp_barrierf(float x) +{ + volatile float y = x; + return y; +} +#endif + +#ifndef fp_barrier +#define fp_barrier fp_barrier +static inline double fp_barrier(double x) +{ + volatile double y = x; + return y; +} +#endif + +#ifndef fp_barrierl +#define fp_barrierl fp_barrierl +static inline long double fp_barrierl(long double x) +{ + volatile long double y = x; + return y; +} +#endif + +/* fp_force_eval ensures that the input value is computed when that's + otherwise unused. To prevent the constant folding of the input + expression, an additional fp_barrier may be needed or a compilation + mode that does so (e.g. -frounding-math in gcc). Then it can be + used to evaluate an expression for its fenv side-effects only. */ + +#ifndef fp_force_evalf +#define fp_force_evalf fp_force_evalf +static inline void fp_force_evalf(float x) +{ + (void)x; +} +#endif + +#ifndef fp_force_eval +#define fp_force_eval fp_force_eval +static inline void fp_force_eval(double x) +{ + (void)x; +} +#endif + +#ifndef fp_force_evall +#define fp_force_evall fp_force_evall +static inline void fp_force_evall(long double x) +{ + (void)x; +} +#endif + +#define FORCE_EVAL(x) \ + do { \ + if (sizeof(x) == sizeof(float)) { \ + fp_force_evalf(x); \ + } else if (sizeof(x) == sizeof(double)) { \ + fp_force_eval(x); \ + } else { \ + fp_force_evall(x); \ + } \ + } while (0) + +#define asuint(f) \ + ((union { \ + float _f; \ + uint32_t _i; \ + }){ f }) \ + ._i +#define asfloat(i) \ + ((union { \ + uint32_t _i; \ + float _f; \ + }){ i }) \ + ._f +#define asuint64(f) \ + ((union { \ + double _f; \ + uint64_t _i; \ + }){ f }) \ + ._i +#define asdouble(i) \ + ((union { \ + uint64_t _i; \ + double _f; \ + }){ i }) \ + ._f + +#define EXTRACT_WORDS(hi, lo, d) \ + do { \ + uint64_t __u = asuint64(d); \ + (hi) = __u >> 32; \ + (lo) = (uint32_t)__u; \ + } while (0) + +#define GET_HIGH_WORD(hi, d) \ + do { \ + (hi) = asuint64(d) >> 32; \ + } while (0) + +#define GET_LOW_WORD(lo, d) \ + do { \ + (lo) = (uint32_t)asuint64(d); \ + } while (0) + +#define INSERT_WORDS(d, hi, lo) \ + do { \ + (d) = asdouble(((uint64_t)(hi) << 32) | (uint32_t)(lo)); \ + } while (0) + +#define SET_HIGH_WORD(d, hi) INSERT_WORDS(d, hi, (uint32_t)asuint64(d)) + +#define SET_LOW_WORD(d, lo) INSERT_WORDS(d, asuint64(d) >> 32, lo) + +#define GET_FLOAT_WORD(w, d) \ + do { \ + (w) = asuint(d); \ + } while (0) + +#define SET_FLOAT_WORD(d, w) \ + do { \ + (d) = asfloat(w); \ + } while (0) + +hidden int __rem_pio2_large(double *, double *, int, int, int); + +hidden int __rem_pio2(double, double *); +hidden double __sin(double, double, int); +hidden double __cos(double, double); +hidden double __tan(double, double, int); +hidden double __expo2(double, double); + +hidden int __rem_pio2f(float, double *); +hidden float __sindf(double); +hidden float __cosdf(double); +hidden float __tandf(double, int); +hidden float __expo2f(float, float); + +hidden int __rem_pio2l(long double, long double *); +hidden long double __sinl(long double, long double, int); +hidden long double __cosl(long double, long double); +hidden long double __tanl(long double, long double, int); + +hidden long double __polevll(long double, const long double *, int); +hidden long double __p1evll(long double, const long double *, int); + +extern int __signgam; +hidden double __lgamma_r(double, int *); +hidden float __lgammaf_r(float, int *); + +/* error handling functions */ +hidden float __math_xflowf(uint32_t, float); +hidden float __math_uflowf(uint32_t); +hidden float __math_oflowf(uint32_t); +hidden float __math_divzerof(uint32_t); +hidden float __math_invalidf(float); +hidden double __math_xflow(uint32_t, double); +hidden double __math_uflow(uint32_t); +hidden double __math_oflow(uint32_t); +hidden double __math_divzero(uint32_t); +hidden double __math_invalid(double); +#if LDBL_MANT_DIG != DBL_MANT_DIG +hidden long double __math_invalidl(long double); +#endif + +#define weak_alias(old, new) \ + extern __typeof(old) new __attribute__((__weak__, __alias__(#old))) + +#endif diff --git a/lib/libm/llrint.c b/lib/libm/llrint.c new file mode 100644 index 00000000..4f583ae5 --- /dev/null +++ b/lib/libm/llrint.c @@ -0,0 +1,8 @@ +#include <math.h> + +/* uses LLONG_MAX > 2^53, see comments in lrint.c */ + +long long llrint(double x) +{ + return rint(x); +} diff --git a/lib/libm/llrintf.c b/lib/libm/llrintf.c new file mode 100644 index 00000000..96949a00 --- /dev/null +++ b/lib/libm/llrintf.c @@ -0,0 +1,8 @@ +#include <math.h> + +/* uses LLONG_MAX > 2^24, see comments in lrint.c */ + +long long llrintf(float x) +{ + return rintf(x); +} diff --git a/lib/libm/llrintl.c b/lib/libm/llrintl.c new file mode 100644 index 00000000..05f4bc82 --- /dev/null +++ b/lib/libm/llrintl.c @@ -0,0 +1,35 @@ +#include <limits.h> +#include <fenv.h> +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long long llrintl(long double x) +{ + return llrint(x); +} +#elif defined(FE_INEXACT) +/* +see comments in lrint.c + +Note that if LLONG_MAX == 0x7fffffffffffffff && LDBL_MANT_DIG == 64 +then x == 2**63 - 0.5 is the only input that overflows and +raises inexact (with tonearest or upward rounding mode) +*/ +long long llrintl(long double x) +{ +#pragma STDC FENV_ACCESS ON + int e; + + e = fetestexcept(FE_INEXACT); + x = rintl(x); + if (!e && (x > LLONG_MAX || x < LLONG_MIN)) + feclearexcept(FE_INEXACT); + /* conversion */ + return x; +} +#else +long long llrintl(long double x) +{ + return rintl(x); +} +#endif diff --git a/lib/libm/llround.c b/lib/libm/llround.c new file mode 100644 index 00000000..4d94787d --- /dev/null +++ b/lib/libm/llround.c @@ -0,0 +1,6 @@ +#include <math.h> + +long long llround(double x) +{ + return round(x); +} diff --git a/lib/libm/llroundf.c b/lib/libm/llroundf.c new file mode 100644 index 00000000..19eb77ee --- /dev/null +++ b/lib/libm/llroundf.c @@ -0,0 +1,6 @@ +#include <math.h> + +long long llroundf(float x) +{ + return roundf(x); +} diff --git a/lib/libm/llroundl.c b/lib/libm/llroundl.c new file mode 100644 index 00000000..2c2ee5ec --- /dev/null +++ b/lib/libm/llroundl.c @@ -0,0 +1,6 @@ +#include <math.h> + +long long llroundl(long double x) +{ + return roundl(x); +} diff --git a/lib/libm/log.c b/lib/libm/log.c new file mode 100644 index 00000000..38c0ccc4 --- /dev/null +++ b/lib/libm/log.c @@ -0,0 +1,112 @@ +/* + * Double-precision log(x) function. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "log_data.h" + +#define T __log_data.tab +#define T2 __log_data.tab2 +#define B __log_data.poly1 +#define A __log_data.poly +#define Ln2hi __log_data.ln2hi +#define Ln2lo __log_data.ln2lo +#define N (1 << LOG_TABLE_BITS) +#define OFF 0x3fe6000000000000 + +/* Top 16 bits of a double. */ +static inline uint32_t top16(double x) +{ + return asuint64(x) >> 48; +} + +double log(double x) +{ + double_t w, z, r, r2, r3, y, invc, logc, kd, hi, lo; + uint64_t ix, iz, tmp; + uint32_t top; + int k, i; + + ix = asuint64(x); + top = top16(x); +#define LO asuint64(1.0 - 0x1p-4) +#define HI asuint64(1.0 + 0x1.09p-4) + if (predict_false(ix - LO < HI - LO)) { + /* Handle close to 1.0 inputs separately. */ + /* Fix sign of zero with downward rounding when x==1. */ + if (WANT_ROUNDING && predict_false(ix == asuint64(1.0))) + return 0; + r = x - 1.0; + r2 = r * r; + r3 = r * r2; + y = r3 * + (B[1] + r * B[2] + r2 * B[3] + + r3 * (B[4] + r * B[5] + r2 * B[6] + + r3 * (B[7] + r * B[8] + r2 * B[9] + r3 * B[10]))); + /* Worst-case error is around 0.507 ULP. */ + w = r * 0x1p27; + double_t rhi = r + w - w; + double_t rlo = r - rhi; + w = rhi * rhi * B[0]; /* B[0] == -0.5. */ + hi = r + w; + lo = r - hi + w; + lo += B[0] * rlo * (rhi + r); + y += lo; + y += hi; + return eval_as_double(y); + } + if (predict_false(top - 0x0010 >= 0x7ff0 - 0x0010)) { + /* x < 0x1p-1022 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzero(1); + if (ix == asuint64(INFINITY)) /* log(inf) == inf. */ + return x; + if ((top & 0x8000) || (top & 0x7ff0) == 0x7ff0) + return __math_invalid(x); + /* x is subnormal, normalize it. */ + ix = asuint64(x * 0x1p52); + ix -= 52ULL << 52; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (52 - LOG_TABLE_BITS)) % N; + k = (int64_t)tmp >> 52; /* arithmetic shift */ + iz = ix - (tmp & 0xfffULL << 52); + invc = T[i].invc; + logc = T[i].logc; + z = asdouble(iz); + + /* log(x) = log1p(z/c-1) + log(c) + k*Ln2. */ + /* r ~= z/c - 1, |r| < 1/(2*N). */ +#if __FP_FAST_FMA + /* rounding error: 0x1p-55/N. */ + r = __builtin_fma(z, invc, -1.0); +#else + /* rounding error: 0x1p-55/N + 0x1p-66. */ + r = (z - T2[i].chi - T2[i].clo) * invc; +#endif + kd = (double_t)k; + + /* hi + lo = r + log(c) + k*Ln2. */ + w = kd * Ln2hi + logc; + hi = w + r; + lo = w - hi + r + kd * Ln2lo; + + /* log(x) = lo + (log1p(r) - r) + hi. */ + r2 = r * r; /* rounding error: 0x1p-54/N^2. */ + /* Worst case error if |y| > 0x1p-5: + 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma) + Worst case error if |y| > 0x1p-4: + 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ + y = lo + r2 * A[0] + + r * r2 * (A[1] + r * A[2] + r2 * (A[3] + r * A[4])) + hi; + return eval_as_double(y); +} diff --git a/lib/libm/log10.c b/lib/libm/log10.c new file mode 100644 index 00000000..003df818 --- /dev/null +++ b/lib/libm/log10.c @@ -0,0 +1,104 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_log10.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * Return the base 10 logarithm of x. See log.c for most comments. + * + * Reduce x to 2^k (1+f) and calculate r = log(1+f) - f + f*f/2 + * as in log.c, then combine and scale in extra precision: + * log10(x) = (f - f*f/2 + r)/log(10) + k*log10(2) + */ + +#include <math.h> +#include <stdint.h> + +static const double ivln10hi = 4.34294481878168880939e-01, /* 0x3fdbcb7b, + 0x15200000 */ + ivln10lo = 2.50829467116452752298e-11, /* 0x3dbb9438, 0xca9aadd5 */ + log10_2hi = 3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */ + log10_2lo = 3.69423907715893078616e-13, /* 0x3D59FEF3, 0x11F12B36 */ + Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */ + Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */ + Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */ + Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */ + Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */ + Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */ + Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ + +double log10(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + double_t hfsq, f, s, z, R, w, t1, t2, dk, y, hi, lo, val_hi, val_lo; + uint32_t hx; + int k; + + hx = u.i >> 32; + k = 0; + if (hx < 0x00100000 || hx >> 31) { + if (u.i << 1 == 0) + return -1 / (x * x); /* log(+-0)=-inf */ + if (hx >> 31) + return (x - x) / 0.0; /* log(-#) = NaN */ + /* subnormal number, scale x up */ + k -= 54; + x *= 0x1p54; + u.f = x; + hx = u.i >> 32; + } else if (hx >= 0x7ff00000) { + return x; + } else if (hx == 0x3ff00000 && u.i << 32 == 0) + return 0; + + /* reduce x into [sqrt(2)/2, sqrt(2)] */ + hx += 0x3ff00000 - 0x3fe6a09e; + k += (int)(hx >> 20) - 0x3ff; + hx = (hx & 0x000fffff) + 0x3fe6a09e; + u.i = (uint64_t)hx << 32 | (u.i & 0xffffffff); + x = u.f; + + f = x - 1.0; + hfsq = 0.5 * f * f; + s = f / (2.0 + f); + z = s * s; + w = z * z; + t1 = w * (Lg2 + w * (Lg4 + w * Lg6)); + t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7))); + R = t2 + t1; + + /* See log2.c for details. */ + /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */ + hi = f - hfsq; + u.f = hi; + u.i &= (uint64_t)-1 << 32; + hi = u.f; + lo = f - hi - hfsq + s * (hfsq + R); + + /* val_hi+val_lo ~ log10(1+f) + k*log10(2) */ + val_hi = hi * ivln10hi; + dk = k; + y = dk * log10_2hi; + val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi; + + /* + * Extra precision in for adding y is not strictly needed + * since there is no very large cancellation near x = sqrt(2) or + * x = 1/sqrt(2), but we do it anyway since it costs little on CPUs + * with some parallelism and it reduces the error for many args. + */ + w = y + val_hi; + val_lo += (y - w) + val_hi; + val_hi = w; + + return val_lo + val_hi; +} diff --git a/lib/libm/log10f.c b/lib/libm/log10f.c new file mode 100644 index 00000000..c4f9e2ca --- /dev/null +++ b/lib/libm/log10f.c @@ -0,0 +1,81 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_log10f.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * See comments in log10.c. + */ + +#include <math.h> +#include <stdint.h> + +static const float ivln10hi = 4.3432617188e-01, /* 0x3ede6000 */ + ivln10lo = -3.1689971365e-05, /* 0xb804ead9 */ + log10_2hi = 3.0102920532e-01, /* 0x3e9a2080 */ + log10_2lo = 7.9034151668e-07, /* 0x355427db */ + /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). + */ + Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */ + Lg2 = 0xccce13.0p-25, /* 0.40000972152 */ + Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */ + Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */ + +float log10f(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + float_t hfsq, f, s, z, R, w, t1, t2, dk, hi, lo; + uint32_t ix; + int k; + + ix = u.i; + k = 0; + if (ix < 0x00800000 || ix >> 31) { /* x < 2**-126 */ + if (ix << 1 == 0) + return -1 / (x * x); /* log(+-0)=-inf */ + if (ix >> 31) + return (x - x) / 0.0f; /* log(-#) = NaN */ + /* subnormal number, scale up x */ + k -= 25; + x *= 0x1p25f; + u.f = x; + ix = u.i; + } else if (ix >= 0x7f800000) { + return x; + } else if (ix == 0x3f800000) + return 0; + + /* reduce x into [sqrt(2)/2, sqrt(2)] */ + ix += 0x3f800000 - 0x3f3504f3; + k += (int)(ix >> 23) - 0x7f; + ix = (ix & 0x007fffff) + 0x3f3504f3; + u.i = ix; + x = u.f; + + f = x - 1.0f; + s = f / (2.0f + f); + z = s * s; + w = z * z; + t1 = w * (Lg2 + w * Lg4); + t2 = z * (Lg1 + w * Lg3); + R = t2 + t1; + hfsq = 0.5f * f * f; + + hi = f - hfsq; + u.f = hi; + u.i &= 0xfffff000; + hi = u.f; + lo = f - hi - hfsq + s * (hfsq + R); + dk = k; + return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + + hi * ivln10hi + dk * log10_2hi; +} diff --git a/lib/libm/log10l.c b/lib/libm/log10l.c new file mode 100644 index 00000000..f8546cdb --- /dev/null +++ b/lib/libm/log10l.c @@ -0,0 +1,185 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_log10l.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Common logarithm, long double precision + * + * + * SYNOPSIS: + * + * long double x, y, log10l(); + * + * y = log10l( x ); + * + * + * DESCRIPTION: + * + * Returns the base 10 logarithm of x. + * + * The argument is separated into its exponent and fractional + * parts. If the exponent is between -1 and +1, the logarithm + * of the fraction is approximated by + * + * log(1+x) = x - 0.5 x**2 + x**3 P(x)/Q(x). + * + * Otherwise, setting z = 2(x-1)/x+1), + * + * log(x) = z + z**3 P(z)/Q(z). + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE 0.5, 2.0 30000 9.0e-20 2.6e-20 + * IEEE exp(+-10000) 30000 6.0e-20 2.3e-20 + * + * In the tests over the interval exp(+-10000), the logarithms + * of the random arguments were uniformly distributed over + * [-10000, +10000]. + * + * ERROR MESSAGES: + * + * log singularity: x = 0; returns MINLOG + * log domain: x < 0; returns MINLOG + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double log10l(long double x) +{ + return log10(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +/* Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 6.2e-22 + */ +static const long double P[] = { + 4.9962495940332550844739E-1L, 1.0767376367209449010438E1L, + 7.7671073698359539859595E1L, 2.5620629828144409632571E2L, + 4.2401812743503691187826E2L, 3.4258224542413922935104E2L, + 1.0747524399916215149070E2L, +}; +static const long double Q[] = { + /* 1.0000000000000000000000E0,*/ + 2.3479774160285863271658E1L, 1.9444210022760132894510E2L, + 7.7952888181207260646090E2L, 1.6911722418503949084863E3L, + 2.0307734695595183428202E3L, 1.2695660352705325274404E3L, + 3.2242573199748645407652E2L, +}; + +/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2), + * where z = 2(x-1)/(x+1) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 6.16e-22 + */ +static const long double R[4] = { + 1.9757429581415468984296E-3L, + -7.1990767473014147232598E-1L, + 1.0777257190312272158094E1L, + -3.5717684488096787370998E1L, +}; +static const long double S[4] = { + /* 1.00000000000000000000E0L,*/ + -2.6201045551331104417768E1L, + 1.9361891836232102174846E2L, + -4.2861221385716144629696E2L, +}; +/* log10(2) */ +#define L102A 0.3125L +#define L102B -1.1470004336018804786261e-2L +/* log10(e) */ +#define L10EA 0.5L +#define L10EB -6.5705518096748172348871e-2L + +#define SQRTH 0.70710678118654752440L + +long double log10l(long double x) +{ + long double y, z; + int e; + + if (isnan(x)) + return x; + if (x <= 0.0) { + if (x == 0.0) + return -1.0 / (x * x); + return (x - x) / 0.0; + } + if (x == INFINITY) + return INFINITY; + /* separate mantissa from exponent */ + /* Note, frexp is used so that denormal numbers + * will be handled properly. + */ + x = frexpl(x, &e); + + /* logarithm using log(x) = z + z**3 P(z)/Q(z), + * where z = 2(x-1)/x+1) + */ + if (e > 2 || e < -2) { + if (x < SQRTH) { /* 2(2x-1)/(2x+1) */ + e -= 1; + z = x - 0.5; + y = 0.5 * z + 0.5; + } else { /* 2 (x-1)/(x+1) */ + z = x - 0.5; + z -= 0.5; + y = 0.5 * x + 0.5; + } + x = z / y; + z = x * x; + y = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3)); + goto done; + } + + /* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */ + if (x < SQRTH) { + e -= 1; + x = 2.0 * x - 1.0; + } else { + x = x - 1.0; + } + z = x * x; + y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 7)); + y = y - 0.5 * z; + +done: + /* Multiply log of fraction by log10(e) + * and base 2 exponent by log10(2). + * + * ***CAUTION*** + * + * This sequence of operations is critical and it may + * be horribly defeated by some compiler optimizers. + */ + z = y * (L10EB); + z += x * (L10EB); + z += e * (L102B); + z += y * (L10EA); + z += x * (L10EA); + z += e * (L102A); + return z; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double log10l(long double x) +{ + return log10(x); +} +#endif diff --git a/lib/libm/log1p.c b/lib/libm/log1p.c new file mode 100644 index 00000000..1667260a --- /dev/null +++ b/lib/libm/log1p.c @@ -0,0 +1,124 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_log1p.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* double log1p(double x) + * Return the natural logarithm of 1+x. + * + * Method : + * 1. Argument Reduction: find k and f such that + * 1+x = 2^k * (1+f), + * where sqrt(2)/2 < 1+f < sqrt(2) . + * + * Note. If k=0, then f=x is exact. However, if k!=0, then f + * may not be representable exactly. In that case, a correction + * term is need. Let u=1+x rounded. Let c = (1+x)-u, then + * log(1+x) - log(u) ~ c/u. Thus, we proceed to compute log(u), + * and add back the correction term c/u. + * (Note: when x > 2**53, one can simply return log(x)) + * + * 2. Approximation of log(1+f): See log.c + * + * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c + * + * Special cases: + * log1p(x) is NaN with signal if x < -1 (including -INF) ; + * log1p(+INF) is +INF; log1p(-1) is -INF with signal; + * log1p(NaN) is that NaN with no signal. + * + * Accuracy: + * according to an error analysis, the error is always less than + * 1 ulp (unit in the last place). + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + * + * Note: Assuming log() return accurate answer, the following + * algorithm can be used to compute log1p(x) to within a few ULP: + * + * u = 1+x; + * if(u==1.0) return x ; else + * return log(u)*(x/(u-1.0)); + * + * See HP-15C Advanced Functions Handbook, p.193. + */ + +#include "libm.h" + +static const double ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */ + ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */ + Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */ + Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */ + Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */ + Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */ + Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */ + Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */ + Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ + +double log1p(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + double_t hfsq, f, c, s, z, R, w, t1, t2, dk; + uint32_t hx, hu; + int k; + + hx = u.i >> 32; + k = 1; + if (hx < 0x3fda827a || hx >> 31) { /* 1+x < sqrt(2)+ */ + if (hx >= 0xbff00000) { /* x <= -1.0 */ + if (x == -1) + return x / 0.0; /* log1p(-1) = -inf */ + return (x - x) / 0.0; /* log1p(x<-1) = NaN */ + } + if (hx << 1 < 0x3ca00000 << 1) { /* |x| < 2**-53 */ + /* underflow if subnormal */ + if ((hx & 0x7ff00000) == 0) + FORCE_EVAL((float)x); + return x; + } + if (hx <= 0xbfd2bec4) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */ + k = 0; + c = 0; + f = x; + } + } else if (hx >= 0x7ff00000) + return x; + if (k) { + u.f = 1 + x; + hu = u.i >> 32; + hu += 0x3ff00000 - 0x3fe6a09e; + k = (int)(hu >> 20) - 0x3ff; + /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ + if (k < 54) { + c = k >= 2 ? 1 - (u.f - x) : x - (u.f - 1); + c /= u.f; + } else + c = 0; + /* reduce u into [sqrt(2)/2, sqrt(2)] */ + hu = (hu & 0x000fffff) + 0x3fe6a09e; + u.i = (uint64_t)hu << 32 | (u.i & 0xffffffff); + f = u.f - 1; + } + hfsq = 0.5 * f * f; + s = f / (2.0 + f); + z = s * s; + w = z * z; + t1 = w * (Lg2 + w * (Lg4 + w * Lg6)); + t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7))); + R = t2 + t1; + dk = k; + return s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi; +} diff --git a/lib/libm/log1pf.c b/lib/libm/log1pf.c new file mode 100644 index 00000000..bdd702d1 --- /dev/null +++ b/lib/libm/log1pf.c @@ -0,0 +1,80 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_log1pf.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +static const float ln2_hi = 6.9313812256e-01, /* 0x3f317180 */ + ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */ + /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). + */ + Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */ + Lg2 = 0xccce13.0p-25, /* 0.40000972152 */ + Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */ + Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */ + +float log1pf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + float_t hfsq, f, c, s, z, R, w, t1, t2, dk; + uint32_t ix, iu; + int k; + + ix = u.i; + k = 1; + if (ix < 0x3ed413d0 || ix >> 31) { /* 1+x < sqrt(2)+ */ + if (ix >= 0xbf800000) { /* x <= -1.0 */ + if (x == -1) + return x / 0.0f; /* log1p(-1)=+inf */ + return (x - x) / 0.0f; /* log1p(x<-1)=NaN */ + } + if (ix << 1 < 0x33800000 << 1) { /* |x| < 2**-24 */ + /* underflow if subnormal */ + if ((ix & 0x7f800000) == 0) + FORCE_EVAL(x * x); + return x; + } + if (ix <= 0xbe95f619) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */ + k = 0; + c = 0; + f = x; + } + } else if (ix >= 0x7f800000) + return x; + if (k) { + u.f = 1 + x; + iu = u.i; + iu += 0x3f800000 - 0x3f3504f3; + k = (int)(iu >> 23) - 0x7f; + /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ + if (k < 25) { + c = k >= 2 ? 1 - (u.f - x) : x - (u.f - 1); + c /= u.f; + } else + c = 0; + /* reduce u into [sqrt(2)/2, sqrt(2)] */ + iu = (iu & 0x007fffff) + 0x3f3504f3; + u.i = iu; + f = u.f - 1; + } + s = f / (2.0f + f); + z = s * s; + w = z * z; + t1 = w * (Lg2 + w * Lg4); + t2 = z * (Lg1 + w * Lg3); + R = t2 + t1; + hfsq = 0.5f * f * f; + dk = k; + return s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi; +} diff --git a/lib/libm/log1pl.c b/lib/libm/log1pl.c new file mode 100644 index 00000000..6021ccf4 --- /dev/null +++ b/lib/libm/log1pl.c @@ -0,0 +1,171 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/s_log1pl.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Relative error logarithm + * Natural logarithm of 1+x, long double precision + * + * + * SYNOPSIS: + * + * long double x, y, log1pl(); + * + * y = log1pl( x ); + * + * + * DESCRIPTION: + * + * Returns the base e (2.718...) logarithm of 1+x. + * + * The argument 1+x is separated into its exponent and fractional + * parts. If the exponent is between -1 and +1, the logarithm + * of the fraction is approximated by + * + * log(1+x) = x - 0.5 x^2 + x^3 P(x)/Q(x). + * + * Otherwise, setting z = 2(x-1)/x+1), + * + * log(x) = z + z^3 P(z)/Q(z). + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE -1.0, 9.0 100000 8.2e-20 2.5e-20 + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double log1pl(long double x) +{ + return log1p(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +/* Coefficients for log(1+x) = x - x^2 / 2 + x^3 P(x)/Q(x) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 2.32e-20 + */ +static const long double P[] = { + 4.5270000862445199635215E-5L, 4.9854102823193375972212E-1L, + 6.5787325942061044846969E0L, 2.9911919328553073277375E1L, + 6.0949667980987787057556E1L, 5.7112963590585538103336E1L, + 2.0039553499201281259648E1L, +}; +static const long double Q[] = { + /* 1.0000000000000000000000E0,*/ + 1.5062909083469192043167E1L, 8.3047565967967209469434E1L, + 2.2176239823732856465394E2L, 3.0909872225312059774938E2L, + 2.1642788614495947685003E2L, 6.0118660497603843919306E1L, +}; + +/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2), + * where z = 2(x-1)/(x+1) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 6.16e-22 + */ +static const long double R[4] = { + 1.9757429581415468984296E-3L, + -7.1990767473014147232598E-1L, + 1.0777257190312272158094E1L, + -3.5717684488096787370998E1L, +}; +static const long double S[4] = { + /* 1.00000000000000000000E0L,*/ + -2.6201045551331104417768E1L, + 1.9361891836232102174846E2L, + -4.2861221385716144629696E2L, +}; +static const long double C1 = 6.9314575195312500000000E-1L; +static const long double C2 = 1.4286068203094172321215E-6L; + +#define SQRTH 0.70710678118654752440L + +long double log1pl(long double xm1) +{ + long double x, y, z; + int e; + + if (isnan(xm1)) + return xm1; + if (xm1 == INFINITY) + return xm1; + if (xm1 == 0.0) + return xm1; + + x = xm1 + 1.0; + + /* Test for domain errors. */ + if (x <= 0.0) { + if (x == 0.0) + return -1 / (x * x); /* -inf with divbyzero */ + return 0 / 0.0f; /* nan with invalid */ + } + + /* Separate mantissa from exponent. + Use frexp so that denormal numbers will be handled properly. */ + x = frexpl(x, &e); + + /* logarithm using log(x) = z + z^3 P(z)/Q(z), + where z = 2(x-1)/x+1) */ + if (e > 2 || e < -2) { + if (x < SQRTH) { /* 2(2x-1)/(2x+1) */ + e -= 1; + z = x - 0.5; + y = 0.5 * z + 0.5; + } else { /* 2 (x-1)/(x+1) */ + z = x - 0.5; + z -= 0.5; + y = 0.5 * x + 0.5; + } + x = z / y; + z = x * x; + z = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3)); + z = z + e * C2; + z = z + x; + z = z + e * C1; + return z; + } + + /* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */ + if (x < SQRTH) { + e -= 1; + if (e != 0) + x = 2.0 * x - 1.0; + else + x = xm1; + } else { + if (e != 0) + x = x - 1.0; + else + x = xm1; + } + z = x * x; + y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 6)); + y = y + e * C2; + z = y - 0.5 * z; + z = z + x; + z = z + e * C1; + return z; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double log1pl(long double x) +{ + return log1p(x); +} +#endif diff --git a/lib/libm/log2.c b/lib/libm/log2.c new file mode 100644 index 00000000..21f31ec1 --- /dev/null +++ b/lib/libm/log2.c @@ -0,0 +1,124 @@ +/* + * Double-precision log2(x) function. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "log2_data.h" + +#define T __log2_data.tab +#define T2 __log2_data.tab2 +#define B __log2_data.poly1 +#define A __log2_data.poly +#define InvLn2hi __log2_data.invln2hi +#define InvLn2lo __log2_data.invln2lo +#define N (1 << LOG2_TABLE_BITS) +#define OFF 0x3fe6000000000000 + +/* Top 16 bits of a double. */ +static inline uint32_t top16(double x) +{ + return asuint64(x) >> 48; +} + +double log2(double x) +{ + double_t z, r, r2, r4, y, invc, logc, kd, hi, lo, t1, t2, t3, p; + uint64_t ix, iz, tmp; + uint32_t top; + int k, i; + + ix = asuint64(x); + top = top16(x); +#define LO asuint64(1.0 - 0x1.5b51p-5) +#define HI asuint64(1.0 + 0x1.6ab2p-5) + if (predict_false(ix - LO < HI - LO)) { + /* Handle close to 1.0 inputs separately. */ + /* Fix sign of zero with downward rounding when x==1. */ + if (WANT_ROUNDING && predict_false(ix == asuint64(1.0))) + return 0; + r = x - 1.0; +#if __FP_FAST_FMA + hi = r * InvLn2hi; + lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi); +#else + double_t rhi, rlo; + rhi = asdouble(asuint64(r) & -1ULL << 32); + rlo = r - rhi; + hi = rhi * InvLn2hi; + lo = rlo * InvLn2hi + r * InvLn2lo; +#endif + r2 = r * r; /* rounding error: 0x1p-62. */ + r4 = r2 * r2; + /* Worst-case error is less than 0.54 ULP (0.55 ULP without + * fma). */ + p = r2 * (B[0] + r * B[1]); + y = hi + p; + lo += hi - y + p; + lo += r4 * (B[2] + r * B[3] + r2 * (B[4] + r * B[5]) + + r4 * (B[6] + r * B[7] + r2 * (B[8] + r * B[9]))); + y += lo; + return eval_as_double(y); + } + if (predict_false(top - 0x0010 >= 0x7ff0 - 0x0010)) { + /* x < 0x1p-1022 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzero(1); + if (ix == asuint64(INFINITY)) /* log(inf) == inf. */ + return x; + if ((top & 0x8000) || (top & 0x7ff0) == 0x7ff0) + return __math_invalid(x); + /* x is subnormal, normalize it. */ + ix = asuint64(x * 0x1p52); + ix -= 52ULL << 52; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (52 - LOG2_TABLE_BITS)) % N; + k = (int64_t)tmp >> 52; /* arithmetic shift */ + iz = ix - (tmp & 0xfffULL << 52); + invc = T[i].invc; + logc = T[i].logc; + z = asdouble(iz); + kd = (double_t)k; + + /* log2(x) = log2(z/c) + log2(c) + k. */ + /* r ~= z/c - 1, |r| < 1/(2*N). */ +#if __FP_FAST_FMA + /* rounding error: 0x1p-55/N. */ + r = __builtin_fma(z, invc, -1.0); + t1 = r * InvLn2hi; + t2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1); +#else + double_t rhi, rlo; + /* rounding error: 0x1p-55/N + 0x1p-65. */ + r = (z - T2[i].chi - T2[i].clo) * invc; + rhi = asdouble(asuint64(r) & -1ULL << 32); + rlo = r - rhi; + t1 = rhi * InvLn2hi; + t2 = rlo * InvLn2hi + r * InvLn2lo; +#endif + + /* hi + lo = r/ln2 + log2(c) + k. */ + t3 = kd + logc; + hi = t3 + t1; + lo = t3 - hi + t1 + t2; + + /* log2(r+1) = r/ln2 + r^2*poly(r). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; /* rounding error: 0x1p-54/N^2. */ + r4 = r2 * r2; + /* Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma). + ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without + fma). */ + p = A[0] + r * A[1] + r2 * (A[2] + r * A[3]) + r4 * (A[4] + r * A[5]); + y = lo + r2 * p + hi; + return eval_as_double(y); +} diff --git a/lib/libm/log2_data.c b/lib/libm/log2_data.c new file mode 100644 index 00000000..3dd1ca51 --- /dev/null +++ b/lib/libm/log2_data.c @@ -0,0 +1,201 @@ +/* + * Data for log2. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "log2_data.h" + +#define N (1 << LOG2_TABLE_BITS) + +const struct log2_data __log2_data = { +// First coefficient: 0x1.71547652b82fe1777d0ffda0d24p0 +.invln2hi = 0x1.7154765200000p+0, +.invln2lo = 0x1.705fc2eefa200p-33, +.poly1 = { +// relative error: 0x1.2fad8188p-63 +// in -0x1.5b51p-5 0x1.6ab2p-5 +-0x1.71547652b82fep-1, +0x1.ec709dc3a03f7p-2, +-0x1.71547652b7c3fp-2, +0x1.2776c50f05be4p-2, +-0x1.ec709dd768fe5p-3, +0x1.a61761ec4e736p-3, +-0x1.7153fbc64a79bp-3, +0x1.484d154f01b4ap-3, +-0x1.289e4a72c383cp-3, +0x1.0b32f285aee66p-3, +}, +.poly = { +// relative error: 0x1.a72c2bf8p-58 +// abs error: 0x1.67a552c8p-66 +// in -0x1.f45p-8 0x1.f45p-8 +-0x1.71547652b8339p-1, +0x1.ec709dc3a04bep-2, +-0x1.7154764702ffbp-2, +0x1.2776c50034c48p-2, +-0x1.ec7b328ea92bcp-3, +0x1.a6225e117f92ep-3, +}, +/* Algorithm: + + x = 2^k z + log2(x) = k + log2(c) + log2(z/c) + log2(z/c) = poly(z/c - 1) + +where z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls +into the ith one, then table entries are computed as + + tab[i].invc = 1/c + tab[i].logc = (double)log2(c) + tab2[i].chi = (double)c + tab2[i].clo = (double)(c - (double)c) + +where c is near the center of the subinterval and is chosen by trying +-2^29 +floating point invc candidates around 1/center and selecting one for which + + 1) the rounding error in 0x1.8p10 + logc is 0, + 2) the rounding error in z - chi - clo is < 0x1p-64 and + 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68). + +Note: 1) ensures that k + logc can be computed without rounding error, 2) +ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a +single rounding error when there is no fast fma for z*invc - 1, 3) ensures +that logc + poly(z/c - 1) has small error, however near x == 1 when +|log2(x)| < 0x1p-4, this is not enough so that is special cased. */ +.tab = { +{0x1.724286bb1acf8p+0, -0x1.1095feecdb000p-1}, +{0x1.6e1f766d2cca1p+0, -0x1.08494bd76d000p-1}, +{0x1.6a13d0e30d48ap+0, -0x1.00143aee8f800p-1}, +{0x1.661ec32d06c85p+0, -0x1.efec5360b4000p-2}, +{0x1.623fa951198f8p+0, -0x1.dfdd91ab7e000p-2}, +{0x1.5e75ba4cf026cp+0, -0x1.cffae0cc79000p-2}, +{0x1.5ac055a214fb8p+0, -0x1.c043811fda000p-2}, +{0x1.571ed0f166e1ep+0, -0x1.b0b67323ae000p-2}, +{0x1.53909590bf835p+0, -0x1.a152f5a2db000p-2}, +{0x1.5014fed61adddp+0, -0x1.9217f5af86000p-2}, +{0x1.4cab88e487bd0p+0, -0x1.8304db0719000p-2}, +{0x1.49539b4334feep+0, -0x1.74189f9a9e000p-2}, +{0x1.460cbdfafd569p+0, -0x1.6552bb5199000p-2}, +{0x1.42d664ee4b953p+0, -0x1.56b23a29b1000p-2}, +{0x1.3fb01111dd8a6p+0, -0x1.483650f5fa000p-2}, +{0x1.3c995b70c5836p+0, -0x1.39de937f6a000p-2}, +{0x1.3991c4ab6fd4ap+0, -0x1.2baa1538d6000p-2}, +{0x1.3698e0ce099b5p+0, -0x1.1d98340ca4000p-2}, +{0x1.33ae48213e7b2p+0, -0x1.0fa853a40e000p-2}, +{0x1.30d191985bdb1p+0, -0x1.01d9c32e73000p-2}, +{0x1.2e025cab271d7p+0, -0x1.e857da2fa6000p-3}, +{0x1.2b404cf13cd82p+0, -0x1.cd3c8633d8000p-3}, +{0x1.288b02c7ccb50p+0, -0x1.b26034c14a000p-3}, +{0x1.25e2263944de5p+0, -0x1.97c1c2f4fe000p-3}, +{0x1.234563d8615b1p+0, -0x1.7d6023f800000p-3}, +{0x1.20b46e33eaf38p+0, -0x1.633a71a05e000p-3}, +{0x1.1e2eefdcda3ddp+0, -0x1.494f5e9570000p-3}, +{0x1.1bb4a580b3930p+0, -0x1.2f9e424e0a000p-3}, +{0x1.19453847f2200p+0, -0x1.162595afdc000p-3}, +{0x1.16e06c0d5d73cp+0, -0x1.f9c9a75bd8000p-4}, +{0x1.1485f47b7e4c2p+0, -0x1.c7b575bf9c000p-4}, +{0x1.12358ad0085d1p+0, -0x1.960c60ff48000p-4}, +{0x1.0fef00f532227p+0, -0x1.64ce247b60000p-4}, +{0x1.0db2077d03a8fp+0, -0x1.33f78b2014000p-4}, +{0x1.0b7e6d65980d9p+0, -0x1.0387d1a42c000p-4}, +{0x1.0953efe7b408dp+0, -0x1.a6f9208b50000p-5}, +{0x1.07325cac53b83p+0, -0x1.47a954f770000p-5}, +{0x1.05197e40d1b5cp+0, -0x1.d23a8c50c0000p-6}, +{0x1.03091c1208ea2p+0, -0x1.16a2629780000p-6}, +{0x1.0101025b37e21p+0, -0x1.720f8d8e80000p-8}, +{0x1.fc07ef9caa76bp-1, 0x1.6fe53b1500000p-7}, +{0x1.f4465d3f6f184p-1, 0x1.11ccce10f8000p-5}, +{0x1.ecc079f84107fp-1, 0x1.c4dfc8c8b8000p-5}, +{0x1.e573a99975ae8p-1, 0x1.3aa321e574000p-4}, +{0x1.de5d6f0bd3de6p-1, 0x1.918a0d08b8000p-4}, +{0x1.d77b681ff38b3p-1, 0x1.e72e9da044000p-4}, +{0x1.d0cb5724de943p-1, 0x1.1dcd2507f6000p-3}, +{0x1.ca4b2dc0e7563p-1, 0x1.476ab03dea000p-3}, +{0x1.c3f8ee8d6cb51p-1, 0x1.7074377e22000p-3}, +{0x1.bdd2b4f020c4cp-1, 0x1.98ede8ba94000p-3}, +{0x1.b7d6c006015cap-1, 0x1.c0db86ad2e000p-3}, +{0x1.b20366e2e338fp-1, 0x1.e840aafcee000p-3}, +{0x1.ac57026295039p-1, 0x1.0790ab4678000p-2}, +{0x1.a6d01bc2731ddp-1, 0x1.1ac056801c000p-2}, +{0x1.a16d3bc3ff18bp-1, 0x1.2db11d4fee000p-2}, +{0x1.9c2d14967feadp-1, 0x1.406464ec58000p-2}, +{0x1.970e4f47c9902p-1, 0x1.52dbe093af000p-2}, +{0x1.920fb3982bcf2p-1, 0x1.651902050d000p-2}, +{0x1.8d30187f759f1p-1, 0x1.771d2cdeaf000p-2}, +{0x1.886e5ebb9f66dp-1, 0x1.88e9c857d9000p-2}, +{0x1.83c97b658b994p-1, 0x1.9a80155e16000p-2}, +{0x1.7f405ffc61022p-1, 0x1.abe186ed3d000p-2}, +{0x1.7ad22181415cap-1, 0x1.bd0f2aea0e000p-2}, +{0x1.767dcf99eff8cp-1, 0x1.ce0a43dbf4000p-2}, +}, +#if !__FP_FAST_FMA +.tab2 = { +{0x1.6200012b90a8ep-1, 0x1.904ab0644b605p-55}, +{0x1.66000045734a6p-1, 0x1.1ff9bea62f7a9p-57}, +{0x1.69fffc325f2c5p-1, 0x1.27ecfcb3c90bap-55}, +{0x1.6e00038b95a04p-1, 0x1.8ff8856739326p-55}, +{0x1.71fffe09994e3p-1, 0x1.afd40275f82b1p-55}, +{0x1.7600015590e1p-1, -0x1.2fd75b4238341p-56}, +{0x1.7a00012655bd5p-1, 0x1.808e67c242b76p-56}, +{0x1.7e0003259e9a6p-1, -0x1.208e426f622b7p-57}, +{0x1.81fffedb4b2d2p-1, -0x1.402461ea5c92fp-55}, +{0x1.860002dfafcc3p-1, 0x1.df7f4a2f29a1fp-57}, +{0x1.89ffff78c6b5p-1, -0x1.e0453094995fdp-55}, +{0x1.8e00039671566p-1, -0x1.a04f3bec77b45p-55}, +{0x1.91fffe2bf1745p-1, -0x1.7fa34400e203cp-56}, +{0x1.95fffcc5c9fd1p-1, -0x1.6ff8005a0695dp-56}, +{0x1.9a0003bba4767p-1, 0x1.0f8c4c4ec7e03p-56}, +{0x1.9dfffe7b92da5p-1, 0x1.e7fd9478c4602p-55}, +{0x1.a1fffd72efdafp-1, -0x1.a0c554dcdae7ep-57}, +{0x1.a5fffde04ff95p-1, 0x1.67da98ce9b26bp-55}, +{0x1.a9fffca5e8d2bp-1, -0x1.284c9b54c13dep-55}, +{0x1.adfffddad03eap-1, 0x1.812c8ea602e3cp-58}, +{0x1.b1ffff10d3d4dp-1, -0x1.efaddad27789cp-55}, +{0x1.b5fffce21165ap-1, 0x1.3cb1719c61237p-58}, +{0x1.b9fffd950e674p-1, 0x1.3f7d94194cep-56}, +{0x1.be000139ca8afp-1, 0x1.50ac4215d9bcp-56}, +{0x1.c20005b46df99p-1, 0x1.beea653e9c1c9p-57}, +{0x1.c600040b9f7aep-1, -0x1.c079f274a70d6p-56}, +{0x1.ca0006255fd8ap-1, -0x1.a0b4076e84c1fp-56}, +{0x1.cdfffd94c095dp-1, 0x1.8f933f99ab5d7p-55}, +{0x1.d1ffff975d6cfp-1, -0x1.82c08665fe1bep-58}, +{0x1.d5fffa2561c93p-1, -0x1.b04289bd295f3p-56}, +{0x1.d9fff9d228b0cp-1, 0x1.70251340fa236p-55}, +{0x1.de00065bc7e16p-1, -0x1.5011e16a4d80cp-56}, +{0x1.e200002f64791p-1, 0x1.9802f09ef62ep-55}, +{0x1.e600057d7a6d8p-1, -0x1.e0b75580cf7fap-56}, +{0x1.ea00027edc00cp-1, -0x1.c848309459811p-55}, +{0x1.ee0006cf5cb7cp-1, -0x1.f8027951576f4p-55}, +{0x1.f2000782b7dccp-1, -0x1.f81d97274538fp-55}, +{0x1.f6000260c450ap-1, -0x1.071002727ffdcp-59}, +{0x1.f9fffe88cd533p-1, -0x1.81bdce1fda8bp-58}, +{0x1.fdfffd50f8689p-1, 0x1.7f91acb918e6ep-55}, +{0x1.0200004292367p+0, 0x1.b7ff365324681p-54}, +{0x1.05fffe3e3d668p+0, 0x1.6fa08ddae957bp-55}, +{0x1.0a0000a85a757p+0, -0x1.7e2de80d3fb91p-58}, +{0x1.0e0001a5f3fccp+0, -0x1.1823305c5f014p-54}, +{0x1.11ffff8afbaf5p+0, -0x1.bfabb6680bac2p-55}, +{0x1.15fffe54d91adp+0, -0x1.d7f121737e7efp-54}, +{0x1.1a00011ac36e1p+0, 0x1.c000a0516f5ffp-54}, +{0x1.1e00019c84248p+0, -0x1.082fbe4da5dap-54}, +{0x1.220000ffe5e6ep+0, -0x1.8fdd04c9cfb43p-55}, +{0x1.26000269fd891p+0, 0x1.cfe2a7994d182p-55}, +{0x1.2a00029a6e6dap+0, -0x1.00273715e8bc5p-56}, +{0x1.2dfffe0293e39p+0, 0x1.b7c39dab2a6f9p-54}, +{0x1.31ffff7dcf082p+0, 0x1.df1336edc5254p-56}, +{0x1.35ffff05a8b6p+0, -0x1.e03564ccd31ebp-54}, +{0x1.3a0002e0eaeccp+0, 0x1.5f0e74bd3a477p-56}, +{0x1.3e000043bb236p+0, 0x1.c7dcb149d8833p-54}, +{0x1.4200002d187ffp+0, 0x1.e08afcf2d3d28p-56}, +{0x1.460000d387cb1p+0, 0x1.20837856599a6p-55}, +{0x1.4a00004569f89p+0, -0x1.9fa5c904fbcd2p-55}, +{0x1.4e000043543f3p+0, -0x1.81125ed175329p-56}, +{0x1.51fffcc027f0fp+0, 0x1.883d8847754dcp-54}, +{0x1.55ffffd87b36fp+0, -0x1.709e731d02807p-55}, +{0x1.59ffff21df7bap+0, 0x1.7f79f68727b02p-55}, +{0x1.5dfffebfc3481p+0, -0x1.180902e30e93ep-54}, +}, +#endif +}; diff --git a/lib/libm/log2_data.h b/lib/libm/log2_data.h new file mode 100644 index 00000000..49108e25 --- /dev/null +++ b/lib/libm/log2_data.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _LOG2_DATA_H +#define _LOG2_DATA_H + +#define hidden __attribute__((visibility("hidden"))) + +#define LOG2_TABLE_BITS 6 +#define LOG2_POLY_ORDER 7 +#define LOG2_POLY1_ORDER 11 +extern hidden const struct log2_data { + double invln2hi; + double invln2lo; + double poly[LOG2_POLY_ORDER - 1]; + double poly1[LOG2_POLY1_ORDER - 1]; + struct { + double invc, logc; + } tab[1 << LOG2_TABLE_BITS]; +#if !__FP_FAST_FMA + struct { + double chi, clo; + } tab2[1 << LOG2_TABLE_BITS]; +#endif +} __log2_data; + +#endif diff --git a/lib/libm/log2f.c b/lib/libm/log2f.c new file mode 100644 index 00000000..edcb28c6 --- /dev/null +++ b/lib/libm/log2f.c @@ -0,0 +1,72 @@ +/* + * Single-precision log2 function. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "log2f_data.h" + +/* +LOG2F_TABLE_BITS = 4 +LOG2F_POLY_ORDER = 4 + +ULP error: 0.752 (nearest rounding.) +Relative error: 1.9 * 2^-26 (before rounding.) +*/ + +#define N (1 << LOG2F_TABLE_BITS) +#define T __log2f_data.tab +#define A __log2f_data.poly +#define OFF 0x3f330000 + +float log2f(float x) +{ + double_t z, r, r2, p, y, y0, invc, logc; + uint32_t ix, iz, top, tmp; + int k, i; + + ix = asuint(x); + /* Fix sign of zero with downward rounding when x==1. */ + if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) + return 0; + if (predict_false(ix - 0x00800000 >= 0x7f800000 - 0x00800000)) { + /* x < 0x1p-126 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzerof(1); + if (ix == 0x7f800000) /* log2(inf) == inf. */ + return x; + if ((ix & 0x80000000) || ix * 2 >= 0xff000000) + return __math_invalidf(x); + /* x is subnormal, normalize it. */ + ix = asuint(x * 0x1p23f); + ix -= 23 << 23; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF] and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (23 - LOG2F_TABLE_BITS)) % N; + top = tmp & 0xff800000; + iz = ix - top; + k = (int32_t)tmp >> 23; /* arithmetic shift */ + invc = T[i].invc; + logc = T[i].logc; + z = (double_t)asfloat(iz); + + /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ + r = z * invc - 1; + y0 = logc + (double_t)k; + + /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ + r2 = r * r; + y = A[1] * r + A[2]; + y = A[0] * r2 + y; + p = A[3] * r + y0; + y = y * r2 + p; + return eval_as_float(y); +} diff --git a/lib/libm/log2f_data.c b/lib/libm/log2f_data.c new file mode 100644 index 00000000..24e450f1 --- /dev/null +++ b/lib/libm/log2f_data.c @@ -0,0 +1,33 @@ +/* + * Data definition for log2f. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "log2f_data.h" + +const struct log2f_data __log2f_data = { + .tab = { + { 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2 }, + { 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2 }, + { 0x1.49539f0f010bp+0, -0x1.7418b0a1fb77bp-2 }, + { 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2 }, + { 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2 }, + { 0x1.25e227b0b8eap+0, -0x1.97c1d1b3b7afp-3 }, + { 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3 }, + { 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4 }, + { 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5 }, + { 0x1p+0, 0x0p+0 }, + { 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4 }, + { 0x1.ca4b31f026aap-1, 0x1.476a9543891bap-3 }, + { 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3 }, + { 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2 }, + { 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2 }, + { 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2 }, + }, + .poly = { + -0x1.712b6f70a7e4dp-2, 0x1.ecabf496832ep-2, -0x1.715479ffae3dep-1, + 0x1.715475f35c8b8p0, + } +}; diff --git a/lib/libm/log2f_data.h b/lib/libm/log2f_data.h new file mode 100644 index 00000000..ec1dead6 --- /dev/null +++ b/lib/libm/log2f_data.h @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _LOG2F_DATA_H +#define _LOG2F_DATA_H + +#define hidden __attribute__((visibility("hidden"))) + +#define LOG2F_TABLE_BITS 4 +#define LOG2F_POLY_ORDER 4 +extern hidden const struct log2f_data { + struct { + double invc, logc; + } tab[1 << LOG2F_TABLE_BITS]; + double poly[LOG2F_POLY_ORDER]; +} __log2f_data; + +#endif diff --git a/lib/libm/log2l.c b/lib/libm/log2l.c new file mode 100644 index 00000000..65fe6df0 --- /dev/null +++ b/lib/libm/log2l.c @@ -0,0 +1,176 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_log2l.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Base 2 logarithm, long double precision + * + * + * SYNOPSIS: + * + * long double x, y, log2l(); + * + * y = log2l( x ); + * + * + * DESCRIPTION: + * + * Returns the base 2 logarithm of x. + * + * The argument is separated into its exponent and fractional + * parts. If the exponent is between -1 and +1, the (natural) + * logarithm of the fraction is approximated by + * + * log(1+x) = x - 0.5 x**2 + x**3 P(x)/Q(x). + * + * Otherwise, setting z = 2(x-1)/x+1), + * + * log(x) = z + z**3 P(z)/Q(z). + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE 0.5, 2.0 30000 9.8e-20 2.7e-20 + * IEEE exp(+-10000) 70000 5.4e-20 2.3e-20 + * + * In the tests over the interval exp(+-10000), the logarithms + * of the random arguments were uniformly distributed over + * [-10000, +10000]. + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double log2l(long double x) +{ + return log2(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 6.2e-22 + */ +static const long double P[] = { + 4.9962495940332550844739E-1L, 1.0767376367209449010438E1L, + 7.7671073698359539859595E1L, 2.5620629828144409632571E2L, + 4.2401812743503691187826E2L, 3.4258224542413922935104E2L, + 1.0747524399916215149070E2L, +}; +static const long double Q[] = { + /* 1.0000000000000000000000E0,*/ + 2.3479774160285863271658E1L, 1.9444210022760132894510E2L, + 7.7952888181207260646090E2L, 1.6911722418503949084863E3L, + 2.0307734695595183428202E3L, 1.2695660352705325274404E3L, + 3.2242573199748645407652E2L, +}; + +/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2), + * where z = 2(x-1)/(x+1) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 6.16e-22 + */ +static const long double R[4] = { + 1.9757429581415468984296E-3L, + -7.1990767473014147232598E-1L, + 1.0777257190312272158094E1L, + -3.5717684488096787370998E1L, +}; +static const long double S[4] = { + /* 1.00000000000000000000E0L,*/ + -2.6201045551331104417768E1L, + 1.9361891836232102174846E2L, + -4.2861221385716144629696E2L, +}; +/* log2(e) - 1 */ +#define LOG2EA 4.4269504088896340735992e-1L + +#define SQRTH 0.70710678118654752440L + +long double log2l(long double x) +{ + long double y, z; + int e; + + if (isnan(x)) + return x; + if (x == INFINITY) + return x; + if (x <= 0.0) { + if (x == 0.0) + return -1 / (x * x); /* -inf with divbyzero */ + return 0 / 0.0f; /* nan with invalid */ + } + + /* separate mantissa from exponent */ + /* Note, frexp is used so that denormal numbers + * will be handled properly. + */ + x = frexpl(x, &e); + + /* logarithm using log(x) = z + z**3 P(z)/Q(z), + * where z = 2(x-1)/x+1) + */ + if (e > 2 || e < -2) { + if (x < SQRTH) { /* 2(2x-1)/(2x+1) */ + e -= 1; + z = x - 0.5; + y = 0.5 * z + 0.5; + } else { /* 2 (x-1)/(x+1) */ + z = x - 0.5; + z -= 0.5; + y = 0.5 * x + 0.5; + } + x = z / y; + z = x * x; + y = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3)); + goto done; + } + + /* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */ + if (x < SQRTH) { + e -= 1; + x = 2.0 * x - 1.0; + } else { + x = x - 1.0; + } + z = x * x; + y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 7)); + y = y - 0.5 * z; + +done: + /* Multiply log of fraction by log2(e) + * and base 2 exponent by 1 + * + * ***CAUTION*** + * + * This sequence of operations is critical and it may + * be horribly defeated by some compiler optimizers. + */ + z = y * LOG2EA; + z += x * LOG2EA; + z += y; + z += x; + z += e; + return z; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double log2l(long double x) +{ + return log2(x); +} +#endif diff --git a/lib/libm/log_data.c b/lib/libm/log_data.c new file mode 100644 index 00000000..1a6ec712 --- /dev/null +++ b/lib/libm/log_data.c @@ -0,0 +1,328 @@ +/* + * Data for log. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "log_data.h" + +#define N (1 << LOG_TABLE_BITS) + +const struct log_data __log_data = { +.ln2hi = 0x1.62e42fefa3800p-1, +.ln2lo = 0x1.ef35793c76730p-45, +.poly1 = { +// relative error: 0x1.c04d76cp-63 +// in -0x1p-4 0x1.09p-4 (|log(1+x)| > 0x1p-4 outside the interval) +-0x1p-1, +0x1.5555555555577p-2, +-0x1.ffffffffffdcbp-3, +0x1.999999995dd0cp-3, +-0x1.55555556745a7p-3, +0x1.24924a344de3p-3, +-0x1.fffffa4423d65p-4, +0x1.c7184282ad6cap-4, +-0x1.999eb43b068ffp-4, +0x1.78182f7afd085p-4, +-0x1.5521375d145cdp-4, +}, +.poly = { +// relative error: 0x1.926199e8p-56 +// abs error: 0x1.882ff33p-65 +// in -0x1.fp-9 0x1.fp-9 +-0x1.0000000000001p-1, +0x1.555555551305bp-2, +-0x1.fffffffeb459p-3, +0x1.999b324f10111p-3, +-0x1.55575e506c89fp-3, +}, +/* Algorithm: + + x = 2^k z + log(x) = k ln2 + log(c) + log(z/c) + log(z/c) = poly(z/c - 1) + +where z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls +into the ith one, then table entries are computed as + + tab[i].invc = 1/c + tab[i].logc = (double)log(c) + tab2[i].chi = (double)c + tab2[i].clo = (double)(c - (double)c) + +where c is near the center of the subinterval and is chosen by trying +-2^29 +floating point invc candidates around 1/center and selecting one for which + + 1) the rounding error in 0x1.8p9 + logc is 0, + 2) the rounding error in z - chi - clo is < 0x1p-66 and + 3) the rounding error in (double)log(c) is minimized (< 0x1p-66). + +Note: 1) ensures that k*ln2hi + logc can be computed without rounding error, +2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to +a single rounding error when there is no fast fma for z*invc - 1, 3) ensures +that logc + poly(z/c - 1) has small error, however near x == 1 when +|log(x)| < 0x1p-4, this is not enough so that is special cased. */ +.tab = { +{0x1.734f0c3e0de9fp+0, -0x1.7cc7f79e69000p-2}, +{0x1.713786a2ce91fp+0, -0x1.76feec20d0000p-2}, +{0x1.6f26008fab5a0p+0, -0x1.713e31351e000p-2}, +{0x1.6d1a61f138c7dp+0, -0x1.6b85b38287800p-2}, +{0x1.6b1490bc5b4d1p+0, -0x1.65d5590807800p-2}, +{0x1.69147332f0cbap+0, -0x1.602d076180000p-2}, +{0x1.6719f18224223p+0, -0x1.5a8ca86909000p-2}, +{0x1.6524f99a51ed9p+0, -0x1.54f4356035000p-2}, +{0x1.63356aa8f24c4p+0, -0x1.4f637c36b4000p-2}, +{0x1.614b36b9ddc14p+0, -0x1.49da7fda85000p-2}, +{0x1.5f66452c65c4cp+0, -0x1.445923989a800p-2}, +{0x1.5d867b5912c4fp+0, -0x1.3edf439b0b800p-2}, +{0x1.5babccb5b90dep+0, -0x1.396ce448f7000p-2}, +{0x1.59d61f2d91a78p+0, -0x1.3401e17bda000p-2}, +{0x1.5805612465687p+0, -0x1.2e9e2ef468000p-2}, +{0x1.56397cee76bd3p+0, -0x1.2941b3830e000p-2}, +{0x1.54725e2a77f93p+0, -0x1.23ec58cda8800p-2}, +{0x1.52aff42064583p+0, -0x1.1e9e129279000p-2}, +{0x1.50f22dbb2bddfp+0, -0x1.1956d2b48f800p-2}, +{0x1.4f38f4734ded7p+0, -0x1.141679ab9f800p-2}, +{0x1.4d843cfde2840p+0, -0x1.0edd094ef9800p-2}, +{0x1.4bd3ec078a3c8p+0, -0x1.09aa518db1000p-2}, +{0x1.4a27fc3e0258ap+0, -0x1.047e65263b800p-2}, +{0x1.4880524d48434p+0, -0x1.feb224586f000p-3}, +{0x1.46dce1b192d0bp+0, -0x1.f474a7517b000p-3}, +{0x1.453d9d3391854p+0, -0x1.ea4443d103000p-3}, +{0x1.43a2744b4845ap+0, -0x1.e020d44e9b000p-3}, +{0x1.420b54115f8fbp+0, -0x1.d60a22977f000p-3}, +{0x1.40782da3ef4b1p+0, -0x1.cc00104959000p-3}, +{0x1.3ee8f5d57fe8fp+0, -0x1.c202956891000p-3}, +{0x1.3d5d9a00b4ce9p+0, -0x1.b81178d811000p-3}, +{0x1.3bd60c010c12bp+0, -0x1.ae2c9ccd3d000p-3}, +{0x1.3a5242b75dab8p+0, -0x1.a45402e129000p-3}, +{0x1.38d22cd9fd002p+0, -0x1.9a877681df000p-3}, +{0x1.3755bc5847a1cp+0, -0x1.90c6d69483000p-3}, +{0x1.35dce49ad36e2p+0, -0x1.87120a645c000p-3}, +{0x1.34679984dd440p+0, -0x1.7d68fb4143000p-3}, +{0x1.32f5cceffcb24p+0, -0x1.73cb83c627000p-3}, +{0x1.3187775a10d49p+0, -0x1.6a39a9b376000p-3}, +{0x1.301c8373e3990p+0, -0x1.60b3154b7a000p-3}, +{0x1.2eb4ebb95f841p+0, -0x1.5737d76243000p-3}, +{0x1.2d50a0219a9d1p+0, -0x1.4dc7b8fc23000p-3}, +{0x1.2bef9a8b7fd2ap+0, -0x1.4462c51d20000p-3}, +{0x1.2a91c7a0c1babp+0, -0x1.3b08abc830000p-3}, +{0x1.293726014b530p+0, -0x1.31b996b490000p-3}, +{0x1.27dfa5757a1f5p+0, -0x1.2875490a44000p-3}, +{0x1.268b39b1d3bbfp+0, -0x1.1f3b9f879a000p-3}, +{0x1.2539d838ff5bdp+0, -0x1.160c8252ca000p-3}, +{0x1.23eb7aac9083bp+0, -0x1.0ce7f57f72000p-3}, +{0x1.22a012ba940b6p+0, -0x1.03cdc49fea000p-3}, +{0x1.2157996cc4132p+0, -0x1.f57bdbc4b8000p-4}, +{0x1.201201dd2fc9bp+0, -0x1.e370896404000p-4}, +{0x1.1ecf4494d480bp+0, -0x1.d17983ef94000p-4}, +{0x1.1d8f5528f6569p+0, -0x1.bf9674ed8a000p-4}, +{0x1.1c52311577e7cp+0, -0x1.adc79202f6000p-4}, +{0x1.1b17c74cb26e9p+0, -0x1.9c0c3e7288000p-4}, +{0x1.19e010c2c1ab6p+0, -0x1.8a646b372c000p-4}, +{0x1.18ab07bb670bdp+0, -0x1.78d01b3ac0000p-4}, +{0x1.1778a25efbcb6p+0, -0x1.674f145380000p-4}, +{0x1.1648d354c31dap+0, -0x1.55e0e6d878000p-4}, +{0x1.151b990275fddp+0, -0x1.4485cdea1e000p-4}, +{0x1.13f0ea432d24cp+0, -0x1.333d94d6aa000p-4}, +{0x1.12c8b7210f9dap+0, -0x1.22079f8c56000p-4}, +{0x1.11a3028ecb531p+0, -0x1.10e4698622000p-4}, +{0x1.107fbda8434afp+0, -0x1.ffa6c6ad20000p-5}, +{0x1.0f5ee0f4e6bb3p+0, -0x1.dda8d4a774000p-5}, +{0x1.0e4065d2a9fcep+0, -0x1.bbcece4850000p-5}, +{0x1.0d244632ca521p+0, -0x1.9a1894012c000p-5}, +{0x1.0c0a77ce2981ap+0, -0x1.788583302c000p-5}, +{0x1.0af2f83c636d1p+0, -0x1.5715e67d68000p-5}, +{0x1.09ddb98a01339p+0, -0x1.35c8a49658000p-5}, +{0x1.08cabaf52e7dfp+0, -0x1.149e364154000p-5}, +{0x1.07b9f2f4e28fbp+0, -0x1.e72c082eb8000p-6}, +{0x1.06ab58c358f19p+0, -0x1.a55f152528000p-6}, +{0x1.059eea5ecf92cp+0, -0x1.63d62cf818000p-6}, +{0x1.04949cdd12c90p+0, -0x1.228fb8caa0000p-6}, +{0x1.038c6c6f0ada9p+0, -0x1.c317b20f90000p-7}, +{0x1.02865137932a9p+0, -0x1.419355daa0000p-7}, +{0x1.0182427ea7348p+0, -0x1.81203c2ec0000p-8}, +{0x1.008040614b195p+0, -0x1.0040979240000p-9}, +{0x1.fe01ff726fa1ap-1, 0x1.feff384900000p-9}, +{0x1.fa11cc261ea74p-1, 0x1.7dc41353d0000p-7}, +{0x1.f6310b081992ep-1, 0x1.3cea3c4c28000p-6}, +{0x1.f25f63ceeadcdp-1, 0x1.b9fc114890000p-6}, +{0x1.ee9c8039113e7p-1, 0x1.1b0d8ce110000p-5}, +{0x1.eae8078cbb1abp-1, 0x1.58a5bd001c000p-5}, +{0x1.e741aa29d0c9bp-1, 0x1.95c8340d88000p-5}, +{0x1.e3a91830a99b5p-1, 0x1.d276aef578000p-5}, +{0x1.e01e009609a56p-1, 0x1.07598e598c000p-4}, +{0x1.dca01e577bb98p-1, 0x1.253f5e30d2000p-4}, +{0x1.d92f20b7c9103p-1, 0x1.42edd8b380000p-4}, +{0x1.d5cac66fb5ccep-1, 0x1.606598757c000p-4}, +{0x1.d272caa5ede9dp-1, 0x1.7da76356a0000p-4}, +{0x1.cf26e3e6b2ccdp-1, 0x1.9ab434e1c6000p-4}, +{0x1.cbe6da2a77902p-1, 0x1.b78c7bb0d6000p-4}, +{0x1.c8b266d37086dp-1, 0x1.d431332e72000p-4}, +{0x1.c5894bd5d5804p-1, 0x1.f0a3171de6000p-4}, +{0x1.c26b533bb9f8cp-1, 0x1.067152b914000p-3}, +{0x1.bf583eeece73fp-1, 0x1.147858292b000p-3}, +{0x1.bc4fd75db96c1p-1, 0x1.2266ecdca3000p-3}, +{0x1.b951e0c864a28p-1, 0x1.303d7a6c55000p-3}, +{0x1.b65e2c5ef3e2cp-1, 0x1.3dfc33c331000p-3}, +{0x1.b374867c9888bp-1, 0x1.4ba366b7a8000p-3}, +{0x1.b094b211d304ap-1, 0x1.5933928d1f000p-3}, +{0x1.adbe885f2ef7ep-1, 0x1.66acd2418f000p-3}, +{0x1.aaf1d31603da2p-1, 0x1.740f8ec669000p-3}, +{0x1.a82e63fd358a7p-1, 0x1.815c0f51af000p-3}, +{0x1.a5740ef09738bp-1, 0x1.8e92954f68000p-3}, +{0x1.a2c2a90ab4b27p-1, 0x1.9bb3602f84000p-3}, +{0x1.a01a01393f2d1p-1, 0x1.a8bed1c2c0000p-3}, +{0x1.9d79f24db3c1bp-1, 0x1.b5b515c01d000p-3}, +{0x1.9ae2505c7b190p-1, 0x1.c2967ccbcc000p-3}, +{0x1.9852ef297ce2fp-1, 0x1.cf635d5486000p-3}, +{0x1.95cbaeea44b75p-1, 0x1.dc1bd3446c000p-3}, +{0x1.934c69de74838p-1, 0x1.e8c01b8cfe000p-3}, +{0x1.90d4f2f6752e6p-1, 0x1.f5509c0179000p-3}, +{0x1.8e6528effd79dp-1, 0x1.00e6c121fb800p-2}, +{0x1.8bfce9fcc007cp-1, 0x1.071b80e93d000p-2}, +{0x1.899c0dabec30ep-1, 0x1.0d46b9e867000p-2}, +{0x1.87427aa2317fbp-1, 0x1.13687334bd000p-2}, +{0x1.84f00acb39a08p-1, 0x1.1980d67234800p-2}, +{0x1.82a49e8653e55p-1, 0x1.1f8ffe0cc8000p-2}, +{0x1.8060195f40260p-1, 0x1.2595fd7636800p-2}, +{0x1.7e22563e0a329p-1, 0x1.2b9300914a800p-2}, +{0x1.7beb377dcb5adp-1, 0x1.3187210436000p-2}, +{0x1.79baa679725c2p-1, 0x1.377266dec1800p-2}, +{0x1.77907f2170657p-1, 0x1.3d54ffbaf3000p-2}, +{0x1.756cadbd6130cp-1, 0x1.432eee32fe000p-2}, +}, +#if !__FP_FAST_FMA +.tab2 = { +{0x1.61000014fb66bp-1, 0x1.e026c91425b3cp-56}, +{0x1.63000034db495p-1, 0x1.dbfea48005d41p-55}, +{0x1.650000d94d478p-1, 0x1.e7fa786d6a5b7p-55}, +{0x1.67000074e6fadp-1, 0x1.1fcea6b54254cp-57}, +{0x1.68ffffedf0faep-1, -0x1.c7e274c590efdp-56}, +{0x1.6b0000763c5bcp-1, -0x1.ac16848dcda01p-55}, +{0x1.6d0001e5cc1f6p-1, 0x1.33f1c9d499311p-55}, +{0x1.6efffeb05f63ep-1, -0x1.e80041ae22d53p-56}, +{0x1.710000e86978p-1, 0x1.bff6671097952p-56}, +{0x1.72ffffc67e912p-1, 0x1.c00e226bd8724p-55}, +{0x1.74fffdf81116ap-1, -0x1.e02916ef101d2p-57}, +{0x1.770000f679c9p-1, -0x1.7fc71cd549c74p-57}, +{0x1.78ffffa7ec835p-1, 0x1.1bec19ef50483p-55}, +{0x1.7affffe20c2e6p-1, -0x1.07e1729cc6465p-56}, +{0x1.7cfffed3fc9p-1, -0x1.08072087b8b1cp-55}, +{0x1.7efffe9261a76p-1, 0x1.dc0286d9df9aep-55}, +{0x1.81000049ca3e8p-1, 0x1.97fd251e54c33p-55}, +{0x1.8300017932c8fp-1, -0x1.afee9b630f381p-55}, +{0x1.850000633739cp-1, 0x1.9bfbf6b6535bcp-55}, +{0x1.87000204289c6p-1, -0x1.bbf65f3117b75p-55}, +{0x1.88fffebf57904p-1, -0x1.9006ea23dcb57p-55}, +{0x1.8b00022bc04dfp-1, -0x1.d00df38e04b0ap-56}, +{0x1.8cfffe50c1b8ap-1, -0x1.8007146ff9f05p-55}, +{0x1.8effffc918e43p-1, 0x1.3817bd07a7038p-55}, +{0x1.910001efa5fc7p-1, 0x1.93e9176dfb403p-55}, +{0x1.9300013467bb9p-1, 0x1.f804e4b980276p-56}, +{0x1.94fffe6ee076fp-1, -0x1.f7ef0d9ff622ep-55}, +{0x1.96fffde3c12d1p-1, -0x1.082aa962638bap-56}, +{0x1.98ffff4458a0dp-1, -0x1.7801b9164a8efp-55}, +{0x1.9afffdd982e3ep-1, -0x1.740e08a5a9337p-55}, +{0x1.9cfffed49fb66p-1, 0x1.fce08c19bep-60}, +{0x1.9f00020f19c51p-1, -0x1.a3faa27885b0ap-55}, +{0x1.a10001145b006p-1, 0x1.4ff489958da56p-56}, +{0x1.a300007bbf6fap-1, 0x1.cbeab8a2b6d18p-55}, +{0x1.a500010971d79p-1, 0x1.8fecadd78793p-55}, +{0x1.a70001df52e48p-1, -0x1.f41763dd8abdbp-55}, +{0x1.a90001c593352p-1, -0x1.ebf0284c27612p-55}, +{0x1.ab0002a4f3e4bp-1, -0x1.9fd043cff3f5fp-57}, +{0x1.acfffd7ae1ed1p-1, -0x1.23ee7129070b4p-55}, +{0x1.aefffee510478p-1, 0x1.a063ee00edea3p-57}, +{0x1.b0fffdb650d5bp-1, 0x1.a06c8381f0ab9p-58}, +{0x1.b2ffffeaaca57p-1, -0x1.9011e74233c1dp-56}, +{0x1.b4fffd995badcp-1, -0x1.9ff1068862a9fp-56}, +{0x1.b7000249e659cp-1, 0x1.aff45d0864f3ep-55}, +{0x1.b8ffff987164p-1, 0x1.cfe7796c2c3f9p-56}, +{0x1.bafffd204cb4fp-1, -0x1.3ff27eef22bc4p-57}, +{0x1.bcfffd2415c45p-1, -0x1.cffb7ee3bea21p-57}, +{0x1.beffff86309dfp-1, -0x1.14103972e0b5cp-55}, +{0x1.c0fffe1b57653p-1, 0x1.bc16494b76a19p-55}, +{0x1.c2ffff1fa57e3p-1, -0x1.4feef8d30c6edp-57}, +{0x1.c4fffdcbfe424p-1, -0x1.43f68bcec4775p-55}, +{0x1.c6fffed54b9f7p-1, 0x1.47ea3f053e0ecp-55}, +{0x1.c8fffeb998fd5p-1, 0x1.383068df992f1p-56}, +{0x1.cb0002125219ap-1, -0x1.8fd8e64180e04p-57}, +{0x1.ccfffdd94469cp-1, 0x1.e7ebe1cc7ea72p-55}, +{0x1.cefffeafdc476p-1, 0x1.ebe39ad9f88fep-55}, +{0x1.d1000169af82bp-1, 0x1.57d91a8b95a71p-56}, +{0x1.d30000d0ff71dp-1, 0x1.9c1906970c7dap-55}, +{0x1.d4fffea790fc4p-1, -0x1.80e37c558fe0cp-58}, +{0x1.d70002edc87e5p-1, -0x1.f80d64dc10f44p-56}, +{0x1.d900021dc82aap-1, -0x1.47c8f94fd5c5cp-56}, +{0x1.dafffd86b0283p-1, 0x1.c7f1dc521617ep-55}, +{0x1.dd000296c4739p-1, 0x1.8019eb2ffb153p-55}, +{0x1.defffe54490f5p-1, 0x1.e00d2c652cc89p-57}, +{0x1.e0fffcdabf694p-1, -0x1.f8340202d69d2p-56}, +{0x1.e2fffdb52c8ddp-1, 0x1.b00c1ca1b0864p-56}, +{0x1.e4ffff24216efp-1, 0x1.2ffa8b094ab51p-56}, +{0x1.e6fffe88a5e11p-1, -0x1.7f673b1efbe59p-58}, +{0x1.e9000119eff0dp-1, -0x1.4808d5e0bc801p-55}, +{0x1.eafffdfa51744p-1, 0x1.80006d54320b5p-56}, +{0x1.ed0001a127fa1p-1, -0x1.002f860565c92p-58}, +{0x1.ef00007babcc4p-1, -0x1.540445d35e611p-55}, +{0x1.f0ffff57a8d02p-1, -0x1.ffb3139ef9105p-59}, +{0x1.f30001ee58ac7p-1, 0x1.a81acf2731155p-55}, +{0x1.f4ffff5823494p-1, 0x1.a3f41d4d7c743p-55}, +{0x1.f6ffffca94c6bp-1, -0x1.202f41c987875p-57}, +{0x1.f8fffe1f9c441p-1, 0x1.77dd1f477e74bp-56}, +{0x1.fafffd2e0e37ep-1, -0x1.f01199a7ca331p-57}, +{0x1.fd0001c77e49ep-1, 0x1.181ee4bceacb1p-56}, +{0x1.feffff7e0c331p-1, -0x1.e05370170875ap-57}, +{0x1.00ffff465606ep+0, -0x1.a7ead491c0adap-55}, +{0x1.02ffff3867a58p+0, -0x1.77f69c3fcb2ep-54}, +{0x1.04ffffdfc0d17p+0, 0x1.7bffe34cb945bp-54}, +{0x1.0700003cd4d82p+0, 0x1.20083c0e456cbp-55}, +{0x1.08ffff9f2cbe8p+0, -0x1.dffdfbe37751ap-57}, +{0x1.0b000010cda65p+0, -0x1.13f7faee626ebp-54}, +{0x1.0d00001a4d338p+0, 0x1.07dfa79489ff7p-55}, +{0x1.0effffadafdfdp+0, -0x1.7040570d66bcp-56}, +{0x1.110000bbafd96p+0, 0x1.e80d4846d0b62p-55}, +{0x1.12ffffae5f45dp+0, 0x1.dbffa64fd36efp-54}, +{0x1.150000dd59ad9p+0, 0x1.a0077701250aep-54}, +{0x1.170000f21559ap+0, 0x1.dfdf9e2e3deeep-55}, +{0x1.18ffffc275426p+0, 0x1.10030dc3b7273p-54}, +{0x1.1b000123d3c59p+0, 0x1.97f7980030188p-54}, +{0x1.1cffff8299eb7p+0, -0x1.5f932ab9f8c67p-57}, +{0x1.1effff48ad4p+0, 0x1.37fbf9da75bebp-54}, +{0x1.210000c8b86a4p+0, 0x1.f806b91fd5b22p-54}, +{0x1.2300003854303p+0, 0x1.3ffc2eb9fbf33p-54}, +{0x1.24fffffbcf684p+0, 0x1.601e77e2e2e72p-56}, +{0x1.26ffff52921d9p+0, 0x1.ffcbb767f0c61p-56}, +{0x1.2900014933a3cp+0, -0x1.202ca3c02412bp-56}, +{0x1.2b00014556313p+0, -0x1.2808233f21f02p-54}, +{0x1.2cfffebfe523bp+0, -0x1.8ff7e384fdcf2p-55}, +{0x1.2f0000bb8ad96p+0, -0x1.5ff51503041c5p-55}, +{0x1.30ffffb7ae2afp+0, -0x1.10071885e289dp-55}, +{0x1.32ffffeac5f7fp+0, -0x1.1ff5d3fb7b715p-54}, +{0x1.350000ca66756p+0, 0x1.57f82228b82bdp-54}, +{0x1.3700011fbf721p+0, 0x1.000bac40dd5ccp-55}, +{0x1.38ffff9592fb9p+0, -0x1.43f9d2db2a751p-54}, +{0x1.3b00004ddd242p+0, 0x1.57f6b707638e1p-55}, +{0x1.3cffff5b2c957p+0, 0x1.a023a10bf1231p-56}, +{0x1.3efffeab0b418p+0, 0x1.87f6d66b152bp-54}, +{0x1.410001532aff4p+0, 0x1.7f8375f198524p-57}, +{0x1.4300017478b29p+0, 0x1.301e672dc5143p-55}, +{0x1.44fffe795b463p+0, 0x1.9ff69b8b2895ap-55}, +{0x1.46fffe80475ep+0, -0x1.5c0b19bc2f254p-54}, +{0x1.48fffef6fc1e7p+0, 0x1.b4009f23a2a72p-54}, +{0x1.4afffe5bea704p+0, -0x1.4ffb7bf0d7d45p-54}, +{0x1.4d000171027dep+0, -0x1.9c06471dc6a3dp-54}, +{0x1.4f0000ff03ee2p+0, 0x1.77f890b85531cp-54}, +{0x1.5100012dc4bd1p+0, 0x1.004657166a436p-57}, +{0x1.530001605277ap+0, -0x1.6bfcece233209p-54}, +{0x1.54fffecdb704cp+0, -0x1.902720505a1d7p-55}, +{0x1.56fffef5f54a9p+0, 0x1.bbfe60ec96412p-54}, +{0x1.5900017e61012p+0, 0x1.87ec581afef9p-55}, +{0x1.5b00003c93e92p+0, -0x1.f41080abf0ccp-54}, +{0x1.5d0001d4919bcp+0, -0x1.8812afb254729p-54}, +{0x1.5efffe7b87a89p+0, -0x1.47eb780ed6904p-54}, +}, +#endif +}; diff --git a/lib/libm/log_data.h b/lib/libm/log_data.h new file mode 100644 index 00000000..5d82f02f --- /dev/null +++ b/lib/libm/log_data.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _LOG_DATA_H +#define _LOG_DATA_H + +#define hidden __attribute__((visibility("hidden"))) + +#define LOG_TABLE_BITS 7 +#define LOG_POLY_ORDER 6 +#define LOG_POLY1_ORDER 12 +extern hidden const struct log_data { + double ln2hi; + double ln2lo; + double poly[LOG_POLY_ORDER - 1]; /* First coefficient is 1. */ + double poly1[LOG_POLY1_ORDER - 1]; + struct { + double invc, logc; + } tab[1 << LOG_TABLE_BITS]; +#if !__FP_FAST_FMA + struct { + double chi, clo; + } tab2[1 << LOG_TABLE_BITS]; +#endif +} __log_data; + +#endif diff --git a/lib/libm/logb.c b/lib/libm/logb.c new file mode 100644 index 00000000..f36a9646 --- /dev/null +++ b/lib/libm/logb.c @@ -0,0 +1,17 @@ +#include <math.h> + +/* +special cases: + logb(+-0) = -inf, and raise divbyzero + logb(+-inf) = +inf + logb(nan) = nan +*/ + +double logb(double x) +{ + if (!isfinite(x)) + return x * x; + if (x == 0) + return -1 / (x * x); + return ilogb(x); +} diff --git a/lib/libm/logbf.c b/lib/libm/logbf.c new file mode 100644 index 00000000..2344ed3a --- /dev/null +++ b/lib/libm/logbf.c @@ -0,0 +1,10 @@ +#include <math.h> + +float logbf(float x) +{ + if (!isfinite(x)) + return x * x; + if (x == 0) + return -1 / (x * x); + return ilogbf(x); +} diff --git a/lib/libm/logbl.c b/lib/libm/logbl.c new file mode 100644 index 00000000..4d7348a0 --- /dev/null +++ b/lib/libm/logbl.c @@ -0,0 +1,16 @@ +#include <math.h> +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double logbl(long double x) +{ + return logb(x); +} +#else +long double logbl(long double x) +{ + if (!isfinite(x)) + return x * x; + if (x == 0) + return -1 / (x * x); + return ilogbl(x); +} +#endif diff --git a/lib/libm/logf.c b/lib/libm/logf.c new file mode 100644 index 00000000..5db4edaf --- /dev/null +++ b/lib/libm/logf.c @@ -0,0 +1,71 @@ +/* + * Single-precision log function. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "logf_data.h" + +/* +LOGF_TABLE_BITS = 4 +LOGF_POLY_ORDER = 4 + +ULP error: 0.818 (nearest rounding.) +Relative error: 1.957 * 2^-26 (before rounding.) +*/ + +#define T __logf_data.tab +#define A __logf_data.poly +#define Ln2 __logf_data.ln2 +#define N (1 << LOGF_TABLE_BITS) +#define OFF 0x3f330000 + +float logf(float x) +{ + double_t z, r, r2, y, y0, invc, logc; + uint32_t ix, iz, tmp; + int k, i; + + ix = asuint(x); + /* Fix sign of zero with downward rounding when x==1. */ + if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) + return 0; + if (predict_false(ix - 0x00800000 >= 0x7f800000 - 0x00800000)) { + /* x < 0x1p-126 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzerof(1); + if (ix == 0x7f800000) /* log(inf) == inf. */ + return x; + if ((ix & 0x80000000) || ix * 2 >= 0xff000000) + return __math_invalidf(x); + /* x is subnormal, normalize it. */ + ix = asuint(x * 0x1p23f); + ix -= 23 << 23; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF] and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (23 - LOGF_TABLE_BITS)) % N; + k = (int32_t)tmp >> 23; /* arithmetic shift */ + iz = ix - (tmp & 0xff800000); + invc = T[i].invc; + logc = T[i].logc; + z = (double_t)asfloat(iz); + + /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ + r = z * invc - 1; + y0 = logc + (double_t)k * Ln2; + + /* Pipelined polynomial evaluation to approximate log1p(r). */ + r2 = r * r; + y = A[1] * r + A[2]; + y = A[0] * r2 + y; + y = y * r2 + (y0 + r); + return eval_as_float(y); +} diff --git a/lib/libm/logf_data.c b/lib/libm/logf_data.c new file mode 100644 index 00000000..857221f7 --- /dev/null +++ b/lib/libm/logf_data.c @@ -0,0 +1,33 @@ +/* + * Data definition for logf. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "logf_data.h" + +const struct logf_data __logf_data = { + .tab = { + { 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2 }, + { 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2 }, + { 0x1.49539f0f010bp+0, -0x1.01eae7f513a67p-2 }, + { 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3 }, + { 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3 }, + { 0x1.25e227b0b8eap+0, -0x1.1aa2bc79c81p-3 }, + { 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4 }, + { 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4 }, + { 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5 }, + { 0x1p+0, 0x0p+0 }, + { 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5 }, + { 0x1.ca4b31f026aap-1, 0x1.c5e53aa362eb4p-4 }, + { 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3 }, + { 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 }, + { 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2 }, + { 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2 }, + }, + .ln2 = 0x1.62e42fefa39efp-1, + .poly = { + -0x1.00ea348b88334p-2, 0x1.5575b0be00b6ap-2, -0x1.ffffef20a4123p-2, + } +}; diff --git a/lib/libm/logf_data.h b/lib/libm/logf_data.h new file mode 100644 index 00000000..3d820f26 --- /dev/null +++ b/lib/libm/logf_data.h @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _LOGF_DATA_H +#define _LOGF_DATA_H + +#define hidden __attribute__((visibility("hidden"))) + +#define LOGF_TABLE_BITS 4 +#define LOGF_POLY_ORDER 4 +extern hidden const struct logf_data { + struct { + double invc, logc; + } tab[1 << LOGF_TABLE_BITS]; + double ln2; + double poly[LOGF_POLY_ORDER - 1]; /* First order coefficient is 1. */ +} __logf_data; + +#endif diff --git a/lib/libm/logl.c b/lib/libm/logl.c new file mode 100644 index 00000000..a46484fa --- /dev/null +++ b/lib/libm/logl.c @@ -0,0 +1,169 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_logl.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Natural logarithm, long double precision + * + * + * SYNOPSIS: + * + * long double x, y, logl(); + * + * y = logl( x ); + * + * + * DESCRIPTION: + * + * Returns the base e (2.718...) logarithm of x. + * + * The argument is separated into its exponent and fractional + * parts. If the exponent is between -1 and +1, the logarithm + * of the fraction is approximated by + * + * log(1+x) = x - 0.5 x**2 + x**3 P(x)/Q(x). + * + * Otherwise, setting z = 2(x-1)/(x+1), + * + * log(x) = log(1+z/2) - log(1-z/2) = z + z**3 P(z)/Q(z). + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE 0.5, 2.0 150000 8.71e-20 2.75e-20 + * IEEE exp(+-10000) 100000 5.39e-20 2.34e-20 + * + * In the tests over the interval exp(+-10000), the logarithms + * of the random arguments were uniformly distributed over + * [-10000, +10000]. + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double logl(long double x) +{ + return log(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +/* Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 2.32e-20 + */ +static const long double P[] = { + 4.5270000862445199635215E-5L, 4.9854102823193375972212E-1L, + 6.5787325942061044846969E0L, 2.9911919328553073277375E1L, + 6.0949667980987787057556E1L, 5.7112963590585538103336E1L, + 2.0039553499201281259648E1L, +}; +static const long double Q[] = { + /* 1.0000000000000000000000E0,*/ + 1.5062909083469192043167E1L, 8.3047565967967209469434E1L, + 2.2176239823732856465394E2L, 3.0909872225312059774938E2L, + 2.1642788614495947685003E2L, 6.0118660497603843919306E1L, +}; + +/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2), + * where z = 2(x-1)/(x+1) + * 1/sqrt(2) <= x < sqrt(2) + * Theoretical peak relative error = 6.16e-22 + */ +static const long double R[4] = { + 1.9757429581415468984296E-3L, + -7.1990767473014147232598E-1L, + 1.0777257190312272158094E1L, + -3.5717684488096787370998E1L, +}; +static const long double S[4] = { + /* 1.00000000000000000000E0L,*/ + -2.6201045551331104417768E1L, + 1.9361891836232102174846E2L, + -4.2861221385716144629696E2L, +}; +static const long double C1 = 6.9314575195312500000000E-1L; +static const long double C2 = 1.4286068203094172321215E-6L; + +#define SQRTH 0.70710678118654752440L + +long double logl(long double x) +{ + long double y, z; + int e; + + if (isnan(x)) + return x; + if (x == INFINITY) + return x; + if (x <= 0.0) { + if (x == 0.0) + return -1 / (x * x); /* -inf with divbyzero */ + return 0 / 0.0f; /* nan with invalid */ + } + + /* separate mantissa from exponent */ + /* Note, frexp is used so that denormal numbers + * will be handled properly. + */ + x = frexpl(x, &e); + + /* logarithm using log(x) = z + z**3 P(z)/Q(z), + * where z = 2(x-1)/(x+1) + */ + if (e > 2 || e < -2) { + if (x < SQRTH) { /* 2(2x-1)/(2x+1) */ + e -= 1; + z = x - 0.5; + y = 0.5 * z + 0.5; + } else { /* 2 (x-1)/(x+1) */ + z = x - 0.5; + z -= 0.5; + y = 0.5 * x + 0.5; + } + x = z / y; + z = x * x; + z = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3)); + z = z + e * C2; + z = z + x; + z = z + e * C1; + return z; + } + + /* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */ + if (x < SQRTH) { + e -= 1; + x = 2.0 * x - 1.0; + } else { + x = x - 1.0; + } + z = x * x; + y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 6)); + y = y + e * C2; + z = y - 0.5 * z; + /* Note, the sum of above terms does not exceed x/4, + * so it contributes at most about 1/4 lsb to the error. + */ + z = z + x; + z = z + e * C1; /* This sum has an error of 1/2 lsb. */ + return z; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double logl(long double x) +{ + return log(x); +} +#endif diff --git a/lib/libm/lrint.c b/lib/libm/lrint.c new file mode 100644 index 00000000..5ddd5fa9 --- /dev/null +++ b/lib/libm/lrint.c @@ -0,0 +1,72 @@ +#include <limits.h> +#include <fenv.h> +#include <math.h> +#include "libm.h" + +/* +If the result cannot be represented (overflow, nan), then +lrint raises the invalid exception. + +Otherwise if the input was not an integer then the inexact +exception is raised. + +C99 is a bit vague about whether inexact exception is +allowed to be raised when invalid is raised. +(F.9 explicitly allows spurious inexact exceptions, F.9.6.5 +does not make it clear if that rule applies to lrint, but +IEEE 754r 7.8 seems to forbid spurious inexact exception in +the ineger conversion functions) + +So we try to make sure that no spurious inexact exception is +raised in case of an overflow. + +If the bit size of long > precision of double, then there +cannot be inexact rounding in case the result overflows, +otherwise LONG_MAX and LONG_MIN can be represented exactly +as a double. +*/ + +#if LONG_MAX < 1U << 53 && defined(FE_INEXACT) +#include <float.h> +#include <stdint.h> +#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif +#ifdef __GNUC__ +/* avoid stack frame in lrint */ +__attribute__((noinline)) +#endif +static long lrint_slow(double x) +{ +#pragma STDC FENV_ACCESS ON + int e; + + e = fetestexcept(FE_INEXACT); + x = rint(x); + if (!e && (x > LONG_MAX || x < LONG_MIN)) + feclearexcept(FE_INEXACT); + /* conversion */ + return x; +} + +long lrint(double x) +{ + uint32_t abstop = asuint64(x) >> 32 & 0x7fffffff; + uint64_t sign = asuint64(x) & (1ULL << 63); + + if (abstop < 0x41dfffff) { + /* |x| < 0x7ffffc00, no overflow */ + double_t toint = asdouble(asuint64(1 / EPS) | sign); + double_t y = x + toint - toint; + return (long)y; + } + return lrint_slow(x); +} +#else +long lrint(double x) +{ + return rint(x); +} +#endif diff --git a/lib/libm/lrintf.c b/lib/libm/lrintf.c new file mode 100644 index 00000000..ca0b6a46 --- /dev/null +++ b/lib/libm/lrintf.c @@ -0,0 +1,8 @@ +#include <math.h> + +/* uses LONG_MAX > 2^24, see comments in lrint.c */ + +long lrintf(float x) +{ + return rintf(x); +} diff --git a/lib/libm/lrintl.c b/lib/libm/lrintl.c new file mode 100644 index 00000000..82ce6393 --- /dev/null +++ b/lib/libm/lrintl.c @@ -0,0 +1,35 @@ +#include <limits.h> +#include <fenv.h> +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long lrintl(long double x) +{ + return lrint(x); +} +#elif defined(FE_INEXACT) +/* +see comments in lrint.c + +Note that if LONG_MAX == 0x7fffffffffffffff && LDBL_MANT_DIG == 64 +then x == 2**63 - 0.5 is the only input that overflows and +raises inexact (with tonearest or upward rounding mode) +*/ +long lrintl(long double x) +{ +#pragma STDC FENV_ACCESS ON + int e; + + e = fetestexcept(FE_INEXACT); + x = rintl(x); + if (!e && (x > LONG_MAX || x < LONG_MIN)) + feclearexcept(FE_INEXACT); + /* conversion */ + return x; +} +#else +long lrintl(long double x) +{ + return rintl(x); +} +#endif diff --git a/lib/libm/lround.c b/lib/libm/lround.c new file mode 100644 index 00000000..b8b79547 --- /dev/null +++ b/lib/libm/lround.c @@ -0,0 +1,6 @@ +#include <math.h> + +long lround(double x) +{ + return round(x); +} diff --git a/lib/libm/lroundf.c b/lib/libm/lroundf.c new file mode 100644 index 00000000..c4707e7d --- /dev/null +++ b/lib/libm/lroundf.c @@ -0,0 +1,6 @@ +#include <math.h> + +long lroundf(float x) +{ + return roundf(x); +} diff --git a/lib/libm/lroundl.c b/lib/libm/lroundl.c new file mode 100644 index 00000000..094fdf64 --- /dev/null +++ b/lib/libm/lroundl.c @@ -0,0 +1,6 @@ +#include <math.h> + +long lroundl(long double x) +{ + return roundl(x); +} diff --git a/lib/libm/modf.c b/lib/libm/modf.c new file mode 100644 index 00000000..94fe5439 --- /dev/null +++ b/lib/libm/modf.c @@ -0,0 +1,37 @@ +#include "libm.h" + +double modf(double x, double *iptr) +{ + union { + double f; + uint64_t i; + } u = { x }; + uint64_t mask; + int e = (int)(u.i >> 52 & 0x7ff) - 0x3ff; + + /* no fractional part */ + if (e >= 52) { + *iptr = x; + if (e == 0x400 && u.i << 12 != 0) /* nan */ + return x; + u.i &= 1ULL << 63; + return u.f; + } + + /* no integral part*/ + if (e < 0) { + u.i &= 1ULL << 63; + *iptr = u.f; + return x; + } + + mask = -1ULL >> 12 >> e; + if ((u.i & mask) == 0) { + *iptr = x; + u.i &= 1ULL << 63; + return u.f; + } + u.i &= ~mask; + *iptr = u.f; + return x - u.f; +} diff --git a/lib/libm/modff.c b/lib/libm/modff.c new file mode 100644 index 00000000..d40752ba --- /dev/null +++ b/lib/libm/modff.c @@ -0,0 +1,37 @@ +#include "libm.h" + +float modff(float x, float *iptr) +{ + union { + float f; + uint32_t i; + } u = { x }; + uint32_t mask; + int e = (int)(u.i >> 23 & 0xff) - 0x7f; + + /* no fractional part */ + if (e >= 23) { + *iptr = x; + if (e == 0x80 && u.i << 9 != 0) { /* nan */ + return x; + } + u.i &= 0x80000000; + return u.f; + } + /* no integral part */ + if (e < 0) { + u.i &= 0x80000000; + *iptr = u.f; + return x; + } + + mask = 0x007fffff >> e; + if ((u.i & mask) == 0) { + *iptr = x; + u.i &= 0x80000000; + return u.f; + } + u.i &= ~mask; + *iptr = u.f; + return x - u.f; +} diff --git a/lib/libm/modfl.c b/lib/libm/modfl.c new file mode 100644 index 00000000..d46ce9fb --- /dev/null +++ b/lib/libm/modfl.c @@ -0,0 +1,53 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double modfl(long double x, long double *iptr) +{ + double d; + long double r; + + r = modf(x, &d); + *iptr = d; + return r; +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 + +static const long double toint = 1 / LDBL_EPSILON; + +long double modfl(long double x, long double *iptr) +{ + union ldshape u = { x }; + int e = (u.i.se & 0x7fff) - 0x3fff; + int s = u.i.se >> 15; + long double absx; + long double y; + + /* no fractional part */ + if (e >= LDBL_MANT_DIG - 1) { + *iptr = x; + if (isnan(x)) + return x; + return s ? -0.0 : 0.0; + } + + /* no integral part*/ + if (e < 0) { + *iptr = s ? -0.0 : 0.0; + return x; + } + + /* raises spurious inexact */ + absx = s ? -x : x; + y = absx + toint - toint - absx; + if (y == 0) { + *iptr = x; + return s ? -0.0 : 0.0; + } + if (y > 0) + y -= 1; + if (s) + y = -y; + *iptr = x + y; + return -y; +} +#endif diff --git a/lib/libm/nan.c b/lib/libm/nan.c new file mode 100644 index 00000000..e0f545d4 --- /dev/null +++ b/lib/libm/nan.c @@ -0,0 +1,7 @@ +#include <sys/cdefs.h> +#include <math.h> + +double nan(const char *__unused s) +{ + return NAN; +} diff --git a/lib/libm/nanf.c b/lib/libm/nanf.c new file mode 100644 index 00000000..db7bff6e --- /dev/null +++ b/lib/libm/nanf.c @@ -0,0 +1,7 @@ +#include <sys/cdefs.h> +#include <math.h> + +float nanf(const char *__unused s) +{ + return NAN; +} diff --git a/lib/libm/nanl.c b/lib/libm/nanl.c new file mode 100644 index 00000000..6e3c1377 --- /dev/null +++ b/lib/libm/nanl.c @@ -0,0 +1,7 @@ +#include <sys/cdefs.h> +#include <math.h> + +long double nanl(const char *__unused s) +{ + return NAN; +} diff --git a/lib/libm/nearbyint.c b/lib/libm/nearbyint.c new file mode 100644 index 00000000..b0ffcc8a --- /dev/null +++ b/lib/libm/nearbyint.c @@ -0,0 +1,20 @@ +#include <fenv.h> +#include <math.h> + +/* nearbyint is the same as rint, but it must not raise the inexact exception */ + +double nearbyint(double x) +{ +#ifdef FE_INEXACT +#pragma STDC FENV_ACCESS ON + int e; + + e = fetestexcept(FE_INEXACT); +#endif + x = rint(x); +#ifdef FE_INEXACT + if (!e) + feclearexcept(FE_INEXACT); +#endif + return x; +} diff --git a/lib/libm/nearbyintf.c b/lib/libm/nearbyintf.c new file mode 100644 index 00000000..c96002b0 --- /dev/null +++ b/lib/libm/nearbyintf.c @@ -0,0 +1,18 @@ +#include <fenv.h> +#include <math.h> + +float nearbyintf(float x) +{ +#ifdef FE_INEXACT +#pragma STDC FENV_ACCESS ON + int e; + + e = fetestexcept(FE_INEXACT); +#endif + x = rintf(x); +#ifdef FE_INEXACT + if (!e) + feclearexcept(FE_INEXACT); +#endif + return x; +} diff --git a/lib/libm/nearbyintl.c b/lib/libm/nearbyintl.c new file mode 100644 index 00000000..7d97b661 --- /dev/null +++ b/lib/libm/nearbyintl.c @@ -0,0 +1,26 @@ +#include <math.h> +#include <float.h> + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double nearbyintl(long double x) +{ + return nearbyint(x); +} +#else +#include <fenv.h> +long double nearbyintl(long double x) +{ +#ifdef FE_INEXACT +#pragma STDC FENV_ACCESS ON + int e; + + e = fetestexcept(FE_INEXACT); +#endif + x = rintl(x); +#ifdef FE_INEXACT + if (!e) + feclearexcept(FE_INEXACT); +#endif + return x; +} +#endif diff --git a/lib/libm/nextafter.c b/lib/libm/nextafter.c new file mode 100644 index 00000000..f00857c3 --- /dev/null +++ b/lib/libm/nextafter.c @@ -0,0 +1,34 @@ +#include "libm.h" + +double nextafter(double x, double y) +{ + union { + double f; + uint64_t i; + } ux = { x }, uy = { y }; + uint64_t ax, ay; + int e; + + if (isnan(x) || isnan(y)) + return x + y; + if (ux.i == uy.i) + return y; + ax = ux.i & -1ULL / 2; + ay = uy.i & -1ULL / 2; + if (ax == 0) { + if (ay == 0) + return y; + ux.i = (uy.i & 1ULL << 63) | 1; + } else if (ax > ay || ((ux.i ^ uy.i) & 1ULL << 63)) + ux.i--; + else + ux.i++; + e = ux.i >> 52 & 0x7ff; + /* raise overflow if ux.f is infinite and x is finite */ + if (e == 0x7ff) + FORCE_EVAL(x + x); + /* raise underflow if ux.f is subnormal or zero */ + if (e == 0) + FORCE_EVAL(x * x + ux.f * ux.f); + return ux.f; +} diff --git a/lib/libm/nextafterf.c b/lib/libm/nextafterf.c new file mode 100644 index 00000000..912e1578 --- /dev/null +++ b/lib/libm/nextafterf.c @@ -0,0 +1,33 @@ +#include "libm.h" + +float nextafterf(float x, float y) +{ + union { + float f; + uint32_t i; + } ux = { x }, uy = { y }; + uint32_t ax, ay, e; + + if (isnan(x) || isnan(y)) + return x + y; + if (ux.i == uy.i) + return y; + ax = ux.i & 0x7fffffff; + ay = uy.i & 0x7fffffff; + if (ax == 0) { + if (ay == 0) + return y; + ux.i = (uy.i & 0x80000000) | 1; + } else if (ax > ay || ((ux.i ^ uy.i) & 0x80000000)) + ux.i--; + else + ux.i++; + e = ux.i & 0x7f800000; + /* raise overflow if ux.f is infinite and x is finite */ + if (e == 0x7f800000) + FORCE_EVAL(x + x); + /* raise underflow if ux.f is subnormal or zero */ + if (e == 0) + FORCE_EVAL(x * x + ux.f * ux.f); + return ux.f; +} diff --git a/lib/libm/nextafterl.c b/lib/libm/nextafterl.c new file mode 100644 index 00000000..a50dd503 --- /dev/null +++ b/lib/libm/nextafterl.c @@ -0,0 +1,75 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double nextafterl(long double x, long double y) +{ + return nextafter(x, y); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +long double nextafterl(long double x, long double y) +{ + union ldshape ux, uy; + + if (isnan(x) || isnan(y)) + return x + y; + if (x == y) + return y; + ux.f = x; + if (x == 0) { + uy.f = y; + ux.i.m = 1; + ux.i.se = uy.i.se & 0x8000; + } else if ((x < y) == !(ux.i.se & 0x8000)) { + ux.i.m++; + if (ux.i.m << 1 == 0) { + ux.i.m = 1ULL << 63; + ux.i.se++; + } + } else { + if (ux.i.m << 1 == 0) { + ux.i.se--; + if (ux.i.se) + ux.i.m = 0; + } + ux.i.m--; + } + /* raise overflow if ux is infinite and x is finite */ + if ((ux.i.se & 0x7fff) == 0x7fff) + return x + x; + /* raise underflow if ux is subnormal or zero */ + if ((ux.i.se & 0x7fff) == 0) + FORCE_EVAL(x * x + ux.f * ux.f); + return ux.f; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +long double nextafterl(long double x, long double y) +{ + union ldshape ux, uy; + + if (isnan(x) || isnan(y)) + return x + y; + if (x == y) + return y; + ux.f = x; + if (x == 0) { + uy.f = y; + ux.i.lo = 1; + ux.i.se = uy.i.se & 0x8000; + } else if ((x < y) == !(ux.i.se & 0x8000)) { + ux.i2.lo++; + if (ux.i2.lo == 0) + ux.i2.hi++; + } else { + if (ux.i2.lo == 0) + ux.i2.hi--; + ux.i2.lo--; + } + /* raise overflow if ux is infinite and x is finite */ + if ((ux.i.se & 0x7fff) == 0x7fff) + return x + x; + /* raise underflow if ux is subnormal or zero */ + if ((ux.i.se & 0x7fff) == 0) + FORCE_EVAL(x * x + ux.f * ux.f); + return ux.f; +} +#endif diff --git a/lib/libm/nexttoward.c b/lib/libm/nexttoward.c new file mode 100644 index 00000000..2082dff1 --- /dev/null +++ b/lib/libm/nexttoward.c @@ -0,0 +1,45 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +double nexttoward(double x, long double y) +{ + return nextafter(x, y); +} +#else +double nexttoward(double x, long double y) +{ + union { + double f; + uint64_t i; + } ux = { x }; + int e; + + if (isnan(x) || isnan(y)) + return x + y; + if (x == y) + return y; + if (x == 0) { + ux.i = 1; + if (signbit(y)) + ux.i |= 1ULL << 63; + } else if (x < y) { + if (signbit(x)) + ux.i--; + else + ux.i++; + } else { + if (signbit(x)) + ux.i++; + else + ux.i--; + } + e = ux.i >> 52 & 0x7ff; + /* raise overflow if ux.f is infinite and x is finite */ + if (e == 0x7ff) + FORCE_EVAL(x + x); + /* raise underflow if ux.f is subnormal or zero */ + if (e == 0) + FORCE_EVAL(x * x + ux.f * ux.f); + return ux.f; +} +#endif diff --git a/lib/libm/nexttowardf.c b/lib/libm/nexttowardf.c new file mode 100644 index 00000000..a342bc4c --- /dev/null +++ b/lib/libm/nexttowardf.c @@ -0,0 +1,38 @@ +#include "libm.h" + +float nexttowardf(float x, long double y) +{ + union { + float f; + uint32_t i; + } ux = { x }; + uint32_t e; + + if (isnan(x) || isnan(y)) + return x + y; + if (x == y) + return y; + if (x == 0) { + ux.i = 1; + if (signbit(y)) + ux.i |= 0x80000000; + } else if (x < y) { + if (signbit(x)) + ux.i--; + else + ux.i++; + } else { + if (signbit(x)) + ux.i++; + else + ux.i--; + } + e = ux.i & 0x7f800000; + /* raise overflow if ux.f is infinite and x is finite */ + if (e == 0x7f800000) + FORCE_EVAL(x + x); + /* raise underflow if ux.f is subnormal or zero */ + if (e == 0) + FORCE_EVAL(x * x + ux.f * ux.f); + return ux.f; +} diff --git a/lib/libm/nexttowardl.c b/lib/libm/nexttowardl.c new file mode 100644 index 00000000..67a63403 --- /dev/null +++ b/lib/libm/nexttowardl.c @@ -0,0 +1,6 @@ +#include <math.h> + +long double nexttowardl(long double x, long double y) +{ + return nextafterl(x, y); +} diff --git a/lib/libm/pow.c b/lib/libm/pow.c new file mode 100644 index 00000000..63dcf5ca --- /dev/null +++ b/lib/libm/pow.c @@ -0,0 +1,352 @@ +/* + * Double-precision x^y function. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "exp_data.h" +#include "pow_data.h" + +/* +Worst-case error: 0.54 ULP (~= ulperr_exp + 1024*Ln2*relerr_log*2^53) +relerr_log: 1.3 * 2^-68 (Relative error of log, 1.5 * 2^-68 without fma) +ulperr_exp: 0.509 ULP (ULP error of exp, 0.511 ULP without fma) +*/ + +#define T __pow_log_data.tab +#define A __pow_log_data.poly +#define Ln2hi __pow_log_data.ln2hi +#define Ln2lo __pow_log_data.ln2lo +#define N (1 << POW_LOG_TABLE_BITS) +#define OFF 0x3fe6955500000000 + +/* Top 12 bits of a double (sign and exponent bits). */ +static inline uint32_t top12(double x) +{ + return asuint64(x) >> 52; +} + +/* Compute y+TAIL = log(x) where the rounded result is y and TAIL has about + additional 15 bits precision. IX is the bit representation of x, but + normalized in the subnormal range using the sign bit for the exponent. */ +static inline double_t log_inline(uint64_t ix, double_t *tail) +{ + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. + */ + double_t z, r, y, invc, logc, logctail, kd, hi, t1, t2, lo, lo1, lo2, p; + uint64_t iz, tmp; + int k, i; + + /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (52 - POW_LOG_TABLE_BITS)) % N; + k = (int64_t)tmp >> 52; /* arithmetic shift */ + iz = ix - (tmp & 0xfffULL << 52); + z = asdouble(iz); + kd = (double_t)k; + + /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ + invc = T[i].invc; + logc = T[i].logc; + logctail = T[i].logctail; + + /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and + |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ +#if __FP_FAST_FMA + r = __builtin_fma(z, invc, -1.0); +#else + /* Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|. */ + double_t zhi = asdouble((iz + (1ULL << 31)) & (-1ULL << 32)); + double_t zlo = z - zhi; + double_t rhi = zhi * invc - 1.0; + double_t rlo = zlo * invc; + r = rhi + rlo; +#endif + + /* k*Ln2 + log(c) + r. */ + t1 = kd * Ln2hi + logc; + t2 = t1 + r; + lo1 = kd * Ln2lo + logctail; + lo2 = t1 - t2 + r; + + /* Evaluation is optimized assuming superscalar pipelined execution. */ + double_t ar, ar2, ar3, lo3, lo4; + ar = A[0] * r; /* A[0] = -0.5. */ + ar2 = r * ar; + ar3 = r * ar2; + /* k*Ln2 + log(c) + r + A[0]*r*r. */ +#if __FP_FAST_FMA + hi = t2 + ar2; + lo3 = __builtin_fma(ar, r, -ar2); + lo4 = t2 - hi + ar2; +#else + double_t arhi = A[0] * rhi; + double_t arhi2 = rhi * arhi; + hi = t2 + arhi2; + lo3 = rlo * (ar + arhi); + lo4 = t2 - hi + arhi2; +#endif + /* p = log1p(r) - r - A[0]*r*r. */ + p = (ar3 * (A[1] + r * A[2] + + ar2 * (A[3] + r * A[4] + ar2 * (A[5] + r * A[6])))); + lo = lo1 + lo2 + lo3 + lo4 + p; + y = hi + lo; + *tail = hi - y + lo; + return y; +} + +#undef N +#undef T +#define N (1 << EXP_TABLE_BITS) +#define InvLn2N __exp_data.invln2N +#define NegLn2hiN __exp_data.negln2hiN +#define NegLn2loN __exp_data.negln2loN +#define Shift __exp_data.shift +#define T __exp_data.tab +#define C2 __exp_data.poly[5 - EXP_POLY_ORDER] +#define C3 __exp_data.poly[6 - EXP_POLY_ORDER] +#define C4 __exp_data.poly[7 - EXP_POLY_ORDER] +#define C5 __exp_data.poly[8 - EXP_POLY_ORDER] +#define C6 __exp_data.poly[9 - EXP_POLY_ORDER] + +/* Handle cases that may overflow or underflow when computing the result that + is scale*(1+TMP) without intermediate rounding. The bit representation of + scale is in SBITS, however it has a computed exponent that may have + overflown into the sign bit so that needs to be adjusted before using it as + a double. (int32_t)KI is the k used in the argument reduction and exponent + adjustment of scale, positive k here means the result may overflow and + negative k means the result may underflow. */ +static inline double specialcase(double_t tmp, uint64_t sbits, uint64_t ki) +{ + double_t scale, y; + + if ((ki & 0x80000000) == 0) { + /* k > 0, the exponent of scale might have overflowed by <= 460. + */ + sbits -= 1009ull << 52; + scale = asdouble(sbits); + y = 0x1p1009 * (scale + scale * tmp); + return eval_as_double(y); + } + /* k < 0, need special care in the subnormal range. */ + sbits += 1022ull << 52; + /* Note: sbits is signed scale. */ + scale = asdouble(sbits); + y = scale + scale * tmp; + if (fabs(y) < 1.0) { + /* Round y to the right precision before scaling it into the + subnormal range to avoid double rounding that can cause + 0.5+E/2 ulp error where E is the worst-case ulp error outside + the subnormal range. So this is only useful if the goal is + better than 1 ulp worst-case error. */ + double_t hi, lo, one = 1.0; + if (y < 0.0) + one = -1.0; + lo = scale - y + scale * tmp; + hi = one + y; + lo = one - hi + y + lo; + y = eval_as_double(hi + lo) - one; + /* Fix the sign of 0. */ + if (y == 0.0) + y = asdouble(sbits & 0x8000000000000000); + /* The underflow exception needs to be signaled explicitly. */ + fp_force_eval(fp_barrier(0x1p-1022) * 0x1p-1022); + } + y = 0x1p-1022 * y; + return eval_as_double(y); +} + +#define SIGN_BIAS (0x800 << EXP_TABLE_BITS) + +/* Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|. + The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1. */ +static inline double exp_inline(double_t x, double_t xtail, uint32_t sign_bias) +{ + uint32_t abstop; + uint64_t ki, idx, top, sbits; + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. + */ + double_t kd, z, r, r2, scale, tail, tmp; + + abstop = top12(x) & 0x7ff; + if (predict_false(abstop - top12(0x1p-54) >= + top12(512.0) - top12(0x1p-54))) { + if (abstop - top12(0x1p-54) >= 0x80000000) { + /* Avoid spurious underflow for tiny x. */ + /* Note: 0 is common input. */ + double_t one = WANT_ROUNDING ? 1.0 + x : 1.0; + return sign_bias ? -one : one; + } + if (abstop >= top12(1024.0)) { + /* Note: inf and nan are already handled. */ + if (asuint64(x) >> 63) + return __math_uflow(sign_bias); + else + return __math_oflow(sign_bias); + } + /* Large x is special cased below. */ + abstop = 0; + } + + /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ + /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ + z = InvLn2N * x; +#if TOINT_INTRINSICS + kd = roundtoint(z); + ki = converttoint(z); +#elif EXP_USE_TOINT_NARROW + /* z - kd is in [-0.5-2^-16, 0.5] in all rounding modes. */ + kd = eval_as_double(z + Shift); + ki = asuint64(kd) >> 16; + kd = (double_t)(int32_t)ki; +#else + /* z - kd is in [-1, 1] in non-nearest rounding modes. */ + kd = eval_as_double(z + Shift); + ki = asuint64(kd); + kd -= Shift; +#endif + r = x + kd * NegLn2hiN + kd * NegLn2loN; + /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ + r += xtail; + /* 2^(k/N) ~= scale * (1 + tail). */ + idx = 2 * (ki % N); + top = (ki + sign_bias) << (52 - EXP_TABLE_BITS); + tail = asdouble(T[idx]); + /* This is only a valid scale when -1023*N < k < 1024*N. */ + sbits = T[idx + 1] + top; + /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; + /* Without fma the worst case error is 0.25/N ulp larger. */ + /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. + */ + tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5); + if (predict_false(abstop == 0)) + return specialcase(tmp, sbits, ki); + scale = asdouble(sbits); + /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there + is no spurious underflow here even without fma. */ + return eval_as_double(scale + scale * tmp); +} + +/* Returns 0 if not int, 1 if odd int, 2 if even int. The argument is + the bit representation of a non-zero finite floating-point value. */ +static inline int checkint(uint64_t iy) +{ + int e = iy >> 52 & 0x7ff; + if (e < 0x3ff) + return 0; + if (e > 0x3ff + 52) + return 2; + if (iy & ((1ULL << (0x3ff + 52 - e)) - 1)) + return 0; + if (iy & (1ULL << (0x3ff + 52 - e))) + return 1; + return 2; +} + +/* Returns 1 if input is the bit representation of 0, infinity or nan. */ +static inline int zeroinfnan(uint64_t i) +{ + return 2 * i - 1 >= 2 * asuint64(INFINITY) - 1; +} + +double pow(double x, double y) +{ + uint32_t sign_bias = 0; + uint64_t ix, iy; + uint32_t topx, topy; + + ix = asuint64(x); + iy = asuint64(y); + topx = top12(x); + topy = top12(y); + if (predict_false(topx - 0x001 >= 0x7ff - 0x001 || + (topy & 0x7ff) - 0x3be >= 0x43e - 0x3be)) { + /* Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) + = inf/0 and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then + pow(x,y) = +-1. */ + /* Special cases: (x < 0x1p-126 or inf or nan) or + (|y| < 0x1p-65 or |y| >= 0x1p63 or nan). */ + if (predict_false(zeroinfnan(iy))) { + if (2 * iy == 0) + return issignaling_inline(x) ? x + y : 1.0; + if (ix == asuint64(1.0)) + return issignaling_inline(y) ? x + y : 1.0; + if (2 * ix > 2 * asuint64(INFINITY) || + 2 * iy > 2 * asuint64(INFINITY)) + return x + y; + if (2 * ix == 2 * asuint64(1.0)) + return 1.0; + if ((2 * ix < 2 * asuint64(1.0)) == !(iy >> 63)) + return 0.0; /* |x|<1 && y==inf or |x|>1 && + y==-inf. */ + return y * y; + } + if (predict_false(zeroinfnan(ix))) { + double_t x2 = x * x; + if (ix >> 63 && checkint(iy) == 1) + x2 = -x2; + /* Without the barrier some versions of clang hoist the + 1/x2 and thus division by zero exception can be + signaled spuriously. */ + return iy >> 63 ? fp_barrier(1 / x2) : x2; + } + /* Here x and y are non-zero finite. */ + if (ix >> 63) { + /* Finite x < 0. */ + int yint = checkint(iy); + if (yint == 0) + return __math_invalid(x); + if (yint == 1) + sign_bias = SIGN_BIAS; + ix &= 0x7fffffffffffffff; + topx &= 0x7ff; + } + if ((topy & 0x7ff) - 0x3be >= 0x43e - 0x3be) { + /* Note: sign_bias == 0 here because y is not odd. */ + if (ix == asuint64(1.0)) + return 1.0; + if ((topy & 0x7ff) < 0x3be) { + /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ + if (WANT_ROUNDING) + return ix > asuint64(1.0) ? 1.0 + y : + 1.0 - y; + else + return 1.0; + } + return (ix > asuint64(1.0)) == (topy < 0x800) ? + __math_oflow(0) : + __math_uflow(0); + } + if (topx == 0) { + /* Normalize subnormal x so exponent becomes negative. + */ + ix = asuint64(x * 0x1p52); + ix &= 0x7fffffffffffffff; + ix -= 52ULL << 52; + } + } + + double_t lo; + double_t hi = log_inline(ix, &lo); + double_t ehi, elo; +#if __FP_FAST_FMA + ehi = y * hi; + elo = y * lo + __builtin_fma(y, hi, -ehi); +#else + double_t yhi = asdouble(iy & -1ULL << 27); + double_t ylo = y - yhi; + double_t lhi = asdouble(asuint64(hi) & -1ULL << 27); + double_t llo = hi - lhi + lo; + ehi = yhi * lhi; + elo = ylo * lhi + y * llo; /* |elo| < |ehi| * 2^-25. */ +#endif + return exp_inline(ehi, elo, sign_bias); +} diff --git a/lib/libm/pow_data.c b/lib/libm/pow_data.c new file mode 100644 index 00000000..c08d2b83 --- /dev/null +++ b/lib/libm/pow_data.c @@ -0,0 +1,180 @@ +/* + * Data for the log part of pow. + * + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "pow_data.h" + +#define N (1 << POW_LOG_TABLE_BITS) + +const struct pow_log_data __pow_log_data = { +.ln2hi = 0x1.62e42fefa3800p-1, +.ln2lo = 0x1.ef35793c76730p-45, +.poly = { +// relative error: 0x1.11922ap-70 +// in -0x1.6bp-8 0x1.6bp-8 +// Coefficients are scaled to match the scaling during evaluation. +-0x1p-1, +0x1.555555555556p-2 * -2, +-0x1.0000000000006p-2 * -2, +0x1.999999959554ep-3 * 4, +-0x1.555555529a47ap-3 * 4, +0x1.2495b9b4845e9p-3 * -8, +-0x1.0002b8b263fc3p-3 * -8, +}, +/* Algorithm: + + x = 2^k z + log(x) = k ln2 + log(c) + log(z/c) + log(z/c) = poly(z/c - 1) + +where z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals +and z falls into the ith one, then table entries are computed as + + tab[i].invc = 1/c + tab[i].logc = round(0x1p43*log(c))/0x1p43 + tab[i].logctail = (double)(log(c) - logc) + +where c is chosen near the center of the subinterval such that 1/c has only a +few precision bits so z/c - 1 is exactly representible as double: + + 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2 + +Note: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97, +the last few bits of logc are rounded away so k*ln2hi + logc has no rounding +error and the interval for z is selected such that near x == 1, where log(x) +is tiny, large cancellation error is avoided in logc + poly(z/c - 1). */ +.tab = { +#define A(a, b, c) { a, 0, b, c }, +A(0x1.6a00000000000p+0, -0x1.62c82f2b9c800p-2, 0x1.ab42428375680p-48) +A(0x1.6800000000000p+0, -0x1.5d1bdbf580800p-2, -0x1.ca508d8e0f720p-46) +A(0x1.6600000000000p+0, -0x1.5767717455800p-2, -0x1.362a4d5b6506dp-45) +A(0x1.6400000000000p+0, -0x1.51aad872df800p-2, -0x1.684e49eb067d5p-49) +A(0x1.6200000000000p+0, -0x1.4be5f95777800p-2, -0x1.41b6993293ee0p-47) +A(0x1.6000000000000p+0, -0x1.4618bc21c6000p-2, 0x1.3d82f484c84ccp-46) +A(0x1.5e00000000000p+0, -0x1.404308686a800p-2, 0x1.c42f3ed820b3ap-50) +A(0x1.5c00000000000p+0, -0x1.3a64c55694800p-2, 0x1.0b1c686519460p-45) +A(0x1.5a00000000000p+0, -0x1.347dd9a988000p-2, 0x1.5594dd4c58092p-45) +A(0x1.5800000000000p+0, -0x1.2e8e2bae12000p-2, 0x1.67b1e99b72bd8p-45) +A(0x1.5600000000000p+0, -0x1.2895a13de8800p-2, 0x1.5ca14b6cfb03fp-46) +A(0x1.5600000000000p+0, -0x1.2895a13de8800p-2, 0x1.5ca14b6cfb03fp-46) +A(0x1.5400000000000p+0, -0x1.22941fbcf7800p-2, -0x1.65a242853da76p-46) +A(0x1.5200000000000p+0, -0x1.1c898c1699800p-2, -0x1.fafbc68e75404p-46) +A(0x1.5000000000000p+0, -0x1.1675cababa800p-2, 0x1.f1fc63382a8f0p-46) +A(0x1.4e00000000000p+0, -0x1.1058bf9ae4800p-2, -0x1.6a8c4fd055a66p-45) +A(0x1.4c00000000000p+0, -0x1.0a324e2739000p-2, -0x1.c6bee7ef4030ep-47) +A(0x1.4a00000000000p+0, -0x1.0402594b4d000p-2, -0x1.036b89ef42d7fp-48) +A(0x1.4a00000000000p+0, -0x1.0402594b4d000p-2, -0x1.036b89ef42d7fp-48) +A(0x1.4800000000000p+0, -0x1.fb9186d5e4000p-3, 0x1.d572aab993c87p-47) +A(0x1.4600000000000p+0, -0x1.ef0adcbdc6000p-3, 0x1.b26b79c86af24p-45) +A(0x1.4400000000000p+0, -0x1.e27076e2af000p-3, -0x1.72f4f543fff10p-46) +A(0x1.4200000000000p+0, -0x1.d5c216b4fc000p-3, 0x1.1ba91bbca681bp-45) +A(0x1.4000000000000p+0, -0x1.c8ff7c79aa000p-3, 0x1.7794f689f8434p-45) +A(0x1.4000000000000p+0, -0x1.c8ff7c79aa000p-3, 0x1.7794f689f8434p-45) +A(0x1.3e00000000000p+0, -0x1.bc286742d9000p-3, 0x1.94eb0318bb78fp-46) +A(0x1.3c00000000000p+0, -0x1.af3c94e80c000p-3, 0x1.a4e633fcd9066p-52) +A(0x1.3a00000000000p+0, -0x1.a23bc1fe2b000p-3, -0x1.58c64dc46c1eap-45) +A(0x1.3a00000000000p+0, -0x1.a23bc1fe2b000p-3, -0x1.58c64dc46c1eap-45) +A(0x1.3800000000000p+0, -0x1.9525a9cf45000p-3, -0x1.ad1d904c1d4e3p-45) +A(0x1.3600000000000p+0, -0x1.87fa06520d000p-3, 0x1.bbdbf7fdbfa09p-45) +A(0x1.3400000000000p+0, -0x1.7ab890210e000p-3, 0x1.bdb9072534a58p-45) +A(0x1.3400000000000p+0, -0x1.7ab890210e000p-3, 0x1.bdb9072534a58p-45) +A(0x1.3200000000000p+0, -0x1.6d60fe719d000p-3, -0x1.0e46aa3b2e266p-46) +A(0x1.3000000000000p+0, -0x1.5ff3070a79000p-3, -0x1.e9e439f105039p-46) +A(0x1.3000000000000p+0, -0x1.5ff3070a79000p-3, -0x1.e9e439f105039p-46) +A(0x1.2e00000000000p+0, -0x1.526e5e3a1b000p-3, -0x1.0de8b90075b8fp-45) +A(0x1.2c00000000000p+0, -0x1.44d2b6ccb8000p-3, 0x1.70cc16135783cp-46) +A(0x1.2c00000000000p+0, -0x1.44d2b6ccb8000p-3, 0x1.70cc16135783cp-46) +A(0x1.2a00000000000p+0, -0x1.371fc201e9000p-3, 0x1.178864d27543ap-48) +A(0x1.2800000000000p+0, -0x1.29552f81ff000p-3, -0x1.48d301771c408p-45) +A(0x1.2600000000000p+0, -0x1.1b72ad52f6000p-3, -0x1.e80a41811a396p-45) +A(0x1.2600000000000p+0, -0x1.1b72ad52f6000p-3, -0x1.e80a41811a396p-45) +A(0x1.2400000000000p+0, -0x1.0d77e7cd09000p-3, 0x1.a699688e85bf4p-47) +A(0x1.2400000000000p+0, -0x1.0d77e7cd09000p-3, 0x1.a699688e85bf4p-47) +A(0x1.2200000000000p+0, -0x1.fec9131dbe000p-4, -0x1.575545ca333f2p-45) +A(0x1.2000000000000p+0, -0x1.e27076e2b0000p-4, 0x1.a342c2af0003cp-45) +A(0x1.2000000000000p+0, -0x1.e27076e2b0000p-4, 0x1.a342c2af0003cp-45) +A(0x1.1e00000000000p+0, -0x1.c5e548f5bc000p-4, -0x1.d0c57585fbe06p-46) +A(0x1.1c00000000000p+0, -0x1.a926d3a4ae000p-4, 0x1.53935e85baac8p-45) +A(0x1.1c00000000000p+0, -0x1.a926d3a4ae000p-4, 0x1.53935e85baac8p-45) +A(0x1.1a00000000000p+0, -0x1.8c345d631a000p-4, 0x1.37c294d2f5668p-46) +A(0x1.1a00000000000p+0, -0x1.8c345d631a000p-4, 0x1.37c294d2f5668p-46) +A(0x1.1800000000000p+0, -0x1.6f0d28ae56000p-4, -0x1.69737c93373dap-45) +A(0x1.1600000000000p+0, -0x1.51b073f062000p-4, 0x1.f025b61c65e57p-46) +A(0x1.1600000000000p+0, -0x1.51b073f062000p-4, 0x1.f025b61c65e57p-46) +A(0x1.1400000000000p+0, -0x1.341d7961be000p-4, 0x1.c5edaccf913dfp-45) +A(0x1.1400000000000p+0, -0x1.341d7961be000p-4, 0x1.c5edaccf913dfp-45) +A(0x1.1200000000000p+0, -0x1.16536eea38000p-4, 0x1.47c5e768fa309p-46) +A(0x1.1000000000000p+0, -0x1.f0a30c0118000p-5, 0x1.d599e83368e91p-45) +A(0x1.1000000000000p+0, -0x1.f0a30c0118000p-5, 0x1.d599e83368e91p-45) +A(0x1.0e00000000000p+0, -0x1.b42dd71198000p-5, 0x1.c827ae5d6704cp-46) +A(0x1.0e00000000000p+0, -0x1.b42dd71198000p-5, 0x1.c827ae5d6704cp-46) +A(0x1.0c00000000000p+0, -0x1.77458f632c000p-5, -0x1.cfc4634f2a1eep-45) +A(0x1.0c00000000000p+0, -0x1.77458f632c000p-5, -0x1.cfc4634f2a1eep-45) +A(0x1.0a00000000000p+0, -0x1.39e87b9fec000p-5, 0x1.502b7f526feaap-48) +A(0x1.0a00000000000p+0, -0x1.39e87b9fec000p-5, 0x1.502b7f526feaap-48) +A(0x1.0800000000000p+0, -0x1.f829b0e780000p-6, -0x1.980267c7e09e4p-45) +A(0x1.0800000000000p+0, -0x1.f829b0e780000p-6, -0x1.980267c7e09e4p-45) +A(0x1.0600000000000p+0, -0x1.7b91b07d58000p-6, -0x1.88d5493faa639p-45) +A(0x1.0400000000000p+0, -0x1.fc0a8b0fc0000p-7, -0x1.f1e7cf6d3a69cp-50) +A(0x1.0400000000000p+0, -0x1.fc0a8b0fc0000p-7, -0x1.f1e7cf6d3a69cp-50) +A(0x1.0200000000000p+0, -0x1.fe02a6b100000p-8, -0x1.9e23f0dda40e4p-46) +A(0x1.0200000000000p+0, -0x1.fe02a6b100000p-8, -0x1.9e23f0dda40e4p-46) +A(0x1.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0) +A(0x1.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0) +A(0x1.fc00000000000p-1, 0x1.0101575890000p-7, -0x1.0c76b999d2be8p-46) +A(0x1.f800000000000p-1, 0x1.0205658938000p-6, -0x1.3dc5b06e2f7d2p-45) +A(0x1.f400000000000p-1, 0x1.8492528c90000p-6, -0x1.aa0ba325a0c34p-45) +A(0x1.f000000000000p-1, 0x1.0415d89e74000p-5, 0x1.111c05cf1d753p-47) +A(0x1.ec00000000000p-1, 0x1.466aed42e0000p-5, -0x1.c167375bdfd28p-45) +A(0x1.e800000000000p-1, 0x1.894aa149fc000p-5, -0x1.97995d05a267dp-46) +A(0x1.e400000000000p-1, 0x1.ccb73cdddc000p-5, -0x1.a68f247d82807p-46) +A(0x1.e200000000000p-1, 0x1.eea31c006c000p-5, -0x1.e113e4fc93b7bp-47) +A(0x1.de00000000000p-1, 0x1.1973bd1466000p-4, -0x1.5325d560d9e9bp-45) +A(0x1.da00000000000p-1, 0x1.3bdf5a7d1e000p-4, 0x1.cc85ea5db4ed7p-45) +A(0x1.d600000000000p-1, 0x1.5e95a4d97a000p-4, -0x1.c69063c5d1d1ep-45) +A(0x1.d400000000000p-1, 0x1.700d30aeac000p-4, 0x1.c1e8da99ded32p-49) +A(0x1.d000000000000p-1, 0x1.9335e5d594000p-4, 0x1.3115c3abd47dap-45) +A(0x1.cc00000000000p-1, 0x1.b6ac88dad6000p-4, -0x1.390802bf768e5p-46) +A(0x1.ca00000000000p-1, 0x1.c885801bc4000p-4, 0x1.646d1c65aacd3p-45) +A(0x1.c600000000000p-1, 0x1.ec739830a2000p-4, -0x1.dc068afe645e0p-45) +A(0x1.c400000000000p-1, 0x1.fe89139dbe000p-4, -0x1.534d64fa10afdp-45) +A(0x1.c000000000000p-1, 0x1.1178e8227e000p-3, 0x1.1ef78ce2d07f2p-45) +A(0x1.be00000000000p-1, 0x1.1aa2b7e23f000p-3, 0x1.ca78e44389934p-45) +A(0x1.ba00000000000p-1, 0x1.2d1610c868000p-3, 0x1.39d6ccb81b4a1p-47) +A(0x1.b800000000000p-1, 0x1.365fcb0159000p-3, 0x1.62fa8234b7289p-51) +A(0x1.b400000000000p-1, 0x1.4913d8333b000p-3, 0x1.5837954fdb678p-45) +A(0x1.b200000000000p-1, 0x1.527e5e4a1b000p-3, 0x1.633e8e5697dc7p-45) +A(0x1.ae00000000000p-1, 0x1.6574ebe8c1000p-3, 0x1.9cf8b2c3c2e78p-46) +A(0x1.ac00000000000p-1, 0x1.6f0128b757000p-3, -0x1.5118de59c21e1p-45) +A(0x1.aa00000000000p-1, 0x1.7898d85445000p-3, -0x1.c661070914305p-46) +A(0x1.a600000000000p-1, 0x1.8beafeb390000p-3, -0x1.73d54aae92cd1p-47) +A(0x1.a400000000000p-1, 0x1.95a5adcf70000p-3, 0x1.7f22858a0ff6fp-47) +A(0x1.a000000000000p-1, 0x1.a93ed3c8ae000p-3, -0x1.8724350562169p-45) +A(0x1.9e00000000000p-1, 0x1.b31d8575bd000p-3, -0x1.c358d4eace1aap-47) +A(0x1.9c00000000000p-1, 0x1.bd087383be000p-3, -0x1.d4bc4595412b6p-45) +A(0x1.9a00000000000p-1, 0x1.c6ffbc6f01000p-3, -0x1.1ec72c5962bd2p-48) +A(0x1.9600000000000p-1, 0x1.db13db0d49000p-3, -0x1.aff2af715b035p-45) +A(0x1.9400000000000p-1, 0x1.e530effe71000p-3, 0x1.212276041f430p-51) +A(0x1.9200000000000p-1, 0x1.ef5ade4dd0000p-3, -0x1.a211565bb8e11p-51) +A(0x1.9000000000000p-1, 0x1.f991c6cb3b000p-3, 0x1.bcbecca0cdf30p-46) +A(0x1.8c00000000000p-1, 0x1.07138604d5800p-2, 0x1.89cdb16ed4e91p-48) +A(0x1.8a00000000000p-1, 0x1.0c42d67616000p-2, 0x1.7188b163ceae9p-45) +A(0x1.8800000000000p-1, 0x1.1178e8227e800p-2, -0x1.c210e63a5f01cp-45) +A(0x1.8600000000000p-1, 0x1.16b5ccbacf800p-2, 0x1.b9acdf7a51681p-45) +A(0x1.8400000000000p-1, 0x1.1bf99635a6800p-2, 0x1.ca6ed5147bdb7p-45) +A(0x1.8200000000000p-1, 0x1.214456d0eb800p-2, 0x1.a87deba46baeap-47) +A(0x1.7e00000000000p-1, 0x1.2bef07cdc9000p-2, 0x1.a9cfa4a5004f4p-45) +A(0x1.7c00000000000p-1, 0x1.314f1e1d36000p-2, -0x1.8e27ad3213cb8p-45) +A(0x1.7a00000000000p-1, 0x1.36b6776be1000p-2, 0x1.16ecdb0f177c8p-46) +A(0x1.7800000000000p-1, 0x1.3c25277333000p-2, 0x1.83b54b606bd5cp-46) +A(0x1.7600000000000p-1, 0x1.419b423d5e800p-2, 0x1.8e436ec90e09dp-47) +A(0x1.7400000000000p-1, 0x1.4718dc271c800p-2, -0x1.f27ce0967d675p-45) +A(0x1.7200000000000p-1, 0x1.4c9e09e173000p-2, -0x1.e20891b0ad8a4p-45) +A(0x1.7000000000000p-1, 0x1.522ae0738a000p-2, 0x1.ebe708164c759p-45) +A(0x1.6e00000000000p-1, 0x1.57bf753c8d000p-2, 0x1.fadedee5d40efp-46) +A(0x1.6c00000000000p-1, 0x1.5d5bddf596000p-2, -0x1.a0b2a08a465dcp-47) +}, +}; diff --git a/lib/libm/pow_data.h b/lib/libm/pow_data.h new file mode 100644 index 00000000..671373c6 --- /dev/null +++ b/lib/libm/pow_data.h @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _POW_DATA_H +#define _POW_DATA_H + +#define hidden __attribute__((visibility("hidden"))) + +#define POW_LOG_TABLE_BITS 7 +#define POW_LOG_POLY_ORDER 8 +extern hidden const struct pow_log_data { + double ln2hi; + double ln2lo; + double poly[POW_LOG_POLY_ORDER - 1]; /* First coefficient is 1. */ + /* Note: the pad field is unused, but allows slightly faster indexing. + */ + struct { + double invc, pad, logc, logctail; + } tab[1 << POW_LOG_TABLE_BITS]; +} __pow_log_data; + +#endif diff --git a/lib/libm/powf.c b/lib/libm/powf.c new file mode 100644 index 00000000..d20bb6af --- /dev/null +++ b/lib/libm/powf.c @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include <math.h> +#include <stdint.h> +#include "libm.h" +#include "exp2f_data.h" +#include "powf_data.h" + +/* +POWF_LOG2_POLY_ORDER = 5 +EXP2F_TABLE_BITS = 5 + +ULP error: 0.82 (~ 0.5 + relerr*2^24) +relerr: 1.27 * 2^-26 (Relative error ~= 128*Ln2*relerr_log2 + relerr_exp2) +relerr_log2: 1.83 * 2^-33 (Relative error of logx.) +relerr_exp2: 1.69 * 2^-34 (Relative error of exp2(ylogx).) +*/ + +#define N (1 << POWF_LOG2_TABLE_BITS) +#define T __powf_log2_data.tab +#define A __powf_log2_data.poly +#define OFF 0x3f330000 + +/* Subnormal input is normalized so ix has negative biased exponent. + Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set. */ +static inline double_t log2_inline(uint32_t ix) +{ + double_t z, r, r2, r4, p, q, y, y0, invc, logc; + uint32_t iz, top, tmp; + int k, i; + + /* x = 2^k z; where z is in range [OFF,2*OFF] and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (23 - POWF_LOG2_TABLE_BITS)) % N; + top = tmp & 0xff800000; + iz = ix - top; + k = (int32_t)top >> (23 - POWF_SCALE_BITS); /* arithmetic shift */ + invc = T[i].invc; + logc = T[i].logc; + z = (double_t)asfloat(iz); + + /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ + r = z * invc - 1; + y0 = logc + (double_t)k; + + /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ + r2 = r * r; + y = A[0] * r + A[1]; + p = A[2] * r + A[3]; + r4 = r2 * r2; + q = A[4] * r + y0; + q = p * r2 + q; + y = y * r4 + q; + return y; +} + +#undef N +#undef T +#define N (1 << EXP2F_TABLE_BITS) +#define T __exp2f_data.tab +#define SIGN_BIAS (1 << (EXP2F_TABLE_BITS + 11)) + +/* The output of log2 and thus the input of exp2 is either scaled by N + (in case of fast toint intrinsics) or not. The unscaled xd must be + in [-1021,1023], sign_bias sets the sign of the result. */ +static inline float exp2_inline(double_t xd, uint32_t sign_bias) +{ + uint64_t ki, ski, t; + double_t kd, z, r, r2, y, s; + +#if TOINT_INTRINSICS +#define C __exp2f_data.poly_scaled + /* N*x = k + r with r in [-1/2, 1/2] */ + kd = roundtoint(xd); /* k */ + ki = converttoint(xd); +#else +#define C __exp2f_data.poly +#define SHIFT __exp2f_data.shift_scaled + /* x = k/N + r with r in [-1/(2N), 1/(2N)] */ + kd = eval_as_double(xd + SHIFT); + ki = asuint64(kd); + kd -= SHIFT; /* k/N */ +#endif + r = xd - kd; + + /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ + t = T[ki % N]; + ski = ki + sign_bias; + t += ski << (52 - EXP2F_TABLE_BITS); + s = asdouble(t); + z = C[0] * r + C[1]; + r2 = r * r; + y = C[2] * r + 1; + y = z * r2 + y; + y = y * s; + return eval_as_float(y); +} + +/* Returns 0 if not int, 1 if odd int, 2 if even int. The argument is + the bit representation of a non-zero finite floating-point value. */ +static inline int checkint(uint32_t iy) +{ + int e = iy >> 23 & 0xff; + if (e < 0x7f) + return 0; + if (e > 0x7f + 23) + return 2; + if (iy & ((1 << (0x7f + 23 - e)) - 1)) + return 0; + if (iy & (1 << (0x7f + 23 - e))) + return 1; + return 2; +} + +static inline int zeroinfnan(uint32_t ix) +{ + return 2 * ix - 1 >= 2u * 0x7f800000 - 1; +} + +float powf(float x, float y) +{ + uint32_t sign_bias = 0; + uint32_t ix, iy; + + ix = asuint(x); + iy = asuint(y); + if (predict_false(ix - 0x00800000 >= 0x7f800000 - 0x00800000 || + zeroinfnan(iy))) { + /* Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or + * nan). */ + if (predict_false(zeroinfnan(iy))) { + if (2 * iy == 0) + return issignalingf_inline(x) ? x + y : 1.0f; + if (ix == 0x3f800000) + return issignalingf_inline(y) ? x + y : 1.0f; + if (2 * ix > 2u * 0x7f800000 || + 2 * iy > 2u * 0x7f800000) + return x + y; + if (2 * ix == 2 * 0x3f800000) + return 1.0f; + if ((2 * ix < 2 * 0x3f800000) == !(iy & 0x80000000)) + return 0.0f; /* |x|<1 && y==inf or |x|>1 && + y==-inf. */ + return y * y; + } + if (predict_false(zeroinfnan(ix))) { + float_t x2 = x * x; + if (ix & 0x80000000 && checkint(iy) == 1) + x2 = -x2; + /* Without the barrier some versions of clang hoist the + 1/x2 and thus division by zero exception can be + signaled spuriously. */ + return iy & 0x80000000 ? fp_barrierf(1 / x2) : x2; + } + /* x and y are non-zero finite. */ + if (ix & 0x80000000) { + /* Finite x < 0. */ + int yint = checkint(iy); + if (yint == 0) + return __math_invalidf(x); + if (yint == 1) + sign_bias = SIGN_BIAS; + ix &= 0x7fffffff; + } + if (ix < 0x00800000) { + /* Normalize subnormal x so exponent becomes negative. + */ + ix = asuint(x * 0x1p23f); + ix &= 0x7fffffff; + ix -= 23 << 23; + } + } + double_t logx = log2_inline(ix); + double_t ylogx = y * logx; /* cannot overflow, y is single prec. */ + if (predict_false((asuint64(ylogx) >> 47 & 0xffff) >= + asuint64(126.0 * POWF_SCALE) >> 47)) { + /* |y*log(x)| >= 126. */ + if (ylogx > 0x1.fffffffd1d571p+6 * POWF_SCALE) + return __math_oflowf(sign_bias); + if (ylogx <= -150.0 * POWF_SCALE) + return __math_uflowf(sign_bias); + } + return exp2_inline(ylogx, sign_bias); +} diff --git a/lib/libm/powf_data.c b/lib/libm/powf_data.c new file mode 100644 index 00000000..13e1d9a0 --- /dev/null +++ b/lib/libm/powf_data.c @@ -0,0 +1,34 @@ +/* + * Data definition for powf. + * + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ + +#include "powf_data.h" + +const struct powf_log2_data __powf_log2_data = { + .tab = { + { 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2 * POWF_SCALE }, + { 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2 * POWF_SCALE }, + { 0x1.49539f0f010bp+0, -0x1.7418b0a1fb77bp-2 * POWF_SCALE }, + { 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2 * POWF_SCALE }, + { 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2 * POWF_SCALE }, + { 0x1.25e227b0b8eap+0, -0x1.97c1d1b3b7afp-3 * POWF_SCALE }, + { 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3 * POWF_SCALE }, + { 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4 * POWF_SCALE }, + { 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5 * POWF_SCALE }, + { 0x1p+0, 0x0p+0 * POWF_SCALE }, + { 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4 * POWF_SCALE }, + { 0x1.ca4b31f026aap-1, 0x1.476a9543891bap-3 * POWF_SCALE }, + { 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3 * POWF_SCALE }, + { 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2 * POWF_SCALE }, + { 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2 * POWF_SCALE }, + { 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2 * POWF_SCALE }, + }, + .poly = { + 0x1.27616c9496e0bp-2 * POWF_SCALE, -0x1.71969a075c67ap-2 * POWF_SCALE, + 0x1.ec70a6ca7baddp-2 * POWF_SCALE, -0x1.7154748bef6c8p-1 * POWF_SCALE, + 0x1.71547652ab82bp0 * POWF_SCALE, + } +}; diff --git a/lib/libm/powf_data.h b/lib/libm/powf_data.h new file mode 100644 index 00000000..5b136e28 --- /dev/null +++ b/lib/libm/powf_data.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2017-2018, Arm Limited. + * SPDX-License-Identifier: MIT + */ +#ifndef _POWF_DATA_H +#define _POWF_DATA_H + +#include "libm.h" +#include "exp2f_data.h" + +#define POWF_LOG2_TABLE_BITS 4 +#define POWF_LOG2_POLY_ORDER 5 +#if TOINT_INTRINSICS +#define POWF_SCALE_BITS EXP2F_TABLE_BITS +#else +#define POWF_SCALE_BITS 0 +#endif +#define POWF_SCALE ((double)(1 << POWF_SCALE_BITS)) +extern hidden const struct powf_log2_data { + struct { + double invc, logc; + } tab[1 << POWF_LOG2_TABLE_BITS]; + double poly[POWF_LOG2_POLY_ORDER]; +} __powf_log2_data; + +#endif diff --git a/lib/libm/powl.c b/lib/libm/powl.c new file mode 100644 index 00000000..1a2d48c8 --- /dev/null +++ b/lib/libm/powl.c @@ -0,0 +1,495 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_powl.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* powl.c + * + * Power function, long double precision + * + * + * SYNOPSIS: + * + * long double x, y, z, powl(); + * + * z = powl( x, y ); + * + * + * DESCRIPTION: + * + * Computes x raised to the yth power. Analytically, + * + * x**y = exp( y log(x) ). + * + * Following Cody and Waite, this program uses a lookup table + * of 2**-i/32 and pseudo extended precision arithmetic to + * obtain several extra bits of accuracy in both the logarithm + * and the exponential. + * + * + * ACCURACY: + * + * The relative error of pow(x,y) can be estimated + * by y dl ln(2), where dl is the absolute error of + * the internally computed base 2 logarithm. At the ends + * of the approximation interval the logarithm equal 1/32 + * and its relative error is about 1 lsb = 1.1e-19. Hence + * the predicted relative error in the result is 2.3e-21 y . + * + * Relative error: + * arithmetic domain # trials peak rms + * + * IEEE +-1000 40000 2.8e-18 3.7e-19 + * .001 < x < 1000, with log(x) uniformly distributed. + * -1000 < y < 1000, y uniformly distributed. + * + * IEEE 0,8700 60000 6.5e-18 1.0e-18 + * 0.99 < x < 1.01, 0 < y < 8700, uniformly distributed. + * + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double powl(long double x, long double y) +{ + return pow(x, y); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 + +/* Table size */ +#define NXT 32 + +/* log(1+x) = x - .5x^2 + x^3 * P(z)/Q(z) + * on the domain 2^(-1/32) - 1 <= x <= 2^(1/32) - 1 + */ +static const long double P[] = { + 8.3319510773868690346226E-4L, + 4.9000050881978028599627E-1L, + 1.7500123722550302671919E0L, + 1.4000100839971580279335E0L, +}; +static const long double Q[] = { + /* 1.0000000000000000000000E0L,*/ + 5.2500282295834889175431E0L, + 8.4000598057587009834666E0L, + 4.2000302519914740834728E0L, +}; +/* A[i] = 2^(-i/32), rounded to IEEE long double precision. + * If i is even, A[i] + B[i/2] gives additional accuracy. + */ +static const long double A[33] = { + 1.0000000000000000000000E0L, 9.7857206208770013448287E-1L, + 9.5760328069857364691013E-1L, 9.3708381705514995065011E-1L, + 9.1700404320467123175367E-1L, 8.9735453750155359320742E-1L, + 8.7812608018664974155474E-1L, 8.5930964906123895780165E-1L, + 8.4089641525371454301892E-1L, 8.2287773907698242225554E-1L, + 8.0524516597462715409607E-1L, 7.8799042255394324325455E-1L, + 7.7110541270397041179298E-1L, 7.5458221379671136985669E-1L, + 7.3841307296974965571198E-1L, 7.2259040348852331001267E-1L, + 7.0710678118654752438189E-1L, 6.9195494098191597746178E-1L, + 6.7712777346844636413344E-1L, 6.6261832157987064729696E-1L, + 6.4841977732550483296079E-1L, 6.3452547859586661129850E-1L, + 6.2092890603674202431705E-1L, 6.0762367999023443907803E-1L, + 5.9460355750136053334378E-1L, 5.8186242938878875689693E-1L, + 5.6939431737834582684856E-1L, 5.5719337129794626814472E-1L, + 5.4525386633262882960438E-1L, 5.3357020033841180906486E-1L, + 5.2213689121370692017331E-1L, 5.1094857432705833910408E-1L, + 5.0000000000000000000000E-1L, +}; +static const long double B[17] = { + 0.0000000000000000000000E0L, 2.6176170809902549338711E-20L, + -1.0126791927256478897086E-20L, 1.3438228172316276937655E-21L, + 1.2207982955417546912101E-20L, -6.3084814358060867200133E-21L, + 1.3164426894366316434230E-20L, -1.8527916071632873716786E-20L, + 1.8950325588932570796551E-20L, 1.5564775779538780478155E-20L, + 6.0859793637556860974380E-21L, -2.0208749253662532228949E-20L, + 1.4966292219224761844552E-20L, 3.3540909728056476875639E-21L, + -8.6987564101742849540743E-22L, -1.2327176863327626135542E-20L, + 0.0000000000000000000000E0L, +}; + +/* 2^x = 1 + x P(x), + * on the interval -1/32 <= x <= 0 + */ +static const long double R[] = { + 1.5089970579127659901157E-5L, 1.5402715328927013076125E-4L, + 1.3333556028915671091390E-3L, 9.6181291046036762031786E-3L, + 5.5504108664798463044015E-2L, 2.4022650695910062854352E-1L, + 6.9314718055994530931447E-1L, +}; + +#define MEXP (NXT * 16384.0L) +/* The following if denormal numbers are supported, else -MEXP: */ +#define MNEXP (-NXT * (16384.0L + 64.0L)) +/* log2(e) - 1 */ +#define LOG2EA 0.44269504088896340735992L + +#define F W +#define Fa Wa +#define Fb Wb +#define G W +#define Ga Wa +#define Gb u +#define H W +#define Ha Wb +#define Hb Wb + +static const long double MAXLOGL = 1.1356523406294143949492E4L; +static const long double MINLOGL = -1.13994985314888605586758E4L; +static const long double LOGE2L = 6.9314718055994530941723E-1L; +static const long double huge = 0x1p10000L; +/* XXX Prevent gcc from erroneously constant folding this. */ +static const volatile long double twom10000 = 0x1p-10000L; + +static long double reducl(long double); +static long double powil(long double, int); + +long double powl(long double x, long double y) +{ + /* double F, Fa, Fb, G, Ga, Gb, H, Ha, Hb */ + int i, nflg, iyflg, yoddint; + long e; + volatile long double z = 0; + long double w = 0, W = 0, Wa = 0, Wb = 0, ya = 0, yb = 0, u = 0; + + /* make sure no invalid exception is raised by nan comparision */ + if (isnan(x)) { + if (!isnan(y) && y == 0.0) + return 1.0; + return x; + } + if (isnan(y)) { + if (x == 1.0) + return 1.0; + return y; + } + if (x == 1.0) + return 1.0; /* 1**y = 1, even if y is nan */ + if (y == 0.0) + return 1.0; /* x**0 = 1, even if x is nan */ + if (y == 1.0) + return x; + /* if y*log2(x) < log2(LDBL_TRUE_MIN)-1 then x^y uflows to 0 + if y*log2(x) > -log2(LDBL_TRUE_MIN)+1 > LDBL_MAX_EXP then x^y oflows + if |x|!=1 then |log2(x)| > |log(x)| > LDBL_EPSILON/2 so + x^y oflows/uflows if |y|*LDBL_EPSILON/2 > -log2(LDBL_TRUE_MIN)+1 */ + if (fabsl(y) > 2 * (-LDBL_MIN_EXP + LDBL_MANT_DIG + 1) / LDBL_EPSILON) { + /* y is not an odd int */ + if (x == -1.0) + return 1.0; + if (y == INFINITY) { + if (x > 1.0 || x < -1.0) + return INFINITY; + return 0.0; + } + if (y == -INFINITY) { + if (x > 1.0 || x < -1.0) + return 0.0; + return INFINITY; + } + if ((x > 1.0 || x < -1.0) == (y > 0)) + return huge * huge; + return twom10000 * twom10000; + } + if (x == INFINITY) { + if (y > 0.0) + return INFINITY; + return 0.0; + } + + w = floorl(y); + + /* Set iyflg to 1 if y is an integer. */ + iyflg = 0; + if (w == y) + iyflg = 1; + + /* Test for odd integer y. */ + yoddint = 0; + if (iyflg) { + ya = fabsl(y); + ya = floorl(0.5 * ya); + yb = 0.5 * fabsl(w); + if (ya != yb) + yoddint = 1; + } + + if (x == -INFINITY) { + if (y > 0.0) { + if (yoddint) + return -INFINITY; + return INFINITY; + } + if (y < 0.0) { + if (yoddint) + return -0.0; + return 0.0; + } + } + nflg = 0; /* (x<0)**(odd int) */ + if (x <= 0.0) { + if (x == 0.0) { + if (y < 0.0) { + if (signbit(x) && yoddint) + /* (-0.0)**(-odd int) = -inf, divbyzero + */ + return -1.0 / 0.0; + /* (+-0.0)**(negative) = inf, divbyzero */ + return 1.0 / 0.0; + } + if (signbit(x) && yoddint) + return -0.0; + return 0.0; + } + if (iyflg == 0) + return (x - x) / (x - x); /* (x<0)**(non-int) is NaN */ + /* (x<0)**(integer) */ + if (yoddint) + nflg = 1; /* negate result */ + x = -x; + } + /* (+integer)**(integer) */ + if (iyflg && floorl(x) == x && fabsl(y) < 32768.0) { + w = powil(x, (int)y); + return nflg ? -w : w; + } + + /* separate significand from exponent */ + x = frexpl(x, &i); + e = i; + + /* find significand in antilog table A[] */ + i = 1; + if (x <= A[17]) + i = 17; + if (x <= A[i + 8]) + i += 8; + if (x <= A[i + 4]) + i += 4; + if (x <= A[i + 2]) + i += 2; + if (x >= A[1]) + i = -1; + i += 1; + + /* Find (x - A[i])/A[i] + * in order to compute log(x/A[i]): + * + * log(x) = log( a x/a ) = log(a) + log(x/a) + * + * log(x/a) = log(1+v), v = x/a - 1 = (x-a)/a + */ + x -= A[i]; + x -= B[i / 2]; + x /= A[i]; + + /* rational approximation for log(1+v): + * + * log(1+v) = v - v**2/2 + v**3 P(v) / Q(v) + */ + z = x * x; + w = x * (z * __polevll(x, P, 3) / __p1evll(x, Q, 3)); + w = w - 0.5 * z; + + /* Convert to base 2 logarithm: + * multiply by log2(e) = 1 + LOG2EA + */ + z = LOG2EA * w; + z += w; + z += LOG2EA * x; + z += x; + + /* Compute exponent term of the base 2 logarithm. */ + w = -i; + w /= NXT; + w += e; + /* Now base 2 log of x is w + z. */ + + /* Multiply base 2 log by y, in extended precision. */ + + /* separate y into large part ya + * and small part yb less than 1/NXT + */ + ya = reducl(y); + yb = y - ya; + + /* (w+z)(ya+yb) + * = w*ya + w*yb + z*y + */ + F = z * y + w * yb; + Fa = reducl(F); + Fb = F - Fa; + + G = Fa + w * ya; + Ga = reducl(G); + Gb = G - Ga; + + H = Fb + Gb; + Ha = reducl(H); + w = (Ga + Ha) * NXT; + + /* Test the power of 2 for overflow */ + if (w > MEXP) + return huge * huge; /* overflow */ + if (w < MNEXP) + return twom10000 * twom10000; /* underflow */ + + e = w; + Hb = H - Ha; + + if (Hb > 0.0) { + e += 1; + Hb -= 1.0 / NXT; /*0.0625L;*/ + } + + /* Now the product y * log2(x) = Hb + e/NXT. + * + * Compute base 2 exponential of Hb, + * where -0.0625 <= Hb <= 0. + */ + z = Hb * __polevll(Hb, R, 6); /* z = 2**Hb - 1 */ + + /* Express e/NXT as an integer plus a negative number of (1/NXT)ths. + * Find lookup table entry for the fractional power of 2. + */ + if (e < 0) + i = 0; + else + i = 1; + i = e / NXT + i; + e = NXT * i - e; + w = A[e]; + z = w * z; /* 2**-e * ( 1 + (2**Hb-1) ) */ + z = z + w; + z = scalbnl(z, i); /* multiply by integer power of 2 */ + + if (nflg) + z = -z; + return z; +} + +/* Find a multiple of 1/NXT that is within 1/NXT of x. */ +static long double reducl(long double x) +{ + long double t; + + t = x * NXT; + t = floorl(t); + t = t / NXT; + return t; +} + +/* + * Positive real raised to integer power, long double precision + * + * + * SYNOPSIS: + * + * long double x, y, powil(); + * int n; + * + * y = powil( x, n ); + * + * + * DESCRIPTION: + * + * Returns argument x>0 raised to the nth power. + * The routine efficiently decomposes n as a sum of powers of + * two. The desired power is a product of two-to-the-kth + * powers of x. Thus to compute the 32767 power of x requires + * 28 multiplications instead of 32767 multiplications. + * + * + * ACCURACY: + * + * Relative error: + * arithmetic x domain n domain # trials peak rms + * IEEE .001,1000 -1022,1023 50000 4.3e-17 7.8e-18 + * IEEE 1,2 -1022,1023 20000 3.9e-17 7.6e-18 + * IEEE .99,1.01 0,8700 10000 3.6e-16 7.2e-17 + * + * Returns MAXNUM on overflow, zero on underflow. + */ + +static long double powil(long double x, int nn) +{ + long double ww, y; + long double s; + int n, e, sign, lx; + + if (nn == 0) + return 1.0; + + if (nn < 0) { + sign = -1; + n = -nn; + } else { + sign = 1; + n = nn; + } + + /* Overflow detection */ + + /* Calculate approximate logarithm of answer */ + s = x; + s = frexpl(s, &lx); + e = (lx - 1) * n; + if ((e == 0) || (e > 64) || (e < -64)) { + s = (s - 7.0710678118654752e-1L) / (s + 7.0710678118654752e-1L); + s = (2.9142135623730950L * s - 0.5 + lx) * nn * LOGE2L; + } else { + s = LOGE2L * e; + } + + if (s > MAXLOGL) + return huge * huge; /* overflow */ + + if (s < MINLOGL) + return twom10000 * twom10000; /* underflow */ + /* Handle tiny denormal answer, but with less accuracy + * since roundoff error in 1.0/x will be amplified. + * The precise demarcation should be the gradual underflow threshold. + */ + if (s < -MAXLOGL + 2.0) { + x = 1.0 / x; + sign = -sign; + } + + /* First bit of the power */ + if (n & 1) + y = x; + else + y = 1.0; + + ww = x; + n >>= 1; + while (n) { + ww = ww * ww; /* arg to the 2-to-the-kth power */ + if (n & 1) /* if that bit is set, then include in product */ + y *= ww; + n >>= 1; + } + + if (sign < 0) + y = 1.0 / y; + return y; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double powl(long double x, long double y) +{ + return pow(x, y); +} +#endif diff --git a/lib/libm/projf.c b/lib/libm/projf.c new file mode 100644 index 00000000..4efd9605 --- /dev/null +++ b/lib/libm/projf.c @@ -0,0 +1,11 @@ +#include "__complex.h" + +float complex cprojf(float complex z) +{ + float_complex w = { .z = z }; + if (isinf(crealf(z)) || isinf(cimagf(z))) { + REAL_PART(w) = INFINITY; + IMAG_PART(w) = copysignf(0.0, cimagf(z)); + } + return (w.z); +} diff --git a/lib/libm/remainder.c b/lib/libm/remainder.c new file mode 100644 index 00000000..53b5c8f6 --- /dev/null +++ b/lib/libm/remainder.c @@ -0,0 +1,11 @@ +#include "libm.h" + +#include <math.h> + +double remainder(double x, double y) +{ + int q; + return remquo(x, y, &q); +} + +weak_alias(remainder, drem); diff --git a/lib/libm/remainderf.c b/lib/libm/remainderf.c new file mode 100644 index 00000000..6a80a25c --- /dev/null +++ b/lib/libm/remainderf.c @@ -0,0 +1,11 @@ +#include "libm.h" + +#include <math.h> + +float remainderf(float x, float y) +{ + int q; + return remquof(x, y, &q); +} + +weak_alias(remainderf, dremf); diff --git a/lib/libm/remainderl.c b/lib/libm/remainderl.c new file mode 100644 index 00000000..2a13c1d5 --- /dev/null +++ b/lib/libm/remainderl.c @@ -0,0 +1,15 @@ +#include <math.h> +#include <float.h> + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double remainderl(long double x, long double y) +{ + return remainder(x, y); +} +#else +long double remainderl(long double x, long double y) +{ + int q; + return remquol(x, y, &q); +} +#endif diff --git a/lib/libm/remquo.c b/lib/libm/remquo.c new file mode 100644 index 00000000..a412f8e1 --- /dev/null +++ b/lib/libm/remquo.c @@ -0,0 +1,89 @@ +#include <math.h> +#include <stdint.h> + +double remquo(double x, double y, int *quo) +{ + union { + double f; + uint64_t i; + } ux = { x }, uy = { y }; + int ex = ux.i >> 52 & 0x7ff; + int ey = uy.i >> 52 & 0x7ff; + int sx = ux.i >> 63; + int sy = uy.i >> 63; + uint32_t q; + uint64_t i; + uint64_t uxi = ux.i; + + *quo = 0; + if (uy.i << 1 == 0 || isnan(y) || ex == 0x7ff) + return (x * y) / (x * y); + if (ux.i << 1 == 0) + return x; + + /* normalize x and y */ + if (!ex) { + for (i = uxi << 12; i >> 63 == 0; ex--, i <<= 1) + ; + uxi <<= -ex + 1; + } else { + uxi &= -1ULL >> 12; + uxi |= 1ULL << 52; + } + if (!ey) { + for (i = uy.i << 12; i >> 63 == 0; ey--, i <<= 1) + ; + uy.i <<= -ey + 1; + } else { + uy.i &= -1ULL >> 12; + uy.i |= 1ULL << 52; + } + + q = 0; + if (ex < ey) { + if (ex + 1 == ey) + goto end; + return x; + } + + /* x mod y */ + for (; ex > ey; ex--) { + i = uxi - uy.i; + if (i >> 63 == 0) { + uxi = i; + q++; + } + uxi <<= 1; + q <<= 1; + } + i = uxi - uy.i; + if (i >> 63 == 0) { + uxi = i; + q++; + } + if (uxi == 0) + ex = -60; + else + for (; uxi >> 52 == 0; uxi <<= 1, ex--) + ; +end: + /* scale result and decide between |x| and |x|-|y| */ + if (ex > 0) { + uxi -= 1ULL << 52; + uxi |= (uint64_t)ex << 52; + } else { + uxi >>= -ex + 1; + } + ux.i = uxi; + x = ux.f; + if (sy) + y = -y; + if (ex == ey || + (ex + 1 == ey && (2 * x > y || (2 * x == y && q % 2)))) { + x -= y; + q++; + } + q &= 0x7fffffff; + *quo = sx ^ sy ? -(int)q : (int)q; + return sx ? -x : x; +} diff --git a/lib/libm/remquof.c b/lib/libm/remquof.c new file mode 100644 index 00000000..82124c65 --- /dev/null +++ b/lib/libm/remquof.c @@ -0,0 +1,89 @@ +#include <math.h> +#include <stdint.h> + +float remquof(float x, float y, int *quo) +{ + union { + float f; + uint32_t i; + } ux = { x }, uy = { y }; + int ex = ux.i >> 23 & 0xff; + int ey = uy.i >> 23 & 0xff; + int sx = ux.i >> 31; + int sy = uy.i >> 31; + uint32_t q; + uint32_t i; + uint32_t uxi = ux.i; + + *quo = 0; + if (uy.i << 1 == 0 || isnan(y) || ex == 0xff) + return (x * y) / (x * y); + if (ux.i << 1 == 0) + return x; + + /* normalize x and y */ + if (!ex) { + for (i = uxi << 9; i >> 31 == 0; ex--, i <<= 1) + ; + uxi <<= -ex + 1; + } else { + uxi &= -1U >> 9; + uxi |= 1U << 23; + } + if (!ey) { + for (i = uy.i << 9; i >> 31 == 0; ey--, i <<= 1) + ; + uy.i <<= -ey + 1; + } else { + uy.i &= -1U >> 9; + uy.i |= 1U << 23; + } + + q = 0; + if (ex < ey) { + if (ex + 1 == ey) + goto end; + return x; + } + + /* x mod y */ + for (; ex > ey; ex--) { + i = uxi - uy.i; + if (i >> 31 == 0) { + uxi = i; + q++; + } + uxi <<= 1; + q <<= 1; + } + i = uxi - uy.i; + if (i >> 31 == 0) { + uxi = i; + q++; + } + if (uxi == 0) + ex = -30; + else + for (; uxi >> 23 == 0; uxi <<= 1, ex--) + ; +end: + /* scale result and decide between |x| and |x|-|y| */ + if (ex > 0) { + uxi -= 1U << 23; + uxi |= (uint32_t)ex << 23; + } else { + uxi >>= -ex + 1; + } + ux.i = uxi; + x = ux.f; + if (sy) + y = -y; + if (ex == ey || + (ex + 1 == ey && (2 * x > y || (2 * x == y && q % 2)))) { + x -= y; + q++; + } + q &= 0x7fffffff; + *quo = sx ^ sy ? -(int)q : (int)q; + return sx ? -x : x; +} diff --git a/lib/libm/remquol.c b/lib/libm/remquol.c new file mode 100644 index 00000000..23c88487 --- /dev/null +++ b/lib/libm/remquol.c @@ -0,0 +1,128 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double remquol(long double x, long double y, int *quo) +{ + return remquo(x, y, quo); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double remquol(long double x, long double y, int *quo) +{ + union ldshape ux = { x }, uy = { y }; + int ex = ux.i.se & 0x7fff; + int ey = uy.i.se & 0x7fff; + int sx = ux.i.se >> 15; + int sy = uy.i.se >> 15; + uint32_t q; + + *quo = 0; + if (y == 0 || isnan(y) || ex == 0x7fff) + return (x * y) / (x * y); + if (x == 0) + return x; + + /* normalize x and y */ + if (!ex) { + ux.i.se = ex; + ux.f *= 0x1p120f; + ex = ux.i.se - 120; + } + if (!ey) { + uy.i.se = ey; + uy.f *= 0x1p120f; + ey = uy.i.se - 120; + } + + q = 0; + if (ex >= ey) { + /* x mod y */ +#if LDBL_MANT_DIG == 64 + uint64_t i, mx, my; + mx = ux.i.m; + my = uy.i.m; + for (; ex > ey; ex--) { + i = mx - my; + if (mx >= my) { + mx = 2 * i; + q++; + q <<= 1; + } else if (2 * mx < mx) { + mx = 2 * mx - my; + q <<= 1; + q++; + } else { + mx = 2 * mx; + q <<= 1; + } + } + i = mx - my; + if (mx >= my) { + mx = i; + q++; + } + if (mx == 0) + ex = -120; + else + for (; mx >> 63 == 0; mx *= 2, ex--) + ; + ux.i.m = mx; +#elif LDBL_MANT_DIG == 113 + uint64_t hi, lo, xhi, xlo, yhi, ylo; + xhi = (ux.i2.hi & -1ULL >> 16) | 1ULL << 48; + yhi = (uy.i2.hi & -1ULL >> 16) | 1ULL << 48; + xlo = ux.i2.lo; + ylo = ux.i2.lo; + for (; ex > ey; ex--) { + hi = xhi - yhi; + lo = xlo - ylo; + if (xlo < ylo) + hi -= 1; + if (hi >> 63 == 0) { + xhi = 2 * hi + (lo >> 63); + xlo = 2 * lo; + q++; + } else { + xhi = 2 * xhi + (xlo >> 63); + xlo = 2 * xlo; + } + q <<= 1; + } + hi = xhi - yhi; + lo = xlo - ylo; + if (xlo < ylo) + hi -= 1; + if (hi >> 63 == 0) { + xhi = hi; + xlo = lo; + q++; + } + if ((xhi | xlo) == 0) + ex = -120; + else + for (; xhi >> 48 == 0; + xhi = 2 * xhi + (xlo >> 63), xlo = 2 * xlo, ex--) + ; + ux.i2.hi = xhi; + ux.i2.lo = xlo; +#endif + } + + /* scale result and decide between |x| and |x|-|y| */ + if (ex <= 0) { + ux.i.se = ex + 120; + ux.f *= 0x1p-120f; + } else + ux.i.se = ex; + x = ux.f; + if (sy) + y = -y; + if (ex == ey || + (ex + 1 == ey && (2 * x > y || (2 * x == y && q % 2)))) { + x -= y; + q++; + } + q &= 0x7fffffff; + *quo = sx ^ sy ? -(int)q : (int)q; + return sx ? -x : x; +} +#endif diff --git a/lib/libm/rint.c b/lib/libm/rint.c new file mode 100644 index 00000000..f1159643 --- /dev/null +++ b/lib/libm/rint.c @@ -0,0 +1,31 @@ +#include <float.h> +#include <math.h> +#include <stdint.h> + +#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif +static const double_t toint = 1 / EPS; + +double rint(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + int e = u.i >> 52 & 0x7ff; + int s = u.i >> 63; + double_t y; + + if (e >= 0x3ff + 52) + return x; + if (s) + y = x - toint + toint; + else + y = x + toint - toint; + if (y == 0) + return s ? -0.0 : 0; + return y; +} diff --git a/lib/libm/rintf.c b/lib/libm/rintf.c new file mode 100644 index 00000000..5db9e0fe --- /dev/null +++ b/lib/libm/rintf.c @@ -0,0 +1,33 @@ +#include <float.h> +#include <math.h> +#include <stdint.h> + +#if FLT_EVAL_METHOD == 0 +#define EPS FLT_EPSILON +#elif FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif +static const float_t toint = 1 / EPS; + +float rintf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + int e = u.i >> 23 & 0xff; + int s = u.i >> 31; + float_t y; + + if (e >= 0x7f + 23) + return x; + if (s) + y = x - toint + toint; + else + y = x + toint - toint; + if (y == 0) + return s ? -0.0f : 0.0f; + return y; +} diff --git a/lib/libm/rintl.c b/lib/libm/rintl.c new file mode 100644 index 00000000..e75fe870 --- /dev/null +++ b/lib/libm/rintl.c @@ -0,0 +1,29 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double rintl(long double x) +{ + return rint(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 + +static const long double toint = 1 / LDBL_EPSILON; + +long double rintl(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + int s = u.i.se >> 15; + long double y; + + if (e >= 0x3fff + LDBL_MANT_DIG - 1) + return x; + if (s) + y = x - toint + toint; + else + y = x + toint - toint; + if (y == 0) + return 0 * x; + return y; +} +#endif diff --git a/lib/libm/round.c b/lib/libm/round.c new file mode 100644 index 00000000..aa36cce4 --- /dev/null +++ b/lib/libm/round.c @@ -0,0 +1,38 @@ +#include "libm.h" + +#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif +static const double_t toint = 1 / EPS; + +double round(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + int e = u.i >> 52 & 0x7ff; + double_t y; + + if (e >= 0x3ff + 52) + return x; + if (u.i >> 63) + x = -x; + if (e < 0x3ff - 1) { + /* raise inexact if x!=0 */ + FORCE_EVAL(x + toint); + return 0 * u.f; + } + y = x + toint - toint - x; + if (y > 0.5) + y = y + x - 1; + else if (y <= -0.5) + y = y + x + 1; + else + y = y + x; + if (u.i >> 63) + y = -y; + return y; +} diff --git a/lib/libm/roundf.c b/lib/libm/roundf.c new file mode 100644 index 00000000..fef6a24b --- /dev/null +++ b/lib/libm/roundf.c @@ -0,0 +1,39 @@ +#include "libm.h" + +#if FLT_EVAL_METHOD == 0 +#define EPS FLT_EPSILON +#elif FLT_EVAL_METHOD == 1 +#define EPS DBL_EPSILON +#elif FLT_EVAL_METHOD == 2 +#define EPS LDBL_EPSILON +#endif +static const float_t toint = 1 / EPS; + +float roundf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + int e = u.i >> 23 & 0xff; + float_t y; + + if (e >= 0x7f + 23) + return x; + if (u.i >> 31) + x = -x; + if (e < 0x7f - 1) { + FORCE_EVAL(x + toint); + return 0 * u.f; + } + y = x + toint - toint - x; + if (y > 0.5f) + y = y + x - 1; + else if (y <= -0.5f) + y = y + x + 1; + else + y = y + x; + if (u.i >> 31) + y = -y; + return y; +} diff --git a/lib/libm/roundl.c b/lib/libm/roundl.c new file mode 100644 index 00000000..cb148310 --- /dev/null +++ b/lib/libm/roundl.c @@ -0,0 +1,37 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double roundl(long double x) +{ + return round(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 + +static const long double toint = 1 / LDBL_EPSILON; + +long double roundl(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + long double y; + + if (e >= 0x3fff + LDBL_MANT_DIG - 1) + return x; + if (u.i.se >> 15) + x = -x; + if (e < 0x3fff - 1) { + FORCE_EVAL(x + toint); + return 0 * u.f; + } + y = x + toint - toint - x; + if (y > 0.5) + y = y + x - 1; + else if (y <= -0.5) + y = y + x + 1; + else + y = y + x; + if (u.i.se >> 15) + y = -y; + return y; +} +#endif diff --git a/lib/libm/scalb.c b/lib/libm/scalb.c new file mode 100644 index 00000000..478dd2ae --- /dev/null +++ b/lib/libm/scalb.c @@ -0,0 +1,38 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_scalb.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * scalb(x, fn) is provide for + * passing various standard test suite. One + * should use scalbn() instead. + */ + +#define _GNU_SOURCE +#include <math.h> + +double scalb(double x, double fn) +{ + if (isnan(x) || isnan(fn)) + return x * fn; + if (!isfinite(fn)) { + if (fn > 0.0) + return x * fn; + else + return x / (-fn); + } + if (rint(fn) != fn) + return (fn - fn) / (fn - fn); + if (fn > 65000.0) + return scalbn(x, 65000); + if (-fn > 65000.0) + return scalbn(x, -65000); + return scalbn(x, (int)fn); +} diff --git a/lib/libm/scalbf.c b/lib/libm/scalbf.c new file mode 100644 index 00000000..7a938de2 --- /dev/null +++ b/lib/libm/scalbf.c @@ -0,0 +1,36 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/e_scalbf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#define _GNU_SOURCE +#include <math.h> + +float scalbf(float x, float fn) +{ + if (isnan(x) || isnan(fn)) + return x * fn; + if (!isfinite(fn)) { + if (fn > 0.0f) + return x * fn; + else + return x / (-fn); + } + if (rintf(fn) != fn) + return (fn - fn) / (fn - fn); + if (fn > 65000.0f) + return scalbnf(x, 65000); + if (-fn > 65000.0f) + return scalbnf(x, -65000); + return scalbnf(x, (int)fn); +} diff --git a/lib/libm/scalbln.c b/lib/libm/scalbln.c new file mode 100644 index 00000000..e6f3f195 --- /dev/null +++ b/lib/libm/scalbln.c @@ -0,0 +1,11 @@ +#include <limits.h> +#include <math.h> + +double scalbln(double x, long n) +{ + if (n > INT_MAX) + n = INT_MAX; + else if (n < INT_MIN) + n = INT_MIN; + return scalbn(x, n); +} diff --git a/lib/libm/scalblnf.c b/lib/libm/scalblnf.c new file mode 100644 index 00000000..d8e8166b --- /dev/null +++ b/lib/libm/scalblnf.c @@ -0,0 +1,11 @@ +#include <limits.h> +#include <math.h> + +float scalblnf(float x, long n) +{ + if (n > INT_MAX) + n = INT_MAX; + else if (n < INT_MIN) + n = INT_MIN; + return scalbnf(x, n); +} diff --git a/lib/libm/scalblnl.c b/lib/libm/scalblnl.c new file mode 100644 index 00000000..854c51c4 --- /dev/null +++ b/lib/libm/scalblnl.c @@ -0,0 +1,19 @@ +#include <limits.h> +#include <math.h> +#include <float.h> + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double scalblnl(long double x, long n) +{ + return scalbln(x, n); +} +#else +long double scalblnl(long double x, long n) +{ + if (n > INT_MAX) + n = INT_MAX; + else if (n < INT_MIN) + n = INT_MIN; + return scalbnl(x, n); +} +#endif diff --git a/lib/libm/scalbn.c b/lib/libm/scalbn.c new file mode 100644 index 00000000..d38d4338 --- /dev/null +++ b/lib/libm/scalbn.c @@ -0,0 +1,36 @@ +#include <math.h> +#include <stdint.h> + +double scalbn(double x, int n) +{ + union { + double f; + uint64_t i; + } u; + double_t y = x; + + if (n > 1023) { + y *= 0x1p1023; + n -= 1023; + if (n > 1023) { + y *= 0x1p1023; + n -= 1023; + if (n > 1023) + n = 1023; + } + } else if (n < -1022) { + /* make sure final n < -53 to avoid double + rounding in the subnormal range */ + y *= 0x1p-1022 * 0x1p53; + n += 1022 - 53; + if (n < -1022) { + y *= 0x1p-1022 * 0x1p53; + n += 1022 - 53; + if (n < -1022) + n = -1022; + } + } + u.i = (uint64_t)(0x3ff + n) << 52; + x = y * u.f; + return x; +} diff --git a/lib/libm/scalbnf.c b/lib/libm/scalbnf.c new file mode 100644 index 00000000..38b7d5b3 --- /dev/null +++ b/lib/libm/scalbnf.c @@ -0,0 +1,34 @@ +#include <math.h> +#include <stdint.h> + +float scalbnf(float x, int n) +{ + union { + float f; + uint32_t i; + } u; + float_t y = x; + + if (n > 127) { + y *= 0x1p127f; + n -= 127; + if (n > 127) { + y *= 0x1p127f; + n -= 127; + if (n > 127) + n = 127; + } + } else if (n < -126) { + y *= 0x1p-126f * 0x1p24f; + n += 126 - 24; + if (n < -126) { + y *= 0x1p-126f * 0x1p24f; + n += 126 - 24; + if (n < -126) + n = -126; + } + } + u.i = (uint32_t)(0x7f + n) << 23; + x = y * u.f; + return x; +} diff --git a/lib/libm/scalbnl.c b/lib/libm/scalbnl.c new file mode 100644 index 00000000..db44dab0 --- /dev/null +++ b/lib/libm/scalbnl.c @@ -0,0 +1,36 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double scalbnl(long double x, int n) +{ + return scalbn(x, n); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double scalbnl(long double x, int n) +{ + union ldshape u; + + if (n > 16383) { + x *= 0x1p16383L; + n -= 16383; + if (n > 16383) { + x *= 0x1p16383L; + n -= 16383; + if (n > 16383) + n = 16383; + } + } else if (n < -16382) { + x *= 0x1p-16382L * 0x1p113L; + n += 16382 - 113; + if (n < -16382) { + x *= 0x1p-16382L * 0x1p113L; + n += 16382 - 113; + if (n < -16382) + n = -16382; + } + } + u.f = 1.0; + u.i.se = 0x3fff + n; + return x * u.f; +} +#endif diff --git a/lib/libm/signgam.c b/lib/libm/signgam.c new file mode 100644 index 00000000..ee331b27 --- /dev/null +++ b/lib/libm/signgam.c @@ -0,0 +1,6 @@ +#include <math.h> +#include "libm.h" + +int __signgam = 0; + +weak_alias(__signgam, signgam); diff --git a/lib/libm/significand.c b/lib/libm/significand.c new file mode 100644 index 00000000..40d9aa9f --- /dev/null +++ b/lib/libm/significand.c @@ -0,0 +1,7 @@ +#define _GNU_SOURCE +#include <math.h> + +double significand(double x) +{ + return scalbn(x, -ilogb(x)); +} diff --git a/lib/libm/significandf.c b/lib/libm/significandf.c new file mode 100644 index 00000000..8a697e1a --- /dev/null +++ b/lib/libm/significandf.c @@ -0,0 +1,7 @@ +#define _GNU_SOURCE +#include <math.h> + +float significandf(float x) +{ + return scalbnf(x, -ilogbf(x)); +} diff --git a/lib/libm/sin.c b/lib/libm/sin.c new file mode 100644 index 00000000..d836c705 --- /dev/null +++ b/lib/libm/sin.c @@ -0,0 +1,82 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_sin.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* sin(x) + * Return sine function of x. + * + * kernel function: + * __sin ... sine function on [-pi/4,pi/4] + * __cos ... cose function on [-pi/4,pi/4] + * __rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "libm.h" + +double sin(double x) +{ + double y[2]; + uint32_t ix; + unsigned n; + + /* High word of x. */ + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + + /* |x| ~< pi/4 */ + if (ix <= 0x3fe921fb) { + if (ix < 0x3e500000) { /* |x| < 2**-26 */ + /* raise inexact if x != 0 and underflow if subnormal*/ + FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : + x + 0x1p120f); + return x; + } + return __sin(x, 0.0, 0); + } + + /* sin(Inf or NaN) is NaN */ + if (ix >= 0x7ff00000) + return x - x; + + /* argument reduction needed */ + n = __rem_pio2(x, y); + switch (n & 3) { + case 0: + return __sin(y[0], y[1], 1); + case 1: + return __cos(y[0], y[1]); + case 2: + return -__sin(y[0], y[1], 1); + default: + return -__cos(y[0], y[1]); + } +} diff --git a/lib/libm/sincos.c b/lib/libm/sincos.c new file mode 100644 index 00000000..50f22f46 --- /dev/null +++ b/lib/libm/sincos.c @@ -0,0 +1,70 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_sin.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#define _GNU_SOURCE +#include "libm.h" + +void sincos(double x, double *sin, double *cos) +{ + double y[2], s, c; + uint32_t ix; + unsigned n; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + + /* |x| ~< pi/4 */ + if (ix <= 0x3fe921fb) { + /* if |x| < 2**-27 * sqrt(2) */ + if (ix < 0x3e46a09e) { + /* raise inexact if x!=0 and underflow if subnormal */ + FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : + x + 0x1p120f); + *sin = x; + *cos = 1.0; + return; + } + *sin = __sin(x, 0.0, 0); + *cos = __cos(x, 0.0); + return; + } + + /* sincos(Inf or NaN) is NaN */ + if (ix >= 0x7ff00000) { + *sin = *cos = x - x; + return; + } + + /* argument reduction needed */ + n = __rem_pio2(x, y); + s = __sin(y[0], y[1], 1); + c = __cos(y[0], y[1]); + switch (n & 3) { + case 0: + *sin = s; + *cos = c; + break; + case 1: + *sin = c; + *cos = -s; + break; + case 2: + *sin = -s; + *cos = -c; + break; + case 3: + default: + *sin = -c; + *cos = s; + break; + } +} diff --git a/lib/libm/sincosf.c b/lib/libm/sincosf.c new file mode 100644 index 00000000..359c41cb --- /dev/null +++ b/lib/libm/sincosf.c @@ -0,0 +1,117 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_sinf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#define _GNU_SOURCE +#include "libm.h" + +/* Small multiples of pi/2 rounded to double precision. */ +static const double s1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */ + s2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */ + s3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */ + s4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */ + +void sincosf(float x, float *sin, float *cos) +{ + double y; + float_t s, c; + uint32_t ix; + unsigned n, sign; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + + /* |x| ~<= pi/4 */ + if (ix <= 0x3f490fda) { + /* |x| < 2**-12 */ + if (ix < 0x39800000) { + /* raise inexact if x!=0 and underflow if subnormal */ + FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : + x + 0x1p120f); + *sin = x; + *cos = 1.0f; + return; + } + *sin = __sindf(x); + *cos = __cosdf(x); + return; + } + + /* |x| ~<= 5*pi/4 */ + if (ix <= 0x407b53d1) { + if (ix <= 0x4016cbe3) { /* |x| ~<= 3pi/4 */ + if (sign) { + *sin = -__cosdf(x + s1pio2); + *cos = __sindf(x + s1pio2); + } else { + *sin = __cosdf(s1pio2 - x); + *cos = __sindf(s1pio2 - x); + } + return; + } + /* -sin(x+c) is not correct if x+c could be 0: -0 vs +0 */ + *sin = -__sindf(sign ? x + s2pio2 : x - s2pio2); + *cos = -__cosdf(sign ? x + s2pio2 : x - s2pio2); + return; + } + + /* |x| ~<= 9*pi/4 */ + if (ix <= 0x40e231d5) { + if (ix <= 0x40afeddf) { /* |x| ~<= 7*pi/4 */ + if (sign) { + *sin = __cosdf(x + s3pio2); + *cos = -__sindf(x + s3pio2); + } else { + *sin = -__cosdf(x - s3pio2); + *cos = __sindf(x - s3pio2); + } + return; + } + *sin = __sindf(sign ? x + s4pio2 : x - s4pio2); + *cos = __cosdf(sign ? x + s4pio2 : x - s4pio2); + return; + } + + /* sin(Inf or NaN) is NaN */ + if (ix >= 0x7f800000) { + *sin = *cos = x - x; + return; + } + + /* general argument reduction needed */ + n = __rem_pio2f(x, &y); + s = __sindf(y); + c = __cosdf(y); + switch (n & 3) { + case 0: + *sin = s; + *cos = c; + break; + case 1: + *sin = c; + *cos = -s; + break; + case 2: + *sin = -s; + *cos = -c; + break; + case 3: + default: + *sin = -c; + *cos = s; + break; + } +} diff --git a/lib/libm/sincosl.c b/lib/libm/sincosl.c new file mode 100644 index 00000000..21b19945 --- /dev/null +++ b/lib/libm/sincosl.c @@ -0,0 +1,61 @@ +#define _GNU_SOURCE +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +void sincosl(long double x, long double *sin, long double *cos) +{ + double sind, cosd; + sincos(x, &sind, &cosd); + *sin = sind; + *cos = cosd; +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +void sincosl(long double x, long double *sin, long double *cos) +{ + union ldshape u = { x }; + unsigned n; + long double y[2], s, c; + + u.i.se &= 0x7fff; + if (u.i.se == 0x7fff) { + *sin = *cos = x - x; + return; + } + if (u.f < M_PI_4) { + if (u.i.se < 0x3fff - LDBL_MANT_DIG) { + /* raise underflow if subnormal */ + if (u.i.se == 0) + FORCE_EVAL(x * 0x1p-120f); + *sin = x; + /* raise inexact if x!=0 */ + *cos = 1.0 + x; + return; + } + *sin = __sinl(x, 0, 0); + *cos = __cosl(x, 0); + return; + } + n = __rem_pio2l(x, y); + s = __sinl(y[0], y[1], 1); + c = __cosl(y[0], y[1]); + switch (n & 3) { + case 0: + *sin = s; + *cos = c; + break; + case 1: + *sin = c; + *cos = -s; + break; + case 2: + *sin = -s; + *cos = -c; + break; + case 3: + default: + *sin = -c; + *cos = s; + break; + } +} +#endif diff --git a/lib/libm/sinf.c b/lib/libm/sinf.c new file mode 100644 index 00000000..f835ef8a --- /dev/null +++ b/lib/libm/sinf.c @@ -0,0 +1,79 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_sinf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +/* Small multiples of pi/2 rounded to double precision. */ +static const double s1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */ + s2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */ + s3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */ + s4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */ + +float sinf(float x) +{ + double y; + uint32_t ix; + int n, sign; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + + if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */ + if (ix < 0x39800000) { /* |x| < 2**-12 */ + /* raise inexact if x!=0 and underflow if subnormal */ + FORCE_EVAL(ix < 0x00800000 ? x / 0x1p120f : + x + 0x1p120f); + return x; + } + return __sindf(x); + } + if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */ + if (ix <= 0x4016cbe3) { /* |x| ~<= 3pi/4 */ + if (sign) + return -__cosdf(x + s1pio2); + else + return __cosdf(x - s1pio2); + } + return __sindf(sign ? -(x + s2pio2) : -(x - s2pio2)); + } + if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */ + if (ix <= 0x40afeddf) { /* |x| ~<= 7*pi/4 */ + if (sign) + return __cosdf(x + s3pio2); + else + return -__cosdf(x - s3pio2); + } + return __sindf(sign ? x + s4pio2 : x - s4pio2); + } + + /* sin(Inf or NaN) is NaN */ + if (ix >= 0x7f800000) + return x - x; + + /* general argument reduction needed */ + n = __rem_pio2f(x, &y); + switch (n & 3) { + case 0: + return __sindf(y); + case 1: + return __cosdf(y); + case 2: + return __sindf(-y); + default: + return -__cosdf(y); + } +} diff --git a/lib/libm/sinh.c b/lib/libm/sinh.c new file mode 100644 index 00000000..b2b6e813 --- /dev/null +++ b/lib/libm/sinh.c @@ -0,0 +1,44 @@ +#include "libm.h" + +/* sinh(x) = (exp(x) - 1/exp(x))/2 + * = (exp(x)-1 + (exp(x)-1)/exp(x))/2 + * = x + x^3/6 + o(x^5) + */ +double sinh(double x) +{ + union { + double f; + uint64_t i; + } u = { .f = x }; + uint32_t w; + double t, h, absx; + + h = 0.5; + if (u.i >> 63) + h = -h; + /* |x| */ + u.i &= (uint64_t)-1 / 2; + absx = u.f; + w = u.i >> 32; + + /* |x| < log(DBL_MAX) */ + if (w < 0x40862e42) { + t = expm1(absx); + if (w < 0x3ff00000) { + if (w < 0x3ff00000 - (26 << 20)) + /* note: inexact and underflow are raised by + * expm1 */ + /* note: this branch avoids spurious underflow + */ + return x; + return h * (2 * t - t * t / (t + 1)); + } + /* note: |x|>log(0x1p26)+eps could be just h*exp(x) */ + return h * (t + t / (t + 1)); + } + + /* |x| > log(DBL_MAX) or nan */ + /* note: the result is stored to handle overflow */ + t = __expo2(absx, 2 * h); + return t; +} diff --git a/lib/libm/sinhf.c b/lib/libm/sinhf.c new file mode 100644 index 00000000..e5bd1a2a --- /dev/null +++ b/lib/libm/sinhf.c @@ -0,0 +1,34 @@ +#include "libm.h" + +float sinhf(float x) +{ + union { + float f; + uint32_t i; + } u = { .f = x }; + uint32_t w; + float t, h, absx; + + h = 0.5; + if (u.i >> 31) + h = -h; + /* |x| */ + u.i &= 0x7fffffff; + absx = u.f; + w = u.i; + + /* |x| < log(FLT_MAX) */ + if (w < 0x42b17217) { + t = expm1f(absx); + if (w < 0x3f800000) { + if (w < 0x3f800000 - (12 << 23)) + return x; + return h * (2 * t - t * t / (t + 1)); + } + return h * (t + t / (t + 1)); + } + + /* |x| > logf(FLT_MAX) or nan */ + t = __expo2f(absx, 2 * h); + return t; +} diff --git a/lib/libm/sinhl.c b/lib/libm/sinhl.c new file mode 100644 index 00000000..55dc20a2 --- /dev/null +++ b/lib/libm/sinhl.c @@ -0,0 +1,44 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double sinhl(long double x) +{ + return sinh(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +long double sinhl(long double x) +{ + union ldshape u = { x }; + unsigned ex = u.i.se & 0x7fff; + long double h, t, absx; + + h = 0.5; + if (u.i.se & 0x8000) + h = -h; + /* |x| */ + u.i.se = ex; + absx = u.f; + + /* |x| < log(LDBL_MAX) */ + if (ex < 0x3fff + 13 || + (ex == 0x3fff + 13 && u.i.m >> 32 < 0xb17217f7)) { + t = expm1l(absx); + if (ex < 0x3fff) { + if (ex < 0x3fff - 32) + return x; + return h * (2 * t - t * t / (1 + t)); + } + return h * (t + t / (t + 1)); + } + + /* |x| > log(LDBL_MAX) or nan */ + t = expl(0.5 * absx); + return h * t * t; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double sinhl(long double x) +{ + return sinh(x); +} +#endif diff --git a/lib/libm/sinl.c b/lib/libm/sinl.c new file mode 100644 index 00000000..bb1352f1 --- /dev/null +++ b/lib/libm/sinl.c @@ -0,0 +1,41 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double sinl(long double x) +{ + return sin(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double sinl(long double x) +{ + union ldshape u = { x }; + unsigned n; + long double y[2], hi, lo; + + u.i.se &= 0x7fff; + if (u.i.se == 0x7fff) + return x - x; + if (u.f < M_PI_4) { + if (u.i.se < 0x3fff - LDBL_MANT_DIG / 2) { + /* raise inexact if x!=0 and underflow if subnormal */ + FORCE_EVAL(u.i.se == 0 ? x * 0x1p-120f : x + 0x1p120f); + return x; + } + return __sinl(x, 0.0, 0); + } + n = __rem_pio2l(x, y); + hi = y[0]; + lo = y[1]; + switch (n & 3) { + case 0: + return __sinl(hi, lo, 1); + case 1: + return __cosl(hi, lo); + case 2: + return -__sinl(hi, lo, 1); + case 3: + default: + return -__cosl(hi, lo); + } +} +#endif diff --git a/lib/libm/sqrt.c b/lib/libm/sqrt.c new file mode 100644 index 00000000..9c54b70c --- /dev/null +++ b/lib/libm/sqrt.c @@ -0,0 +1,159 @@ +#include <stdint.h> +#include <math.h> +#include "libm.h" +#include "sqrt_data.h" + +#define FENV_SUPPORT 1 + +/* returns a*b*2^-32 - e, with error 0 <= e < 1. */ +static inline uint32_t mul32(uint32_t a, uint32_t b) +{ + return (uint64_t)a * b >> 32; +} + +/* returns a*b*2^-64 - e, with error 0 <= e < 3. */ +static inline uint64_t mul64(uint64_t a, uint64_t b) +{ + uint64_t ahi = a >> 32; + uint64_t alo = a & 0xffffffff; + uint64_t bhi = b >> 32; + uint64_t blo = b & 0xffffffff; + return ahi * bhi + (ahi * blo >> 32) + (alo * bhi >> 32); +} + +double sqrt(double x) +{ + uint64_t ix, top, m; + + /* special case handling. */ + ix = asuint64(x); + top = ix >> 52; + if (predict_false(top - 0x001 >= 0x7ff - 0x001)) { + /* x < 0x1p-1022 or inf or nan. */ + if (ix * 2 == 0) + return x; + if (ix == 0x7ff0000000000000) + return x; + if (ix > 0x7ff0000000000000) + return __math_invalid(x); + /* x is subnormal, normalize it. */ + ix = asuint64(x * 0x1p52); + top = ix >> 52; + top -= 52; + } + + /* argument reduction: + x = 4^e m; with integer e, and m in [1, 4) + m: fixed point representation [2.62] + 2^e is the exponent part of the result. */ + int even = top & 1; + m = (ix << 11) | 0x8000000000000000; + if (even) + m >>= 1; + top = (top + 0x3ff) >> 1; + + /* approximate r ~ 1/sqrt(m) and s ~ sqrt(m) when m in [1,4) + + initial estimate: + 7bit table lookup (1bit exponent and 6bit significand). + + iterative approximation: + using 2 goldschmidt iterations with 32bit int arithmetics + and a final iteration with 64bit int arithmetics. + + details: + + the relative error (e = r0 sqrt(m)-1) of a linear estimate + (r0 = a m + b) is |e| < 0.085955 ~ 0x1.6p-4 at best, + a table lookup is faster and needs one less iteration + 6 bit lookup table (128b) gives |e| < 0x1.f9p-8 + 7 bit lookup table (256b) gives |e| < 0x1.fdp-9 + for single and double prec 6bit is enough but for quad + prec 7bit is needed (or modified iterations). to avoid + one more iteration >=13bit table would be needed (16k). + + a newton-raphson iteration for r is + w = r*r + u = 3 - m*w + r = r*u/2 + can use a goldschmidt iteration for s at the end or + s = m*r + + first goldschmidt iteration is + s = m*r + u = 3 - s*r + r = r*u/2 + s = s*u/2 + next goldschmidt iteration is + u = 3 - s*r + r = r*u/2 + s = s*u/2 + and at the end r is not computed only s. + + they use the same amount of operations and converge at the + same quadratic rate, i.e. if + r1 sqrt(m) - 1 = e, then + r2 sqrt(m) - 1 = -3/2 e^2 - 1/2 e^3 + the advantage of goldschmidt is that the mul for s and r + are independent (computed in parallel), however it is not + "self synchronizing": it only uses the input m in the + first iteration so rounding errors accumulate. at the end + or when switching to larger precision arithmetics rounding + errors dominate so the first iteration should be used. + + the fixed point representations are + m: 2.30 r: 0.32, s: 2.30, d: 2.30, u: 2.30, three: 2.30 + and after switching to 64 bit + m: 2.62 r: 0.64, s: 2.62, d: 2.62, u: 2.62, three: 2.62 */ + + static const uint64_t three = 0xc0000000; + uint64_t r, s, d, u, i; + + i = (ix >> 46) % 128; + r = (uint32_t)__rsqrt_tab[i] << 16; + /* |r sqrt(m) - 1| < 0x1.fdp-9 */ + s = mul32(m >> 32, r); + /* |s/sqrt(m) - 1| < 0x1.fdp-9 */ + d = mul32(s, r); + u = three - d; + r = mul32(r, u) << 1; + /* |r sqrt(m) - 1| < 0x1.7bp-16 */ + s = mul32(s, u) << 1; + /* |s/sqrt(m) - 1| < 0x1.7bp-16 */ + d = mul32(s, r); + u = three - d; + r = mul32(r, u) << 1; + /* |r sqrt(m) - 1| < 0x1.3704p-29 (measured worst-case) */ + r = r << 32; + s = mul64(m, r); + d = mul64(s, r); + u = (three << 32) - d; + s = mul64(s, u); /* repr: 3.61 */ + /* -0x1p-57 < s - sqrt(m) < 0x1.8001p-61 */ + s = (s - 2) >> 9; /* repr: 12.52 */ + /* -0x1.09p-52 < s - sqrt(m) < -0x1.fffcp-63 */ + + /* s < sqrt(m) < s + 0x1.09p-52, + compute nearest rounded result: + the nearest result to 52 bits is either s or s+0x1p-52, + we can decide by comparing (2^52 s + 0.5)^2 to 2^104 m. */ + uint64_t d0, d1, d2; + double y, t; + d0 = (m << 42) - s * s; + d1 = s - d0; + d2 = d1 + s + 1; + s += d1 >> 63; + s &= 0x000fffffffffffff; + s |= top << 52; + y = asdouble(s); + if (FENV_SUPPORT) { + /* handle rounding modes and inexact exception: + only (s+1)^2 == 2^42 m case is exact otherwise + add a tiny value to cause the fenv effects. */ + uint64_t tiny = predict_false(d2 == 0) ? 0 : 0x0010000000000000; + tiny |= (d1 ^ d2) & 0x8000000000000000; + t = asdouble(tiny); + y = eval_as_double(y + t); + } + return y; +} diff --git a/lib/libm/sqrt_data.c b/lib/libm/sqrt_data.c new file mode 100644 index 00000000..4b15ae2b --- /dev/null +++ b/lib/libm/sqrt_data.c @@ -0,0 +1,18 @@ +#include "sqrt_data.h" +const uint16_t __rsqrt_tab[128] = { + 0xb451, 0xb2f0, 0xb196, 0xb044, 0xaef9, 0xadb6, 0xac79, 0xab43, 0xaa14, + 0xa8eb, 0xa7c8, 0xa6aa, 0xa592, 0xa480, 0xa373, 0xa26b, 0xa168, 0xa06a, + 0x9f70, 0x9e7b, 0x9d8a, 0x9c9d, 0x9bb5, 0x9ad1, 0x99f0, 0x9913, 0x983a, + 0x9765, 0x9693, 0x95c4, 0x94f8, 0x9430, 0x936b, 0x92a9, 0x91ea, 0x912e, + 0x9075, 0x8fbe, 0x8f0a, 0x8e59, 0x8daa, 0x8cfe, 0x8c54, 0x8bac, 0x8b07, + 0x8a64, 0x89c4, 0x8925, 0x8889, 0x87ee, 0x8756, 0x86c0, 0x862b, 0x8599, + 0x8508, 0x8479, 0x83ec, 0x8361, 0x82d8, 0x8250, 0x81c9, 0x8145, 0x80c2, + 0x8040, 0xff02, 0xfd0e, 0xfb25, 0xf947, 0xf773, 0xf5aa, 0xf3ea, 0xf234, + 0xf087, 0xeee3, 0xed47, 0xebb3, 0xea27, 0xe8a3, 0xe727, 0xe5b2, 0xe443, + 0xe2dc, 0xe17a, 0xe020, 0xdecb, 0xdd7d, 0xdc34, 0xdaf1, 0xd9b3, 0xd87b, + 0xd748, 0xd61a, 0xd4f1, 0xd3cd, 0xd2ad, 0xd192, 0xd07b, 0xcf69, 0xce5b, + 0xcd51, 0xcc4a, 0xcb48, 0xca4a, 0xc94f, 0xc858, 0xc764, 0xc674, 0xc587, + 0xc49d, 0xc3b7, 0xc2d4, 0xc1f4, 0xc116, 0xc03c, 0xbf65, 0xbe90, 0xbdbe, + 0xbcef, 0xbc23, 0xbb59, 0xba91, 0xb9cc, 0xb90a, 0xb84a, 0xb78c, 0xb6d0, + 0xb617, 0xb560, +}; diff --git a/lib/libm/sqrt_data.h b/lib/libm/sqrt_data.h new file mode 100644 index 00000000..f5929b8d --- /dev/null +++ b/lib/libm/sqrt_data.h @@ -0,0 +1,14 @@ +#ifndef _SQRT_DATA_H +#define _SQRT_DATA_H + +#include <stdint.h> + +#define hidden __attribute__((visibility("hidden"))) + +/* if x in [1,2): i = (int)(64*x); + if x in [2,4): i = (int)(32*x-64); + __rsqrt_tab[i]*2^-16 is estimating 1/sqrt(x) with small relative error: + |__rsqrt_tab[i]*0x1p-16*sqrt(x) - 1| < -0x1.fdp-9 < 2^-8 */ +extern hidden const uint16_t __rsqrt_tab[128]; + +#endif diff --git a/lib/libm/sqrtf.c b/lib/libm/sqrtf.c new file mode 100644 index 00000000..b9cd7961 --- /dev/null +++ b/lib/libm/sqrtf.c @@ -0,0 +1,83 @@ +#include <stdint.h> +#include <math.h> +#include "libm.h" +#include "sqrt_data.h" + +#define FENV_SUPPORT 1 + +static inline uint32_t mul32(uint32_t a, uint32_t b) +{ + return (uint64_t)a * b >> 32; +} + +/* see sqrt.c for more detailed comments. */ + +float sqrtf(float x) +{ + uint32_t ix, m, m1, m0, even, ey; + + ix = asuint(x); + if (predict_false(ix - 0x00800000 >= 0x7f800000 - 0x00800000)) { + /* x < 0x1p-126 or inf or nan. */ + if (ix * 2 == 0) + return x; + if (ix == 0x7f800000) + return x; + if (ix > 0x7f800000) + return __math_invalidf(x); + /* x is subnormal, normalize it. */ + ix = asuint(x * 0x1p23f); + ix -= 23 << 23; + } + + /* x = 4^e m; with int e and m in [1, 4). */ + even = ix & 0x00800000; + m1 = (ix << 8) | 0x80000000; + m0 = (ix << 7) & 0x7fffffff; + m = even ? m0 : m1; + + /* 2^e is the exponent part of the return value. */ + ey = ix >> 1; + ey += 0x3f800000 >> 1; + ey &= 0x7f800000; + + /* compute r ~ 1/sqrt(m), s ~ sqrt(m) with 2 goldschmidt iterations. */ + static const uint32_t three = 0xc0000000; + uint32_t r, s, d, u, i; + i = (ix >> 17) % 128; + r = (uint32_t)__rsqrt_tab[i] << 16; + /* |r*sqrt(m) - 1| < 0x1p-8 */ + s = mul32(m, r); + /* |s/sqrt(m) - 1| < 0x1p-8 */ + d = mul32(s, r); + u = three - d; + r = mul32(r, u) << 1; + /* |r*sqrt(m) - 1| < 0x1.7bp-16 */ + s = mul32(s, u) << 1; + /* |s/sqrt(m) - 1| < 0x1.7bp-16 */ + d = mul32(s, r); + u = three - d; + s = mul32(s, u); + /* -0x1.03p-28 < s/sqrt(m) - 1 < 0x1.fp-31 */ + s = (s - 1) >> 6; + /* s < sqrt(m) < s + 0x1.08p-23 */ + + /* compute nearest rounded result. */ + uint32_t d0, d1, d2; + float y, t; + d0 = (m << 16) - s * s; + d1 = s - d0; + d2 = d1 + s + 1; + s += d1 >> 31; + s &= 0x007fffff; + s |= ey; + y = asfloat(s); + if (FENV_SUPPORT) { + /* handle rounding and inexact exception. */ + uint32_t tiny = predict_false(d2 == 0) ? 0 : 0x01000000; + tiny |= (d1 ^ d2) & 0x80000000; + t = asfloat(tiny); + y = eval_as_float(y + t); + } + return y; +} diff --git a/lib/libm/sqrtl.c b/lib/libm/sqrtl.c new file mode 100644 index 00000000..57249e9f --- /dev/null +++ b/lib/libm/sqrtl.c @@ -0,0 +1,261 @@ +#include <stdint.h> +#include <math.h> +#include <float.h> +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double sqrtl(long double x) +{ + return sqrt(x); +} +#elif (LDBL_MANT_DIG == 113 || LDBL_MANT_DIG == 64) && LDBL_MAX_EXP == 16384 +#include "sqrt_data.h" + +#define FENV_SUPPORT 1 + +typedef struct { + uint64_t hi; + uint64_t lo; +} u128; + +/* top: 16 bit sign+exponent, x: significand. */ +static inline long double mkldbl(uint64_t top, u128 x) +{ + union ldshape u; +#if LDBL_MANT_DIG == 113 + u.i2.hi = x.hi; + u.i2.lo = x.lo; + u.i2.hi &= 0x0000ffffffffffff; + u.i2.hi |= top << 48; +#elif LDBL_MANT_DIG == 64 + u.i.se = top; + u.i.m = x.lo; + /* force the top bit on non-zero (and non-subnormal) results. */ + if (top & 0x7fff) + u.i.m |= 0x8000000000000000; +#endif + return u.f; +} + +/* return: top 16 bit is sign+exp and following bits are the significand. */ +static inline u128 asu128(long double x) +{ + union ldshape u = { .f = x }; + u128 r; +#if LDBL_MANT_DIG == 113 + r.hi = u.i2.hi; + r.lo = u.i2.lo; +#elif LDBL_MANT_DIG == 64 + r.lo = u.i.m << 49; + /* ignore the top bit: pseudo numbers are not handled. */ + r.hi = u.i.m >> 15; + r.hi &= 0x0000ffffffffffff; + r.hi |= (uint64_t)u.i.se << 48; +#endif + return r; +} + +/* returns a*b*2^-32 - e, with error 0 <= e < 1. */ +static inline uint32_t mul32(uint32_t a, uint32_t b) +{ + return (uint64_t)a * b >> 32; +} + +/* returns a*b*2^-64 - e, with error 0 <= e < 3. */ +static inline uint64_t mul64(uint64_t a, uint64_t b) +{ + uint64_t ahi = a >> 32; + uint64_t alo = a & 0xffffffff; + uint64_t bhi = b >> 32; + uint64_t blo = b & 0xffffffff; + return ahi * bhi + (ahi * blo >> 32) + (alo * bhi >> 32); +} + +static inline u128 add64(u128 a, uint64_t b) +{ + u128 r; + r.lo = a.lo + b; + r.hi = a.hi; + if (r.lo < a.lo) + r.hi++; + return r; +} + +static inline u128 add128(u128 a, u128 b) +{ + u128 r; + r.lo = a.lo + b.lo; + r.hi = a.hi + b.hi; + if (r.lo < a.lo) + r.hi++; + return r; +} + +static inline u128 sub64(u128 a, uint64_t b) +{ + u128 r; + r.lo = a.lo - b; + r.hi = a.hi; + if (a.lo < b) + r.hi--; + return r; +} + +static inline u128 sub128(u128 a, u128 b) +{ + u128 r; + r.lo = a.lo - b.lo; + r.hi = a.hi - b.hi; + if (a.lo < b.lo) + r.hi--; + return r; +} + +/* a<<n, 0 <= n <= 127 */ +static inline u128 lsh(u128 a, int n) +{ + if (n == 0) + return a; + if (n >= 64) { + a.hi = a.lo << (n - 64); + a.lo = 0; + } else { + a.hi = (a.hi << n) | (a.lo >> (64 - n)); + a.lo = a.lo << n; + } + return a; +} + +/* a>>n, 0 <= n <= 127 */ +static inline u128 rsh(u128 a, int n) +{ + if (n == 0) + return a; + if (n >= 64) { + a.lo = a.hi >> (n - 64); + a.hi = 0; + } else { + a.lo = (a.lo >> n) | (a.hi << (64 - n)); + a.hi = a.hi >> n; + } + return a; +} + +/* returns a*b exactly. */ +static inline u128 mul64_128(uint64_t a, uint64_t b) +{ + u128 r; + uint64_t ahi = a >> 32; + uint64_t alo = a & 0xffffffff; + uint64_t bhi = b >> 32; + uint64_t blo = b & 0xffffffff; + uint64_t lo1 = ((ahi * blo) & 0xffffffff) + ((alo * bhi) & 0xffffffff) + + (alo * blo >> 32); + uint64_t lo2 = (alo * blo) & 0xffffffff; + r.hi = ahi * bhi + (ahi * blo >> 32) + (alo * bhi >> 32) + (lo1 >> 32); + r.lo = (lo1 << 32) + lo2; + return r; +} + +/* returns a*b*2^-128 - e, with error 0 <= e < 7. */ +static inline u128 mul128(u128 a, u128 b) +{ + u128 hi = mul64_128(a.hi, b.hi); + uint64_t m1 = mul64(a.hi, b.lo); + uint64_t m2 = mul64(a.lo, b.hi); + return add64(add64(hi, m1), m2); +} + +/* returns a*b % 2^128. */ +static inline u128 mul128_tail(u128 a, u128 b) +{ + u128 lo = mul64_128(a.lo, b.lo); + lo.hi += a.hi * b.lo + a.lo * b.hi; + return lo; +} + +/* see sqrt.c for detailed comments. */ + +long double sqrtl(long double x) +{ + u128 ix, ml; + uint64_t top; + + ix = asu128(x); + top = ix.hi >> 48; + if (predict_false(top - 0x0001 >= 0x7fff - 0x0001)) { + /* x < 0x1p-16382 or inf or nan. */ + if (2 * ix.hi == 0 && ix.lo == 0) + return x; + if (ix.hi == 0x7fff000000000000 && ix.lo == 0) + return x; + if (top >= 0x7fff) + return __math_invalidl(x); + /* x is subnormal, normalize it. */ + ix = asu128(x * 0x1p112); + top = ix.hi >> 48; + top -= 112; + } + + /* x = 4^e m; with int e and m in [1, 4) */ + int even = top & 1; + ml = lsh(ix, 15); + ml.hi |= 0x8000000000000000; + if (even) + ml = rsh(ml, 1); + top = (top + 0x3fff) >> 1; + + /* r ~ 1/sqrt(m) */ + const uint64_t three = 0xc0000000; + uint64_t r, s, d, u, i; + i = (ix.hi >> 42) % 128; + r = (uint32_t)__rsqrt_tab[i] << 16; + /* |r sqrt(m) - 1| < 0x1p-8 */ + s = mul32(ml.hi >> 32, r); + d = mul32(s, r); + u = three - d; + r = mul32(u, r) << 1; + /* |r sqrt(m) - 1| < 0x1.7bp-16, switch to 64bit */ + r = r << 32; + s = mul64(ml.hi, r); + d = mul64(s, r); + u = (three << 32) - d; + r = mul64(u, r) << 1; + /* |r sqrt(m) - 1| < 0x1.a5p-31 */ + s = mul64(u, s) << 1; + d = mul64(s, r); + u = (three << 32) - d; + r = mul64(u, r) << 1; + /* |r sqrt(m) - 1| < 0x1.c001p-59, switch to 128bit */ + + const u128 threel = { .hi = three << 32, .lo = 0 }; + u128 rl, sl, dl, ul; + rl.hi = r; + rl.lo = 0; + sl = mul128(ml, rl); + dl = mul128(sl, rl); + ul = sub128(threel, dl); + sl = mul128(ul, sl); /* repr: 3.125 */ + /* -0x1p-116 < s - sqrt(m) < 0x3.8001p-125 */ + sl = rsh(sub64(sl, 4), 125 - (LDBL_MANT_DIG - 1)); + /* s < sqrt(m) < s + 1 ULP + tiny */ + + long double y; + u128 d2, d1, d0; + d0 = sub128(lsh(ml, 2 * (LDBL_MANT_DIG - 1) - 126), + mul128_tail(sl, sl)); + d1 = sub128(sl, d0); + d2 = add128(add64(sl, 1), d1); + sl = add64(sl, d1.hi >> 63); + y = mkldbl(top, sl); + if (FENV_SUPPORT) { + /* handle rounding modes and inexact exception. */ + top = predict_false((d2.hi | d2.lo) == 0) ? 0 : 1; + top |= ((d1.hi ^ d2.hi) & 0x8000000000000000) >> 48; + y += mkldbl(top, (u128){ 0 }); + } + return y; +} +#else +#error unsupported long double format +#endif diff --git a/lib/libm/tan.c b/lib/libm/tan.c new file mode 100644 index 00000000..ecdf5515 --- /dev/null +++ b/lib/libm/tan.c @@ -0,0 +1,71 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_tan.c */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* tan(x) + * Return tangent function of x. + * + * kernel function: + * __tan ... tangent function on [-pi/4,pi/4] + * __rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "libm.h" + +double tan(double x) +{ + double y[2]; + uint32_t ix; + unsigned n; + + GET_HIGH_WORD(ix, x); + ix &= 0x7fffffff; + + /* |x| ~< pi/4 */ + if (ix <= 0x3fe921fb) { + if (ix < 0x3e400000) { /* |x| < 2**-27 */ + /* raise inexact if x!=0 and underflow if subnormal */ + FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : + x + 0x1p120f); + return x; + } + return __tan(x, 0.0, 0); + } + + /* tan(Inf or NaN) is NaN */ + if (ix >= 0x7ff00000) + return x - x; + + /* argument reduction */ + n = __rem_pio2(x, y); + return __tan(y[0], y[1], n & 1); +} diff --git a/lib/libm/tanf.c b/lib/libm/tanf.c new file mode 100644 index 00000000..1007aa91 --- /dev/null +++ b/lib/libm/tanf.c @@ -0,0 +1,64 @@ +/* origin: FreeBSD /usr/src/lib/msun/src/s_tanf.c */ +/* + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + * Optimized by Bruce D. Evans. + */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "libm.h" + +/* Small multiples of pi/2 rounded to double precision. */ +static const double t1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */ + t2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */ + t3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */ + t4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */ + +float tanf(float x) +{ + double y; + uint32_t ix; + unsigned n, sign; + + GET_FLOAT_WORD(ix, x); + sign = ix >> 31; + ix &= 0x7fffffff; + + if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */ + if (ix < 0x39800000) { /* |x| < 2**-12 */ + /* raise inexact if x!=0 and underflow if subnormal */ + FORCE_EVAL(ix < 0x00800000 ? x / 0x1p120f : + x + 0x1p120f); + return x; + } + return __tandf(x, 0); + } + if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */ + if (ix <= 0x4016cbe3) /* |x| ~<= 3pi/4 */ + return __tandf((sign ? x + t1pio2 : x - t1pio2), 1); + else + return __tandf((sign ? x + t2pio2 : x - t2pio2), 0); + } + if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */ + if (ix <= 0x40afeddf) /* |x| ~<= 7*pi/4 */ + return __tandf((sign ? x + t3pio2 : x - t3pio2), 1); + else + return __tandf((sign ? x + t4pio2 : x - t4pio2), 0); + } + + /* tan(Inf or NaN) is NaN */ + if (ix >= 0x7f800000) + return x - x; + + /* argument reduction */ + n = __rem_pio2f(x, &y); + return __tandf(y, n & 1); +} diff --git a/lib/libm/tanh.c b/lib/libm/tanh.c new file mode 100644 index 00000000..b32bf0b6 --- /dev/null +++ b/lib/libm/tanh.c @@ -0,0 +1,49 @@ +#include "libm.h" + +/* tanh(x) = (exp(x) - exp(-x))/(exp(x) + exp(-x)) + * = (exp(2*x) - 1)/(exp(2*x) - 1 + 2) + * = (1 - exp(-2*x))/(exp(-2*x) - 1 + 2) + */ +double tanh(double x) +{ + union { + double f; + uint64_t i; + } u = { .f = x }; + uint32_t w; + int sign; + double_t t; + + /* x = |x| */ + sign = u.i >> 63; + u.i &= (uint64_t)-1 / 2; + x = u.f; + w = u.i >> 32; + + if (w > 0x3fe193ea) { + /* |x| > log(3)/2 ~= 0.5493 or nan */ + if (w > 0x40340000) { + /* |x| > 20 or nan */ + /* note: this branch avoids raising overflow */ + t = 1 - 0 / x; + } else { + t = expm1(2 * x); + t = 1 - 2 / (t + 2); + } + } else if (w > 0x3fd058ae) { + /* |x| > log(5/3)/2 ~= 0.2554 */ + t = expm1(2 * x); + t = t / (t + 2); + } else if (w >= 0x00100000) { + /* |x| >= 0x1p-1022, up to 2ulp error in [0.1,0.2554] */ + t = expm1(-2 * x); + t = -t / (t + 2); + } else { + /* |x| is subnormal */ + /* note: the branch above would not raise underflow in + * [0x1p-1023,0x1p-1022) */ + FORCE_EVAL((float)x); + t = x; + } + return sign ? -t : t; +} diff --git a/lib/libm/tanhf.c b/lib/libm/tanhf.c new file mode 100644 index 00000000..f4ae759d --- /dev/null +++ b/lib/libm/tanhf.c @@ -0,0 +1,42 @@ +#include "libm.h" + +float tanhf(float x) +{ + union { + float f; + uint32_t i; + } u = { .f = x }; + uint32_t w; + int sign; + float t; + + /* x = |x| */ + sign = u.i >> 31; + u.i &= 0x7fffffff; + x = u.f; + w = u.i; + + if (w > 0x3f0c9f54) { + /* |x| > log(3)/2 ~= 0.5493 or nan */ + if (w > 0x41200000) { + /* |x| > 10 */ + t = 1 + 0 / x; + } else { + t = expm1f(2 * x); + t = 1 - 2 / (t + 2); + } + } else if (w > 0x3e82c578) { + /* |x| > log(5/3)/2 ~= 0.2554 */ + t = expm1f(2 * x); + t = t / (t + 2); + } else if (w >= 0x00800000) { + /* |x| >= 0x1p-126 */ + t = expm1f(-2 * x); + t = -t / (t + 2); + } else { + /* |x| is subnormal */ + FORCE_EVAL(x * x); + t = x; + } + return sign ? -t : t; +} diff --git a/lib/libm/tanhl.c b/lib/libm/tanhl.c new file mode 100644 index 00000000..a5be4a68 --- /dev/null +++ b/lib/libm/tanhl.c @@ -0,0 +1,48 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double tanhl(long double x) +{ + return tanh(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +long double tanhl(long double x) +{ + union ldshape u = { x }; + unsigned ex = u.i.se & 0x7fff; + unsigned sign = u.i.se & 0x8000; + uint32_t w; + long double t; + + /* x = |x| */ + u.i.se = ex; + x = u.f; + w = u.i.m >> 32; + + if (ex > 0x3ffe || (ex == 0x3ffe && w > 0x8c9f53d5)) { + /* |x| > log(3)/2 ~= 0.5493 or nan */ + if (ex >= 0x3fff + 5) { + /* |x| >= 32 */ + t = 1 + 0 / (x + 0x1p-120f); + } else { + t = expm1l(2 * x); + t = 1 - 2 / (t + 2); + } + } else if (ex > 0x3ffd || (ex == 0x3ffd && w > 0x82c577d4)) { + /* |x| > log(5/3)/2 ~= 0.2554 */ + t = expm1l(2 * x); + t = t / (t + 2); + } else { + /* |x| is small */ + t = expm1l(-2 * x); + t = -t / (t + 2); + } + return sign ? -t : t; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double tanhl(long double x) +{ + return tanh(x); +} +#endif diff --git a/lib/libm/tanl.c b/lib/libm/tanl.c new file mode 100644 index 00000000..c8c0984b --- /dev/null +++ b/lib/libm/tanl.c @@ -0,0 +1,29 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double tanl(long double x) +{ + return tan(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 +long double tanl(long double x) +{ + union ldshape u = { x }; + long double y[2]; + unsigned n; + + u.i.se &= 0x7fff; + if (u.i.se == 0x7fff) + return x - x; + if (u.f < M_PI_4) { + if (u.i.se < 0x3fff - LDBL_MANT_DIG / 2) { + /* raise inexact if x!=0 and underflow if subnormal */ + FORCE_EVAL(u.i.se == 0 ? x * 0x1p-120f : x + 0x1p120f); + return x; + } + return __tanl(x, 0, 0); + } + n = __rem_pio2l(x, y); + return __tanl(y[0], y[1], n & 1); +} +#endif diff --git a/lib/libm/tgamma.c b/lib/libm/tgamma.c new file mode 100644 index 00000000..afc15b4b --- /dev/null +++ b/lib/libm/tgamma.c @@ -0,0 +1,245 @@ +/* +"A Precision Approximation of the Gamma Function" - Cornelius Lanczos (1964) +"Lanczos Implementation of the Gamma Function" - Paul Godfrey (2001) +"An Analysis of the Lanczos Gamma Approximation" - Glendon Ralph Pugh (2004) + +approximation method: + + (x - 0.5) S(x) +Gamma(x) = (x + g - 0.5) * ---------------- + exp(x + g - 0.5) + +with + a1 a2 a3 aN +S(x) ~= [ a0 + ----- + ----- + ----- + ... + ----- ] + x + 1 x + 2 x + 3 x + N + +with a0, a1, a2, a3,.. aN constants which depend on g. + +for x < 0 the following reflection formula is used: + +Gamma(x)*Gamma(-x) = -pi/(x sin(pi x)) + +most ideas and constants are from boost and python +*/ +#include "libm.h" + +static const double pi = 3.141592653589793238462643383279502884; + +/* sin(pi x) with x > 0x1p-100, if sin(pi*x)==0 the sign is arbitrary */ +static double sinpi(double x) +{ + int n; + + /* argument reduction: x = |x| mod 2 */ + /* spurious inexact when x is odd int */ + x = x * 0.5; + x = 2 * (x - floor(x)); + + /* reduce x into [-.25,.25] */ + n = 4 * x; + n = (n + 1) / 2; + x -= n * 0.5; + + x *= pi; + switch (n) { + default: /* case 4 */ + case 0: + return __sin(x, 0, 0); + case 1: + return __cos(x, 0); + case 2: + return __sin(-x, 0, 0); + case 3: + return -__cos(x, 0); + } +} + +#define N 12 +// static const double g = 6.024680040776729583740234375; +static const double gmhalf = 5.524680040776729583740234375; +static const double Snum[N + 1] = { + 23531376880.410759688572007674451636754734846804940, + 42919803642.649098768957899047001988850926355848959, + 35711959237.355668049440185451547166705960488635843, + 17921034426.037209699919755754458931112671403265390, + 6039542586.3520280050642916443072979210699388420708, + 1439720407.3117216736632230727949123939715485786772, + 248874557.86205415651146038641322942321632125127801, + 31426415.585400194380614231628318205362874684987640, + 2876370.6289353724412254090516208496135991145378768, + 186056.26539522349504029498971604569928220784236328, + 8071.6720023658162106380029022722506138218516325024, + 210.82427775157934587250973392071336271166969580291, + 2.5066282746310002701649081771338373386264310793408, +}; +static const double Sden[N + 1] = { + 0, 39916800, 120543840, 150917976, 105258076, 45995730, 13339535, + 2637558, 357423, 32670, 1925, 66, 1, +}; +/* n! for small integer n */ +static const double fact[] = { + 1, + 1, + 2, + 6, + 24, + 120, + 720, + 5040.0, + 40320.0, + 362880.0, + 3628800.0, + 39916800.0, + 479001600.0, + 6227020800.0, + 87178291200.0, + 1307674368000.0, + 20922789888000.0, + 355687428096000.0, + 6402373705728000.0, + 121645100408832000.0, + 2432902008176640000.0, + 51090942171709440000.0, + 1124000727777607680000.0, +}; + +/* S(x) rational function for positive x */ +static double S(double x) +{ + double_t num = 0, den = 0; + int i; + + /* to avoid overflow handle large x differently */ + if (x < 8) + for (i = N; i >= 0; i--) { + num = num * x + Snum[i]; + den = den * x + Sden[i]; + } + else + for (i = 0; i <= N; i++) { + num = num / x + Snum[i]; + den = den / x + Sden[i]; + } + return num / den; +} + +double tgamma(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + double absx, y; + double_t dy, z, r; + uint32_t ix = u.i >> 32 & 0x7fffffff; + int sign = u.i >> 63; + + /* special cases */ + if (ix >= 0x7ff00000) + /* tgamma(nan)=nan, tgamma(inf)=inf, tgamma(-inf)=nan with + * invalid */ + return x + INFINITY; + if (ix < (0x3ff - 54) << 20) + /* |x| < 2^-54: tgamma(x) ~ 1/x, +-0 raises div-by-zero */ + return 1 / x; + + /* integer arguments */ + /* raise inexact when non-integer */ + if (x == floor(x)) { + if (sign) + return 0 / 0.0; + if (x <= sizeof fact / sizeof *fact) + return fact[(int)x - 1]; + } + + /* x >= 172: tgamma(x)=inf with overflow */ + /* x =< -184: tgamma(x)=+-0 with underflow */ + if (ix >= 0x40670000) { /* |x| >= 184 */ + if (sign) { + FORCE_EVAL((float)(0x1p-126 / x)); + if (floor(x) * 0.5 == floor(x * 0.5)) + return 0; + return -0.0; + } + x *= 0x1p1023; + return x; + } + + absx = sign ? -x : x; + + /* handle the error of x + g - 0.5 */ + y = absx + gmhalf; + if (absx > gmhalf) { + dy = y - absx; + dy -= gmhalf; + } else { + dy = y - gmhalf; + dy -= absx; + } + + z = absx - 0.5; + r = S(absx) * exp(-y); + if (x < 0) { + /* reflection formula for negative x */ + /* sinpi(absx) is not 0, integers are already handled */ + r = -pi / (sinpi(absx) * absx * r); + dy = -dy; + z = -z; + } + r += dy * (gmhalf + 0.5) * r / y; + z = pow(y, 0.5 * z); + y = r * z * z; + return y; +} + +#if 0 +double __lgamma_r(double x, int *sign) +{ + double r, absx; + + *sign = 1; + + /* special cases */ + if (!isfinite(x)) + /* lgamma(nan)=nan, lgamma(+-inf)=inf */ + return x*x; + + /* integer arguments */ + if (x == floor(x) && x <= 2) { + /* n <= 0: lgamma(n)=inf with divbyzero */ + /* n == 1,2: lgamma(n)=0 */ + if (x <= 0) + return 1/0.0; + return 0; + } + + absx = fabs(x); + + /* lgamma(x) ~ -log(|x|) for tiny |x| */ + if (absx < 0x1p-54) { + *sign = 1 - 2*!!signbit(x); + return -log(absx); + } + + /* use tgamma for smaller |x| */ + if (absx < 128) { + x = tgamma(x); + *sign = 1 - 2*!!signbit(x); + return log(fabs(x)); + } + + /* second term (log(S)-g) could be more precise here.. */ + /* or with stirling: (|x|-0.5)*(log(|x|)-1) + poly(1/|x|) */ + r = (absx-0.5)*(log(absx+gmhalf)-1) + (log(S(absx)) - (gmhalf+0.5)); + if (x < 0) { + /* reflection formula for negative x */ + x = sinpi(absx); + *sign = 2*!!signbit(x) - 1; + r = log(pi/(fabs(x)*absx)) - r; + } + return r; +} + +weak_alias(__lgamma_r, lgamma_r); +#endif diff --git a/lib/libm/tgammaf.c b/lib/libm/tgammaf.c new file mode 100644 index 00000000..b4ca51c9 --- /dev/null +++ b/lib/libm/tgammaf.c @@ -0,0 +1,6 @@ +#include <math.h> + +float tgammaf(float x) +{ + return tgamma(x); +} diff --git a/lib/libm/tgammal.c b/lib/libm/tgammal.c new file mode 100644 index 00000000..1ebbfab8 --- /dev/null +++ b/lib/libm/tgammal.c @@ -0,0 +1,267 @@ +/* origin: OpenBSD /usr/src/lib/libm/src/ld80/e_tgammal.c */ +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Gamma function + * + * + * SYNOPSIS: + * + * long double x, y, tgammal(); + * + * y = tgammal( x ); + * + * + * DESCRIPTION: + * + * Returns gamma function of the argument. The result is + * correctly signed. + * + * Arguments |x| <= 13 are reduced by recurrence and the function + * approximated by a rational function of degree 7/8 in the + * interval (2,3). Large arguments are handled by Stirling's + * formula. Large negative arguments are made positive using + * a reflection formula. + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE -40,+40 10000 3.6e-19 7.9e-20 + * IEEE -1755,+1755 10000 4.8e-18 6.5e-19 + * + * Accuracy for large arguments is dominated by error in powl(). + * + */ + +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double tgammal(long double x) +{ + return tgamma(x); +} +#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 +/* +tgamma(x+2) = tgamma(x+2) P(x)/Q(x) +0 <= x <= 1 +Relative error +n=7, d=8 +Peak error = 1.83e-20 +Relative error spread = 8.4e-23 +*/ +static const long double P[8] = { + 4.212760487471622013093E-5L, 4.542931960608009155600E-4L, + 4.092666828394035500949E-3L, 2.385363243461108252554E-2L, + 1.113062816019361559013E-1L, 3.629515436640239168939E-1L, + 8.378004301573126728826E-1L, 1.000000000000000000009E0L, +}; +static const long double Q[9] = { + -1.397148517476170440917E-5L, 2.346584059160635244282E-4L, + -1.237799246653152231188E-3L, -7.955933682494738320586E-4L, + 2.773706565840072979165E-2L, -4.633887671244534213831E-2L, + -2.243510905670329164562E-1L, 4.150160950588455434583E-1L, + 9.999999999999999999908E-1L, +}; + +/* +static const long double P[] = { +-3.01525602666895735709e0L, +-3.25157411956062339893e1L, +-2.92929976820724030353e2L, +-1.70730828800510297666e3L, +-7.96667499622741999770e3L, +-2.59780216007146401957e4L, +-5.99650230220855581642e4L, +-7.15743521530849602425e4L +}; +static const long double Q[] = { + 1.00000000000000000000e0L, +-1.67955233807178858919e1L, + 8.85946791747759881659e1L, + 5.69440799097468430177e1L, +-1.98526250512761318471e3L, + 3.31667508019495079814e3L, + 1.60577839621734713377e4L, +-2.97045081369399940529e4L, +-7.15743521530849602412e4L +}; +*/ +#define MAXGAML 1755.455L +/*static const long double LOGPI = 1.14472988584940017414L;*/ + +/* Stirling's formula for the gamma function +tgamma(x) = sqrt(2 pi) x^(x-.5) exp(-x) (1 + 1/x P(1/x)) +z(x) = x +13 <= x <= 1024 +Relative error +n=8, d=0 +Peak error = 9.44e-21 +Relative error spread = 8.8e-4 +*/ +static const long double STIR[9] = { + 7.147391378143610789273E-4L, -2.363848809501759061727E-5L, + -5.950237554056330156018E-4L, 6.989332260623193171870E-5L, + 7.840334842744753003862E-4L, -2.294719747873185405699E-4L, + -2.681327161876304418288E-3L, 3.472222222230075327854E-3L, + 8.333333333333331800504E-2L, +}; + +#define MAXSTIR 1024.0L +static const long double SQTPI = 2.50662827463100050242E0L; + +/* 1/tgamma(x) = z P(z) + * z(x) = 1/x + * 0 < x < 0.03125 + * Peak relative error 4.2e-23 + */ +static const long double S[9] = { + -1.193945051381510095614E-3L, 7.220599478036909672331E-3L, + -9.622023360406271645744E-3L, -4.219773360705915470089E-2L, + 1.665386113720805206758E-1L, -4.200263503403344054473E-2L, + -6.558780715202540684668E-1L, 5.772156649015328608253E-1L, + 1.000000000000000000000E0L, +}; + +/* 1/tgamma(-x) = z P(z) + * z(x) = 1/x + * 0 < x < 0.03125 + * Peak relative error 5.16e-23 + * Relative error spread = 2.5e-24 + */ +static const long double SN[9] = { + 1.133374167243894382010E-3L, 7.220837261893170325704E-3L, + 9.621911155035976733706E-3L, -4.219773343731191721664E-2L, + -1.665386113944413519335E-1L, -4.200263503402112910504E-2L, + 6.558780715202536547116E-1L, 5.772156649015328608727E-1L, + -1.000000000000000000000E0L, +}; + +static const long double PIL = 3.1415926535897932384626L; + +/* Gamma function computed by Stirling's formula. + */ +static long double stirf(long double x) +{ + long double y, w, v; + + w = 1.0 / x; + /* For large x, use rational coefficients from the analytical expansion. + */ + if (x > 1024.0) + w = (((((6.97281375836585777429E-5L * w + + 7.84039221720066627474E-4L) * + w - + 2.29472093621399176955E-4L) * + w - + 2.68132716049382716049E-3L) * + w + + 3.47222222222222222222E-3L) * + w + + 8.33333333333333333333E-2L) * + w + + 1.0; + else + w = 1.0 + w * __polevll(w, STIR, 8); + y = expl(x); + if (x > MAXSTIR) { /* Avoid overflow in pow() */ + v = powl(x, 0.5L * x - 0.25L); + y = v * (v / y); + } else { + y = powl(x, x - 0.5L) / y; + } + y = SQTPI * y * w; + return y; +} + +long double tgammal(long double x) +{ + long double p, q, z; + + if (!isfinite(x)) + return x + INFINITY; + + q = fabsl(x); + if (q > 13.0) { + if (x < 0.0) { + p = floorl(q); + z = q - p; + if (z == 0) + return 0 / z; + if (q > MAXGAML) { + z = 0; + } else { + if (z > 0.5) { + p += 1.0; + z = q - p; + } + z = q * sinl(PIL * z); + z = fabsl(z) * stirf(q); + z = PIL / z; + } + if (0.5 * p == floorl(q * 0.5)) + z = -z; + } else if (x > MAXGAML) { + z = x * 0x1p16383L; + } else { + z = stirf(x); + } + return z; + } + + z = 1.0; + while (x >= 3.0) { + x -= 1.0; + z *= x; + } + while (x < -0.03125L) { + z /= x; + x += 1.0; + } + if (x <= 0.03125L) + goto small; + while (x < 2.0) { + z /= x; + x += 1.0; + } + if (x == 2.0) + return z; + + x -= 2.0; + p = __polevll(x, P, 7); + q = __polevll(x, Q, 8); + z = z * p / q; + return z; + +small: + /* z==1 if x was originally +-0 */ + if (x == 0 && z != 1) + return x / x; + if (x < 0.0) { + x = -x; + q = z / (x * __polevll(x, SN, 8)); + } else + q = z / (x * __polevll(x, S, 8)); + return q; +} +#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 +// TODO: broken implementation to make things compile +long double tgammal(long double x) +{ + return tgamma(x); +} +#endif diff --git a/lib/libm/trunc.c b/lib/libm/trunc.c new file mode 100644 index 00000000..d76f9993 --- /dev/null +++ b/lib/libm/trunc.c @@ -0,0 +1,22 @@ +#include "libm.h" + +double trunc(double x) +{ + union { + double f; + uint64_t i; + } u = { x }; + int e = (int)(u.i >> 52 & 0x7ff) - 0x3ff + 12; + uint64_t m; + + if (e >= 52 + 12) + return x; + if (e < 12) + e = 1; + m = -1ULL >> e; + if ((u.i & m) == 0) + return x; + FORCE_EVAL(x + 0x1p120f); + u.i &= ~m; + return u.f; +} diff --git a/lib/libm/truncf.c b/lib/libm/truncf.c new file mode 100644 index 00000000..4cdf082e --- /dev/null +++ b/lib/libm/truncf.c @@ -0,0 +1,22 @@ +#include "libm.h" + +float truncf(float x) +{ + union { + float f; + uint32_t i; + } u = { x }; + int e = (int)(u.i >> 23 & 0xff) - 0x7f + 9; + uint32_t m; + + if (e >= 23 + 9) + return x; + if (e < 9) + e = 1; + m = -1U >> e; + if ((u.i & m) == 0) + return x; + FORCE_EVAL(x + 0x1p120f); + u.i &= ~m; + return u.f; +} diff --git a/lib/libm/truncl.c b/lib/libm/truncl.c new file mode 100644 index 00000000..00e459ce --- /dev/null +++ b/lib/libm/truncl.c @@ -0,0 +1,34 @@ +#include "libm.h" + +#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 +long double truncl(long double x) +{ + return trunc(x); +} +#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 + +static const long double toint = 1 / LDBL_EPSILON; + +long double truncl(long double x) +{ + union ldshape u = { x }; + int e = u.i.se & 0x7fff; + int s = u.i.se >> 15; + long double y; + + if (e >= 0x3fff + LDBL_MANT_DIG - 1) + return x; + if (e <= 0x3fff - 1) { + FORCE_EVAL(x + 0x1p120f); + return x * 0; + } + /* y = int(|x|) - |x|, where int(|x|) is an integer neighbor of |x| */ + if (s) + x = -x; + y = x + toint - toint - x; + if (y > 0) + y -= 1; + x += y; + return s ? -x : x; +} +#endif @@ -131,7 +131,7 @@ defconfig: $(Q)$(MAKE) -f scripts/kconfig/makefile defconfig clang-tidy: compile_commands.json - $(Q)clang-tidy -p=. $(shell find . -name '*.c' -o -name '*.h' | grep -v './scripts/') + $(Q)clang-tidy -header-filter=.* -p=. $(shell find . -name '*.c' -o -name '*.h' | grep -v './scripts/\|dtoa\|linux\|arch\|bits') clang-format: $(Q)clang-format -i $(shell find . -name '*.c' -o -name '*.h' | grep -v './scripts/') diff --git a/scripts/makefile.build b/scripts/makefile.build index f4cb5cd2..b5b9aebc 100644 --- a/scripts/makefile.build +++ b/scripts/makefile.build @@ -1,5 +1,7 @@ obj-y := obj-m := +always := +targets := src := $(patsubst %/,%,$(obj)) @@ -44,21 +46,26 @@ subdir-s-sources := $(wildcard $(addprefix $(obj),$(subdir-objects:.o=.s))) PHONY := all ifdef lib-y -all: $(obj)$(lib-y) +all: $(obj)$(lib-y) $(addprefix $(obj),$(always)) $(obj)$(lib-y): $(addprefix $(obj),$(all-objects)) $(MSG) AR "$@" $(Q)$(AR) rcs $@ $^ else ifdef bin-y -all: $(obj)$(bin-y) -$(obj)$(bin-y): $(addprefix $(obj),$(all-objects)) $(libs-y) +all: $(obj)$(bin-y) $(addprefix $(obj),$(always)) + +$(obj)$(bin-y): $(addprefix $(obj),$(all-objects)) $(libs-y) ${prereq} $(MSG) LD "$@" $(Q)$(LD) $(ldflags) -o $@ $^ else -all: $(addprefix $(obj),$(all-objects)) $(subdirs) +all: $(addprefix $(obj),$(all-objects)) $(subdirs) $(addprefix $(obj),$(always)) endif PHONY += clean clean-% clean: $(addprefix clean-,$(subdirs)) +ifdef targets + $(info Cleaning targets: $(targets)) + $(Q)rm -f $(addprefix $(obj),$(targets)) +endif ifdef all-objects $(Q)rm -f $(addprefix $(obj),$(all-objects)) endif @@ -68,6 +75,9 @@ endif ifdef bin-y $(Q)rm -f $(obj)$(bin-y) endif +ifdef always + $(Q)rm -f $(addprefix $(obj),$(always)) +endif # Build C sources to objects $(filter $(addprefix $(obj),$(all-objects)),$(c-sources:.c=.o) $(subdir-c-sources:.c=.o)): $(obj)%.o: $(obj)%.c |