diff --git a/src/runtime/c/AUTHORS b/src/runtime/c/AUTHORS deleted file mode 100644 index d9d4d2f9f..000000000 --- a/src/runtime/c/AUTHORS +++ /dev/null @@ -1,9 +0,0 @@ -libpgf is written by: - -Krasimir Angelov -Lauri Alanko - -with some contributions from: - -Prasanth Kolachina -Bjørnar Luteberget diff --git a/src/runtime/c/CMakeLists.txt b/src/runtime/c/CMakeLists.txt deleted file mode 100644 index 45a13a067..000000000 --- a/src/runtime/c/CMakeLists.txt +++ /dev/null @@ -1,91 +0,0 @@ -project(libpgf) -cmake_minimum_required(VERSION 2.8) - -set(GNU_LIGHTNING_ARCH "i386" CACHE STRING "Target architecture for GNU Lightning JIT") -#set(ADD_CFLAGS "-Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wno-unused-value" CACHE STRING "Additional C compiler options") -#set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-no-undefined") -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99 ${ADD_CFLAGS}") - -set(GNU_LIGHTNING_ARCH_HEADERS - pgf/lightning/${GNU_LIGHTNING_ARCH}/asm.h - pgf/lightning/${GNU_LIGHTNING_ARCH}/fp.h - pgf/lightning/${GNU_LIGHTNING_ARCH}/core.h - pgf/lightning/${GNU_LIGHTNING_ARCH}/funcs.h -) - -file(COPY ${GNU_LIGHTNING_ARCH_HEADERS} - DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/pgf/lightning/) - - -include_directories(.) -include_directories(./pgf) - - -set(libgu_la_SOURCES - gu/assert.c - gu/bits.c - gu/choice.c - gu/defs.c - gu/seq.c - gu/enum.c - gu/exn.c - gu/file.c - gu/fun.c - gu/hash.c - gu/in.c - gu/map.c - gu/mem.c - gu/out.c - gu/prime.c - gu/string.c - gu/utf8.c - gu/ucs.c - gu/variant.c -) - -set(libpgf_la_SOURCES - pgf/data.c - pgf/data.h - pgf/expr.c - pgf/expr.h - pgf/parser.c - pgf/lookup.c - pgf/jit.c - pgf/parseval.c - pgf/literals.c - pgf/literals.h - pgf/reader.h - pgf/reader.c - pgf/linearizer.c - pgf/typechecker.c - pgf/reasoner.c - pgf/evaluator.c - pgf/hopu.c - pgf/printer.c - pgf/graphviz.c - pgf/aligner.c - pgf/pgf.c - pgf/pgf.h -) - -set(libsg_la_SOURCES - sg/sqlite3Btree.c - sg/sg.c -) - - -add_library(gu SHARED ${libgu_la_SOURCES}) -#set_property(TARGET gu PROPERTY C_STANDARD 99) -#set_property(TARGET gu PROPERTY WINDOWS_EXPORT_ALL_SYMBOLS true) -target_compile_definitions(gu PRIVATE COMPILING_GU=1) - -add_library(pgf SHARED ${libpgf_la_SOURCES}) -#set_property(TARGET pgf PROPERTY C_STANDARD 99) -#set_property(TARGET pgf PROPERTY WINDOWS_EXPORT_ALL_SYMBOLS true) -target_compile_definitions(pgf PRIVATE COMPILING_PGF=1) -target_link_libraries(pgf gu) -if(UNIX) - target_link_libraries(pgf m) -endif(UNIX) - -install(TARGETS gu pgf DESTINATION lib) diff --git a/src/runtime/c/COPYING.LESSER b/src/runtime/c/COPYING.LESSER deleted file mode 100644 index 65c5ca88a..000000000 --- a/src/runtime/c/COPYING.LESSER +++ /dev/null @@ -1,165 +0,0 @@ - GNU LESSER GENERAL PUBLIC LICENSE - Version 3, 29 June 2007 - - Copyright (C) 2007 Free Software Foundation, Inc. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - - This version of the GNU Lesser General Public License incorporates -the terms and conditions of version 3 of the GNU General Public -License, supplemented by the additional permissions listed below. - - 0. Additional Definitions. - - As used herein, "this License" refers to version 3 of the GNU Lesser -General Public License, and the "GNU GPL" refers to version 3 of the GNU -General Public License. - - "The Library" refers to a covered work governed by this License, -other than an Application or a Combined Work as defined below. - - An "Application" is any work that makes use of an interface provided -by the Library, but which is not otherwise based on the Library. -Defining a subclass of a class defined by the Library is deemed a mode -of using an interface provided by the Library. - - A "Combined Work" is a work produced by combining or linking an -Application with the Library. The particular version of the Library -with which the Combined Work was made is also called the "Linked -Version". - - The "Minimal Corresponding Source" for a Combined Work means the -Corresponding Source for the Combined Work, excluding any source code -for portions of the Combined Work that, considered in isolation, are -based on the Application, and not on the Linked Version. - - The "Corresponding Application Code" for a Combined Work means the -object code and/or source code for the Application, including any data -and utility programs needed for reproducing the Combined Work from the -Application, but excluding the System Libraries of the Combined Work. - - 1. Exception to Section 3 of the GNU GPL. - - You may convey a covered work under sections 3 and 4 of this License -without being bound by section 3 of the GNU GPL. - - 2. Conveying Modified Versions. - - If you modify a copy of the Library, and, in your modifications, a -facility refers to a function or data to be supplied by an Application -that uses the facility (other than as an argument passed when the -facility is invoked), then you may convey a copy of the modified -version: - - a) under this License, provided that you make a good faith effort to - ensure that, in the event an Application does not supply the - function or data, the facility still operates, and performs - whatever part of its purpose remains meaningful, or - - b) under the GNU GPL, with none of the additional permissions of - this License applicable to that copy. - - 3. Object Code Incorporating Material from Library Header Files. - - The object code form of an Application may incorporate material from -a header file that is part of the Library. You may convey such object -code under terms of your choice, provided that, if the incorporated -material is not limited to numerical parameters, data structure -layouts and accessors, or small macros, inline functions and templates -(ten or fewer lines in length), you do both of the following: - - a) Give prominent notice with each copy of the object code that the - Library is used in it and that the Library and its use are - covered by this License. - - b) Accompany the object code with a copy of the GNU GPL and this license - document. - - 4. Combined Works. - - You may convey a Combined Work under terms of your choice that, -taken together, effectively do not restrict modification of the -portions of the Library contained in the Combined Work and reverse -engineering for debugging such modifications, if you also do each of -the following: - - a) Give prominent notice with each copy of the Combined Work that - the Library is used in it and that the Library and its use are - covered by this License. - - b) Accompany the Combined Work with a copy of the GNU GPL and this license - document. - - c) For a Combined Work that displays copyright notices during - execution, include the copyright notice for the Library among - these notices, as well as a reference directing the user to the - copies of the GNU GPL and this license document. - - d) Do one of the following: - - 0) Convey the Minimal Corresponding Source under the terms of this - License, and the Corresponding Application Code in a form - suitable for, and under terms that permit, the user to - recombine or relink the Application with a modified version of - the Linked Version to produce a modified Combined Work, in the - manner specified by section 6 of the GNU GPL for conveying - Corresponding Source. - - 1) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (a) uses at run time - a copy of the Library already present on the user's computer - system, and (b) will operate properly with a modified version - of the Library that is interface-compatible with the Linked - Version. - - e) Provide Installation Information, but only if you would otherwise - be required to provide such information under section 6 of the - GNU GPL, and only to the extent that such information is - necessary to install and execute a modified version of the - Combined Work produced by recombining or relinking the - Application with a modified version of the Linked Version. (If - you use option 4d0, the Installation Information must accompany - the Minimal Corresponding Source and Corresponding Application - Code. If you use option 4d1, you must provide the Installation - Information in the manner specified by section 6 of the GNU GPL - for conveying Corresponding Source.) - - 5. Combined Libraries. - - You may place library facilities that are a work based on the -Library side by side in a single library together with other library -facilities that are not Applications and are not covered by this -License, and convey such a combined library under terms of your -choice, if you do both of the following: - - a) Accompany the combined library with a copy of the same work based - on the Library, uncombined with any other library facilities, - conveyed under the terms of this License. - - b) Give prominent notice with the combined library that part of it - is a work based on the Library, and explaining where to find the - accompanying uncombined form of the same work. - - 6. Revised Versions of the GNU Lesser General Public License. - - The Free Software Foundation may publish revised and/or new versions -of the GNU Lesser 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 -Library as you received it specifies that a certain numbered version -of the GNU Lesser General Public License "or any later version" -applies to it, you have the option of following the terms and -conditions either of that published version or of any later version -published by the Free Software Foundation. If the Library as you -received it does not specify a version number of the GNU Lesser -General Public License, you may choose any version of the GNU Lesser -General Public License ever published by the Free Software Foundation. - - If the Library as you received it specifies that a proxy can decide -whether future versions of the GNU Lesser General Public License shall -apply, that proxy's public statement of acceptance of any version is -permanent authorization for you to choose that version for the -Library. diff --git a/src/runtime/c/INSTALL b/src/runtime/c/INSTALL deleted file mode 100644 index c45c18fa9..000000000 --- a/src/runtime/c/INSTALL +++ /dev/null @@ -1,63 +0,0 @@ -General Note ------------- - -If you want to use the statistical ranking in the parser then you -have to compile your grammar with the option '-probs=grammar.probs', -where grammar.probs must contain a tab separated file with -the probabilities for all functions in the abstract syntax. -In order to enable the named entity recongizer for the ParseEngAbs -grammar you also have to add the option '-literal=Symb' while compiling. - - -For Linux users ---------------- - -You will need the packages: autoconf, automake, libtool, make - -- On Ubuntu: $ apt-get install autotools-dev -- On Fedora: $ dnf install autoconf automake libtool - -The compilation steps are: - -$ autoreconf -i -$ ./configure -$ make -$ make install - - -For Mac OSX users ------------------ - -The following is what I did to make it work on MacOSX 10.8: - -- Install XCode and XCode command line tools -- Install Homebrew: https://brew.sh - -$ brew install automake autoconf libtool -$ glibtoolize -$ autoreconf -i -$ ./configure -$ make -$ make install - - -For Windows users ------------------ - -- Install MinGW: http://www.mingw.org/. From the installer you need - to select at least the following packages: - - Mingw-developer-toolkit - - Mingw-base - - Msys-base - After the installation, don't forget to fix the fstab file. See here: - http://www.mingw.org/wiki/Getting_Started - -- From the MSYS shell (c:/MinGW/msys/1.0/msys.bat) go to the directory - which contains the INSTALL file and do: - - $ autoreconf -i - $ ./configure - $ make - $ make install - - The compiled binaries should be now in c:/MinGW/msys/1.0/local/bin. diff --git a/src/runtime/c/Makefile.am b/src/runtime/c/Makefile.am index cca595ebe..8b94fb4db 100644 --- a/src/runtime/c/Makefile.am +++ b/src/runtime/c/Makefile.am @@ -1,92 +1,24 @@ -lib_LTLIBRARIES = libgu.la libpgf.la +lib_LTLIBRARIES = libpgf.la pkgconfigdir = $(libdir)/pkgconfig -pkgconfig_DATA = libgu.pc libpgf.pc +pkgconfig_DATA = libpgf.pc -configincludedir = $(libdir)/libgu/include - -guincludedir=$(includedir)/gu -guinclude_HEADERS = \ - gu/assert.h \ - gu/bits.h \ - gu/choice.h \ - gu/defs.h \ - gu/enum.h \ - gu/exn.h \ - gu/file.h \ - gu/fun.h \ - gu/hash.h \ - gu/in.h \ - gu/map.h \ - gu/mem.h \ - gu/out.h \ - gu/prime.h \ - gu/seq.h \ - gu/string.h \ - gu/sysdeps.h \ - gu/ucs.h \ - gu/utf8.h \ - gu/variant.h - -pgfincludedir=$(includedir)/pgf +pgfincludedir=$(includedir) pgfinclude_HEADERS = \ - pgf/expr.h \ - pgf/linearizer.h \ - pgf/literals.h \ - pgf/graphviz.h \ - pgf/pgf.h \ - pgf/data.h - -libgu_la_SOURCES = \ - gu/assert.c \ - gu/bits.c \ - gu/choice.c \ - gu/defs.c \ - gu/seq.c \ - gu/enum.c \ - gu/exn.c \ - gu/file.c \ - gu/fun.c \ - gu/hash.c \ - gu/in.c \ - gu/map.c \ - gu/mem.c \ - gu/out.c \ - gu/prime.c \ - gu/string.c \ - gu/utf8.c \ - gu/ucs.c \ - gu/variant.c -libgu_la_LDFLAGS = -no-undefined + pgf.h libpgf_la_SOURCES = \ - pgf/data.c \ - pgf/data.h \ - pgf/expr.c \ - pgf/expr.h \ - pgf/scanner.c \ - pgf/parser.c \ - pgf/lookup.c \ - pgf/jit.c \ - pgf/parseval.c \ - pgf/literals.c \ - pgf/literals.h \ - pgf/reader.h \ - pgf/reader.c \ - pgf/writer.h \ - pgf/writer.c \ - pgf/linearizer.c \ - pgf/typechecker.c \ - pgf/reasoner.c \ - pgf/evaluator.c \ - pgf/hopu.c \ - pgf/printer.c \ - pgf/graphviz.c \ - pgf/aligner.c \ - pgf/pgf.c \ - pgf/pgf.h \ + db.cxx \ + db.h \ + pgf.cxx \ + reader.cxx \ + reader.h \ + data.h \ + expr.h \ + namespace.h \ + variant.h + libpgf_la_LDFLAGS = "-no-undefined" -libpgf_la_LIBADD = libgu.la bin_PROGRAMS = @@ -94,5 +26,4 @@ AUTOMAKE_OPTIONS = foreign subdir-objects dist-bzip2 ACLOCAL_AMFLAGS = -I m4 EXTRA_DIST = \ - libgu.pc.in \ libpgf.pc.in diff --git a/src/runtime/c/configure.ac b/src/runtime/c/configure.ac index d8e55c164..c90189411 100644 --- a/src/runtime/c/configure.ac +++ b/src/runtime/c/configure.ac @@ -1,9 +1,8 @@ -AC_INIT(Portable Grammar Format library, 0.1-pre, +AC_INIT(Portable Grammar Format library, 3.0-pre, http://www.grammaticalframework.org/, libpgf) AC_PREREQ(2.58) -AC_CONFIG_SRCDIR([gu/mem.c]) AC_CONFIG_AUX_DIR([scripts]) AC_CONFIG_MACRO_DIR([m4]) @@ -21,9 +20,7 @@ AC_CHECK_LIB(m,nan) AC_PROG_MAKE_SET AC_PROG_INSTALL AC_PROG_LIBTOOL -AC_PROG_CC -AC_PROG_CC_C99 -AM_PROG_CC_C_O +AC_PROG_CXX [if [ "x$GCC" = "xyes" ]; then CFLAGS="$CFLAGS\ @@ -34,29 +31,7 @@ AM_PROG_CC_C_O -Wno-unused-value" fi] -case "$target_cpu" in - i?86) cpu=i386; AC_DEFINE(LIGHTNING_I386, 1, - [Define if lightning is targeting the x86 architecture]) ;; - x86_64) cpu=i386; AC_DEFINE(LIGHTNING_I386, 1, - [Define if lightning is targeting the x86 architecture]) ;; - sparc*) cpu=sparc; AC_DEFINE(LIGHTNING_SPARC, 1, - [Define if lightning is targeting the sparc architecture]) ;; - powerpc) cpu=ppc; AC_DEFINE(LIGHTNING_PPC, 1, - [Define if lightning is targeting the powerpc architecture]) ;; - arm*) cpu=arm; AC_DEFINE(LIGHTNING_ARM, 1, - [Define if lightning is targeting the arm architecture]) ;; - *) AC_MSG_ERROR([cpu $target_cpu not supported]) ;; -esac - -cpu_dir=pgf/lightning/$cpu -AC_CONFIG_LINKS(pgf/lightning/asm.h:$cpu_dir/asm.h dnl - pgf/lightning/fp.h:$cpu_dir/fp.h dnl - pgf/lightning/core.h:$cpu_dir/core.h dnl - pgf/lightning/funcs.h:$cpu_dir/funcs.h, [], - [cpu_dir=$cpu_dir]) - AC_CONFIG_FILES([Makefile - libgu.pc libpgf.pc ]) diff --git a/src/runtime/c/data.h b/src/runtime/c/data.h new file mode 100644 index 000000000..a90b882e3 --- /dev/null +++ b/src/runtime/c/data.h @@ -0,0 +1,64 @@ +#ifndef PGF_DATA_H_ +#define PGF_DATA_H_ + +#include +#include +#include +#include +#include +#include + +#include "pgf.h" +#include "db.h" +#include "namespace.h" +#include "expr.h" + +class PGF_INTERNAL_DECL pgf_error : public std::runtime_error { +public: + pgf_error(const char *msg) : std::runtime_error(msg) + { + this->msg = msg; + } + + const char *what() const throw () + { + return msg; + } + +private: + const char *msg; +}; + +struct PGF_INTERNAL_DECL PgfFlag { + PgfLiteral value; + char name[]; +}; + +typedef struct { + ref name; + Namespace aflags; +} PgfAbstr; + +struct PGF_INTERNAL_DECL PgfPGFRoot { + uint16_t major_version; + uint16_t minor_version; + Namespace gflags; + PgfAbstr abstract; + //PgfConcrs* concretes; +}; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wattributes" + +struct PgfPGF : public PgfPGFRoot { + DB db; + + PGF_INTERNAL_DECL PgfPGF(const char* fpath) : db(fpath) {}; + PGF_INTERNAL_DECL ~PgfPGF() {}; + + PGF_INTERNAL_DECL void set_root(); +}; + +#pragma GCC diagnostic pop + +#endif diff --git a/src/runtime/c/db.cxx b/src/runtime/c/db.cxx new file mode 100644 index 000000000..cc5654fca --- /dev/null +++ b/src/runtime/c/db.cxx @@ -0,0 +1,911 @@ +#include +#include +#include +#include +#include + +#include "data.h" + +thread_local unsigned char* current_base; +thread_local DB* current_db; + +#ifndef DEFAULT_TOP_PAD +#define DEFAULT_TOP_PAD (0) +#endif + +#define ptr(ms,o) ((mchunk*) (((char*) (ms)) + (o))) +#define ofs(ms,p) (((char*) (p)) - ((char*) (ms))) + +struct mchunk { + size_t mchunk_prev_size; /* Size of previous chunk (if free). */ + size_t mchunk_size; /* Size in bytes, including overhead. */ + + moffset fd; /* double links -- used only if free. */ + moffset bk; + + /* Only used for large blocks: pointer to next larger size. */ + moffset fd_nextsize; /* double links -- used only if free. */ + moffset bk_nextsize; +}; + +#define POOL_ALIGNMENT (2 * sizeof(size_t) < __alignof__ (long double) \ + ? __alignof__ (long double) : 2 * sizeof(size_t)) + +/* + Bins + An array of bin headers for free chunks. Each bin is doubly + linked. The bins are approximately proportionally (log) spaced. + There are a lot of these bins (128). This may look excessive, but + works very well in practice. Most bins hold sizes that are + unusual as allocation request sizes, but are more usual for fragments + and consolidated sets of chunks, which is what these bins hold, so + they can be found quickly. All procedures maintain the invariant + that no consolidated chunk physically borders another one, so each + chunk in a list is known to be preceeded and followed by either + inuse chunks or the ends of memory. + Chunks in bins are kept in size order, with ties going to the + approximately least recently used chunk. Ordering isn't needed + for the small bins, which all contain the same-sized chunks, but + facilitates best-fit allocation for larger chunks. These lists + are just sequential. Keeping them in order almost never requires + enough traversal to warrant using fancier ordered data + structures. + Chunks of the same size are linked with the most + recently freed at the front, and allocations are taken from the + back. This results in LRU (FIFO) allocation order, which tends + to give each chunk an equal opportunity to be consolidated with + adjacent freed chunks, resulting in larger free chunks and less + fragmentation. + To simplify use in double-linked lists, each bin header acts + as an mchunk. This avoids special-casing for headers. + But to conserve space and improve locality, we allocate + only the fd/bk pointers of bins, and then use repositioning tricks + to treat these as the fields of a mchunk*. + */ + +typedef struct mchunk mbin; + +/* addressing -- note that bin_at(0) does not exist */ +#define bin_at(m, i) \ + (mbin*) (((char *) &((m)->bins[((i) - 1) * 2])) \ + - offsetof (mchunk, fd)) +/* analog of ++bin */ +#define next_bin(b) ((mbin*) ((char *) (b) + (sizeof(mchunk*) << 1))) +/* Reminders about list directionality within bins */ +#define first(b) ((b)->fd) +#define last(b) ((b)->bk) + +/* + Indexing + Bins for sizes < 512 bytes contain chunks of all the same size, spaced + 8 bytes apart. Larger bins are approximately logarithmically spaced: + 64 bins of size 8 + 32 bins of size 64 + 16 bins of size 512 + 8 bins of size 4096 + 4 bins of size 32768 + 2 bins of size 262144 + 1 bin of size what's left + There is actually a little bit of slop in the numbers in bin_index + for the sake of speed. This makes no difference elsewhere. + The bins top out around 1MB because we expect to service large + requests via mmap. + Bin 0 does not exist. Bin 1 is the unordered list; if that would be + a valid chunk size the small bins are bumped up one. + */ +#define NBINS 128 +#define NSMALLBINS 64 +#define SMALLBIN_WIDTH POOL_ALIGNMENT +#define SMALLBIN_CORRECTION (POOL_ALIGNMENT > 2 * sizeof(size_t)) +#define MIN_LARGE_SIZE ((NSMALLBINS - SMALLBIN_CORRECTION) * SMALLBIN_WIDTH) + +#define in_smallbin_range(sz) \ + ((unsigned long) (sz) < (unsigned long) MIN_LARGE_SIZE) +#define smallbin_index(sz) \ + ((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\ + + SMALLBIN_CORRECTION) +#define largebin_index_32(sz) \ + (((((unsigned long) (sz)) >> 6) <= 38) ? 56 + (((unsigned long) (sz)) >> 6) :\ + ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ + ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ + ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ + ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ + 126) +#define largebin_index_32_big(sz) \ + (((((unsigned long) (sz)) >> 6) <= 45) ? 49 + (((unsigned long) (sz)) >> 6) :\ + ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ + ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ + ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ + ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ + 126) +// XXX It remains to be seen whether it is good to keep the widths of +// XXX the buckets the same or whether it should be scaled by a factor +// XXX of two as well. +#define largebin_index_64(sz) \ + (((((unsigned long) (sz)) >> 6) <= 48) ? 48 + (((unsigned long) (sz)) >> 6) :\ + ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\ + ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\ + ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\ + ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\ + 126) +#define largebin_index(sz) \ + (sizeof(size_t) == 8 ? largebin_index_64 (sz) \ + : POOL_ALIGNMENT == 16 ? largebin_index_32_big (sz) \ + : largebin_index_32 (sz)) + + +/* + Unsorted chunks + All remainders from chunk splits, as well as all returned chunks, + are first placed in the "unsorted" bin. They are then placed + in regular bins after malloc gives them ONE chance to be used before + binning. So, basically, the unsorted_chunks list acts as a queue, + with chunks being placed on it in free (and pool_consolidate), + and taken off (to be either used or placed in bins) in malloc. + */ +/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */ +#define unsorted_chunks(M) (bin_at (M, 1)) + +/* conversion from malloc headers to user pointers, and back */ +#define chunk2mem(p) ((void*)((char*)(p) + 2*sizeof(size_t))) +#define mem2chunk(mem) ((mchunk*)((char*)(mem) - 2*sizeof(size_t))) + +#define MIN_CHUNK_SIZE (offsetof(mchunk, fd_nextsize)) + +#define MALLOC_ALIGN_MASK (2*sizeof(size_t) - 1) + +/* The smallest size we can malloc is an aligned minimal chunk */ +#define MINSIZE \ + (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)) + +/* pad request bytes into a usable size -- internal version */ +#define request2size(req) \ + (((req) + sizeof(size_t) + MALLOC_ALIGN_MASK < MINSIZE) ? \ + MINSIZE : \ + ((req) + sizeof(size_t) + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK) + +/* + --------------- Physical chunk operations --------------- + */ +/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */ +#define PREV_INUSE 0x1 +/* extract inuse bit of previous chunk */ +#define prev_inuse(p) ((p)->mchunk_size & PREV_INUSE) + +/* Get size, ignoring use bits */ +#define chunksize(p) (p->mchunk_size & ~(PREV_INUSE)) + +/* Size of the chunk below P. Only valid if !prev_inuse (P). */ +#define prev_size(p) ((p)->mchunk_prev_size) + +/* Treat space at ptr + offset as a chunk */ +#define chunk_at_offset(p, s) ((mchunk*) (((char *) (p)) + (s))) + +/* check/set/clear inuse bits in known places */ +#define inuse_bit_at_offset(p, s) \ + (((mchunk*) (((char *) (p)) + (s)))->mchunk_size & PREV_INUSE) + +#define set_inuse_bit_at_offset(p, s) \ + (((mchunk*) (((char *) (p)) + (s)))->mchunk_size |= PREV_INUSE) + +#define clear_inuse_bit_at_offset(p, s) \ + (((mchunk*) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE)) + +/* Set size/use field */ +#define set_head(p, s) ((p)->mchunk_size = (s)) +/* Set size at footer (only when chunk is not in use) */ +#define set_foot(p, s) (((mchunk*) ((char *) (p) + (s)))->mchunk_prev_size = (s)) + +/* + Binmap + To help compensate for the large number of bins, a one-level index + structure is used for bin-by-bin searching. `binmap' is a + bitvector recording whether bins are definitely empty so they can + be skipped over during during traversals. The bits are NOT always + cleared as soon as bins are empty, but instead only + when they are noticed to be empty during traversal in malloc. + */ +/* Conservatively use 32 bits per map word, even if on 64bit system */ +#define BINMAPSHIFT 5 +#define BITSPERMAP (1U << BINMAPSHIFT) +#define BINMAPSIZE (NBINS / BITSPERMAP) + +#define idx2block(i) ((i) >> BINMAPSHIFT) +#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT) - 1)))) +#define mark_bin(ms, i) ((ms)->binmap[idx2block(i)] |= idx2bit (i)) +#define unmark_bin(ms, i) ((ms)->binmap[idx2block(i)] &= ~(idx2bit (i))) +#define get_binmap(ms, i) ((ms)->binmap[idx2block(i)] & idx2bit (i)) + +/* + Fastbins + An array of lists holding recently freed small chunks. Fastbins + are not doubly linked. It is faster to single-link them, and + since chunks are never removed from the middles of these lists, + double linking is not necessary. Also, unlike regular bins, they + are not even processed in FIFO order (they use faster LIFO) since + ordering doesn't much matter in the transient contexts in which + fastbins are normally used. + Chunks in fastbins keep their inuse bit set, so they cannot + be consolidated with other free chunks. malloc_consolidate + releases all chunks in fastbins and consolidates them with + other free chunks. + */ + +#define DEFAULT_MXFAST (64 * sizeof(size_t) / 4) + +/* offset 2 to use otherwise unindexable first 2 bins */ +#define fastbin_index(sz) \ + ((((unsigned int) (sz)) >> (sizeof(size_t) == 8 ? 4 : 3)) - 2) +/* The maximum fastbin request size we support */ +#define MAX_FAST_SIZE (80 * sizeof(size_t) / 4) +#define NFASTBINS (fastbin_index (request2size (MAX_FAST_SIZE)) + 1) + +/* + FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free() + that triggers automatic consolidation of possibly-surrounding + fastbin chunks. This is a heuristic, so the exact value should not + matter too much. It is defined at half the default trim threshold as a + compromise heuristic to only attempt consolidation if it is likely + to lead to trimming. However, it is not dynamically tunable, since + consolidation reduces fragmentation surrounding large chunks even + if trimming is not used. + */ +#define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL) + +struct malloc_state +{ + /* Set if the fastbin chunks contain recently inserted free blocks. */ + bool have_fastchunks; + /* Fastbins */ + moffset fastbins[NFASTBINS]; + /* Base of the topmost chunk -- not otherwise kept in a bin */ + moffset top; + /* The remainder from the most recent split of a small request */ + moffset last_remainder; + /* Normal bins packed as described above */ + moffset bins[NBINS * 2 - 2]; + /* Bitmap of bins */ + unsigned int binmap[BINMAPSIZE]; + /* Reference to the root object */ + size_t root_offset; +}; + +DB::DB(const char* pathname) { + fd = open(pathname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); + if (fd < 0) + throw std::system_error(errno, std::generic_category()); + + size_t file_size = lseek(fd, 0, SEEK_END); + + if (file_size == ((off_t) -1)) + throw std::system_error(errno, std::generic_category()); + + bool is_new = false; + if (file_size == 0) { + file_size = getpagesize(); + if (ftruncate(fd, file_size) < 0) + throw std::system_error(errno, std::generic_category()); + is_new = true; + } + + ms = (malloc_state*) + mmap(NULL, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (ms == MAP_FAILED) + throw std::system_error(errno, std::generic_category()); + + if (is_new) { + init_state(file_size); + } + + current_base = (unsigned char*) ms; + current_db = this; +} + +DB::~DB() { + size_t size = + ms->top + size + sizeof(size_t); + + munmap(ms,size); + close(fd); +} + +moffset DB::get_root_offset() { + return ms->root_offset; +} + +void DB::set_root_offset(moffset root) { + ms->root_offset = root; +} + +void +DB::init_state(size_t size) +{ + /* Init fastbins */ + ms->have_fastchunks = false; + for (int i = 0; i < NFASTBINS; ++i) { + ms->fastbins[i] = 0; + } + + mchunk* top_chunk = + mem2chunk(((char*) ms) + sizeof(*ms) + sizeof(size_t)); + ms->top = ofs(ms,top_chunk); + set_head(top_chunk, (size - sizeof(*ms)) | PREV_INUSE); + + ms->last_remainder = 0; + + /* Establish circular links for normal bins */ + for (int i = 1; i < NBINS; ++i) { + mbin *bin = bin_at(ms, i); + bin->fd = bin->bk = ofs(ms,bin); + } + + memset(ms->binmap, 0, sizeof(ms->binmap)); + + ms->root_offset = 0; +} + +/* Take a chunk off a bin list. */ +static void +unlink_chunk (malloc_state* ms, mchunk* p) +{ + mchunk* fd = ptr(ms,p->fd); + mchunk* bk = ptr(ms,p->bk); + fd->bk = ofs(ms,bk); + bk->fd = ofs(ms,fd); + if (!in_smallbin_range(p->mchunk_size) && p->fd_nextsize != 0) { + if (fd->fd_nextsize == 0) { + if (p->fd_nextsize == ofs(ms,p)) + fd->fd_nextsize = fd->bk_nextsize = ofs(ms,fd); + else { + fd->fd_nextsize = p->fd_nextsize; + fd->bk_nextsize = p->bk_nextsize; + ptr(ms,p->fd_nextsize)->bk_nextsize = ofs(ms,fd); + ptr(ms,p->bk_nextsize)->fd_nextsize = ofs(ms,fd); + } + } else { + ptr(ms,p->fd_nextsize)->bk_nextsize = p->bk_nextsize; + ptr(ms,p->bk_nextsize)->fd_nextsize = p->fd_nextsize; + } + } +} + +/* + ------------------------- malloc_consolidate ------------------------- + malloc_consolidate is a specialized version of free() that tears + down chunks held in fastbins. Free itself cannot be used for this + purpose since, among other things, it might place chunks back onto + fastbins. So, instead, we need to use a minor variant of the same + code. +*/ +static void malloc_consolidate(malloc_state *ms) +{ + moffset* fb; /* current fastbin being consolidated */ + moffset* maxfb; /* last fastbin (for loop control) */ + mchunk* p; /* current chunk being consolidated */ + mchunk* nextp; /* next chunk to consolidate */ + mchunk* unsorted_bin; /* bin header */ + mchunk* first_unsorted; /* chunk to link to */ + /* These have same use as in free() */ + mchunk* nextchunk; + size_t size; + size_t nextsize; + size_t prevsize; + int nextinuse; + + ms->have_fastchunks = false; + unsorted_bin = unsorted_chunks(ms); + /* + Remove each chunk from fast bin and consolidate it, placing it + then in unsorted bin. Among other reasons for doing this, + placing in unsorted bin avoids needing to calculate actual bins + until malloc is sure that chunks aren't immediately going to be + reused anyway. + */ + maxfb = &ms->fastbins[NFASTBINS - 1]; + fb = &ms->fastbins[0]; + do { + p = ptr(ms,*fb); + *fb = 0; + if (p != NULL) { + do { + nextp = ptr(ms,p->fd); + /* Slightly streamlined version of consolidation code in free() */ + size = chunksize(p); + nextchunk = chunk_at_offset(p, size); + nextsize = chunksize(nextchunk); + if (!prev_inuse(p)) { + prevsize = prev_size(p); + size += prevsize; + p = chunk_at_offset(p, -((long) prevsize)); + unlink_chunk (ms, p); + } + if (nextchunk != ptr(ms,ms->top)) { + nextinuse = inuse_bit_at_offset(nextchunk, nextsize); + if (!nextinuse) { + size += nextsize; + unlink_chunk (ms, nextchunk); + } else + clear_inuse_bit_at_offset(nextchunk, 0); + first_unsorted = ptr(ms,unsorted_bin->fd); + unsorted_bin->fd = ofs(ms,p); + first_unsorted->bk = ofs(ms,p); + if (!in_smallbin_range(size)) { + p->fd_nextsize = 0; + p->bk_nextsize = 0; + } + set_head(p, size | PREV_INUSE); + p->bk = ofs(ms,unsorted_bin); + p->fd = ofs(ms,first_unsorted); + set_foot(p, size); + } else { + size += nextsize; + set_head(p, size | PREV_INUSE); + ms->top = ofs(ms,p); + } + } while ((p = nextp) != 0); + } + } while (fb++ != maxfb); +} + +moffset +DB::malloc(size_t bytes) +{ + unsigned int idx; /* associated bin index */ + mbin* bin; /* associated bin */ + mchunk* victim; /* inspected/selected chunk */ + + mchunk* remainder; /* remainder from a split */ + unsigned long remainder_size; /* its size */ + + /* + Convert request size to internal form by adding SIZE_SZ bytes + overhead plus possibly more to obtain necessary alignment and/or + to obtain a size of at least MINSIZE, the smallest allocatable + size. Also, checked_request2size traps (returning 0) request sizes + that are so large that they wrap around zero when padded and + aligned. + */ + size_t nb = request2size(bytes); + + if (nb <= DEFAULT_MXFAST) { + idx = fastbin_index(nb); + + if (ms->fastbins[idx] != 0) { + victim = ptr(ms,ms->fastbins[idx]); + ms->fastbins[idx] = victim->fd; + return ofs(ms,chunk2mem(victim)); + } + } + + /* + If a small request, check regular bin. Since these "smallbins" + hold one size each, no searching within bins is necessary. + (For a large request, we need to wait until unsorted chunks are + processed to find best fit. But for small ones, fits are exact + anyway, so we can check now, which is faster.) + */ + if (in_smallbin_range (nb)) { + idx = smallbin_index (nb); + bin = bin_at (ms, idx); + if ((victim = ptr(ms,last(bin))) != bin) + { + moffset bck = victim->bk; + set_inuse_bit_at_offset (victim, nb); + bin->bk = bck; + ptr(ms,bck)->fd = ofs(ms,bin); + return ofs(ms,chunk2mem(victim)); + } + } else { + /* + If this is a large request, consolidate fastbins before continuing. + While it might look excessive to kill all fastbins before + even seeing if there is space available, this avoids + fragmentation problems normally associated with fastbins. + Also, in practice, programs tend to have runs of either small or + large requests, but less often mixtures, so consolidation is not + invoked all that often in most programs. And the programs that + it is called frequently in otherwise tend to fragment. + */ + + idx = largebin_index(nb); + if (ms->have_fastchunks) + malloc_consolidate(ms); + } + + /* + Process recently freed or remaindered chunks, taking one only if + it is exact fit, or, if this a small request, the chunk is remainder from + the most recent non-exact fit. Place other traversed chunks in + bins. Note that this step is the only place in any routine where + chunks are placed in bins. + The outer loop here is needed because we might not realize until + near the end of malloc that we should have consolidated, so must + do so and retry. This happens at most once, and only when we would + otherwise need to expand memory to service a "small" request. + */ + for (;;) + { + size_t size; + mchunk *fwd, *bck; + + int iters = 0; + while ((victim = ptr(ms,unsorted_chunks(ms)->bk)) != unsorted_chunks(ms)) { + bck = ptr(ms,victim->bk); + size = chunksize(victim); + mchunk *next = chunk_at_offset(victim, size); + + /* + If a small request, try to use last remainder if it is the + only chunk in unsorted bin. This helps promote locality for + runs of consecutive small requests. This is the only + exception to best-fit, and applies only when there is + no exact fit for a small chunk. + */ + + if (in_smallbin_range(nb) && + bck == unsorted_chunks(ms) && + victim == ptr(ms,ms->last_remainder) && + (unsigned long) (size) > (unsigned long) (nb + MINSIZE)) { + + /* split and reattach remainder */ + remainder_size = size - nb; + remainder = chunk_at_offset(victim, nb); + ms->last_remainder = + unsorted_chunks(ms)->bk = + unsorted_chunks(ms)->fd = ofs(ms,remainder); + remainder->bk = remainder->fd = ofs(ms,unsorted_chunks(ms)); + if (!in_smallbin_range(remainder_size)) { + remainder->fd_nextsize = 0; + remainder->bk_nextsize = 0; + } + set_head(victim, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + set_foot(remainder, remainder_size); + return ofs(ms,chunk2mem(victim)); + } + + /* remove from unsorted list */ + unsorted_chunks(ms)->bk = ofs(ms,bck); + bck->fd = ofs(ms,unsorted_chunks(ms)); + + /* Take now instead of binning if exact fit */ + if (size == nb) { + set_inuse_bit_at_offset(victim, size); + return ofs(ms,chunk2mem(victim)); + } + + /* place chunk in bin */ + size_t victim_index; + if (in_smallbin_range(size)) { + victim_index = smallbin_index(size); + bck = bin_at(ms, victim_index); + fwd = ptr(ms,bck->fd); + } else { + victim_index = largebin_index(size); + bck = bin_at(ms, victim_index); + fwd = ptr(ms,bck->fd); + + /* maintain large bins in sorted order */ + if (fwd != bck) { + /* Or with inuse bit to speed comparisons */ + size |= PREV_INUSE; + /* if smaller than smallest, bypass loop below */ + if ((unsigned long) (size) < (unsigned long) ptr(ms,bck->bk)->mchunk_size) { + fwd = bck; + bck = ptr(ms,bck->bk); + victim->fd_nextsize = fwd->fd; + victim->bk_nextsize = ptr(ms,fwd->fd)->bk_nextsize; + ptr(ms,fwd->fd)->bk_nextsize = ptr(ms,victim->bk_nextsize)->fd_nextsize = ofs(ms,victim); + } else { + while ((unsigned long) size < fwd->mchunk_size) { + fwd = ptr(ms,fwd->fd_nextsize); + } + if ((unsigned long) size == (unsigned long) fwd->mchunk_size) + /* Always insert in the second position. */ + fwd = ptr(ms,fwd->fd); + else { + victim->fd_nextsize = ofs(ms,fwd); + victim->bk_nextsize = fwd->bk_nextsize; + fwd->bk_nextsize = ofs(ms,victim); + ptr(ms,victim->bk_nextsize)->fd_nextsize = ofs(ms,victim); + } + bck = ptr(ms,fwd->bk); + } + } else { + victim->fd_nextsize = victim->bk_nextsize = ofs(ms,victim); + } + } + + mark_bin(ms, victim_index); + victim->bk = ofs(ms,bck); + victim->fd = ofs(ms,fwd); + fwd->bk = ofs(ms,victim); + bck->fd = ofs(ms,victim); + +#define MAX_ITERS 10000 + if (++iters >= MAX_ITERS) + break; + } + + /* + If a large request, scan through the chunks of current bin in + sorted order to find smallest that fits. Use the skip list for this. + */ + if (!in_smallbin_range(nb)) { + bin = bin_at(ms, idx); + + /* skip scan if empty or largest chunk is too small */ + if ((victim = ptr(ms,first(bin))) != bin && + (unsigned long) victim->mchunk_size >= (unsigned long) (nb)) { + size_t size; + + victim = ptr(ms,victim->bk_nextsize); + while (((unsigned long) (size = chunksize(victim)) < + (unsigned long) (nb))) + victim = ptr(ms,victim->bk_nextsize); + + /* Avoid removing the first entry for a size so that the skip + list does not have to be rerouted. */ + if (victim != ptr(ms,last(bin)) && + victim->mchunk_size == ptr(ms,victim->fd)->mchunk_size) + victim = ptr(ms,victim->fd); + + remainder_size = size - nb; + unlink_chunk(ms, victim); + + /* Exhaust */ + if (remainder_size < MINSIZE) { + set_inuse_bit_at_offset(victim, size); + } else { /* Split */ + remainder = chunk_at_offset(victim, nb); + + /* We cannot assume the unsorted list is empty and therefore + have to perform a complete insert here. */ + bck = unsorted_chunks(ms); + fwd = ptr(ms,bck->fd); + remainder->bk = ofs(ms,bck); + remainder->fd = ofs(ms,fwd); + bck->fd = fwd->bk = ofs(ms,remainder); + if (!in_smallbin_range(remainder_size)) { + remainder->fd_nextsize = 0; + remainder->bk_nextsize = 0; + } + set_head (victim, nb | PREV_INUSE); + set_head (remainder, remainder_size | PREV_INUSE); + set_foot (remainder, remainder_size); + } + return ofs(ms,chunk2mem(victim)); + } + } + + /* + Search for a chunk by scanning bins, starting with next largest + bin. This search is strictly by best-fit; i.e., the smallest + (with ties going to approximately the least recently used) chunk + that fits is selected. + The bitmap avoids needing to check that most blocks are nonempty. + The particular case of skipping all bins during warm-up phases + when no chunks have been returned yet is faster than it might look. + */ + + ++idx; + bin = bin_at(ms, idx); + unsigned int block = idx2block(idx); + unsigned int map = ms->binmap[block]; + unsigned int bit = idx2bit(idx); + + for (;;) + { + /* Skip rest of block if there are no more set bits in this block. */ + if (bit > map || bit == 0) { + do { + if (++block >= BINMAPSIZE) /* out of bins */ + goto use_top; + } while ((map = ms->binmap[block]) == 0); + bin = bin_at(ms, (block << BINMAPSHIFT)); + bit = 1; + } + + /* Advance to bin with set bit. There must be one. */ + while ((bit & map) == 0) { + bin = next_bin(bin); + bit <<= 1; + } + /* Inspect the bin. It is likely to be non-empty */ + victim = ptr(ms,last(bin)); + /* If a false alarm (empty bin), clear the bit. */ + if (victim == bin) { + ms->binmap[block] = map &= ~bit; /* Write through */ + bin = next_bin(bin); + bit <<= 1; + } else { + size = chunksize(victim); + /* We know the first chunk in this bin is big enough to use. */ + remainder_size = size - nb; + /* unlink */ + unlink_chunk (ms, victim); + /* Exhaust */ + if (remainder_size < MINSIZE) { + set_inuse_bit_at_offset(victim, size); + } else { /* Split */ + remainder = chunk_at_offset(victim, nb); + /* We cannot assume the unsorted list is empty and therefore + have to perform a complete insert here. */ + bck = unsorted_chunks(ms); + fwd = ptr(ms,bck->fd); + remainder->bk = ofs(ms,bck); + remainder->fd = ofs(ms,fwd); + bck->fd = fwd->bk = ofs(ms,remainder); + + /* advertise as last remainder */ + if (in_smallbin_range(nb)) + ms->last_remainder = ofs(ms,remainder); + if (!in_smallbin_range(remainder_size)) { + remainder->fd_nextsize = 0; + remainder->bk_nextsize = 0; + } + set_head (victim, nb | PREV_INUSE); + set_head (remainder, remainder_size | PREV_INUSE); + set_foot (remainder, remainder_size); + } + return ofs(ms,chunk2mem(victim)); + } + } + + use_top: + /* + If large enough, split off the chunk bordering the end of memory + (held in ms->top). Note that this is in accord with the best-fit + search rule. In effect, ms->top is treated as larger (and thus + less well fitting) than any other available chunk since it can + be extended to be as large as necessary (up to system + limitations). + We require that ms->top always exists (i.e., has size >= + MINSIZE) after initialization, so if it would otherwise be + exhausted by current request, it is replenished. (The main + reason for ensuring it exists is that we may need MINSIZE space + to put in fenceposts in sysmalloc.) + */ + victim = ptr(ms,ms->top); + size = chunksize(victim); + + if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE)) { + remainder_size = size - nb; + remainder = chunk_at_offset(victim, nb); + ms->top = ofs(ms,remainder); + set_head(victim, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + return ofs(ms,chunk2mem(victim)); + } else if (ms->have_fastchunks) { + malloc_consolidate (ms); + /* restore original bin index */ + if (in_smallbin_range (nb)) + idx = smallbin_index (nb); + else + idx = largebin_index (nb); + } else { /* Otherwise, relay to handle system-dependent cases */ + size_t page_size = getpagesize(); + size_t alloc_size = + ((nb + MINSIZE - size + page_size - 1) / page_size) * page_size; + + size_t old_size = + ms->top + size + sizeof(size_t); + size_t new_size = + old_size + alloc_size; + + if (ftruncate(fd, new_size) < 0) + throw std::system_error(errno, std::generic_category()); + + malloc_state* new_ms = + (malloc_state*) mremap(ms, old_size, new_size, MREMAP_MAYMOVE); + if (new_ms == MAP_FAILED) + throw std::system_error(errno, std::generic_category()); + + ms = new_ms; + current_base = (unsigned char*) ms; + + victim = ptr(ms,ms->top); + + size += alloc_size; + + remainder_size = size - nb; + remainder = chunk_at_offset(victim, nb); + ms->top = ofs(ms,remainder); + set_head(victim, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + return ofs(ms,chunk2mem(victim)); + } + } +} + +void +DB::free(moffset o) +{ + size_t size; /* its size */ + moffset *fb; /* associated fastbin */ + mchunk *nextchunk; /* next contiguous chunk */ + size_t nextsize; /* its size */ + int nextinuse; /* true if nextchunk is used */ + size_t prevsize; /* size of previous contiguous chunk */ + mchunk* bck; /* misc temp for linking */ + mchunk* fwd; /* misc temp for linking */ + + mchunk* p = ptr(ms,o); + size = chunksize (p); + + + /* + If eligible, place chunk on a fastbin so it can be found + and used quickly in malloc. + */ + if ((unsigned long)(size) <= (unsigned long)(DEFAULT_MXFAST)) { + ms->have_fastchunks = true; + unsigned int idx = fastbin_index(size); + fb = &ms->fastbins[idx]; + /* Atomically link P to its fastbin: P->FD = *FB; *FB = P; */ + p->fd = *fb; + *fb = ofs(ms,p); + } else { /* Consolidate other chunks as they arrive. */ + nextchunk = chunk_at_offset(p, size); + nextsize = chunksize(nextchunk); + /* consolidate backward */ + if (!prev_inuse(p)) { + prevsize = prev_size(p); + size += prevsize; + p = chunk_at_offset(p, -((long) prevsize)); + unlink_chunk (ms, p); + } + if (nextchunk != ptr(ms,ms->top)) { + /* get and clear inuse bit */ + nextinuse = inuse_bit_at_offset(nextchunk, nextsize); + /* consolidate forward */ + if (!nextinuse) { + unlink_chunk (ms, nextchunk); + size += nextsize; + } else + clear_inuse_bit_at_offset(nextchunk, 0); + /* + Place the chunk in unsorted chunk list. Chunks are + not placed into regular bins until after they have + been given one chance to be used in malloc. + */ + bck = unsorted_chunks(ms); + fwd = ptr(ms,bck->fd); + p->fd = ofs(ms,fwd); + p->bk = ofs(ms,bck); + if (!in_smallbin_range(size)) { + p->fd_nextsize = 0; + p->bk_nextsize = 0; + } + bck->fd = ofs(ms,p); + fwd->bk = ofs(ms,p); + set_head(p, size | PREV_INUSE); + set_foot(p, size); + } else { + /* + If the chunk borders the current high end of memory, + consolidate into top + */ + + size += nextsize; + set_head(p, size | PREV_INUSE); + ms->top = ofs(ms,p); + } + + /* + If freeing a large space, consolidate possibly-surrounding + chunks. Then, if the total unused topmost memory exceeds trim + threshold, ask malloc_trim to reduce top. + Unless max_fast is 0, we don't know if there are fastbins + bordering top, so we cannot tell for sure whether threshold + has been reached unless fastbins are consolidated. But we + don't want to consolidate on each free. As a compromise, + consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD + is reached. + */ + if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) { + if (ms->have_fastchunks) + malloc_consolidate(ms); + } + } +} diff --git a/src/runtime/c/db.h b/src/runtime/c/db.h new file mode 100644 index 000000000..a484c2399 --- /dev/null +++ b/src/runtime/c/db.h @@ -0,0 +1,55 @@ +#ifndef DB_H +#define DB_H + +class DB; + +extern thread_local PGF_INTERNAL_DECL unsigned char* current_base; +extern thread_local PGF_INTERNAL_DECL DB* current_db; + +typedef size_t moffset; + +struct malloc_state; + +template class ref { + size_t offset; + +public: + ref() { } + ref(size_t o) { offset = o; } + inline A* operator->() const { return (A*) (current_base+offset); } + inline operator A*() const { return (A*) (current_base+offset); } + inline bool operator ==(ref& other) const { return offset==other->offset; } + inline operator size_t() { return offset; } +}; + +class PGF_INTERNAL_DECL DB { + int fd; + malloc_state* ms; + +public: + DB(const char* pathname); + ~DB(); + + template ref malloc() { + return malloc(sizeof(A)); + } + + moffset malloc(size_t bytes); + + template ref get_root() { + return get_root_offset(); + } + template void set_root(ref root) { + set_root_offset(root); + } + +private: + void init_state(size_t size); + + void free(moffset o); + + moffset get_root_offset(); + void set_root_offset(moffset root); +}; + +#endif diff --git a/src/runtime/c/expr.h b/src/runtime/c/expr.h new file mode 100644 index 000000000..6a077458d --- /dev/null +++ b/src/runtime/c/expr.h @@ -0,0 +1,30 @@ +#ifndef EXPR_H_ +#define EXPR_H_ + +#include "variant.h" + +// PgfLiteral + +typedef variant PgfLiteral; + + +typedef enum { + PGF_LITERAL_STR, + PGF_LITERAL_INT, + PGF_LITERAL_FLT, + PGF_LITERAL_NUM_TAGS +} PgfLiteralTag; + +typedef struct { + char val[0]; // a flexible array that contains the value +} PgfLiteralStr; + +typedef struct { + int val; +} PgfLiteralInt; + +typedef struct { + double val; +} PgfLiteralFlt; + +#endif /* EXPR_H_ */ diff --git a/src/runtime/c/gu/assert.c b/src/runtime/c/gu/assert.c deleted file mode 100644 index ff2ab1355..000000000 --- a/src/runtime/c/gu/assert.c +++ /dev/null @@ -1,52 +0,0 @@ -#include -#include -#include -#include - -static const char* -gu_assert_mode_descs[] = { - [GU_ASSERT_PRECOND] = "precondition failed", - [GU_ASSERT_POSTCOND] = "postcondition failed", - [GU_ASSERT_ASSERTION] = "assertion failed", - [GU_ASSERT_NEVER] = "control should not reach here", -}; - -GU_API void -gu_abort_v_(GuAssertMode mode, - const char* file, const char* func, int line, - const char* msg_fmt, va_list args) -{ - const char* desc = gu_assert_mode_descs[mode]; - (void) fprintf(stderr, "%s (%s:%d): %s\n", func, file, line, desc); - if (msg_fmt != NULL) { - (void) fputc('\t', stderr); - (void) vfprintf(stderr, msg_fmt, args); - (void) fputc('\n', stderr); - } - abort(); -} - -GU_API void -gu_abort_(GuAssertMode mode, - const char* file, const char* func, int line, - const char* msg_fmt, ...) -{ - va_list args; - va_start(args, msg_fmt); - gu_abort_v_(mode, file, func, line, msg_fmt, args); - va_end(args); -} - -GU_API void -gu_fatal(const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - fputs("Fatal error", stderr); - if (fmt) { - fputs(": ", stderr); - (void) vfprintf(stderr, fmt, args); - } - fputc('\n', stderr); - abort(); -} diff --git a/src/runtime/c/gu/assert.h b/src/runtime/c/gu/assert.h deleted file mode 100644 index a49d64748..000000000 --- a/src/runtime/c/gu/assert.h +++ /dev/null @@ -1,61 +0,0 @@ -#ifndef GU_ASSERT_H_ -#define GU_ASSERT_H_ - -#include - -typedef enum { - GU_ASSERT_PRECOND, - GU_ASSERT_ASSERTION, - GU_ASSERT_POSTCOND, - GU_ASSERT_NEVER -} GuAssertMode; - -GU_API_DECL void -gu_abort_v_(GuAssertMode mode, - const char* file, const char* func, int line, - const char* msg_fmt, va_list args); - -GU_API_DECL void -gu_abort_(GuAssertMode mode, - const char* file, const char* func, int line, - const char* msg_fmt, ...); - -#ifndef NDEBUG -#define gu_assertion_(mode_, expr_, ...) \ - GU_BEGIN \ - if (!(expr_)) { \ - gu_abort_(mode_, __FILE__, __func__, __LINE__, __VA_ARGS__); \ - } \ - GU_END -#else -// this should prevent unused variable warnings when a variable is only used -// in an assertion -#define gu_assertion_(mode_, expr_, ...) \ - GU_BEGIN \ - (void) (sizeof (expr_)); \ - GU_END -#endif - - -#define gu_require(expr) \ - gu_assertion_(GU_ASSERT_PRECOND, expr, "%s", #expr) - -#define gu_assert_msg(expr, ...) \ - gu_assertion_(GU_ASSERT_ASSERTION, expr, __VA_ARGS__) - -#define gu_assert(expr) \ - gu_assert_msg(expr, "%s", #expr) - -#define gu_ensure(expr) \ - gu_assertion_(GU_ASSERT_POSTCOND, expr, "%s", #expr) - -#define gu_impossible_msg(...) \ - gu_assertion_(GU_ASSERT_ASSERTION, false, __VA_ARGS__) - -#define gu_impossible() \ - gu_impossible_msg(NULL) - -GU_API_DECL void -gu_fatal(const char* fmt, ...); - -#endif /* GU_ASSERT_H_ */ diff --git a/src/runtime/c/gu/bits.c b/src/runtime/c/gu/bits.c deleted file mode 100644 index b5696a19c..000000000 --- a/src/runtime/c/gu/bits.c +++ /dev/null @@ -1,76 +0,0 @@ -#include - -#include -#include -#include -#include -#include -#include - -GU_INTERNAL unsigned -gu_ceil2e(unsigned u) -{ - u--; - u |= u >> 1; - u |= u >> 2; - u |= u >> 4; - u |= u >> 8; -#if UINT_MAX > UINT16_MAX - u |= u >> 16; -#endif -#if UINT_MAX > UINT32_MAX - u |= u >> 32; -#endif - u++; - return u; -} - -GU_INTERNAL double -gu_decode_double(uint64_t u) -{ - bool sign = u >> 63; - unsigned rawexp = u >> 52 & 0x7ff; - uint64_t mantissa = u & 0xfffffffffffff; - double ret; - - if (rawexp == 0x7ff) { - ret = (mantissa == 0) ? INFINITY : NAN; - } else { - uint64_t m = rawexp ? 1ULL << 52 | mantissa : mantissa << 1; - ret = ldexp((double) m, rawexp - 1075); - } - return sign ? copysign(ret, -1.0) : ret; -} - -GU_INTERNAL uint64_t -gu_encode_double(double d) -{ - int sign = signbit(d) > 0; - unsigned rawexp; - uint64_t mantissa; - - switch (fpclassify(d)) { - case FP_NAN: - rawexp = 0x7ff; - mantissa = 1; - break; - case FP_INFINITE: - rawexp = 0x7ff; - mantissa = 0; - break; - default: { - int exp; - mantissa = (uint64_t) scalbn(frexp(d, &exp), 53); - mantissa &= ~ (1ULL << 52); - exp -= 53; - - rawexp = exp + 1075; - } - } - - uint64_t u = (((uint64_t) sign) << 63) | - (((uint64_t) rawexp & 0x7ff) << 52) | - mantissa; - - return u; -} diff --git a/src/runtime/c/gu/bits.h b/src/runtime/c/gu/bits.h deleted file mode 100644 index ee619f400..000000000 --- a/src/runtime/c/gu/bits.h +++ /dev/null @@ -1,150 +0,0 @@ -#ifndef GU_BITS_H_ -#define GU_BITS_H_ - -#include -#include - - -#define GU_WORD_BITS (sizeof(GuWord) * CHAR_BIT) - - -/* - * Based on the Bit Twiddling Hacks collection by Sean Eron Anderson - * - */ - -GU_INTERNAL_DECL -unsigned gu_ceil2e(unsigned i); - -static inline int -gu_sign(int i) { - return (i > 0) - (i < 0); -} - -static inline size_t -gu_ceildiv(size_t size, size_t div) -{ - return (size + div - 1) / div; -} - -static inline bool -gu_aligned(uintptr_t addr, size_t alignment) -{ - //gu_require(alignment == gu_ceil2e(alignment)); - return (addr & (alignment - 1)) == 0; -} - -static inline uintptr_t -gu_align_forward(uintptr_t addr, size_t alignment) { - //gu_require(alignment == gu_ceil2e(alignment)); - uintptr_t mask = alignment - 1; - return (addr + mask) & ~mask; -} - -static inline uintptr_t -gu_align_backward(uintptr_t addr, size_t alignment) { - //gu_require(alignment == gu_ceil2e(alignment)); - return addr & ~(alignment - 1); -} - -static inline bool -gu_bits_test(const GuWord* bitmap, int idx) { - return !!(bitmap[idx / GU_WORD_BITS] & 1 << (idx % GU_WORD_BITS)); -} - -static inline void -gu_bits_set(GuWord* bitmap, int idx) { - bitmap[idx / GU_WORD_BITS] |= ((GuWord) 1) << (idx % GU_WORD_BITS); -} - -static inline void -gu_bits_clear(GuWord* bitmap, int idx) { - bitmap[idx / GU_WORD_BITS] &= ~(((GuWord) 1) << (idx % GU_WORD_BITS)); -} - -static inline size_t -gu_bits_size(size_t n_bits) { - return gu_ceildiv(n_bits, GU_WORD_BITS) * sizeof(GuWord); -} - -static inline void* -gu_word_ptr(GuWord w) -{ - return (void*) w; -} - -static inline GuWord -gu_ptr_word(void* p) -{ - return (GuWord) p; -} - -#define GuOpaque() struct { GuWord w_; } - -typedef GuWord GuTagged; - -#define GU_TAG_MAX (sizeof(GuWord) - 1) - -static inline size_t -gu_tagged_tag(GuTagged t) { - return (int) (t & (sizeof(GuWord) - 1)); -} - -static inline void* -gu_tagged_ptr(GuTagged w) { - return (void*) gu_align_backward(w, sizeof(GuWord)); -} - -static inline GuTagged -gu_tagged(void* ptr, size_t tag) { - gu_require(tag < sizeof(GuWord)); - uintptr_t u = (uintptr_t) ptr; - gu_require(gu_align_backward(u, sizeof(GuWord)) == u); - return (GuWord) { u | tag }; -} - -#include - -#define GU_DECODE_2C_(u_, t_, umax_, posmax_, tmin_, err_) \ - (((u_) <= (posmax_)) \ - ? (t_) (u_) \ - : (tmin_) + ((t_) ((umax_) - (u_))) < 0 \ - ? (t_) (-1 - ((t_) ((umax_) - (u_)))) \ - : (t_) (gu_raise(err_, GuIntDecodeExn), -1)) - - -static inline int8_t -gu_decode_2c8(uint8_t u, GuExn* err) -{ - return GU_DECODE_2C_(u, int8_t, UINT8_C(0xff), - UINT8_C(0x7f), INT8_MIN, err); -} - -static inline int16_t -gu_decode_2c16(uint16_t u, GuExn* err) -{ - return GU_DECODE_2C_(u, int16_t, UINT16_C(0xffff), - UINT16_C(0x7fff), INT16_MIN, err); -} - -static inline int32_t -gu_decode_2c32(uint32_t u, GuExn* err) -{ - return GU_DECODE_2C_(u, int32_t, UINT32_C(0xffffffff), - UINT32_C(0x7fffffff), INT32_MIN, err); -} - -static inline int64_t -gu_decode_2c64(uint64_t u, GuExn* err) -{ - return GU_DECODE_2C_(u, int64_t, UINT64_C(0xffffffffffffffff), - UINT64_C(0x7fffffffffffffff), INT64_MIN, err); -} - -GU_INTERNAL_DECL double -gu_decode_double(uint64_t u); - -GU_INTERNAL_DECL uint64_t -gu_encode_double(double d); - -#endif // GU_BITS_H_ diff --git a/src/runtime/c/gu/choice.c b/src/runtime/c/gu/choice.c deleted file mode 100644 index 5102e15e9..000000000 --- a/src/runtime/c/gu/choice.c +++ /dev/null @@ -1,68 +0,0 @@ -#include -#include -#include - -struct GuChoice { - GuBuf* path; - size_t path_idx; -}; - -GU_API GuChoice* -gu_new_choice(GuPool* pool) -{ - GuChoice* ch = gu_new(GuChoice, pool); - ch->path = gu_new_buf(size_t, pool); - ch->path_idx = 0; - return ch; -} - -GU_API GuChoiceMark -gu_choice_mark(GuChoice* ch) -{ - gu_assert(ch->path_idx <= gu_buf_length(ch->path)); - return (GuChoiceMark){ch->path_idx}; -} - -GU_API void -gu_choice_reset(GuChoice* ch, GuChoiceMark mark) -{ - gu_assert(ch->path_idx <= gu_buf_length(ch->path)); - gu_require(mark.path_idx <= ch->path_idx ); - ch->path_idx = mark.path_idx; -} - -GU_API int -gu_choice_next(GuChoice* ch, int n_choices) -{ - gu_assert(n_choices >= 0); - gu_assert(ch->path_idx <= gu_buf_length(ch->path)); - if (n_choices == 0) { - return -1; - } - int i = 0; - if (gu_buf_length(ch->path) > ch->path_idx) { - i = (int) gu_buf_get(ch->path, size_t, ch->path_idx); - gu_assert(i <= n_choices); - } else { - gu_buf_push(ch->path, size_t, n_choices); - i = n_choices; - } - int ret = (i == 0) ? -1 : n_choices - i; - ch->path_idx++; - return ret; -} - -GU_API bool -gu_choice_advance(GuChoice* ch) -{ - gu_assert(ch->path_idx <= gu_buf_length(ch->path)); - - while (gu_buf_length(ch->path) > ch->path_idx) { - size_t last = gu_buf_pop(ch->path, size_t); - if (last > 1) { - gu_buf_push(ch->path, size_t, last-1); - return true; - } - } - return false; -} diff --git a/src/runtime/c/gu/choice.h b/src/runtime/c/gu/choice.h deleted file mode 100644 index 976bdce47..000000000 --- a/src/runtime/c/gu/choice.h +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef GU_CHOICE_H_ -#define GU_CHOICE_H_ - -#include - -typedef struct GuChoice GuChoice; - -typedef struct GuChoiceMark GuChoiceMark; - -GU_API_DECL GuChoice* -gu_new_choice(GuPool* pool); - -GU_API_DECL int -gu_choice_next(GuChoice* ch, int n_choices); - -GU_API_DECL GuChoiceMark -gu_choice_mark(GuChoice* ch); - -GU_API_DECL void -gu_choice_reset(GuChoice* ch, GuChoiceMark mark); - -GU_API_DECL bool -gu_choice_advance(GuChoice* ch); - - -// private - -struct GuChoiceMark { - size_t path_idx; -}; - - - - - - -#endif // GU_CHOICE_H_ diff --git a/src/runtime/c/gu/defs.c b/src/runtime/c/gu/defs.c deleted file mode 100644 index ec1098433..000000000 --- a/src/runtime/c/gu/defs.c +++ /dev/null @@ -1,4 +0,0 @@ -#include - -void* const gu_null = NULL; -GU_API GuStruct* const gu_null_struct = NULL; diff --git a/src/runtime/c/gu/defs.h b/src/runtime/c/gu/defs.h deleted file mode 100644 index 9f59d8656..000000000 --- a/src/runtime/c/gu/defs.h +++ /dev/null @@ -1,227 +0,0 @@ -/** @file - * - * Miscellaneous macros. - */ - -#ifndef GU_DEFS_H_ -#define GU_DEFS_H_ - -// MSVC requires explicit export/import of -// symbols in DLLs. CMake takes care of this -// for functions, but not for data/variables. -#if defined(_MSC_VER) -#if defined(COMPILING_GU) -#define GU_API_DECL __declspec(dllexport) -#define GU_API __declspec(dllexport) -#else -#define GU_API_DECL __declspec(dllimport) -#define GU_API ERROR_NOT_COMPILING_LIBGU -#endif - -#define GU_INTERNAL_DECL -#define GU_INTERNAL - -#define restrict __restrict - -#else - -#define GU_API_DECL -#define GU_API - -#define GU_INTERNAL_DECL __attribute__ ((visibility ("hidden"))) -#define GU_INTERNAL __attribute__ ((visibility ("hidden"))) -#endif -// end MSVC workaround - -#include -#include -#include -#include -#include -#include -#include - -#define gu_container(mem_p, container_type, member) \ - ((container_type*)(((uint8_t*) (mem_p)) - offsetof(container_type, member))) -/**< Find the address of a containing structure. - * - * If @c s has type @c t*, where @c t is a struct or union type with a - * member @m, then GU_CONTAINER_P(&s->m, t, m) == s. - * - * @param mem_p Pointer to the member of a structure. - * @param container_type The type of the containing structure. - * @param member The name of the member of @a container_type - * @return The address of the containing structure. - * - * @hideinitializer */ - - -#define gu_member_p(struct_p_, offset_) \ - ((void*)&((uint8_t*)(struct_p_))[offset_]) - -#define gu_member(t_, struct_p_, offset_) \ - (*(t_*)gu_member_p(struct_p_, offset_)) - -#ifdef GU_ALIGNOF -# define gu_alignof GU_ALIGNOF -#elif defined(_MSC_VER) -# define gu_alignof __alignof -#else -# define gu_alignof(t_) \ - ((size_t)(offsetof(struct { char c_; t_ e_; }, e_))) -#endif - -#define GU_PLIT(type, expr) \ - ((type[1]){ expr }) - -#define GU_LVALUE(type, expr) \ - (*((type[1]){ expr })) - -#define GU_COMMA , - -#define GU_ARRAY_LEN(a) (sizeof(a) / sizeof(a[0])) - -#define GU_ID(...) __VA_ARGS__ - -// This trick is by Laurent Deniau -#define GU_N_ARGS(...) \ - GU_N_ARGS_(__VA_ARGS__, \ - 31,30,29,28,27,26,25,24, \ - 23,22,21,20,19,18,17,16, \ - 15,14,13,12,11,10,9,8, \ - 7,6,5,4,3,2,1,0) -#define GU_N_ARGS_(...) GU_N_ARGS__(__VA_ARGS__) -#define GU_N_ARGS__(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p, \ - q,r,s,t,u,v,w,x,y,z,aa,ab,ac,ad,ae,N,...) \ - N - -#define GU_ARG1(a1, ...) a1 -#define GU_ARG2(a1, a2, ...) a2 - -#define GU_BEGIN do { -#define GU_END } while (false) - -#define GU_NOP GU_BEGIN (void) 0; GU_END - -/**< @hideinitializer */ - -// -// Assert -// - -#define GU_MAX(a_, b_) ((a_) > (b_) ? (a_) : (b_)) -#define GU_MIN(a_, b_) ((a_) < (b_) ? (a_) : (b_)) - -static inline int -gu_max(int a, int b) { - return GU_MAX(a, b); -} - -static inline int -gu_min(int a, int b) { - return GU_MIN(a, b); -} - -#ifdef GU_ALIGNOF -#define gu_flex_alignof gu_alignof -#else -#define gu_flex_alignof(t) 0 -#endif - -static inline size_t -gu_flex_size(size_t ssize, size_t offset, int n_elems, size_t e_size) -{ - return GU_MAX(ssize, offset + n_elems * e_size); -} - -#define GU_FLEX_SIZE(type, flex_member, n_elems) \ - gu_flex_size(sizeof(type), offsetof(type, flex_member), \ - n_elems, sizeof(((type*)NULL)->flex_member[0])) - - -// The following are directly from gmacros.h in GLib - -#define GU_PASTE_ARGS(id1_,id2_) \ - id1_ ## id2_ - -#define GU_PASTE(id1_, id2_) \ - GU_PASTE_ARGS(id1_, id2_) - -#define GU_STATIC_ASSERT(expr_) \ - typedef struct { \ - char static_assert[(expr_) ? 1 : -1]; \ - } GU_PASTE(GuStaticAssert_, __LINE__) - - -#define GU_ENSURE_TYPE(T, EXPR) \ - ((void)(sizeof(*(T*)NULL=(EXPR))),(EXPR)) - -#define GU_END_DECLS \ - extern void gu_dummy_(void) - -extern void* const gu_null; - -// Dummy struct used for generic struct pointers -typedef struct GuStruct GuStruct; - -GU_API_DECL extern GuStruct* const gu_null_struct; - -typedef uintptr_t GuWord; - -#define GU_WORD_MAX UINTPTR_MAX - -// TODO: use max_align_t once C1X is supported -typedef union { - char c; - short s; - int i; - long l; - long long ll; - intmax_t im; - float f; - double d; - long double ld; - void* p; - void (*fp)(); -} GuMaxAlign; - -#if defined(_MSC_VER) -#include -#define gu_alloca(N) alloca(N) -#else -#define gu_alloca(N) \ - (((union { GuMaxAlign align_; uint8_t buf_[N]; }){{0}}).buf_) -#endif - -// For Doxygen -#define GU_PRIVATE /** @private */ - -#ifdef GU_GNUC -# define GU_LIKELY(EXPR) __builtin_expect(EXPR, 1) -# define GU_UNLIKELY(EXPR) __builtin_expect(EXPR, 0) -# define GU_IS_CONSTANT(EXPR) __builtin_constant_p(EXPR) -#else -# define GU_LIKELY(EXPR) (EXPR) -# define GU_UNLIKELY(EXPR) (EXPR) -# ifdef GU_OPTIMIZE_SIZE -# define GU_IS_CONSTANT(EXPR) false -# else -# define GU_IS_CONSTANT(EXPR) true -# endif -#endif - -// Splint annotations -#define GU_ONLY GU_SPLINT(only) -#define GU_NULL GU_SPLINT(null) -#define GU_NOTNULL GU_SPLINT(notnull) -#define GU_RETURNED GU_SPLINT(returned) -#define GU_ABSTRACT GU_SPLINT(abstract) -#define GU_IMMUTABLE GU_SPLINT(immutable) -#define GU_NOTREACHED GU_SPLINT(notreached) -#define GU_UNUSED GU_SPLINT(unused) GU_GNUC_ATTR(unused) -#define GU_OUT GU_SPLINT(out) -#define GU_IN GU_SPLINT(in) -#define GU_NORETURN GU_SPLINT(noreturn) GU_GNUC_ATTR(noreturn) -#define GU_MODIFIES(x) GU_SPLINT(modifies x) - -#endif // GU_DEFS_H_ diff --git a/src/runtime/c/gu/enum.c b/src/runtime/c/gu/enum.c deleted file mode 100644 index 538ef0dbc..000000000 --- a/src/runtime/c/gu/enum.c +++ /dev/null @@ -1,7 +0,0 @@ -#include - -GU_API void -gu_enum_next(GuEnum* en, void* to, GuPool* pool) -{ - en->next(en, to, pool); -} diff --git a/src/runtime/c/gu/enum.h b/src/runtime/c/gu/enum.h deleted file mode 100644 index 92f5d69f6..000000000 --- a/src/runtime/c/gu/enum.h +++ /dev/null @@ -1,35 +0,0 @@ -#ifndef GU_ENUM_H_ -#define GU_ENUM_H_ - -#include - -typedef struct GuEnum GuEnum; - -struct GuEnum { - void (*next)(GuEnum* self, void* to, GuPool* pool); -}; - -GU_API_DECL void -gu_enum_next(GuEnum* en, void* to, GuPool* pool); - -#ifdef GU_GNUC - -#define gu_next(ENUM, T, POOL) \ - ({ \ - T gu_next_tmp_; \ - gu_enum_next((ENUM), &gu_next_tmp_, (POOL)); \ - gu_next_tmp_; \ - }) -#else -static inline void* -gu_enum_next_(GuEnum* en, void* to, GuPool* pool) -{ - gu_enum_next(en, to, pool); - return to; -} -#define gu_next(ENUM, T, POOL) \ - (*(T*)gu_enum_next_((ENUM), &(T){0}, (POOL))) - -#endif - -#endif /* GU_ENUM_H_ */ diff --git a/src/runtime/c/gu/exn.c b/src/runtime/c/gu/exn.c deleted file mode 100644 index c6c7652d6..000000000 --- a/src/runtime/c/gu/exn.c +++ /dev/null @@ -1,78 +0,0 @@ -#include -#include - - -GU_API GuExn* -gu_new_exn(GuPool* pool) -{ - GuExn* exn = gu_new(GuExn, pool); - exn->state = GU_EXN_OK; - exn->caught = NULL; - exn->data.pool = pool; - exn->data.data = NULL; - return exn; -} - -GU_API bool -gu_exn_is_raised(GuExn* err) { - return err && (err->state == GU_EXN_RAISED); -} - -GU_API bool -gu_exn_caught_(GuExn* err, const char* type) -{ - return (err->caught && strcmp(err->caught, type) == 0); -} - -GU_API void -gu_exn_block(GuExn* err) -{ - if (err && err->state == GU_EXN_RAISED) { - err->state = GU_EXN_BLOCKED; - } -} - -GU_API void -gu_exn_unblock(GuExn* err) -{ - if (err && err->state == GU_EXN_BLOCKED) { - err->state = GU_EXN_RAISED; - } -} - -GU_API GuExnData* -gu_exn_raise_debug_(GuExn* err, const char* type, - const char* filename, const char* func, int lineno) -{ - gu_require(type); - - GuExnState old_state = err->state; - err->state = GU_EXN_RAISED; - if (old_state == GU_EXN_OK) { - err->caught = type; - if (err->data.pool) { - return &err->data; - } - } - - // Exceptian had already been raised, possibly blocked, or no - // exception value is required. - return NULL; -} - -GU_API GuExnData* -gu_exn_raise_(GuExn* base, const char* type) -{ - return gu_exn_raise_debug_(base, type, NULL, NULL, -1); -} - -GU_API void -gu_raise_errno(GuExn* err) -{ - GuExnData* err_data = gu_raise(err, GuErrno); - if (err_data) { - GuErrno* gu_errno = gu_new(GuErrno, err_data->pool); - *gu_errno = errno; - err_data->data = gu_errno; - } -} diff --git a/src/runtime/c/gu/exn.h b/src/runtime/c/gu/exn.h deleted file mode 100644 index 6f5d0ff38..000000000 --- a/src/runtime/c/gu/exn.h +++ /dev/null @@ -1,171 +0,0 @@ -#ifndef GU_EXN_H_ -#define GU_EXN_H_ - -#include - -/** @file - * - * @defgroup GuExn Exceptions - * Defined in . - * @{ - */ - -/// An exception frame. -typedef struct GuExn GuExn; - -/// @private -typedef enum { - GU_EXN_RAISED, - GU_EXN_OK, - GU_EXN_BLOCKED -} GuExnState; - -typedef struct GuExnData GuExnData; - -/// A structure for storing exception values. -struct GuExnData -/** - * When an exception is raised, if there is an associated value, it - * must be allocated from a pool that still exists when control - * returns to the handler of that exception. This structure is used to - * communicate the exception from the raiser to the handler: the - * handler sets #pool when setting up the exception frame, and the - * raiser uses that pool to allocate the value and stores that in - * #data. When control returns to the handler, it reads the value from - * there. - */ -{ - - /// The pool that the exception value should be allocated from. - GuPool* pool; - - /// The exception value. - void* data; -}; - -struct GuExn { - /// @privatesection - GuExnState state; - const char* caught; - GuExnData data; -}; - - -/// @name Creating exception frames -//@{ - - -/// Allocate a new local exception frame. -#define gu_exn(pool_) &(GuExn){ \ - .state = GU_EXN_OK, \ - .caught = NULL, \ - .data = {.pool = pool_, .data = NULL} \ -} - - -/// Allocate a new exception frame. -GU_API_DECL GuExn* -gu_new_exn(GuPool* pool); - - -GU_API_DECL bool -gu_exn_is_raised(GuExn* err); - -static inline void -gu_exn_clear(GuExn* err) { - err->caught = NULL; - err->state = GU_EXN_OK; -} - -#define gu_exn_caught(err, type) \ - (err->caught && strcmp(err->caught, #type) == 0) - -GU_API_DECL bool -gu_exn_caught_(GuExn* err, const char* type); - -static inline const void* -gu_exn_caught_data(GuExn* err) -{ - return err->data.data; -} - -/// Temporarily block a raised exception. -GU_API_DECL void -gu_exn_block(GuExn* err); - -/// Show again a blocked exception. -GU_API_DECL void -gu_exn_unblock(GuExn* err); - -//@private -GU_API_DECL GuExnData* -gu_exn_raise_(GuExn* err, const char* type); - -//@private -GU_API_DECL GuExnData* -gu_exn_raise_debug_(GuExn* err, const char* type, - const char* filename, const char* func, int lineno); - -#ifdef NDEBUG -#define gu_exn_raise(err_, type_) \ - gu_exn_raise_(err_, type_) -#else -#define gu_exn_raise(err_, type_) \ - gu_exn_raise_debug_(err_, type_, \ - __FILE__, __func__, __LINE__) -#endif - -/// Raise an exception. -#define gu_raise(exn, T) \ - gu_exn_raise(exn, #T) -/**< - * @param exn The current exception frame. - * - * @param T The C type of the exception to raise. - * - * @return A #GuExnData object that can be used to store the exception value, or - * \c NULL if no value is required. - * - * @note The associated #GuType object for type \p T must be visible. - */ - -#define gu_raise_new(error_, t_, pool_, expr_) \ - GU_BEGIN \ - GuExnData* gu_raise_err_ = gu_raise(error_, t_); \ - if (gu_raise_err_) { \ - GuPool* pool_ = gu_raise_err_->pool; \ - gu_raise_err_->data = expr_; \ - } \ - GU_END - -/// Check the status of the current exception frame -static inline bool -gu_ok(GuExn* exn) { - return !GU_UNLIKELY(gu_exn_is_raised(exn)); -} -/**< - * @return \c false if an exception has been raised in the frame \p exn - * and it has not been blocked, \c true otherwise. - */ - - -/// Return from current function if an exception has been raised. -#define gu_return_on_exn(exn_, retval_) \ - GU_BEGIN \ - if (gu_exn_is_raised(exn_)) return retval_; \ - GU_END -/**< - * @showinitializer - */ - - -#include - -typedef int GuErrno; - -GU_API_DECL void -gu_raise_errno(GuExn* err); - -/** @} */ - -#endif // GU_EXN_H_ diff --git a/src/runtime/c/gu/file.c b/src/runtime/c/gu/file.c deleted file mode 100644 index c5a9f6912..000000000 --- a/src/runtime/c/gu/file.c +++ /dev/null @@ -1,77 +0,0 @@ -#include - -typedef struct GuFileOutStream GuFileOutStream; - -struct GuFileOutStream { - GuOutStream stream; - FILE* file; -}; - -static size_t -gu_file_output(GuOutStream* stream, const uint8_t* buf, size_t len, GuExn* err) -{ - GuFileOutStream* fos = gu_container(stream, GuFileOutStream, stream); - errno = 0; - size_t wrote = fwrite(buf, 1, len, fos->file); - if (wrote < len) { - if (ferror(fos->file)) { - gu_raise_errno(err); - } - } - return wrote; -} - -static void -gu_file_flush(GuOutStream* stream, GuExn* err) -{ - GuFileOutStream* fos = gu_container(stream, GuFileOutStream, stream); - errno = 0; - if (fflush(fos->file) != 0) { - gu_raise_errno(err); - } -} - -GU_API GuOut* -gu_file_out(FILE* file, GuPool* pool) -{ - GuFileOutStream* fos = gu_new(GuFileOutStream, pool); - fos->stream.begin_buf = NULL; - fos->stream.end_buf = NULL; - fos->stream.output = gu_file_output; - fos->stream.flush = gu_file_flush; - fos->file = file; - return gu_new_out(&fos->stream, pool); -} - - -typedef struct GuFileInStream GuFileInStream; - -struct GuFileInStream { - GuInStream stream; - FILE* file; -}; - -static size_t -gu_file_input(GuInStream* stream, uint8_t* buf, size_t sz, GuExn* err) -{ - GuFileInStream* fis = gu_container(stream, GuFileInStream, stream); - errno = 0; - size_t got = fread(buf, 1, sz, fis->file); - if (got == 0) { - if (ferror(fis->file)) { - gu_raise_errno(err); - } - } - return got; -} - -GU_API GuIn* -gu_file_in(FILE* file, GuPool* pool) -{ - GuFileInStream* fis = gu_new(GuFileInStream, pool); - fis->stream.begin_buffer = NULL; - fis->stream.end_buffer = NULL; - fis->stream.input = gu_file_input; - fis->file = file; - return gu_new_in(&fis->stream, pool); -} diff --git a/src/runtime/c/gu/file.h b/src/runtime/c/gu/file.h deleted file mode 100644 index 9636b8383..000000000 --- a/src/runtime/c/gu/file.h +++ /dev/null @@ -1,14 +0,0 @@ -#ifndef GU_FILE_H_ -#define GU_FILE_H_ - -#include -#include -#include - -GU_API_DECL GuOut* -gu_file_out(FILE* file, GuPool* pool); - -GU_API_DECL GuIn* -gu_file_in(FILE* file, GuPool* pool); - -#endif // GU_FILE_H_ diff --git a/src/runtime/c/gu/fun.c b/src/runtime/c/gu/fun.c deleted file mode 100644 index ca777c490..000000000 --- a/src/runtime/c/gu/fun.c +++ /dev/null @@ -1 +0,0 @@ -#include diff --git a/src/runtime/c/gu/fun.h b/src/runtime/c/gu/fun.h deleted file mode 100644 index f4c1a5a38..000000000 --- a/src/runtime/c/gu/fun.h +++ /dev/null @@ -1,71 +0,0 @@ -#ifndef GU_FUN_H_ -#define GU_FUN_H_ - -#include - -typedef void (*GuFn)(); -typedef void (*GuFn0)(GuFn* clo); -typedef void (*GuFn1)(GuFn* clo, void* arg1); -typedef void (*GuFn2)(GuFn* clo, void* arg1, void* arg2); - -#define gu_fn(fn_) (&(GuFn){ fn_ }) - -static inline void -gu_apply0(GuFn* fn) { - (*fn)(fn); -} - -static inline void -gu_apply1(GuFn* fn, void* arg1) { - (*fn)(fn, arg1); -} - -static inline void -gu_apply2(GuFn* fn, void* arg1, void* arg2) { - (*fn)(fn, arg1, arg2); -} - -#define gu_apply(fn_, ...) \ - ((fn_)->fn((fn_), __VA_ARGS__)) - -typedef struct GuClo0 GuClo0; - -struct GuClo0 { - GuFn fn; -}; - -typedef struct GuClo1 GuClo1; - -struct GuClo1 { - GuFn fn; - void *env1; -}; - -typedef struct GuClo2 GuClo2; -struct GuClo2 { - GuFn fn; - void *env1; - void *env2; -}; - -typedef struct GuClo3 GuClo3; -struct GuClo3 { - GuFn fn; - void *env1; - void *env2; - void *env3; -}; - -typedef const struct GuEquality GuEquality; - -struct GuEquality { - bool (*is_equal)(GuEquality* self, const void* a, const void* b); -}; - -typedef const struct GuOrder GuOrder; - -struct GuOrder { - int (*compare)(GuOrder* self, const void* a, const void* b); -}; - -#endif // GU_FUN_H_ diff --git a/src/runtime/c/gu/hash.c b/src/runtime/c/gu/hash.c deleted file mode 100644 index 9813471d7..000000000 --- a/src/runtime/c/gu/hash.c +++ /dev/null @@ -1,77 +0,0 @@ -#include - -GU_API GuHash -gu_hash_bytes(GuHash h, const uint8_t* buf, size_t len) -{ - for (size_t n = 0; n < len; n++) { - h = gu_hash_byte(h, buf[n]); - } - return h; -} - -static bool -gu_int_eq_fn(GuEquality* self, const void* p1, const void* p2) -{ - (void) self; - const int* ip1 = p1; - const int* ip2 = p2; - return *ip1 == *ip2; -} - -static GuHash -gu_int_hash_fn(GuHasher* self, const void* p) -{ - (void) self; - return (GuHash) *(const int*) p; -} - -GU_API GuHasher gu_int_hasher[1] = { - { - { gu_int_eq_fn }, - gu_int_hash_fn - } -}; - -static bool -gu_addr_eq_fn(GuEquality* self, const void* p1, const void* p2) -{ - (void) self; - return (p1 == p2); -} - -static GuHash -gu_addr_hash_fn(GuHasher* self, const void* p) -{ - (void) self; - return (GuHash) (uintptr_t) p; -} - -GU_API GuHasher gu_addr_hasher[1] = { - { - { gu_addr_eq_fn }, - gu_addr_hash_fn - } -}; - -static bool -gu_word_eq_fn(GuEquality* self, const void* p1, const void* p2) -{ - (void) self; - const GuWord* wp1 = p1; - const GuWord* wp2 = p2; - return (*wp1 == *wp2); -} - -static GuHash -gu_word_hash_fn(GuHasher* self, const void* p) -{ - (void) self; - return (GuHash) (uintptr_t) p; -} - -GU_API GuHasher gu_word_hasher[1] = { - { - { gu_word_eq_fn }, - gu_word_hash_fn - } -}; diff --git a/src/runtime/c/gu/hash.h b/src/runtime/c/gu/hash.h deleted file mode 100644 index 7c8b298cf..000000000 --- a/src/runtime/c/gu/hash.h +++ /dev/null @@ -1,40 +0,0 @@ -#ifndef GU_HASH_H_ -#define GU_HASH_H_ - -#include - -typedef GuWord GuHash; - -static inline GuHash -gu_hash_ptr(void* ptr) -{ - return (GuHash) ptr; -} - - -static inline GuHash -gu_hash_byte(GuHash h, uint8_t u) -{ - // Paul Larson's simple byte hash - return h * 101 + u; -} - - -GU_API_DECL GuHash -gu_hash_bytes(GuHash h, const uint8_t* buf, size_t len); - -typedef const struct GuHasher GuHasher; - -struct GuHasher { - GuEquality eq; - GuHash (*hash)(GuHasher* self, const void* p); -}; - - -GU_API_DECL extern GuHasher gu_int_hasher[1]; - -GU_API_DECL extern GuHasher gu_addr_hasher[1]; - -GU_API_DECL extern GuHasher gu_word_hasher[1]; - -#endif // GU_HASH_H_ diff --git a/src/runtime/c/gu/in.c b/src/runtime/c/gu/in.c deleted file mode 100644 index c241d3086..000000000 --- a/src/runtime/c/gu/in.c +++ /dev/null @@ -1,378 +0,0 @@ -#include -#include -#include - - -static bool -gu_in_is_buffering(GuIn* in) -{ - return (in->buf_end != NULL); -} - -static void -gu_in_end_buffering(GuIn* in, GuExn* err) -{ - if (!gu_in_is_buffering(in)) { - return; - } - if (in->stream->end_buffer) { - size_t len = ((ptrdiff_t) in->buf_size) + in->buf_curr; - in->stream->end_buffer(in->stream, len, err); - } - in->buf_curr = 0; - in->buf_size = 0; - in->buf_end = NULL; -} - -static bool -gu_in_begin_buffering(GuIn* in, GuExn* err) -{ - if (gu_in_is_buffering(in)) { - if (in->buf_curr < 0) { - return true; - } else { - gu_in_end_buffering(in, err); - if (!gu_ok(err)) return false; - } - } - if (!in->stream->begin_buffer) { - return false; - } - size_t sz = 0; - const uint8_t* new_buf = - in->stream->begin_buffer(in->stream, &sz, err); - if (new_buf) { - in->buf_end = &new_buf[sz]; - in->buf_curr = -(ptrdiff_t) sz; - in->buf_size = sz; - return true; - } - return false; -} - -static size_t -gu_in_input(GuIn* in, uint8_t* dst, size_t sz, GuExn* err) -{ - if (sz == 0) { - return 0; - } - gu_in_end_buffering(in, err); - if (!gu_ok(err)) { - return 0; - } - GuInStream* stream = in->stream; - if (stream->input) { - return stream->input(stream, dst, sz, err); - } - gu_raise(err, GuEOF); - return 0; -} - -GU_API size_t -gu_in_some(GuIn* in, uint8_t* dst, size_t sz, GuExn* err) -{ - gu_require(sz <= PTRDIFF_MAX); - if (!gu_in_begin_buffering(in, err)) { - if (!gu_ok(err)) return 0; - return gu_in_input(in, dst, sz, err); - } - size_t real_sz = GU_MIN(sz, (size_t)(-in->buf_curr)); - memcpy(dst, &in->buf_end[in->buf_curr], real_sz); - in->buf_curr += real_sz; - return real_sz; -} - -GU_API void -gu_in_bytes_(GuIn* in, uint8_t* dst, size_t sz, GuExn* err) -{ - for (;;) { - size_t avail_sz = GU_MIN(sz, (size_t)(-in->buf_curr)); - memcpy(dst, &in->buf_end[in->buf_curr], avail_sz); - in->buf_curr += avail_sz; - dst += avail_sz; - sz -= avail_sz; - - if (sz == 0) - break; - - if (!gu_in_begin_buffering(in, err)) { - gu_in_input(in, dst, sz, err); - return; - } - } -} - -GU_API const uint8_t* -gu_in_begin_span(GuIn* in, size_t *sz_out, GuExn* err) -{ - if (!gu_in_begin_buffering(in, err)) { - return NULL; - } - *sz_out = (size_t) -in->buf_curr; - return &in->buf_end[in->buf_curr]; -} - -GU_API void -gu_in_end_span(GuIn* in, size_t consumed) -{ - gu_require(consumed <= (size_t) -in->buf_curr); - in->buf_curr += (ptrdiff_t) consumed; -} - -GU_API uint8_t -gu_in_u8_(GuIn* in, GuExn* err) -{ - if (gu_in_begin_buffering(in, err) && in->buf_curr < 0) { - return in->buf_end[in->buf_curr++]; - } - uint8_t u = 0; - size_t r = gu_in_input(in, &u, 1, err); - if (r < 1) { - gu_raise(err, GuEOF); - return 0; - } - return u; -} - -static uint64_t -gu_in_be(GuIn* in, GuExn* err, int n) -{ - uint8_t buf[8]; - gu_in_bytes(in, buf, n, err); - uint64_t u = 0; - for (int i = 0; i < n; i++) { - u = u << 8 | buf[i]; - } - return u; -} - -static uint64_t -gu_in_le(GuIn* in, GuExn* err, int n) -{ - uint8_t buf[8]; - gu_in_bytes(in, buf, n, err); - uint64_t u = 0; - for (int i = n-1; i >= 0; i--) { - u = u << 8 | buf[i]; - } - return u; -} - -GU_API int8_t -gu_in_s8(GuIn* in, GuExn* err) -{ - return gu_decode_2c8(gu_in_u8(in, err), err); -} - - -GU_API uint16_t -gu_in_u16le(GuIn* in, GuExn* err) -{ - return gu_in_le(in, err, 2); -} - -GU_API int16_t -gu_in_s16le(GuIn* in, GuExn* err) -{ - return gu_decode_2c16(gu_in_u16le(in, err), err); -} - -GU_API uint16_t -gu_in_u16be(GuIn* in, GuExn* err) -{ - return gu_in_be(in, err, 2); -} - -GU_API int16_t -gu_in_s16be(GuIn* in, GuExn* err) -{ - return gu_decode_2c16(gu_in_u16be(in, err), err); -} - -GU_API uint32_t -gu_in_u32le(GuIn* in, GuExn* err) -{ - return gu_in_le(in, err, 4); -} - -GU_API int32_t -gu_in_s32le(GuIn* in, GuExn* err) -{ - return gu_decode_2c32(gu_in_u32le(in, err), err); -} - -GU_API uint32_t -gu_in_u32be(GuIn* in, GuExn* err) -{ - return gu_in_be(in, err, 4); -} - -GU_API int32_t -gu_in_s32be(GuIn* in, GuExn* err) -{ - return gu_decode_2c32(gu_in_u32be(in, err), err); -} - -GU_API uint64_t -gu_in_u64le(GuIn* in, GuExn* err) -{ - return gu_in_le(in, err, 8); -} - -GU_API int64_t -gu_in_s64le(GuIn* in, GuExn* err) -{ - return gu_decode_2c64(gu_in_u64le(in, err), err); -} - -GU_API uint64_t -gu_in_u64be(GuIn* in, GuExn* err) -{ - return gu_in_be(in, err, 8); -} - -GU_API int64_t -gu_in_s64be(GuIn* in, GuExn* err) -{ - return gu_decode_2c64(gu_in_u64be(in, err), err); -} - -GU_API double -gu_in_f64le(GuIn* in, GuExn* err) -{ - return gu_decode_double(gu_in_u64le(in, err)); -} - -GU_API double -gu_in_f64be(GuIn* in, GuExn* err) -{ - return gu_decode_double(gu_in_u64be(in, err)); -} - -static void -gu_in_fini(GuFinalizer* fin) -{ - GuIn* in = gu_container(fin, GuIn, fini); - GuPool* pool = gu_local_pool(); - GuExn* err = gu_exn(pool); - gu_in_end_buffering(in, err); - gu_pool_free(pool); -} - -GU_API GuIn* -gu_new_in(GuInStream* stream, GuPool* pool) -{ - gu_require(stream != NULL); - - GuIn* in = gu_new(GuIn, pool); - in->buf_end = NULL; - in->buf_curr = 0; - in->buf_size = 0; - in->stream = stream; - in->fini.fn = gu_in_fini; - return in; -} - -typedef struct GuBufferedInStream GuBufferedInStream; - -struct GuBufferedInStream { - GuInStream stream; - size_t alloc; - size_t have; - size_t curr; - GuIn* in; - uint8_t buf[]; -}; - -static const uint8_t* -gu_buffered_in_begin_buffer(GuInStream* self, size_t* sz_out, GuExn* err) -{ - GuBufferedInStream* bis = - gu_container(self, GuBufferedInStream, stream); - if (bis->curr == bis->have) { - bis->curr = 0; - bis->have = gu_in_some(bis->in, bis->buf, bis->alloc, err); - if (!gu_ok(err)) return NULL; - } - *sz_out = bis->have - bis->curr; - return &bis->buf[bis->curr]; -} - -static void -gu_buffered_in_end_buffer(GuInStream* self, size_t consumed, GuExn* err) -{ - GuBufferedInStream* bis = - gu_container(self, GuBufferedInStream, stream); - gu_require(consumed < bis->have - bis->curr); - bis->curr += consumed; -} - -static size_t -gu_buffered_in_input(GuInStream* self, uint8_t* dst, size_t sz, GuExn* err) -{ - GuBufferedInStream* bis = - gu_container(self, GuBufferedInStream, stream); - return gu_in_some(bis->in, dst, sz, err); -} - -GU_API GuIn* -gu_buffered_in(GuIn* in, size_t buf_sz, GuPool* pool) -{ - GuBufferedInStream* bis = gu_new_flex(pool, GuBufferedInStream, - buf, buf_sz); - bis->stream = (GuInStream) { - .begin_buffer = gu_buffered_in_begin_buffer, - .end_buffer = gu_buffered_in_end_buffer, - .input = gu_buffered_in_input - }; - bis->alloc = buf_sz; - bis->have = bis->curr = 0; - bis->in = in; - return gu_new_in(&bis->stream, pool); -} - -typedef struct GuDataIn GuDataIn; - -struct GuDataIn { - GuInStream stream; - const uint8_t* data; - size_t sz; -}; - -static const uint8_t* -gu_data_in_begin_buffer(GuInStream* self, size_t* sz_out, GuExn* err) -{ - (void) err; - GuDataIn* di = gu_container(self, GuDataIn, stream); - const uint8_t* buf = di->data; - if (buf) { - *sz_out = di->sz; - di->data = NULL; - di->sz = 0; - } - return buf; -} - -GU_API GuIn* -gu_data_in(const uint8_t* data, size_t sz, GuPool* pool) -{ - GuDataIn* di = gu_new(GuDataIn, pool); - di->stream.begin_buffer = gu_data_in_begin_buffer; - di->stream.end_buffer = NULL; - di->stream.input = NULL; - di->data = data; - di->sz = sz; - return gu_new_in(&di->stream, pool); -} - -extern inline uint8_t -gu_in_u8(GuIn* restrict in, GuExn* err); - -extern inline void -gu_in_bytes(GuIn* in, uint8_t* buf, size_t sz, GuExn* err); - -extern inline int -gu_in_peek_u8(GuIn* restrict in); - -extern inline void -gu_in_consume(GuIn* restrict in, size_t sz); diff --git a/src/runtime/c/gu/in.h b/src/runtime/c/gu/in.h deleted file mode 100644 index 712073465..000000000 --- a/src/runtime/c/gu/in.h +++ /dev/null @@ -1,134 +0,0 @@ -#ifndef GU_IN_H_ -#define GU_IN_H_ - -#include -#include -#include - -typedef struct GuInStream GuInStream; - -struct GuInStream { - const uint8_t* (*begin_buffer)(GuInStream* self, size_t* sz_out, - GuExn* err); - void (*end_buffer)(GuInStream* self, size_t consumed, GuExn* err); - size_t (*input)(GuInStream* self, uint8_t* buf, size_t max_sz, - GuExn* err); -}; - -typedef struct GuIn GuIn; - -struct GuIn { - const uint8_t* restrict buf_end; - ptrdiff_t buf_curr; - size_t buf_size; - GuInStream* stream; - GuFinalizer fini; -}; - -GU_API_DECL GuIn* -gu_new_in(GuInStream* stream, GuPool* pool); - -GU_API_DECL const uint8_t* -gu_in_begin_span(GuIn* in, size_t *sz_out, GuExn* err); - -GU_API_DECL void -gu_in_end_span(GuIn* in, size_t consumed); - -GU_API_DECL size_t -gu_in_some(GuIn* in, uint8_t* buf, size_t max_len, GuExn* err); - -inline void -gu_in_bytes(GuIn* in, uint8_t* buf, size_t sz, GuExn* err) -{ - gu_require(sz < PTRDIFF_MAX); - ptrdiff_t curr = in->buf_curr; - ptrdiff_t new_curr = curr + (ptrdiff_t) sz; - if (GU_UNLIKELY(new_curr > 0)) { - GU_API_DECL void gu_in_bytes_(GuIn* in, uint8_t* buf, size_t sz, - GuExn* err); - gu_in_bytes_(in, buf, sz, err); - return; - } - memcpy(buf, &in->buf_end[curr], sz); - in->buf_curr = new_curr; -} - -inline int -gu_in_peek_u8(GuIn* restrict in) -{ - if (GU_UNLIKELY(in->buf_curr == 0)) { - return -1; - } - return in->buf_end[in->buf_curr]; -} - -inline void -gu_in_consume(GuIn* restrict in, size_t sz) -{ - gu_require((ptrdiff_t) sz + in->buf_curr <= 0); - in->buf_curr += sz; -} - -inline uint8_t -gu_in_u8(GuIn* restrict in, GuExn* err) -{ - if (GU_UNLIKELY(in->buf_curr == 0)) { - GU_API_DECL uint8_t gu_in_u8_(GuIn* restrict in, GuExn* err); - return gu_in_u8_(in, err); - } - return in->buf_end[in->buf_curr++]; -} - -GU_API_DECL int8_t -gu_in_s8(GuIn* in, GuExn* err); - -GU_API_DECL uint16_t -gu_in_u16le(GuIn* in, GuExn* err); - -GU_API_DECL uint16_t -gu_in_u16be(GuIn* in, GuExn* err); - -GU_API_DECL int16_t -gu_in_s16le(GuIn* in, GuExn* err); - -GU_API_DECL int16_t -gu_in_s16be(GuIn* in, GuExn* err); - -GU_API_DECL uint32_t -gu_in_u32le(GuIn* in, GuExn* err); - -GU_API_DECL uint32_t -gu_in_u32be(GuIn* in, GuExn* err); - -GU_API_DECL int32_t -gu_in_s32le(GuIn* in, GuExn* err); - -GU_API_DECL int32_t -gu_in_s32be(GuIn* in, GuExn* err); - -GU_API_DECL uint64_t -gu_in_u64le(GuIn* in, GuExn* err); - -GU_API_DECL uint64_t -gu_in_u64be(GuIn* in, GuExn* err); - -GU_API_DECL int64_t -gu_in_s64le(GuIn* in, GuExn* err); - -GU_API_DECL int64_t -gu_in_s64be(GuIn* in, GuExn* err); - -GU_API_DECL double -gu_in_f64le(GuIn* in, GuExn* err); - -GU_API_DECL double -gu_in_f64be(GuIn* in, GuExn* err); - -GU_API_DECL GuIn* -gu_buffered_in(GuIn* in, size_t sz, GuPool* pool); - -GU_API_DECL GuIn* -gu_data_in(const uint8_t* buf, size_t size, GuPool* pool); - - -#endif // GU_IN_H_ diff --git a/src/runtime/c/gu/map.c b/src/runtime/c/gu/map.c deleted file mode 100644 index ebd917b3e..000000000 --- a/src/runtime/c/gu/map.c +++ /dev/null @@ -1,392 +0,0 @@ -#include -#include -#include -#include -#include -#include - -typedef struct GuMapData GuMapData; - -#define SKIP_DELETED 1 -#define SKIP_NONE 2 - -struct GuMapData { - uint8_t* keys; - uint8_t* values; - size_t n_occupied; - size_t n_entries; - size_t zero_idx; -}; - -struct GuMap { - GuHasher* hasher; - size_t key_size; - size_t value_size; - size_t cell_size; // cell_size = GU_MAX(value_size,sizeof(uint8_t)) - const void* default_value; - GuMapData data; - - GuFinalizer fin; -}; - -static void -gu_map_finalize(GuFinalizer* fin) -{ - GuMap* map = gu_container(fin, GuMap, fin); - gu_mem_buf_free(map->data.keys); - gu_mem_buf_free(map->data.values); -} - -static const GuWord gu_map_empty_key = 0; - -static bool -gu_map_buf_is_zero(const uint8_t* p, size_t sz) { - while (sz >= sizeof(GuWord)) { - sz -= sizeof(GuWord); - if (memcmp(&p[sz], &gu_map_empty_key, sizeof(GuWord)) != 0) { - return false; - } - } - return (memcmp(p, &gu_map_empty_key, sz) == 0); -} - -static bool -gu_map_entry_is_free(GuMap* map, GuMapData* data, size_t idx) -{ - if (idx == data->zero_idx) { - return false; - } else if (map->hasher == gu_addr_hasher) { - const void* key = ((const void**)data->keys)[idx]; - return key == NULL; - } else if (map->hasher == gu_word_hasher) { - GuWord key = ((GuWord*)data->keys)[idx]; - return key == 0; - } else if (map->hasher == gu_string_hasher) { - GuString key = ((GuString*)data->keys)[idx]; - return key == NULL; - } - const void* key = &data->keys[idx * map->key_size]; - return gu_map_buf_is_zero(key, map->key_size); -} - -static bool -gu_map_lookup(GuMap* map, const void* key, uint8_t del, size_t* idx_out) -{ - size_t n = map->data.n_entries; - if (map->hasher == gu_addr_hasher) { - GuHash hash = (GuHash) key; - size_t idx = hash % n; - size_t offset = (hash % (n - 2)) + 1; - while (true) { - const void* entry_key = - ((const void**)map->data.keys)[idx]; - - if (entry_key == NULL && map->data.zero_idx != idx) { - if (map->data.values[idx * map->cell_size] != del) { //skip deleted - *idx_out = idx; - return false; - } - } else if (entry_key == key) { - *idx_out = idx; - return true; - } - - idx = (idx + offset) % n; - } - } else if (map->hasher == gu_word_hasher) { - GuWord w = *(const GuWord*)key; - GuHash hash = (GuHash) w; - size_t idx = hash % n; - size_t offset = (hash % (n - 2)) + 1; - while (true) { - GuWord entry_key = ((GuWord*)map->data.keys)[idx]; - if (entry_key == 0 && map->data.zero_idx != idx) { - *idx_out = idx; - return false; - } else if (entry_key == w) { - *idx_out = idx; - return true; - } - idx = (idx + offset) % n; - } - } else if (map->hasher == gu_string_hasher) { - GuHasher* hasher = map->hasher; - GuEquality* eq = (GuEquality*) hasher; - GuHash hash = hasher->hash(hasher, key); - size_t idx = hash % n; - size_t offset = (hash % (n - 2)) + 1; - while (true) { - GuString entry_key = - ((GuString*)map->data.keys)[idx]; - if (entry_key == NULL && map->data.zero_idx != idx) { - *idx_out = idx; - return false; - } else if (eq->is_equal(eq, key, entry_key)) { - *idx_out = idx; - return true; - } - idx = (idx + offset) % n; - } - } else { - GuHasher* hasher = map->hasher; - GuEquality* eq = (GuEquality*) hasher; - GuHash hash = hasher->hash(hasher, key); - size_t idx = hash % n; - size_t offset = (hash % (n - 2)) + 1; - size_t key_size = map->key_size; - while (true) { - void* entry_key = &map->data.keys[idx * key_size]; - if (gu_map_buf_is_zero(entry_key, key_size) && - map->data.zero_idx != idx) { - *idx_out = idx; - return false; - } else if (eq->is_equal(eq, key, entry_key)) { - *idx_out = idx; - return true; - } - idx = (idx + offset) % n; - } - } - - gu_impossible(); - return false; -} - - -static void -gu_map_resize(GuMap* map, size_t req_entries) -{ - GuMapData* data = &map->data; - GuMapData old_data = *data; - - size_t key_size = map->key_size; - size_t key_alloc = 0; - data->keys = gu_mem_buf_alloc(req_entries * key_size, &key_alloc); - memset(data->keys, 0, key_alloc); - - size_t value_alloc = 0; - size_t cell_size = map->cell_size; - data->values = gu_mem_buf_alloc(req_entries * cell_size, &value_alloc); - memset(data->values, 0, value_alloc); - - data->n_entries = gu_twin_prime_inf( - GU_MIN(key_alloc / key_size, - value_alloc / cell_size)); - gu_assert(data->n_entries > data->n_occupied); - - data->n_occupied = 0; - data->zero_idx = SIZE_MAX; - - for (size_t i = 0; i < old_data.n_entries; i++) { - if (gu_map_entry_is_free(map, &old_data, i)) { - continue; - } - void* old_key = &old_data.keys[i * key_size]; - if (map->hasher == gu_addr_hasher) { - old_key = *(void**)old_key; - } else if (map->hasher == gu_string_hasher) { - old_key = (void*) *(GuString*)old_key; - } - void* old_value = &old_data.values[i * cell_size]; - - memcpy(gu_map_insert(map, old_key), - old_value, map->value_size); - } - - gu_mem_buf_free(old_data.keys); - gu_mem_buf_free(old_data.values); -} - - -static bool -gu_map_maybe_resize(GuMap* map) -{ - if (map->data.n_entries <= - map->data.n_occupied + (map->data.n_occupied / 4)) { - size_t req_entries = - gu_twin_prime_sup(GU_MAX(11, map->data.n_occupied * 4 / 3 + 1)); - gu_map_resize(map, req_entries); - return true; - } - return false; -} - -GU_API void* -gu_map_find(GuMap* map, const void* key) -{ - size_t idx; - bool found = gu_map_lookup(map, key, SKIP_DELETED, &idx); - if (found) { - return &map->data.values[idx * map->cell_size]; - } - return NULL; -} - -GU_API const void* -gu_map_find_default(GuMap* map, const void* key) -{ - void* p = gu_map_find(map, key); - return p ? p : map->default_value; -} - -GU_API const void* -gu_map_find_key(GuMap* map, const void* key) -{ - size_t idx; - bool found = gu_map_lookup(map, key, SKIP_DELETED, &idx); - if (found) { - return &map->data.keys[idx * map->key_size]; - } - return NULL; -} - -GU_API bool -gu_map_has(GuMap* ht, const void* key) -{ - size_t idx; - return gu_map_lookup(ht, key, SKIP_DELETED, &idx); -} - -GU_API void* -gu_map_insert(GuMap* map, const void* key) -{ - size_t idx; - bool found = gu_map_lookup(map, key, SKIP_NONE, &idx); - if (!found) { - if (gu_map_maybe_resize(map)) { - found = gu_map_lookup(map, key, SKIP_NONE, &idx); - gu_assert(!found); - } - if (map->hasher == gu_addr_hasher) { - ((const void**)map->data.keys)[idx] = key; - } else if (map->hasher == gu_string_hasher) { - ((GuString*)map->data.keys)[idx] = key; - } else { - memcpy(&map->data.keys[idx * map->key_size], - key, map->key_size); - } - if (map->default_value) { - memcpy(&map->data.values[idx * map->cell_size], - map->default_value, map->value_size); - } - if (gu_map_entry_is_free(map, &map->data, idx)) { - gu_assert(map->data.zero_idx == SIZE_MAX); - map->data.zero_idx = idx; - } - map->data.n_occupied++; - } - return &map->data.values[idx * map->cell_size]; -} - -GU_API void -gu_map_delete(GuMap* map, const void* key) -{ - size_t idx; - bool found = gu_map_lookup(map, key, SKIP_NONE, &idx); - if (found) { - if (map->hasher == gu_addr_hasher) { - ((const void**)map->data.keys)[idx] = NULL; - } else if (map->hasher == gu_string_hasher) { - ((GuString*)map->data.keys)[idx] = NULL; - } else { - memset(&map->data.keys[idx * map->key_size], - 0, map->key_size); - } - map->data.values[idx * map->cell_size] = SKIP_DELETED; - - if (gu_map_buf_is_zero(&map->data.keys[idx * map->key_size], - map->key_size)) { - map->data.zero_idx = SIZE_MAX; - } - - map->data.n_occupied--; - } -} - -GU_API void -gu_map_iter(GuMap* map, GuMapItor* itor, GuExn* err) -{ - for (size_t i = 0; i < map->data.n_entries && gu_ok(err); i++) { - if (gu_map_entry_is_free(map, &map->data, i)) { - continue; - } - const void* key = &map->data.keys[i * map->key_size]; - void* value = &map->data.values[i * map->cell_size]; - if (map->hasher == gu_addr_hasher) { - key = *(const void* const*) key; - } else if (map->hasher == gu_string_hasher) { - key = *(GuString*) key; - } - itor->fn(itor, key, value, err); - } -} - -GU_API bool -gu_map_next(GuMap* map, size_t* pi, void* pkey, void* pvalue) -{ - while (*pi < map->data.n_entries) { - if (gu_map_entry_is_free(map, &map->data, *pi)) { - (*pi)++; - continue; - } - - if (map->hasher == gu_addr_hasher) { - *((void**) pkey) = *((void**) &map->data.keys[*pi * sizeof(void*)]); - } else if (map->hasher == gu_word_hasher) { - *((GuWord*) pkey) = *((GuWord*) &map->data.keys[*pi * sizeof(GuWord)]); - } else if (map->hasher == gu_string_hasher) { - *((GuString*) pkey) = *((GuString*) &map->data.keys[*pi * sizeof(GuString)]); - } else { - memcpy(pkey, &map->data.keys[*pi * map->key_size], map->key_size); - } - - memcpy(pvalue, &map->data.values[*pi * map->cell_size], - map->value_size); - - (*pi)++; - return true; - } - - return false; -} - -GU_API size_t -gu_map_count(GuMap* map) -{ - size_t count = 0; - for (size_t i = 0; i < map->data.n_entries; i++) { - if (gu_map_entry_is_free(map, &map->data, i)) { - continue; - } - count++; - } - return count; -} - -GU_API GuMap* -gu_make_map(size_t key_size, GuHasher* hasher, - size_t value_size, const void* default_value, - size_t init_size, - GuPool* pool) -{ - GuMapData data = { - .n_occupied = 0, - .n_entries = 0, - .keys = NULL, - .values = NULL, - .zero_idx = SIZE_MAX - }; - GuMap* map = gu_new(GuMap, pool); - map->default_value = default_value; - map->hasher = hasher; - map->data = data; - map->key_size = key_size; - map->value_size = value_size; - map->cell_size = GU_MAX(value_size,sizeof(uint8_t)); - map->fin.fn = gu_map_finalize; - gu_pool_finally(pool, &map->fin); - - init_size = gu_twin_prime_sup(init_size); - gu_map_resize(map, init_size); - return map; -} diff --git a/src/runtime/c/gu/map.h b/src/runtime/c/gu/map.h deleted file mode 100644 index 7ac33dc3b..000000000 --- a/src/runtime/c/gu/map.h +++ /dev/null @@ -1,85 +0,0 @@ -#ifndef GU_MAP_H_ -#define GU_MAP_H_ - -#include -#include -#include -#include - -typedef struct GuMapItor GuMapItor; - -struct GuMapItor { - void (*fn)(GuMapItor* self, const void* key, void* value, - GuExn *err); -}; - -typedef struct GuMap GuMap; - -GU_API_DECL GuMap* -gu_make_map(size_t key_size, GuHasher* hasher, - size_t value_size, const void* default_value, - size_t init_size, - GuPool* pool); - -#define GU_MAP_DEFAULT_INIT_SIZE 11 - -#define gu_new_map(K, HASHER, V, DV, POOL) \ - (gu_make_map(sizeof(K), (HASHER), sizeof(V), (DV), GU_MAP_DEFAULT_INIT_SIZE, (POOL))) - -#define gu_new_set(K, HASHER, POOL) \ - (gu_make_map(sizeof(K), (HASHER), 0, NULL, GU_MAP_DEFAULT_INIT_SIZE, (POOL))) - -#define gu_new_addr_map(K, V, DV, POOL) \ - (gu_make_map(sizeof(K), gu_addr_hasher, sizeof(V), (DV), GU_MAP_DEFAULT_INIT_SIZE, (POOL))) - -GU_API_DECL size_t -gu_map_count(GuMap* map); - -GU_API_DECL void* -gu_map_find_full(GuMap* ht, void* key_inout); - -GU_API_DECL const void* -gu_map_find_default(GuMap* ht, const void* key); - -#define gu_map_get(MAP, KEYP, V) \ - (*(V*)gu_map_find_default((MAP), (KEYP))) - -GU_API_DECL void* -gu_map_find(GuMap* ht, const void* key); - -#define gu_map_set(MAP, KEYP, V, VAL) \ - GU_BEGIN \ - V* gu_map_set_p_ = gu_map_find((MAP), (KEYP)); \ - *gu_map_set_p_ = (VAL); \ - GU_END - -GU_API_DECL const void* -gu_map_find_key(GuMap* ht, const void* key); - -GU_API_DECL bool -gu_map_has(GuMap* ht, const void* key); - -GU_API_DECL void* -gu_map_insert(GuMap* ht, const void* key); - -GU_API_DECL void -gu_map_delete(GuMap* ht, const void* key); - -#define gu_map_put(MAP, KEYP, V, VAL) \ - GU_BEGIN \ - V* gu_map_put_p_ = gu_map_insert((MAP), (KEYP)); \ - *gu_map_put_p_ = (VAL); \ - GU_END - -GU_API_DECL void -gu_map_iter(GuMap* ht, GuMapItor* itor, GuExn* err); - -GU_API bool -gu_map_next(GuMap* map, size_t* pi, void* pkey, void* pvalue); - -typedef GuMap GuIntMap; - -#define gu_new_int_map(VAL_T, DEFAULT, POOL) \ - gu_new_map(int, gu_int_hasher, VAL_T, DEFAULT, POOL) - -#endif // GU_MAP_H_ diff --git a/src/runtime/c/gu/mem.c b/src/runtime/c/gu/mem.c deleted file mode 100644 index 80e99242e..000000000 --- a/src/runtime/c/gu/mem.c +++ /dev/null @@ -1,428 +0,0 @@ -#include -#include -#include -#include -#include -#include -#if !defined(_WIN32) && !defined(_WIN64) -#include -#include -#endif -#if defined(__MINGW32__) || defined(_MSC_VER) -#include -#endif - -#if !defined(_MSC_VER) -#include -#endif -#include - -#ifdef USE_VALGRIND -#include -#define VG(X) X -#else -#define VG(X) GU_NOP -#endif - -static const size_t -// Maximum request size for a chunk. The actual maximum chunk size -// may be somewhat larger. - gu_mem_chunk_max_size = 1024 * sizeof(void*), - -// number of bytes to allocate in the pool when it is created - gu_mem_pool_initial_size = 24 * sizeof(void*), - -// Pool allocations larger than this will get their own chunk if -// there's no room in the current one. Allocations smaller than this may trigger -// the creation of a new chunk, in which case the remaining space in -// the current chunk is left unused (internal fragmentation). - gu_mem_max_shared_alloc = 64 * sizeof(void*), - -// Should not be smaller than the granularity for malloc - gu_mem_unit_size = 2 * sizeof(void*), - -/* Malloc tuning: the additional memory used by malloc next to the - allocated object */ - gu_malloc_overhead = sizeof(size_t); - -static void* -gu_mem_realloc(void* p, size_t size) -{ - void* buf = realloc(p, size); - if (size != 0 && buf == NULL) { - gu_fatal("Memory allocation failed"); - } - return buf; -} - -static void* -gu_mem_alloc(size_t size) -{ - void* buf = malloc(size); - if (buf == NULL) { - gu_fatal("Memory allocation failed"); - } - return buf; -} - -static void -gu_mem_free(void* p) -{ - free(p); -} - -static size_t -gu_mem_padovan(size_t min) -{ - // This could in principle be done faster with Q-matrices for - // Padovan numbers, but not really worth it for our commonly - // small numbers. - if (min <= 5) { - return min; - } - size_t a = 7, b = 9, c = 12; - while (min > a) { - if (b < a) { - // overflow - return SIZE_MAX; - } - size_t tmp = a + b; - a = b; - b = c; - c = tmp; - } - return a; -} - -GU_API void* -gu_mem_buf_realloc(void* old_buf, size_t min_size, size_t* real_size_out) -{ - size_t min_blocks = ((min_size + gu_malloc_overhead - 1) / - gu_mem_unit_size) + 1; - size_t blocks = gu_mem_padovan(min_blocks); - size_t size = blocks * gu_mem_unit_size - gu_malloc_overhead; - void* buf = gu_mem_realloc(old_buf, size); - *real_size_out = buf ? size : 0; - return buf; -} - -GU_API void* -gu_mem_buf_alloc(size_t min_size, size_t* real_size_out) -{ - return gu_mem_buf_realloc(NULL, min_size, real_size_out); -} - -#if defined(__MINGW32__) || defined(_MSC_VER) -#include - -static int -getpagesize() -{ - SYSTEM_INFO system_info; - GetSystemInfo(&system_info); - return system_info.dwPageSize; -} -#endif - -GU_API void* -gu_mem_page_alloc(size_t min_size, size_t* real_size_out) -{ - size_t page_size = getpagesize(); - size_t size = ((min_size + page_size - 1) / page_size) * page_size; - void *page = NULL; - -#if defined(ANDROID) - if ((page = memalign(page_size, size)) == NULL) { -#elif defined(__MINGW32__) || defined(_MSC_VER) - if ((page = malloc(size)) == NULL) { -#else - if (posix_memalign(&page, page_size, size) != 0) { -#endif - gu_fatal("Memory allocation failed"); - } - - *real_size_out = size; - return page; -} - -GU_API void -gu_mem_buf_free(void* buf) -{ - gu_mem_free(buf); -} - - -typedef struct GuMemChunk GuMemChunk; - -struct GuMemChunk { - GuMemChunk* next; - uint8_t data[]; -}; - -typedef struct GuFinalizerNode GuFinalizerNode; - -struct GuFinalizerNode { - GuFinalizerNode* next; - GuFinalizer* fin; -}; - -enum GuPoolType { - GU_POOL_HEAP, - GU_POOL_LOCAL, - GU_POOL_PAGE, - GU_POOL_MMAP -}; - -struct GuPool { - uint8_t* curr_buf; // actually GuMemChunk* - GuMemChunk* chunks; - GuFinalizerNode* finalizers; - uint16_t type; - size_t left_edge; - size_t right_edge; - size_t curr_size; - uint8_t init_buf[]; -}; - -static GuPool* -gu_init_pool(uint8_t* buf, size_t sz) -{ - gu_require(gu_aligned((uintptr_t) (void*) buf, gu_alignof(GuPool))); - gu_require(sz >= sizeof(GuPool)); - GuPool* pool = (GuPool*) buf; - pool->type = GU_POOL_HEAP; - pool->curr_size = sz; - pool->curr_buf = (uint8_t*) pool; - pool->chunks = NULL; - pool->finalizers = NULL; - pool->left_edge = offsetof(GuPool, init_buf); - pool->right_edge = sz; - VG(VALGRIND_CREATE_MEMPOOL(pool, 0, false)); - return pool; -} - -GU_API GuPool* -gu_local_pool_(uint8_t* buf, size_t sz) -{ - GuPool* pool = gu_init_pool(buf, sz); - pool->type = GU_POOL_LOCAL; - return pool; -} - -GU_API GuPool* -gu_new_pool(void) -{ - size_t sz = GU_FLEX_SIZE(GuPool, init_buf, gu_mem_pool_initial_size); - uint8_t* buf = gu_mem_buf_alloc(sz, &sz); - GuPool* pool = gu_init_pool(buf, sz); - return pool; -} - -GU_API GuPool* -gu_new_page_pool(void) -{ - size_t sz = GU_FLEX_SIZE(GuPool, init_buf, gu_mem_pool_initial_size); - uint8_t* buf = gu_mem_page_alloc(sz, &sz); - GuPool* pool = gu_init_pool(buf, sz); - pool->type = GU_POOL_PAGE; - return pool; -} - -GU_API GuPool* -gu_mmap_pool(char* fpath, void* addr, size_t size, void**pptr) -{ -#if !defined(_WIN32) && !defined(_WIN64) - int prot = PROT_READ; - int fd = open(fpath, O_RDONLY); - if (fd < 0) { - if (errno == ENOENT) { - fd = open(fpath, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); - if (fd < 0) - return NULL; - - if (ftruncate(fd, size) < 0) { - close(fd); - return NULL; - } - - prot |= PROT_WRITE; - } else { - return NULL; - } - } - - void *ptr = mmap(addr, size, prot, MAP_SHARED | MAP_FIXED, fd, 0); - if (ptr == MAP_FAILED) { - close(fd); - return NULL; - } - - gu_require(ptr == addr); - - *pptr = (prot & PROT_WRITE) ? NULL : ptr; - - size_t sz = GU_FLEX_SIZE(GuPool, init_buf, sizeof(int)); - uint8_t* buf = gu_mem_buf_alloc(sz, &sz); - GuPool* pool = gu_init_pool(buf, size); - - uint8_t* pfd = pool->init_buf; - *((int*) pfd) = fd; - - pool->type = GU_POOL_MMAP; - pool->curr_buf = ptr; - pool->left_edge = 0; - - return pool; -#else - return NULL; -#endif -} - -static void -gu_pool_expand(GuPool* pool, size_t req) -{ - gu_require(pool->type != GU_POOL_MMAP); - size_t real_req = GU_MAX(req, GU_MIN(((size_t)pool->curr_size) + 1, - gu_mem_chunk_max_size)); - gu_assert(real_req >= sizeof(GuMemChunk)); - size_t size = 0; - GuMemChunk* chunk = - (pool->type == GU_POOL_PAGE) - ? gu_mem_page_alloc(real_req, &size) - : gu_mem_buf_alloc(real_req, &size); - chunk->next = pool->chunks; - pool->chunks = chunk; - pool->curr_buf = (uint8_t*) chunk; - pool->left_edge = offsetof(GuMemChunk, data); - pool->right_edge = pool->curr_size = size; - gu_assert((size_t) pool->right_edge == size); -} - -static size_t -gu_mem_advance(size_t old_pos, size_t pre_align, size_t pre_size, - size_t align, size_t size) -{ - size_t p = gu_align_forward(old_pos, pre_align); - p += pre_size; - p = gu_align_forward(p, align); - p += size; - return p; -} - -static void* -gu_pool_malloc_aligned(GuPool* pool, size_t pre_align, size_t pre_size, - size_t align, size_t size) -{ - size_t pos = gu_mem_advance(pool->left_edge, pre_align, pre_size, - align, size); - if (pos > (size_t) pool->right_edge) { - pos = gu_mem_advance(offsetof(GuMemChunk, data), - pre_align, pre_size, align, size); - gu_pool_expand(pool, pos); - gu_assert(pos <= pool->right_edge); - } - pool->left_edge = pos; - uint8_t* addr = &pool->curr_buf[pos - size]; - VG(VALGRIND_MEMPOOL_ALLOC(pool, addr - pre_size, size + pre_size )); - return addr; -} - -static size_t -gu_pool_avail(GuPool* pool) -{ - return (size_t) pool->right_edge - (size_t) pool->left_edge; -} - -GU_API void* -gu_pool_malloc_unaligned(GuPool* pool, size_t size) -{ - if (size > gu_pool_avail(pool)) { - gu_pool_expand(pool, offsetof(GuMemChunk, data) + size); - gu_assert(size <= gu_pool_avail(pool)); - } - pool->right_edge -= size; - void* addr = &pool->curr_buf[pool->right_edge]; - VG(VALGRIND_MEMPOOL_ALLOC(pool, addr, size)); - return addr; -} - -GU_API void* -gu_malloc_prefixed(GuPool* pool, size_t pre_align, size_t pre_size, - size_t align, size_t size) -{ - void* ret = NULL; - if (pre_align == 0) { - pre_align = gu_alignof(GuMaxAlign); - } - if (align == 0) { - align = gu_alignof(GuMaxAlign); - } - size_t full_size = gu_mem_advance(offsetof(GuMemChunk, data), - pre_align, pre_size, align, size); - if (full_size > gu_mem_max_shared_alloc && - pool->type != GU_POOL_PAGE && - pool->type != GU_POOL_MMAP) { - GuMemChunk* chunk = gu_mem_alloc(full_size); - chunk->next = pool->chunks; - pool->chunks = chunk; - uint8_t* addr = &chunk->data[full_size - size - - offsetof(GuMemChunk, data)]; - VG(VALGRIND_MEMPOOL_ALLOC(pool, addr - pre_size, - pre_size + size)); - ret = addr; - } else if (pre_align == 1 && align == 1) { - uint8_t* buf = gu_pool_malloc_unaligned(pool, pre_size + size); - ret = &buf[pre_size]; - } else { - ret = gu_pool_malloc_aligned(pool, pre_align, pre_size, - align, size); - } - return ret; -} - -GU_API void* -gu_malloc_aligned(GuPool* pool, size_t size, size_t align) -{ - return gu_malloc_prefixed(pool, 1, 0, align, size); -} - -GU_API void -gu_pool_finally(GuPool* pool, GuFinalizer* finalizer) -{ - gu_require(pool->type != GU_POOL_MMAP); - GuFinalizerNode* node = gu_new(GuFinalizerNode, pool); - node->next = pool->finalizers; - node->fin = finalizer; - pool->finalizers = node; -} - -GU_API void -gu_pool_free(GuPool* pool) -{ - GuFinalizerNode* node = pool->finalizers; - while (node) { - node->fin->fn(node->fin); - node = node->next; - } - GuMemChunk* chunk = pool->chunks; - while (chunk) { - GuMemChunk* next = chunk->next; - gu_mem_buf_free(chunk); - chunk = next; - } - VG(VALGRIND_DESTROY_MEMPOOL(pool)); - if (pool->type == GU_POOL_HEAP) { - gu_mem_buf_free(pool); - } else if (pool->type == GU_POOL_MMAP) { -#if !defined(_WIN32) && !defined(_WIN64) - uint8_t* pfd = pool->init_buf; - int fd = *(pfd); - - munmap(pool->curr_buf, pool->curr_size); - close(fd); -#endif - } -} - - -extern inline void* gu_malloc(GuPool* pool, size_t size); diff --git a/src/runtime/c/gu/mem.h b/src/runtime/c/gu/mem.h deleted file mode 100644 index 1d4a52bf9..000000000 --- a/src/runtime/c/gu/mem.h +++ /dev/null @@ -1,218 +0,0 @@ -/** @file - * - * Memory allocation tools. - */ - -#ifndef GU_MEM_H_ -#define GU_MEM_H_ - -#include -#include - -/** @defgroup GuPool Memory pools */ -//@{ - - -/// A memory pool. -typedef struct GuPool GuPool; - -/// @name Creating a pool -//@{ - - -/// Create a new memory pool. -GU_API_DECL GuPool* -gu_new_pool(void); - -/**< - * @return A new memory pool. - */ - - -//@private -GU_API_DECL GuPool* -gu_local_pool_(uint8_t* init_buf, size_t sz); - -//@private -#define GU_LOCAL_POOL_INIT_SIZE (16 * sizeof(GuWord)) - - -/// Create a stack-allocated memory pool. -#define gu_local_pool() \ - gu_local_pool_(gu_alloca(GU_LOCAL_POOL_INIT_SIZE), \ - GU_LOCAL_POOL_INIT_SIZE) -/**< - * @return A memory pool whose first chunk is allocated directly from - * the stack. This makes its creation faster, and more suitable for - * functions that usually allocate only a little memory from the pool - * until it is freed. - * - * @note The pool created with #gu_local_pool \e must be freed with - * #gu_pool_free before the end of the block where #gu_local_pool was - * called. - * - * @note Because #gu_local_pool uses relatively much stack space, it - * should not be used in the bodies of recursive functions. - */ - -/// Create a pool where each chunk is corresponds to one or -/// more pages. -GU_API_DECL GuPool* -gu_new_page_pool(void); - -/// Create a pool stored in a memory mapped file. -GU_API_DECL GuPool* -gu_mmap_pool(char* fpath, void* addr, size_t size, void**pptr); - -//@} -/// @name Destroying a pool -//@{ - - -/// Free a memory pool and all objects allocated from it. -GU_API_DECL void -gu_pool_free(GU_ONLY GuPool* pool); -/**< - * When the pool is freed, all finalizers registered by - * #gu_pool_finally on \p pool are invoked in reverse order of - * registration. - * - * @note After the pool is freed, all objects allocated from it become - * invalid and may no longer be used. */ - -//@} -/// @name Allocating from a pool -//@{ - - -/// Allocate memory with a specified alignment. -GU_API_DECL void* -gu_malloc_aligned(GuPool* pool, size_t size, size_t alignment); - -GU_API_DECL void* -gu_malloc_prefixed(GuPool* pool, size_t pre_align, size_t pre_size, - size_t align, size_t size); - -/// Allocate memory from a pool. -inline void* -gu_malloc(GuPool* pool, size_t size) { - return gu_malloc_aligned(pool, size, 0); -} - -#include - -/** Allocate memory to store an array of objects of a given type. */ - -#define gu_new_n(type, n, pool) \ - ((type*)gu_malloc_aligned((pool), \ - sizeof(type) * (n), \ - gu_alignof(type))) -/**< - * @param type The C type of the objects to allocate. - * - * @param n The number of objects to allocate. - * - * @param pool The memory pool to allocate from. - * - * @return A pointer to a heap-allocated array of \p n uninitialized - * objects of type \p type. - */ - - -/** Allocate memory to store an object of a given type. */ - -#define gu_new(type, pool) \ - gu_new_n(type, 1, pool) -/**< - * @param type The C type of the object to allocate. - * - * @param pool The memory pool to allocate from. - * - * @return A pointer to a heap-allocated uninitialized object of type - * \p type. - */ - - -#define gu_new_prefixed(pre_type, type, pool) \ - ((type*)(gu_malloc_prefixed((pool), \ - gu_alignof(pre_type), sizeof(pre_type), \ - gu_alignof(type), sizeof(type)))) - -// Alas, there's no portable way to get the alignment of flex structs. -#define gu_new_flex(pool_, type_, flex_member_, n_elems_) \ - ((type_ *)gu_malloc_aligned( \ - (pool_), \ - GU_FLEX_SIZE(type_, flex_member_, n_elems_), \ - gu_flex_alignof(type_))) - - -//@} -/// @name Finalizers -//@{ - - -typedef struct GuFinalizer GuFinalizer; - -struct GuFinalizer { - void (*fn)(GuFinalizer* self); - ///< @param self A pointer to this finalizer. -}; - -/// Register a finalizer. -GU_API_DECL void gu_pool_finally(GuPool* pool, GuFinalizer* fini); - -/**< Register \p fini to be called when \p pool is destroyed. The - * finalizers are called in reverse order of registration. - */ - - -//@} -//@} - -/** @defgroup GuMemBuf Memory buffers - * - * Resizable blocks of heap-allocated memory. These operations differ - * from standard \c malloc, \c realloc and \c free -functions in that - * memory buffers are not allocated by exact size. Instead, a minimum - * size is requested, and the returned buffer may be larger. This - * gives the memory allocator more flexibility when the client code - * can make use of larger buffers than requested. - * */ - -//@{ - - -/// Allocate a new memory buffer. -GU_API_DECL void* -gu_mem_buf_alloc(size_t min_size, size_t* real_size); -/**< - * @param min_size The minimum acceptable size for a returned memory block. - * - * @param[out] real_size The actual size of the returned memory - * block. This is never less than \p min_size. - * - * @return A pointer to the memory buffer. - */ - - -/// Allocate a new memory buffer to replace an old one. -GU_API_DECL void* -gu_mem_buf_realloc( - GU_NULL GU_ONLY GU_RETURNED - void* buf, - size_t min_size, - size_t* real_size_out); - -/// Allocate enough memory pages to contain min_size bytes. -GU_API_DECL void* -gu_mem_page_alloc(size_t min_size, size_t* real_size_out); - -/// Free a memory buffer. -GU_API_DECL void -gu_mem_buf_free(GU_ONLY void* buf); - - -//@} - - -#endif // GU_MEM_H_ diff --git a/src/runtime/c/gu/out.c b/src/runtime/c/gu/out.c deleted file mode 100644 index 164f483d1..000000000 --- a/src/runtime/c/gu/out.c +++ /dev/null @@ -1,303 +0,0 @@ -#include -#include -#include -#include -#include - -static bool -gu_out_is_buffering(GuOut* out) -{ - return !!out->buf_end; -} - - -static void -gu_out_end_buf(GuOut* out, GuExn* err) -{ - if (!gu_out_is_buffering(out)) { - return; - } - GuOutStream* stream = out->stream; - size_t curr_len = ((ptrdiff_t)out->buf_size) + out->buf_curr; - stream->end_buf(stream, curr_len, err); - out->buf_end = NULL; - out->buf_size = out->buf_curr = 0; -} - -static bool -gu_out_begin_buf(GuOut* out, size_t req, GuExn* err) -{ - GuOutStream* stream = out->stream; - if (gu_out_is_buffering(out)) { - if (out->buf_curr < 0) { - return true; - } else { - gu_out_end_buf(out, err); - if (!gu_ok(err)) { - return false; - } - } - } - if (stream->begin_buf) { - size_t sz = 0; - uint8_t* buf = stream->begin_buf(stream, req, &sz, err); - gu_assert(sz <= PTRDIFF_MAX); - if (buf) { - out->buf_end = &buf[sz]; - out->buf_curr = -(ptrdiff_t) sz; - out->buf_size = sz; - return true; - } - } - return false; -} - - - -static void -gu_out_fini(GuFinalizer* self) -{ - GuOut* out = gu_container(self, GuOut, fini); - if (gu_out_is_buffering(out)) { - GuPool* pool = gu_local_pool(); - GuExn* err = gu_new_exn(pool); - gu_out_end_buf(out, err); - gu_pool_free(pool); - } -} - -GU_API GuOut* -gu_new_out(GuOutStream* stream, GuPool* pool) -{ - gu_require(stream != NULL); - - GuOut* out = gu_new(GuOut, pool); - out->buf_end = NULL, - out->buf_curr = 0, - out->stream = stream, - out->fini.fn = gu_out_fini; - gu_pool_finally(pool, &out->fini); - return out; -} - -extern inline bool -gu_out_try_buf_(GuOut* out, const uint8_t* src, size_t len); - -extern inline size_t -gu_out_bytes(GuOut* out, const uint8_t* buf, size_t len, GuExn* err); - -static size_t -gu_out_output(GuOut* out, const uint8_t* src, size_t len, GuExn* err) -{ - gu_out_end_buf(out, err); - if (!gu_ok(err)) { - return 0; - } - return out->stream->output(out->stream, src, len, err); -} - -GU_API void -gu_out_flush(GuOut* out, GuExn* err) -{ - GuOutStream* stream = out->stream; - if (out->buf_end) { - gu_out_end_buf(out, err); - if (!gu_ok(err)) { - return; - } - } - if (stream->flush) { - stream->flush(stream, err); - } -} - -GU_API uint8_t* -gu_out_begin_span(GuOut* out, size_t req, size_t* sz_out, GuExn* err) -{ - if (!out->buf_end && !gu_out_begin_buf(out, req, err)) { - return NULL; - } - *sz_out = -out->buf_curr; - return &out->buf_end[out->buf_curr]; -} - -GU_API void -gu_out_end_span(GuOut* out, size_t sz) -{ - ptrdiff_t new_curr = (ptrdiff_t) sz + out->buf_curr; - gu_require(new_curr <= 0); - out->buf_curr = new_curr; -} - -GU_API size_t -gu_out_bytes_(GuOut* restrict out, const uint8_t* restrict src, size_t len, - GuExn* err) -{ - if (!gu_ok(err)) { - return 0; - } else if (gu_out_try_buf_(out, src, len)) { - return len; - } - if (gu_out_begin_buf(out, len, err)) { - if (gu_out_try_buf_(out, src, len)) { - return len; - } - } - return gu_out_output(out, src, len, err); -} - -GU_API void -gu_out_u8_(GuOut* restrict out, uint8_t u, GuExn* err) -{ - if (gu_out_begin_buf(out, 1, err)) { - if (gu_out_try_u8_(out, u)) { - return; - } - } - gu_out_output(out, &u, 1, err); -} - -extern inline void -gu_out_u8(GuOut* restrict out, uint8_t u, GuExn* err); - -extern inline void -gu_out_s8(GuOut* restrict out, int8_t i, GuExn* err); - -extern inline bool -gu_out_is_buffered(GuOut* out); - -extern inline bool -gu_out_try_u8_(GuOut* restrict out, uint8_t u); - -GU_API void -gu_out_u16be(GuOut* out, uint16_t u, GuExn* err) -{ - gu_out_u8(out, (u>>8) & 0xFF, err); - gu_out_u8(out, u & 0xFF, err); -} - -GU_API void -gu_out_u64be(GuOut* out, uint64_t u, GuExn* err) -{ - gu_out_u8(out, (u>>56) & 0xFF, err); - gu_out_u8(out, (u>>48) & 0xFF, err); - gu_out_u8(out, (u>>40) & 0xFF, err); - gu_out_u8(out, (u>>32) & 0xFF, err); - gu_out_u8(out, (u>>24) & 0xFF, err); - gu_out_u8(out, (u>>16) & 0xFF, err); - gu_out_u8(out, (u>>8) & 0xFF, err); - gu_out_u8(out, u & 0xFF, err); -} - -GU_API void -gu_out_f64be(GuOut* out, double d, GuExn* err) -{ - gu_out_u64be(out, gu_encode_double(d), err); -} - -typedef struct GuBufferedOutStream GuBufferedOutStream; - -struct GuBufferedOutStream { - GuOutStream stream; - GuOut* real_out; - size_t sz; - uint8_t buf[]; -}; - -static uint8_t* -gu_buffered_out_buf_begin(GuOutStream* self, size_t req, size_t* sz_out, - GuExn* err) -{ - (void) (req && err); - GuBufferedOutStream* b = - gu_container(self, GuBufferedOutStream, stream); - *sz_out = b->sz; - return b->buf; -} - -static void -gu_buffered_out_buf_end(GuOutStream* self, size_t sz, GuExn* err) -{ - GuBufferedOutStream* b = - gu_container(self, GuBufferedOutStream, stream); - gu_require(sz <= b->sz); - gu_out_bytes(b->real_out, b->buf, sz, err); -} - -static size_t -gu_buffered_out_output(GuOutStream* self, const uint8_t* src, size_t sz, - GuExn* err) -{ - GuBufferedOutStream* bos = - gu_container(self, GuBufferedOutStream, stream); - return gu_out_bytes(bos->real_out, src, sz, err); -} - -static void -gu_buffered_out_flush(GuOutStream* self, GuExn* err) -{ - GuBufferedOutStream* bos = - gu_container(self, GuBufferedOutStream, stream); - gu_out_flush(bos->real_out, err); -} - -GU_API GuOut* -gu_new_buffered_out(GuOut* out, size_t sz, GuPool* pool) -{ - GuBufferedOutStream* b = - gu_new_flex(pool, GuBufferedOutStream, buf, sz); - b->stream = (GuOutStream) { - .begin_buf = gu_buffered_out_buf_begin, - .end_buf = gu_buffered_out_buf_end, - .output = gu_buffered_out_output, - .flush = gu_buffered_out_flush - }; - b->real_out = out; - b->sz = sz; - return gu_new_out(&b->stream, pool); -} - -GU_API GuOut* -gu_out_buffered(GuOut* out, GuPool* pool) -{ - if (gu_out_is_buffered(out)) { - return out; - } - return gu_new_buffered_out(out, 4096, pool); -} - - -extern inline void -gu_putc(char c, GuOut* out, GuExn* err); - -GU_API void -gu_puts(const char* str, GuOut* out, GuExn* err) -{ - gu_out_bytes(out, (const uint8_t*) str, strlen(str), err); -} - -GU_API void -gu_vprintf(const char* fmt, va_list args, GuOut* out, GuExn* err) -{ - GuPool* tmp_pool = gu_local_pool(); - - va_list args2; - va_copy(args2, args); - int len = vsnprintf(NULL, 0, fmt, args2); - gu_assert_msg(len >= 0, "Invalid format string: \"%s\"", fmt); - va_end(args2); - char* str = gu_new_n(char, len + 1, tmp_pool); - vsnprintf(str, len + 1, fmt, args); - - gu_out_bytes(out, (const uint8_t*) str, strlen(str), err); - gu_pool_free(tmp_pool); -} - -GU_API void -gu_printf(GuOut* out, GuExn* err, const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - gu_vprintf(fmt, args, out, err); - va_end(args); -} diff --git a/src/runtime/c/gu/out.h b/src/runtime/c/gu/out.h deleted file mode 100644 index f8cfbed0c..000000000 --- a/src/runtime/c/gu/out.h +++ /dev/null @@ -1,174 +0,0 @@ -#ifndef GU_OUT_H_ -#define GU_OUT_H_ - -#include -#include -#include -#include - -typedef struct GuOut GuOut; - -typedef struct GuOutStream GuOutStream; - -struct GuOutStream { - uint8_t* (*begin_buf)(GuOutStream* self, size_t req, size_t* sz_out, - GuExn* err); - void (*end_buf)(GuOutStream* self, size_t span, GuExn* err); - size_t (*output)(GuOutStream* self, const uint8_t* buf, size_t size, - GuExn* err); - void (*flush)(GuOutStream* self, GuExn* err); -}; - - -struct GuOut { - uint8_t* restrict buf_end; - ptrdiff_t buf_curr; - size_t buf_size; - GuOutStream* stream; - GuFinalizer fini; -}; - -GU_API_DECL GuOut* -gu_new_out(GuOutStream* stream, GuPool* pool); - -inline bool -gu_out_is_buffered(GuOut* out) -{ - return !!out->stream->begin_buf; -} - -GU_API_DECL GuOut* -gu_new_buffered_out(GuOut* out, size_t buf_sz, GuPool* pool); - -GU_API_DECL GuOut* -gu_out_buffered(GuOut* out, GuPool* pool); - -GU_API_DECL uint8_t* -gu_out_begin_span(GuOut* out, size_t req, size_t* sz_out, GuExn* err); - -GU_API_DECL uint8_t* -gu_out_force_span(GuOut* out, size_t min, size_t max, size_t* sz_out, - GuExn* err); - -GU_API_DECL void -gu_out_end_span(GuOut* out, size_t sz); - -GU_API_DECL size_t -gu_out_bytes_(GuOut* restrict out, const uint8_t* restrict src, - size_t len, GuExn* err); - -inline bool -gu_out_try_buf_(GuOut* restrict out, const uint8_t* restrict src, size_t len) -{ - gu_require(len <= PTRDIFF_MAX); - ptrdiff_t curr = out->buf_curr; - ptrdiff_t new_curr = curr + (ptrdiff_t) len; - if (GU_UNLIKELY(new_curr > 0)) { - return false; - } - memcpy(&out->buf_end[curr], src, len); - out->buf_curr = new_curr; - return true; -} - -inline size_t -gu_out_bytes(GuOut* restrict out, const uint8_t* restrict src, size_t len, - GuExn* err) -{ - if (GU_LIKELY(gu_out_try_buf_(out, src, len))) { - return len; - } - return gu_out_bytes_(out, src, len, err); -} - -GU_API_DECL void -gu_out_flush(GuOut* out, GuExn* err); - -inline bool -gu_out_try_u8_(GuOut* restrict out, uint8_t u) -{ - ptrdiff_t curr = out->buf_curr; - ptrdiff_t new_curr = curr + 1; - if (GU_UNLIKELY(new_curr > 0)) { - return false; - } - out->buf_end[curr] = u; - out->buf_curr = new_curr; - return true; -} - -inline void -gu_out_u8(GuOut* restrict out, uint8_t u, GuExn* err) -{ - if (GU_UNLIKELY(!gu_out_try_u8_(out, u))) { - GU_API_DECL void gu_out_u8_(GuOut* restrict out, uint8_t u, - GuExn* err); - gu_out_u8_(out, u, err); - } -} - -inline void -gu_out_s8(GuOut* restrict out, int8_t i, GuExn* err) -{ - gu_out_u8(out, (uint8_t) i, err); -} - -GU_API_DECL void -gu_out_u16le(GuOut* out, uint16_t u, GuExn* err); - -GU_API_DECL void -gu_out_u16be(GuOut* out, uint16_t u, GuExn* err); - -GU_API_DECL void -gu_out_s16le(GuOut* out, int16_t u, GuExn* err); - -GU_API_DECL void -gu_out_s16be(GuOut* out, int16_t u, GuExn* err); - -GU_API_DECL void -gu_out_u32le(GuOut* out, uint32_t u, GuExn* err); - -GU_API_DECL void -gu_out_u32be(GuOut* out, uint32_t u, GuExn* err); - -GU_API_DECL void -gu_out_s32le(GuOut* out, int32_t u, GuExn* err); - -GU_API_DECL void -gu_out_s32be(GuOut* out, int32_t u, GuExn* err); - -GU_API_DECL void -gu_out_u64le(GuOut* out, uint64_t u, GuExn* err); - -GU_API_DECL void -gu_out_u64be(GuOut* out, uint64_t u, GuExn* err); - -GU_API_DECL void -gu_out_s64le(GuOut* out, int64_t u, GuExn* err); - -GU_API_DECL void -gu_out_s64be(GuOut* out, int64_t u, GuExn* err); - -GU_API_DECL void -gu_out_f64le(GuOut* out, double d, GuExn* err); - -GU_API_DECL void -gu_out_f64be(GuOut* out, double d, GuExn* err); - -inline void -gu_putc(char c, GuOut* out, GuExn* err) -{ - GuUCS ucs = gu_char_ucs(c); - gu_out_u8(out, (uint8_t) ucs, err); -} - -GU_API_DECL void -gu_puts(const char* str, GuOut* out, GuExn* err); - -GU_API_DECL void -gu_vprintf(const char* fmt, va_list args, GuOut* out, GuExn* err); - -GU_API_DECL void -gu_printf(GuOut* out, GuExn* err, const char* fmt, ...); - -#endif // GU_OUT_H_ diff --git a/src/runtime/c/gu/prime.c b/src/runtime/c/gu/prime.c deleted file mode 100644 index 195215bee..000000000 --- a/src/runtime/c/gu/prime.c +++ /dev/null @@ -1,154 +0,0 @@ -#include -#include - -static const uint32_t gu_prime_wheel_mask = 0UL - | 1 << 1 - | 1 << 7 - | 1 << 11 - | 1 << 13 - | 1 << 17 - | 1 << 19 - | 1 << 23 - | 1 << 29; - -static bool -gu_prime_wheel(int i) -{ - gu_assert(i >= 0 && i < 30); - return !!(gu_prime_wheel_mask & (1 << i)); -} - -static const uint32_t gu_small_prime_mask = 0UL - | 1 << 2 - | 1 << 3 - | 1 << 5 - | 1 << 7 - | 1 << 11 - | 1 << 13 - | 1 << 17 - | 1 << 19 - | 1 << 23 - | 1 << 29 - | 1U << 31; - -static bool -gu_is_wheel_prime(int u) -{ - gu_assert(u > 30 && u % 2 != 0 && u % 3 != 0 && u % 5 != 0); - int d = 0; - int i = 7; - goto start; - while (d * d <= u) { - for (i = 1; i <= 29; i+=2) { - start: - if (gu_prime_wheel(i) && u % (d + i) == 0) { - return false; - } - } - d += 30; - } - return true; -} - -GU_INTERNAL int -gu_prime_inf(int i) -{ - if (i < 2) { - return 0; - } else if (i < 32) { - while (!(gu_small_prime_mask & (1 << i))) { - i--; - } - return i; - } - - int d = (i - 1) | 1; - int r = d % 30; - - while (!gu_prime_wheel(r) || !gu_is_wheel_prime(d)) { - d -= 2; - r -= 2; - if (r < 0) { - r += 30; - } - } - return d; -} - -GU_INTERNAL int -gu_prime_sup(int i) -{ - if (i <= 2) { - return 2; - } else if (i < 32) { - while (!(gu_small_prime_mask & (1 << i))) { - i++; - } - return i; - } - - int d = i | 1; - int r = d % 30; - - while (!gu_prime_wheel(r) || !gu_is_wheel_prime(d)) { - d += 2; - r += 2; - if (r > 30) { - r -= 30; - } - } - return d; -} - -GU_INTERNAL bool -gu_is_prime(int i) -{ - if (i < 2) { - return false; - } else if (i < 30) { - return !!(gu_small_prime_mask & (1 << i)); - } else if (!gu_prime_wheel(i % 30)) { - return false; - } else { - return gu_is_wheel_prime(i); - } -} - -GU_INTERNAL bool -gu_is_twin_prime(int i) -{ - return gu_is_prime(i) && gu_is_prime(i - 2); -} - -GU_INTERNAL int -gu_twin_prime_inf(int i) -{ - while (true) { - i = gu_prime_inf(i); - if (i == 0) { - return 0; - } else if (gu_is_prime(i - 2)) { - return i; - } - i = i - 4; - } - return i; -} - -GU_INTERNAL int -gu_twin_prime_sup(int i) -{ - if (i <= 5) { - return 5; - } - i = i - 2; - while (true) { - i = gu_prime_sup(i); - if (gu_is_prime(i + 2)) { - return i + 2; - } - i = i + 4; - } - return i; -} - diff --git a/src/runtime/c/gu/prime.h b/src/runtime/c/gu/prime.h deleted file mode 100644 index 1118878a8..000000000 --- a/src/runtime/c/gu/prime.h +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef GU_PRIME_H_ -#define GU_PRIME_H_ - -#include - -GU_INTERNAL_DECL bool gu_is_prime(int i); - -GU_INTERNAL_DECL bool gu_is_twin_prime(int i); - -GU_INTERNAL_DECL int gu_prime_inf(int i); -GU_INTERNAL_DECL int gu_twin_prime_inf(int i); - -GU_INTERNAL_DECL int gu_prime_sup(int i); -GU_INTERNAL_DECL int gu_twin_prime_sup(int i); - -#endif // GU_PRIME_H_ diff --git a/src/runtime/c/gu/seq.c b/src/runtime/c/gu/seq.c deleted file mode 100644 index fd535caf6..000000000 --- a/src/runtime/c/gu/seq.c +++ /dev/null @@ -1,386 +0,0 @@ -#include -#include -#include -#include -#include -#if defined(__MINGW32__) || defined(_MSC_VER) -#include -#endif - -static void -gu_buf_fini(GuFinalizer* fin) -{ - GuBuf* buf = gu_container(fin, GuBuf, fin); - if (buf->avail_len > 0) - gu_mem_buf_free(buf->seq); -} - -GU_API GuBuf* -gu_make_buf(size_t elem_size, GuPool* pool) -{ - GuBuf* buf = gu_new(GuBuf, pool); - buf->seq = gu_empty_seq(); - buf->elem_size = elem_size; - buf->avail_len = 0; - buf->fin.fn = gu_buf_fini; - gu_pool_finally(pool, &buf->fin); - return buf; -} - -extern size_t -gu_buf_length(GuBuf* buf); - -extern size_t -gu_buf_avail(GuBuf* buf); - -extern void* -gu_buf_data(GuBuf* buf); - -extern GuSeq* -gu_buf_data_seq(GuBuf* buf); - -extern void* -gu_buf_extend(GuBuf* buf); - -extern const void* -gu_buf_trim(GuBuf* buf); - -extern void -gu_buf_flush(GuBuf* buf); - -static GuSeq gu_empty_seq_ = {0}; - -GU_API GuSeq* -gu_empty_seq() { - return &gu_empty_seq_; -} - -GU_API GuSeq* -gu_make_seq(size_t elem_size, size_t length, GuPool* pool) -{ - GuSeq* seq = gu_malloc(pool, sizeof(GuSeq) + elem_size * length); - seq->len = length; - return seq; -} - -extern size_t -gu_seq_length(GuSeq* seq); - -extern void* -gu_seq_data(GuSeq* seq); - -GU_API GuSeq* -gu_alloc_seq_(size_t elem_size, size_t length) -{ - if (length == 0) - return gu_empty_seq(); - - size_t real_size; - GuSeq* seq = gu_mem_buf_alloc(sizeof(GuSeq) + elem_size * length, &real_size); - seq->len = (real_size - sizeof(GuSeq)) / elem_size; - return seq; -} - -GU_API GuSeq* -gu_realloc_seq_(GuSeq* seq, size_t elem_size, size_t length) -{ - size_t real_size; - GuSeq* new_seq = (seq == NULL || seq == gu_empty_seq()) ? - gu_mem_buf_alloc(sizeof(GuSeq) + elem_size * length, &real_size) : - gu_mem_buf_realloc(seq, sizeof(GuSeq) + elem_size * length, &real_size); - new_seq->len = (real_size - sizeof(GuSeq)) / elem_size; - return new_seq; -} - -GU_API void -gu_seq_free(GuSeq* seq) -{ - if (seq == NULL || seq == gu_empty_seq()) - return; - gu_mem_buf_free(seq); -} - -static void -gu_dummy_finalizer(GuFinalizer* self) -{ -} - -GU_API void -gu_buf_require(GuBuf* buf, size_t req_len) -{ - if (req_len <= buf->avail_len) { - return; - } - - size_t req_size = sizeof(GuSeq) + buf->elem_size * req_len; - size_t real_size; - - gu_require(buf->fin.fn != gu_dummy_finalizer); - - if (buf->seq == NULL || buf->seq == gu_empty_seq()) { - buf->seq = gu_mem_buf_alloc(req_size, &real_size); - buf->seq->len = 0; - } else { - buf->seq = gu_mem_buf_realloc(buf->seq, req_size, &real_size); - } - - buf->avail_len = (real_size - sizeof(GuSeq)) / buf->elem_size; -} - -GU_API void* -gu_buf_extend_n(GuBuf* buf, size_t n_elems) -{ - size_t len = gu_buf_length(buf); - size_t new_len = len + n_elems; - gu_buf_require(buf, new_len); - buf->seq->len = new_len; - return &buf->seq->data[buf->elem_size * len]; -} - -GU_API void -gu_buf_push_n(GuBuf* buf, const void* data, size_t n_elems) -{ - void* p = gu_buf_extend_n(buf, n_elems); - memcpy(p, data, buf->elem_size * n_elems); -} - -GU_API const void* -gu_buf_trim_n(GuBuf* buf, size_t n_elems) -{ - gu_require(n_elems <= gu_buf_length(buf)); - size_t new_len = gu_buf_length(buf) - n_elems; - buf->seq->len = new_len; - return &buf->seq->data[buf->elem_size * new_len]; -} - -GU_API void -gu_buf_pop_n(GuBuf* buf, size_t n_elems, void* data_out) -{ - const void* p = gu_buf_trim_n(buf, n_elems); - memcpy(data_out, p, buf->elem_size * n_elems); -} - -GU_API GuSeq* -gu_buf_freeze(GuBuf* buf, GuPool* pool) -{ - size_t len = gu_buf_length(buf); - GuSeq* seq = gu_make_seq(buf->elem_size, len, pool); - void* bufdata = gu_buf_data(buf); - void* seqdata = gu_seq_data(seq); - memcpy(seqdata, bufdata, buf->elem_size * len); - return seq; -} - -GU_API void -gu_buf_evacuate(GuBuf* buf, GuPool* pool) -{ - if (buf->seq != gu_empty_seq()) { - size_t len = gu_buf_length(buf); - - GuSeq* seq = gu_make_seq(buf->elem_size, len, pool); - void* bufdata = gu_buf_data(buf); - void* seqdata = gu_seq_data(seq); - memcpy(seqdata, bufdata, buf->elem_size * len); - gu_mem_buf_free(buf->seq); - - buf->seq = seq; - buf->fin.fn = gu_dummy_finalizer; - buf->avail_len = len; - } -} - -GU_API void* -gu_buf_insert(GuBuf* buf, size_t index) -{ - size_t len = buf->seq->len; - gu_buf_require(buf, len + 1); - - uint8_t* target = - buf->seq->data + buf->elem_size * index; - memmove(target+buf->elem_size, target, (len-index)*buf->elem_size); - - buf->seq->len++; - return target; -} - -static void -gu_quick_sort(GuBuf *buf, GuOrder *order, int left, int right) -{ - int l_hold = left; - int r_hold = right; - - void* pivot = alloca(buf->elem_size); - memcpy(pivot, - &buf->seq->data[buf->elem_size * left], - buf->elem_size); - while (left < right) { - - while ((order->compare(order, &buf->seq->data[buf->elem_size * right], pivot) >= 0) && (left < right)) - right--; - - if (left != right) { - memcpy(&buf->seq->data[buf->elem_size * left], - &buf->seq->data[buf->elem_size * right], - buf->elem_size); - left++; - } - - while ((order->compare(order, &buf->seq->data[buf->elem_size * left], pivot) <= 0) && (left < right)) - left++; - - if (left != right) { - memcpy(&buf->seq->data[buf->elem_size * right], - &buf->seq->data[buf->elem_size * left], - buf->elem_size); - right--; - } - } - - memcpy(&buf->seq->data[buf->elem_size * left], - pivot, - buf->elem_size); - int index = left; - left = l_hold; - right = r_hold; - - if (left < index) - gu_quick_sort(buf, order, left, index-1); - - if (right > index) - gu_quick_sort(buf, order, index+1, right); -} - -GU_API void -gu_buf_sort(GuBuf *buf, GuOrder *order) -{ - gu_quick_sort(buf, order, 0, gu_buf_length(buf) - 1); -} - -GU_API void* -gu_seq_binsearch_(GuSeq *seq, GuOrder *order, size_t elem_size, const void *key) -{ - int i = 0; - int j = seq->len-1; - - while (i <= j) { - int k = (i+j) / 2; - uint8_t* elem_p = &seq->data[elem_size * k]; - int cmp = order->compare(order, key, elem_p); - - if (cmp < 0) { - j = k-1; - } else if (cmp > 0) { - i = k+1; - } else { - return elem_p; - } - } - - return NULL; -} - -GU_API bool -gu_seq_binsearch_index_(GuSeq *seq, GuOrder *order, size_t elem_size, - const void *key, size_t *pindex) -{ - size_t i = 0; - size_t j = seq->len-1; - - while (i <= j) { - size_t k = (i+j) / 2; - uint8_t* elem_p = &seq->data[elem_size * k]; - int cmp = order->compare(order, key, elem_p); - - if (cmp < 0) { - j = k-1; - } else if (cmp > 0) { - i = k+1; - } else { - *pindex = k; - return true; - } - } - - *pindex = j; - return false; -} - -static void -gu_heap_siftdown(GuBuf *buf, GuOrder *order, - const void *value, int startpos, int pos) -{ - while (pos > startpos) { - int parentpos = (pos - 1) >> 1; - void *parent = &buf->seq->data[buf->elem_size * parentpos]; - - if (order->compare(order, value, parent) >= 0) - break; - - memcpy(&buf->seq->data[buf->elem_size * pos], parent, buf->elem_size); - pos = parentpos; - } - - memcpy(&buf->seq->data[buf->elem_size * pos], value, buf->elem_size); -} - -static void -gu_heap_siftup(GuBuf *buf, GuOrder *order, - const void *value, int pos) -{ - int startpos = pos; - int endpos = gu_buf_length(buf); - - int childpos = 2*pos + 1; - while (childpos < endpos) { - int rightpos = childpos + 1; - if (rightpos < endpos && - order->compare(order, - &buf->seq->data[buf->elem_size * childpos], - &buf->seq->data[buf->elem_size * rightpos]) >= 0) { - childpos = rightpos; - } - - memcpy(&buf->seq->data[buf->elem_size * pos], - &buf->seq->data[buf->elem_size * childpos], buf->elem_size); - pos = childpos; - childpos = 2*pos + 1; - } - - gu_heap_siftdown(buf, order, value, startpos, pos); -} - -GU_API void -gu_buf_heap_push(GuBuf *buf, GuOrder *order, void *value) -{ - gu_buf_extend(buf); - gu_heap_siftdown(buf, order, value, 0, gu_buf_length(buf)-1); -} - -GU_API void -gu_buf_heap_pop(GuBuf *buf, GuOrder *order, void* data_out) -{ - const void* last = gu_buf_trim(buf); // raises an error if empty - memcpy(data_out, buf->seq->data, buf->elem_size); - gu_heap_siftup(buf, order, last, 0); -} - -GU_API void -gu_buf_heap_replace(GuBuf *buf, GuOrder *order, void *value, void *data_out) -{ - gu_require(gu_buf_length(buf) > 0); - - memcpy(data_out, buf->seq->data, buf->elem_size); - gu_heap_siftup(buf, order, value, 0); -} - -GU_API void -gu_buf_heapify(GuBuf *buf, GuOrder *order) -{ - size_t middle = gu_buf_length(buf) / 2; - void *value = alloca(buf->elem_size); - - for (size_t i = 0; i < middle; i++) { - memcpy(value, &buf->seq->data[buf->elem_size * i], buf->elem_size); - gu_heap_siftup(buf, order, value, i); - } -} diff --git a/src/runtime/c/gu/seq.h b/src/runtime/c/gu/seq.h deleted file mode 100644 index b639369c3..000000000 --- a/src/runtime/c/gu/seq.h +++ /dev/null @@ -1,193 +0,0 @@ -#ifndef GU_SEQ_H_ -#define GU_SEQ_H_ - -#include - -typedef struct { - size_t len; - uint8_t data[0]; -} GuSeq; - -typedef struct { - GuSeq* seq; - size_t elem_size; - size_t avail_len; - GuFinalizer fin; -} GuBuf; - -GU_API_DECL GuSeq* -gu_empty_seq(); - -GU_API_DECL GuSeq* -gu_make_seq(size_t elem_size, size_t len, GuPool* pool); - -#define gu_new_seq(T, N, POOL) \ - gu_make_seq(sizeof(T), (N), (POOL)) - -GU_API_DECL GuSeq* -gu_alloc_seq_(size_t elem_size, size_t length); - -#define gu_alloc_seq(T, N) \ - gu_alloc_seq_(sizeof(T), (N)) - -GU_API_DECL GuSeq* -gu_realloc_seq_(GuSeq* seq, size_t elem_size, size_t length); - -#define gu_realloc_seq(S, T, N) \ - gu_realloc_seq_(S, sizeof(T), (N)) - -GU_API_DECL void -gu_seq_free(GuSeq* seq); - -inline size_t -gu_seq_length(GuSeq* seq) -{ - return seq->len; -} - -inline void* -gu_seq_data(GuSeq* seq) -{ - return seq->data; -} - -#define gu_seq_index(SEQ, T, I) \ - (&((T*)gu_seq_data(SEQ))[I]) - -#define gu_seq_get(SEQ, T, I) \ - (*gu_seq_index(SEQ, T, I)) - -#define gu_seq_set(SEQ, T, I, V) \ - GU_BEGIN \ - (*gu_seq_index(SEQ, T, I) = (V)); \ - GU_END - - -GU_API_DECL GuBuf* -gu_make_buf(size_t elem_size, GuPool* pool); - -#define gu_new_buf(T, POOL) \ - gu_make_buf(sizeof(T), (POOL)) - -inline size_t -gu_buf_length(GuBuf* buf) -{ - return buf->seq->len; -} - -inline size_t -gu_buf_avail(GuBuf* buf) -{ - return buf->avail_len; -} - -inline void* -gu_buf_data(GuBuf* buf) -{ - return &buf->seq->data; -} - -inline GuSeq* -gu_buf_data_seq(GuBuf* buf) -{ - return buf->seq; -} - -#define gu_buf_index(BUF, T, I) \ - (&((T*)gu_buf_data(BUF))[I]) - -#define gu_buf_get(BUF, T, I) \ - (*gu_buf_index(BUF, T, I)) - -#define gu_buf_set(BUF, T, I, V) \ - GU_BEGIN \ - (*gu_buf_index(BUF, T, I) = (V)); \ - GU_END - -GU_API_DECL void -gu_buf_push_n(GuBuf* buf, const void* elems, size_t n_elems); - -GU_API_DECL void* -gu_buf_extend_n(GuBuf* buf, size_t n_elems); - -inline void* -gu_buf_extend(GuBuf* buf) -{ - return gu_buf_extend_n(buf, 1); -} - -#define gu_buf_push(BUF, T, VAL) \ - GU_BEGIN \ - ((*(T*)gu_buf_extend(BUF)) = (VAL)); \ - GU_END - -GU_API_DECL void -gu_buf_pop_n(GuBuf* buf, size_t n_elems, void* data_out); - -#define gu_buf_get_last(BUF, T) \ - (((T*)gu_buf_data(BUF))[(BUF)->seq->len-1]) - -#define gu_buf_index_last(BUF, T) \ - (&((T*)gu_buf_data(BUF))[(BUF)->seq->len-1]) - -GU_API_DECL const void* -gu_buf_trim_n(GuBuf* buf, size_t n_elems); - -inline const void* -gu_buf_trim(GuBuf* buf) -{ - return gu_buf_trim_n(buf, 1); -} - -GU_API_DECL void* -gu_buf_insert(GuBuf* buf, size_t n_index); - -inline void -gu_buf_flush(GuBuf* buf) -{ - buf->seq->len = 0; -} - -#define gu_buf_pop(BUF, T) \ - (*(T*)gu_buf_trim(BUF)) - -GU_API_DECL void -gu_buf_sort(GuBuf *buf, GuOrder *order); - -#define gu_seq_binsearch(S, O, T, V) \ - ((T*) gu_seq_binsearch_(S, O, sizeof(T), V)) - -GU_API_DECL void* -gu_seq_binsearch_(GuSeq *seq, GuOrder *order, size_t elem_size, const void *key); - -#define gu_seq_binsearch_index(S, O, T, V, PI) \ - gu_seq_binsearch_index_(S, O, sizeof(T), V, PI) - -GU_API_DECL bool -gu_seq_binsearch_index_(GuSeq *seq, GuOrder *order, size_t elem_size, - const void *key, size_t *pindex); - -// Using a buffer as a heap -GU_API_DECL void -gu_buf_heap_push(GuBuf *buf, GuOrder *order, void *value); - -GU_API_DECL void -gu_buf_heap_pop(GuBuf *buf, GuOrder *order, void* data_out); - -GU_API_DECL void -gu_buf_heap_replace(GuBuf *buf, GuOrder *order, void *value, void *data_out); - -GU_API_DECL void -gu_buf_heapify(GuBuf *buf, GuOrder *order); - -GU_API_DECL GuSeq* -gu_buf_freeze(GuBuf* buf, GuPool* pool); - -GU_API_DECL void -gu_buf_evacuate(GuBuf* buf, GuPool* pool); -#endif // GU_SEQ_H_ - -#ifdef GU_STRING_H_ -GU_INTERNAL_DECL void -gu_buf_require(GuBuf* buf, size_t req_len); -#endif // GU_STRING_H_ diff --git a/src/runtime/c/gu/string.c b/src/runtime/c/gu/string.c deleted file mode 100644 index 2b83e2a86..000000000 --- a/src/runtime/c/gu/string.c +++ /dev/null @@ -1,313 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#if defined(__MINGW32__) || defined(_MSC_VER) -#include -#endif - -struct GuStringBuf { - GuOutStream stream; - GuBuf* buf; - GuOut* out; -}; - -static size_t -gu_string_buf_output(GuOutStream* stream, const uint8_t* src, size_t sz, - GuExn* err) -{ - (void) err; - GuStringBuf* sbuf = gu_container(stream, GuStringBuf, stream); - gu_buf_push_n(sbuf->buf, src, sz); - return sz; -} - -static uint8_t* -gu_string_buf_begin(GuOutStream* stream, size_t req, size_t* sz_out, GuExn* err) -{ - (void) req; - (void) err; - GuStringBuf* sbuf = gu_container(stream, GuStringBuf, stream); - size_t len = gu_buf_length(sbuf->buf); - gu_buf_require(sbuf->buf, len + req); - size_t avail = sbuf->buf->avail_len; - gu_assert(len < avail); - *sz_out = (avail - len); - return (uint8_t*) gu_buf_index(sbuf->buf, char, len); -} - -static void -gu_string_buf_end(GuOutStream* stream, size_t sz, GuExn* err) -{ - (void) err; - GuStringBuf* sbuf = gu_container(stream, GuStringBuf, stream); - size_t len = gu_buf_length(sbuf->buf); - gu_require(sz < len - sbuf->buf->avail_len); - sbuf->buf->seq->len = len + sz; -} - -GU_API GuStringBuf* -gu_new_string_buf(GuPool* pool) -{ - GuStringBuf* sbuf = gu_new(GuStringBuf, pool); - sbuf->stream.output = gu_string_buf_output; - sbuf->stream.begin_buf = gu_string_buf_begin; - sbuf->stream.end_buf = gu_string_buf_end; - sbuf->stream.flush = NULL; - sbuf->buf = gu_new_buf(char, pool); - sbuf->out = gu_new_out(&sbuf->stream, pool); - return sbuf; -} - -GU_API GuOut* -gu_string_buf_out(GuStringBuf* sb) -{ - return sb->out; -} - -GU_API GuString -gu_string_buf_freeze(GuStringBuf* sb, GuPool* pool) -{ - gu_out_flush(sb->out, NULL); - char* data = gu_buf_data(sb->buf); - size_t len = gu_buf_length(sb->buf); - - char* p = gu_malloc_aligned(pool, len+1, 2); - memcpy(p, data, len); - p[len] = 0; - - return p; -} - -GU_API char* -gu_string_buf_data(GuStringBuf* sb) -{ - gu_out_flush(sb->out, NULL); - return gu_buf_data(sb->buf); -} - -GU_API size_t -gu_string_buf_length(GuStringBuf* sb) -{ - gu_out_flush(sb->out, NULL); - return gu_buf_length(sb->buf); -} - -GU_API void -gu_string_buf_flush(GuStringBuf* sb) -{ - gu_buf_flush(sb->buf); -} - -GU_API GuIn* -gu_string_in(GuString s, GuPool* pool) -{ - return gu_data_in((uint8_t*) s, strlen(s), pool); -} - -GU_API GuString -gu_string_copy(GuString string, GuPool* pool) -{ - size_t len = strlen(string); - char* p = gu_malloc_aligned(pool, len+1, 2); - memcpy(p, string, len+1); - return p; -} - -GU_API void -gu_string_write(GuString s, GuOut* out, GuExn* err) -{ - gu_out_bytes(out, (uint8_t*) s, strlen(s), err); -} - -GU_API GuString -gu_string_read(size_t len, GuPool* pool, GuIn* in, GuExn* err) -{ - char* buf = alloca(len*6+1); - char* p = buf; - for (size_t i = 0; i < len; i++) { - gu_in_utf8_buf((uint8_t**) &p, in, err); - } - *p++ = 0; - - p = gu_malloc_aligned(pool, p-buf, 2); - strcpy(p, buf); - - return p; -} - -GU_API GuString -gu_string_read_latin1(size_t len, GuPool* pool, GuIn* in, GuExn* err) -{ - char* p = gu_malloc_aligned(pool, len+1, 2); - gu_in_bytes(in, (uint8_t*)p, len, err); - p[len] = 0; - return p; -} - -GU_API GuString -gu_format_string_v(const char* fmt, va_list args, GuPool* pool) -{ - GuPool* tmp_pool = gu_local_pool(); - GuStringBuf* sb = gu_new_string_buf(tmp_pool); - GuOut* out = gu_string_buf_out(sb); - gu_vprintf(fmt, args, out, NULL); - gu_out_flush(out, NULL); - GuString s = gu_string_buf_freeze(sb, pool); - gu_pool_free(tmp_pool); - return s; -} - -GU_API GuString -gu_format_string(GuPool* pool, const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - GuString s = gu_format_string_v(fmt, args, pool); - va_end(args); - return s; -} - -GU_API bool -gu_string_to_int(GuString s, int *res) -{ - bool neg = false; - if (*s == '-') { - neg = true; - s++; - } - - if (*s == 0) - return false; - - int n = 0; - for (; *s; s++) { - if (*s < '0' || *s > '9') - return false; - - n = n * 10 + (*s - '0'); - } - - *res = neg ? -n : n; - return true; -} - -GU_API bool -gu_string_to_double(GuString s, double *res) -{ - bool neg = false; - bool dec = false; - double exp = 1; - - if (*s == '-') { - neg = true; - s++; - } - - if (*s == 0) - return false; - - double d = 0; - for (; *s; s++) { - if (*s == '.') { - if (dec) return false; - - dec = true; - continue; - } - - if (*s < '0' || *s > '9') - return false; - - if (dec) exp = exp * 10; - - d = d * 10 + (*s - '0'); - } - - *res = (neg ? -d : d) / exp; - return true; -} - -GU_API void -gu_double_to_string(double val, GuOut* out, GuExn* err) -{ - int ival = (int) val; - gu_printf(out, err, "%d", ival); - val -= ival; - - if (val < 0) - val = -val; - - if (val != 0) { - gu_putc('.', out, err); - - while (val > 0.000001) // process remaining digits - { - val = val * 10; - ival = (int) val; - gu_printf(out, err, "%d", ival); - val -= ival; - } - } -} - -GU_API bool -gu_string_is_prefix(GuString s1, GuString s2) -{ - size_t len1 = strlen(s1); - size_t len2 = strlen(s2); - - if (len1 > len2) - return false; - - for (size_t len = len1; len > 0; len--) { - if (*s1 != *s2) - return false; - - s1++; - s2++; - } - - return true; -} - -GU_API GuHash -gu_string_hash(GuHash h, GuString s) -{ - return gu_hash_bytes(h, (uint8_t*)s, strlen(s)); -} - -static bool -gu_string_eq_fn(GuEquality* self, const void* p1, const void* p2) -{ - (void) self; - return strcmp((GuString) p1, (GuString) p2) == 0; -} - -GU_API GuEquality gu_string_equality[1] = { { gu_string_eq_fn } }; - -static int -gu_string_cmp_fn(GuOrder* self, const void* p1, const void* p2) -{ - (void) self; - return strcmp((GuString) p1, (GuString) p2); -} - -GU_API GuOrder gu_string_order[1] = { { gu_string_cmp_fn } }; - -static GuHash -gu_string_hasher_hash(GuHasher* self, const void* p) -{ - (void) self; - return gu_string_hash(0, (GuString) p); -} - -GU_API GuHasher gu_string_hasher[1] = { - { - .eq = { gu_string_eq_fn }, - .hash = gu_string_hasher_hash - } -}; diff --git a/src/runtime/c/gu/string.h b/src/runtime/c/gu/string.h deleted file mode 100644 index e8b49a1de..000000000 --- a/src/runtime/c/gu/string.h +++ /dev/null @@ -1,97 +0,0 @@ -#ifndef GU_STRING_H_ -#define GU_STRING_H_ - -#include -#include -#include - -typedef const char* GuString; - -GU_API_DECL GuString -gu_string_copy(GuString string, GuPool* pool); - -GU_API_DECL void -gu_string_write(GuString string, GuOut* out, GuExn* err); - -GU_API_DECL GuString -gu_string_read(size_t len, GuPool* pool, GuIn* in, GuExn* err); - -GU_API_DECL GuString -gu_string_read_latin1(size_t len, GuPool* pool, GuIn* in, GuExn* err); - -GU_API_DECL GuIn* -gu_string_in(GuString string, GuPool* pool); - -typedef struct GuStringBuf GuStringBuf; - -GU_API_DECL GuStringBuf* -gu_new_string_buf(GuPool* pool); - -GU_API_DECL GuOut* -gu_string_buf_out(GuStringBuf* sb); - -GU_API_DECL GuString -gu_string_buf_freeze(GuStringBuf* sb, GuPool* pool); - -GU_API_DECL char* -gu_string_buf_data(GuStringBuf* sb); - -GU_API_DECL size_t -gu_string_buf_length(GuStringBuf* sb); - -GU_API_DECL void -gu_string_buf_flush(GuStringBuf* sb); - -GU_API_DECL GuString -gu_format_string_v(const char* fmt, va_list args, GuPool* pool); - -GU_API_DECL GuString -gu_format_string(GuPool* pool, const char* fmt, ...); - -GU_API_DECL bool -gu_string_to_int(GuString s, int *res); - -GU_API_DECL bool -gu_string_to_double(GuString s, double *res); - -GU_API_DECL void -gu_double_to_string(double val, GuOut* out, GuExn* err); - -GU_API_DECL bool -gu_string_is_prefix(GuString s1, GuString s2); - -#endif // GU_STRING_H_ - -#if defined(GU_FUN_H_) && !defined(GU_STRING_H_FUN_) -#define GU_STRING_H_FUN_ -GU_API_DECL extern GuEquality gu_string_equality[1]; - -GU_API_DECL extern GuOrder gu_string_order[1]; -#endif - -#if defined(GU_HASH_H_) && !defined(GU_STRING_H_HASH_) -#define GU_STRING_H_HASH_ - -GU_API_DECL GuHash -gu_string_hash(GuHash h, GuString s); - -GU_API_DECL extern GuHasher gu_string_hasher[1]; -#endif - -#if defined(GU_SEQ_H_) && !defined(GU_STRING_H_SEQ_) -#define GU_STRING_H_SEQ_ - -typedef GuSeq GuStrings; -#endif - - -#if defined(GU_MAP_H_) && !defined(GU_STRING_H_MAP_) -#define GU_STRING_H_MAP_ - -typedef GuMap GuStringMap; - -#define gu_new_string_map(VAL_T, DEFAULT, POOL) \ - gu_new_map(GuString, gu_string_hasher, VAL_T, (DEFAULT), (POOL)) - -#endif - diff --git a/src/runtime/c/gu/sysdeps.h b/src/runtime/c/gu/sysdeps.h deleted file mode 100644 index fc889ce19..000000000 --- a/src/runtime/c/gu/sysdeps.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef GU_SYSDEPS_H_ -#define GU_SYSDEPS_H_ - -#if defined(__GNUC__) && !defined(__STRICT_ANSI__) -# define GU_GNUC -#endif - -#ifdef GU_GNUC -# define GU_ALIGNOF __alignof -# define GU_GNUC_ATTR(x) __attribute__(( x )) -# if defined(__OPTIMIZE_SIZE__) -# define GU_OPTIMIZE_SIZE -# elif defined(__OPTIMIZE__) -# define GU_OPTIMIZE_SPEED -# endif -#else -# define GU_GNUC_ATTR(x) -#endif - -#ifdef S_SPLINT_S -# define GU_SPLINT(x) %{ x %} -#else -# define GU_SPLINT(x) -#endif - - -#endif // GU_SYSDEPS_H_ diff --git a/src/runtime/c/gu/ucs.c b/src/runtime/c/gu/ucs.c deleted file mode 100644 index 38423f738..000000000 --- a/src/runtime/c/gu/ucs.c +++ /dev/null @@ -1,4818 +0,0 @@ -#include -#include -#include - -GU_API bool -gu_char_is_valid(char c) -{ - if (c < 0) { - return false; - } else if (c < 64) { - return UINT64_C(0xffffffef00003f81) & (UINT64_C(1) << c); - } -#if CHAR_MAX > 127 // Let's avoid spurious warnings - else if (c > 127) { - return false; - } -#endif - return UINT64_C(0x7ffffffefffffffe) & (UINT64_C(1) << (c - 64)); -} - -GU_API char -gu_ucs_char(GuUCS uc, GuExn* err) -{ - if (0 <= uc && uc <= 127) { - char c = (char) uc; - if (gu_char_is_valid(c)) { - return c; - } - } - gu_raise(err, GuUCSExn); - return 0; -} - -GU_API size_t -gu_str_to_ucs(const char* cbuf, size_t len, GuUCS* ubuf, GuExn* err) -{ - size_t n = 0; - while (n < len) { - char c = cbuf[n]; - if (!gu_char_is_valid(c)) { - gu_raise(err, GuUCSExn); - return n; - } - ubuf[n] = gu_char_ucs(c); - n++; - } - return n; -} - -GU_API size_t -gu_ucs_to_str(const GuUCS* ubuf, size_t len, char* cbuf, GuExn* err) -{ - size_t n = 0; - while (n < len) { - char c = gu_ucs_char(ubuf[n], err); - if (!gu_ok(err)) { - break; - } - cbuf[n] = c; - n++; - } - return n; -} - - -extern inline bool -gu_ucs_valid(GuUCS ucs); - -GU_API GuUCS -gu_char_ucs(char c) -{ - gu_require(gu_char_is_valid(c)); - GuUCS u = (GuUCS) c; - gu_ensure(u < 0x80); - return u; -} - - - -/*---------------------------------------------------------------------- -* The rest of this file is a modified version of WCsubst.c from -* the base library in Haskell. It encodes the Unicode classes and it -* should not be changed -----------------------------------------------------------------------*/ - -enum { - NUMCAT_LU, /* Letter, Uppercase */ - NUMCAT_LL, /* Letter, Lowercase */ - NUMCAT_LT, /* Letter, Titlecase */ - NUMCAT_LM, /* Letter, Modifier */ - NUMCAT_LO, /* Letter, Other */ - NUMCAT_MN, /* Mark, Non-Spacing */ - NUMCAT_MC, /* Mark, Spacing Combining */ - NUMCAT_ME, /* Mark, Enclosing */ - NUMCAT_ND, /* Number, Decimal */ - NUMCAT_NL, /* Number, Letter */ - NUMCAT_NO, /* Number, Other */ - NUMCAT_PC, /* Punctuation, Connector */ - NUMCAT_PD, /* Punctuation, Dash */ - NUMCAT_PS, /* Punctuation, Open */ - NUMCAT_PE, /* Punctuation, Close */ - NUMCAT_PI, /* Punctuation, Initial quote */ - NUMCAT_PF, /* Punctuation, Final quote */ - NUMCAT_PO, /* Punctuation, Other */ - NUMCAT_SM, /* Symbol, Math */ - NUMCAT_SC, /* Symbol, Currency */ - NUMCAT_SK, /* Symbol, Modifier */ - NUMCAT_SO, /* Symbol, Other */ - NUMCAT_ZS, /* Separator, Space */ - NUMCAT_ZL, /* Separator, Line */ - NUMCAT_ZP, /* Separator, Paragraph */ - NUMCAT_CC, /* Other, Control */ - NUMCAT_CF, /* Other, Format */ - NUMCAT_CS, /* Other, Surrogate */ - NUMCAT_CO, /* Other, Private Use */ - NUMCAT_CN /* Other, Not Assigned */ -}; - -struct _convrule_ -{ - unsigned int category; - unsigned int catnumber; - int possible; - int updist; - int lowdist; - int titledist; -}; - -struct _charblock_ -{ - int start; - int length; - const struct _convrule_ *rule; -}; - -#define GENCAT_ZP 67108864 -#define GENCAT_MC 8388608 -#define GENCAT_NO 131072 -#define GENCAT_SK 1024 -#define GENCAT_CO 268435456 -#define GENCAT_ME 4194304 -#define GENCAT_ND 256 -#define GENCAT_PO 4 -#define GENCAT_LT 524288 -#define GENCAT_PC 2048 -#define GENCAT_SM 64 -#define GENCAT_ZS 2 -#define GENCAT_CC 1 -#define GENCAT_LU 512 -#define GENCAT_PD 128 -#define GENCAT_SO 8192 -#define GENCAT_PE 32 -#define GENCAT_CS 134217728 -#define GENCAT_PF 262144 -#define GENCAT_CF 65536 -#define GENCAT_PS 16 -#define GENCAT_SC 8 -#define GENCAT_LL 4096 -#define GENCAT_ZL 33554432 -#define GENCAT_LM 1048576 -#define GENCAT_PI 32768 -#define GENCAT_NL 16777216 -#define GENCAT_MN 2097152 -#define GENCAT_LO 16384 -#define MAX_UNI_CHAR 1114109 -#define NUM_BLOCKS 3073 -#define NUM_CONVBLOCKS 1276 -#define NUM_SPACEBLOCKS 7 -#define NUM_LAT1BLOCKS 63 -#define NUM_RULES 181 -static const struct _convrule_ rule169={GENCAT_LU, NUMCAT_LU, 1, 0, -35332, 0}; -static const struct _convrule_ rule157={GENCAT_SO, NUMCAT_SO, 1, -26, 0, -26}; -static const struct _convrule_ rule168={GENCAT_LL, NUMCAT_LL, 1, -7264, 0, -7264}; -static const struct _convrule_ rule173={GENCAT_LU, NUMCAT_LU, 1, 0, -42315, 0}; -static const struct _convrule_ rule129={GENCAT_LL, NUMCAT_LL, 1, 8, 0, 8}; -static const struct _convrule_ rule88={GENCAT_LL, NUMCAT_LL, 1, 42258, 0, 42258}; -static const struct _convrule_ rule20={GENCAT_LL, NUMCAT_LL, 0, 0, 0, 0}; -static const struct _convrule_ rule76={GENCAT_LL, NUMCAT_LL, 1, 10743, 0, 10743}; -static const struct _convrule_ rule61={GENCAT_LL, NUMCAT_LL, 1, 10783, 0, 10783}; -static const struct _convrule_ rule37={GENCAT_LU, NUMCAT_LU, 1, 0, 211, 0}; -static const struct _convrule_ rule80={GENCAT_LL, NUMCAT_LL, 1, -214, 0, -214}; -static const struct _convrule_ rule75={GENCAT_LL, NUMCAT_LL, 1, -211, 0, -211}; -static const struct _convrule_ rule121={GENCAT_LL, NUMCAT_LL, 1, -48, 0, -48}; -static const struct _convrule_ rule52={GENCAT_LU, NUMCAT_LU, 1, 0, -56, 0}; -static const struct _convrule_ rule135={GENCAT_LL, NUMCAT_LL, 1, 112, 0, 112}; -static const struct _convrule_ rule71={GENCAT_LL, NUMCAT_LL, 1, -207, 0, -207}; -static const struct _convrule_ rule123={GENCAT_LU, NUMCAT_LU, 1, 0, 7264, 0}; -static const struct _convrule_ rule152={GENCAT_LU, NUMCAT_LU, 1, 0, 28, 0}; -static const struct _convrule_ rule159={GENCAT_LU, NUMCAT_LU, 1, 0, -3814, 0}; -static const struct _convrule_ rule45={GENCAT_LU, NUMCAT_LU, 1, 0, 219, 0}; -static const struct _convrule_ rule7={GENCAT_PD, NUMCAT_PD, 0, 0, 0, 0}; -static const struct _convrule_ rule180={GENCAT_LL, NUMCAT_LL, 1, -40, 0, -40}; -static const struct _convrule_ rule97={GENCAT_LL, NUMCAT_LL, 1, -38, 0, -38}; -static const struct _convrule_ rule95={GENCAT_LU, NUMCAT_LU, 1, 0, 64, 0}; -static const struct _convrule_ rule1={GENCAT_ZS, NUMCAT_ZS, 0, 0, 0, 0}; -static const struct _convrule_ rule29={GENCAT_LU, NUMCAT_LU, 1, 0, 210, 0}; -static const struct _convrule_ rule35={GENCAT_LU, NUMCAT_LU, 1, 0, 207, 0}; -static const struct _convrule_ rule154={GENCAT_NL, NUMCAT_NL, 1, 0, 16, 0}; -static const struct _convrule_ rule13={GENCAT_SO, NUMCAT_SO, 0, 0, 0, 0}; -static const struct _convrule_ rule149={GENCAT_LU, NUMCAT_LU, 1, 0, -7517, 0}; -static const struct _convrule_ rule128={GENCAT_LU, NUMCAT_LU, 1, 0, -7615, 0}; -static const struct _convrule_ rule98={GENCAT_LL, NUMCAT_LL, 1, -37, 0, -37}; -static const struct _convrule_ rule2={GENCAT_PO, NUMCAT_PO, 0, 0, 0, 0}; -static const struct _convrule_ rule69={GENCAT_LL, NUMCAT_LL, 1, 42319, 0, 42319}; -static const struct _convrule_ rule56={GENCAT_LU, NUMCAT_LU, 1, 0, 10792, 0}; -static const struct _convrule_ rule25={GENCAT_LL, NUMCAT_LL, 1, -232, 0, -232}; -static const struct _convrule_ rule43={GENCAT_LU, NUMCAT_LU, 1, 0, 218, 0}; -static const struct _convrule_ rule165={GENCAT_LU, NUMCAT_LU, 1, 0, -10783, 0}; -static const struct _convrule_ rule133={GENCAT_LL, NUMCAT_LL, 1, 100, 0, 100}; -static const struct _convrule_ rule96={GENCAT_LU, NUMCAT_LU, 1, 0, 63, 0}; -static const struct _convrule_ rule90={GENCAT_MN, NUMCAT_MN, 0, 0, 0, 0}; -static const struct _convrule_ rule12={GENCAT_LL, NUMCAT_LL, 1, -32, 0, -32}; -static const struct _convrule_ rule93={GENCAT_LU, NUMCAT_LU, 1, 0, 38, 0}; -static const struct _convrule_ rule99={GENCAT_LL, NUMCAT_LL, 1, -31, 0, -31}; -static const struct _convrule_ rule105={GENCAT_LU, NUMCAT_LU, 0, 0, 0, 0}; -static const struct _convrule_ rule11={GENCAT_PC, NUMCAT_PC, 0, 0, 0, 0}; -static const struct _convrule_ rule175={GENCAT_LU, NUMCAT_LU, 1, 0, -42258, 0}; -static const struct _convrule_ rule144={GENCAT_LU, NUMCAT_LU, 1, 0, -112, 0}; -static const struct _convrule_ rule15={GENCAT_PI, NUMCAT_PI, 0, 0, 0, 0}; -static const struct _convrule_ rule132={GENCAT_LL, NUMCAT_LL, 1, 86, 0, 86}; -static const struct _convrule_ rule122={GENCAT_MC, NUMCAT_MC, 0, 0, 0, 0}; -static const struct _convrule_ rule126={GENCAT_LL, NUMCAT_LL, 1, 3814, 0, 3814}; -static const struct _convrule_ rule44={GENCAT_LU, NUMCAT_LU, 1, 0, 217, 0}; -static const struct _convrule_ rule153={GENCAT_LL, NUMCAT_LL, 1, -28, 0, -28}; -static const struct _convrule_ rule178={GENCAT_CO, NUMCAT_CO, 0, 0, 0, 0}; -static const struct _convrule_ rule114={GENCAT_LL, NUMCAT_LL, 1, -96, 0, -96}; -static const struct _convrule_ rule51={GENCAT_LU, NUMCAT_LU, 1, 0, -97, 0}; -static const struct _convrule_ rule39={GENCAT_LL, NUMCAT_LL, 1, 163, 0, 163}; -static const struct _convrule_ rule179={GENCAT_LU, NUMCAT_LU, 1, 0, 40, 0}; -static const struct _convrule_ rule124={GENCAT_NL, NUMCAT_NL, 0, 0, 0, 0}; -static const struct _convrule_ rule94={GENCAT_LU, NUMCAT_LU, 1, 0, 37, 0}; -static const struct _convrule_ rule82={GENCAT_LL, NUMCAT_LL, 1, -218, 0, -218}; -static const struct _convrule_ rule118={GENCAT_LU, NUMCAT_LU, 1, 0, 15, 0}; -static const struct _convrule_ rule67={GENCAT_LL, NUMCAT_LL, 1, -202, 0, -202}; -static const struct _convrule_ rule66={GENCAT_LL, NUMCAT_LL, 1, -205, 0, -205}; -static const struct _convrule_ rule47={GENCAT_LU, NUMCAT_LU, 1, 0, 2, 1}; -static const struct _convrule_ rule30={GENCAT_LU, NUMCAT_LU, 1, 0, 206, 0}; -static const struct _convrule_ rule109={GENCAT_LL, NUMCAT_LL, 1, -86, 0, -86}; -static const struct _convrule_ rule4={GENCAT_PS, NUMCAT_PS, 0, 0, 0, 0}; -static const struct _convrule_ rule3={GENCAT_SC, NUMCAT_SC, 0, 0, 0, 0}; -static const struct _convrule_ rule150={GENCAT_LU, NUMCAT_LU, 1, 0, -8383, 0}; -static const struct _convrule_ rule120={GENCAT_LU, NUMCAT_LU, 1, 0, 48, 0}; -static const struct _convrule_ rule14={GENCAT_LO, NUMCAT_LO, 0, 0, 0, 0}; -static const struct _convrule_ rule18={GENCAT_LL, NUMCAT_LL, 1, 743, 0, 743}; -static const struct _convrule_ rule147={GENCAT_ZL, NUMCAT_ZL, 0, 0, 0, 0}; -static const struct _convrule_ rule142={GENCAT_LU, NUMCAT_LU, 1, 0, -86, 0}; -static const struct _convrule_ rule171={GENCAT_LU, NUMCAT_LU, 1, 0, -42308, 0}; -static const struct _convrule_ rule162={GENCAT_LL, NUMCAT_LL, 1, -10792, 0, -10792}; -static const struct _convrule_ rule166={GENCAT_LU, NUMCAT_LU, 1, 0, -10782, 0}; -static const struct _convrule_ rule139={GENCAT_LU, NUMCAT_LU, 1, 0, -74, 0}; -static const struct _convrule_ rule24={GENCAT_LU, NUMCAT_LU, 1, 0, -199, 0}; -static const struct _convrule_ rule143={GENCAT_LU, NUMCAT_LU, 1, 0, -100, 0}; -static const struct _convrule_ rule125={GENCAT_LL, NUMCAT_LL, 1, 35332, 0, 35332}; -static const struct _convrule_ rule141={GENCAT_LL, NUMCAT_LL, 1, -7205, 0, -7205}; -static const struct _convrule_ rule138={GENCAT_LL, NUMCAT_LL, 1, 9, 0, 9}; -static const struct _convrule_ rule27={GENCAT_LL, NUMCAT_LL, 1, -300, 0, -300}; -static const struct _convrule_ rule172={GENCAT_LU, NUMCAT_LU, 1, 0, -42319, 0}; -static const struct _convrule_ rule31={GENCAT_LU, NUMCAT_LU, 1, 0, 205, 0}; -static const struct _convrule_ rule59={GENCAT_LU, NUMCAT_LU, 1, 0, 69, 0}; -static const struct _convrule_ rule6={GENCAT_SM, NUMCAT_SM, 0, 0, 0, 0}; -static const struct _convrule_ rule119={GENCAT_LL, NUMCAT_LL, 1, -15, 0, -15}; -static const struct _convrule_ rule110={GENCAT_LL, NUMCAT_LL, 1, -80, 0, -80}; -static const struct _convrule_ rule176={GENCAT_LU, NUMCAT_LU, 1, 0, -42282, 0}; -static const struct _convrule_ rule151={GENCAT_LU, NUMCAT_LU, 1, 0, -8262, 0}; -static const struct _convrule_ rule130={GENCAT_LU, NUMCAT_LU, 1, 0, -8, 0}; -static const struct _convrule_ rule26={GENCAT_LU, NUMCAT_LU, 1, 0, -121, 0}; -static const struct _convrule_ rule0={GENCAT_CC, NUMCAT_CC, 0, 0, 0, 0}; -static const struct _convrule_ rule111={GENCAT_LL, NUMCAT_LL, 1, 7, 0, 7}; -static const struct _convrule_ rule91={GENCAT_MN, NUMCAT_MN, 1, 84, 0, 84}; -static const struct _convrule_ rule78={GENCAT_LL, NUMCAT_LL, 1, 10749, 0, 10749}; -static const struct _convrule_ rule77={GENCAT_LL, NUMCAT_LL, 1, 42305, 0, 42305}; -static const struct _convrule_ rule70={GENCAT_LL, NUMCAT_LL, 1, 42315, 0, 42315}; -static const struct _convrule_ rule50={GENCAT_LL, NUMCAT_LL, 1, -79, 0, -79}; -static const struct _convrule_ rule60={GENCAT_LU, NUMCAT_LU, 1, 0, 71, 0}; -static const struct _convrule_ rule22={GENCAT_LU, NUMCAT_LU, 1, 0, 1, 0}; -static const struct _convrule_ rule49={GENCAT_LL, NUMCAT_LL, 1, -2, 0, -1}; -static const struct _convrule_ rule92={GENCAT_LU, NUMCAT_LU, 1, 0, 116, 0}; -static const struct _convrule_ rule83={GENCAT_LL, NUMCAT_LL, 1, 42282, 0, 42282}; -static const struct _convrule_ rule155={GENCAT_NL, NUMCAT_NL, 1, -16, 0, -16}; -static const struct _convrule_ rule102={GENCAT_LU, NUMCAT_LU, 1, 0, 8, 0}; -static const struct _convrule_ rule23={GENCAT_LL, NUMCAT_LL, 1, -1, 0, -1}; -static const struct _convrule_ rule87={GENCAT_LL, NUMCAT_LL, 1, -219, 0, -219}; -static const struct _convrule_ rule79={GENCAT_LL, NUMCAT_LL, 1, -213, 0, -213}; -static const struct _convrule_ rule64={GENCAT_LL, NUMCAT_LL, 1, -210, 0, -210}; -static const struct _convrule_ rule163={GENCAT_LU, NUMCAT_LU, 1, 0, -10780, 0}; -static const struct _convrule_ rule86={GENCAT_LL, NUMCAT_LL, 1, -71, 0, -71}; -static const struct _convrule_ rule84={GENCAT_LL, NUMCAT_LL, 1, -69, 0, -69}; -static const struct _convrule_ rule32={GENCAT_LU, NUMCAT_LU, 1, 0, 79, 0}; -static const struct _convrule_ rule115={GENCAT_LU, NUMCAT_LU, 1, 0, -7, 0}; -static const struct _convrule_ rule74={GENCAT_LL, NUMCAT_LL, 1, -209, 0, -209}; -static const struct _convrule_ rule177={GENCAT_CS, NUMCAT_CS, 0, 0, 0, 0}; -static const struct _convrule_ rule140={GENCAT_LT, NUMCAT_LT, 1, 0, -9, 0}; -static const struct _convrule_ rule57={GENCAT_LL, NUMCAT_LL, 1, 10815, 0, 10815}; -static const struct _convrule_ rule72={GENCAT_LL, NUMCAT_LL, 1, 42280, 0, 42280}; -static const struct _convrule_ rule34={GENCAT_LU, NUMCAT_LU, 1, 0, 203, 0}; -static const struct _convrule_ rule63={GENCAT_LL, NUMCAT_LL, 1, 10782, 0, 10782}; -static const struct _convrule_ rule170={GENCAT_LU, NUMCAT_LU, 1, 0, -42280, 0}; -static const struct _convrule_ rule145={GENCAT_LU, NUMCAT_LU, 1, 0, -128, 0}; -static const struct _convrule_ rule100={GENCAT_LL, NUMCAT_LL, 1, -64, 0, -64}; -static const struct _convrule_ rule17={GENCAT_NO, NUMCAT_NO, 0, 0, 0, 0}; -static const struct _convrule_ rule89={GENCAT_LM, NUMCAT_LM, 0, 0, 0, 0}; -static const struct _convrule_ rule46={GENCAT_LL, NUMCAT_LL, 1, 56, 0, 56}; -static const struct _convrule_ rule131={GENCAT_LL, NUMCAT_LL, 1, 74, 0, 74}; -static const struct _convrule_ rule42={GENCAT_LU, NUMCAT_LU, 1, 0, 214, 0}; -static const struct _convrule_ rule148={GENCAT_ZP, NUMCAT_ZP, 0, 0, 0, 0}; -static const struct _convrule_ rule101={GENCAT_LL, NUMCAT_LL, 1, -63, 0, -63}; -static const struct _convrule_ rule36={GENCAT_LL, NUMCAT_LL, 1, 97, 0, 97}; -static const struct _convrule_ rule137={GENCAT_LT, NUMCAT_LT, 1, 0, -8, 0}; -static const struct _convrule_ rule134={GENCAT_LL, NUMCAT_LL, 1, 128, 0, 128}; -static const struct _convrule_ rule81={GENCAT_LL, NUMCAT_LL, 1, 10727, 0, 10727}; -static const struct _convrule_ rule62={GENCAT_LL, NUMCAT_LL, 1, 10780, 0, 10780}; -static const struct _convrule_ rule41={GENCAT_LL, NUMCAT_LL, 1, 130, 0, 130}; -static const struct _convrule_ rule68={GENCAT_LL, NUMCAT_LL, 1, -203, 0, -203}; -static const struct _convrule_ rule65={GENCAT_LL, NUMCAT_LL, 1, -206, 0, -206}; -static const struct _convrule_ rule48={GENCAT_LT, NUMCAT_LT, 1, -1, 1, 0}; -static const struct _convrule_ rule19={GENCAT_PF, NUMCAT_PF, 0, 0, 0, 0}; -static const struct _convrule_ rule33={GENCAT_LU, NUMCAT_LU, 1, 0, 202, 0}; -static const struct _convrule_ rule103={GENCAT_LL, NUMCAT_LL, 1, -62, 0, -62}; -static const struct _convrule_ rule8={GENCAT_ND, NUMCAT_ND, 0, 0, 0, 0}; -static const struct _convrule_ rule53={GENCAT_LU, NUMCAT_LU, 1, 0, -130, 0}; -static const struct _convrule_ rule28={GENCAT_LL, NUMCAT_LL, 1, 195, 0, 195}; -static const struct _convrule_ rule158={GENCAT_LU, NUMCAT_LU, 1, 0, -10743, 0}; -static const struct _convrule_ rule127={GENCAT_LL, NUMCAT_LL, 1, -59, 0, -59}; -static const struct _convrule_ rule113={GENCAT_LU, NUMCAT_LU, 1, 0, -60, 0}; -static const struct _convrule_ rule108={GENCAT_LL, NUMCAT_LL, 1, -8, 0, -8}; -static const struct _convrule_ rule73={GENCAT_LL, NUMCAT_LL, 1, 42308, 0, 42308}; -static const struct _convrule_ rule40={GENCAT_LU, NUMCAT_LU, 1, 0, 213, 0}; -static const struct _convrule_ rule136={GENCAT_LL, NUMCAT_LL, 1, 126, 0, 126}; -static const struct _convrule_ rule116={GENCAT_LU, NUMCAT_LU, 1, 0, 80, 0}; -static const struct _convrule_ rule55={GENCAT_LU, NUMCAT_LU, 1, 0, -163, 0}; -static const struct _convrule_ rule174={GENCAT_LU, NUMCAT_LU, 1, 0, -42305, 0}; -static const struct _convrule_ rule161={GENCAT_LL, NUMCAT_LL, 1, -10795, 0, -10795}; -static const struct _convrule_ rule58={GENCAT_LU, NUMCAT_LU, 1, 0, -195, 0}; -static const struct _convrule_ rule54={GENCAT_LU, NUMCAT_LU, 1, 0, 10795, 0}; -static const struct _convrule_ rule107={GENCAT_LL, NUMCAT_LL, 1, -54, 0, -54}; -static const struct _convrule_ rule146={GENCAT_LU, NUMCAT_LU, 1, 0, -126, 0}; -static const struct _convrule_ rule104={GENCAT_LL, NUMCAT_LL, 1, -57, 0, -57}; -static const struct _convrule_ rule21={GENCAT_LL, NUMCAT_LL, 1, 121, 0, 121}; -static const struct _convrule_ rule156={GENCAT_SO, NUMCAT_SO, 1, 0, 26, 0}; -static const struct _convrule_ rule85={GENCAT_LL, NUMCAT_LL, 1, -217, 0, -217}; -static const struct _convrule_ rule16={GENCAT_CF, NUMCAT_CF, 0, 0, 0, 0}; -static const struct _convrule_ rule112={GENCAT_LL, NUMCAT_LL, 1, -116, 0, -116}; -static const struct _convrule_ rule38={GENCAT_LU, NUMCAT_LU, 1, 0, 209, 0}; -static const struct _convrule_ rule10={GENCAT_SK, NUMCAT_SK, 0, 0, 0, 0}; -static const struct _convrule_ rule167={GENCAT_LU, NUMCAT_LU, 1, 0, -10815, 0}; -static const struct _convrule_ rule5={GENCAT_PE, NUMCAT_PE, 0, 0, 0, 0}; -static const struct _convrule_ rule164={GENCAT_LU, NUMCAT_LU, 1, 0, -10749, 0}; -static const struct _convrule_ rule117={GENCAT_ME, NUMCAT_ME, 0, 0, 0, 0}; -static const struct _convrule_ rule106={GENCAT_LL, NUMCAT_LL, 1, -47, 0, -47}; -static const struct _convrule_ rule160={GENCAT_LU, NUMCAT_LU, 1, 0, -10727, 0}; -static const struct _convrule_ rule9={GENCAT_LU, NUMCAT_LU, 1, 0, 32, 0}; -static const struct _charblock_ allchars[]={ - {0, 32, &rule0}, - {32, 1, &rule1}, - {33, 3, &rule2}, - {36, 1, &rule3}, - {37, 3, &rule2}, - {40, 1, &rule4}, - {41, 1, &rule5}, - {42, 1, &rule2}, - {43, 1, &rule6}, - {44, 1, &rule2}, - {45, 1, &rule7}, - {46, 2, &rule2}, - {48, 10, &rule8}, - {58, 2, &rule2}, - {60, 3, &rule6}, - {63, 2, &rule2}, - {65, 26, &rule9}, - {91, 1, &rule4}, - {92, 1, &rule2}, - {93, 1, &rule5}, - {94, 1, &rule10}, - {95, 1, &rule11}, - {96, 1, &rule10}, - {97, 26, &rule12}, - {123, 1, &rule4}, - {124, 1, &rule6}, - {125, 1, &rule5}, - {126, 1, &rule6}, - {127, 33, &rule0}, - {160, 1, &rule1}, - {161, 1, &rule2}, - {162, 4, &rule3}, - {166, 1, &rule13}, - {167, 1, &rule2}, - {168, 1, &rule10}, - {169, 1, &rule13}, - {170, 1, &rule14}, - {171, 1, &rule15}, - {172, 1, &rule6}, - {173, 1, &rule16}, - {174, 1, &rule13}, - {175, 1, &rule10}, - {176, 1, &rule13}, - {177, 1, &rule6}, - {178, 2, &rule17}, - {180, 1, &rule10}, - {181, 1, &rule18}, - {182, 2, &rule2}, - {184, 1, &rule10}, - {185, 1, &rule17}, - {186, 1, &rule14}, - {187, 1, &rule19}, - {188, 3, &rule17}, - {191, 1, &rule2}, - {192, 23, &rule9}, - {215, 1, &rule6}, - {216, 7, &rule9}, - {223, 1, &rule20}, - {224, 23, &rule12}, - {247, 1, &rule6}, - {248, 7, &rule12}, - {255, 1, &rule21}, - {256, 1, &rule22}, - {257, 1, &rule23}, - {258, 1, &rule22}, - {259, 1, &rule23}, - {260, 1, &rule22}, - {261, 1, &rule23}, - {262, 1, &rule22}, - {263, 1, &rule23}, - {264, 1, &rule22}, - {265, 1, &rule23}, - {266, 1, &rule22}, - {267, 1, &rule23}, - {268, 1, &rule22}, - {269, 1, &rule23}, - {270, 1, &rule22}, - {271, 1, &rule23}, - {272, 1, &rule22}, - {273, 1, &rule23}, - {274, 1, &rule22}, - {275, 1, &rule23}, - {276, 1, &rule22}, - {277, 1, &rule23}, - {278, 1, &rule22}, - {279, 1, &rule23}, - {280, 1, &rule22}, - {281, 1, &rule23}, - {282, 1, &rule22}, - {283, 1, &rule23}, - {284, 1, &rule22}, - {285, 1, &rule23}, - {286, 1, &rule22}, - {287, 1, &rule23}, - {288, 1, &rule22}, - {289, 1, &rule23}, - {290, 1, &rule22}, - {291, 1, &rule23}, - {292, 1, &rule22}, - {293, 1, &rule23}, - {294, 1, &rule22}, - {295, 1, &rule23}, - {296, 1, &rule22}, - {297, 1, &rule23}, - {298, 1, &rule22}, - {299, 1, &rule23}, - {300, 1, &rule22}, - {301, 1, &rule23}, - {302, 1, &rule22}, - {303, 1, &rule23}, - {304, 1, &rule24}, - {305, 1, &rule25}, - {306, 1, &rule22}, - {307, 1, &rule23}, - {308, 1, &rule22}, - {309, 1, &rule23}, - {310, 1, &rule22}, - {311, 1, &rule23}, - {312, 1, &rule20}, - {313, 1, &rule22}, - {314, 1, &rule23}, - {315, 1, &rule22}, - {316, 1, &rule23}, - {317, 1, &rule22}, - {318, 1, &rule23}, - {319, 1, &rule22}, - {320, 1, &rule23}, - {321, 1, &rule22}, - {322, 1, &rule23}, - {323, 1, &rule22}, - {324, 1, &rule23}, - {325, 1, &rule22}, - {326, 1, &rule23}, - {327, 1, &rule22}, - {328, 1, &rule23}, - {329, 1, &rule20}, - {330, 1, &rule22}, - {331, 1, &rule23}, - {332, 1, &rule22}, - {333, 1, &rule23}, - {334, 1, &rule22}, - {335, 1, &rule23}, - {336, 1, &rule22}, - {337, 1, &rule23}, - {338, 1, &rule22}, - {339, 1, &rule23}, - {340, 1, &rule22}, - {341, 1, &rule23}, - {342, 1, &rule22}, - {343, 1, &rule23}, - {344, 1, &rule22}, - {345, 1, &rule23}, - {346, 1, &rule22}, - {347, 1, &rule23}, - {348, 1, &rule22}, - {349, 1, &rule23}, - {350, 1, &rule22}, - {351, 1, &rule23}, - {352, 1, &rule22}, - {353, 1, &rule23}, - {354, 1, &rule22}, - {355, 1, &rule23}, - {356, 1, &rule22}, - {357, 1, &rule23}, - {358, 1, &rule22}, - {359, 1, &rule23}, - {360, 1, &rule22}, - {361, 1, &rule23}, - {362, 1, &rule22}, - {363, 1, &rule23}, - {364, 1, &rule22}, - {365, 1, &rule23}, - {366, 1, &rule22}, - {367, 1, &rule23}, - {368, 1, &rule22}, - {369, 1, &rule23}, - {370, 1, &rule22}, - {371, 1, &rule23}, - {372, 1, &rule22}, - {373, 1, &rule23}, - {374, 1, &rule22}, - {375, 1, &rule23}, - {376, 1, &rule26}, - {377, 1, &rule22}, - {378, 1, &rule23}, - {379, 1, &rule22}, - {380, 1, &rule23}, - {381, 1, &rule22}, - {382, 1, &rule23}, - {383, 1, &rule27}, - {384, 1, &rule28}, - {385, 1, &rule29}, - {386, 1, &rule22}, - {387, 1, &rule23}, - {388, 1, &rule22}, - {389, 1, &rule23}, - {390, 1, &rule30}, - {391, 1, &rule22}, - {392, 1, &rule23}, - {393, 2, &rule31}, - {395, 1, &rule22}, - {396, 1, &rule23}, - {397, 1, &rule20}, - {398, 1, &rule32}, - {399, 1, &rule33}, - {400, 1, &rule34}, - {401, 1, &rule22}, - {402, 1, &rule23}, - {403, 1, &rule31}, - {404, 1, &rule35}, - {405, 1, &rule36}, - {406, 1, &rule37}, - {407, 1, &rule38}, - {408, 1, &rule22}, - {409, 1, &rule23}, - {410, 1, &rule39}, - {411, 1, &rule20}, - {412, 1, &rule37}, - {413, 1, &rule40}, - {414, 1, &rule41}, - {415, 1, &rule42}, - {416, 1, &rule22}, - {417, 1, &rule23}, - {418, 1, &rule22}, - {419, 1, &rule23}, - {420, 1, &rule22}, - {421, 1, &rule23}, - {422, 1, &rule43}, - {423, 1, &rule22}, - {424, 1, &rule23}, - {425, 1, &rule43}, - {426, 2, &rule20}, - {428, 1, &rule22}, - {429, 1, &rule23}, - {430, 1, &rule43}, - {431, 1, &rule22}, - {432, 1, &rule23}, - {433, 2, &rule44}, - {435, 1, &rule22}, - {436, 1, &rule23}, - {437, 1, &rule22}, - {438, 1, &rule23}, - {439, 1, &rule45}, - {440, 1, &rule22}, - {441, 1, &rule23}, - {442, 1, &rule20}, - {443, 1, &rule14}, - {444, 1, &rule22}, - {445, 1, &rule23}, - {446, 1, &rule20}, - {447, 1, &rule46}, - {448, 4, &rule14}, - {452, 1, &rule47}, - {453, 1, &rule48}, - {454, 1, &rule49}, - {455, 1, &rule47}, - {456, 1, &rule48}, - {457, 1, &rule49}, - {458, 1, &rule47}, - {459, 1, &rule48}, - {460, 1, &rule49}, - {461, 1, &rule22}, - {462, 1, &rule23}, - {463, 1, &rule22}, - {464, 1, &rule23}, - {465, 1, &rule22}, - {466, 1, &rule23}, - {467, 1, &rule22}, - {468, 1, &rule23}, - {469, 1, &rule22}, - {470, 1, &rule23}, - {471, 1, &rule22}, - {472, 1, &rule23}, - {473, 1, &rule22}, - {474, 1, &rule23}, - {475, 1, &rule22}, - {476, 1, &rule23}, - {477, 1, &rule50}, - {478, 1, &rule22}, - {479, 1, &rule23}, - {480, 1, &rule22}, - {481, 1, &rule23}, - {482, 1, &rule22}, - {483, 1, &rule23}, - {484, 1, &rule22}, - {485, 1, &rule23}, - {486, 1, &rule22}, - {487, 1, &rule23}, - {488, 1, &rule22}, - {489, 1, &rule23}, - {490, 1, &rule22}, - {491, 1, &rule23}, - {492, 1, &rule22}, - {493, 1, &rule23}, - {494, 1, &rule22}, - {495, 1, &rule23}, - {496, 1, &rule20}, - {497, 1, &rule47}, - {498, 1, &rule48}, - {499, 1, &rule49}, - {500, 1, &rule22}, - {501, 1, &rule23}, - {502, 1, &rule51}, - {503, 1, &rule52}, - {504, 1, &rule22}, - {505, 1, &rule23}, - {506, 1, &rule22}, - {507, 1, &rule23}, - {508, 1, &rule22}, - {509, 1, &rule23}, - {510, 1, &rule22}, - {511, 1, &rule23}, - {512, 1, &rule22}, - {513, 1, &rule23}, - {514, 1, &rule22}, - {515, 1, &rule23}, - {516, 1, &rule22}, - {517, 1, &rule23}, - {518, 1, &rule22}, - {519, 1, &rule23}, - {520, 1, &rule22}, - {521, 1, &rule23}, - {522, 1, &rule22}, - {523, 1, &rule23}, - {524, 1, &rule22}, - {525, 1, &rule23}, - {526, 1, &rule22}, - {527, 1, &rule23}, - {528, 1, &rule22}, - {529, 1, &rule23}, - {530, 1, &rule22}, - {531, 1, &rule23}, - {532, 1, &rule22}, - {533, 1, &rule23}, - {534, 1, &rule22}, - {535, 1, &rule23}, - {536, 1, &rule22}, - {537, 1, &rule23}, - {538, 1, &rule22}, - {539, 1, &rule23}, - {540, 1, &rule22}, - {541, 1, &rule23}, - {542, 1, &rule22}, - {543, 1, &rule23}, - {544, 1, &rule53}, - {545, 1, &rule20}, - {546, 1, &rule22}, - {547, 1, &rule23}, - {548, 1, &rule22}, - {549, 1, &rule23}, - {550, 1, &rule22}, - {551, 1, &rule23}, - {552, 1, &rule22}, - {553, 1, &rule23}, - {554, 1, &rule22}, - {555, 1, &rule23}, - {556, 1, &rule22}, - {557, 1, &rule23}, - {558, 1, &rule22}, - {559, 1, &rule23}, - {560, 1, &rule22}, - {561, 1, &rule23}, - {562, 1, &rule22}, - {563, 1, &rule23}, - {564, 6, &rule20}, - {570, 1, &rule54}, - {571, 1, &rule22}, - {572, 1, &rule23}, - {573, 1, &rule55}, - {574, 1, &rule56}, - {575, 2, &rule57}, - {577, 1, &rule22}, - {578, 1, &rule23}, - {579, 1, &rule58}, - {580, 1, &rule59}, - {581, 1, &rule60}, - {582, 1, &rule22}, - {583, 1, &rule23}, - {584, 1, &rule22}, - {585, 1, &rule23}, - {586, 1, &rule22}, - {587, 1, &rule23}, - {588, 1, &rule22}, - {589, 1, &rule23}, - {590, 1, &rule22}, - {591, 1, &rule23}, - {592, 1, &rule61}, - {593, 1, &rule62}, - {594, 1, &rule63}, - {595, 1, &rule64}, - {596, 1, &rule65}, - {597, 1, &rule20}, - {598, 2, &rule66}, - {600, 1, &rule20}, - {601, 1, &rule67}, - {602, 1, &rule20}, - {603, 1, &rule68}, - {604, 1, &rule69}, - {605, 3, &rule20}, - {608, 1, &rule66}, - {609, 1, &rule70}, - {610, 1, &rule20}, - {611, 1, &rule71}, - {612, 1, &rule20}, - {613, 1, &rule72}, - {614, 1, &rule73}, - {615, 1, &rule20}, - {616, 1, &rule74}, - {617, 1, &rule75}, - {618, 1, &rule20}, - {619, 1, &rule76}, - {620, 1, &rule77}, - {621, 2, &rule20}, - {623, 1, &rule75}, - {624, 1, &rule20}, - {625, 1, &rule78}, - {626, 1, &rule79}, - {627, 2, &rule20}, - {629, 1, &rule80}, - {630, 7, &rule20}, - {637, 1, &rule81}, - {638, 2, &rule20}, - {640, 1, &rule82}, - {641, 2, &rule20}, - {643, 1, &rule82}, - {644, 3, &rule20}, - {647, 1, &rule83}, - {648, 1, &rule82}, - {649, 1, &rule84}, - {650, 2, &rule85}, - {652, 1, &rule86}, - {653, 5, &rule20}, - {658, 1, &rule87}, - {659, 1, &rule20}, - {660, 1, &rule14}, - {661, 9, &rule20}, - {670, 1, &rule88}, - {671, 17, &rule20}, - {688, 18, &rule89}, - {706, 4, &rule10}, - {710, 12, &rule89}, - {722, 14, &rule10}, - {736, 5, &rule89}, - {741, 7, &rule10}, - {748, 1, &rule89}, - {749, 1, &rule10}, - {750, 1, &rule89}, - {751, 17, &rule10}, - {768, 69, &rule90}, - {837, 1, &rule91}, - {838, 42, &rule90}, - {880, 1, &rule22}, - {881, 1, &rule23}, - {882, 1, &rule22}, - {883, 1, &rule23}, - {884, 1, &rule89}, - {885, 1, &rule10}, - {886, 1, &rule22}, - {887, 1, &rule23}, - {890, 1, &rule89}, - {891, 3, &rule41}, - {894, 1, &rule2}, - {895, 1, &rule92}, - {900, 2, &rule10}, - {902, 1, &rule93}, - {903, 1, &rule2}, - {904, 3, &rule94}, - {908, 1, &rule95}, - {910, 2, &rule96}, - {912, 1, &rule20}, - {913, 17, &rule9}, - {931, 9, &rule9}, - {940, 1, &rule97}, - {941, 3, &rule98}, - {944, 1, &rule20}, - {945, 17, &rule12}, - {962, 1, &rule99}, - {963, 9, &rule12}, - {972, 1, &rule100}, - {973, 2, &rule101}, - {975, 1, &rule102}, - {976, 1, &rule103}, - {977, 1, &rule104}, - {978, 3, &rule105}, - {981, 1, &rule106}, - {982, 1, &rule107}, - {983, 1, &rule108}, - {984, 1, &rule22}, - {985, 1, &rule23}, - {986, 1, &rule22}, - {987, 1, &rule23}, - {988, 1, &rule22}, - {989, 1, &rule23}, - {990, 1, &rule22}, - {991, 1, &rule23}, - {992, 1, &rule22}, - {993, 1, &rule23}, - {994, 1, &rule22}, - {995, 1, &rule23}, - {996, 1, &rule22}, - {997, 1, &rule23}, - {998, 1, &rule22}, - {999, 1, &rule23}, - {1000, 1, &rule22}, - {1001, 1, &rule23}, - {1002, 1, &rule22}, - {1003, 1, &rule23}, - {1004, 1, &rule22}, - {1005, 1, &rule23}, - {1006, 1, &rule22}, - {1007, 1, &rule23}, - {1008, 1, &rule109}, - {1009, 1, &rule110}, - {1010, 1, &rule111}, - {1011, 1, &rule112}, - {1012, 1, &rule113}, - {1013, 1, &rule114}, - {1014, 1, &rule6}, - {1015, 1, &rule22}, - {1016, 1, &rule23}, - {1017, 1, &rule115}, - {1018, 1, &rule22}, - {1019, 1, &rule23}, - {1020, 1, &rule20}, - {1021, 3, &rule53}, - {1024, 16, &rule116}, - {1040, 32, &rule9}, - {1072, 32, &rule12}, - {1104, 16, &rule110}, - {1120, 1, &rule22}, - {1121, 1, &rule23}, - {1122, 1, &rule22}, - {1123, 1, &rule23}, - {1124, 1, &rule22}, - {1125, 1, &rule23}, - {1126, 1, &rule22}, - {1127, 1, &rule23}, - {1128, 1, &rule22}, - {1129, 1, &rule23}, - {1130, 1, &rule22}, - {1131, 1, &rule23}, - {1132, 1, &rule22}, - {1133, 1, &rule23}, - {1134, 1, &rule22}, - {1135, 1, &rule23}, - {1136, 1, &rule22}, - {1137, 1, &rule23}, - {1138, 1, &rule22}, - {1139, 1, &rule23}, - {1140, 1, &rule22}, - {1141, 1, &rule23}, - {1142, 1, &rule22}, - {1143, 1, &rule23}, - {1144, 1, &rule22}, - {1145, 1, &rule23}, - {1146, 1, &rule22}, - {1147, 1, &rule23}, - {1148, 1, &rule22}, - {1149, 1, &rule23}, - {1150, 1, &rule22}, - {1151, 1, &rule23}, - {1152, 1, &rule22}, - {1153, 1, &rule23}, - {1154, 1, &rule13}, - {1155, 5, &rule90}, - {1160, 2, &rule117}, - {1162, 1, &rule22}, - {1163, 1, &rule23}, - {1164, 1, &rule22}, - {1165, 1, &rule23}, - {1166, 1, &rule22}, - {1167, 1, &rule23}, - {1168, 1, &rule22}, - {1169, 1, &rule23}, - {1170, 1, &rule22}, - {1171, 1, &rule23}, - {1172, 1, &rule22}, - {1173, 1, &rule23}, - {1174, 1, &rule22}, - {1175, 1, &rule23}, - {1176, 1, &rule22}, - {1177, 1, &rule23}, - {1178, 1, &rule22}, - {1179, 1, &rule23}, - {1180, 1, &rule22}, - {1181, 1, &rule23}, - {1182, 1, &rule22}, - {1183, 1, &rule23}, - {1184, 1, &rule22}, - {1185, 1, &rule23}, - {1186, 1, &rule22}, - {1187, 1, &rule23}, - {1188, 1, &rule22}, - {1189, 1, &rule23}, - {1190, 1, &rule22}, - {1191, 1, &rule23}, - {1192, 1, &rule22}, - {1193, 1, &rule23}, - {1194, 1, &rule22}, - {1195, 1, &rule23}, - {1196, 1, &rule22}, - {1197, 1, &rule23}, - {1198, 1, &rule22}, - {1199, 1, &rule23}, - {1200, 1, &rule22}, - {1201, 1, &rule23}, - {1202, 1, &rule22}, - {1203, 1, &rule23}, - {1204, 1, &rule22}, - {1205, 1, &rule23}, - {1206, 1, &rule22}, - {1207, 1, &rule23}, - {1208, 1, &rule22}, - {1209, 1, &rule23}, - {1210, 1, &rule22}, - {1211, 1, &rule23}, - {1212, 1, &rule22}, - {1213, 1, &rule23}, - {1214, 1, &rule22}, - {1215, 1, &rule23}, - {1216, 1, &rule118}, - {1217, 1, &rule22}, - {1218, 1, &rule23}, - {1219, 1, &rule22}, - {1220, 1, &rule23}, - {1221, 1, &rule22}, - {1222, 1, &rule23}, - {1223, 1, &rule22}, - {1224, 1, &rule23}, - {1225, 1, &rule22}, - {1226, 1, &rule23}, - {1227, 1, &rule22}, - {1228, 1, &rule23}, - {1229, 1, &rule22}, - {1230, 1, &rule23}, - {1231, 1, &rule119}, - {1232, 1, &rule22}, - {1233, 1, &rule23}, - {1234, 1, &rule22}, - {1235, 1, &rule23}, - {1236, 1, &rule22}, - {1237, 1, &rule23}, - {1238, 1, &rule22}, - {1239, 1, &rule23}, - {1240, 1, &rule22}, - {1241, 1, &rule23}, - {1242, 1, &rule22}, - {1243, 1, &rule23}, - {1244, 1, &rule22}, - {1245, 1, &rule23}, - {1246, 1, &rule22}, - {1247, 1, &rule23}, - {1248, 1, &rule22}, - {1249, 1, &rule23}, - {1250, 1, &rule22}, - {1251, 1, &rule23}, - {1252, 1, &rule22}, - {1253, 1, &rule23}, - {1254, 1, &rule22}, - {1255, 1, &rule23}, - {1256, 1, &rule22}, - {1257, 1, &rule23}, - {1258, 1, &rule22}, - {1259, 1, &rule23}, - {1260, 1, &rule22}, - {1261, 1, &rule23}, - {1262, 1, &rule22}, - {1263, 1, &rule23}, - {1264, 1, &rule22}, - {1265, 1, &rule23}, - {1266, 1, &rule22}, - {1267, 1, &rule23}, - {1268, 1, &rule22}, - {1269, 1, &rule23}, - {1270, 1, &rule22}, - {1271, 1, &rule23}, - {1272, 1, &rule22}, - {1273, 1, &rule23}, - {1274, 1, &rule22}, - {1275, 1, &rule23}, - {1276, 1, &rule22}, - {1277, 1, &rule23}, - {1278, 1, &rule22}, - {1279, 1, &rule23}, - {1280, 1, &rule22}, - {1281, 1, &rule23}, - {1282, 1, &rule22}, - {1283, 1, &rule23}, - {1284, 1, &rule22}, - {1285, 1, &rule23}, - {1286, 1, &rule22}, - {1287, 1, &rule23}, - {1288, 1, &rule22}, - {1289, 1, &rule23}, - {1290, 1, &rule22}, - {1291, 1, &rule23}, - {1292, 1, &rule22}, - {1293, 1, &rule23}, - {1294, 1, &rule22}, - {1295, 1, &rule23}, - {1296, 1, &rule22}, - {1297, 1, &rule23}, - {1298, 1, &rule22}, - {1299, 1, &rule23}, - {1300, 1, &rule22}, - {1301, 1, &rule23}, - {1302, 1, &rule22}, - {1303, 1, &rule23}, - {1304, 1, &rule22}, - {1305, 1, &rule23}, - {1306, 1, &rule22}, - {1307, 1, &rule23}, - {1308, 1, &rule22}, - {1309, 1, &rule23}, - {1310, 1, &rule22}, - {1311, 1, &rule23}, - {1312, 1, &rule22}, - {1313, 1, &rule23}, - {1314, 1, &rule22}, - {1315, 1, &rule23}, - {1316, 1, &rule22}, - {1317, 1, &rule23}, - {1318, 1, &rule22}, - {1319, 1, &rule23}, - {1320, 1, &rule22}, - {1321, 1, &rule23}, - {1322, 1, &rule22}, - {1323, 1, &rule23}, - {1324, 1, &rule22}, - {1325, 1, &rule23}, - {1326, 1, &rule22}, - {1327, 1, &rule23}, - {1329, 38, &rule120}, - {1369, 1, &rule89}, - {1370, 6, &rule2}, - {1377, 38, &rule121}, - {1415, 1, &rule20}, - {1417, 1, &rule2}, - {1418, 1, &rule7}, - {1421, 2, &rule13}, - {1423, 1, &rule3}, - {1425, 45, &rule90}, - {1470, 1, &rule7}, - {1471, 1, &rule90}, - {1472, 1, &rule2}, - {1473, 2, &rule90}, - {1475, 1, &rule2}, - {1476, 2, &rule90}, - {1478, 1, &rule2}, - {1479, 1, &rule90}, - {1488, 27, &rule14}, - {1520, 3, &rule14}, - {1523, 2, &rule2}, - {1536, 6, &rule16}, - {1542, 3, &rule6}, - {1545, 2, &rule2}, - {1547, 1, &rule3}, - {1548, 2, &rule2}, - {1550, 2, &rule13}, - {1552, 11, &rule90}, - {1563, 1, &rule2}, - {1564, 1, &rule16}, - {1566, 2, &rule2}, - {1568, 32, &rule14}, - {1600, 1, &rule89}, - {1601, 10, &rule14}, - {1611, 21, &rule90}, - {1632, 10, &rule8}, - {1642, 4, &rule2}, - {1646, 2, &rule14}, - {1648, 1, &rule90}, - {1649, 99, &rule14}, - {1748, 1, &rule2}, - {1749, 1, &rule14}, - {1750, 7, &rule90}, - {1757, 1, &rule16}, - {1758, 1, &rule13}, - {1759, 6, &rule90}, - {1765, 2, &rule89}, - {1767, 2, &rule90}, - {1769, 1, &rule13}, - {1770, 4, &rule90}, - {1774, 2, &rule14}, - {1776, 10, &rule8}, - {1786, 3, &rule14}, - {1789, 2, &rule13}, - {1791, 1, &rule14}, - {1792, 14, &rule2}, - {1807, 1, &rule16}, - {1808, 1, &rule14}, - {1809, 1, &rule90}, - {1810, 30, &rule14}, - {1840, 27, &rule90}, - {1869, 89, &rule14}, - {1958, 11, &rule90}, - {1969, 1, &rule14}, - {1984, 10, &rule8}, - {1994, 33, &rule14}, - {2027, 9, &rule90}, - {2036, 2, &rule89}, - {2038, 1, &rule13}, - {2039, 3, &rule2}, - {2042, 1, &rule89}, - {2048, 22, &rule14}, - {2070, 4, &rule90}, - {2074, 1, &rule89}, - {2075, 9, &rule90}, - {2084, 1, &rule89}, - {2085, 3, &rule90}, - {2088, 1, &rule89}, - {2089, 5, &rule90}, - {2096, 15, &rule2}, - {2112, 25, &rule14}, - {2137, 3, &rule90}, - {2142, 1, &rule2}, - {2208, 19, &rule14}, - {2276, 31, &rule90}, - {2307, 1, &rule122}, - {2308, 54, &rule14}, - {2362, 1, &rule90}, - {2363, 1, &rule122}, - {2364, 1, &rule90}, - {2365, 1, &rule14}, - {2366, 3, &rule122}, - {2369, 8, &rule90}, - {2377, 4, &rule122}, - {2381, 1, &rule90}, - {2382, 2, &rule122}, - {2384, 1, &rule14}, - {2385, 7, &rule90}, - {2392, 10, &rule14}, - {2402, 2, &rule90}, - {2404, 2, &rule2}, - {2406, 10, &rule8}, - {2416, 1, &rule2}, - {2417, 1, &rule89}, - {2418, 15, &rule14}, - {2433, 1, &rule90}, - {2434, 2, &rule122}, - {2437, 8, &rule14}, - {2447, 2, &rule14}, - {2451, 22, &rule14}, - {2474, 7, &rule14}, - {2482, 1, &rule14}, - {2486, 4, &rule14}, - {2492, 1, &rule90}, - {2493, 1, &rule14}, - {2494, 3, &rule122}, - {2497, 4, &rule90}, - {2503, 2, &rule122}, - {2507, 2, &rule122}, - {2509, 1, &rule90}, - {2510, 1, &rule14}, - {2519, 1, &rule122}, - {2524, 2, &rule14}, - {2527, 3, &rule14}, - {2530, 2, &rule90}, - {2534, 10, &rule8}, - {2544, 2, &rule14}, - {2546, 2, &rule3}, - {2548, 6, &rule17}, - {2554, 1, &rule13}, - {2555, 1, &rule3}, - {2561, 2, &rule90}, - {2563, 1, &rule122}, - {2565, 6, &rule14}, - {2575, 2, &rule14}, - {2579, 22, &rule14}, - {2602, 7, &rule14}, - {2610, 2, &rule14}, - {2613, 2, &rule14}, - {2616, 2, &rule14}, - {2620, 1, &rule90}, - {2622, 3, &rule122}, - {2625, 2, &rule90}, - {2631, 2, &rule90}, - {2635, 3, &rule90}, - {2641, 1, &rule90}, - {2649, 4, &rule14}, - {2654, 1, &rule14}, - {2662, 10, &rule8}, - {2672, 2, &rule90}, - {2674, 3, &rule14}, - {2677, 1, &rule90}, - {2689, 2, &rule90}, - {2691, 1, &rule122}, - {2693, 9, &rule14}, - {2703, 3, &rule14}, - {2707, 22, &rule14}, - {2730, 7, &rule14}, - {2738, 2, &rule14}, - {2741, 5, &rule14}, - {2748, 1, &rule90}, - {2749, 1, &rule14}, - {2750, 3, &rule122}, - {2753, 5, &rule90}, - {2759, 2, &rule90}, - {2761, 1, &rule122}, - {2763, 2, &rule122}, - {2765, 1, &rule90}, - {2768, 1, &rule14}, - {2784, 2, &rule14}, - {2786, 2, &rule90}, - {2790, 10, &rule8}, - {2800, 1, &rule2}, - {2801, 1, &rule3}, - {2817, 1, &rule90}, - {2818, 2, &rule122}, - {2821, 8, &rule14}, - {2831, 2, &rule14}, - {2835, 22, &rule14}, - {2858, 7, &rule14}, - {2866, 2, &rule14}, - {2869, 5, &rule14}, - {2876, 1, &rule90}, - {2877, 1, &rule14}, - {2878, 1, &rule122}, - {2879, 1, &rule90}, - {2880, 1, &rule122}, - {2881, 4, &rule90}, - {2887, 2, &rule122}, - {2891, 2, &rule122}, - {2893, 1, &rule90}, - {2902, 1, &rule90}, - {2903, 1, &rule122}, - {2908, 2, &rule14}, - {2911, 3, &rule14}, - {2914, 2, &rule90}, - {2918, 10, &rule8}, - {2928, 1, &rule13}, - {2929, 1, &rule14}, - {2930, 6, &rule17}, - {2946, 1, &rule90}, - {2947, 1, &rule14}, - {2949, 6, &rule14}, - {2958, 3, &rule14}, - {2962, 4, &rule14}, - {2969, 2, &rule14}, - {2972, 1, &rule14}, - {2974, 2, &rule14}, - {2979, 2, &rule14}, - {2984, 3, &rule14}, - {2990, 12, &rule14}, - {3006, 2, &rule122}, - {3008, 1, &rule90}, - {3009, 2, &rule122}, - {3014, 3, &rule122}, - {3018, 3, &rule122}, - {3021, 1, &rule90}, - {3024, 1, &rule14}, - {3031, 1, &rule122}, - {3046, 10, &rule8}, - {3056, 3, &rule17}, - {3059, 6, &rule13}, - {3065, 1, &rule3}, - {3066, 1, &rule13}, - {3072, 1, &rule90}, - {3073, 3, &rule122}, - {3077, 8, &rule14}, - {3086, 3, &rule14}, - {3090, 23, &rule14}, - {3114, 16, &rule14}, - {3133, 1, &rule14}, - {3134, 3, &rule90}, - {3137, 4, &rule122}, - {3142, 3, &rule90}, - {3146, 4, &rule90}, - {3157, 2, &rule90}, - {3160, 2, &rule14}, - {3168, 2, &rule14}, - {3170, 2, &rule90}, - {3174, 10, &rule8}, - {3192, 7, &rule17}, - {3199, 1, &rule13}, - {3201, 1, &rule90}, - {3202, 2, &rule122}, - {3205, 8, &rule14}, - {3214, 3, &rule14}, - {3218, 23, &rule14}, - {3242, 10, &rule14}, - {3253, 5, &rule14}, - {3260, 1, &rule90}, - {3261, 1, &rule14}, - {3262, 1, &rule122}, - {3263, 1, &rule90}, - {3264, 5, &rule122}, - {3270, 1, &rule90}, - {3271, 2, &rule122}, - {3274, 2, &rule122}, - {3276, 2, &rule90}, - {3285, 2, &rule122}, - {3294, 1, &rule14}, - {3296, 2, &rule14}, - {3298, 2, &rule90}, - {3302, 10, &rule8}, - {3313, 2, &rule14}, - {3329, 1, &rule90}, - {3330, 2, &rule122}, - {3333, 8, &rule14}, - {3342, 3, &rule14}, - {3346, 41, &rule14}, - {3389, 1, &rule14}, - {3390, 3, &rule122}, - {3393, 4, &rule90}, - {3398, 3, &rule122}, - {3402, 3, &rule122}, - {3405, 1, &rule90}, - {3406, 1, &rule14}, - {3415, 1, &rule122}, - {3424, 2, &rule14}, - {3426, 2, &rule90}, - {3430, 10, &rule8}, - {3440, 6, &rule17}, - {3449, 1, &rule13}, - {3450, 6, &rule14}, - {3458, 2, &rule122}, - {3461, 18, &rule14}, - {3482, 24, &rule14}, - {3507, 9, &rule14}, - {3517, 1, &rule14}, - {3520, 7, &rule14}, - {3530, 1, &rule90}, - {3535, 3, &rule122}, - {3538, 3, &rule90}, - {3542, 1, &rule90}, - {3544, 8, &rule122}, - {3558, 10, &rule8}, - {3570, 2, &rule122}, - {3572, 1, &rule2}, - {3585, 48, &rule14}, - {3633, 1, &rule90}, - {3634, 2, &rule14}, - {3636, 7, &rule90}, - {3647, 1, &rule3}, - {3648, 6, &rule14}, - {3654, 1, &rule89}, - {3655, 8, &rule90}, - {3663, 1, &rule2}, - {3664, 10, &rule8}, - {3674, 2, &rule2}, - {3713, 2, &rule14}, - {3716, 1, &rule14}, - {3719, 2, &rule14}, - {3722, 1, &rule14}, - {3725, 1, &rule14}, - {3732, 4, &rule14}, - {3737, 7, &rule14}, - {3745, 3, &rule14}, - {3749, 1, &rule14}, - {3751, 1, &rule14}, - {3754, 2, &rule14}, - {3757, 4, &rule14}, - {3761, 1, &rule90}, - {3762, 2, &rule14}, - {3764, 6, &rule90}, - {3771, 2, &rule90}, - {3773, 1, &rule14}, - {3776, 5, &rule14}, - {3782, 1, &rule89}, - {3784, 6, &rule90}, - {3792, 10, &rule8}, - {3804, 4, &rule14}, - {3840, 1, &rule14}, - {3841, 3, &rule13}, - {3844, 15, &rule2}, - {3859, 1, &rule13}, - {3860, 1, &rule2}, - {3861, 3, &rule13}, - {3864, 2, &rule90}, - {3866, 6, &rule13}, - {3872, 10, &rule8}, - {3882, 10, &rule17}, - {3892, 1, &rule13}, - {3893, 1, &rule90}, - {3894, 1, &rule13}, - {3895, 1, &rule90}, - {3896, 1, &rule13}, - {3897, 1, &rule90}, - {3898, 1, &rule4}, - {3899, 1, &rule5}, - {3900, 1, &rule4}, - {3901, 1, &rule5}, - {3902, 2, &rule122}, - {3904, 8, &rule14}, - {3913, 36, &rule14}, - {3953, 14, &rule90}, - {3967, 1, &rule122}, - {3968, 5, &rule90}, - {3973, 1, &rule2}, - {3974, 2, &rule90}, - {3976, 5, &rule14}, - {3981, 11, &rule90}, - {3993, 36, &rule90}, - {4030, 8, &rule13}, - {4038, 1, &rule90}, - {4039, 6, &rule13}, - {4046, 2, &rule13}, - {4048, 5, &rule2}, - {4053, 4, &rule13}, - {4057, 2, &rule2}, - {4096, 43, &rule14}, - {4139, 2, &rule122}, - {4141, 4, &rule90}, - {4145, 1, &rule122}, - {4146, 6, &rule90}, - {4152, 1, &rule122}, - {4153, 2, &rule90}, - {4155, 2, &rule122}, - {4157, 2, &rule90}, - {4159, 1, &rule14}, - {4160, 10, &rule8}, - {4170, 6, &rule2}, - {4176, 6, &rule14}, - {4182, 2, &rule122}, - {4184, 2, &rule90}, - {4186, 4, &rule14}, - {4190, 3, &rule90}, - {4193, 1, &rule14}, - {4194, 3, &rule122}, - {4197, 2, &rule14}, - {4199, 7, &rule122}, - {4206, 3, &rule14}, - {4209, 4, &rule90}, - {4213, 13, &rule14}, - {4226, 1, &rule90}, - {4227, 2, &rule122}, - {4229, 2, &rule90}, - {4231, 6, &rule122}, - {4237, 1, &rule90}, - {4238, 1, &rule14}, - {4239, 1, &rule122}, - {4240, 10, &rule8}, - {4250, 3, &rule122}, - {4253, 1, &rule90}, - {4254, 2, &rule13}, - {4256, 38, &rule123}, - {4295, 1, &rule123}, - {4301, 1, &rule123}, - {4304, 43, &rule14}, - {4347, 1, &rule2}, - {4348, 1, &rule89}, - {4349, 332, &rule14}, - {4682, 4, &rule14}, - {4688, 7, &rule14}, - {4696, 1, &rule14}, - {4698, 4, &rule14}, - {4704, 41, &rule14}, - {4746, 4, &rule14}, - {4752, 33, &rule14}, - {4786, 4, &rule14}, - {4792, 7, &rule14}, - {4800, 1, &rule14}, - {4802, 4, &rule14}, - {4808, 15, &rule14}, - {4824, 57, &rule14}, - {4882, 4, &rule14}, - {4888, 67, &rule14}, - {4957, 3, &rule90}, - {4960, 9, &rule2}, - {4969, 20, &rule17}, - {4992, 16, &rule14}, - {5008, 10, &rule13}, - {5024, 85, &rule14}, - {5120, 1, &rule7}, - {5121, 620, &rule14}, - {5741, 2, &rule2}, - {5743, 17, &rule14}, - {5760, 1, &rule1}, - {5761, 26, &rule14}, - {5787, 1, &rule4}, - {5788, 1, &rule5}, - {5792, 75, &rule14}, - {5867, 3, &rule2}, - {5870, 3, &rule124}, - {5873, 8, &rule14}, - {5888, 13, &rule14}, - {5902, 4, &rule14}, - {5906, 3, &rule90}, - {5920, 18, &rule14}, - {5938, 3, &rule90}, - {5941, 2, &rule2}, - {5952, 18, &rule14}, - {5970, 2, &rule90}, - {5984, 13, &rule14}, - {5998, 3, &rule14}, - {6002, 2, &rule90}, - {6016, 52, &rule14}, - {6068, 2, &rule90}, - {6070, 1, &rule122}, - {6071, 7, &rule90}, - {6078, 8, &rule122}, - {6086, 1, &rule90}, - {6087, 2, &rule122}, - {6089, 11, &rule90}, - {6100, 3, &rule2}, - {6103, 1, &rule89}, - {6104, 3, &rule2}, - {6107, 1, &rule3}, - {6108, 1, &rule14}, - {6109, 1, &rule90}, - {6112, 10, &rule8}, - {6128, 10, &rule17}, - {6144, 6, &rule2}, - {6150, 1, &rule7}, - {6151, 4, &rule2}, - {6155, 3, &rule90}, - {6158, 1, &rule16}, - {6160, 10, &rule8}, - {6176, 35, &rule14}, - {6211, 1, &rule89}, - {6212, 52, &rule14}, - {6272, 41, &rule14}, - {6313, 1, &rule90}, - {6314, 1, &rule14}, - {6320, 70, &rule14}, - {6400, 31, &rule14}, - {6432, 3, &rule90}, - {6435, 4, &rule122}, - {6439, 2, &rule90}, - {6441, 3, &rule122}, - {6448, 2, &rule122}, - {6450, 1, &rule90}, - {6451, 6, &rule122}, - {6457, 3, &rule90}, - {6464, 1, &rule13}, - {6468, 2, &rule2}, - {6470, 10, &rule8}, - {6480, 30, &rule14}, - {6512, 5, &rule14}, - {6528, 44, &rule14}, - {6576, 17, &rule122}, - {6593, 7, &rule14}, - {6600, 2, &rule122}, - {6608, 10, &rule8}, - {6618, 1, &rule17}, - {6622, 34, &rule13}, - {6656, 23, &rule14}, - {6679, 2, &rule90}, - {6681, 2, &rule122}, - {6683, 1, &rule90}, - {6686, 2, &rule2}, - {6688, 53, &rule14}, - {6741, 1, &rule122}, - {6742, 1, &rule90}, - {6743, 1, &rule122}, - {6744, 7, &rule90}, - {6752, 1, &rule90}, - {6753, 1, &rule122}, - {6754, 1, &rule90}, - {6755, 2, &rule122}, - {6757, 8, &rule90}, - {6765, 6, &rule122}, - {6771, 10, &rule90}, - {6783, 1, &rule90}, - {6784, 10, &rule8}, - {6800, 10, &rule8}, - {6816, 7, &rule2}, - {6823, 1, &rule89}, - {6824, 6, &rule2}, - {6832, 14, &rule90}, - {6846, 1, &rule117}, - {6912, 4, &rule90}, - {6916, 1, &rule122}, - {6917, 47, &rule14}, - {6964, 1, &rule90}, - {6965, 1, &rule122}, - {6966, 5, &rule90}, - {6971, 1, &rule122}, - {6972, 1, &rule90}, - {6973, 5, &rule122}, - {6978, 1, &rule90}, - {6979, 2, &rule122}, - {6981, 7, &rule14}, - {6992, 10, &rule8}, - {7002, 7, &rule2}, - {7009, 10, &rule13}, - {7019, 9, &rule90}, - {7028, 9, &rule13}, - {7040, 2, &rule90}, - {7042, 1, &rule122}, - {7043, 30, &rule14}, - {7073, 1, &rule122}, - {7074, 4, &rule90}, - {7078, 2, &rule122}, - {7080, 2, &rule90}, - {7082, 1, &rule122}, - {7083, 3, &rule90}, - {7086, 2, &rule14}, - {7088, 10, &rule8}, - {7098, 44, &rule14}, - {7142, 1, &rule90}, - {7143, 1, &rule122}, - {7144, 2, &rule90}, - {7146, 3, &rule122}, - {7149, 1, &rule90}, - {7150, 1, &rule122}, - {7151, 3, &rule90}, - {7154, 2, &rule122}, - {7164, 4, &rule2}, - {7168, 36, &rule14}, - {7204, 8, &rule122}, - {7212, 8, &rule90}, - {7220, 2, &rule122}, - {7222, 2, &rule90}, - {7227, 5, &rule2}, - {7232, 10, &rule8}, - {7245, 3, &rule14}, - {7248, 10, &rule8}, - {7258, 30, &rule14}, - {7288, 6, &rule89}, - {7294, 2, &rule2}, - {7360, 8, &rule2}, - {7376, 3, &rule90}, - {7379, 1, &rule2}, - {7380, 13, &rule90}, - {7393, 1, &rule122}, - {7394, 7, &rule90}, - {7401, 4, &rule14}, - {7405, 1, &rule90}, - {7406, 4, &rule14}, - {7410, 2, &rule122}, - {7412, 1, &rule90}, - {7413, 2, &rule14}, - {7416, 2, &rule90}, - {7424, 44, &rule20}, - {7468, 63, &rule89}, - {7531, 13, &rule20}, - {7544, 1, &rule89}, - {7545, 1, &rule125}, - {7546, 3, &rule20}, - {7549, 1, &rule126}, - {7550, 29, &rule20}, - {7579, 37, &rule89}, - {7616, 54, &rule90}, - {7676, 4, &rule90}, - {7680, 1, &rule22}, - {7681, 1, &rule23}, - {7682, 1, &rule22}, - {7683, 1, &rule23}, - {7684, 1, &rule22}, - {7685, 1, &rule23}, - {7686, 1, &rule22}, - {7687, 1, &rule23}, - {7688, 1, &rule22}, - {7689, 1, &rule23}, - {7690, 1, &rule22}, - {7691, 1, &rule23}, - {7692, 1, &rule22}, - {7693, 1, &rule23}, - {7694, 1, &rule22}, - {7695, 1, &rule23}, - {7696, 1, &rule22}, - {7697, 1, &rule23}, - {7698, 1, &rule22}, - {7699, 1, &rule23}, - {7700, 1, &rule22}, - {7701, 1, &rule23}, - {7702, 1, &rule22}, - {7703, 1, &rule23}, - {7704, 1, &rule22}, - {7705, 1, &rule23}, - {7706, 1, &rule22}, - {7707, 1, &rule23}, - {7708, 1, &rule22}, - {7709, 1, &rule23}, - {7710, 1, &rule22}, - {7711, 1, &rule23}, - {7712, 1, &rule22}, - {7713, 1, &rule23}, - {7714, 1, &rule22}, - {7715, 1, &rule23}, - {7716, 1, &rule22}, - {7717, 1, &rule23}, - {7718, 1, &rule22}, - {7719, 1, &rule23}, - {7720, 1, &rule22}, - {7721, 1, &rule23}, - {7722, 1, &rule22}, - {7723, 1, &rule23}, - {7724, 1, &rule22}, - {7725, 1, &rule23}, - {7726, 1, &rule22}, - {7727, 1, &rule23}, - {7728, 1, &rule22}, - {7729, 1, &rule23}, - {7730, 1, &rule22}, - {7731, 1, &rule23}, - {7732, 1, &rule22}, - {7733, 1, &rule23}, - {7734, 1, &rule22}, - {7735, 1, &rule23}, - {7736, 1, &rule22}, - {7737, 1, &rule23}, - {7738, 1, &rule22}, - {7739, 1, &rule23}, - {7740, 1, &rule22}, - {7741, 1, &rule23}, - {7742, 1, &rule22}, - {7743, 1, &rule23}, - {7744, 1, &rule22}, - {7745, 1, &rule23}, - {7746, 1, &rule22}, - {7747, 1, &rule23}, - {7748, 1, &rule22}, - {7749, 1, &rule23}, - {7750, 1, &rule22}, - {7751, 1, &rule23}, - {7752, 1, &rule22}, - {7753, 1, &rule23}, - {7754, 1, &rule22}, - {7755, 1, &rule23}, - {7756, 1, &rule22}, - {7757, 1, &rule23}, - {7758, 1, &rule22}, - {7759, 1, &rule23}, - {7760, 1, &rule22}, - {7761, 1, &rule23}, - {7762, 1, &rule22}, - {7763, 1, &rule23}, - {7764, 1, &rule22}, - {7765, 1, &rule23}, - {7766, 1, &rule22}, - {7767, 1, &rule23}, - {7768, 1, &rule22}, - {7769, 1, &rule23}, - {7770, 1, &rule22}, - {7771, 1, &rule23}, - {7772, 1, &rule22}, - {7773, 1, &rule23}, - {7774, 1, &rule22}, - {7775, 1, &rule23}, - {7776, 1, &rule22}, - {7777, 1, &rule23}, - {7778, 1, &rule22}, - {7779, 1, &rule23}, - {7780, 1, &rule22}, - {7781, 1, &rule23}, - {7782, 1, &rule22}, - {7783, 1, &rule23}, - {7784, 1, &rule22}, - {7785, 1, &rule23}, - {7786, 1, &rule22}, - {7787, 1, &rule23}, - {7788, 1, &rule22}, - {7789, 1, &rule23}, - {7790, 1, &rule22}, - {7791, 1, &rule23}, - {7792, 1, &rule22}, - {7793, 1, &rule23}, - {7794, 1, &rule22}, - {7795, 1, &rule23}, - {7796, 1, &rule22}, - {7797, 1, &rule23}, - {7798, 1, &rule22}, - {7799, 1, &rule23}, - {7800, 1, &rule22}, - {7801, 1, &rule23}, - {7802, 1, &rule22}, - {7803, 1, &rule23}, - {7804, 1, &rule22}, - {7805, 1, &rule23}, - {7806, 1, &rule22}, - {7807, 1, &rule23}, - {7808, 1, &rule22}, - {7809, 1, &rule23}, - {7810, 1, &rule22}, - {7811, 1, &rule23}, - {7812, 1, &rule22}, - {7813, 1, &rule23}, - {7814, 1, &rule22}, - {7815, 1, &rule23}, - {7816, 1, &rule22}, - {7817, 1, &rule23}, - {7818, 1, &rule22}, - {7819, 1, &rule23}, - {7820, 1, &rule22}, - {7821, 1, &rule23}, - {7822, 1, &rule22}, - {7823, 1, &rule23}, - {7824, 1, &rule22}, - {7825, 1, &rule23}, - {7826, 1, &rule22}, - {7827, 1, &rule23}, - {7828, 1, &rule22}, - {7829, 1, &rule23}, - {7830, 5, &rule20}, - {7835, 1, &rule127}, - {7836, 2, &rule20}, - {7838, 1, &rule128}, - {7839, 1, &rule20}, - {7840, 1, &rule22}, - {7841, 1, &rule23}, - {7842, 1, &rule22}, - {7843, 1, &rule23}, - {7844, 1, &rule22}, - {7845, 1, &rule23}, - {7846, 1, &rule22}, - {7847, 1, &rule23}, - {7848, 1, &rule22}, - {7849, 1, &rule23}, - {7850, 1, &rule22}, - {7851, 1, &rule23}, - {7852, 1, &rule22}, - {7853, 1, &rule23}, - {7854, 1, &rule22}, - {7855, 1, &rule23}, - {7856, 1, &rule22}, - {7857, 1, &rule23}, - {7858, 1, &rule22}, - {7859, 1, &rule23}, - {7860, 1, &rule22}, - {7861, 1, &rule23}, - {7862, 1, &rule22}, - {7863, 1, &rule23}, - {7864, 1, &rule22}, - {7865, 1, &rule23}, - {7866, 1, &rule22}, - {7867, 1, &rule23}, - {7868, 1, &rule22}, - {7869, 1, &rule23}, - {7870, 1, &rule22}, - {7871, 1, &rule23}, - {7872, 1, &rule22}, - {7873, 1, &rule23}, - {7874, 1, &rule22}, - {7875, 1, &rule23}, - {7876, 1, &rule22}, - {7877, 1, &rule23}, - {7878, 1, &rule22}, - {7879, 1, &rule23}, - {7880, 1, &rule22}, - {7881, 1, &rule23}, - {7882, 1, &rule22}, - {7883, 1, &rule23}, - {7884, 1, &rule22}, - {7885, 1, &rule23}, - {7886, 1, &rule22}, - {7887, 1, &rule23}, - {7888, 1, &rule22}, - {7889, 1, &rule23}, - {7890, 1, &rule22}, - {7891, 1, &rule23}, - {7892, 1, &rule22}, - {7893, 1, &rule23}, - {7894, 1, &rule22}, - {7895, 1, &rule23}, - {7896, 1, &rule22}, - {7897, 1, &rule23}, - {7898, 1, &rule22}, - {7899, 1, &rule23}, - {7900, 1, &rule22}, - {7901, 1, &rule23}, - {7902, 1, &rule22}, - {7903, 1, &rule23}, - {7904, 1, &rule22}, - {7905, 1, &rule23}, - {7906, 1, &rule22}, - {7907, 1, &rule23}, - {7908, 1, &rule22}, - {7909, 1, &rule23}, - {7910, 1, &rule22}, - {7911, 1, &rule23}, - {7912, 1, &rule22}, - {7913, 1, &rule23}, - {7914, 1, &rule22}, - {7915, 1, &rule23}, - {7916, 1, &rule22}, - {7917, 1, &rule23}, - {7918, 1, &rule22}, - {7919, 1, &rule23}, - {7920, 1, &rule22}, - {7921, 1, &rule23}, - {7922, 1, &rule22}, - {7923, 1, &rule23}, - {7924, 1, &rule22}, - {7925, 1, &rule23}, - {7926, 1, &rule22}, - {7927, 1, &rule23}, - {7928, 1, &rule22}, - {7929, 1, &rule23}, - {7930, 1, &rule22}, - {7931, 1, &rule23}, - {7932, 1, &rule22}, - {7933, 1, &rule23}, - {7934, 1, &rule22}, - {7935, 1, &rule23}, - {7936, 8, &rule129}, - {7944, 8, &rule130}, - {7952, 6, &rule129}, - {7960, 6, &rule130}, - {7968, 8, &rule129}, - {7976, 8, &rule130}, - {7984, 8, &rule129}, - {7992, 8, &rule130}, - {8000, 6, &rule129}, - {8008, 6, &rule130}, - {8016, 1, &rule20}, - {8017, 1, &rule129}, - {8018, 1, &rule20}, - {8019, 1, &rule129}, - {8020, 1, &rule20}, - {8021, 1, &rule129}, - {8022, 1, &rule20}, - {8023, 1, &rule129}, - {8025, 1, &rule130}, - {8027, 1, &rule130}, - {8029, 1, &rule130}, - {8031, 1, &rule130}, - {8032, 8, &rule129}, - {8040, 8, &rule130}, - {8048, 2, &rule131}, - {8050, 4, &rule132}, - {8054, 2, &rule133}, - {8056, 2, &rule134}, - {8058, 2, &rule135}, - {8060, 2, &rule136}, - {8064, 8, &rule129}, - {8072, 8, &rule137}, - {8080, 8, &rule129}, - {8088, 8, &rule137}, - {8096, 8, &rule129}, - {8104, 8, &rule137}, - {8112, 2, &rule129}, - {8114, 1, &rule20}, - {8115, 1, &rule138}, - {8116, 1, &rule20}, - {8118, 2, &rule20}, - {8120, 2, &rule130}, - {8122, 2, &rule139}, - {8124, 1, &rule140}, - {8125, 1, &rule10}, - {8126, 1, &rule141}, - {8127, 3, &rule10}, - {8130, 1, &rule20}, - {8131, 1, &rule138}, - {8132, 1, &rule20}, - {8134, 2, &rule20}, - {8136, 4, &rule142}, - {8140, 1, &rule140}, - {8141, 3, &rule10}, - {8144, 2, &rule129}, - {8146, 2, &rule20}, - {8150, 2, &rule20}, - {8152, 2, &rule130}, - {8154, 2, &rule143}, - {8157, 3, &rule10}, - {8160, 2, &rule129}, - {8162, 3, &rule20}, - {8165, 1, &rule111}, - {8166, 2, &rule20}, - {8168, 2, &rule130}, - {8170, 2, &rule144}, - {8172, 1, &rule115}, - {8173, 3, &rule10}, - {8178, 1, &rule20}, - {8179, 1, &rule138}, - {8180, 1, &rule20}, - {8182, 2, &rule20}, - {8184, 2, &rule145}, - {8186, 2, &rule146}, - {8188, 1, &rule140}, - {8189, 2, &rule10}, - {8192, 11, &rule1}, - {8203, 5, &rule16}, - {8208, 6, &rule7}, - {8214, 2, &rule2}, - {8216, 1, &rule15}, - {8217, 1, &rule19}, - {8218, 1, &rule4}, - {8219, 2, &rule15}, - {8221, 1, &rule19}, - {8222, 1, &rule4}, - {8223, 1, &rule15}, - {8224, 8, &rule2}, - {8232, 1, &rule147}, - {8233, 1, &rule148}, - {8234, 5, &rule16}, - {8239, 1, &rule1}, - {8240, 9, &rule2}, - {8249, 1, &rule15}, - {8250, 1, &rule19}, - {8251, 4, &rule2}, - {8255, 2, &rule11}, - {8257, 3, &rule2}, - {8260, 1, &rule6}, - {8261, 1, &rule4}, - {8262, 1, &rule5}, - {8263, 11, &rule2}, - {8274, 1, &rule6}, - {8275, 1, &rule2}, - {8276, 1, &rule11}, - {8277, 10, &rule2}, - {8287, 1, &rule1}, - {8288, 5, &rule16}, - {8294, 10, &rule16}, - {8304, 1, &rule17}, - {8305, 1, &rule89}, - {8308, 6, &rule17}, - {8314, 3, &rule6}, - {8317, 1, &rule4}, - {8318, 1, &rule5}, - {8319, 1, &rule89}, - {8320, 10, &rule17}, - {8330, 3, &rule6}, - {8333, 1, &rule4}, - {8334, 1, &rule5}, - {8336, 13, &rule89}, - {8352, 30, &rule3}, - {8400, 13, &rule90}, - {8413, 4, &rule117}, - {8417, 1, &rule90}, - {8418, 3, &rule117}, - {8421, 12, &rule90}, - {8448, 2, &rule13}, - {8450, 1, &rule105}, - {8451, 4, &rule13}, - {8455, 1, &rule105}, - {8456, 2, &rule13}, - {8458, 1, &rule20}, - {8459, 3, &rule105}, - {8462, 2, &rule20}, - {8464, 3, &rule105}, - {8467, 1, &rule20}, - {8468, 1, &rule13}, - {8469, 1, &rule105}, - {8470, 2, &rule13}, - {8472, 1, &rule6}, - {8473, 5, &rule105}, - {8478, 6, &rule13}, - {8484, 1, &rule105}, - {8485, 1, &rule13}, - {8486, 1, &rule149}, - {8487, 1, &rule13}, - {8488, 1, &rule105}, - {8489, 1, &rule13}, - {8490, 1, &rule150}, - {8491, 1, &rule151}, - {8492, 2, &rule105}, - {8494, 1, &rule13}, - {8495, 1, &rule20}, - {8496, 2, &rule105}, - {8498, 1, &rule152}, - {8499, 1, &rule105}, - {8500, 1, &rule20}, - {8501, 4, &rule14}, - {8505, 1, &rule20}, - {8506, 2, &rule13}, - {8508, 2, &rule20}, - {8510, 2, &rule105}, - {8512, 5, &rule6}, - {8517, 1, &rule105}, - {8518, 4, &rule20}, - {8522, 1, &rule13}, - {8523, 1, &rule6}, - {8524, 2, &rule13}, - {8526, 1, &rule153}, - {8527, 1, &rule13}, - {8528, 16, &rule17}, - {8544, 16, &rule154}, - {8560, 16, &rule155}, - {8576, 3, &rule124}, - {8579, 1, &rule22}, - {8580, 1, &rule23}, - {8581, 4, &rule124}, - {8585, 1, &rule17}, - {8592, 5, &rule6}, - {8597, 5, &rule13}, - {8602, 2, &rule6}, - {8604, 4, &rule13}, - {8608, 1, &rule6}, - {8609, 2, &rule13}, - {8611, 1, &rule6}, - {8612, 2, &rule13}, - {8614, 1, &rule6}, - {8615, 7, &rule13}, - {8622, 1, &rule6}, - {8623, 31, &rule13}, - {8654, 2, &rule6}, - {8656, 2, &rule13}, - {8658, 1, &rule6}, - {8659, 1, &rule13}, - {8660, 1, &rule6}, - {8661, 31, &rule13}, - {8692, 268, &rule6}, - {8960, 8, &rule13}, - {8968, 1, &rule4}, - {8969, 1, &rule5}, - {8970, 1, &rule4}, - {8971, 1, &rule5}, - {8972, 20, &rule13}, - {8992, 2, &rule6}, - {8994, 7, &rule13}, - {9001, 1, &rule4}, - {9002, 1, &rule5}, - {9003, 81, &rule13}, - {9084, 1, &rule6}, - {9085, 30, &rule13}, - {9115, 25, &rule6}, - {9140, 40, &rule13}, - {9180, 6, &rule6}, - {9186, 25, &rule13}, - {9216, 39, &rule13}, - {9280, 11, &rule13}, - {9312, 60, &rule17}, - {9372, 26, &rule13}, - {9398, 26, &rule156}, - {9424, 26, &rule157}, - {9450, 22, &rule17}, - {9472, 183, &rule13}, - {9655, 1, &rule6}, - {9656, 9, &rule13}, - {9665, 1, &rule6}, - {9666, 54, &rule13}, - {9720, 8, &rule6}, - {9728, 111, &rule13}, - {9839, 1, &rule6}, - {9840, 248, &rule13}, - {10088, 1, &rule4}, - {10089, 1, &rule5}, - {10090, 1, &rule4}, - {10091, 1, &rule5}, - {10092, 1, &rule4}, - {10093, 1, &rule5}, - {10094, 1, &rule4}, - {10095, 1, &rule5}, - {10096, 1, &rule4}, - {10097, 1, &rule5}, - {10098, 1, &rule4}, - {10099, 1, &rule5}, - {10100, 1, &rule4}, - {10101, 1, &rule5}, - {10102, 30, &rule17}, - {10132, 44, &rule13}, - {10176, 5, &rule6}, - {10181, 1, &rule4}, - {10182, 1, &rule5}, - {10183, 31, &rule6}, - {10214, 1, &rule4}, - {10215, 1, &rule5}, - {10216, 1, &rule4}, - {10217, 1, &rule5}, - {10218, 1, &rule4}, - {10219, 1, &rule5}, - {10220, 1, &rule4}, - {10221, 1, &rule5}, - {10222, 1, &rule4}, - {10223, 1, &rule5}, - {10224, 16, &rule6}, - {10240, 256, &rule13}, - {10496, 131, &rule6}, - {10627, 1, &rule4}, - {10628, 1, &rule5}, - {10629, 1, &rule4}, - {10630, 1, &rule5}, - {10631, 1, &rule4}, - {10632, 1, &rule5}, - {10633, 1, &rule4}, - {10634, 1, &rule5}, - {10635, 1, &rule4}, - {10636, 1, &rule5}, - {10637, 1, &rule4}, - {10638, 1, &rule5}, - {10639, 1, &rule4}, - {10640, 1, &rule5}, - {10641, 1, &rule4}, - {10642, 1, &rule5}, - {10643, 1, &rule4}, - {10644, 1, &rule5}, - {10645, 1, &rule4}, - {10646, 1, &rule5}, - {10647, 1, &rule4}, - {10648, 1, &rule5}, - {10649, 63, &rule6}, - {10712, 1, &rule4}, - {10713, 1, &rule5}, - {10714, 1, &rule4}, - {10715, 1, &rule5}, - {10716, 32, &rule6}, - {10748, 1, &rule4}, - {10749, 1, &rule5}, - {10750, 258, &rule6}, - {11008, 48, &rule13}, - {11056, 21, &rule6}, - {11077, 2, &rule13}, - {11079, 6, &rule6}, - {11085, 39, &rule13}, - {11126, 32, &rule13}, - {11160, 34, &rule13}, - {11197, 12, &rule13}, - {11210, 8, &rule13}, - {11264, 47, &rule120}, - {11312, 47, &rule121}, - {11360, 1, &rule22}, - {11361, 1, &rule23}, - {11362, 1, &rule158}, - {11363, 1, &rule159}, - {11364, 1, &rule160}, - {11365, 1, &rule161}, - {11366, 1, &rule162}, - {11367, 1, &rule22}, - {11368, 1, &rule23}, - {11369, 1, &rule22}, - {11370, 1, &rule23}, - {11371, 1, &rule22}, - {11372, 1, &rule23}, - {11373, 1, &rule163}, - {11374, 1, &rule164}, - {11375, 1, &rule165}, - {11376, 1, &rule166}, - {11377, 1, &rule20}, - {11378, 1, &rule22}, - {11379, 1, &rule23}, - {11380, 1, &rule20}, - {11381, 1, &rule22}, - {11382, 1, &rule23}, - {11383, 5, &rule20}, - {11388, 2, &rule89}, - {11390, 2, &rule167}, - {11392, 1, &rule22}, - {11393, 1, &rule23}, - {11394, 1, &rule22}, - {11395, 1, &rule23}, - {11396, 1, &rule22}, - {11397, 1, &rule23}, - {11398, 1, &rule22}, - {11399, 1, &rule23}, - {11400, 1, &rule22}, - {11401, 1, &rule23}, - {11402, 1, &rule22}, - {11403, 1, &rule23}, - {11404, 1, &rule22}, - {11405, 1, &rule23}, - {11406, 1, &rule22}, - {11407, 1, &rule23}, - {11408, 1, &rule22}, - {11409, 1, &rule23}, - {11410, 1, &rule22}, - {11411, 1, &rule23}, - {11412, 1, &rule22}, - {11413, 1, &rule23}, - {11414, 1, &rule22}, - {11415, 1, &rule23}, - {11416, 1, &rule22}, - {11417, 1, &rule23}, - {11418, 1, &rule22}, - {11419, 1, &rule23}, - {11420, 1, &rule22}, - {11421, 1, &rule23}, - {11422, 1, &rule22}, - {11423, 1, &rule23}, - {11424, 1, &rule22}, - {11425, 1, &rule23}, - {11426, 1, &rule22}, - {11427, 1, &rule23}, - {11428, 1, &rule22}, - {11429, 1, &rule23}, - {11430, 1, &rule22}, - {11431, 1, &rule23}, - {11432, 1, &rule22}, - {11433, 1, &rule23}, - {11434, 1, &rule22}, - {11435, 1, &rule23}, - {11436, 1, &rule22}, - {11437, 1, &rule23}, - {11438, 1, &rule22}, - {11439, 1, &rule23}, - {11440, 1, &rule22}, - {11441, 1, &rule23}, - {11442, 1, &rule22}, - {11443, 1, &rule23}, - {11444, 1, &rule22}, - {11445, 1, &rule23}, - {11446, 1, &rule22}, - {11447, 1, &rule23}, - {11448, 1, &rule22}, - {11449, 1, &rule23}, - {11450, 1, &rule22}, - {11451, 1, &rule23}, - {11452, 1, &rule22}, - {11453, 1, &rule23}, - {11454, 1, &rule22}, - {11455, 1, &rule23}, - {11456, 1, &rule22}, - {11457, 1, &rule23}, - {11458, 1, &rule22}, - {11459, 1, &rule23}, - {11460, 1, &rule22}, - {11461, 1, &rule23}, - {11462, 1, &rule22}, - {11463, 1, &rule23}, - {11464, 1, &rule22}, - {11465, 1, &rule23}, - {11466, 1, &rule22}, - {11467, 1, &rule23}, - {11468, 1, &rule22}, - {11469, 1, &rule23}, - {11470, 1, &rule22}, - {11471, 1, &rule23}, - {11472, 1, &rule22}, - {11473, 1, &rule23}, - {11474, 1, &rule22}, - {11475, 1, &rule23}, - {11476, 1, &rule22}, - {11477, 1, &rule23}, - {11478, 1, &rule22}, - {11479, 1, &rule23}, - {11480, 1, &rule22}, - {11481, 1, &rule23}, - {11482, 1, &rule22}, - {11483, 1, &rule23}, - {11484, 1, &rule22}, - {11485, 1, &rule23}, - {11486, 1, &rule22}, - {11487, 1, &rule23}, - {11488, 1, &rule22}, - {11489, 1, &rule23}, - {11490, 1, &rule22}, - {11491, 1, &rule23}, - {11492, 1, &rule20}, - {11493, 6, &rule13}, - {11499, 1, &rule22}, - {11500, 1, &rule23}, - {11501, 1, &rule22}, - {11502, 1, &rule23}, - {11503, 3, &rule90}, - {11506, 1, &rule22}, - {11507, 1, &rule23}, - {11513, 4, &rule2}, - {11517, 1, &rule17}, - {11518, 2, &rule2}, - {11520, 38, &rule168}, - {11559, 1, &rule168}, - {11565, 1, &rule168}, - {11568, 56, &rule14}, - {11631, 1, &rule89}, - {11632, 1, &rule2}, - {11647, 1, &rule90}, - {11648, 23, &rule14}, - {11680, 7, &rule14}, - {11688, 7, &rule14}, - {11696, 7, &rule14}, - {11704, 7, &rule14}, - {11712, 7, &rule14}, - {11720, 7, &rule14}, - {11728, 7, &rule14}, - {11736, 7, &rule14}, - {11744, 32, &rule90}, - {11776, 2, &rule2}, - {11778, 1, &rule15}, - {11779, 1, &rule19}, - {11780, 1, &rule15}, - {11781, 1, &rule19}, - {11782, 3, &rule2}, - {11785, 1, &rule15}, - {11786, 1, &rule19}, - {11787, 1, &rule2}, - {11788, 1, &rule15}, - {11789, 1, &rule19}, - {11790, 9, &rule2}, - {11799, 1, &rule7}, - {11800, 2, &rule2}, - {11802, 1, &rule7}, - {11803, 1, &rule2}, - {11804, 1, &rule15}, - {11805, 1, &rule19}, - {11806, 2, &rule2}, - {11808, 1, &rule15}, - {11809, 1, &rule19}, - {11810, 1, &rule4}, - {11811, 1, &rule5}, - {11812, 1, &rule4}, - {11813, 1, &rule5}, - {11814, 1, &rule4}, - {11815, 1, &rule5}, - {11816, 1, &rule4}, - {11817, 1, &rule5}, - {11818, 5, &rule2}, - {11823, 1, &rule89}, - {11824, 10, &rule2}, - {11834, 2, &rule7}, - {11836, 4, &rule2}, - {11840, 1, &rule7}, - {11841, 1, &rule2}, - {11842, 1, &rule4}, - {11904, 26, &rule13}, - {11931, 89, &rule13}, - {12032, 214, &rule13}, - {12272, 12, &rule13}, - {12288, 1, &rule1}, - {12289, 3, &rule2}, - {12292, 1, &rule13}, - {12293, 1, &rule89}, - {12294, 1, &rule14}, - {12295, 1, &rule124}, - {12296, 1, &rule4}, - {12297, 1, &rule5}, - {12298, 1, &rule4}, - {12299, 1, &rule5}, - {12300, 1, &rule4}, - {12301, 1, &rule5}, - {12302, 1, &rule4}, - {12303, 1, &rule5}, - {12304, 1, &rule4}, - {12305, 1, &rule5}, - {12306, 2, &rule13}, - {12308, 1, &rule4}, - {12309, 1, &rule5}, - {12310, 1, &rule4}, - {12311, 1, &rule5}, - {12312, 1, &rule4}, - {12313, 1, &rule5}, - {12314, 1, &rule4}, - {12315, 1, &rule5}, - {12316, 1, &rule7}, - {12317, 1, &rule4}, - {12318, 2, &rule5}, - {12320, 1, &rule13}, - {12321, 9, &rule124}, - {12330, 4, &rule90}, - {12334, 2, &rule122}, - {12336, 1, &rule7}, - {12337, 5, &rule89}, - {12342, 2, &rule13}, - {12344, 3, &rule124}, - {12347, 1, &rule89}, - {12348, 1, &rule14}, - {12349, 1, &rule2}, - {12350, 2, &rule13}, - {12353, 86, &rule14}, - {12441, 2, &rule90}, - {12443, 2, &rule10}, - {12445, 2, &rule89}, - {12447, 1, &rule14}, - {12448, 1, &rule7}, - {12449, 90, &rule14}, - {12539, 1, &rule2}, - {12540, 3, &rule89}, - {12543, 1, &rule14}, - {12549, 41, &rule14}, - {12593, 94, &rule14}, - {12688, 2, &rule13}, - {12690, 4, &rule17}, - {12694, 10, &rule13}, - {12704, 27, &rule14}, - {12736, 36, &rule13}, - {12784, 16, &rule14}, - {12800, 31, &rule13}, - {12832, 10, &rule17}, - {12842, 30, &rule13}, - {12872, 8, &rule17}, - {12880, 1, &rule13}, - {12881, 15, &rule17}, - {12896, 32, &rule13}, - {12928, 10, &rule17}, - {12938, 39, &rule13}, - {12977, 15, &rule17}, - {12992, 63, &rule13}, - {13056, 256, &rule13}, - {13312, 6582, &rule14}, - {19904, 64, &rule13}, - {19968, 20941, &rule14}, - {40960, 21, &rule14}, - {40981, 1, &rule89}, - {40982, 1143, &rule14}, - {42128, 55, &rule13}, - {42192, 40, &rule14}, - {42232, 6, &rule89}, - {42238, 2, &rule2}, - {42240, 268, &rule14}, - {42508, 1, &rule89}, - {42509, 3, &rule2}, - {42512, 16, &rule14}, - {42528, 10, &rule8}, - {42538, 2, &rule14}, - {42560, 1, &rule22}, - {42561, 1, &rule23}, - {42562, 1, &rule22}, - {42563, 1, &rule23}, - {42564, 1, &rule22}, - {42565, 1, &rule23}, - {42566, 1, &rule22}, - {42567, 1, &rule23}, - {42568, 1, &rule22}, - {42569, 1, &rule23}, - {42570, 1, &rule22}, - {42571, 1, &rule23}, - {42572, 1, &rule22}, - {42573, 1, &rule23}, - {42574, 1, &rule22}, - {42575, 1, &rule23}, - {42576, 1, &rule22}, - {42577, 1, &rule23}, - {42578, 1, &rule22}, - {42579, 1, &rule23}, - {42580, 1, &rule22}, - {42581, 1, &rule23}, - {42582, 1, &rule22}, - {42583, 1, &rule23}, - {42584, 1, &rule22}, - {42585, 1, &rule23}, - {42586, 1, &rule22}, - {42587, 1, &rule23}, - {42588, 1, &rule22}, - {42589, 1, &rule23}, - {42590, 1, &rule22}, - {42591, 1, &rule23}, - {42592, 1, &rule22}, - {42593, 1, &rule23}, - {42594, 1, &rule22}, - {42595, 1, &rule23}, - {42596, 1, &rule22}, - {42597, 1, &rule23}, - {42598, 1, &rule22}, - {42599, 1, &rule23}, - {42600, 1, &rule22}, - {42601, 1, &rule23}, - {42602, 1, &rule22}, - {42603, 1, &rule23}, - {42604, 1, &rule22}, - {42605, 1, &rule23}, - {42606, 1, &rule14}, - {42607, 1, &rule90}, - {42608, 3, &rule117}, - {42611, 1, &rule2}, - {42612, 10, &rule90}, - {42622, 1, &rule2}, - {42623, 1, &rule89}, - {42624, 1, &rule22}, - {42625, 1, &rule23}, - {42626, 1, &rule22}, - {42627, 1, &rule23}, - {42628, 1, &rule22}, - {42629, 1, &rule23}, - {42630, 1, &rule22}, - {42631, 1, &rule23}, - {42632, 1, &rule22}, - {42633, 1, &rule23}, - {42634, 1, &rule22}, - {42635, 1, &rule23}, - {42636, 1, &rule22}, - {42637, 1, &rule23}, - {42638, 1, &rule22}, - {42639, 1, &rule23}, - {42640, 1, &rule22}, - {42641, 1, &rule23}, - {42642, 1, &rule22}, - {42643, 1, &rule23}, - {42644, 1, &rule22}, - {42645, 1, &rule23}, - {42646, 1, &rule22}, - {42647, 1, &rule23}, - {42648, 1, &rule22}, - {42649, 1, &rule23}, - {42650, 1, &rule22}, - {42651, 1, &rule23}, - {42652, 2, &rule89}, - {42655, 1, &rule90}, - {42656, 70, &rule14}, - {42726, 10, &rule124}, - {42736, 2, &rule90}, - {42738, 6, &rule2}, - {42752, 23, &rule10}, - {42775, 9, &rule89}, - {42784, 2, &rule10}, - {42786, 1, &rule22}, - {42787, 1, &rule23}, - {42788, 1, &rule22}, - {42789, 1, &rule23}, - {42790, 1, &rule22}, - {42791, 1, &rule23}, - {42792, 1, &rule22}, - {42793, 1, &rule23}, - {42794, 1, &rule22}, - {42795, 1, &rule23}, - {42796, 1, &rule22}, - {42797, 1, &rule23}, - {42798, 1, &rule22}, - {42799, 1, &rule23}, - {42800, 2, &rule20}, - {42802, 1, &rule22}, - {42803, 1, &rule23}, - {42804, 1, &rule22}, - {42805, 1, &rule23}, - {42806, 1, &rule22}, - {42807, 1, &rule23}, - {42808, 1, &rule22}, - {42809, 1, &rule23}, - {42810, 1, &rule22}, - {42811, 1, &rule23}, - {42812, 1, &rule22}, - {42813, 1, &rule23}, - {42814, 1, &rule22}, - {42815, 1, &rule23}, - {42816, 1, &rule22}, - {42817, 1, &rule23}, - {42818, 1, &rule22}, - {42819, 1, &rule23}, - {42820, 1, &rule22}, - {42821, 1, &rule23}, - {42822, 1, &rule22}, - {42823, 1, &rule23}, - {42824, 1, &rule22}, - {42825, 1, &rule23}, - {42826, 1, &rule22}, - {42827, 1, &rule23}, - {42828, 1, &rule22}, - {42829, 1, &rule23}, - {42830, 1, &rule22}, - {42831, 1, &rule23}, - {42832, 1, &rule22}, - {42833, 1, &rule23}, - {42834, 1, &rule22}, - {42835, 1, &rule23}, - {42836, 1, &rule22}, - {42837, 1, &rule23}, - {42838, 1, &rule22}, - {42839, 1, &rule23}, - {42840, 1, &rule22}, - {42841, 1, &rule23}, - {42842, 1, &rule22}, - {42843, 1, &rule23}, - {42844, 1, &rule22}, - {42845, 1, &rule23}, - {42846, 1, &rule22}, - {42847, 1, &rule23}, - {42848, 1, &rule22}, - {42849, 1, &rule23}, - {42850, 1, &rule22}, - {42851, 1, &rule23}, - {42852, 1, &rule22}, - {42853, 1, &rule23}, - {42854, 1, &rule22}, - {42855, 1, &rule23}, - {42856, 1, &rule22}, - {42857, 1, &rule23}, - {42858, 1, &rule22}, - {42859, 1, &rule23}, - {42860, 1, &rule22}, - {42861, 1, &rule23}, - {42862, 1, &rule22}, - {42863, 1, &rule23}, - {42864, 1, &rule89}, - {42865, 8, &rule20}, - {42873, 1, &rule22}, - {42874, 1, &rule23}, - {42875, 1, &rule22}, - {42876, 1, &rule23}, - {42877, 1, &rule169}, - {42878, 1, &rule22}, - {42879, 1, &rule23}, - {42880, 1, &rule22}, - {42881, 1, &rule23}, - {42882, 1, &rule22}, - {42883, 1, &rule23}, - {42884, 1, &rule22}, - {42885, 1, &rule23}, - {42886, 1, &rule22}, - {42887, 1, &rule23}, - {42888, 1, &rule89}, - {42889, 2, &rule10}, - {42891, 1, &rule22}, - {42892, 1, &rule23}, - {42893, 1, &rule170}, - {42894, 1, &rule20}, - {42896, 1, &rule22}, - {42897, 1, &rule23}, - {42898, 1, &rule22}, - {42899, 1, &rule23}, - {42900, 2, &rule20}, - {42902, 1, &rule22}, - {42903, 1, &rule23}, - {42904, 1, &rule22}, - {42905, 1, &rule23}, - {42906, 1, &rule22}, - {42907, 1, &rule23}, - {42908, 1, &rule22}, - {42909, 1, &rule23}, - {42910, 1, &rule22}, - {42911, 1, &rule23}, - {42912, 1, &rule22}, - {42913, 1, &rule23}, - {42914, 1, &rule22}, - {42915, 1, &rule23}, - {42916, 1, &rule22}, - {42917, 1, &rule23}, - {42918, 1, &rule22}, - {42919, 1, &rule23}, - {42920, 1, &rule22}, - {42921, 1, &rule23}, - {42922, 1, &rule171}, - {42923, 1, &rule172}, - {42924, 1, &rule173}, - {42925, 1, &rule174}, - {42928, 1, &rule175}, - {42929, 1, &rule176}, - {42999, 1, &rule14}, - {43000, 2, &rule89}, - {43002, 1, &rule20}, - {43003, 7, &rule14}, - {43010, 1, &rule90}, - {43011, 3, &rule14}, - {43014, 1, &rule90}, - {43015, 4, &rule14}, - {43019, 1, &rule90}, - {43020, 23, &rule14}, - {43043, 2, &rule122}, - {43045, 2, &rule90}, - {43047, 1, &rule122}, - {43048, 4, &rule13}, - {43056, 6, &rule17}, - {43062, 2, &rule13}, - {43064, 1, &rule3}, - {43065, 1, &rule13}, - {43072, 52, &rule14}, - {43124, 4, &rule2}, - {43136, 2, &rule122}, - {43138, 50, &rule14}, - {43188, 16, &rule122}, - {43204, 1, &rule90}, - {43214, 2, &rule2}, - {43216, 10, &rule8}, - {43232, 18, &rule90}, - {43250, 6, &rule14}, - {43256, 3, &rule2}, - {43259, 1, &rule14}, - {43264, 10, &rule8}, - {43274, 28, &rule14}, - {43302, 8, &rule90}, - {43310, 2, &rule2}, - {43312, 23, &rule14}, - {43335, 11, &rule90}, - {43346, 2, &rule122}, - {43359, 1, &rule2}, - {43360, 29, &rule14}, - {43392, 3, &rule90}, - {43395, 1, &rule122}, - {43396, 47, &rule14}, - {43443, 1, &rule90}, - {43444, 2, &rule122}, - {43446, 4, &rule90}, - {43450, 2, &rule122}, - {43452, 1, &rule90}, - {43453, 4, &rule122}, - {43457, 13, &rule2}, - {43471, 1, &rule89}, - {43472, 10, &rule8}, - {43486, 2, &rule2}, - {43488, 5, &rule14}, - {43493, 1, &rule90}, - {43494, 1, &rule89}, - {43495, 9, &rule14}, - {43504, 10, &rule8}, - {43514, 5, &rule14}, - {43520, 41, &rule14}, - {43561, 6, &rule90}, - {43567, 2, &rule122}, - {43569, 2, &rule90}, - {43571, 2, &rule122}, - {43573, 2, &rule90}, - {43584, 3, &rule14}, - {43587, 1, &rule90}, - {43588, 8, &rule14}, - {43596, 1, &rule90}, - {43597, 1, &rule122}, - {43600, 10, &rule8}, - {43612, 4, &rule2}, - {43616, 16, &rule14}, - {43632, 1, &rule89}, - {43633, 6, &rule14}, - {43639, 3, &rule13}, - {43642, 1, &rule14}, - {43643, 1, &rule122}, - {43644, 1, &rule90}, - {43645, 1, &rule122}, - {43646, 50, &rule14}, - {43696, 1, &rule90}, - {43697, 1, &rule14}, - {43698, 3, &rule90}, - {43701, 2, &rule14}, - {43703, 2, &rule90}, - {43705, 5, &rule14}, - {43710, 2, &rule90}, - {43712, 1, &rule14}, - {43713, 1, &rule90}, - {43714, 1, &rule14}, - {43739, 2, &rule14}, - {43741, 1, &rule89}, - {43742, 2, &rule2}, - {43744, 11, &rule14}, - {43755, 1, &rule122}, - {43756, 2, &rule90}, - {43758, 2, &rule122}, - {43760, 2, &rule2}, - {43762, 1, &rule14}, - {43763, 2, &rule89}, - {43765, 1, &rule122}, - {43766, 1, &rule90}, - {43777, 6, &rule14}, - {43785, 6, &rule14}, - {43793, 6, &rule14}, - {43808, 7, &rule14}, - {43816, 7, &rule14}, - {43824, 43, &rule20}, - {43867, 1, &rule10}, - {43868, 4, &rule89}, - {43876, 2, &rule20}, - {43968, 35, &rule14}, - {44003, 2, &rule122}, - {44005, 1, &rule90}, - {44006, 2, &rule122}, - {44008, 1, &rule90}, - {44009, 2, &rule122}, - {44011, 1, &rule2}, - {44012, 1, &rule122}, - {44013, 1, &rule90}, - {44016, 10, &rule8}, - {44032, 11172, &rule14}, - {55216, 23, &rule14}, - {55243, 49, &rule14}, - {55296, 896, &rule177}, - {56192, 128, &rule177}, - {56320, 1024, &rule177}, - {57344, 6400, &rule178}, - {63744, 366, &rule14}, - {64112, 106, &rule14}, - {64256, 7, &rule20}, - {64275, 5, &rule20}, - {64285, 1, &rule14}, - {64286, 1, &rule90}, - {64287, 10, &rule14}, - {64297, 1, &rule6}, - {64298, 13, &rule14}, - {64312, 5, &rule14}, - {64318, 1, &rule14}, - {64320, 2, &rule14}, - {64323, 2, &rule14}, - {64326, 108, &rule14}, - {64434, 16, &rule10}, - {64467, 363, &rule14}, - {64830, 1, &rule5}, - {64831, 1, &rule4}, - {64848, 64, &rule14}, - {64914, 54, &rule14}, - {65008, 12, &rule14}, - {65020, 1, &rule3}, - {65021, 1, &rule13}, - {65024, 16, &rule90}, - {65040, 7, &rule2}, - {65047, 1, &rule4}, - {65048, 1, &rule5}, - {65049, 1, &rule2}, - {65056, 14, &rule90}, - {65072, 1, &rule2}, - {65073, 2, &rule7}, - {65075, 2, &rule11}, - {65077, 1, &rule4}, - {65078, 1, &rule5}, - {65079, 1, &rule4}, - {65080, 1, &rule5}, - {65081, 1, &rule4}, - {65082, 1, &rule5}, - {65083, 1, &rule4}, - {65084, 1, &rule5}, - {65085, 1, &rule4}, - {65086, 1, &rule5}, - {65087, 1, &rule4}, - {65088, 1, &rule5}, - {65089, 1, &rule4}, - {65090, 1, &rule5}, - {65091, 1, &rule4}, - {65092, 1, &rule5}, - {65093, 2, &rule2}, - {65095, 1, &rule4}, - {65096, 1, &rule5}, - {65097, 4, &rule2}, - {65101, 3, &rule11}, - {65104, 3, &rule2}, - {65108, 4, &rule2}, - {65112, 1, &rule7}, - {65113, 1, &rule4}, - {65114, 1, &rule5}, - {65115, 1, &rule4}, - {65116, 1, &rule5}, - {65117, 1, &rule4}, - {65118, 1, &rule5}, - {65119, 3, &rule2}, - {65122, 1, &rule6}, - {65123, 1, &rule7}, - {65124, 3, &rule6}, - {65128, 1, &rule2}, - {65129, 1, &rule3}, - {65130, 2, &rule2}, - {65136, 5, &rule14}, - {65142, 135, &rule14}, - {65279, 1, &rule16}, - {65281, 3, &rule2}, - {65284, 1, &rule3}, - {65285, 3, &rule2}, - {65288, 1, &rule4}, - {65289, 1, &rule5}, - {65290, 1, &rule2}, - {65291, 1, &rule6}, - {65292, 1, &rule2}, - {65293, 1, &rule7}, - {65294, 2, &rule2}, - {65296, 10, &rule8}, - {65306, 2, &rule2}, - {65308, 3, &rule6}, - {65311, 2, &rule2}, - {65313, 26, &rule9}, - {65339, 1, &rule4}, - {65340, 1, &rule2}, - {65341, 1, &rule5}, - {65342, 1, &rule10}, - {65343, 1, &rule11}, - {65344, 1, &rule10}, - {65345, 26, &rule12}, - {65371, 1, &rule4}, - {65372, 1, &rule6}, - {65373, 1, &rule5}, - {65374, 1, &rule6}, - {65375, 1, &rule4}, - {65376, 1, &rule5}, - {65377, 1, &rule2}, - {65378, 1, &rule4}, - {65379, 1, &rule5}, - {65380, 2, &rule2}, - {65382, 10, &rule14}, - {65392, 1, &rule89}, - {65393, 45, &rule14}, - {65438, 2, &rule89}, - {65440, 31, &rule14}, - {65474, 6, &rule14}, - {65482, 6, &rule14}, - {65490, 6, &rule14}, - {65498, 3, &rule14}, - {65504, 2, &rule3}, - {65506, 1, &rule6}, - {65507, 1, &rule10}, - {65508, 1, &rule13}, - {65509, 2, &rule3}, - {65512, 1, &rule13}, - {65513, 4, &rule6}, - {65517, 2, &rule13}, - {65529, 3, &rule16}, - {65532, 2, &rule13}, - {65536, 12, &rule14}, - {65549, 26, &rule14}, - {65576, 19, &rule14}, - {65596, 2, &rule14}, - {65599, 15, &rule14}, - {65616, 14, &rule14}, - {65664, 123, &rule14}, - {65792, 3, &rule2}, - {65799, 45, &rule17}, - {65847, 9, &rule13}, - {65856, 53, &rule124}, - {65909, 4, &rule17}, - {65913, 17, &rule13}, - {65930, 2, &rule17}, - {65932, 1, &rule13}, - {65936, 12, &rule13}, - {65952, 1, &rule13}, - {66000, 45, &rule13}, - {66045, 1, &rule90}, - {66176, 29, &rule14}, - {66208, 49, &rule14}, - {66272, 1, &rule90}, - {66273, 27, &rule17}, - {66304, 32, &rule14}, - {66336, 4, &rule17}, - {66352, 17, &rule14}, - {66369, 1, &rule124}, - {66370, 8, &rule14}, - {66378, 1, &rule124}, - {66384, 38, &rule14}, - {66422, 5, &rule90}, - {66432, 30, &rule14}, - {66463, 1, &rule2}, - {66464, 36, &rule14}, - {66504, 8, &rule14}, - {66512, 1, &rule2}, - {66513, 5, &rule124}, - {66560, 40, &rule179}, - {66600, 40, &rule180}, - {66640, 78, &rule14}, - {66720, 10, &rule8}, - {66816, 40, &rule14}, - {66864, 52, &rule14}, - {66927, 1, &rule2}, - {67072, 311, &rule14}, - {67392, 22, &rule14}, - {67424, 8, &rule14}, - {67584, 6, &rule14}, - {67592, 1, &rule14}, - {67594, 44, &rule14}, - {67639, 2, &rule14}, - {67644, 1, &rule14}, - {67647, 23, &rule14}, - {67671, 1, &rule2}, - {67672, 8, &rule17}, - {67680, 23, &rule14}, - {67703, 2, &rule13}, - {67705, 7, &rule17}, - {67712, 31, &rule14}, - {67751, 9, &rule17}, - {67840, 22, &rule14}, - {67862, 6, &rule17}, - {67871, 1, &rule2}, - {67872, 26, &rule14}, - {67903, 1, &rule2}, - {67968, 56, &rule14}, - {68030, 2, &rule14}, - {68096, 1, &rule14}, - {68097, 3, &rule90}, - {68101, 2, &rule90}, - {68108, 4, &rule90}, - {68112, 4, &rule14}, - {68117, 3, &rule14}, - {68121, 27, &rule14}, - {68152, 3, &rule90}, - {68159, 1, &rule90}, - {68160, 8, &rule17}, - {68176, 9, &rule2}, - {68192, 29, &rule14}, - {68221, 2, &rule17}, - {68223, 1, &rule2}, - {68224, 29, &rule14}, - {68253, 3, &rule17}, - {68288, 8, &rule14}, - {68296, 1, &rule13}, - {68297, 28, &rule14}, - {68325, 2, &rule90}, - {68331, 5, &rule17}, - {68336, 7, &rule2}, - {68352, 54, &rule14}, - {68409, 7, &rule2}, - {68416, 22, &rule14}, - {68440, 8, &rule17}, - {68448, 19, &rule14}, - {68472, 8, &rule17}, - {68480, 18, &rule14}, - {68505, 4, &rule2}, - {68521, 7, &rule17}, - {68608, 73, &rule14}, - {69216, 31, &rule17}, - {69632, 1, &rule122}, - {69633, 1, &rule90}, - {69634, 1, &rule122}, - {69635, 53, &rule14}, - {69688, 15, &rule90}, - {69703, 7, &rule2}, - {69714, 20, &rule17}, - {69734, 10, &rule8}, - {69759, 3, &rule90}, - {69762, 1, &rule122}, - {69763, 45, &rule14}, - {69808, 3, &rule122}, - {69811, 4, &rule90}, - {69815, 2, &rule122}, - {69817, 2, &rule90}, - {69819, 2, &rule2}, - {69821, 1, &rule16}, - {69822, 4, &rule2}, - {69840, 25, &rule14}, - {69872, 10, &rule8}, - {69888, 3, &rule90}, - {69891, 36, &rule14}, - {69927, 5, &rule90}, - {69932, 1, &rule122}, - {69933, 8, &rule90}, - {69942, 10, &rule8}, - {69952, 4, &rule2}, - {69968, 35, &rule14}, - {70003, 1, &rule90}, - {70004, 2, &rule2}, - {70006, 1, &rule14}, - {70016, 2, &rule90}, - {70018, 1, &rule122}, - {70019, 48, &rule14}, - {70067, 3, &rule122}, - {70070, 9, &rule90}, - {70079, 2, &rule122}, - {70081, 4, &rule14}, - {70085, 4, &rule2}, - {70093, 1, &rule2}, - {70096, 10, &rule8}, - {70106, 1, &rule14}, - {70113, 20, &rule17}, - {70144, 18, &rule14}, - {70163, 25, &rule14}, - {70188, 3, &rule122}, - {70191, 3, &rule90}, - {70194, 2, &rule122}, - {70196, 1, &rule90}, - {70197, 1, &rule122}, - {70198, 2, &rule90}, - {70200, 6, &rule2}, - {70320, 47, &rule14}, - {70367, 1, &rule90}, - {70368, 3, &rule122}, - {70371, 8, &rule90}, - {70384, 10, &rule8}, - {70401, 1, &rule90}, - {70402, 2, &rule122}, - {70405, 8, &rule14}, - {70415, 2, &rule14}, - {70419, 22, &rule14}, - {70442, 7, &rule14}, - {70450, 2, &rule14}, - {70453, 5, &rule14}, - {70460, 1, &rule90}, - {70461, 1, &rule14}, - {70462, 2, &rule122}, - {70464, 1, &rule90}, - {70465, 4, &rule122}, - {70471, 2, &rule122}, - {70475, 3, &rule122}, - {70487, 1, &rule122}, - {70493, 5, &rule14}, - {70498, 2, &rule122}, - {70502, 7, &rule90}, - {70512, 5, &rule90}, - {70784, 48, &rule14}, - {70832, 3, &rule122}, - {70835, 6, &rule90}, - {70841, 1, &rule122}, - {70842, 1, &rule90}, - {70843, 4, &rule122}, - {70847, 2, &rule90}, - {70849, 1, &rule122}, - {70850, 2, &rule90}, - {70852, 2, &rule14}, - {70854, 1, &rule2}, - {70855, 1, &rule14}, - {70864, 10, &rule8}, - {71040, 47, &rule14}, - {71087, 3, &rule122}, - {71090, 4, &rule90}, - {71096, 4, &rule122}, - {71100, 2, &rule90}, - {71102, 1, &rule122}, - {71103, 2, &rule90}, - {71105, 9, &rule2}, - {71168, 48, &rule14}, - {71216, 3, &rule122}, - {71219, 8, &rule90}, - {71227, 2, &rule122}, - {71229, 1, &rule90}, - {71230, 1, &rule122}, - {71231, 2, &rule90}, - {71233, 3, &rule2}, - {71236, 1, &rule14}, - {71248, 10, &rule8}, - {71296, 43, &rule14}, - {71339, 1, &rule90}, - {71340, 1, &rule122}, - {71341, 1, &rule90}, - {71342, 2, &rule122}, - {71344, 6, &rule90}, - {71350, 1, &rule122}, - {71351, 1, &rule90}, - {71360, 10, &rule8}, - {71840, 32, &rule9}, - {71872, 32, &rule12}, - {71904, 10, &rule8}, - {71914, 9, &rule17}, - {71935, 1, &rule14}, - {72384, 57, &rule14}, - {73728, 921, &rule14}, - {74752, 111, &rule124}, - {74864, 5, &rule2}, - {77824, 1071, &rule14}, - {92160, 569, &rule14}, - {92736, 31, &rule14}, - {92768, 10, &rule8}, - {92782, 2, &rule2}, - {92880, 30, &rule14}, - {92912, 5, &rule90}, - {92917, 1, &rule2}, - {92928, 48, &rule14}, - {92976, 7, &rule90}, - {92983, 5, &rule2}, - {92988, 4, &rule13}, - {92992, 4, &rule89}, - {92996, 1, &rule2}, - {92997, 1, &rule13}, - {93008, 10, &rule8}, - {93019, 7, &rule17}, - {93027, 21, &rule14}, - {93053, 19, &rule14}, - {93952, 69, &rule14}, - {94032, 1, &rule14}, - {94033, 46, &rule122}, - {94095, 4, &rule90}, - {94099, 13, &rule89}, - {110592, 2, &rule14}, - {113664, 107, &rule14}, - {113776, 13, &rule14}, - {113792, 9, &rule14}, - {113808, 10, &rule14}, - {113820, 1, &rule13}, - {113821, 2, &rule90}, - {113823, 1, &rule2}, - {113824, 4, &rule16}, - {118784, 246, &rule13}, - {119040, 39, &rule13}, - {119081, 60, &rule13}, - {119141, 2, &rule122}, - {119143, 3, &rule90}, - {119146, 3, &rule13}, - {119149, 6, &rule122}, - {119155, 8, &rule16}, - {119163, 8, &rule90}, - {119171, 2, &rule13}, - {119173, 7, &rule90}, - {119180, 30, &rule13}, - {119210, 4, &rule90}, - {119214, 48, &rule13}, - {119296, 66, &rule13}, - {119362, 3, &rule90}, - {119365, 1, &rule13}, - {119552, 87, &rule13}, - {119648, 18, &rule17}, - {119808, 26, &rule105}, - {119834, 26, &rule20}, - {119860, 26, &rule105}, - {119886, 7, &rule20}, - {119894, 18, &rule20}, - {119912, 26, &rule105}, - {119938, 26, &rule20}, - {119964, 1, &rule105}, - {119966, 2, &rule105}, - {119970, 1, &rule105}, - {119973, 2, &rule105}, - {119977, 4, &rule105}, - {119982, 8, &rule105}, - {119990, 4, &rule20}, - {119995, 1, &rule20}, - {119997, 7, &rule20}, - {120005, 11, &rule20}, - {120016, 26, &rule105}, - {120042, 26, &rule20}, - {120068, 2, &rule105}, - {120071, 4, &rule105}, - {120077, 8, &rule105}, - {120086, 7, &rule105}, - {120094, 26, &rule20}, - {120120, 2, &rule105}, - {120123, 4, &rule105}, - {120128, 5, &rule105}, - {120134, 1, &rule105}, - {120138, 7, &rule105}, - {120146, 26, &rule20}, - {120172, 26, &rule105}, - {120198, 26, &rule20}, - {120224, 26, &rule105}, - {120250, 26, &rule20}, - {120276, 26, &rule105}, - {120302, 26, &rule20}, - {120328, 26, &rule105}, - {120354, 26, &rule20}, - {120380, 26, &rule105}, - {120406, 26, &rule20}, - {120432, 26, &rule105}, - {120458, 28, &rule20}, - {120488, 25, &rule105}, - {120513, 1, &rule6}, - {120514, 25, &rule20}, - {120539, 1, &rule6}, - {120540, 6, &rule20}, - {120546, 25, &rule105}, - {120571, 1, &rule6}, - {120572, 25, &rule20}, - {120597, 1, &rule6}, - {120598, 6, &rule20}, - {120604, 25, &rule105}, - {120629, 1, &rule6}, - {120630, 25, &rule20}, - {120655, 1, &rule6}, - {120656, 6, &rule20}, - {120662, 25, &rule105}, - {120687, 1, &rule6}, - {120688, 25, &rule20}, - {120713, 1, &rule6}, - {120714, 6, &rule20}, - {120720, 25, &rule105}, - {120745, 1, &rule6}, - {120746, 25, &rule20}, - {120771, 1, &rule6}, - {120772, 6, &rule20}, - {120778, 1, &rule105}, - {120779, 1, &rule20}, - {120782, 50, &rule8}, - {124928, 197, &rule14}, - {125127, 9, &rule17}, - {125136, 7, &rule90}, - {126464, 4, &rule14}, - {126469, 27, &rule14}, - {126497, 2, &rule14}, - {126500, 1, &rule14}, - {126503, 1, &rule14}, - {126505, 10, &rule14}, - {126516, 4, &rule14}, - {126521, 1, &rule14}, - {126523, 1, &rule14}, - {126530, 1, &rule14}, - {126535, 1, &rule14}, - {126537, 1, &rule14}, - {126539, 1, &rule14}, - {126541, 3, &rule14}, - {126545, 2, &rule14}, - {126548, 1, &rule14}, - {126551, 1, &rule14}, - {126553, 1, &rule14}, - {126555, 1, &rule14}, - {126557, 1, &rule14}, - {126559, 1, &rule14}, - {126561, 2, &rule14}, - {126564, 1, &rule14}, - {126567, 4, &rule14}, - {126572, 7, &rule14}, - {126580, 4, &rule14}, - {126585, 4, &rule14}, - {126590, 1, &rule14}, - {126592, 10, &rule14}, - {126603, 17, &rule14}, - {126625, 3, &rule14}, - {126629, 5, &rule14}, - {126635, 17, &rule14}, - {126704, 2, &rule6}, - {126976, 44, &rule13}, - {127024, 100, &rule13}, - {127136, 15, &rule13}, - {127153, 15, &rule13}, - {127169, 15, &rule13}, - {127185, 37, &rule13}, - {127232, 13, &rule17}, - {127248, 31, &rule13}, - {127280, 60, &rule13}, - {127344, 43, &rule13}, - {127462, 29, &rule13}, - {127504, 43, &rule13}, - {127552, 9, &rule13}, - {127568, 2, &rule13}, - {127744, 45, &rule13}, - {127792, 78, &rule13}, - {127872, 79, &rule13}, - {127956, 36, &rule13}, - {128000, 255, &rule13}, - {128256, 75, &rule13}, - {128336, 42, &rule13}, - {128379, 41, &rule13}, - {128421, 158, &rule13}, - {128581, 139, &rule13}, - {128736, 13, &rule13}, - {128752, 4, &rule13}, - {128768, 116, &rule13}, - {128896, 85, &rule13}, - {129024, 12, &rule13}, - {129040, 56, &rule13}, - {129104, 10, &rule13}, - {129120, 40, &rule13}, - {129168, 30, &rule13}, - {131072, 42711, &rule14}, - {173824, 4149, &rule14}, - {177984, 222, &rule14}, - {194560, 542, &rule14}, - {917505, 1, &rule16}, - {917536, 96, &rule16}, - {917760, 240, &rule90}, - {983040, 65534, &rule178}, - {1048576, 65534, &rule178} -}; -static const struct _charblock_ convchars[]={ - {65, 26, &rule9}, - {97, 26, &rule12}, - {181, 1, &rule18}, - {192, 23, &rule9}, - {216, 7, &rule9}, - {224, 23, &rule12}, - {248, 7, &rule12}, - {255, 1, &rule21}, - {256, 1, &rule22}, - {257, 1, &rule23}, - {258, 1, &rule22}, - {259, 1, &rule23}, - {260, 1, &rule22}, - {261, 1, &rule23}, - {262, 1, &rule22}, - {263, 1, &rule23}, - {264, 1, &rule22}, - {265, 1, &rule23}, - {266, 1, &rule22}, - {267, 1, &rule23}, - {268, 1, &rule22}, - {269, 1, &rule23}, - {270, 1, &rule22}, - {271, 1, &rule23}, - {272, 1, &rule22}, - {273, 1, &rule23}, - {274, 1, &rule22}, - {275, 1, &rule23}, - {276, 1, &rule22}, - {277, 1, &rule23}, - {278, 1, &rule22}, - {279, 1, &rule23}, - {280, 1, &rule22}, - {281, 1, &rule23}, - {282, 1, &rule22}, - {283, 1, &rule23}, - {284, 1, &rule22}, - {285, 1, &rule23}, - {286, 1, &rule22}, - {287, 1, &rule23}, - {288, 1, &rule22}, - {289, 1, &rule23}, - {290, 1, &rule22}, - {291, 1, &rule23}, - {292, 1, &rule22}, - {293, 1, &rule23}, - {294, 1, &rule22}, - {295, 1, &rule23}, - {296, 1, &rule22}, - {297, 1, &rule23}, - {298, 1, &rule22}, - {299, 1, &rule23}, - {300, 1, &rule22}, - {301, 1, &rule23}, - {302, 1, &rule22}, - {303, 1, &rule23}, - {304, 1, &rule24}, - {305, 1, &rule25}, - {306, 1, &rule22}, - {307, 1, &rule23}, - {308, 1, &rule22}, - {309, 1, &rule23}, - {310, 1, &rule22}, - {311, 1, &rule23}, - {313, 1, &rule22}, - {314, 1, &rule23}, - {315, 1, &rule22}, - {316, 1, &rule23}, - {317, 1, &rule22}, - {318, 1, &rule23}, - {319, 1, &rule22}, - {320, 1, &rule23}, - {321, 1, &rule22}, - {322, 1, &rule23}, - {323, 1, &rule22}, - {324, 1, &rule23}, - {325, 1, &rule22}, - {326, 1, &rule23}, - {327, 1, &rule22}, - {328, 1, &rule23}, - {330, 1, &rule22}, - {331, 1, &rule23}, - {332, 1, &rule22}, - {333, 1, &rule23}, - {334, 1, &rule22}, - {335, 1, &rule23}, - {336, 1, &rule22}, - {337, 1, &rule23}, - {338, 1, &rule22}, - {339, 1, &rule23}, - {340, 1, &rule22}, - {341, 1, &rule23}, - {342, 1, &rule22}, - {343, 1, &rule23}, - {344, 1, &rule22}, - {345, 1, &rule23}, - {346, 1, &rule22}, - {347, 1, &rule23}, - {348, 1, &rule22}, - {349, 1, &rule23}, - {350, 1, &rule22}, - {351, 1, &rule23}, - {352, 1, &rule22}, - {353, 1, &rule23}, - {354, 1, &rule22}, - {355, 1, &rule23}, - {356, 1, &rule22}, - {357, 1, &rule23}, - {358, 1, &rule22}, - {359, 1, &rule23}, - {360, 1, &rule22}, - {361, 1, &rule23}, - {362, 1, &rule22}, - {363, 1, &rule23}, - {364, 1, &rule22}, - {365, 1, &rule23}, - {366, 1, &rule22}, - {367, 1, &rule23}, - {368, 1, &rule22}, - {369, 1, &rule23}, - {370, 1, &rule22}, - {371, 1, &rule23}, - {372, 1, &rule22}, - {373, 1, &rule23}, - {374, 1, &rule22}, - {375, 1, &rule23}, - {376, 1, &rule26}, - {377, 1, &rule22}, - {378, 1, &rule23}, - {379, 1, &rule22}, - {380, 1, &rule23}, - {381, 1, &rule22}, - {382, 1, &rule23}, - {383, 1, &rule27}, - {384, 1, &rule28}, - {385, 1, &rule29}, - {386, 1, &rule22}, - {387, 1, &rule23}, - {388, 1, &rule22}, - {389, 1, &rule23}, - {390, 1, &rule30}, - {391, 1, &rule22}, - {392, 1, &rule23}, - {393, 2, &rule31}, - {395, 1, &rule22}, - {396, 1, &rule23}, - {398, 1, &rule32}, - {399, 1, &rule33}, - {400, 1, &rule34}, - {401, 1, &rule22}, - {402, 1, &rule23}, - {403, 1, &rule31}, - {404, 1, &rule35}, - {405, 1, &rule36}, - {406, 1, &rule37}, - {407, 1, &rule38}, - {408, 1, &rule22}, - {409, 1, &rule23}, - {410, 1, &rule39}, - {412, 1, &rule37}, - {413, 1, &rule40}, - {414, 1, &rule41}, - {415, 1, &rule42}, - {416, 1, &rule22}, - {417, 1, &rule23}, - {418, 1, &rule22}, - {419, 1, &rule23}, - {420, 1, &rule22}, - {421, 1, &rule23}, - {422, 1, &rule43}, - {423, 1, &rule22}, - {424, 1, &rule23}, - {425, 1, &rule43}, - {428, 1, &rule22}, - {429, 1, &rule23}, - {430, 1, &rule43}, - {431, 1, &rule22}, - {432, 1, &rule23}, - {433, 2, &rule44}, - {435, 1, &rule22}, - {436, 1, &rule23}, - {437, 1, &rule22}, - {438, 1, &rule23}, - {439, 1, &rule45}, - {440, 1, &rule22}, - {441, 1, &rule23}, - {444, 1, &rule22}, - {445, 1, &rule23}, - {447, 1, &rule46}, - {452, 1, &rule47}, - {453, 1, &rule48}, - {454, 1, &rule49}, - {455, 1, &rule47}, - {456, 1, &rule48}, - {457, 1, &rule49}, - {458, 1, &rule47}, - {459, 1, &rule48}, - {460, 1, &rule49}, - {461, 1, &rule22}, - {462, 1, &rule23}, - {463, 1, &rule22}, - {464, 1, &rule23}, - {465, 1, &rule22}, - {466, 1, &rule23}, - {467, 1, &rule22}, - {468, 1, &rule23}, - {469, 1, &rule22}, - {470, 1, &rule23}, - {471, 1, &rule22}, - {472, 1, &rule23}, - {473, 1, &rule22}, - {474, 1, &rule23}, - {475, 1, &rule22}, - {476, 1, &rule23}, - {477, 1, &rule50}, - {478, 1, &rule22}, - {479, 1, &rule23}, - {480, 1, &rule22}, - {481, 1, &rule23}, - {482, 1, &rule22}, - {483, 1, &rule23}, - {484, 1, &rule22}, - {485, 1, &rule23}, - {486, 1, &rule22}, - {487, 1, &rule23}, - {488, 1, &rule22}, - {489, 1, &rule23}, - {490, 1, &rule22}, - {491, 1, &rule23}, - {492, 1, &rule22}, - {493, 1, &rule23}, - {494, 1, &rule22}, - {495, 1, &rule23}, - {497, 1, &rule47}, - {498, 1, &rule48}, - {499, 1, &rule49}, - {500, 1, &rule22}, - {501, 1, &rule23}, - {502, 1, &rule51}, - {503, 1, &rule52}, - {504, 1, &rule22}, - {505, 1, &rule23}, - {506, 1, &rule22}, - {507, 1, &rule23}, - {508, 1, &rule22}, - {509, 1, &rule23}, - {510, 1, &rule22}, - {511, 1, &rule23}, - {512, 1, &rule22}, - {513, 1, &rule23}, - {514, 1, &rule22}, - {515, 1, &rule23}, - {516, 1, &rule22}, - {517, 1, &rule23}, - {518, 1, &rule22}, - {519, 1, &rule23}, - {520, 1, &rule22}, - {521, 1, &rule23}, - {522, 1, &rule22}, - {523, 1, &rule23}, - {524, 1, &rule22}, - {525, 1, &rule23}, - {526, 1, &rule22}, - {527, 1, &rule23}, - {528, 1, &rule22}, - {529, 1, &rule23}, - {530, 1, &rule22}, - {531, 1, &rule23}, - {532, 1, &rule22}, - {533, 1, &rule23}, - {534, 1, &rule22}, - {535, 1, &rule23}, - {536, 1, &rule22}, - {537, 1, &rule23}, - {538, 1, &rule22}, - {539, 1, &rule23}, - {540, 1, &rule22}, - {541, 1, &rule23}, - {542, 1, &rule22}, - {543, 1, &rule23}, - {544, 1, &rule53}, - {546, 1, &rule22}, - {547, 1, &rule23}, - {548, 1, &rule22}, - {549, 1, &rule23}, - {550, 1, &rule22}, - {551, 1, &rule23}, - {552, 1, &rule22}, - {553, 1, &rule23}, - {554, 1, &rule22}, - {555, 1, &rule23}, - {556, 1, &rule22}, - {557, 1, &rule23}, - {558, 1, &rule22}, - {559, 1, &rule23}, - {560, 1, &rule22}, - {561, 1, &rule23}, - {562, 1, &rule22}, - {563, 1, &rule23}, - {570, 1, &rule54}, - {571, 1, &rule22}, - {572, 1, &rule23}, - {573, 1, &rule55}, - {574, 1, &rule56}, - {575, 2, &rule57}, - {577, 1, &rule22}, - {578, 1, &rule23}, - {579, 1, &rule58}, - {580, 1, &rule59}, - {581, 1, &rule60}, - {582, 1, &rule22}, - {583, 1, &rule23}, - {584, 1, &rule22}, - {585, 1, &rule23}, - {586, 1, &rule22}, - {587, 1, &rule23}, - {588, 1, &rule22}, - {589, 1, &rule23}, - {590, 1, &rule22}, - {591, 1, &rule23}, - {592, 1, &rule61}, - {593, 1, &rule62}, - {594, 1, &rule63}, - {595, 1, &rule64}, - {596, 1, &rule65}, - {598, 2, &rule66}, - {601, 1, &rule67}, - {603, 1, &rule68}, - {604, 1, &rule69}, - {608, 1, &rule66}, - {609, 1, &rule70}, - {611, 1, &rule71}, - {613, 1, &rule72}, - {614, 1, &rule73}, - {616, 1, &rule74}, - {617, 1, &rule75}, - {619, 1, &rule76}, - {620, 1, &rule77}, - {623, 1, &rule75}, - {625, 1, &rule78}, - {626, 1, &rule79}, - {629, 1, &rule80}, - {637, 1, &rule81}, - {640, 1, &rule82}, - {643, 1, &rule82}, - {647, 1, &rule83}, - {648, 1, &rule82}, - {649, 1, &rule84}, - {650, 2, &rule85}, - {652, 1, &rule86}, - {658, 1, &rule87}, - {670, 1, &rule88}, - {837, 1, &rule91}, - {880, 1, &rule22}, - {881, 1, &rule23}, - {882, 1, &rule22}, - {883, 1, &rule23}, - {886, 1, &rule22}, - {887, 1, &rule23}, - {891, 3, &rule41}, - {895, 1, &rule92}, - {902, 1, &rule93}, - {904, 3, &rule94}, - {908, 1, &rule95}, - {910, 2, &rule96}, - {913, 17, &rule9}, - {931, 9, &rule9}, - {940, 1, &rule97}, - {941, 3, &rule98}, - {945, 17, &rule12}, - {962, 1, &rule99}, - {963, 9, &rule12}, - {972, 1, &rule100}, - {973, 2, &rule101}, - {975, 1, &rule102}, - {976, 1, &rule103}, - {977, 1, &rule104}, - {981, 1, &rule106}, - {982, 1, &rule107}, - {983, 1, &rule108}, - {984, 1, &rule22}, - {985, 1, &rule23}, - {986, 1, &rule22}, - {987, 1, &rule23}, - {988, 1, &rule22}, - {989, 1, &rule23}, - {990, 1, &rule22}, - {991, 1, &rule23}, - {992, 1, &rule22}, - {993, 1, &rule23}, - {994, 1, &rule22}, - {995, 1, &rule23}, - {996, 1, &rule22}, - {997, 1, &rule23}, - {998, 1, &rule22}, - {999, 1, &rule23}, - {1000, 1, &rule22}, - {1001, 1, &rule23}, - {1002, 1, &rule22}, - {1003, 1, &rule23}, - {1004, 1, &rule22}, - {1005, 1, &rule23}, - {1006, 1, &rule22}, - {1007, 1, &rule23}, - {1008, 1, &rule109}, - {1009, 1, &rule110}, - {1010, 1, &rule111}, - {1011, 1, &rule112}, - {1012, 1, &rule113}, - {1013, 1, &rule114}, - {1015, 1, &rule22}, - {1016, 1, &rule23}, - {1017, 1, &rule115}, - {1018, 1, &rule22}, - {1019, 1, &rule23}, - {1021, 3, &rule53}, - {1024, 16, &rule116}, - {1040, 32, &rule9}, - {1072, 32, &rule12}, - {1104, 16, &rule110}, - {1120, 1, &rule22}, - {1121, 1, &rule23}, - {1122, 1, &rule22}, - {1123, 1, &rule23}, - {1124, 1, &rule22}, - {1125, 1, &rule23}, - {1126, 1, &rule22}, - {1127, 1, &rule23}, - {1128, 1, &rule22}, - {1129, 1, &rule23}, - {1130, 1, &rule22}, - {1131, 1, &rule23}, - {1132, 1, &rule22}, - {1133, 1, &rule23}, - {1134, 1, &rule22}, - {1135, 1, &rule23}, - {1136, 1, &rule22}, - {1137, 1, &rule23}, - {1138, 1, &rule22}, - {1139, 1, &rule23}, - {1140, 1, &rule22}, - {1141, 1, &rule23}, - {1142, 1, &rule22}, - {1143, 1, &rule23}, - {1144, 1, &rule22}, - {1145, 1, &rule23}, - {1146, 1, &rule22}, - {1147, 1, &rule23}, - {1148, 1, &rule22}, - {1149, 1, &rule23}, - {1150, 1, &rule22}, - {1151, 1, &rule23}, - {1152, 1, &rule22}, - {1153, 1, &rule23}, - {1162, 1, &rule22}, - {1163, 1, &rule23}, - {1164, 1, &rule22}, - {1165, 1, &rule23}, - {1166, 1, &rule22}, - {1167, 1, &rule23}, - {1168, 1, &rule22}, - {1169, 1, &rule23}, - {1170, 1, &rule22}, - {1171, 1, &rule23}, - {1172, 1, &rule22}, - {1173, 1, &rule23}, - {1174, 1, &rule22}, - {1175, 1, &rule23}, - {1176, 1, &rule22}, - {1177, 1, &rule23}, - {1178, 1, &rule22}, - {1179, 1, &rule23}, - {1180, 1, &rule22}, - {1181, 1, &rule23}, - {1182, 1, &rule22}, - {1183, 1, &rule23}, - {1184, 1, &rule22}, - {1185, 1, &rule23}, - {1186, 1, &rule22}, - {1187, 1, &rule23}, - {1188, 1, &rule22}, - {1189, 1, &rule23}, - {1190, 1, &rule22}, - {1191, 1, &rule23}, - {1192, 1, &rule22}, - {1193, 1, &rule23}, - {1194, 1, &rule22}, - {1195, 1, &rule23}, - {1196, 1, &rule22}, - {1197, 1, &rule23}, - {1198, 1, &rule22}, - {1199, 1, &rule23}, - {1200, 1, &rule22}, - {1201, 1, &rule23}, - {1202, 1, &rule22}, - {1203, 1, &rule23}, - {1204, 1, &rule22}, - {1205, 1, &rule23}, - {1206, 1, &rule22}, - {1207, 1, &rule23}, - {1208, 1, &rule22}, - {1209, 1, &rule23}, - {1210, 1, &rule22}, - {1211, 1, &rule23}, - {1212, 1, &rule22}, - {1213, 1, &rule23}, - {1214, 1, &rule22}, - {1215, 1, &rule23}, - {1216, 1, &rule118}, - {1217, 1, &rule22}, - {1218, 1, &rule23}, - {1219, 1, &rule22}, - {1220, 1, &rule23}, - {1221, 1, &rule22}, - {1222, 1, &rule23}, - {1223, 1, &rule22}, - {1224, 1, &rule23}, - {1225, 1, &rule22}, - {1226, 1, &rule23}, - {1227, 1, &rule22}, - {1228, 1, &rule23}, - {1229, 1, &rule22}, - {1230, 1, &rule23}, - {1231, 1, &rule119}, - {1232, 1, &rule22}, - {1233, 1, &rule23}, - {1234, 1, &rule22}, - {1235, 1, &rule23}, - {1236, 1, &rule22}, - {1237, 1, &rule23}, - {1238, 1, &rule22}, - {1239, 1, &rule23}, - {1240, 1, &rule22}, - {1241, 1, &rule23}, - {1242, 1, &rule22}, - {1243, 1, &rule23}, - {1244, 1, &rule22}, - {1245, 1, &rule23}, - {1246, 1, &rule22}, - {1247, 1, &rule23}, - {1248, 1, &rule22}, - {1249, 1, &rule23}, - {1250, 1, &rule22}, - {1251, 1, &rule23}, - {1252, 1, &rule22}, - {1253, 1, &rule23}, - {1254, 1, &rule22}, - {1255, 1, &rule23}, - {1256, 1, &rule22}, - {1257, 1, &rule23}, - {1258, 1, &rule22}, - {1259, 1, &rule23}, - {1260, 1, &rule22}, - {1261, 1, &rule23}, - {1262, 1, &rule22}, - {1263, 1, &rule23}, - {1264, 1, &rule22}, - {1265, 1, &rule23}, - {1266, 1, &rule22}, - {1267, 1, &rule23}, - {1268, 1, &rule22}, - {1269, 1, &rule23}, - {1270, 1, &rule22}, - {1271, 1, &rule23}, - {1272, 1, &rule22}, - {1273, 1, &rule23}, - {1274, 1, &rule22}, - {1275, 1, &rule23}, - {1276, 1, &rule22}, - {1277, 1, &rule23}, - {1278, 1, &rule22}, - {1279, 1, &rule23}, - {1280, 1, &rule22}, - {1281, 1, &rule23}, - {1282, 1, &rule22}, - {1283, 1, &rule23}, - {1284, 1, &rule22}, - {1285, 1, &rule23}, - {1286, 1, &rule22}, - {1287, 1, &rule23}, - {1288, 1, &rule22}, - {1289, 1, &rule23}, - {1290, 1, &rule22}, - {1291, 1, &rule23}, - {1292, 1, &rule22}, - {1293, 1, &rule23}, - {1294, 1, &rule22}, - {1295, 1, &rule23}, - {1296, 1, &rule22}, - {1297, 1, &rule23}, - {1298, 1, &rule22}, - {1299, 1, &rule23}, - {1300, 1, &rule22}, - {1301, 1, &rule23}, - {1302, 1, &rule22}, - {1303, 1, &rule23}, - {1304, 1, &rule22}, - {1305, 1, &rule23}, - {1306, 1, &rule22}, - {1307, 1, &rule23}, - {1308, 1, &rule22}, - {1309, 1, &rule23}, - {1310, 1, &rule22}, - {1311, 1, &rule23}, - {1312, 1, &rule22}, - {1313, 1, &rule23}, - {1314, 1, &rule22}, - {1315, 1, &rule23}, - {1316, 1, &rule22}, - {1317, 1, &rule23}, - {1318, 1, &rule22}, - {1319, 1, &rule23}, - {1320, 1, &rule22}, - {1321, 1, &rule23}, - {1322, 1, &rule22}, - {1323, 1, &rule23}, - {1324, 1, &rule22}, - {1325, 1, &rule23}, - {1326, 1, &rule22}, - {1327, 1, &rule23}, - {1329, 38, &rule120}, - {1377, 38, &rule121}, - {4256, 38, &rule123}, - {4295, 1, &rule123}, - {4301, 1, &rule123}, - {7545, 1, &rule125}, - {7549, 1, &rule126}, - {7680, 1, &rule22}, - {7681, 1, &rule23}, - {7682, 1, &rule22}, - {7683, 1, &rule23}, - {7684, 1, &rule22}, - {7685, 1, &rule23}, - {7686, 1, &rule22}, - {7687, 1, &rule23}, - {7688, 1, &rule22}, - {7689, 1, &rule23}, - {7690, 1, &rule22}, - {7691, 1, &rule23}, - {7692, 1, &rule22}, - {7693, 1, &rule23}, - {7694, 1, &rule22}, - {7695, 1, &rule23}, - {7696, 1, &rule22}, - {7697, 1, &rule23}, - {7698, 1, &rule22}, - {7699, 1, &rule23}, - {7700, 1, &rule22}, - {7701, 1, &rule23}, - {7702, 1, &rule22}, - {7703, 1, &rule23}, - {7704, 1, &rule22}, - {7705, 1, &rule23}, - {7706, 1, &rule22}, - {7707, 1, &rule23}, - {7708, 1, &rule22}, - {7709, 1, &rule23}, - {7710, 1, &rule22}, - {7711, 1, &rule23}, - {7712, 1, &rule22}, - {7713, 1, &rule23}, - {7714, 1, &rule22}, - {7715, 1, &rule23}, - {7716, 1, &rule22}, - {7717, 1, &rule23}, - {7718, 1, &rule22}, - {7719, 1, &rule23}, - {7720, 1, &rule22}, - {7721, 1, &rule23}, - {7722, 1, &rule22}, - {7723, 1, &rule23}, - {7724, 1, &rule22}, - {7725, 1, &rule23}, - {7726, 1, &rule22}, - {7727, 1, &rule23}, - {7728, 1, &rule22}, - {7729, 1, &rule23}, - {7730, 1, &rule22}, - {7731, 1, &rule23}, - {7732, 1, &rule22}, - {7733, 1, &rule23}, - {7734, 1, &rule22}, - {7735, 1, &rule23}, - {7736, 1, &rule22}, - {7737, 1, &rule23}, - {7738, 1, &rule22}, - {7739, 1, &rule23}, - {7740, 1, &rule22}, - {7741, 1, &rule23}, - {7742, 1, &rule22}, - {7743, 1, &rule23}, - {7744, 1, &rule22}, - {7745, 1, &rule23}, - {7746, 1, &rule22}, - {7747, 1, &rule23}, - {7748, 1, &rule22}, - {7749, 1, &rule23}, - {7750, 1, &rule22}, - {7751, 1, &rule23}, - {7752, 1, &rule22}, - {7753, 1, &rule23}, - {7754, 1, &rule22}, - {7755, 1, &rule23}, - {7756, 1, &rule22}, - {7757, 1, &rule23}, - {7758, 1, &rule22}, - {7759, 1, &rule23}, - {7760, 1, &rule22}, - {7761, 1, &rule23}, - {7762, 1, &rule22}, - {7763, 1, &rule23}, - {7764, 1, &rule22}, - {7765, 1, &rule23}, - {7766, 1, &rule22}, - {7767, 1, &rule23}, - {7768, 1, &rule22}, - {7769, 1, &rule23}, - {7770, 1, &rule22}, - {7771, 1, &rule23}, - {7772, 1, &rule22}, - {7773, 1, &rule23}, - {7774, 1, &rule22}, - {7775, 1, &rule23}, - {7776, 1, &rule22}, - {7777, 1, &rule23}, - {7778, 1, &rule22}, - {7779, 1, &rule23}, - {7780, 1, &rule22}, - {7781, 1, &rule23}, - {7782, 1, &rule22}, - {7783, 1, &rule23}, - {7784, 1, &rule22}, - {7785, 1, &rule23}, - {7786, 1, &rule22}, - {7787, 1, &rule23}, - {7788, 1, &rule22}, - {7789, 1, &rule23}, - {7790, 1, &rule22}, - {7791, 1, &rule23}, - {7792, 1, &rule22}, - {7793, 1, &rule23}, - {7794, 1, &rule22}, - {7795, 1, &rule23}, - {7796, 1, &rule22}, - {7797, 1, &rule23}, - {7798, 1, &rule22}, - {7799, 1, &rule23}, - {7800, 1, &rule22}, - {7801, 1, &rule23}, - {7802, 1, &rule22}, - {7803, 1, &rule23}, - {7804, 1, &rule22}, - {7805, 1, &rule23}, - {7806, 1, &rule22}, - {7807, 1, &rule23}, - {7808, 1, &rule22}, - {7809, 1, &rule23}, - {7810, 1, &rule22}, - {7811, 1, &rule23}, - {7812, 1, &rule22}, - {7813, 1, &rule23}, - {7814, 1, &rule22}, - {7815, 1, &rule23}, - {7816, 1, &rule22}, - {7817, 1, &rule23}, - {7818, 1, &rule22}, - {7819, 1, &rule23}, - {7820, 1, &rule22}, - {7821, 1, &rule23}, - {7822, 1, &rule22}, - {7823, 1, &rule23}, - {7824, 1, &rule22}, - {7825, 1, &rule23}, - {7826, 1, &rule22}, - {7827, 1, &rule23}, - {7828, 1, &rule22}, - {7829, 1, &rule23}, - {7835, 1, &rule127}, - {7838, 1, &rule128}, - {7840, 1, &rule22}, - {7841, 1, &rule23}, - {7842, 1, &rule22}, - {7843, 1, &rule23}, - {7844, 1, &rule22}, - {7845, 1, &rule23}, - {7846, 1, &rule22}, - {7847, 1, &rule23}, - {7848, 1, &rule22}, - {7849, 1, &rule23}, - {7850, 1, &rule22}, - {7851, 1, &rule23}, - {7852, 1, &rule22}, - {7853, 1, &rule23}, - {7854, 1, &rule22}, - {7855, 1, &rule23}, - {7856, 1, &rule22}, - {7857, 1, &rule23}, - {7858, 1, &rule22}, - {7859, 1, &rule23}, - {7860, 1, &rule22}, - {7861, 1, &rule23}, - {7862, 1, &rule22}, - {7863, 1, &rule23}, - {7864, 1, &rule22}, - {7865, 1, &rule23}, - {7866, 1, &rule22}, - {7867, 1, &rule23}, - {7868, 1, &rule22}, - {7869, 1, &rule23}, - {7870, 1, &rule22}, - {7871, 1, &rule23}, - {7872, 1, &rule22}, - {7873, 1, &rule23}, - {7874, 1, &rule22}, - {7875, 1, &rule23}, - {7876, 1, &rule22}, - {7877, 1, &rule23}, - {7878, 1, &rule22}, - {7879, 1, &rule23}, - {7880, 1, &rule22}, - {7881, 1, &rule23}, - {7882, 1, &rule22}, - {7883, 1, &rule23}, - {7884, 1, &rule22}, - {7885, 1, &rule23}, - {7886, 1, &rule22}, - {7887, 1, &rule23}, - {7888, 1, &rule22}, - {7889, 1, &rule23}, - {7890, 1, &rule22}, - {7891, 1, &rule23}, - {7892, 1, &rule22}, - {7893, 1, &rule23}, - {7894, 1, &rule22}, - {7895, 1, &rule23}, - {7896, 1, &rule22}, - {7897, 1, &rule23}, - {7898, 1, &rule22}, - {7899, 1, &rule23}, - {7900, 1, &rule22}, - {7901, 1, &rule23}, - {7902, 1, &rule22}, - {7903, 1, &rule23}, - {7904, 1, &rule22}, - {7905, 1, &rule23}, - {7906, 1, &rule22}, - {7907, 1, &rule23}, - {7908, 1, &rule22}, - {7909, 1, &rule23}, - {7910, 1, &rule22}, - {7911, 1, &rule23}, - {7912, 1, &rule22}, - {7913, 1, &rule23}, - {7914, 1, &rule22}, - {7915, 1, &rule23}, - {7916, 1, &rule22}, - {7917, 1, &rule23}, - {7918, 1, &rule22}, - {7919, 1, &rule23}, - {7920, 1, &rule22}, - {7921, 1, &rule23}, - {7922, 1, &rule22}, - {7923, 1, &rule23}, - {7924, 1, &rule22}, - {7925, 1, &rule23}, - {7926, 1, &rule22}, - {7927, 1, &rule23}, - {7928, 1, &rule22}, - {7929, 1, &rule23}, - {7930, 1, &rule22}, - {7931, 1, &rule23}, - {7932, 1, &rule22}, - {7933, 1, &rule23}, - {7934, 1, &rule22}, - {7935, 1, &rule23}, - {7936, 8, &rule129}, - {7944, 8, &rule130}, - {7952, 6, &rule129}, - {7960, 6, &rule130}, - {7968, 8, &rule129}, - {7976, 8, &rule130}, - {7984, 8, &rule129}, - {7992, 8, &rule130}, - {8000, 6, &rule129}, - {8008, 6, &rule130}, - {8017, 1, &rule129}, - {8019, 1, &rule129}, - {8021, 1, &rule129}, - {8023, 1, &rule129}, - {8025, 1, &rule130}, - {8027, 1, &rule130}, - {8029, 1, &rule130}, - {8031, 1, &rule130}, - {8032, 8, &rule129}, - {8040, 8, &rule130}, - {8048, 2, &rule131}, - {8050, 4, &rule132}, - {8054, 2, &rule133}, - {8056, 2, &rule134}, - {8058, 2, &rule135}, - {8060, 2, &rule136}, - {8064, 8, &rule129}, - {8072, 8, &rule137}, - {8080, 8, &rule129}, - {8088, 8, &rule137}, - {8096, 8, &rule129}, - {8104, 8, &rule137}, - {8112, 2, &rule129}, - {8115, 1, &rule138}, - {8120, 2, &rule130}, - {8122, 2, &rule139}, - {8124, 1, &rule140}, - {8126, 1, &rule141}, - {8131, 1, &rule138}, - {8136, 4, &rule142}, - {8140, 1, &rule140}, - {8144, 2, &rule129}, - {8152, 2, &rule130}, - {8154, 2, &rule143}, - {8160, 2, &rule129}, - {8165, 1, &rule111}, - {8168, 2, &rule130}, - {8170, 2, &rule144}, - {8172, 1, &rule115}, - {8179, 1, &rule138}, - {8184, 2, &rule145}, - {8186, 2, &rule146}, - {8188, 1, &rule140}, - {8486, 1, &rule149}, - {8490, 1, &rule150}, - {8491, 1, &rule151}, - {8498, 1, &rule152}, - {8526, 1, &rule153}, - {8544, 16, &rule154}, - {8560, 16, &rule155}, - {8579, 1, &rule22}, - {8580, 1, &rule23}, - {9398, 26, &rule156}, - {9424, 26, &rule157}, - {11264, 47, &rule120}, - {11312, 47, &rule121}, - {11360, 1, &rule22}, - {11361, 1, &rule23}, - {11362, 1, &rule158}, - {11363, 1, &rule159}, - {11364, 1, &rule160}, - {11365, 1, &rule161}, - {11366, 1, &rule162}, - {11367, 1, &rule22}, - {11368, 1, &rule23}, - {11369, 1, &rule22}, - {11370, 1, &rule23}, - {11371, 1, &rule22}, - {11372, 1, &rule23}, - {11373, 1, &rule163}, - {11374, 1, &rule164}, - {11375, 1, &rule165}, - {11376, 1, &rule166}, - {11378, 1, &rule22}, - {11379, 1, &rule23}, - {11381, 1, &rule22}, - {11382, 1, &rule23}, - {11390, 2, &rule167}, - {11392, 1, &rule22}, - {11393, 1, &rule23}, - {11394, 1, &rule22}, - {11395, 1, &rule23}, - {11396, 1, &rule22}, - {11397, 1, &rule23}, - {11398, 1, &rule22}, - {11399, 1, &rule23}, - {11400, 1, &rule22}, - {11401, 1, &rule23}, - {11402, 1, &rule22}, - {11403, 1, &rule23}, - {11404, 1, &rule22}, - {11405, 1, &rule23}, - {11406, 1, &rule22}, - {11407, 1, &rule23}, - {11408, 1, &rule22}, - {11409, 1, &rule23}, - {11410, 1, &rule22}, - {11411, 1, &rule23}, - {11412, 1, &rule22}, - {11413, 1, &rule23}, - {11414, 1, &rule22}, - {11415, 1, &rule23}, - {11416, 1, &rule22}, - {11417, 1, &rule23}, - {11418, 1, &rule22}, - {11419, 1, &rule23}, - {11420, 1, &rule22}, - {11421, 1, &rule23}, - {11422, 1, &rule22}, - {11423, 1, &rule23}, - {11424, 1, &rule22}, - {11425, 1, &rule23}, - {11426, 1, &rule22}, - {11427, 1, &rule23}, - {11428, 1, &rule22}, - {11429, 1, &rule23}, - {11430, 1, &rule22}, - {11431, 1, &rule23}, - {11432, 1, &rule22}, - {11433, 1, &rule23}, - {11434, 1, &rule22}, - {11435, 1, &rule23}, - {11436, 1, &rule22}, - {11437, 1, &rule23}, - {11438, 1, &rule22}, - {11439, 1, &rule23}, - {11440, 1, &rule22}, - {11441, 1, &rule23}, - {11442, 1, &rule22}, - {11443, 1, &rule23}, - {11444, 1, &rule22}, - {11445, 1, &rule23}, - {11446, 1, &rule22}, - {11447, 1, &rule23}, - {11448, 1, &rule22}, - {11449, 1, &rule23}, - {11450, 1, &rule22}, - {11451, 1, &rule23}, - {11452, 1, &rule22}, - {11453, 1, &rule23}, - {11454, 1, &rule22}, - {11455, 1, &rule23}, - {11456, 1, &rule22}, - {11457, 1, &rule23}, - {11458, 1, &rule22}, - {11459, 1, &rule23}, - {11460, 1, &rule22}, - {11461, 1, &rule23}, - {11462, 1, &rule22}, - {11463, 1, &rule23}, - {11464, 1, &rule22}, - {11465, 1, &rule23}, - {11466, 1, &rule22}, - {11467, 1, &rule23}, - {11468, 1, &rule22}, - {11469, 1, &rule23}, - {11470, 1, &rule22}, - {11471, 1, &rule23}, - {11472, 1, &rule22}, - {11473, 1, &rule23}, - {11474, 1, &rule22}, - {11475, 1, &rule23}, - {11476, 1, &rule22}, - {11477, 1, &rule23}, - {11478, 1, &rule22}, - {11479, 1, &rule23}, - {11480, 1, &rule22}, - {11481, 1, &rule23}, - {11482, 1, &rule22}, - {11483, 1, &rule23}, - {11484, 1, &rule22}, - {11485, 1, &rule23}, - {11486, 1, &rule22}, - {11487, 1, &rule23}, - {11488, 1, &rule22}, - {11489, 1, &rule23}, - {11490, 1, &rule22}, - {11491, 1, &rule23}, - {11499, 1, &rule22}, - {11500, 1, &rule23}, - {11501, 1, &rule22}, - {11502, 1, &rule23}, - {11506, 1, &rule22}, - {11507, 1, &rule23}, - {11520, 38, &rule168}, - {11559, 1, &rule168}, - {11565, 1, &rule168}, - {42560, 1, &rule22}, - {42561, 1, &rule23}, - {42562, 1, &rule22}, - {42563, 1, &rule23}, - {42564, 1, &rule22}, - {42565, 1, &rule23}, - {42566, 1, &rule22}, - {42567, 1, &rule23}, - {42568, 1, &rule22}, - {42569, 1, &rule23}, - {42570, 1, &rule22}, - {42571, 1, &rule23}, - {42572, 1, &rule22}, - {42573, 1, &rule23}, - {42574, 1, &rule22}, - {42575, 1, &rule23}, - {42576, 1, &rule22}, - {42577, 1, &rule23}, - {42578, 1, &rule22}, - {42579, 1, &rule23}, - {42580, 1, &rule22}, - {42581, 1, &rule23}, - {42582, 1, &rule22}, - {42583, 1, &rule23}, - {42584, 1, &rule22}, - {42585, 1, &rule23}, - {42586, 1, &rule22}, - {42587, 1, &rule23}, - {42588, 1, &rule22}, - {42589, 1, &rule23}, - {42590, 1, &rule22}, - {42591, 1, &rule23}, - {42592, 1, &rule22}, - {42593, 1, &rule23}, - {42594, 1, &rule22}, - {42595, 1, &rule23}, - {42596, 1, &rule22}, - {42597, 1, &rule23}, - {42598, 1, &rule22}, - {42599, 1, &rule23}, - {42600, 1, &rule22}, - {42601, 1, &rule23}, - {42602, 1, &rule22}, - {42603, 1, &rule23}, - {42604, 1, &rule22}, - {42605, 1, &rule23}, - {42624, 1, &rule22}, - {42625, 1, &rule23}, - {42626, 1, &rule22}, - {42627, 1, &rule23}, - {42628, 1, &rule22}, - {42629, 1, &rule23}, - {42630, 1, &rule22}, - {42631, 1, &rule23}, - {42632, 1, &rule22}, - {42633, 1, &rule23}, - {42634, 1, &rule22}, - {42635, 1, &rule23}, - {42636, 1, &rule22}, - {42637, 1, &rule23}, - {42638, 1, &rule22}, - {42639, 1, &rule23}, - {42640, 1, &rule22}, - {42641, 1, &rule23}, - {42642, 1, &rule22}, - {42643, 1, &rule23}, - {42644, 1, &rule22}, - {42645, 1, &rule23}, - {42646, 1, &rule22}, - {42647, 1, &rule23}, - {42648, 1, &rule22}, - {42649, 1, &rule23}, - {42650, 1, &rule22}, - {42651, 1, &rule23}, - {42786, 1, &rule22}, - {42787, 1, &rule23}, - {42788, 1, &rule22}, - {42789, 1, &rule23}, - {42790, 1, &rule22}, - {42791, 1, &rule23}, - {42792, 1, &rule22}, - {42793, 1, &rule23}, - {42794, 1, &rule22}, - {42795, 1, &rule23}, - {42796, 1, &rule22}, - {42797, 1, &rule23}, - {42798, 1, &rule22}, - {42799, 1, &rule23}, - {42802, 1, &rule22}, - {42803, 1, &rule23}, - {42804, 1, &rule22}, - {42805, 1, &rule23}, - {42806, 1, &rule22}, - {42807, 1, &rule23}, - {42808, 1, &rule22}, - {42809, 1, &rule23}, - {42810, 1, &rule22}, - {42811, 1, &rule23}, - {42812, 1, &rule22}, - {42813, 1, &rule23}, - {42814, 1, &rule22}, - {42815, 1, &rule23}, - {42816, 1, &rule22}, - {42817, 1, &rule23}, - {42818, 1, &rule22}, - {42819, 1, &rule23}, - {42820, 1, &rule22}, - {42821, 1, &rule23}, - {42822, 1, &rule22}, - {42823, 1, &rule23}, - {42824, 1, &rule22}, - {42825, 1, &rule23}, - {42826, 1, &rule22}, - {42827, 1, &rule23}, - {42828, 1, &rule22}, - {42829, 1, &rule23}, - {42830, 1, &rule22}, - {42831, 1, &rule23}, - {42832, 1, &rule22}, - {42833, 1, &rule23}, - {42834, 1, &rule22}, - {42835, 1, &rule23}, - {42836, 1, &rule22}, - {42837, 1, &rule23}, - {42838, 1, &rule22}, - {42839, 1, &rule23}, - {42840, 1, &rule22}, - {42841, 1, &rule23}, - {42842, 1, &rule22}, - {42843, 1, &rule23}, - {42844, 1, &rule22}, - {42845, 1, &rule23}, - {42846, 1, &rule22}, - {42847, 1, &rule23}, - {42848, 1, &rule22}, - {42849, 1, &rule23}, - {42850, 1, &rule22}, - {42851, 1, &rule23}, - {42852, 1, &rule22}, - {42853, 1, &rule23}, - {42854, 1, &rule22}, - {42855, 1, &rule23}, - {42856, 1, &rule22}, - {42857, 1, &rule23}, - {42858, 1, &rule22}, - {42859, 1, &rule23}, - {42860, 1, &rule22}, - {42861, 1, &rule23}, - {42862, 1, &rule22}, - {42863, 1, &rule23}, - {42873, 1, &rule22}, - {42874, 1, &rule23}, - {42875, 1, &rule22}, - {42876, 1, &rule23}, - {42877, 1, &rule169}, - {42878, 1, &rule22}, - {42879, 1, &rule23}, - {42880, 1, &rule22}, - {42881, 1, &rule23}, - {42882, 1, &rule22}, - {42883, 1, &rule23}, - {42884, 1, &rule22}, - {42885, 1, &rule23}, - {42886, 1, &rule22}, - {42887, 1, &rule23}, - {42891, 1, &rule22}, - {42892, 1, &rule23}, - {42893, 1, &rule170}, - {42896, 1, &rule22}, - {42897, 1, &rule23}, - {42898, 1, &rule22}, - {42899, 1, &rule23}, - {42902, 1, &rule22}, - {42903, 1, &rule23}, - {42904, 1, &rule22}, - {42905, 1, &rule23}, - {42906, 1, &rule22}, - {42907, 1, &rule23}, - {42908, 1, &rule22}, - {42909, 1, &rule23}, - {42910, 1, &rule22}, - {42911, 1, &rule23}, - {42912, 1, &rule22}, - {42913, 1, &rule23}, - {42914, 1, &rule22}, - {42915, 1, &rule23}, - {42916, 1, &rule22}, - {42917, 1, &rule23}, - {42918, 1, &rule22}, - {42919, 1, &rule23}, - {42920, 1, &rule22}, - {42921, 1, &rule23}, - {42922, 1, &rule171}, - {42923, 1, &rule172}, - {42924, 1, &rule173}, - {42925, 1, &rule174}, - {42928, 1, &rule175}, - {42929, 1, &rule176}, - {65313, 26, &rule9}, - {65345, 26, &rule12}, - {66560, 40, &rule179}, - {66600, 40, &rule180}, - {71840, 32, &rule9}, - {71872, 32, &rule12} -}; -static const struct _charblock_ spacechars[]={ - {32, 1, &rule1}, - {160, 1, &rule1}, - {5760, 1, &rule1}, - {8192, 11, &rule1}, - {8239, 1, &rule1}, - {8287, 1, &rule1}, - {12288, 1, &rule1} -}; - -/* - Obtain the reference to character rule by doing - binary search over the specified array of blocks. - To make checkattr shorter, the address of - nullrule is returned if the search fails: - this rule defines no category and no conversion - distances. The compare function returns 0 when - key->start is within the block. Otherwise - result of comparison of key->start and start of the - current block is returned as usual. -*/ - -static const struct _convrule_ nullrule={0,NUMCAT_CN,0,0,0,0}; - -static int blkcmp(const void *vk,const void *vb) -{ - const struct _charblock_ *key,*cur; - key=vk; - cur=vb; - if((key->start>=cur->start)&&(key->start<(cur->start+cur->length))) - { - return 0; - } - if(key->start>cur->start) return 1; - return -1; -} - -static const struct _convrule_ *getrule( - const struct _charblock_ *blocks, - int numblocks, - int unichar) -{ - struct _charblock_ key={unichar,1,(void *)0}; - struct _charblock_ *cb=bsearch(&key,blocks,numblocks,sizeof(key),blkcmp); - if(cb==(void *)0) return &nullrule; - return cb->rule; -} - - - -/* - Check whether a character (internal code) has certain attributes. - Attributes (category flags) may be ORed. The function ANDs - character category flags and the mask and returns the result. - If the character belongs to one of the categories requested, - the result will be nonzero. -*/ - -inline static int checkattr(int c,unsigned int catmask) -{ - return (catmask & (getrule(allchars,(c<256)?NUM_LAT1BLOCKS:NUM_BLOCKS,c)->category)); -} - -inline static int checkattr_s(int c,unsigned int catmask) -{ - return (catmask & (getrule(spacechars,NUM_SPACEBLOCKS,c)->category)); -} - -/* - Define predicate functions for some combinations of categories. -*/ - -#define unipred(p,m) \ -bool p(GuUCS c) \ -{ \ - return checkattr(c,m); \ -} - -bool gu_ucs_is_space(GuUCS c) -{ - if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || - c == '\f' || c == '\v' || c == '\xa0') - return true; - return checkattr_s(c,GENCAT_ZS); -} - - -GU_API unipred(gu_ucs_is_cntrl,GENCAT_CC) -GU_API unipred(gu_ucs_is_print, (GENCAT_MC | GENCAT_NO | GENCAT_SK | GENCAT_ME | GENCAT_ND | GENCAT_PO | GENCAT_LT | GENCAT_PC | GENCAT_SM | GENCAT_ZS | GENCAT_LU | GENCAT_PD | GENCAT_SO | GENCAT_PE | GENCAT_PF | GENCAT_PS | GENCAT_SC | GENCAT_LL | GENCAT_LM | GENCAT_PI | GENCAT_NL | GENCAT_MN | GENCAT_LO)) -GU_API unipred(gu_ucs_is_upper,(GENCAT_LU|GENCAT_LT)) -GU_API unipred(gu_ucs_is_lower,GENCAT_LL) -GU_API unipred(gu_ucs_is_alpha,(GENCAT_LL|GENCAT_LU|GENCAT_LT|GENCAT_LM|GENCAT_LO)) -GU_API unipred(gu_ucs_is_digit,GENCAT_ND) - -GU_API unipred(gu_ucs_is_alnum,(GENCAT_LT|GENCAT_LU|GENCAT_LL|GENCAT_LM|GENCAT_LO| - GENCAT_MC|GENCAT_ME|GENCAT_MN| - GENCAT_NO|GENCAT_ND|GENCAT_NL)) - -#define caseconv(p,to) \ -GuUCS p(GuUCS c) \ -{ \ - const struct _convrule_ *rule=getrule(convchars,NUM_CONVBLOCKS,c);\ - if(rule==&nullrule) return c;\ - return c+rule->to;\ -} - -GU_API caseconv(gu_ucs_to_upper,updist) -GU_API caseconv(gu_ucs_to_lower,lowdist) -GU_API caseconv(gu_ucs_to_title,titledist) - -GU_API int gu_ucs_gen_cat(GuUCS c) -{ - return getrule(allchars,NUM_BLOCKS,c)->catnumber; -} diff --git a/src/runtime/c/gu/ucs.h b/src/runtime/c/gu/ucs.h deleted file mode 100644 index 1af74d27e..000000000 --- a/src/runtime/c/gu/ucs.h +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef GU_UCS_H_ -#define GU_UCS_H_ - -#include -#include -#include - -#if defined(__STDC_ISO_10646__) && WCHAR_MAX >= 0x10FFFF -#include -#define GU_UCS_WCHAR -typedef wchar_t GuUCS; -#else -typedef int32_t GuUCS; -#endif - -#define GU_UCS_MAX ((GuUCS)(0x10FFFF)) - -GU_API_DECL bool -gu_char_is_valid(char c); - -inline bool -gu_ucs_valid(GuUCS ucs) -{ - return ucs >= 0 && ucs <= GU_UCS_MAX; -} - -GU_API_DECL GuUCS -gu_char_ucs(char c); - -GU_API_DECL char -gu_ucs_char(GuUCS uc, GuExn* err); - -GU_API_DECL size_t -gu_str_to_ucs(const char* cbuf, size_t len, GuUCS* ubuf, GuExn* err); - -GU_API_DECL size_t -gu_ucs_to_str(const GuUCS* ubuf, size_t len, char* cbuf, GuExn* err); - -GU_API_DECL bool gu_ucs_is_upper(GuUCS c); -GU_API_DECL bool gu_ucs_is_digit(GuUCS c); -GU_API_DECL bool gu_ucs_is_alpha(GuUCS c); -GU_API_DECL bool gu_ucs_is_cntrl(GuUCS c); -GU_API_DECL bool gu_ucs_is_space(GuUCS c); -GU_API_DECL bool gu_ucs_is_print(GuUCS c); -GU_API_DECL bool gu_ucs_is_lower(GuUCS c); - -GU_API_DECL bool gu_ucs_is_alnum(GuUCS c); - -GU_API_DECL GuUCS gu_ucs_to_lower(GuUCS c); -GU_API_DECL GuUCS gu_ucs_to_upper(GuUCS c); -GU_API_DECL GuUCS gu_ucs_to_title(GuUCS c); - -GU_API_DECL int gu_ucs_is_gencat(GuUCS wc); - -#endif // GU_ISO10646_H_ diff --git a/src/runtime/c/gu/utf8.c b/src/runtime/c/gu/utf8.c deleted file mode 100644 index 29869fd7f..000000000 --- a/src/runtime/c/gu/utf8.c +++ /dev/null @@ -1,176 +0,0 @@ -#include -#include - -GU_API GuUCS -gu_utf8_decode(const uint8_t** src_inout) -{ - const uint8_t* src = *src_inout; - uint8_t c = src[0]; - if (c < 0x80) { - *src_inout = src + 1; - return (GuUCS) c; - } - size_t len = (c < 0xe0 ? 1 : - c < 0xf0 ? 2 : - c < 0xf8 ? 3 : - c < 0xfc ? 4 : - 5 - ); - uint64_t mask = 0x0103070F1f7f; - uint32_t u = c & (mask >> (len * 8)); - for (size_t i = 1; i <= len; i++) { - c = src[i]; - u = u << 6 | (c & 0x3f); - } - *src_inout = &src[len + 1]; - return (GuUCS) u; -} - -GU_API GuUCS -gu_in_utf8_(GuIn* in, GuExn* err) -{ - uint8_t c = gu_in_u8(in, err); - if (!gu_ok(err)) { - return 0; - } - if (c < 0x80) { - return c; - } - if (c < 0xc2) { - goto fail; - } - int len = (c < 0xe0 ? 1 : - c < 0xf0 ? 2 : - c < 0xf8 ? 3 : - c < 0xfc ? 4 : - 5 - ); - uint64_t mask = 0x0103070F1f7f; - uint32_t u = c & (mask >> (len * 8)); - uint8_t buf[5]; - // If reading the extra bytes causes EOF, it is an encoding - // error, not a legitimate end of character stream. - gu_in_bytes(in, buf, len, err); - if (gu_exn_caught(err, GuEOF)) { - gu_exn_clear(err); - goto fail; - } - if (!gu_ok(err)) { - return 0; - } - for (int i = 0; i < len; i++) { - c = buf[i]; - if ((c & 0xc0) != 0x80) { - goto fail; - } - u = u << 6 | (c & 0x3f); - } - GuUCS ucs = (GuUCS) u; - if (!gu_ucs_valid(ucs)) { - goto fail; - } - return ucs; - -fail: - gu_raise(err, GuUCSExn); - return 0; -} - -extern inline GuUCS -gu_in_utf8(GuIn* in, GuExn* err); - -GU_API void -gu_in_utf8_buf(uint8_t** buf, GuIn* in, GuExn* err) -{ - uint8_t* p = *buf; - - uint8_t c = gu_in_u8(in, err); - if (!gu_ok(err)) { - return; - } - *(p++) = c; - - if (c < 0x80) { - *buf = p; - return; - } - if (c < 0xc2) { - goto fail; - } - - int len = (c < 0xe0 ? 1 : - c < 0xf0 ? 2 : - c < 0xf8 ? 3 : - c < 0xfc ? 4 : - 5 - ); - // If reading the extra bytes causes EOF, it is an encoding - // error, not a legitimate end of character stream. - gu_in_bytes(in, p, len, err); - if (gu_exn_caught(err, GuEOF)) { - gu_exn_clear(err); - goto fail; - } - if (!gu_ok(err)) { - return; - } - *buf = p+len; - return; - -fail: - gu_raise(err, GuUCSExn); - return; -} - -GU_API void -gu_utf8_encode(GuUCS ucs, uint8_t** buf) -{ - gu_require(gu_ucs_valid(ucs)); - uint8_t* p = *buf; - if (ucs < 0x80) { - p[0] = (uint8_t) ucs; - *buf = p+1; - } else if (ucs < 0x800) { - p[0] = 0xc0 | (ucs >> 6); - p[1] = 0x80 | (ucs & 0x3f); - *buf = p+2; - } else if (ucs < 0x10000) { - p[0] = 0xe0 | (ucs >> 12); - p[1] = 0x80 | ((ucs >> 6) & 0x3f); - p[2] = 0x80 | (ucs & 0x3f); - *buf = p+3; - } else if (ucs < 0x200000) { - p[0] = 0xf0 | (ucs >> 18); - p[1] = 0x80 | ((ucs >> 12) & 0x3f); - p[2] = 0x80 | ((ucs >> 6) & 0x3f); - p[3] = 0x80 | (ucs & 0x3f); - *buf = p+4; - } else if (ucs < 0x4000000) { - p[0] = 0xf8 | (ucs >> 24); - p[1] = 0x80 | ((ucs >> 18) & 0x3f); - p[2] = 0x80 | ((ucs >> 12) & 0x3f); - p[3] = 0x80 | ((ucs >> 6) & 0x3f); - p[4] = 0x80 | (ucs & 0x3f); - *buf = p+5; - } else { - p[0] = 0xfc | (ucs >> 30); - p[1] = 0x80 | ((ucs >> 24) & 0x3f); - p[2] = 0x80 | ((ucs >> 18) & 0x3f); - p[3] = 0x80 | ((ucs >> 12) & 0x3f); - p[4] = 0x80 | ((ucs >> 6) & 0x3f); - p[5] = 0x80 | (ucs & 0x3f); - *buf = p+6; - } -} - -GU_API void -gu_out_utf8_(GuUCS ucs, GuOut* out, GuExn* err) -{ - uint8_t buf[6]; - uint8_t* p = buf; - gu_utf8_encode(ucs, &p); - gu_out_bytes(out, buf, p-buf, err); -} - -extern inline void -gu_out_utf8(GuUCS ucs, GuOut* out, GuExn* err); diff --git a/src/runtime/c/gu/utf8.h b/src/runtime/c/gu/utf8.h deleted file mode 100644 index 2b7e037ab..000000000 --- a/src/runtime/c/gu/utf8.h +++ /dev/null @@ -1,43 +0,0 @@ -#ifndef GU_UTF8_H_ -#define GU_UTF8_H_ - -#include -#include -#include - -inline GuUCS -gu_in_utf8(GuIn* in, GuExn* err) -{ - int i = gu_in_peek_u8(in); - if (i >= 0 && i < 0x80) { - gu_in_consume(in, 1); - return (GuUCS) i; - } - GU_API_DECL GuUCS gu_in_utf8_(GuIn* in, GuExn* err); - return gu_in_utf8_(in, err); -} - -inline void -gu_out_utf8(GuUCS ucs, GuOut* out, GuExn* err) -{ - gu_require(gu_ucs_valid(ucs)); - if (GU_LIKELY(ucs < 0x80)) { - gu_out_u8(out, ucs, err); - } else { - GU_API_DECL void gu_out_utf8_(GuUCS ucs, GuOut* out, GuExn* err); - gu_out_utf8_(ucs, out, err); - } -} - -// Helper functions used in other modules - -GU_API_DECL GuUCS -gu_utf8_decode(const uint8_t** buf); - -GU_API_DECL void -gu_utf8_encode(GuUCS ucs, uint8_t** buf); - -GU_API_DECL void -gu_in_utf8_buf(uint8_t** buf, GuIn* in, GuExn* err); - -#endif // GU_UTF8_H_ diff --git a/src/runtime/c/gu/variant.c b/src/runtime/c/gu/variant.c deleted file mode 100644 index 5508c0ce4..000000000 --- a/src/runtime/c/gu/variant.c +++ /dev/null @@ -1,94 +0,0 @@ -#include "variant.h" -#include "bits.h" - -enum { - GU_VARIANT_ALIGNMENT = sizeof(uintptr_t) -}; - -GU_API void* -gu_alloc_variant(uint8_t tag, size_t size, - size_t align, GuVariant* variant_out, GuPool* pool) -{ - align = gu_max(align, GU_VARIANT_ALIGNMENT); - if (((size_t)tag) > GU_VARIANT_ALIGNMENT - 2) { - uint8_t* alloc = gu_malloc_aligned(pool, align + size, align); - alloc[align - 1] = tag; - void* p = &alloc[align]; - *variant_out = (uintptr_t)p; - return p; - } - void* p = gu_malloc_aligned(pool, size, align); - *variant_out = ((uintptr_t)p) | (tag + 1); - return p; -} - -GU_API GuVariant -gu_make_variant(uint8_t tag, size_t size, size_t align, const void* init, - GuPool* pool) -{ - GuVariant v; - void* data = gu_alloc_variant(tag, size, align, &v, pool); - memcpy(data, init, size); - return v; -} - -GU_API int -gu_variant_tag(GuVariant variant) -{ - if (gu_variant_is_null(variant)) { - return GU_VARIANT_NULL; - } - int u = variant % GU_VARIANT_ALIGNMENT; - if (u == 0) { - uint8_t* mem = (uint8_t*)variant; - return mem[-1]; - } - return u - 1; -} - -GU_API void* -gu_variant_data(GuVariant variant) -{ - if (gu_variant_is_null(variant)) { - return NULL; - } - return (void*)gu_align_backward(variant, GU_VARIANT_ALIGNMENT); -} - -GU_API GuVariantInfo -gu_variant_open(GuVariant variant) -{ - GuVariantInfo info = { - .tag = gu_variant_tag(variant), - .data = gu_variant_data(variant) - }; - return info; -} - -GU_API GuVariant -gu_variant_close(GuVariantInfo info) -{ - GuVariant variant; - - if (((size_t)info.tag) > GU_VARIANT_ALIGNMENT - 2) { - variant = (uintptr_t)info.data; - assert(gu_variant_tag(variant) == info.tag); - } else { - variant = ((uintptr_t)info.data) | (info.tag + 1); - } - - return variant; -} - -GU_API int -gu_variant_intval(GuVariant variant) -{ - int u = variant % GU_VARIANT_ALIGNMENT; - if (u == 0) { - int* mem = (int*)variant; - return *mem; - } - return (variant / GU_VARIANT_ALIGNMENT); -} - -GU_API const GuVariant gu_null_variant = { (GuWord) NULL }; diff --git a/src/runtime/c/gu/variant.h b/src/runtime/c/gu/variant.h deleted file mode 100644 index df2ea214f..000000000 --- a/src/runtime/c/gu/variant.h +++ /dev/null @@ -1,111 +0,0 @@ -/* - * Copyright 2010 University of Helsinki. - * - * This file is part of libgu. - * - * Libgu is free software: you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. - * - * Libgu 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with libgu. If not, see . - */ - -/** @file - * - * Lightweight tagged data. - */ - -#ifndef GU_VARIANT_H_ -#define GU_VARIANT_H_ - -#include -#include - -/** @name Variants - * @{ - */ - -typedef uintptr_t GuVariant; - - -GU_API_DECL -void* gu_alloc_variant(uint8_t tag, - size_t size, size_t align, - GuVariant* variant_out, GuPool* pool); - -GU_API_DECL -GuVariant gu_make_variant(uint8_t tag, - size_t size, size_t align, - const void* init, GuPool* pool); - -#define gu_new_variant(tag, type, variant_out, pool) \ - ((type*)gu_alloc_variant(tag, sizeof(type), \ - gu_alignof(type), variant_out, pool)) - -/**< - * @hideinitializer */ - -#define gu_new_variant_i(POOL, TAG, T, ...) \ - gu_make_variant(TAG, sizeof(T), gu_alignof(T), \ - &(T){ __VA_ARGS__ }, POOL) - - - -#define gu_new_flex_variant(tag, type, flex_mem, n_elems, variant_out, pool) \ - ((type*)gu_alloc_variant(tag, \ - GU_FLEX_SIZE(type, flex_mem, n_elems), \ - gu_flex_alignof(type), \ - variant_out, pool)) -/**< - * @hideinitializer */ - -enum { - GU_VARIANT_NULL = -1 -}; - -GU_API_DECL -int gu_variant_tag(GuVariant variant); - -GU_API_DECL -void* gu_variant_data(GuVariant variant); - - -typedef struct GuVariantInfo GuVariantInfo; - -struct GuVariantInfo { - int tag; - void* data; -}; - -GU_API_DECL GuVariantInfo gu_variant_open(GuVariant variant); -GU_API_DECL GuVariant gu_variant_close(GuVariantInfo info); - -/** @} */ - -static inline void* -gu_variant_to_ptr(GuVariant variant) -{ - return (void*) variant; -} - -static inline GuVariant -gu_variant_from_ptr(const void* p) -{ - return (uintptr_t) p; -} - -GU_API_DECL extern const GuVariant gu_null_variant; - -static inline bool -gu_variant_is_null(GuVariant v) { - return ((void*)v == NULL); -} - -#endif // GU_VARIANT_H_ diff --git a/src/runtime/c/install.sh b/src/runtime/c/install.sh deleted file mode 100755 index 78483719d..000000000 --- a/src/runtime/c/install.sh +++ /dev/null @@ -1,3 +0,0 @@ -bash setup.sh configure -bash setup.sh build -bash setup.sh install diff --git a/src/runtime/c/libgu.pc.in b/src/runtime/c/libgu.pc.in deleted file mode 100644 index 7b216f69f..000000000 --- a/src/runtime/c/libgu.pc.in +++ /dev/null @@ -1,10 +0,0 @@ -prefix=@prefix@ -exec_prefix=@exec_prefix@ -libdir=@libdir@ -includedir=@includedir@ - -Name: libgu -Description: Gothenburg Utilities library -Version: @VERSION@ -Libs: -L${libdir} -lgu -Cflags: -I${includedir} diff --git a/src/runtime/c/libpgf.pc.in b/src/runtime/c/libpgf.pc.in index 414388cbc..2ccdabe5c 100644 --- a/src/runtime/c/libpgf.pc.in +++ b/src/runtime/c/libpgf.pc.in @@ -5,7 +5,6 @@ includedir=@includedir@ Name: libpgf Description: Portable Grammar Format library -Requires: libgu Version: @VERSION@ Libs: -L${libdir} -lpgf Cflags: -I${includedir} diff --git a/src/runtime/c/namespace.h b/src/runtime/c/namespace.h new file mode 100644 index 000000000..ab14b67c1 --- /dev/null +++ b/src/runtime/c/namespace.h @@ -0,0 +1,215 @@ +#ifndef NAMESPACE_H +#define NAMESPACE_H + +#include "db.h" + +template +class Node; + +template +using Namespace = ref>; + +template +class Node { +public: + size_t sz; + ref value; + ref left; + ref right; + + static + ref new_node(ref value) { + ref node = current_db->malloc(); + node->sz = 1; + node->value = value; + node->left = 0; + node->right = 0; + return node; + } + + static + ref new_node(ref value, ref left, ref right) { + ref node = current_db->malloc(); + node->sz = 1+namespace_size(left)+namespace_size(right); + node->value = value; + node->left = left; + node->right = right; + return node; + } + + static + ref balanceL(ref value, ref left, ref right) { + if (right == 0) { + if (left == 0) { + return new_node(value); + } else { + if (left->left == 0) { + if (left->right == 0) { + return new_node(value,left,0); + } else { + return new_node(left->right->value, + new_node(left->value), + new_node(value)); + } + } else { + if (left->right == 0) { + return new_node(left->value, + left->left, + new_node(value)); + } else { + if (left->right->sz < 2 * left->left->sz) { + return new_node(left->value, + left->left, + new_node(value, + left->right, + 0)); + } else { + return new_node(left->right->value, + new_node(left->value, + left->left, + left->right->left), + new_node(value, + left->right->right, + 0)); + } + } + } + } + } else { + if (left == 0) { + return new_node(value,0,right); + } else { + if (left->sz > 3*right->sz) { + if (left->right->sz < 2*left->left->sz) + return new_node(left->value, + left->left, + new_node(value, + left->right, + right)); + else + return new_node(left->right->value, + new_node(left->value, + left->left, + left->right->left), + new_node(value, + left->right->right, + right)); + } else { + return new_node(value,left,right); + } + } + } + } + + static + ref balanceR(ref value, ref left, ref right) { + if (left == 0) { + if (right == 0) { + return new_node(value); + } else { + if (right->left == 0) { + if (right->right == 0) { + return new_node(value,0,right); + } else { + return new_node(right->value, + new_node(value), + right->right); + } + } else { + if (right->right == 0) { + return new_node(right->left->value, + new_node(value), + new_node(right->value)); + } else { + if (right->left->sz < 2 * right->right->sz) { + return new_node(right->value, + new_node(value, + 0, + right->left), + right->right); + } else { + return new_node(right->left->value, + new_node(value, + 0, + right->left->left), + new_node(right->value, + right->left->right, + right->right)); + } + } + } + } + } else { + if (right == 0) { + return new_node(value,left,0); + } else { + if (right->sz > 3*left->sz) { + if (right->left->sz < 2*right->right->sz) + return new_node(right->value, + new_node(value, + left, + right->left), + right->right); + else + return new_node(right->left->value, + new_node(value, + left, + right->left->left), + new_node(right->value, + right->left->right, + right->right)); + } else { + return new_node(value,left,right); + } + } + } + } +}; + +template +Namespace namespace_empty() { + return 0; +} + +template +Namespace namespace_singleton(ref value) { + return Node::new_node(value); +} + +template +Namespace namespace_insert(Namespace map, ref value) { + if (map == 0) + return Node::new_node(value); + + int cmp = strcmp(value->name,map->value->name); + if (cmp < 0) + return Node::balanceL(map->value, + namespace_insert(map->left, value),map->right); + else if (cmp > 0) + return Node::balanceR(map->value, + map->left, namespace_insert(map->right, value)); + else + return Node::new_node(value,map->left,map->right); +} + +template +ref namespace_lookup(Namespace map, const char *name) { + while (map != 0) { + int cmp = strcmp(name,map->value->name); + if (cmp < 0) + map = map->left; + else if (cmp > 0) + map = map->right; + else + return map->value; + } + return NULL; +} + +template +size_t namespace_size(Namespace map) { + if (map == 0) + return 0; + return map->sz; +} +#endif diff --git a/src/runtime/c/pgf.cxx b/src/runtime/c/pgf.cxx new file mode 100644 index 000000000..bdbb05eab --- /dev/null +++ b/src/runtime/c/pgf.cxx @@ -0,0 +1,51 @@ +#include "data.h" +#include "reader.h" + +PGF_API +PgfPGF *pgf_read(const char* fpath, PgfExn* err) +{ + PgfPGF *pgf = NULL; + + try { + std::string fpath_n = fpath; + size_t len = fpath_n.length(); + if (len > 4 && fpath_n.substr(len-4) == ".pgf") + fpath_n[len-3] = 'n'; + else if (!(len > 4 && fpath_n.substr(len-4) == ".ngf")) + fpath_n += ".ngf"; + + pgf = new PgfPGF(fpath_n.c_str()); + + if (pgf->db.get_root() == 0) { + std::ifstream in(fpath, std::ios::binary); + if (in.fail()) { + throw std::system_error(errno, std::generic_category()); + } + + PgfReader rdr(&in); + rdr.read_pgf(pgf); + + pgf->set_root(); + } + + return pgf; + } catch (std::system_error& e) { + err->type = "system_error"; + err->msg = NULL; + } catch (pgf_error& e) { + err->type = "pgf_error"; + err->msg = e.what(); + } + + if (pgf != NULL) + delete pgf; + + return NULL; +} + +void PgfPGF::set_root() { + ref root = db.malloc(); + root->major_version = major_version; + root->minor_version = minor_version; + db.set_root(root); +} diff --git a/src/runtime/c/pgf.h b/src/runtime/c/pgf.h new file mode 100644 index 000000000..d96fb911d --- /dev/null +++ b/src/runtime/c/pgf.h @@ -0,0 +1,50 @@ +#ifndef PGF_H_ +#define PGF_H_ + +#ifdef __cplusplus +#define EXTERN_C extern "C" +#else +#define EXTERN_C +#endif + +#if defined(_MSC_VER) + +#if defined(COMPILING_PGF) +#define PGF_API_DECL __declspec(dllexport) EXTERN_C +#define PGF_API __declspec(dllexport) EXTERN_C +#else +#define PGF_API_DECL __declspec(dllimport) +#define PGF_API ERROR_NOT_COMPILING_LIBPGF +#endif +#define PGF_INTERNAL_DECL +#define PGF_INTERNAL + +#elif defined(__MINGW32__) + +#define PGF_API_DECL EXTERN_C +#define PGF_API EXTERN_C + +#define PGF_INTERNAL_DECL +#define PGF_INTERNAL + +#else + +#define PGF_API_DECL EXTERN_C +#define PGF_API EXTERN_C + +#define PGF_INTERNAL_DECL __attribute__ ((visibility ("hidden"))) +#define PGF_INTERNAL __attribute__ ((visibility ("hidden"))) + +#endif + +typedef struct PgfPGF PgfPGF; + +typedef struct { + const char *type; + const char *msg; +} PgfExn; + +PGF_API_DECL +PgfPGF *pgf_read(const char* fpath, PgfExn* err); + +#endif // PGF_H_ diff --git a/src/runtime/c/pgf/aligner.c b/src/runtime/c/pgf/aligner.c deleted file mode 100644 index e75743d99..000000000 --- a/src/runtime/c/pgf/aligner.c +++ /dev/null @@ -1,241 +0,0 @@ -#include "data.h" -#include "linearizer.h" -#include "pgf.h" -#include - -typedef struct { - PgfLinFuncs* funcs; - GuBuf* parent_stack; - GuBuf* parent_current; - GuBuf* phrases; - PgfAlignmentPhrase* last_phrase; - GuStringBuf* sbuf; - size_t n_matches; - GuExn* err; - bool bind; - PgfCapitState capit; - GuPool* out_pool; - GuPool* tmp_pool; -} PgfAlignerLin; - -static void -pgf_aligner_flush_phrase(PgfAlignerLin* alin) -{ - size_t n_fids = gu_buf_length(alin->parent_current); - - if (alin->n_matches == n_fids && - alin->n_matches == alin->last_phrase->n_fids) { - // if the current compound word has the same parents - // as the last one then we just combine them with a space - - alin->last_phrase->phrase = - gu_format_string(alin->out_pool, "%s %s", - alin->last_phrase->phrase, - gu_string_buf_freeze(alin->sbuf, alin->tmp_pool)); - } else { - // push the current word to the buffer of words - - PgfAlignmentPhrase* phrase = - gu_new_flex(alin->out_pool, PgfAlignmentPhrase, fids, n_fids); - phrase->phrase = gu_string_buf_freeze(alin->sbuf, alin->out_pool); - phrase->n_fids = n_fids; - for (size_t i = 0; i < n_fids; i++) { - phrase->fids[i] = gu_buf_get(alin->parent_current, int, i); - } - gu_buf_push(alin->phrases, PgfAlignmentPhrase*, phrase); - - alin->last_phrase = phrase; - } - - alin->n_matches = 0; -} - -static void -pgf_aligner_push_parent(PgfAlignerLin* alin, int fid) -{ - gu_buf_push(alin->parent_current, int, fid); - - if (alin->last_phrase != NULL) { - for (size_t i = 0; i < alin->last_phrase->n_fids; i++) { - if (fid == alin->last_phrase->fids[i]) { - alin->n_matches++; - break; - } - } - } -} - -static void -pgf_aligner_lzn_symbol_token(PgfLinFuncs** funcs, PgfToken tok) -{ - PgfAlignerLin* alin = gu_container(funcs, PgfAlignerLin, funcs); - if (!gu_ok(alin->err)) { - return; - } - - // get the tree node id that generates this token - size_t n_parents = gu_buf_length(alin->parent_stack); - int fid = gu_buf_get(alin->parent_stack, int, n_parents-1); - - // how many nodes so far are involved in the current compound word - size_t n_fids = gu_buf_length(alin->parent_current); - - if (alin->bind) { - // here we glue tokens - - alin->bind = false; - - bool found = false; - for (size_t i = 0; i < n_fids; i++) { - int current_fid = gu_buf_get(alin->parent_current, int, i); - if (fid == current_fid) { - found = true; - break; - } - } - - // add the tree node id to the list of parents if it has not - // been added already. - if (!found) { - pgf_aligner_push_parent(alin, fid); - } - } else { - // here we start a new (compound) word - - pgf_aligner_flush_phrase(alin); - gu_string_buf_flush(alin->sbuf); - gu_buf_flush(alin->parent_current); - - pgf_aligner_push_parent(alin, fid); - - if (alin->capit == PGF_CAPIT_NEXT) - alin->capit = PGF_CAPIT_NONE; - } - - GuOut* out = gu_string_buf_out(alin->sbuf); - - switch (alin->capit) { - case PGF_CAPIT_NONE: - gu_string_write(tok, out, alin->err); - break; - case PGF_CAPIT_FIRST: { - GuUCS c = gu_utf8_decode((const uint8_t**) &tok); - c = gu_ucs_to_upper(c); - gu_out_utf8(c, out, alin->err); - gu_string_write(tok, out, alin->err); - alin->capit = PGF_CAPIT_NONE; - break; - } - case PGF_CAPIT_ALL: - alin->capit = PGF_CAPIT_NEXT; - // continue - case PGF_CAPIT_NEXT: { - const uint8_t* p = (uint8_t*) tok; - while (*p) { - GuUCS c = gu_utf8_decode(&p); - c = gu_ucs_to_upper(c); - gu_out_utf8(c, out, alin->err); - } - break; - } - } -} - -static void -pgf_aligner_lzn_begin_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfAlignerLin* alin = gu_container(funcs, PgfAlignerLin, funcs); - gu_buf_push(alin->parent_stack, int, fid); -} - -static void -pgf_aligner_lzn_end_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfAlignerLin* alin = gu_container(funcs, PgfAlignerLin, funcs); - gu_buf_pop(alin->parent_stack, int); -} - -static void -pgf_aligner_lzn_symbol_ne(PgfLinFuncs** funcs) -{ - PgfAlignerLin* alin = gu_container(funcs, PgfAlignerLin, funcs); - gu_raise(alin->err, PgalinNonExist); -} - -static void -pgf_aligner_lzn_symbol_bind(PgfLinFuncs** funcs) -{ - PgfAlignerLin* alin = gu_container(funcs, PgfAlignerLin, funcs); - alin->bind = true; -} - -static void -pgf_aligner_lzn_symbol_capit(PgfLinFuncs** funcs, PgfCapitState capit) -{ - PgfAlignerLin* alin = gu_container(funcs, PgfAlignerLin, funcs); - alin->capit = capit; -} - -static void -pgf_aligner_lzn_symbol_meta(PgfLinFuncs** funcs, PgfMetaId id) -{ - pgf_aligner_lzn_symbol_token(funcs, "?"); -} - -static PgfLinFuncs pgf_file_lin_funcs = { - .symbol_token = pgf_aligner_lzn_symbol_token, - .begin_phrase = pgf_aligner_lzn_begin_phrase, - .end_phrase = pgf_aligner_lzn_end_phrase, - .symbol_ne = pgf_aligner_lzn_symbol_ne, - .symbol_bind = pgf_aligner_lzn_symbol_bind, - .symbol_capit = pgf_aligner_lzn_symbol_capit, - .symbol_meta = pgf_aligner_lzn_symbol_meta -}; - -GuSeq* -pgf_align_words(PgfConcr* concr, PgfExpr expr, - GuExn* err, GuPool* pool) -{ - GuPool* tmp_pool = gu_local_pool(); - - GuEnum* cts = - pgf_lzr_concretize(concr, expr, err, tmp_pool); - if (!gu_ok(err)) { - gu_pool_free(tmp_pool); - return NULL; - } - - GuBuf* phrases = gu_new_buf(PgfAlignmentPhrase*, pool); - - PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool); - if (!gu_variant_is_null(ctree)) { - ctree = pgf_lzr_wrap_linref(ctree, tmp_pool); - - PgfAlignerLin alin = { - .funcs = &pgf_file_lin_funcs, - .parent_stack = gu_new_buf(int, tmp_pool), - .parent_current = gu_new_buf(int, tmp_pool), - .phrases = phrases, - .last_phrase = NULL, - .sbuf = gu_new_string_buf(tmp_pool), - .n_matches = 0, - .err = err, - .bind = true, - .capit = PGF_CAPIT_NONE, - .out_pool = pool, - .tmp_pool = tmp_pool - }; - gu_buf_push(alin.parent_stack, int, -1); - - pgf_lzr_linearize(concr, ctree, 0, &alin.funcs, tmp_pool); - if (!gu_ok(err)) { - gu_pool_free(tmp_pool); - return NULL; - } - - pgf_aligner_flush_phrase(&alin); - } - - gu_pool_free(tmp_pool); - return gu_buf_data_seq(phrases); -} diff --git a/src/runtime/c/pgf/data.c b/src/runtime/c/pgf/data.c deleted file mode 100644 index 233755937..000000000 --- a/src/runtime/c/pgf/data.c +++ /dev/null @@ -1,58 +0,0 @@ -#include "data.h" -#include -#include -#include - -PGF_INTERNAL bool -pgf_tokens_equal(PgfTokens* t1, PgfTokens* t2) -{ - size_t len1 = gu_seq_length(t1); - size_t len2 = gu_seq_length(t2); - if (len1 != len2) { - return false; - } - for (size_t i = 0; i < len1; i++) { - GuString s1 = gu_seq_get(t1, PgfToken, i); - GuString s2 = gu_seq_get(t2, PgfToken, i); - if (strcmp(s1, s2) != 0) { - return false; - } - } - return true; -} - -static int -pgf_flag_cmp_fn(GuOrder* self, const void* p1, const void* p2) -{ - (void) self; - return strcmp((GuString) p1, ((PgfFlag*) p2)->name); -} - -PGF_INTERNAL GuOrder pgf_flag_order[1] = { { pgf_flag_cmp_fn } }; - -static int -pgf_abscat_cmp_fn(GuOrder* self, const void* p1, const void* p2) -{ - (void) self; - return strcmp((GuString) p1, ((PgfAbsCat*) p2)->name); -} - -PGF_INTERNAL GuOrder pgf_abscat_order[1] = { { pgf_abscat_cmp_fn } }; - -static int -pgf_absfun_cmp_fn(GuOrder* self, const void* p1, const void* p2) -{ - (void) self; - return strcmp((GuString) p1, ((PgfAbsFun*) p2)->name); -} - -PGF_INTERNAL GuOrder pgf_absfun_order[1] = { { pgf_absfun_cmp_fn } }; - -static int -pgf_concr_cmp_fn(GuOrder* self, const void* p1, const void* p2) -{ - (void) self; - return strcmp((GuString) p1, ((PgfConcr*) p2)->name); -} - -PGF_INTERNAL GuOrder pgf_concr_order[1] = { { pgf_concr_cmp_fn } }; diff --git a/src/runtime/c/pgf/data.h b/src/runtime/c/pgf/data.h deleted file mode 100644 index 17a7f185b..000000000 --- a/src/runtime/c/pgf/data.h +++ /dev/null @@ -1,372 +0,0 @@ -#ifndef PGF_DATA_H_ -#define PGF_DATA_H_ - -#include -#include -#include -#include -#include - -typedef struct PgfCCat PgfCCat; - -typedef GuSeq PgfCCats; - -#define PgfCIdMap GuStringMap - -typedef struct { - PgfCId name; - PgfLiteral value; -} PgfFlag; - -typedef GuSeq PgfFlags; - -PGF_INTERNAL_DECL extern GuOrder pgf_flag_order[1]; - -// PgfPatt - -typedef GuVariant PgfPatt; - -typedef enum { - PGF_PATT_APP, - PGF_PATT_VAR, - PGF_PATT_AS, - PGF_PATT_WILD, - PGF_PATT_LIT, - PGF_PATT_IMPL_ARG, - PGF_PATT_TILDE, - PGF_PATT_NUM_TAGS -} PgfPattTag; - -typedef struct { - PgfCId ctor; - size_t n_args; - PgfPatt args[]; -} PgfPattApp; - -typedef struct { - PgfLiteral lit; -} PgfPattLit; - -typedef struct { - PgfCId var; -} PgfPattVar; - -typedef struct { - PgfCId var; - PgfPatt patt; -} PgfPattAs; - -typedef char PgfPattWild; - -typedef struct { - PgfPatt patt; -} PgfPattImplArg; - -typedef struct { - PgfExpr expr; -} PgfPattTilde; - -typedef struct { - PgfExpr body; - size_t n_patts; - PgfPatt patts[]; -} PgfEquation; - -typedef GuSeq PgfEquations; - -typedef void *PgfFunction; - -typedef struct { - PgfCId name; - PgfType* type; - int arity; - PgfEquations* defns; // maybe null - PgfExprProb ep; - PgfFunction predicate; - struct { - PgfFunction code; - union { - size_t caf_offset; - PgfFunction* con; - }; - } closure; -} PgfAbsFun; - -typedef GuSeq PgfAbsFuns; - -PGF_INTERNAL_DECL extern GuOrder pgf_absfun_order[1]; - -typedef GuMap PgfMetaChildMap; - -typedef struct { - PgfCId name; - PgfHypos* context; - - prob_t prob; - - void* predicate; -} PgfAbsCat; - -typedef GuSeq PgfAbsCats; - -PGF_INTERNAL_DECL extern GuOrder pgf_abscat_order[1]; - - -typedef struct PgfEvalGates PgfEvalGates; - -typedef struct { - PgfCId name; - PgfFlags* aflags; - PgfAbsFuns* funs; - PgfAbsCats* cats; - PgfAbsFun* abs_lin_fun; - PgfEvalGates* eval_gates; -} PgfAbstr; - -typedef enum { - PGF_INSTR_CHECK_ARGS = 0, - PGF_INSTR_CASE = 1, - PGF_INSTR_CASE_LIT = 2, - PGF_INSTR_SAVE = 3, - PGF_INSTR_ALLOC = 4, - PGF_INSTR_PUT_CONSTR = 5, - PGF_INSTR_PUT_CLOSURE = 6, - PGF_INSTR_PUT_LIT = 7, - PGF_INSTR_SET = 8, - PGF_INSTR_SET_PAD = 9, - PGF_INSTR_PUSH_FRAME = 10, - PGF_INSTR_PUSH = 11, - PGF_INSTR_TUCK = 12, - PGF_INSTR_EVAL = 13, - PGF_INSTR_DROP = 16, - PGF_INSTR_JUMP = 17, - PGF_INSTR_FAIL = 18, - PGF_INSTR_PUSH_ACCUM = 19, - PGF_INSTR_POP_ACCUM = 20, - PGF_INSTR_ADD = 21, -} PgfInstruction; - -typedef GuSeq PgfConcrs; - -PGF_INTERNAL_DECL extern GuOrder pgf_concr_order[1]; - -struct PgfPGF { - uint16_t major_version; - uint16_t minor_version; - PgfFlags* gflags; - PgfAbstr abstract; - PgfConcrs* concretes; - GuPool* pool; // the pool in which the grammar is allocated -}; - -typedef struct { - PgfAbsCat *abscat; - PgfCCats* cats; - - size_t n_lins; - GuString labels[]; - /**< Labels for tuples. All nested tuples, records and tables - * in the GF linearization types are flattened into a single - * tuple in the corresponding PGF concrete category. This - * field holds the labels that indicate which GF field or - * parameter (or their combination) each tuple element - * represents. */ -} PgfCncCat; - -typedef GuSeq PgfTokens; - -PGF_INTERNAL_DECL bool -pgf_tokens_equal(PgfTokens* t1, PgfTokens* t2); - -typedef GuSeq PgfSymbols; - -typedef struct { - PgfSymbols* form; - /**< The form of this variant as a list of tokens. */ - - GuStrings* prefixes; - /**< The prefixes of the following symbol that trigger this - * form. */ -} PgfAlternative; - -typedef struct PgfItemConts PgfItemConts; - -typedef PgfCIdMap PgfPrintNames; - -typedef GuStringMap PgfCncFunOverloadMap; - -typedef GuMap PgfCncOverloadMap; - -typedef struct PgfItem PgfItem; - -typedef GuVariant PgfSymbol; - -typedef enum { - PGF_SYMBOL_CAT, - PGF_SYMBOL_LIT, - PGF_SYMBOL_VAR, - PGF_SYMBOL_KS, - PGF_SYMBOL_KP, - PGF_SYMBOL_BIND, - PGF_SYMBOL_SOFT_BIND, - PGF_SYMBOL_NE, - PGF_SYMBOL_SOFT_SPACE, - PGF_SYMBOL_CAPIT, - PGF_SYMBOL_ALL_CAPIT, -} PgfSymbolTag; - -typedef struct { - int d; - int r; -} PgfSymbolIdx; - -typedef PgfSymbolIdx PgfSymbolCat, PgfSymbolLit, PgfSymbolVar; - -typedef struct { - char token[0]; // a flexible array that contains the token -} PgfSymbolKS; - -typedef struct PgfSymbolKP -/** A prefix-dependent symbol. The form that this symbol takes - * depends on the form of a prefix of the following symbol. */ -{ - PgfSymbols* default_form; - /**< Default form that this symbol takes if none of of the - * variant forms is triggered. */ - - size_t n_forms; - PgfAlternative forms[]; - /**< Variant forms whose choise depends on the following - * symbol. */ -} PgfSymbolKP; - -typedef struct { - char nothing[0]; // Empty struct -} PgfSymbolNE; - -typedef struct { - char nothing[0]; // Empty struct -} PgfSymbolBIND; - -typedef struct { - char nothing[0]; // Empty struct -} PgfSymbolCAPIT; - -typedef GuBuf PgfProductionIdx; - -typedef struct { - PgfSymbols* syms; // -> PgfSymbol - PgfProductionIdx* idx; -} PgfSequence; - -typedef GuSeq PgfSequences; - -typedef struct { - PgfAbsFun* absfun; - PgfExprProb *ep; - int funid; - size_t n_lins; - PgfSequence* lins[]; -} PgfCncFun; - -typedef GuSeq PgfCncFuns; - -struct PgfConcr { - PgfCId name; - PgfAbstr* abstr; - PgfFlags* cflags; - PgfPrintNames* printnames; - GuMap* ccats; - PgfCncFunOverloadMap* fun_indices; - PgfCncOverloadMap* coerce_idx; - PgfCncFuns* cncfuns; - PgfSequences* sequences; - PgfCIdMap* cnccats; - int total_cats; - - GuPool* pool; // if the language is loaded separately then this is the pool - GuFinalizer fin; // and this is the finalizer in the pool of the whole grammar -}; - - - -// PgfProduction - -typedef GuVariant PgfProduction; - -typedef enum { - PGF_PRODUCTION_APPLY, - PGF_PRODUCTION_COERCE, - PGF_PRODUCTION_EXTERN -} PgfProductionTag; - -typedef struct { - PgfCCat* ccat; - PgfCCats* hypos; -} PgfPArg; - -typedef GuSeq PgfPArgs; - -typedef struct { - PgfCncFun* fun; - PgfPArgs* args; -} PgfProductionApply; - -typedef struct PgfProductionCoerce -/** A coercion. This production is a logical union of the coercions of - * another FId. This allows common subsets of productions to be - * shared. */ -{ - PgfCCat* coerce; -} PgfProductionCoerce; - -typedef struct { - PgfExprProb *ep; - size_t n_lins; - PgfSymbols* lins[]; -} PgfProductionExtern; - -typedef struct { - PgfExprProb *ep; - PgfPArgs* args; -} PgfProductionMeta; - -typedef GuSeq PgfProductionSeq; - -typedef struct { - PgfCCat* ccat; - size_t lin_idx; - PgfProductionApply* papp; -} PgfProductionIdxEntry; - -struct PgfCCat { - PgfCncCat* cnccat; - PgfCncFuns* lindefs; - PgfCncFuns* linrefs; - size_t n_synprods; - PgfProductionSeq* prods; - prob_t viterbi_prob; - int fid; - int chunk_count; - PgfItemConts* conts; - struct PgfAnswers* answers; - GuFinalizer fin[0]; -}; - -PGF_API_DECL bool -pgf_production_is_lexical(PgfProductionApply *papp, - GuBuf* non_lexical_buf, GuPool* pool); - -PGF_API_DECL void -pgf_parser_index(PgfConcr* concr, - PgfCCat* ccat, PgfProduction prod, - bool is_lexical, - GuPool *pool); - -PGF_API_DECL void -pgf_lzr_index(PgfConcr* concr, - PgfCCat* ccat, PgfProduction prod, - bool is_lexical, - GuPool *pool); - -#endif diff --git a/src/runtime/c/pgf/evaluator.c b/src/runtime/c/pgf/evaluator.c deleted file mode 100644 index 484ee3896..000000000 --- a/src/runtime/c/pgf/evaluator.c +++ /dev/null @@ -1,513 +0,0 @@ -#include "pgf/pgf.h" -#include "pgf/data.h" -#include "pgf/reasoner.h" -#include - -#define PGF_ARGS_DELTA 5 - -static inline PgfClosure* -pgf_mk_pap(PgfReasoner* rs, PgfClosure* fun, - size_t n_args, PgfClosure** args) -{ - if (n_args > 0) { - PgfValuePAP* val = gu_new_flex(rs->pool, PgfValuePAP, args, n_args); - val->header.code = rs->eval_gates->evaluate_value_pap; - val->fun = fun; - val->n_args = n_args*sizeof(PgfClosure*); - for (size_t i = 0; i < n_args; i++) { - val->args[i] = args[i]; - } - return &val->header; - } - return fun; -} - -PGF_INTERNAL PgfClosure* -pgf_evaluate_expr_thunk(PgfReasoner* rs, PgfExprThunk* thunk) -{ - PgfEnv* env = thunk->env; - PgfExpr expr = thunk->expr; - - size_t n_args = 0; - PgfClosure** args = NULL; - PgfClosure* res = NULL; - -repeat:; - GuVariantInfo ei = gu_variant_open(expr); - switch (ei.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* eabs = ei.data; - - if (n_args > 0) { - PgfEnv* new_env = gu_new(PgfEnv, rs->pool); - new_env->next = env; - new_env->closure = args[--n_args]; - - env = new_env; - expr = eabs->body; - goto repeat; - } else { - thunk->header.code = rs->eval_gates->evaluate_value_lambda; - thunk->expr = eabs->body; - res = &thunk->header; - } - break; - } - case PGF_EXPR_APP: { - PgfExprApp* eapp = ei.data; - PgfExprThunk* thunk = - gu_new(PgfExprThunk, rs->pool); - thunk->header.code = rs->eval_gates->evaluate_expr_thunk; - thunk->env = env; - thunk->expr = eapp->arg; - - if (n_args % PGF_ARGS_DELTA == 0) { - args = realloc(args, n_args + PGF_ARGS_DELTA); - } - args[n_args++] = &thunk->header; - - expr = eapp->fun; - goto repeat; - } - case PGF_EXPR_LIT: { - PgfExprLit* elit = ei.data; - PgfValueLit* val = (PgfValueLit*) thunk; - val->header.code = rs->eval_gates->evaluate_value_lit; - val->lit = elit->lit; - res = &val->header; - break; - } - case PGF_EXPR_META: { - PgfExprMeta* emeta = ei.data; - - PgfValueMeta* val = - gu_new(PgfValueMeta, rs->pool); - val->header.code = rs->eval_gates->evaluate_meta; - val->env = env; - val->id = emeta->id; - res = pgf_mk_pap(rs, &val->header, n_args, args); - break; - } - case PGF_EXPR_FUN: { - PgfExprFun* efun = ei.data; - - PgfAbsFun* absfun = - gu_seq_binsearch(rs->abstract->funs, pgf_absfun_order, PgfAbsFun, efun->fun); - gu_assert(absfun != NULL); - - if (absfun->closure.code != NULL) { - res = pgf_mk_pap(rs, (PgfClosure*) &absfun->closure, n_args, args); - } else { - size_t arity = absfun->arity; - - if (n_args >= arity) { - PgfValue* val = gu_new_flex(rs->pool, PgfValue, args, n_args); - val->header.code = rs->eval_gates->evaluate_value; - val->con = (PgfClosure*) &absfun->closure; - - for (size_t i = 0; i < n_args; i++) { - val->args[i] = args[--n_args]; - } - res = &val->header; - } else { - PgfExprThunk* lambda = gu_new(PgfExprThunk, rs->pool); - lambda->header.code = rs->eval_gates->evaluate_value_lambda; - lambda->env = NULL; - res = pgf_mk_pap(rs, &lambda->header, n_args, args); - - for (size_t i = 0; i < arity; i++) { - PgfExpr new_expr, arg; - - PgfExprVar *evar = - gu_new_variant(PGF_EXPR_VAR, - PgfExprVar, - &arg, rs->pool); - evar->var = arity-i-1; - - PgfExprApp *eapp = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &new_expr, rs->pool); - eapp->fun = expr; - eapp->arg = arg; - - expr = new_expr; - } - - for (size_t i = 0; i < arity-1; i++) { - PgfExpr new_expr; - - PgfExprAbs *eabs = - gu_new_variant(PGF_EXPR_ABS, - PgfExprAbs, - &new_expr, rs->pool); - eabs->bind_type = PGF_BIND_TYPE_EXPLICIT; - eabs->id = "_"; - eabs->body = expr; - - expr = new_expr; - } - - lambda->expr = expr; - } - } - break; - } - case PGF_EXPR_VAR: { - PgfExprVar* evar = ei.data; - PgfEnv* tmp_env = env; - size_t i = evar->var; - while (i > 0) { - tmp_env = tmp_env->next; - if (tmp_env == NULL) { - GuExnData* err_data = gu_raise(rs->err, PgfExn); - if (err_data) { - err_data->data = "invalid de Bruijn index"; - } - return NULL; - } - i--; - } - - res = pgf_mk_pap(rs, tmp_env->closure, n_args, args); - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* etyped = ei.data; - expr = etyped->expr; - goto repeat; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* eimpl = ei.data; - expr = eimpl->expr; - goto repeat; - } - default: - gu_impossible(); - } - - free(args); - return res; -} - -PGF_INTERNAL PgfClosure* -pgf_evaluate_lambda_application(PgfReasoner* rs, PgfExprThunk* lambda, - PgfClosure* arg) -{ - PgfEnv* new_env = gu_new(PgfEnv, rs->pool); - new_env->next = lambda->env; - new_env->closure = arg; - - PgfExprThunk* thunk = gu_new(PgfExprThunk, rs->pool); - thunk->header.code = rs->eval_gates->evaluate_expr_thunk; - thunk->env = new_env; - thunk->expr = lambda->expr; - return pgf_evaluate_expr_thunk(rs, thunk); -} - -static PgfExpr -pgf_value2expr(PgfReasoner* rs, int level, PgfClosure* clos) -{ - clos = rs->eval_gates->enter(rs, clos); - if (clos == NULL) - return gu_null_variant; - - PgfExpr expr = gu_null_variant; - size_t n_args = 0; - PgfClosure** args; - - if (clos->code == rs->eval_gates->evaluate_value) { - PgfValue* val = (PgfValue*) clos; - PgfAbsFun* absfun = gu_container(val->con, PgfAbsFun, closure); - - expr = absfun->ep.expr; - n_args = gu_seq_length(absfun->type->hypos); - args = val->args; - } else if (clos->code == rs->eval_gates->evaluate_value_lit) { - PgfValueLit* val = (PgfValueLit*) clos; - - PgfExprLit *elit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &expr, rs->out_pool); - - GuVariantInfo i = gu_variant_open(val->lit); - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lstr = i.data; - - PgfLiteralStr* new_lstr = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(lstr->val)+1, - &elit->lit, rs->out_pool); - strcpy(new_lstr->val, lstr->val); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lint = i.data; - - PgfLiteralInt* new_lint = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &elit->lit, rs->out_pool); - new_lint->val = lint->val; - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lflt = i.data; - - PgfLiteralFlt* new_lflt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &elit->lit, rs->out_pool); - new_lflt->val = lflt->val; - break; - } - default: - gu_impossible(); - } - } else if (clos->code == rs->eval_gates->evaluate_value_pap) { - PgfValuePAP *pap = (PgfValuePAP*) clos; - - PgfValueGen* gen = - gu_new(PgfValueGen, rs->pool); - gen->header.code = rs->eval_gates->evaluate_gen; - gen->level = level; - - size_t n_args = pap->n_args/sizeof(PgfClosure*); - PgfValuePAP* new_pap = gu_new_flex(rs->pool, PgfValuePAP, args, n_args+1); - new_pap->header.code = rs->eval_gates->evaluate_value_pap; - new_pap->fun = pap->fun; - new_pap->n_args = pap->n_args+sizeof(PgfClosure*); - new_pap->args[0] = &gen->header; - for (size_t i = 0; i < n_args; i++) { - new_pap->args[i+1] = pap->args[i]; - } - - PgfExprAbs *eabs = - gu_new_variant(PGF_EXPR_ABS, - PgfExprAbs, - &expr, rs->out_pool); - eabs->bind_type = PGF_BIND_TYPE_EXPLICIT; - eabs->id = gu_format_string(rs->out_pool, "v%d", level); - eabs->body = pgf_value2expr(rs, level+1, &new_pap->header); - } else if (clos->code == rs->eval_gates->evaluate_value_const) { - PgfValuePAP* val = (PgfValuePAP*) clos; - - if (val->fun->code == rs->eval_gates->evaluate_meta) { - PgfValueMeta* fun = (PgfValueMeta*) val->fun; - - PgfExprMeta *emeta = - gu_new_variant(PGF_EXPR_META, - PgfExprMeta, - &expr, rs->out_pool); - emeta->id = fun->id; - } else if (val->fun->code == rs->eval_gates->evaluate_gen) { - PgfValueGen* fun = (PgfValueGen*) val->fun; - - PgfExprVar *evar = - gu_new_variant(PGF_EXPR_VAR, - PgfExprVar, - &expr, rs->out_pool); - evar->var = level - fun->level - 1; - } else if (val->fun->code == rs->eval_gates->evaluate_sum) { - PgfValueSum* sum = (PgfValueSum*) val->fun; - - PgfExpr e1,e2; - PgfExprFun *efun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, 2, - &e1, rs->out_pool); - strcpy(efun->fun, "+"); - - PgfExprLit *elit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &e2, rs->out_pool); - elit->lit = sum->lit; - - PgfExprApp* eapp = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &expr, rs->out_pool); - eapp->fun = e1; - eapp->arg = e2; - - size_t n_consts = gu_buf_length(sum->consts); - for (size_t i = 0; i < n_consts; i++) { - PgfClosure* con = - gu_buf_get(sum->consts, PgfClosure*, i); - - PgfExpr fun = expr; - PgfExpr arg = - pgf_value2expr(rs, level, con); - if (gu_variant_is_null(arg)) - return gu_null_variant; - - PgfExprApp* e = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &expr, rs->out_pool); - e->fun = fun; - e->arg = arg; - } - } else { - PgfAbsFun* absfun = gu_container(val->fun, PgfAbsFun, closure); - expr = absfun->ep.expr; - } - - n_args = val->n_args/sizeof(PgfClosure*); - args = val->args; - } else { - gu_impossible(); - } - - for (size_t i = 0; i < n_args; i++) { - PgfExpr fun = expr; - PgfExpr arg = - pgf_value2expr(rs, level, args[i]); - if (gu_variant_is_null(arg)) - return gu_null_variant; - - PgfExprApp* e = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &expr, rs->out_pool); - e->fun = fun; - e->arg = arg; - } - - return expr; -} - -PGF_API PgfExpr -pgf_compute(PgfPGF* pgf, PgfExpr expr, GuExn* err, GuPool* pool, GuPool* out_pool) -{ - PgfReasoner* rs = - pgf_new_reasoner(pgf, err, pool, out_pool); - - PgfExprThunk* thunk = - gu_new(PgfExprThunk, pool); - thunk->header.code = rs->eval_gates->evaluate_expr_thunk; - thunk->env = NULL; - thunk->expr = expr; - - return pgf_value2expr(rs, 0, &thunk->header); -} - -PGF_INTERNAL void -pgf_evaluate_accum_init_int(PgfReasoner* rs, - PgfEvalAccum* accum, int val) -{ - PgfLiteralInt *lit_int = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &accum->lit, - rs->pool); - lit_int->val = val; - accum->consts = NULL; -} - -PGF_INTERNAL void -pgf_evaluate_accum_init_str(PgfReasoner* rs, - PgfEvalAccum* accum, GuString val) -{ - if (val == NULL) - val = ""; - - PgfLiteralStr *lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(val)+1, - &accum->lit, rs->pool); - strcpy((char*) lit_str->val, (char*) val); - accum->consts = NULL; -} - -PGF_INTERNAL void -pgf_evaluate_accum_init_flt(PgfReasoner* rs, - PgfEvalAccum* accum, float val) -{ - PgfLiteralFlt *lit_flt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &accum->lit, - rs->pool); - lit_flt->val = val; - accum->enter_stack_ptr = rs->enter_stack_ptr; - rs->enter_stack_ptr = ((char*)accum)-sizeof(char*)*2; - accum->consts = NULL; -} - -static void -pgf_evaluate_accum_add_helper(PgfEvalAccum* accum, PgfLiteral lit) -{ - GuVariantInfo ei = gu_variant_open(lit); - switch (ei.tag) { - case PGF_LITERAL_INT: { - PgfLiteralInt* lint = ei.data; - ((PgfLiteralInt*)gu_variant_data(accum->lit))->val += lint->val; - break; - } - case PGF_LITERAL_STR: { - PgfLiteralStr* lstr = ei.data; - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lflt = ei.data; - ((PgfLiteralFlt*)gu_variant_data(accum->lit))->val += lflt->val; - break; - } - } -} - -PGF_INTERNAL void -pgf_evaluate_accum_add(PgfReasoner* rs, - PgfEvalAccum* accum, PgfClosure* closure) -{ - if (closure->code == rs->eval_gates->evaluate_value_lit) { - PgfValueLit* val = (PgfValueLit*) closure; - pgf_evaluate_accum_add_helper(accum, val->lit); - } else if (closure->code == rs->eval_gates->evaluate_value_const) { - if (accum->consts == NULL) - accum->consts = gu_new_buf(PgfClosure*, rs->pool); - - PgfValuePAP* pap = (PgfValuePAP*) closure; - - if (pap->fun->code == rs->eval_gates->evaluate_sum) { - PgfValueSum* val = (PgfValueSum*) ((PgfValuePAP*) closure)->fun; - pgf_evaluate_accum_add_helper(accum, val->lit); - - size_t n_consts = gu_buf_length(val->consts); - for (size_t i = 0; i < n_consts; i++) { - PgfClosure* clos = gu_buf_get(val->consts, PgfClosure*, i); - gu_buf_push(accum->consts, PgfClosure*, clos); - } - } else { - gu_buf_push(accum->consts, PgfClosure*, closure); - } - } else { - gu_impossible(); - } -} - -PGF_INTERNAL PgfClosure* -pgf_evaluate_accum_done(PgfReasoner* rs, PgfEvalAccum* accum) -{ - rs->enter_stack_ptr = accum->enter_stack_ptr; - - if (accum->consts == NULL) { - PgfValueLit* val = gu_new(PgfValueLit, rs->pool); - val->header.code = rs->eval_gates->evaluate_value_lit; - val->lit = accum->lit; - return &val->header; - } else { - PgfValueSum* val = gu_new(PgfValueSum, rs->pool); - val->header.code = rs->eval_gates->evaluate_sum; - val->lit = accum->lit; - val->consts = accum->consts; - return &val->header; - } -} diff --git a/src/runtime/c/pgf/expr.c b/src/runtime/c/pgf/expr.c deleted file mode 100644 index 3187d218f..000000000 --- a/src/runtime/c/pgf/expr.c +++ /dev/null @@ -1,1892 +0,0 @@ -#include "pgf.h" -#include "data.h" -#include -#include -#include -#include -#include -#include -#include - -static PgfExpr -pgf_expr_unwrap(PgfExpr expr) -{ - while (true) { - GuVariantInfo i = gu_variant_open(expr); - switch (i.tag) { - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* eimpl = i.data; - expr = eimpl->expr; - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* etyped = i.data; - expr = etyped->expr; - break; - } - default: - return expr; - } - } -} - -static PgfExprTag -pgf_expr_arity(PgfExpr expr, int *arity) -{ - int n = 0; - while (true) { - PgfExpr e = pgf_expr_unwrap(expr); - GuVariantInfo i = gu_variant_open(e); - switch (i.tag) { - case PGF_EXPR_APP: { - PgfExprApp* app = i.data; - expr = app->fun; - n = n + 1; - break; - } - default: - *arity = n; - return i.tag; - } - } -} - -PGF_API PgfApplication* -pgf_expr_unapply(PgfExpr expr, GuPool* pool) -{ - int arity; - if (pgf_expr_arity(expr, &arity) != PGF_EXPR_FUN) { - return NULL; - } - PgfApplication* appl = gu_new_flex(pool, PgfApplication, args, arity); - appl->n_args = arity; - for (int n = arity - 1; n >= 0; n--) { - PgfExpr e = pgf_expr_unwrap(expr); - gu_assert(gu_variant_tag(e) == PGF_EXPR_APP); - PgfExprApp* app = gu_variant_data(e); - appl->args[n] = app->arg; - expr = app->fun; - } - appl->efun = pgf_expr_unwrap(expr); - gu_assert(gu_variant_tag(appl->efun) == PGF_EXPR_FUN); - PgfExprFun* fun = gu_variant_data(appl->efun); - appl->fun = fun->fun; - return appl; -} - -PGF_API PgfApplication* -pgf_expr_unapply_ex(PgfExpr expr, GuPool* pool) -{ - int arity; - pgf_expr_arity(expr, &arity); - - PgfApplication* appl = gu_new_flex(pool, PgfApplication, args, arity); - appl->n_args = arity; - for (int n = arity - 1; n >= 0; n--) { - PgfExpr e = pgf_expr_unwrap(expr); - gu_assert(gu_variant_tag(e) == PGF_EXPR_APP); - PgfExprApp* app = gu_variant_data(e); - appl->args[n] = app->arg; - expr = app->fun; - } - appl->efun = pgf_expr_unwrap(expr); - if (gu_variant_tag(appl->efun) == PGF_EXPR_FUN) { - PgfExprFun* fun = gu_variant_data(appl->efun); - appl->fun = fun->fun; - } else { - appl->fun = NULL; - } - return appl; -} - -PGF_API PgfExpr -pgf_expr_apply(PgfApplication* app, GuPool* pool) -{ - PgfExpr expr; - - size_t len = strlen(app->fun); - PgfExprFun *efun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, len+1, - &expr, pool); - strcpy(efun->fun, app->fun); - - for (int i = 0; i < app->n_args; i++) { - expr = gu_new_variant_i(pool, - PGF_EXPR_APP, PgfExprApp, - .fun = expr, - .arg = app->args[i]); - } - - return expr; -} - -PGF_API PgfExpr -pgf_expr_abs(PgfBindType bind_type, PgfCId id, PgfExpr body, GuPool* pool) -{ - return gu_new_variant_i(pool, - PGF_EXPR_ABS, PgfExprAbs, - .bind_type = bind_type, - .id = id, - .body = body); -} - -PGF_API PgfExprAbs* -pgf_expr_unabs(PgfExpr expr) -{ - GuVariantInfo i = gu_variant_open(expr); - if (i.tag == PGF_EXPR_ABS) { - return (PgfExprAbs*) i.data; - } - - return NULL; -} - -PGF_API PgfExpr -pgf_expr_meta(int id, GuPool* pool) -{ - return gu_new_variant_i(pool, - PGF_EXPR_META, PgfExprMeta, - .id = id); -} - -PGF_API PgfExprMeta* -pgf_expr_unmeta(PgfExpr expr) -{ - GuVariantInfo i = gu_variant_open(expr); - if (i.tag == PGF_EXPR_META) { - return (PgfExprMeta*) i.data; - } - - return NULL; -} - -PGF_API PgfExpr -pgf_expr_string(GuString str, GuPool* pool) -{ - PgfLiteral lit; - PgfLiteralStr* plit = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(str)+1, - &lit, pool); - strcpy(plit->val, str); - return gu_new_variant_i(pool, - PGF_EXPR_LIT, - PgfExprLit, - lit); -} - -PGF_API PgfExpr -pgf_expr_int(int val, GuPool* pool) -{ - PgfLiteral lit; - PgfLiteralInt* plit = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &lit, pool); - plit->val = val; - return gu_new_variant_i(pool, - PGF_EXPR_LIT, - PgfExprLit, - lit); -} - -PGF_API PgfExpr -pgf_expr_float(double val, GuPool* pool) -{ - PgfLiteral lit; - PgfLiteralFlt* plit = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &lit, pool); - plit->val = val; - return gu_new_variant_i(pool, - PGF_EXPR_LIT, - PgfExprLit, - lit); -} - -PGF_API void* -pgf_expr_unlit(PgfExpr expr, int lit_tag) -{ - expr = pgf_expr_unwrap(expr); - GuVariantInfo i = gu_variant_open(expr); - if (i.tag == PGF_EXPR_LIT) { - PgfExprLit* elit = i.data; - GuVariantInfo i2 = gu_variant_open(elit->lit); - if (i2.tag == lit_tag) { - return i2.data; - } - } - - return NULL; -} - -typedef struct PgfExprParser PgfExprParser; - -typedef enum { - PGF_TOKEN_LPAR, - PGF_TOKEN_RPAR, - PGF_TOKEN_LCURLY, - PGF_TOKEN_RCURLY, - PGF_TOKEN_QUESTION, - PGF_TOKEN_LAMBDA, - PGF_TOKEN_RARROW, - PGF_TOKEN_LTRIANGLE, - PGF_TOKEN_RTRIANGLE, - PGF_TOKEN_COMMA, - PGF_TOKEN_COLON, - PGF_TOKEN_SEMI, - PGF_TOKEN_WILD, - PGF_TOKEN_IDENT, - PGF_TOKEN_INT, - PGF_TOKEN_FLT, - PGF_TOKEN_STR, - PGF_TOKEN_UNKNOWN, - PGF_TOKEN_EOF, -} PGF_TOKEN_TAG; - -typedef GuUCS (*PgfParserGetc)(void* state, bool mark, GuExn* err); - -struct PgfExprParser { - GuExn* err; - GuPool* expr_pool; - GuPool* tmp_pool; - PGF_TOKEN_TAG token_tag; - GuStringBuf* token_value; - - void* getch_state; - PgfParserGetc getch; - GuUCS ch; -}; - -static void -pgf_expr_parser_getc(PgfExprParser* parser, bool mark) -{ - parser->ch = parser->getch(parser->getch_state, mark, parser->err); - if (!gu_ok(parser->err)) { - gu_exn_clear(parser->err); - parser->ch = EOF; - } -} - -static bool -pgf_is_ident_first(GuUCS ucs) -{ - return (ucs == '_') || - (ucs >= 'a' && ucs <= 'z') || - (ucs >= 'A' && ucs <= 'Z') || - (ucs >= 192 && ucs <= 255 && ucs != 247 && ucs != 215); -} - -static bool -pgf_is_ident_rest(GuUCS ucs) -{ - return (ucs == '_') || - (ucs == '\'') || - (ucs >= '0' && ucs <= '9') || - (ucs >= 'a' && ucs <= 'z') || - (ucs >= 'A' && ucs <= 'Z') || - (ucs >= 192 && ucs <= 255 && ucs != 247 && ucs != 215); -} - -static bool -pgf_is_normal_ident(PgfCId id) -{ - const uint8_t* p = (const uint8_t*) id; - GuUCS ucs = gu_utf8_decode(&p); - if (!pgf_is_ident_first(ucs)) - return false; - - for (;;) { - ucs = gu_utf8_decode(&p); - if (ucs == 0) - break; - if (!pgf_is_ident_rest(ucs)) - return false; - } - - return true; -} - -static void -pgf_expr_parser_token(PgfExprParser* parser, bool mark) -{ - while (isspace(parser->ch)) { - pgf_expr_parser_getc(parser, mark); - mark = false; - } - - parser->token_tag = PGF_TOKEN_UNKNOWN; - parser->token_value = NULL; - - switch (parser->ch) { - case EOF: - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_EOF; - break; - case '(': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_LPAR; - break; - case ')': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_RPAR; - break; - case '{': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_LCURLY; - break; - case '}': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_RCURLY; - break; - case '<': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_LTRIANGLE; - break; - case '>': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_RTRIANGLE; - break; - case '?': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_QUESTION; - break; - case '\\': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_LAMBDA; - break; - case '-': - pgf_expr_parser_getc(parser, mark); - if (parser->ch == '>') { - pgf_expr_parser_getc(parser, false); - parser->token_tag = PGF_TOKEN_RARROW; - } - break; - case ',': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_COMMA; - break; - case ':': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_COLON; - break; - case ';': - pgf_expr_parser_getc(parser, mark); - parser->token_tag = PGF_TOKEN_SEMI; - break; - case '\'': - pgf_expr_parser_getc(parser, mark); - - GuStringBuf* chars = gu_new_string_buf(parser->tmp_pool); - while (parser->ch != '\'' && parser->ch != EOF) { - if (parser->ch == '\\') { - pgf_expr_parser_getc(parser, false); - } - gu_out_utf8(parser->ch, gu_string_buf_out(chars), parser->err); - pgf_expr_parser_getc(parser, false); - } - if (parser->ch == '\'') { - pgf_expr_parser_getc(parser, false); - gu_out_utf8(0, gu_string_buf_out(chars), parser->err); - parser->token_tag = PGF_TOKEN_IDENT; - parser->token_value = chars; - } - break; - default: { - GuStringBuf* chars = gu_new_string_buf(parser->tmp_pool); - - if (pgf_is_ident_first(parser->ch)) { - do { - gu_out_utf8(parser->ch, gu_string_buf_out(chars), parser->err); - pgf_expr_parser_getc(parser, mark); - mark = false; - } while (pgf_is_ident_rest(parser->ch)); - gu_out_utf8(0, gu_string_buf_out(chars), parser->err); - parser->token_tag = PGF_TOKEN_IDENT; - parser->token_value = chars; - } else if (isdigit(parser->ch)) { - while (isdigit(parser->ch)) { - gu_out_utf8(parser->ch, gu_string_buf_out(chars), parser->err); - pgf_expr_parser_getc(parser, mark); - mark = false; - } - - if (parser->ch == '.') { - gu_out_utf8(parser->ch, gu_string_buf_out(chars), parser->err); - pgf_expr_parser_getc(parser, false); - - while (isdigit(parser->ch)) { - gu_out_utf8(parser->ch, gu_string_buf_out(chars), parser->err); - pgf_expr_parser_getc(parser, false); - } - gu_out_utf8(0, gu_string_buf_out(chars), parser->err); - parser->token_tag = PGF_TOKEN_FLT; - parser->token_value = chars; - } else { - gu_out_utf8(0, gu_string_buf_out(chars), parser->err); - parser->token_tag = PGF_TOKEN_INT; - parser->token_value = chars; - } - } else if (parser->ch == '"') { - pgf_expr_parser_getc(parser, mark); - - while (parser->ch != '"' && parser->ch != EOF) { - if (parser->ch == '\\') { - pgf_expr_parser_getc(parser, false); - switch (parser->ch) { - case '\\': - gu_out_utf8('\\', gu_string_buf_out(chars), parser->err); - break; - case '"': - gu_out_utf8('\"', gu_string_buf_out(chars), parser->err); - break; - case 'n': - gu_out_utf8('\n', gu_string_buf_out(chars), parser->err); - break; - case 'r': - gu_out_utf8('\r', gu_string_buf_out(chars), parser->err); - break; - case 'b': - gu_out_utf8('\b', gu_string_buf_out(chars), parser->err); - break; - case 't': - gu_out_utf8('\t', gu_string_buf_out(chars), parser->err); - break; - default: - return; - } - } else { - gu_out_utf8(parser->ch, gu_string_buf_out(chars), parser->err); - } - pgf_expr_parser_getc(parser, false); - } - - if (parser->ch == '"') { - pgf_expr_parser_getc(parser, false); - gu_out_utf8(0, gu_string_buf_out(chars), parser->err); - parser->token_tag = PGF_TOKEN_STR; - parser->token_value = chars; - } - } else { - pgf_expr_parser_getc(parser, mark); - } - break; - } - } -} - -static bool -pgf_expr_parser_lookahead(PgfExprParser* parser, int ch) -{ - while (isspace(parser->ch)) { - pgf_expr_parser_getc(parser, false); - } - - return (parser->ch == ch); -} - -PGF_API PgfExpr -pgf_expr_parser_expr(PgfExprParser* parser, bool mark); - -static PgfType* -pgf_expr_parser_type(PgfExprParser* parser, bool mark); - -static PgfExpr -pgf_expr_parser_term(PgfExprParser* parser, bool mark) -{ - switch (parser->token_tag) { - case PGF_TOKEN_LPAR: { - pgf_expr_parser_token(parser, false); - PgfExpr expr = pgf_expr_parser_expr(parser, false); - if (parser->token_tag == PGF_TOKEN_RPAR) { - pgf_expr_parser_token(parser, mark); - return expr; - } else { - return gu_null_variant; - } - } - case PGF_TOKEN_LTRIANGLE: { - pgf_expr_parser_token(parser, false); - PgfExpr expr = pgf_expr_parser_expr(parser, false); - if (gu_variant_is_null(expr)) - return gu_null_variant; - - if (parser->token_tag != PGF_TOKEN_COLON) { - return gu_null_variant; - } - pgf_expr_parser_token(parser, false); - - PgfType* type = pgf_expr_parser_type(parser, false); - if (type == NULL) - return gu_null_variant; - - if (parser->token_tag != PGF_TOKEN_RTRIANGLE) { - return gu_null_variant; - } - pgf_expr_parser_token(parser, mark); - - return gu_new_variant_i(parser->expr_pool, - PGF_EXPR_TYPED, - PgfExprTyped, - expr, type); - } - case PGF_TOKEN_QUESTION: { - pgf_expr_parser_token(parser, mark); - - PgfMetaId id = 0; - if (parser->token_tag == PGF_TOKEN_INT) { - char* str = - gu_string_buf_data(parser->token_value); - id = atoi(str); - pgf_expr_parser_token(parser, mark); - } - return gu_new_variant_i(parser->expr_pool, - PGF_EXPR_META, - PgfExprMeta, - id); - } - case PGF_TOKEN_IDENT: { - PgfCId id = gu_string_buf_data(parser->token_value); - pgf_expr_parser_token(parser, mark); - PgfExpr e; - PgfExprFun* fun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(id)+1, - &e, parser->expr_pool); - strcpy(fun->fun, id); - return e; - } - case PGF_TOKEN_INT: { - char* str = - gu_string_buf_data(parser->token_value); - int n = atoi(str); - pgf_expr_parser_token(parser, mark); - PgfLiteral lit = - gu_new_variant_i(parser->expr_pool, - PGF_LITERAL_INT, - PgfLiteralInt, - n); - return gu_new_variant_i(parser->expr_pool, - PGF_EXPR_LIT, - PgfExprLit, - lit); - } - case PGF_TOKEN_STR: { - char* str = - gu_string_buf_data(parser->token_value); - pgf_expr_parser_token(parser, mark); - return pgf_expr_string(str, parser->expr_pool); - } - case PGF_TOKEN_FLT: { - char* str = - gu_string_buf_data(parser->token_value); - double d; - if (!gu_string_to_double(str,&d)) - return gu_null_variant; - pgf_expr_parser_token(parser, mark); - PgfLiteral lit = - gu_new_variant_i(parser->expr_pool, - PGF_LITERAL_FLT, - PgfLiteralFlt, - d); - return gu_new_variant_i(parser->expr_pool, - PGF_EXPR_LIT, - PgfExprLit, - lit); - } - default: - return gu_null_variant; - } -} - -static PgfExpr -pgf_expr_parser_arg(PgfExprParser* parser, bool mark) -{ - PgfExpr arg; - - if (parser->token_tag == PGF_TOKEN_LCURLY) { - pgf_expr_parser_token(parser, false); - - arg = pgf_expr_parser_expr(parser, false); - if (gu_variant_is_null(arg)) - return gu_null_variant; - - if (parser->token_tag != PGF_TOKEN_RCURLY) { - return gu_null_variant; - } - pgf_expr_parser_token(parser, mark); - - arg = gu_new_variant_i(parser->expr_pool, - PGF_EXPR_IMPL_ARG, - PgfExprImplArg, - arg); - } else { - arg = pgf_expr_parser_term(parser, mark); - } - - return arg; -} - -static bool -pgf_expr_parser_bind(PgfExprParser* parser, GuBuf* binds) -{ - PgfCId var; - PgfBindType bind_type = PGF_BIND_TYPE_EXPLICIT; - - if (parser->token_tag == PGF_TOKEN_LCURLY) { - bind_type = PGF_BIND_TYPE_IMPLICIT; - pgf_expr_parser_token(parser, false); - } - - for (;;) { - if (parser->token_tag == PGF_TOKEN_IDENT) { - var = - gu_string_copy(gu_string_buf_data(parser->token_value), parser->expr_pool); - pgf_expr_parser_token(parser, false); - } else if (parser->token_tag == PGF_TOKEN_WILD) { - var = "_"; - pgf_expr_parser_token(parser, false); - } else { - return false; - } - - PgfExpr bind = - gu_new_variant_i(parser->expr_pool, - PGF_EXPR_ABS, - PgfExprAbs, - bind_type, - var, - gu_null_variant); - gu_buf_push(binds, PgfExpr, bind); - - if (bind_type == PGF_BIND_TYPE_EXPLICIT || - parser->token_tag != PGF_TOKEN_COMMA) { - break; - } - - pgf_expr_parser_token(parser, false); - } - - if (bind_type == PGF_BIND_TYPE_IMPLICIT) { - if (parser->token_tag != PGF_TOKEN_RCURLY) - return false; - pgf_expr_parser_token(parser, false); - } - - return true; -} - -static GuBuf* -pgf_expr_parser_binds(PgfExprParser* parser) -{ - GuBuf* binds = gu_new_buf(PgfExpr, parser->tmp_pool); - - for (;;) { - if (!pgf_expr_parser_bind(parser, binds)) - return NULL; - - if (parser->token_tag != PGF_TOKEN_COMMA) - break; - - pgf_expr_parser_token(parser, false); - } - - return binds; -} - -PGF_API GuString -pgf_expr_parser_ident(PgfExprParser* parser) -{ - GuString ident = NULL; - if (parser->token_tag == PGF_TOKEN_IDENT) { - ident = gu_string_copy(gu_string_buf_data(parser->token_value), parser->expr_pool); - pgf_expr_parser_token(parser, true); - } - return ident; -} - -PGF_API PgfExpr -pgf_expr_parser_expr(PgfExprParser* parser, bool mark) -{ - if (parser->token_tag == PGF_TOKEN_LAMBDA) { - pgf_expr_parser_token(parser, false); - GuBuf* binds = pgf_expr_parser_binds(parser); - if (binds == NULL) - return gu_null_variant; - - if (parser->token_tag != PGF_TOKEN_RARROW) { - return gu_null_variant; - } - pgf_expr_parser_token(parser, false); - - PgfExpr expr = pgf_expr_parser_expr(parser, mark); - if (gu_variant_is_null(expr)) - return gu_null_variant; - - size_t n_binds = gu_buf_length(binds); - for (size_t i = n_binds; i > 0; i--) { - PgfExpr bind = gu_buf_get(binds, PgfExpr, i-1); - - ((PgfExprAbs*) gu_variant_data(bind))->body = expr; - expr = bind; - } - return expr; - } else { - PgfExpr expr = pgf_expr_parser_term(parser, mark); - if (gu_variant_is_null(expr)) - return gu_null_variant; - - while (parser->token_tag != PGF_TOKEN_EOF && - parser->token_tag != PGF_TOKEN_RPAR && - parser->token_tag != PGF_TOKEN_RCURLY && - parser->token_tag != PGF_TOKEN_RTRIANGLE && - parser->token_tag != PGF_TOKEN_COLON && - parser->token_tag != PGF_TOKEN_COMMA && - parser->token_tag != PGF_TOKEN_SEMI && - parser->token_tag != PGF_TOKEN_UNKNOWN) { - PgfExpr arg = pgf_expr_parser_arg(parser, mark); - if (gu_variant_is_null(arg)) - return expr; - - expr = gu_new_variant_i(parser->expr_pool, - PGF_EXPR_APP, - PgfExprApp, - expr, arg); - } - - return expr; - } -} - -static bool -pgf_expr_parser_hypos(PgfExprParser* parser, GuBuf* hypos) -{ - PgfCId var; - PgfBindType bind_type = PGF_BIND_TYPE_EXPLICIT; - - for (;;) { - if (bind_type == PGF_BIND_TYPE_EXPLICIT && - parser->token_tag == PGF_TOKEN_LCURLY) { - bind_type = PGF_BIND_TYPE_IMPLICIT; - pgf_expr_parser_token(parser, false); - } - - if (parser->token_tag == PGF_TOKEN_IDENT) { - var = - gu_string_copy(gu_string_buf_data(parser->token_value), parser->expr_pool); - pgf_expr_parser_token(parser, false); - } else if (parser->token_tag == PGF_TOKEN_WILD) { - var = "_"; - pgf_expr_parser_token(parser, false); - } else { - return false; - } - - PgfHypo* hypo = gu_buf_extend(hypos); - hypo->bind_type = bind_type; - hypo->cid = var; - hypo->type = NULL; - - if (bind_type == PGF_BIND_TYPE_IMPLICIT && - parser->token_tag == PGF_TOKEN_RCURLY) { - bind_type = PGF_BIND_TYPE_EXPLICIT; - pgf_expr_parser_token(parser, false); - } - - if (parser->token_tag != PGF_TOKEN_COMMA) { - break; - } - - pgf_expr_parser_token(parser, false); - } - - if (bind_type == PGF_BIND_TYPE_IMPLICIT) - return false; - - return true; -} - -static PgfType* -pgf_expr_parser_atom(PgfExprParser* parser, bool mark) -{ - if (parser->token_tag != PGF_TOKEN_IDENT) - return NULL; - - PgfCId cid = - gu_string_copy(gu_string_buf_data(parser->token_value), parser->expr_pool); - pgf_expr_parser_token(parser, mark); - - GuBuf* args = gu_new_buf(PgfExpr, parser->tmp_pool); - while (parser->token_tag != PGF_TOKEN_EOF && - parser->token_tag != PGF_TOKEN_RPAR && - parser->token_tag != PGF_TOKEN_RTRIANGLE && - parser->token_tag != PGF_TOKEN_RARROW) { - PgfExpr arg = - pgf_expr_parser_arg(parser, mark); - if (gu_variant_is_null(arg)) - break; - - gu_buf_push(args, PgfExpr, arg); - } - - size_t n_exprs = gu_buf_length(args); - - PgfType* type = gu_new_flex(parser->expr_pool, PgfType, exprs, n_exprs); - type->hypos = gu_empty_seq(); - type->cid = cid; - type->n_exprs = n_exprs; - - for (size_t i = 0; i < n_exprs; i++) { - type->exprs[i] = gu_buf_get(args, PgfExpr, i); - } - - return type; -} - -static PgfType* -pgf_expr_parser_type(PgfExprParser* parser, bool mark) -{ - PgfType* type = NULL; - GuBuf* hypos = gu_new_buf(PgfHypo, parser->expr_pool); - - for (;;) { - if (parser->token_tag == PGF_TOKEN_LPAR) { - pgf_expr_parser_token(parser, false); - - size_t n_start = gu_buf_length(hypos); - - if ((parser->token_tag == PGF_TOKEN_IDENT && - (pgf_expr_parser_lookahead(parser, ',') || - pgf_expr_parser_lookahead(parser, ':'))) || - (parser->token_tag == PGF_TOKEN_LCURLY) || - (parser->token_tag == PGF_TOKEN_WILD)) { - - if (!pgf_expr_parser_hypos(parser, hypos)) - return NULL; - - if (parser->token_tag != PGF_TOKEN_COLON) - return NULL; - - pgf_expr_parser_token(parser, false); - } else { - PgfHypo* hypo = gu_buf_extend(hypos); - hypo->bind_type = PGF_BIND_TYPE_EXPLICIT; - hypo->cid = "_"; - hypo->type = NULL; - } - - size_t n_end = gu_buf_length(hypos); - - PgfType* type = pgf_expr_parser_type(parser, false); - if (type == NULL) - return NULL; - - if (parser->token_tag != PGF_TOKEN_RPAR) - return NULL; - - pgf_expr_parser_token(parser, false); - - if (parser->token_tag != PGF_TOKEN_RARROW) - return NULL; - - pgf_expr_parser_token(parser, false); - - for (size_t i = n_start; i < n_end; i++) { - PgfHypo* hypo = gu_buf_index(hypos, PgfHypo, i); - hypo->type = type; - } - } else { - type = pgf_expr_parser_atom(parser, mark); - if (type == NULL) - return NULL; - - if (parser->token_tag != PGF_TOKEN_RARROW) - break; - - pgf_expr_parser_token(parser, false); - - PgfHypo* hypo = gu_buf_extend(hypos); - hypo->bind_type = PGF_BIND_TYPE_EXPLICIT; - hypo->cid = "_"; - hypo->type = type; - } - } - - type->hypos = gu_buf_data_seq(hypos); - - return type; -} - -PGF_API PgfExprParser* -pgf_new_parser(void* getc_state, PgfParserGetc getc, GuPool* pool, GuPool* tmp_pool, GuExn* err) -{ - PgfExprParser* parser = gu_new(PgfExprParser, tmp_pool); - parser->err = err; - parser->expr_pool = pool; - parser->tmp_pool = tmp_pool; - parser->getch_state = getc_state; - parser->getch = getc; - parser->ch = ' '; - pgf_expr_parser_token(parser, false); - return parser; -} - -static GuUCS -pgf_expr_parser_in_getc(void* state, bool mark, GuExn* err) -{ - return gu_in_utf8((GuIn*) state, err); -} - -PGF_API PgfExpr -pgf_read_expr(GuIn* in, GuPool* pool, GuPool* tmp_pool, GuExn* err) -{ - PgfExprParser* parser = - pgf_new_parser(in, pgf_expr_parser_in_getc, pool, tmp_pool, err); - PgfExpr expr = pgf_expr_parser_expr(parser, true); - if (parser->token_tag != PGF_TOKEN_EOF) - return gu_null_variant; - return expr; -} - -PGF_API PgfType* -pgf_read_type(GuIn* in, GuPool* pool, GuPool* tmp_pool, GuExn* err) -{ - PgfExprParser* parser = - pgf_new_parser(in, pgf_expr_parser_in_getc, pool, tmp_pool, err); - PgfType* type = pgf_expr_parser_type(parser, true); - if (parser->token_tag != PGF_TOKEN_EOF) - return NULL; - return type; -} - -PGF_API bool -pgf_literal_eq(PgfLiteral lit1, PgfLiteral lit2) -{ - GuVariantInfo ei1 = gu_variant_open(lit1); - GuVariantInfo ei2 = gu_variant_open(lit2); - - if (ei1.tag != ei2.tag) - return false; - - switch (ei1.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lit1 = ei1.data; - PgfLiteralStr* lit2 = ei2.data; - return strcmp(lit1->val, lit2->val) == 0; - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lit1 = ei1.data; - PgfLiteralInt* lit2 = ei2.data; - return (lit1->val == lit2->val); - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lit1 = ei1.data; - PgfLiteralFlt* lit2 = ei2.data; - return (lit1->val == lit2->val); - } - default: - gu_impossible(); - } - - return false; -} - -PGF_API int -pgf_expr_eq(PgfExpr e1, PgfExpr e2) -{ - GuVariantInfo ei1 = gu_variant_open(e1); - GuVariantInfo ei2 = gu_variant_open(e2); - - if (ei1.tag != ei2.tag) - return false; - - switch (ei1.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* abs1 = ei1.data; - PgfExprAbs* abs2 = ei2.data; - return strcmp(abs1->id, abs2->id) == 0 && - pgf_expr_eq(abs1->body, abs2->body); - } - case PGF_EXPR_APP: { - PgfExprApp* app1 = ei1.data; - PgfExprApp* app2 = ei2.data; - return (pgf_expr_eq(app1->fun,app2->fun) && - pgf_expr_eq(app1->arg,app2->arg)); - } - case PGF_EXPR_LIT: { - PgfExprLit* lit1 = ei1.data; - PgfExprLit* lit2 = ei2.data; - return (pgf_literal_eq(lit1->lit,lit2->lit)); - } - case PGF_EXPR_META: { - PgfExprMeta* meta1 = ei1.data; - PgfExprMeta* meta2 = ei2.data; - return (meta1->id == meta2->id); - } - case PGF_EXPR_FUN: { - PgfExprFun* fun1 = ei1.data; - PgfExprFun* fun2 = ei2.data; - return strcmp(fun1->fun, fun2->fun) == 0; - } - case PGF_EXPR_VAR: { - PgfExprVar* var1 = ei1.data; - PgfExprVar* var2 = ei2.data; - return (var1->var == var2->var); - } - case PGF_EXPR_TYPED: { - PgfExprTyped* typed1 = ei1.data; - PgfExprTyped* typed2 = ei2.data; - return pgf_expr_eq(typed1->expr, typed2->expr) && - pgf_type_eq(typed1->type, typed2->type); - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* impl1 = ei1.data; - PgfExprImplArg* impl2 = ei2.data; - return pgf_expr_eq(impl1->expr, impl2->expr); - } - default: - gu_impossible(); - } - - return false; -} - -PGF_API GuHash -pgf_literal_hash(GuHash h, PgfLiteral lit) -{ - GuVariantInfo i = gu_variant_open(lit); - - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lit = i.data; - h = gu_string_hash(h, lit->val); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lit = i.data; - h = gu_hash_byte(h, lit->val); - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lit = i.data; - h = gu_hash_byte(h, lit->val); - break; - } - default: - gu_impossible(); - } - - return h; -} - -PGF_API GuHash -pgf_expr_hash(GuHash h, PgfExpr e) -{ - GuVariantInfo ei = gu_variant_open(e); - switch (ei.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* abs = ei.data; - h = gu_string_hash(h, abs->id); - h = pgf_expr_hash(h, abs->body); - break; - } - case PGF_EXPR_APP: { - PgfExprApp* app = ei.data; - h = pgf_expr_hash(h, app->fun); - h = pgf_expr_hash(h, app->arg); - break; - } - case PGF_EXPR_LIT: { - PgfExprLit* lit = ei.data; - h = pgf_literal_hash(h, lit->lit); - break; - } - case PGF_EXPR_META: - h = gu_hash_byte(h, '?'); - break; - case PGF_EXPR_FUN: { - PgfExprFun* fun = ei.data; - h = gu_string_hash(h, fun->fun); - break; - } - case PGF_EXPR_VAR: { - PgfExprVar* evar = ei.data; - - h = gu_hash_byte(h, evar->var); - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* typed = ei.data; - h = pgf_expr_hash(h, typed->expr); - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* impl = ei.data; - h = pgf_expr_hash(h, impl->expr); - break; - } - default: - gu_impossible(); - } - return h; -} - -PGF_API size_t -pgf_expr_size(PgfExpr expr) -{ - GuVariantInfo ei = gu_variant_open(expr); - switch (ei.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* abs = ei.data; - return pgf_expr_size(abs->body); - } - case PGF_EXPR_APP: { - PgfExprApp* app = ei.data; - return pgf_expr_size(app->fun) + pgf_expr_size(app->arg); - } - case PGF_EXPR_LIT: - case PGF_EXPR_META: - case PGF_EXPR_FUN: - case PGF_EXPR_VAR: { - return 1; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* typed = ei.data; - return pgf_expr_size(typed->expr); - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* impl = ei.data; - return pgf_expr_size(impl->expr); - } - default: - gu_impossible(); - return 0; - } -} - -static void -pgf_expr_functions_helper(PgfExpr expr, GuBuf* functions) -{ - GuVariantInfo ei = gu_variant_open(expr); - switch (ei.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* abs = ei.data; - pgf_expr_functions_helper(abs->body, functions); - break; - } - case PGF_EXPR_APP: { - PgfExprApp* app = ei.data; - pgf_expr_functions_helper(app->fun, functions); - pgf_expr_functions_helper(app->arg, functions); - break; - } - case PGF_EXPR_LIT: - case PGF_EXPR_META: - case PGF_EXPR_VAR: { - break; - } - case PGF_EXPR_FUN:{ - PgfExprFun* fun = ei.data; - gu_buf_push(functions, GuString, fun->fun); - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* typed = ei.data; - pgf_expr_functions_helper(typed->expr, functions); - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* impl = ei.data; - pgf_expr_functions_helper(impl->expr, functions); - break; - } - default: - gu_impossible(); - } -} - -PGF_API GuSeq* -pgf_expr_functions(PgfExpr expr, GuPool* pool) -{ - GuBuf* functions = gu_new_buf(GuString, pool); - pgf_expr_functions_helper(expr, functions); - return gu_buf_data_seq(functions); -} - -PGF_API PgfType* -pgf_type_substitute(PgfType* type, GuSeq* meta_values, GuPool* pool) -{ - size_t n_hypos = gu_seq_length(type->hypos); - PgfHypos* new_hypos = gu_new_seq(PgfHypo, n_hypos, pool); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(type->hypos, PgfHypo, i); - PgfHypo* new_hypo = gu_seq_index(new_hypos, PgfHypo, i); - - new_hypo->bind_type = hypo->bind_type; - new_hypo->cid = gu_string_copy(hypo->cid, pool); - new_hypo->type = pgf_type_substitute(hypo->type, meta_values, pool); - } - - PgfType *new_type = - gu_new_flex(pool, PgfType, exprs, type->n_exprs); - new_type->hypos = new_hypos; - new_type->cid = gu_string_copy(type->cid, pool); - new_type->n_exprs = type->n_exprs; - - for (size_t i = 0; i < type->n_exprs; i++) { - new_type->exprs[i] = - pgf_expr_substitute(type->exprs[i], meta_values, pool); - } - - return new_type; -} - -PGF_API PgfExpr -pgf_expr_substitute(PgfExpr expr, GuSeq* meta_values, GuPool* pool) -{ - GuVariantInfo ei = gu_variant_open(expr); - switch (ei.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* abs = ei.data; - - PgfCId id = gu_string_copy(abs->id, pool); - PgfExpr body = pgf_expr_substitute(abs->body, meta_values, pool); - return gu_new_variant_i(pool, - PGF_EXPR_ABS, - PgfExprAbs, - abs->bind_type, id, body); - } - case PGF_EXPR_APP: { - PgfExprApp* app = ei.data; - - PgfExpr fun = pgf_expr_substitute(app->fun, meta_values, pool); - PgfExpr arg = pgf_expr_substitute(app->arg, meta_values, pool); - return gu_new_variant_i(pool, - PGF_EXPR_APP, - PgfExprApp, - fun, arg); - } - case PGF_EXPR_LIT: { - PgfExprLit* elit = ei.data; - - PgfLiteral lit; - GuVariantInfo i = gu_variant_open(elit->lit); - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lstr = i.data; - - PgfLiteralStr* new_lstr = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(lstr->val)+1, - &lit, pool); - strcpy(new_lstr->val, lstr->val); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lint = i.data; - - PgfLiteralInt* new_lint = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &lit, pool); - new_lint->val = lint->val; - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lflt = i.data; - - PgfLiteralFlt* new_lflt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &lit, pool); - new_lflt->val = lflt->val; - break; - } - default: - gu_impossible(); - } - - return gu_new_variant_i(pool, - PGF_EXPR_LIT, - PgfExprLit, - lit); - } - case PGF_EXPR_META: { - PgfExprMeta* meta = ei.data; - PgfExpr e = gu_null_variant; - if ((size_t) meta->id < gu_seq_length(meta_values)) { - e = gu_seq_get(meta_values, PgfExpr, meta->id); - } - if (gu_variant_is_null(e)) { - e = gu_new_variant_i(pool, - PGF_EXPR_META, - PgfExprMeta, - meta->id); - } - return e; - } - case PGF_EXPR_FUN: { - PgfExprFun* fun = ei.data; - - PgfExpr e; - PgfExprFun* new_fun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(fun->fun)+1, - &e, pool); - strcpy(new_fun->fun, fun->fun); - return e; - } - case PGF_EXPR_VAR: { - PgfExprVar* var = ei.data; - return gu_new_variant_i(pool, - PGF_EXPR_VAR, - PgfExprVar, - var->var); - } - case PGF_EXPR_TYPED: { - PgfExprTyped* typed = ei.data; - - PgfExpr expr = pgf_expr_substitute(typed->expr, meta_values, pool); - PgfType *type = pgf_type_substitute(typed->type, meta_values, pool); - - return gu_new_variant_i(pool, - PGF_EXPR_TYPED, - PgfExprTyped, - expr, - type); - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* impl = ei.data; - - PgfExpr expr = pgf_expr_substitute(impl->expr, meta_values, pool); - return gu_new_variant_i(pool, - PGF_EXPR_IMPL_ARG, - PgfExprImplArg, - expr); - } - default: - gu_impossible(); - return gu_null_variant; - } -} - -PGF_API void -pgf_print_cid(PgfCId id, - GuOut* out, GuExn* err) -{ - if (pgf_is_normal_ident(id)) - gu_string_write(id, out, err); - else { - gu_putc('\'', out, err); - const uint8_t* p = (const uint8_t*) id; - for (;;) { - GuUCS ucs = gu_utf8_decode(&p); - if (ucs == 0) - break; - if (ucs == '\'') - gu_puts("\\\'", out, err); - else if (ucs == '\\') - gu_puts("\\\\", out, err); - else - gu_out_utf8(ucs, out, err); - } - gu_putc('\'', out, err); - } -} - -PGF_API void -pgf_print_literal(PgfLiteral lit, - GuOut* out, GuExn* err) -{ - GuVariantInfo ei = gu_variant_open(lit); - switch (ei.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lit = ei.data; - gu_putc('"', out, err); - const uint8_t* s = (uint8_t*) lit->val; - while (*s) { - GuUCS c = gu_utf8_decode(&s); - switch (c) { - case '\\': - gu_puts("\\\\", out, err); - break; - case '"': - gu_puts("\\\"", out, err); - break; - case '\n': - gu_puts("\\n", out, err); - break; - case '\r': - gu_puts("\\r", out, err); - break; - case '\b': - gu_puts("\\b", out, err); - break; - case '\t': - gu_puts("\\t", out, err); - break; - default: - gu_out_utf8(c, out, err); - } - } - gu_putc('"', out, err); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lit = ei.data; - gu_printf(out, err, "%d", lit->val); - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lit = ei.data; - gu_printf(out, err, "%lf", lit->val); - break; - } - default: - gu_impossible(); - } -} - -PGF_API void -pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec, - GuOut* out, GuExn* err) -{ - GuVariantInfo ei = gu_variant_open(expr); - switch (ei.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* abs = ei.data; - - if (prec > 1) { - gu_puts("(", out, err); - } - - gu_putc('\\', out, err); - - PgfPrintContext* new_ctxt = ctxt; - - for (;;) { - if (abs->bind_type == PGF_BIND_TYPE_IMPLICIT) { - gu_putc('{', out, err); - } - pgf_print_cid(abs->id, out, err); - if (abs->bind_type == PGF_BIND_TYPE_IMPLICIT) { - gu_putc('}', out, err); - } - - PgfPrintContext* c = malloc(sizeof(PgfPrintContext)); - c->name = abs->id; - c->next = new_ctxt; - new_ctxt = c; - - if (gu_variant_tag(abs->body) != PGF_EXPR_ABS) - break; - - gu_putc(',', out, err); - - abs = gu_variant_data(abs->body); - } - - gu_puts(" -> ", out, err); - pgf_print_expr(abs->body, new_ctxt, 1, out, err); - - while (new_ctxt != ctxt) { - PgfPrintContext* next = new_ctxt->next; - free(new_ctxt); - new_ctxt = next; - } - - if (prec > 1) { - gu_puts(")", out, err); - } - break; - } - case PGF_EXPR_APP: { - PgfExprApp* app = ei.data; - if (prec > 3) { - gu_puts("(", out, err); - } - pgf_print_expr(app->fun, ctxt, 3, out, err); - gu_puts(" ", out, err); - pgf_print_expr(app->arg, ctxt, 4, out, err); - if (prec > 3) { - gu_puts(")", out, err); - } - break; - } - case PGF_EXPR_LIT: { - PgfExprLit* lit = ei.data; - pgf_print_literal(lit->lit, out, err); - break; - } - case PGF_EXPR_META: { - PgfExprMeta* meta = ei.data; - gu_putc('?', out, err); - if (meta->id > 0) - gu_printf(out, err, "%d", meta->id); - break; - } - case PGF_EXPR_FUN: { - PgfExprFun* fun = ei.data; - pgf_print_cid(fun->fun, out, err); - break; - } - case PGF_EXPR_VAR: { - PgfExprVar* evar = ei.data; - - int var = evar->var; - PgfPrintContext* c = ctxt; - while (c != NULL && var > 0) { - c = ctxt->next; - var--; - } - - if (c == NULL) { - gu_printf(out, err, "#%d", evar->var); - } else { - pgf_print_cid(c->name, out, err); - } - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* typed = ei.data; - gu_putc('<', out, err); - pgf_print_expr(typed->expr, ctxt, 0, out, err); - gu_puts(" : ", out, err); - pgf_print_type(typed->type, ctxt, 0, out, err); - gu_putc('>', out, err); - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* impl = ei.data; - gu_putc('{', out, err); - pgf_print_expr(impl->expr, ctxt, 0, out, err); - gu_putc('}', out, err); - break; - } - default: - gu_impossible(); - } -} - -PGF_API PgfPrintContext* -pgf_print_hypo(PgfHypo *hypo, PgfPrintContext* ctxt, int prec, - GuOut *out, GuExn *err) -{ - if (hypo->bind_type == PGF_BIND_TYPE_IMPLICIT) { - gu_puts("({", out, err); - pgf_print_cid(hypo->cid, out, err); - gu_puts("} : ", out, err); - pgf_print_type(hypo->type, ctxt, 0, out, err); - gu_puts(")", out, err); - } else { - GuPool* tmp_pool = gu_new_pool(); - - if (strcmp(hypo->cid, "_") != 0) { - gu_puts("(", out, err); - pgf_print_cid(hypo->cid, out, err); - gu_puts(" : ", out, err); - pgf_print_type(hypo->type, ctxt, 0, out, err); - gu_puts(")", out, err); - } else { - pgf_print_type(hypo->type, ctxt, prec, out, err); - } - - gu_pool_free(tmp_pool); - } - - PgfPrintContext* new_ctxt = malloc(sizeof(PgfPrintContext)); - new_ctxt->name = hypo->cid; - new_ctxt->next = ctxt; - return new_ctxt; -} - -PGF_API void -pgf_print_type(PgfType *type, PgfPrintContext* ctxt, int prec, - GuOut *out, GuExn *err) -{ - size_t n_hypos = gu_seq_length(type->hypos); - - if (n_hypos > 0) { - if (prec > 0) gu_putc('(', out, err); - - PgfPrintContext* new_ctxt = ctxt; - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo *hypo = gu_seq_index(type->hypos, PgfHypo, i); - new_ctxt = pgf_print_hypo(hypo, new_ctxt, 1, out, err); - - gu_puts(" -> ", out, err); - } - - pgf_print_cid(type->cid, out, err); - - for (size_t i = 0; i < type->n_exprs; i++) { - gu_puts(" ", out, err); - pgf_print_expr(type->exprs[i], new_ctxt, 4, out, err); - } - - while (new_ctxt != ctxt) { - PgfPrintContext* next = new_ctxt->next; - free(new_ctxt); - new_ctxt = next; - } - - if (prec > 0) gu_putc(')', out, err); - } else if (type->n_exprs > 0) { - if (prec > 3) gu_putc('(', out, err); - - gu_string_write(type->cid, out, err); - - for (size_t i = 0; i < type->n_exprs; i++) { - gu_puts(" ", out, err); - pgf_print_expr(type->exprs[i], ctxt, 4, out, err); - } - - if (prec > 3) gu_putc(')', out, err); - } else { - pgf_print_cid(type->cid, out, err); - } -} - -PGF_API void -pgf_print_context(PgfHypos *hypos, PgfPrintContext* ctxt, - GuOut *out, GuExn *err) -{ - PgfPrintContext* new_ctxt = ctxt; - - size_t n_hypos = gu_seq_length(hypos); - for (size_t i = 0; i < n_hypos; i++) { - if (i > 0) - gu_putc(' ', out, err); - - PgfHypo *hypo = gu_seq_index(hypos, PgfHypo, i); - new_ctxt = pgf_print_hypo(hypo, new_ctxt, 4, out, err); - } -} - -PGF_API bool -pgf_type_eq(PgfType* t1, PgfType* t2) -{ - if (gu_seq_length(t1->hypos) != gu_seq_length(t2->hypos)) - return false; - - size_t n_hypos = gu_seq_length(t1->hypos); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo *hypo1 = gu_seq_index(t1->hypos, PgfHypo, i); - PgfHypo *hypo2 = gu_seq_index(t1->hypos, PgfHypo, i); - - if (hypo1->bind_type != hypo2->bind_type) - return false; - - if (strcmp(hypo1->cid, hypo2->cid) != 0) - return false; - - if (!pgf_type_eq(hypo1->type, hypo2->type)) - return false; - } - - if (strcmp(t1->cid, t2->cid) != 0) - return false; - - if (t1->n_exprs != t2->n_exprs) - return false; - - for (size_t i = 0; i < t1->n_exprs; i++) { - if (!pgf_expr_eq(t1->exprs[i], t2->exprs[i])) - return false; - } - - return true; -} - -PGF_API PgfLiteral -pgf_clone_literal(PgfLiteral lit, GuPool* pool) -{ - PgfLiteral new_lit = gu_null_variant; - - GuVariantInfo inf = gu_variant_open(lit); - switch (inf.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lit_str = inf.data; - PgfLiteralStr* new_lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(lit_str->val)+1, - &new_lit, pool); - strcpy(new_lit_str->val, lit_str->val); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt *lit_int = inf.data; - PgfLiteralInt *new_lit_int = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &new_lit, pool); - new_lit_int->val = lit_int->val; - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt *lit_flt = inf.data; - PgfLiteralFlt *new_lit_flt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &new_lit, pool); - new_lit_flt->val = lit_flt->val; - break; - } - default: - gu_impossible(); - } - - return new_lit; -} - -PGF_API PgfExpr -pgf_clone_expr(PgfExpr expr, GuPool* pool) -{ - PgfExpr new_expr = gu_null_variant; - - GuVariantInfo inf = gu_variant_open(expr); - switch (inf.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* abs = inf.data; - PgfExprAbs* new_abs = - gu_new_variant(PGF_EXPR_ABS, - PgfExprAbs, - &new_expr, pool); - - new_abs->bind_type = abs->bind_type; - new_abs->id = gu_string_copy(abs->id, pool); - new_abs->body = pgf_clone_expr(abs->body,pool); - break; - } - case PGF_EXPR_APP: { - PgfExprApp* app = inf.data; - PgfExprApp* new_app = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &new_expr, pool); - new_app->fun = pgf_clone_expr(app->fun, pool); - new_app->arg = pgf_clone_expr(app->arg, pool); - break; - } - case PGF_EXPR_LIT: { - PgfExprLit* lit = inf.data; - PgfExprLit* new_lit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &new_expr, pool); - new_lit->lit = pgf_clone_literal(lit->lit, pool); - break; - } - case PGF_EXPR_META: { - PgfExprMeta* meta = inf.data; - PgfExprMeta* new_meta = - gu_new_variant(PGF_EXPR_META, - PgfExprMeta, - &new_expr, pool); - new_meta->id = meta->id; - break; - } - case PGF_EXPR_FUN: { - PgfExprFun* fun = inf.data; - PgfExprFun* new_fun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(fun->fun)+1, - &new_expr, pool); - strcpy(new_fun->fun, fun->fun); - break; - } - case PGF_EXPR_VAR: { - PgfExprVar* var = inf.data; - PgfExprVar* new_var = - gu_new_variant(PGF_EXPR_VAR, - PgfExprVar, - &new_expr, pool); - new_var->var = var->var; - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* typed = inf.data; - - PgfExprTyped *new_typed = - gu_new_variant(PGF_EXPR_TYPED, - PgfExprTyped, - &new_expr, pool); - new_typed->expr = pgf_clone_expr(typed->expr, pool); - new_typed->type = pgf_clone_type(typed->type, pool); - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* impl = inf.data; - PgfExprImplArg *new_impl = - gu_new_variant(PGF_EXPR_IMPL_ARG, - PgfExprImplArg, - &new_expr, pool); - new_impl->expr = pgf_clone_expr(impl->expr, pool); - break; - } - default: - gu_impossible(); - } - - return new_expr; -} - -PGF_API PgfType* -pgf_clone_type(PgfType* type, GuPool* pool) -{ - PgfType* new_type = - gu_new_flex(pool, PgfType, exprs, type->n_exprs); - - size_t n_hypos = gu_seq_length(type->hypos); - new_type->hypos = gu_new_seq(PgfHypo, n_hypos, pool); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(type->hypos, PgfHypo, i); - PgfHypo* new_hypo = gu_seq_index(new_type->hypos, PgfHypo, i); - - new_hypo->bind_type = hypo->bind_type; - new_hypo->cid = gu_string_copy(hypo->cid, pool); - new_hypo->type = pgf_clone_type(hypo->type, pool); - } - - new_type->cid = gu_string_copy(type->cid, pool); - - new_type->n_exprs = type->n_exprs; - for (size_t i = 0; i < new_type->n_exprs; i++) { - new_type->exprs[i] = pgf_clone_expr(type->exprs[i], pool); - } - - return new_type; -} - -PGF_API prob_t -pgf_compute_tree_probability(PgfPGF *gr, PgfExpr expr) -{ - GuVariantInfo ei = gu_variant_open(expr); - switch (ei.tag) { - case PGF_EXPR_APP: { - PgfExprApp* app = ei.data; - return pgf_compute_tree_probability(gr, app->fun) + - pgf_compute_tree_probability(gr, app->arg); - } - case PGF_EXPR_FUN: { - PgfExprFun* fun = ei.data; - PgfAbsFun* absfun = - gu_seq_binsearch(gr->abstract.funs, pgf_absfun_order, PgfAbsFun, fun->fun); - if (absfun == NULL) - return INFINITY; - else - return absfun->ep.prob; - } - default: - return 0; - } -} diff --git a/src/runtime/c/pgf/expr.h b/src/runtime/c/pgf/expr.h deleted file mode 100644 index 2f1ab9889..000000000 --- a/src/runtime/c/pgf/expr.h +++ /dev/null @@ -1,245 +0,0 @@ -#ifndef EXPR_H_ -#define EXPR_H_ - -#include -#include -#include -#include - -/// Abstract syntax trees -/// @file - -/// An abstract syntax tree -typedef GuVariant PgfExpr; - -typedef struct PgfHypo PgfHypo; -typedef struct PgfType PgfType; - -typedef int PgfMetaId; - -typedef enum { - PGF_BIND_TYPE_EXPLICIT, - PGF_BIND_TYPE_IMPLICIT -} PgfBindType; - -// PgfLiteral - -typedef GuVariant PgfLiteral; - - -typedef enum { - PGF_LITERAL_STR, - PGF_LITERAL_INT, - PGF_LITERAL_FLT, - PGF_LITERAL_NUM_TAGS -} PgfLiteralTag; - -typedef struct { - char val[0]; // a flexible array that contains the value -} PgfLiteralStr; - -typedef struct { - int val; -} PgfLiteralInt; - -typedef struct { - double val; -} PgfLiteralFlt; - - - -struct PgfHypo { - PgfBindType bind_type; - - PgfCId cid; - /**< Locally scoped name for the parameter if dependent types - * are used. "_" for normal parameters. */ - - PgfType* type; -}; - -typedef GuSeq PgfHypos; - -struct PgfType { - PgfHypos* hypos; - PgfCId cid; /// XXX: resolve to PgfCat*? - size_t n_exprs; - PgfExpr exprs[]; -}; - - -typedef enum { - PGF_EXPR_ABS, - PGF_EXPR_APP, - PGF_EXPR_LIT, - PGF_EXPR_META, - PGF_EXPR_FUN, - PGF_EXPR_VAR, - PGF_EXPR_TYPED, - PGF_EXPR_IMPL_ARG, - PGF_EXPR_NUM_TAGS -} PgfExprTag; - -typedef struct { - PgfBindType bind_type; - PgfCId id; - PgfExpr body; -} PgfExprAbs; - -typedef struct { - PgfExpr fun; - PgfExpr arg; -} PgfExprApp; - -typedef struct { - PgfLiteral lit; -} PgfExprLit; - -typedef struct { - PgfMetaId id; -} PgfExprMeta; - -typedef struct { - char fun[0]; -} PgfExprFun; - -typedef struct { - int var; -} PgfExprVar; - -/**< A variable. The value is a de Bruijn index to the environment, - * beginning from the innermost variable. */ - -typedef struct { - PgfExpr expr; - PgfType* type; -} PgfExprTyped; - -typedef struct { - PgfExpr expr; -} PgfExprImplArg; - -typedef float prob_t; - -typedef struct { - prob_t prob; - PgfExpr expr; -} PgfExprProb; - -typedef struct PgfApplication PgfApplication; - -struct PgfApplication { - PgfExpr efun; - PgfCId fun; - int n_args; - PgfExpr args[]; -}; - -PGF_API_DECL PgfApplication* -pgf_expr_unapply(PgfExpr expr, GuPool* pool); - -PGF_API_DECL PgfApplication* -pgf_expr_unapply_ex(PgfExpr expr, GuPool* pool); - -PGF_API_DECL PgfExpr -pgf_expr_apply(PgfApplication*, GuPool* pool); - -PGF_API_DECL PgfExpr -pgf_expr_abs(PgfBindType bind_type, PgfCId id, PgfExpr body, GuPool* pool); - -PGF_API_DECL PgfExprAbs* -pgf_expr_unabs(PgfExpr expr); - -PGF_API_DECL PgfExpr -pgf_expr_string(GuString, GuPool* pool); - -PGF_API_DECL PgfExpr -pgf_expr_int(int val, GuPool* pool); - -PGF_API_DECL PgfExpr -pgf_expr_float(double val, GuPool* pool); - -PGF_API_DECL void* -pgf_expr_unlit(PgfExpr expr, int lit_tag); - -PGF_API_DECL PgfExpr -pgf_expr_meta(int id, GuPool* pool); - -PGF_API_DECL PgfExprMeta* -pgf_expr_unmeta(PgfExpr expr); - -PGF_API_DECL PgfExpr -pgf_read_expr(GuIn* in, GuPool* pool, GuPool* tmp_pool, GuExn* err); - -PGF_API_DECL PgfType* -pgf_read_type(GuIn* in, GuPool* pool, GuPool* tmp_pool, GuExn* err); - -PGF_API_DECL bool -pgf_literal_eq(PgfLiteral lit1, PgfLiteral lit2); - -PGF_API_DECL int -pgf_expr_eq(PgfExpr e1, PgfExpr e2); - -PGF_API_DECL bool -pgf_type_eq(PgfType* t1, PgfType* t2); - -PGF_API_DECL GuHash -pgf_literal_hash(GuHash h, PgfLiteral lit); - -PGF_API_DECL GuHash -pgf_expr_hash(GuHash h, PgfExpr e); - -PGF_API_DECL size_t -pgf_expr_size(PgfExpr expr); - -PGF_API_DECL GuSeq* -pgf_expr_functions(PgfExpr expr, GuPool* pool); - -PGF_API_DECL PgfExpr -pgf_expr_substitute(PgfExpr expr, GuSeq* meta_values, GuPool* pool); - -PGF_API_DECL PgfType* -pgf_type_substitute(PgfType* type, GuSeq* meta_values, GuPool* pool); - -typedef struct PgfPrintContext PgfPrintContext; - -struct PgfPrintContext { - PgfCId name; - PgfPrintContext* next; -}; - -PGF_API_DECL void -pgf_print_cid(PgfCId id, GuOut* out, GuExn* err); - -PGF_API_DECL void -pgf_print_literal(PgfLiteral lit, GuOut* out, GuExn* err); - -PGF_API_DECL void -pgf_print_expr(PgfExpr expr, PgfPrintContext* ctxt, int prec, - GuOut* out, GuExn* err); - -PGF_API_DECL PgfPrintContext* -pgf_print_hypo(PgfHypo *hypo, PgfPrintContext* ctxt, int prec, - GuOut* out, GuExn *err); - -PGF_API_DECL void -pgf_print_type(PgfType *type, PgfPrintContext* ctxt, int prec, - GuOut* out, GuExn *err); - -PGF_API_DECL void -pgf_print_context(PgfHypos *hypos, PgfPrintContext* ctxt, - GuOut *out, GuExn *err); - -PGF_API PgfLiteral -pgf_clone_literal(PgfLiteral lit, GuPool* pool); - -PGF_API PgfExpr -pgf_clone_expr(PgfExpr expr, GuPool* pool); - -PGF_API PgfType* -pgf_clone_type(PgfType* type, GuPool* pool); - -PGF_API_DECL prob_t -pgf_compute_tree_probability(PgfPGF *gr, PgfExpr expr); - -#endif /* EXPR_H_ */ diff --git a/src/runtime/c/pgf/graphviz.c b/src/runtime/c/pgf/graphviz.c deleted file mode 100644 index f46b8dd3a..000000000 --- a/src/runtime/c/pgf/graphviz.c +++ /dev/null @@ -1,415 +0,0 @@ -#include "data.h" -#include "graphviz.h" -#include "linearizer.h" - -PgfGraphvizOptions pgf_default_graphviz_options[1] = - { {0, 0, 0, 1, NULL, NULL, NULL, NULL, NULL, NULL} } ; - -static int -pgf_graphviz_abstract_tree_(PgfPGF* pgf, PgfExpr expr, int *pid, - PgfGraphvizOptions* opts, - GuOut* out, GuExn* err) -{ - int id = -1; - - GuVariantInfo ei = gu_variant_open(expr); - switch (ei.tag) { - case PGF_EXPR_ABS: - gu_impossible(); - break; - case PGF_EXPR_APP: { - PgfExprApp* app = ei.data; - id = pgf_graphviz_abstract_tree_(pgf, app->fun, pid, opts, out, err); - int arg_id = pgf_graphviz_abstract_tree_(pgf, app->arg, pid, opts, out, err); - gu_printf(out, err, "n%d -- n%d", id, arg_id); - if (opts->nodeEdgeStyle != NULL && *opts->nodeEdgeStyle && opts->nodeColor != NULL && *opts->nodeColor) - gu_printf(out, err, " [style = \"%s\", color = \"%s\"]", opts->nodeEdgeStyle, opts->nodeColor); - else if (opts->nodeEdgeStyle != NULL && *opts->nodeEdgeStyle) - gu_printf(out, err, " [style = \"%s\"]", opts->nodeEdgeStyle); - else if (opts->nodeColor != NULL && *opts->nodeColor) - gu_printf(out, err, " [color = \"%s\"]", opts->nodeColor); - gu_printf(out, err, "\n", id, arg_id); - break; - } - case PGF_EXPR_LIT: { - PgfExprLit* lit = ei.data; - id = (*pid)++; - gu_printf(out, err, "n%d[label = \"", id); - - GuVariantInfo ei = gu_variant_open(lit->lit); - switch (ei.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lit = ei.data; - gu_puts("\\\"", out, err); - gu_string_write(lit->val, out, err); - gu_puts("\\\"", out, err); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lit = ei.data; - gu_printf(out, err, "%d", lit->val); - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lit = ei.data; - gu_printf(out, err, "%lf", lit->val); - break; - } - default: - gu_impossible(); - } - - gu_puts("\", style = \"solid\", shape = \"plaintext\"]\n", out, err); - break; - } - case PGF_EXPR_META: - id = (*pid)++; - gu_printf(out, err, "n%d[label = \"?\", style = \"solid\", shape = \"plaintext\"]\n", id); - break; - case PGF_EXPR_FUN: { - PgfExprFun* fun = ei.data; - id = (*pid)++; - if (opts->noFun && opts->noCat) { - gu_printf(out, err, "n%d[shape = \"point\"]\n", id); - } else { - gu_printf(out, err, "n%d[label = \"", id); - PgfType* ty = (opts->noCat) ? NULL : pgf_function_type(pgf, fun->fun); - if (!opts->noFun) - gu_string_write(fun->fun, out, err); - if (!opts->noFun && ty != NULL) - gu_puts(" : ", out,err); - if (ty != NULL) - gu_string_write(ty->cid, out, err); - gu_puts("\", shape = \"plaintext\", style = \"solid\"", out, err); - if (opts->nodeColor != NULL && *opts->nodeColor) - gu_printf(out, err, ", fontcolor = \"%s\"", opts->nodeColor); - if (opts->nodeFont != NULL && *opts->nodeFont) - gu_printf(out, err, ", fontname = \"%s\"", opts->nodeFont); - gu_puts("]\n", out, err); - } - break; - } - case PGF_EXPR_VAR: - gu_impossible(); - break; - case PGF_EXPR_TYPED: { - PgfExprTyped* typed = ei.data; - id = pgf_graphviz_abstract_tree_(pgf, typed->expr, pid, opts, out, err); - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* implarg = ei.data; - id = pgf_graphviz_abstract_tree_(pgf, implarg->expr, pid, opts, out, err); - break; - } - default: - gu_impossible(); - } - - return id; -} - -PGF_API void -pgf_graphviz_abstract_tree(PgfPGF* pgf, PgfExpr expr, PgfGraphvizOptions* opts, GuOut* out, GuExn* err) -{ - int id = 0; - - gu_puts("graph {\n", out, err); - pgf_graphviz_abstract_tree_(pgf, expr, &id, opts, out, err); - gu_puts("}", out, err); -} - -typedef struct PgfParseNode PgfParseNode; - -struct PgfParseNode { - int id; - PgfParseNode* parent; - GuString fun; - GuString label; -}; - -typedef struct { - PgfLinFuncs* funcs; - - GuPool* pool; - GuOut* out; - GuExn* err; - - PgfParseNode* parent; - size_t level; - GuBuf* internals; - GuBuf* leaves; -} PgfBracketLznState; - -static void -pgf_bracket_lzn_symbol_token(PgfLinFuncs** funcs, PgfToken tok) -{ - PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); - - PgfParseNode* node = gu_new(PgfParseNode, state->pool); - node->id = 100000 + gu_buf_length(state->leaves); - node->parent = state->parent; - node->fun = NULL; - node->label = tok; - gu_buf_push(state->leaves, PgfParseNode*, node); -} - -static void -pgf_bracket_lzn_begin_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); - - if (strcmp(cat, "_") == 0) - return; - - state->level++; - - GuBuf* level; - if (state->level < gu_buf_length(state->internals)) - level = gu_buf_get(state->internals, GuBuf*, state->level); - else { - level = gu_new_buf(PgfParseNode*, state->pool); - gu_buf_push(state->internals, GuBuf*, level); - } - - size_t len = gu_buf_length(level); - for (size_t i = 0; i < len; i++) { - PgfParseNode* node = gu_buf_get(level, PgfParseNode*, i); - if (node->id == fid) { - state->parent = node; - return; - } - } - - PgfParseNode* node = gu_new(PgfParseNode, state->pool); - node->id = fid; - node->parent = state->parent; - node->fun = fun; - node->label = cat; - gu_buf_push(level, PgfParseNode*, node); - - state->parent = node; -} - -static void -pgf_bracket_lzn_end_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); - - if (strcmp(cat, "_") == 0) - return; - - state->level--; - state->parent = state->parent->parent; -} - -static void -pgf_bracket_lzn_symbol_meta(PgfLinFuncs** funcs, PgfMetaId meta_id) -{ - PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs); - - PgfParseNode* node = gu_new(PgfParseNode, state->pool); - node->id = 100000 + gu_buf_length(state->leaves); - node->parent = state->parent; - node->fun = NULL; - node->label = "?"; - gu_buf_push(state->leaves, PgfParseNode*, node); -} - -static PgfLinFuncs pgf_bracket_lin_funcs = { - .symbol_token = pgf_bracket_lzn_symbol_token, - .begin_phrase = pgf_bracket_lzn_begin_phrase, - .end_phrase = pgf_bracket_lzn_end_phrase, - .symbol_ne = NULL, - .symbol_bind = NULL, - .symbol_capit = NULL, - .symbol_meta = pgf_bracket_lzn_symbol_meta -}; - -static void -pgf_graphviz_parse_level(GuBuf* level, PgfGraphvizOptions* opts, GuOut* out, GuExn* err) -{ - gu_puts("\n subgraph {rank=same;\n", out, err); - - size_t len = gu_buf_length(level); - - if (len > 1) - gu_puts(" edge[style=invis]\n", out, err); - - for (size_t i = 0; i < len; i++) { - PgfParseNode* node = gu_buf_get(level, PgfParseNode*, i); - if (node->fun != NULL) { - gu_printf(out, err, " n%d[label=\"", node->id); - if (!opts->noFun) - gu_string_write(node->fun, out, err); - if (!opts->noFun && !opts->noCat) - gu_puts(" : ", out, err); - if (!opts->noCat) - gu_string_write(node->label, out, err); - gu_puts("\"", out, err); - if (opts->nodeColor != NULL && *opts->nodeColor) - gu_printf(out, err, ", fontcolor = \"%s\"", opts->nodeColor); - if (opts->nodeFont != NULL && *opts->nodeFont) - gu_printf(out, err, ", fontname = \"%s\"", opts->nodeFont); - gu_puts("]\n", out, err); - } else { - if (opts->noLeaves) - gu_printf(out, err, " n%d[label=\"\"]\n", node->id); - else { - gu_printf(out, err, " n%d[label=\"%s\"", node->id, node->label); - if (opts->leafColor != NULL && *opts->leafColor) - gu_printf(out, err, ", fontcolor = \"%s\"", opts->leafColor); - if (opts->leafFont != NULL && *opts->leafFont) - gu_printf(out, err, ", fontname = \"%s\"", opts->leafFont); - gu_puts("]\n", out, err); - } - } - } - - if (len > 1) { - for (size_t i = 0; i < len; i++) { - PgfParseNode* node = gu_buf_get(level, PgfParseNode*, i); - - gu_puts((i == 0) ? " " : " -- ", out, err); - gu_printf(out, err, "n%d", node->id); - } - gu_puts("\n", out, err); - } - - gu_puts(" }\n", out, err); - - for (size_t i = 0; i < len; i++) { - PgfParseNode* node = gu_buf_get(level, PgfParseNode*, i); - if (node->parent != NULL) { - gu_printf(out, err, " n%d -- n%d", node->parent->id, node->id); - - GuString edgeStyle, color; - if (node->fun == NULL) { - edgeStyle = opts->leafEdgeStyle; - color = opts->leafColor; - } else { - edgeStyle = opts->nodeEdgeStyle; - color = opts->nodeColor; - } - - if (edgeStyle != NULL && *edgeStyle && color != NULL && *color) - gu_printf(out, err, " [style = \"%s\", color = \"%s\"]", edgeStyle, color); - else if (edgeStyle != NULL && *edgeStyle) - gu_printf(out, err, " [style = \"%s\"]", edgeStyle); - else if (color != NULL && *color) - gu_printf(out, err, " [color = \"%s\"]", color); - - gu_putc('\n', out, err); - } - } -} - -PGF_API void -pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, PgfGraphvizOptions* opts, GuOut* out, GuExn* err) -{ - GuPool* tmp_pool = gu_local_pool(); - - GuEnum* cts = - pgf_lzr_concretize(concr, expr, err, tmp_pool); - if (!gu_ok(err)) { - gu_pool_free(tmp_pool); - return; - } - - PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool); - if (gu_variant_is_null(ctree)) { - gu_pool_free(tmp_pool); - return; - } - - gu_puts("graph {\n", out, err); - gu_puts(" node[shape=plaintext]\n", out, err); - - PgfBracketLznState state; - state.funcs = &pgf_bracket_lin_funcs; - state.pool = tmp_pool; - state.out = out; - state.err = err; - - state.parent = NULL; - state.level = -1; - state.internals = gu_new_buf(GuBuf*, tmp_pool); - state.leaves = gu_new_buf(PgfParseNode*, tmp_pool); - pgf_lzr_linearize(concr, ctree, 0, &state.funcs, tmp_pool); - - size_t len = gu_buf_length(state.internals); - for (size_t i = 0; i < len; i++) { - GuBuf* level = gu_buf_get(state.internals, GuBuf*, i); - pgf_graphviz_parse_level(level, opts, out, err); - } - pgf_graphviz_parse_level(state.leaves, opts, out, err); - - gu_puts("}", out, err); - - gu_pool_free(tmp_pool); -} - - -PGF_API_DECL void -pgf_graphviz_word_alignment(PgfConcr** concrs, size_t n_concrs, PgfExpr expr, PgfGraphvizOptions* opts, GuOut* out, GuExn* err) -{ - GuPool* tmp_pool = gu_local_pool(); - - gu_puts("digraph {\n", out, err); - gu_puts("rankdir=LR ;\n", out, err); - gu_puts("node [shape = record", out, err); - if (opts->leafFont != NULL && *opts->leafFont) - gu_printf(out, err, ", fontname = \"%s\"", opts->leafFont); - if (opts->leafColor != NULL && *opts->leafColor) - gu_printf(out, err, ", fontcolor = \"%s\"", opts->leafColor); - gu_puts("] ;\n\n", out, err); - if (opts->leafEdgeStyle != NULL && *opts->leafEdgeStyle) - gu_printf(out, err, "edge [style = %s];\n", opts->leafEdgeStyle); - gu_puts("\n", out, err); - - GuSeq* alignment = NULL; - GuSeq* last_alignment = NULL; - for (size_t i = 0; i < n_concrs; i++) { - alignment = pgf_align_words(concrs[i], expr, err, tmp_pool); - gu_printf(out, err, " struct%d[label=\"", i); - - size_t n_tokens = gu_seq_length(alignment); - for (size_t j = 0; j < n_tokens; j++) { - PgfAlignmentPhrase* phrase = gu_seq_get(alignment, PgfAlignmentPhrase*, j); - if (j > 0) - gu_puts(" | ", out, err); - gu_printf(out, err, " %s", j, phrase->phrase); - } - - gu_puts("\"] ;\n", out, err); - - if (last_alignment != NULL) { - size_t n_last_tokens = gu_seq_length(last_alignment); - - for (size_t j = 0; j < n_tokens; j++) { - PgfAlignmentPhrase* phrase = gu_seq_get(alignment, PgfAlignmentPhrase*, j); - - for (size_t k = 0; k < phrase->n_fids; k++) { - int fid = phrase->fids[k]; - - for (size_t l = 0; l < n_last_tokens; l++) { - PgfAlignmentPhrase* last_phrase = gu_seq_get(last_alignment, PgfAlignmentPhrase*, l); - - for (size_t r = 0; r < last_phrase->n_fids; r++) { - int last_fid = last_phrase->fids[r]; - if (fid == last_fid) { - gu_printf(out, err, "struct%d:n%d:e -> struct%d:n%d:w ;\n",i,j,i-1,l); - } - } - } - } - } - } - - last_alignment = alignment; - } - - gu_puts("}", out, err); - - gu_pool_free(tmp_pool); -} diff --git a/src/runtime/c/pgf/graphviz.h b/src/runtime/c/pgf/graphviz.h deleted file mode 100644 index 483e86f1e..000000000 --- a/src/runtime/c/pgf/graphviz.h +++ /dev/null @@ -1,28 +0,0 @@ -#ifndef PGF_GRAPHVIZ_H_ -#define PGF_GRAPHVIZ_H_ - -typedef struct { - int noLeaves; - int noFun; - int noCat; - int noDep; - GuString nodeFont; - GuString leafFont; - GuString nodeColor; - GuString leafColor; - GuString nodeEdgeStyle; - GuString leafEdgeStyle; -} PgfGraphvizOptions; - -extern PgfGraphvizOptions pgf_default_graphviz_options[1]; - -PGF_API_DECL void -pgf_graphviz_abstract_tree(PgfPGF* pgf, PgfExpr expr, PgfGraphvizOptions* opts, GuOut* out, GuExn* err); - -PGF_API_DECL void -pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, PgfGraphvizOptions* opts, GuOut* out, GuExn* err); - -PGF_API_DECL void -pgf_graphviz_word_alignment(PgfConcr** concrs, size_t n_concrs, PgfExpr expr, PgfGraphvizOptions* opts, GuOut* out, GuExn* err); - -#endif diff --git a/src/runtime/c/pgf/hopu.c b/src/runtime/c/pgf/hopu.c deleted file mode 100644 index 39aae6db4..000000000 --- a/src/runtime/c/pgf/hopu.c +++ /dev/null @@ -1,11 +0,0 @@ -#include "data.h" -#include "reasoner.h" -#include "hopu.h" - -PGF_INTERNAL void -pgf_pattern_unify(PgfReasoner* rs, PgfClosure* c1, PgfClosure* c2) -{ - c1 = rs->eval_gates->enter(rs, c1); - c2 = rs->eval_gates->enter(rs, c2); -} - diff --git a/src/runtime/c/pgf/hopu.h b/src/runtime/c/pgf/hopu.h deleted file mode 100644 index 367d9d5e2..000000000 --- a/src/runtime/c/pgf/hopu.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef HOPU_H -#define HOPU_H - -PGF_INTERNAL_DECL void -pgf_pattern_unify(PgfReasoner* rs, PgfClosure* c1, PgfClosure* c2); - -#endif - diff --git a/src/runtime/c/pgf/jit.c b/src/runtime/c/pgf/jit.c deleted file mode 100644 index 6c8679523..000000000 --- a/src/runtime/c/pgf/jit.c +++ /dev/null @@ -1,1331 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include "lightning.h" - -//#define PGF_JIT_DEBUG - - -struct PgfJitState { - jit_state jit; - jit_insn *buf; - char *save_ip_ptr; - GuBuf* call_patches; - GuBuf* segment_patches; - size_t n_cafs; -}; - -#define _jit (rdr->jit_state->jit) - -typedef struct { - PgfCId cid; - jit_insn *ref; -} PgfCallPatch; - -typedef struct { - size_t segment; - jit_insn *ref; - bool is_abs; -} PgfSegmentPatch; - -// Between two calls to pgf_jit_make_space we are not allowed -// to emit more that JIT_CODE_WINDOW bytes. This is not quite -// safe but this is how GNU lightning is designed. -#define JIT_CODE_WINDOW 128 - -#define JIT_VHEAP JIT_V0 -#define JIT_VSTATE JIT_V1 -#define JIT_VCLOS JIT_V2 - - -static void -pgf_jit_finalize_page(GuFinalizer* self) -{ - free(self); -} - -static void -pgf_jit_alloc_page(PgfReader* rdr) -{ - size_t page_size; - void *page = gu_mem_page_alloc(sizeof(GuFinalizer), &page_size); - - GuFinalizer* fin = page; - fin->fn = pgf_jit_finalize_page; - gu_pool_finally(rdr->opool, fin); - - rdr->jit_state->buf = page; - jit_set_ip(rdr->jit_state->buf+sizeof(GuFinalizer)); -} - -PGF_INTERNAL PgfJitState* -pgf_new_jit(PgfReader* rdr) -{ - PgfJitState* state = gu_new(PgfJitState, rdr->tmp_pool); - memset(&state->jit, 0, sizeof(state->jit)); - state->call_patches = gu_new_buf(PgfCallPatch, rdr->tmp_pool); - state->segment_patches = gu_new_buf(PgfSegmentPatch, rdr->tmp_pool); - state->buf = NULL; - state->save_ip_ptr = NULL; - state->n_cafs = 0; - return state; -} - -static void -pgf_jit_make_space(PgfReader* rdr, size_t space) -{ - size_t page_size = getpagesize(); - if (rdr->jit_state->buf == NULL) { - pgf_jit_alloc_page(rdr); - } else { - assert (jit_get_ip().ptr < rdr->jit_state->save_ip_ptr); - - if (jit_get_ip().ptr + space > ((char*) rdr->jit_state->buf) + page_size) { - jit_flush_code(rdr->jit_state->buf, jit_get_ip().ptr); - pgf_jit_alloc_page(rdr); - } - } - - rdr->jit_state->save_ip_ptr = jit_get_ip().ptr + space; -} - -static PgfAbsFun* -pgf_jit_read_absfun(PgfReader* rdr, PgfAbstr* abstr) -{ - gu_in_f64be(rdr->in, rdr->err); // ignore - gu_return_on_exn(rdr->err, NULL); - - PgfCId name = pgf_read_cid(rdr, rdr->tmp_pool); - gu_return_on_exn(rdr->err, NULL); - - PgfAbsFun* absfun = - gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, name); - assert(absfun != NULL); - - return absfun; -} - -PGF_INTERNAL void -pgf_jit_predicate(PgfReader* rdr, PgfAbstr* abstr, - PgfAbsCat* abscat) -{ -#ifdef PGF_JIT_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - - gu_string_write(abscat->name, out, err); - gu_puts(":\n", out, err); -#endif - - size_t n_funs = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - abscat->predicate = (PgfFunction) jit_get_ip().ptr; - - if (strcmp(abscat->name, "String") == 0) { -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, " MK_STRING\n"); -#endif - - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_mk_string); - -#ifdef PGF_JIT_DEBUG - gu_puts(" RET\n", out, err); -#endif - // compile RET - jit_bare_ret(); - - return; - } - - if (strcmp(abscat->name, "Int") == 0) { -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, " MK_INT\n"); -#endif - - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_mk_int); - -#ifdef PGF_JIT_DEBUG - gu_puts(" RET\n", out, err); -#endif - // compile RET - jit_bare_ret(); - - return; - } - - if (strcmp(abscat->name, "Float") == 0) { -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, " MK_FLOAT\n"); -#endif - - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_mk_float); - -#ifdef PGF_JIT_DEBUG - gu_puts(" RET\n", out, err); -#endif - // compile RET - jit_bare_ret(); - - return; - } - - PgfAbsFun* absfun = NULL; - PgfAbsFun* next_absfun = NULL; - - if (n_funs > 0) { - next_absfun = pgf_jit_read_absfun(rdr, abstr); - -#ifdef PGF_JIT_DEBUG - gu_puts(" TRY_FIRST ", out, err); - gu_string_write(next_absfun->name, out, err); - gu_puts("\n", out, err); -#endif - - // compile TRY_FIRST - jit_prepare(3); - jit_movi_p(JIT_R0,next_absfun); - jit_pusharg_p(JIT_R0); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_try_first); - jit_bare_ret(); - } else { -#ifdef PGF_JIT_DEBUG - gu_puts(" RET\n", out, err); -#endif - // compile RET - jit_bare_ret(); - } - -#ifdef PGF_JIT_DEBUG - if (n_funs > 0) { - gu_string_write(next_absfun->name, out, err); - gu_puts(":\n", out, err); - } -#endif - - for (size_t i = 0; i < n_funs; i++) { - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - absfun = next_absfun; - absfun->predicate = (PgfFunction) jit_get_ip().ptr; - - size_t n_hypos = gu_seq_length(absfun->type->hypos); - - if (n_hypos > 0) { - if (i+1 < n_funs) { - next_absfun = pgf_jit_read_absfun(rdr, abstr); // i+1 - -#ifdef PGF_JIT_DEBUG - gu_puts(" TRY_ELSE ", out, err); - gu_string_write(next_absfun->name, out, err); - gu_puts("\n", out, err); -#endif - - // compile TRY_ELSE - jit_prepare(3); - jit_movi_p(JIT_R0, next_absfun); - jit_pusharg_p(JIT_R0); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_try_else); - } - - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(absfun->type->hypos, PgfHypo, i); - - jit_insn *ref; - - // call the predicate for the category in hypo->type->cid -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, - (i+1 < n_hypos) ? " CALL %s\n" - : " CALL %s tail(0)\n", - hypo->type->cid); -#endif - - // compile CALL - ref = jit_movi_p(JIT_R0, jit_forward()); - jit_str_p(JIT_VCLOS, JIT_R0); - - PgfCallPatch patch; - patch.cid = hypo->type->cid; - patch.ref = jit_jmpi(jit_forward()); - gu_buf_push(rdr->jit_state->call_patches, PgfCallPatch, patch); - - if (i+1 < n_hypos) { - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - jit_patch_movi(ref,jit_get_label()); - } else { - jit_patch_movi(ref,abstr->eval_gates->complete); - } - } - } else { - if (i+1 < n_funs) { - next_absfun = pgf_jit_read_absfun(rdr, abstr); // i+1 - -#ifdef PGF_JIT_DEBUG - gu_puts(" TRY_CONSTANT ", out, err); - gu_string_write(next_absfun->name, out, err); - gu_puts("\n", out, err); -#endif - - // compile TRY_CONSTANT - jit_prepare(3); - jit_movi_p(JIT_R0, next_absfun); - jit_pusharg_p(JIT_R0); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_try_constant); - } else { -#ifdef PGF_JIT_DEBUG - gu_puts(" COMPLETE\n", out, err); -#endif - - // compile COMPLETE - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_complete); - } - -#ifdef PGF_JIT_DEBUG - gu_puts(" RET\n", out, err); -#endif - - // compile RET - jit_ret(); - } - -#ifdef PGF_JIT_DEBUG - if (i+1 < n_funs) { - gu_string_write(next_absfun->name, out, err); - gu_puts(":\n", out, err); - } -#endif - } - -#ifdef PGF_JIT_DEBUG - gu_pool_free(tmp_pool); -#endif -} - -static void -pgf_jit_finalize_cafs(GuFinalizer* self) -{ - PgfEvalGates* gates = gu_container(self, PgfEvalGates, fin); - if (gates->cafs != NULL) - gu_seq_free(gates->cafs); -} - -PGF_INTERNAL PgfEvalGates* -pgf_jit_gates(PgfReader* rdr) -{ - PgfEvalGates* gates = gu_new(PgfEvalGates, rdr->opool); - jit_insn *ref, *next, *ref2; - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_indirection = jit_get_ip().ptr; - jit_ldxi_p(JIT_VCLOS, JIT_VCLOS, offsetof(PgfIndirection,val)); - jit_ldr_p(JIT_R0, JIT_VCLOS); - jit_jmpr(JIT_R0); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_value = jit_get_ip().ptr; - jit_movr_p(JIT_VHEAP, JIT_VCLOS); - jit_ldxi_p(JIT_RET, JIT_VHEAP, offsetof(PgfValue, con)); - jit_bare_ret(); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_value_lit = jit_get_ip().ptr; - jit_movr_p(JIT_VHEAP, JIT_VCLOS); - jit_prepare(1); - jit_ldxi_p(JIT_R0, JIT_VHEAP, offsetof(PgfValueLit, lit)); - jit_pusharg_p(JIT_R0); - jit_finish(gu_variant_data); - jit_bare_ret(); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_caf = jit_get_ip().ptr; - jit_ldxi_i(JIT_R0, JIT_VCLOS, offsetof(PgfAbsFun, closure.caf_offset) - offsetof(PgfAbsFun, closure)); - jit_addr_p(JIT_VCLOS, JIT_VSTATE, JIT_R0); - jit_ldr_p(JIT_R0, JIT_VCLOS); - jit_jmpr(JIT_R0); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->enter = (void*) jit_get_ip().ptr; - jit_prolog(2); - int rs_arg = jit_arg_p(); - int closure_arg = jit_arg_p(); - jit_getarg_p(JIT_VSTATE, rs_arg); - jit_getarg_p(JIT_VCLOS, closure_arg); - jit_stxi_p(offsetof(PgfReasoner, enter_stack_ptr), JIT_VSTATE, JIT_SP); - jit_ldr_p(JIT_R0, JIT_VCLOS); - jit_pushr_i(JIT_R0); // this is just for stack alignment on System V - jit_callr(JIT_R0); - jit_popr_i(JIT_R0); // this is just for stack alignment on System V - jit_movr_p(JIT_RET, JIT_VHEAP); - jit_ret(); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_value_pap = jit_get_ip().ptr; - jit_popr_p(JIT_VHEAP); - jit_addi_p(JIT_R1, JIT_VCLOS, offsetof(PgfValuePAP,args)); - jit_ldxi_p(JIT_R2, JIT_VCLOS, offsetof(PgfValuePAP,n_args)); - jit_addr_p(JIT_R2, JIT_R2, JIT_R1); - next = jit_get_label(); - ref = jit_bger_i(jit_forward(), JIT_R1, JIT_R2); - jit_ldr_p(JIT_R0, JIT_R1); - jit_pushr_p(JIT_R0); - jit_addi_p(JIT_R1, JIT_R1, sizeof(PgfClosure*)); - jit_jmpi(next); - jit_patch(ref); - jit_pushr_p(JIT_VHEAP); - jit_ldxi_p(JIT_VCLOS, JIT_VCLOS, offsetof(PgfValuePAP,fun)); - jit_ldr_p(JIT_R0, JIT_VCLOS); - jit_jmpr(JIT_R0); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->update_closure = jit_get_ip().ptr; - jit_popr_p(JIT_FP); - jit_popr_p(JIT_VCLOS); - jit_movi_p(JIT_R1, gates->evaluate_indirection); - jit_str_p(JIT_VCLOS, JIT_R1); - jit_stxi_p(offsetof(PgfIndirection, val), JIT_VCLOS, JIT_VHEAP); - jit_bare_ret(); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW*4); - - gates->update_pap = jit_get_ip().ptr; - jit_subi_p(JIT_R0, JIT_R0, sizeof(void*)); - jit_pushr_i(JIT_R0); - jit_prepare(2); - jit_addi_i(JIT_R0, JIT_R0, sizeof(PgfValuePAP)); - jit_pusharg_ui(JIT_R0); - jit_ldxi_p(JIT_R0, JIT_VSTATE, offsetof(PgfReasoner,pool)); - jit_pusharg_p(JIT_R0); - jit_finish(gu_malloc); - jit_popr_i(JIT_R1); - jit_movi_p(JIT_R2, gates->evaluate_value_pap); - jit_str_p(JIT_RET, JIT_R2); - jit_stxi_p(offsetof(PgfValuePAP,fun), JIT_RET, JIT_VCLOS); - jit_stxi_p(offsetof(PgfValuePAP,n_args), JIT_RET, JIT_R1); - jit_ldr_p(JIT_R2, JIT_SP); - ref2 = jit_bnei_p(jit_forward(), JIT_R2, gates->update_closure); - jit_ldxi_p(JIT_VHEAP, JIT_FP, sizeof(void*)); - jit_movi_p(JIT_R2, gates->evaluate_indirection); - jit_str_p(JIT_VHEAP, JIT_R2); - jit_stxi_p(offsetof(PgfIndirection, val), JIT_VHEAP, JIT_RET); - jit_ldr_p(JIT_R2, JIT_FP); - jit_pushr_p(JIT_R2); - jit_ldxi_p(JIT_R2, JIT_FP, 2*sizeof(void*)); - jit_pushr_p(JIT_R2); - next = jit_get_label(); - ref = jit_blei_i(jit_forward(), JIT_R1, 0); - jit_ldxi_p(JIT_R2, JIT_FP, -sizeof(void*)); - jit_stxi_p(2*sizeof(void*), JIT_FP, JIT_R2); - jit_stxi_p(offsetof(PgfValuePAP,args), JIT_RET, JIT_R2); - jit_addi_i(JIT_RET, JIT_RET, sizeof(void*)); - jit_subi_i(JIT_FP, JIT_FP, sizeof(void*)); - jit_subi_i(JIT_R1, JIT_R1, sizeof(void*)); - jit_jmpi(next); - jit_patch(ref); - jit_popr_p(JIT_R0); - jit_popr_p(JIT_FP); - jit_addi_p(JIT_SP, JIT_SP, 4*sizeof(void*)); - jit_pushr_p(JIT_R0); - jit_ldr_p(JIT_R0, JIT_VCLOS); - jit_jmpr(JIT_R0); - jit_patch(ref2); - jit_movr_p(JIT_VHEAP, JIT_RET); - jit_pushr_p(JIT_R1); - next = jit_get_label(); - ref = jit_blei_i(jit_forward(), JIT_R1, 0); - jit_ldxi_p(JIT_R2, JIT_FP, -sizeof(void*)); - jit_stxi_p(offsetof(PgfValuePAP,args), JIT_RET, JIT_R2); - jit_addi_i(JIT_RET, JIT_RET, sizeof(void*)); - jit_subi_i(JIT_FP, JIT_FP, sizeof(void*)); - jit_subi_i(JIT_R1, JIT_R1, sizeof(void*)); - jit_jmpi(next); - jit_patch(ref); - jit_popr_p(JIT_R1); - jit_popr_p(JIT_R0); - jit_addr_p(JIT_SP, JIT_SP, JIT_R1); - jit_jmpr(JIT_R0); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_expr_thunk = jit_get_ip().ptr; - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_evaluate_expr_thunk); - ref = jit_beqr_p(jit_forward(), JIT_VCLOS, JIT_RET); - jit_pushr_p(JIT_VCLOS); - jit_pushr_p(JIT_FP); - jit_movr_p(JIT_FP, JIT_SP); - jit_movi_p(JIT_R1, gates->update_closure); - jit_pushr_p(JIT_R1); - jit_retval_p(JIT_VCLOS); - jit_patch(ref); - jit_ldr_p(JIT_R0, JIT_VCLOS); - jit_jmpr(JIT_R0); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_value_lambda = jit_get_ip().ptr; - jit_subr_p(JIT_R0, JIT_FP, JIT_SP); - jit_blti_i(gates->update_pap, JIT_R0, 2*sizeof(PgfClosure*)); - jit_popr_p(JIT_R2); - jit_popr_p(JIT_R1); - jit_pushr_p(JIT_R2); - jit_prepare(3); - jit_pusharg_p(JIT_R1); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_evaluate_lambda_application); - jit_retval(JIT_VCLOS); - jit_ldr_p(JIT_R0, JIT_VCLOS); - jit_jmpr(JIT_R0); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW*2); - - gates->evaluate_value_const = jit_get_ip().ptr; - jit_jmpi(gates->evaluate_value); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW*4); - - gates->mk_const = jit_get_ip().ptr; - jit_popr_p(JIT_R0); - ref2 = jit_bnei_p(jit_forward(), JIT_R0, gates->update_closure); - jit_subr_p(JIT_R0, JIT_FP, JIT_SP); - jit_pushr_i(JIT_R0); - jit_prepare(2); - jit_addi_i(JIT_R0, JIT_R0, sizeof(PgfValuePAP)); - jit_pusharg_ui(JIT_R0); - jit_ldxi_p(JIT_R0, JIT_VSTATE, offsetof(PgfReasoner,pool)); - jit_pusharg_p(JIT_R0); - jit_finish(gu_malloc); - jit_popr_i(JIT_R1); - jit_movi_p(JIT_R2, gates->evaluate_value_const); - jit_str_p(JIT_RET, JIT_R2); - jit_stxi_p(offsetof(PgfValuePAP,fun), JIT_RET, JIT_VCLOS); - jit_stxi_p(offsetof(PgfValuePAP,n_args), JIT_RET, JIT_R1); - jit_ldxi_p(JIT_VHEAP, JIT_FP, sizeof(void*)); - jit_movi_p(JIT_R2, gates->evaluate_indirection); - jit_str_p(JIT_VHEAP, JIT_R2); - jit_stxi_p(offsetof(PgfIndirection, val), JIT_VHEAP, JIT_RET); - jit_ldr_p(JIT_R2, JIT_FP); - jit_pushr_p(JIT_R2); - jit_ldxi_p(JIT_R2, JIT_FP, 2*sizeof(void*)); - jit_pushr_p(JIT_R2); - jit_addi_p(JIT_RET, JIT_RET, offsetof(PgfValuePAP,args)-sizeof(PgfClosure*)); - next = jit_get_label(); - ref = jit_blei_i(jit_forward(), JIT_R1, 0); - jit_ldxi_p(JIT_R2, JIT_FP, -sizeof(void*)); - jit_stxi_p(2*sizeof(void*), JIT_FP, JIT_R2); - jit_stxr_p(JIT_R1, JIT_RET, JIT_R2); - jit_subi_i(JIT_FP, JIT_FP, sizeof(void*)); - jit_subi_i(JIT_R1, JIT_R1, sizeof(void*)); - jit_jmpi(next); - jit_patch(ref); - jit_popr_p(JIT_R0); - jit_popr_p(JIT_FP); - jit_addi_p(JIT_SP, JIT_SP, 3*sizeof(void*)); - jit_pushr_p(JIT_R0); - jit_jmpi(gates->mk_const); - jit_patch(ref2); - jit_ldxi_p(JIT_R1, JIT_VSTATE, offsetof(PgfReasoner,enter_stack_ptr)); - ref2 = jit_bner_p(jit_forward(), JIT_FP, JIT_R1); - jit_stxi_p(offsetof(PgfReasoner,tmp), JIT_VSTATE, JIT_R0); - jit_subr_p(JIT_R0, JIT_FP, JIT_SP); - jit_pushr_i(JIT_R0); - jit_prepare(2); - jit_addi_i(JIT_R0, JIT_R0, sizeof(PgfValuePAP)); - jit_pusharg_ui(JIT_R0); - jit_ldxi_p(JIT_R0, JIT_VSTATE, offsetof(PgfReasoner,pool)); - jit_pusharg_p(JIT_R0); - jit_finish(gu_malloc); - jit_movr_p(JIT_VHEAP, JIT_RET); - jit_popr_i(JIT_R1); - jit_movi_p(JIT_R2, gates->evaluate_value_const); - jit_str_p(JIT_VHEAP, JIT_R2); - jit_stxi_p(offsetof(PgfValuePAP,fun), JIT_VHEAP, JIT_VCLOS); - jit_stxi_p(offsetof(PgfValuePAP,n_args), JIT_VHEAP, JIT_R1); - next = jit_get_label(); - ref = jit_blei_i(jit_forward(), JIT_R1, 0); - jit_popr_p(JIT_R2); - jit_stxi_p(offsetof(PgfValuePAP,args), JIT_RET, JIT_R2); - jit_addi_p(JIT_RET, JIT_RET, sizeof(void*)); - jit_subi_i(JIT_R1, JIT_R1, sizeof(void*)); - jit_jmpi(next); - jit_patch(ref); - jit_ldxi_p(JIT_R0, JIT_VSTATE, offsetof(PgfReasoner,tmp)); - jit_jmpr(JIT_R0); - jit_patch(ref2); - jit_ldxi_p(JIT_VCLOS, JIT_FP, sizeof(void*)); - jit_ldr_p(JIT_FP, JIT_FP); - jit_ldxi_i(JIT_R0, JIT_VCLOS, offsetof(PgfAbsFun,arity)-offsetof(PgfAbsFun,closure)); - jit_muli_i(JIT_R0, JIT_R0, sizeof(PgfClosure*)); - jit_addi_i(JIT_R0, JIT_R0, sizeof(void*)); - jit_subr_p(JIT_R0, JIT_FP, JIT_R0); // don't use jit_subr_p(JIT_SP, JIT_FP, JIT_R0) since it is dangerous on x86 - jit_movr_p(JIT_SP, JIT_R0); - jit_jmpi(gates->mk_const); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_gen = jit_get_ip().ptr; - jit_jmpi(gates->mk_const); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_meta = jit_get_ip().ptr; - jit_jmpi(gates->mk_const); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->evaluate_sum = jit_get_ip().ptr; - jit_jmpi(gates->mk_const); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->combine1 = (void*) jit_get_ip().ptr; - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_combine1); - jit_bare_ret(); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->combine2 = (void*) jit_get_ip().ptr; - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_combine2); - jit_bare_ret(); - - pgf_jit_make_space(rdr, JIT_CODE_WINDOW); - - gates->complete = (void*) jit_get_ip().ptr; - jit_prepare(2); - jit_pusharg_p(JIT_VCLOS); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_reasoner_complete); - jit_ret(); - - gates->fin.fn = pgf_jit_finalize_cafs; - gates->cafs = NULL; - gu_pool_finally(rdr->opool, &gates->fin); - - return gates; -} - -#define PGF_CAFS_DELTA 20 - -PGF_INTERNAL void -pgf_jit_function(PgfReader* rdr, PgfAbstr* abstr, - PgfAbsFun* absfun) -{ -#ifdef PGF_JIT_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - - gu_string_write(absfun->name, out, err); - gu_puts(":\n", out, err); -#endif - - size_t n_segments = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - gu_buf_flush(rdr->jit_state->segment_patches); - - absfun->closure.code = abstr->eval_gates->mk_const; - - for (size_t segment = 0; segment < n_segments; segment++) { - size_t n_instrs = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - pgf_jit_make_space(rdr, (JIT_CODE_WINDOW/4)*n_instrs); - - if (segment == 0) { - if (absfun->arity == 0) { - // we add a new CAF - if (rdr->jit_state->n_cafs % PGF_CAFS_DELTA == 0) { - abstr->eval_gates->cafs = - gu_realloc_seq(abstr->eval_gates->cafs, - PgfFunction, - rdr->jit_state->n_cafs + PGF_CAFS_DELTA); - } - absfun->closure.code = abstr->eval_gates->evaluate_caf; - size_t caf_id = rdr->jit_state->n_cafs++; - absfun->closure.caf_offset = - offsetof(PgfReasoner,cafs)+ - caf_id*sizeof(PgfIndirection); - gu_seq_set(abstr->eval_gates->cafs, - PgfFunction, - caf_id, - jit_get_ip().ptr); - } else { - absfun->closure.code = jit_get_ip().ptr; - } - } - - size_t curr_offset = 0; - - size_t n_patches = gu_buf_length(rdr->jit_state->segment_patches); - for (size_t i = 0; i < n_patches; i++) { - PgfSegmentPatch* patch = - gu_buf_index(rdr->jit_state->segment_patches, PgfSegmentPatch, i); - if (patch->segment == segment) { - if (patch->is_abs) { - jit_patch_movi(patch->ref,jit_get_ip().ptr); - } else { - jit_patch(patch->ref); - } - } - } - -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "%03d ", segment); -#endif - - for (size_t label = 0; label < n_instrs; label++) { -#ifdef PGF_JIT_DEBUG - if (label > 0) - gu_printf(out, err, " "); -#endif - - uint8_t tag = pgf_read_tag(rdr); - uint8_t opcode = tag >> 2; - uint8_t mod = tag & 0x03; - switch (opcode) { - case PGF_INSTR_CHECK_ARGS: { - int n = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "CHECK_ARGS %d\n", n); -#endif - jit_subr_p(JIT_R0, JIT_FP, JIT_SP); - jit_blti_i(abstr->eval_gates->update_pap, JIT_R0, (n+1)*sizeof(PgfClosure*)); - break; - } - case PGF_INSTR_CASE: { - PgfCId id = pgf_read_cid(rdr, rdr->tmp_pool); - int target = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "CASE %s %03d\n", id, target); -#endif - jit_insn *ref1 = - jit_movi_p(JIT_R1, jit_forward()); - PgfCallPatch call_patch; - call_patch.cid = id; - call_patch.ref = ref1; - gu_buf_push(rdr->jit_state->call_patches, PgfCallPatch, call_patch); - - jit_insn *ref2 = - jit_bner_p(jit_forward(), JIT_RET, JIT_R1); - PgfSegmentPatch label_patch; - label_patch.segment = target; - label_patch.ref = ref2; - label_patch.is_abs = false; - gu_buf_push(rdr->jit_state->segment_patches, PgfSegmentPatch, label_patch); - break; - } - case PGF_INSTR_CASE_LIT: { - int target = 0; - jit_insn *jump = 0; - - switch (mod) { - case 0: { - int n = pgf_read_int(rdr); - target = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "CASE_LIT %d %03d\n", n, target); -#endif - jit_ldxi_p(JIT_R1, JIT_RET, offsetof(PgfLiteralInt,val)); - jump = - jit_bnei_i(jit_forward(), JIT_R1, n); - break; - } - case 1: { - GuString s = pgf_read_string(rdr); - target = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "CASE_LIT %s %03d\n", s, target); -#endif - jit_pushr_p(JIT_RET); - jit_prepare(2); - jit_pusharg_p(JIT_RET); - jit_movi_p(JIT_R0, s); - jit_pusharg_p(JIT_R0); - jit_finish(strcmp); - jit_retval(JIT_R1); - jit_popr_p(JIT_RET); - jump = - jit_bnei_i(jit_forward(), JIT_R1, 0); - break; - } - case 2: { - double d = pgf_read_double(rdr); - target = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "CASE_LIT %f %03d\n", d, target); -#endif - jit_ldxi_d(JIT_FPR0, JIT_RET, offsetof(PgfLiteralFlt,val)); - jit_movi_d(JIT_FPR1, d); - jump = - jit_bner_d(jit_forward(), JIT_FPR0, JIT_FPR1); - break; - } - default: - gu_impossible(); - } - - PgfSegmentPatch label_patch; - label_patch.segment = target; - label_patch.ref = jump; - label_patch.is_abs = false; - gu_buf_push(rdr->jit_state->segment_patches, PgfSegmentPatch, label_patch); - - break; - } - case PGF_INSTR_SAVE: { - int i = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "SAVE %d\n", i); -#endif - jit_ldxi_p(JIT_R0, JIT_VHEAP, sizeof(PgfValue)+sizeof(PgfClosure*)*i); - jit_pushr_p(JIT_R0); - break; - } - case PGF_INSTR_ALLOC: { - size_t size = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "ALLOC %d\n", size); -#endif - jit_prepare(2); - jit_movi_ui(JIT_R0, size*sizeof(void*)); - jit_pusharg_ui(JIT_R0); - jit_ldxi_p(JIT_R0, JIT_VSTATE, offsetof(PgfReasoner,pool)); - jit_pusharg_p(JIT_R0); - jit_finish(gu_malloc); - jit_retval_p(JIT_VHEAP); - - curr_offset = 0; - break; - } - case PGF_INSTR_PUT_CONSTR: { - PgfCId id = pgf_read_cid(rdr, rdr->tmp_pool); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUT_CONSTR %s\n", id); -#endif - - jit_movi_p(JIT_R0, abstr->eval_gates->evaluate_value); - jit_stxi_p(curr_offset*sizeof(void*), JIT_VHEAP, JIT_R0); - curr_offset++; - - PgfCallPatch patch; - patch.cid = id; - patch.ref = jit_movi_p(JIT_R0, jit_forward()); - jit_stxi_p(curr_offset*sizeof(void*), JIT_VHEAP, JIT_R0); - curr_offset++; - - gu_buf_push(rdr->jit_state->call_patches, PgfCallPatch, patch); - break; - } - case PGF_INSTR_PUT_CLOSURE: { - size_t target = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUT_CLOSURE %03d\n", target); -#endif - - PgfSegmentPatch patch; - patch.segment = target; - patch.ref = jit_movi_p(JIT_R0, jit_forward()); - patch.is_abs = true; - jit_stxi_p(curr_offset*sizeof(void*), JIT_VHEAP, JIT_R0); - curr_offset++; - - gu_buf_push(rdr->jit_state->segment_patches, PgfSegmentPatch, patch); - break; - } - case PGF_INSTR_PUT_LIT: { - jit_movi_p(JIT_R0, abstr->eval_gates->evaluate_value_lit); - jit_stxi_p(curr_offset*sizeof(void*), JIT_VHEAP, JIT_R0); - curr_offset++; - - PgfLiteral lit = gu_null_variant; - switch (mod) { - case 0: { - PgfLiteralInt *lit_int = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &lit, - rdr->opool); - lit_int->val = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUT_LIT %d\n", lit_int->val); -#endif - break; - } - case 1: { - size_t len = pgf_read_len(rdr); - uint8_t* buf = alloca(len*6+1); - uint8_t* p = buf; - for (size_t i = 0; i < len; i++) { - gu_in_utf8_buf(&p, rdr->in, rdr->err); - } - *p++ = 0; - - PgfLiteralStr *lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, p-buf, - &lit, rdr->opool); - strcpy((char*) lit_str->val, (char*) buf); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUT_LIT \"%s\"\n", lit_str->val); -#endif - break; - } - case 2: { - PgfLiteralFlt *lit_flt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &lit, - rdr->opool); - lit_flt->val = pgf_read_double(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUT_LIT %f\n", lit_flt->val); -#endif - break; - } - default: - gu_impossible(); - } - - jit_movi_p(JIT_R0, lit); - jit_stxi_p(curr_offset*sizeof(void*), JIT_VHEAP, JIT_R0); - curr_offset++; - break; - } - case PGF_INSTR_SET: { - switch (mod) { - case 0: { - size_t offset = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "SET hp(%d)\n", offset); -#endif - jit_addi_p(JIT_R0, JIT_VHEAP, offset*sizeof(void*)); - break; - } - case 1: { - size_t index = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "SET stk(%d)\n", index); -#endif - jit_ldxi_p(JIT_R0, JIT_SP, index*sizeof(PgfClosure*)); - break; - } - case 2: { - size_t index = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "SET env(%d)\n", index); -#endif - jit_ldxi_p(JIT_R0, JIT_VCLOS, sizeof(PgfClosure)+index*sizeof(PgfClosure*)); - break; - } - case 3: { - PgfCId id = pgf_read_cid(rdr, rdr->tmp_pool); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "SET %s\n", id); -#endif - PgfCallPatch patch; - patch.cid = id; - patch.ref = jit_movi_p(JIT_R0, jit_forward()); - gu_buf_push(rdr->jit_state->call_patches, PgfCallPatch, patch); - break; - } - default: - gu_impossible(); - } - - jit_stxi_p(curr_offset*sizeof(void*), JIT_VHEAP, JIT_R0); - curr_offset++; - break; - } - case PGF_INSTR_SET_PAD: { -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "SET_PAD\n"); -#endif - jit_movi_p(JIT_R0, NULL); - jit_stxi_p(curr_offset*sizeof(void*), JIT_VHEAP, JIT_R0); - curr_offset++; - break; - } - case PGF_INSTR_PUSH_FRAME: { -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH_FRAME\n"); -#endif - jit_pushr_p(JIT_VCLOS); - jit_pushr_p(JIT_FP); - jit_movr_p(JIT_FP, JIT_SP); - break; - } - case PGF_INSTR_PUSH: { - switch (mod) { - case 0: { - size_t offset = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH hp(%d)\n", offset); -#endif - - if (offset == 0) { - jit_pushr_p(JIT_VHEAP); - } else { - jit_addi_p(JIT_R0, JIT_VHEAP, offset*sizeof(void*)); - jit_pushr_p(JIT_R0); - } - break; - } - case 1: { - size_t index = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH stk(%d)\n", index); -#endif - jit_ldxi_p(JIT_R0, JIT_SP, index*sizeof(PgfClosure*)); - jit_pushr_p(JIT_R0); - break; - } - case 2: { - size_t index = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH env(%d)\n", index); -#endif - jit_ldxi_p(JIT_R0, JIT_VCLOS, sizeof(PgfClosure)+index*sizeof(PgfClosure*)); - jit_pushr_p(JIT_R0); - break; - } - case 3: { - PgfCId id = pgf_read_cid(rdr, rdr->tmp_pool); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH %s\n", id); -#endif - PgfCallPatch patch; - patch.cid = id; - patch.ref = jit_movi_p(JIT_R0, jit_forward()); - gu_buf_push(rdr->jit_state->call_patches, PgfCallPatch, patch); - jit_pushr_p(JIT_R0); - break; - } - default: - gu_impossible(); - } - break; - } - case PGF_INSTR_TUCK: { - switch (mod) { - case 0: { - size_t offset = pgf_read_int(rdr); - size_t sindex = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "TUCK hp(%d) %d\n", offset, sindex); -#endif - - if (offset == 0) { - jit_stxi_p(sizeof(PgfClosure*)*sindex, JIT_SP, JIT_VHEAP); - } else { - jit_addi_p(JIT_R0, JIT_VHEAP, offset*sizeof(void*)); - jit_stxi_p(sizeof(PgfClosure*)*sindex, JIT_SP, JIT_R0); - } - break; - } - case 1: { - size_t index = pgf_read_int(rdr); - size_t sindex = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "TUCK stk(%d) %d\n", index, sindex); -#endif - jit_ldxi_p(JIT_R0, JIT_SP, index*sizeof(PgfClosure*)); - jit_stxi_p(sizeof(PgfClosure*)*sindex, JIT_SP, JIT_R0); - break; - } - case 2: { - size_t index = pgf_read_int(rdr); - size_t sindex = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "TUCK env(%d) %d\n", index, sindex); -#endif - jit_ldxi_p(JIT_R0, JIT_VCLOS, sizeof(PgfClosure)+index*sizeof(PgfClosure*)); - jit_stxi_p(sizeof(PgfClosure*)*sindex, JIT_SP, JIT_R0); - break; - } - case 3: { - PgfCId id = pgf_read_cid(rdr, rdr->tmp_pool); - size_t sindex = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "TUCK %s %d\n", id, sindex); -#endif - PgfCallPatch patch; - patch.cid = id; - patch.ref = jit_movi_p(JIT_R0, jit_forward()); - gu_buf_push(rdr->jit_state->call_patches, PgfCallPatch, patch); - jit_stxi_p(sizeof(PgfClosure*)*sindex, JIT_SP, JIT_R0); - break; - } - default: - gu_impossible(); - } - break; - } - case PGF_INSTR_EVAL+0: - case PGF_INSTR_EVAL+2: - case PGF_INSTR_EVAL+1: { - switch (mod) { - case 0: { - size_t offset = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "EVAL hp(%d)", offset); -#endif - jit_addi_p(JIT_VCLOS, JIT_VHEAP, offset*sizeof(void*)); - break; - } - case 1: { - size_t index = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "EVAL stk(%d)", index); -#endif - jit_ldxi_p(JIT_VCLOS, JIT_SP, index*sizeof(PgfClosure*)); - break; - } - case 2: { - size_t index = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "EVAL env(%d)", index); -#endif - jit_ldxi_p(JIT_VCLOS, JIT_VCLOS, sizeof(PgfClosure)+index*sizeof(PgfClosure*)); - break; - } - case 3: { - PgfCId id = pgf_read_cid(rdr, rdr->tmp_pool); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "EVAL %s", id); -#endif - PgfCallPatch patch; - patch.cid = id; - patch.ref = jit_movi_p(JIT_VCLOS, jit_forward()); - gu_buf_push(rdr->jit_state->call_patches, PgfCallPatch, patch); - break; - } - default: - gu_impossible(); - } - - jit_ldr_p(JIT_R0, JIT_VCLOS); - - switch (opcode - PGF_INSTR_EVAL) { - case 0: { -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "\n"); -#endif - jit_callr(JIT_R0); - jit_popr_p(JIT_FP); - jit_popr_p(JIT_VCLOS); - break; - } - case 1: { - size_t a = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, " tail(%d)\n", a); -#endif - jit_addi_p(JIT_SP, JIT_SP, a*sizeof(PgfClosure*)); - jit_jmpr(JIT_R0); - break; - } - case 2: { -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, " update\n"); -#endif - - jit_movi_p(JIT_R1, abstr->eval_gates->update_closure); - jit_pushr_p(JIT_R1); - jit_jmpr(JIT_R0); - break; - } - default: - gu_impossible(); - } - break; - } - case PGF_INSTR_DROP: { - size_t n = pgf_read_int(rdr); - -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "DROP %d\n", n); -#endif - - jit_addi_p(JIT_SP, JIT_SP, n*sizeof(PgfClosure*)); - break; - } - case PGF_INSTR_JUMP: { - size_t target = pgf_read_int(rdr); - -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "JUMP %03d\n", target); -#endif - - jit_insn *jump = - jit_jmpi(jit_forward()); - - PgfSegmentPatch label_patch; - label_patch.segment = target; - label_patch.ref = jump; - label_patch.is_abs = false; - gu_buf_push(rdr->jit_state->segment_patches, PgfSegmentPatch, label_patch); - break; - } - case PGF_INSTR_FAIL: -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "FAIL\n"); -#endif - jit_jmpi(abstr->eval_gates->mk_const); - break; - case PGF_INSTR_PUSH_ACCUM: - jit_subi_p(JIT_SP, JIT_SP, sizeof(PgfEvalAccum)); - - switch (mod) { - case 0: { - int val = pgf_read_int(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH_ACCUM %d\n", val); -#endif - jit_prepare(3); - jit_movi_i(JIT_R0, val); - jit_movr_p(JIT_R1, JIT_SP); - jit_pusharg_p(JIT_R0); - jit_pusharg_p(JIT_R1); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_evaluate_accum_init_int); - break; - } - case 1: { - size_t len = pgf_read_len(rdr); - uint8_t* buf = alloca(len*6+1); - uint8_t* p = buf; - for (size_t i = 0; i < len; i++) { - gu_in_utf8_buf(&p, rdr->in, rdr->err); - } - *p++ = 0; - - GuString val = - *buf ? gu_string_copy((GuString) buf, rdr->opool) - : NULL; -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH_ACCUM \"%s\"\n", buf); -#endif - jit_prepare(3); - jit_movi_p(JIT_R0, val); - jit_movr_p(JIT_R1, JIT_SP); - jit_pusharg_p(JIT_R0); - jit_pusharg_p(JIT_R1); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_evaluate_accum_init_str); - break; - } - case 2: { - double val = pgf_read_double(rdr); -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "PUSH_ACCUM %f\n", val); -#endif - jit_prepare_d(1); - jit_prepare_i(2); - jit_movi_d(JIT_FPR0, val); - jit_movr_p(JIT_R1, JIT_SP); - jit_pusharg_d(JIT_FPR0); - jit_pusharg_p(JIT_R1); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_evaluate_accum_init_flt); - break; - } - default: - gu_impossible(); - } - break; - case PGF_INSTR_POP_ACCUM: -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "POP_ACCUM\n"); -#endif - jit_prepare(2); - jit_pusharg_p(JIT_SP); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_evaluate_accum_done); - jit_addi_p(JIT_SP, JIT_SP, sizeof(PgfEvalAccum)); - jit_pushr_p(JIT_RET); - break; - case PGF_INSTR_ADD: -#ifdef PGF_JIT_DEBUG - gu_printf(out, err, "ADD\n"); -#endif - jit_prepare(3); - jit_movr_p(JIT_R1, JIT_SP); - jit_pusharg_p(JIT_VHEAP); - jit_pusharg_p(JIT_R1); - jit_pusharg_p(JIT_VSTATE); - jit_finish(pgf_evaluate_accum_add); - break; - default: - gu_impossible(); - } - } - } -} - -PGF_INTERNAL void -pgf_jit_done(PgfReader* rdr, PgfAbstr* abstr) -{ - size_t n_patches = gu_buf_length(rdr->jit_state->call_patches); - for (size_t i = 0; i < n_patches; i++) { - PgfCallPatch* patch = - gu_buf_index(rdr->jit_state->call_patches, PgfCallPatch, i); - - PgfAbsCat* arg = - gu_seq_binsearch(abstr->cats, pgf_abscat_order, PgfAbsCat, patch->cid); - if (arg != NULL) { - jit_patch_at(patch->ref,(jit_insn*) arg->predicate); - } else { - PgfAbsFun* fun = - gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, patch->cid); - if (fun == NULL) - gu_impossible(); - else { - jit_patch_movi(patch->ref,&fun->closure); - } - } - } - - jit_flush_code(rdr->jit_state->buf, jit_get_ip().ptr); -} diff --git a/src/runtime/c/pgf/lightning.h b/src/runtime/c/pgf/lightning.h deleted file mode 100644 index 42780ecb7..000000000 --- a/src/runtime/c/pgf/lightning.h +++ /dev/null @@ -1,62 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * lightning main include file - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_h -#define __lightning_h - -#ifdef __cplusplus -extern "C" { -#endif - -#include "lightning/asm-common.h" - -#ifndef LIGHTNING_DEBUG -#include "lightning/asm.h" -#endif - -#include "lightning/core.h" -#include "lightning/core-common.h" -#include "lightning/funcs.h" -#include "lightning/funcs-common.h" -#include "lightning/fp.h" -#include "lightning/fp-common.h" - -#ifndef JIT_R0 -#error GNU lightning does not support the current target -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* __lightning_h */ diff --git a/src/runtime/c/pgf/lightning/arm/asm.h b/src/runtime/c/pgf/lightning/arm/asm.h deleted file mode 100644 index c60ae2224..000000000 --- a/src/runtime/c/pgf/lightning/arm/asm.h +++ /dev/null @@ -1,1801 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler for the arm - * - ***********************************************************************/ - -/*********************************************************************** - * - * Copyright 2011 Free Software Foundation - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - * Authors: - * Paulo Cesar Pereira de Andrade - ***********************************************************************/ - -#ifndef __lightning_asm_h -#define __lightning_asm_h - -typedef enum { - _R0, /* argument / result */ - _R1, /* argument */ - _R2, /* argument */ - _R3, /* argument */ - _R4, /* variable */ - _R5, /* variable */ - _R6, /* variable */ - _R7, /* variable */ - _R8, /* variable */ - _R9, /* variable */ - _R10, /* sl - stack limit */ - _R11, /* fp - frame pointer */ - _R12, /* ip - temporary */ - _R13, /* sp - stack pointer */ - _R14, /* lr - link register */ - _R15, /* pc - program counter */ -} jit_gpr_t; - -#define JIT_RET _R0 -#define JIT_PC _R15 -#define JIT_LR _R14 -#define JIT_SP _R13 -#define JIT_FP _R11 -#define JIT_TMP _R8 -#define JIT_FTMP _R9 - -/* must use blx to call functions or jit instruction set matches runtime? */ -#define jit_exchange_p() 1 - -/* _VxxxQ macros mean _Q0=_D0, _Q1=_D2, ... */ -typedef enum { - _S0, _D0 = _S0, _Q0 = _D0, - _S1, - _S2, _D1 = _S2, - _S3, - _S4, _D2 = _S4, _Q1 = _D2, - _S5, - _S6, _D3 = _S6, - _S7, - _S8, _D4 = _S8, _Q2 = _D4, - _S9, - _S10, _D5 = _S10, - _S11, - _S12, _D6 = _S12, _Q3 = _D6, - _S13, - _S14, _D7 = _S14, - _S15, - _S16, _D8 = _S16, _Q4 = _D8, - _S17, - _S18, _D9 = _S18, - _S19, - _S20, _D10 = _S20, _Q5 = _D10, - _S21, - _S22, _D11 = _S22, - _S23, - _S24, _D12 = _S24, _Q6 = _D12, - _S25, - _S26, _D13 = _S26, - _S27, - _S28, _D14 = _S28, _Q7 = _D14, - _S29, - _S30, _D15 = _S30, - _S31, - JIT_FPRET, /* for abstraction of returning a float/double result */ -} jit_fpr_t; - -/* match vfpv3 result */ -#define NAN_TO_INT_IS_ZERO 1 - -#define jit_armv6_p() (jit_cpu.version >= 6) -typedef union _jit_thumb_t { - int i; - short s[2]; -} jit_thumb_t; - -#if __BYTE_ORDER == __LITTLE_ENDIAN -# define _jit_WW(i, j) (_jit_W(j), _jit_W(i)) -# define code2thumb(t0, t1, c0, c1) (t1 = c0, t0 = c1) -# define thumb2code(t0, t1, c0, c1) (c0 = t1, c1 = t0) -#else -# define _jit_WW(i, j) (_jit_W(i), _jit_W(j)) -# define code2thumb(t0, t1, c0, c1) (t0 = c0, t1 = c1) -# define thumb2code(t0, t1, c0, c1) (c0 = t0, c1 = t1) -#endif - -#define ARM_CC_EQ 0x00000000 /* Z=1 */ -#define ARM_CC_NE 0x10000000 /* Z=0 */ -#define ARM_CC_HS 0x20000000 /* C=1 */ -# define ARM_CC_CS ARM_CC_HS -#define ARM_CC_LO 0x30000000 /* C=0 */ -# define ARM_CC_CC ARM_CC_LO -#define ARM_CC_MI 0x40000000 /* N=1 */ -#define ARM_CC_PL 0x50000000 /* N=0 */ -#define ARM_CC_VS 0x60000000 /* V=1 */ -#define ARM_CC_VC 0x70000000 /* V=0 */ -#define ARM_CC_HI 0x80000000 /* C=1 && Z=0 */ -#define ARM_CC_LS 0x90000000 /* C=0 || Z=1 */ -#define ARM_CC_GE 0xa0000000 /* N=V */ -#define ARM_CC_LT 0xb0000000 /* N!=V */ -#define ARM_CC_GT 0xc0000000 /* Z=0 && N=V */ -#define ARM_CC_LE 0xd0000000 /* Z=1 || N!=V */ -#define ARM_CC_AL 0xe0000000 /* always */ -#define ARM_CC_NV 0xf0000000 /* reserved */ - -#define ARM_MOV 0x01a00000 -#define THUMB_MOV 0x4600 -#define ARM_MOVWI 0x03000000 -#define THUMB_MOVI 0x2000 -#define THUMB2_MOVI 0xf0400000 -#define THUMB2_MOVWI 0xf2400000 -#define ARM_MOVTI 0x03400000 -#define THUMB2_MOVTI 0xf2c00000 -#define ARM_MVN 0x01e00000 -#define THUMB_MVN 0x43c0 -#define THUMB2_MVN 0xea600000 -#define THUMB2_MVNI 0xf0600000 -#define ARM_MRC 0x0e100010 -#define ARM_MRRC 0x0c500000 -#define ARM_MRS 0x010f0000 -#define ARM_MSRI 0x03200000 -#define ARM_MSR 0x0120f000 - -#define ARM_I 0x02000000 /* immediate */ -#define ARM_S 0x00100000 /* set flags */ -#define ARM_ADD 0x00800000 -#define THUMB_ADD 0x1800 -#define THUMB_ADDX 0x4400 -#define THUMB2_ADD 0xeb000000 -#define THUMB_ADDI3 0x1c00 -#define THUMB_ADDI8 0x3000 -#define THUMB2_ADDI 0xf1000000 -#define THUMB2_ADDWI 0xf2000000 -#define ARM_ADC 0x00a00000 -#define THUMB_ADC 0x4140 -#define THUMB2_ADC 0xeb400000 -#define THUMB2_ADCI 0xf1400000 -#define ARM_SUB 0x00400000 -#define THUMB_SUB 0x1a00 -#define THUMB2_SUB 0xeba00000 -#define THUMB_SUBI3 0x1e00 -#define THUMB_SUBI8 0x3800 -#define THUMB2_SUBI 0xf1a00000 -#define THUMB2_SUBWI 0xf2a00000 -#define ARM_SBC 0x00c00000 -#define THUMB_SBC 0x4180 -#define THUMB2_SBC 0xeb600000 -#define THUMB2_SBCI 0xf1600000 -#define ARM_RSB 0x00600000 -#define THUMB2_RSB 0xebc00000 -#define THUMB_RSBI 0x4240 -#define THUMB2_RSBI 0xf1c00000 -#define ARM_MUL 0x00000090 -#define THUMB_MUL 0x4340 -#define THUMB2_MUL 0xfb00f000 -#define ARM_SMULL 0x00c00090 -#define THUMB2_SMULL 0xfb800000 -#define ARM_UMULL 0x00800090 -#define THUMB2_UMULL 0xfba00000 -#define THUMB2_SDIV 0xfb90f0f0 -#define THUMB2_UDIV 0xfbb0f0f0 - -#define ARM_AND 0x00000000 -#define THUMB_AND 0x4000 -#define THUMB2_AND 0xea000000 -#define THUMB2_ANDI 0xf0000000 -#define ARM_BIC 0x01c00000 -#define THUMB2_BIC 0xea200000 -#define THUMB2_BICI 0xf0200000 -#define ARM_ORR 0x01800000 -#define THUMB_ORR 0x4300 -#define THUMB2_ORR 0xea400000 -#define THUMB2_ORRI 0xf0400000 -#define ARM_EOR 0x00200000 -#define THUMB_EOR 0x4040 -#define THUMB2_EOR 0xea800000 -#define THUMB2_EORI 0xf0800000 -#define ARM_REV 0x06bf0f30 -#define THUMB_REV 0xba00 -#define THUMB2_REV 0xfa90f080 -#define ARM_REV16 0x06bf0fb0 -#define THUMB_REV16 0xba40 -#define THUMB2_REV16 0xfa90f090 -#define ARM_SXTB 0x06af0070 -#define THUMB_SXTB 0xb240 -#define THUMB2_SXTB 0xfa4f0080 -#define ARM_UXTB 0x06ef0070 -#define THUMB_UXTB 0xb2c0 -#define THUMB2_UXTB 0xfa5f0080 -#define ARM_SXTH 0x06bf0070 -#define THUMB_SXTH 0xb200 -#define THUMB2_SXTH 0xfa0f0080 -#define ARM_UXTH 0x06ff0070 -#define THUMB_UXTH 0xb280 -#define THUMB2_UXTH 0xfa1f0080 -#define ARM_XTR8 0x00000400 /* ?xt? rotate 8 bits */ -#define ARM_XTR16 0x00000800 /* ?xt? rotate 16 bits */ -#define ARM_XTR24 0x00000c00 /* ?xt? rotate 24 bits */ - -#define ARM_SHIFT 0x01a00000 -#define ARM_R 0x00000010 /* register shift */ -#define ARM_LSL 0x00000000 -#define THUMB_LSL 0x4080 -#define THUMB2_LSL 0xfa00f000 -#define THUMB_LSLI 0x0000 -#define THUMB2_LSLI 0xea4f0000 -#define ARM_LSR 0x00000020 -#define THUMB_LSR 0x40c0 -#define THUMB2_LSR 0xfa20f000 -#define THUMB_LSRI 0x0800 -#define THUMB2_LSRI 0xea4f0010 -#define ARM_ASR 0x00000040 -#define THUMB_ASR 0x4100 -#define THUMB2_ASR 0xfa40f000 -#define THUMB_ASRI 0x1000 -#define THUMB2_ASRI 0xea4f0020 -#define ARM_ROR 0x00000060 -#define ARM_PKH 0x06800010 /* v6T2,v7 */ - -#define ARM_CMP 0x01500000 -#define THUMB_CMP 0x4280 -#define THUMB_CMPX 0x4500 -#define THUMB2_CMP 0xebb00000 -#define THUMB_CMPI 0x2800 -#define THUMB2_CMPI 0xf1b00000 -#define ARM_CMN 0x01700000 -#define THUMB_CMN 0x42c0 -#define THUMB2_CMN 0xeb100000 -#define THUMB2_CMNI 0xf1100000 -#define ARM_TST 0x01100000 -#define THUMB_TST 0x4200 -#define THUMB2_TST 0xea100000 -#define THUMB2_TSTI 0xf0100000 -#define ARM_TEQ 0x01300000 - -/* branch */ -#define ARM_BX 0x012fff10 -#define ARM_BLX 0x012fff30 -#define THUMB_BLX 0x4780 -#define ARM_BLXI 0xfa000000 -#define THUMB2_BLXI 0xf000c000 -#define ARM_B 0x0a000000 -#define THUMB_CC_B 0xd000 -#define THUMB_B 0xe000 -#define THUMB2_CC_B 0xf0008000 -#define THUMB2_B 0xf0009000 -#define ARM_BLI 0x0b000000 -#define THUMB2_BLI 0xf000d000 - -/* ldr/str */ -#define ARM_P 0x00800000 /* positive offset - * actually, the errata manual - * calls this to U field and - * 1<<24 the P field */ -#define THUMB2_P 0x00000400 -#define THUMB2_U 0x00000200 -#define THUMB2_W 0x00000100 -#define ARM_LDRSB 0x011000d0 -#define THUMB_LDRSB 0x5600 -#define THUMB2_LDRSB 0xf9100000 -#define ARM_LDRSBI 0x015000d0 -#define THUMB2_LDRSBI 0xf9100c00 -#define THUMB2_LDRSBWI 0xf9900000 -#define ARM_LDRB 0x07500000 -#define THUMB_LDRB 0x5c00 -#define THUMB2_LDRB 0xf8100000 -#define ARM_LDRBI 0x05500000 -#define THUMB_LDRBI 0x7800 -#define THUMB2_LDRBI 0xf8100c00 -#define THUMB2_LDRBWI 0xf8900000 -#define ARM_LDRSH 0x011000f0 -#define THUMB_LDRSH 0x5e00 -#define THUMB2_LDRSH 0xf9300000 -#define ARM_LDRSHI 0x015000f0 -#define THUMB2_LDRSHI 0xf9300c00 -#define THUMB2_LDRSHWI 0xf9b00000 -#define ARM_LDRH 0x011000b0 -#define THUMB_LDRH 0x5a00 -#define THUMB2_LDRH 0xf8300000 -#define ARM_LDRHI 0x015000b0 -#define THUMB_LDRHI 0x8800 -#define THUMB2_LDRHI 0xf8300c00 -#define THUMB2_LDRHWI 0xf8b00000 -#define ARM_LDR 0x07100000 -#define THUMB_LDR 0x5800 -#define THUMB2_LDR 0xf8500000 -#define ARM_LDRI 0x05100000 -#define THUMB_LDRI 0x6800 -#define THUMB_LDRISP 0x9800 -#define THUMB2_LDRI 0xf8500c00 /* manual says v6t2/v7; does not work */ -#define THUMB2_LDRWI 0xf8d00000 -#define ARM_LDRD 0x010000d0 -#define ARM_LDRDI 0x014000d0 -#define THUMB2_LDRDI 0xe8500000 -#define ARM_STRB 0x07400000 -#define THUMB_STRB 0x5400 -#define THUMB2_STRB 0xf8000000 -#define ARM_STRBI 0x05400000 -#define THUMB_STRBI 0x7000 -#define THUMB2_STRBI 0xf8000c00 -#define THUMB2_STRBWI 0xf8800000 -#define ARM_STRH 0x010000b0 -#define THUMB_STRH 0x5200 -#define THUMB2_STRH 0xf8200000 -#define ARM_STRHI 0x014000b0 -#define THUMB_STRHI 0x8000 -#define THUMB2_STRHI 0xf8200c00 -#define THUMB2_STRHWI 0xf8a00000 -#define ARM_STR 0x07000000 -#define THUMB_STR 0x5000 -#define THUMB2_STR 0xf8400000 -#define ARM_STRI 0x05000000 -#define THUMB_STRI 0x6000 -#define THUMB_STRISP 0x9000 -#define THUMB2_STRI 0xf8400c00 -#define THUMB2_STRWI 0xf8c00000 -#define ARM_STRD 0x010000f0 -#define ARM_STRDI 0x014000f0 -#define THUMB2_STRDI 0xe8400000 /* manual says v6t2/v7; does not work */ - -/* ldm/stm */ -#define ARM_M 0x08000000 -#define ARM_M_L 0x00100000 /* load; store if not set */ -#define ARM_M_I 0x00800000 /* inc; dec if not set */ -#define ARM_M_B 0x01000000 /* before; after if not set */ -#define ARM_M_U 0x00200000 /* update Rn */ -#define THUMB2_LDM_W 0x00200000 -#define THUMB2_LDM_P 0x00008000 -#define THUMB2_LDM_M 0x00004000 -#define THUMB_LDMIA 0xc800 -#define THUMB2_LDMIA 0xe8900000 -#define THUMB2_LDMDB 0xe9100000 -#define THUMB_PUSH 0xb400 -#define THUMB2_PUSH 0xe92d0000 -#define THUMB_POP 0xbc00 -#define THUMB2_POP 0xe8bd0000 - -/* misc */ -#define ARM_CLZ 0x016f0f10 -#define ARM_PLD 0xf750f000 -#define ARM_PLDW 0xf710f000 -#define ARM_PLDI 0xf510f000 -#define ARM_PLDWI 0xf510f000 -#define ARM_PLDLI 0xf55ff000 -#define ARM_PLD_U 0x00800000 -#define ARM_PLII 0xf4d0f000 -#define ARM_PLINI 0xf450f000 -#define ARM_PLI 0xf6d0f000 -#define ARM_PLIN 0xf650f000 - -#define FPSCR_N 0x80000000/* Negative condition code flag */ -#define FPSCR_Z 0x40000000/* Zero condition code flag */ -#define FPSCR_C 0x20000000/* Carry condition code flag */ -#define FPSCR_V 0x10000000/* Overflow condition code flag */ -#define FPSCR_QC 0x08000000/* Cumulative saturation flag */ -#define FPSCR_AHP 0x04000000/* Alternative half-precision (unset is IEEE format) */ -#define FPSCR_DN 0x02000000/* Default NaN mode */ -#define FPSCR_FZ 0x01000000/* Flush to zero (unset is fully IEEE-754 compliant) */ -#define FPSCR_RMASK 0x00c00000 -# define FPSCR_RN 0x00000000 /* Round to Nearest */ -# define FPSCR_RP 0x00400000 /* Round towards Plus Infinity */ -# define FPSCR_RM 0x00800000 /* Round towards Minus Infinity */ -# define FPSCR_RZ 0x00c00000 /* Round towards Zero */ -#define FPSCR_STRIDE 0x00300000 -#define FPSCR_RES1 0x00080000/* Reserved, UNK/SBZP */ -#define FPSCR_LEN 0x00070000 -#define FPSCR_IDE 0x00008000/* Input Denormal exception trap enable */ -#define FPSCR_IXE 0x00001000/* Inexact exception trap enable */ -#define FPSCR_UFE 0x00000800/* Underflow exception trap enable */ -#define FPSCR_OFE 0x00000400/* Overflow exception trap enable */ -#define FPSCR_DZE 0x00000200/* Division by zero exception trap enable */ -#define FPSCR_IOE 0x00000100/* Invalid Operation exception trap enable */ -#define FPSCR_IDC 0x00000080/* Input Denormal cumulative exception flag */ -#define FPSCR_RES0 0x00000060/* Reserved, UNK/SBZP */ -#define FPSCR_IXC 0x00000010/* Inexact cumulative exception flag */ -#define FPSCR_UFC 0x00000008/* Underflow cumulative exception flag */ -#define FPSCR_OFC 0x00000004/* Overflow cumulative exception flag */ -#define FPSCR_DZC 0x00000002/* Division by zero cumulative exception flag */ -#define FPSCR_IOC 0x00000001/* Invalid Operation cumulative exception flag */ - -/*********************************************************************** - * VFPv2 and VFPv3 (encoding T2/A2) instructions - ***********************************************************************/ -#define ARM_V_E 0x00000080 /* ARM_VCMP exception if NaN arg(s) */ -#define ARM_V_Z 0x00010000 /* ARM_VCMP with zero */ -#define ARM_V_F64 0x00000100 /* Undefined in single precision only variant */ -#define ARM_VADD_F 0x0e300a00 -#define ARM_VSUB_F 0x0e300a40 -#define ARM_VMUL_F 0x0e200a00 -#define ARM_VDIV_F 0x0e800a00 -#define ARM_VABS_F 0x0eb00ac0 -#define ARM_VNEG_F 0x0eb10a40 -#define ARM_VSQRT_F 0x0eb10ac0 -#define ARM_VMOV_F 0x0eb00a40 -#define ARM_VMOV_A_S 0x0e100a10 /* vmov rn, sn */ -#define ARM_VMOV_S_A 0x0e000a10 /* vmov sn, rn */ -#define ARM_VMOV_AA_D 0x0c500b10 /* vmov rn,rn, dn */ -#define ARM_VMOV_D_AA 0x0c400b10 /* vmov dn, rn,rn */ -#define ARM_VCMP 0x0eb40a40 -#define ARM_VMRS 0x0ef10a10 -#define ARM_VMSR 0x0ee10a10 -#define ARM_VCVT_2I 0x00040000 /* to integer */ -#define ARM_VCVT_2S 0x00010000 /* to signed */ -#define ARM_VCVT_RS 0x00000080 /* round to zero or signed */ -#define ARM_VCVT 0x0eb80a40 -#define ARM_VCVT_S32_F32 ARM_VCVT|ARM_VCVT_2I|ARM_VCVT_2S|ARM_VCVT_RS -#define ARM_VCVT_U32_F32 ARM_VCVT|ARM_VCVT_2I|ARM_VCVT_RS -#define ARM_VCVT_S32_F64 ARM_VCVT|ARM_VCVT_2I|ARM_VCVT_2S|ARM_VCVT_RS|ARM_V_F64 -#define ARM_VCVT_U32_F64 ARM_VCVT|ARM_VCVT_2I|ARM_VCVT_RS|ARM_V_F64 -#define ARM_VCVT_F32_S32 ARM_VCVT|ARM_VCVT_RS -#define ARM_VCVT_F32_U32 ARM_VCVT -#define ARM_VCVT_F64_S32 ARM_VCVT|ARM_VCVT_RS|ARM_V_F64 -#define ARM_VCVT_F64_U32 ARM_VCVT|ARM_V_F64 -#define ARM_VCVT_F 0x0eb70ac0 -#define ARM_VCVT_F32_F64 ARM_VCVT_F -#define ARM_VCVT_F64_F32 ARM_VCVT_F|ARM_V_F64 - -/* does not set bit 7, meaning to use rounding mode of FPSCR */ -#define ARM_VCVTR_S32_F32 ARM_VCVT|ARM_VCVT_2I|ARM_VCVT_2S -#define ARM_VCVTR_U32_F32 ARM_VCVT|ARM_VCVT_2I -#define ARM_VCVTR_S32_F64 ARM_VCVT|ARM_VCVT_2I|ARM_VCVT_2S|ARM_V_F64 -#define ARM_VCVTR_U32_F64 ARM_VCVT|ARM_VCVT_2I|ARM_V_F64 - -/*********************************************************************** - * NEON instructions (encoding T1/A1) (condition must always be ARM_CC_NV) - ***********************************************************************/ -#define ARM_V_D 0x00400000 -#define ARM_V_N 0x00000080 -#define ARM_V_Q 0x00000040 -#define ARM_V_M 0x00000020 -#define ARM_V_U 0x01000000 -#define ARM_V_I16 0x00100000 -#define ARM_V_I32 0x00200000 -#define ARM_V_I64 0x00300000 -#define ARM_V_S16 0x00040000 -#define ARM_V_S32 0x00080000 - -#define ARM_VADD_I 0x02000800 -#define ARM_VQADD_I 0x02000010 /* sets flag on overflow/carry */ -#define ARM_VADDL_I 0x02800000 /* q=d+d */ -#define ARM_VADDW_I 0x02800100 /* q=q+d */ -#define ARM_VSUB_I 0x03000800 -#define ARM_VQSUB_I 0x02000210 /* sets flag on overflow/carry */ -#define ARM_VSUBL_I 0x02800200 -#define ARM_VSUBW_I 0x02800300 -#define ARM_VMUL_I 0x02000910 -#define ARM_VMULL_I 0x02800c00 - -#define ARM_VABS_I 0x03b10300 -#define ARM_VQABS_I 0x03b00700 /* sets flag on overflow */ -#define ARM_VNEG_I 0x03b10380 -#define ARM_VQNEG_I 0x03b00780 /* sets flag on overflow */ - -#define ARM_VAND 0x02000110 -#define ARM_VBIC 0x02100110 -#define ARM_VORR 0x02200110 -#define ARM_VORN 0x02300110 -#define ARM_VEOR 0x03000110 -#define ARM_VMOVL_S8 0x00080000 -#define ARM_VMOVL_S16 0x00100000 -#define ARM_VMOVL_S32 0x00200000 -#define ARM_VMOVL_I 0x02800a10 - -#define ARM_VMVSI 0x0eb00a00 -#define ARM_VMOVI 0x02800010 -#define ARM_VMVNI 0x02800030 - -#define ARM_VLDR 0x0d100a00 -#define ARM_VSTR 0x0d000a00 -#define ARM_VM 0x0c000a00 - -/*********************************************************************** - * Advanced SIMD (encoding T2/A2) instructions - ***********************************************************************/ -#define ARM_VMOV_ADV_U 0x00800000 /* zero extend, sign extend if unset */ -#define ARM_VMOV_ADV_8 0x00400000 -#define ARM_VMOV_ADV_16 0x00000020 -#define ARM_VMOV_A_D 0x0e100b10 -#define ARM_VMOV_D_A 0x0e000b10 - -static int -encode_vfp_double(int mov, int inv, unsigned lo, unsigned hi) -{ - int code, mode, imm, mask; - - if (hi != lo) { - if (mov && !inv) { - /* (I64) - * aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh - */ - for (mode = 0, mask = 0xff; mode < 4; mask <<= 8, mode++) { - imm = lo & mask; - if (imm != mask && imm != 0) - goto fail; - imm = hi & mask; - if (imm != mask && imm != 0) - goto fail; - } - mode = 0xe20; - imm = (((hi & 0x80000000) >> 24) | ((hi & 0x00800000) >> 17) | - ((hi & 0x00008000) >> 10) | ((hi & 0x00000080) >> 3) | - ((lo & 0x80000000) >> 28) | ((lo & 0x00800000) >> 21) | - ((lo & 0x00008000) >> 14) | ((lo & 0x00000080) >> 7)); - goto success; - } - goto fail; - } - /* (I32) - * 00000000 00000000 00000000 abcdefgh - * 00000000 00000000 abcdefgh 00000000 - * 00000000 abcdefgh 00000000 00000000 - * abcdefgh 00000000 00000000 00000000 */ - for (mode = 0, mask = 0xff; mode < 4; mask <<= 8, mode++) { - if ((lo & mask) == lo) { - imm = lo >> (mode << 3); - mode <<= 9; - goto success; - } - } - /* (I16) - * 00000000 abcdefgh 00000000 abcdefgh - * abcdefgh 00000000 abcdefgh 00000000 */ - for (mode = 0, mask = 0xff; mode < 2; mask <<= 8, mode++) { - if ((lo & mask) && ((lo & (mask << 16)) >> 16) == (lo & mask)) { - imm = lo >> (mode << 3); - mode = 0x800 | (mode << 9); - goto success; - } - } - if (mov) { - /* (I32) - * 00000000 00000000 abcdefgh 11111111 - * 00000000 abcdefgh 11111111 11111111 */ - for (mode = 0, mask = 0xff; mode < 2; - mask = (mask << 8) | 0xff, mode++) { - if ((lo & mask) == mask && - !((lo & ~mask) >> 8) && - (imm = lo >> (8 + (mode << 8)))) { - mode = 0xc00 | (mode << 8); - goto success; - } - } - if (!inv) { - /* (F32) - * aBbbbbbc defgh000 00000000 00000000 - * from the ARM Architecture Reference Manual: - * In this entry, B = NOT(b). The bit pattern represents the - * floating-point number (-1)^s* 2^exp * mantissa, where - * S = UInt(a), - * exp = UInt(NOT(b):c:d)-3 and - * mantissa = (16+UInt(e:f:g:h))/16. */ - if ((lo & 0x7ffff) == 0 && - (((lo & 0x7e000000) == 0x3e000000) || - ((lo & 0x7e000000) == 0x40000000))) { - mode = 0xf00; - imm = ((lo >> 24) & 0x80) | ((lo >> 19) & 0x7f); - goto success; - } - } - } - -fail: - /* need another approach (load from memory, move from arm register, etc) */ - return (-1); - -success: - code = inv ? ARM_VMVNI : ARM_VMOVI; - switch ((mode & 0xf00) >> 8) { - case 0x0: case 0x2: case 0x4: case 0x6: - case 0x8: case 0xa: - if (inv) mode |= 0x20; - if (!mov) mode |= 0x100; - break; - case 0x1: case 0x3: case 0x5: case 0x7: - /* should actually not reach here */ - assert(!inv); - case 0x9: case 0xb: - assert(!mov); - break; - case 0xc: case 0xd: - /* should actually not reach here */ - assert(inv); - case 0xe: - assert(mode & 0x20); - assert(mov && !inv); - break; - default: - assert(!(mode & 0x20)); - break; - } - imm = ((imm & 0x80) << 17) | ((imm & 0x70) << 12) | (imm & 0x0f); - code |= mode | imm; -#ifdef USE_THUMB_CODE - if (code & 0x1000000) - code |= 0xff000000; - else - code |= 0xef000000; -#else - code |= ARM_CC_NV; -#endif - return (code); -} - -#ifdef USE_THUMB_CODE -#define _jit_TI(I) (_jitl.thumb.i = (I), _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) -#else -#define _jit_TI(I) _jit_I(I) -#endif - -#define arm_vodi(oi,r0) \ - (assert(!((oi) & 0x0000f000) && !((r0) & 1)), \ - _jit_TI((oi)|(_u4((r0) >> 1)<<12))) - -#define arm_voqi(oi,r0) \ - (assert(!((oi) & 0x0000f000) && !((r0) & 3)), \ - _jit_TI((oi)|(_u4((r0) >> 1)<<12))) - -#define arm_vo_ss(o,r0,r1) _arm_cc_vo_ss(ARM_CC_NV,o,r0,r1) -#define arm_cc_vo_ss(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f)), \ - _jit_TI((cc)|(o) | (((r0) & 1) ? ARM_V_D : 0) | (((r1) & 1) ? ARM_V_M : 0)|(_u4((r0) >> 1)<<12)|_u4((r1) >> 1))) - -#define arm_vo_dd(o,r0,r1) _arm_cc_vo_dd(ARM_CC_NV,o,r0,r1) -#define arm_cc_vo_dd(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f) && !((r0) & 1) && !((r1) & 1)), \ - _jit_TI((cc)|(o)|(_u4((r0) >> 1)<<12)|_u4((r1) >> 1))) - -#define arm_vo_qd(o,r0,r1) arm_cc_vo_qd(ARM_CC_NV,o,r0,r1) -#define arm_cc_vo_qd(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f) && !((r0) & 3) && !((r1) & 1)), \ - _jit_TI((cc)|(o)|(_u4((r0) >> 1)<<12)|_u4((r1) >> 1))) - -#define arm_vo_qq(o,r0,r1) arm_cc_vo_qq(ARM_CC_NV,o,r0,r1) -#define arm_cc_vo_qq(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f) && !((r0) & 3) && !((r1) & 3)), \ - _jit_TI((cc)|(o)|(_u4((r0) >> 1)<<12)|_u4((r1) >> 1))) - -#define arm_vorr_(o,r0,r1) arm_cc_vorr_(ARM_CC_NV,o,r0,r1) -#define arm_cc_vorr_(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f)), \ - _jit_TI((cc)|(o)|(_u4(r1)<<16)|(_u4(r0)<<12))) - -#define arm_vors_(o,r0,r1) arm_cc_vors_(ARM_CC_NV,o,r0,r1) -#define arm_cc_vors_(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f)), \ - _jit_TI((cc)|(o)|(((r1) & 1) ? ARM_V_N : 0)|(_u4(r1 >> 1)<<16)|(_u4(r0)<<12))) - -#define arm_vorv_(o,r0,r1) arm_cc_vorv_(ARM_CC_NV,o,r0,r1) -#define arm_cc_vorv_(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && ((o) & 0xf000f00f)), \ - _jit_TI((cc)|(o)|(((r1) & 1) ? ARM_V_M : 0)|(_u4((r1) >> 1)<<16)|(_u4(r0)<<12))) - -#define arm_vori_(o,r0,r1) arm_cc_vori_(ARM_CC_NV,o,r0,r1) -#define arm_cc_vori_(cc,o,r0,r1) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f)), \ - /* use same bit pattern, to set opc1... */ \ - _jit_TI((cc)|(o)|((r1 & 1) ? ARM_V_I32 : 0)|(_u4((r1) >> 1)<<16)|(_u4(r0)<<12))) - -#define arm_vorrd(o,r0,r1,r2) arm_cc_vorrd(ARM_CC_NV,o,r0,r1,r2) -#define arm_cc_vorrd(cc,o,r0,r1,r2) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff00f) && !((r2) & 1)), \ - _jit_TI((cc)|(o)|(_u4(r1)<<16)|(_u4(r0)<<12)|_u4((r2) >> 1))) - -#define arm_vosss(o,r0,r1,r2) arm_cc_vosss(ARM_CC_NV,o,r0,r1,r2) -#define arm_cc_vosss(cc,o,r0,r1,r2) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff00f)), \ - _jit_TI((cc)|(o)|(((r0) & 1) ? ARM_V_D : 0)|(((r1) & 1) ? ARM_V_N : 0)|(((r2) & 1) ? ARM_V_M : 0)|(_u4((r1) >> 1)<<16)|(_u4((r0) >> 1)<<12)|_u4((r2) >> 1))) - -#define arm_voddd(o,r0,r1,r2) arm_cc_voddd(ARM_CC_NV,o,r0,r1,r2) -#define arm_cc_voddd(cc,o,r0,r1,r2) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff00f) && !((r0) & 1) && !((r1) & 1) && !((r2) & 1)), \ - _jit_TI((cc)|(o)|(_u4((r1) >> 1)<<16)|(_u4((r0) >> 1)<<12)|_u4((r2) >> 1))) - -#define arm_voqdd(o,r0,r1,r2) arm_cc_voqdd(ARM_CC_NV,o,r0,r1,r2) -#define arm_cc_voqdd(cc,o,r0,r1,r2) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff00f) && !((r0) & 3) && !((r1) & 1) && !((r2) & 1)), \ - _jit_TI((cc)|(o)|(_u4((r1) >> 1)<<16)|(_u4((r0) >> 1)<<12)|_u4((r2) >> 1))) - -#define arm_voqqd(o,r0,r1,r2) arm_cc_voqqd(ARM_CC_NV,o,r0,r1,r2) -#define arm_cc_voqqd(cc,o,r0,r1,r2) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff00f) && !((r0) & 3) && !((r1) & 3) && !((r2) & 1)), \ - _jit_TI((cc)|(o)|(_u4((r1) >> 1)<<16)|(_u4((r0) >> 1)<<12)|_u4((r2) >> 1))) - -#define arm_voqqq(o,r0,r1,r2) arm_cc_voqqq(ARM_CC_NV,o,r0,r1,r2) -#define arm_cc_voqqq(cc,o,r0,r1,r2) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff00f) && !((r0) & 3) && !((r1) & 3) && !((r2) & 3)), \ - _jit_TI((cc)|(o)|(_u4((r1) >> 1)<<16)|(_u4((r0) >> 1)<<12)|_u4((r2) >> 1))) - -#define arm_cc_vldst(cc,o,r0,r1,i0) \ - /* i0 << 2 is byte offset */ \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff0ff) && (!((r0) & 1) | !((o) & ARM_V_F64))), \ - _jit_TI((cc)|(o)|(((r0) & 1) ? ARM_V_D : 0)|(_u4(r1)<<16)|(_u4((r0) >> 1)<<12)|_u8(i0))) - -#define arm_cc_vorsl(cc,o,r0,r1,i0) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff0ff)), \ - /* save i0 double precision registers */ \ - _jit_TI((cc)|((o) | ((r1) & 1) ? ARM_V_D : 0)|(_u4(r0)<<16)|(_u4((r1) >> 1)<<12)|_u8(((o) & ARM_V_F64) ? ((i0) << 1) : (i0)))) - -/*********************************************************************** - * VFPv2 and VFPv3 (encoding T2/A2) instructions - ***********************************************************************/ -#define _CC_VADD_F32(cc,r0,r1,r2) arm_cc_vosss(cc,ARM_VADD_F,r0,r1,r2) -#define _VADD_F32(r0,r1,r2) _CC_VADD_F32(ARM_CC_AL,r0,r1,r2) -#define _CC_VADD_F64(cc,r0,r1,r2) arm_cc_voddd(cc,ARM_VADD_F|ARM_V_F64,r0,r1,r2) -#define _VADD_F64(r0,r1,r2) _CC_VADD_F64(ARM_CC_AL,r0,r1,r2) -#define _CC_VSUB_F32(cc,r0,r1,r2) arm_cc_vosss(cc,ARM_VSUB_F,r0,r1,r2) -#define _VSUB_F32(r0,r1,r2) _CC_VSUB_F32(ARM_CC_AL,r0,r1,r2) -#define _CC_VSUB_F64(cc,r0,r1,r2) arm_cc_voddd(cc,ARM_VSUB_F|ARM_V_F64,r0,r1,r2) -#define _VSUB_F64(r0,r1,r2) _CC_VSUB_F64(ARM_CC_AL,r0,r1,r2) -#define _CC_VMUL_F32(cc,r0,r1,r2) arm_cc_vosss(cc,ARM_VMUL_F,r0,r1,r2) -#define _VMUL_F32(r0,r1,r2) _CC_VMUL_F32(ARM_CC_AL,r0,r1,r2) -#define _CC_VMUL_F64(cc,r0,r1,r2) arm_cc_voddd(cc,ARM_VMUL_F|ARM_V_F64,r0,r1,r2) -#define _VMUL_F64(r0,r1,r2) _CC_VMUL_F64(ARM_CC_AL,r0,r1,r2) -#define _CC_VDIV_F32(cc,r0,r1,r2) arm_cc_vosss(cc,ARM_VDIV_F,r0,r1,r2) -#define _VDIV_F32(r0,r1,r2) _CC_VDIV_F32(ARM_CC_AL,r0,r1,r2) -#define _CC_VDIV_F64(cc,r0,r1,r2) arm_cc_voddd(cc,ARM_VDIV_F|ARM_V_F64,r0,r1,r2) -#define _VDIV_F64(r0,r1,r2) _CC_VDIV_F64(ARM_CC_AL,r0,r1,r2) -#define _CC_VABS_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VABS_F,r0,r1) -#define _VABS_F32(r0,r1) _CC_VABS_F32(ARM_CC_AL,r0,r1) -#define _CC_VABS_F64(cc,r0,r1) arm_cc_vo_dd(cc,ARM_VABS_F|ARM_V_F64,r0,r1) -#define _VABS_F64(r0,r1) _CC_VABS_F64(ARM_CC_AL,r0,r1) -#define _CC_VNEG_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VNEG_F,r0,r1) -#define _VNEG_F32(r0,r1) _CC_VNEG_F32(ARM_CC_AL,r0,r1) -#define _CC_VNEG_F64(cc,r0,r1) arm_cc_vo_dd(cc,ARM_VNEG_F|ARM_V_F64,r0,r1) -#define _VNEG_F64(r0,r1) _CC_VNEG_F64(ARM_CC_AL,r0,r1) -#define _CC_VSQRT_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VSQRT_F,r0,r1) -#define _VSQRT_F32(r0,r1) _CC_VSQRT_F32(ARM_CC_AL,r0,r1) -#define _CC_VSQRT_F64(cc,r0,r1) arm_cc_vo_dd(cc,ARM_VSQRT_F|ARM_V_F64,r0,r1) -#define _VSQRT_F64(r0,r1) _CC_VSQRT_F64(ARM_CC_AL,r0,r1) -#define _CC_VMOV_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VMOV_F,r0,r1) -#define _VMOV_F32(r0,r1) _CC_VMOV_F32(ARM_CC_AL,r0,r1) -#define _CC_VMOV_F64(cc,r0,r1) arm_cc_vo_dd(cc,ARM_VMOV_F|ARM_V_F64,r0,r1) -#define _VMOV_F64(r0,r1) _CC_VMOV_F64(ARM_CC_AL,r0,r1) -#define _CC_VMOV_AA_D(cc,r0,r1,r2) arm_cc_vorrd(cc,ARM_VMOV_AA_D,r0,r1,r2) -#define _VMOV_AA_D(r0,r1,r2) _CC_VMOV_AA_D(ARM_CC_AL,r0,r1,r2) -#define _CC_VMOV_D_AA(cc,r0,r1,r2) arm_cc_vorrd(cc,ARM_VMOV_D_AA,r1,r2,r0) -#define _VMOV_D_AA(r0,r1,r2) _CC_VMOV_D_AA(ARM_CC_AL,r0,r1,r2) -#define _CC_VMOV_A_S(cc,r0,r1) arm_cc_vors_(cc,ARM_VMOV_A_S,r0,r1) -#define _VMOV_A_S(r0,r1) _CC_VMOV_A_S(ARM_CC_AL,r0,r1) -#define _CC_VMOV_S_A(cc,r0,r1) arm_cc_vors_(cc,ARM_VMOV_S_A,r1,r0) -#define _VMOV_S_A(r0,r1) _CC_VMOV_S_A(ARM_CC_AL,r0,r1) -#define _CC_VCMP_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCMP,r0,r1) -#define _VCMP_F32(r0,r1) _CC_VCMP_F32(ARM_CC_AL,r0,r1) -#define _CC_VCMP_F64(cc,r0,r1) arm_cc_vo_dd(cc,ARM_VCMP|ARM_V_F64,r0,r1) -#define _VCMP_F64(r0,r1) _CC_VCMP_F64(ARM_CC_AL,r0,r1) -#define _CC_VCMPE_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCMP|ARM_V_E,r0,r1) -#define _VCMPE_F32(r0,r1) _CC_VCMPE_F32(ARM_CC_AL,r0,r1) -#define _CC_VCMPE_F64(cc,r0,r1) arm_cc_vo_dd(cc,ARM_VCMP|ARM_V_E|ARM_V_F64,r0,r1) -#define _VCMPE_F64(r0,r1) _CC_VCMPE_F64(ARM_CC_AL,r0,r1) -#define _CC_VCMPZ_F32(cc,r0) arm_cc_vo_ss(cc,ARM_VCMP|ARM_V_Z,r0,0) -#define _VCMPZ_F32(r0) _CC_VCMPZ_F32(ARM_CC_AL,r0) -#define _CC_VCMPZ_F64(cc,r0) arm_cc_vo_dd(cc,ARM_VCMP|ARM_V_Z|ARM_V_F64,r0,0) -#define _VCMPZ_F64(r0) _CC_VCMPZ_F64(ARM_CC_AL,r0) -#define _CC_VCMPEZ_F32(cc,r0) arm_cc_vo_ss(cc,ARM_VCMP|ARM_V_Z|ARM_V_E,r0,0) -#define _VCMPEZ_F32(r0) _CC_VCMPEZ_F32(ARM_CC_AL,r0) -#define _CC_VCMPEZ_F64(cc,r0) arm_cc_vo_dd(cc,ARM_VCMP|ARM_V_Z|ARM_V_E|ARM_V_F64,r0,0) -#define _VCMPEZ_F64(r0) _CC_VCMPEZ_F64(ARM_CC_AL,r0) -#define _CC_VMRS(cc,r0) arm_cc_vorr_(cc,ARM_VMRS,r0,0) -#define _VMRS(r0) _CC_VMRS(ARM_CC_AL,r0) -#define _CC_VMSR(cc,r0) arm_cc_vorr_(cc,ARM_VMSR,r0,0) -#define _VMSR(r0) _CC_VMSR(ARM_CC_AL,r0) -#define _CC_VCVT_S32_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_S32_F32,r0,r1) -#define _VCVT_S32_F32(r0,r1) _CC_VCVT_S32_F32(ARM_CC_AL,r0,r1) -#define _CC_VCVT_U32_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_U32_F32,r0,r1) -#define _VCVT_U32_F32(r0,r1) _CC_VCVT_U32_F32(ARM_CC_AL,r0,r1) -#define _CC_VCVT_S32_F64(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_S32_F64,r0,r1) -#define _VCVT_S32_F64(r0,r1) _CC_VCVT_S32_F64(ARM_CC_AL,r0,r1) -#define _CC_VCVT_U32_F64(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_U32_F64,r0,r1) -#define _VCVT_U32_F64(r0,r1) _CC_VCVT_U32_F64(ARM_CC_AL,r0,r1) -#define _CC_VCVT_F32_S32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_F32_S32,r0,r1) -#define _VCVT_F32_S32(r0,r1) _CC_VCVT_F32_S32(ARM_CC_AL,r0,r1) -#define _CC_VCVT_F32_U32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_F32_U32,r0,r1) -#define _VCVT_F32_U32(r0,r1) _CC_VCVT_F32_U32(ARM_CC_AL,r0,r1) -#define _CC_VCVT_F64_S32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_F64_S32,r0,r1) -#define _VCVT_F64_S32(r0,r1) _CC_VCVT_F64_S32(ARM_CC_AL,r0,r1) -#define _CC_VCVT_F64_U32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_F64_U32,r0,r1) -#define _VCVT_F64_U32(r0,r1) _CC_VCVT_F64_U32(ARM_CC_AL,r0,r1) -#define _CC_VCVT_F32_F64(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_F32_F64,r0,r1) -#define _VCVT_F32_F64(r0,r1) _CC_VCVT_F32_F64(ARM_CC_AL,r0,r1) -#define _CC_VCVT_F64_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVT_F64_F32,r0,r1) -#define _VCVT_F64_F32(r0,r1) _CC_VCVT_F64_F32(ARM_CC_AL,r0,r1) -/* use rounding mode in fpscr (intended for floor, ceil, etc) */ -#define _CC_VCVTR_S32_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVTR_S32_F32,r0,r1) -#define _VCVTR_S32_F32(r0,r1) _CC_VCVTR_S32_F32(ARM_CC_AL,r0,r1) -#define _CC_VCVTR_U32_F32(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVTR_U32_F32,r0,r1) -#define _VCVTR_U32_F32(r0,r1) _CC_VCVTR_U32_F32(ARM_CC_AL,r0,r1) -#define _CC_VCVTR_S32_F64(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVTR_S32_F64,r0,r1) -#define _VCVTR_S32_F64(r0,r1) _CC_VCVTR_S32_F64(ARM_CC_AL,r0,r1) -#define _CC_VCVTR_U32_F64(cc,r0,r1) arm_cc_vo_ss(cc,ARM_VCVTR_U32_F64,r0,r1) -#define _VCVTR_U32_F64(r0,r1) _CC_VCVTR_U32_F64(ARM_CC_AL,r0,r1) -/*********************************************************************** - * NEON instructions (encoding T1/A1) (condition must always be ARM_CC_NV) - ***********************************************************************/ -#define _CC_VLDMIA_F32(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_L|ARM_M_I,r0,r1,i0) -#define _VLDMIA_F32(r0,r1,i0) _CC_VLDMIA_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDMIA_F64(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_L|ARM_M_I|ARM_V_F64,r0,r1,i0) -#define _VLDMIA_F64(r0,r1,i0) _CC_VLDMIA_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTMIA_F32(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_I,r0,r1,i0) -#define _VSTMIA_F32(r0,r1,i0) _CC_VSTMIA_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTMIA_F64(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_I|ARM_V_F64,r0,r1,i0) -#define _VSTMIA_F64(r0,r1,i0) _CC_VSTMIA_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDMIA_U_F32(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_L|ARM_M_I|ARM_M_U,r0,r1,i0) -#define _VLDMIA_U_F32(r0,r1,i0) _CC_VLDMIA_U_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDMIA_U_F64(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_L|ARM_M_I|ARM_M_U|ARM_V_F64,r0,r1,i0) -#define _VLDMIA_U_F64(r0,r1,i0) _CC_VLDMIA_U_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTMIA_U_F32(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_I|ARM_M_U,r0,r1,i0) -#define _VSTMIA_U_F32(r0,r1,i0) _CC_VSTMIA_U_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTMIA_U_F64(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_I|ARM_M_U|ARM_V_F64,r0,r1,i0) -#define _VSTMIA_U_F64(r0,r1,i0) _CC_VSTMIA_U_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDMDB_U_F32(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_L|ARM_M_B|ARM_M_U,r0,r1,i0) -#define _VLDMDB_U_F32(r0,r1,i0) _CC_VLDMDB_U_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDMDB_U_F64(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_L|ARM_M_B|ARM_M_U|ARM_V_F64,r0,r1,i0) -#define _VLDMDB_U_F64(r0,r1,i0) _CC_VLDMDB_U_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTMDB_U_F32(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_B|ARM_M_U,r0,r1,i0) -#define _VSTMDB_U_F32(r0,r1,i0) _CC_VSTMDB_U_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTMDB_U_F64(cc,r0,r1,i0) arm_cc_vorsl(cc,ARM_VM|ARM_M_B|ARM_M_U|ARM_V_F64,r0,r1,i0) -#define _VSTMDB_U_F64(r0,r1,i0) _CC_VSTMDB_U_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VPUSH_F32(cc,r0,i0) _CC_VSTMDB_U_F32(cc,JIT_SP,r0,i0) -#define _VPUSH_F32(r0,i0) _CC_VPUSH_F32(ARM_CC_AL,r0,i0) -#define _CC_VPUSH_F64(cc,r0,i0) _CC_VSTMDB_U_F64(cc,JIT_SP,r0,i0) -#define _VPUSH_F64(r0,i0) _CC_VPUSH_F64(ARM_CC_AL,r0,i0) -#define _CC_VPOP_F32(cc,r0,i0) _CC_VLDMIA_U_F32(cc,JIT_SP,r0,i0) -#define _VPOP_F32(r0,i0) _CC_VPOP_F32(ARM_CC_AL,r0,i0) -#define _CC_VPOP_F64(cc,r0,i0) _CC_VLDMIA_U_F64(cc,JIT_SP,r0,i0) -#define _VPOP_F64(r0,i0) _CC_VPOP_F64(ARM_CC_AL,r0,i0) -/*********************************************************************** - * Advanced SIMD (encoding T2/A2) instructions - ***********************************************************************/ -#define _CC_VMOV_A_S8(cc,r0,r1) arm_cc_vorv_(cc,ARM_VMOV_A_D|ARM_VMOV_ADV_8,r0,r1) -#define _VMOV_A_S8(r0,r1) _CC_VMOV_A_S8(ARM_CC_AL,r0,r1) -#define _CC_VMOV_A_U8(cc,r0,r1) arm_cc_vorv_(cc,ARM_VMOV_A_D|ARM_VMOV_ADV_8|ARM_VMOV_ADV_U,r0,r1) -#define _VMOV_A_U8(r0,r1) _CC_VMOV_A_U8(ARM_CC_AL,r0,r1) -#define _CC_VMOV_A_S16(cc,r0,r1) arm_cc_vorv_(cc,ARM_VMOV_A_D|ARM_VMOV_ADV_16,r0,r1) -#define _VMOV_A_S16(r0,r1) _CC_VMOV_A_S16(ARM_CC_AL,r0,r1) -#define _CC_VMOV_A_U16(cc,r0,r1) arm_cc_vorv_(cc,ARM_VMOV_A_D|ARM_VMOV_ADV_16|ARM_VMOV_ADV_U,r0,r1) -#define _VMOV_A_U16(r0,r1) _CC_VMOV_A_U16(ARM_CC_AL,r0,r1) -#define _CC_VMOV_A_S32(cc,r0,r1) arm_cc_vori_(cc,ARM_VMOV_A_D,r0,r1) -#define _VMOV_A_S32(r0,r1) _CC_VMOV_A_S32(ARM_CC_AL,r0,r1) -#define _CC_VMOV_A_U32(cc,r0,r1) arm_cc_vori_(cc,ARM_VMOV_A_D|ARM_VMOV_ADV_U,r0,r1) -#define _VMOV_A_U32(r0,r1) _CC_VMOV_A_U32(ARM_CC_AL,r0,r1) -#define _CC_VMOV_V_I8(cc,r0,r1) arm_cc_vorv_(cc,ARM_VMOV_D_A|ARM_VMOV_ADV_8,r1,r0) -#define _VMOV_V_I8(r0,r1) _CC_VMOV_V_I8(ARM_CC_AL,r0,r1) -#define _CC_VMOV_V_I16(cc,r0,r1) arm_cc_vorv_(cc,ARM_VMOV_D_A|ARM_VMOV_ADV_16,r1,r0) -#define _VMOV_V_I16(r0,r1) _CC_VMOV_V_I16(ARM_CC_AL,r0,r1) -#define _CC_VMOV_V_I32(cc,r0,r1) arm_cc_vori_(cc,ARM_VMOV_D_A,r1,r0) -#define _VMOV_V_I32(r0,r1) _CC_VMOV_V_I32(ARM_CC_AL,r0,r1) -#define _VADD_I8(r0,r1,r2) arm_voddd(ARM_VADD_I,r0,r1,r2) -#define _VADDQ_I8(r0,r1,r2) arm_voqqq(ARM_VADD_I|ARM_V_Q,r0,r1,r2) -#define _VADD_I16(r0,r1,r2) arm_voddd(ARM_VADD_I|ARM_V_I16,r0,r1,r2) -#define _VADDQ_I16(r0,r1,r2) arm_voqqq(ARM_VADD_I|ARM_V_I16|ARM_V_Q,r0,r1,r2) -#define _VADD_I32(r0,r1,r2) arm_voddd(ARM_VADD_I|ARM_V_I32,r0,r1,r2) -#define _VADDQ_I32(r0,r1,r2) arm_voqqq(ARM_VADD_I|ARM_V_I32|ARM_V_Q,r0,r1,r2) -#define _VADD_I64(r0,r1,r2) arm_voddd(ARM_VADD_I|ARM_V_I64,r0,r1,r2) -#define _VADDQ_I64(r0,r1,r2) arm_voqqq(ARM_VADD_I|ARM_V_I64|ARM_V_Q,r0,r1,r2) -#define _VQADD_S8(r0,r1,r2) arm_voddd(ARM_VQADD_I,r0,r1,r2) -#define _VQADDQ_S8(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_Q,r0,r1,r2) -#define _VQADD_U8(r0,r1,r2) arm_voddd(ARM_VQADD_I|ARM_V_U,r0,r1,r2) -#define _VQADDQ_U8(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VQADD_S16(r0,r1,r2) arm_voddd(ARM_VQADD_I|ARM_V_I16,r0,r1,r2) -#define _VQADDQ_S16(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_I16|ARM_V_Q,r0,r1,r2) -#define _VQADD_U16(r0,r1,r2) arm_voddd(ARM_VQADD_I|ARM_V_I16|ARM_V_U,r0,r1,r2) -#define _VQADDQ_U16(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_I16|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VQADD_S32(r0,r1,r2) arm_voddd(ARM_VQADD_I|ARM_V_I32,r0,r1,r2) -#define _VQADDQ_S32(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_I32|ARM_V_Q,r0,r1,r2) -#define _VQADD_U32(r0,r1,r2) arm_voddd(ARM_VQADD_I|ARM_V_I32|ARM_V_U,r0,r1,r2) -#define _VQADDQ_U32(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_I32|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VQADD_S64(r0,r1,r2) arm_voddd(ARM_VQADD_I|ARM_V_I64,r0,r1,r2) -#define _VQADDQ_S64(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_I64|ARM_V_Q,r0,r1,r2) -#define _VQADD_U64(r0,r1,r2) arm_voddd(ARM_VQADD_I|ARM_V_I64|ARM_V_U,r0,r1,r2) -#define _VQADDQ_U64(r0,r1,r2) arm_voqqq(ARM_VQADD_I|ARM_V_I64|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VADDL_S8(r0,r1,r2) arm_voqdd(ARM_VADDL_I,r0,r1,r2) -#define _VADDL_U8(r0,r1,r2) arm_voqdd(ARM_VADDL_I|ARM_V_U,r0,r1,r2) -#define _VADDL_S16(r0,r1,r2) arm_voqdd(ARM_VADDL_I|ARM_V_I16,r0,r1,r2) -#define _VADDL_U16(r0,r1,r2) arm_voqdd(ARM_VADDL_I|ARM_V_I16|ARM_V_U,r0,r1,r2) -#define _VADDL_S32(r0,r1,r2) arm_voqdd(ARM_VADDL_I|ARM_V_I32,r0,r1,r2) -#define _VADDL_U32(r0,r1,r2) arm_voqdd(ARM_VADDL_I|ARM_V_I32|ARM_V_U,r0,r1,r2) -#define _VADDW_S8(r0,r1,r2) arm_voqqd(ARM_VADDW_I,r0,r1,r2) -#define _VADDW_U8(r0,r1,r2) arm_voqqd(ARM_VADDW_I|ARM_V_U,r0,r1,r2) -#define _VADDW_S16(r0,r1,r2) arm_voqqd(ARM_VADDW_I|ARM_V_I16,r0,r1,r2) -#define _VADDW_U16(r0,r1,r2) arm_voqqd(ARM_VADDW_I|ARM_V_I16|ARM_V_U,r0,r1,r2) -#define _VADDW_S32(r0,r1,r2) arm_voqqd(ARM_VADDW_I|ARM_V_I32,r0,r1,r2) -#define _VADDW_U32(r0,r1,r2) arm_voqqd(ARM_VADDW_I|ARM_V_I32|ARM_V_U,r0,r1,r2) -#define _VSUB_I8(r0,r1,r2) arm_voddd(ARM_VSUB_I,r0,r1,r2) -#define _VSUBQ_I8(r0,r1,r2) arm_voqqq(ARM_VSUB_I|ARM_V_Q,r0,r1,r2) -#define _VSUB_I16(r0,r1,r2) arm_voddd(ARM_VSUB_I|ARM_V_I16,r0,r1,r2) -#define _VSUBQ_I16(r0,r1,r2) arm_voqqq(ARM_VSUB_I|ARM_V_I16|ARM_V_Q,r0,r1,r2) -#define _VSUB_I32(r0,r1,r2) arm_voddd(ARM_VSUB_I|ARM_V_I32,r0,r1,r2) -#define _VSUBQ_I32(r0,r1,r2) arm_voqqq(ARM_VSUB_I|ARM_V_I32|ARM_V_Q,r0,r1,r2) -#define _VSUB_I64(r0,r1,r2) arm_voddd(ARM_VSUB_I|ARM_V_I64,r0,r1,r2) -#define _VSUBQ_I64(r0,r1,r2) arm_voqqq(ARM_VSUB_I|ARM_V_I64|ARM_V_Q,r0,r1,r2) -#define _VQSUB_S8(r0,r1,r2) arm_voddd(ARM_VQSUB_I,r0,r1,r2) -#define _VQSUBQ_S8(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_Q,r0,r1,r2) -#define _VQSUB_U8(r0,r1,r2) arm_voddd(ARM_VQSUB_I|ARM_V_U,r0,r1,r2) -#define _VQSUBQ_U8(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VQSUB_S16(r0,r1,r2) arm_voddd(ARM_VQSUB_I|ARM_V_I16,r0,r1,r2) -#define _VQSUBQ_S16(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_I16|ARM_V_Q,r0,r1,r2) -#define _VQSUB_U16(r0,r1,r2) arm_voddd(ARM_VQSUB_I|ARM_V_I16|ARM_V_U,r0,r1,r2) -#define _VQSUBQ_U16(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_I16|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VQSUB_S32(r0,r1,r2) arm_voddd(ARM_VQSUB_I|ARM_V_I32,r0,r1,r2) -#define _VQSUBQ_S32(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_I32|ARM_V_Q,r0,r1,r2) -#define _VQSUB_U32(r0,r1,r2) arm_voddd(ARM_VQSUB_I|ARM_V_I32|ARM_V_U,r0,r1,r2) -#define _VQSUBQ_U32(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_I32|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VQSUB_S64(r0,r1,r2) arm_voddd(ARM_VQSUB_I|ARM_V_I64,r0,r1,r2) -#define _VQSUBQ_S64(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_I64|ARM_V_Q,r0,r1,r2) -#define _VQSUB_U64(r0,r1,r2) arm_voddd(ARM_VQSUB_I|ARM_V_I64|ARM_V_U,r0,r1,r2) -#define _VQSUBQ_U64(r0,r1,r2) arm_voqqq(ARM_VQSUB_I|ARM_V_I64|ARM_V_U|ARM_V_Q,r0,r1,r2) -#define _VSUBL_S8(r0,r1,r2) arm_voqdd(ARM_VSUBL_I,r0,r1,r2) -#define _VSUBL_U8(r0,r1,r2) arm_voqdd(ARM_VSUBL_I|ARM_V_U,r0,r1,r2) -#define _VSUBL_S16(r0,r1,r2) arm_voqdd(ARM_VSUBL_I|ARM_V_I16,r0,r1,r2) -#define _VSUBL_U16(r0,r1,r2) arm_voqdd(ARM_VSUBL_I|ARM_V_I16|ARM_V_U,r0,r1,r2) -#define _VSUBL_S32(r0,r1,r2) arm_voqdd(ARM_VSUBL_I|ARM_V_I32,r0,r1,r2) -#define _VSUBL_U32(r0,r1,r2) arm_voqdd(ARM_VSUBL_I|ARM_V_I32|ARM_V_U,r0,r1,r2) -#define _VSUBW_S8(r0,r1,r2) arm_voqqd(ARM_VSUBW_I,r0,r1,r2) -#define _VSUBW_U8(r0,r1,r2) arm_voqqd(ARM_VSUBW_I|ARM_V_U,r0,r1,r2) -#define _VSUBW_S16(r0,r1,r2) arm_voqqd(ARM_VSUBW_I|ARM_V_I16,r0,r1,r2) -#define _VSUBW_U16(r0,r1,r2) arm_voqqd(ARM_VSUBW_I|ARM_V_I16|ARM_V_U,r0,r1,r2) -#define _VSUBW_S32(r0,r1,r2) arm_voqqd(ARM_VSUBW_I|ARM_V_I32,r0,r1,r2) -#define _VSUBW_U32(r0,r1,r2) arm_voqqd(ARM_VSUBW_I|ARM_V_I32|ARM_V_U,r0,r1,r2) -#define _VMUL_I8(r0,r1,r2) arm_voddd(ARM_VMUL_I,r0,r1,r2) -#define _VMULQ_I8(r0,r1,r2) arm_voqqq(ARM_VMUL_I|ARM_V_Q,r0,r1,r2) -#define _VMUL_I16(r0,r1,r2) arm_voddd(ARM_VMUL_I|ARM_V_I16,r0,r1,r2) -#define _VMULQ_I16(r0,r1,r2) arm_voqqq(ARM_VMUL_I|ARM_V_Q|ARM_V_I16,r0,r1,r2) -#define _VMUL_I32(r0,r1,r2) arm_voddd(ARM_VMUL_I|ARM_V_I32,r0,r1,r2) -#define _VMULQ_I32(r0,r1,r2) arm_voqqq(ARM_VMUL_I|ARM_V_Q|ARM_V_I32,r0,r1,r2) -#define _VMULL_S8(r0,r1,r2) arm_voqdd(ARM_VMULL_I,r0,r1,r2) -#define _VMULL_U8(r0,r1,r2) arm_voqdd(ARM_VMULL_I|ARM_V_U,r0,r1,r2) -#define _VMULL_S16(r0,r1,r2) arm_voqdd(ARM_VMULL_I|ARM_V_I16,r0,r1,r2) -#define _VMULL_U16(r0,r1,r2) arm_voqdd(ARM_VMULL_I|ARM_V_U|ARM_V_I16,r0,r1,r2) -#define _VMULL_S32(r0,r1,r2) arm_voqdd(ARM_VMULL_I|ARM_V_I32,r0,r1,r2) -#define _VMULL_U32(r0,r1,r2) arm_voqdd(ARM_VMULL_I|ARM_V_U|ARM_V_I32,r0,r1,r2) -#define _VABS_S8(r0,r1) arm_vo_dd(ARM_VABS_I,r0,r1) -#define _VABSQ_S8(r0,r1) arm_vo_qq(ARM_VABS_I|ARM_V_Q,r0,r1) -#define _VABS_S16(r0,r1) arm_vo_dd(ARM_VABS_I|ARM_V_S16,r0,r1) -#define _VABSQ_S16(r0,r1) arm_vo_qq(ARM_VABS_I|ARM_V_S16|ARM_V_Q,r0,r1) -#define _VABS_S32(r0,r1) arm_vo_dd(ARM_VABS_I|ARM_V_S32,r0,r1) -#define _VABSQ_S32(r0,r1) arm_vo_qq(ARM_VABS_I|ARM_V_S32|ARM_V_Q,r0,r1) -#define _VQABS_S8(r0,r1) arm_vo_dd(ARM_VQABS_I,r0,r1) -#define _VQABSQ_S8(r0,r1) arm_vo_qq(ARM_VQABS_I|ARM_V_Q,r0,r1) -#define _VQABS_S16(r0,r1) arm_vo_dd(ARM_VQABS_I|ARM_V_S16,r0,r1) -#define _VQABSQ_S16(r0,r1) arm_vo_qq(ARM_VQABS_I|ARM_V_S16|ARM_V_Q,r0,r1) -#define _VQABS_S32(r0,r1) arm_vo_dd(ARM_VQABS_I|ARM_V_S32,r0,r1) -#define _VQABSQ_S32(r0,r1) arm_vo_qq(ARM_VQABS_I|ARM_V_S32|ARM_V_Q,r0,r1) -#define _VNEG_S8(r0,r1) arm_vo_dd(ARM_VNEG_I,r0,r1) -#define _VNEGQ_S8(r0,r1) arm_vo_qq(ARM_VNEG_I|ARM_V_Q,r0,r1) -#define _VNEG_S16(r0,r1) arm_vo_dd(ARM_VNEG_I|ARM_V_S16,r0,r1) -#define _VNEGQ_S16(r0,r1) arm_vo_qq(ARM_VNEG_I|ARM_V_S16|ARM_V_Q,r0,r1) -#define _VNEG_S32(r0,r1) arm_vo_dd(ARM_VNEG_I|ARM_V_S32,r0,r1) -#define _VNEGQ_S32(r0,r1) arm_vo_qq(ARM_VNEG_I|ARM_V_S32|ARM_V_Q,r0,r1) -#define _VQNEG_S8(r0,r1) arm_vo_dd(ARM_VQNEG_I,r0,r1) -#define _VQNEGQ_S8(r0,r1) arm_vo_qq(ARM_VQNEG_I|ARM_V_Q,r0,r1) -#define _VQNEG_S16(r0,r1) arm_vo_dd(ARM_VQNEG_I|ARM_V_S16,r0,r1) -#define _VQNEGQ_S16(r0,r1) arm_vo_qq(ARM_VQNEG_I|ARM_V_S16|ARM_V_Q,r0,r1) -#define _VQNEG_S32(r0,r1) arm_vo_dd(ARM_VQNEG_I|ARM_V_S32,r0,r1) -#define _VQNEGQ_S32(r0,r1) arm_vo_qq(ARM_VQNEG_I|ARM_V_S32|ARM_V_Q,r0,r1) -#define _VAND(r0,r1,r2) arm_voddd(ARM_VAND,r0,r1,r2) -#define _VANDQ(r0,r1,r2) arm_voqqq(ARM_VAND|ARM_V_Q,r0,r1,r2) -#define _VBIC(r0,r1,r2) arm_voddd(ARM_VBIC,r0,r1,r2) -#define _VBICQ(r0,r1,r2) arm_voqqq(ARM_VBIC|ARM_V_Q,r0,r1,r2) -#define _VORR(r0,r1,r2) arm_voddd(ARM_VORR,r0,r1,r2) -#define _VORRQ(r0,r1,r2) arm_voqqq(ARM_VORR|ARM_V_Q,r0,r1,r2) -#define _VORN(r0,r1,r2) arm_voddd(ARM_VORN,r0,r1,r2) -#define _VORNQ(r0,r1,r2) arm_voqqq(ARM_VORN|ARM_V_Q,r0,r1,r2) -#define _VEOR(r0,r1,r2) arm_voddd(ARM_VEOR,r0,r1,r2) -#define _VEORQ(r0,r1,r2) arm_voqqq(ARM_VEOR|ARM_V_Q,r0,r1,r2) -#define _VMOV(r0,r1) _VORR(r0,r1,r1) -#define _VMOVQ(r0,r1) _VORRQ(r0,r1,r1) -#define _VMOVL_S8(r0,r1) arm_vo_qd(ARM_VMOVL_I|ARM_VMOVL_S8,r0,r1) -#define _VMOVL_U8(r0,r1) arm_vo_qd(ARM_VMOVL_I|ARM_V_U|ARM_VMOVL_S8,r0,r1) -#define _VMOVL_S16(r0,r1) arm_vo_qd(ARM_VMOVL_I|ARM_VMOVL_S16,r0,r1) -#define _VMOVL_U16(r0,r1) arm_vo_qd(ARM_VMOVL_I|ARM_V_U|ARM_VMOVL_S16,r0,r1) -#define _VMOVL_S32(r0,r1) arm_vo_qd(ARM_VMOVL_I|ARM_VMOVL_S32,r0,r1) -#define _VMOVL_U32(r0,r1) arm_vo_qd(ARM_VMOVL_I|ARM_V_U|ARM_VMOVL_S32,r0,r1) -/* "oi" should be the result of encode_vfp_double */ -#define _VIMM(oi,r0) arm_vodi(oi,r0) -#define _VIMMQ(oi,r0) arm_voqi(oi|ARM_V_Q,r0) -/* index is multipled by four */ -#define _CC_VLDRN_F32(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VLDR,r0,r1,i0) -#define _VLDRN_F32(r0,r1,i0) _CC_VLDRN_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDR_F32(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VLDR|ARM_P,r0,r1,i0) -#define _VLDR_F32(r0,r1,i0) _CC_VLDR_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDRN_F64(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VLDR|ARM_V_F64,r0,r1,i0) -#define _VLDRN_F64(r0,r1,i0) _CC_VLDRN_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VLDR_F64(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VLDR|ARM_V_F64|ARM_P,r0,r1,i0) -#define _VLDR_F64(r0,r1,i0) _CC_VLDR_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTRN_F32(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VSTR,r0,r1,i0) -#define _VSTRN_F32(r0,r1,i0) _CC_VSTRN_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTR_F32(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VSTR|ARM_P,r0,r1,i0) -#define _VSTR_F32(r0,r1,i0) _CC_VSTR_F32(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTRN_F64(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VSTR|ARM_V_F64,r0,r1,i0) -#define _VSTRN_F64(r0,r1,i0) _CC_VSTRN_F64(ARM_CC_AL,r0,r1,i0) -#define _CC_VSTR_F64(cc,r0,r1,i0) arm_cc_vldst(cc,ARM_VSTR|ARM_V_F64|ARM_P,r0,r1,i0) -#define _VSTR_F64(r0,r1,i0) _CC_VSTR_F64(ARM_CC_AL,r0,r1,i0) - -/* from binutils */ -#define rotate_left(v, n) (v << n | v >> (32 - n)) -static int -encode_arm_immediate(unsigned int v) -{ - unsigned int a, i; - - for (i = 0; i < 32; i += 2) - if ((a = rotate_left(v, i)) <= 0xff) - return (a | (i << 7)); - - return (-1); -} - -#define corrr(cc,o,rn,rd,rm) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00fff0f)), \ - _jit_I((cc)|(o)|(_u4(rn)<<16)|(_u4(rd)<<12)|_u4(rm))) - -#define corri(cc,o,rn,rd,im) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00fffff) && !((im) & 0xfffff000)), \ - _jit_I((cc)|(o)|(_u4(rn)<<16)|(_u4(rd)<<12)|_u12(im))) - -#define coriw(cc,o,rd,im) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00fffff) && !(im & 0xffff0000)), \ - _jit_I((cc)|(o)|((im&0xf000)<<4)|(_u4(rd)<<12)|(im&0xfff))) - -#define corri8(cc,o,rn,rt,im) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00fff0f) && !(im & 0xffffff00)), \ - _jit_I((cc)|(o)|(_u4(rn)<<16)|(_u4(rt)<<12)|((im&0xf0)<<4)|(im&0x0f))) - -#define corrrr(cc,o,rh,rl,rm,rn) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00fff0f)), \ - _jit_I((cc)|(o)|(_u4(rh)<<16)|(_u4(rl)<<12)|(_u4(rm)<<8)|_u4(rn))) - -#define corrrs(cc,o,rn,rd,rm,im) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000ff8f)), \ - _jit_I((cc)|(o)|(_u4(rd)<<12)|(_u4(rn)<<16)|(im<<7)|_u4(rm))) - -#define cshift(cc,o,rd,rm,rn,im) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xffe0ff8f) && ((_u4(rm)<<8)&(im<<7)) == 0), \ - _jit_I((cc)|ARM_SHIFT|(o)|(_u4(rd)<<12)|(_u4(rm)<<8)|(im<<7)|_u4(rn))) - -#define cb(cc,o,im) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf0ffffff)), \ - _jit_I((cc)|(o)|_u24(im))) - -#define cbx(cc,o,rm) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000000f)), \ - _jit_I((cc)|(o)|_u4(rm))) - -#define corl(cc,o,r0,i0) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00fffff)), \ - _jit_I((cc)|(o)|(_u4(r0)<<16)|_u16(i0))) - -#define c6orr(cc,o,rd,rm) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf000f00f)), \ - _jit_I((cc)|(o)|(_u4(rd)<<12)|_u4(rm))) - -#define arm_cc_pkh(cc,o,rn,rd,rm,im) \ - (assert(!((cc) & 0x0fffffff) && !((o) & 0xf00ff00f)), \ - _jit_I((cc)|(o)|(_u4(rn)<<16)|(_u4(rd)<<12)|(_u5(im)<<7)|_u4(rm))) - - -#define _CC_MOV(cc,rd,rm) corrr(cc,ARM_MOV,0,rd,rm) -#define _MOV(rd,rm) _CC_MOV(ARM_CC_AL,rd,rm) -#define T1_MOV(rd,rm) _jit_W(THUMB_MOV|((_u4(rd)&8)<<4)|(_u4(rm)<<3)|(rd&7)) -#define T2_MOV(rd,rm) T2_ORR(rd,_R15,rm) -#define _CC_MOVI(cc,rd,im) corri(cc,ARM_MOV|ARM_I,0,rd,im) -#define _MOVI(rd,im) _CC_MOVI(ARM_CC_AL,rd,im) -#define _CC_MOVWI(cc,rd,im) coriw(cc,ARM_MOVWI,rd,im) -#define _MOVWI(rd,im) _CC_MOVWI(ARM_CC_AL,rd,im) -#define T1_MOVI(rd,im) _jit_W(THUMB_MOVI|(_u3(rd)<<8)|_u8(im)) -#define T2_MOVI(rd,im) torri(THUMB2_MOVI,_R15,rd,im) -#define T2_MOVWI(rd,im) toriw(THUMB2_MOVWI,rd,im) -#define _CC_MOVTI(cc,rd,im) coriw(cc,ARM_MOVTI,rd,im) -#define _MOVTI(rd,im) _CC_MOVTI(ARM_CC_AL,rd,im) -#define T2_MOVTI(rd,im) toriw(THUMB2_MOVTI,rd,im) -#define _CC_MVN(cc,rd,rm) corrr(cc,ARM_MVN,0,rd,rm) -#define _MVN(rd,rm) _CC_MVN(ARM_CC_AL,rd,rm) -#define T1_MVN(rd,rm) _jit_W(THUMB_MVN|(_u3(rm)<<3)|_u3(rd)) -#define T2_MVN(rd,rm) torrr(THUMB2_MVN,rd,_R15,rm) -#define _CC_MVNI(cc,rd,im) corri(cc,ARM_MVN|ARM_I,0,rd,im) -#define _MVNI(rd,im) _CC_MVNI(ARM_CC_AL,rd,im) -#define T2_MVNI(rd,im) torri(THUMB2_MVNI,_R15,rd,im) -#define _CC_NOT(cc,rd,rm) _CC_MVN(cc,rd,rm) -#define _NOT(rd,rm) _CC_NOT(ARM_CC_AL,rd,rm) -#define T1_NOT(rd,rm) T1_MVN(rd,rm) -#define T2_NOT(rd,rm) T2_MVN(rd,rm) -#define _NOP() _MOV(_R0, _R0) -#define T1_NOP() _jit_W(0xbf00) - -#define _CC_ADD(cc,rd,rn,rm) corrr(cc,ARM_ADD,rn,rd,rm) -#define _ADD(rd,rn,rm) _CC_ADD(ARM_CC_AL,rd,rn,rm) -#define T1_ADD(rd,rn,rm) _jit_W(THUMB_ADD|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rd)) -#define T1_ADDX(rdn,rm) _jit_W(THUMB_ADDX|((_u4(rdn)&8)<<4)|(_u4(rm)<<3)|(rdn&7)) -#define T2_ADD(rd,rn,rm) torrr(THUMB2_ADD,rn,rd,rm) -#define _CC_ADDI(cc,rd,rn,im) corri(cc,ARM_ADD|ARM_I,rn,rd,im) -#define _ADDI(rd,rn,im) _CC_ADDI(ARM_CC_AL,rd,rn,im) -#define T1_ADDI3(rd,rn,im) _jit_W(THUMB_ADDI3|(_u3(im)<<6)|(_u3(rn)<<3)|_u3(rd)) -#define T1_ADDI8(rdn,im) _jit_W(THUMB_ADDI8|(_u3(rdn)<<8)|_u8(im)) -#define T2_ADDI(rd,rn,im) torri(THUMB2_ADDI,rn,rd,im) -#define T2_ADDWI(rd,rn,im) torri(THUMB2_ADDWI,rn,rd,im) -#define _CC_ADDS(cc,rd,rn,rm) corrr(cc,ARM_ADD|ARM_S,rn,rd,rm) -#define _ADDS(rd,rn,rm) _CC_ADDS(ARM_CC_AL,rd,rn,rm) -#define T2_ADDS(rd,rn,rm) torrr(THUMB2_ADD|ARM_S,rn,rd,rm) -#define _ADDSI(rd,rn,im) corri(ARM_CC_AL,ARM_ADD|ARM_S|ARM_I,rn,rd,im) -#define T2_ADDSI(rd,rn,im) torri(THUMB2_ADDI|ARM_S,rn,rd,im) -#define _CC_ADC(cc,rd,rn,rm) corrr(cc,ARM_ADC,rn,rd,rm) -#define _ADC(rd,rn,rm) _CC_ADC(ARM_CC_AL,rd,rn,rm) -#define T1_ADC(rdn,rm) _jit_W(THUMB_ADC|(_u3(rm)<<3)|_u3(rdn)) -#define T2_ADC(rd,rn,rm) torrr(THUMB2_ADC,rn,rd,rm) -#define _CC_ADCI(cc,rd,rn,im) corri(cc,ARM_ADC|ARM_I,rn,rd,im) -#define _ADCI(rd,rn,im) _CC_ADCI(ARM_CC_AL,rd,rn,im) -#define T2_ADCI(rd,rn,im) torri(THUMB2_ADCI,rn,rd,im) -#define _CC_ADCS(cc,rd,rn,rm) corrr(cc,ARM_ADC|ARM_S,rn,rd,rm) -#define _ADCS(rd,rn,rm) _CC_ADCS(ARM_CC_AL,rd,rn,rm) -#define T2_ADCS(rd,rn,rm) torrr(THUMB2_ADC|ARM_S,rn,rd,rm) -#define _CC_ADCSI(cc,rd,rn,im) corri(cc,ARM_ADC|ARM_S|ARM_I,rn,rd,im) -#define _ADCSI(rd,rn,im) _CC_ADCSI(ARM_CC_AL,rd,rn,im) -#define T2_ADCSI(rd,rn,im) torri(THUMB2_ADCI|ARM_S,rn,rd,im) -#define _CC_SUB(cc,rd,rn,rm) corrr(cc,ARM_SUB,rn,rd,rm) -#define _SUB(rd,rn,rm) _CC_SUB(ARM_CC_AL,rd,rn,rm) -#define T1_SUB(rd,rn,rm) _jit_W(THUMB_SUB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rd)) -#define T2_SUB(rd,rn,rm) torrr(THUMB2_SUB,rn,rd,rm) -#define _CC_SUBI(cc,rd,rn,im) corri(cc,ARM_SUB|ARM_I,rn,rd,im) -#define _SUBI(rd,rn,im) _CC_SUBI(ARM_CC_AL,rd,rn,im) -#define T1_SUBI3(rd,rn,im) _jit_W(THUMB_SUBI3|(_u3(im)<<6)|(_u3(rn)<<3)|_u3(rd)) -#define T1_SUBI8(rdn,im) _jit_W(THUMB_SUBI8|(_u3(rdn)<<8)|_u8(im)) -#define T2_SUBI(rd,rn,im) torri(THUMB2_SUBI,rn,rd,im) -#define T2_SUBWI(rd,rn,im) torri(THUMB2_SUBWI,rn,rd,im) -#define _CC_SUBS(cc,rd,rn,rm) corrr(cc,ARM_SUB|ARM_S,rn,rd,rm) -#define _SUBS(rd,rn,rm) _CC_SUBS(ARM_CC_AL,rd,rn,rm) -#define T2_SUBS(rd,rn,rm) torrr(THUMB2_SUB|ARM_S,rn,rd,rm) -#define _CC_SUBSI(cc,rd,rn,im) corri(cc,ARM_SUB|ARM_S|ARM_I,rn,rd,im) -#define _SUBSI(rd,rn,im) _CC_SUBSI(ARM_CC_AL,rd,rn,im) -#define T2_SUBSI(rd,rn,im) torri(THUMB2_SUBI|ARM_S,rn,rd,im) -#define _CC_SBC(cc,rd,rn,rm) corrr(cc,ARM_SBC,rn,rd,rm) -#define _SBC(rd,rn,rm) _CC_SBC(ARM_CC_AL,rd,rn,rm) -#define T1_SBC(rdn,rm) _jit_W(THUMB_SBC|(_u3(rm)<<3)|_u3(rdn)) -#define T2_SBC(rd,rn,rm) torrr(THUMB2_SBC,rn,rd,rm) -#define _CC_SBCI(cc,rd,rn,im) corri(cc,ARM_SBC|ARM_I,rn,rd,im) -#define _SBCI(rd,rn,im) _CC_SBCI(ARM_CC_AL,rd,rn,im) -#define T2_SBCI(rd,rn,im) torri(THUMB2_SBCI,rn,rd,im) -#define _CC_SBCS(cc,rd,rn,rm) corrr(cc,ARM_SBC|ARM_S,rn,rd,rm) -#define _SBCS(rd,rn,rm) _CC_SBCS(ARM_CC_AL,rd,rn,rm) -#define T2_SBCS(rd,rn,rm) torrr(THUMB2_SBC|ARM_S,rn,rd,rm) -#define _CC_SBCSI(cc,rd,rn,im) corri(cc,ARM_SBC|ARM_S|ARM_I,rn,rd,im) -#define _SBCSI(rd,rn,im) _CC_SBCSI(ARM_CC_AL,rd,rn,im) -#define T2_SBCSI(rd,rn,im) torri(THUMB2_SBCI|ARM_S,rn,rd,im) -#define _CC_RSB(cc,rd,rn,rm) corrr(cc,ARM_RSB,rn,rd,rm) -#define _RSB(rd,rn,rm) _CC_RSB(ARM_CC_AL,rd,rn,rm) -#define T2_RSB(rd,rn,rm) torrr(THUMB2_RSB,rn,rd,rm) -#define _CC_RSBI(cc,rd,rn,im) corri(cc,ARM_RSB|ARM_I,rn,rd,im) -#define _RSBI(rd,rn,im) _CC_RSBI(ARM_CC_AL,rd,rn,im) -#define T1_RSBI(rd,rn) _jit_W(THUMB_RSBI|(_u3(rn)<<3)|_u3(rd)) -#define T2_RSBI(rd,rn,im) torri(THUMB2_RSBI,rn,rd,im) - -#define _CC_MUL(cc,rl,rn,rm) corrrr(cc,ARM_MUL,rl,0,rm,rn) -#define _MUL(rl,rn,rm) _CC_MUL(ARM_CC_AL,rl,rn,rm) -#define T1_MUL(rdm,rn) _jit_W(THUMB_MUL|(_u3(rn)<<3)|_u3(rdm)) -#define T2_MUL(rd,rn,rm) torrr(THUMB2_MUL,rn,rd,rm) -#define _CC_SMULL(cc,rl,rh,rn,rm) corrrr(cc,ARM_SMULL,rh,rl,rm,rn) -#define _SMULL(rl,rh,rn,rm) _CC_SMULL(ARM_CC_AL,rl,rh,rn,rm) -#define T2_SMULL(rl,rh,rn,rm) torrrr(THUMB2_SMULL,rn,rl,rh,rm) -#define _CC_UMULL(cc,rl,rh,rn,rm) corrrr(cc,ARM_UMULL,rh,rl,rm,rn) -#define _UMULL(rl,rh,rn,rm) _CC_UMULL(ARM_CC_AL,rl,rh,rn,rm) -#define T2_UMULL(rl,rh,rn,rm) torrrr(THUMB2_UMULL,rn,rl,rh,rm) -#define T2_SDIV(rd,rn,rm) torrr(THUMB2_SDIV,rn,rd,rm) -#define T2_UDIV(rd,rn,rm) torrr(THUMB2_UDIV,rn,rd,rm) - -#define _CC_AND(cc,rd,rn,rm) corrr(cc,ARM_AND,rn,rd,rm) -#define _AND(rd,rn,rm) _CC_AND(ARM_CC_AL,rd,rn,rm) -#define T1_AND(rdn,rm) _jit_W(THUMB_AND|(_u3(rm)<<3)|_u3(rdn)) -#define T2_AND(rd,rn,rm) torrr(THUMB2_AND,rn,rd,rm) -#define _CC_ANDI(cc,rd,rn,im) corri(cc,ARM_AND|ARM_I,rn,rd,im) -#define _ANDI(rd,rn,im) _CC_ANDI(ARM_CC_AL,rd,rn,im) -#define T2_ANDI(rd,rn,im) torri(THUMB2_ANDI,rn,rd,im) -#define _CC_ANDS(cc,rd,rn,rm) corrr(cc,ARM_AND|ARM_S,rn,rd,rm) -#define _ANDS(rd,rn,rm) _CC_ANDS(ARM_CC_AL,rd,rn,rm) -#define T2_ANDS(rd,rn,rm) torrr(THUMB2_AND|ARM_S,rn,rd,rm) -#define _CC_ANDSI(cc,rd,rn,im) corri(cc,ARM_AND|ARM_S|ARM_I,rn,rd,im) -#define _ANDSI(rd,rn,im) _CC_ANDSI(ARM_CC_AL,rd,rn,im) -#define T2_ANDSI(rd,rn,im) torri(ARM_CC_AL,THUMB2_ANDI|ARM_S,rn,rd,im) -#define _CC_BIC(cc,rd,rn,rm) corrr(cc,ARM_BIC,rn,rd,rm) -#define _BIC(rd,rn,rm) _CC_BIC(ARM_CC_AL,rd,rn,rm) -#define T2_BIC(rd,rn,rm) torrr(THUMB2_BIC,rn,rd,rm) -#define _CC_BICI(cc,rd,rn,im) corri(cc,ARM_BIC|ARM_I,rn,rd,im) -#define _BICI(rd,rn,im) _CC_BICI(ARM_CC_AL,rd,rn,im) -#define T2_BICI(rd,rn,im) torri(THUMB2_BICI,rn,rd,im) -#define _CC_BICS(cc,rd,rn,rm) corrr(cc,ARM_BIC|ARM_S,rn,rd,rm) -#define _BICS(rd,rn,rm) _CC_BICS(ARM_CC_AL,rd,rn,rm) -#define T2_BICS(rd,rn,rm) torrr(THUMB2_BIC|ARM_S,rn,rd,rm) -#define _CC_BICSI(cc,rd,rn,im) corri(cc,ARM_BIC|ARM_S|ARM_I,rn,rd,im) -#define _BICSI(rd,rn,im) _CC_BICSI(ARM_CC_AL,rd,rn,im) -#define T2_BICSI(rd,rn,im) torri(ARM_CC_AL,THUMB2_BICI|ARM_S,rn,rd,im) -#define _CC_ORR(cc,rd,rn,rm) corrr(cc,ARM_ORR,rn,rd,rm) -#define _ORR(rd,rn,rm) _CC_ORR(ARM_CC_AL,rd,rn,rm) -#define T1_ORR(rdn,rm) _jit_W(THUMB_ORR|(_u3(rm)<<3)|_u3(rdn)) -#define T2_ORR(rd,rn,rm) torrr(THUMB2_ORR,rn,rd,rm) -#define _CC_ORR_SI(cc,rd,rn,rm,sh,im) \ - corrrs(cc,ARM_ORR|sh,rn,rd,rm,im) -#define _ORR_SI(rd,rn,rm,sh,im) _CC_ORR_SI(ARM_CC_AL,rd,rn,rm,sh,im) -#define _CC_ORRI(cc,rd,rn,im) corri(cc,ARM_ORR|ARM_I,rn,rd,im) -#define _ORRI(rd,rn,im) _CC_ORRI(ARM_CC_AL,rd,rn,im) -#define T2_ORRI(rd,rn,im) torri(THUMB2_ORRI,rn,rd,im) -#define _CC_EOR(cc,rd,rn,rm) corrr(cc,ARM_EOR,rn,rd,rm) -#define _EOR(rd,rn,rm) _CC_EOR(ARM_CC_AL,rd,rn,rm) -#define T1_EOR(rdn,rm) _jit_W(THUMB_EOR|(_u3(rm)<<3)|_u3(rdn)) -#define T2_EOR(rd,rn,rm) torrr(THUMB2_EOR,rn,rd,rm) -#define _CC_EOR_SI(cc,rd,rn,rm,sh,im) \ - corrrs(cc,ARM_EOR|sh,rn,rd,rm,im) -#define _EOR_SI(rd,rn,rm,sh,im) _CC_EOR_SI(ARM_CC_AL,rd,rn,rm,sh,im) -#define _CC_EORI(cc,rd,rn,im) corri(cc,ARM_EOR|ARM_I,rn,rd,im) -#define _EORI(rd,rn,im) _CC_EORI(ARM_CC_AL,rd,rn,im) -#define T2_EORI(rd,rn,im) torri(THUMB2_EORI,rn,rd,im) - -#define _CC_REV(cc,rd,rm) c6orr(cc,ARM_REV,rd,rm) -#define _REV(rd,rm) _CC_REV(ARM_CC_AL,rd,rm) -#define T1_REV(rd,rm) _jit_W(THUMB_REV|(_u3(rm)<<3)|_u3(rd)) -#define T2_REV(rd,rm) torrr(THUMB2_REV,rm,rd,rm) -#define _CC_REV16(cc,rd,rm) c6orr(cc,ARM_REV16,rd,rm) -#define _REV16(rd,rm) _CC_REV16(ARM_CC_AL,rd,rm) -#define T1_REV16(rd,rm) _jit_W(THUMB_REV16|(_u3(rm)<<3)|_u3(rd)) -#define T2_REV16(rd,rm) torrr(THUMB2_REV16,rm,rd,rm) -#define _CC_SXTB(cc,rd,rm) c6orr(cc,ARM_SXTB,rd,rm) -#define _SXTB(rd,rm) _CC_SXTB(ARM_CC_AL,rd,rm) -#define T1_SXTB(rd,rm) _jit_W(THUMB_SXTB|(_u3(rm)<<3)|_u3(rd)) -#define T2_SXTB(rd,rm) torrr(THUMB2_SXTB,_R15,rd,rm) -#define _CC_UXTB(cc,rd,rm) c6orr(cc,ARM_UXTB,rd,rm) -#define _UXTB(rd,rm) _CC_UXTB(ARM_CC_AL,rd,rm) -#define T1_UXTB(rd,rm) _jit_W(THUMB_UXTB|(_u3(rm)<<3)|_u3(rd)) -#define T2_UXTB(rd,rm) torrr(THUMB2_UXTB,_R15,rd,rm) -#define _CC_SXTH(cc,rd,rm) c6orr(cc,ARM_SXTH,rd,rm) -#define _SXTH(rd,rm) _CC_SXTH(ARM_CC_AL,rd,rm) -#define T1_SXTH(rd,rm) _jit_W(THUMB_SXTH|(_u3(rm)<<3)|_u3(rd)) -#define T2_SXTH(rd,rm) torrr(THUMB2_SXTH,_R15,rd,rm) -#define _CC_UXTH(cc,rd,rm) c6orr(cc,ARM_UXTH,rd,rm) -#define _UXTH(rd,rm) _CC_UXTH(ARM_CC_AL,rd,rm) -#define T1_UXTH(rd,rm) _jit_W(THUMB_UXTH|(_u3(rm)<<3)|_u3(rd)) -#define T2_UXTH(rd,rm) torrr(THUMB2_UXTH,_R15,rd,rm) - -#define _CC_SHIFT(cc,o,rd,rm,rn,im) cshift(cc,o,rd,rm,rn,im) -#define _CC_LSL(cc,rd,rn,rm) _CC_SHIFT(cc,ARM_LSL|ARM_R,rd,rm,rn,0) -#define _LSL(rd,rn,rm) _CC_LSL(ARM_CC_AL,rd,rn,rm) -#define T1_LSL(rdn,rm) _jit_W(THUMB_LSL|(_u3(rm)<<3)|_u3(rdn)) -#define T2_LSL(rd,rn,rm) torrr(THUMB2_LSL,rn,rd,rm) -#define _CC_LSLI(cc,rd,rn,im) _CC_SHIFT(cc,ARM_LSL,rd,0,rn,im) -#define _LSLI(rd,rn,im) _CC_LSLI(ARM_CC_AL,rd,rn,im) -#define T1_LSLI(rd,rm,im) _jit_W(THUMB_LSLI|(_u5(im)<<6)|(_u3(rm)<<3)|_u3(rd)) -#define T2_LSLI(rd,rm,im) tshift(THUMB2_LSLI,rd,rm,im) -#define _CC_LSR(cc,rd,rn,rm) _CC_SHIFT(cc,ARM_LSR|ARM_R,rd,rm,rn,0) -#define _LSR(rd,rn,rm) _CC_LSR(ARM_CC_AL,rd,rn,rm) -#define T1_LSR(rdn,rm) _jit_W(THUMB_LSR|(_u3(rm)<<3)|_u3(rdn)) -#define T2_LSR(rd,rn,rm) torrr(THUMB2_LSR,rn,rd,rm) -#define _CC_LSRI(cc,rd,rn,im) _CC_SHIFT(cc,ARM_LSR,rd,0,rn,im) -#define _LSRI(rd,rn,im) _CC_LSRI(ARM_CC_AL,rd,rn,im) -#define T1_LSRI(rd,rm,im) _jit_W(THUMB_LSRI|(_u5(im)<<6)|(_u3(rm)<<3)|_u3(rd)) -#define T2_LSRI(rd,rm,im) tshift(THUMB2_LSRI,rd,rm,im) -#define _CC_ASR(cc,rd,rn,rm) _CC_SHIFT(cc,ARM_ASR|ARM_R,rd,rm,rn,0) -#define _ASR(rd,rn,rm) _CC_ASR(ARM_CC_AL,rd,rn,rm) -#define T1_ASR(rdn,rm) _jit_W(THUMB_ASR|(_u3(rm)<<3)|_u3(rdn)) -#define T2_ASR(rd,rn,rm) torrr(THUMB2_ASR,rn,rd,rm) -#define _CC_ASRI(cc,rd,rn,im) _CC_SHIFT(cc,ARM_ASR,rd,0,rn,im) -#define _ASRI(rd,rn,im) _CC_ASRI(ARM_CC_AL,rd,rn,im) -#define T1_ASRI(rd,rm,im) _jit_W(THUMB_ASRI|(_u5(im)<<6)|(_u3(rm)<<3)|_u3(rd)) -#define T2_ASRI(rd,rm,im) tshift(THUMB2_ASRI,rd,rm,im) - -#define _CC_CMP(cc,rn,rm) corrr(cc,ARM_CMP,rn,0,rm) -#define _CMP(rn,rm) _CC_CMP(ARM_CC_AL,rn,rm) -#define T1_CMP(rn,rm) _jit_W(THUMB_CMP|(_u3(rm)<<3)|_u3(rn)) -#define T1_CMPX(rn,rm) _jit_W(THUMB_CMPX|((_u4(rn)&8)<<4)|(_u4(rm)<<3)|(rn&7)) -#define T2_CMP(rn,rm) torrr(THUMB2_CMP,rn,_R15,rm) -#define _CC_CMPI(cc,rn,im) corri(cc,ARM_CMP|ARM_I,rn,0,im) -#define _CMPI(rn,im) _CC_CMPI(ARM_CC_AL,rn,im) -#define T1_CMPI(rn,im) _jit_W(THUMB_CMPI|(_u3(rn)<<8)|_u8(im)) -#define T2_CMPI(rn,im) torri(THUMB2_CMPI,rn,_R15,im) -#define _CC_CMN(cc,rn,rm) corrr(cc,ARM_CMN,rn,0,rm) -#define _CMN(rn,rm) _CC_CMN(ARM_CC_AL,rn,rm) -#define T1_CMN(rn,rm) _jit_W(THUMB_CMN|(_u3(rm)<<3)|_u3(rm)) -#define T2_CMN(rn,rm) torrr(THUMB2_CMN,rn,_R15,rm) -#define _CC_CMNI(cc,rn,im) corri(cc,ARM_CMN|ARM_I,rn,_R15,im) -#define _CMNI(rn,im) _CC_CMNI(ARM_CC_AL,rn,im) -#define T2_CMNI(rn,im) torri(THUMB2_CMNI,rn,_R15,im) -#define _CC_TST(cc,rn,rm) corrr(cc,ARM_TST,rn,r0,rm) -#define _TST(rn,rm) _CC_TST(ARM_CC_AL,rn,rm) -#define T1_TST(rn,rm) _jit_W(THUMB_TST|(_u3(rm)<<3)|_u3(rn)) -#define T2_TST(rn,rm) torrr(THUMB2_TST,rn,_R15,rm) -#define _CC_TSTI(cc,rn,im) corri(cc,ARM_TST|ARM_I,rn,0,im) -#define _TSTI(rn,im) _CC_TSTI(ARM_CC_AL,rn,im) -#define T2_TSTI(rn,im) torri(THUMB2_TSTI,rn,_R15,im) -#define _CC_TEQ(cc,rn,rm) corrr(cc,ARM_TEQ,rn,0,rm) -#define _TEQ(rn,rm) _CC_TEQ(ARM_CC_AL,rn,rm) -#define _CC_TEQI(cc,rm,im) corri(cc,ARM_TEQ|ARM_I,rn,0,im) -#define _TEQI(rn,im) _CC_TEQI(ARM_CC_AL,rn,im) - -#define _CC_BX(cc,rm) cbx(cc,ARM_BX,rm) -#define _BX(rm) _CC_BX(ARM_CC_AL,rm) -#define T1_BX(rm) _jit_W(0x4700|(_u4(rm)<<3)) -#define _CC_BLX(cc,rm) cbx(cc,ARM_BLX,rm) -#define _BLX(rm) _CC_BLX(ARM_CC_AL,rm) -#define T1_BLX(rm) _jit_W(THUMB_BLX|(_u4(rm)<<3)) -#define _BLXI(im) blxi(im) -#define T2_BLXI(im) tb(THUMB2_BLXI,im) -#define _CC_B(cc,im) cb(cc,ARM_B,im) -#define _B(im) _CC_B(ARM_CC_AL,im) -#define T1_CC_B(cc,im) tc8(cc,im) -#define T1_B(im) t11(im) -#define T2_CC_B(cc,im) tcb(cc,im) -#define T2_B(im) tb(THUMB2_B,im) -#define _CC_BLI(cc,im) cb(cc,ARM_BLI,im) -#define _BLI(im) _CC_BLI(ARM_CC_AL,im) -#define T2_BLI(im) tb(THUMB2_BLI,im) - -#define _CC_LDRSB(cc,rt,rn,rm) corrr(cc,ARM_LDRSB|ARM_P,rn,rt,rm) -#define _LDRSB(rt,rn,rm) _CC_LDRSB(ARM_CC_AL,rt,rn,rm) -#define T1_LDRSB(rt,rn,rm) _jit_W(THUMB_LDRSB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_LDRSB(rt,rn,rm) torxr(THUMB2_LDRSB,rn,rt,rm) -#define _CC_LDRSBN(cc,rt,rn,rm) corrr(cc,ARM_LDRSB,rn,rt,rm) -#define _LDRSBN(rt,rn,rm) _CC_LDRSBN(ARM_CC_AL,rt,rn,rm) -#define _CC_LDRSBI(cc,rt,rn,im) corri8(cc,ARM_LDRSBI|ARM_P,rn,rt,im) -#define _LDRSBI(rt,rn,im) _CC_LDRSBI(ARM_CC_AL,rt,rn,im) -#define T2_LDRSBI(rt,rn,im) torri8(THUMB2_LDRSBI|THUMB2_U,rn,rt,im) -#define T2_LDRSBWI(rt,rn,im) torri12(THUMB2_LDRSBWI,rn,rt,im) -#define _CC_LDRSBIN(cc,rt,rn,im) corri8(cc,ARM_LDRSBI,rn,rt,im) -#define _LDRSBIN(rt,rn,im) _CC_LDRSBIN(ARM_CC_AL,rt,rn,im) -#define T2_LDRSBIN(rt,rn,im) torri8(THUMB2_LDRSBI,rn,rt,im) -#define _CC_LDRB(cc,rt,rn,rm) corrr(cc,ARM_LDRB|ARM_P,rn,rt,rm) -#define _LDRB(rt,rn,rm) _CC_LDRB(ARM_CC_AL,rt,rn,rm) -#define T1_LDRB(rt,rn,rm) _jit_W(THUMB_LDRB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_LDRB(rt,rn,rm) torxr(THUMB2_LDRB,rn,rt,rm) -#define _CC_LDRBN(cc,rt,rn,rm) corrr(cc,ARM_LDRB,rn,rt,rm) -#define _LDRBN(rt,rn,rm) _CC_LDRBN(ARM_CC_AL,rt,rn,rm) -#define _CC_LDRBI(cc,rt,rn,im) corri(cc,ARM_LDRBI|ARM_P,rn,rt,im) -#define _LDRBI(rt,rn,im) _CC_LDRBI(ARM_CC_AL,rt,rn,im) -#define T1_LDRBI(rt,rn,im) _jit_W(THUMB_LDRBI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_LDRBI(rt,rn,im) torri8(THUMB2_LDRBI|THUMB2_U,rn,rt,im) -#define T2_LDRBWI(rt,rn,im) torri12(THUMB2_LDRBWI,rn,rt,im) -#define _CC_LDRBIN(cc,rt,rn,im) corri(cc,ARM_LDRBI,rn,rt,im) -#define _LDRBIN(rt,rn,im) _CC_LDRBIN(ARM_CC_AL,rt,rn,im) -#define T2_LDRBIN(rt,rn,im) torri8(THUMB2_LDRBI,rn,rt,im) -#define _CC_LDRSH(cc,rt,rn,rm) corrr(cc,ARM_LDRSH|ARM_P,rn,rt,rm) -#define _LDRSH(rt,rn,rm) _CC_LDRSH(ARM_CC_AL,rt,rn,rm) -#define T1_LDRSH(rt,rn,rm) _jit_W(THUMB_LDRSH|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_LDRSH(rt,rn,rm) torxr(THUMB2_LDRSH,rn,rt,rm) -#define _CC_LDRSHN(cc,rt,rn,rm) corrr(cc,ARM_LDRSH,rn,rt,rm) -#define _LDRSHN(rt,rn,rm) _CC_LDRSHN(ARM_CC_AL,rt,rn,rm) -#define _CC_LDRSHI(cc,rt,rn,im) corri8(cc,ARM_LDRSHI|ARM_P,rn,rt,im) -#define _LDRSHI(rt,rn,im) _CC_LDRSHI(ARM_CC_AL,rt,rn,im) -#define T2_LDRSHI(rt,rn,im) torri8(THUMB2_LDRSHI|THUMB2_U,rn,rt,im) -#define T2_LDRSHWI(rt,rn,im) torri12(THUMB2_LDRSHWI,rn,rt,im) -#define _CC_LDRSHIN(cc,rt,rn,im) corri8(cc,ARM_LDRSHI,rn,rt,im) -#define _LDRSHIN(rt,rn,im) _CC_LDRSHIN(ARM_CC_AL,rt,rn,im) -#define T2_LDRSHIN(rt,rn,im) torri8(THUMB2_LDRSHI,rn,rt,im) -#define _CC_LDRH(cc,rt,rn,rm) corrr(cc,ARM_LDRH|ARM_P,rn,rt,rm) -#define _LDRH(rt,rn,rm) _CC_LDRH(ARM_CC_AL,rt,rn,rm) -#define T1_LDRH(rt,rn,rm) _jit_W(THUMB_LDRH|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_LDRH(rt,rn,rm) torxr(THUMB2_LDRH,rn,rt,rm) -#define _CC_LDRHN(cc,rt,rn,rm) corrr(cc,ARM_LDRH,rn,rt,rm) -#define _LDRHN(rt,rn,rm) CC_LDRHN(ARM_CC_AL,rt,rn,rm) -#define _CC_LDRHI(cc,rt,rn,im) corri8(cc,ARM_LDRHI|ARM_P,rn,rt,im) -#define _LDRHI(rt,rn,im) _CC_LDRHI(ARM_CC_AL,rt,rn,im) -#define T1_LDRHI(rt,rn,im) _jit_W(THUMB_LDRHI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_LDRHI(rt,rn,im) torri8(THUMB2_LDRHI|THUMB2_U,rn,rt,im) -#define T2_LDRHWI(rt,rn,im) torri12(THUMB2_LDRHWI,rn,rt,im) -#define _CC_LDRHIN(cc,rt,rn,im) corri8(cc,ARM_LDRHI,rn,rt,im) -#define _LDRHIN(rt,rn,im) _CC_LDRHIN(ARM_CC_AL,rt,rn,im) -#define T2_LDRHIN(rt,rn,im) torri8(THUMB2_LDRHI,rn,rt,im) -#define _CC_LDR(cc,rt,rn,rm) corrr(cc,ARM_LDR|ARM_P,rn,rt,rm) -#define _LDR(rt,rn,rm) _CC_LDR(ARM_CC_AL,rt,rn,rm) -#define T1_LDR(rt,rn,rm) _jit_W(THUMB_LDR|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_LDR(rt,rn,rm) torxr(THUMB2_LDR,rn,rt,rm) -#define _CC_LDRN(cc,rt,rn,rm) corrr(cc,ARM_LDR,rn,rt,rm) -#define _LDRN(rt,rn,rm) _CC_LDRN(ARM_CC_AL,rt,rn,rm) -#define _CC_LDRI(cc,rt,rn,im) corri(cc,ARM_LDRI|ARM_P,rn,rt,im) -#define _LDRI(rt,rn,im) _CC_LDRI(ARM_CC_AL,rt,rn,im) -#define T1_LDRI(rt,rn,im) _jit_W(THUMB_LDRI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T1_LDRISP(rt,im) _jit_W(THUMB_LDRISP|(_u3(rt)<<8)|_u8(im)) -#define T2_LDRI(rt,rn,im) torri8(THUMB2_LDRI|THUMB2_U,rn,rt,im) -#define T2_LDRWI(rt,rn,im) torri12(THUMB2_LDRWI,rn,rt,im) -#define _CC_LDRIN(cc,rt,rn,im) corri(cc,ARM_LDRI,rn,rt,im) -#define _LDRIN(rt,rn,im) _CC_LDRIN(ARM_CC_AL,rt,rn,im) -#define T2_LDRIN(rt,rn,im) torri8(THUMB2_LDRI,rn,rt,im) -#define _CC_LDRD(cc,rt,rn,rm) corrr(cc,ARM_LDRD|ARM_P,rn,rt,rm) -#define _LDRD(rt,rn,rm) _CC_LDRD(ARM_CC_AL,rt,rn,rm) -#define _CC_LDRDN(cc,rt,rn,rm) corrr(cc,ARM_LDRD,rn,rt,rm) -#define _LDRDN(rd,rn,rm) _CC_LDRDN(ARM_CC_AL,rn,rt,rm) -#define _CC_LDRDI(cc,rt,rn,im) corri8(cc,ARM_LDRDI|ARM_P,rn,rt,im) -#define _LDRDI(rt,rn,im) _CC_LDRDI(ARM_CC_AL,rn,rt,im) -#define T2_LDRDI(rt,rt2,rn,im) torrri8(THUMB2_LDRDI|ARM_P,rn,rt,rt2,im) -#define _CC_LDRDIN(cc,rt,rn,im) corri8(cc,ARM_LDRDI,rn,rt,im) -#define _LDRDIN(rt,rn,im) _CC_LDRDIN(ARM_CC_AL,rt,rn,im) -#define T2_LDRDIN(rt,rt2,rn,im) torrri8(THUMB2_LDRDI,rn,rt,rt2,im) -#define _CC_STRB(cc,rt,rn,rm) corrr(cc,ARM_STRB|ARM_P,rn,rt,rm) -#define _STRB(rt,rn,rm) _CC_STRB(ARM_CC_AL,rt,rn,rm) -#define T1_STRB(rt,rn,rm) _jit_W(THUMB_STRB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_STRB(rt,rn,rm) torxr(THUMB2_STRB,rn,rt,rm) -#define _CC_STRBN(cc,rt,rn,rm) corrr(cc,ARM_STRB,rn,rt,rm) -#define _STRBN(rt,rn,rm) _CC_STRBN(ARM_CC_AL,rt,rn,rm) -#define _CC_STRBI(cc,rt,rn,im) corri(cc,ARM_STRBI|ARM_P,rn,rt,im) -#define _STRBI(rt,rn,im) _CC_STRBI(ARM_CC_AL,rt,rn,im) -#define T1_STRBI(rt,rn,im) _jit_W(THUMB_STRBI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_STRBI(rt,rn,im) torri8(THUMB2_STRBI|THUMB2_U,rn,rt,im) -#define T2_STRBWI(rt,rn,im) torri12(THUMB2_STRBWI,rn,rt,im) -#define _CC_STRBIN(cc,rt,rn,im) corri(cc,ARM_STRBI,rn,rt,im) -#define _STRBIN(rt,rn,im) _CC_STRBIN(ARM_CC_AL,rt,rn,im) -#define T2_STRBIN(rt,rn,im) torri8(THUMB2_STRBI,rn,rt,im) -#define _CC_STRH(cc,rt,rn,rm) corrr(cc,ARM_STRH|ARM_P,rn,rt,rm) -#define _STRH(rt,rn,rm) _CC_STRH(ARM_CC_AL,rt,rn,rm) -#define T1_STRH(rt,rn,rm) _jit_W(THUMB_STRH|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_STRH(rt,rn,rm) torxr(THUMB2_STRH,rn,rt,rm) -#define _CC_STRHN(cc,rt,rn,rm) corrr(cc,ARM_STRH,rn,rt,rm) -#define _STRHN(rt,rn,rm) _CC_STRHN(ARM_CC_AL,rt,rn,rm) -#define _CC_STRHI(cc,rt,rn,im) corri8(cc,ARM_STRHI|ARM_P,rn,rt,im) -#define _STRHI(rt,rn,im) _CC_STRHI(ARM_CC_AL,rt,rn,im) -#define T1_STRHI(rt,rn,im) _jit_W(THUMB_STRHI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_STRHI(rt,rn,im) torri8(THUMB2_STRHI|THUMB2_U,rn,rt,im) -#define T2_STRHWI(rt,rn,im) torri12(THUMB2_STRHWI,rn,rt,im) -#define _CC_STRHIN(cc,rt,rn,im) corri8(cc,ARM_STRHI,rn,rt,im) -#define _STRHIN(rt,rn,im) _CC_STRHIN(ARM_CC_AL,rt,rn,im) -#define T2_STRHIN(rt,rn,im) torri8(THUMB2_STRHI,rn,rt,im) -#define _CC_STR(cc,rt,rn,rm) corrr(cc,ARM_STR|ARM_P,rn,rt,rm) -#define _STR(rt,rn,rm) _CC_STR(ARM_CC_AL,rt,rn,rm) -#define T1_STR(rt,rn,rm) _jit_W(THUMB_STR|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T2_STR(rt,rn,rm) torxr(THUMB2_STR,rn,rt,rm) -#define _CC_STRN(cc,rt,rn,rm) corrr(cc,ARM_STR,rn,rt,rm) -#define _STRN(rt,rn,rm) _CC_STRN(ARM_CC_AL,rt,rn,rm) -#define _CC_STRI(cc,rt,rn,im) corri(cc,ARM_STRI|ARM_P,rn,rt,im) -#define _STRI(rt,rn,im) _CC_STRI(ARM_CC_AL,rt,rn,im) -#define T1_STRI(rt,rn,im) _jit_W(THUMB_STRI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt)) -#define T1_STRISP(rt,im) _jit_W(THUMB_STRISP|(_u3(rt)<<8)|(_u8(im))) -#define T2_STRI(rt,rn,im) torri8(THUMB2_STRI|THUMB2_U,rn,rt,im) -#define T2_STRWI(rt,rn,im) torri12(THUMB2_STRWI,rn,rt,im) -#define _CC_STRIN(cc,rt,rn,im) corri(cc,ARM_STRI,rn,rt,im) -#define _STRIN(rt,rn,im) _CC_STRIN(ARM_CC_AL,rt,rn,im) -#define T2_STRIN(rt,rn,im) torri8(THUMB2_STRI,rn,rt,im) -#define _CC_STRD(cc,rt,rn,rm) corrr(cc,ARM_STRD|ARM_P,rt,rn,rm) -#define _STRD(rt,rn,rm) _CC_STRD(ARM_CC_AL,rt,rn,rm) -#define _CC_STRDN(cc,rt,rn,rm) corrr(cc,ARM_STRD,rn,rt,rm) -#define _STRDN(rt,rn,rm) _CC_STRDN(ARM_CC_AL,rt,rn,rm) -#define _CC_STRDI(cc,rt,rn,im) corri8(cc,ARM_STRDI|ARM_P,rn,rt,im) -#define _STRDI(rt,rn,im) _CC_STRDI(ARM_CC_AL,rt,rn,im) -#define T2_STRDI(rt,rt2,rn,im) torrri8(THUMB2_STRDI|ARM_P,rn,rt,rt2,im) -#define _CC_STRDIN(cc,rt,rn,im) corri8(cc,ARM_STRDI,rn,rt,im) -#define _STRDIN(rt,rn,im) _CC_STRDIN(ARM_CC_AL,rt,rn,im) -#define T2_STRDIN(rt,rt2,rn,im) torrri8(THUMB2_STRDI,rn,rt,rt2,im) - -#define _CC_LDMIA(cc,rn,im) corl(cc,ARM_M|ARM_M_L|ARM_M_I,rn,im) -#define _LDMIA(rn,im) _CC_LDMIA(ARM_CC_AL,rn,im) -#define _CC_LDM(cc,rn,im) _CC_LDMIA(cc,rn,im) -#define _LDM(rn,im) _LDMIA(rn,im) -#define T1_LDMIA(rn,im) _jit_W(THUMB_LDMIA|(_u3(rn)<<8)|im) -#define T2_LDMIA(rn,im) torl(THUMB2_LDMIA,rn,im) -#define _CC_LDMIA_U(cc,rn,im) corl(cc,ARM_M|ARM_M_L|ARM_M_I|ARM_M_U,rn,im) -#define _LDMIA_U(rn,im) _CC_LDMIA_U(ARM_CC_AL,rn,im) -#define _LDM_U(r0,i0) _LDMIA_U(r0,i0) -#define _CC_LDMIB(cc,rn,im) corl(cc,ARM_M|ARM_M_L|ARM_M_I|ARM_M_B,rn,im) -#define _LDMIB(rn,im) _CC_LDMIB(ARM_CC_AL,rn,im) -#define _CC_LDMIB_U(cc,rn,im) corl(cc,ARM_M|ARM_M_L|ARM_M_I|ARM_M_B|ARM_M_U,rn,im) -#define _LDMIB_U(rn,im) _CC_LDMIB_U(ARM_CC_AL,rn,im) -#define _CC_LDMDA(cc,rn,im) corl(cc,ARM_M|ARM_M_L,rn,im) -#define _LDMDA(rn,im) _CC_LDMDA(ARM_CC_AL,rn,im) -#define _CC_LDMDA_U(cc,rn,im) corl(cc,ARM_M|ARM_M_L|ARM_M_U,rn,im) -#define _LDMDA_U(rn,im) _CC_LDMDA_U(ARM_CC_AL,rn,im) -#define _CC_LDMDB(cc,rn,im) corl(cc,ARM_M|ARM_M_L|ARM_M_B,rn,im) -#define _LDMDB(rn,im) _CC_LDMDB(ARM_CC_AL,rn,im) -# define T2_LDMDB(rn,im) torl(THUMB2_LDMDB,rn,im) - -#define _CC_LDMDB_U(cc,rn,im) corl(cc,ARM_M|ARM_M_L|ARM_M_B|ARM_M_U,rn,im) -#define _LDMDB_U(rn,im) _CC_LDMDB_U(ARM_CC_AL,rn,im) -#define _CC_STMIA(cc,rn,im) corl(cc,ARM_M|ARM_M_I,rn,im) -#define _STMIA(rn,im) _CC_STMIA(ARM_CC_AL,rn,im) -#define _CC_STM(cc,rn,im) _CC_STMIA(cc,rn,im) -#define _STM(rn,im) _STMIA(rn,im) -#define _CC_STMIA_U(cc,rn,im) corl(cc,ARM_M|ARM_M_I|ARM_M_U,rn,im) -#define _STMIA_U(rn,im) _CC_STMIA_U(ARM_CC_AL,rn,im) -#define _CC_STM_U(cc,rn,im) _CC_STMIA_U(cc,rn,im) -#define _STM_U(rn,im) _STMIA_U(rn,im) -#define _CC_STMIB(cc,rn,im) corl(cc,ARM_M|ARM_M_I|ARM_M_B,rn,im) -#define _STMIB(rn,im) _CC_STMIB(ARM_CC_AL,rn,im) -#define _CC_STMIB_U(cc,rn,im) corl(cc,ARM_M|ARM_M_I|ARM_M_B|ARM_M_U,rn,im) -#define _STMIB_U(rn,im) _CC_STMIB_U(ARM_CC_AL,rn,im) -#define _CC_STMDA(cc,rn,im) corl(cc,ARM_M,rn,im) -#define _STMDA(rn,im) _CC_STMDA(ARM_CC_AL,rn,im) -#define _CC_STMDA_U(cc,rn,im) corl(cc,ARM_M|ARM_M_U,rn,im) -#define _STMDA_U(rn,im) _CC_STMDA_U(ARM_CC_AL,rn,im) -#define _CC_STMDB(cc,rn,im) corl(cc,ARM_M|ARM_M_B,rn,im) -#define _STMDB(rn,im) _CC_STMDB(ARM_CC_AL,rn,im) -#define _CC_STMDB_U(cc,rn,im) corl(cc,ARM_M|ARM_M_B|ARM_M_U,rn,im) -#define _STMDB_U(rn,im) _CC_STMDB_U(ARM_CC_AL,rn,im) -#define _CC_PUSH(cc,im) _CC_STMDB_U(cc,JIT_SP,im) -#define _PUSH(im) _STMDB_U(JIT_SP,im) -#define T1_PUSH(im) _jit_W(THUMB_PUSH|((im&0x4000)>>6)|(im&0xff)) -#define T2_PUSH(im) tpp(THUMB2_PUSH,im) -#define _CC_POP(cc,im) _LDMIA_U(cc,JIT_SP,im) -#define _POP(im) _LDMIA_U(JIT_SP,im) -#define T1_POP(im) _jit_W(THUMB_POP|((im&0x8000)>>7)|(im&0xff)) -#define T2_POP(im) tpp(THUMB2_POP,im) - -#define _CC_PKHBTI(cc,rd,rn,rm,im) arm_cc_pkh(cc,ARM_PKH,rn,rd,rm,im) -#define _CC_PKHTBI(cc,rd,rn,rm,im) arm_cc_pkh(cc,ARM_PKH|ARM_ASR,rn,rd,rm,im) -#define _PKHBTI(rd,rn,rm,im) _CC_PKHBTI(ARM_CC_AL,rd,rn,rm,im) -#define _PKHTBI(rd,rn,rm,im) _CC_PKHTBI(ARM_CC_AL,rd,rn,rm,im) -#define _PKHBT(rd,rn,rm) _CC_PKHBTI(ARM_CC_AL,rd,rn,rm,0) -#define _PKHTB(rd,rn,rm) _CC_PKHTBI(ARM_CC_AL,rd,rn,rm,0) - -static int -encode_thumb_immediate(unsigned int v) -{ - int i; - unsigned int m; - unsigned int n; - /* 00000000 00000000 00000000 abcdefgh */ - if ((v & 0xff) == v) - return (v); - /* 00000000 abcdefgh 00000000 abcdefgh */ - if ((v & 0xff00ff) == v && ((v & 0xff0000) >> 16) == (v & 0xff)) - return ((v & 0xff) | (1 << 12)); - /* abcdefgh 00000000 abcdefgh 00000000 */ - if (((v & 0xffff0000) >> 16) == (v & 0xffff) && (v & 0xff) == 0) - return ((v & 0x000000ff) | (2 << 12)); - /* abcdefgh abcdefgh abcdefgh abcdefgh */ - if ( (v & 0xff) == ((v & 0xff00) >> 8) && - ((v & 0xff00) >> 8) == ((v & 0xff0000) >> 16) && - ((v & 0xff0000) << 8) == (v & 0xff000000)) - return ((v & 0xff) | (3 << 12)); - /* 1bcdefgh << 24 ... 1bcdefgh << 1 */ - for (i = 8, m = 0xff000000, n = 0x80000000; - i < 23; i++, m >>= 1, n >>= 1) { - if ((v & m) == v && (v & n)) { - v >>= 32 - i; - if (!(i & 1)) - v &= 0x7f; - i >>= 1; - return (((i & 7) << 12) | ((i & 8) << 23) | v); - } - } - return (-1); -} - -static int -encode_thumb_word_immediate(unsigned int v) -{ - if ((v & 0xfffff000) == 0) - return (((v & 0x800) << 15) | ((v & 0x700) << 4) | (v & 0xff)); - return (-1); -} - -static int -encode_thumb_jump(int v) -{ - int s, i1, i2, j1, j2; - if (v >= (int)-0x800000 && v <= 0x7fffff) { - s = !!(v & 0x800000); - i1 = !!(v & 0x400000); - i2 = !!(v & 0x200000); - j1 = s ? i1 : !i1; - j2 = s ? i2 : !i2; - return ((s<<26)|((v&0x1ff800)<<5)|(j1<<13)|(j2<<11)|(v&0x7ff)); - } - return (-1); -} - -static int -encode_thumb_cc_jump(int v) -{ - int s, j1, j2; - if (v >= (int)-0x80000 && v <= 0x7ffff) { - s = !!(v & 0x80000); - j1 = !!(v & 0x20000); - j2 = !!(v & 0x40000); - return ((s<<26)|((v&0x1f800)<<5)|(j1<<13)|(j2<<11)|(v&0x7ff)); - } - return (-1); -} - -#if !NAN_TO_INT_IS_ZERO -static int -encode_thumb_shift(int v, int type) -{ - switch (type) { - case ARM_ASR: - case ARM_LSL: - case ARM_LSR: type >>= 1; break; - default: assert(!"handled shift"); - } - assert(v >= 0 && v <= 31); - return (((v & 0x1c) << 10) | ((v & 3) << 6) | type); -} -#endif - -#define thumb2_orri(o,rn,rd,im) torri(o,rn,rd,im) -#define torri(o,rn,rd,im) \ - (assert(!((o) & 0x0c0f7fff) && !((im) & 0xfbff8f00)), \ - _jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rd)<<8)|(im)), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define torri8(o,rn,rt,im) \ - (assert(!((o) & 0x000ff0ff) && !((im) & 0xffffff00)), \ - _jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rt)<<12)|im), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define torri12(o,rn,rt,im) \ - (assert(!((o) & 0x000fffff) && !((im) & 0xfffff000)), \ - _jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rt)<<12)|(im)), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define toriw(o,rd,im) \ - (assert(!((o) & 0x40f7fff) && !((im) & 0xffff0000)), \ - _jitl.thumb.i = ((o)|(((im)&0xf000)<<4)|(((im)&0x800)<<15)|(((im)&0x700)<<4)|(_u4(rd)<<8)|((im)&0xff)), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define torrr(o,rn,rd,rm) \ - (assert(!((o) & 0xf0f0f)), \ - _jit.jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rd)<<8)|_u4(rm)), \ - _jit_WW(_jit.jitl.thumb.s[0], _jit.jitl.thumb.s[1])) - -#define torrrs(o,rn,rd,rm,im) \ - (assert(!((o) & 0x000f0f0f) && !((im) & 0xffff8f0f)), \ - _jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rd)<<8)|(im)|_u4(rm)), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define torxr(o,rn,rt,rm) \ - (assert(!((o) & 0xf0f0f)), \ - _jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rt)<<12)|_u4(rm)) \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define torrrr(o,rn,rl,rh,rm) \ - (assert(!((o) & 0x000fff0f)), \ - _jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rl)<<12)|(_u4(rh)<<8)|_u4(rm)), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define torrri8(o,rn,rt,rt2,im) \ - (assert(!((o) & 0x000fffff) && !((im) & 0xffffff00)), \ - _jitl.thumb.i = ((o)|(_u4(rn)<<16)|(_u4(rt)<<12)|(_u4(rt2)<<8)|(im)), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define tc8(cc,im) \ - (assert(!((cc) & 0x0fffffff) && ((cc) != ARM_CC_AL) && ((cc) != ARM_CC_NV) && _s8P(im)), \ - _jit_W(THUMB_CC_B|((cc)>>20)|((im)&0xff))) - -#define t11(im) \ - (assert(!((im) & 0xfffff800)), \ - _jit_W(THUMB_B|(im))) - -#define tcb(cc,im) \ - (assert(!((cc) & 0xfffffff) && ((cc) != ARM_CC_AL) && ((cc) != ARM_CC_NV) && !((im) & (THUMB2_CC_B|(((unsigned)cc) >> 6)))), \ - _jitl.thumb.i = THUMB2_CC_B|(((unsigned)(cc)) >> 6)|(im), \ - _jit_WW(_jitl.thumb.s[0], _jitl.thumb.s[1])) - -#define blxi(im) \ - (assert(!((im) & 0xfe000000)), \ - _jit_I(ARM_BLXI|(im))) - -#define tb(o,im) \ - (assert(!((o) & 0x07ff2fff) && !((o) & (im))), \ - jitl.thumb.i = (o)|(im), \ - _jit_WW(thumb.s[0], thumb.s[1])) - -#define tshift(o,rd,rm,im) \ - (assert(!((o) & 0x7fcf) && ((im) >= 0) && ((im) < 32)), \ - thumb.i = (o|(((im)&0x1c)<<10)|(_u4(rd)<<8)|(((im)&3)<<6)|_u4(rm)), \ - _jit_WW(thumb.s[0], thumb.s[1])) - -#define thumb2_orrr(o,rn,rd,rm) \ - (assert(!((o) & 0x000f0f0f)), \ - thumb.i = (o) | (_u4(rn)<<16) | (_u4(rd)<<8) | _u4(rm), \ - _jit_WW(thumb.s[0], thumb.s[1])) - -#define thumb2_bfx(o,rn,rd,lsb,width) \ - (assert(!((o) & 0x7fdf) && ((lsb) >= 0) && ((lsb) < 32) && ((width) >= 0) && ((width) <= 32)), \ - thumb.i = (o) | (_u4(rn) << 16) | (_u4(rd) << 8) | \ - (((((lsb) + (width) > 31) ? 31 : (lsb) + (width)) & 7) << 10) | \ - (((((lsb) + (width) > 31) ? 31 : (lsb) + (width)) & 3) << 5) | \ - (((lsb) + (width) > 31) ? 31 : (lsb) + (width)), \ - _jit_WW(thumb.s[0], thumb.s[1])) - -#define thumb2_cbxz(o,rn,im) \ - (assert(!((o) & 0x2ff) && (im) >= 0 && (im) < 128 && !((im) & 1)), \ - _jit_W((o)|((((im) >> 1)&0x80)<<5)|((((im) >> 1)&0x1f)<<3)|_u3(rn))) - -#define thumb2_dbg(h,l,im) \ - (assert(!((h) & ~0xffff) && !((l) & 0xffff000f)), \ - _jit_WW((h), (l) | _u4(im))) - -#define tpp(o,im) \ - (assert(!((o) & 0x0000ffff) && !((im) & 0xffff2000) && \ - (!((o) == THUMB2_PUSH) || !((im) & 0x8000)) && \ - (__builtin_popcount((im) & 0x1fff) > 1)), \ - _jit.jitl.thumb.i = (o)|(im), \ - _jit_WW(_jit.jitl.thumb.s[0], _jit.jitl.thumb.s[1])) - -#define THUMB2_IT 0 -#define THUMB2_ITT 1 -#define THUMB2_ITE 2 -#define THUMB2_ITTT 3 -#define THUMB2_ITET 4 -#define THUMB2_ITTE 5 -#define THUMB2_ITEE 6 -#define THUMB2_ITTTT 7 -#define THUMB2_ITETT 8 -#define THUMB2_ITTET 9 -#define THUMB2_ITEET 10 -#define THUMB2_ITTTE 11 -#define THUMB2_ITETE 12 -#define THUMB2_ITTEE 13 -#define THUMB2_ITEEE 14 -#define tcit(tc,it) \ - (assert(!(tc & 0xfffffff) && tc != ARM_CC_NV), \ - _jit_W(0xbf00 | (tc >> 24) | \ - ((it == THUMB2_IT) ? 1<<3 : \ - (it == THUMB2_ITT) ? ((((tc) >> 28) & 1)<<3)| (1<<2) : \ - (it == THUMB2_ITE) ? (!(((tc) >> 28) & 1)<<3)| (1<<2) : \ - (it == THUMB2_ITTT) ? ((((tc) >> 28) & 1)<<3)| ((((tc) >> 28) & 1)<<2)| (1<<1) : \ - (it == THUMB2_ITET) ? (!(((tc) >> 28) & 1)<<3)| ((((tc) >> 28) & 1)<<2)| (1<<1) : \ - (it == THUMB2_ITTE) ? ((((tc) >> 28) & 1)<<3)|(!(((tc) >> 28) & 1)<<2)| (1<<1) : \ - (it == THUMB2_ITEE) ? (!(((tc) >> 28) & 1)<<3)|(!(((tc) >> 28) & 1)<<2)| (1<<1) : \ - (it == THUMB2_ITTTT) ? ((((tc) >> 28) & 1)<<3)| ((((tc) >> 28) & 1)<<2)| ((((tc) >> 28) & 1)<<1)|1 : \ - (it == THUMB2_ITETT) ? (!(((tc) >> 28) & 1)<<3)| ((((tc) >> 28) & 1)<<2)| ((((tc) >> 28) & 1)<<1)|1 : \ - (it == THUMB2_ITTET) ? ((((tc) >> 28) & 1)<<3)|(!(((tc) >> 28) & 1)<<2)| ((((tc) >> 28) & 1)<<1)|1 : \ - (it == THUMB2_ITEET) ? (!(((tc) >> 28) & 1)<<3)|(!(((tc) >> 28) & 1)<<2)| ((((tc) >> 28) & 1)<<1)|1 : \ - (it == THUMB2_ITTTE) ? ((((tc) >> 28) & 1)<<3)| ((((tc) >> 28) & 1)<<2)|(!(((tc) >> 28) & 1)<<1)|1 : \ - (it == THUMB2_ITETE) ? (!(((tc) >> 28) & 1)<<3)| ((((tc) >> 28) & 1)<<2)|(!(((tc) >> 28) & 1)<<1)|1 : \ - (it == THUMB2_ITTEE) ? ((((tc) >> 28) & 1)<<3)|(!(((tc) >> 28) & 1)<<2)|(!(((tc) >> 28) & 1)<<1)|1 : \ - (it == THUMB2_ITEEE) ? (!(((tc) >> 28) & 1)<<3)|(!(((tc) >> 28) & 1)<<2)|(!(((tc) >> 28) & 1)<<1)|1 : \ - assert(!"valid it code")))) - -#define _IT(cc) tcit(cc,THUMB2_IT) -#define _ITT(cc) tcit(cc,THUMB2_ITT) -#define _ITE(cc) tcit(cc,THUMB2_ITE) -#define _ITTT(cc) tcit(cc,THUMB2_ITTT) -#define _ITTE(cc) tcit(cc,THUMB2_ITTE) -#define _ITET(cc) tcit(cc,THUMB2_ITET) -#define _ITEE(cc) tcit(cc,THUMB2_ITEE) -#define _ITTTT(cc) tcit(cc,THUMB2_ITTTT) -#define _ITETT(cc) tcit(cc,THUMB2_ITETT) -#define _ITTET(cc) tcit(cc,THUMB2_ITTET) -#define _ITEET(cc) tcit(cc,THUMB2_ITEET) -#define _ITTTE(cc) tcit(cc,THUMB2_ITTTE) -#define _ITETE(cc) tcit(cc,THUMB2_ITETE) -#define _ITTEE(cc) tcit(cc,THUMB2_ITTEE) -#define _ITEEE(cc) tcit(cc,THUMB2_ITEEE) - -#define torl(o,rn,im) \ - (assert(!((o) & 0xf1fff) && \ - ((rn) != _R15 || !(im) || (((o) & 0xc000) == 0xc000)) && \ - !((o) & THUMB2_LDM_W) || !((im) & (1 << (rn)))), \ - thumb.i = ((o) | (_u4(rn)<<16) | _u13(im)), \ - _jit_WW(thumb.s[0], thumb.s[1])) - -#define thumb2_mrrc(o,t2,t,cc,o1,m) \ - (assert(!((o) & 0x03afffff)), \ - thumb.i = ((o)|(_u4(t2)<<16)|(_u4(t)<<12)|(_u4(cc)<<8)|(_u4(o1)<<4)|_u4(m)), \ - _jit_WW(thumb.s[0], thumb.s[1])) - -#define thumb2_pkh(o,rn,rd,rm,im) \ - (assert(!((o) & 0x7ffcf)), \ - thumb.i = ((o)|(_u4(rn)<<16)|((_u5(im)&0x1c)<<10)| \ - (_u4(rd)<<12)|(((im)&3)<<6)|_u4(rm)), \ - _jit_WW(thumb.s[0], thumb.s[1])) - -/* v6T2, v7 */ -#define THUMB2_BFX 0xf3600000 -#define T2_BFC(rd,lsb,width) thumb2_bfx(THUMB2_BFX,_R15,rd,lsb,width) -#define T2_BFI(rd,rn,lsb,width) thumb2_bfx(THUMB2_BFX,rn,rd,lsb,width) -/* not permitted in IT block */ -#define THUMB2_CBZ 0xb100 -#define T2_CBZ(rn,im) thumb2_cbxz(THUMB2_CBZ,rn,im) -#define THUMB2_CBNZ 0xb900 -#define T2_CBNZ(rn,im) thumb2_cbxz(THUMB2_CBNZ,rn,im) -/* CDP/CDP2 here - same encoding as arm, but can start at "&3 == 2 offset" */ -#define THUMB2_CLZ 0xfab0f080 -#define T2_CLZ(rd,rm) thumb2_orrr(THUMB2_CLZ,rd,rm,rm) - -#endif /* __lightning_asm_h */ diff --git a/src/runtime/c/pgf/lightning/arm/core.h b/src/runtime/c/pgf/lightning/arm/core.h deleted file mode 100644 index eabb29c32..000000000 --- a/src/runtime/c/pgf/lightning/arm/core.h +++ /dev/null @@ -1,2163 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer (arm version) - * - ***********************************************************************/ - -/*********************************************************************** - * - * Copyright 2011 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - * Authors: - * Paulo Cesar Pereira de Andrade - ***********************************************************************/ - -#ifndef __lightning_core_arm_h -#define __lightning_core_arm_h - -typedef unsigned char _uc, jit_insn; - -struct { - _ui version : 4; - _ui extend : 1; - /* only generate thumb instructions for thumb2 */ - _ui thumb : 1; - _ui vfp : 3; - _ui neon : 1; - _ui abi : 2; -} jit_cpu; -struct { - /* prevent using thumb instructions that set flags? */ - _ui no_set_flags : 1; -} jit_flags; - -struct jit_local_state { - int framesize; - int nextarg_get; - int nextarg_put; - int nextarg_getf; - int alloca_offset; - int stack_length; - int stack_offset; - void *stack; - jit_thumb_t thumb; - jit_insn* thumb_pc; - jit_insn* thumb_tmp; - int tmp; - /* hackish mostly to make test cases work; use arm instruction - * set in jmpi if did not yet see a prolog */ - int after_prolog; - void *arguments[256]; - int types[8]; -#ifdef JIT_NEED_PUSH_POP - /* minor support for unsupported code but that exists in test cases... */ - int push[32]; - int pop; -#endif -}; - -#define JIT_R_NUM 4 -static const jit_gpr_t -jit_r_order[JIT_R_NUM] = { - _R0, _R1, _R2, _R3 -}; -#define JIT_R(i) jit_r_order[i] - -#define JIT_V_NUM 4 -static const jit_gpr_t -jit_v_order[JIT_V_NUM] = { - _R4, _R5, _R6, _R7 -}; -#define JIT_V(i) jit_v_order[i] - -#define JIT_FRAMESIZE 48 - -#define jit_no_set_flags() jit_flags.no_set_flags -#define jit_thumb_p() jit_cpu.thumb -#define jit_armv5_p() (jit_cpu.version >= 5) -#define jit_armv5e_p() (jit_cpu.version >= 5 && jit_cpu.extend) -#define jit_armv7r_p() 0 -#define jit_swf_p() (jit_cpu.vfp == 0) -#define jit_hardfp_p() jit_cpu.abi - -#define __jit_inline static - -#ifdef USE_THUMB_CODE -#define jit_nop(n) \ -{ \ - assert(n >= 0); \ - for (; n > 0; n -= 2) \ - T1_NOP(); \ -} -#else -#define jit_nop(n) \ -{ \ - assert(n >= 0); \ - for (; n > 0; n -= 4) \ - _NOP(); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_movr_i(r0, r1) \ -{ \ - if (r0 != r1) { \ - T1_MOV(r0, r1); \ - } \ -} -#else -#define jit_movr_i(r0, r1) \ -{ \ - if (r0 != r1) { \ - _MOV(r0, r1); \ - } \ -} -#endif - -#define jit_movi_i(r0, i0) \ - ((!jit_no_set_flags() && r0 < 8 && !(i0 & 0xffffff80)) ? \ - T1_MOVI(r0, i0) : \ - ((_jitl.tmp = encode_thumb_immediate(i0)) != -1) ? \ - T2_MOVI(r0, _jitl.tmp) : \ - ((_jitl.tmp = encode_thumb_immediate(~i0)) != -1) ? \ - T2_MVNI(r0, _jitl.tmp) : \ - ( T2_MOVWI(r0, _jit_US(i0)), \ - ((i0 & 0xffff0000) ? T2_MOVTI(r0, _jit_US((unsigned)i0 >> 16)) : 0) )) - -#ifdef USE_THUMB_CODE -#define jit_movi_p(r0, i0) \ - (T2_MOVWI(r0, _jit_US((int)i0)), T2_MOVTI(r0, _jit_US((int)i0 >> 16)), _jit.x.pc-8) -#else -#define jit_movi_p(r0, i0) \ - ((jit_armv6_p()) ? \ - (_MOVWI(r0, _jit_US((unsigned int)i0)), \ - _MOVTI(r0, _jit_US(((unsigned int)i0) >> 16)), \ - _jit.x.pc - 8) : \ - (_MOVI(r0, encode_arm_immediate(((int) i0) & 0xff000000)), \ - _ORRI(r0, r0, encode_arm_immediate(((int) i0) & 0x00ff0000)), \ - _ORRI(r0, r0, encode_arm_immediate(((int) i0) & 0x0000ff00)), \ - _ORRI(r0, r0, ((int) i0) & 0x000000ff), \ - _jit.x.pc - 16)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_patch_movi(i0, i1) \ -{ \ - union { \ - short *s; \ - int *i; \ - void *v; \ - } u; \ - jit_thumb_t thumb; \ - unsigned int im; \ - int q0, q1, q2, q3; \ - im = (unsigned int)i1; u.v = i0; \ -\ - q0 = (im & 0xf000) << 4; \ - q1 = (im & 0x0800) << 15; \ - q2 = (im & 0x0700) << 4; \ - q3 = im & 0x00ff; \ - code2thumb(thumb.s[0], thumb.s[1], u.s[0], u.s[1]); \ - assert( (thumb.i & 0xfbf00000) == THUMB2_MOVWI); \ - thumb.i = (thumb.i & 0xfbf00f00) | q0 | q1 | q2 | q3; \ - thumb2code(thumb.s[0], thumb.s[1], u.s[0], u.s[1]); \ - im >>= 16; \ - q0 = (im & 0xf000) << 4; \ - q1 = (im & 0x0800) << 15; \ - q2 = (im & 0x0700) << 4; \ - q3 = im & 0x00ff; \ - code2thumb(thumb.s[0], thumb.s[1], u.s[2], u.s[3]); \ - assert( (thumb.i & 0xfbf00000) == THUMB2_MOVTI); \ - thumb.i = (thumb.i & 0xfbf00f00) | q0 | q1 | q2 | q3; \ - thumb2code(thumb.s[0], thumb.s[1], u.s[2], u.s[3]); \ -} -#else -#define jit_patch_movi(i0, i1) \ -{ \ - union { \ - short *s; \ - int *i; \ - void *v; \ - } u; \ - jit_thumb_t thumb; \ - unsigned int im; \ - int q0, q1, q2, q3; \ - im = (unsigned int)i1; u.v = i0; \ -\ - if (jit_armv6_p()) { \ - q0 = im & 0xfff; \ - q1 = (im & 0xf000) << 4; \ - q2 = (im & 0xfff0000) >> 16; \ - q3 = (im & 0xf0000000) >> 12; \ - assert( (u.i[0] & 0x0ff00000) == (ARM_MOVWI)); \ - assert( (u.i[1] & 0x0ff00000) == (ARM_MOVTI)); \ - u.i[0] = (u.i[0] & 0xfff0f000) | q1 | q0; \ - u.i[1] = (u.i[1] & 0xfff0f000) | q3 | q2; \ - } \ - else { \ - q0 = im & 0x000000ff; q1 = im & 0x0000ff00; \ - q2 = im & 0x00ff0000; q3 = im & 0xff000000; \ - assert( (u.i[0] & 0x0ff00000) == (ARM_MOV|ARM_I)); \ - u.i[0] = (u.i[0] & 0xfffff000) | encode_arm_immediate(q3); \ - assert( (u.i[1] & 0x0ff00000) == (ARM_ORR|ARM_I)); \ - u.i[1] = (u.i[1] & 0xfffff000) | encode_arm_immediate(q2); \ - assert( (u.i[2] & 0x0ff00000) == (ARM_ORR|ARM_I)); \ - u.i[2] = (u.i[2] & 0xfffff000) | encode_arm_immediate(q1); \ - assert( (u.i[3] & 0x0ff00000) == (ARM_ORR|ARM_I)); \ - u.i[3] = (u.i[3] & 0xfffff000) | encode_arm_immediate(q0); \ - } \ -} -#endif - -#define jit_patch_calli(i0, i1) jit_patch_at(i0, i1) - -#ifdef USE_THUMB_CODE -#define jit_patch_at(jump, label) \ -{ \ - long d; \ - union { \ - short *s; \ - int *i; \ - void *v; \ - } u; \ - jit_thumb_t thumb; \ - u.v = jump; \ - if (jump >= _jitl.thumb_pc) \ - { \ - code2thumb(thumb.s[0], thumb.s[1], u.s[0], u.s[1]); \ - if ((thumb.i & THUMB2_B) == THUMB2_B) { \ - d = (((long)label - (long)jump) >> 1) - 2; \ - assert(_s24P(d)); \ - thumb.i = THUMB2_B | encode_thumb_jump(d); \ - thumb2code(thumb.s[0], thumb.s[1], u.s[0], u.s[1]); \ - } \ - else if ((thumb.i & THUMB2_B) == THUMB2_CC_B) { \ - d = (((long)label - (long)jump) >> 1) - 2; \ - assert(_s20P(d)); \ - thumb.i = THUMB2_CC_B | (thumb.i & 0x3c00000) | \ - encode_thumb_cc_jump(d); \ - thumb2code(thumb.s[0], thumb.s[1], u.s[0], u.s[1]); \ - } \ - else if ((thumb.i & 0xfbf08000) == THUMB2_MOVWI) { \ - jit_patch_movi(jump, label); \ - } else \ - assert(!"handled branch opcode"); \ - } else { \ - /* 0x0e000000 because 0x01000000 is (branch&) link modifier */ \ - if ((u.i[0] & 0x0e000000) == ARM_B) { \ - d = (((long)label - (long)jump) >> 2) - 2; \ - assert(_s24P(d)); \ - u.i[0] = (u.i[0] & 0xff000000) | (d & 0x00ffffff); \ - } else if ((jit_armv6_p() && (u.i[0] & 0x0ff00000) == ARM_MOVWI) || \ - (!jit_armv6_p() && (u.i[0] & 0x0ff00000) == (ARM_MOV|ARM_I))) { \ - jit_patch_movi(jump, label); \ - } else { \ - assert(!"handled branch opcode"); \ - } \ - } \ -} -#else -#define jit_patch_at(jump, label) \ -{ \ - union { \ - short *s; \ - int *i; \ - void *v; \ - } u; \ - u.v = jump; \ - /* 0x0e000000 because 0x01000000 is (branch&) link modifier */ \ - if ((u.i[0] & 0x0e000000) == ARM_B) { \ - long d = (((long)label - (long)jump) >> 2) - 2; \ - assert(_s24P(d)); \ - u.i[0] = (u.i[0] & 0xff000000) | (d & 0x00ffffff); \ - } else if ((jit_armv6_p() && (u.i[0] & 0x0ff00000) == ARM_MOVWI) || \ - (!jit_armv6_p() && (u.i[0] & 0x0ff00000) == (ARM_MOV|ARM_I))) { \ - jit_patch_movi(jump, label); \ - } else { \ - assert(!"handled branch opcode"); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_notr_i(r0, r1) \ - ((!jit_no_set_flags() && (r0|r1) < 8) ? T1_NOT(r0, r1) : T2_NOT(r0, r1)) -#else -#define jit_notr_i(r0, r1) \ - _NOT(r0, r1) -#endif - -#ifdef USE_THUMB_CODE -#define jit_negr_i(r0, r1) \ - ((!jit_no_set_flags() && (r0|r1) < 8) ? T1_RSBI(r0, r1), T2_RSBI(r0, r1, 0)) -#else -#define jit_negr_i(r0, r1) \ - _RSBI(r0, r1, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_addr_i(r0, r1, r2) \ -{ \ - if (!jit_no_set_flags() && (r0|r1|r2) < 8) \ - T1_ADD(r0, r1, r2); \ - else if (r0 == r1 || r0 == r2) \ - T1_ADDX(r0, r0 == r1 ? r2 : r1); \ - else \ - T2_ADD(r0, r1, r2); \ -} -#else -#define jit_addr_i(r0, r1, r2) \ - _ADD(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_addi_i(r0, r1, i0) \ -{ \ - int i; \ - jit_gpr_t reg; \ - if (!jit_no_set_flags() && (r0|r1) < 8 && !(i0 & ~7)) \ - T1_ADDI3(r0, r1, i0); \ - else if (!jit_no_set_flags() && (r0|r1) < 8 && !(-i0 & ~7)) \ - T1_SUBI3(r0, r1, -i0); \ - else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(i0 & ~0xff)) \ - T1_ADDI8(r0, i0); \ - else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(-i0 & ~0xff)) \ - T1_SUBI8(r0, -i0); \ - else if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_ADDI(r0, r1, i); \ - else if ((i = encode_thumb_immediate(-i0)) != -1) \ - T2_SUBI(r0, r1, i); \ - else if ((i = encode_thumb_word_immediate(i0)) != -1) \ - T2_ADDWI(r0, r1, i); \ - else if ((i = encode_thumb_word_immediate(-i0)) != -1) \ - T2_SUBWI(r0, r1, i); \ - else { \ - reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - T2_ADD(r0, r1, reg); \ - } \ -} -#else -#define jit_addi_i(r0, r1, i0) \ - (encode_arm_immediate(i0) != -1) ? \ - _ADDI(r0, r1, encode_arm_immediate(i0)) : \ - ((encode_arm_immediate(-i0) != -1) ? \ - _SUBI(r0, r1, encode_arm_immediate(-i0)) : \ - (jit_movi_i(JIT_TMP, i0), _ADD(r0, r1, JIT_TMP))) -#endif - -#ifdef USE_THUMB_CODE -#define jit_addcr_i(r0, r1, r2) \ - /* thumb auto set carry if not inside IT block */ \ - ((r0|r1|r2) < 8) ? T1_ADD(r0, r1, r2) : T2_ADDS(r0, r1, r2) -#else -#define jit_addcr_i(r0, r1, r2) \ - _ADDS(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_addci_i(r0, r1, i0) \ -{ \ - int i; \ - if ((r0|r1) < 8 && !(i0 & ~7)) \ - T1_ADDI3(r0, r1, i0); \ - else if ((r0|r1) < 8 && !(-i0 & ~7)) \ - T1_SUBI3(r0, r1, -i0); \ - else if (r0 < 8 && r0 == r1 && !(i0 & ~0xff)) \ - T1_ADDI8(r0, i0); \ - else if (r0 < 8 && r0 == r1 && !(-i0 & ~0xff)) \ - T1_SUBI8(r0, -i0); \ - else if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_ADDSI(r0, r1, i); \ - else if ((i = encode_thumb_immediate(-i0)) != -1) \ - T2_SUBSI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - T2_ADDS(r0, r1, reg); \ - } \ -} -#else -#define jit_addci_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _ADDSI(r0, r1, i); \ - else if ((i = encode_arm_immediate(-i0)) != -1) \ - _SUBSI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _ADDS(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_addxr_i(r0, r1, r2) \ -{ /* keep setting carry because don't know last ADC */ \ - /* thumb auto set carry if not inside IT block */ \ - if ((r0|r1|r2) < 8 && (r0 == r1 || r0 == r2)) \ - T1_ADC(r0, r0 == r1 ? r2 : r1); \ - else \ - T2_ADCS(r0, r1, r2); \ -} -#else -#define jit_addxr_i(r0, r1, r2) \ - /* keep setting carry because don't know last ADC */ \ - _ADCS(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_addxi_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_ADCSI(r0, r1, i); \ - else if ((i = encode_thumb_immediate(-i0)) != -1) \ - T2_SBCSI(r0, r1, i); \ - else { \ - int no_set_flags = jit_no_set_flags(); \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_no_set_flags() = 1; \ - jit_movi_i(reg, i0); \ - jit_no_set_flags() = no_set_flags; \ - T2_ADCS(r0, r1, reg); \ - } \ -} -#else -#define jit_addxi_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _ADCSI(r0, r1, i); \ - else if ((i = encode_arm_immediate(-i0)) != -1) \ - _SBCSI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _ADCS(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_subr_i(r0, r1, r2) \ -{ \ - if (!jit_no_set_flags() && (r0|r1|r2) < 8) \ - T1_SUB(r0, r1, r2); \ - else \ - T2_SUB(r0, r1, r2); \ -} -#else -#define jit_subr_i(r0, r1, r2) \ - _SUB(r0, r1, r2); -#endif - -#ifdef USE_THUMB_CODE -#define jit_subi_i(r0, r1, i0) \ -{ \ - int i; \ - if (!jit_no_set_flags() && (r0|r1) < 8 && !(i0 & ~7)) \ - T1_SUBI3(r0, r1, i0); \ - else if (!jit_no_set_flags() && (r0|r1) < 8 && !(-i0 & ~7)) \ - T1_ADDI3(r0, r1, -i0); \ - else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(i0 & ~0xff)) \ - T1_SUBI8(r0, i0); \ - else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(-i0 & ~0xff)) \ - T1_ADDI8(r0, -i0); \ - else if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_SUBI(r0, r1, i); \ - else if ((i = encode_thumb_immediate(-i0)) != -1) \ - T2_ADDI(r0, r1, i); \ - else if ((i = encode_thumb_word_immediate(i0)) != -1) \ - T2_SUBWI(r0, r1, i); \ - else if ((i = encode_thumb_word_immediate(-i0)) != -1) \ - T2_ADDWI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - T2_SUB(r0, r1, reg); \ - } \ -} -#else -#define jit_subi_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _SUBI(r0, r1, i); \ - else if ((i = encode_arm_immediate(-i0)) != -1) \ - _ADDI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _SUB(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_subcr_i(r0, r1, r2) \ - /* thumb auto set carry if not inside IT block */ \ - ((r0|r1|r2) < 8) ? T1_SUB(r0, r1, r2) : T2_SUBS(r0, r1, r2) -#else -#define jit_subcr_i(r0, r1, r2) \ - _SUBS(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_subci_i(r0, r1, i0) \ -{ \ - int i; \ - if ((r0|r1) < 8 && !(i0 & ~7)) \ - T1_SUBI3(r0, r1, i0); \ - else if ((r0|r1) < 8 && !(-i0 & ~7)) \ - T1_ADDI3(r0, r1, -i0); \ - else if (r0 < 8 && r0 == r1 && !(i0 & ~0xff)) \ - T1_SUBI8(r0, i0); \ - else if (r0 < 8 && r0 == r1 && !(-i0 & ~0xff)) \ - T1_ADDI8(r0, -i0); \ - else if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_SUBSI(r0, r1, i); \ - else if ((i = encode_thumb_immediate(-i0)) != -1) \ - T2_ADDSI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - T2_SUBS(r0, r1, reg); \ - } \ -} -#else -#define jit_subci_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _SUBSI(r0, r1, i); \ - else if ((i = encode_arm_immediate(-i0)) != -1) \ - _ADDSI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _SUBS(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_subxr_i(r0, r1, r2) \ - /* keep setting carry because don't know last ADC */ \ - /* thumb auto set carry if not inside IT block */ \ - ((r0|r1|r2) < 8 && r0 == r1) ? T1_SBC(r0, r2) : T2_SBCS(r0, r1, r2) -#else -#define jit_subxr_i(r0, r1, r2) \ - /* keep setting carry because don't know last ADC */ \ - _SBCS(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_subxi_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_SBCSI(r0, r1, i); \ - else if ((i = encode_thumb_immediate(-i0)) != -1) \ - T2_ADCSI(r0, r1, i); \ - else { \ - int no_set_flags = jit_no_set_flags(); \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_no_set_flags() = 1; \ - jit_movi_i(reg, i0); \ - jit_no_set_flags() = no_set_flags; \ - T2_SBCS(r0, r1, reg); \ - } \ -} -#else -#define jit_subxi_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _SBCSI(r0, r1, i); \ - else if ((i = encode_arm_immediate(-i0)) != -1) \ - _ADCSI(r0, r1, i); \ - else { \ - reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _SBCS(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_rsbr_i(r0, r1, r2) \ - T2_RSB(r0, r1, r2) -#else -#define jit_rsbr_i(r0, r1, r2) \ - _RSB(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_rsbi_i(r0, r1, i0) \ -{ \ - int i; \ - if (i0 == 0) \ - jit_negr_i(r0, r1); \ - else if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_RSBI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - T2_RSB(r0, r1, reg); \ - } \ -} -#else -#define jit_rsbi_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _RSBI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _RSB(r0, r1, reg); \ - } \ -} -#endif - -#define jit_mulr_i(r0, r1, r2) jit_mulr_ui(r0, r1, r2) -#ifdef USE_THUMB_CODE -#define jit_mulr_ui(r0, r1, r2) \ -{ \ - if (!jit_no_set_flags() && r0 == r2 && (r0|r1) < 8) \ - T1_MUL(r0, r1); \ - else if (!jit_no_set_flags() && r0 == r1 && (r0|r2) < 8) \ - T1_MUL(r0, r2); \ - else \ - T2_MUL(r0, r1, r2); \ -} -#else -#define jit_mulr_ui(r0, r1, r2) \ -{ \ - if (r0 == r1 && !jit_armv6_p()) { \ - if (r0 != r2) \ - _MUL(r0, r2, r1); \ - else { \ - _MOV(JIT_TMP, r1); \ - _MUL(r0, JIT_TMP, r2); \ - } \ - } \ - else \ - _MUL(r0, r1, r2); \ -} -#endif - -#define jit_muli_i(r0, r1, i0) jit_muli_ui(r0, r1, i0) -#define jit_muli_ui(r0, r1, i0) \ -{ \ - jit_gpr_t reg; \ - reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - jit_mulr_i(r0, r1, reg); \ -} - -#ifdef USE_THUMB_CODE -#define jit_hmulr_i(r0, r1, r2) \ - T2_SMULL(JIT_TMP, r0, r1, r2) -#else -#define jit_hmulr_i(r0, r1, r2) \ -{ \ - if (r0 == r1 && !jit_armv6_p()) { \ - assert(r2 != JIT_TMP); \ - _SMULL(JIT_TMP, r0, r2, r1); \ - } \ - else \ - _SMULL(JIT_TMP, r0, r1, r2); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_hmuli_i(r0, r1, i0) \ -{ \ - assert(r0 != JIT_TMP); \ - jit_movi_i(JIT_TMP, i0); \ - T2_SMULL(JIT_TMP, r0, r1, JIT_TMP); \ -} -#else -#define jit_hmuli_i(r0, r1, i0) \ -{ \ - jit_gpr_t reg; \ - if (r0 != r1 || jit_armv6_p()) { \ - jit_movi_i(JIT_TMP, i0); \ - _SMULL(JIT_TMP, r0, r1, JIT_TMP); \ - } \ - else { \ - if (r0 != _R0) reg = _R0; \ - else if (r0 != _R1) reg = _R1; \ - else if (r0 != _R2) reg = _R2; \ - else reg = _R3; \ - _PUSH(1<= 0 && i0 <= 31); \ - if (i0 == 0) \ - jit_movr_i(r0, r1); \ - else \ - if (!jit_no_set_flags() && (r0|r1) < 8) \ - T1_LSLI(r0, r1, i0); \ - else \ - T2_LSLI(r0, r1, i0); \ -} -#else -#define jit_lshi_i(r0, r1, i0) \ -{ \ - assert(i0 >= 0 && i0 <= 31); \ - if (i0 == 0) \ - jit_movr_i(r0, r1); \ - else \ - _LSLI(r0, r1, i0); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_rshr_i(r0, r1, r2) \ -{ \ - if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1) \ - T1_ASR(r0, r2); \ - else \ - T2_ASR(r0, r1, r2); \ -} -#else -#define jit_rshr_i(r0, r1, r2) \ - _ASR(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_rshi_i(r0, r1, i0) \ -{ \ - assert(i0 >= 0 && i0 <= 31); \ - if (i0 == 0) \ - jit_movr_i(r0, r1); \ - else if (!jit_no_set_flags() && (r0|r1) < 8) \ - T1_ASRI(r0, r1, i0); \ - else \ - T2_ASRI(r0, r1, i0); \ -} -#else -#define jit_rshi_i(r0, r1, i0) \ -{ \ - assert(i0 >= 0 && i0 <= 31); \ - if (i0 == 0) \ - jit_movr_i(r0, r1); \ - else \ - _ASRI(r0, r1, i0); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_rshr_ui(r0, r1, r2) \ -{ \ - if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1) \ - T1_LSR(r0, r2); \ - else \ - T2_LSR(r0, r1, r2); \ -} -#else -#define jit_rshr_ui(r0, r1, r2) \ - _LSR(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_rshi_ui(r0, r1, i0) \ -{ \ - assert(i0 >= 0 && i0 <= 31); \ - if (i0 == 0) \ - jit_movr_i(r0, r1); \ - else if (!jit_no_set_flags() && (r0|r1) < 8) \ - T1_LSRI(r0, r1, i0); \ - else \ - T2_LSRI(r0, r1, i0); \ -} -#else -#define jit_rshi_ui(r0, r1, i0) \ -{ \ - assert(i0 >= 0 && i0 <= 31); \ - if (i0 == 0) \ - jit_movr_i(r0, r1); \ - else \ - _LSRI(r0, r1, i0); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define arm_ccr(ct, cf, r0, r1, r2) \ -{ \ - assert((ct ^ cf) >> 28 == 1); \ - if ((r1|r2) < 8) \ - T1_CMP(r1, r2); \ - else if ((r1&r2) & 8) \ - T1_CMPX(r1, r2); \ - else \ - T2_CMP(r1, r2); \ - _ITE(ct); \ - if (r0 < 8) { \ - T1_MOVI(r0, 1); \ - T1_MOVI(r0, 0); \ - } else { \ - T2_MOVI(r0, 1); \ - T2_MOVI(r0, 0); \ - } \ -} -#else -#define arm_ccr(ct, cf, r0, r1, r2) \ -{ \ - _CMP(r1, r2); \ - _CC_MOVI(ct, r0, 1); \ - _CC_MOVI(cf, r0, 0); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define arm_cci(ct, cf, r0, r1, i0) \ -{ \ - int i; \ - if (r1 < 7 && !(i0 & 0xffffff00)) \ - T1_CMPI(r1, i0); \ - else if ((i = encode_thumb_immediate(i0)) != -1) \ - T2_CMPI(r1, i); \ - else if ((i = encode_thumb_immediate(-i0)) != -1) \ - T2_CMNI(r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - arm_ccr(_jit, ct, cf, r0, r1, reg); \ - goto next; \ - } \ - _ITE(ct); \ - if (r0 < 8) { \ - T1_MOVI(r0, 1); \ - T1_MOVI(r0, 0); \ - } \ - else { \ - T2_MOVI(r0, 1); \ - T2_MOVI(r0, 0); \ - } \ -next: \ -} -#else -#define arm_cci(ct, cf, r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _CMPI(r1, i); \ - else if ((i = encode_arm_immediate(-i0)) != -1) \ - _CMNI(r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _CMP(r1, reg); \ - } \ - _CC_MOVI(ct, r0, 1); \ - _CC_MOVI(cf, r0, 0); \ -} -#endif - -#define jit_ltr_i(r0, r1, r2) arm_ccr(_jit,ARM_CC_LT,ARM_CC_GE,r0,r1,r2) -#define jit_lti_i(r0, r1, i0) arm_cci(_jit,ARM_CC_LT,ARM_CC_GE,r0,r1,i0) -#define jit_ltr_ui(r0, r1, r2) arm_ccr(_jit,ARM_CC_LO,ARM_CC_HS,r0,r1,r2) -#define jit_lti_ui(r0, r1, i0) arm_cci(_jit,ARM_CC_LO,ARM_CC_HS,r0,r1,i0) -#define jit_ler_i(r0, r1, r2) arm_ccr(_jit,ARM_CC_LE,ARM_CC_GT,r0,r1,r2) -#define jit_lei_i(r0, r1, i0) arm_cci(_jit,ARM_CC_LE,ARM_CC_GT,r0,r1,i0) -#define jit_ler_ui(r0, r1, r2) arm_ccr(_jit,ARM_CC_LS,ARM_CC_HI,r0,r1,r2) -#define jit_lei_ui(r0, r1, i0) arm_cci(_jit,ARM_CC_LS,ARM_CC_HI,r0,r1,i0) -#define jit_eqr_i(r0, r1, r2) arm_ccr(_jit,ARM_CC_EQ,ARM_CC_NE,r0,r1,r2) -#define jit_eqi_i(r0, r1, i0) arm_cci(_jit,ARM_CC_EQ,ARM_CC_NE,r0,r1,i0) -#define jit_ger_i(r0, r1, r2) arm_ccr(_jit,ARM_CC_GE,ARM_CC_LT,r0,r1,r2) -#define jit_gei_i(r0, r1, i0) arm_cci(_jit,ARM_CC_GE,ARM_CC_LT,r0,r1,i0) -#define jit_ger_ui(r0, r1, r2) arm_ccr(_jit,ARM_CC_HS,ARM_CC_LO,r0,r1,r2) -#define jit_gei_ui(r0, r1, i0) arm_cci(_jit,ARM_CC_HS,ARM_CC_LO,r0,r1,i0) -#define jit_gtr_i(r0, r1, r2) arm_ccr(_jit,ARM_CC_GT,ARM_CC_LE,r0,r1,r2) -#define jit_gti_i(r0, r1, i0) arm_cci(_jit,ARM_CC_GT,ARM_CC_LE,r0,r1,i0) -#define jit_gtr_ui(r0, r1, r2) arm_ccr(_jit,ARM_CC_HI,ARM_CC_LS,r0,r1,r2) -#define jit_gti_ui(r0, r1, i0) arm_cci(_jit,ARM_CC_HI,ARM_CC_LS,r0,r1,i0) - -#ifdef USE_THUMB_CODE -#define jit_ner_i(r0, r1, r2) \ - arm_ccr(_jit, ARM_CC_NE, ARM_CC_EQ, r0, r1, r2) -#else -#define jit_ner_i(r0, r1, r2) \ - (_SUBS(r0, r1, r2), _CC_MOVI(ARM_CC_NE, r0, 1)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_nei_i(r0, r1, i0) \ - arm_cci(_jit, ARM_CC_NE, ARM_CC_EQ, r0, r1, i0) -#else -#define jit_nei_i(r0, r1, i0) \ -{ \ - int i; \ - if ((i = encode_arm_immediate(i0)) != -1) \ - _SUBSI(r0, r1, i); \ - else if ((i = encode_arm_immediate(-i0)) != -1) \ - _ADDSI(r0, r1, i); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _SUBS(r0, r1, reg); \ - } \ - _CC_MOVI(ARM_CC_NE, r0, 1); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_jmpr(r0) T1_MOV(_R15, r0) -#else -#define jit_jmpr(r0) _MOV(_R15, r0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_jmpi(i0) \ - (_jitl.thumb_tmp = _jit.x.pc, \ - (_jitl.after_prolog) ? \ - ((_s20P((((long)i0 - (long)_jitl.thumb_tmp) >> 1) - 2)) ? \ - T2_B(encode_thumb_jump((((long)i0 - (long)_jitl.thumb_tmp) >> 1) - 2)) : \ - (jit_movi_p(JIT_TMP, i0), jit_jmpr(JIT_TMP))) : \ - (assert(_s24P((((long)i0 - (long)_jitl.thumb_tmp) >> 2) - 2)), \ - _CC_B(ARM_CC_AL, ((((long)i0 - (long)_jitl.thumb_tmp) >> 2) - 2) & 0x00ffffff)) \ - _jitl.thumb_tmp) -#else -#define jit_jmpi(i0) \ - (_jitl.thumb_tmp = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)_jitl.thumb_tmp) >> 2) - 2)), \ - _CC_B(ARM_CC_AL, ((((long)i0 - (long)_jitl.thumb_tmp) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_tmp) -#endif - -#ifdef USE_THUMB_CODE -#define arm_bccr(cc, i0, r0, r1) \ - (((r0|r1) < 8) ? T1_CMP(r0, r1) : (((r0&r1) & 8) ? T1_CMPX(r0, r1) : T2_CMP(r0, r1)), \ - /* use only thumb2 conditional as does not know if will be patched */ \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s20P((((long)i0 - (long)l) >> 1) - 2)), \ - T2_CC_B(cc, encode_thumb_cc_jump((((long)i0 - (long)l) >> 1) - 2)), \ - _jitl.thumb_tmp) -#else -#define arm_bccr(cc, i0, r0, r1) \ - (_CMP(r0, r1), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s24P((((long)(i0) - (long)_jit.x.pc) >> 2) - 2)), \ - _CC_B(cc, ((((long)(i0) - (long)_jit.x.pc) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_tmp) -#endif - -#ifdef USE_THUMB_CODE -#define arm_bcci(cc, i0, r0, i1) \ - (((r0 < 7 && !(i1 & 0xffffff00)) ? \ - T1_CMPI(r0, i1) : \ - ((encode_thumb_immediate(i1) != -1) ? \ - T2_CMPI(r0, encode_thumb_immediate(i1)) : \ - ((encode_thumb_immediate(-i1) != -1) ? \ - T2_CMNI(r0, encode_thumb_immediate(-i1)) : \ - (jit_movi_i(JIT_TMP, i1), T2_CMP(r0, JIT_TMP))))), \ - /* use only thumb2 conditional as does not know if will be patched */ \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s20P((((long)i0 - (long)_jitl.thumb_tmp) >> 1) - 2)), \ - T2_CC_B(cc, encode_thumb_cc_jump((((long)i0 - (long)l) >> 1) - 2)), \ - _jitl.thumb_tmp) -#else -#define arm_bcci(cc, i0, r0, i1) \ - (((encode_arm_immediate(i1) != -1) ? \ - _CMPI(r0, encode_arm_immediate(i1)) : \ - ((encode_arm_immediate(-i1) != -1) ? \ - _CMNI(r0, encode_arm_immediate(-i1)) : \ - (jit_movi_i(JIT_TMP, i1), _CMP(r0, JIT_TMP)))), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)_jitl.thumb_tmp) >> 2) - 2)), \ - _CC_B(cc, ((((long)i0 - (long)_jitl.thumb_tmp) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_tmp) -#endif - -#define jit_bltr_i(i0, r0, r1) arm_bccr(ARM_CC_LT, i0, r0, r1) -#define jit_blti_i(i0, r0, i1) arm_bcci(ARM_CC_LT, i0, r0, i1) -#define jit_bltr_ui(i0, r0, r1) arm_bccr(ARM_CC_LO, i0, r0, r1) -#define jit_blti_ui(i0, r0, i1) arm_bcci(ARM_CC_LO, i0, r0, i1) -#define jit_bler_i(i0, r0, r1) arm_bccr(ARM_CC_LE, i0, r0, r1) -#define jit_blei_i(i0, r0, i1) arm_bcci(ARM_CC_LE, i0, r0, i1) -#define jit_bler_ui(i0, r0, r1) arm_bccr(ARM_CC_LS, i0, r0, r1) -#define jit_blei_ui(i0, r0, i1) arm_bcci(ARM_CC_LS, i0, r0, i1) -#define jit_beqr_i(i0, r0, r1) arm_bccr(ARM_CC_EQ, i0, r0, r1) -#define jit_beqi_i(i0, r0, i1) arm_bcci(ARM_CC_EQ, i0, r0, i1) -#define jit_bger_i(i0, r0, r1) arm_bccr(ARM_CC_GE, i0, r0, r1) -#define jit_bgei_i(i0, r0, i1) arm_bcci(ARM_CC_GE, i0, r0, i1) -#define jit_bger_ui(i0, r0, r1) arm_bccr(ARM_CC_HS, i0, r0, r1) -#define jit_bgei_ui(i0, r0, i1) arm_bcci(ARM_CC_HS, i0, r0, i1) -#define jit_bgtr_i(i0, r0, r1) arm_bccr(ARM_CC_GT, i0, r0, r1) -#define jit_bgti_i(i0, r0, i1) arm_bcci(ARM_CC_GT, i0, r0, i1) -#define jit_bgtr_ui(i0, r0, r1) arm_bccr(ARM_CC_HI, i0, r0, r1) -#define jit_bgti_ui(i0, r0, i1) arm_bcci(ARM_CC_HI, i0, r0, i1) -#define jit_bner_i(i0, r0, r1) arm_bccr(ARM_CC_NE, i0, r0, r1) -#define jit_bnei_i(i0, r0, i1) arm_bcci(ARM_CC_NE, i0, r0, i1) - -#ifdef USE_THUMB_CODE -#define arm_baddr(cc, i0, r0, r1) \ - (((r0|r1) < 8) ? T1_ADD(r0, r0, r1) : T2_ADDS(r0, r0, r1), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s20P((((long)i0 - (long)l) >> 1) - 2)), \ - T2_CC_B(cc, encode_thumb_cc_jump((((long)i0 - (long)l) >> 1) - 2)), \ - _jitl.thumb_tmp) -#else -#define arm_baddr(cc, i0, r0, r1) \ - (_ADDS(r0, r0, r1), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)l) >> 2) - 2)), \ - _CC_B(cc, ((((long)i0 - (long)l) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_tmp) -#endif - -#ifdef USE_THUMB_CODE -#define arm_baddi(cc, i0, r0, i1) \ - (((r0 < 8 && !(i1 & ~7)) ? \ - T1_ADDI3(r0, r0, i1) : \ - ((r0 < 8 && !(-i1 & ~7)) ? \ - T1_SUBI3(r0, r0, -i1) : \ - ((r0 < 8 && !(i1 & ~0xff)) ? \ - T1_ADDI8(r0, i1) : \ - ((r0 < 8 && !(-i1 & ~0xff)) ? \ - T1_SUBI8(r0, -i1) : \ - ((encode_thumb_immediate(i1) != -1) ? \ - T2_ADDSI(r0, r0, encode_thumb_immediate(i1)) : \ - ((encode_thumb_immediate(-i1) != -1) ? \ - T2_SUBSI(r0, r0, encode_thumb_immediate(-i1)) : \ - (jit_movi_i(JIT_TMP, i1), T2_ADDS(r0, r0, JIT_TMP)))))))), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s20P((((long)i0 - (long)l) >> 1) - 2)), \ - T2_CC_B(cc, encode_thumb_cc_jump((((long)i0 - (long)l) >> 1) - 2)), \ - _jitl.thumb_tmp) -#else -#define arm_baddi(cc, i0, r0, i1) \ - (((encode_arm_immediate(i1) != -1) ? \ - _ADDSI(r0, r0, encode_arm_immediate(i1)) : \ - ((encode_arm_immediate(-i1) != -1) ? \ - _SUBSI(r0, r0, encode_arm_immediate(-i1)) : \ - (jit_movi_i(JIT_TMP, i1), _ADDS(r0, r0, JIT_TMP)))), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)l) >> 2) - 2)), \ - _CC_B(cc, ((((long)i0 - (long)l) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_tmp) -#endif - -#define jit_boaddr_i(i0, r0, r1) arm_baddr(ARM_CC_VS, i0, r0, r1) -#define jit_boaddi_i(i0, r0, i1) arm_baddi(ARM_CC_VS, i0, r0, i1) -#define jit_boaddr_ui(i0, r0, r1) arm_baddr(ARM_CC_HS, i0, r0, r1) -#define jit_boaddi_ui(i0, r0, i1) arm_baddi(ARM_CC_HS, i0, r0, i1) - -#ifdef USE_THUMB_CODE -#define arm_bsubr(cc, i0, r0, r1) \ - (((r0|r1) < 8) ? T1_SUB(r0, r0, r1) : T2_SUBS(r0, r0, r1), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s20P((((long)i0 - (long)l) >> 1) - 2)), \ - T2_CC_B(cc, encode_thumb_cc_jump((((long)i0 - (long)l) >> 1) - 2)), \ - _jitl.thumb_tmp) -#else -#define arm_bsubr(cc, i0, r0, r1) \ - (_SUBS(r0, r0, r1), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)l) >> 2) - 2)), \ - _CC_B(cc, ((((long)i0 - (long)l) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_tmp) -#endif - -#ifdef USE_THUMB_CODE -#define arm_bsubi(cc, i0, r0, i1) \ - (((r0 < 8 && !((i1) & ~7)) ? \ - T1_SUBI3(r0, r0, i1) : \ - ((r0 < 8 && !(-(i1) & ~7)) ? \ - T1_ADDI3(r0, r0, -i1) : \ - ((r0 < 8 && !((i1) & ~0xff)) ? \ - T1_SUBI8(r0, i1) : \ - ((r0 < 8 && !(-(i1) & ~0xff)) ? \ - T1_ADDI8(r0, -(i1)) : \ - ((encode_thumb_immediate(i1) != -1) ? \ - T2_SUBSI(r0, r0, encode_thumb_immediate(i1)) : \ - ((encode_thumb_immediate(-i1) != -1) ? \ - T2_ADDSI(r0, r0, encode_thumb_immediate(-i1)) : \ - (jit_movi_i(JIT_TMP, i1), T2_SUBS(r0, r0, JIT_TMP)))))))), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s20P((((long)i0 - (long)_jitl.thumb_tmp) >> 1) - 2)), \ - T2_CC_B(cc, encode_thumb_cc_jump((((long)(i0) - (long)_jitl.thumb_tmp) >> 1) - 2)), \ - _jitl.thumb_tmp) -#else -#define arm_bsubi(cc, i0, r0, i1) \ - (((encode_arm_immediate(i1) != -1) ? \ - _SUBSI(r0, r0, encode_arm_immediate(i1)) : \ - ((encode_arm_immediate(-i1) != -1) ? \ - _ADDSI(r0, r0, encode_arm_immediate(-i1)) : \ - (jit_movi_i(JIT_TMP, i1), _SUBS(r0, r0, JIT_TMP)))), \ - _jitl.thumb_tmp = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)l) >> 2) - 2)), \ - _CC_B(cc, ((((long)i0 - (long)l) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_tmp) -#endif - -#define jit_bosubr_i(i0, r0, r1) arm_bsubr(ARM_CC_VS, i0, r0, r1) -#define jit_bosubi_i(i0, r0, i1) arm_bsubi(ARM_CC_VS, i0, r0, i1) -#define jit_bosubr_ui(i0, r0, r1) arm_bsubr(ARM_CC_LO, i0, r0, r1) -#define jit_bosubi_ui(i0, r0, i1) arm_bsubi(ARM_CC_LO, i0, r0, i1) - -#ifdef USE_THUMB_CODE -#define arm_bmxr(cc, i0, r0, r1) \ - (((r0|r1) < 8) ? T1_TST(r0, r1) : T2_TST(r0, r1), \ - _jitl.thumb_pc = _jit.x.pc, \ - assert(_s20P((((long)i0 - (long)l) >> 1) - 2)), \ - T2_CC_B(cc, encode_thumb_cc_jump((((long)i0 - (long)l) >> 1) - 2)), \ - _jitl.thumb_pc) -#else -#define arm_bmxr(cc, i0, r0, r1) \ - (((jit_armv5_p()) ? _TST(r0, r1) : _ANDS(JIT_TMP, r0, r1)), \ - _jitl.thumb_pc = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)l) >> 2) - 2)), \ - _CC_B(cc, ((((long)i0 - (long)l) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_pc) -#endif - -#ifdef USE_THUMB_CODE -#define arm_bmxi(cc, i0, r0, i1) \ - ((jit_armv5_p()) ? \ - ((encode_arm_immediate(i1) != -1) ? \ - _TSTI(r0, encode_arm_immediate(i1)) : \ - (jit_movi_i(JIT_TMP, i1), _TST(r0, JIT_TMP))) \ - (((i = encode_arm_immediate(i1)) != -1) ? \ - _ANDSI(JIT_TMP, r0, i) : \ - (((encode_arm_immediate(~i1)) != -1) ? \ - _BICSI(JIT_TMP, r0, encode_arm_immediate(~i1)) : \ - (jit_movi_i(JIT_TMP, i1), _ANDS(JIT_TMP, r0, JIT_TMP)))), \ - _jitl.thumb_pc = _jit.x.pc, \ - assert(_s24P((((long)i0 - (long)_jitl.thumb_pc) >> 2) - 2)), \ - _CC_B(cc, ((((long)i0 - (long)_jitl.thumb_pc) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_pc) -#else -#define arm_bmxi(cc, i0, r0, i1) \ - ((jit_armv5_p()) ? \ - ((encode_arm_immediate(i1) != -1) ? \ - _TSTI(r0, encode_arm_immediate(i1)) : \ - (jit_movi_i(JIT_TMP, i1), _TST(r0, JIT_TMP))) : \ - ((encode_arm_immediate(i1) != -1) ? \ - _ANDSI(JIT_TMP, r0, encode_arm_immediate(i1)) : \ - ((encode_arm_immediate(~(i1)) != -1) ? \ - _BICSI(JIT_TMP, r0, encode_arm_immediate(~i1)) : \ - (jit_movi_i(JIT_TMP, i1), _ANDS(JIT_TMP, r0, JIT_TMP)))), \ - _jitl.thumb_pc = _jit.x.pc, \ - assert(_s24P((((long)(i0) - (long)_jitl.thumb_pc) >> 2) - 2)), \ - _CC_B(cc, ((((long)(i0) - (long)_jitl.thumb_pc) >> 2) - 2) & 0x00ffffff), \ - _jitl.thumb_pc) -#endif - -#define jit_bmsr_i(i0, r0, r1) arm_bmxr(ARM_CC_NE, i0, r0, r1) -#define jit_bmsi_i(i0, r0, i1) arm_bmxi(ARM_CC_NE, i0, r0, i1) -#define jit_bmcr_i(i0, r0, r1) arm_bmxr(ARM_CC_EQ, i0, r0, r1) -#define jit_bmci_i(i0, r0, i1) arm_bmxi(ARM_CC_EQ, i0, r0, i1) - -#ifdef USE_THUMB_CODE -#define jit_ldr_c(r0, r1) T2_LDRSBI(r0, r1, 0) -#else -#define jit_ldr_c(r0, r1) _LDRSBI(r0, r1, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldi_c(r0, i0) \ -{ \ - jit_movi_i(JIT_TMP, (int)i0); \ - T2_LDRSBI(r0, JIT_TMP, 0); \ -} -#else -#define jit_ldi_c(r0, i0) \ -{ \ - jit_movi_i(JIT_TMP, (int)i0); \ - _LDRSBI(r0, JIT_TMP, 0); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxr_c(r0, r1, r2) \ - ((r0|r1|r2) < 8) ? T1_LDRSB(r0, r1, r2) : T2_LDRSB(r0, r1, r2) -#else -#define jit_ldxr_c(r0, r1, r2) _LDRSB(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxi_c(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 255) \ - T2_LDRSBI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -255) \ - T2_LDRSBIN(r0, r1, -i0); \ - else if (i0 >= 0 && i0 <= 4095) \ - T2_LDRSBWI(r0, r1, i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - if ((r0|r1|reg) < 8) \ - T1_LDRSB(r0, r1, reg); \ - else \ - T2_LDRSB(r0, r1, reg); \ - } \ -} -#else -#define jit_ldxi_c(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 255) \ - _LDRSBI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -255) \ - _LDRSBIN(r0, r1, -i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _LDRSB(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldr_uc(r0, r1) T2_LDRBI(r0, r1, 0) -#else -#define jit_ldr_uc(r0, r1) _LDRBI(r0, r1, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldi_uc(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), T2_LDRBI(r0, JIT_TMP, 0)) -#else -#define jit_ldi_uc(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), _LDRBI(r0, JIT_TMP, 0)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxr_uc(r0, r1, r2) \ - ((r0|r1|r2) < 8) ? T1_LDRB(r0, r1, r2) : T2_LDRB(r0, r1, r2) -#else -#define jit_ldxr_uc(r0, r1, r2) _LDRB(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxi_uc(r0, r1, i0) \ -{ \ - if ((r0|r1) < 8 && i0 >= 0 && i0 < 0x20) \ - T1_LDRBI(r0, r1, i0); \ - else if (i0 >= 0 && i0 <= 255) \ - T2_LDRBI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -255) \ - T2_LDRBIN(r0, r1, -i0); \ - else if (i0 >= 0 && i0 <= 4095) \ - T2_LDRBWI(r0, r1, i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - if ((r0|r1|reg) < 8) \ - T1_LDRB(r0, r1, reg); \ - else \ - T2_LDRB(r0, r1, reg); \ - } \ -} -#else -#define jit_ldxi_uc(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 4095) \ - _LDRBI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -4095) \ - _LDRBIN(r0, r1, -i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _LDRB(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldr_s(r0, r1) T2_LDRSHI(r0, r1, 0) -#else -#define jit_ldr_s(r0, r1) _LDRSHI(r0, r1, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldi_s(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), T2_LDRSHI(r0, JIT_TMP, 0)) -#else -#define jit_ldi_s(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), _LDRSHI(r0, JIT_TMP, 0)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxr_s(r0, r1, r2) \ - ((r0|r1|r2) < 8) ? T1_LDRSH(r0, r1, r2) : T2_LDRSH(r0, r1, r2) -#else -#define jit_ldxr_s(r0, r1, r2) _LDRSH(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxi_s(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 255) \ - T2_LDRSHI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -255) \ - T2_LDRSHIN(r0, r1, -i0); \ - else if (i0 >= 0 && i0 <= 4095) \ - T2_LDRSHWI(r0, r1, i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - if ((r0|r1|reg) < 8) \ - T1_LDRSH(r0, r1, reg); \ - else \ - T2_LDRSH(r0, r1, reg); \ - } \ -} -#else -#define jit_ldxi_s(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 255) \ - _LDRSHI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -255) \ - _LDRSHIN(r0, r1, -i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _LDRSH(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldr_us(r0, r1) T2_LDRHI(r0, r1, 0) -#else -#define jit_ldr_us(r0, r1) _LDRHI(r0, r1, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldi_us(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), T2_LDRHI(r0, JIT_TMP, 0)) -#else -#define jit_ldi_us(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), _LDRHI(r0, JIT_TMP, 0)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxr_us(r0, r1, r2) \ - ((r0|r1|r2) < 8) ? T1_LDRH(r0, r1, r2) : T2_LDRH(r0, r1, r2) -#else -#define jit_ldxr_us(r0, r1, r2) _LDRH(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxi_us(r0, r1, i0) \ -{ \ - if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 1) && (i0 >> 1) < 0x20) \ - T1_LDRHI(r0, r1, i0 >> 1); \ - else if (i0 >= 0 && i0 <= 255) \ - T2_LDRHI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -255) \ - T2_LDRHIN(r0, r1, -i0); \ - else if (i0 >= 0 && i0 <= 4095) \ - T2_LDRHWI(r0, r1, i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - if ((r0|r1|reg) < 8) \ - T1_LDRH(r0, r1, reg); \ - else \ - T2_LDRH(r0, r1, reg); \ - } \ -} -#else -#define jit_ldxi_us(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 255) \ - _LDRHI(r0, r1, i0); \ - else if (i0 < 0 && i0 >= -255) \ - _LDRHIN(r0, r1, -i0); \ - else { \ - jit_gpr_t reg = r0 != r1 ? r0 : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _LDRH(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldr_i(r0, r1) T2_LDRI(r0, r1, 0) -#else -#define jit_ldr_i(r0, r1) _LDRI(r0, r1, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldi_i(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), T2_LDRI(r0, JIT_TMP, 0)) -#else -#define jit_ldi_i(r0, i0) \ - (jit_movi_i(JIT_TMP, (int)i0), _LDRI(r0, JIT_TMP, 0)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxr_i(r0, r1, r2) \ - (((r0|r1|r2) < 8) ? T1_LDR(r0, r1, r2) : T2_LDR(r0, r1, r2)) -#else -#define jit_ldxr_i(r0, r1, r2) _LDR(r0, r1, r2) -#endif - -#ifdef USE_THUMB_CODE -#define jit_ldxi_i(r0, r1, i0) \ -{ \ - if (((r0)|(r1)) < 8 && (i0) >= 0 && !((i0) & 3) && ((i0) >> 2) < 0x20) \ - T1_LDRI(r0, r1, (i0) >> 2); \ - else if ((r1) == _R13 && (r0) < 8 && \ - (i0) >= 0 && !((i0) & 3) && ((i0) >> 2) <= 255) \ - T1_LDRISP(r0, (i0) >> 2); \ - else if ((i0) >= 0 && (i0) <= 255) \ - T2_LDRI(r0, r1, i0); \ - else if ((i0) < 0 && (i0) >= -255) \ - T2_LDRIN((r0), (r1), -(i0)); \ - else if ((i0) >= 0 && (i0) <= 4095) \ - T2_LDRWI(r0, r1, i0); \ - else { \ - jit_gpr_t reg = (r0) != (r1) ? (r0) : JIT_TMP; \ - jit_movi_i(reg, i0); \ - if (((r0)|(r1)|reg) < 8) \ - T1_LDR(r0, r1, reg); \ - else \ - T2_LDR(r0, r1, reg); \ - } \ -} -#else -#define jit_ldxi_i(r0, r1, i0) \ -{ \ - if ((i0) >= 0 && (i0) <= 4095) \ - _LDRI(r0, r1, i0); \ - else if ((i0) < 0 && (i0) >= -4095) \ - _LDRIN(r0, r1, -i0); \ - else { \ - jit_gpr_t reg = (r0) != (r1) ? (r0) : JIT_TMP; \ - jit_movi_i(reg, i0); \ - _LDR(r0, r1, reg); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_str_c(r0, r1) T2_STRBI(r1, r0, 0); -#else -#define jit_str_c(r0, r1) _STRBI(r1, r0, 0); -#endif - -#ifdef USE_THUMB_CODE -#define jit_sti_c(r0, i0) (jit_movi_i(JIT_TMP, (int)i0), T2_STRBI(r0, JIT_TMP, 0)) -#else -#define jit_sti_c(r0, i0) (jit_movi_i(JIT_TMP, (int)i0), _STRBI(r0, JIT_TMP, 0)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_stxr_c(r0, r1, r2) \ - (((r0)|(r1)|(r2)) < 8) ? T1_STRB(r2, r1, r0) : T2_STRB(r2, r1, r0) -#else -#define jit_stxr_c(r0, r1, r2) _STRB(r2, r1, r0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_stxi_c(r0, r1, i0) \ -{ \ - if ((r0|r1) < 8 && i0 >= 0 && i0 < 0x20) \ - T1_STRBI(r1, r0, i0); \ - else if (i0 >= 0 && i0 <= 255) \ - T2_STRBI(r1, r0, i0); \ - else if (i0 < 0 && i0 >= -255) \ - T2_STRBIN(r1, r0, -i0); \ - else if (i0 >= 0 && i0 <= 4095) \ - T2_STRBWI(r1, r0, i0); \ - else { \ - jit_movi_i(JIT_TMP, (int)i0); \ - if ((r0|r1|JIT_TMP) < 8) \ - T1_STRB(r1, r0, JIT_TMP); \ - else \ - T2_STRB(r1, r0, JIT_TMP); \ - } \ -} -#else -#define jit_stxi_c(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 4095) \ - _STRBI(r1, r0, i0); \ - else if (i0 < 0 && i0 >= -4095) \ - _STRBIN(r1, r0, -i0); \ - else { \ - jit_movi_i(JIT_TMP, i0); \ - _STRB(r1, r0, JIT_TMP); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_str_s(r0, r1) T2_STRHI(r1, r0, 0) -#else -#define jit_str_s(r0, r1) _STRHI(r1, r0, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_sti_s(r0, i0) (jit_movi_i(JIT_TMP, (int)i0), T2_STRHI(r0, JIT_TMP, 0)) -#else -#define jit_sti_s(r0, i0) (jit_movi_i(JIT_TMP, (int)i0), _STRHI(r0, JIT_TMP, 0)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_stxr_s(r0, r1, r2) \ - ((((r0)|(r1)|(r2)) < 8) ? T1_STRH(r2, r1, r0) : T2_STRH(r2, r1, r0)) -#else -#define jit_stxr_s(r0, r1, r2) _STRH(r2, r1, r0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_stxi_s(r0, r1, i0) \ -{ \ - if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 1) && (i0 >> 1) < 0x20) \ - T1_STRHI(r1, r0, i0 >> 1); \ - else if (i0 >= 0 && i0 <= 255) \ - T2_STRHI(r1, r0, i0); \ - else if (i0 < 0 && i0 >= -255) \ - T2_STRHIN(r1, r0, -i0); \ - else if (i0 >= 0 && i0 <= 4095) \ - T2_STRHWI(r1, r0, i0); \ - else { \ - jit_movi_i(JIT_TMP, (int)i0); \ - if ((r0|r1|JIT_TMP) < 8) \ - T1_STRH(r1, r0, JIT_TMP); \ - else \ - T2_STRH(r1, r0, JIT_TMP); \ - } \ -} -#else -#define jit_stxi_s(r0, r1, i0) \ -{ \ - if (i0 >= 0 && i0 <= 255) \ - _STRHI(r1, r0, i0); \ - else if (i0 < 0 && i0 >= -255) \ - _STRHIN(r1, r0, -i0); \ - else { \ - jit_movi_i(JIT_TMP, i0); \ - _STRH(r1, r0, JIT_TMP); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_str_i(r0, r1) T2_STRI(r1, r0, 0) -#else -#define jit_str_i(r0, r1) _STRI(r1, r0, 0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_sti_i(r0, i0) (jit_movi_i(JIT_TMP, (int)i0), T2_STRI(r0, JIT_TMP, 0)) -#else -#define jit_sti_i(r0, i0) (jit_movi_i(JIT_TMP, (int)i0), _STRI(r0, JIT_TMP, 0)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_stxr_i(r0, r1, r2) ((((r0)|(r1)|(r2)) < 8) ? T1_STR(r2, r1, r0) : T2_STR(r2, r1, r0)) -#else -#define jit_stxr_i(r0, r1, r2) _STR(r2, r1, r0) -#endif - -#ifdef USE_THUMB_CODE -#define jit_stxi_i(i0, r0, r1) \ -{ \ - if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 3) && (i0 >> 2) < 0x20) \ - T1_STRI(r1, r0, i0 >> 2); \ - else if (r0 == _R13 && r1 < 8 && \ - i0 >= 0 && !(i0 & 3) && (i0 >> 2) <= 255) \ - T1_STRISP(r1, i0 >> 2); \ - else if (i0 >= 0 && i0 <= 255) \ - T2_STRI(r1, r0, i0); \ - else if (i0 < 0 && i0 >= -255) \ - T2_STRIN(r1, r0, -i0); \ - else if (i0 >= 0 && i0 <= 4095) \ - T2_STRWI(r1, r0, i0); \ - else { \ - jit_movi_i(JIT_TMP, (int)i0); \ - if ((r0|r1|JIT_TMP) < 8) \ - T1_STR(r1, r0, JIT_TMP); \ - else \ - T2_STR(r1, r0, JIT_TMP); \ - } \ -} -#else -#define jit_stxi_i(i0, r0, r1) \ -{ \ - if (i0 >= 0 && i0 <= 4095) \ - _STRI(r1, r0, i0); \ - else if (i0 < 0 && i0 >= -4095) \ - _STRIN(r1, r0, -i0); \ - else { \ - jit_movi_i(JIT_TMP, i0); \ - _STR(r1, r0, JIT_TMP); \ - } \ -} -#endif - -#if __BYTE_ORDER == __LITTLE_ENDIAN -/* inline glibc htons (without register clobber) */ -#ifdef USE_THUMB_CODE -#define jit_ntoh_us(r0, r1) \ - ((r0|r1) < 8) ? T1_REV16(r0, r1) : T2_REV16(r0, r1) -#else -#define jit_ntoh_us(r0, r1) \ -{ \ - if (jit_armv6_p()) \ - _REV16(r0, r1); \ - else { \ - _LSLI(JIT_TMP, r1, 24); \ - _LSRI(r0, r1, 8); \ - _ORR_SI(r0, r0, JIT_TMP, ARM_LSR, 16); \ - } \ -} -#endif - -/* inline glibc htonl (without register clobber) */ -#ifdef USE_THUMB_CODE -#define jit_ntoh_ui(r0, r1) \ - ((r0|r1) < 8) ? T1_REV(r0, r1) : T2_REV(r0, r1) -#else -#define jit_ntoh_ui(r0, r1) \ -{ \ - if (jit_armv6_p()) \ - _REV(r0, r1); \ - else { \ - _EOR_SI(JIT_TMP, r1, r1, ARM_ROR, 16); \ - _LSRI(JIT_TMP, JIT_TMP, 8); \ - _BICI(JIT_TMP, JIT_TMP, encode_arm_immediate(0xff00)); \ - _EOR_SI(r0, JIT_TMP, r1, ARM_ROR, 8); \ - } \ -} -#endif -#endif - -#ifdef USE_THUMB_CODE -#define jit_extr_c_i(r0, r1) \ - ((r0|r1) < 8) ? T1_SXTB(r0, r1) : T2_SXTB(r0, r1) -#else -#define jit_extr_c_i(r0, r1) \ -{ \ - if (jit_armv6_p()) \ - _SXTB(r0, r1); \ - else { \ - _LSLI(r0, r1, 24); \ - _ASRI(r0, r0, 24); \ - } \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_extr_c_ui(r0, r1) \ - ((r0|r1) < 8) ? T1_UXTB(r0, r1) : T2_UXTB(r0, r1) -#else -#define jit_extr_c_ui(r0, r1) \ - jit_armv6_p() ? _UXTB(r0, r1) : _ANDI(r0, r1, 0xff) -#endif - -#ifdef USE_THUMB_CODE -#define jit_extr_s_i(r0, r1) \ - ((r0|r1) < 8) ? T1_SXTH(r0, r1) : T2_SXTH(r0, r1) -#else -#define jit_extr_s_i(r0, r1) \ - (jit_armv6_p()) ? _SXTH(r0, r1) : (_LSLI(r0, r1, 16), _ASRI(r0, r0, 16)) -#endif - -#ifdef USE_THUMB_CODE -#define jit_extr_s_ui(r0, r1) \ - ((r0|r1) < 8) ? T1_UXTH(r0, r1) : T2_UXTH(r0, r1) -#else -#define jit_extr_s_ui(r0, r1) \ - /* _ANDI(r0, r1, 0xffff) needs more instructions */ \ - (jit_armv6_p()) ? _UXTH(r0, r1) : (_LSLI(r0, r1, 16), _LSRI(r0, r0, 16)) -#endif - -#define jit_allocai(i0) \ - (assert((i0) >= 0), \ - _jitl.alloca_offset += i0, \ - jit_patch_movi(_jitl.stack, (void *) \ - ((_jitl.alloca_offset + _jitl.stack_length + 7) & -8)), \ - (-_jitl.alloca_offset)) - -#ifdef USE_THUMB_CODE -#define jit_prolog(n) \ -{ \ - /* switch to thumb mode (better approach would be to - * or 1 address being called, but no clear distinction - * of what is a pointer to a jit function, or if patching - * a pointer to a jit function) */ \ - _ADDI(_R12, _R15, 1); \ - _BX(_R12); \ - if (!_jitl.after_prolog) { \ - _jitl.after_prolog = 1; \ - _jitl.thumb_pc = _jit.x.pc; \ - } \ - if (jit_hardfp_p()) { \ - T2_PUSH((1<<_R4)|(1<<_R5)|(1<<_R6)|(1<<_R7)|(1<<_R8)|(1<<_R9)| \ - /* previous fp and return address */ \ - (1<= 0 && !_jitl.nextarg_put), \ - _jitl.stack_offset = i0 << 2) - -#define jit_arg_c() jit_arg_p() -#define jit_arg_uc() jit_arg_p() -#define jit_arg_s() jit_arg_p() -#define jit_arg_us() jit_arg_p() -#define jit_arg_i() jit_arg_p() -#define jit_arg_ui() jit_arg_p() -#define jit_arg_l() jit_arg_p() -#define jit_arg_ul() jit_arg_p() -#define jit_arg_p() \ - ((_jitl.nextarg_get > 2) ? \ - ((_jitl.framesize += sizeof(int)) - sizeof(int)) : \ - (_jitl.nextarg_get++)) - -#define jit_getarg_c(r0, i0) \ - jit_ldxi_c(r0, JIT_FP, (((i0) < 4) ? (i0) << 2 : (i0)) + ((__BYTE_ORDER == __BIG_ENDIAN) ? (sizeof(int) - sizeof(char)) : 0)) - -#define jit_getarg_uc(r0, i0) \ - jit_ldxi_uc(r0, JIT_FP, (((i0) < 4) ? (i0) << 2 : (i0)) + ((__BYTE_ORDER == __BIG_ENDIAN) ? (sizeof(int) - sizeof(char)) : 0)) - -#define jit_getarg_s(r0, i0) \ - jit_ldxi_s(r0, JIT_FP, (((i0) < 4) ? (i0) << 2 : (i0)) + ((__BYTE_ORDER == __BIG_ENDIAN) ? (sizeof(int) - sizeof(short)) : 0)) - -#define jit_getarg_us(r0, i0) \ - jit_ldxi_us(r0, JIT_FP, (((i0) < 4) ? (i0) << 2 : (i0)) + ((__BYTE_ORDER == __BIG_ENDIAN) ? (sizeof(int) - sizeof(short)) : 0)) - -#define jit_getarg_i(r0, i0) arm_getarg_i(_jit, r0, i0) -#define jit_getarg_ui(r0, i0) arm_getarg_i(_jit, r0, i0) -#define jit_getarg_l(r0, i0) arm_getarg_i(_jit, r0, i0) -#define jit_getarg_ul(r0, i0) arm_getarg_i(_jit, r0, i0) -#define jit_getarg_p(r0, i0) \ - jit_ldxi_i(r0, JIT_FP, (((i0) < 4) ? (i0) << 2 : (i0))); /* arguments are saved in prolog */ - -#define jit_pusharg_i(r0) \ - (jit_pushr_i(r0), _jitl.nextarg_put++) - -#ifdef USE_THUMB_CODE -#define jit_finishr(rs) \ -{ \ - if (r0 < 4) { \ - jit_movr_i(JIT_TMP, r0); \ - r0 = JIT_TMP; \ - } \ - if (_jitl.nextarg_put) { \ - T2_POP(((1 << _jitl.nextarg_put) - 1) & 0xf); \ - _jitl.nextarg_put = 0; \ - } \ - T1_BLX(r0); \ -} -#else -#define jit_finishr(rs) \ -{ \ - if (r0 < 4) { \ - jit_movr_i(JIT_TMP, r0); \ - r0 = JIT_TMP; \ - } \ - if (_jitl.nextarg_put) { \ - _POP(((1 << _jitl.nextarg_put) - 1) & 0xf); \ - _jitl.nextarg_put = 0; \ - } \ - _BLX(r0); \ -} -#endif - -#ifdef USE_THUMB_CODE -#define jit_finish(i0) \ - ((_jitl.nextarg_put) ? \ - (T2_POP(((1 << _jitl.nextarg_put) - 1) & 0xf), \ - _jitl.nextarg_put = 0) : 0, \ - _jitl.thumb_tmp = jit_movi_p(JIT_TMP, i0), \ - T1_BLX(JIT_TMP), \ - _jitl.thumb_tmp) -#else -#define jit_finish(i0) \ - ((_jitl.nextarg_put) ? \ - (_POP(((1 << _jitl.nextarg_put) - 1) & 0xf), \ - _jitl.nextarg_put = 0) : 0, \ - _jitl.thumb_tmp = jit_movi_p(JIT_TMP, i0), \ - _BLX(JIT_TMP), \ - _jitl.thumb_tmp) -#endif - -#define jit_retval_i(r0) jit_movr_i(r0, JIT_RET) - -#ifdef USE_THUMB_CODE -#define jit_ret() \ -{ \ - /* do not restore arguments */ \ - jit_addi_i(JIT_SP, JIT_FP, 16); \ - if (jit_hardfp_p()) \ - _VPOP_F64(_D8, 8); \ - T2_POP(/* callee save */ \ - (1<<_R4)|(1<<_R5)|(1<<_R6)|(1<<_R7)|(1<<_R8)|(1<<_R9)| \ - /* previous fp and return address */ \ - (1< - -#define swf_off(rn) ((rn) << 2) - -extern float __addsf3(float, float); -extern double __adddf3(double, double); -extern float __aeabi_fsub(float, float); -extern double __aeabi_dsub(double, double); -extern float __aeabi_fmul(float, float); -extern double __aeabi_dmul(double, double); -extern float __aeabi_fdiv(float, float); -extern double __aeabi_ddiv(double, double); -extern float __aeabi_i2f(int); -extern double __aeabi_i2d(int); -extern float __aeabi_d2f(double); -extern double __aeabi_f2d(float); -extern int __aeabi_f2iz(double); -extern int __aeabi_d2iz(float); -extern int __aeabi_fcmplt(float, float); -extern int __aeabi_dcmplt(double, double); -extern int __aeabi_fcmple(float, float); -extern int __aeabi_dcmple(double, double); -extern int __aeabi_fcmpeq(float, float); -extern int __aeabi_dcmpeq(double, double); -extern int __aeabi_fcmpge(float, float); -extern int __aeabi_dcmpge(double, double); -extern int __aeabi_fcmpgt(float, float); -extern int __aeabi_dcmpgt(double, double); -extern int __aeabi_fcmpun(float, float); -extern int __aeabi_dcmpun(double, double); - -#define swf_call(function, label) \ - do { \ - int d; \ - if (!jit_exchange_p()) { \ - if (jit_thumb_p()) \ - d = (((int)function - (int)_jit->x.pc) >> 1) - 2; \ - else \ - d = (((int)function - (int)_jit->x.pc) >> 2) - 2; \ - if (_s24P(d)) { \ - if (jit_thumb_p()) \ - T2_BLI(encode_thumb_jump(d)); \ - else \ - _BLI(d & 0x00ffffff); \ - } \ - else \ - goto label; \ - } \ - else { \ - label: \ - jit_movi_i(JIT_FTMP, (int)function); \ - if (jit_thumb_p()) \ - T1_BLX(JIT_FTMP); \ - else \ - _BLX(JIT_FTMP); \ - } \ - } while (0) -#define swf_ldrin(rt, rn, im) \ - do { \ - if (jit_thumb_p()) T2_LDRIN(rt, rn, im); \ - else _LDRIN(rt, rn, im); \ - } while (0) -#define swf_strin(rt, rn, im) \ - do { \ - if (jit_thumb_p()) T2_STRIN(rt, rn, im); \ - else _STRIN(rt, rn, im); \ - } while (0) -#define swf_push(mask) \ - do { \ - if (jit_thumb_p()) T1_PUSH(mask); \ - else _PUSH(mask); \ - } while (0) -#define swf_pop(mask) \ - do { \ - if (jit_thumb_p()) T1_POP(mask); \ - else _POP(mask); \ - } while (0) -#define swf_bici(rt, rn, im) \ - do { \ - if (jit_thumb_p()) \ - T2_BICI(rt, rn, encode_thumb_immediate(im)); \ - else \ - _BICI(rt, rn, encode_arm_immediate(im)); \ - } while (0) -#if 0 -__jit_inline void -swf_movr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - if (r0 != r1) { - if (r0 == JIT_FPRET) - /* jit_ret() must follow! */ - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - else { - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - } - } -} - -__jit_inline void -swf_movr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - if (r0 != r1) { - if (!jit_thumb_p() && jit_armv5e_p()) { - if (r0 == JIT_FPRET) - /* jit_ret() must follow! */ - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - else { - _LDRDIN(JIT_TMP, JIT_FP, swf_off(r1) + 8); - _STRDIN(JIT_TMP, JIT_FP, swf_off(r0) + 8); - } - } - else { - if (r0 == JIT_FPRET) { - /* jit_ret() must follow! */ - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - } - else { - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r1) + 8); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 4); - swf_strin(JIT_TMP, JIT_FP, swf_off(r0) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } - } - } -} - -__jit_inline void -swf_movi_f(jit_state_t _jit, jit_fpr_t r0, float i0) -{ - union { - int i; - float f; - } u; - u.f = i0; - if (r0 == JIT_FPRET) - /* jit_ret() must follow! */ - jit_movi_i(_R0, u.i); - else { - jit_movi_i(JIT_FTMP, u.i); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - } -} - -__jit_inline void -swf_movi_d(jit_state_t _jit, jit_fpr_t r0, double i0) -{ - union { - int i[2]; - double d; - } u; - u.d = i0; - if (r0 == JIT_FPRET) { - /* jit_ret() must follow! */ - jit_movi_i(_R0, u.i[0]); - jit_movi_i(_R1, u.i[1]); - } - else { - jit_movi_i(JIT_FTMP, u.i[0]); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - jit_movi_i(JIT_FTMP, u.i[1]); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } -} - -__jit_inline void -swf_extr_i_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - swf_push(0xf); - if (r1 != _R0) - jit_movr_i(_R0, r1); - swf_call(__aeabi_i2f, i2f); - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_pop(0xf); -} - -__jit_inline void -swf_extr_i_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - swf_push(0xf); - if (r1 != _R0) - jit_movr_i(_R0, r1); - swf_call(__aeabi_i2d, i2d); - if (!jit_thumb_p() && jit_armv5e_p()) - _STRDIN(_R0, JIT_FP, swf_off(r0) + 8); - else { - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_strin(_R1, JIT_FP, swf_off(r0) + 4); - } - swf_pop(0xf); -} - -static void -swf_extr_d_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - swf_push(0xf); - if (!jit_thumb_p() && jit_armv5e_p()) - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - } - swf_call(__aeabi_d2f, d2f); - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_pop(0xf); -} - -static void -swf_extr_f_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - swf_push(0xf); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_call(__aeabi_f2d, f2d); - if (!jit_thumb_p() && jit_armv5e_p()) - _STRDIN(_R0, JIT_FP, swf_off(r0) + 8); - else { - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_strin(_R1, JIT_FP, swf_off(r0) + 4); - } - swf_pop(0xf); -} - -static void -swf_if(jit_state_t _jit, float (*i0)(float), jit_gpr_t r0, jit_fpr_t r1) -{ - int l; -#if !NAN_TO_INT_IS_ZERO - jit_insn *is_nan; - jit_insn *fast_not_nan; - jit_insn *slow_not_nan; -#endif - l = 0xf; - if ((int)r0 < 4) - /* bogus extra push to align at 8 bytes */ - l = (l & ~(1 << r0)) | 0x10; - swf_push(l); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); -#if !NAN_TO_INT_IS_ZERO - /* >> based on fragment of __aeabi_fcmpun */ - jit_lshi_i(JIT_FTMP, _R0, 1); - if (jit_thumb_p()) - torrrs(THUMB2_MVN|ARM_S, _R0, JIT_TMP, JIT_FTMP, - encode_thumb_shift(24, ARM_ASR)); - else - corrrs(ARM_CC_AL,ARM_MVN|ARM_S|ARM_ASR, _R0, JIT_TMP, JIT_FTMP, 24); - fast_not_nan = _jit->x.pc; - if (jit_thumb_p()) { - T2_CC_B(ARM_CC_NE, 0); - tshift(THUMB2_LSLI|ARM_S, _R0, JIT_TMP, 9); - } - else { - _CC_B(ARM_CC_NE, 0); - cshift(ARM_CC_AL, ARM_S|ARM_LSL, _R0, JIT_TMP, _R0, 9); - } - slow_not_nan = _jit->x.pc; - if (jit_thumb_p()) - T2_CC_B(ARM_CC_EQ, 0); - else - _CC_B(ARM_CC_EQ, 0); - jit_movi_i(r0, 0x80000000); - is_nan = _jit->x.pc; - if (jit_thumb_p()) - T2_B(0); - else - _B(ARM_CC_AL, 0); - jit_patch(fast_not_nan); - jit_patch(slow_not_nan); - /* << based on fragment of __aeabi_fcmpun */ -#endif - if (i0) - swf_call(i0, fallback); - swf_call(__aeabi_f2iz, f2iz); - jit_movr_i(r0, _R0); -#if !NAN_TO_INT_IS_ZERO - jit_patch(is_nan); -#endif - swf_pop(l); -} - -static void -swf_id(jit_state_t _jit, double (*i0)(double), jit_gpr_t r0, jit_fpr_t r1) -{ - int l; -#if !NAN_TO_INT_IS_ZERO - jit_insn *is_nan; - jit_insn *fast_not_nan; - jit_insn *slow_not_nan; -#endif - l = 0xf; - if ((int)r0 < 4) - /* bogus extra push to align at 8 bytes */ - l = (l & ~(1 << r0)) | 0x10; - swf_push(l); - if (!jit_thumb_p() && jit_armv5e_p()) - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - } -#if !NAN_TO_INT_IS_ZERO - /* >> based on fragment of __aeabi_dcmpun */ - jit_lshi_i(JIT_TMP, _R1, 1); - if (jit_thumb_p()) - torrrs(THUMB2_MVN|ARM_S, _R0, JIT_TMP, JIT_TMP, - encode_thumb_shift(21, ARM_ASR)); - else - corrrs(ARM_CC_AL,ARM_MVN|ARM_S|ARM_ASR, _R0, JIT_TMP, JIT_TMP, 21); - fast_not_nan = _jit->x.pc; - if (jit_thumb_p()) { - T2_CC_B(ARM_CC_NE, 0); - torrrs(THUMB2_ORR|ARM_S, _R0, JIT_TMP, _R1, - encode_thumb_shift(12, ARM_LSL)); - } - else { - _CC_B(ARM_CC_NE, 0); - corrrs(ARM_CC_AL,ARM_ORR|ARM_S|ARM_LSL, _R0, JIT_TMP, _R1, 12); - } - slow_not_nan = _jit->x.pc; - if (jit_thumb_p()) - T2_CC_B(ARM_CC_EQ, 0); - else - _CC_B(ARM_CC_EQ, 0); - jit_movi_i(r0, 0x80000000); - is_nan = _jit->x.pc; - if (jit_thumb_p()) - T2_B(0); - else - _B(0); - jit_patch(fast_not_nan); - jit_patch(slow_not_nan); - /* << based on fragment of __aeabi_dcmpun */ -#endif - if (i0) - swf_call(i0, fallback); - swf_call(__aeabi_d2iz, d2iz); - jit_movr_i(r0, _R0); -#if !NAN_TO_INT_IS_ZERO - jit_patch(is_nan); -#endif - swf_pop(l); -} - -#define swf_rintr_f_i(_jit, r0, r1) swf_if(_jit, rintf, r0, r1) -#define swf_rintr_d_i(_jit, r0, r1) swf_id(_jit, rint, r0, r1) -#define swf_roundr_f_i(_jit, r0, r1) swf_if(_jit, roundf, r0, r1) -#define swf_roundr_d_i(_jit, r0, r1) swf_id(_jit, round, r0, r1) -#define swf_truncr_f_i(_jit, r0, r1) swf_if(_jit, (void *)0, r0, r1) -#define swf_truncr_d_i(_jit, r0, r1) swf_id(_jit, (void *)0, r0, r1) -#define swf_ceilr_f_i(_jit, r0, r1) swf_if(_jit, ceilf, r0, r1) -#define swf_ceilr_d_i(_jit, r0, r1) swf_id(_jit, ceil, r0, r1) -#define swf_floorr_f_i(_jit, r0, r1) swf_if(_jit, floorf, r0, r1) -#define swf_floorr_d_i(_jit, r0, r1) swf_id(_jit, floor, r0, r1) - -__jit_inline void -swf_absr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 8); - swf_bici(JIT_FTMP, JIT_FTMP, 0x80000000); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); -} - -__jit_inline void -swf_absr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 4); - swf_bici(JIT_FTMP, JIT_FTMP, 0x80000000); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - if (r0 != r1) { - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - } -} - -__jit_inline void -swf_negr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 8); - jit_xori_i(JIT_FTMP, JIT_FTMP, 0x80000000); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); -} - -__jit_inline void -swf_negr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 4); - jit_xori_i(JIT_FTMP, JIT_FTMP, 0x80000000); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - if (r0 != r1) { - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - } -} - -static void -swf_ff(jit_state_t _jit, float (*i0)(float), jit_fpr_t r0, jit_fpr_t r1) -{ - swf_push(0xf); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_call(i0, fallback); - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_pop(0xf); -} - -static void -swf_dd(jit_state_t _jit, double (*i0)(double), jit_fpr_t r0, jit_fpr_t r1) -{ - swf_push(0xf); - if (!jit_thumb_p() && jit_armv5e_p()) - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - } - swf_call(i0, fallback); - if (!jit_thumb_p() && jit_armv5e_p()) - _STRDIN(_R0, JIT_FP, swf_off(r0) + 8); - else { - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_strin(_R1, JIT_FP, swf_off(r0) + 4); - } - swf_pop(0xf); -} - -#define swf_sqrtr_f(_jit, r0, r1) swf_ff(_jit, sqrtf, r0, r1) -#define swf_sqrtr_d(_jit, r0, r1) swf_dd(_jit, sqrt, r0, r1) - -static void -swf_fff(jit_state_t _jit, float (*i0)(float, float), - jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_push(0xf); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r2) + 8); - swf_call(i0, fallback); - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_pop(0xf); -} - -static void -swf_ddd(jit_state_t _jit, double (*i0)(double, double), - jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_push(0xf); - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - _LDRDIN(_R2, JIT_FP, swf_off(r2) + 8); - } - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - swf_ldrin(_R2, JIT_FP, swf_off(r2) + 8); - swf_ldrin(_R3, JIT_FP, swf_off(r2) + 4); - } - swf_call(i0, fallback); - if (!jit_thumb_p() && jit_armv5e_p()) - _STRDIN(_R0, JIT_FP, swf_off(r0) + 8); - else { - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_strin(_R1, JIT_FP, swf_off(r0) + 4); - } - swf_pop(0xf); -} - -#define swf_addr_f(_jit, r0, r1, r2) swf_fff(_jit, __addsf3, r0, r1, r2) -#define swf_addr_d(_jit, r0, r1, r2) swf_ddd(_jit, __adddf3, r0, r1, r2) -#define swf_subr_f(_jit, r0, r1, r2) swf_fff(_jit, __aeabi_fsub, r0, r1, r2) -#define swf_subr_d(_jit, r0, r1, r2) swf_ddd(_jit, __aeabi_dsub, r0, r1, r2) -#define swf_mulr_f(_jit, r0, r1, r2) swf_fff(_jit, __aeabi_fmul, r0, r1, r2) -#define swf_mulr_d(_jit, r0, r1, r2) swf_ddd(_jit, __aeabi_dmul, r0, r1, r2) -#define swf_divr_f(_jit, r0, r1, r2) swf_fff(_jit, __aeabi_fdiv, r0, r1, r2) -#define swf_divr_d(_jit, r0, r1, r2) swf_ddd(_jit, __aeabi_ddiv, r0, r1, r2) - -static void -swf_iff(jit_state_t _jit, int (*i0)(float, float), - jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - int l; - l = 0xf; - if ((int)r0 < 4) - /* bogus extra push to align at 8 bytes */ - l = (l & ~(1 << r0)) | 0x10; - swf_push(l); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r2) + 8); - swf_call(i0, fallback); - jit_movr_i(r0, _R0); - swf_pop(l); -} - -static void -swf_idd(jit_state_t _jit, int (*i0)(double, double), - jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - int l; - l = 0xf; - if ((int)r0 < 4) - /* bogus extra push to align at 8 bytes */ - l = (l & ~(1 << r0)) | 0x10; - swf_push(l); - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - _LDRDIN(_R2, JIT_FP, swf_off(r2) + 8); - } - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - swf_ldrin(_R2, JIT_FP, swf_off(r2) + 8); - swf_ldrin(_R3, JIT_FP, swf_off(r2) + 4); - } - swf_call(i0, fallback); - jit_movr_i(r0, _R0); - swf_pop(l); -} - -#define swf_ltr_f(_jit, r0, r1, r2) swf_iff(_jit, __aeabi_fcmplt,r0,r1,r2) -#define swf_ltr_d(_jit, r0, r1, r2) swf_idd(_jit, __aeabi_dcmplt,r0,r1,r2) -#define swf_ler_f(_jit, r0, r1, r2) swf_iff(_jit, __aeabi_fcmple,r0,r1,r2) -#define swf_ler_d(_jit, r0, r1, r2) swf_idd(_jit, __aeabi_dcmple,r0,r1,r2) -#define swf_eqr_f(_jit, r0, r1, r2) swf_iff(_jit, __aeabi_fcmpeq,r0,r1,r2) -#define swf_eqr_d(_jit, r0, r1, r2) swf_idd(_jit, __aeabi_dcmpeq,r0,r1,r2) -#define swf_ger_f(_jit, r0, r1, r2) swf_iff(_jit, __aeabi_fcmpge,r0,r1,r2) -#define swf_ger_d(_jit, r0, r1, r2) swf_idd(_jit, __aeabi_dcmpge,r0,r1,r2) -#define swf_gtr_f(_jit, r0, r1, r2) swf_iff(_jit, __aeabi_fcmpgt,r0,r1,r2) -#define swf_gtr_d(_jit, r0, r1, r2) swf_idd(_jit, __aeabi_dcmpgt,r0,r1,r2) - -__jit_inline void -swf_ner_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_iff(_jit, __aeabi_fcmpeq, r0, r1, r2); - jit_xori_i(r0, r0, 1); -} - -__jit_inline void -swf_ner_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_idd(_jit, __aeabi_dcmpeq, r0, r1, r2); - jit_xori_i(r0, r0, 1); -} - -static void -swf_iunff(jit_state_t _jit, int (*i0)(float, float), - jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - int l; - jit_insn *i; - l = 0xf; - if ((int)r0 < 4) - /* bogus extra push to align at 8 bytes */ - l = (l & ~(1 << r0)) | 0x10; - swf_push(l); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r2) + 8); - swf_call(__aeabi_fcmpun, fcmpun); - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - _IT(ARM_CC_NE); - if (r0 < 8) - T1_MOVI(r0, 1); - else - T2_MOVI(r0, 1); - i = _jit->x.pc; - T2_CC_B(ARM_CC_NE, 0); - } - else { - _CMPI(_R0, 0); - _CC_MOVI(ARM_CC_NE, r0, 1); - i = _jit->x.pc; - _CC_B(ARM_CC_NE, 0); - } - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r2) + 8); - swf_call(i0, fallback); - jit_movr_i(r0, _R0); - jit_patch(i); - swf_pop(l); -} - -static void -swf_iundd(jit_state_t _jit, int (*i0)(double, double), - jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - int l; - jit_insn *i; - l = 0xf; - if ((int)r0 < 4) - /* bogus extra push to align at 8 bytes */ - l = (l & ~(1 << r0)) | 0x10; - swf_push(l); - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - _LDRDIN(_R2, JIT_FP, swf_off(r2) + 8); - } - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - swf_ldrin(_R2, JIT_FP, swf_off(r2) + 8); - swf_ldrin(_R3, JIT_FP, swf_off(r2) + 4); - } - swf_call(__aeabi_dcmpun, dcmpun); - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - _IT(ARM_CC_NE); - if (r0 < 8) - T1_MOVI(r0, 1); - else - T2_MOVI(r0, 1); - i = _jit->x.pc; - T2_CC_B(ARM_CC_NE, 0); - } - else { - _CMPI(_R0, 0); - _CC_MOVI(ARM_CC_NE, r0, 1); - i = _jit->x.pc; - _CC_B(ARM_CC_NE, 0); - } - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - _LDRDIN(_R2, JIT_FP, swf_off(r2) + 8); - } - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - swf_ldrin(_R2, JIT_FP, swf_off(r2) + 8); - swf_ldrin(_R3, JIT_FP, swf_off(r2) + 4); - } - swf_call(i0, fallback); - jit_movr_i(r0, _R0); - jit_patch(i); - swf_pop(l); -} - -#define swf_unltr_f(_jit, r0, r1, r2) swf_iunff(_jit,__aeabi_fcmplt,r0,r1,r2) -#define swf_unltr_d(_jit, r0, r1, r2) swf_iundd(_jit,__aeabi_dcmplt,r0,r1,r2) -#define swf_unler_f(_jit, r0, r1, r2) swf_iunff(_jit,__aeabi_fcmple,r0,r1,r2) -#define swf_unler_d(_jit, r0, r1, r2) swf_iundd(_jit,__aeabi_dcmple,r0,r1,r2) -#define swf_uneqr_f(_jit, r0, r1, r2) swf_iunff(_jit,__aeabi_fcmpeq,r0,r1,r2) -#define swf_uneqr_d(_jit, r0, r1, r2) swf_iundd(_jit,__aeabi_dcmpeq,r0,r1,r2) -#define swf_unger_f(_jit, r0, r1, r2) swf_iunff(_jit,__aeabi_fcmpge,r0,r1,r2) -#define swf_unger_d(_jit, r0, r1, r2) swf_iundd(_jit,__aeabi_dcmpge,r0,r1,r2) -#define swf_ungtr_f(_jit, r0, r1, r2) swf_iunff(_jit,__aeabi_fcmpgt,r0,r1,r2) -#define swf_ungtr_d(_jit, r0, r1, r2) swf_iundd(_jit,__aeabi_dcmpgt,r0,r1,r2) - -__jit_inline void -swf_ltgtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_iunff(_jit, __aeabi_fcmpeq, r0, r1, r2); - jit_xori_i(r0, r0, 1); -} - -__jit_inline void -swf_ltgtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_iundd(_jit, __aeabi_dcmpeq, r0, r1, r2); - jit_xori_i(r0, r0, 1); -} - -__jit_inline void -swf_ordr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_iff(_jit, __aeabi_fcmpun, r0, r1, r2); - jit_xori_i(r0, r0, 1); -} - -__jit_inline void -swf_ordr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - swf_idd(_jit, __aeabi_dcmpun, r0, r1, r2); - jit_xori_i(r0, r0, 1); -} - -#define swf_unordr_f(_jit, r0, r1, r2) swf_iunff(_jit,__aeabi_fcmpun,r0,r1,r2) -#define swf_unordr_d(_jit, r0, r1, r2) swf_iundd(_jit,__aeabi_dcmpun,r0,r1,r2) - -static jit_insn * -swf_bff(jit_state_t _jit, int (*i0)(float, float), int cc, - void *i1, jit_fpr_t r1, jit_fpr_t r2) -{ - jit_insn *l; - int d; - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - swf_push(0xf); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r2) + 8); - swf_call(i0, fallback); - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 1) - 2; - assert(_s20P(d)); - T2_CC_B(cc, encode_thumb_cc_jump(d)); - } - else { - _CMPI(_R0, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 2) - 2; - assert(_s24P(d)); - _CC_B(cc, d & 0x00ffffff); - } - return (l); -} - -static jit_insn * -swf_bdd(jit_state_t _jit, int (*i0)(double, double), int cc, - void *i1, jit_fpr_t r1, jit_fpr_t r2) -{ - jit_insn *l; - int d; - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - swf_push(0xf); - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - _LDRDIN(_R2, JIT_FP, swf_off(r2) + 8); - } - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - swf_ldrin(_R2, JIT_FP, swf_off(r2) + 8); - swf_ldrin(_R3, JIT_FP, swf_off(r2) + 4); - } - swf_call(i0, fallback); - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 1) - 2; - assert(_s20P(d)); - T2_CC_B(cc, encode_thumb_cc_jump(d)); - } - else { - _CMPI(_R0, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 2) - 2; - assert(_s24P(d)); - _CC_B(cc, d & 0x00ffffff); - } - return (l); -} - -#define swf_bltr_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmplt,ARM_CC_NE,i0,r0,r1) -#define swf_bltr_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmplt,ARM_CC_NE,i0,r0,r1) -#define swf_bler_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmple,ARM_CC_NE,i0,r0,r1) -#define swf_bler_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmple,ARM_CC_NE,i0,r0,r1) -#define swf_beqr_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpeq,ARM_CC_NE,i0,r0,r1) -#define swf_beqr_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpeq,ARM_CC_NE,i0,r0,r1) -#define swf_bger_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpge,ARM_CC_NE,i0,r0,r1) -#define swf_bger_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpge,ARM_CC_NE,i0,r0,r1) -#define swf_bgtr_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpgt,ARM_CC_NE,i0,r0,r1) -#define swf_bgtr_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpgt,ARM_CC_NE,i0,r0,r1) -#define swf_bner_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpeq,ARM_CC_EQ,i0,r0,r1) -#define swf_bner_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpeq,ARM_CC_EQ,i0,r0,r1) -#define swf_bunltr_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpge,ARM_CC_EQ,i0,r0,r1) -#define swf_bunltr_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpge,ARM_CC_EQ,i0,r0,r1) -#define swf_bunler_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpgt,ARM_CC_EQ,i0,r0,r1) -#define swf_bunler_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpgt,ARM_CC_EQ,i0,r0,r1) - -static jit_insn * -swf_bunff(jit_state_t _jit, int eq, void *i1, jit_fpr_t r1, jit_fpr_t r2) -{ - int d; - jit_insn *l; - jit_insn *j0; - jit_insn *j1; - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - swf_push(0xf); - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r2) + 8); - swf_call(__aeabi_fcmpun, fcmpun); - /* if unordered */ - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - j0 = _jit->x.pc; - T2_CC_B(ARM_CC_NE, 0); - } - else { - _CMPI(_R0, 0); - j0 = _jit->x.pc; - _CC_B(ARM_CC_NE, 0); - } - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r2) + 8); - swf_call(__aeabi_fcmpeq, fcmpeq); - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - j1 = _jit->x.pc; - if (eq) { - T2_CC_B(ARM_CC_EQ, 0); - jit_patch(j0); - } - else - T2_CC_B(ARM_CC_NE, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 1) - 2; - assert(_s24P(d)); - T2_B(encode_thumb_jump(d)); - } - else { - _CMPI(_R0, 0); - j1 = _jit->x.pc; - if (eq) { - _CC_B(ARM_CC_EQ, 0); - jit_patch(j0); - } - else - _CC_B(ARM_CC_NE, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 2) - 2; - assert(_s24P(d)); - _B(d & 0x00ffffff); - } - if (!eq) - jit_patch(j0); - jit_patch(j1); - swf_pop(0xf); - return (l); -} - -static jit_insn * -swf_bundd(jit_state_t _jit, int eq, void *i1, jit_fpr_t r1, jit_fpr_t r2) -{ - int d; - jit_insn *l; - jit_insn *j0; - jit_insn *j1; - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - swf_push(0xf); - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - _LDRDIN(_R2, JIT_FP, swf_off(r2) + 8); - } - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - swf_ldrin(_R2, JIT_FP, swf_off(r2) + 8); - swf_ldrin(_R3, JIT_FP, swf_off(r2) + 4); - } - swf_call(__aeabi_dcmpun, dcmpun); - /* if unordered */ - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - j0 = _jit->x.pc; - T2_CC_B(ARM_CC_NE, 0); - } - else { - _CMPI(_R0, 0); - j0 = _jit->x.pc; - _CC_B(ARM_CC_NE, 0); - } - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(_R0, JIT_FP, swf_off(r1) + 8); - _LDRDIN(_R2, JIT_FP, swf_off(r2) + 8); - } - else { - swf_ldrin(_R0, JIT_FP, swf_off(r1) + 8); - swf_ldrin(_R1, JIT_FP, swf_off(r1) + 4); - swf_ldrin(_R2, JIT_FP, swf_off(r2) + 8); - swf_ldrin(_R3, JIT_FP, swf_off(r2) + 4); - } - swf_call(__aeabi_dcmpeq, dcmpeq); - if (jit_thumb_p()) { - T1_CMPI(_R0, 0); - j1 = _jit->x.pc; - if (eq) { - T2_CC_B(ARM_CC_EQ, 0); - jit_patch(j0); - } - else - T2_CC_B(ARM_CC_NE, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 1) - 2; - assert(_s24P(d)); - T2_B(encode_thumb_jump(d)); - } - else { - _CMPI(_R0, 0); - j1 = _jit->x.pc; - if (eq) { - _CC_B(ARM_CC_EQ, 0); - jit_patch(j0); - } - else - _CC_B(ARM_CC_NE, 0); - swf_pop(0xf); - l = _jit->x.pc; - d = (((int)i1 - (int)l) >> 2) - 2; - assert(_s24P(d)); - _B(d & 0x00ffffff); - } - if (!eq) - jit_patch(j0); - jit_patch(j1); - swf_pop(0xf); - return (l); -} - -#define swf_buneqr_f(_jit,i0,r0,r1) swf_bunff(_jit,1,i0,r0,r1) -#define swf_buneqr_d(_jit,i0,r0,r1) swf_bundd(_jit,1,i0,r0,r1) -#define swf_bunger_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmplt,ARM_CC_EQ,i0,r0,r1) -#define swf_bunger_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmplt,ARM_CC_EQ,i0,r0,r1) -#define swf_bungtr_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmple,ARM_CC_EQ,i0,r0,r1) -#define swf_bungtr_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmple,ARM_CC_EQ,i0,r0,r1) -#define swf_bltgtr_f(_jit,i0,r0,r1) swf_bunff(_jit,0,i0,r0,r1) -#define swf_bltgtr_d(_jit,i0,r0,r1) swf_bundd(_jit,0,i0,r0,r1) -#define swf_bordr_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpun,ARM_CC_EQ,i0,r0,r1) -#define swf_bordr_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpun,ARM_CC_EQ,i0,r0,r1) -#define swf_bunordr_f(_jit,i0,r0,r1) swf_bff(_jit,__aeabi_fcmpun,ARM_CC_NE,i0,r0,r1) -#define swf_bunordr_d(_jit,i0,r0,r1) swf_bdd(_jit,__aeabi_dcmpun,ARM_CC_NE,i0,r0,r1) - -__jit_inline void -swf_ldr_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - jit_ldr_i(JIT_FTMP, r1); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); -} - -__jit_inline void -swf_ldr_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDI(JIT_TMP, r1, 0); - _STRDIN(JIT_TMP, JIT_FP, swf_off(r0) + 8); - } - else { - jit_ldxi_i(JIT_TMP, r1, 0); - jit_ldxi_i(JIT_FTMP, r1, 4); - swf_strin(JIT_TMP, JIT_FP, swf_off(r0) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } -} - -__jit_inline void -swf_ldi_f(jit_state_t _jit, jit_fpr_t r0, void *i0) -{ - jit_ldi_i(JIT_FTMP, i0); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); -} - -__jit_inline void -swf_ldi_d(jit_state_t _jit, jit_fpr_t r0, void *i0) -{ - jit_movi_i(JIT_TMP, (int)i0); - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDI(JIT_TMP, JIT_TMP, 0); - _STRDIN(JIT_TMP, JIT_FP, swf_off(r0) + 8); - } - else { - jit_ldxi_i(JIT_FTMP, JIT_TMP, 4); - jit_ldxi_i(JIT_TMP, JIT_TMP, 0); - swf_strin(JIT_TMP, JIT_FP, swf_off(r0) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } -} - -__jit_inline void -swf_ldxr_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - jit_ldxr_i(JIT_TMP, r1, r2); - swf_strin(JIT_TMP, JIT_FP, swf_off(r0) + 8); -} - -__jit_inline void -swf_ldxr_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRD(JIT_TMP, r1, r2); - _STRDIN(JIT_TMP, JIT_FP, swf_off(r0) + 8); - } - else { - jit_addr_i(JIT_TMP, r1, r2); - jit_ldxi_i(JIT_FTMP, JIT_TMP, 4); - jit_ldxi_i(JIT_TMP, JIT_TMP, 0); - swf_strin(JIT_TMP, JIT_FP, swf_off(r0) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } -} - -__jit_inline void -swf_ldxi_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0) -{ - jit_ldxi_i(JIT_FTMP, r1, i0); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); -} - -__jit_inline void -swf_ldxi_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0) -{ - if (!jit_thumb_p() && jit_armv5e_p()) { - if (i0 >= 0 && i0 <= 255) - _LDRDI(JIT_TMP, r1, i0); - else if (i0 < 0 && i0 >= -255) - _LDRDIN(JIT_TMP, r1, -i0); - else { - jit_addi_i(JIT_FTMP, r1, i0); - _LDRDI(JIT_TMP, JIT_FTMP, 0); - } - _STRDIN(JIT_TMP, JIT_FP, swf_off(r0) + 8); - } - else { - if (((jit_thumb_p() && i0 >= -255) || - (!jit_thumb_p() && i0 >= -4095)) && i0 + 4 <= 4095) { - if (i0 >= 0) - jit_ldxi_i(JIT_TMP, r1, i0); - else if (i0 < 0) - swf_ldrin(JIT_TMP, r1, -i0); - i0 += 4; - if (i0 >= 0) - jit_ldxi_i(JIT_FTMP, r1, i0); - else if (i0 < 0) - swf_ldrin(JIT_FTMP, r1, -i0); - } - else { - jit_addi_i(JIT_FTMP, r1, i0); - jit_ldxi_i(JIT_TMP, JIT_FTMP, 0); - jit_ldxi_i(JIT_FTMP, JIT_FTMP, 4); - } - swf_strin(JIT_TMP, JIT_FP, swf_off(r0) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } -} - -__jit_inline void -swf_str_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 8); - jit_stxi_i(0, r0, JIT_FTMP); -} - -__jit_inline void -swf_str_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(JIT_TMP, JIT_FP, swf_off(r1) + 8); - _STRDI(JIT_TMP, r0, 0); - } - else { - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r1) + 8); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 4); - jit_stxi_i(0, r0, JIT_TMP); - jit_stxi_i(4, r0, JIT_FTMP); - } -} - -__jit_inline void -swf_sti_f(jit_state_t _jit, void *i0, jit_fpr_t r0) -{ - jit_movi_i(JIT_TMP, (int)i0); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - jit_stxi_i(0, JIT_TMP, JIT_FTMP); -} - -__jit_inline void -swf_sti_d(jit_state_t _jit, void *i0, jit_fpr_t r0) -{ - jit_movi_i(JIT_TMP, (int)i0); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - jit_stxi_i(0, JIT_TMP, JIT_FTMP); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - jit_stxi_i(4, JIT_TMP, JIT_FTMP); -} - -__jit_inline void -swf_stxr_f(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2) -{ - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r2) + 8); - jit_stxr_i(r1, r0, JIT_TMP); -} - -__jit_inline void -swf_stxr_d(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2) -{ - if (!jit_thumb_p() && jit_armv5e_p()) { - _LDRDIN(JIT_TMP, JIT_FP, swf_off(r2) + 8); - _STRD(JIT_TMP, r0, r1); - } - else { - jit_addr_i(JIT_TMP, r0, r1); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r2) + 8); - jit_stxi_i(0, JIT_TMP, JIT_FTMP); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r2) + 4); - jit_stxi_i(4, JIT_TMP, JIT_FTMP); - } -} - -__jit_inline void -swf_stxi_f(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1) -{ - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r1) + 8); - jit_stxi_i(i0, r0, JIT_FTMP); -} - -__jit_inline void -swf_stxi_d(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1) -{ - if (!jit_thumb_p() && jit_armv5e_p()) { - if (i0 >= 0 && i0 <= 255) { - _LDRDIN(JIT_TMP, JIT_FP, swf_off(r1) + 8); - _STRDI(JIT_TMP, r0, i0); - } - else if (i0 < 0 && i0 >= -255) { - _LDRDIN(JIT_TMP, JIT_FP, swf_off(r1) + 8); - _STRDIN(JIT_TMP, r0, -i0); - } - else { - jit_addi_i(JIT_FTMP, r0, i0); - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r1) + 8); - jit_stxi_i(0, JIT_TMP, JIT_FTMP); - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r1) + 4); - jit_stxi_i(4, JIT_TMP, JIT_FTMP); - } - } - else { - jit_addi_i(JIT_FTMP, r0, i0); - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r1) + 8); - jit_stxi_i(0, JIT_FTMP, JIT_TMP); - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r1) + 4); - jit_stxi_i(4, JIT_FTMP, JIT_TMP); - } -} - -__jit_inline void -swf_getarg_f(jit_state_t _jit, jit_fpr_t r0, int i0) -{ - if (i0 < 4) - i0 <<= 2; - jit_ldxi_i(JIT_FTMP, JIT_FP, i0); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); -} - -__jit_inline void -swf_getarg_d(jit_state_t _jit, jit_fpr_t r0, int i0) -{ - if (i0 < 4) - i0 <<= 2; - if (!jit_thumb_p() && jit_armv5e_p()) { - if (i0 < 255) - _LDRDI(JIT_TMP, JIT_FP, i0); - else { - jit_addi_i(JIT_FTMP, JIT_FP, i0); - jit_ldxi_i(JIT_TMP, JIT_FTMP, 0); - jit_ldxi_i(JIT_FTMP, JIT_FTMP, 4); - } - _STRDIN(JIT_TMP, JIT_FP, swf_off(r0) + 8); - } - else { - if (i0 + 4 < 4095) { - jit_ldxi_i(JIT_TMP, JIT_FP, i0); - jit_ldxi_i(JIT_FTMP, JIT_FP, i0 + 4); - } - else { - jit_addi_i(JIT_FTMP, JIT_FP, i0); - jit_ldxi_i(JIT_TMP, JIT_FTMP, 0); - jit_ldxi_i(JIT_FTMP, JIT_FTMP, 4); - } - swf_strin(JIT_TMP, JIT_FP, swf_off(r0) + 8); - swf_strin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } -} - -__jit_inline void -swf_pusharg_f(jit_state_t _jit, jit_fpr_t r0) -{ - int ofs = _jitl.nextarg_put++; - assert(ofs < 256); - _jitl.stack_offset -= sizeof(float); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r0) + 8); - _jitl.arguments[ofs] = (int *)_jit->x.pc; - _jitl.types[ofs >> 5] &= ~(1 << (ofs & 31)); - if (jit_thumb_p()) - T2_STRWI(JIT_FTMP, JIT_SP, 0); - else - _STRI(JIT_FTMP, JIT_SP, 0); -} -#endif -__jit_inline void -swf_pusharg_d(jit_state _jit, jit_fpr_t r0) -{ - int ofs = _jitl.nextarg_put++; - assert(ofs < 256); - _jitl.stack_offset -= sizeof(double); - if (!jit_thumb_p() && jit_armv5e_p()) - _LDRDIN(JIT_TMP, JIT_FP, swf_off(r0) + 8); - else { - swf_ldrin(JIT_TMP, JIT_FP, swf_off(r0) + 8); - swf_ldrin(JIT_FTMP, JIT_FP, swf_off(r0) + 4); - } - _jitl.arguments[ofs] = (int *)_jit.x.pc; - _jitl.types[ofs >> 5] |= 1 << (ofs & 31); - /* large offsets (handled by patch_arguments) cannot be encoded in STRDI */ - if (jit_thumb_p()) { - T2_STRWI(JIT_TMP, JIT_SP, 0); - T2_STRWI(JIT_FTMP, JIT_SP, 0); - } - else { - _STRI(JIT_TMP, JIT_SP, 0); - _STRI(JIT_FTMP, JIT_SP, 0); - } -} -#if 0 -#define swf_retval_f(_jit, r0) swf_strin(_R0, JIT_FP, swf_off(r0) + 8) -__jit_inline void -swf_retval_d(jit_state_t _jit, jit_fpr_t r0) -{ - if (!jit_thumb_p() && jit_armv5e_p()) - _STRDIN(_R0, JIT_FP, swf_off(r0) + 8); - else { - swf_strin(_R0, JIT_FP, swf_off(r0) + 8); - swf_strin(_R1, JIT_FP, swf_off(r0) + 4); - } -} -#endif -#endif /* __lightning_fp_swf_h */ diff --git a/src/runtime/c/pgf/lightning/arm/fp-vfp.h b/src/runtime/c/pgf/lightning/arm/fp-vfp.h deleted file mode 100644 index f78c96d91..000000000 --- a/src/runtime/c/pgf/lightning/arm/fp-vfp.h +++ /dev/null @@ -1,1091 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Support macros for arm VFP floating-point math - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2011 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - * Authors: - * Paulo Cesar Pereira de Andrade - ***********************************************************************/ - - -#ifndef __lightning_fp_vfp_h -#define __lightning_fp_vfp_h - -#if 0 - -__jit_inline void -vfp_movr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - if (r0 != r1) { - if (r0 == JIT_FPRET) { - /* jit_ret() must follow! */ - if (!jit_hardfp_p()) - _VMOV_A_S(_R0, r1); - else - _VMOV_F32(_D0, r1); - } - else - _VMOV_F32(r0, r1); - } -} - -__jit_inline void -vfp_movr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - if (r0 != r1) { - if (r0 == JIT_FPRET) { - /* jit_ret() must follow! */ - if (!jit_hardfp_p()) - _VMOV_AA_D(_R0, _R1, r1); - else - _VMOV_F64(_D0, r1); - } - else - _VMOV_F64(r0, r1); - } -} - -__jit_inline void -vfp_movi_f(jit_state_t _jit, jit_fpr_t r0, float i0) -{ - union { - int i; - float f; - } u; - int code; - u.f = i0; - if (!jit_hardfp_p() && r0 == JIT_FPRET) - /* jit_ret() must follow! */ - jit_movi_i(_R0, u.i); - else { - if (r0 == JIT_FPRET) - r0 = _D0; - if ((code = encode_vfp_double(1, 0, u.i, u.i)) != -1 || - (code = encode_vfp_double(1, 1, ~u.i, ~u.i)) != -1) - _VIMM(code, r0); - else { - jit_movi_i(JIT_FTMP, u.i); - _VMOV_S_A(r0, JIT_FTMP); - } - } -} - -__jit_inline void -vfp_movi_d(jit_state_t _jit, jit_fpr_t r0, double i0) -{ - union { - int i[2]; - double d; - } u; - int code; - u.d = i0; - if (!jit_hardfp_p() && r0 == JIT_FPRET) { - /* jit_ret() must follow! */ - jit_movi_i(_R0, u.i[0]); - jit_movi_i(_R1, u.i[1]); - } - else { - if (r0 == JIT_FPRET) - r0 = _D0; - if ((code = encode_vfp_double(1, 0, u.i[0], u.i[1])) != -1 || - (code = encode_vfp_double(1, 1, ~u.i[0], ~u.i[1])) != -1) - _VIMM(code, r0); - else { - jit_movi_i(JIT_TMP, u.i[0]); - jit_movi_i(JIT_FTMP, u.i[1]); - _VMOV_D_AA(r0, JIT_TMP, JIT_FTMP); - } - } -} - -__jit_inline void -vfp_extr_i_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - _VMOV_V_I32(r0, r1); - _VCVT_F32_S32(r0, r0); -} - -__jit_inline void -vfp_extr_i_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - _VMOV_V_I32(r0, r1); - _VCVT_F64_S32(r0, r0); -} - -#define vfp_extr_d_f(_jit, r0, r1) _VCVT_F64_F32(r0, r1) -#define vfp_extr_f_d(_jit, r0, r1) _VCVT_F32_F64(r0, r1) - -/* FIXME keeping for now, in case there exists, and/or to support - * only 4 double precision registers */ -#define vfp_get_tmp(r, n) \ - jit_fpr_t tmp; \ - if (0) { \ - tmp = r == _D0 ? _D1 : _D0; \ - _VPUSH_F##n(tmp, 2); \ - } \ - else \ - tmp = _D15 -#define vfp_unget_tmp(n) \ - if (0) \ - _VPOP_F##n(tmp, 2) - -__jit_inline void -vfp_rintr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 32); - _VCVT_S32_F32(tmp, r1); - _VMOV_A_S32(r0, tmp); - vfp_unget_tmp(32); -} - -__jit_inline void -vfp_rintr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 64); - _VCVT_S32_F64(tmp, r1); - _VMOV_A_S32(r0, tmp); - vfp_unget_tmp(64); -} - -__jit_inline void -vfp_roundr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 32); - _VMOV_A_S(JIT_FTMP, r1); - if (jit_thumb_p()) { - T2_TSTI(JIT_FTMP, encode_thumb_immediate(0x80000000)); - _ITE(ARM_CC_NE); - /* add -0.5 if negative */ - T2_MOVI(JIT_FTMP, encode_thumb_immediate(0xbf000000)); - /* add 0.5 if positive */ - T2_MOVI(JIT_FTMP, encode_thumb_immediate(0x3f000000)); - } - else { - if (jit_armv6_p()) - _TSTI(JIT_FTMP, encode_arm_immediate(0x80000000)); - else - _ANDSI(JIT_FTMP, JIT_FTMP, encode_arm_immediate(0x80000000)); - /* add -0.5 if negative */ - _CC_MOVI(ARM_CC_NE, JIT_FTMP, encode_arm_immediate(0xbf000000)); - /* add 0.5 if positive */ - _CC_MOVI(ARM_CC_EQ, JIT_FTMP, encode_arm_immediate(0x3f000000)); - } - _VMOV_S_A(tmp, JIT_FTMP); - _VADD_F32(tmp, r1, tmp); - /* truncate to zero */ - _VCVT_S32_F32(tmp, tmp); - _VMOV_A_S32(r0, tmp); - vfp_unget_tmp(32); -} - -__jit_inline void -vfp_roundr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 64); - _VMOV_AA_D(JIT_TMP, JIT_FTMP, r1); - if (jit_thumb_p()) { - T2_TSTI(JIT_FTMP, encode_thumb_immediate(0x80000000)); - T2_MOVI(JIT_FTMP, encode_thumb_immediate(0x0fe00000)); - _ITE(ARM_CC_NE); - /* add -0.5 if negative */ - T2_ORRI(JIT_FTMP, JIT_FTMP, encode_thumb_immediate(0xb0000000)); - /* add 0.5 if positive */ - T2_ORRI(JIT_FTMP, JIT_FTMP, encode_thumb_immediate(0x30000000)); - } - else { - if (jit_armv6_p()) - _TSTI(JIT_FTMP, encode_arm_immediate(0x80000000)); - else - _ANDSI(JIT_FTMP, JIT_FTMP, encode_arm_immediate(0x80000000)); - _MOVI(JIT_FTMP, encode_arm_immediate(0x0fe00000)); - /* add -0.5 if negative */ - _CC_ORRI(ARM_CC_NE, JIT_FTMP, JIT_FTMP, - encode_arm_immediate(0xb0000000)); - /* add 0.5 if positive */ - _CC_ORRI(ARM_CC_EQ, JIT_FTMP, JIT_FTMP, - encode_arm_immediate(0x30000000)); - } - jit_movi_i(JIT_TMP, 0); - _VMOV_D_AA(tmp, JIT_TMP, JIT_FTMP); - _VADD_F64(tmp, r1, tmp); - /* truncate to zero */ - _VCVT_S32_F64(tmp, tmp); - _VMOV_A_S32(r0, tmp); - vfp_unget_tmp(64); -} - -#define vfp_truncr_f_i(_jit, r0, r1) vfp_rintr_f_i(_jit, r0, r1) -#define vfp_truncr_d_i(_jit, r0, r1) vfp_rintr_d_i(_jit, r0, r1) - -__jit_inline void -vfp_ceilr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 32); - _VMRS(JIT_TMP); - if (jit_thumb_p()) { - T2_BICI(JIT_FTMP, JIT_TMP, encode_thumb_immediate(FPSCR_RMASK)); - T2_ORRI(JIT_FTMP, JIT_FTMP, encode_thumb_immediate(FPSCR_RP)); - } - else { - _BICI(JIT_FTMP, JIT_TMP, encode_arm_immediate(FPSCR_RMASK)); - _ORRI(JIT_FTMP, JIT_FTMP, encode_arm_immediate(FPSCR_RP)); - } - _VMSR(JIT_FTMP); - _VCVTR_S32_F32(tmp, r1); - _VMOV_A_S32(r0, tmp); - _VMSR(JIT_TMP); - vfp_unget_tmp(32); -} - -__jit_inline void -vfp_ceilr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 64); - _VMRS(JIT_TMP); - if (jit_thumb_p()) { - T2_BICI(JIT_FTMP, JIT_TMP, encode_thumb_immediate(FPSCR_RMASK)); - T2_ORRI(JIT_FTMP, JIT_FTMP, encode_thumb_immediate(FPSCR_RP)); - } - else { - _BICI(JIT_FTMP, JIT_TMP, encode_arm_immediate(FPSCR_RMASK)); - _ORRI(JIT_FTMP, JIT_FTMP, encode_arm_immediate(FPSCR_RP)); - } - _VMSR(JIT_FTMP); - _VCVTR_S32_F64(tmp, r1); - _VMOV_A_S32(r0, tmp); - _VMSR(JIT_TMP); - vfp_unget_tmp(64); -} - -__jit_inline void -vfp_floorr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 32); - _VMRS(JIT_TMP); - if (jit_thumb_p()) { - T2_BICI(JIT_FTMP, JIT_TMP, encode_thumb_immediate(FPSCR_RMASK)); - T2_ORRI(JIT_FTMP, JIT_FTMP, encode_thumb_immediate(FPSCR_RM)); - } - else { - _BICI(JIT_FTMP, JIT_TMP, encode_arm_immediate(FPSCR_RMASK)); - _ORRI(JIT_FTMP, JIT_FTMP, encode_arm_immediate(FPSCR_RM)); - } - _VMSR(JIT_FTMP); - _VCVTR_S32_F32(tmp, r1); - _VMOV_A_S32(r0, tmp); - _VMSR(JIT_TMP); - vfp_unget_tmp(32); -} - -__jit_inline void -vfp_floorr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - vfp_get_tmp(r1, 64); - _VMRS(JIT_TMP); - if (jit_thumb_p()) { - T2_BICI(JIT_FTMP, JIT_TMP, encode_thumb_immediate(FPSCR_RMASK)); - T2_ORRI(JIT_FTMP, JIT_FTMP, encode_thumb_immediate(FPSCR_RM)); - } - else { - _BICI(JIT_FTMP, JIT_TMP, encode_arm_immediate(FPSCR_RMASK)); - _ORRI(JIT_FTMP, JIT_FTMP, encode_arm_immediate(FPSCR_RM)); - } - _VMSR(JIT_FTMP); - _VCVTR_S32_F64(tmp, r1); - _VMOV_A_S32(r0, tmp); - _VMSR(JIT_TMP); - vfp_unget_tmp(64); -} - -#define vfp_absr_f(_jit, r0, r1) _VABS_F32(r0, r1) -#define vfp_absr_d(_jit, r0, r1) _VABS_F64(r0, r1) -#define vfp_negr_f(_jit, r0, r1) _VNEG_F32(r0, r1) -#define vfp_negr_d(_jit, r0, r1) _VNEG_F64(r0, r1) -#define vfp_sqrtr_f(_jit, r0, r1) _VSQRT_F32(r0, r1) -#define vfp_sqrtr_d(_jit, r0, r1) _VSQRT_F64(r0, r1) -#define vfp_addr_f(_jit, r0, r1, r2) _VADD_F32(r0, r1, r2) -#define vfp_addr_d(_jit, r0, r1, r2) _VADD_F64(r0, r1, r2) -#define vfp_subr_f(_jit, r0, r1, r2) _VSUB_F32(r0, r1, r2) -#define vfp_subr_d(_jit, r0, r1, r2) _VSUB_F64(r0, r1, r2) -#define vfp_mulr_f(_jit, r0, r1, r2) _VMUL_F32(r0, r1, r2) -#define vfp_mulr_d(_jit, r0, r1, r2) _VMUL_F64(r0, r1, r2) -#define vfp_divr_f(_jit, r0, r1, r2) _VDIV_F32(r0, r1, r2) -#define vfp_divr_d(_jit, r0, r1, r2) _VDIV_F64(r0, r1, r2) - -static void -_vcmp01_x(jit_state_t _jit, int c0, int c1, jit_gpr_t r0) -{ - _VMRS(_R15); - if (jit_thumb_p()) { - if ((c0 ^ c1) >> 28 == 1) { - _ITE(c0); - if (r0 < 8) { - T1_MOVI(r0, 0); - T1_MOVI(r0, 1); - } - else { - T2_MOVI(r0, 0); - T2_MOVI(r0, 1); - } - } - else { - if (r0 < 8) { - _IT(c0); - T1_MOVI(r0, 0); - _IT(c1); - T1_MOVI(r0, 1); - } - else { - _IT(c0); - T2_MOVI(r0, 0); - _IT(c1); - T2_MOVI(r0, 1); - } - } - } - else { - _CC_MOVI(c0, r0, 0); - _CC_MOVI(c1, r0, 1); - } -} - -static void -_vcmp01_f(jit_state_t _jit, int c0, int c1, - jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F32(r1, r2); - _vcmp01_x(_jit, c0, c1, r0); -} - -static void -_vcmp01_d(jit_state_t _jit, int c0, int c1, - jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F64(r1, r2); - _vcmp01_x(_jit, c0, c1, r0); -} - -#define vfp_ltr_f(_jit,r0,r1,r2) _vcmp01_f(_jit,ARM_CC_PL,ARM_CC_MI,r0,r1,r2) -#define vfp_ltr_d(_jit,r0,r1,r2) _vcmp01_d(_jit,ARM_CC_PL,ARM_CC_MI,r0,r1,r2) -#define vfp_ler_f(_jit,r0,r1,r2) _vcmp01_f(_jit,ARM_CC_HS,ARM_CC_LS,r0,r1,r2) -#define vfp_ler_d(_jit,r0,r1,r2) _vcmp01_d(_jit,ARM_CC_HS,ARM_CC_LS,r0,r1,r2) -#define vfp_eqr_f(_jit,r0,r1,r2) _vcmp01_f(_jit,ARM_CC_NE,ARM_CC_EQ,r0,r1,r2) -#define vfp_eqr_d(_jit,r0,r1,r2) _vcmp01_d(_jit,ARM_CC_NE,ARM_CC_EQ,r0,r1,r2) -#define vfp_ger_f(_jit,r0,r1,r2) _vcmp01_f(_jit,ARM_CC_LT,ARM_CC_GE,r0,r1,r2) -#define vfp_ger_d(_jit,r0,r1,r2) _vcmp01_d(_jit,ARM_CC_LT,ARM_CC_GE,r0,r1,r2) -#define vfp_gtr_f(_jit,r0,r1,r2) _vcmp01_f(_jit,ARM_CC_LE,ARM_CC_GT,r0,r1,r2) -#define vfp_gtr_d(_jit,r0,r1,r2) _vcmp01_d(_jit,ARM_CC_LE,ARM_CC_GT,r0,r1,r2) -#define vfp_ner_f(_jit,r0,r1,r2) _vcmp01_f(_jit,ARM_CC_EQ,ARM_CC_NE,r0,r1,r2) -#define vfp_ner_d(_jit,r0,r1,r2) _vcmp01_d(_jit,ARM_CC_EQ,ARM_CC_NE,r0,r1,r2) - -static void -_vcmp10_x(jit_state_t _jit, int cc, jit_gpr_t r0) -{ - if (jit_thumb_p()) { - if (r0 < 8) { - T1_MOVI(r0, 1); - _VMRS(_R15); - _IT(cc); - T1_MOVI(r0, 0); - } - else { - T2_MOVI(r0, 1); - _VMRS(_R15); - _IT(cc); - T2_MOVI(r0, 0); - } - } - else { - _VMRS(_R15); - _MOVI(r0, 1); - _CC_MOVI(cc, r0, 0); - } -} - -static void -_vcmp_10_f(jit_state_t _jit, int cc, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F32(r1, r2); - _vcmp10_x(_jit, cc, r0); -} - -static void -_vcmp_10_d(jit_state_t _jit, int cc, jit_gpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - _VCMP_F64(r1, r2); - _vcmp10_x(_jit, cc, r0); -} - -#define vfp_unltr_f(_jit,r0,r1,r2) _vcmp_10_f(_jit,ARM_CC_GE,r0,r1,r2) -#define vfp_unltr_d(_jit,r0,r1,r2) _vcmp_10_d(_jit,ARM_CC_GE,r0,r1,r2) -#define vfp_unler_f(_jit,r0,r1,r2) _vcmp_10_f(_jit,ARM_CC_GT,r0,r1,r2) -#define vfp_unler_d(_jit,r0,r1,r2) _vcmp_10_d(_jit,ARM_CC_GT,r0,r1,r2) - -static void -vfp_uneqr_x(jit_state_t _jit, jit_gpr_t r0) -{ - _VMRS(_R15); - if (jit_thumb_p()) { - _ITE(ARM_CC_NE); - if (r0 < 8) { - T1_MOVI(r0, 0); - T1_MOVI(r0, 1); - _IT(ARM_CC_VS); - T1_MOVI(r0, 1); - } - else { - T2_MOVI(r0, 0); - T2_MOVI(r0, 1); - _IT(ARM_CC_VS); - T2_MOVI(r0, 1); - } - } - else { - _CC_MOVI(ARM_CC_NE, r0, 0); - _CC_MOVI(ARM_CC_EQ, r0, 1); - _CC_MOVI(ARM_CC_VS, r0, 1); - } -} - -__jit_inline void -vfp_uneqr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F32(r1, r2); - vfp_uneqr_x(_jit, r0); -} - -__jit_inline void -vfp_uneqr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F64(r1, r2); - vfp_uneqr_x(_jit, r0); -} - -static void -_vcmp_01_x(jit_state_t _jit, int cc, jit_gpr_t r0) -{ - if (jit_thumb_p()) { - if (r0 < 8) { - T1_MOVI(r0, 0); - _VMRS(_R15); - _IT(cc); - T1_MOVI(r0, 1); - } - else { - T2_MOVI(r0, 0); - _VMRS(_R15); - _IT(cc); - T2_MOVI(r0, 1); - } - } - else { - _VMRS(_R15); - _MOVI(r0, 0); - _CC_MOVI(cc, r0, 1); - } -} - -static void -_vcmp_01_f(jit_state_t _jit, int cc, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F32(r1, r2); - _vcmp_01_x(_jit, cc, r0); -} - -static void -_vcmp_01_d(jit_state_t _jit, int cc, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F64(r1, r2); - _vcmp_01_x(_jit, cc, r0); -} - -#define vfp_unger_f(_jit,r0,r1,r2) _vcmp_01_f(_jit,ARM_CC_CS,r0,r1,r2) -#define vfp_unger_d(_jit,r0,r1,r2) _vcmp_01_d(_jit,ARM_CC_CS,r0,r1,r2) -#define vfp_ungtr_f(_jit,r0,r1,r2) _vcmp_01_f(_jit,ARM_CC_HI,r0,r1,r2) -#define vfp_ungtr_d(_jit,r0,r1,r2) _vcmp_01_d(_jit,ARM_CC_HI,r0,r1,r2) - -static void -_vfp_ltgtr_x(jit_state_t _jit, jit_gpr_t r0) -{ - _VMRS(_R15); - if (jit_thumb_p()) { - _ITE(ARM_CC_NE); - if (r0 < 8) { - T1_MOVI(r0, 1); - T1_MOVI(r0, 0); - _IT(ARM_CC_VS); - T1_MOVI(r0, 0); - } - else { - T2_MOVI(r0, 1); - T2_MOVI(r0, 0); - _IT(ARM_CC_VS); - T2_MOVI(r0, 0); - } - } - else { - _CC_MOVI(ARM_CC_NE, r0, 1); - _CC_MOVI(ARM_CC_EQ, r0, 0); - _CC_MOVI(ARM_CC_VS, r0, 0); - } -} - -__jit_inline void -vfp_ltgtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F32(r1, r2); - _vfp_ltgtr_x(_jit, r0); -} - -__jit_inline void -vfp_ltgtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F64(r1, r2); - _vfp_ltgtr_x(_jit, r0); -} - -__jit_inline void -vfp_ordr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F32(r1, r2); - _vcmp10_x(_jit, ARM_CC_VS, r0); -} - -__jit_inline void -vfp_ordr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F64(r1, r2); - _vcmp10_x(_jit, ARM_CC_VS, r0); -} - -__jit_inline void -vfp_unordr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F32(r1, r2); - _vcmp_01_x(_jit, ARM_CC_VS, r0); -} - -__jit_inline void -vfp_unordr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - _VCMP_F64(r1, r2); - _vcmp_01_x(_jit, ARM_CC_VS, r0); -} - -static jit_insn * -_vbcmp_x(jit_state_t _jit, int cc, jit_insn *i0) -{ - jit_insn *l; - long d; - _VMRS(_R15); - l = _jit->x.pc; - if (jit_thumb_p()) { - d = (((long)i0 - (long)l) >> 1) - 2; - assert(_s20P(d)); - T2_CC_B(cc, encode_thumb_cc_jump(d)); - } - else { - d = (((long)i0 - (long)l) >> 2) - 2; - assert(_s24P(d)); - _CC_B(cc, d & 0x00ffffff); - } - return (l); -} - -__jit_inline jit_insn * -_vbcmp_f(jit_state_t _jit, int cc, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F32(r0, r1); - return (_vbcmp_x(_jit, cc, i0)); -} - -__jit_inline jit_insn * -_vbcmp_d(jit_state_t _jit, int cc, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F64(r0, r1); - return (_vbcmp_x(_jit, cc, i0)); -} - -#define vfp_bltr_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_MI,i0,r0,r1) -#define vfp_bltr_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_MI,i0,r0,r1) -#define vfp_bler_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_LS,i0,r0,r1) -#define vfp_bler_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_LS,i0,r0,r1) -#define vfp_beqr_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_EQ,i0,r0,r1) -#define vfp_beqr_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_EQ,i0,r0,r1) -#define vfp_bger_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_GE,i0,r0,r1) -#define vfp_bger_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_GE,i0,r0,r1) -#define vfp_bgtr_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_GT,i0,r0,r1) -#define vfp_bgtr_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_GT,i0,r0,r1) -#define vfp_bner_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_NE,i0,r0,r1) -#define vfp_bner_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_NE,i0,r0,r1) - -static jit_insn * -_vbncmp_x(jit_state_t _jit, int cc, jit_insn *i0) -{ - jit_insn *i; - jit_insn *l; - long d; - _VMRS(_R15); - i = _jit->x.pc; - if (jit_thumb_p()) { - T2_CC_B(cc, 0); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 1) - 2; - assert(_s24P(d)); - T2_B(encode_thumb_jump(d)); - } - else { - _CC_B(cc, 0); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 2) - 2; - assert(_s24P(d)); - _B(d & 0x00ffffff); - } - jit_patch(i); - return (l); -} - -__jit_inline jit_insn * -_vbncmp_f(jit_state_t _jit, int cc, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F32(r0, r1); - return (_vbncmp_x(_jit, cc, i0)); -} - -__jit_inline jit_insn * -_vbncmp_d(jit_state_t _jit, int cc, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F64(r0, r1); - return (_vbncmp_x(_jit, cc, i0)); -} - -#define vfp_bunltr_f(_jit,i0,r0,r1) _vbncmp_f(_jit,ARM_CC_GE,i0,r0,r1) -#define vfp_bunltr_d(_jit,i0,r0,r1) _vbncmp_d(_jit,ARM_CC_GE,i0,r0,r1) -#define vfp_bunler_f(_jit,i0,r0,r1) _vbncmp_f(_jit,ARM_CC_GT,i0,r0,r1) -#define vfp_bunler_d(_jit,i0,r0,r1) _vbncmp_d(_jit,ARM_CC_GT,i0,r0,r1) - -static jit_insn * -vfp_buneqr_x(jit_state_t _jit, jit_insn *i0) -{ - jit_insn *i; - jit_insn *j; - jit_insn *l; - long d; - _VMRS(_R15); - i = _jit->x.pc; - if (jit_thumb_p()) { - T2_CC_B(ARM_CC_VS, 0); - j = _jit->x.pc; - T2_CC_B(ARM_CC_NE, 0); - jit_patch(i); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 1) - 2; - assert(_s20P(d)); - T2_B(encode_thumb_jump(d)); - } - else { - _CC_B(ARM_CC_VS, 0); - j = _jit->x.pc; - _CC_B(ARM_CC_NE, 0); - jit_patch(i); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 2) - 2; - assert(_s24P(d)); - _B(d & 0x00ffffff); - } - jit_patch(j); - return (l); -} - -__jit_inline jit_insn * -vfp_buneqr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F32(r0, r1); - return (vfp_buneqr_x(_jit, i0)); -} - -__jit_inline jit_insn * -vfp_buneqr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F64(r0, r1); - return (vfp_buneqr_x(_jit, i0)); -} - -static jit_insn * -vfp_bunger_x(jit_state_t _jit, jit_insn *i0) -{ - jit_insn *i; - jit_insn *l; - long d; - _VMRS(_R15); - i = _jit->x.pc; - if (jit_thumb_p()) { - T2_CC_B(ARM_CC_MI, 0); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 1) - 2; - assert(_s20P(d)); - T2_CC_B(ARM_CC_HS, encode_thumb_cc_jump(d)); - - } - else { - _CC_B(ARM_CC_MI, 0); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 2) - 2; - assert(_s24P(d)); - _CC_B(ARM_CC_HS, d & 0x00ffffff); - } - jit_patch(i); - return (l); -} - -__jit_inline jit_insn * -vfp_bunger_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F32(r0, r1); - return (vfp_bunger_x(_jit, i0)); -} - -__jit_inline jit_insn * -vfp_bunger_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F64(r0, r1); - return (vfp_bunger_x(_jit, i0)); -} - -#define vfp_bungtr_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_HI,i0,r0,r1) -#define vfp_bungtr_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_HI,i0,r0,r1) - -static jit_insn * -vfp_bltgtr_x(jit_state_t _jit, jit_insn *i0) -{ - jit_insn *i; - jit_insn *j; - jit_insn *l; - long d; - _VMRS(_R15); - i = _jit->x.pc; - if (jit_thumb_p()) { - T2_CC_B(ARM_CC_VS, 0); - j = _jit->x.pc; - T2_CC_B(ARM_CC_EQ, 0); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 1) - 2; - assert(_s24P(d)); - T2_B(encode_thumb_jump(d)); - } - else { - _CC_B(ARM_CC_VS, 0); - j = _jit->x.pc; - _CC_B(ARM_CC_EQ, 0); - l = _jit->x.pc; - d = (((long)i0 - (long)l) >> 2) - 2; - assert(_s24P(d)); - _B(d & 0x00ffffff); - } - jit_patch(i); - jit_patch(j); - return (l); -} - -__jit_inline jit_insn * -vfp_bltgtr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F32(r0, r1); - return (vfp_bltgtr_x(_jit, i0)); -} - -__jit_inline jit_insn * -vfp_bltgtr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - _VCMP_F64(r0, r1); - return (vfp_bltgtr_x(_jit, i0)); -} - -#define vfp_bordr_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_VC,i0,r0,r1) -#define vfp_bordr_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_VC,i0,r0,r1) -#define vfp_bunordr_f(_jit,i0,r0,r1) _vbcmp_f(_jit,ARM_CC_VS,i0,r0,r1) -#define vfp_bunordr_d(_jit,i0,r0,r1) _vbcmp_d(_jit,ARM_CC_VS,i0,r0,r1) -#define vfp_ldr_f(_jit, r0, r1) _VLDR_F32(r0, r1, 0) -#define vfp_ldr_d(_jit, r0, r1) _VLDR_F64(r0, r1, 0) - -__jit_inline void -vfp_ldi_f(jit_state_t _jit, jit_fpr_t r0, void *i0) -{ - jit_movi_i(JIT_FTMP, (int)i0); - _VLDR_F32(r0, JIT_FTMP, 0); -} - -__jit_inline void -vfp_ldi_d(jit_state_t _jit, jit_fpr_t r0, void *i0) -{ - jit_movi_i(JIT_FTMP, (int)i0); - _VLDR_F64(r0, JIT_FTMP, 0); -} - -__jit_inline void -vfp_ldxr_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - jit_addr_i(JIT_FTMP, r1, r2); - _VLDR_F32(r0, JIT_FTMP, 0); -} - -__jit_inline void -vfp_ldxr_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - jit_addr_i(JIT_FTMP, r1, r2); - _VLDR_F64(r0, JIT_FTMP, 0); -} - -__jit_inline void -vfp_ldxi_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0) -{ - if (i0 >= 0) { - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VLDR_F32(r0, r1, i0); - else { - jit_addi_i(JIT_FTMP, r1, i0); - _VLDR_F32(r0, JIT_FTMP, 0); - } - } - else { - i0 = -i0; - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VLDRN_F32(r0, r1, i0); - else { - jit_subi_i(JIT_FTMP, r1, i0); - _VLDR_F32(r0, JIT_FTMP, 0); - } - } -} - -__jit_inline void -vfp_ldxi_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0) -{ - if (i0 >= 0) { - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VLDR_F64(r0, r1, i0); - else { - jit_addi_i(JIT_FTMP, r1, i0); - _VLDR_F64(r0, JIT_FTMP, 0); - } - } - else { - i0 = -i0; - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VLDRN_F64(r0, r1, i0); - else { - jit_subi_i(JIT_FTMP, r1, i0); - _VLDR_F64(r0, JIT_FTMP, 0); - } - } -} - -#define vfp_str_f(_jit, r0, r1) _VSTR_F32(r1, r0, 0) -#define vfp_str_d(_jit, r0, r1) _VSTR_F64(r1, r0, 0) - -__jit_inline void -vfp_sti_f(jit_state_t _jit, void *i0, jit_fpr_t r0) -{ - jit_movi_i(JIT_FTMP, (int)i0); - _VSTR_F32(r0, JIT_FTMP, 0); -} - -__jit_inline void -vfp_sti_d(jit_state_t _jit, void *i0, jit_fpr_t r0) -{ - jit_movi_i(JIT_FTMP, (int)i0); - _VSTR_F64(r0, JIT_FTMP, 0); -} - -__jit_inline void -vfp_stxr_f(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2) -{ - jit_addr_i(JIT_FTMP, r0, r1); - _VSTR_F32(r2, JIT_FTMP, 0); -} - -__jit_inline void -vfp_stxr_d(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2) -{ - jit_addr_i(JIT_FTMP, r0, r1); - _VSTR_F64(r2, JIT_FTMP, 0); -} - -__jit_inline void -vfp_stxi_f(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1) -{ - if (i0 >= 0) { - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VSTR_F32(r1, r0, i0); - else { - jit_addi_i(JIT_FTMP, r0, i0); - _VSTR_F32(r1, JIT_FTMP, 0); - } - } - else { - i0 = -i0; - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VSTRN_F32(r1, r0, i0); - else { - jit_subi_i(JIT_FTMP, r0, i0); - _VSTR_F32(r1, JIT_FTMP, 0); - } - } -} - -__jit_inline void -vfp_stxi_d(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1) -{ - if (i0 >= 0) { - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VSTR_F64(r1, r0, i0); - else { - jit_addi_i(JIT_FTMP, r0, i0); - _VSTR_F64(r1, JIT_FTMP, 0); - } - } - else { - i0 = -i0; - assert(!(i0 & 3)); - i0 >>= 2; - if (i0 < 256) - _VSTRN_F64(r1, r0, i0); - else { - jit_subi_i(JIT_FTMP, r0, i0); - _VSTR_F64(r1, JIT_FTMP, 0); - } - } -} - -__jit_inline void -vfp_getarg_f(jit_state_t _jit, jit_fpr_t r0, int i0) -{ - if (jit_hardfp_p()) { - if (i0 < 16) { - if (r0 != (jit_fpr_t)i0) - _VMOV_F32(r0, (jit_fpr_t)i0); - return; - } - } - else if (i0 < 4) { - /* registers are already saved on stack and argument registers - * may have been clobbered */ -#if 0 - _VMOV_S_A(r0, i0); -#else - vfp_ldxi_f(_jit, r0, JIT_FP, i0 << 2); -#endif - return; - } - vfp_ldxi_f(_jit, r0, JIT_FP, i0); -} - -__jit_inline void -vfp_getarg_d(jit_state_t _jit, jit_fpr_t r0, int i0) -{ - if (jit_hardfp_p()) { - if (i0 < 16) { - if (r0 != (jit_fpr_t)i0) - _VMOV_F64(r0, (jit_fpr_t)i0); - return; - } - } - else if (i0 < 4) { - /* registers are already saved on stack and argument registers - * may have been clobbered */ -#if 0 - _VMOV_D_AA(r0, i0, i0 + 1); -#else - vfp_ldxi_d(_jit, r0, JIT_FP, i0 << 2); -#endif - return; - } - vfp_ldxi_d(_jit, r0, JIT_FP, i0); -} - -__jit_inline void -vfp_pusharg_f(jit_state_t _jit, jit_fpr_t r0) -{ - int ofs = _jitl.nextarg_put++; - assert(ofs < 256); - _jitl.stack_offset -= sizeof(float); - _jitl.arguments[ofs] = (int *)_jit->x.pc; - _jitl.types[ofs >> 5] &= ~(1 << (ofs & 31)); - _VSTR_F32(r0, JIT_SP, 0); -} -#endif -__jit_inline void -vfp_pusharg_d(jit_state _jit, jit_fpr_t r0) -{ - int ofs = _jitl.nextarg_put++; - assert(ofs < 256); - _jitl.stack_offset -= sizeof(double); - _jitl.arguments[ofs] = (int *)_jit.x.pc; - _jitl.types[ofs >> 5] |= 1 << (ofs & 31); - _VSTR_F64(r0, JIT_SP, 0); -} -#if 0 -__jit_inline void -vfp_retval_f(jit_state_t _jit, jit_fpr_t r0) -{ - if (jit_hardfp_p()) { - if (r0 != _D0) - _VMOV_F32(r0, _D0); - } - else - _VMOV_S_A(r0, _R0); -} - -__jit_inline void -vfp_retval_d(jit_state_t _jit, jit_fpr_t r0) -{ - if (jit_hardfp_p()) { - if (r0 != _D0) - _VMOV_F64(r0, _D0); - } - else - _VMOV_D_AA(r0, _R0, _R1); -} - -#undef vfp_unget_tmp -#undef vfp_get_tmp -#endif - -#endif /* __lightning_fp_vfp_h */ diff --git a/src/runtime/c/pgf/lightning/arm/fp.h b/src/runtime/c/pgf/lightning/arm/fp.h deleted file mode 100644 index 479be9804..000000000 --- a/src/runtime/c/pgf/lightning/arm/fp.h +++ /dev/null @@ -1,1104 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Floating-point support (arm) - * - ***********************************************************************/ - -/*********************************************************************** - * - * Copyright 2011 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - * Authors: - * Paulo Cesar Pereira de Andrade - ***********************************************************************/ - -#ifndef __lightning_fp_arm_h -#define __lightning_fp_arm_h - -#define JIT_FPR_NUM 6 - -static const jit_fpr_t -jit_soft_order[6] = { - _D0, _D1, _D2, _D3, _D4, _D5 -}; -static const jit_fpr_t -jit_hard_order[6] = { - _D8, _D9, _D10, _D11, _D12, _D13 -}; -#define JIT_FPR(n) \ - (jit_hardfp_p() ? jit_hard_order[n] : jit_soft_order[n]) - -#include "arm/fp-swf.h" -#include "arm/fp-vfp.h" - -#if 0 -#define jit_movr_f(r0, r1) arm_movr_f(_jit, r0, r1) -__jit_inline void -arm_movr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - if (jit_swf_p()) swf_movr_f(_jit, r0, r1); - else vfp_movr_f(_jit, r0, r1); -} - -#define jit_movr_d(r0, r1) arm_movr_d(_jit, r0, r1) -__jit_inline void -arm_movr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - if (jit_swf_p()) swf_movr_d(_jit, r0, r1); - else vfp_movr_d(_jit, r0, r1); -} - -#define jit_movi_f(r0, i0) arm_movi_f(_jit, r0, i0) -__jit_inline void -arm_movi_f(jit_state_t _jit, jit_fpr_t r0, float i0) -{ - if (jit_swf_p()) swf_movi_f(_jit, r0, i0); - else vfp_movi_f(_jit, r0, i0); -} - -#define jit_movi_d(r0, i0) arm_movi_d(_jit, r0, i0) -__jit_inline void -arm_movi_d(jit_state_t _jit, jit_fpr_t r0, double i0) -{ - if (jit_swf_p()) swf_movi_d(_jit, r0, i0); - else vfp_movi_d(_jit, r0, i0); -} - -#define jit_extr_i_f(r0, r1) arm_extr_i_f(_jit, r0, r1) -__jit_inline void -arm_extr_i_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_extr_i_f(_jit, r0, r1); - else vfp_extr_i_f(_jit, r0, r1); -} - -#define jit_extr_i_d(r0, r1) arm_extr_i_d(_jit, r0, r1) -__jit_inline void -arm_extr_i_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_extr_i_d(_jit, r0, r1); - else vfp_extr_i_d(_jit, r0, r1); -} - -#define jit_extr_d_f(r0, r1) arm_extr_d_f(_jit, r0, r1) -static void -arm_extr_d_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) swf_extr_d_f(_jit, r0, r1); - else vfp_extr_d_f(_jit, r0, r1); -} - -#define jit_extr_f_d(r0, r1) arm_extr_f_d(_jit, r0, r1) -static void -arm_extr_f_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - if (jit_swf_p()) swf_extr_f_d(_jit, r0, r1); - else vfp_extr_f_d(_jit, r0, r1); -} - -#define jit_rintr_f_i(r0, r1) arm_rintr_f_i(_jit, r0, r1) -static void -arm_rintr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_rintr_f_i(_jit, r0, r1); - else vfp_rintr_f_i(_jit, r0, r1); -} - -#define jit_rintr_d_i(r0, r1) arm_rintr_d_i(_jit, r0, r1) -static void -arm_rintr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_rintr_d_i(_jit, r0, r1); - else vfp_rintr_d_i(_jit, r0, r1); -} - -#define jit_roundr_f_i(r0, r1) arm_roundr_f_i(_jit, r0, r1) -static void -arm_roundr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_roundr_f_i(_jit, r0, r1); - else vfp_roundr_f_i(_jit, r0, r1); -} - -#define jit_roundr_d_i(r0, r1) arm_roundr_d_i(_jit, r0, r1) -static void -arm_roundr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_roundr_d_i(_jit, r0, r1); - else vfp_roundr_d_i(_jit, r0, r1); -} - -#define jit_truncr_f_i(r0, r1) arm_truncr_f_i(_jit, r0, r1) -static void -arm_truncr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_truncr_f_i(_jit, r0, r1); - else vfp_truncr_f_i(_jit, r0, r1); -} - -#define jit_truncr_d_i(r0, r1) arm_truncr_d_i(_jit, r0, r1) -static void -arm_truncr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_truncr_d_i(_jit, r0, r1); - else vfp_truncr_d_i(_jit, r0, r1); -} - -#define jit_ceilr_f_i(r0, r1) arm_ceilr_f_i(_jit, r0, r1) -static void -arm_ceilr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_ceilr_f_i(_jit, r0, r1); - else vfp_ceilr_f_i(_jit, r0, r1); -} - -#define jit_ceilr_d_i(r0, r1) arm_ceilr_d_i(_jit, r0, r1) -static void -arm_ceilr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_ceilr_d_i(_jit, r0, r1); - else vfp_ceilr_d_i(_jit, r0, r1); -} - -#define jit_floorr_f_i(r0, r1) arm_floorr_f_i(_jit, r0, r1) -static void -arm_floorr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_floorr_f_i(_jit, r0, r1); - else vfp_floorr_f_i(_jit, r0, r1); -} - -#define jit_floorr_d_i(r0, r1) arm_floorr_d_i(_jit, r0, r1) -static void -arm_floorr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_floorr_d_i(_jit, r0, r1); - else vfp_floorr_d_i(_jit, r0, r1); -} - -#define jit_absr_f(r0, r1) arm_absr_f(_jit, r0, r1) -static void -arm_absr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) swf_absr_f(_jit, r0, r1); - else vfp_absr_f(_jit, r0, r1); -} - -#define jit_absr_d(r0, r1) arm_absr_d(_jit, r0, r1) -static void -arm_absr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) swf_absr_d(_jit, r0, r1); - else vfp_absr_d(_jit, r0, r1); -} - -#define jit_negr_f(r0, r1) arm_negr_f(_jit, r0, r1) -static void -arm_negr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) swf_negr_f(_jit, r0, r1); - else vfp_negr_f(_jit, r0, r1); -} - -#define jit_negr_d(r0, r1) arm_negr_d(_jit, r0, r1) -static void -arm_negr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) swf_negr_d(_jit, r0, r1); - else vfp_negr_d(_jit, r0, r1); -} - -#define jit_sqrtr_f(r0, r1) arm_sqrtr_f(_jit, r0, r1) -static void -arm_sqrtr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) swf_sqrtr_f(_jit, r0, r1); - else vfp_sqrtr_f(_jit, r0, r1); -} - -#define jit_sqrtr_d(r0, r1) arm_sqrtr_d(_jit, r0, r1) -static void -arm_sqrtr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) swf_sqrtr_d(_jit, r0, r1); - else vfp_sqrtr_d(_jit, r0, r1); -} - -#define jit_addr_f(r0, r1, r2) arm_addr_f(_jit, r0, r1, r2) -static void -arm_addr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_addr_f(_jit, r0, r1, r2); - else vfp_addr_f(_jit, r0, r1, r2); -} - -#define jit_addr_d(r0, r1, r2) arm_addr_d(_jit, r0, r1, r2) -static void -arm_addr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_addr_d(_jit, r0, r1, r2); - else vfp_addr_d(_jit, r0, r1, r2); -} - -#define jit_subr_f(r0, r1, r2) arm_subr_f(_jit, r0, r1, r2) -static void -arm_subr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_subr_f(_jit, r0, r1, r2); - else vfp_subr_f(_jit, r0, r1, r2); -} - -#define jit_subr_d(r0, r1, r2) arm_subr_d(_jit, r0, r1, r2) -static void -arm_subr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_subr_d(_jit, r0, r1, r2); - else vfp_subr_d(_jit, r0, r1, r2); -} - -#define jit_mulr_f(r0, r1, r2) arm_mulr_f(_jit, r0, r1, r2) -static void -arm_mulr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_mulr_f(_jit, r0, r1, r2); - else vfp_mulr_f(_jit, r0, r1, r2); -} - -#define jit_mulr_d(r0, r1, r2) arm_mulr_d(_jit, r0, r1, r2) -static void -arm_mulr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_mulr_d(_jit, r0, r1, r2); - else vfp_mulr_d(_jit, r0, r1, r2); -} - -#define jit_divr_f(r0, r1, r2) arm_divr_f(_jit, r0, r1, r2) -static void -arm_divr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_divr_f(_jit, r0, r1, r2); - else vfp_divr_f(_jit, r0, r1, r2); -} - -#define jit_divr_d(r0, r1, r2) arm_divr_d(_jit, r0, r1, r2) -static void -arm_divr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_divr_d(_jit, r0, r1, r2); - else vfp_divr_d(_jit, r0, r1, r2); -} - -#define jit_ltr_f(r0, r1, r2) arm_ltr_f(_jit, r0, r1, r2) -__jit_inline void -arm_ltr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ltr_f(_jit, r0, r1, r2); - else vfp_ltr_f(_jit, r0, r1, r2); -} - -#define jit_ltr_d(r0, r1, r2) arm_ltr_d(_jit, r0, r1, r2) -__jit_inline void -arm_ltr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ltr_d(_jit, r0, r1, r2); - else vfp_ltr_d(_jit, r0, r1, r2); -} - -#define jit_ler_f(r0, r1, r2) arm_ler_f(_jit, r0, r1, r2) -__jit_inline void -arm_ler_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ler_f(_jit, r0, r1, r2); - else vfp_ler_f(_jit, r0, r1, r2); -} - -#define jit_ler_d(r0, r1, r2) arm_ler_d(_jit, r0, r1, r2) -__jit_inline void -arm_ler_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ler_d(_jit, r0, r1, r2); - else vfp_ler_d(_jit, r0, r1, r2); -} - -#define jit_eqr_f(r0, r1, r2) arm_eqr_f(_jit, r0, r1, r2) -__jit_inline void -arm_eqr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_eqr_f(_jit, r0, r1, r2); - else vfp_eqr_f(_jit, r0, r1, r2); -} - -#define jit_eqr_d(r0, r1, r2) arm_eqr_d(_jit, r0, r1, r2) -__jit_inline void -arm_eqr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_eqr_d(_jit, r0, r1, r2); - else vfp_eqr_d(_jit, r0, r1, r2); -} - -#define jit_ger_f(r0, r1, r2) arm_ger_f(_jit, r0, r1, r2) -__jit_inline void -arm_ger_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ger_f(_jit, r0, r1, r2); - else vfp_ger_f(_jit, r0, r1, r2); -} - -#define jit_ger_d(r0, r1, r2) arm_ger_d(_jit, r0, r1, r2) -__jit_inline void -arm_ger_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ger_d(_jit, r0, r1, r2); - else vfp_ger_d(_jit, r0, r1, r2); -} - -#define jit_gtr_f(r0, r1, r2) arm_gtr_f(_jit, r0, r1, r2) -__jit_inline void -arm_gtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_gtr_f(_jit, r0, r1, r2); - else vfp_gtr_f(_jit, r0, r1, r2); -} - -#define jit_gtr_d(r0, r1, r2) arm_gtr_d(_jit, r0, r1, r2) -__jit_inline void -arm_gtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_gtr_d(_jit, r0, r1, r2); - else vfp_gtr_d(_jit, r0, r1, r2); -} - -#define jit_ner_f(r0, r1, r2) arm_ner_f(_jit, r0, r1, r2) -__jit_inline void -arm_ner_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ner_f(_jit, r0, r1, r2); - else vfp_ner_f(_jit, r0, r1, r2); -} - -#define jit_ner_d(r0, r1, r2) arm_ner_d(_jit, r0, r1, r2) -__jit_inline void -arm_ner_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ner_d(_jit, r0, r1, r2); - else vfp_ner_d(_jit, r0, r1, r2); -} - -#define jit_unltr_f(r0, r1, r2) arm_unltr_f(_jit, r0, r1, r2) -__jit_inline void -arm_unltr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unltr_f(_jit, r0, r1, r2); - else vfp_unltr_f(_jit, r0, r1, r2); -} - -#define jit_unltr_d(r0, r1, r2) arm_unltr_d(_jit, r0, r1, r2) -__jit_inline void -arm_unltr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unltr_d(_jit, r0, r1, r2); - else vfp_unltr_d(_jit, r0, r1, r2); -} - -#define jit_unler_f(r0, r1, r2) arm_unler_f(_jit, r0, r1, r2) -__jit_inline void -arm_unler_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unler_f(_jit, r0, r1, r2); - else vfp_unler_f(_jit, r0, r1, r2); -} - -#define jit_unler_d(r0, r1, r2) arm_unler_d(_jit, r0, r1, r2) -__jit_inline void -arm_unler_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unler_d(_jit, r0, r1, r2); - else vfp_unler_d(_jit, r0, r1, r2); -} - -#define jit_uneqr_f(r0, r1, r2) arm_uneqr_f(_jit, r0, r1, r2) -__jit_inline void -arm_uneqr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_uneqr_f(_jit, r0, r1, r2); - else vfp_uneqr_f(_jit, r0, r1, r2); -} - -#define jit_uneqr_d(r0, r1, r2) arm_uneqr_d(_jit, r0, r1, r2) -__jit_inline void -arm_uneqr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_uneqr_d(_jit, r0, r1, r2); - else vfp_uneqr_d(_jit, r0, r1, r2); -} - -#define jit_unger_f(r0, r1, r2) arm_unger_f(_jit, r0, r1, r2) -__jit_inline void -arm_unger_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unger_f(_jit, r0, r1, r2); - else vfp_unger_f(_jit, r0, r1, r2); -} - -#define jit_unger_d(r0, r1, r2) arm_unger_d(_jit, r0, r1, r2) -__jit_inline void -arm_unger_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unger_d(_jit, r0, r1, r2); - else vfp_unger_d(_jit, r0, r1, r2); -} - -#define jit_ungtr_f(r0, r1, r2) arm_ungtr_f(_jit, r0, r1, r2) -__jit_inline void -arm_ungtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ungtr_f(_jit, r0, r1, r2); - else vfp_ungtr_f(_jit, r0, r1, r2); -} - -#define jit_ungtr_d(r0, r1, r2) arm_ungtr_d(_jit, r0, r1, r2) -__jit_inline void -arm_ungtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ungtr_d(_jit, r0, r1, r2); - else vfp_ungtr_d(_jit, r0, r1, r2); -} - -#define jit_ltgtr_f(r0, r1, r2) arm_ltgtr_f(_jit, r0, r1, r2) -__jit_inline void -arm_ltgtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ltgtr_f(_jit, r0, r1, r2); - else vfp_ltgtr_f(_jit, r0, r1, r2); -} - -#define jit_ltgtr_d(r0, r1, r2) arm_ltgtr_d(_jit, r0, r1, r2) -__jit_inline void -arm_ltgtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ltgtr_d(_jit, r0, r1, r2); - else vfp_ltgtr_d(_jit, r0, r1, r2); -} - -#define jit_ordr_f(r0, r1, r2) arm_ordr_f(_jit, r0, r1, r2) -__jit_inline void -arm_ordr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ordr_f(_jit, r0, r1, r2); - else vfp_ordr_f(_jit, r0, r1, r2); -} - -#define jit_ordr_d(r0, r1, r2) arm_ordr_d(_jit, r0, r1, r2) -__jit_inline void -arm_ordr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_ordr_d(_jit, r0, r1, r2); - else vfp_ordr_d(_jit, r0, r1, r2); -} - -#define jit_unordr_f(r0, r1, r2) arm_unordr_f(_jit, r0, r1, r2) -__jit_inline void -arm_unordr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unordr_f(_jit, r0, r1, r2); - else vfp_unordr_f(_jit, r0, r1, r2); -} - -#define jit_unordr_d(r0, r1, r2) arm_unordr_d(_jit, r0, r1, r2) -__jit_inline void -arm_unordr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2) -{ - assert(r1 != JIT_FPRET && r2 != JIT_FPRET); - if (jit_swf_p()) swf_unordr_d(_jit, r0, r1, r2); - else vfp_unordr_d(_jit, r0, r1, r2); -} - -#define jit_bltr_f(i0, r0, r1) arm_bltr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bltr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bltr_f(_jit, i0, r0, r1)); - return (vfp_bltr_f(_jit, i0, r0, r1)); -} - -#define jit_bltr_d(i0, r0, r1) arm_bltr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bltr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bltr_d(_jit, i0, r0, r1)); - return (vfp_bltr_d(_jit, i0, r0, r1)); -} - -#define jit_bler_f(i0, r0, r1) arm_bler_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bler_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bler_f(_jit, i0, r0, r1)); - return (vfp_bler_f(_jit, i0, r0, r1)); -} - -#define jit_bler_d(i0, r0, r1) arm_bler_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bler_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bler_d(_jit, i0, r0, r1)); - return (vfp_bler_d(_jit, i0, r0, r1)); -} - -#define jit_beqr_f(i0, r0, r1) arm_beqr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_beqr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_beqr_f(_jit, i0, r0, r1)); - return (vfp_beqr_f(_jit, i0, r0, r1)); -} - -#define jit_beqr_d(i0, r0, r1) arm_beqr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_beqr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_beqr_d(_jit, i0, r0, r1)); - return (vfp_beqr_d(_jit, i0, r0, r1)); -} - -#define jit_bger_f(i0, r0, r1) arm_bger_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bger_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bger_f(_jit, i0, r0, r1)); - return (vfp_bger_f(_jit, i0, r0, r1)); -} - -#define jit_bger_d(i0, r0, r1) arm_bger_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bger_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bger_d(_jit, i0, r0, r1)); - return (vfp_bger_d(_jit, i0, r0, r1)); -} - -#define jit_bgtr_f(i0, r0, r1) arm_bgtr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bgtr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bgtr_f(_jit, i0, r0, r1)); - return (vfp_bgtr_f(_jit, i0, r0, r1)); -} - -#define jit_bgtr_d(i0, r0, r1) arm_bgtr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bgtr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bgtr_d(_jit, i0, r0, r1)); - return (vfp_bgtr_d(_jit, i0, r0, r1)); -} - -#define jit_bner_f(i0, r0, r1) arm_bner_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bner_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bner_f(_jit, i0, r0, r1)); - return (vfp_bner_f(_jit, i0, r0, r1)); -} - -#define jit_bner_d(i0, r0, r1) arm_bner_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bner_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bner_d(_jit, i0, r0, r1)); - return (vfp_bner_d(_jit, i0, r0, r1)); -} - -#define jit_bunltr_f(i0, r0, r1) arm_bunltr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunltr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunltr_f(_jit, i0, r0, r1)); - return (vfp_bunltr_f(_jit, i0, r0, r1)); -} - -#define jit_bunltr_d(i0, r0, r1) arm_bunltr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunltr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunltr_d(_jit, i0, r0, r1)); - return (vfp_bunltr_d(_jit, i0, r0, r1)); -} - -#define jit_bunler_f(i0, r0, r1) arm_bunler_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunler_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunler_f(_jit, i0, r0, r1)); - return (vfp_bunler_f(_jit, i0, r0, r1)); -} - -#define jit_bunler_d(i0, r0, r1) arm_bunler_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunler_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunler_d(_jit, i0, r0, r1)); - return (vfp_bunler_d(_jit, i0, r0, r1)); -} - -#define jit_buneqr_f(i0, r0, r1) arm_buneqr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_buneqr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_buneqr_f(_jit, i0, r0, r1)); - return (vfp_buneqr_f(_jit, i0, r0, r1)); -} - -#define jit_buneqr_d(i0, r0, r1) arm_buneqr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_buneqr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_buneqr_d(_jit, i0, r0, r1)); - return (vfp_buneqr_d(_jit, i0, r0, r1)); -} - -#define jit_bunger_f(i0, r0, r1) arm_bunger_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunger_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunger_f(_jit, i0, r0, r1)); - return (vfp_bunger_f(_jit, i0, r0, r1)); -} - -#define jit_bunger_d(i0, r0, r1) arm_bunger_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunger_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunger_d(_jit, i0, r0, r1)); - return (vfp_bunger_d(_jit, i0, r0, r1)); -} - -#define jit_bungtr_f(i0, r0, r1) arm_bungtr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bungtr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bungtr_f(_jit, i0, r0, r1)); - return (vfp_bungtr_f(_jit, i0, r0, r1)); -} - -#define jit_bungtr_d(i0, r0, r1) arm_bungtr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bungtr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bungtr_d(_jit, i0, r0, r1)); - return (vfp_bungtr_d(_jit, i0, r0, r1)); -} - -#define jit_bltgtr_f(i0, r0, r1) arm_bltgtr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bltgtr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bltgtr_f(_jit, i0, r0, r1)); - return (vfp_bltgtr_f(_jit, i0, r0, r1)); -} - -#define jit_bltgtr_d(i0, r0, r1) arm_bltgtr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bltgtr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bltgtr_d(_jit, i0, r0, r1)); - return (vfp_bltgtr_d(_jit, i0, r0, r1)); -} - -#define jit_bordr_f(i0, r0, r1) arm_bordr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bordr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bordr_f(_jit, i0, r0, r1)); - return (vfp_bordr_f(_jit, i0, r0, r1)); -} - -#define jit_bordr_d(i0, r0, r1) arm_bordr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bordr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bordr_d(_jit, i0, r0, r1)); - return (vfp_bordr_d(_jit, i0, r0, r1)); -} - -#define jit_bunordr_f(i0, r0, r1) arm_bunordr_f(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunordr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunordr_f(_jit, i0, r0, r1)); - return (vfp_bunordr_f(_jit, i0, r0, r1)); -} - -#define jit_bunordr_d(i0, r0, r1) arm_bunordr_d(_jit, i0, r0, r1) -__jit_inline jit_insn * -arm_bunordr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1) -{ - assert(r0 != JIT_FPRET && r1 != JIT_FPRET); - if (jit_swf_p()) return (swf_bunordr_d(_jit, i0, r0, r1)); - return (vfp_bunordr_d(_jit, i0, r0, r1)); -} - -#define jit_ldr_f(r0, r1) arm_ldr_f(_jit, r0, r1) -__jit_inline void -arm_ldr_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldr_f(_jit, r0, r1); - else vfp_ldr_f(_jit, r0, r1); -} - -#define jit_ldr_d(r0, r1) arm_ldr_d(_jit, r0, r1) -__jit_inline void -arm_ldr_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldr_d(_jit, r0, r1); - else vfp_ldr_d(_jit, r0, r1); -} - -#define jit_ldi_f(r0, i0) arm_ldi_f(_jit, r0, i0) -__jit_inline void -arm_ldi_f(jit_state_t _jit, jit_fpr_t r0, void *i0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldi_f(_jit, r0, i0); - else vfp_ldi_f(_jit, r0, i0); -} - -#define jit_ldi_d(r0, i0) arm_ldi_d(_jit, r0, i0) -__jit_inline void -arm_ldi_d(jit_state_t _jit, jit_fpr_t r0, void *i0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldi_d(_jit, r0, i0); - else vfp_ldi_d(_jit, r0, i0); -} - -#define jit_ldxr_f(r0, r1, r2) arm_ldxr_f(_jit, r0, r1, r2) -__jit_inline void -arm_ldxr_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldxr_f(_jit, r0, r1, r2); - else vfp_ldxr_f(_jit, r0, r1, r2); -} - -#define jit_ldxr_d(r0, r1, r2) arm_ldxr_d(_jit, r0, r1, r2) -__jit_inline void -arm_ldxr_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldxr_d(_jit, r0, r1, r2); - else vfp_ldxr_d(_jit, r0, r1, r2); -} - -#define jit_ldxi_f(r0, r1, i0) arm_ldxi_f(_jit, r0, r1, i0) -__jit_inline void -arm_ldxi_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldxi_f(_jit, r0, r1, i0); - else vfp_ldxi_f(_jit, r0, r1, i0); -} - -#define jit_ldxi_d(r0, r1, i0) arm_ldxi_d(_jit, r0, r1, i0) -__jit_inline void -arm_ldxi_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_ldxi_d(_jit, r0, r1, i0); - else vfp_ldxi_d(_jit, r0, r1, i0); -} - -#define jit_str_f(r0, r1) arm_str_f(_jit, r0, r1) -__jit_inline void -arm_str_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_str_f(_jit, r0, r1); - else vfp_str_f(_jit, r0, r1); -} - -#define jit_str_d(r0, r1) arm_str_d(_jit, r0, r1) -__jit_inline void -arm_str_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_str_d(_jit, r0, r1); - else vfp_str_d(_jit, r0, r1); -} - -#define jit_sti_f(i0, r0) arm_sti_f(_jit, i0, r0) -__jit_inline void -arm_sti_f(jit_state_t _jit, void *i0, jit_fpr_t r0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_sti_f(_jit, i0, r0); - else vfp_sti_f(_jit, i0, r0); -} - -#define jit_sti_d(i0, r0) arm_sti_d(_jit, i0, r0) -__jit_inline void -arm_sti_d(jit_state_t _jit, void *i0, jit_fpr_t r0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_sti_d(_jit, i0, r0); - else vfp_sti_d(_jit, i0, r0); -} - -#define jit_stxr_f(r0, r1, r2) arm_stxr_f(_jit, r0, r1, r2) -__jit_inline void -arm_stxr_f(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2) -{ - assert(r2 != JIT_FPRET); - if (jit_swf_p()) swf_stxr_f(_jit, r0, r1, r2); - else vfp_stxr_f(_jit, r0, r1, r2); -} - -#define jit_stxr_d(r0, r1, r2) arm_stxr_d(_jit, r0, r1, r2) -__jit_inline void -arm_stxr_d(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2) -{ - assert(r2 != JIT_FPRET); - if (jit_swf_p()) swf_stxr_d(_jit, r0, r1, r2); - else vfp_stxr_d(_jit, r0, r1, r2); -} - -#define jit_stxi_f(i0, r0, r1) arm_stxi_f(_jit, i0, r0, r1) -__jit_inline void -arm_stxi_f(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_stxi_f(_jit, i0, r0, r1); - else vfp_stxi_f(_jit, i0, r0, r1); -} - -#define jit_stxi_d(i0, r0, r1) arm_stxi_d(_jit, i0, r0, r1) -__jit_inline void -arm_stxi_d(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1) -{ - assert(r1 != JIT_FPRET); - if (jit_swf_p()) swf_stxi_d(_jit, i0, r0, r1); - else vfp_stxi_d(_jit, i0, r0, r1); -} - -#define jit_prolog_f(i0) do {} while (0) -#define jit_prolog_d(i0) do {} while (0) - -#define jit_prepare_f(i0) arm_prepare_f(_jit, i0) -__jit_inline void -arm_prepare_f(jit_state_t _jit, int i0) -{ - assert(i0 >= 0); - _jitl.stack_offset += i0 << 2; -} -#endif -#define jit_prepare_d(i0) \ - (assert(i0 >= 0), \ - _jitl.stack_offset += i0 << 3) -#if 0 -#define jit_arg_f() arm_arg_f(_jit) -__jit_inline int -arm_arg_f(jit_state_t _jit) -{ - int ofs; - if (jit_hardfp_p()) { - ofs = _jitl.nextarg_getf++; - if (ofs < 16) - return (ofs); - } - else { - ofs = _jitl.nextarg_get++; - if (ofs < 4) - return (ofs); - } - ofs = _jitl.framesize; - _jitl.framesize += sizeof(int); - return (ofs); -} - -#define jit_arg_d() arm_arg_d(_jit) -__jit_inline int -arm_arg_d(jit_state_t _jit) -{ - int ofs; - if (jit_hardfp_p()) { - if (_jitl.nextarg_getf & 1) - ++_jitl.nextarg_getf; - ofs = _jitl.nextarg_getf; - _jitl.nextarg_getf += 2; - if (ofs < 16) - return (ofs); - } - else { - if (_jitl.nextarg_get & 1) - ++_jitl.nextarg_get; - ofs = _jitl.nextarg_get; - _jitl.nextarg_get += 2; - if (ofs < 4) - return (ofs); - } - if (_jitl.framesize & 7) - _jitl.framesize += 4; - ofs = _jitl.framesize; - _jitl.framesize += sizeof(double); - return (ofs); -} - -#define jit_getarg_f(r0, i0) arm_getarg_f(_jit, r0, i0) -__jit_inline void -arm_getarg_f(jit_state_t _jit, jit_fpr_t r0, int i0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_getarg_f(_jit, r0, i0); - else vfp_getarg_f(_jit, r0, i0); -} - -#define jit_getarg_d(r0, i0) arm_getarg_d(_jit, r0, i0) -__jit_inline void -arm_getarg_d(jit_state_t _jit, jit_fpr_t r0, int i0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_getarg_d(_jit, r0, i0); - else vfp_getarg_d(_jit, r0, i0); -} - -#define jit_pusharg_f(r0) arm_pusharg_f(_jit, r0) -__jit_inline void -arm_pusharg_f(jit_state_t _jit, jit_fpr_t r0) -{ - assert(r0 != JIT_FPRET); - if (jit_swf_p()) swf_pusharg_f(_jit, r0); - else vfp_pusharg_f(_jit, r0); -} -#endif -#define jit_pusharg_d(r0) \ - (assert(r0 != JIT_FPRET), \ - jit_swf_p() ? swf_pusharg_d(_jit, r0) \ - : vfp_pusharg_d(_jit, r0)) -#if 0 -#define jit_retval_f(r0) arm_retval_f(_jit, r0) -__jit_inline void -arm_retval_f(jit_state_t _jit, jit_fpr_t r0) -{ - if (r0 != JIT_FPRET) { - if (jit_swf_p()) swf_retval_f(_jit, r0); - else vfp_retval_f(_jit, r0); - } - /* else assume chaining call to jit_retval_f as done in tests/funcfp.c */ -} - -#define jit_retval_d(r0) arm_retval_d(_jit, r0) -__jit_inline void -arm_retval_d(jit_state_t _jit, jit_fpr_t r0) -{ - if (r0 != JIT_FPRET) { - if (jit_swf_p()) swf_retval_d(_jit, r0); - else vfp_retval_d(_jit, r0); - } - /* else assume chaining call to jit_retval_d as done in tests/funcfp.c */ -} -#else -#define jit_ldxi_d(r0, r1, i0) 0 -#define jit_movi_d(r0, i0) 0 -#define jit_bner_d(i0, r0, r1) 0 -#endif -#endif /* __lightning_fp_arm_h */ diff --git a/src/runtime/c/pgf/lightning/arm/funcs.h b/src/runtime/c/pgf/lightning/arm/funcs.h deleted file mode 100644 index 27b2185b1..000000000 --- a/src/runtime/c/pgf/lightning/arm/funcs.h +++ /dev/null @@ -1,193 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler for the arm - * - ***********************************************************************/ - -/*********************************************************************** - * - * Copyright 2011 Free Software Foundation - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - * Authors: - * Paulo Cesar Pereira de Andrade - ***********************************************************************/ - -#ifndef __lightning_funcs_h -#define __lightning_funcs_h - -#if defined(__linux__) -# include -# include -#endif - -#include -#include -#include - -#if defined(ios_HOST_OS) || defined (darwin_HOST_OS) -extern void sys_icache_invalidate(void *start, size_t len); - -static void -jit_flush_code(void *start, void *end) -{ - mprotect(start, (char *)end - (char *)start, - PROT_READ | PROT_WRITE | PROT_EXEC); - sys_icache_invalidate(start, (char *)end-(char *)start); -} -#else -extern void __clear_cache(void*, void*); - -static void -jit_flush_code(void *start, void *end) -{ - mprotect(start, (char *)end - (char *)start, - PROT_READ | PROT_WRITE | PROT_EXEC); - __clear_cache(start, end); -} -#endif - -__attribute__((constructor)) static void -jit_get_cpu(void) -{ -#if defined(__linux__) - FILE *fp; - char *ptr; - char buf[128]; - static int initialized; - - if (initialized) - return; - initialized = 1; - if ((fp = fopen("/proc/cpuinfo", "r")) == NULL) - return; - - while (fgets(buf, sizeof(buf), fp)) { - if (strncmp(buf, "CPU architecture:", 17) == 0) { - jit_cpu.version = strtol(buf + 17, &ptr, 10); - while (*ptr) { - if (*ptr == 'T' || *ptr == 't') { - ++ptr; - jit_cpu.thumb = 1; - } - else if (*ptr == 'E' || *ptr == 'e') { - jit_cpu.extend = 1; - ++ptr; - } - else - ++ptr; - } - } - else if (strncmp(buf, "Features\t:", 10) == 0) { - if ((ptr = strstr(buf + 10, "vfpv"))) - jit_cpu.vfp = strtol(ptr + 4, NULL, 0); - if ((ptr = strstr(buf + 10, "neon"))) - jit_cpu.neon = 1; - if ((ptr = strstr(buf + 10, "thumb"))) - jit_cpu.thumb = 1; - } - } - fclose(fp); -#endif -#if defined(__ARM_PCS_VFP) - if (!jit_cpu.vfp) - jit_cpu.vfp = 3; - if (!jit_cpu.version) - jit_cpu.version = 7; - jit_cpu.abi = 1; -#endif - /* armv6t2 todo (software float and thumb2) */ - if (!jit_cpu.vfp && jit_cpu.thumb) - jit_cpu.thumb = 0; -} - -extern int __aeabi_idivmod(int, int); -extern unsigned __aeabi_uidivmod(unsigned, unsigned); - -#pragma push_macro("_jit") -#ifdef _jit -#undef _jit -#endif -#define _jit (*jit) -static void -arm_divmod(jit_state* jit, int div, int sign, - jit_gpr_t r0, jit_gpr_t r1, jit_gpr_t r2) -{ - int d; - int l; - void *p; - l = 0xf; - if ((int)r0 < 4) - /* bogus extra push to align at 8 bytes */ - l = (l & ~(1 << r0)) | 0x10; -#ifdef USE_THUMB_CODE - T1_PUSH(l); -#else - _PUSH(l); -#endif - if (r1 == _R1 && r2 == _R0) { - jit_movr_i(JIT_FTMP, _R0); - jit_movr_i(_R0, _R1); - jit_movr_i(_R1, JIT_FTMP); - } else if (r2 == _R0) { - jit_movr_i(_R1, r2); - jit_movr_i(_R0, r1); - } else { - jit_movr_i(_R0, r1); - jit_movr_i(_R1, r2); - } - p = (sign) ? (void*) __aeabi_idivmod : (void*) __aeabi_uidivmod; - if (!jit_exchange_p()) { -#ifdef USE_THUMB_CODE - d = (((int)p - (int)_jit.x.pc) >> 1) - 2; -#else - d = (((int)p - (int)_jit.x.pc) >> 2) - 2; -#endif - if (_s24P(d)) { -#ifdef USE_THUMB_CODE - T2_BLI(encode_thumb_jump(d)); -#else - _BLI(d & 0x00ffffff); -#endif - } - else - goto fallback; - } else { -fallback: - jit_movi_i(JIT_FTMP, (int)p); -#ifdef USE_THUMB_CODE - T1_BLX(JIT_FTMP); -#else - _BLX(JIT_FTMP); -#endif - } - if (div) { - jit_movr_i(r0, _R0); - } else { - jit_movr_i(r0, _R1); - } -#ifdef USE_THUMB_CODE - T1_POP(l); -#else - _POP(l); -#endif -} -#pragma pop_macro("_jit") - -#endif /* __lightning_funcs_h */ diff --git a/src/runtime/c/pgf/lightning/asm-common.h b/src/runtime/c/pgf/lightning/asm-common.h deleted file mode 100644 index c0bb46c47..000000000 --- a/src/runtime/c/pgf/lightning/asm-common.h +++ /dev/null @@ -1,207 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Dynamic assembler support - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - ***********************************************************************/ - - -#ifndef __lightning_asm_common_h_ -#define __lightning_asm_common_h_ - - -#ifndef _ASM_SAFETY -#define JITFAIL(MSG) 0 -#else -#if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || (defined __GNUC__ && (__GNUC__ == 3 ? __GNUC_MINOR__ >= 2 : __GNUC__ > 3)) -#define JITFAIL(MSG) jit_fail(MSG, __FILE__, __LINE__, __func__) -#elif defined __GNUC__ -#define JITFAIL(MSG) jit_fail(MSG, __FILE__, __LINE__, __FUNCTION__) -#else -#define JITFAIL(MSG) jit_fail(MSG, __FILE__, __LINE__, "(unknown)") -#endif -#endif - -#if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || (defined __GNUC__ && (__GNUC__ == 3 ? __GNUC_MINOR__ >= 2 : __GNUC__ > 3)) -#define JITSORRY(MSG) jit_fail("sorry, unimplemented: " MSG, __FILE__, __LINE__, __func__) -#elif defined __GNUC__ -#define JITSORRY(MSG) jit_fail("sorry, unimplemented: " MSG, __FILE__, __LINE__, __FUNCTION__) -#else -#define JITSORRY(MSG) jit_fail("sorry, unimplemented: " MSG, __FILE__, __LINE__, "(unknown)") -#endif - -#ifdef __GNUC__ -#define JIT_UNUSED __attribute__((__unused__)) -#else -#define JIT_UNUSED -#endif - - -/* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and - does not implement __extension__. But that compiler doesn't define - __GNUC_MINOR__. */ -#ifdef __GNUC__ -#if __GNUC__ < 2 || (defined(__NeXT__) && !__GNUC_MINOR__) -#define __extension__ -#endif - -#define _TEMPD(type, var) - -#define _TEMP(type, var, val, body) __extension__ ({ \ - register struct { type var } _jitl; _jitl.var = val; \ - body; \ -}) - -#else - -/* Between loading a global and calling a subroutine, we choose the lesser - * evil. */ -#define _TEMPD(type, var) static type var; -#define _TEMP(type, var, val, body) ((var = val), body) - -#endif - -typedef char _sc; -typedef unsigned char _uc; -typedef unsigned short _us; -typedef unsigned int _ui; -typedef long _sl; -typedef unsigned long _ul; - -#define _jit_UC(X) ((_uc )(X)) -#define _jit_US(X) ((_us )(X)) -#define _jit_UI(X) ((_ui )(X)) -#define _jit_SI(X) ((int )(X)) -#define _jit_SL(X) ((_sl )(X)) -#define _jit_UL(X) ((_ul )(X)) -# define _PUC(X) ((_uc *)(X)) -# define _PUS(X) ((_us *)(X)) -# define _PUI(X) ((_ui *)(X)) -# define _PSI(X) ((int *)(X)) -# define _PSL(X) ((_sl *)(X)) -# define _PUL(X) ((_ul *)(X)) - -#define _jit_B(B) _jit_UL(((*_jit.x.uc_pc++)= _jit_UC((B)& 0xff))) -#define _jit_W(W) _jit_UL(((*_jit.x.us_pc++)= _jit_US((W)&0xffff))) -#define _jit_I(I) _jit_UL(((*_jit.x.ui_pc++)= _jit_UI((I) ))) -#define _jit_L(L) _jit_UL(((*_jit.x.ul_pc++)= _jit_UL((L) ))) -#define _jit_I_noinc(I) _jit_UL(((*_jit.x.ui_pc)= _jit_UI((I) ))) - -#define _MASK(N) ((unsigned long)((1L<<(N)))-1L) -#define _siP(N,I) (!((((unsigned long)(I))^(((unsigned long)(I))<<1))&~_MASK(N))) -#define _uiP(N,I) (!(((unsigned long)(I))&~_MASK(N))) -#define _suiP(N,I) (_siP(N,I) | _uiP(N,I)) - -#ifndef _ASM_SAFETY -#define _ck_s(W,I) (_jit_UL(I) & _MASK(W)) -#define _ck_u(W,I) (_jit_UL(I) & _MASK(W)) -#define _ck_su(W,I) (_jit_UL(I) & _MASK(W)) -#define _ck_d(W,I) (_jit_UL(I) & _MASK(W)) -#else -#define _ck_s(W,I) (_siP(W,I) ? (_jit_UL(I) & _MASK(W)) : JITFAIL( "signed integer `"#I"' too large for "#W"-bit field")) -#define _ck_u(W,I) (_uiP(W,I) ? (_jit_UL(I) & _MASK(W)) : JITFAIL("unsigned integer `"#I"' too large for "#W"-bit field")) -#define _ck_su(W,I) (_suiP(W,I) ? (_jit_UL(I) & _MASK(W)) : JITFAIL( "integer `"#I"' too large for "#W"-bit field")) -#define _ck_d(W,I) (_siP(W,I) ? (_jit_UL(I) & _MASK(W)) : JITFAIL( "displacement `"#I"' too large for "#W"-bit field")) -#endif - -#define _s0P(I) ((I)==0) -#define _s8P(I) _siP(8,I) -#define _s16P(I) _siP(16,I) -#define _s20P(I) _siP(20,I) -#define _s24P(I) _siP(24,I) -#define _s32P(I) _siP(32,I) -#define _u8P(I) _uiP(8,I) -#define _u16P(I) _uiP(16,I) -#define _u32P(I) _uiP(32,I) - -#define _su8(I) _ck_su(8,I) -#define _su16(I) _ck_su(16,I) - -#define _s1(I) _ck_s( 1,I) -#define _s2(I) _ck_s( 2,I) -#define _s3(I) _ck_s( 3,I) -#define _s4(I) _ck_s( 4,I) -#define _s5(I) _ck_s( 5,I) -#define _s6(I) _ck_s( 6,I) -#define _s7(I) _ck_s( 7,I) -#define _s8(I) _ck_s( 8,I) -#define _s9(I) _ck_s( 9,I) -#define _s10(I) _ck_s(10,I) -#define _s11(I) _ck_s(11,I) -#define _s12(I) _ck_s(12,I) -#define _s13(I) _ck_s(13,I) -#define _s14(I) _ck_s(14,I) -#define _s15(I) _ck_s(15,I) -#define _s16(I) _ck_s(16,I) -#define _s17(I) _ck_s(17,I) -#define _s18(I) _ck_s(18,I) -#define _s19(I) _ck_s(19,I) -#define _s20(I) _ck_s(20,I) -#define _s21(I) _ck_s(21,I) -#define _s22(I) _ck_s(22,I) -#define _s23(I) _ck_s(23,I) -#define _s24(I) _ck_s(24,I) -#define _s25(I) _ck_s(25,I) -#define _s26(I) _ck_s(26,I) -#define _s27(I) _ck_s(27,I) -#define _s28(I) _ck_s(28,I) -#define _s29(I) _ck_s(29,I) -#define _s30(I) _ck_s(30,I) -#define _s31(I) _ck_s(31,I) -#define _u1(I) _ck_u( 1,I) -#define _u2(I) _ck_u( 2,I) -#define _u3(I) _ck_u( 3,I) -#define _u4(I) _ck_u( 4,I) -#define _u5(I) _ck_u( 5,I) -#define _u6(I) _ck_u( 6,I) -#define _u7(I) _ck_u( 7,I) -#define _u8(I) _ck_u( 8,I) -#define _u9(I) _ck_u( 9,I) -#define _u10(I) _ck_u(10,I) -#define _u11(I) _ck_u(11,I) -#define _u12(I) _ck_u(12,I) -#define _u13(I) _ck_u(13,I) -#define _u14(I) _ck_u(14,I) -#define _u15(I) _ck_u(15,I) -#define _u16(I) _ck_u(16,I) -#define _u17(I) _ck_u(17,I) -#define _u18(I) _ck_u(18,I) -#define _u19(I) _ck_u(19,I) -#define _u20(I) _ck_u(20,I) -#define _u21(I) _ck_u(21,I) -#define _u22(I) _ck_u(22,I) -#define _u23(I) _ck_u(23,I) -#define _u24(I) _ck_u(24,I) -#define _u25(I) _ck_u(25,I) -#define _u26(I) _ck_u(26,I) -#define _u27(I) _ck_u(27,I) -#define _u28(I) _ck_u(28,I) -#define _u29(I) _ck_u(29,I) -#define _u30(I) _ck_u(30,I) -#define _u31(I) _ck_u(31,I) - -#endif /* __lightning_asm_common_h */ diff --git a/src/runtime/c/pgf/lightning/core-common.h b/src/runtime/c/pgf/lightning/core-common.h deleted file mode 100644 index ee90bd472..000000000 --- a/src/runtime/c/pgf/lightning/core-common.h +++ /dev/null @@ -1,638 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer support - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - -#ifndef __lightning_core_common_h_ -#define __lightning_core_common_h_ - -typedef struct { - union { - jit_insn *pc; - _uc *uc_pc; - _us *us_pc; - _ui *ui_pc; - _ul *ul_pc; - } x; - struct jit_fp *fp; - struct jit_local_state jitl; -} jit_state; - -#define JIT_NOREG (-1) -#define JIT_R0 JIT_R(0) -#define JIT_R1 JIT_R(1) -#define JIT_R2 JIT_R(2) -#define JIT_V0 JIT_V(0) -#define JIT_V1 JIT_V(1) -#define JIT_V2 JIT_V(2) -#define JIT_FPR0 JIT_FPR(0) -#define JIT_FPR1 JIT_FPR(1) -#define JIT_FPR2 JIT_FPR(2) -#define JIT_FPR3 JIT_FPR(3) -#define JIT_FPR4 JIT_FPR(4) -#define JIT_FPR5 JIT_FPR(5) - -#define _jitl _jit.jitl - -#define jit_get_ip() (*(jit_code *) &_jit.x.pc) -#define jit_set_ip(ptr) (_jit.x.pc = (ptr), jit_get_ip ()) -#define jit_get_label() (_jit.x.pc) -#define jit_forward() (_jit.x.pc) - -#define jit_field(struc, f) ( ((long) (&((struc *) 8)->f) ) - 8) -#define jit_ptr_field(struc_p, f) ( ((long) (&((struc_p) 8)->f) ) - 8) - -/* realignment via N-byte no-ops */ - -#ifndef jit_align -#define jit_align(n) -#endif - -/* jit_code: union of many possible function pointer types. Returned - * by jit_get_ip(). - */ -typedef union jit_code { - char *ptr; - void (*vptr)(void); - char (*cptr)(void); - unsigned char (*ucptr)(void); - short (*sptr)(void); - unsigned short (*usptr)(void); - int (*iptr)(void); - unsigned int (*uiptr)(void); - long (*lptr)(void); - unsigned long (*ulptr)(void); - void * (*pptr)(void); - float (*fptr)(void); - double (*dptr)(void); -} jit_code; - -#ifndef jit_fill_delay_after -#define jit_fill_delay_after(branch) (branch) -#endif - -#define jit_delay(insn, branch) ((insn), jit_fill_delay_after(branch)) - - -/* ALU synonyms */ -#define jit_addi_ui(d, rs, is) jit_addi_i((d), (rs), (is)) -#define jit_addr_ui(d, s1, s2) jit_addr_i((d), (s1), (s2)) -#define jit_addci_ui(d, rs, is) jit_addci_i((d), (rs), (is)) -#define jit_addcr_ui(d, s1, s2) jit_addcr_i((d), (s1), (s2)) -#define jit_addxi_ui(d, rs, is) jit_addxi_i((d), (rs), (is)) -#define jit_addxr_ui(d, s1, s2) jit_addxr_i((d), (s1), (s2)) -#define jit_andi_ui(d, rs, is) jit_andi_i((d), (rs), (is)) -#define jit_andr_ui(d, s1, s2) jit_andr_i((d), (s1), (s2)) -#define jit_lshi_ui(d, rs, is) jit_lshi_i((d), (rs), (is)) -#define jit_lshr_ui(d, s1, s2) jit_lshr_i((d), (s1), (s2)) -#define jit_movi_ui(d, rs) jit_movi_i((d), (rs)) -#define jit_movr_ui(d, rs) jit_movr_i((d), (rs)) -#define jit_ori_ui(d, rs, is) jit_ori_i((d), (rs), (is)) -#define jit_orr_ui(d, s1, s2) jit_orr_i((d), (s1), (s2)) -#define jit_rsbi_ui(d, rs, is) jit_rsbi_i((d), (rs), (is)) -#define jit_rsbr_ui(d, s1, s2) jit_rsbr_i((d), (s1), (s2)) -#define jit_subi_ui(d, rs, is) jit_subi_i((d), (rs), (is)) -#define jit_subr_ui(d, s1, s2) jit_subr_i((d), (s1), (s2)) -#define jit_subci_ui(d, rs, is) jit_subci_i((d), (rs), (is)) -#define jit_subcr_ui(d, s1, s2) jit_subcr_i((d), (s1), (s2)) -#define jit_subxi_ui(d, rs, is) jit_subxi_i((d), (rs), (is)) -#define jit_subxr_ui(d, s1, s2) jit_subxr_i((d), (s1), (s2)) -#define jit_xori_ui(d, rs, is) jit_xori_i((d), (rs), (is)) -#define jit_xorr_ui(d, s1, s2) jit_xorr_i((d), (s1), (s2)) - -#define jit_addi_ul(d, rs, is) jit_addi_l((d), (rs), (is)) -#define jit_addr_ul(d, s1, s2) jit_addr_l((d), (s1), (s2)) -#define jit_addci_ul(d, rs, is) jit_addci_l((d), (rs), (is)) -#define jit_addcr_ul(d, s1, s2) jit_addcr_l((d), (s1), (s2)) -#define jit_addxi_ul(d, rs, is) jit_addxi_l((d), (rs), (is)) -#define jit_addxr_ul(d, s1, s2) jit_addxr_l((d), (s1), (s2)) -#define jit_andi_ul(d, rs, is) jit_andi_l((d), (rs), (is)) -#define jit_andr_ul(d, s1, s2) jit_andr_l((d), (s1), (s2)) -#define jit_lshi_ul(d, rs, is) jit_lshi_l((d), (rs), (is)) -#define jit_lshr_ul(d, s1, s2) jit_lshr_l((d), (s1), (s2)) -#define jit_movi_ul(d, rs) jit_movi_l((d), (rs)) -#define jit_movr_ul(d, rs) jit_movr_l((d), (rs)) -#define jit_ori_ul(d, rs, is) jit_ori_l((d), (rs), (is)) -#define jit_orr_ul(d, s1, s2) jit_orr_l((d), (s1), (s2)) -#define jit_rsbi_ul(d, rs, is) jit_rsbi_l((d), (rs), (is)) -#define jit_rsbr_ul(d, s1, s2) jit_rsbr_l((d), (s1), (s2)) -#define jit_subi_ul(d, rs, is) jit_subi_l((d), (rs), (is)) -#define jit_subr_ul(d, s1, s2) jit_subr_l((d), (s1), (s2)) -#define jit_subci_ul(d, rs, is) jit_subci_l((d), (rs), (is)) -#define jit_subcr_ul(d, s1, s2) jit_subcr_l((d), (s1), (s2)) -#define jit_subxi_ui(d, rs, is) jit_subxi_i((d), (rs), (is)) -#define jit_subxi_ul(d, rs, is) jit_subxi_l((d), (rs), (is)) -#define jit_subxr_ui(d, s1, s2) jit_subxr_i((d), (s1), (s2)) -#define jit_subxr_ul(d, s1, s2) jit_subxr_i((d), (s1), (s2)) -#define jit_xori_ul(d, rs, is) jit_xori_l((d), (rs), (is)) -#define jit_xorr_ul(d, s1, s2) jit_xorr_l((d), (s1), (s2)) - -#define jit_addr_p(d, s1, s2) jit_addr_ul((d), (s1), (s2)) -#define jit_addi_p(d, rs, is) (jit_addi_ul((d), (rs), (long) (is)), _jit.x.pc) -#define jit_movr_p(d, rs) jit_movr_ul((d), (rs)) -#define jit_subr_p(d, s1, s2) jit_subr_ul((d), (s1), (s2)) -#define jit_subi_p(d, rs, is) jit_subi_ul((d), (rs), (long) (is)) -#define jit_rsbi_p(d, rs, is) jit_rsbi_ul((d), (rs), (long) (is)) - -#ifndef jit_movi_p -#define jit_movi_p(d, is) (jit_movi_ul((d), (long) (is)), _jit.x.pc) -#endif - -#define jit_patch(pv) jit_patch_at ((pv), (_jit.x.pc)) - -#ifndef jit_addci_i -#define jit_addci_i(d, rs, is) jit_addi_i((d), (rs), (is)) -#define jit_addcr_i(d, s1, s2) jit_addr_i((d), (s1), (s2)) -#define jit_addci_l(d, rs, is) jit_addi_l((d), (rs), (is)) -#define jit_addcr_l(d, s1, s2) jit_addr_l((d), (s1), (s2)) -#endif - -#ifndef jit_subcr_i -#define jit_subcr_i(d, s1, s2) jit_subr_i((d), (s1), (s2)) -#endif - -/* NEG is not mandatory -- pick an appropriate implementation */ -#ifndef jit_negr_i -# ifdef JIT_RZERO -# define jit_negr_i(d, rs) jit_subr_i((d), JIT_RZERO, (rs)) -# define jit_negr_l(d, rs) jit_subr_l((d), JIT_RZERO, (rs)) -# else /* !JIT_RZERO */ -# ifndef jit_rsbi_i -# define jit_negr_i(d, rs) (jit_xori_i((d), (rs), -1), jit_addi_l((d), (d), 1)) -# define jit_negr_l(d, rs) (jit_xori_l((d), (rs), -1), jit_addi_l((d), (d), 1)) -# else /* jit_rsbi_i */ -# define jit_negr_i(d, rs) jit_rsbi_i((d), (rs), 0) -# define jit_negr_l(d, rs) jit_rsbi_l((d), (rs), 0) -# endif /* jit_rsbi_i */ -# endif /* !JIT_RZERO */ -#endif /* !jit_negr_i */ - -/* RSB is not mandatory */ -#ifndef jit_rsbi_i -# define jit_rsbi_i(d, rs, is) (jit_subi_i((d), (rs), (is)), jit_negr_i((d), (d))) - -# ifndef jit_rsbi_l -# define jit_rsbi_l(d, rs, is) (jit_subi_l((d), (rs), (is)), jit_negr_l((d), (d))) -# endif -#endif - -/* Common 'shortcut' implementations */ -#ifndef jit_subi_i -#define jit_subi_i(d, rs, is) jit_addi_i((d), (rs), -(is)) -#endif -#define jit_subi_l(d, rs, is) jit_addi_l((d), (rs), -(is)) -#ifndef jit_subci_i -#define jit_subci_i(d, rs, is) jit_addci_i((d), (rs), -(is)) -#endif -#define jit_subci_l(d, rs, is) jit_addci_l((d), (rs), -(is)) -#define jit_rsbr_f(d, s1, s2) jit_subr_f((d), (s2), (s1)) -#define jit_rsbr_d(d, s1, s2) jit_subr_d((d), (s2), (s1)) -#ifndef jit_rsbr_i -#define jit_rsbr_i(d, s1, s2) jit_subr_i((d), (s2), (s1)) -#endif -#define jit_rsbr_l(d, s1, s2) jit_subr_l((d), (s2), (s1)) -#define jit_rsbr_p(d, s1, s2) jit_subr_p((d), (s2), (s1)) - -/* Unary */ -#define jit_notr_c(d, rs) jit_xori_c((d), (rs), 255) -#define jit_notr_uc(d, rs) jit_xori_c((d), (rs), 255) -#define jit_notr_s(d, rs) jit_xori_s((d), (rs), 65535) -#define jit_notr_us(d, rs) jit_xori_s((d), (rs), 65535) -#ifndef jit_notr_i -#define jit_notr_i(d, rs) jit_xori_i((d), (rs), ~0) -#endif -#define jit_notr_ui(d, rs) jit_xori_i((d), (rs), ~0) -#define jit_notr_l(d, rs) jit_xori_l((d), (rs), ~0L) -#define jit_notr_ul(d, rs) jit_xori_l((d), (rs), ~0L) - -#ifndef jit_extr_c_ui -#define jit_extr_c_ui(d, rs) jit_andi_ui((d), (rs), 0xFF) -#endif -#ifndef jit_extr_s_ui -#define jit_extr_s_ui(d, rs) jit_andi_ui((d), (rs), 0xFFFF) -#endif -#ifndef jit_extr_c_i -#define jit_extr_c_i(d, rs) (jit_lshi_i((d), (rs), 24), jit_rshi_i((d), (d), 24)) -#endif -#ifndef jit_extr_s_i -#define jit_extr_s_i(d, rs) (jit_lshi_i((d), (rs), 16), jit_rshi_i((d), (d), 16)) -#endif - -#ifdef jit_addi_l /* sizeof(long) != sizeof(int) */ -#ifndef jit_extr_c_l -#define jit_extr_c_l(d, rs) (jit_lshi_l((d), (rs), 56), jit_rshi_l((d), (d), 56)) -#endif -#ifndef jit_extr_s_l -#define jit_extr_s_l(d, rs) (jit_lshi_l((d), (rs), 48), jit_rshi_l((d), (d), 48)) -#endif -#ifndef jit_extr_i_l -#define jit_extr_i_l(d, rs) (jit_lshi_l((d), (rs), 32), jit_rshi_l((d), (d), 32)) -#endif -#ifndef jit_extr_c_ul -#define jit_extr_c_ul(d, rs) jit_andi_l((d), (rs), 0xFF) -#endif -#ifndef jit_extr_s_ul -#define jit_extr_s_ul(d, rs) jit_andi_l((d), (rs), 0xFFFF) -#endif -#ifndef jit_extr_i_ul -#define jit_extr_i_ul(d, rs) jit_andi_l((d), (rs), 0xFFFFFFFFUL) -#endif -#endif - -#define jit_extr_c_s(d, rs) jit_extr_c_i((d), (rs)) -#define jit_extr_c_us(d, rs) jit_extr_c_ui((d), (rs)) -#define jit_extr_uc_s(d, rs) jit_extr_uc_i((d), (rs)) -#define jit_extr_uc_us(d, rs) jit_extr_uc_ui((d), (rs)) -#define jit_extr_uc_i(d, rs) jit_extr_c_ui((d), (rs)) -#define jit_extr_uc_ui(d, rs) jit_extr_c_ui((d), (rs)) -#define jit_extr_us_i(d, rs) jit_extr_s_ui((d), (rs)) -#define jit_extr_us_ui(d, rs) jit_extr_s_ui((d), (rs)) -#define jit_extr_uc_l(d, rs) jit_extr_c_ul((d), (rs)) -#define jit_extr_uc_ul(d, rs) jit_extr_c_ul((d), (rs)) -#define jit_extr_us_l(d, rs) jit_extr_s_ul((d), (rs)) -#define jit_extr_us_ul(d, rs) jit_extr_s_ul((d), (rs)) -#define jit_extr_ui_l(d, rs) jit_extr_i_ul((d), (rs)) -#define jit_extr_ui_ul(d, rs) jit_extr_i_ul((d), (rs)) - - -/* NTOH/HTON is not mandatory for big endian architectures */ -#ifndef jit_ntoh_ui /* big endian */ -#define jit_ntoh_ui(d, rs) ((d) == (rs) ? (void)0 : jit_movr_i((d), (rs))) -#define jit_ntoh_us(d, rs) ((d) == (rs) ? (void)0 : jit_movr_i((d), (rs))) -#endif /* big endian */ - -/* hton is a synonym for ntoh */ -#define jit_hton_ui(d, rs) jit_ntoh_ui((d), (rs)) -#define jit_hton_us(d, rs) jit_ntoh_us((d), (rs)) - -/* Stack synonyms */ -#define jit_pushr_ui(rs) jit_pushr_i(rs) -#define jit_popr_ui(rs) jit_popr_i(rs) -#define jit_pushr_ul(rs) jit_pushr_l(rs) -#define jit_popr_ul(rs) jit_popr_l(rs) -#define jit_pushr_p(rs) jit_pushr_ul(rs) -#define jit_popr_p(rs) jit_popr_ul(rs) - -#define jit_prepare(nint) jit_prepare_i((nint)) -#define jit_pusharg_c(rs) jit_pusharg_i(rs) -#define jit_pusharg_s(rs) jit_pusharg_i(rs) -#define jit_pusharg_uc(rs) jit_pusharg_i(rs) -#define jit_pusharg_us(rs) jit_pusharg_i(rs) -#define jit_pusharg_ui(rs) jit_pusharg_i(rs) -#define jit_pusharg_ul(rs) jit_pusharg_l(rs) -#define jit_pusharg_p(rs) jit_pusharg_ul(rs) - -/* Memory synonyms */ - -#ifdef JIT_RZERO -#ifndef jit_ldi_c -#define jit_ldi_c(rd, is) jit_ldxi_c((rd), JIT_RZERO, (is)) -#define jit_sti_c(id, rs) jit_stxi_c((id), JIT_RZERO, (rs)) -#define jit_ldi_s(rd, is) jit_ldxi_s((rd), JIT_RZERO, (is)) -#define jit_sti_s(id, rs) jit_stxi_s((id), JIT_RZERO, (rs)) -#define jit_ldi_i(rd, is) jit_ldxi_i((rd), JIT_RZERO, (is)) -#define jit_sti_i(id, rs) jit_stxi_i((id), JIT_RZERO, (rs)) -#define jit_ldi_l(rd, is) jit_ldxi_l((rd), JIT_RZERO, (is)) -#define jit_sti_l(id, rs) jit_stxi_l((id), JIT_RZERO, (rs)) -#define jit_ldi_uc(rd, is) jit_ldxi_uc((rd), JIT_RZERO, (is)) -#define jit_ldi_us(rd, is) jit_ldxi_us((rd), JIT_RZERO, (is)) -#define jit_ldi_ui(rd, is) jit_ldxi_ui((rd), JIT_RZERO, (is)) -#define jit_ldi_ul(rd, is) jit_ldxi_ul((rd), JIT_RZERO, (is)) -#endif - -#ifndef jit_ldr_c -#define jit_ldr_c(rd, rs) jit_ldxr_c((rd), JIT_RZERO, (rs)) -#define jit_str_c(rd, rs) jit_stxr_c(JIT_RZERO, (rd), (rs)) -#define jit_ldr_s(rd, rs) jit_ldxr_s((rd), JIT_RZERO, (rs)) -#define jit_str_s(rd, rs) jit_stxr_s(JIT_RZERO, (rd), (rs)) -#define jit_ldr_i(rd, rs) jit_ldxr_i((rd), JIT_RZERO, (rs)) -#define jit_str_i(rd, rs) jit_stxr_i(JIT_RZERO, (rd), (rs)) -#define jit_ldr_l(rd, rs) jit_ldxr_l((rd), JIT_RZERO, (rs)) -#define jit_str_l(rd, rs) jit_stxr_l(JIT_RZERO, (rd), (rs)) -#define jit_ldr_uc(rd, rs) jit_ldxr_uc((rd), JIT_RZERO, (rs)) -#define jit_ldr_us(rd, rs) jit_ldxr_us((rd), JIT_RZERO, (rs)) -#define jit_ldr_ui(rd, rs) jit_ldxr_ui((rd), JIT_RZERO, (rs)) -#define jit_ldr_ul(rd, rs) jit_ldxr_ul((rd), JIT_RZERO, (rs)) -#endif -#endif - -#define jit_str_uc(rd, rs) jit_str_c((rd), (rs)) -#define jit_sti_uc(id, rs) jit_sti_c((id), (rs)) -#define jit_stxr_uc(d1, d2, rs) jit_stxr_c((d1), (d2), (rs)) -#define jit_stxi_uc(id, rd, is) jit_stxi_c((id), (rd), (is)) - -#define jit_str_us(rd, rs) jit_str_s((rd), (rs)) -#define jit_sti_us(id, rs) jit_sti_s((id), (rs)) -#define jit_stxr_us(d1, d2, rs) jit_stxr_s((d1), (d2), (rs)) -#define jit_stxi_us(id, rd, is) jit_stxi_s((id), (rd), (is)) - -#define jit_str_ui(rd, rs) jit_str_i((rd), (rs)) -#define jit_sti_ui(id, rs) jit_sti_i((id), (rs)) -#define jit_stxr_ui(d1, d2, rs) jit_stxr_i((d1), (d2), (rs)) -#define jit_stxi_ui(id, rd, is) jit_stxi_i((id), (rd), (is)) - -#define jit_str_ul(rd, rs) jit_str_l((rd), (rs)) -#define jit_sti_ul(id, rs) jit_sti_l((id), (rs)) -#define jit_stxr_ul(d1, d2, rs) jit_stxr_l((d1), (d2), (rs)) -#define jit_stxi_ul(id, rd, is) jit_stxi_l((id), (rd), (is)) - -#define jit_str_p(rd, rs) jit_str_l((rd), (rs)) -#define jit_sti_p(id, rs) jit_sti_l((id), (rs)) -#define jit_stxr_p(d1, d2, rs) jit_stxr_l((d1), (d2), (rs)) -#define jit_stxi_p(id, rd, is) jit_stxi_l((id), (rd), (is)) - -#define jit_ldr_p(rd, rs) jit_ldr_l((rd), (rs)) -#define jit_ldi_p(rd, is) jit_ldi_l((rd), (is)) -#define jit_ldxr_p(rd, s1, s2) jit_ldxr_l((rd), (s1), (s2)) -#define jit_ldxi_p(rd, rs, is) jit_ldxi_l((rd), (rs), (is)) - - -/* Boolean & branch synonyms */ -#define jit_eqr_ui(d, s1, s2) jit_eqr_i((d), (s1), (s2)) -#define jit_eqi_ui(d, rs, is) jit_eqi_i((d), (rs), (is)) -#define jit_ner_ui(d, s1, s2) jit_ner_i((d), (s1), (s2)) -#define jit_nei_ui(d, rs, is) jit_nei_i((d), (rs), (is)) - -#define jit_eqr_ul(d, s1, s2) jit_eqr_l((d), (s1), (s2)) -#define jit_eqi_ul(d, rs, is) jit_eqi_l((d), (rs), (is)) -#define jit_ner_ul(d, s1, s2) jit_ner_l((d), (s1), (s2)) -#define jit_nei_ul(d, rs, is) jit_nei_l((d), (rs), (is)) - -#define jit_beqr_ui(label, s1, s2) jit_beqr_i((label), (s1), (s2)) -#define jit_beqi_ui(label, rs, is) jit_beqi_i((label), (rs), (is)) -#define jit_bner_ui(label, s1, s2) jit_bner_i((label), (s1), (s2)) -#define jit_bnei_ui(label, rs, is) jit_bnei_i((label), (rs), (is)) -#define jit_bmcr_ui(label, s1, s2) jit_bmcr_i((label), (s1), (s2)) -#define jit_bmci_ui(label, rs, is) jit_bmci_i((label), (rs), (is)) -#define jit_bmsr_ui(label, s1, s2) jit_bmsr_i((label), (s1), (s2)) -#define jit_bmsi_ui(label, rs, is) jit_bmsi_i((label), (rs), (is)) - -#define jit_beqr_ul(label, s1, s2) jit_beqr_l((label), (s1), (s2)) -#define jit_beqi_ul(label, rs, is) jit_beqi_l((label), (rs), (is)) -#define jit_bner_ul(label, s1, s2) jit_bner_l((label), (s1), (s2)) -#define jit_bnei_ul(label, rs, is) jit_bnei_l((label), (rs), (is)) -#define jit_bmcr_ul(label, s1, s2) jit_bmcr_l((label), (s1), (s2)) -#define jit_bmci_ul(label, rs, is) jit_bmci_l((label), (rs), (is)) -#define jit_bmsr_ul(label, s1, s2) jit_bmsr_l((label), (s1), (s2)) -#define jit_bmsi_ul(label, rs, is) jit_bmsi_l((label), (rs), (is)) - -#define jit_ltr_p(d, s1, s2) jit_ltr_ul((d), (s1), (s2)) -#define jit_lti_p(d, rs, is) jit_lti_ul((d), (rs), (is)) -#define jit_ler_p(d, s1, s2) jit_ler_ul((d), (s1), (s2)) -#define jit_lei_p(d, rs, is) jit_lei_ul((d), (rs), (is)) -#define jit_gtr_p(d, s1, s2) jit_gtr_ul((d), (s1), (s2)) -#define jit_gti_p(d, rs, is) jit_gti_ul((d), (rs), (is)) -#define jit_ger_p(d, s1, s2) jit_ger_ul((d), (s1), (s2)) -#define jit_gei_p(d, rs, is) jit_gei_ul((d), (rs), (is)) -#define jit_eqr_p(d, s1, s2) jit_eqr_ul((d), (s1), (s2)) -#define jit_eqi_p(d, rs, is) jit_eqi_ul((d), (rs), (is)) -#define jit_ner_p(d, s1, s2) jit_ner_ul((d), (s1), (s2)) -#define jit_nei_p(d, rs, is) jit_nei_ul((d), (rs), (is)) - -#define jit_bltr_p(label, s1, s2) jit_bltr_ul((label), (s1), (s2)) -#define jit_blti_p(label, rs, is) jit_blti_ul((label), (rs), (is)) -#define jit_bler_p(label, s1, s2) jit_bler_ul((label), (s1), (s2)) -#define jit_blei_p(label, rs, is) jit_blei_ul((label), (rs), (is)) -#define jit_bgtr_p(label, s1, s2) jit_bgtr_ul((label), (s1), (s2)) -#define jit_bgti_p(label, rs, is) jit_bgti_ul((label), (rs), (is)) -#define jit_bger_p(label, s1, s2) jit_bger_ul((label), (s1), (s2)) -#define jit_bgei_p(label, rs, is) jit_bgei_ul((label), (rs), (is)) -#define jit_beqr_p(label, s1, s2) jit_beqr_ul((label), (s1), (s2)) -#define jit_beqi_p(label, rs, is) jit_beqi_ul((label), (rs), (is)) -#define jit_bner_p(label, s1, s2) jit_bner_ul((label), (s1), (s2)) -#define jit_bnei_p(label, rs, is) jit_bnei_ul((label), (rs), _jit_UL(is)) - -#define jit_retval_ui(rd) jit_retval_i((rd)) -#define jit_retval_uc(rd) jit_retval_i((rd)) -#define jit_retval_us(rd) jit_retval_i((rd)) -#define jit_retval_ul(rd) jit_retval_l((rd)) -#define jit_retval_p(rd) jit_retval_ul((rd)) -#define jit_retval_c(rd) jit_retval_i((rd)) -#define jit_retval_s(rd) jit_retval_i((rd)) - -/* This was a bug, but we keep it. */ -#define jit_retval(rd) jit_retval_i ((rd)) - -#ifndef jit_finish -#define jit_finish(sub) jit_calli(sub) -#endif - -#ifndef jit_finishr -#define jit_finishr(reg) jit_callr(reg) -#endif - -#ifndef jit_prolog -#define jit_prolog(numargs) -#endif - -#ifndef jit_leaf -#define jit_leaf(numargs) jit_prolog(numargs) -#endif - -#ifndef jit_getarg_c -#ifndef JIT_FP -#define jit_getarg_c(reg, ofs) jit_extr_c_i ((reg), (ofs)) -#define jit_getarg_i(reg, ofs) jit_movr_i ((reg), (ofs)) -#define jit_getarg_l(reg, ofs) jit_movr_l ((reg), (ofs)) -#define jit_getarg_p(reg, ofs) jit_movr_p ((reg), (ofs)) -#define jit_getarg_s(reg, ofs) jit_extr_s_i ((reg), (ofs)) -#define jit_getarg_uc(reg, ofs) jit_extr_uc_ui((reg), (ofs)) -#define jit_getarg_ui(reg, ofs) jit_movr_ui ((reg), (ofs)) -#define jit_getarg_ul(reg, ofs) jit_extr_uc_ul((reg), (ofs)) -#define jit_getarg_us(reg, ofs) jit_extr_us_ul((reg), (ofs)) -#else -#define jit_getarg_c(reg, ofs) jit_ldxi_c((reg), JIT_FP, (ofs)); -#define jit_getarg_uc(reg, ofs) jit_ldxi_uc((reg), JIT_FP, (ofs)); -#define jit_getarg_s(reg, ofs) jit_ldxi_s((reg), JIT_FP, (ofs)); -#define jit_getarg_us(reg, ofs) jit_ldxi_us((reg), JIT_FP, (ofs)); -#define jit_getarg_i(reg, ofs) jit_ldxi_i((reg), JIT_FP, (ofs)); -#define jit_getarg_ui(reg, ofs) jit_ldxi_ui((reg), JIT_FP, (ofs)); -#define jit_getarg_l(reg, ofs) jit_ldxi_l((reg), JIT_FP, (ofs)); -#define jit_getarg_ul(reg, ofs) jit_ldxi_ul((reg), JIT_FP, (ofs)); -#define jit_getarg_p(reg, ofs) jit_ldxi_p((reg), JIT_FP, (ofs)); -#endif -#endif - -#ifndef jit_setarg_p -#ifdef JIT_FP -#define jit_setarg_p(reg, ofs) jit_stxi_p((ofs), JIT_FP, (reg)); -#endif -#endif - - -/* Common definitions when sizeof(long) = sizeof(int) */ -#ifndef jit_addi_l -#define JIT_LONG_IS_INT - -/* ALU */ -#define jit_addi_l(d, rs, is) jit_addi_i((d), (rs), (is)) -#define jit_addr_l(d, s1, s2) jit_addr_i((d), (s1), (s2)) -#define jit_addci_l(d, rs, is) jit_addci_i((d), (rs), (is)) -#define jit_addcr_l(d, s1, s2) jit_addcr_i((d), (s1), (s2)) -#define jit_addxi_l(d, rs, is) jit_addxi_i((d), (rs), (is)) -#define jit_addxr_l(d, s1, s2) jit_addxr_i((d), (s1), (s2)) -#define jit_andi_l(d, rs, is) jit_andi_i((d), (rs), (is)) -#define jit_andr_l(d, s1, s2) jit_andr_i((d), (s1), (s2)) -#define jit_divi_l(d, rs, is) jit_divi_i((d), (rs), (is)) -#define jit_divr_l(d, s1, s2) jit_divr_i((d), (s1), (s2)) -#define jit_hmuli_l(d, rs, is) jit_hmuli_i((d), (rs), (is)) -#define jit_hmulr_l(d, s1, s2) jit_hmulr_i((d), (s1), (s2)) -#define jit_lshi_l(d, rs, is) jit_lshi_i((d), (rs), (is)) -#define jit_lshr_l(d, s1, s2) jit_lshr_i((d), (s1), (s2)) -#define jit_modi_l(d, rs, is) jit_modi_i((d), (rs), (is)) -#define jit_modr_l(d, s1, s2) jit_modr_i((d), (s1), (s2)) -#define jit_muli_l(d, rs, is) jit_muli_i((d), (rs), (is)) -#define jit_mulr_l(d, s1, s2) jit_mulr_i((d), (s1), (s2)) -#define jit_ori_l(d, rs, is) jit_ori_i((d), (rs), (is)) -#define jit_orr_l(d, s1, s2) jit_orr_i((d), (s1), (s2)) -#define jit_rshi_l(d, rs, is) jit_rshi_i((d), (rs), (is)) -#define jit_rshr_l(d, s1, s2) jit_rshr_i((d), (s1), (s2)) -#define jit_subr_l(d, s1, s2) jit_subr_i((d), (s1), (s2)) -#define jit_subcr_l(d, s1, s2) jit_subcr_i((d), (s1), (s2)) -#define jit_subxi_l(d, rs, is) jit_subxi_i((d), (rs), (is)) -#define jit_subxr_l(d, s1, s2) jit_subxr_i((d), (s1), (s2)) -#define jit_xori_l(d, rs, is) jit_xori_i((d), (rs), (is)) -#define jit_xorr_l(d, s1, s2) jit_xorr_i((d), (s1), (s2)) - -#ifndef jit_rsbi_l -#define jit_rsbi_l(d, rs, is) jit_rsbi_i((d), (rs), (is)) -#endif - -#define jit_divi_ul(d, rs, is) jit_divi_ui((d), (rs), (is)) -#define jit_divr_ul(d, s1, s2) jit_divr_ui((d), (s1), (s2)) -#define jit_hmuli_ul(d, rs, is) jit_hmuli_ui((d), (rs), (is)) -#define jit_hmulr_ul(d, s1, s2) jit_hmulr_ui((d), (s1), (s2)) -#define jit_modi_ul(d, rs, is) jit_modi_ui((d), (rs), (is)) -#define jit_modr_ul(d, s1, s2) jit_modr_ui((d), (s1), (s2)) -#define jit_muli_ul(d, rs, is) jit_muli_ui((d), (rs), (is)) -#define jit_mulr_ul(d, s1, s2) jit_mulr_ui((d), (s1), (s2)) -#define jit_rshi_ul(d, rs, is) jit_rshi_ui((d), (rs), (is)) -#define jit_rshr_ul(d, s1, s2) jit_rshr_ui((d), (s1), (s2)) - -/* Sign/Zero extension */ -#define jit_extr_c_l(d, rs) jit_extr_c_i(d, rs) -#define jit_extr_c_ul(d, rs) jit_extr_c_ui(d, rs) -#define jit_extr_s_l(d, rs) jit_extr_s_i(d, rs) -#define jit_extr_s_ul(d, rs) jit_extr_s_ui(d, rs) -#define jit_extr_i_l(d, rs) jit_movr_i(d, rs) -#define jit_extr_i_ul(d, rs) jit_movr_i(d, rs) - -/* Unary */ -#define jit_movi_l(d, rs) jit_movi_i((d), (rs)) -#define jit_movr_l(d, rs) jit_movr_i((d), (rs)) - -/* Stack */ -#define jit_pushr_l(rs) jit_pushr_i(rs) -#define jit_popr_l(rs) jit_popr_i(rs) -#define jit_pusharg_l(rs) jit_pusharg_i(rs) - -/* Memory */ -#ifndef JIT_RZERO -#define jit_ldr_l(d, rs) jit_ldr_i((d), (rs)) -#define jit_ldi_l(d, is) jit_ldi_i((d), (is)) -#define jit_str_l(d, rs) jit_str_i((d), (rs)) -#define jit_sti_l(d, is) jit_sti_i((d), (is)) -#define jit_ldr_ui(d, rs) jit_ldr_i((d), (rs)) -#define jit_ldi_ui(d, is) jit_ldi_i((d), (is)) -#define jit_ldr_ul(d, rs) jit_ldr_ui((d), (rs)) -#define jit_ldi_ul(d, is) jit_ldi_ui((d), (is)) -#endif - -#define jit_ldxr_l(d, s1, s2) jit_ldxr_i((d), (s1), (s2)) -#define jit_ldxi_l(d, rs, is) jit_ldxi_i((d), (rs), (is)) -#define jit_stxr_l(d, s1, s2) jit_stxr_i((d), (s1), (s2)) -#define jit_stxi_l(d, rs, is) jit_stxi_i((d), (rs), (is)) -#define jit_ldxr_ui(d, s1, s2) jit_ldxr_i((d), (s1), (s2)) -#define jit_ldxi_ui(d, rs, is) jit_ldxi_i((d), (rs), (is)) -#define jit_ldxr_ul(d, s1, s2) jit_ldxr_ui((d), (s1), (s2)) -#define jit_ldxi_ul(d, rs, is) jit_ldxi_ui((d), (rs), (is)) - - -/* Boolean */ -#define jit_ltr_l(d, s1, s2) jit_ltr_i((d), (s1), (s2)) -#define jit_lti_l(d, rs, is) jit_lti_i((d), (rs), (is)) -#define jit_ler_l(d, s1, s2) jit_ler_i((d), (s1), (s2)) -#define jit_lei_l(d, rs, is) jit_lei_i((d), (rs), (is)) -#define jit_gtr_l(d, s1, s2) jit_gtr_i((d), (s1), (s2)) -#define jit_gti_l(d, rs, is) jit_gti_i((d), (rs), (is)) -#define jit_ger_l(d, s1, s2) jit_ger_i((d), (s1), (s2)) -#define jit_gei_l(d, rs, is) jit_gei_i((d), (rs), (is)) -#define jit_eqr_l(d, s1, s2) jit_eqr_i((d), (s1), (s2)) -#define jit_eqi_l(d, rs, is) jit_eqi_i((d), (rs), (is)) -#define jit_ner_l(d, s1, s2) jit_ner_i((d), (s1), (s2)) -#define jit_nei_l(d, rs, is) jit_nei_i((d), (rs), (is)) -#define jit_ltr_ul(d, s1, s2) jit_ltr_ui((d), (s1), (s2)) -#define jit_lti_ul(d, rs, is) jit_lti_ui((d), (rs), (is)) -#define jit_ler_ul(d, s1, s2) jit_ler_ui((d), (s1), (s2)) -#define jit_lei_ul(d, rs, is) jit_lei_ui((d), (rs), (is)) -#define jit_gtr_ul(d, s1, s2) jit_gtr_ui((d), (s1), (s2)) -#define jit_gti_ul(d, rs, is) jit_gti_ui((d), (rs), (is)) -#define jit_ger_ul(d, s1, s2) jit_ger_ui((d), (s1), (s2)) -#define jit_gei_ul(d, rs, is) jit_gei_ui((d), (rs), (is)) - -/* Branches */ -#define jit_bltr_l(label, s1, s2) jit_bltr_i((label), (s1), (s2)) -#define jit_blti_l(label, rs, is) jit_blti_i((label), (rs), (is)) -#define jit_bler_l(label, s1, s2) jit_bler_i((label), (s1), (s2)) -#define jit_blei_l(label, rs, is) jit_blei_i((label), (rs), (is)) -#define jit_bgtr_l(label, s1, s2) jit_bgtr_i((label), (s1), (s2)) -#define jit_bgti_l(label, rs, is) jit_bgti_i((label), (rs), (is)) -#define jit_bger_l(label, s1, s2) jit_bger_i((label), (s1), (s2)) -#define jit_bgei_l(label, rs, is) jit_bgei_i((label), (rs), (is)) -#define jit_beqr_l(label, s1, s2) jit_beqr_i((label), (s1), (s2)) -#define jit_beqi_l(label, rs, is) jit_beqi_i((label), (rs), (is)) -#define jit_bner_l(label, s1, s2) jit_bner_i((label), (s1), (s2)) -#define jit_bnei_l(label, rs, is) jit_bnei_i((label), (rs), (is)) -#define jit_bmcr_l(label, s1, s2) jit_bmcr_i((label), (s1), (s2)) -#define jit_bmci_l(label, rs, is) jit_bmci_i((label), (rs), (is)) -#define jit_bmsr_l(label, s1, s2) jit_bmsr_i((label), (s1), (s2)) -#define jit_bmsi_l(label, rs, is) jit_bmsi_i((label), (rs), (is)) -#define jit_boaddr_l(label, s1, s2) jit_boaddr_i((label), (s1), (s2)) -#define jit_boaddi_l(label, rs, is) jit_boaddi_i((label), (rs), (is)) -#define jit_bosubr_l(label, s1, s2) jit_bosubr_i((label), (s1), (s2)) -#define jit_bosubi_l(label, rs, is) jit_bosubi_i((label), (rs), (is)) -#define jit_bltr_ul(label, s1, s2) jit_bltr_ui((label), (s1), (s2)) -#define jit_blti_ul(label, rs, is) jit_blti_ui((label), (rs), (is)) -#define jit_bler_ul(label, s1, s2) jit_bler_ui((label), (s1), (s2)) -#define jit_blei_ul(label, rs, is) jit_blei_ui((label), (rs), (is)) -#define jit_bgtr_ul(label, s1, s2) jit_bgtr_ui((label), (s1), (s2)) -#define jit_bgti_ul(label, rs, is) jit_bgti_ui((label), (rs), (is)) -#define jit_bger_ul(label, s1, s2) jit_bger_ui((label), (s1), (s2)) -#define jit_bgei_ul(label, rs, is) jit_bgei_ui((label), (rs), (is)) -#define jit_boaddr_ul(label, s1, s2) jit_boaddr_ui((label), (s1), (s2)) -#define jit_boaddi_ul(label, rs, is) jit_boaddi_ui((label), (rs), (is)) -#define jit_bosubr_ul(label, s1, s2) jit_bosubr_ui((label), (s1), (s2)) -#define jit_bosubi_ul(label, rs, is) jit_bosubi_ui((label), (rs), (is)) - -#define jit_retval_l(rd) jit_retval_i((rd)) - -#endif - -#endif /* __lightning_core_common_h_ */ diff --git a/src/runtime/c/pgf/lightning/fp-common.h b/src/runtime/c/pgf/lightning/fp-common.h deleted file mode 100644 index 907fdc4d9..000000000 --- a/src/runtime/c/pgf/lightning/fp-common.h +++ /dev/null @@ -1,86 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer floating-point interface - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - -#define JIT_FPR0 JIT_FPR(0) -#define JIT_FPR1 JIT_FPR(1) -#define JIT_FPR2 JIT_FPR(2) -#define JIT_FPR3 JIT_FPR(3) -#define JIT_FPR4 JIT_FPR(4) -#define JIT_FPR5 JIT_FPR(5) - -#ifdef JIT_RZERO -#ifndef jit_ldi_f -#define jit_ldi_f(rd, is) jit_ldxi_f((rd), JIT_RZERO, (is)) -#define jit_sti_f(id, rs) jit_stxi_f((id), JIT_RZERO, (rs)) -#define jit_ldi_d(rd, is) jit_ldxi_d((rd), JIT_RZERO, (is)) -#define jit_sti_d(id, rs) jit_stxi_d((id), JIT_RZERO, (rs)) -#endif - -#ifndef jit_ldr_f -#define jit_ldr_f(rd, rs) jit_ldxr_f((rd), JIT_RZERO, (rs)) -#define jit_str_f(rd, rs) jit_stxr_f((rd), JIT_RZERO, (rs)) -#define jit_ldr_d(rd, rs) jit_ldxr_d((rd), JIT_RZERO, (rs)) -#define jit_str_d(rd, rs) jit_stxr_d((rd), JIT_RZERO, (rs)) -#endif -#endif - -#ifndef jit_addr_f -#define jit_addr_f(rd,s1,s2) jit_addr_d(rd,s1,s2) -#define jit_subr_f(rd,s1,s2) jit_subr_d(rd,s1,s2) -#define jit_mulr_f(rd,s1,s2) jit_mulr_d(rd,s1,s2) -#define jit_divr_f(rd,s1,s2) jit_divr_d(rd,s1,s2) -#define jit_movr_f(rd,rs) jit_movr_d(rd,rs) -#define jit_abs_f(rd,rs) jit_abs_d(rd,rs) -#define jit_negr_f(rd,rs) jit_negr_d(rd,rs) -#define jit_sqrt_f(rd,rs) jit_sqrt_d(rd,rs) -#define jit_extr_f_d(rs, rd) -#define jit_extr_d_f(rs, rd) -#define jit_extr_i_f(rd, rs) jit_extr_i_d(rd, rs) -#define jit_roundr_f_i(rd, rs) jit_roundr_d_i(rd, rs) -#define jit_floorr_f_i(rd, rs) jit_floorr_d_i(rd, rs) -#define jit_ceilr_f_i(rd, rs) jit_ceilr_d_i(rd, rs) -#define jit_truncr_f_i(rd, rs) jit_truncr_d_i(rd, rs) -#define jit_ltr_f(d, s1, s2) jit_ltr_d(d, s1, s2) -#define jit_ler_f(d, s1, s2) jit_ler_d(d, s1, s2) -#define jit_eqr_f(d, s1, s2) jit_eqr_d(d, s1, s2) -#define jit_ner_f(d, s1, s2) jit_ner_d(d, s1, s2) -#define jit_ger_f(d, s1, s2) jit_ger_d(d, s1, s2) -#define jit_gtr_f(d, s1, s2) jit_gtr_d(d, s1, s2) -#define jit_unltr_f(d, s1, s2) jit_unltr_d(d, s1, s2) -#define jit_unler_f(d, s1, s2) jit_unler_d(d, s1, s2) -#define jit_uneqr_f(d, s1, s2) jit_uneqr_d(d, s1, s2) -#define jit_ltgtr_f(d, s1, s2) jit_ltgtr_d(d, s1, s2) -#define jit_unger_f(d, s1, s2) jit_unger_d(d, s1, s2) -#define jit_ungtr_f(d, s1, s2) jit_ungtr_d(d, s1, s2) -#define jit_ordr_f(d, s1, s2) jit_ordr_d(d, s1, s2) -#define jit_unordr_f(d, s1, s2) jit_unordr_d(d, s1, s2) -#define jit_retval_f(rs) jit_retval_d(rs) -#endif diff --git a/src/runtime/c/pgf/lightning/funcs-common.h b/src/runtime/c/pgf/lightning/funcs-common.h deleted file mode 100644 index 278c544f3..000000000 --- a/src/runtime/c/pgf/lightning/funcs-common.h +++ /dev/null @@ -1,54 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer inline functions (common part) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - -#ifndef __lightning_funcs_common_h -#define __lightning_funcs_common_h - -#include -#include - -static int jit_fail(const char *, const char*, int, const char *) JIT_UNUSED; - -int -jit_fail(const char *msg, const char *file, int line, const char *function) -{ - fprintf(stderr, "%s: In function `%s':\n", file, function); - fprintf(stderr, "%s:%d: %s\n", file, line, msg); - abort(); -} - - -#ifndef jit_start_pfx -#define jit_start_pfx() ( (jit_insn*)0x4) -#define jit_end_pfx() ( (jit_insn*)0x0) -#endif - -#endif /* __lightning_funcs_common_h */ diff --git a/src/runtime/c/pgf/lightning/i386/asm-32.h b/src/runtime/c/pgf/lightning/i386/asm-32.h deleted file mode 100644 index c5c0f802d..000000000 --- a/src/runtime/c/pgf/lightning/i386/asm-32.h +++ /dev/null @@ -1,125 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler for the i386 - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2003 Gwenole Beauchesne - * Copyright 2006 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - - -#ifndef __lightning_asm_h -#define __lightning_asm_h - -#ifndef LIGHTNING_DEBUG - -/* OPCODE + i = immediate operand - * + r = register operand - * + m = memory operand (disp,base,index,scale) - * + sr/sm = a star preceding a register or memory - */ - -#if !_ASM_SAFETY -# define _r1(R) _rN(R) -# define _r2(R) _rN(R) -# define _r4(R) _rN(R) -# define _r8(R) _rN(R) -# define _rM(R) _rN(R) -# define _rX(R) _rN(R) -#else -/* _r1() used to check only for _AL and _AH but there is - * usage of _CL and _DL when _*AX is already an operand */ -# define _r1(R) \ - /* Valid 32 bit register? */ \ - ((!((R) & ~0x77) \ - /* 32, 16 or 8 bit register? */ \ - && (((_rC(R) == 0x40 || _rC(R) == 0x30 || _rC(R) == 0x10) \ - /* Yes. Register is _AL, _CL or _DL? */ \ - && ( (_rN(R) | 0x10) == _AL \ - || (_rN(R) | 0x10) == _CL \ - || (_rN(R) | 0x10) == _DL)) \ - /* No. Register is _AH? */ \ - || ((_rC(R) == 0x20 && (_rN(R) | 0x20) == _AH)))) \ - ? _rN(R) : JITFAIL("bad 8-bit register " #R)) -# define _r2(R) \ - /* Valid 32 bit register? */ \ - ((!((R) & ~0x77) \ - /* 32, 16 or 8 bit register? */ \ - && (_rC(R) == 0x40 || _rC(R) == 0x30 || _rC(R) == 0x10)) \ - ? _rN(R) : JITFAIL("bad 16-bit register " #R)) -# define _r4(R) \ - /* Valid 32 bit register? */ \ - ((!((R) & ~0x77) \ - /* 32, 16 or 8 bit register? */ \ - && (_rC(R) == 0x40 || _rC(R) == 0x30 || _rC(R) == 0x10)) \ - ? _rN(R) : JITFAIL("bad 32-bit register " #R)) -# define _r8(R) \ - JITFAIL("bad 64-bit register " #R) -# define _rM(R) \ - /* Valid MMX register? */ \ - ((!((R) & ~0x67) && _rC(R) == 0x60) \ - ? _rN(R) : JITFAIL("bad MMX register " #R)) -# define _rX(R) \ - /* Valid SSE register? */ \ - ((!((R) & ~0x77) && _rC(R) == 0x70) \ - ? _rN(R) : JITFAIL("bad SSE register " #R)) -#endif - -#define _rA(R) _r4(R) - -#define jit_check8(rs) ((_rN(rs) | _AL) == _AL) -#define jit_reg8(rs) \ - ((jit_reg16(rs) == _SI || jit_reg16(rs) == _DI) \ - ? _AL : (_rN(rs) | _AL)) -#define jit_reg16(rs) (_rN(rs) | _AX) - -/* Use RIP-addressing in 64-bit mode, if possible */ -#define _r_X( R, D,B,I,S,O) (_r0P(I) ? (_r0P(B) ? _r_D (R,D ) : \ - (_rsp12P(B) ? _r_DBIS(R,D,_ESP,_ESP,1) : \ - _r_DB (R,D, B ))) : \ - (_r0P(B) ? _r_4IS (R,D, I,S) : \ - (!_rspP(I) ? _r_DBIS(R,D, B, I,S) : \ - JITFAIL("illegal index register: %esp")))) -#define _m32only(X) (X) -#define _m64only(X) JITFAIL("invalid instruction in 32-bit mode") -#define _m64(X) ((void)0) - -#define _AH 0x24 -#define _CH 0x25 -#define _DH 0x26 -#define _BH 0x27 - -#define CALLsr(R) CALLLsr(R) -#define JMPsr(R) JMPLsr(R) - -#define DECWr(RD) (_d16(), _Or (0x48,_r2(RD) )) -#define DECLr(RD) _Or (0x48,_r4(RD) ) -#define INCWr(RD) (_d16(), _Or (0x40,_r2(RD) )) -#define INCLr(RD) _Or (0x40,_r4(RD) ) - -#endif -#endif /* __lightning_asm_h */ diff --git a/src/runtime/c/pgf/lightning/i386/asm-64.h b/src/runtime/c/pgf/lightning/i386/asm-64.h deleted file mode 100644 index e1ce99bae..000000000 --- a/src/runtime/c/pgf/lightning/i386/asm-64.h +++ /dev/null @@ -1,430 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler for the x86-64 - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2003 Gwenole Beauchesne - * Copyright 2006 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - - -#ifndef __lightning_asm_h -#define __lightning_asm_h - -#ifndef LIGHTNING_DEBUG - -/* OPCODE + i = immediate operand - * + r = register operand - * + m = memory operand (disp,base,index,scale) - * + sr/sm = a star preceding a register or memory - */ - -#if !_ASM_SAFETY -# define _r1(R) _rN(R) -# define _r2(R) _rN(R) -# define _r4(R) _rN(R) -# define _r8(R) _rN(R) -# define _rM(R) _rN(R) -# define _rX(R) _rN(R) -#else -# define _r1(R) \ - /* Valid 64 bit register? */ \ - ((!((R) & ~0xff) \ - /* 64, 32, 16 or 8 bit register? */ \ - && (_rC(R) == 0x50 || _rC(R) == 0x40 \ - || _rC(R) == 0x30 || _rC(R) == 0x10)) \ - ? _rN(R) : JITFAIL("bad 8-bit register " #R)) -# define _r2(R) \ - /* Valid 64 bit register? */ \ - ((!((R) & ~0xff) \ - /* 64, 32, 16 or 8 bit register? */ \ - && (_rC(R) == 0x50 || _rC(R) == 0x40 \ - || _rC(R) == 0x30 || _rC(R) == 0x10)) \ - ? _rN(R) : JITFAIL("bad 16-bit register " #R)) -# define _r4(R) \ - /* Valid 64 bit register? */ \ - ((!((R) & ~0xff) \ - /* 64, 32, 16 or 8 bit register? */ \ - && (_rC(R) == 0x50 || _rC(R) == 0x40 \ - || _rC(R) == 0x30 || _rC(R) == 0x10)) \ - ? _rN(R) : JITFAIL("bad 32-bit register " #R)) -# define _r8(R) \ - /* Valid 64 bit register? */ \ - ((!((R) & ~0xff) \ - /* 64, 32, 16 or 8 bit register? */ \ - && (_rC(R) == 0x50 || _rC(R) == 0x40 \ - || _rC(R) == 0x30 || _rC(R) == 0x10)) \ - ? _rN(R) : JITFAIL("bad 64-bit register " #R)) -# define _rM(R) \ - /* Valid MMX* register? */ \ - ((!((R) & ~0x6f) && _rC(R) == 0x60) \ - ? _rN(R) : JITFAIL("bad MMX register " #R)) -# define _rX(R) \ - /* Valid SSE2 register? */ \ - ((!((R) & ~0x7f) && _rC(R) == 0x70) \ - ? _rN(R) : JITFAIL("bad SSE2 register " #R)) -#endif - -#define _rA(R) _r8(R) - -#define jit_check8(rs) 1 -#define jit_reg8(rs) (_rR(rs) | _AL) -#define jit_reg16(rs) (_rR(rs) | _AX) - -/* Use RIP-addressing in 64-bit mode, if possible */ -#if 0 -#define _x86_RIP_addressing_possible(D,O) (X86_RIP_RELATIVE_ADDR && \ - ((unsigned long)x86_get_target() + 4 + (O) - (D) <= 0xffffffff)) - -#define _r_X( R, D,B,I,S,O) (_r0P(I) ? (_r0P(B) ? (!X86_TARGET_64BIT ? _r_D(R,D) : \ - (_x86_RIP_addressing_possible(D, O) ? \ - _r_D(R, (D) - ((unsigned long)x86_get_target() + 4 + (O))) : \ - _r_DSIB(R,D))) : \ - _r_DSIB(R,D )) : \ - (_rIP(B) ? _r_D (R,D ) : \ - (_rsp12P(B) ? _r_DBIS(R,D,_RSP,_RSP,1) : \ - _r_DB (R,D, B )))) : \ - (_r0P(B) ? _r_4IS (R,D, I,S) : \ - (!_rspP(I) ? _r_DBIS(R,D, B, I,S) : \ - JITFAIL("illegal index register: %esp")))) -#else -#define _r_X( R, D,B,I,S,O) (_r0P(I) ? (_r0P(B) ? _r_DSIB(R,D ) : \ - (_rIP(B) ? _r_D (R,D ) : \ - (_rsp12P(B) ? _r_DBIS(R,D,_RSP,_RSP,1) : \ - _r_DB (R,D, B )))) : \ - (_r0P(B) ? _r_4IS (R,D, I,S) : \ - (!_rspP(I) ? _r_DBIS(R,D, B, I,S) : \ - JITFAIL("illegal index register: %esp")))) -#endif - - -#define _m32only(X) (JITFAIL("invalid instruction in 64-bit mode")) -#define _m64only(X) (X) -#define _m64(X) (X) - -#define _SPL 0x14 -#define _BPL 0x15 -#define _SIL 0x16 -#define _DIL 0x17 -#define _R8B 0x18 -#define _R9B 0x19 -#define _R10B 0x1A -#define _R11B 0x1B -#define _R12B 0x1C -#define _R13B 0x1D -#define _R14B 0x1E -#define _R15B 0x1F - -#define _R8W 0x38 -#define _R9W 0x39 -#define _R10W 0x3A -#define _R11W 0x3B -#define _R12W 0x3C -#define _R13W 0x3D -#define _R14W 0x3E -#define _R15W 0x3F -#define _R8D 0x48 -#define _R9D 0x49 -#define _R10D 0x4A -#define _R11D 0x4B -#define _R12D 0x4C -#define _R13D 0x4D -#define _R14D 0x4E -#define _R15D 0x4F - -#define _RAX 0x50 -#define _RCX 0x51 -#define _RDX 0x52 -#define _RBX 0x53 -#define _RSP 0x54 -#define _RBP 0x55 -#define _RSI 0x56 -#define _RDI 0x57 -#define _R8 0x58 -#define _R9 0x59 -#define _R10 0x5A -#define _R11 0x5B -#define _R12 0x5C -#define _R13 0x5D -#define _R14 0x5E -#define _R15 0x5F -#define _RIP -2 - -#define _r1e8lP(R) ((int)(R) >= _SPL && (int)(R) <= _DIL) - -#define DECWr(RD) (_d16(), _REXLrr(0, RD), _O_Mrm (0xff ,_b11,_b001 ,_r2(RD) )) -#define DECLr(RD) (_REXLrr(0, RD), _O_Mrm (0xff ,_b11,_b001 ,_r4(RD) )) -#define INCWr(RD) (_d16(), _REXLrr(0, RD), _O_Mrm (0xff ,_b11,_b000 ,_r2(RD) )) -#define INCLr(RD) (_REXLrr(0, RD), _O_Mrm (0xff ,_b11,_b000 ,_r4(RD) )) - -#define ADCQrr(RS, RD) _ALUQrr(X86_ADC, RS, RD) -#define ADCQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_ADC, MD, MB, MI, MS, RD) -#define ADCQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_ADC, RS, MD, MB, MI, MS) -#define ADCQir(IM, RD) _ALUQir(X86_ADC, IM, RD) -#define ADCQim(IM, MD, MB, MI, MS) _ALUQim(X86_ADC, IM, MD, MB, MI, MS) - -#define ADDQrr(RS, RD) _ALUQrr(X86_ADD, RS, RD) -#define ADDQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_ADD, MD, MB, MI, MS, RD) -#define ADDQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_ADD, RS, MD, MB, MI, MS) -#define ADDQir(IM, RD) _ALUQir(X86_ADD, IM, RD) -#define ADDQim(IM, MD, MB, MI, MS) _ALUQim(X86_ADD, IM, MD, MB, MI, MS) - -#define ANDQrr(RS, RD) _ALUQrr(X86_AND, RS, RD) -#define ANDQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_AND, MD, MB, MI, MS, RD) -#define ANDQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_AND, RS, MD, MB, MI, MS) -#define ANDQir(IM, RD) _ALUQir(X86_AND, IM, RD) -#define ANDQim(IM, MD, MB, MI, MS) _ALUQim(X86_AND, IM, MD, MB, MI, MS) - -#define CMPQrr(RS, RD) _ALUQrr(X86_CMP, RS, RD) -#define CMPQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_CMP, MD, MB, MI, MS, RD) -#define CMPQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_CMP, RS, MD, MB, MI, MS) -#define CMPQir(IM, RD) _ALUQir(X86_CMP, IM, RD) -#define CMPQim(IM, MD, MB, MI, MS) _ALUQim(X86_CMP, IM, MD, MB, MI, MS) - -#define ORQrr(RS, RD) _ALUQrr(X86_OR, RS, RD) -#define ORQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_OR, MD, MB, MI, MS, RD) -#define ORQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_OR, RS, MD, MB, MI, MS) -#define ORQir(IM, RD) _ALUQir(X86_OR, IM, RD) -#define ORQim(IM, MD, MB, MI, MS) _ALUQim(X86_OR, IM, MD, MB, MI, MS) - -#define SBBQrr(RS, RD) _ALUQrr(X86_SBB, RS, RD) -#define SBBQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_SBB, MD, MB, MI, MS, RD) -#define SBBQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_SBB, RS, MD, MB, MI, MS) -#define SBBQir(IM, RD) _ALUQir(X86_SBB, IM, RD) -#define SBBQim(IM, MD, MB, MI, MS) _ALUQim(X86_SBB, IM, MD, MB, MI, MS) - -#define SUBQrr(RS, RD) _ALUQrr(X86_SUB, RS, RD) -#define SUBQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_SUB, MD, MB, MI, MS, RD) -#define SUBQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_SUB, RS, MD, MB, MI, MS) -#define SUBQir(IM, RD) _ALUQir(X86_SUB, IM, RD) -#define SUBQim(IM, MD, MB, MI, MS) _ALUQim(X86_SUB, IM, MD, MB, MI, MS) - -#define XORQrr(RS, RD) _ALUQrr(X86_XOR, RS, RD) -#define XORQmr(MD, MB, MI, MS, RD) _ALUQmr(X86_XOR, MD, MB, MI, MS, RD) -#define XORQrm(RS, MD, MB, MI, MS) _ALUQrm(X86_XOR, RS, MD, MB, MI, MS) -#define XORQir(IM, RD) _ALUQir(X86_XOR, IM, RD) -#define XORQim(IM, MD, MB, MI, MS) _ALUQim(X86_XOR, IM, MD, MB, MI, MS) - -#define ROLQir(IM, RD) _ROTSHIQir(X86_ROL, IM, RD) -#define ROLQim(IM, MD, MB, MI, MS) _ROTSHIQim(X86_ROL, IM, MD, MB, MI, MS) -#define ROLQrr(RS, RD) _ROTSHIQrr(X86_ROL, RS, RD) -#define ROLQrm(RS, MD, MB, MI, MS) _ROTSHIQrm(X86_ROL, RS, MD, MB, MI, MS) - -#define RORQir(IM, RD) _ROTSHIQir(X86_ROR, IM, RD) -#define RORQim(IM, MD, MB, MI, MS) _ROTSHIQim(X86_ROR, IM, MD, MB, MI, MS) -#define RORQrr(RS, RD) _ROTSHIQrr(X86_ROR, RS, RD) -#define RORQrm(RS, MD, MB, MI, MS) _ROTSHIQrm(X86_ROR, RS, MD, MB, MI, MS) - -#define RCLQir(IM, RD) _ROTSHIQir(X86_RCL, IM, RD) -#define RCLQim(IM, MD, MB, MI, MS) _ROTSHIQim(X86_RCL, IM, MD, MB, MI, MS) -#define RCLQrr(RS, RD) _ROTSHIQrr(X86_RCL, RS, RD) -#define RCLQrm(RS, MD, MB, MI, MS) _ROTSHIQrm(X86_RCL, RS, MD, MB, MI, MS) - -#define RCRQir(IM, RD) _ROTSHIQir(X86_RCR, IM, RD) -#define RCRQim(IM, MD, MB, MI, MS) _ROTSHIQim(X86_RCR, IM, MD, MB, MI, MS) -#define RCRQrr(RS, RD) _ROTSHIQrr(X86_RCR, RS, RD) -#define RCRQrm(RS, MD, MB, MI, MS) _ROTSHIQrm(X86_RCR, RS, MD, MB, MI, MS) - -#define SHLQir(IM, RD) _ROTSHIQir(X86_SHL, IM, RD) -#define SHLQim(IM, MD, MB, MI, MS) _ROTSHIQim(X86_SHL, IM, MD, MB, MI, MS) -#define SHLQrr(RS, RD) _ROTSHIQrr(X86_SHL, RS, RD) -#define SHLQrm(RS, MD, MB, MI, MS) _ROTSHIQrm(X86_SHL, RS, MD, MB, MI, MS) - -#define SHRQir(IM, RD) _ROTSHIQir(X86_SHR, IM, RD) -#define SHRQim(IM, MD, MB, MI, MS) _ROTSHIQim(X86_SHR, IM, MD, MB, MI, MS) -#define SHRQrr(RS, RD) _ROTSHIQrr(X86_SHR, RS, RD) -#define SHRQrm(RS, MD, MB, MI, MS) _ROTSHIQrm(X86_SHR, RS, MD, MB, MI, MS) - -#define SALQir SHLQir -#define SALQim SHLQim -#define SALQrr SHLQrr -#define SALQrm SHLQrm - -#define SARQir(IM, RD) _ROTSHIQir(X86_SAR, IM, RD) -#define SARQim(IM, MD, MB, MI, MS) _ROTSHIQim(X86_SAR, IM, MD, MB, MI, MS) -#define SARQrr(RS, RD) _ROTSHIQrr(X86_SAR, RS, RD) -#define SARQrm(RS, MD, MB, MI, MS) _ROTSHIQrm(X86_SAR, RS, MD, MB, MI, MS) - -#define BTQir(IM, RD) _BTQir(X86_BT, IM, RD) -#define BTQim(IM, MD, MB, MI, MS) _BTQim(X86_BT, IM, MD, MB, MI, MS) -#define BTQrr(RS, RD) _BTQrr(X86_BT, RS, RD) -#define BTQrm(RS, MD, MB, MI, MS) _BTQrm(X86_BT, RS, MD, MB, MI, MS) - -#define BTCQir(IM, RD) _BTQir(X86_BTC, IM, RD) -#define BTCQim(IM, MD, MB, MI, MS) _BTQim(X86_BTC, IM, MD, MB, MI, MS) -#define BTCQrr(RS, RD) _BTQrr(X86_BTC, RS, RD) -#define BTCQrm(RS, MD, MB, MI, MS) _BTQrm(X86_BTC, RS, MD, MB, MI, MS) - -#define BTRQir(IM, RD) _BTQir(X86_BTR, IM, RD) -#define BTRQim(IM, MD, MB, MI, MS) _BTQim(X86_BTR, IM, MD, MB, MI, MS) -#define BTRQrr(RS, RD) _BTQrr(X86_BTR, RS, RD) -#define BTRQrm(RS, MD, MB, MI, MS) _BTQrm(X86_BTR, RS, MD, MB, MI, MS) - -#define BTSQir(IM, RD) _BTQir(X86_BTS, IM, RD) -#define BTSQim(IM, MD, MB, MI, MS) _BTQim(X86_BTS, IM, MD, MB, MI, MS) -#define BTSQrr(RS, RD) _BTQrr(X86_BTS, RS, RD) -#define BTSQrm(RS, MD, MB, MI, MS) _BTQrm(X86_BTS, RS, MD, MB, MI, MS) - -#define LEAQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _O_r_X (0x8d ,_r8(RD) ,MD,MB,MI,MS )) - -#define MOVQrr(RS, RD) (_REXQrr(RS, RD), _O_Mrm (0x89 ,_b11,_r8(RS),_r8(RD) )) -#define MOVQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _O_r_X (0x8b ,_r8(RD) ,MD,MB,MI,MS )) -#define MOVQrm(RS, MD, MB, MI, MS) (_REXQrm(RS, MB, MI), _O_r_X (0x89 ,_r8(RS) ,MD,MB,MI,MS )) -#define MOVQir(IM, R) (_REXQrr(0, R), _Or_Q (0xb8,_r8(R) ,IM )) -#define MOVQim(IM, MD, MB, MI, MS) (_REXQrm(0, MB, MI), _O_X_L (0xc7 ,MD,MB,MI,MS ,IM )) - -#define NOTQr(RS) _UNARYQr(X86_NOT, RS) -#define NOTQm(MD, MB, MI, MS) _UNARYQm(X86_NOT, MD, MB, MI, MS) - -#define NEGQr(RS) _UNARYQr(X86_NEG, RS) -#define NEGQm(MD, MB, MI, MS) _UNARYQm(X86_NEG, MD, MB, MI, MS) - -#define MULQr(RS) _UNARYQr(X86_MUL, RS) -#define MULQm(MD, MB, MI, MS) _UNARYQm(X86_MUL, MD, MB, MI, MS) - -#define IMULQr(RS) _UNARYQr(X86_IMUL, RS) -#define IMULQm(MD, MB, MI, MS) _UNARYQm(X86_IMUL, MD, MB, MI, MS) - -#define DIVQr(RS) _UNARYQr(X86_DIV, RS) -#define DIVQm(MD, MB, MI, MS) _UNARYQm(X86_DIV, MD, MB, MI, MS) - -#define IDIVQr(RS) _UNARYQr(X86_IDIV, RS) -#define IDIVQm(MD, MB, MI, MS) _UNARYQm(X86_IDIV, MD, MB, MI, MS) - -#define IMULQir(IM, RD) IMULQirr(IM, RD, RD) -#define IMULQrr(RS, RD) (_REXQrr(RD, RS), _OO_Mrm (0x0faf ,_b11,_r8(RD),_r8(RS) )) -#define IMULQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0faf ,_r8(RD) ,MD,MB,MI,MS )) -#define IMULQirr(IM,RS,RD) (_REXQrr(RD, RS), _Os_Mrm_sL (0x69 ,_b11,_r8(RS),_r8(RD) ,IM )) -#define IMULQimr(IM,MD,MB,MI,MS,RD) (_REXQmr(MB, MI, RD), _Os_r_X_sL (0x69 ,_r8(RD) ,MD,MB,MI,MS ,IM )) - -#define CALLQsr(R) (_REXQrr(0, R), _O_Mrm (0xff ,_b11,_b010,_r8(R) )) -#define JMPQsr(R) (_REXQrr(0, R), _O_Mrm (0xff ,_b11,_b100,_r8(R) )) - -#define CMOVQrr(CC,RS,RD) (_REXQrr(RD, RS), _OO_Mrm (0x0f40|(CC) ,_b11,_r8(RD),_r8(RS) )) -#define CMOVQmr(CC,MD,MB,MI,MS,RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0f40|(CC) ,_r8(RD) ,MD,MB,MI,MS )) - -#define POPQr(RD) _m64only((_REXQr(RD), _Or (0x58,_r8(RD) ))) -#define POPQm(MD, MB, MI, MS) _m64only((_REXQm(MB, MI), _O_r_X (0x8f ,_b000 ,MD,MB,MI,MS ))) - -#define PUSHQr(RS) _m64only((_REXQr(RS), _Or (0x50,_r8(RS) ))) -#define PUSHQm(MD, MB, MI, MS) _m64only((_REXQm(MB, MI), _O_r_X (0xff ,_b110 ,MD,MB,MI,MS ))) -#define PUSHQi(IM) _m64only( _Os_sL (0x68 ,IM )) - -#define TESTQrr(RS, RD) (_REXQrr(RS, RD), _O_Mrm (0x85 ,_b11,_r8(RS),_r8(RD) )) -#define TESTQrm(RS, MD, MB, MI, MS) (_REXQrm(RS, MB, MI), _O_r_X (0x85 ,_r8(RS) ,MD,MB,MI,MS )) -#define TESTQir(IM, RD) \ - /* Immediate fits in 32 bits? */ \ - (_s32P((long)(IM)) \ - /* Yes. Immediate does not fit in 8 bits and reg is %rax? */ \ - ? (!_s8P(IM) && (RD) == _RAX \ - ? (_REXQrr(0, RD), _O_L(0xa9, IM)) \ - : (_REXQrr(0, RD), _O_Mrm_L(0xf7, _b11, _b000, _r8(RD), IM))) \ - /* No. Need immediate in a register */ \ - : (MOVQir(IM, JIT_REXTMP), TESTQrr(JIT_REXTMP, RD))) -#define TESTQim(IM, MD, MB, MI, MS) (_REXQrm(0, MB, MI), _O_r_X_L (0xf7 ,_b000 ,MD,MB,MI,MS ,IM )) - -#define CMPXCHGQrr(RS, RD) (_REXQrr(RS, RD), _OO_Mrm (0x0fb1 ,_b11,_r8(RS),_r8(RD) )) -#define CMPXCHGQrm(RS, MD, MB, MI, MS) (_REXQrm(RS, MB, MI), _OO_r_X (0x0fb1 ,_r8(RS) ,MD,MB,MI,MS )) - -#define XADDQrr(RS, RD) (_REXQrr(RS, RD), _OO_Mrm (0x0fc1 ,_b11,_r8(RS),_r8(RD) )) -#define XADDQrm(RS, MD, MB, MI, MS) (_REXQrm(RS, MB, MI), _OO_r_X (0x0fc1 ,_r8(RS) ,MD,MB,MI,MS )) - -#define XCHGQrr(RS, RD) (_REXQrr(RS, RD), _O_Mrm (0x87 ,_b11,_r8(RS),_r8(RD) )) -#define XCHGQrm(RS, MD, MB, MI, MS) (_REXQrm(RS, MB, MI), _O_r_X (0x87 ,_r8(RS) ,MD,MB,MI,MS )) - -#define DECQm(MD, MB, MI, MS) (_REXQrm(0, MB, MI), _O_r_X (0xff ,_b001 ,MD,MB,MI,MS )) -#define DECQr(RD) (_REXQrr(0, RD), _O_Mrm (0xff ,_b11,_b001 ,_r8(RD) )) -#define INCQm(MD, MB, MI, MS) (_REXQrm(0, MB, MI), _O_r_X (0xff ,_b000 ,MD,MB,MI,MS )) -#define INCQr(RD) (_REXQrr(0, RD), _O_Mrm (0xff ,_b11,_b000 ,_r8(RD) )) - -#define BSFQrr(RS, RD) (_REXQrr(RD, RS), _OO_Mrm (0x0fbc ,_b11,_r8(RD),_r8(RS) )) -#define BSFQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0fbc ,_r8(RD) ,MD,MB,MI,MS )) - -#define BSRQrr(RS, RD) (_REXQrr(RD, RS), _OO_Mrm (0x0fbd ,_b11,_r8(RD),_r8(RS) )) -#define BSRQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0fbd ,_r8(RD) ,MD,MB,MI,MS )) - -#define MOVSBQrr(RS, RD) (_REXQrr(RD, RS), _OO_Mrm (0x0fbe ,_b11,_r8(RD),_r1(RS) )) -#define MOVSBQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0fbe ,_r8(RD) ,MD,MB,MI,MS )) - -#define MOVZBQrr(RS, RD) (_REXQrr(RD, RS), _OO_Mrm (0x0fb6 ,_b11,_r8(RD),_r1(RS) )) -#define MOVZBQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0fb6 ,_r8(RD) ,MD,MB,MI,MS )) - -#define MOVSWQrr(RS, RD) (_REXQrr(RD, RS), _OO_Mrm (0x0fbf ,_b11,_r8(RD),_r2(RS) )) -#define MOVSWQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0fbf ,_r8(RD) ,MD,MB,MI,MS )) - -#define MOVZWQrr(RS, RD) (_REXQrr(RD, RS), _OO_Mrm (0x0fb7 ,_b11,_r8(RD),_r2(RS) )) -#define MOVZWQmr(MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _OO_r_X (0x0fb7 ,_r8(RD) ,MD,MB,MI,MS )) - -#define MOVSLQrr(RS, RD) _m64only((_REXQrr(RD, RS), _O_Mrm (0x63 ,_b11,_r8(RD),_r4(RS) ))) -#define MOVSLQmr(MD, MB, MI, MS, RD) _m64only((_REXQmr(MB, MI, RD), _O_r_X (0x63 ,_r8(RD) ,MD,MB,MI,MS ))) - -#define BSWAPQr(R) (_REXQrr(0, R), _OOr (0x0fc8,_r8(R) )) - - - -#define __SSEQrr(OP,RS,RSA,RD,RDA) (_REXQrr(RD, RS), _OO_Mrm (0x0f00|(OP) ,_b11,RDA(RD),RSA(RS) )) -#define __SSEQmr(OP,MD,MB,MI,MS,RD,RDA) (_REXQmr(MB, MI, RD), _OO_r_X (0x0f00|(OP) ,RDA(RD) ,MD,MB,MI,MS )) -#define __SSEQrm(OP,RS,RSA,MD,MB,MI,MS) (_REXQrm(RS, MB, MI), _OO_r_X (0x0f00|(OP) ,RSA(RS) ,MD,MB,MI,MS )) -#define __SSEQ1rm(OP,RS,RSA,MD,MB,MI,MS) (_REXQrm(RS, MB, MI), _OO_r_X (0x0f01|(OP) ,RSA(RS) ,MD,MB,MI,MS )) - -#define _SSEQrr(PX,OP,RS,RSA,RD,RDA) (_jit_B(PX), __SSEQrr(OP, RS, RSA, RD, RDA)) -#define _SSEQmr(PX,OP,MD,MB,MI,MS,RD,RDA) (_jit_B(PX), __SSEQmr(OP, MD, MB, MI, MS, RD, RDA)) -#define _SSEQrm(PX,OP,RS,RSA,MD,MB,MI,MS) (_jit_B(PX), __SSEQrm(OP, RS, RSA, MD, MB, MI, MS)) -#define _SSEQ1rm(PX,OP,RS,RSA,MD,MB,MI,MS) (_jit_B(PX), __SSEQ1rm(OP, RS, RSA, MD, MB, MI, MS)) - -#define CVTTSS2SIQrr(RS, RD) _SSEQrr(0xf3, X86_SSE_CVTTSI, RS,_rX, RD,_r8) -#define CVTTSS2SIQmr(MD, MB, MI, MS, RD) _SSEQmr(0xf3, X86_SSE_CVTTSI, MD, MB, MI, MS, RD,_r8) -#define CVTTSD2SIQrr(RS, RD) _SSEQrr(0xf2, X86_SSE_CVTTSI, RS,_rX, RD,_r8) -#define CVTTSD2SIQmr(MD, MB, MI, MS, RD) _SSEQmr(0xf2, X86_SSE_CVTTSI, MD, MB, MI, MS, RD,_r8) - -#define CVTSS2SIQrr(RS, RD) _SSEQrr(0xf3, X86_SSE_CVTSI, RS,_rX, RD,_r8) -#define CVTSS2SIQmr(MD, MB, MI, MS, RD) _SSEQmr(0xf3, X86_SSE_CVTSI, MD, MB, MI, MS, RD,_r8) -#define CVTSD2SIQrr(RS, RD) _SSEQrr(0xf2, X86_SSE_CVTSI, RS,_rX, RD,_r8) -#define CVTSD2SIQmr(MD, MB, MI, MS, RD) _SSEQmr(0xf2, X86_SSE_CVTSI, MD, MB, MI, MS, RD,_r8) - -#define CVTSI2SSQrr(RS, RD) _SSEQrr(0xf3, X86_SSE_CVTIS, RS,_r8, RD,_rX) -#define CVTSI2SSQmr(MD, MB, MI, MS, RD) _SSEQmr(0xf3, X86_SSE_CVTIS, MD, MB, MI, MS, RD,_rX) -#define CVTSI2SDQrr(RS, RD) _SSEQrr(0xf2, X86_SSE_CVTIS, RS,_r8, RD,_rX) -#define CVTSI2SDQmr(MD, MB, MI, MS, RD) _SSEQmr(0xf2, X86_SSE_CVTIS, MD, MB, MI, MS, RD,_rX) - -#define MOVDQXrr(RS, RD) _SSEQrr(0x66, 0x6e, RS,_r8, RD,_rX) -#define MOVDQXmr(MD, MB, MI, MS, RD) _SSEQmr(0x66, 0x6e, MD, MB, MI, MS, RD,_rX) - -#define MOVDXQrr(RS, RD) _SSEQrr(0x66, 0x7e, RS,_rX, RD,_r8) -#define MOVDXQrm(RS, MD, MB, MI, MS) _SSEQrm(0x66, 0x7e, RS,_rX, MD, MB, MI, MS) -#define MOVDQMrr(RS, RD) __SSEQrr( 0x6e, RS,_r8, RD,_rM) -#define MOVDQMmr(MD, MB, MI, MS, RD) __SSEQmr( 0x6e, MD, MB, MI, MS, RD,_rM) -#define MOVDMQrr(RS, RD) __SSEQrr( 0x7e, RS,_rM, RD,_r8) -#define MOVDMQrm(RS, MD, MB, MI, MS) __SSEQrm( 0x7e, RS,_rM, MD, MB, MI, MS) - - - -#define CALLsr(R) CALLQsr(R) -#define JMPsr(R) JMPQsr(R) - -#endif -#endif /* __lightning_asm_h */ diff --git a/src/runtime/c/pgf/lightning/i386/asm.h b/src/runtime/c/pgf/lightning/i386/asm.h deleted file mode 100644 index 37c3f7f38..000000000 --- a/src/runtime/c/pgf/lightning/i386/asm.h +++ /dev/null @@ -1,1606 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler for the i386 - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 1999, 2000, 2001, 2002 Ian Piumarta - * Copyright 2003 Gwenole Beauchesne - * Copyright 2006 Free Software Foundation - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - ***********************************************************************/ - - - - -#ifndef __lightning_asm_i386_h -#define __lightning_asm_i386_h - -/* OPCODE + i = immediate operand - * + r = register operand - * + m = memory operand (disp,base,index,scale) - * + sr/sm = a star preceding a register or memory - */ - -typedef _uc jit_insn; - -#ifndef LIGHTNING_DEBUG -#define _b00 0 -#define _b01 1 -#define _b10 2 -#define _b11 3 - -#define _b000 0 -#define _b001 1 -#define _b010 2 -#define _b011 3 -#define _b100 4 -#define _b101 5 -#define _b110 6 -#define _b111 7 - -/*** REGISTERS ***/ /* [size,,number] */ - -#define _NOREG 0 - -#define _AL 0x10 -#define _CL 0x11 -#define _DL 0x12 -#define _BL 0x13 - -#define _AX 0x30 -#define _CX 0x31 -#define _DX 0x32 -#define _BX 0x33 -#define _SP 0x34 -#define _BP 0x35 -#define _SI 0x36 -#define _DI 0x37 - -#define _EAX 0x40 -#define _ECX 0x41 -#define _EDX 0x42 -#define _EBX 0x43 -#define _ESP 0x44 -#define _EBP 0x45 -#define _ESI 0x46 -#define _EDI 0x47 - -#define _MM0 0x60 -#define _MM1 0x61 -#define _MM2 0x62 -#define _MM3 0x63 -#define _MM4 0x64 -#define _MM5 0x65 -#define _MM6 0x66 -#define _MM7 0x67 - -#define _XMM0 0x70 -#define _XMM1 0x71 -#define _XMM2 0x72 -#define _XMM3 0x73 -#define _XMM4 0x74 -#define _XMM5 0x75 -#define _XMM6 0x76 -#define _XMM7 0x77 -#define _XMM8 0x78 -#define _XMM9 0x79 -#define _XMM10 0x7a -#define _XMM11 0x7b -#define _XMM12 0x7c -#define _XMM13 0x7d -#define _XMM14 0x7e -#define _XMM15 0x7f - -#define _ST0 0 -#define _ST1 1 -#define _ST2 2 -#define _ST3 3 -#define _ST4 4 -#define _ST5 5 -#define _ST6 6 -#define _ST7 7 - -#define _r0P(R) ((int)(R) == (int)_NOREG) -#define _rIP(R) ((int)(R) == (int)_RIP) - -#define _rC(R) ((R) & 0xf0) -#define _rR(R) ((R) & 0x0f) -#define _rN(R) ((R) & 0x07) -#define _rXP(R) ((R) > 0 && _rR(R) > 7) - -#define _rbpP(R) (_rR(R) == _rR(_EBP)) -#define _rspP(R) (_rR(R) == _rR(_ESP)) -#define _rbp13P(R) (_rN(R) == _rN(_EBP)) -#define _rsp12P(R) (_rN(R) == _rN(_ESP)) - -/*** ASSEMBLER ***/ - -#define _OFF4(D) (_jit_UL(D) - _jit_UL(_jit.x.pc)) -#define _CKD8(D) _ck_d(8, ((_uc) _OFF4(D)) ) - -#define _D8(D) (_jit_B(0), ((*(_PUC(_jit.x.pc)-1))= _CKD8(D))) -#define _D32(D) (_jit_I(0), ((*(_PUI(_jit.x.pc)-1))= _OFF4(D))) - -#ifndef _ASM_SAFETY -# define _M(M) (M) -# define _r(R) (R) -# define _m(M) (M) -# define _s(S) (S) -# define _i(I) (I) -# define _b(B) (B) -# define _noESP(I,OK) (OK) -#else -# define _M(M) (((M)>3) ? JITFAIL("internal error: mod = " #M) : (M)) -# define _r(R) (((R)>7) ? JITFAIL("internal error: reg = " #R) : (R)) -# define _m(M) (((M)>7) ? JITFAIL("internal error: r/m = " #M) : (M)) -# define _s(S) (((S)>3) ? JITFAIL("internal error: memory scale = " #S) : (S)) -# define _i(I) (((I)>7) ? JITFAIL("internal error: memory index = " #I) : (I)) -# define _b(B) (((B)>7) ? JITFAIL("internal error: memory base = " #B) : (B)) -# define _noESP(I,OK) (((I)==_ESP) ? JITFAIL("illegal index register: %esp") : (OK)) -#endif - -#define _Mrm(Md,R,M) _jit_B((_M(Md)<<6)|(_r(R)<<3)|_m(M)) -#define _SIB(Sc,I, B) _jit_B((_s(Sc)<<6)|(_i(I)<<3)|_b(B)) - -#define _SCL(S) ((((S)==1) ? _b00 : \ - (((S)==2) ? _b01 : \ - (((S)==4) ? _b10 : \ - (((S)==8) ? _b11 : JITFAIL("illegal scale: " #S)))))) - -/* memory subformats - urgh! */ - -/* _r_D() is RIP addressing mode if X86_TARGET_64BIT, use _r_DSIB() instead */ -#define _r_D( R, D ) (_Mrm(_b00,_rN(R),_b101 ) ,_jit_I((long)(D))) -#define _r_DSIB(R, D ) (_Mrm(_b00,_rN(R),_b100 ),_SIB(_SCL(1),_b100 ,_b101 ),_jit_I((long)(D))) -#define _r_0B( R, B ) (_Mrm(_b00,_rN(R),_rA(B)) ) -#define _r_0BIS(R, B,I,S) (_Mrm(_b00,_rN(R),_b100 ),_SIB(_SCL(S),_rA(I),_rA(B)) ) -#define _r_1B( R, D,B ) (_Mrm(_b01,_rN(R),_rA(B)) ,_jit_B((long)(D))) -#define _r_1BIS(R, D,B,I,S) (_Mrm(_b01,_rN(R),_b100 ),_SIB(_SCL(S),_rA(I),_rA(B)),_jit_B((long)(D))) -#define _r_4B( R, D,B ) (_Mrm(_b10,_rN(R),_rA(B)) ,_jit_I((long)(D))) -#define _r_4IS( R, D,I,S) (_Mrm(_b00,_rN(R),_b100 ),_SIB(_SCL(S),_rA(I),_b101 ),_jit_I((long)(D))) -#define _r_4BIS(R, D,B,I,S) (_Mrm(_b10,_rN(R),_b100 ),_SIB(_SCL(S),_rA(I),_rA(B)),_jit_I((long)(D))) - -#define _r_DB( R, D,B ) ((_s0P(D) && (!_rbp13P(B)) ? _r_0B (R, B ) : (_s8P(D) ? _r_1B( R,D,B ) : _r_4B( R,D,B )))) -#define _r_DBIS(R, D,B,I,S) ((_s0P(D) && (!_rbp13P(B)) ? _r_0BIS(R, B,I,S) : (_s8P(D) ? _r_1BIS(R,D,B,I,S) : _r_4BIS(R,D,B,I,S)))) - - - -/* --- Instruction formats ------------------------------------------------- */ - -/* _format Opcd ModR/M dN(rB,rI,Sc) imm... */ - -#define _d16() ( _jit_B(0x66 ) ) -#define _O( OP ) ( _jit_B( OP ) ) -#define _Or( OP,R ) ( _jit_B( (OP)|_r(R)) ) -#define _OO( OP ) ( _jit_B((OP)>>8), _jit_B( (OP) ) ) -#define _OOr( OP,R ) ( _jit_B((OP)>>8), _jit_B( (OP)|_r(R)) ) -#define _Os( OP,B ) ( _s8P(B) ? _jit_B(((OP)|_b10)) : _jit_B(OP) ) -#define _sW( W ) ( _s8P(W) ? _jit_B(W):_jit_W(W) ) -#define _sL( L ) ( _s8P(L) ? _jit_B(L):_jit_I(L) ) -#define _sWO( W ) ( _s8P(W) ? 1 : 2 ) -#define _sLO( L ) ( _s8P(L) ? 1 : 4 ) -#define _O_B( OP ,B ) ( _O ( OP ) ,_jit_B(B) ) -#define _O_W( OP ,W ) ( _O ( OP ) ,_jit_W(W) ) -#define _O_L( OP ,L ) ( _O ( OP ) ,_jit_I(L) ) -#define _O_D8( OP ,D ) ( _O ( OP ) ,_D8(D) ) -#define _O_D32( OP ,D ) ( _O ( OP ) ,_D32(D) ) -#define _OO_D32( OP ,D ) ( _OO ( OP ) ,_D32(D) ) -#define _Os_sW( OP ,W ) ( _Os ( OP,W) ,_sW(W) ) -#define _Os_sL( OP ,L ) ( _Os ( OP,L) ,_sL(L) ) -#define _O_W_B( OP ,W,B) ( _O ( OP ) ,_jit_W(W),_jit_B(B)) -#define _Or_B( OP,R ,B ) ( _Or ( OP,R) ,_jit_B(B) ) -#define _Or_W( OP,R ,W ) ( _Or ( OP,R) ,_jit_W(W) ) -#define _Or_L( OP,R ,L ) ( _Or ( OP,R) ,_jit_I(L) ) -#define _Or_Q( OP,R ,Q ) ( _Or ( OP,R) ,_jit_L(Q) ) -#define _O_Mrm( OP ,MO,R,M ) ( _O ( OP ),_Mrm(MO,R,M ) ) -#define _OO_Mrm( OP ,MO,R,M ) ( _OO ( OP ),_Mrm(MO,R,M ) ) -#define _O_Mrm_B( OP ,MO,R,M ,B ) ( _O ( OP ),_Mrm(MO,R,M ) ,_jit_B(B) ) -#define _O_Mrm_W( OP ,MO,R,M ,W ) ( _O ( OP ),_Mrm(MO,R,M ) ,_jit_W(W) ) -#define _O_Mrm_L( OP ,MO,R,M ,L ) ( _O ( OP ),_Mrm(MO,R,M ) ,_jit_I(L) ) -#define _OO_Mrm_B( OP ,MO,R,M ,B ) ( _OO ( OP ),_Mrm(MO,R,M ) ,_jit_B(B) ) -#define _Os_Mrm_sW(OP ,MO,R,M ,W ) ( _Os ( OP,W),_Mrm(MO,R,M ),_sW(W) ) -#define _Os_Mrm_sL(OP ,MO,R,M ,L ) ( _Os ( OP,L),_Mrm(MO,R,M ),_sL(L) ) -#define _O_r_X( OP ,R ,MD,MB,MI,MS ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS,0) ) -#define _OO_r_X( OP ,R ,MD,MB,MI,MS ) ( _OO ( OP ),_r_X( R ,MD,MB,MI,MS,0) ) -#define _O_r_X_B( OP ,R ,MD,MB,MI,MS,B ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS,1) ,_jit_B(B) ) -#define _O_r_X_W( OP ,R ,MD,MB,MI,MS,W ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS,2) ,_jit_W(W) ) -#define _O_r_X_L( OP ,R ,MD,MB,MI,MS,L ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS,4) ,_jit_I(L) ) -#define _OO_r_X_B( OP ,R ,MD,MB,MI,MS,B ) ( _OO ( OP ),_r_X( R ,MD,MB,MI,MS,1) ,_jit_B(B) ) -#define _Os_r_X_sW(OP ,R ,MD,MB,MI,MS,W ) ( _Os ( OP,W),_r_X( R ,MD,MB,MI,MS,_sWO(W)),_sW(W)) -#define _Os_r_X_sL(OP ,R ,MD,MB,MI,MS,L ) ( _Os ( OP,L),_r_X( R ,MD,MB,MI,MS,_sLO(L)),_sL(L)) -#define _O_X_B( OP ,MD,MB,MI,MS,B ) ( _O_r_X_B( OP ,0 ,MD,MB,MI,MS ,B) ) -#define _O_X_W( OP ,MD,MB,MI,MS,W ) ( _O_r_X_W( OP ,0 ,MD,MB,MI,MS ,W) ) -#define _O_X_L( OP ,MD,MB,MI,MS,L ) ( _O_r_X_L( OP ,0 ,MD,MB,MI,MS ,L) ) - - -/* --- REX prefixes -------------------------------------------------------- */ - - -#define _BIT(X) (!!(X)) -#define _d64(W,R,X,B) (_jit_B(0x40|(W)<<3|(R)<<2|(X)<<1|(B))) - -#define __REXwrxb(L,W,R,X,B) ((W|R|X|B) || (L) ? (void)_d64(W,R,X,B) : ((void)0)) -#define __REXwrx_(L,W,R,X,MR) (__REXwrxb(L,W,R,X,_BIT(_rIP(MR)?0:_rXP(MR)))) -#define __REXw_x_(L,W,R,X,MR) (__REXwrx_(L,W,_BIT(_rXP(R)),X,MR)) -#define __REX_reg(RR) (__REXwrxb(0,0,0,00,_BIT(_rXP(RR)))) -#define __REX_mem(MB,MI) (__REXwrxb(0,0,0,_BIT(_rXP(MI)),_BIT(_rXP(MB)))) - -/* FIXME: can't mix new (SPL,BPL,SIL,DIL) with (AH,BH,CH,DH) */ -#define _REXBrr(RR,MR) _m64(__REXw_x_(_r1e8lP(RR)||_r1e8lP(MR),0,RR,0,MR)) -#define _REXBmr(MB,MI,RD) _m64(__REXw_x_(_r1e8lP(RD)||_r1e8lP(MB),0,RD,_BIT(_rXP(MI)),MB)) -#define _REXBrm(RS,MB,MI) _REXBmr(MB,MI,RS) - -#define _REXBLrr(RR,MR) _m64(__REXw_x_(_r1e8lP(MR),0,RR,0,MR)) -#define _REXLrr(RR,MR) _m64(__REXw_x_(0,0,RR,0,MR)) -#define _REXLmr(MB,MI,RD) _m64(__REXw_x_(0,0,RD,_BIT(_rXP(MI)),MB)) -#define _REXLrm(RS,MB,MI) _REXLmr(MB,MI,RS) -#define _REXLr(RR) _m64(__REX_reg(RR)) -#define _REXLm(MB,MI) _m64(__REX_mem(MB,MI)) - -#define _REXQrr(RR,MR) _m64only(__REXw_x_(0,1,RR,0,MR)) -#define _REXQmr(MB,MI,RD) _m64only(__REXw_x_(0,1,RD,_BIT(_rXP(MI)),MB)) -#define _REXQrm(RS,MB,MI) _REXQmr(MB,MI,RS) -#define _REXQr(RR) _m64only(__REX_reg(RR)) -#define _REXQm(MB,MI) _m64only(__REX_mem(MB,MI)) - - -/* ========================================================================= */ -/* --- Fully-qualified intrinsic instructions ------------------------------ */ -/* ========================================================================= */ - -/* OPCODE + i = immediate operand - * + r = register operand - * + m = memory operand (disp,base,index,scale) - * + sr/sm = a star preceding a register or memory - * + 0 = top of stack register (for FPU instructions) - * - * NOTE in x86-64 mode: a memory operand with only a valid - * displacement value will lead to the expect absolute mode. If - * RIP addressing is necessary, X86_RIP shall be used as the base - * register argument. - */ - -/* --- ALU instructions ---------------------------------------------------- */ - -enum { - X86_ADD = 0, - X86_OR = 1, - X86_ADC = 2, - X86_SBB = 3, - X86_AND = 4, - X86_SUB = 5, - X86_XOR = 6, - X86_CMP = 7, -}; - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define _ALUBrr(OP,RS, RD) (_REXBrr(RS, RD), _O_Mrm (((OP) << 3) ,_b11,_r1(RS),_r1(RD) )) -#define _ALUBmr(OP, MD, MB, MI, MS, RD) (_REXBmr(MB, MI, RD), _O_r_X (((OP) << 3) + 2,_r1(RD) ,MD,MB,MI,MS )) -#define _ALUBrm(OP, RS, MD, MB, MI, MS) (_REXBrm(RS, MB, MI), _O_r_X (((OP) << 3) , ,_r1(RS) ,MD,MB,MI,MS )) -#define _ALUBir(OP, IM, RD) ((RD) == _AL ? \ - (_REXBrr(0, RD), _O_B (((OP) << 3) + 4 ,_su8(IM))) : \ - (_REXBrr(0, RD), _O_Mrm_B (0x80 ,_b11,OP ,_r1(RD) ,_su8(IM))) ) -#define _ALUBim(OP, IM, MD, MB, MI, MS) (_REXBrm(0, MB, MI), _O_r_X_B (0x80 ,OP ,MD,MB,MI,MS ,_su8(IM))) - -#define _ALUWrr(OP, RS, RD) (_d16(), _REXLrr(RS, RD), _O_Mrm (((OP) << 3) + 1,_b11,_r2(RS),_r2(RD) )) -#define _ALUWmr(OP, MD, MB, MI, MS, RD) (_d16(), _REXLmr(MB, MI, RD), _O_r_X (((OP) << 3) + 3 ,_r2(RD) ,MD,MB,MI,MS )) -#define _ALUWrm(OP, RS, MD, MB, MI, MS) (_d16(), _REXLrm(RS, MB, MI), _O_r_X (((OP) << 3) + 1 ,_r2(RS) ,MD,MB,MI,MS )) -#define _ALUWir(OP, IM, RD) ((RD) == _AX ? \ - (_d16(), _REXLrr(0, RD), _O_W (((OP) << 3) + 5 ,_su16(IM))) : \ - (_d16(), _REXLrr(0, RD), _Os_Mrm_sW (0x81 ,_b11,OP ,_r2(RD) ,_su16(IM))) ) -#define _ALUWim(OP, IM, MD, MB, MI, MS) (_d16(), _REXLrm(0, MB, MI), _Os_r_X_sW (0x81 ,OP ,MD,MB,MI,MS ,_su16(IM))) - -#define _ALULrr(OP, RS, RD) (_REXLrr(RS, RD), _O_Mrm (((OP) << 3) + 1,_b11,_r4(RS),_r4(RD) )) -#define _ALULmr(OP, MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _O_r_X (((OP) << 3) + 3 ,_r4(RD) ,MD,MB,MI,MS )) -#define _ALULrm(OP, RS, MD, MB, MI, MS) (_REXLrm(RS, MB, MI), _O_r_X (((OP) << 3) + 1 ,_r4(RS) ,MD,MB,MI,MS )) -#define _ALULir(OP, IM, RD) (!_s8P(IM) && (RD) == _EAX ? \ - (_REXLrr(0, RD), _O_L (((OP) << 3) + 5 ,IM )) : \ - (_REXLrr(0, RD), _Os_Mrm_sL (0x81 ,_b11,OP ,_r4(RD) ,IM )) ) -#define _ALULim(OP, IM, MD, MB, MI, MS) (_REXLrm(0, MB, MI), _Os_r_X_sL (0x81 ,OP ,MD,MB,MI,MS ,IM )) - -#define _ALUQrr(OP, RS, RD) (_REXQrr(RS, RD), _O_Mrm (((OP) << 3) + 1,_b11,_r8(RS),_r8(RD) )) -#define _ALUQmr(OP, MD, MB, MI, MS, RD) (_REXQmr(MB, MI, RD), _O_r_X (((OP) << 3) + 3 ,_r8(RD) ,MD,MB,MI,MS )) -#define _ALUQrm(OP, RS, MD, MB, MI, MS) (_REXQrm(RS, MB, MI), _O_r_X (((OP) << 3) + 1 ,_r8(RS) ,MD,MB,MI,MS )) -#define _ALUQir(OP, IM, RD) \ - /* Immediate fits in 32 bits? */ \ - (_s32P((long)(IM)) \ - /* Yes. Immediate does not fit in 8 bits and reg is %rax? */ \ - ? (!_s8P(IM) && (RD) == _RAX \ - ? (_REXQrr(0, RD), _O_L(((OP) << 3) + 5, IM)) \ - : (_REXQrr(0, RD), _Os_Mrm_sL(0x81, _b11, OP, _r8(RD), IM))) \ - /* No. Need immediate in a register */ \ - : (MOVQir(IM, JIT_REXTMP), _ALUQrr(OP, JIT_REXTMP, RD))) -#define _ALUQim(OP, IM, MD, MB, MI, MS) (_REXQrm(0, MB, MI), _Os_r_X_sL (0x81 ,OP ,MD,MB,MI,MS ,IM )) - -#define ADCBrr(RS, RD) _ALUBrr(X86_ADC, RS, RD) -#define ADCBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_ADC, MD, MB, MI, MS, RD) -#define ADCBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_ADC, RS, MD, MB, MI, MS) -#define ADCBir(IM, RD) _ALUBir(X86_ADC, IM, RD) -#define ADCBim(IM, MD, MB, MI, MS) _ALUBim(X86_ADC, IM, MD, MB, MI, MS) - -#define ADCWrr(RS, RD) _ALUWrr(X86_ADC, RS, RD) -#define ADCWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_ADC, MD, MB, MI, MS, RD) -#define ADCWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_ADC, RS, MD, MB, MI, MS) -#define ADCWir(IM, RD) _ALUWir(X86_ADC, IM, RD) -#define ADCWim(IM, MD, MB, MI, MS) _ALUWim(X86_ADC, IM, MD, MB, MI, MS) - -#define ADCLrr(RS, RD) _ALULrr(X86_ADC, RS, RD) -#define ADCLmr(MD, MB, MI, MS, RD) _ALULmr(X86_ADC, MD, MB, MI, MS, RD) -#define ADCLrm(RS, MD, MB, MI, MS) _ALULrm(X86_ADC, RS, MD, MB, MI, MS) -#define ADCLir(IM, RD) _ALULir(X86_ADC, IM, RD) -#define ADCLim(IM, MD, MB, MI, MS) _ALULim(X86_ADC, IM, MD, MB, MI, MS) - - -#define ADDBrr(RS, RD) _ALUBrr(X86_ADD, RS, RD) -#define ADDBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_ADD, MD, MB, MI, MS, RD) -#define ADDBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_ADD, RS, MD, MB, MI, MS) -#define ADDBir(IM, RD) _ALUBir(X86_ADD, IM, RD) -#define ADDBim(IM, MD, MB, MI, MS) _ALUBim(X86_ADD, IM, MD, MB, MI, MS) - -#define ADDWrr(RS, RD) _ALUWrr(X86_ADD, RS, RD) -#define ADDWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_ADD, MD, MB, MI, MS, RD) -#define ADDWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_ADD, RS, MD, MB, MI, MS) -#define ADDWir(IM, RD) _ALUWir(X86_ADD, IM, RD) -#define ADDWim(IM, MD, MB, MI, MS) _ALUWim(X86_ADD, IM, MD, MB, MI, MS) - -#define ADDLrr(RS, RD) _ALULrr(X86_ADD, RS, RD) -#define ADDLmr(MD, MB, MI, MS, RD) _ALULmr(X86_ADD, MD, MB, MI, MS, RD) -#define ADDLrm(RS, MD, MB, MI, MS) _ALULrm(X86_ADD, RS, MD, MB, MI, MS) -#define ADDLir(IM, RD) _ALULir(X86_ADD, IM, RD) -#define ADDLim(IM, MD, MB, MI, MS) _ALULim(X86_ADD, IM, MD, MB, MI, MS) - - -#define ANDBrr(RS, RD) _ALUBrr(X86_AND, RS, RD) -#define ANDBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_AND, MD, MB, MI, MS, RD) -#define ANDBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_AND, RS, MD, MB, MI, MS) -#define ANDBir(IM, RD) _ALUBir(X86_AND, IM, RD) -#define ANDBim(IM, MD, MB, MI, MS) _ALUBim(X86_AND, IM, MD, MB, MI, MS) - -#define ANDWrr(RS, RD) _ALUWrr(X86_AND, RS, RD) -#define ANDWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_AND, MD, MB, MI, MS, RD) -#define ANDWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_AND, RS, MD, MB, MI, MS) -#define ANDWir(IM, RD) _ALUWir(X86_AND, IM, RD) -#define ANDWim(IM, MD, MB, MI, MS) _ALUWim(X86_AND, IM, MD, MB, MI, MS) - -#define ANDLrr(RS, RD) _ALULrr(X86_AND, RS, RD) -#define ANDLmr(MD, MB, MI, MS, RD) _ALULmr(X86_AND, MD, MB, MI, MS, RD) -#define ANDLrm(RS, MD, MB, MI, MS) _ALULrm(X86_AND, RS, MD, MB, MI, MS) -#define ANDLir(IM, RD) _ALULir(X86_AND, IM, RD) -#define ANDLim(IM, MD, MB, MI, MS) _ALULim(X86_AND, IM, MD, MB, MI, MS) - - -#define CMPBrr(RS, RD) _ALUBrr(X86_CMP, RS, RD) -#define CMPBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_CMP, MD, MB, MI, MS, RD) -#define CMPBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_CMP, RS, MD, MB, MI, MS) -#define CMPBir(IM, RD) _ALUBir(X86_CMP, IM, RD) -#define CMPBim(IM, MD, MB, MI, MS) _ALUBim(X86_CMP, IM, MD, MB, MI, MS) - -#define CMPWrr(RS, RD) _ALUWrr(X86_CMP, RS, RD) -#define CMPWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_CMP, MD, MB, MI, MS, RD) -#define CMPWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_CMP, RS, MD, MB, MI, MS) -#define CMPWir(IM, RD) _ALUWir(X86_CMP, IM, RD) -#define CMPWim(IM, MD, MB, MI, MS) _ALUWim(X86_CMP, IM, MD, MB, MI, MS) - -#define CMPLrr(RS, RD) _ALULrr(X86_CMP, RS, RD) -#define CMPLmr(MD, MB, MI, MS, RD) _ALULmr(X86_CMP, MD, MB, MI, MS, RD) -#define CMPLrm(RS, MD, MB, MI, MS) _ALULrm(X86_CMP, RS, MD, MB, MI, MS) -#define CMPLir(IM, RD) _ALULir(X86_CMP, IM, RD) -#define CMPLim(IM, MD, MB, MI, MS) _ALULim(X86_CMP, IM, MD, MB, MI, MS) - - -#define ORBrr(RS, RD) _ALUBrr(X86_OR, RS, RD) -#define ORBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_OR, MD, MB, MI, MS, RD) -#define ORBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_OR, RS, MD, MB, MI, MS) -#define ORBir(IM, RD) _ALUBir(X86_OR, IM, RD) -#define ORBim(IM, MD, MB, MI, MS) _ALUBim(X86_OR, IM, MD, MB, MI, MS) - -#define ORWrr(RS, RD) _ALUWrr(X86_OR, RS, RD) -#define ORWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_OR, MD, MB, MI, MS, RD) -#define ORWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_OR, RS, MD, MB, MI, MS) -#define ORWir(IM, RD) _ALUWir(X86_OR, IM, RD) -#define ORWim(IM, MD, MB, MI, MS) _ALUWim(X86_OR, IM, MD, MB, MI, MS) - -#define ORLrr(RS, RD) _ALULrr(X86_OR, RS, RD) -#define ORLmr(MD, MB, MI, MS, RD) _ALULmr(X86_OR, MD, MB, MI, MS, RD) -#define ORLrm(RS, MD, MB, MI, MS) _ALULrm(X86_OR, RS, MD, MB, MI, MS) -#define ORLir(IM, RD) _ALULir(X86_OR, IM, RD) -#define ORLim(IM, MD, MB, MI, MS) _ALULim(X86_OR, IM, MD, MB, MI, MS) - - -#define SBBBrr(RS, RD) _ALUBrr(X86_SBB, RS, RD) -#define SBBBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_SBB, MD, MB, MI, MS, RD) -#define SBBBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_SBB, RS, MD, MB, MI, MS) -#define SBBBir(IM, RD) _ALUBir(X86_SBB, IM, RD) -#define SBBBim(IM, MD, MB, MI, MS) _ALUBim(X86_SBB, IM, MD, MB, MI, MS) - -#define SBBWrr(RS, RD) _ALUWrr(X86_SBB, RS, RD) -#define SBBWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_SBB, MD, MB, MI, MS, RD) -#define SBBWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_SBB, RS, MD, MB, MI, MS) -#define SBBWir(IM, RD) _ALUWir(X86_SBB, IM, RD) -#define SBBWim(IM, MD, MB, MI, MS) _ALUWim(X86_SBB, IM, MD, MB, MI, MS) - -#define SBBLrr(RS, RD) _ALULrr(X86_SBB, RS, RD) -#define SBBLmr(MD, MB, MI, MS, RD) _ALULmr(X86_SBB, MD, MB, MI, MS, RD) -#define SBBLrm(RS, MD, MB, MI, MS) _ALULrm(X86_SBB, RS, MD, MB, MI, MS) -#define SBBLir(IM, RD) _ALULir(X86_SBB, IM, RD) -#define SBBLim(IM, MD, MB, MI, MS) _ALULim(X86_SBB, IM, MD, MB, MI, MS) - - -#define SUBBrr(RS, RD) _ALUBrr(X86_SUB, RS, RD) -#define SUBBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_SUB, MD, MB, MI, MS, RD) -#define SUBBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_SUB, RS, MD, MB, MI, MS) -#define SUBBir(IM, RD) _ALUBir(X86_SUB, IM, RD) -#define SUBBim(IM, MD, MB, MI, MS) _ALUBim(X86_SUB, IM, MD, MB, MI, MS) - -#define SUBWrr(RS, RD) _ALUWrr(X86_SUB, RS, RD) -#define SUBWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_SUB, MD, MB, MI, MS, RD) -#define SUBWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_SUB, RS, MD, MB, MI, MS) -#define SUBWir(IM, RD) _ALUWir(X86_SUB, IM, RD) -#define SUBWim(IM, MD, MB, MI, MS) _ALUWim(X86_SUB, IM, MD, MB, MI, MS) - -#define SUBLrr(RS, RD) _ALULrr(X86_SUB, RS, RD) -#define SUBLmr(MD, MB, MI, MS, RD) _ALULmr(X86_SUB, MD, MB, MI, MS, RD) -#define SUBLrm(RS, MD, MB, MI, MS) _ALULrm(X86_SUB, RS, MD, MB, MI, MS) -#define SUBLir(IM, RD) _ALULir(X86_SUB, IM, RD) -#define SUBLim(IM, MD, MB, MI, MS) _ALULim(X86_SUB, IM, MD, MB, MI, MS) - - -#define XORBrr(RS, RD) _ALUBrr(X86_XOR, RS, RD) -#define XORBmr(MD, MB, MI, MS, RD) _ALUBmr(X86_XOR, MD, MB, MI, MS, RD) -#define XORBrm(RS, MD, MB, MI, MS) _ALUBrm(X86_XOR, RS, MD, MB, MI, MS) -#define XORBir(IM, RD) _ALUBir(X86_XOR, IM, RD) -#define XORBim(IM, MD, MB, MI, MS) _ALUBim(X86_XOR, IM, MD, MB, MI, MS) - -#define XORWrr(RS, RD) _ALUWrr(X86_XOR, RS, RD) -#define XORWmr(MD, MB, MI, MS, RD) _ALUWmr(X86_XOR, MD, MB, MI, MS, RD) -#define XORWrm(RS, MD, MB, MI, MS) _ALUWrm(X86_XOR, RS, MD, MB, MI, MS) -#define XORWir(IM, RD) _ALUWir(X86_XOR, IM, RD) -#define XORWim(IM, MD, MB, MI, MS) _ALUWim(X86_XOR, IM, MD, MB, MI, MS) - -#define XORLrr(RS, RD) _ALULrr(X86_XOR, RS, RD) -#define XORLmr(MD, MB, MI, MS, RD) _ALULmr(X86_XOR, MD, MB, MI, MS, RD) -#define XORLrm(RS, MD, MB, MI, MS) _ALULrm(X86_XOR, RS, MD, MB, MI, MS) -#define XORLir(IM, RD) _ALULir(X86_XOR, IM, RD) -#define XORLim(IM, MD, MB, MI, MS) _ALULim(X86_XOR, IM, MD, MB, MI, MS) - - - -/* --- Shift/Rotate instructions ------------------------------------------- */ - -enum { - X86_ROL = 0, - X86_ROR = 1, - X86_RCL = 2, - X86_RCR = 3, - X86_SHL = 4, - X86_SHR = 5, - X86_SAR = 7, -}; - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define _ROTSHIBir(OP,IM,RD) ((IM) == 1 ? \ - (_REXBrr(0, RD), _O_Mrm (0xd0 ,_b11,OP,_r1(RD) )) : \ - (_REXBrr(0, RD), _O_Mrm_B (0xc0 ,_b11,OP,_r1(RD) ,_u8(IM))) ) -#define _ROTSHIBim(OP,IM,MD,MB,MI,MS) ((IM) == 1 ? \ - (_REXBrm(0, MB, MI), _O_r_X (0xd0 ,OP ,MD,MB,MI,MS )) : \ - (_REXBrm(0, MB, MI), _O_r_X_B (0xc0 ,OP ,MD,MB,MI,MS ,_u8(IM))) ) -#define _ROTSHIBrr(OP,RS,RD) (((RS) == _CL) ? \ - (_REXBrr(RS, RD), _O_Mrm (0xd2 ,_b11,OP,_r1(RD) )) : \ - JITFAIL("source register must be CL" ) ) -#define _ROTSHIBrm(OP,RS,MD,MB,MI,MS) (((RS) == _CL) ? \ - (_REXBrm(RS, MB, MI), _O_r_X (0xd2 ,OP ,MD,MB,MI,MS )) : \ - JITFAIL("source register must be CL" ) ) - -#define _ROTSHIWir(OP,IM,RD) ((IM) == 1 ? \ - (_d16(), _REXLrr(0, RD), _O_Mrm (0xd1 ,_b11,OP,_r2(RD) )) : \ - (_d16(), _REXLrr(0, RD), _O_Mrm_B (0xc1 ,_b11,OP,_r2(RD) ,_u8(IM))) ) -#define _ROTSHIWim(OP,IM,MD,MB,MI,MS) ((IM) == 1 ? \ - (_d16(), _REXLrm(0, MB, MI), _O_r_X (0xd1 ,OP ,MD,MB,MI,MS )) : \ - (_d16(), _REXLrm(0, MB, MI), _O_r_X_B (0xc1 ,OP ,MD,MB,MI,MS ,_u8(IM))) ) -#define _ROTSHIWrr(OP,RS,RD) (((RS) == _CL) ? \ - (_d16(), _REXLrr(RS, RD), _O_Mrm (0xd3 ,_b11,OP,_r2(RD) )) : \ - JITFAIL("source register must be CL" ) ) -#define _ROTSHIWrm(OP,RS,MD,MB,MI,MS) (((RS) == _CL) ? \ - (_d16(), _REXLrm(RS, MB, MI), _O_r_X (0xd3 ,OP ,MD,MB,MI,MS )) : \ - JITFAIL("source register must be CL" ) ) - -#define _ROTSHILir(OP,IM,RD) ((IM) == 1 ? \ - (_REXLrr(0, RD), _O_Mrm (0xd1 ,_b11,OP,_r4(RD) )) : \ - (_REXLrr(0, RD), _O_Mrm_B (0xc1 ,_b11,OP,_r4(RD) ,_u8(IM))) ) -#define _ROTSHILim(OP,IM,MD,MB,MI,MS) ((IM) == 1 ? \ - (_REXLrm(0, MB, MI), _O_r_X (0xd1 ,OP ,MD,MB,MI,MS )) : \ - (_REXLrm(0, MB, MI), _O_r_X_B (0xc1 ,OP ,MD,MB,MI,MS ,_u8(IM))) ) -#define _ROTSHILrr(OP,RS,RD) (((RS) == _CL) ? \ - (_REXLrr(RS, RD), _O_Mrm (0xd3 ,_b11,OP,_r4(RD) )) : \ - JITFAIL("source register must be CL" ) ) -#define _ROTSHILrm(OP,RS,MD,MB,MI,MS) (((RS) == _CL) ? \ - (_REXLrm(RS, MB, MI), _O_r_X (0xd3 ,OP ,MD,MB,MI,MS )) : \ - JITFAIL("source register must be CL" ) ) - -#define _ROTSHIQir(OP,IM,RD) ((IM) == 1 ? \ - (_REXQrr(0, RD), _O_Mrm (0xd1 ,_b11,OP,_r8(RD) )) : \ - (_REXQrr(0, RD), _O_Mrm_B (0xc1 ,_b11,OP,_r8(RD) ,_u8(IM))) ) -#define _ROTSHIQim(OP,IM,MD,MB,MI,MS) ((IM) == 1 ? \ - (_REXQrm(0, MB, MI), _O_r_X (0xd1 ,OP ,MD,MB,MI,MS )) : \ - (_REXQrm(0, MB, MI), _O_r_X_B (0xc1 ,OP ,MD,MB,MI,MS ,_u8(IM))) ) -#define _ROTSHIQrr(OP,RS,RD) (((RS) == _CL) ? \ - (_REXQrr(RS, RD), _O_Mrm (0xd3 ,_b11,OP,_r8(RD) )) : \ - JITFAIL("source register must be CL" ) ) -#define _ROTSHIQrm(OP,RS,MD,MB,MI,MS) (((RS) == _CL) ? \ - (_REXQrm(RS, MB, MI), _O_r_X (0xd3 ,OP ,MD,MB,MI,MS )) : \ - JITFAIL("source register must be CL" ) ) - -#define ROLBir(IM, RD) _ROTSHIBir(X86_ROL, IM, RD) -#define ROLBim(IM, MD, MB, MI, MS) _ROTSHIBim(X86_ROL, IM, MD, MB, MI, MS) -#define ROLBrr(RS, RD) _ROTSHIBrr(X86_ROL, RS, RD) -#define ROLBrm(RS, MD, MB, MI, MS) _ROTSHIBrm(X86_ROL, RS, MD, MB, MI, MS) - -#define ROLWir(IM, RD) _ROTSHIWir(X86_ROL, IM, RD) -#define ROLWim(IM, MD, MB, MI, MS) _ROTSHIWim(X86_ROL, IM, MD, MB, MI, MS) -#define ROLWrr(RS, RD) _ROTSHIWrr(X86_ROL, RS, RD) -#define ROLWrm(RS, MD, MB, MI, MS) _ROTSHIWrm(X86_ROL, RS, MD, MB, MI, MS) - -#define ROLLir(IM, RD) _ROTSHILir(X86_ROL, IM, RD) -#define ROLLim(IM, MD, MB, MI, MS) _ROTSHILim(X86_ROL, IM, MD, MB, MI, MS) -#define ROLLrr(RS, RD) _ROTSHILrr(X86_ROL, RS, RD) -#define ROLLrm(RS, MD, MB, MI, MS) _ROTSHILrm(X86_ROL, RS, MD, MB, MI, MS) - - -#define RORBir(IM, RD) _ROTSHIBir(X86_ROR, IM, RD) -#define RORBim(IM, MD, MB, MI, MS) _ROTSHIBim(X86_ROR, IM, MD, MB, MI, MS) -#define RORBrr(RS, RD) _ROTSHIBrr(X86_ROR, RS, RD) -#define RORBrm(RS, MD, MB, MI, MS) _ROTSHIBrm(X86_ROR, RS, MD, MB, MI, MS) - -#define RORWir(IM, RD) _ROTSHIWir(X86_ROR, IM, RD) -#define RORWim(IM, MD, MB, MI, MS) _ROTSHIWim(X86_ROR, IM, MD, MB, MI, MS) -#define RORWrr(RS, RD) _ROTSHIWrr(X86_ROR, RS, RD) -#define RORWrm(RS, MD, MB, MI, MS) _ROTSHIWrm(X86_ROR, RS, MD, MB, MI, MS) - -#define RORLir(IM, RD) _ROTSHILir(X86_ROR, IM, RD) -#define RORLim(IM, MD, MB, MI, MS) _ROTSHILim(X86_ROR, IM, MD, MB, MI, MS) -#define RORLrr(RS, RD) _ROTSHILrr(X86_ROR, RS, RD) -#define RORLrm(RS, MD, MB, MI, MS) _ROTSHILrm(X86_ROR, RS, MD, MB, MI, MS) - - -#define RCLBir(IM, RD) _ROTSHIBir(X86_RCL, IM, RD) -#define RCLBim(IM, MD, MB, MI, MS) _ROTSHIBim(X86_RCL, IM, MD, MB, MI, MS) -#define RCLBrr(RS, RD) _ROTSHIBrr(X86_RCL, RS, RD) -#define RCLBrm(RS, MD, MB, MI, MS) _ROTSHIBrm(X86_RCL, RS, MD, MB, MI, MS) - -#define RCLWir(IM, RD) _ROTSHIWir(X86_RCL, IM, RD) -#define RCLWim(IM, MD, MB, MI, MS) _ROTSHIWim(X86_RCL, IM, MD, MB, MI, MS) -#define RCLWrr(RS, RD) _ROTSHIWrr(X86_RCL, RS, RD) -#define RCLWrm(RS, MD, MB, MI, MS) _ROTSHIWrm(X86_RCL, RS, MD, MB, MI, MS) - -#define RCLLir(IM, RD) _ROTSHILir(X86_RCL, IM, RD) -#define RCLLim(IM, MD, MB, MI, MS) _ROTSHILim(X86_RCL, IM, MD, MB, MI, MS) -#define RCLLrr(RS, RD) _ROTSHILrr(X86_RCL, RS, RD) -#define RCLLrm(RS, MD, MB, MI, MS) _ROTSHILrm(X86_RCL, RS, MD, MB, MI, MS) - - -#define RCRBir(IM, RD) _ROTSHIBir(X86_RCR, IM, RD) -#define RCRBim(IM, MD, MB, MI, MS) _ROTSHIBim(X86_RCR, IM, MD, MB, MI, MS) -#define RCRBrr(RS, RD) _ROTSHIBrr(X86_RCR, RS, RD) -#define RCRBrm(RS, MD, MB, MI, MS) _ROTSHIBrm(X86_RCR, RS, MD, MB, MI, MS) - -#define RCRWir(IM, RD) _ROTSHIWir(X86_RCR, IM, RD) -#define RCRWim(IM, MD, MB, MI, MS) _ROTSHIWim(X86_RCR, IM, MD, MB, MI, MS) -#define RCRWrr(RS, RD) _ROTSHIWrr(X86_RCR, RS, RD) -#define RCRWrm(RS, MD, MB, MI, MS) _ROTSHIWrm(X86_RCR, RS, MD, MB, MI, MS) - -#define RCRLir(IM, RD) _ROTSHILir(X86_RCR, IM, RD) -#define RCRLim(IM, MD, MB, MI, MS) _ROTSHILim(X86_RCR, IM, MD, MB, MI, MS) -#define RCRLrr(RS, RD) _ROTSHILrr(X86_RCR, RS, RD) -#define RCRLrm(RS, MD, MB, MI, MS) _ROTSHILrm(X86_RCR, RS, MD, MB, MI, MS) - - -#define SHLBir(IM, RD) _ROTSHIBir(X86_SHL, IM, RD) -#define SHLBim(IM, MD, MB, MI, MS) _ROTSHIBim(X86_SHL, IM, MD, MB, MI, MS) -#define SHLBrr(RS, RD) _ROTSHIBrr(X86_SHL, RS, RD) -#define SHLBrm(RS, MD, MB, MI, MS) _ROTSHIBrm(X86_SHL, RS, MD, MB, MI, MS) - -#define SHLWir(IM, RD) _ROTSHIWir(X86_SHL, IM, RD) -#define SHLWim(IM, MD, MB, MI, MS) _ROTSHIWim(X86_SHL, IM, MD, MB, MI, MS) -#define SHLWrr(RS, RD) _ROTSHIWrr(X86_SHL, RS, RD) -#define SHLWrm(RS, MD, MB, MI, MS) _ROTSHIWrm(X86_SHL, RS, MD, MB, MI, MS) - -#define SHLLir(IM, RD) _ROTSHILir(X86_SHL, IM, RD) -#define SHLLim(IM, MD, MB, MI, MS) _ROTSHILim(X86_SHL, IM, MD, MB, MI, MS) -#define SHLLrr(RS, RD) _ROTSHILrr(X86_SHL, RS, RD) -#define SHLLrm(RS, MD, MB, MI, MS) _ROTSHILrm(X86_SHL, RS, MD, MB, MI, MS) - - -#define SHRBir(IM, RD) _ROTSHIBir(X86_SHR, IM, RD) -#define SHRBim(IM, MD, MB, MI, MS) _ROTSHIBim(X86_SHR, IM, MD, MB, MI, MS) -#define SHRBrr(RS, RD) _ROTSHIBrr(X86_SHR, RS, RD) -#define SHRBrm(RS, MD, MB, MI, MS) _ROTSHIBrm(X86_SHR, RS, MD, MB, MI, MS) - -#define SHRWir(IM, RD) _ROTSHIWir(X86_SHR, IM, RD) -#define SHRWim(IM, MD, MB, MI, MS) _ROTSHIWim(X86_SHR, IM, MD, MB, MI, MS) -#define SHRWrr(RS, RD) _ROTSHIWrr(X86_SHR, RS, RD) -#define SHRWrm(RS, MD, MB, MI, MS) _ROTSHIWrm(X86_SHR, RS, MD, MB, MI, MS) - -#define SHRLir(IM, RD) _ROTSHILir(X86_SHR, IM, RD) -#define SHRLim(IM, MD, MB, MI, MS) _ROTSHILim(X86_SHR, IM, MD, MB, MI, MS) -#define SHRLrr(RS, RD) _ROTSHILrr(X86_SHR, RS, RD) -#define SHRLrm(RS, MD, MB, MI, MS) _ROTSHILrm(X86_SHR, RS, MD, MB, MI, MS) - - -#define SALBir SHLBir -#define SALBim SHLBim -#define SALBrr SHLBrr -#define SALBrm SHLBrm - -#define SALWir SHLWir -#define SALWim SHLWim -#define SALWrr SHLWrr -#define SALWrm SHLWrm - -#define SALLir SHLLir -#define SALLim SHLLim -#define SALLrr SHLLrr -#define SALLrm SHLLrm - - -#define SARBir(IM, RD) _ROTSHIBir(X86_SAR, IM, RD) -#define SARBim(IM, MD, MB, MI, MS) _ROTSHIBim(X86_SAR, IM, MD, MB, MI, MS) -#define SARBrr(RS, RD) _ROTSHIBrr(X86_SAR, RS, RD) -#define SARBrm(RS, MD, MB, MI, MS) _ROTSHIBrm(X86_SAR, RS, MD, MB, MI, MS) - -#define SARWir(IM, RD) _ROTSHIWir(X86_SAR, IM, RD) -#define SARWim(IM, MD, MB, MI, MS) _ROTSHIWim(X86_SAR, IM, MD, MB, MI, MS) -#define SARWrr(RS, RD) _ROTSHIWrr(X86_SAR, RS, RD) -#define SARWrm(RS, MD, MB, MI, MS) _ROTSHIWrm(X86_SAR, RS, MD, MB, MI, MS) - -#define SARLir(IM, RD) _ROTSHILir(X86_SAR, IM, RD) -#define SARLim(IM, MD, MB, MI, MS) _ROTSHILim(X86_SAR, IM, MD, MB, MI, MS) -#define SARLrr(RS, RD) _ROTSHILrr(X86_SAR, RS, RD) -#define SARLrm(RS, MD, MB, MI, MS) _ROTSHILrm(X86_SAR, RS, MD, MB, MI, MS) - - - -/* --- Bit test instructions ----------------------------------------------- */ - -enum { - X86_BT = 4, - X86_BTS = 5, - X86_BTR = 6, - X86_BTC = 7, -}; - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define _BTWir(OP, IM, RD) (_d16(), _REXLrr(0, RD), _OO_Mrm_B (0x0fba ,_b11,OP ,_r2(RD) ,_u8(IM))) -#define _BTWim(OP, IM, MD, MB, MI, MS) (_d16(), _REXLrm(0, MB, MI), _OO_r_X_B (0x0fba ,OP ,MD,MB,MI,MS ,_u8(IM))) -#define _BTWrr(OP, RS, RD) (_d16(), _REXLrr(RS, RD), _OO_Mrm (0x0f83|((OP)<<3),_b11,_r2(RS),_r2(RD) )) -#define _BTWrm(OP, RS, MD, MB, MI, MS) (_d16(), _REXLrm(RS, MB, MI), _OO_r_X (0x0f83|((OP)<<3) ,_r2(RS) ,MD,MB,MI,MS )) - -#define _BTLir(OP, IM, RD) (_REXLrr(0, RD), _OO_Mrm_B (0x0fba ,_b11,OP ,_r4(RD) ,_u8(IM))) -#define _BTLim(OP, IM, MD, MB, MI, MS) (_REXLrm(0, MB, MI), _OO_r_X_B (0x0fba ,OP ,MD,MB,MI,MS ,_u8(IM))) -#define _BTLrr(OP, RS, RD) (_REXLrr(RS, RD), _OO_Mrm (0x0f83|((OP)<<3),_b11,_r4(RS),_r4(RD) )) -#define _BTLrm(OP, RS, MD, MB, MI, MS) (_REXLrm(RS, MB, MI), _OO_r_X (0x0f83|((OP)<<3) ,_r4(RS) ,MD,MB,MI,MS )) - -#define _BTQir(OP, IM, RD) (_REXQrr(0, RD), _OO_Mrm_B (0x0fba ,_b11,OP ,_r8(RD) ,_u8(IM))) -#define _BTQim(OP, IM, MD, MB, MI, MS) (_REXQrm(0, MB, MI), _OO_r_X_B (0x0fba ,OP ,MD,MB,MI,MS ,_u8(IM))) -#define _BTQrr(OP, RS, RD) (_REXQrr(RS, RD), _OO_Mrm (0x0f83|((OP)<<3),_b11,_r8(RS),_r8(RD) )) -#define _BTQrm(OP, RS, MD, MB, MI, MS) (_REXQrm(RS, MB, MI), _OO_r_X (0x0f83|((OP)<<3) ,_r8(RS) ,MD,MB,MI,MS )) - -#define BTWir(IM, RD) _BTWir(X86_BT, IM, RD) -#define BTWim(IM, MD, MB, MI, MS) _BTWim(X86_BT, IM, MD, MI, MS) -#define BTWrr(RS, RD) _BTWrr(X86_BT, RS, RD) -#define BTWrm(RS, MD, MB, MI, MS) _BTWrm(X86_BT, RS, MD, MB, MI, MS) - -#define BTLir(IM, RD) _BTLir(X86_BT, IM, RD) -#define BTLim(IM, MD, MB, MI, MS) _BTLim(X86_BT, IM, MD, MB, MI, MS) -#define BTLrr(RS, RD) _BTLrr(X86_BT, RS, RD) -#define BTLrm(RS, MD, MB, MI, MS) _BTLrm(X86_BT, RS, MD, MB, MI, MS) - - -#define BTCWir(IM, RD) _BTWir(X86_BTC, IM, RD) -#define BTCWim(IM, MD, MB, MI, MS) _BTWim(X86_BTC, IM, MD, MI, MS) -#define BTCWrr(RS, RD) _BTWrr(X86_BTC, RS, RD) -#define BTCWrm(RS, MD, MB, MI, MS) _BTWrm(X86_BTC, RS, MD, MB, MI, MS) - -#define BTCLir(IM, RD) _BTLir(X86_BTC, IM, RD) -#define BTCLim(IM, MD, MB, MI, MS) _BTLim(X86_BTC, IM, MD, MB, MI, MS) -#define BTCLrr(RS, RD) _BTLrr(X86_BTC, RS, RD) -#define BTCLrm(RS, MD, MB, MI, MS) _BTLrm(X86_BTC, RS, MD, MB, MI, MS) - - -#define BTRWir(IM, RD) _BTWir(X86_BTR, IM, RD) -#define BTRWim(IM, MD, MB, MI, MS) _BTWim(X86_BTR, IM, MD, MI, MS) -#define BTRWrr(RS, RD) _BTWrr(X86_BTR, RS, RD) -#define BTRWrm(RS, MD, MB, MI, MS) _BTWrm(X86_BTR, RS, MD, MB, MI, MS) - -#define BTRLir(IM, RD) _BTLir(X86_BTR, IM, RD) -#define BTRLim(IM, MD, MB, MI, MS) _BTLim(X86_BTR, IM, MD, MB, MI, MS) -#define BTRLrr(RS, RD) _BTLrr(X86_BTR, RS, RD) -#define BTRLrm(RS, MD, MB, MI, MS) _BTLrm(X86_BTR, RS, MD, MB, MI, MS) - - -#define BTSWir(IM, RD) _BTWir(X86_BTS, IM, RD) -#define BTSWim(IM, MD, MB, MI, MS) _BTWim(X86_BTS, IM, MD, MI, MS) -#define BTSWrr(RS, RD) _BTWrr(X86_BTS, RS, RD) -#define BTSWrm(RS, MD, MB, MI, MS) _BTWrm(X86_BTS, RS, MD, MB, MI, MS) - -#define BTSLir(IM, RD) _BTLir(X86_BTS, IM, RD) -#define BTSLim(IM, MD, MB, MI, MS) _BTLim(X86_BTS, IM, MD, MB, MI, MS) -#define BTSLrr(RS, RD) _BTLrr(X86_BTS, RS, RD) -#define BTSLrm(RS, MD, MB, MI, MS) _BTLrm(X86_BTS, RS, MD, MB, MI, MS) - - - -/* --- Move instructions --------------------------------------------------- */ - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define MOVBrr(RS, RD) (_REXBrr(RS, RD), _O_Mrm (0x88 ,_b11,_r1(RS),_r1(RD) )) -#define MOVBmr(MD, MB, MI, MS, RD) (_REXBmr(MB, MI, RD), _O_r_X (0x8a ,_r1(RD) ,MD,MB,MI,MS )) -#define MOVBrm(RS, MD, MB, MI, MS) (_REXBrm(RS, MB, MI), _O_r_X (0x88 ,_r1(RS) ,MD,MB,MI,MS )) -#define MOVBir(IM, R) (_REXBrr(0, R), _Or_B (0xb0,_r1(R) ,_su8(IM))) -#define MOVBim(IM, MD, MB, MI, MS) (_REXBrm(0, MB, MI), _O_X_B (0xc6 ,MD,MB,MI,MS ,_su8(IM))) - -#define MOVWrr(RS, RD) (_d16(), _REXLrr(RS, RD), _O_Mrm (0x89 ,_b11,_r2(RS),_r2(RD) )) -#define MOVWmr(MD, MB, MI, MS, RD) (_d16(), _REXLmr(MB, MI, RD), _O_r_X (0x8b ,_r2(RD) ,MD,MB,MI,MS )) -#define MOVWrm(RS, MD, MB, MI, MS) (_d16(), _REXLrm(RS, MB, MI), _O_r_X (0x89 ,_r2(RS) ,MD,MB,MI,MS )) -#define MOVWir(IM, R) (_d16(), _REXLrr(0, R), _Or_W (0xb8,_r2(R) ,_su16(IM))) -#define MOVWim(IM, MD, MB, MI, MS) (_d16(), _REXLrm(0, MB, MI), _O_X_W (0xc7 ,MD,MB,MI,MS ,_su16(IM))) - -#define MOVLrr(RS, RD) (_REXLrr(RS, RD), _O_Mrm (0x89 ,_b11,_r4(RS),_r4(RD) )) -#define MOVLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _O_r_X (0x8b ,_r4(RD) ,MD,MB,MI,MS )) -#define MOVLrm(RS, MD, MB, MI, MS) (_REXLrm(RS, MB, MI), _O_r_X (0x89 ,_r4(RS) ,MD,MB,MI,MS )) -#define MOVLir(IM, R) (_REXLrr(0, R), _Or_L (0xb8,_r4(R) ,IM )) -#define MOVLim(IM, MD, MB, MI, MS) (_REXLrm(0, MB, MI), _O_X_L (0xc7 ,MD,MB,MI,MS ,IM )) - - - -/* --- Unary and Multiply/Divide instructions ------------------------------ */ - -enum { - X86_NOT = 2, - X86_NEG = 3, - X86_MUL = 4, - X86_IMUL = 5, - X86_DIV = 6, - X86_IDIV = 7, -}; - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define _UNARYBr(OP, RS) (_REXBrr(0, RS), _O_Mrm (0xf6 ,_b11,OP ,_r1(RS) )) -#define _UNARYBm(OP, MD, MB, MI, MS) (_REXBrm(0, MB, MI), _O_r_X (0xf6 ,OP ,MD,MB,MI,MS )) -#define _UNARYWr(OP, RS) (_d16(), _REXLrr(0, RS), _O_Mrm (0xf7 ,_b11,OP ,_r2(RS) )) -#define _UNARYWm(OP, MD, MB, MI, MS) (_d16(), _REXLmr(MB, MI, 0), _O_r_X (0xf7 ,OP ,MD,MB,MI,MS )) -#define _UNARYLr(OP, RS) (_REXLrr(0, RS), _O_Mrm (0xf7 ,_b11,OP ,_r4(RS) )) -#define _UNARYLm(OP, MD, MB, MI, MS) (_REXLmr(MB, MI, 0), _O_r_X (0xf7 ,OP ,MD,MB,MI,MS )) -#define _UNARYQr(OP, RS) (_REXQrr(0, RS), _O_Mrm (0xf7 ,_b11,OP ,_r8(RS) )) -#define _UNARYQm(OP, MD, MB, MI, MS) (_REXQmr(MB, MI, 0), _O_r_X (0xf7 ,OP ,MD,MB,MI,MS )) - -#define NOTBr(RS) _UNARYBr(X86_NOT, RS) -#define NOTBm(MD, MB, MI, MS) _UNARYBm(X86_NOT, MD, MB, MI, MS) -#define NOTWr(RS) _UNARYWr(X86_NOT, RS) -#define NOTWm(MD, MB, MI, MS) _UNARYWm(X86_NOT, MD, MB, MI, MS) -#define NOTLr(RS) _UNARYLr(X86_NOT, RS) -#define NOTLm(MD, MB, MI, MS) _UNARYLm(X86_NOT, MD, MB, MI, MS) - -#define NEGBr(RS) _UNARYBr(X86_NEG, RS) -#define NEGBm(MD, MB, MI, MS) _UNARYBm(X86_NEG, MD, MB, MI, MS) -#define NEGWr(RS) _UNARYWr(X86_NEG, RS) -#define NEGWm(MD, MB, MI, MS) _UNARYWm(X86_NEG, MD, MB, MI, MS) -#define NEGLr(RS) _UNARYLr(X86_NEG, RS) -#define NEGLm(MD, MB, MI, MS) _UNARYLm(X86_NEG, MD, MB, MI, MS) - -#define MULBr(RS) _UNARYBr(X86_MUL, RS) -#define MULBm(MD, MB, MI, MS) _UNARYBm(X86_MUL, MD, MB, MI, MS) -#define MULWr(RS) _UNARYWr(X86_MUL, RS) -#define MULWm(MD, MB, MI, MS) _UNARYWm(X86_MUL, MD, MB, MI, MS) -#define MULLr(RS) _UNARYLr(X86_MUL, RS) -#define MULLm(MD, MB, MI, MS) _UNARYLm(X86_MUL, MD, MB, MI, MS) - -#define IMULBr(RS) _UNARYBr(X86_IMUL, RS) -#define IMULBm(MD, MB, MI, MS) _UNARYBm(X86_IMUL, MD, MB, MI, MS) -#define IMULWr(RS) _UNARYWr(X86_IMUL, RS) -#define IMULWm(MD, MB, MI, MS) _UNARYWm(X86_IMUL, MD, MB, MI, MS) -#define IMULLr(RS) _UNARYLr(X86_IMUL, RS) -#define IMULLm(MD, MB, MI, MS) _UNARYLm(X86_IMUL, MD, MB, MI, MS) - -#define DIVBr(RS) _UNARYBr(X86_DIV, RS) -#define DIVBm(MD, MB, MI, MS) _UNARYBm(X86_DIV, MD, MB, MI, MS) -#define DIVWr(RS) _UNARYWr(X86_DIV, RS) -#define DIVWm(MD, MB, MI, MS) _UNARYWm(X86_DIV, MD, MB, MI, MS) -#define DIVLr(RS) _UNARYLr(X86_DIV, RS) -#define DIVLm(MD, MB, MI, MS) _UNARYLm(X86_DIV, MD, MB, MI, MS) - -#define IDIVBr(RS) _UNARYBr(X86_IDIV, RS) -#define IDIVBm(MD, MB, MI, MS) _UNARYBm(X86_IDIV, MD, MB, MI, MS) -#define IDIVWr(RS) _UNARYWr(X86_IDIV, RS) -#define IDIVWm(MD, MB, MI, MS) _UNARYWm(X86_IDIV, MD, MB, MI, MS) -#define IDIVLr(RS) _UNARYLr(X86_IDIV, RS) -#define IDIVLm(MD, MB, MI, MS) _UNARYLm(X86_IDIV, MD, MB, MI, MS) - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define IMULWrr(RS, RD) (_d16(), _REXLrr(RD, RS), _OO_Mrm (0x0faf ,_b11,_r2(RD),_r2(RS) )) -#define IMULWmr(MD, MB, MI, MS, RD) (_d16(), _REXLmr(MB, MI, RD), _OO_r_X (0x0faf ,_r2(RD) ,MD,MB,MI,MS )) - -#define IMULWirr(IM,RS,RD) (_d16(), _REXLrr(RS, RD), _Os_Mrm_sW (0x69 ,_b11,_r2(RS),_r2(RD) ,_su16(IM) )) -#define IMULWimr(IM,MD,MB,MI,MS,RD) (_d16(), _REXLmr(MB, MI, RD), _Os_r_X_sW (0x69 ,_r2(RD) ,MD,MB,MI,MS ,_su16(IM) )) - -#define IMULLir(IM, RD) (_REXLrr(0, RD), _Os_Mrm_sL (0x69 ,_b11,_r4(RD),_r4(RD) ,IM )) -#define IMULLrr(RS, RD) (_REXLrr(RD, RS), _OO_Mrm (0x0faf ,_b11,_r4(RD),_r4(RS) )) -#define IMULLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0faf ,_r4(RD) ,MD,MB,MI,MS )) - - -#define IMULLirr(IM,RS,RD) (_REXLrr(RS, RD), _Os_Mrm_sL (0x69 ,_b11,_r4(RS),_r4(RD) ,IM )) -#define IMULLimr(IM,MD,MB,MI,MS,RD) (_REXLmr(MB, MI, RD), _Os_r_X_sL (0x69 ,_r4(RD) ,MD,MB,MI,MS ,IM )) - - - -/* --- Control Flow related instructions ----------------------------------- */ - -enum { - X86_CC_O = 0x0, - X86_CC_NO = 0x1, - X86_CC_NAE = 0x2, - X86_CC_B = 0x2, - X86_CC_C = 0x2, - X86_CC_AE = 0x3, - X86_CC_NB = 0x3, - X86_CC_NC = 0x3, - X86_CC_E = 0x4, - X86_CC_Z = 0x4, - X86_CC_NE = 0x5, - X86_CC_NZ = 0x5, - X86_CC_BE = 0x6, - X86_CC_NA = 0x6, - X86_CC_A = 0x7, - X86_CC_NBE = 0x7, - X86_CC_S = 0x8, - X86_CC_NS = 0x9, - X86_CC_P = 0xa, - X86_CC_PE = 0xa, - X86_CC_NP = 0xb, - X86_CC_PO = 0xb, - X86_CC_L = 0xc, - X86_CC_NGE = 0xc, - X86_CC_GE = 0xd, - X86_CC_NL = 0xd, - X86_CC_LE = 0xe, - X86_CC_NG = 0xe, - X86_CC_G = 0xf, - X86_CC_NLE = 0xf, -}; - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -/* FIXME: no prefix is availble to encode a 32-bit operand size in 64-bit - mode */ -#define CALLm(M) _O_D32 (0xe8 ,(int)(M) ) -#define CALLLsr(R) (_REXLrr(0, R), _O_Mrm (0xff ,_b11,_b010,_r4(R) )) -#define CALLsm(D,B,I,S) (_REXLrm(0, B, I), _O_r_X (0xff ,_b010 ,(int)(D),B,I,S )) - -/* FIXME: no prefix is availble to encode a 32-bit operand size in 64-bit - mode */ -#define JMPSm(M) _O_D8 (0xeb ,(int)(M) ) -#define JMPm(M) _O_D32 (0xe9 ,(M) ) -#define JMPLsr(R) (_REXLrr(0, R), _O_Mrm (0xff ,_b11,_b100,_r4(R) )) -#define JMPsm(D,B,I,S) (_REXLrm(0, B, I), _O_r_X (0xff ,_b100 ,(int)(D),B,I,S )) - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ -#define JCCSii(CC, D) _O_B (0x70|(CC) ,(_sc)(int)(D) ) -#define JCCSim(CC, D) _O_D8 (0x70|(CC) ,(int)(D) ) -#define JOSm(D) JCCSim(0x0, D) -#define JNOSm(D) JCCSim(0x1, D) -#define JBSm(D) JCCSim(0x2, D) -#define JCSm(D) JCCSim(0x2, D) -#define JNAESm(D) JCCSim(0x2, D) -#define JNBSm(D) JCCSim(0x3, D) -#define JNCSm(D) JCCSim(0x3, D) -#define JAESm(D) JCCSim(0x3, D) -#define JESm(D) JCCSim(0x4, D) -#define JZSm(D) JCCSim(0x4, D) -#define JNESm(D) JCCSim(0x5, D) -#define JNZSm(D) JCCSim(0x5, D) -#define JBESm(D) JCCSim(0x6, D) -#define JNASm(D) JCCSim(0x6, D) -#define JNBESm(D) JCCSim(0x7, D) -#define JASm(D) JCCSim(0x7, D) -#define JSSm(D) JCCSim(0x8, D) -#define JNSSm(D) JCCSim(0x9, D) -#define JPSm(D) JCCSim(0xa, D) -#define JPESm(D) JCCSim(0xa, D) -#define JNPSm(D) JCCSim(0xb, D) -#define JPOSm(D) JCCSim(0xb, D) -#define JLSm(D) JCCSim(0xc, D) -#define JNGESm(D) JCCSim(0xc, D) -#define JNLSm(D) JCCSim(0xd, D) -#define JGESm(D) JCCSim(0xd, D) -#define JLESm(D) JCCSim(0xe, D) -#define JNGSm(D) JCCSim(0xe, D) -#define JNLESm(D) JCCSim(0xf, D) -#define JGSm(D) JCCSim(0xf, D) - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ -#define JCCim(CC, D) _OO_D32 (0x0f80|(CC) ,(long)(D) ) -#define JOm(D) JCCim(0x0, D) -#define JNOm(D) JCCim(0x1, D) -#define JBm(D) JCCim(0x2, D) -#define JCm(D) JCCim(0x2, D) -#define JNAEm(D) JCCim(0x2, D) -#define JNBm(D) JCCim(0x3, D) -#define JNCm(D) JCCim(0x3, D) -#define JAEm(D) JCCim(0x3, D) -#define JEm(D) JCCim(0x4, D) -#define JZm(D) JCCim(0x4, D) -#define JNEm(D) JCCim(0x5, D) -#define JNZm(D) JCCim(0x5, D) -#define JBEm(D) JCCim(0x6, D) -#define JNAm(D) JCCim(0x6, D) -#define JNBEm(D) JCCim(0x7, D) -#define JAm(D) JCCim(0x7, D) -#define JSm(D) JCCim(0x8, D) -#define JNSm(D) JCCim(0x9, D) -#define JPm(D) JCCim(0xa, D) -#define JPEm(D) JCCim(0xa, D) -#define JNPm(D) JCCim(0xb, D) -#define JPOm(D) JCCim(0xb, D) -#define JLm(D) JCCim(0xc, D) -#define JNGEm(D) JCCim(0xc, D) -#define JNLm(D) JCCim(0xd, D) -#define JGEm(D) JCCim(0xd, D) -#define JLEm(D) JCCim(0xe, D) -#define JNGm(D) JCCim(0xe, D) -#define JNLEm(D) JCCim(0xf, D) -#define JGm(D) JCCim(0xf, D) - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ -#define SETCCir(CC, RD) (_REXBrr(0, RD), _OO_Mrm (0x0f90|(CC) ,_b11,_b000,_r1(RD) )) -#define SETOr(RD) SETCCir(0x0,RD) -#define SETNOr(RD) SETCCir(0x1,RD) -#define SETBr(RD) SETCCir(0x2,RD) -#define SETNAEr(RD) SETCCir(0x2,RD) -#define SETNBr(RD) SETCCir(0x3,RD) -#define SETAEr(RD) SETCCir(0x3,RD) -#define SETEr(RD) SETCCir(0x4,RD) -#define SETZr(RD) SETCCir(0x4,RD) -#define SETNEr(RD) SETCCir(0x5,RD) -#define SETNZr(RD) SETCCir(0x5,RD) -#define SETBEr(RD) SETCCir(0x6,RD) -#define SETNAr(RD) SETCCir(0x6,RD) -#define SETNBEr(RD) SETCCir(0x7,RD) -#define SETAr(RD) SETCCir(0x7,RD) -#define SETSr(RD) SETCCir(0x8,RD) -#define SETNSr(RD) SETCCir(0x9,RD) -#define SETPr(RD) SETCCir(0xa,RD) -#define SETPEr(RD) SETCCir(0xa,RD) -#define SETNPr(RD) SETCCir(0xb,RD) -#define SETPOr(RD) SETCCir(0xb,RD) -#define SETLr(RD) SETCCir(0xc,RD) -#define SETNGEr(RD) SETCCir(0xc,RD) -#define SETNLr(RD) SETCCir(0xd,RD) -#define SETGEr(RD) SETCCir(0xd,RD) -#define SETLEr(RD) SETCCir(0xe,RD) -#define SETNGr(RD) SETCCir(0xe,RD) -#define SETNLEr(RD) SETCCir(0xf,RD) -#define SETGr(RD) SETCCir(0xf,RD) - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ -#define SETCCim(CC,MD,MB,MI,MS) (_REXBrm(0, MB, MI), _OO_r_X (0x0f90|(CC) ,_b000 ,MD,MB,MI,MS )) -#define SETOm(D, B, I, S) SETCCim(0x0, D, B, I, S) -#define SETNOm(D, B, I, S) SETCCim(0x1, D, B, I, S) -#define SETBm(D, B, I, S) SETCCim(0x2, D, B, I, S) -#define SETNAEm(D, B, I, S) SETCCim(0x2, D, B, I, S) -#define SETNBm(D, B, I, S) SETCCim(0x3, D, B, I, S) -#define SETAEm(D, B, I, S) SETCCim(0x3, D, B, I, S) -#define SETEm(D, B, I, S) SETCCim(0x4, D, B, I, S) -#define SETZm(D, B, I, S) SETCCim(0x4, D, B, I, S) -#define SETNEm(D, B, I, S) SETCCim(0x5, D, B, I, S) -#define SETNZm(D, B, I, S) SETCCim(0x5, D, B, I, S) -#define SETBEm(D, B, I, S) SETCCim(0x6, D, B, I, S) -#define SETNAm(D, B, I, S) SETCCim(0x6, D, B, I, S) -#define SETNBEm(D, B, I, S) SETCCim(0x7, D, B, I, S) -#define SETAm(D, B, I, S) SETCCim(0x7, D, B, I, S) -#define SETSm(D, B, I, S) SETCCim(0x8, D, B, I, S) -#define SETNSm(D, B, I, S) SETCCim(0x9, D, B, I, S) -#define SETPm(D, B, I, S) SETCCim(0xa, D, B, I, S) -#define SETPEm(D, B, I, S) SETCCim(0xa, D, B, I, S) -#define SETNPm(D, B, I, S) SETCCim(0xb, D, B, I, S) -#define SETPOm(D, B, I, S) SETCCim(0xb, D, B, I, S) -#define SETLm(D, B, I, S) SETCCim(0xc, D, B, I, S) -#define SETNGEm(D, B, I, S) SETCCim(0xc, D, B, I, S) -#define SETNLm(D, B, I, S) SETCCim(0xd, D, B, I, S) -#define SETGEm(D, B, I, S) SETCCim(0xd, D, B, I, S) -#define SETLEm(D, B, I, S) SETCCim(0xe, D, B, I, S) -#define SETNGm(D, B, I, S) SETCCim(0xe, D, B, I, S) -#define SETNLEm(D, B, I, S) SETCCim(0xf, D, B, I, S) -#define SETGm(D, B, I, S) SETCCim(0xf, D, B, I, S) - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ -#define CMOVWrr(CC,RS,RD) (_d16(), _REXLrr(RD, RS), _OO_Mrm (0x0f40|(CC) ,_b11,_r2(RD),_r2(RS) )) -#define CMOVWmr(CC,MD,MB,MI,MS,RD) (_d16(), _REXLmr(MB, MI, RD), _OO_r_X (0x0f40|(CC) ,_r2(RD) ,MD,MB,MI,MS )) -#define CMOVLrr(CC,RS,RD) (_REXLrr(RD, RS), _OO_Mrm (0x0f40|(CC) ,_b11,_r4(RD),_r4(RS) )) -#define CMOVLmr(CC,MD,MB,MI,MS,RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0f40|(CC) ,_r4(RD) ,MD,MB,MI,MS )) - - -/* --- Push/Pop instructions ----------------------------------------------- */ - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define POPWr(RD) _m32only((_d16(), _Or (0x58,_r2(RD) ))) -#define POPWm(MD, MB, MI, MS) _m32only((_d16(), _O_r_X (0x8f ,_b000 ,MD,MB,MI,MS ))) - -#define POPLr(RD) _m32only( _Or (0x58,_r4(RD) )) -#define POPLm(MD, MB, MI, MS) _m32only( _O_r_X (0x8f ,_b000 ,MD,MB,MI,MS )) - - -#define PUSHWr(RS) _m32only((_d16(), _Or (0x50,_r2(RS) ))) -#define PUSHWm(MD, MB, MI, MS) _m32only((_d16(), _O_r_X (0xff, ,_b110 ,MD,MB,MI,MS ))) -#define PUSHWi(IM) _m32only((_d16(), _Os_sW (0x68 ,IM ))) - -#define PUSHLr(RS) _m32only( _Or (0x50,_r4(RS) )) -#define PUSHLm(MD, MB, MI, MS) _m32only( _O_r_X (0xff ,_b110 ,MD,MB,MI,MS )) -#define PUSHLi(IM) _m32only( _Os_sL (0x68 ,IM )) - - -#define POPA_() (_d16(), _O (0x61 )) -#define POPAD_() _O (0x61 ) - -#define PUSHA_() (_d16(), _O (0x60 )) -#define PUSHAD_() _O (0x60 ) - -#define POPF_() _O (0x9d ) -#define PUSHF_() _O (0x9c ) - - -/* --- Test instructions --------------------------------------------------- */ - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define TESTBrr(RS, RD) (_REXBrr(RS, RD), _O_Mrm (0x84 ,_b11,_r1(RS),_r1(RD) )) -#define TESTBrm(RS, MD, MB, MI, MS) (_REXBrm(RS, MB, MI), _O_r_X (0x84 ,_r1(RS) ,MD,MB,MI,MS )) -#define TESTBir(IM, RD) ((RD) == _AL ? \ - (_REXBrr(0, RD), _O_B (0xa8 ,_u8(IM))) : \ - (_REXBrr(0, RD), _O_Mrm_B (0xf6 ,_b11,_b000 ,_r1(RD) ,_u8(IM))) ) -#define TESTBim(IM, MD, MB, MI, MS) (_REXBrm(0, MB, MI), _O_r_X_B (0xf6 ,_b000 ,MD,MB,MI,MS ,_u8(IM))) - -#define TESTWrr(RS, RD) (_d16(), _REXLrr(RS, RD), _O_Mrm (0x85 ,_b11,_r2(RS),_r2(RD) )) -#define TESTWrm(RS, MD, MB, MI, MS) (_d16(), _REXLrm(RS, MB, MI), _O_r_X (0x85 ,_r2(RS) ,MD,MB,MI,MS )) -#define TESTWir(IM, RD) ((RD) == _AX ? \ - (_d16(), _REXLrr(0, RD), _O_W (0xa9 ,_u16(IM))) : \ - (_d16(), _REXLrr(0, RD), _O_Mrm_W (0xf7 ,_b11,_b000 ,_r2(RD) ,_u16(IM))) ) -#define TESTWim(IM, MD, MB, MI, MS) (_d16(), _REXLrm(0, MB, MI), _O_r_X_W (0xf7 ,_b000 ,MD,MB,MI,MS ,_u16(IM))) - -#define TESTLrr(RS, RD) (_REXLrr(RS, RD), _O_Mrm (0x85 ,_b11,_r4(RS),_r4(RD) )) -#define TESTLrm(RS, MD, MB, MI, MS) (_REXLrm(RS, MB, MI), _O_r_X (0x85 ,_r4(RS) ,MD,MB,MI,MS )) -#define TESTLir(IM, RD) (!_s8P(IM) && (RD) == _EAX ? \ - (_REXLrr(0, RD), _O_L (0xa9 ,IM )) : \ - (_REXLrr(0, RD), _O_Mrm_L (0xf7 ,_b11,_b000 ,_r4(RD) ,IM )) ) -#define TESTLim(IM, MD, MB, MI, MS) (_REXLrm(0, MB, MI), _O_r_X_L (0xf7 ,_b000 ,MD,MB,MI,MS ,IM )) - - - -/* --- Exchange instructions ----------------------------------------------- */ - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define CMPXCHGBrr(RS, RD) (_REXBrr(RS, RD), _OO_Mrm (0x0fb0 ,_b11,_r1(RS),_r1(RD) )) -#define CMPXCHGBrm(RS, MD, MB, MI, MS) (_REXBrm(RS, MB, MI), _OO_r_X (0x0fb0 ,_r1(RS) ,MD,MB,MI,MS )) - -#define CMPXCHGWrr(RS, RD) (_d16(), _REXLrr(RS, RD), _OO_Mrm (0x0fb1 ,_b11,_r2(RS),_r2(RD) )) -#define CMPXCHGWrm(RS, MD, MB, MI, MS) (_d16(), _REXLrm(RS, MB, MI), _OO_r_X (0x0fb1 ,_r2(RS) ,MD,MB,MI,MS )) - -#define CMPXCHGLrr(RS, RD) (_REXLrr(RS, RD), _OO_Mrm (0x0fb1 ,_b11,_r4(RS),_r4(RD) )) -#define CMPXCHGLrm(RS, MD, MB, MI, MS) (_REXLrm(RS, MB, MI), _OO_r_X (0x0fb1 ,_r4(RS) ,MD,MB,MI,MS )) - - -#define XADDBrr(RS, RD) (_REXBrr(RS, RD), _OO_Mrm (0x0fc0 ,_b11,_r1(RS),_r1(RD) )) -#define XADDBrm(RS, MD, MB, MI, MS) (_REXBrm(RS, MB, MI), _OO_r_X (0x0fc0 ,_r1(RS) ,MD,MB,MI,MS )) - -#define XADDWrr(RS, RD) (_d16(), _REXLrr(RS, RD), _OO_Mrm (0x0fc1 ,_b11,_r2(RS),_r2(RD) )) -#define XADDWrm(RS, MD, MB, MI, MS) (_d16(), _REXLrm(RS, MB, MI), _OO_r_X (0x0fc1 ,_r2(RS) ,MD,MB,MI,MS )) - -#define XADDLrr(RS, RD) (_REXLrr(RS, RD), _OO_Mrm (0x0fc1 ,_b11,_r4(RS),_r4(RD) )) -#define XADDLrm(RS, MD, MB, MI, MS) (_REXLrm(RS, MB, MI), _OO_r_X (0x0fc1 ,_r4(RS) ,MD,MB,MI,MS )) - - -#define XCHGBrr(RS, RD) (_REXBrr(RS, RD), _O_Mrm (0x86 ,_b11,_r1(RS),_r1(RD) )) -#define XCHGBrm(RS, MD, MB, MI, MS) (_REXBrm(RS, MB, MI), _O_r_X (0x86 ,_r1(RS) ,MD,MB,MI,MS )) - -#define XCHGWrr(RS, RD) (_d16(), _REXLrr(RS, RD), _O_Mrm (0x87 ,_b11,_r2(RS),_r2(RD) )) -#define XCHGWrm(RS, MD, MB, MI, MS) (_d16(), _REXLrm(RS, MB, MI), _O_r_X (0x87 ,_r2(RS) ,MD,MB,MI,MS )) - -#define XCHGLrr(RS, RD) (_REXLrr(RS, RD), _O_Mrm (0x87 ,_b11,_r4(RS),_r4(RD) )) -#define XCHGLrm(RS, MD, MB, MI, MS) (_REXLrm(RS, MB, MI), _O_r_X (0x87 ,_r4(RS) ,MD,MB,MI,MS )) - - - -/* --- Increment/Decrement instructions ------------------------------------ */ - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define DECBm(MD, MB, MI, MS) (_REXBrm(0, MB, MI), _O_r_X (0xfe ,_b001 ,MD,MB,MI,MS )) -#define DECBr(RD) (_REXBrr(0, RD), _O_Mrm (0xfe ,_b11,_b001 ,_r1(RD) )) - -#define DECWm(MD, MB, MI, MS) (_d16(), _REXLrm(0, MB, MI), _O_r_X (0xff ,_b001 ,MD,MB,MI,MS )) - -#define DECLm(MD, MB, MI, MS) (_REXLrm(0, MB, MI), _O_r_X (0xff ,_b001 ,MD,MB,MI,MS )) - - -#define INCBm(MD, MB, MI, MS) (_REXBrm(0, MB, MI), _O_r_X (0xfe ,_b000 ,MD,MB,MI,MS )) -#define INCBr(RD) (_REXBrr(0, RD), _O_Mrm (0xfe ,_b11,_b000 ,_r1(RD) )) - -#define INCWm(MD, MB, MI, MS) (_d16(), _REXLrm(0, MB, MI), _O_r_X (0xff ,_b000 ,MD,MB,MI,MS )) - -#define INCLm(MD, MB, MI, MS) (_REXLrm(0, MB, MI), _O_r_X (0xff ,_b000 ,MD,MB,MI,MS )) - - - -/* --- Misc instructions --------------------------------------------------- */ - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define BSFWrr(RS, RD) (_d16(), _REXLrr(RD, RS), _OO_Mrm (0x0fbc ,_b11,_r2(RD),_r2(RS) )) -#define BSFWmr(MD, MB, MI, MS, RD) (_d16(), _REXLmr(MB, MI, RD), _OO_r_X (0x0fbc ,_r2(RD) ,MD,MB,MI,MS )) -#define BSRWrr(RS, RD) (_d16(), _REXLrr(RD, RS), _OO_Mrm (0x0fbd ,_b11,_r2(RD),_r2(RS) )) -#define BSRWmr(MD, MB, MI, MS, RD) (_d16(), _REXLmr(MB, MI, RD), _OO_r_X (0x0fbd ,_r2(RD) ,MD,MB,MI,MS )) - -#define BSFLrr(RS, RD) (_REXLrr(RD, RS), _OO_Mrm (0x0fbc ,_b11,_r4(RD),_r4(RS) )) -#define BSFLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0fbc ,_r4(RD) ,MD,MB,MI,MS )) -#define BSRLrr(RS, RD) (_REXLrr(RD, RS), _OO_Mrm (0x0fbd ,_b11,_r4(RD),_r4(RS) )) -#define BSRLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0fbd ,_r4(RD) ,MD,MB,MI,MS )) - - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define MOVSBWrr(RS, RD) (_d16(), _REXBLrr(RD, RS), _OO_Mrm (0x0fbe ,_b11,_r2(RD),_r1(RS) )) -#define MOVSBWmr(MD, MB, MI, MS, RD) (_d16(), _REXLmr(MB, MI, RD), _OO_r_X (0x0fbe ,_r2(RD) ,MD,MB,MI,MS )) -#define MOVZBWrr(RS, RD) (_d16(), _REXBLrr(RD, RS), _OO_Mrm (0x0fb6 ,_b11,_r2(RD),_r1(RS) )) -#define MOVZBWmr(MD, MB, MI, MS, RD) (_d16(), _REXLmr(MB, MI, RD), _OO_r_X (0x0fb6 ,_r2(RD) ,MD,MB,MI,MS )) - -#define MOVSBLrr(RS, RD) (_REXBLrr(RD, RS), _OO_Mrm (0x0fbe ,_b11,_r4(RD),_r1(RS) )) -#define MOVSBLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0fbe ,_r4(RD) ,MD,MB,MI,MS )) -#define MOVZBLrr(RS, RD) (_REXBLrr(RD, RS), _OO_Mrm (0x0fb6 ,_b11,_r4(RD),_r1(RS) )) -#define MOVZBLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0fb6 ,_r4(RD) ,MD,MB,MI,MS )) - - -#define MOVSWLrr(RS, RD) (_REXLrr(RD, RS), _OO_Mrm (0x0fbf ,_b11,_r4(RD),_r2(RS) )) -#define MOVSWLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0fbf ,_r4(RD) ,MD,MB,MI,MS )) -#define MOVZWLrr(RS, RD) (_REXLrr(RD, RS), _OO_Mrm (0x0fb7 ,_b11,_r4(RD),_r2(RS) )) -#define MOVZWLmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _OO_r_X (0x0fb7 ,_r4(RD) ,MD,MB,MI,MS )) - - - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define LEALmr(MD, MB, MI, MS, RD) (_REXLmr(MB, MI, RD), _O_r_X (0x8d ,_r4(RD) ,MD,MB,MI,MS )) - -#define BSWAPLr(R) (_REXLrr(0, R), _OOr (0x0fc8,_r4(R) )) - -#define CLC_() _O (0xf8 ) -#define STC_() _O (0xf9 ) - -#define CMC_() _O (0xf5 ) -#define CLD_() _O (0xfc ) -#define STD_() _O (0xfd ) - -#define CBTW_() (_d16(), _O (0x98 )) -#define CWTL_() _O (0x98 ) -#define CLTQ_() _m64only(_REXQrr(0, 0), _O (0x98 )) - -#define CBW_() CBTW_() -#define CWDE_() CWTL_() -#define CDQE_() CLTQ_() - -#define CWTD_() (_d16(), _O (0x99 )) -#define CLTD_() _O (0x99 ) -#define CQTO_() _m64only(_REXQrr(0, 0), _O (0x99 )) - -#define CWD_() CWTD_() -#define CDQ_() CLTD_() -#define CQO_() CQTO_() - -#define LAHF_() _m32only( _O (0x9f )) -#define SAHF_() _m32only( _O (0x9e )) - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define CPUID_() _OO (0x0fa2 ) -#define RDTSC_() _OO (0xff31 ) - -#define ENTERii(W, B) _O_W_B (0xc8 ,_su16(W),_su8(B)) - -#define LEAVE_() _O (0xc9 ) -#define RET_() _O (0xc3 ) -#define RETi(IM) _O_W (0xc2 ,_su16(IM)) - -#define NOP_() _O (0x90 ) - -/* x87 instructions -- yay, we found a use for octal constants :-) */ - -#define ESCmi(D,B,I,S,OP) (_REXLrm(0,B,I), _O_r_X(0xd8|(OP >> 3), (OP & 7), D,B,I,S)) -#define ESCri(RD,OP) _O_Mrm(0xd8|(OP >> 3), _b11, (OP & 7), RD) - -#define ESCrri(RS,RD,OP) ((RS) == _ST0 ? ESCri(RD,(OP|040)) \ - : (RD) == _ST0 ? ESCri(RS,OP) \ - : JITFAIL ("coprocessor instruction without st0")) - -#define FLDSm(D,B,I,S) ESCmi(D,B,I,S,010) /* fld m32real */ -#define FILDLm(D,B,I,S) ESCmi(D,B,I,S,030) /* fild m32int */ -#define FLDLm(D,B,I,S) ESCmi(D,B,I,S,050) /* fld m64real */ -#define FILDWm(D,B,I,S) ESCmi(D,B,I,S,070) /* fild m16int */ -#define FSTSm(D,B,I,S) ESCmi(D,B,I,S,012) /* fst m32real */ -#define FISTLm(D,B,I,S) ESCmi(D,B,I,S,032) /* fist m32int */ -#define FSTLm(D,B,I,S) ESCmi(D,B,I,S,052) /* fst m64real */ -#define FISTWm(D,B,I,S) ESCmi(D,B,I,S,072) /* fist m16int */ -#define FSTPSm(D,B,I,S) ESCmi(D,B,I,S,013) /* fstp m32real */ -#define FISTPLm(D,B,I,S) ESCmi(D,B,I,S,033) /* fistp m32int */ -#define FSTPLm(D,B,I,S) ESCmi(D,B,I,S,053) /* fstp m64real */ -#define FISTPWm(D,B,I,S) ESCmi(D,B,I,S,073) /* fistp m16int */ -#define FLDTm(D,B,I,S) ESCmi(D,B,I,S,035) /* fld m80real */ -#define FILDQm(D,B,I,S) ESCmi(D,B,I,S,075) /* fild m64int */ -#define FSTPTm(D,B,I,S) ESCmi(D,B,I,S,037) /* fstp m80real */ -#define FISTPQm(D,B,I,S) ESCmi(D,B,I,S,077) /* fistp m64int */ - -#define FADDrr(RS,RD) ESCrri(RS,RD,000) -#define FMULrr(RS,RD) ESCrri(RS,RD,001) -#define FSUBrr(RS,RD) ESCrri(RS,RD,004) -#define FSUBRrr(RS,RD) ESCrri(RS,RD,005) -#define FDIVrr(RS,RD) ESCrri(RS,RD,006) -#define FDIVRrr(RS,RD) ESCrri(RS,RD,007) - -#define FLDr(RD) ESCri(RD,010) -#define FXCHr(RD) ESCri(RD,011) -#define FFREEr(RD) ESCri(RD,050) -#define FSTr(RD) ESCri(RD,052) -#define FSTPr(RD) ESCri(RD,053) -#define FCOMr(RD) ESCri(RD,002) -#define FCOMPr(RD) ESCri(RD,003) -#define FCOMIr(RD) ESCri(RD,036) -#define FCOMIPr(RD) ESCri(RD,076) -#define FUCOMr(RD) ESCri(RD,054) -#define FUCOMPr(RD) ESCri(RD,055) -#define FUCOMIr(RD) ESCri(RD,035) -#define FUCOMIPr(RD) ESCri(RD,075) -#define FADDPr(RD) ESCri(RD,060) -#define FMULPr(RD) ESCri(RD,061) -#define FSUBPr(RD) ESCri(RD,064) -#define FSUBRPr(RD) ESCri(RD,065) -#define FDIVPr(RD) ESCri(RD,066) -#define FDIVRPr(RD) ESCri(RD,067) - -#define FNSTSWr(RD) ((RD == _AX || RD == _EAX) ? _OO (0xdfe0) \ - : JITFAIL ("AX or EAX expected")) -/* N byte NOPs */ -#define NOPi(N) ((( (N) >= 8) ? (_jit_B(0x8d),_jit_B(0xb4),_jit_B(0x26),_jit_I(0x00),_jit_B(0x90)) : (void) 0), \ - (( ((N)&7) == 7) ? (_jit_B(0x8d),_jit_B(0xb4),_jit_B(0x26),_jit_I(0x00)) : \ - ( ((N)&7) == 6) ? (_jit_B(0x8d),_jit_B(0xb6),_jit_I(0x00)) : \ - ( ((N)&7) == 5) ? (_jit_B(0x90),_jit_B(0x8d),_jit_B(0x74),_jit_B(0x26),_jit_B(0x00)) : \ -/* leal 0(,%esi), %esi */ ( ((N)&7) == 4) ? (_jit_B(0x8d),_jit_B(0x74),_jit_B(0x26),_jit_B(0x00)) : \ -/* leal (,%esi), %esi */ ( ((N)&7) == 3) ? (_jit_B(0x8d),_jit_B(0x76),_jit_B(0x00)) : \ -/* movl %esi, %esi */ ( ((N)&7) == 2) ? (_jit_B(0x89),_jit_B(0xf6)) : \ - ( ((N)&7) == 1) ? (_jit_B(0x90)) : \ - ( ((N)&7) == 0) ? 0 : \ - JITFAIL(".align argument too large"))) - - -/* --- Media 128-bit instructions ------------------------------------------ */ - -enum { - X86_SSE_MOV = 0x10, - X86_SSE_MOVLP = 0x12, - X86_SSE_MOVHP = 0x16, - X86_SSE_MOVA = 0x28, - X86_SSE_CVTIS = 0x2a, - X86_SSE_CVTTSI = 0x2c, - X86_SSE_CVTSI = 0x2d, - X86_SSE_UCOMI = 0x2e, - X86_SSE_COMI = 0x2f, - X86_SSE_SQRT = 0x51, - X86_SSE_RSQRT = 0x52, - X86_SSE_RCP = 0x53, - X86_SSE_AND = 0x54, - X86_SSE_ANDN = 0x55, - X86_SSE_OR = 0x56, - X86_SSE_XOR = 0x57, - X86_SSE_ADD = 0x58, - X86_SSE_MUL = 0x59, - X86_SSE_CVTSD = 0x5a, - X86_SSE_CVTDT = 0x5b, - X86_SSE_SUB = 0x5c, - X86_SSE_MIN = 0x5d, - X86_SSE_DIV = 0x5e, - X86_SSE_MAX = 0x5f, - X86_SSE_MOV2 = 0xd6 -}; - -/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */ - -#define __SSELrr(OP,RS,RSA,RD,RDA) (_REXLrr(RD, RS), _OO_Mrm (0x0f00|(OP) ,_b11,RDA(RD),RSA(RS) )) -#define __SSELmr(OP,MD,MB,MI,MS,RD,RDA) (_REXLmr(MB, MI, RD), _OO_r_X (0x0f00|(OP) ,RDA(RD) ,MD,MB,MI,MS )) -#define __SSELrm(OP,RS,RSA,MD,MB,MI,MS) (_REXLrm(RS, MB, MI), _OO_r_X (0x0f00|(OP) ,RSA(RS) ,MD,MB,MI,MS )) -#define __SSEL1rm(OP,RS,RSA,MD,MB,MI,MS) (_REXLrm(RS, MB, MI), _OO_r_X (0x0f01|(OP) ,RSA(RS) ,MD,MB,MI,MS )) - -#define _SSELrr(PX,OP,RS,RSA,RD,RDA) (_jit_B(PX), __SSELrr(OP, RS, RSA, RD, RDA)) -#define _SSELmr(PX,OP,MD,MB,MI,MS,RD,RDA) (_jit_B(PX), __SSELmr(OP, MD, MB, MI, MS, RD, RDA)) -#define _SSELrm(PX,OP,RS,RSA,MD,MB,MI,MS) (_jit_B(PX), __SSELrm(OP, RS, RSA, MD, MB, MI, MS)) -#define _SSEL1rm(PX,OP,RS,RSA,MD,MB,MI,MS) (_jit_B(PX), __SSEL1rm(OP, RS, RSA, MD, MB, MI, MS)) - -#define _SSEPSrr(OP,RS,RD) __SSELrr ( OP, RS,_rX, RD,_rX) -#define _SSEPSmr(OP,MD,MB,MI,MS,RD) __SSELmr ( OP, MD, MB, MI, MS, RD,_rX) -#define _SSEPSrm(OP,RS,MD,MB,MI,MS) __SSELrm ( OP, RS,_rX, MD, MB, MI, MS) -#define _SSEPS1rm(OP,RS,MD,MB,MI,MS) __SSEL1rm( OP, RS,_rX, MD, MB, MI, MS) - -#define _SSEPDrr(OP,RS,RD) _SSELrr (0x66, OP, RS,_rX, RD,_rX) -#define _SSEPDmr(OP,MD,MB,MI,MS,RD) _SSELmr (0x66, OP, MD, MB, MI, MS, RD,_rX) -#define _SSEPDrm(OP,RS,MD,MB,MI,MS) _SSELrm (0x66, OP, RS,_rX, MD, MB, MI, MS) -#define _SSEPD1rm(OP,RS,MD,MB,MI,MS) _SSEL1rm(0x66, OP, RS,_rX, MD, MB, MI, MS) - -#define _SSESSrr(OP,RS,RD) _SSELrr (0xf3, OP, RS,_rX, RD,_rX) -#define _SSESSmr(OP,MD,MB,MI,MS,RD) _SSELmr (0xf3, OP, MD, MB, MI, MS, RD,_rX) -#define _SSESSrm(OP,RS,MD,MB,MI,MS) _SSELrm (0xf3, OP, RS,_rX, MD, MB, MI, MS) -#define _SSESS1rm(OP,RS,MD,MB,MI,MS) _SSEL1rm(0xf3, OP, RS,_rX, MD, MB, MI, MS) - -#define _SSESDrr(OP,RS,RD) _SSELrr (0xf2, OP, RS,_rX, RD,_rX) -#define _SSESDmr(OP,MD,MB,MI,MS,RD) _SSELmr (0xf2, OP, MD, MB, MI, MS, RD,_rX) -#define _SSESDrm(OP,RS,MD,MB,MI,MS) _SSELrm (0xf2, OP, RS,_rX, MD, MB, MI, MS) -#define _SSESD1rm(OP,RS,MD,MB,MI,MS) _SSEL1rm(0xf2, OP, RS,_rX, MD, MB, MI, MS) - -#define ADDPSrr(RS, RD) _SSEPSrr(X86_SSE_ADD, RS, RD) -#define ADDPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_ADD, MD, MB, MI, MS, RD) -#define ADDPDrr(RS, RD) _SSEPDrr(X86_SSE_ADD, RS, RD) -#define ADDPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_ADD, MD, MB, MI, MS, RD) - -#define ADDSSrr(RS, RD) _SSESSrr(X86_SSE_ADD, RS, RD) -#define ADDSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_ADD, MD, MB, MI, MS, RD) -#define ADDSDrr(RS, RD) _SSESDrr(X86_SSE_ADD, RS, RD) -#define ADDSDmr(MD, MB, MI, MS, RD) _SSESDmr(X86_SSE_ADD, MD, MB, MI, MS, RD) - -#define ANDNPSrr(RS, RD) _SSEPSrr(X86_SSE_ANDN, RS, RD) -#define ANDNPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_ANDN, MD, MB, MI, MS, RD) -#define ANDNPDrr(RS, RD) _SSEPDrr(X86_SSE_ANDN, RS, RD) -#define ANDNPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_ANDN, MD, MB, MI, MS, RD) - -#define ANDNSSrr ANDNPSrr -#define ANDNSSmr ANDNPSrr -#define ANDNSDrr ANDNPDrr -#define ANDNSDmr ANDNPDrr - -#define ANDPSrr(RS, RD) _SSEPSrr(X86_SSE_AND, RS, RD) -#define ANDPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_AND, MD, MB, MI, MS, RD) -#define ANDPDrr(RS, RD) _SSEPDrr(X86_SSE_AND, RS, RD) -#define ANDPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_AND, MD, MB, MI, MS, RD) - -#define ANDSSrr ANDPSrr -#define ANDSSmr ANDPSrr -#define ANDSDrr ANDPDrr -#define ANDSDmr ANDPDrr - -#define DIVPSrr(RS, RD) _SSEPSrr(X86_SSE_DIV, RS, RD) -#define DIVPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_DIV, MD, MB, MI, MS, RD) -#define DIVPDrr(RS, RD) _SSEPDrr(X86_SSE_DIV, RS, RD) -#define DIVPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_DIV, MD, MB, MI, MS, RD) - -#define DIVSSrr(RS, RD) _SSESSrr(X86_SSE_DIV, RS, RD) -#define DIVSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_DIV, MD, MB, MI, MS, RD) -#define DIVSDrr(RS, RD) _SSESDrr(X86_SSE_DIV, RS, RD) -#define DIVSDmr(MD, MB, MI, MS, RD) _SSESDmr(X86_SSE_DIV, MD, MB, MI, MS, RD) - -#define MAXPSrr(RS, RD) _SSEPSrr(X86_SSE_MAX, RS, RD) -#define MAXPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_MAX, MD, MB, MI, MS, RD) -#define MAXPDrr(RS, RD) _SSEPDrr(X86_SSE_MAX, RS, RD) -#define MAXPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_MAX, MD, MB, MI, MS, RD) - -#define MAXSSrr(RS, RD) _SSESSrr(X86_SSE_MAX, RS, RD) -#define MAXSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_MAX, MD, MB, MI, MS, RD) -#define MAXSDrr(RS, RD) _SSESDrr(X86_SSE_MAX, RS, RD) -#define MAXSDmr(MD, MB, MI, MS, RD) _SSESDmr(X86_SSE_MAX, MD, MB, MI, MS, RD) - -#define MINPSrr(RS, RD) _SSEPSrr(X86_SSE_MIN, RS, RD) -#define MINPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_MIN, MD, MB, MI, MS, RD) -#define MINPDrr(RS, RD) _SSEPDrr(X86_SSE_MIN, RS, RD) -#define MINPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_MIN, MD, MB, MI, MS, RD) - -#define MINSSrr(RS, RD) _SSESSrr(X86_SSE_MIN, RS, RD) -#define MINSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_MIN, MD, MB, MI, MS, RD) -#define MINSDrr(RS, RD) _SSESDrr(X86_SSE_MIN, RS, RD) -#define MINSDmr(MD, MB, MI, MS, RD) _SSESDmr(X86_SSE_MIN, MD, MB, MI, MS, RD) - -#define MULPSrr(RS, RD) _SSEPSrr(X86_SSE_MUL, RS, RD) -#define MULPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_MUL, MD, MB, MI, MS, RD) -#define MULPDrr(RS, RD) _SSEPDrr(X86_SSE_MUL, RS, RD) -#define MULPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_MUL, MD, MB, MI, MS, RD) - -#define MULSSrr(RS, RD) _SSESSrr(X86_SSE_MUL, RS, RD) -#define MULSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_MUL, MD, MB, MI, MS, RD) -#define MULSDrr(RS, RD) _SSESDrr(X86_SSE_MUL, RS, RD) -#define MULSDmr(MD, MB, MI, MS, RD) _SSESDmr(X86_SSE_MUL, MD, MB, MI, MS, RD) - -#define ORPSrr(RS, RD) _SSEPSrr(X86_SSE_OR, RS, RD) -#define ORPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_OR, MD, MB, MI, MS, RD) -#define ORPDrr(RS, RD) _SSEPDrr(X86_SSE_OR, RS, RD) -#define ORPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_OR, MD, MB, MI, MS, RD) - -#define ORSSrr ORPSrr -#define ORSSmr ORPSrr -#define ORSDrr ORPDrr -#define ORSDmr ORPDrr - -#define RCPPSrr(RS, RD) _SSEPSrr(X86_SSE_RCP, RS, RD) -#define RCPPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_RCP, MD, MB, MI, MS, RD) -#define RCPSSrr(RS, RD) _SSESSrr(X86_SSE_RCP, RS, RD) -#define RCPSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_RCP, MD, MB, MI, MS, RD) - -#define RSQRTPSrr(RS, RD) _SSEPSrr(X86_SSE_RSQRT, RS, RD) -#define RSQRTPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_RSQRT, MD, MB, MI, MS, RD) -#define RSQRTSSrr(RS, RD) _SSESSrr(X86_SSE_RSQRT, RS, RD) -#define RSQRTSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_RSQRT, MD, MB, MI, MS, RD) - -#define SQRTPSrr(RS, RD) _SSEPSrr(X86_SSE_SQRT, RS, RD) -#define SQRTPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_SQRT, MD, MB, MI, MS, RD) -#define SQRTPDrr(RS, RD) _SSEPDrr(X86_SSE_SQRT, RS, RD) -#define SQRTPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_SQRT, MD, MB, MI, MS, RD) - -#define SQRTSSrr(RS, RD) _SSESSrr(X86_SSE_SQRT, RS, RD) -#define SQRTSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_SQRT, MD, MB, MI, MS, RD) -#define SQRTSDrr(RS, RD) _SSESDrr(X86_SSE_SQRT, RS, RD) -#define SQRTSDmr(MD, MB, MI, MS, RD) _SSESDmr(X86_SSE_SQRT, MD, MB, MI, MS, RD) - -#define SUBPSrr(RS, RD) _SSEPSrr(X86_SSE_SUB, RS, RD) -#define SUBPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_SUB, MD, MB, MI, MS, RD) -#define SUBPDrr(RS, RD) _SSEPDrr(X86_SSE_SUB, RS, RD) -#define SUBPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_SUB, MD, MB, MI, MS, RD) - -#define SUBSSrr(RS, RD) _SSESSrr(X86_SSE_SUB, RS, RD) -#define SUBSSmr(MD, MB, MI, MS, RD) _SSESSmr(X86_SSE_SUB, MD, MB, MI, MS, RD) -#define SUBSDrr(RS, RD) _SSESDrr(X86_SSE_SUB, RS, RD) -#define SUBSDmr(MD, MB, MI, MS, RD) _SSESDmr(X86_SSE_SUB, MD, MB, MI, MS, RD) - -#define XORPSrr(RS, RD) _SSEPSrr(X86_SSE_XOR, RS, RD) -#define XORPSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_XOR, MD, MB, MI, MS, RD) -#define XORPDrr(RS, RD) _SSEPDrr(X86_SSE_XOR, RS, RD) -#define XORPDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_XOR, MD, MB, MI, MS, RD) - -#define XORSSrr XORPSrr -#define XORSSmr XORPSrr -#define XORSDrr XORPDrr -#define XORSDmr XORPDrr - -/* No prefixes here. */ -#define COMISSrr(RS, RD) _SSEPSrr(X86_SSE_COMI, RS, RD) -#define COMISSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_COMI, MD, MB, MI, MS, RD) -#define COMISDrr(RS, RD) _SSEPDrr(X86_SSE_COMI, RS, RD) -#define COMISDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_COMI, MD, MB, MI, MS, RD) - -/* No prefixes here. */ -#define UCOMISSrr(RS, RD) _SSEPSrr(X86_SSE_UCOMI, RS, RD) -#define UCOMISSmr(MD, MB, MI, MS, RD) _SSEPSmr(X86_SSE_UCOMI, MD, MB, MI, MS, RD) -#define UCOMISDrr(RS, RD) _SSEPDrr(X86_SSE_UCOMI, RS, RD) -#define UCOMISDmr(MD, MB, MI, MS, RD) _SSEPDmr(X86_SSE_UCOMI, MD, MB, MI, MS, RD) - -#define MOVSSrr(RS, RD) _SSESSrr (X86_SSE_MOV, RS, RD) -#define MOVSSmr(MD, MB, MI, MS, RD) _SSESSmr (X86_SSE_MOV, MD, MB, MI, MS, RD) -#define MOVSSrm(RS, MD, MB, MI, MS) _SSESS1rm(X86_SSE_MOV, RS, MD, MB, MI, MS) - -#define MOVSDrr(RS, RD) _SSESDrr (X86_SSE_MOV, RS, RD) -#define MOVSDmr(MD, MB, MI, MS, RD) _SSESDmr (X86_SSE_MOV, MD, MB, MI, MS, RD) -#define MOVSDrm(RS, MD, MB, MI, MS) _SSESD1rm(X86_SSE_MOV, RS, MD, MB, MI, MS) - -#define MOVAPSrr(RS, RD) _SSEPSrr (X86_SSE_MOVA, RS, RD) -#define MOVAPSmr(MD, MB, MI, MS, RD) _SSEPSmr (X86_SSE_MOVA, MD, MB, MI, MS, RD) -#define MOVAPSrm(RS, MD, MB, MI, MS) _SSEPS1rm(X86_SSE_MOVA, RS, MD, MB, MI, MS) - -#define MOVAPDrr(RS, RD) _SSEPDrr (X86_SSE_MOVA, RS, RD) -#define MOVAPDmr(MD, MB, MI, MS, RD) _SSEPDmr (X86_SSE_MOVA, MD, MB, MI, MS, RD) -#define MOVAPDrm(RS, MD, MB, MI, MS) _SSEPD1rm(X86_SSE_MOVA, RS, MD, MB, MI, MS) - -#define CVTPS2PIrr(RS, RD) __SSELrr( X86_SSE_CVTSI, RS,_rX, RD,_rM) -#define CVTPS2PImr(MD, MB, MI, MS, RD) __SSELmr( X86_SSE_CVTSI, MD, MB, MI, MS, RD,_rM) -#define CVTPD2PIrr(RS, RD) _SSELrr(0x66, X86_SSE_CVTSI, RS,_rX, RD,_rM) -#define CVTPD2PImr(MD, MB, MI, MS, RD) _SSELmr(0x66, X86_SSE_CVTSI, MD, MB, MI, MS, RD,_rM) - -#define CVTPI2PSrr(RS, RD) __SSELrr( X86_SSE_CVTIS, RS,_rM, RD,_rX) -#define CVTPI2PSmr(MD, MB, MI, MS, RD) __SSELmr( X86_SSE_CVTIS, MD, MB, MI, MS, RD,_rX) -#define CVTPI2PDrr(RS, RD) _SSELrr(0x66, X86_SSE_CVTIS, RS,_rM, RD,_rX) -#define CVTPI2PDmr(MD, MB, MI, MS, RD) _SSELmr(0x66, X86_SSE_CVTIS, MD, MB, MI, MS, RD,_rX) - -#define CVTPS2PDrr(RS, RD) __SSELrr( X86_SSE_CVTSD, RS,_rX, RD,_rX) -#define CVTPS2PDmr(MD, MB, MI, MS, RD) __SSELmr( X86_SSE_CVTSD, MD, MB, MI, MS, RD,_rX) -#define CVTPD2PSrr(RS, RD) _SSELrr(0x66, X86_SSE_CVTSD, RS,_rX, RD,_rX) -#define CVTPD2PSmr(MD, MB, MI, MS, RD) _SSELmr(0x66, X86_SSE_CVTSD, MD, MB, MI, MS, RD,_rX) - -#define CVTSS2SDrr(RS, RD) _SSELrr(0xf3, X86_SSE_CVTSD, RS,_rX, RD,_rX) -#define CVTSS2SDmr(MD, MB, MI, MS, RD) _SSELmr(0xf3, X86_SSE_CVTSD, MD, MB, MI, MS, RD,_rX) -#define CVTSD2SSrr(RS, RD) _SSELrr(0xf2, X86_SSE_CVTSD, RS,_rX, RD,_rX) -#define CVTSD2SSmr(MD, MB, MI, MS, RD) _SSELmr(0xf2, X86_SSE_CVTSD, MD, MB, MI, MS, RD,_rX) - -#define CVTTSS2SILrr(RS, RD) _SSELrr(0xf3, X86_SSE_CVTTSI, RS,_rX, RD,_r4) -#define CVTTSS2SILmr(MD, MB, MI, MS, RD) _SSELmr(0xf3, X86_SSE_CVTTSI, MD, MB, MI, MS, RD,_r4) -#define CVTTSD2SILrr(RS, RD) _SSELrr(0xf2, X86_SSE_CVTTSI, RS,_rX, RD,_r4) -#define CVTTSD2SILmr(MD, MB, MI, MS, RD) _SSELmr(0xf2, X86_SSE_CVTTSI, MD, MB, MI, MS, RD,_r4) - -#define CVTSS2SILrr(RS, RD) _SSELrr(0xf3, X86_SSE_CVTSI, RS,_rX, RD,_r4) -#define CVTSS2SILmr(MD, MB, MI, MS, RD) _SSELmr(0xf3, X86_SSE_CVTSI, MD, MB, MI, MS, RD,_r4) -#define CVTSD2SILrr(RS, RD) _SSELrr(0xf2, X86_SSE_CVTSI, RS,_rX, RD,_r4) -#define CVTSD2SILmr(MD, MB, MI, MS, RD) _SSELmr(0xf2, X86_SSE_CVTSI, MD, MB, MI, MS, RD,_r4) - -#define CVTSI2SSLrr(RS, RD) _SSELrr(0xf3, X86_SSE_CVTIS, RS,_r4, RD,_rX) -#define CVTSI2SSLmr(MD, MB, MI, MS, RD) _SSELmr(0xf3, X86_SSE_CVTIS, MD, MB, MI, MS, RD,_rX) -#define CVTSI2SDLrr(RS, RD) _SSELrr(0xf2, X86_SSE_CVTIS, RS,_r4, RD,_rX) -#define CVTSI2SDLmr(MD, MB, MI, MS, RD) _SSELmr(0xf2, X86_SSE_CVTIS, MD, MB, MI, MS, RD,_rX) - -#define MOVDLXrr(RS, RD) _SSELrr(0x66, 0x6e, RS,_r4, RD,_rX) -#define MOVDLXmr(MD, MB, MI, MS, RD) _SSELmr(0x66, 0x6e, MD, MB, MI, MS, RD,_rX) - -#define MOVDXLrr(RS, RD) _SSELrr(0x66, 0x7e, RS,_rX, RD,_r4) -#define MOVDXLrm(RS, MD, MB, MI, MS) _SSELrm(0x66, 0x7e, RS,_rX, MD, MB, MI, MS) - -#define MOVDLMrr(RS, RD) __SSELrr( 0x6e, RS,_r4, RD,_rM) -#define MOVDLMmr(MD, MB, MI, MS, RD) __SSELmr( 0x6e, MD, MB, MI, MS, RD,_rM) - -#define MOVDMLrr(RS, RD) __SSELrr( 0x7e, RS,_rM, RD,_r4) -#define MOVDMLrm(RS, MD, MB, MI, MS) __SSELrm( 0x7e, RS,_rM, MD, MB, MI, MS) - -#define MOVDQ2Qrr(RS, RD) _SSELrr(0xf2, X86_SSE_MOV2, RS,_rX, RD,_rM) -#define MOVQ2DQrr(RS, RD) _SSELrr(0xf3, X86_SSE_MOV2, RS,_rM, RD,_rX) -#define MOVHLPSrr(RS, RD) __SSELrr( X86_SSE_MOVLP, RS,_rX, RD,_rX) -#define MOVLHPSrr(RS, RD) __SSELrr( X86_SSE_MOVHP, RS,_rX, RD,_rX) - -#define MOVDQArr(RS, RD) _SSELrr(0x66, 0x6f, RS,_rX, RD,_rX) -#define MOVDQAmr(MD, MB, MI, MS, RD) _SSELmr(0x66, 0x6f, MD, MB, MI, MS, RD,_rX) -#define MOVDQArm(RS, MD, MB, MI, MS) _SSELrm(0x66, 0x7f, RS,_rX, MD, MB, MI, MS) - -#define MOVDQUrr(RS, RD) _SSELrr(0xf3, 0x6f, RS,_rX, RD,_rX) -#define MOVDQUmr(MD, MB, MI, MS, RD) _SSELmr(0xf3, 0x6f, MD, MB, MI, MS, RD,_rX) -#define MOVDQUrm(RS, MD, MB, MI, MS) _SSELrm(0xf3, 0x7f, RS,_rX, MD, MB, MI, MS) - -#define MOVHPDmr(MD, MB, MI, MS, RD) _SSELmr (0x66, X86_SSE_MOVHP, MD, MB, MI, MS, RD,_rX) -#define MOVHPDrm(RS, MD, MB, MI, MS) _SSEL1rm(0x66, X86_SSE_MOVHP, RS,_rX, MD, MB, MI, MS) -#define MOVHPSmr(MD, MB, MI, MS, RD) __SSELmr ( X86_SSE_MOVHP, MD, MB, MI, MS, RD,_rX) -#define MOVHPSrm(RS, MD, MB, MI, MS) __SSEL1rm( X86_SSE_MOVHP, RS,_rX, MD, MB, MI, MS) - -#define MOVLPDmr(MD, MB, MI, MS, RD) _SSELmr (0x66, X86_SSE_MOVLP, MD, MB, MI, MS, RD,_rX) -#define MOVLPDrm(RS, MD, MB, MI, MS) _SSEL1rm(0x66, X86_SSE_MOVLP, RS,_rX, MD, MB, MI, MS) -#define MOVLPSmr(MD, MB, MI, MS, RD) __SSELmr ( X86_SSE_MOVLP, MD, MB, MI, MS, RD,_rX) -#define MOVLPSrm(RS, MD, MB, MI, MS) __SSEL1rm( X86_SSE_MOVLP, RS,_rX, MD, MB, MI, MS) - -/*** References: */ -/* */ -/* [1] "Intel Architecture Software Developer's Manual Volume 1: Basic Architecture", */ -/* Intel Corporation 1997. */ -/* */ -/* [2] "Intel Architecture Software Developer's Manual Volume 2: Instruction Set Reference", */ -/* Intel Corporation 1997. */ - -#if LIGHTNING_CROSS \ - ? LIGHTNING_TARGET == LIGHTNING_X86_64 \ - : defined (__x86_64__) -#include "i386/asm-64.h" -#else -#include "i386/asm-32.h" -#endif - -#endif -#endif /* __lightning_asm_i386_h */ diff --git a/src/runtime/c/pgf/lightning/i386/core-32.h b/src/runtime/c/pgf/lightning/i386/core-32.h deleted file mode 100644 index 11e0128af..000000000 --- a/src/runtime/c/pgf/lightning/i386/core-32.h +++ /dev/null @@ -1,177 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer (i386 version) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2003, 2006 Free Software Foundation, Inc. - * Written by Paolo Bonzini and Matthew Flatt. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_core_h -#define __lightning_core_h - -#define JIT_CAN_16 1 -#define JIT_AP _EBP - -#define JIT_R_NUM 3 -#define JIT_R(i) (_EAX + (i)) -#define JIT_V_NUM 3 -#define JIT_V(i) ((i) == 0 ? _EBX : _ESI + (i) - 1) - -struct jit_local_state { - int framesize; - int argssize; - int alloca_offset; - int alloca_slack; - jit_insn *finish_ref; -}; - -/* Whether a register is used for the user-accessible registers. */ -#define jit_save(reg) 1 - -#define jit_base_prolog() (_jitl.framesize = 20, _jitl.alloca_offset = _jitl.alloca_slack = 0, _jitl.argssize = 0, \ - PUSHLr(_EBX), PUSHLr(_ESI), PUSHLr(_EDI), PUSHLr(_EBP), MOVLrr(_ESP, _EBP)) -#define jit_base_ret(ofs) \ - (((ofs) < 0 ? LEAVE_() : POPLr(_EBP)), \ - POPLr(_EDI), POPLr(_ESI), POPLr(_EBX), RET_()) - -/* Used internally. SLACK is used by the Darwin ABI which keeps the stack - aligned to 16-bytes. */ - -#define jit_allocai_internal(amount, slack) \ - (((amount) < _jitl.alloca_slack \ - ? (void)0 \ - : (void)(_jitl.alloca_slack += (amount) + (slack), \ - ((amount) + (slack) == sizeof (int) \ - ? PUSHLr(_EAX) \ - : SUBLir((amount) + (slack), _ESP)))), \ - _jitl.alloca_slack -= (amount), \ - _jitl.alloca_offset -= (amount)) - -/* Stack */ -#define jit_pushr_i(rs) PUSHLr(rs) -#define jit_popr_i(rs) POPLr(rs) - -/* The += in argssize allows for stack pollution */ - -#ifdef __APPLE__ -/* Stack must stay 16-byte aligned: */ -# define jit_prepare_i(ni) (((ni & 0x3) \ - ? (void)SUBLir(4 * ((((ni) + 3) & ~(0x3)) - (ni)), JIT_SP) \ - : (void)0), \ - _jitl.argssize += (((ni) + 3) & ~(0x3))) - -#define jit_allocai(n) \ - jit_allocai_internal ((n), (_jitl.alloca_slack - (n)) & 15) - -#define jit_prolog(n) (jit_base_prolog(), jit_subi_i (JIT_SP, JIT_SP, 12)) -#define jit_ret() jit_base_ret (-12) - -#else -# define jit_prepare_i(ni) (_jitl.argssize += (ni)) - -#define jit_allocai(n) \ - jit_allocai_internal ((n), 0) - -#define jit_prolog(n) jit_base_prolog() -#define jit_ret() jit_base_ret (_jitl.alloca_offset) -#endif - -#define jit_bare_ret() RET_() - -#define jit_calli(label) (CALLm( ((unsigned long) (label))), _jit.x.pc) -#define jit_callr(reg) CALLsr(reg) - -#define jit_pusharg_i(rs) PUSHLr(rs) -#define jit_finish(sub) (_jitl.finish_ref = jit_calli((sub)), ADDLir(sizeof(long) * _jitl.argssize, JIT_SP), _jitl.argssize = 0, _jitl.finish_ref) -#define jit_finishr(reg) (jit_callr((reg)), ADDLir(sizeof(long) * _jitl.argssize, JIT_SP), _jitl.argssize = 0) - -#define jit_arg_c() ((_jitl.framesize += sizeof(int)) - sizeof(int)) -#define jit_arg_uc() ((_jitl.framesize += sizeof(int)) - sizeof(int)) -#define jit_arg_s() ((_jitl.framesize += sizeof(int)) - sizeof(int)) -#define jit_arg_us() ((_jitl.framesize += sizeof(int)) - sizeof(int)) -#define jit_arg_i() ((_jitl.framesize += sizeof(int)) - sizeof(int)) -#define jit_arg_ui() ((_jitl.framesize += sizeof(int)) - sizeof(int)) -#define jit_arg_l() ((_jitl.framesize += sizeof(long)) - sizeof(long)) -#define jit_arg_ul() ((_jitl.framesize += sizeof(long)) - sizeof(long)) -#define jit_arg_p() ((_jitl.framesize += sizeof(long)) - sizeof(long)) - -#define jit_movi_p(d, is) (MOVLir (((long)(is)), (d)), _jit.x.pc) -#define jit_patch_long_at(jump_pc,v) (*_PSL((jump_pc) - sizeof(long)) = _jit_SL((jit_insn *)(v) - (jump_pc))) -#define jit_patch_at(jump_pc,v) jit_patch_long_at(jump_pc, v) -#define jit_patch_calli(jump_pc,v) jit_patch_long_at(jump_pc, v) - -/* Memory */ -#define jit_replace(s, rep, op) \ - (jit_pushr_i(rep), \ - MOVLrr((s), (rep)), \ - op, jit_popr_i(rep)) - -#define jit_movbrm(rs, dd, db, di, ds) \ - (jit_check8(rs) \ - ? MOVBrm(jit_reg8(rs), dd, db, di, ds) \ - : jit_replace(rs, \ - ((dd != _EAX && db != _EAX && di != _EAX) ? _EAX : \ - ((dd != _ECX && db != _ECX && di != _ECX) ? _ECX : _EDX)), \ - MOVBrm(((dd != _EAX && db != _EAX && di != _EAX) ? _AL : \ - ((dd != _ECX && db != _ECX && di != _ECX) ? _CL : _DL)), \ - dd, db, di, ds))) - -#define jit_ldr_c(d, rs) MOVSBLmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_c(d, s1, s2) MOVSBLmr(0, (s1), (s2), 1, (d)) - -#define jit_ldr_s(d, rs) MOVSWLmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_s(d, s1, s2) MOVSWLmr(0, (s1), (s2), 1, (d)) - -#define jit_ldi_c(d, is) MOVSBLmr((is), 0, 0, 0, (d)) -#define jit_ldxi_c(d, rs, is) MOVSBLmr((is), (rs), 0, 0, (d)) - -#define jit_ldi_uc(d, is) MOVZBLmr((is), 0, 0, 0, (d)) -#define jit_ldxi_uc(d, rs, is) MOVZBLmr((is), (rs), 0, 0, (d)) - -#define jit_sti_c(id, rs) jit_movbrm((rs), (id), 0, 0, 0) -#define jit_stxi_c(id, rd, rs) jit_movbrm((rs), (id), (rd), 0, 0) - -#define jit_ldi_s(d, is) MOVSWLmr((is), 0, 0, 0, (d)) -#define jit_ldxi_s(d, rs, is) MOVSWLmr((is), (rs), 0, 0, (d)) - -#define jit_ldi_us(d, is) MOVZWLmr((is), 0, 0, 0, (d)) -#define jit_ldxi_us(d, rs, is) MOVZWLmr((is), (rs), 0, 0, (d)) - -#define jit_sti_s(id, rs) MOVWrm(jit_reg16(rs), (id), 0, 0, 0) -#define jit_stxi_s(id, rd, rs) MOVWrm(jit_reg16(rs), (id), (rd), 0, 0) - -#define jit_ldi_i(d, is) MOVLmr((is), 0, 0, 0, (d)) -#define jit_ldxi_i(d, rs, is) MOVLmr((is), (rs), 0, 0, (d)) - -#define jit_ldr_i(d, rs) MOVLmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_i(d, s1, s2) MOVLmr(0, (s1), (s2), 1, (d)) - -#define jit_sti_i(id, rs) MOVLrm((rs), (id), 0, 0, 0) -#define jit_stxi_i(id, rd, rs) MOVLrm((rs), (id), (rd), 0, 0) - -#endif /* __lightning_core_h */ diff --git a/src/runtime/c/pgf/lightning/i386/core-64.h b/src/runtime/c/pgf/lightning/i386/core-64.h deleted file mode 100644 index 44a4de3e5..000000000 --- a/src/runtime/c/pgf/lightning/i386/core-64.h +++ /dev/null @@ -1,499 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer (i386 version) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2003, 2006 Free Software Foundation, Inc. - * Written by Paolo Bonzini and Matthew Flatt. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_core_h -#define __lightning_core_h - -/* Used to implement ldc, stc, ... */ -#define JIT_CAN_16 0 -#define JIT_REXTMP _R12 - -/* Number or integer argument registers */ -#define JIT_ARG_MAX 6 - -/* Number of float argument registers */ -#define JIT_FP_ARG_MAX 8 - -#define JIT_R_NUM 3 -#define JIT_R(i) ((i) == 0 ? _EAX : _R9 + (i)) -#define JIT_V_NUM 3 -#define JIT_V(i) ((i) == 0 ? _EBX : _R12 + (i)) - -struct jit_local_state { - int long_jumps; - int nextarg_getfp; - int nextarg_putfp; - int nextarg_geti; - int nextarg_puti; - int framesize; - int argssize; - int fprssize; - int alloca_offset; - int alloca_slack; - jit_insn *finish_ref; -}; - -/* Whether a register in the "low" bank is used for the user-accessible - registers. */ -#define jit_save(reg) ((reg) == _EAX || (reg) == _EBX) - -/* Keep the stack 16-byte aligned, the SSE hardware prefers it this way. */ -#define jit_allocai_internal(amount, slack) \ - (((amount) < _jitl.alloca_slack \ - ? 0 \ - : (_jitl.alloca_slack += (amount) + (slack), \ - SUBQir((amount) + (slack), _ESP))), \ - _jitl.alloca_slack -= (amount), \ - _jitl.alloca_offset -= (amount)) - -#define jit_allocai(n) \ - jit_allocai_internal ((n), (_jitl.alloca_slack - (n)) & 15) - -/* 3-parameter operation */ -#define jit_qopr_(d, s1, s2, op1d, op2d) \ - ( ((s2) == (d)) ? op1d : \ - ( (((s1) == (d)) ? (void)0 : (void)MOVQrr((s1), (d))), op2d ) \ - ) - -/* 3-parameter operation, with immediate. TODO: fix the case where mmediate - does not fit! */ -#define jit_qop_small(d, s1, op2d) \ - (((s1) == (d)) ? op2d : (MOVQrr((s1), (d)), op2d)) -#define jit_qop_(d, s1, is, op2d, op2i) \ - (_s32P((long)(is)) \ - ? jit_qop_small ((d), (s1), (op2d)) \ - : (MOVQir ((is), JIT_REXTMP), jit_qop_small ((d), (s1), (op2i)))) - -#define jit_bra_qr(s1, s2, op) (CMPQrr(s2, s1), op, _jit.x.pc) -#define _jit_bra_l(rs, is, op) (CMPQir(is, rs), op, _jit.x.pc) - -#define jit_bra_l(rs, is, op) (_s32P((long)(is)) \ - ? _jit_bra_l(rs, is, op) \ - : (MOVQir(is, JIT_REXTMP), jit_bra_qr(rs, JIT_REXTMP, op))) - -/* When CMP with 0 can be replaced with TEST */ -#define jit_bra_l0(rs, is, op, op0) \ - ( (is) == 0 ? (TESTQrr(rs, rs), op0, _jit.x.pc) : jit_bra_l(rs, is, op)) - -#define jit_reduceQ(op, is, rs) \ - (_u8P(is) ? jit_reduce_(op##Bir(is, jit_reg8(rs))) : \ - jit_reduce_(op##Qir(is, rs)) ) - -#define jit_addi_l(d, rs, is) \ - /* Value is not zero? */ \ - ((is) \ - /* Yes. Value is unsigned and fits in signed 32 bits? */ \ - ? (_uiP(31, is) \ - /* Yes. d == rs? */ \ - ? jit_opi_((d), (rs), \ - /* Yes. Use add opcode */ \ - ADDQir((is), (d)), \ - /* No. Use lea opcode */ \ - LEAQmr((is), (rs), 0, 0, (d))) \ - /* No. Need value in a register */ \ - : (jit_movi_l(JIT_REXTMP, is), \ - jit_addr_l(d, rs, JIT_REXTMP))) \ - : jit_opi_((d),(rs),0,jit_movr_l(d, rs))) -#define jit_addr_l(d, s1, s2) jit_opo_((d), (s1), (s2), ADDQrr((s2), (d)), ADDQrr((s1), (d)), LEAQmr(0, (s1), (s2), 1, (d)) ) -#define jit_addci_l(d, rs, is) jit_qop_ ((d), (rs), (is), ADCQir((is), (d)), ADCQrr(JIT_REXTMP, (d))) -#define jit_addcr_l(d, s1, s2) jit_qopr_((d), (s1), (s2), ADCQrr((s1), (d)), ADCQrr((s2), (d)) ) -#define jit_addxi_l(d, rs, is) jit_qop_ ((d), (rs), (is), ADDQir((is), (d)), ADDQrr(JIT_REXTMP, (d))) -#define jit_addxr_l(d, s1, s2) jit_qopr_((d), (s1), (s2), ADDQrr((s1), (d)), ADDQrr((s2), (d)) ) -#define jit_andi_l(d, rs, is) jit_qop_ ((d), (rs), (is), ANDQir((is), (d)), ANDQrr(JIT_REXTMP, (d))) -#define jit_andr_l(d, s1, s2) jit_qopr_((d), (s1), (s2), ANDQrr((s1), (d)), ANDQrr((s2), (d)) ) -#define jit_orr_l(d, s1, s2) jit_qopr_((d), (s1), (s2), ORQrr((s1), (d)), ORQrr((s2), (d)) ) -#define jit_subr_l(d, s1, s2) jit_qopr_((d), (s1), (s2), (SUBQrr((s1), (d)), NEGQr(d)), SUBQrr((s2), (d)) ) -#define jit_xorr_l(d, s1, s2) jit_qopr_((d), (s1), (s2), XORQrr((s1), (d)), XORQrr((s2), (d)) ) - -/* These can sometimes use byte or word versions! */ -#define jit_ori_l(d, rs, is) jit_qop_ ((d), (rs), (is), jit_reduceQ(OR, (is), (d)), ORQrr(JIT_REXTMP, (d)) ) -#define jit_xori_l(d, rs, is) jit_qop_ ((d), (rs), (is), jit_reduceQ(XOR, (is), (d)), XORQrr(JIT_REXTMP, (d)) ) - -#define jit_lshi_l(d, rs, is) ((is) <= 3 ? LEAQmr(0, 0, (rs), 1 << (is), (d)) : jit_qop_small ((d), (rs), SHLQir((is), (d)) )) -#define jit_rshi_l(d, rs, is) jit_qop_small ((d), (rs), SARQir((is), (d)) ) -#define jit_rshi_ul(d, rs, is) jit_qop_small ((d), (rs), SHRQir((is), (d)) ) -#define jit_lshr_l(d, r1, r2) jit_shift((d), (r1), (r2), SHLQrr) -#define jit_rshr_l(d, r1, r2) jit_shift((d), (r1), (r2), SARQrr) -#define jit_rshr_ul(d, r1, r2) jit_shift((d), (r1), (r2), SHRQrr) - - -/* Stack */ -#define jit_pushr_i(rs) PUSHQr(rs) -#define jit_popr_i(rs) POPQr(rs) - -/* A return address is 8 bytes, plus 5 registers = 40 bytes, total = 48 bytes. */ -#define jit_prolog(n) (_jitl.framesize = ((n) & 1) ? 56 : 48, _jitl.nextarg_getfp = _jitl.nextarg_geti = 0, _jitl.alloca_offset = 0, \ - PUSHQr(_EBX), PUSHQr(_R12), PUSHQr(_R13), PUSHQr(_R14), PUSHQr(_EBP), MOVQrr(_ESP, _EBP)) - -#define jit_calli(sub) (MOVQir((long) (sub), JIT_REXTMP), _jitl.finish_ref = _jit.x.pc, CALLsr(JIT_REXTMP), _jitl.finish_ref) -#define jit_callr(reg) CALLsr((reg)) - -#define jit_prepare_i(ni) (_jitl.nextarg_puti = (ni), \ - _jitl.argssize = _jitl.nextarg_puti > JIT_ARG_MAX \ - ? _jitl.nextarg_puti - JIT_ARG_MAX : 0) -#define jit_pusharg_i(rs) (--_jitl.nextarg_puti >= JIT_ARG_MAX \ - ? PUSHQr(rs) : MOVQrr(rs, jit_arg_reg_order[_jitl.nextarg_puti])) - -#define jit_finish(sub) (_jitl.fprssize \ - ? (MOVBir(_jitl.fprssize, _AL), _jitl.fprssize = 0) \ - : MOVBir(0, _AL), \ - ((_jitl.argssize & 1) \ - ? (PUSHQr(_EAX), ++_jitl.argssize) : 0), \ - jit_calli(sub), \ - (_jitl.argssize \ - ? (ADDQir(sizeof(long) * _jitl.argssize, JIT_SP), _jitl.argssize = 0) \ - : 0), \ - _jitl.finish_ref) -#define jit_reg_is_arg(reg) ((reg) == _ECX || (reg) == _EDX) - -#define jit_finishr(reg) (_jitl.fprssize \ - ? (MOVBir(_jitl.fprssize, _AL), _jitl.fprssize = 0) \ - : MOVBir(0, _AL), \ - ((_jitl.argssize & 1) \ - ? (PUSHQr(_EAX), ++_jitl.argssize) : 0), \ - (jit_reg_is_arg((reg)) \ - ? (MOVQrr(reg, JIT_REXTMP), \ - jit_callr(JIT_REXTMP)) \ - : jit_callr(reg)), \ - (_jitl.argssize \ - ? (ADDQir(sizeof(long) * _jitl.argssize, JIT_SP), _jitl.argssize = 0) \ - : 0)) - -#define jit_retval_l(rd) ((void)jit_movr_l ((rd), _EAX)) -#define jit_arg_i() (_jitl.nextarg_geti < JIT_ARG_MAX \ - ? _jitl.nextarg_geti++ \ - : (int) ((_jitl.framesize += sizeof(long)) - sizeof(long))) -#define jit_arg_c() jit_arg_i() -#define jit_arg_uc() jit_arg_i() -#define jit_arg_s() jit_arg_i() -#define jit_arg_us() jit_arg_i() -#define jit_arg_ui() jit_arg_i() -#define jit_arg_l() jit_arg_i() -#define jit_arg_ul() jit_arg_i() -#define jit_arg_p() jit_arg_i() - -#define jit_getarg_c(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_extr_c_l((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_c((reg), JIT_FP, (ofs))) -#define jit_getarg_uc(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_extr_uc_ul((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_uc((reg), JIT_FP, (ofs))) -#define jit_getarg_s(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_extr_s_l((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_s((reg), JIT_FP, (ofs))) -#define jit_getarg_us(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_extr_us_ul((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_us((reg), JIT_FP, (ofs))) -#define jit_getarg_i(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_movr_l((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_i((reg), JIT_FP, (ofs))) -#define jit_getarg_ui(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_movr_ul((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_ui((reg), JIT_FP, (ofs))) -#define jit_getarg_l(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_movr_l((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_l((reg), JIT_FP, (ofs))) -#define jit_getarg_ul(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_movr_ul((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_ul((reg), JIT_FP, ofs)) -#define jit_getarg_p(reg, ofs) ((ofs) < JIT_ARG_MAX \ - ? jit_movr_p((reg), jit_arg_reg_order[(ofs)]) \ - : jit_ldxi_p((reg), JIT_FP, (ofs))) - -static int jit_arg_reg_order[] = { _EDI, _ESI, _EDX, _ECX, _R8D, _R9D }; - -#define jit_negr_l(d, rs) jit_opi_((d), (rs), NEGQr(d), (XORQrr((d), (d)), SUBQrr((rs), (d))) ) -#define jit_movr_l(d, rs) ((void)((rs) == (d) ? 0 : MOVQrr((rs), (d)))) -#define jit_movi_p(d, is) (MOVQir(((long)(is)), (d)), _jit.x.pc) -#define jit_movi_l(d, is) \ - /* Value is not zero? */ \ - ((is) \ - /* Yes. Value is unsigned and fits in signed 32 bits? */ \ - ? (_uiP(31, is) \ - /* Yes. Use 32 bits opcode */ \ - ? MOVLir(is, (d)) \ - /* No. Use 64 bits opcode */ \ - : MOVQir(is, (d))) \ - /* No. Set register to zero. */ \ - : XORQrr ((d), (d))) - -#define jit_bmsr_l(label, s1, s2) (TESTQrr((s1), (s2)), JNZm(label), _jit.x.pc) -#define jit_bmcr_l(label, s1, s2) (TESTQrr((s1), (s2)), JZm(label), _jit.x.pc) -#define jit_boaddr_l(label, s1, s2) (ADDQrr((s2), (s1)), JOm(label), _jit.x.pc) -#define jit_bosubr_l(label, s1, s2) (SUBQrr((s2), (s1)), JOm(label), _jit.x.pc) -#define jit_boaddr_ul(label, s1, s2) (ADDQrr((s2), (s1)), JCm(label), _jit.x.pc) -#define jit_bosubr_ul(label, s1, s2) (SUBQrr((s2), (s1)), JCm(label), _jit.x.pc) - -#define jit_boaddi_l(label, rs, is) (ADDQir((is), (rs)), JOm(label), _jit.x.pc) -#define jit_bosubi_l(label, rs, is) (SUBQir((is), (rs)), JOm(label), _jit.x.pc) -#define jit_boaddi_ul(label, rs, is) (ADDQir((is), (rs)), JCm(label), _jit.x.pc) -#define jit_bosubi_ul(label, rs, is) (SUBQir((is), (rs)), JCm(label), _jit.x.pc) - -#define jit_patch_long_at(jump_pc,v) (*_PSL((jump_pc) - sizeof(long)) = _jit_SL((jit_insn *)(v))) -#define jit_patch_short_at(jump_pc,v) (*_PSI((jump_pc) - sizeof(int)) = _jit_SI((jit_insn *)(v) - (jump_pc))) -#define jit_patch_at(jump_pc,v) (_jitl.long_jumps ? jit_patch_long_at((jump_pc)-3, v) : jit_patch_short_at(jump_pc, v)) -#define jit_patch_calli(pa,pv) (*_PSL((pa) - sizeof(long)) = _jit_SL((pv))) -#define jit_ret() (LEAVE_(), POPQr(_R14), POPQr(_R13), POPQr(_R12), POPQr(_EBX), RET_()) -#define jit_bare_ret() RET_() - -/* Memory */ - -/* Used to implement ldc, stc, ... We have SIL and friends which simplify it all. */ -#define jit_movbrm(rs, dd, db, di, ds) MOVBrm(jit_reg8(rs), dd, db, di, ds) - -#define jit_ldr_c(d, rs) MOVSBQmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_c(d, s1, s2) MOVSBQmr(0, (s1), (s2), 1, (d)) - -#define jit_ldr_s(d, rs) MOVSWQmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_s(d, s1, s2) MOVSWQmr(0, (s1), (s2), 1, (d)) - -#define jit_ldi_c(d, is) (_u32P((long)(is)) ? MOVSBQmr((is), 0, 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldr_c(d, JIT_REXTMP))) -#define jit_ldxi_c(d, rs, is) (_u32P((long)(is)) ? MOVSBQmr((is), (rs), 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldxr_c(d, rs, JIT_REXTMP))) - -#define jit_ldi_uc(d, is) (_u32P((long)(is)) ? MOVZBLmr((is), 0, 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldr_uc(d, JIT_REXTMP))) -#define jit_ldxi_uc(d, rs, is) (_u32P((long)(is)) ? MOVZBLmr((is), (rs), 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldxr_uc(d, rs, JIT_REXTMP))) - -#define jit_sti_c(id, rs) (_u32P((long)(id)) ? MOVBrm(jit_reg8(rs), (id), 0, 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_str_c(JIT_REXTMP, rs))) -#define jit_stxi_c(id, rd, rs) (_u32P((long)(id)) ? MOVBrm(jit_reg8(rs), (id), (rd), 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_stxr_c(JIT_REXTMP, rd, rs))) - -#define jit_ldi_s(d, is) (_u32P((long)(is)) ? MOVSWQmr((is), 0, 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldr_s(d, JIT_REXTMP))) -#define jit_ldxi_s(d, rs, is) (_u32P((long)(is)) ? MOVSWQmr((is), (rs), 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldxr_s(d, rs, JIT_REXTMP))) - -#define jit_ldi_us(d, is) (_u32P((long)(is)) ? MOVZWLmr((is), 0, 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldr_us(d, JIT_REXTMP))) -#define jit_ldxi_us(d, rs, is) (_u32P((long)(is)) ? MOVZWLmr((is), (rs), 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldxr_us(d, rs, JIT_REXTMP))) - -#define jit_sti_s(id, rs) (_u32P((long)(id)) ? MOVWrm(jit_reg16(rs), (id), 0, 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_str_s(JIT_REXTMP, rs))) -#define jit_stxi_s(id, rd, rs) (_u32P((long)(id)) ? MOVWrm(jit_reg16(rs), (id), (rd), 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_stxr_s(JIT_REXTMP, rd, rs))) - -#define jit_ldi_ui(d, is) (_u32P((long)(is)) ? MOVLmr((is), 0, 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldr_ui(d, JIT_REXTMP))) -#define jit_ldxi_ui(d, rs, is) (_u32P((long)(is)) ? MOVLmr((is), (rs), 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldxr_ui(d, rs, JIT_REXTMP))) - -#define jit_ldi_i(d, is) (_u32P((long)(is)) ? MOVSLQmr((is), 0, 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldr_i(d, JIT_REXTMP))) -#define jit_ldxi_i(d, rs, is) (_u32P((long)(is)) ? MOVSLQmr((is), (rs), 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldxr_i(d, rs, JIT_REXTMP))) - -#define jit_sti_i(id, rs) (_u32P((long)(id)) ? MOVLrm((rs), (id), 0, 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_str_i(JIT_REXTMP, rs))) -#define jit_stxi_i(id, rd, rs) (_u32P((long)(id)) ? MOVLrm((rs), (id), (rd), 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_stxr_i(JIT_REXTMP, rd, rs))) - -#define jit_ldi_l(d, is) (_u32P((long)(is)) ? MOVQmr((is), 0, 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldr_l(d, JIT_REXTMP))) -#define jit_ldxi_l(d, rs, is) (_u32P((long)(is)) ? MOVQmr((is), (rs), 0, 0, (d)) : (jit_movi_l(JIT_REXTMP, is), jit_ldxr_l(d, rs, JIT_REXTMP))) - -#define jit_sti_l(id, rs) (_u32P((long)(id)) ? MOVQrm((rs), (id), 0, 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_str_l(JIT_REXTMP, rs))) -#define jit_stxi_l(id, rd, rs) (_u32P((long)(id)) ? MOVQrm((rs), (id), (rd), 0, 0) : (jit_movi_l(JIT_REXTMP, id), jit_stxr_l(JIT_REXTMP, rd, rs))) - -#define jit_ldr_ui(d, rs) MOVLmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_ui(d, s1, s2) MOVLmr(0, (s1), (s2), 1, (d)) - -#define jit_ldr_i(d, rs) MOVSLQmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_i(d, s1, s2) MOVSLQmr(0, (s1), (s2), 1, (d)) - -#define jit_ldr_l(d, rs) MOVQmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_l(d, s1, s2) MOVQmr(0, (s1), (s2), 1, (d)) - -#define jit_str_l(rd, rs) MOVQrm((rs), 0, (rd), 0, 0) -#define jit_stxr_l(d1, d2, rs) MOVQrm((rs), 0, (d1), (d2), 1) - -#define jit_blti_l(label, rs, is) jit_bra_l0((rs), (is), JLm(label), JSm(label) ) -#define jit_blei_l(label, rs, is) jit_bra_l ((rs), (is), JLEm(label) ) -#define jit_bgti_l(label, rs, is) jit_bra_l ((rs), (is), JGm(label) ) -#define jit_bgei_l(label, rs, is) jit_bra_l0((rs), (is), JGEm(label), JNSm(label) ) -#define jit_beqi_l(label, rs, is) jit_bra_l0((rs), (is), JEm(label), JEm(label) ) -#define jit_bnei_l(label, rs, is) jit_bra_l0((rs), (is), JNEm(label), JNEm(label) ) -#define jit_blti_ul(label, rs, is) jit_bra_l ((rs), (is), JBm(label) ) -#define jit_blei_ul(label, rs, is) jit_bra_l0((rs), (is), JBEm(label), JEm(label) ) -#define jit_bgti_ul(label, rs, is) jit_bra_l0((rs), (is), JAm(label), JNEm(label) ) -#define jit_bgei_ul(label, rs, is) jit_bra_l ((rs), (is), JAEm(label) ) -#define jit_bmsi_l(label, rs, is) (jit_reduceQ(TEST, (is), (rs)), JNZm(label), _jit.x.pc) -#define jit_bmci_l(label, rs, is) (jit_reduceQ(TEST, (is), (rs)), JZm(label), _jit.x.pc) - -#define jit_pushr_l(rs) jit_pushr_i(rs) -#define jit_popr_l(rs) jit_popr_i(rs) - -#define jit_pusharg_l(rs) jit_pusharg_i(rs) -#define jit_retval_l(rd) ((void)jit_movr_l ((rd), _EAX)) -#define jit_bltr_l(label, s1, s2) jit_bra_qr((s1), (s2), JLm(label) ) -#define jit_bler_l(label, s1, s2) jit_bra_qr((s1), (s2), JLEm(label) ) -#define jit_bgtr_l(label, s1, s2) jit_bra_qr((s1), (s2), JGm(label) ) -#define jit_bger_l(label, s1, s2) jit_bra_qr((s1), (s2), JGEm(label) ) -#define jit_beqr_l(label, s1, s2) jit_bra_qr((s1), (s2), JEm(label) ) -#define jit_bner_l(label, s1, s2) jit_bra_qr((s1), (s2), JNEm(label) ) -#define jit_bltr_ul(label, s1, s2) jit_bra_qr((s1), (s2), JBm(label) ) -#define jit_bler_ul(label, s1, s2) jit_bra_qr((s1), (s2), JBEm(label) ) -#define jit_bgtr_ul(label, s1, s2) jit_bra_qr((s1), (s2), JAm(label) ) -#define jit_bger_ul(label, s1, s2) jit_bra_qr((s1), (s2), JAEm(label) ) - -/* Bool operations. */ -#define jit_bool_qr(d, s1, s2, op) \ - (jit_replace8(d, CMPQrr(s2, s1), op)) - -#define jit_bool_qi(d, rs, is, op) \ - (jit_replace8(d, CMPQir(is, rs), op)) - -/* When CMP with 0 can be replaced with TEST */ -#define jit_bool_qi0(d, rs, is, op, op0) \ - ((is) != 0 \ - ? (jit_replace8(d, CMPQir(is, rs), op)) \ - : (jit_replace8(d, TESTQrr(rs, rs), op0))) - -#define jit_ltr_l(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETLr ) -#define jit_ler_l(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETLEr ) -#define jit_gtr_l(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETGr ) -#define jit_ger_l(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETGEr ) -#define jit_eqr_l(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETEr ) -#define jit_ner_l(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETNEr ) -#define jit_ltr_ul(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETBr ) -#define jit_ler_ul(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETBEr ) -#define jit_gtr_ul(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETAr ) -#define jit_ger_ul(d, s1, s2) jit_bool_qr((d), (s1), (s2), SETAEr ) - -#define jit_lti_l(d, rs, is) jit_bool_qi0((d), (rs), (is), SETLr, SETSr ) -#define jit_lei_l(d, rs, is) jit_bool_qi ((d), (rs), (is), SETLEr ) -#define jit_gti_l(d, rs, is) jit_bool_qi ((d), (rs), (is), SETGr ) -#define jit_gei_l(d, rs, is) jit_bool_qi0((d), (rs), (is), SETGEr, SETNSr ) -#define jit_eqi_l(d, rs, is) jit_bool_qi0((d), (rs), (is), SETEr, SETEr ) -#define jit_nei_l(d, rs, is) jit_bool_qi0((d), (rs), (is), SETNEr, SETNEr ) -#define jit_lti_ul(d, rs, is) jit_bool_qi ((d), (rs), (is), SETBr ) -#define jit_lei_ul(d, rs, is) jit_bool_qi0((d), (rs), (is), SETBEr, SETEr ) -#define jit_gti_ul(d, rs, is) jit_bool_qi0((d), (rs), (is), SETAr, SETNEr ) -#define jit_gei_ul(d, rs, is) jit_bool_qi0((d), (rs), (is), SETAEr, INCLr ) - -/* Multiplication/division. */ -#define jit_mulr_ul_(s1, s2) \ - jit_qopr_(_RAX, s1, s2, MULQr(s1), MULQr(s2)) - -#define jit_mulr_l_(s1, s2) \ - jit_qopr_(_RAX, s1, s2, IMULQr(s1), IMULQr(s2)) - -#define jit_muli_l_(is, rs) \ - (MOVQir(is, rs == _RAX ? _RDX : _RAX), \ - IMULQr(rs == _RAX ? _RDX : rs)) - -#define jit_muli_ul_(is, rs) \ - (MOVQir(is, rs == _RAX ? _RDX : _RAX), \ - IMULQr(rs == _RAX ? _RDX : rs)) - -#define jit_divi_l_(result, d, rs, is) \ - (jit_might (d, _RAX, jit_pushr_l(_RAX)), \ - jit_might (d, _RCX, jit_pushr_l(_RCX)), \ - jit_might (d, _RDX, jit_pushr_l(_RDX)), \ - jit_might (rs, _RAX, MOVQrr(rs, _RAX)), \ - jit_might (rs, _RDX, MOVQrr(rs, _RDX)), \ - MOVQir(is, _RCX), \ - SARQir(63, _RDX), \ - IDIVQr(_RCX), \ - jit_might(d, result, MOVQrr(result, d)), \ - jit_might(d, _RDX, jit_popr_l(_RDX)), \ - jit_might(d, _RCX, jit_popr_l(_RCX)), \ - jit_might(d, _RAX, jit_popr_l(_RAX))) - -#define jit_divr_l_(result, d, s1, s2) \ - (jit_might (d, _RAX, jit_pushr_l(_RAX)), \ - jit_might (d, _RCX, jit_pushr_l(_RCX)), \ - jit_might (d, _RDX, jit_pushr_l(_RDX)), \ - ((s1 == _RCX) ? jit_pushr_l(_RCX) : 0), \ - jit_might (s2, _RCX, MOVQrr(s2, _RCX)), \ - ((s1 == _RCX) ? jit_popr_l(_RDX) : \ - jit_might (s1, _RDX, MOVQrr(s1, _RDX))), \ - MOVQrr(_RDX, _RAX), \ - SARQir(63, _RDX), \ - IDIVQr(_RCX), \ - jit_might(d, result, MOVQrr(result, d)), \ - jit_might(d, _RDX, jit_popr_l(_RDX)), \ - jit_might(d, _RCX, jit_popr_l(_RCX)), \ - jit_might(d, _RAX, jit_popr_l(_RAX))) - -#define jit_divi_ul_(result, d, rs, is) \ - (jit_might (d, _RAX, jit_pushr_l(_RAX)), \ - jit_might (d, _RCX, jit_pushr_l(_RCX)), \ - jit_might (d, _RDX, jit_pushr_l(_RDX)), \ - jit_might (rs, _RAX, MOVQrr(rs, _RAX)), \ - MOVQir(is, _RCX), \ - XORQrr(_RDX, _RDX), \ - DIVQr(_RCX), \ - jit_might(d, result, MOVQrr(result, d)), \ - jit_might(d, _RDX, jit_popr_l(_RDX)), \ - jit_might(d, _RCX, jit_popr_l(_RCX)), \ - jit_might(d, _RAX, jit_popr_l(_RAX))) - -#define jit_divr_ul_(result, d, s1, s2) \ - (jit_might (d, _RAX, jit_pushr_l(_RAX)), \ - jit_might (d, _RCX, jit_pushr_l(_RCX)), \ - jit_might (d, _RDX, jit_pushr_l(_RDX)), \ - ((s1 == _RCX) ? jit_pushr_l(_RCX) : 0), \ - jit_might (s2, _RCX, MOVQrr(s2, _RCX)), \ - ((s1 == _RCX) ? jit_popr_l(_RAX) : \ - jit_might (s1, _RAX, MOVQrr(s1, _RAX))), \ - XORQrr(_RDX, _RDX), \ - DIVQr(_RCX), \ - jit_might(d, result, MOVQrr(result, d)), \ - jit_might(d, _RDX, jit_popr_l(_RDX)), \ - jit_might(d, _RCX, jit_popr_l(_RCX)), \ - jit_might(d, _RAX, jit_popr_l(_RAX))) - -#define jit_muli_l(d, rs, is) jit_qop_ ((d), (rs), (is), IMULQir((is), (d)), IMULQrr(JIT_REXTMP, (d)) ) -#define jit_mulr_l(d, s1, s2) jit_qopr_((d), (s1), (s2), IMULQrr((s1), (d)), IMULQrr((s2), (d)) ) - -/* As far as low bits are concerned, signed and unsigned multiplies are - exactly the same. */ -#define jit_muli_ul(d, rs, is) jit_qop_ ((d), (rs), (is), IMULQir((is), (d)), IMULQrr(JIT_REXTMP, (d)) ) -#define jit_mulr_ul(d, s1, s2) jit_qopr_((d), (s1), (s2), IMULQrr((s1), (d)), IMULQrr((s2), (d)) ) - -#define jit_hmuli_l(d, rs, is) \ - ((d) == _RDX ? ( jit_pushr_l(_RAX), jit_muli_l_((is), (rs)), jit_popr_l(_RAX) ) : \ - ((d) == _RAX ? (jit_pushr_l(_RDX), jit_muli_l_((is), (rs)), MOVQrr(_RDX, _RAX), jit_popr_l(_RDX) ) : \ - (jit_pushr_l(_RDX), jit_pushr_l(_RAX), jit_muli_l_((is), (rs)), MOVQrr(_RDX, (d)), jit_popr_l(_RAX), jit_popr_l(_RDX) ))) - -#define jit_hmulr_l(d, s1, s2) \ - ((d) == _RDX ? ( jit_pushr_l(_RAX), jit_mulr_l_((s1), (s2)), jit_popr_l(_RAX) ) : \ - ((d) == _RAX ? (jit_pushr_l(_RDX), jit_mulr_l_((s1), (s2)), MOVQrr(_RDX, _RAX), jit_popr_l(_RDX) ) : \ - (jit_pushr_l(_RDX), jit_pushr_l(_RAX), jit_mulr_l_((s1), (s2)), MOVQrr(_RDX, (d)), jit_popr_l(_RAX), jit_popr_l(_RDX) ))) - -#define jit_hmuli_ul(d, rs, is) \ - ((d) == _RDX ? ( jit_pushr_l(_RAX), jit_muli_ul_((is), (rs)), jit_popr_l(_RAX) ) : \ - ((d) == _RAX ? (jit_pushr_l(_RDX), jit_muli_ul_((is), (rs)), MOVQrr(_RDX, _RAX), jit_popr_l(_RDX) ) : \ - (jit_pushr_l(_RDX), jit_pushr_l(_RAX), jit_muli_ul_((is), (rs)), MOVQrr(_RDX, (d)), jit_popr_l(_RAX), jit_popr_l(_RDX) ))) - -#define jit_hmulr_ul(d, s1, s2) \ - ((d) == _RDX ? ( jit_pushr_l(_RAX), jit_mulr_ul_((s1), (s2)), jit_popr_l(_RAX) ) : \ - ((d) == _RAX ? (jit_pushr_l(_RDX), jit_mulr_ul_((s1), (s2)), MOVQrr(_RDX, _RAX), jit_popr_l(_RDX) ) : \ - (jit_pushr_l(_RDX), jit_pushr_l(_RAX), jit_mulr_ul_((s1), (s2)), MOVQrr(_RDX, (d)), jit_popr_l(_RAX), jit_popr_l(_RDX) ))) - -#define jit_divi_l(d, rs, is) jit_divi_l_(_RAX, (d), (rs), (is)) -#define jit_divi_ul(d, rs, is) jit_divi_ul_(_RAX, (d), (rs), (is)) -#define jit_modi_l(d, rs, is) jit_divi_l_(_RDX, (d), (rs), (is)) -#define jit_modi_ul(d, rs, is) jit_divi_ul_(_RDX, (d), (rs), (is)) -#define jit_divr_l(d, s1, s2) jit_divr_l_(_RAX, (d), (s1), (s2)) -#define jit_divr_ul(d, s1, s2) jit_divr_ul_(_RAX, (d), (s1), (s2)) -#define jit_modr_l(d, s1, s2) jit_divr_l_(_RDX, (d), (s1), (s2)) -#define jit_modr_ul(d, s1, s2) jit_divr_ul_(_RDX, (d), (s1), (s2)) - -#endif /* __lightning_core_h */ diff --git a/src/runtime/c/pgf/lightning/i386/core.h b/src/runtime/c/pgf/lightning/i386/core.h deleted file mode 100644 index e6eb7c8a8..000000000 --- a/src/runtime/c/pgf/lightning/i386/core.h +++ /dev/null @@ -1,366 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer (i386 version) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2003, 2006 Free Software Foundation, Inc. - * Written by Paolo Bonzini and Matthew Flatt. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_core_i386_h -#define __lightning_core_i386_h - -#define JIT_FP _EBP -#define JIT_SP _ESP -#define JIT_RET _EAX - - -/* 3-parameter operation */ -#define jit_opr_(d, s1, s2, op1d, op2d) \ - ( (s2 == d) ? op1d : \ - ( ((s1 == d) ? (void)0 : (void)MOVLrr(s1, d)), op2d ) \ - ) - -/* 3-parameter operation, with immediate */ -#define jit_op_(d, s1, op2d) \ - ((s1 == d) ? op2d : (MOVLrr(s1, d), op2d)) - -/* 3-parameter operation, optimizable */ -#define jit_opo_(d, s1, s2, op1d, op2d, op12d) \ - ((s2 == d) ? op2d : \ - ((s1 == d) ? op1d : op12d)) - -/* 3-parameter operation, optimizable, with immediate */ -#define jit_opi_(d, rs, opdi, opdri) \ - ((rs == d) ? opdi : opdri) - -/* For LT, LE, ... */ -#define jit_replace8(d, cmp, op) \ - (jit_check8(d) \ - ? ((cmp), \ - MOVLir(0, (d)), \ - op(_rR(d) | _AL)) \ - : (jit_pushr_i(_EAX), (cmp), \ - MOVLir(0, _EAX), \ - op(_AL), MOVLrr(_EAX, (d)), jit_popr_i(_EAX))) - -#define jit_bool_r(d, s1, s2, op) \ - (jit_replace8(d, CMPLrr(s2, s1), op)) - -#define jit_bool_i(d, rs, is, op) \ - (jit_replace8(d, CMPLir(is, rs), op)) - -/* When CMP with 0 can be replaced with TEST */ -#define jit_bool_i0(d, rs, is, op, op0) \ - ((is) != 0 \ - ? (jit_replace8(d, CMPLir(is, rs), op)) \ - : (jit_replace8(d, TESTLrr(rs, rs), op0))) - -/* For BLT, BLE, ... */ -#define jit_bra_r(s1, s2, op) (CMPLrr(s2, s1), op, _jit.x.pc) -#define jit_bra_i(rs, is, op) (CMPLir(is, rs), op, _jit.x.pc) - -/* When CMP with 0 can be replaced with TEST */ -#define jit_bra_i0(rs, is, op, op0) \ - ( (is) == 0 ? (TESTLrr(rs, rs), op0, _jit.x.pc) : (CMPLir(is, rs), op, _jit.x.pc)) - -/* Reduce arguments of XOR/OR/TEST */ -#define jit_reduce_(op) op -#define jit_reduce(op, is, rs) \ - (_u8P(is) && jit_check8(rs) ? jit_reduce_(op##Bir(is, jit_reg8(rs))) : \ - (_u16P(is) && JIT_CAN_16 ? jit_reduce_(op##Wir(is, jit_reg16(rs))) : \ - jit_reduce_(op##Lir(is, rs)) )) - -/* Helper macros for MUL/DIV/IDIV */ -#define jit_might(d, s1, op) \ - ((s1 == d) ? 0 : op) - -#define jit_mulr_ui_(s1, s2) jit_opr_(_EAX, s1, s2, MULLr(s1), MULLr(s2)) -#define jit_mulr_i_(s1, s2) jit_opr_(_EAX, s1, s2, IMULLr(s1), IMULLr(s2)) - - -#define jit_muli_i_(is, rs) \ - (MOVLir(is, rs == _EAX ? _EDX : _EAX), \ - IMULLr(rs == _EAX ? _EDX : rs)) - -#define jit_muli_ui_(is, rs) \ - (MOVLir(is, rs == _EAX ? _EDX : _EAX), \ - IMULLr(rs == _EAX ? _EDX : rs)) - -#define jit_divi_i_(result, d, rs, is) \ - (jit_might (d, _EAX, jit_pushr_i(_EAX)), \ - jit_might (d, _ECX, jit_pushr_i(_ECX)), \ - jit_might (d, _EDX, jit_pushr_i(_EDX)), \ - jit_might (rs, _EAX, MOVLrr(rs, _EAX)), \ - jit_might (rs, _EDX, MOVLrr(rs, _EDX)), \ - MOVLir(is, _ECX), \ - SARLir(31, _EDX), \ - IDIVLr(_ECX), \ - jit_might(d, result, MOVLrr(result, d)), \ - jit_might(d, _EDX, jit_popr_i(_EDX)), \ - jit_might(d, _ECX, jit_popr_i(_ECX)), \ - jit_might(d, _EAX, jit_popr_i(_EAX))) - -#define jit_divr_i_(result, d, s1, s2) \ - (jit_might (d, _EAX, jit_pushr_i(_EAX)), \ - jit_might (d, _ECX, jit_pushr_i(_ECX)), \ - jit_might (d, _EDX, jit_pushr_i(_EDX)), \ - ((s1 == _ECX) ? jit_pushr_i(_ECX) : 0), \ - jit_might (s2, _ECX, MOVLrr(s2, _ECX)), \ - ((s1 == _ECX) ? jit_popr_i(_EDX) : \ - jit_might (s1, _EDX, MOVLrr(s1, _EDX))), \ - MOVLrr(_EDX, _EAX), \ - SARLir(31, _EDX), \ - IDIVLr(_ECX), \ - jit_might(d, result, MOVLrr(result, d)), \ - jit_might(d, _EDX, jit_popr_i(_EDX)), \ - jit_might(d, _ECX, jit_popr_i(_ECX)), \ - jit_might(d, _EAX, jit_popr_i(_EAX))) - -#define jit_divi_ui_(result, d, rs, is) \ - (jit_might (d, _EAX, jit_pushr_i(_EAX)), \ - jit_might (d, _ECX, jit_pushr_i(_ECX)), \ - jit_might (d, _EDX, jit_pushr_i(_EDX)), \ - jit_might (rs, _EAX, MOVLrr(rs, _EAX)), \ - MOVLir(is, _ECX), \ - XORLrr(_EDX, _EDX), \ - DIVLr(_ECX), \ - jit_might(d, result, MOVLrr(result, d)), \ - jit_might(d, _EDX, jit_popr_i(_EDX)), \ - jit_might(d, _ECX, jit_popr_i(_ECX)), \ - jit_might(d, _EAX, jit_popr_i(_EAX))) - -#define jit_divr_ui_(result, d, s1, s2) \ - (jit_might (d, _EAX, jit_pushr_i(_EAX)), \ - jit_might (d, _ECX, jit_pushr_i(_ECX)), \ - jit_might (d, _EDX, jit_pushr_i(_EDX)), \ - ((s1 == _ECX) ? jit_pushr_i(_ECX) : 0), \ - jit_might (s2, _ECX, MOVLrr(s2, _ECX)), \ - ((s1 == _ECX) ? jit_popr_i(_EAX) : \ - jit_might (s1, _EAX, MOVLrr(s1, _EAX))), \ - XORLrr(_EDX, _EDX), \ - DIVLr(_ECX), \ - jit_might(d, result, MOVLrr(result, d)), \ - jit_might(d, _EDX, jit_popr_i(_EDX)), \ - jit_might(d, _ECX, jit_popr_i(_ECX)), \ - jit_might(d, _EAX, jit_popr_i(_EAX))) - - -/* ALU */ -#define jit_addi_i(d, rs, is) jit_opi_((d), (rs), ADDLir((is), (d)), LEALmr((is), (rs), 0, 0, (d)) ) -#define jit_addr_i(d, s1, s2) jit_opo_((d), (s1), (s2), ADDLrr((s2), (d)), ADDLrr((s1), (d)), LEALmr(0, (s1), (s2), 1, (d)) ) -#define jit_addci_i(d, rs, is) jit_op_ ((d), (rs), ADDLir((is), (d)) ) -#define jit_addcr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ADDLrr((s1), (d)), ADDLrr((s2), (d)) ) -#define jit_addxi_i(d, rs, is) jit_op_ ((d), (rs), ADCLir((is), (d)) ) -#define jit_addxr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ADCLrr((s1), (d)), ADCLrr((s2), (d)) ) -#define jit_andi_i(d, rs, is) jit_op_ ((d), (rs), ANDLir((is), (d)) ) -#define jit_andr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ANDLrr((s1), (d)), ANDLrr((s2), (d)) ) -#define jit_orr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ORLrr((s1), (d)), ORLrr((s2), (d)) ) -#define jit_subr_i(d, s1, s2) jit_opr_((d), (s1), (s2), (SUBLrr((s1), (d)), NEGLr(d)), SUBLrr((s2), (d)) ) -#define jit_subcr_i(d, s1, s2) jit_subr_i((d), (s1), (s2)) -#define jit_subxr_i(d, s1, s2) jit_opr_((d), (s1), (s2), SBBLrr((s1), (d)), SBBLrr((s2), (d)) ) -#define jit_subxi_i(d, rs, is) jit_op_ ((d), (rs), SBBLir((is), (d)) ) -#define jit_xorr_i(d, s1, s2) jit_opr_((d), (s1), (s2), XORLrr((s1), (d)), XORLrr((s2), (d)) ) - - -/* These can sometimes use byte or word versions! */ -#define jit_ori_i(d, rs, is) jit_op_ ((d), (rs), jit_reduce(OR, (is), (d)) ) -#define jit_xori_i(d, rs, is) jit_op_ ((d), (rs), jit_reduce(XOR, (is), (d)) ) - -#define jit_muli_i(d, rs, is) jit_op_ ((d), (rs), IMULLir((is), (d)) ) -#define jit_mulr_i(d, s1, s2) jit_opr_((d), (s1), (s2), IMULLrr((s1), (d)), IMULLrr((s2), (d)) ) - -/* As far as low bits are concerned, signed and unsigned multiplies are - exactly the same. */ -#define jit_muli_ui(d, rs, is) jit_op_ ((d), (rs), IMULLir((is), (d)) ) -#define jit_mulr_ui(d, s1, s2) jit_opr_((d), (s1), (s2), IMULLrr((s1), (d)), IMULLrr((s2), (d)) ) - -#define jit_hmuli_i(d, rs, is) \ - ((d) == _EDX ? ( jit_pushr_i(_EAX), jit_muli_i_((is), (rs)), jit_popr_i(_EAX) ) : \ - ((d) == _EAX ? (jit_pushr_i(_EDX), jit_muli_i_((is), (rs)), MOVLrr(_EDX, _EAX), jit_popr_i(_EDX) ) : \ - (jit_pushr_i(_EDX), jit_pushr_i(_EAX), jit_muli_i_((is), (rs)), MOVLrr(_EDX, (d)), jit_popr_i(_EAX), jit_popr_i(_EDX) ))) - -#define jit_hmulr_i(d, s1, s2) \ - ((d) == _EDX ? ( jit_pushr_i(_EAX), jit_mulr_i_((s1), (s2)), jit_popr_i(_EAX) ) : \ - ((d) == _EAX ? (jit_pushr_i(_EDX), jit_mulr_i_((s1), (s2)), MOVLrr(_EDX, _EAX), jit_popr_i(_EDX) ) : \ - (jit_pushr_i(_EDX), jit_pushr_i(_EAX), jit_mulr_i_((s1), (s2)), MOVLrr(_EDX, (d)), jit_popr_i(_EAX), jit_popr_i(_EDX) ))) - -#define jit_hmuli_ui(d, rs, is) \ - ((d) == _EDX ? ( jit_pushr_i(_EAX), jit_muli_ui_((is), (rs)), jit_popr_i(_EAX) ) : \ - ((d) == _EAX ? (jit_pushr_i(_EDX), jit_muli_ui_((is), (rs)), MOVLrr(_EDX, _EAX), jit_popr_i(_EDX) ) : \ - (jit_pushr_i(_EDX), jit_pushr_i(_EAX), jit_muli_ui_((is), (rs)), MOVLrr(_EDX, (d)), jit_popr_i(_EAX), jit_popr_i(_EDX) ))) - -#define jit_hmulr_ui(d, s1, s2) \ - ((d) == _EDX ? ( jit_pushr_i(_EAX), jit_mulr_ui_((s1), (s2)), jit_popr_i(_EAX) ) : \ - ((d) == _EAX ? (jit_pushr_i(_EDX), jit_mulr_ui_((s1), (s2)), MOVLrr(_EDX, _EAX), jit_popr_i(_EDX) ) : \ - (jit_pushr_i(_EDX), jit_pushr_i(_EAX), jit_mulr_ui_((s1), (s2)), MOVLrr(_EDX, (d)), jit_popr_i(_EAX), jit_popr_i(_EDX) ))) - -#define jit_divi_i(d, rs, is) jit_divi_i_(_EAX, (d), (rs), (is)) -#define jit_divi_ui(d, rs, is) jit_divi_ui_(_EAX, (d), (rs), (is)) -#define jit_modi_i(d, rs, is) jit_divi_i_(_EDX, (d), (rs), (is)) -#define jit_modi_ui(d, rs, is) jit_divi_ui_(_EDX, (d), (rs), (is)) -#define jit_divr_i(d, s1, s2) jit_divr_i_(_EAX, (d), (s1), (s2)) -#define jit_divr_ui(d, s1, s2) jit_divr_ui_(_EAX, (d), (s1), (s2)) -#define jit_modr_i(d, s1, s2) jit_divr_i_(_EDX, (d), (s1), (s2)) -#define jit_modr_ui(d, s1, s2) jit_divr_ui_(_EDX, (d), (s1), (s2)) - - -/* Shifts */ -#define jit_shift(d, s1, s2, m) \ - ((d) == _ECX || (d) == (s2) \ - ? ((s2) == _EAX \ - ? jit_fixd(d, _EDX, jit_shift2(_EDX, s1, s2, m)) \ - : jit_fixd(d, _EAX, jit_shift2(_EAX, s1, s2, m))) \ - : jit_shift2(d, s1, s2, m)) - -/* Shift operation, assuming d != s2 or ECX */ -#define jit_shift2(d, s1, s2, m) \ - jit_op_(d, s1, jit_cfixs(s2, _ECX, m(_CL, d))) - -/* Substitute x for destination register d */ -#define jit_fixd(d, x, op) \ - (jit_pushr_i(x), op, jit_movr_i(d, x), jit_popr_i(x)) - -/* Conditionally substitute y for source register s */ -#define jit_cfixs(s, y, op) \ - ((s) == (y) ? op : \ - (jit_pushr_i(y), jit_movr_i(y, s), op, jit_popr_i(y))) - -#define jit_lshi_i(d, rs, is) ((is) <= 3 ? LEALmr(0, 0, (rs), 1 << (is), (d)) : jit_op_ ((d), (rs), SHLLir((is), (d)) )) -#define jit_rshi_i(d, rs, is) jit_op_ ((d), (rs), SARLir((is), (d)) ) -#define jit_rshi_ui(d, rs, is) jit_op_ ((d), (rs), SHRLir((is), (d)) ) -#define jit_lshr_i(d, r1, r2) jit_shift((d), (r1), (r2), SHLLrr) -#define jit_rshr_i(d, r1, r2) jit_shift((d), (r1), (r2), SARLrr) -#define jit_rshr_ui(d, r1, r2) jit_shift((d), (r1), (r2), SHRLrr) - -/* Stack */ -#define jit_retval_i(rd) ((void)jit_movr_i ((rd), _EAX)) - -/* Unary */ -#define jit_negr_i(d, rs) jit_opi_((d), (rs), NEGLr(d), (XORLrr((d), (d)), SUBLrr((rs), (d))) ) - -#define jit_movr_i(d, rs) ((void)((rs) == (d) ? 0 : MOVLrr((rs), (d)))) -#define jit_movi_i(d, is) ((is) ? MOVLir((is), (d)) : XORLrr ((d), (d)) ) -#define jit_patch_movi(pa,pv) (*_PSL((pa) - sizeof(long)) = _jit_SL((pv))) - -#define jit_ntoh_ui(d, rs) jit_op_((d), (rs), BSWAPLr(d)) -#define jit_ntoh_us(d, rs) jit_op_((d), (rs), RORWir(8, d)) - -/* Boolean */ -#define jit_ltr_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETLr ) -#define jit_ler_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETLEr ) -#define jit_gtr_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETGr ) -#define jit_ger_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETGEr ) -#define jit_eqr_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETEr ) -#define jit_ner_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETNEr ) -#define jit_ltr_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETBr ) -#define jit_ler_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETBEr ) -#define jit_gtr_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETAr ) -#define jit_ger_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETAEr ) - -#define jit_lti_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETLr, SETSr ) -#define jit_lei_i(d, rs, is) jit_bool_i ((d), (rs), (is), SETLEr ) -#define jit_gti_i(d, rs, is) jit_bool_i ((d), (rs), (is), SETGr ) -#define jit_gei_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETGEr, SETNSr ) -#define jit_eqi_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETEr, SETEr ) -#define jit_nei_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETNEr, SETNEr ) -#define jit_lti_ui(d, rs, is) jit_bool_i ((d), (rs), (is), SETBr ) -#define jit_lei_ui(d, rs, is) jit_bool_i0((d), (rs), (is), SETBEr, SETEr ) -#define jit_gti_ui(d, rs, is) jit_bool_i0((d), (rs), (is), SETAr, SETNEr ) -#define jit_gei_ui(d, rs, is) jit_bool_i0((d), (rs), (is), SETAEr, INCLr ) - -/* Jump */ -#define jit_bltr_i(label, s1, s2) jit_bra_r((s1), (s2), JLm(label) ) -#define jit_bler_i(label, s1, s2) jit_bra_r((s1), (s2), JLEm(label) ) -#define jit_bgtr_i(label, s1, s2) jit_bra_r((s1), (s2), JGm(label) ) -#define jit_bger_i(label, s1, s2) jit_bra_r((s1), (s2), JGEm(label) ) -#define jit_beqr_i(label, s1, s2) jit_bra_r((s1), (s2), JEm(label) ) -#define jit_bner_i(label, s1, s2) jit_bra_r((s1), (s2), JNEm(label) ) -#define jit_bltr_ui(label, s1, s2) jit_bra_r((s1), (s2), JBm(label) ) -#define jit_bler_ui(label, s1, s2) jit_bra_r((s1), (s2), JBEm(label) ) -#define jit_bgtr_ui(label, s1, s2) jit_bra_r((s1), (s2), JAm(label) ) -#define jit_bger_ui(label, s1, s2) jit_bra_r((s1), (s2), JAEm(label) ) -#define jit_bmsr_i(label, s1, s2) (TESTLrr((s1), (s2)), JNZm(label), _jit.x.pc) -#define jit_bmcr_i(label, s1, s2) (TESTLrr((s1), (s2)), JZm(label), _jit.x.pc) -#define jit_boaddr_i(label, s1, s2) (ADDLrr((s2), (s1)), JOm(label), _jit.x.pc) -#define jit_bosubr_i(label, s1, s2) (SUBLrr((s2), (s1)), JOm(label), _jit.x.pc) -#define jit_boaddr_ui(label, s1, s2) (ADDLrr((s2), (s1)), JCm(label), _jit.x.pc) -#define jit_bosubr_ui(label, s1, s2) (SUBLrr((s2), (s1)), JCm(label), _jit.x.pc) - -#define jit_blti_i(label, rs, is) jit_bra_i0((rs), (is), JLm(label), JSm(label) ) -#define jit_blei_i(label, rs, is) jit_bra_i ((rs), (is), JLEm(label) ) -#define jit_bgti_i(label, rs, is) jit_bra_i ((rs), (is), JGm(label) ) -#define jit_bgei_i(label, rs, is) jit_bra_i0((rs), (is), JGEm(label), JNSm(label) ) -#define jit_beqi_i(label, rs, is) jit_bra_i0((rs), (is), JEm(label), JEm(label) ) -#define jit_bnei_i(label, rs, is) jit_bra_i0((rs), (is), JNEm(label), JNEm(label) ) -#define jit_blti_ui(label, rs, is) jit_bra_i ((rs), (is), JBm(label) ) -#define jit_blei_ui(label, rs, is) jit_bra_i0((rs), (is), JBEm(label), JEm(label) ) -#define jit_bgti_ui(label, rs, is) jit_bra_i0((rs), (is), JAm(label), JNEm(label) ) -#define jit_bgei_ui(label, rs, is) jit_bra_i ((rs), (is), JAEm(label) ) -#define jit_boaddi_i(label, rs, is) (ADDLir((is), (rs)), JOm(label), _jit.x.pc) -#define jit_bosubi_i(label, rs, is) (SUBLir((is), (rs)), JOm(label), _jit.x.pc) -#define jit_boaddi_ui(label, rs, is) (ADDLir((is), (rs)), JCm(label), _jit.x.pc) -#define jit_bosubi_ui(label, rs, is) (SUBLir((is), (rs)), JCm(label), _jit.x.pc) - -#define jit_bmsi_i(label, rs, is) (jit_reduce(TEST, (is), (rs)), JNZm(label), _jit.x.pc) -#define jit_bmci_i(label, rs, is) (jit_reduce(TEST, (is), (rs)), JZm(label), _jit.x.pc) - -#define jit_jmpi(label) (JMPm( ((unsigned long) (label))), _jit.x.pc) -#define jit_jmpr(reg) JMPsr(reg) - -/* Memory */ -#define jit_ldr_uc(d, rs) MOVZBLmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_uc(d, s1, s2) MOVZBLmr(0, (s1), (s2), 1, (d)) - -#define jit_str_c(rd, rs) jit_movbrm((rs), 0, (rd), 0, 0) -#define jit_stxr_c(d1, d2, rs) jit_movbrm((rs), 0, (d1), (d2), 1) - -#define jit_ldr_us(d, rs) MOVZWLmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_us(d, s1, s2) MOVZWLmr(0, (s1), (s2), 1, (d)) - -#define jit_str_s(rd, rs) MOVWrm(jit_reg16(rs), 0, (rd), 0, 0) -#define jit_stxr_s(d1, d2, rs) MOVWrm(jit_reg16(rs), 0, (d1), (d2), 1) - -#define jit_str_i(rd, rs) MOVLrm((rs), 0, (rd), 0, 0) -#define jit_stxr_i(d1, d2, rs) MOVLrm((rs), 0, (d1), (d2), 1) - -/* Extra */ -#define jit_nop() NOP_() - -#define _jit_alignment(pc, n) (((pc ^ _MASK(4)) + 1) & _MASK(n)) -#define jit_align(n) NOPi(_jit_alignment(_jit_UL(_jit.x.pc), (n))) - - -#if LIGHTNING_CROSS \ - ? LIGHTNING_TARGET == LIGHTNING_X86_64 \ - : defined (__x86_64__) -#include "i386/core-64.h" -#else -#include "i386/core-32.h" -#endif - -#endif /* __lightning_core_i386_h */ diff --git a/src/runtime/c/pgf/lightning/i386/fp-32.h b/src/runtime/c/pgf/lightning/i386/fp-32.h deleted file mode 100644 index 009afc649..000000000 --- a/src/runtime/c/pgf/lightning/i386/fp-32.h +++ /dev/null @@ -1,356 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Support macros for the i386 math coprocessor - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2004, 2008 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - ***********************************************************************/ - - -#ifndef __lightning_fp_h -#define __lightning_fp_h - -/* We really must map the x87 stack onto a flat register file. In practice, - we can provide something sensible and make it work on the x86 using the - stack like a file of eight registers. - - We use six or seven registers so as to have some freedom - for floor, ceil, round, (and log, tan, atn and exp). - - Not hard at all, basically play with FXCH. FXCH is mostly free, - so the generated code is not bad. Of course we special case when one - of the operands turns out to be ST0. - - Here are the macros that actually do the trick. */ - -#define JIT_FPR_NUM 6 -#define JIT_FPRET 0 -#define JIT_FPR(i) (i) - -#define jit_fxch(rs, op) (((rs) != 0 ? FXCHr(rs) : 0), \ - op, ((rs) != 0 ? FXCHr(rs) : 0)) - -#define jit_fp_unary(rd, s1, op) \ - ((rd) == (s1) ? jit_fxch ((rd), op) \ - : (rd) == 0 ? (FSTPr (0), FLDr ((s1)-1), op) \ - : (FLDr ((s1)), op, FSTPr ((rd) + 1))) - -#define jit_fp_binary(rd, s1, s2, op, opr) \ - ((rd) == (s1) ? \ - ((s2) == 0 ? opr(0, (rd)) \ - : (s2) == (s1) ? jit_fxch((rd), op(0, 0)) \ - : jit_fxch((rd), op((s2), 0))) \ - : (rd) == (s2) ? \ - ((s1) == 0 ? op(0, (rd)) \ - : jit_fxch((rd), opr((s1), 0))) \ - : (FLDr (s1), op((s2)+1, 0), FSTPr((rd)+1))) - -#define jit_addr_d(rd,s1,s2) jit_fp_binary((rd),(s1),(s2),FADDrr,FADDrr) -#define jit_subr_d(rd,s1,s2) jit_fp_binary((rd),(s1),(s2),FSUBrr,FSUBRrr) -#define jit_mulr_d(rd,s1,s2) jit_fp_binary((rd),(s1),(s2),FMULrr,FMULrr) -#define jit_divr_d(rd,s1,s2) jit_fp_binary((rd),(s1),(s2),FDIVrr,FDIVRrr) - -#define jit_abs_d(rd,rs) jit_fp_unary ((rd), (rs), _OO (0xd9e1)) -#define jit_negr_d(rd,rs) jit_fp_unary ((rd), (rs), _OO (0xd9e0)) -#define jit_sqrt_d(rd,rs) jit_fp_unary ((rd), (rs), _OO (0xd9fa)) - -/* - moves: - - move FPR0 to FPR3 - FST ST3 - - move FPR3 to FPR0 - FXCH ST3 - FST ST3 - - move FPR3 to FPR1 - FLD ST3 - FSTP ST2 Stack is rotated, so FPRn becomes STn+1 */ - -#define jit_movr_d(rd,s1) \ - ((s1) == (rd) ? 0 \ - : (s1) == 0 ? FSTr ((rd)) \ - : (rd) == 0 ? (FXCHr ((s1)), FSTr ((s1))) \ - : (FLDr ((s1)), FSTPr ((rd)+1))) - -/* - loads: - - load into FPR0 - FSTP ST0 - FLD [FUBAR] - - load into FPR3 - FSTP ST3 Save old st0 into destination register - FLD [FUBAR] - FXCH ST3 Get back old st0 - - (and similarly for immediates, using the stack) */ - -#define jit_movi_f(rd,immf) \ - (_O (0x68), \ - *((float *) _jit.x.pc) = (float) immf, \ - _jit.x.uc_pc += sizeof (float), \ - jit_ldr_f((rd), _ESP), \ - ADDLir(4, _ESP)) - -union jit_double_imm { - double d; - int i[2]; -}; - -#define jit_movi_d(rd,immd) \ - (_O (0x68), \ - _jit.x.uc_pc[4] = 0x68, \ - ((union jit_double_imm *) (_jit.x.uc_pc + 5))->d = (double) immd, \ - *((int *) _jit.x.uc_pc) = ((union jit_double_imm *) (_jit.x.uc_pc + 5))->i[1], \ - _jit.x.uc_pc += 9, \ - jit_ldr_d((rd), _ESP), \ - ADDLir(8, _ESP)) - -#define jit_ldi_f(rd, is) \ - ((rd) == 0 ? (FSTPr (0), FLDSm((is), 0, 0, 0)) \ - : (FLDSm((is), 0, 0, 0), FSTPr ((rd) + 1))) - -#define jit_ldi_d(rd, is) \ - ((rd) == 0 ? (FSTPr (0), FLDLm((is), 0, 0, 0)) \ - : (FLDLm((is), 0, 0, 0), FSTPr ((rd) + 1))) - -#define jit_ldr_f(rd, rs) \ - ((rd) == 0 ? (FSTPr (0), FLDSm(0, (rs), 0, 0)) \ - : (FLDSm(0, (rs), 0, 0), FSTPr ((rd) + 1))) - -#define jit_ldr_d(rd, rs) \ - ((rd) == 0 ? (FSTPr (0), FLDLm(0, (rs), 0, 0)) \ - : (FLDLm(0, (rs), 0, 0), FSTPr ((rd) + 1))) - -#define jit_ldxi_f(rd, rs, is) \ - ((rd) == 0 ? (FSTPr (0), FLDSm((is), (rs), 0, 0)) \ - : (FLDSm((is), (rs), 0, 0), FSTPr ((rd) + 1))) - -#define jit_ldxi_d(rd, rs, is) \ - ((rd) == 0 ? (FSTPr (0), FLDLm((is), (rs), 0, 0)) \ - : (FLDLm((is), (rs), 0, 0), FSTPr ((rd) + 1))) - -#define jit_ldxr_f(rd, s1, s2) \ - ((rd) == 0 ? (FSTPr (0), FLDSm(0, (s1), (s2), 1)) \ - : (FLDSm(0, (s1), (s2), 1), FSTPr ((rd) + 1))) - -#define jit_ldxr_d(rd, s1, s2) \ - ((rd) == 0 ? (FSTPr (0), FLDLm(0, (s1), (s2), 1)) \ - : (FLDLm(0, (s1), (s2), 1), FSTPr ((rd) + 1))) - -#define jit_extr_i_d(rd, rs) (PUSHLr((rs)), \ - ((rd) == 0 ? (FSTPr (0), FILDLm(0, _ESP, 0, 0)) \ - : (FILDLm(0, _ESP, 0, 0), FSTPr ((rd) + 1))), \ - POPLr((rs))) - -#define jit_stxi_f(id, rd, rs) jit_fxch ((rs), FSTSm((id), (rd), 0, 0)) -#define jit_stxr_f(d1, d2, rs) jit_fxch ((rs), FSTSm(0, (d1), (d2), 1)) -#define jit_stxi_d(id, rd, rs) jit_fxch ((rs), FSTLm((id), (rd), 0, 0)) -#define jit_stxr_d(d1, d2, rs) jit_fxch ((rs), FSTLm(0, (d1), (d2), 1)) -#define jit_sti_f(id, rs) jit_fxch ((rs), FSTSm((id), 0, 0, 0)) -#define jit_str_f(rd, rs) jit_fxch ((rs), FSTSm(0, (rd), 0, 0)) -#define jit_sti_d(id, rs) jit_fxch ((rs), FSTLm((id), 0, 0, 0)) -#define jit_str_d(rd, rs) jit_fxch ((rs), FSTLm(0, (rd), 0, 0)) - -/* ABI */ -#define jit_retval_d(rd) FSTPr((rd) + 1) - -/* Assume round to near mode */ -#define jit_floorr_d_i(rd, rs) \ - (FLDr (rs), jit_floor2((rd), ((rd) == _EDX ? _EAX : _EDX))) - -#define jit_ceilr_d_i(rd, rs) \ - (FLDr (rs), jit_ceil2((rd), ((rd) == _EDX ? _EAX : _EDX))) - -#define jit_truncr_d_i(rd, rs) \ - (FLDr (rs), jit_trunc2((rd), ((rd) == _EDX ? _EAX : _EDX))) - -#define jit_calc_diff(ofs) \ - FISTLm(ofs, _ESP, 0, 0), \ - FILDLm(ofs, _ESP, 0, 0), \ - FSUBRPr(1), \ - FSTPSm(4+ofs, _ESP, 0, 0) \ - -/* The real meat */ -#define jit_floor2(rd, aux) \ - (PUSHLr(aux), \ - SUBLir(8, _ESP), \ - jit_calc_diff(0), \ - POPLr(rd), /* floor in rd */ \ - POPLr(aux), /* x-round(x) in aux */ \ - ADDLir(0x7FFFFFFF, aux), /* carry if x-round(x) < -0 */ \ - SBBLir(0, rd), /* subtract 1 if carry */ \ - POPLr(aux)) - -#define jit_ceil2(rd, aux) \ - (PUSHLr(aux), \ - SUBLir(8, _ESP), \ - jit_calc_diff(0), \ - POPLr(rd), /* floor in rd */ \ - POPLr(aux), /* x-round(x) in aux */ \ - TESTLrr(aux, aux), \ - SETGr(jit_reg8(aux)), \ - SHRLir(1, aux), \ - ADCLir(0, rd), \ - POPLr(aux)) - -/* a mingling of the two above */ -#define jit_trunc2(rd, aux) \ - (PUSHLr(aux), \ - SUBLir(12, _ESP), \ - FSTSm(0, _ESP, 0, 0), \ - jit_calc_diff(4), \ - POPLr(aux), \ - POPLr(rd), \ - TESTLrr(aux, aux), \ - POPLr(aux), \ - JSSm(_jit.x.pc + 11), \ - ADDLir(0x7FFFFFFF, aux), /* 6 */ \ - SBBLir(0, rd), /* 3 */ \ - JMPSm(_jit.x.pc + 10), /* 2 */ \ - TESTLrr(aux, aux), /* 2 */ \ - SETGr(jit_reg8(aux)), /* 3 */ \ - SHRLir(1, aux), /* 2 */ \ - ADCLir(0, rd), /* 3 */ \ - POPLr(aux)) - -/* the easy one */ -#define jit_roundr_d_i(rd, rs) \ - (PUSHLr(_EAX), \ - jit_fxch ((rs), FISTLm(0, _ESP, 0, 0)), \ - POPLr((rd))) - -#define jit_fp_test(d, s1, s2, n, _and, res) \ - (((s1) == 0 ? FUCOMr((s2)) : (FLDr((s1)), FUCOMPr((s2) + 1))), \ - ((d) != _EAX ? MOVLrr(_EAX, (d)) : 0), \ - FNSTSWr(_EAX), \ - SHRLir(n, _EAX), \ - ((_and) ? ANDLir((_and), _EAX) : MOVLir(0, _EAX)), \ - res, \ - ((d) != _EAX ? _O (0x90 + ((d) & 7)) : 0)) /* xchg */ - -#define jit_fp_btest(d, s1, s2, n, _and, cmp, res) \ - (((s1) == 0 ? FUCOMr((s2)) : (FLDr((s1)), FUCOMPr((s2) + 1))), \ - PUSHLr(_EAX), \ - FNSTSWr(_EAX), \ - SHRLir(n, _EAX), \ - ((_and) ? ANDLir ((_and), _EAX) : 0), \ - ((cmp) ? CMPLir ((cmp), _EAX) : 0), \ - POPLr(_EAX), \ - res ((d)), \ - _jit.x.pc) - -#define jit_nothing_needed(x) - -/* After FNSTSW we have 1 if <, 40 if =, 0 if >, 45 if unordered. Here - is how to map the values of the status word's high byte to the - conditions. - - < = > unord valid values condition - gt no no yes no 0 STSW & 45 == 0 - lt yes no no no 1 STSW & 45 == 1 - eq no yes no no 40 STSW & 45 == 40 - unord no no no yes 45 bit 2 == 1 - - ge no yes no no 0, 40 bit 0 == 0 - unlt yes no no yes 1, 45 bit 0 == 1 - ltgt yes no yes no 0, 1 bit 6 == 0 - uneq no yes no yes 40, 45 bit 6 == 1 - le yes yes no no 1, 40 odd parity for STSW & 41 - ungt no no yes yes 0, 45 even parity for STSW & 41 - - unle yes yes no yes 1, 40, 45 STSW & 45 != 0 - unge no yes yes yes 0, 40, 45 STSW & 45 != 1 - ne yes no yes yes 0, 1, 45 STSW & 45 != 40 - ord yes yes yes no 0, 1, 40 bit 2 == 0 - - lt, le, ungt, unge are actually computed as gt, ge, unlt, unle with - the operands swapped; it is more efficient this way. */ - -#define jit_gtr_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 8, 0x45, SETZr (_AL)) -#define jit_ger_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 9, 0, SBBBir (-1, _AL)) -#define jit_unler_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 8, 0x45, SETNZr (_AL)) -#define jit_unltr_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 9, 0, ADCBir (0, _AL)) -#define jit_ltr_d(d, s1, s2) jit_fp_test((d), (s2), (s1), 8, 0x45, SETZr (_AL)) -#define jit_ler_d(d, s1, s2) jit_fp_test((d), (s2), (s1), 9, 0, SBBBir (-1, _AL)) -#define jit_unger_d(d, s1, s2) jit_fp_test((d), (s2), (s1), 8, 0x45, SETNZr (_AL)) -#define jit_ungtr_d(d, s1, s2) jit_fp_test((d), (s2), (s1), 9, 0, ADCBir (0, _AL)) -#define jit_eqr_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 8, 0x45, (CMPBir (0x40, _AL), SETEr (_AL))) -#define jit_ner_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 8, 0x45, (CMPBir (0x40, _AL), SETNEr (_AL))) -#define jit_ltgtr_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 15, 0, SBBBir (-1, _AL)) -#define jit_uneqr_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 15, 0, ADCBir (0, _AL)) -#define jit_ordr_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 11, 0, SBBBir (-1, _AL)) -#define jit_unordr_d(d, s1, s2) jit_fp_test((d), (s1), (s2), 11, 0, ADCBir (0, _AL)) - -#define jit_bgtr_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 8, 0x45, 0, JZm) -#define jit_bger_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 9, 0, 0, JNCm) -#define jit_bunler_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 8, 0x45, 0, JNZm) -#define jit_bunltr_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 9, 0, 0, JCm) -#define jit_bltr_d(d, s1, s2) jit_fp_btest((d), (s2), (s1), 8, 0x45, 0, JZm) -#define jit_bler_d(d, s1, s2) jit_fp_btest((d), (s2), (s1), 9, 0, 0, JNCm) -#define jit_bunger_d(d, s1, s2) jit_fp_btest((d), (s2), (s1), 8, 0x45, 0, JNZm) -#define jit_bungtr_d(d, s1, s2) jit_fp_btest((d), (s2), (s1), 9, 0, 0, JCm) -#define jit_beqr_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 8, 0x45, 0x40, JZm) -#define jit_bner_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 8, 0x45, 0x40, JNZm) -#define jit_bltgtr_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 15, 0, 0, JNCm) -#define jit_buneqr_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 15, 0, 0, JCm) -#define jit_bordr_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 11, 0, 0, JNCm) -#define jit_bunordr_d(d, s1, s2) jit_fp_btest((d), (s1), (s2), 11, 0, 0, JCm) - -#define jit_pusharg_d(rs) (jit_subi_i(JIT_SP,JIT_SP,sizeof(double)), jit_str_d(JIT_SP,(rs))) -#define jit_pusharg_f(rs) (jit_subi_i(JIT_SP,JIT_SP,sizeof(float)), jit_str_f(JIT_SP,(rs))) - - -#if 0 -#define jit_sin() _OO(0xd9fe) /* fsin */ -#define jit_cos() _OO(0xd9ff) /* fcos */ -#define jit_tan() (_OO(0xd9f2), /* fptan */ \ - FSTPr(0)) /* fstp st */ -#define jit_atn() (_OO(0xd9e8), /* fld1 */ \ - _OO(0xd9f3)) /* fpatan */ -#define jit_exp() (_OO(0xd9ea), /* fldl2e */ \ - FMULPr(1), /* fmulp */ \ - _OO(0xd9c0), /* fld st */ \ - _OO(0xd9fc), /* frndint */ \ - _OO(0xdce9), /* fsubr */ \ - FXCHr(1), /* fxch st(1) */ \ - _OO(0xd9f0), /* f2xm1 */ \ - _OO(0xd9e8), /* fld1 */ \ - _OO(0xdec1), /* faddp */ \ - _OO(0xd9fd), /* fscale */ \ - FSTPr(1)) /* fstp st(1) */ -#define jit_log() (_OO(0xd9ed), /* fldln2 */ \ - FXCHr(1), /* fxch st(1) */ \ - _OO(0xd9f1)) /* fyl2x */ -#endif - -#define jit_prepare_f(nf) (_jitl.argssize += (nf)) -#define jit_prepare_d(nd) (_jitl.argssize += 2 * (nd)) -#define jit_arg_f() ((_jitl.framesize += sizeof(float)) - sizeof(float)) -#define jit_arg_d() ((_jitl.framesize += sizeof(double)) - sizeof(double)) - -#endif /* __lightning_fp_h */ diff --git a/src/runtime/c/pgf/lightning/i386/fp-64.h b/src/runtime/c/pgf/lightning/i386/fp-64.h deleted file mode 100644 index 22308a7f1..000000000 --- a/src/runtime/c/pgf/lightning/i386/fp-64.h +++ /dev/null @@ -1,325 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Support macros for SSE floating-point math - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2006 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - ***********************************************************************/ - - -#ifndef __lightning_fp_h -#define __lightning_fp_h - -#include - -#define JIT_FPR_NUM 7 -#define JIT_FPRET _XMM0 -#define JIT_FPR(i) (_XMM8 + (i)) -#define JIT_FPTMP _XMM15 - -/* Either use a temporary register that is finally AND/OR/XORed with RS = RD, - or use RD as the temporary register and to the AND/OR/XOR with RS. */ -#define jit_unop_tmp(rd, rs, op) \ - ( (rs) == (rd) \ - ? op((rd), JIT_FPTMP, JIT_FPTMP)) \ - : op((rd), (rd), (rs))) - -#define jit_unop_f(rd, rs, op) \ - ((rs) == (rd) ? op((rd)) : (MOVSSrr ((rs), (rd)), op((rd)))) - -#define jit_unop_d(rd, rs, op) \ - ((rs) == (rd) ? op((rd)) : (MOVSDrr ((rs), (rd)), op((rd)))) - -#define jit_3opc_f(rd, s1, s2, op) \ - ( (s1) == (rd) ? op((s2), (rd)) \ - : ((s2) == (rd) ? op((s1), (rd)) \ - : (MOVSSrr ((s1), (rd)), op((s2), (rd))))) - -#define jit_3opc_d(rd, s1, s2, op) \ - ( (s1) == (rd) ? op((s2), (rd)) \ - : ((s2) == (rd) ? op((s1), (rd)) \ - : (MOVSDrr ((s1), (rd)), op((s2), (rd))))) - -#define jit_3op_f(rd, s1, s2, op) \ - ( (s1) == (rd) ? op((s2), (rd)) \ - : ((s2) == (rd) \ - ? (MOVSSrr ((rd), JIT_FPTMP), MOVSSrr ((s1), (rd)), op(JIT_FPTMP, (rd))) \ - : (MOVSSrr ((s1), (rd)), op((s2), (rd))))) - -#define jit_3op_d(rd, s1, s2, op) \ - ( (s1) == (rd) ? op((s2), (rd)) \ - : ((s2) == (rd) \ - ? (MOVSDrr ((rd), JIT_FPTMP), MOVSDrr ((s1), (rd)), op(JIT_FPTMP, (rd))) \ - : (MOVSDrr ((s1), (rd)), op((s2), (rd))))) - -#define jit_addr_f(rd,s1,s2) jit_3opc_f((rd), (s1), (s2), ADDSSrr) -#define jit_subr_f(rd,s1,s2) jit_3op_f((rd), (s1), (s2), SUBSSrr) -#define jit_mulr_f(rd,s1,s2) jit_3opc_f((rd), (s1), (s2), MULSSrr) -#define jit_divr_f(rd,s1,s2) jit_3op_f((rd), (s1), (s2), DIVSSrr) - -#define jit_addr_d(rd,s1,s2) jit_3opc_d((rd), (s1), (s2), ADDSDrr) -#define jit_subr_d(rd,s1,s2) jit_3op_d((rd), (s1), (s2), SUBSDrr) -#define jit_mulr_d(rd,s1,s2) jit_3opc_d((rd), (s1), (s2), MULSDrr) -#define jit_divr_d(rd,s1,s2) jit_3op_d((rd), (s1), (s2), DIVSDrr) - -#define jit_movr_f(rd,rs) MOVSSrr((rs), (rd)) -#define jit_movr_d(rd,rs) MOVSDrr((rs), (rd)) - -/* either pcmpeqd %xmm7, %xmm7 / psrld $1, %xmm7 / andps %xmm7, %RD (if RS = RD) - or pcmpeqd %RD, %RD / psrld $1, %RD / andps %RS, %RD (if RS != RD) */ -#define _jit_abs_f(rd,cnst,rs) \ - (PCMPEQDrr((cnst), (cnst)), PSRLDir (1, (cnst)), ANDPSrr ((rs), (rd))) -#define _jit_neg_f(rd,cnst,rs) \ - (PCMPEQDrr((cnst), (cnst)), PSLLDir (31, (cnst)), XORPSrr ((rs), (rd))) -#define jit_abs_f(rd,rs) jit_unop_tmp ((rd), (rs), _jit_abs_f) -#define jit_neg_f(rd,rs) jit_unop_tmp ((rd), (rs), _jit_neg_f) - -#define _jit_abs_d(rd,cnst,rs) \ - (PCMPEQDrr((cnst), (cnst)), PSRLQir (1, (cnst)), ANDPDrr ((rs), (rd))) -#define _jit_neg_d(rd,cnst,rs) \ - (PCMPEQDrr((cnst), (cnst)), PSLLQir (63, (cnst)), XORPDrr ((rs), (rd))) -#define jit_abs_d(rd,rs) jit_unop_tmp ((rd), (rs), _jit_abs_d) -#define jit_neg_d(rd,rs) jit_unop_tmp ((rd), (rs), _jit_neg_d) - -#define jit_sqrt_d(rd,rs) SQRTSSrr((rs), (rd)) -#define jit_sqrt_f(rd,rs) SQRTSDrr((rs), (rd)) - -#define _jit_ldi_f(d, is) MOVSSmr((is), 0, 0, 0, (d)) -#define _jit_ldxi_f(d, rs, is) MOVSSmr((is), (rs), 0, 0, (d)) -#define jit_ldr_f(d, rs) MOVSSmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_f(d, s1, s2) MOVSSmr(0, (s1), (s2), 1, (d)) - -#define _jit_sti_f(id, rs) MOVSSrm((rs), (id), 0, 0, 0) -#define _jit_stxi_f(id, rd, rs) MOVSSrm((rs), (id), (rd), 0, 0) -#define jit_str_f(rd, rs) MOVSSrm((rs), 0, (rd), 0, 0) -#define jit_stxr_f(d1, d2, rs) MOVSSrm((rs), 0, (d1), (d2), 1) - -#define jit_ldi_f(d, is) (_u32P((long)(is)) ? _jit_ldi_f((d), (is)) : (jit_movi_l(JIT_REXTMP, (is)), jit_ldr_f((d), JIT_REXTMP))) -#define jit_sti_f(id, rs) (_u32P((long)(id)) ? _jit_sti_f((id), (rs)) : (jit_movi_l(JIT_REXTMP, (id)), jit_str_f (JIT_REXTMP, (rs)))) -#define jit_ldxi_f(d, rs, is) (_u32P((long)(is)) ? _jit_ldxi_f((d), (rs), (is)) : (jit_movi_l(JIT_REXTMP, (is)), jit_ldxr_f((d), (rs), JIT_REXTMP))) -#define jit_stxi_f(id, rd, rs) (_u32P((long)(id)) ? _jit_stxi_f((id), (rd), (rs)) : (jit_movi_l(JIT_REXTMP, (id)), jit_stxr_f (JIT_REXTMP, (rd), (rs)))) - -#define _jit_ldi_d(d, is) MOVSDmr((is), 0, 0, 0, (d)) -#define _jit_ldxi_d(d, rs, is) MOVSDmr((is), (rs), 0, 0, (d)) -#define jit_ldr_d(d, rs) MOVSDmr(0, (rs), 0, 0, (d)) -#define jit_ldxr_d(d, s1, s2) MOVSDmr(0, (s1), (s2), 1, (d)) - -#define _jit_sti_d(id, rs) MOVSDrm((rs), (id), 0, 0, 0) -#define _jit_stxi_d(id, rd, rs) MOVSDrm((rs), (id), (rd), 0, 0) -#define jit_str_d(rd, rs) MOVSDrm((rs), 0, (rd), 0, 0) -#define jit_stxr_d(d1, d2, rs) MOVSDrm((rs), 0, (d1), (d2), 1) - -#define jit_ldi_d(d, is) (_u32P((long)(is)) ? _jit_ldi_d((d), (is)) : (jit_movi_l(JIT_REXTMP, (is)), jit_ldr_d((d), JIT_REXTMP))) -#define jit_sti_d(id, rs) (_u32P((long)(id)) ? _jit_sti_d((id), (rs)) : (jit_movi_l(JIT_REXTMP, (id)), jit_str_d (JIT_REXTMP, (rs)))) -#define jit_ldxi_d(d, rs, is) (_u32P((long)(is)) ? _jit_ldxi_d((d), (rs), (is)) : (jit_movi_l(JIT_REXTMP, (is)), jit_ldxr_d((d), (rs), JIT_REXTMP))) -#define jit_stxi_d(id, rd, rs) (_u32P((long)(id)) ? _jit_stxi_d((id), (rd), (rs)) : (jit_movi_l(JIT_REXTMP, (id)), jit_stxr_d (JIT_REXTMP, (rd), (rs)))) - - -#define jit_movi_f(rd,immf) \ - ((immf) == 0.0 ? XORSSrr ((rd), (rd)) : \ - (PUSHQi (0x12345678L), \ - *((float *) (_jit.x.uc_pc - 4)) = (float) immf, \ - jit_ldr_f((rd), _ESP), \ - ADDQir(8, _ESP))) - -union jit_double_imm { - double d; - long l; -}; - -#define jit_movi_d(rd,immd) \ - ((immd) == 0.0 ? XORSDrr ((rd), (rd)) : \ - (_O (0x50), \ - MOVQir (0x123456789abcdef0L, _EAX), \ - ((union jit_double_imm *) (_jit.x.uc_pc - 8))->d = (double) immd, \ - _O (0x50), jit_ldr_d((rd), _ESP), \ - _O (0x58), _O (0x58))) - -#define jit_extr_i_d(rd, rs) CVTSI2SDLrr((rs), (rd)) -#define jit_extr_i_f(rd, rs) CVTSI2SSLrr((rs), (rd)) -#define jit_extr_l_d(rd, rs) CVTSI2SDQrr((rs), (rd)) -#define jit_extr_l_f(rd, rs) CVTSI2SSQrr((rs), (rd)) -#define jit_extr_f_d(rd, rs) CVTSS2SDrr((rs), (rd)) -#define jit_extr_d_f(rd, rs) CVTSD2SSrr((rs), (rd)) -#define jit_roundr_d_i(rd, rs) CVTSD2SILrr((rs), (rd)) -#define jit_roundr_f_i(rd, rs) CVTSS2SILrr((rs), (rd)) -#define jit_roundr_d_l(rd, rs) CVTSD2SIQrr((rs), (rd)) -#define jit_roundr_f_l(rd, rs) CVTSS2SIQrr((rs), (rd)) -#define jit_truncr_d_i(rd, rs) CVTTSD2SILrr((rs), (rd)) -#define jit_truncr_f_i(rd, rs) CVTTSS2SILrr((rs), (rd)) -#define jit_truncr_d_l(rd, rs) CVTTSD2SIQrr((rs), (rd)) -#define jit_truncr_f_l(rd, rs) CVTTSS2SIQrr((rs), (rd)) - - -#define jit_ceilr_f_i(rd, rs) do { \ - jit_roundr_f_i ((rd), (rs)); \ - jit_extr_i_f (JIT_FPTMP, (rd)); \ - UCOMISSrr ((rs), JIT_FPTMP); \ - ADCLir (0, (rd)); \ - } while (0) - -#define jit_ceilr_d_i(rd, rs) do { \ - jit_roundr_d_i ((rd), (rs)); \ - jit_extr_i_d (JIT_FPTMP, (rd)); \ - UCOMISDrr ((rs), JIT_FPTMP); \ - ADCLir (0, (rd)); \ - } while (0) - -#define jit_ceilr_f_l(rd, rs) do { \ - jit_roundr_f_l ((rd), (rs)); \ - jit_extr_l_f (JIT_FPTMP, (rd)); \ - UCOMISSrr ((rs), JIT_FPTMP); \ - ADCLir (0, (rd)); \ - } while (0) - -#define jit_ceilr_d_l(rd, rs) do { \ - jit_roundr_d_l ((rd), (rs)); \ - jit_extr_l_d (JIT_FPTMP, (rd)); \ - UCOMISDrr ((rs), JIT_FPTMP); \ - ADCLir (0, (rd)); \ - } while (0) - -#define jit_floorr_f_i(rd, rs) do { \ - jit_roundr_f_i ((rd), (rs)); \ - jit_extr_i_f (JIT_FPTMP, (rd)); \ - UCOMISSrr (JIT_FPTMP, (rs)); \ - SBBLir (0, (rd)); \ - } while (0) - -#define jit_floorr_d_i(rd, rs) do { \ - jit_roundr_d_i ((rd), (rs)); \ - jit_extr_i_d (JIT_FPTMP, (rd)); \ - UCOMISDrr (JIT_FPTMP, (rs)); \ - SBBLir (0, (rd)); \ - } while (0) - -#define jit_floorr_f_l(rd, rs) do { \ - jit_roundr_f_l ((rd), (rs)); \ - jit_extr_l_f (JIT_FPTMP, (rd)); \ - UCOMISSrr (JIT_FPTMP, (rs)); \ - SBBLir (0, (rd)); \ - } while (0) - -#define jit_floorr_d_l(rd, rs) do { \ - jit_roundr_d_l ((rd), (rs)); \ - jit_extr_l_d (JIT_FPTMP, (rd)); \ - UCOMISDrr (JIT_FPTMP, (rs)); \ - SBBLir (0, (rd)); \ - } while (0) - -#define jit_bltr_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JAm ((d)), _jit.x.pc) -#define jit_bler_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JAEm ((d)), _jit.x.pc) -#define jit_beqr_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), _OO (0x7a06), JEm ((d)), _jit.x.pc) -#define jit_bner_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), _OO (0x7a02), _OO (0x7405), JMPm (((d))), _jit.x.pc) /* JP to JMP, JZ past JMP */ -#define jit_bger_f(d, s1, s2) (UCOMISSrr ((s2), (s1)), JAEm ((d)), _jit.x.pc) -#define jit_bgtr_f(d, s1, s2) (UCOMISSrr ((s2), (s1)), JAm ((d)), _jit.x.pc) -#define jit_bunltr_f(d, s1, s2) (UCOMISSrr ((s2), (s1)), JNAEm ((d)), _jit.x.pc) -#define jit_bunler_f(d, s1, s2) (UCOMISSrr ((s2), (s1)), JNAm ((d)), _jit.x.pc) -#define jit_buneqr_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JEm ((d)), _jit.x.pc) -#define jit_bltgtr_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JNEm ((d)), _jit.x.pc) -#define jit_bunger_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JNAm ((d)), _jit.x.pc) -#define jit_bungtr_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JNAEm ((d)), _jit.x.pc) -#define jit_bordr_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JNPm ((d)), _jit.x.pc) -#define jit_bunordr_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), JPm ((d)), _jit.x.pc) - -#define jit_bltr_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JAm ((d)), _jit.x.pc) -#define jit_bler_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JAEm ((d)), _jit.x.pc) -#define jit_beqr_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), _OO (0x7a06), JEm ((d)), _jit.x.pc) -#define jit_bner_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), _OO (0x7a02), _OO (0x7405), JMPm (((d))), _jit.x.pc) /* JP to JMP, JZ past JMP */ -#define jit_bger_d(d, s1, s2) (UCOMISDrr ((s2), (s1)), JAEm ((d)), _jit.x.pc) -#define jit_bgtr_d(d, s1, s2) (UCOMISDrr ((s2), (s1)), JAm ((d)), _jit.x.pc) -#define jit_bunltr_d(d, s1, s2) (UCOMISDrr ((s2), (s1)), JNAEm ((d)), _jit.x.pc, _jit.x.pc) -#define jit_bunler_d(d, s1, s2) (UCOMISDrr ((s2), (s1)), JNAm ((d)), _jit.x.pc) -#define jit_buneqr_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JEm ((d)), _jit.x.pc) -#define jit_bltgtr_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JNEm ((d)), _jit.x.pc) -#define jit_bunger_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JNAm ((d)), _jit.x.pc) -#define jit_bungtr_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JNAEm ((d)), _jit.x.pc) -#define jit_bordr_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JNPm ((d)), _jit.x.pc) -#define jit_bunordr_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), JPm ((d)), _jit.x.pc) - -#define jit_ltr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETAr (jit_reg8((d)))) -#define jit_ler_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETAEr (jit_reg8((d)))) -#define jit_eqr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), _OO(0x7a03), SETEr (jit_reg8((d)))) -#define jit_ner_f(d, s1, s2) (UCOMISSrr ((s1), (s2)), MOVLir (1, (d)), _OO(0x7a03), SETNEr (jit_reg8((d)))) -#define jit_ger_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s2), (s1)), SETAEr (jit_reg8((d)))) -#define jit_gtr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s2), (s1)), SETAr (jit_reg8((d)))) -#define jit_unltr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s2), (s1)), SETNAEr (jit_reg8((d)))) -#define jit_unler_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s2), (s1)), SETNAr (jit_reg8((d)))) -#define jit_uneqr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETEr (jit_reg8((d)))) -#define jit_ltgtr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETNEr (jit_reg8((d)))) -#define jit_unger_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETNAr (jit_reg8((d)))) -#define jit_ungtr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETNAEr (jit_reg8((d)))) -#define jit_ordr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETNPr (jit_reg8((d)))) -#define jit_unordr_f(d, s1, s2) (XORLrr ((d), (d)), UCOMISSrr ((s1), (s2)), SETPr (jit_reg8((d)))) - -#define jit_ltr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETAr (jit_reg8((d)))) -#define jit_ler_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETAEr (jit_reg8((d)))) -#define jit_eqr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), _OO(0x7a03), SETEr (jit_reg8((d)))) -#define jit_ner_d(d, s1, s2) (UCOMISDrr ((s1), (s2)), MOVLir (1, (d)), _OO(0x7a03), SETNEr (jit_reg8((d)))) -#define jit_ger_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s2), (s1)), SETAEr (jit_reg8((d)))) -#define jit_gtr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s2), (s1)), SETAr (jit_reg8((d)))) -#define jit_unltr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s2), (s1)), SETNAEr (jit_reg8((d)))) -#define jit_unler_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s2), (s1)), SETNAr (jit_reg8((d)))) -#define jit_uneqr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETEr (jit_reg8((d)))) -#define jit_ltgtr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETNEr (jit_reg8((d)))) -#define jit_unger_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETNAr (jit_reg8((d)))) -#define jit_ungtr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETNAEr (jit_reg8((d)))) -#define jit_ordr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETNPr (jit_reg8((d)))) -#define jit_unordr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETPr (jit_reg8((d)))) - -#define jit_prepare_f(num) ((_jitl.nextarg_putfp + (num) > JIT_FP_ARG_MAX \ - ? (_jitl.argssize += _jitl.nextarg_putfp + (num) - JIT_FP_ARG_MAX, \ - _jitl.fprssize = JIT_FP_ARG_MAX) \ - : (_jitl.fprssize += (num))), \ - _jitl.nextarg_putfp += (num)) -#define jit_prepare_d(num) ((_jitl.nextarg_putfp + (num) > JIT_FP_ARG_MAX \ - ? (_jitl.argssize += _jitl.nextarg_putfp + (num) - JIT_FP_ARG_MAX, \ - _jitl.fprssize = JIT_FP_ARG_MAX) \ - : (_jitl.fprssize += (num))), \ - _jitl.nextarg_putfp += (num)) - -#define jit_arg_f() (_jitl.nextarg_getfp < JIT_FP_ARG_MAX \ - ? _jitl.nextarg_getfp++ \ - : ((_jitl.framesize += sizeof(double)) - sizeof(double))) -#define jit_arg_d() (_jitl.nextarg_getfp < JIT_FP_ARG_MAX \ - ? _jitl.nextarg_getfp++ \ - : ((_jitl.framesize += sizeof(double)) - sizeof(double))) - -#define jit_getarg_f(reg, ofs) ((ofs) < JIT_FP_ARG_MAX \ - ? jit_movr_f((reg), _XMM0 + (ofs)) \ - : jit_ldxi_f((reg), JIT_FP, (ofs))) -#define jit_getarg_d(reg, ofs) ((ofs) < JIT_FP_ARG_MAX \ - ? jit_movr_d((reg), _XMM0 + (ofs)) \ - : jit_ldxi_d((reg), JIT_FP, (ofs))) - -#define jit_pusharg_f(rs) (--_jitl.nextarg_putfp >= JIT_FP_ARG_MAX \ - ? (SUBQir(sizeof(double), JIT_SP), jit_str_f(JIT_SP,(rs))) \ - : jit_movr_f(_XMM0 + _jitl.nextarg_putfp, (rs))) -#define jit_pusharg_d(rs) (--_jitl.nextarg_putfp >= JIT_FP_ARG_MAX \ - ? (SUBQir(sizeof(double), JIT_SP), jit_str_d(JIT_SP,(rs))) \ - : jit_movr_d(_XMM0 + _jitl.nextarg_putfp, (rs))) - -#endif /* __lightning_fp_h */ diff --git a/src/runtime/c/pgf/lightning/i386/fp.h b/src/runtime/c/pgf/lightning/i386/fp.h deleted file mode 100644 index a4942fcf6..000000000 --- a/src/runtime/c/pgf/lightning/i386/fp.h +++ /dev/null @@ -1,45 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Floating-point support (i386) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2008 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_fp_i386_h -#define __lightning_fp_i386_h - -#if LIGHTNING_CROSS \ - ? LIGHTNING_TARGET == LIGHTNING_X86_64 \ - : defined (__x86_64__) -#include "i386/fp-64.h" -#else -#include "i386/fp-32.h" -#endif - -#endif /* __lightning_fp_i386_h */ diff --git a/src/runtime/c/pgf/lightning/i386/funcs.h b/src/runtime/c/pgf/lightning/i386/funcs.h deleted file mode 100644 index bd9bfac4f..000000000 --- a/src/runtime/c/pgf/lightning/i386/funcs.h +++ /dev/null @@ -1,92 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer inline functions (i386) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2006 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_funcs_h -#define __lightning_funcs_h - -#if defined(__linux__) || defined(__APPLE__) -#include -#include -#endif - -static void -jit_flush_code(void *dest, void *end) -{ - /* On the x86, the PROT_EXEC bits are not handled by the MMU. - However, the kernel can emulate this by setting the code - segment's limit to the end address of the highest page - whose PROT_EXEC bit is set. - - Linux kernels that do so and that disable by default the - execution of the data and stack segment are becoming more - and more common (Fedora, for example), so we implement our - jit_flush_code as an mprotect. */ -#if defined(__linux__) || defined(__APPLE__) - static unsigned long prev_page = 0, prev_length = 0; - unsigned long page, length; -#ifdef PAGESIZE - const int page_size = PAGESIZE; -#else - static int page_size = -1; - if (page_size == -1) - page_size = getpagesize(); -#endif - - page = (long) dest & ~(page_size - 1); - length = ((char *) end - (char *) page + page_size - 1) & ~(page_size - 1); - - /* Simple-minded attempt at optimizing the common case where a single - chunk of memory is used to compile multiple functions. */ - if (page >= prev_page && page + length <= prev_page + prev_length) - return; - - mprotect ((void *) page, length, PROT_READ | PROT_WRITE | PROT_EXEC); - - /* See if we can extend the previously mprotect'ed memory area towards - higher addresses: the starting address remains the same as before. */ - if (page >= prev_page && page <= prev_page + prev_length) - prev_length = page + length - prev_page; - - /* See if we can extend the previously mprotect'ed memory area towards - lower addresses: the highest address remains the same as before. */ - else if (page < prev_page && page + length >= prev_page - && page + length <= prev_page + prev_length) - prev_length += prev_page - page, prev_page = page; - - /* Nothing to do, replace the area. */ - else - prev_page = page, prev_length = length; -#endif -} - -#endif /* __lightning_funcs_h */ diff --git a/src/runtime/c/pgf/lightning/ppc/asm.h b/src/runtime/c/pgf/lightning/ppc/asm.h deleted file mode 100644 index 9f3c71dd9..000000000 --- a/src/runtime/c/pgf/lightning/ppc/asm.h +++ /dev/null @@ -1,647 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler for the PowerPC - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 1999, 2000, 2001, 2002 Ian Piumarta - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - -#ifndef __lightning_asm_h -#define __lightning_asm_h - -/* = [0-9]+ | (.+) -> add i, one parameter (imm) - * = r -> add r, one parameter (imm) - * = () -> add m, two parameters (imm,reg) - * = () -> add x, two parameters (reg,reg) - * - * `x' operands have two forms. For example `stwu source, rega(regb)' - * could be written as either - * STWUrx(source, rega, regb) - * or - * STWUXrrr(source, rega, regb) - */ - - - -/*** a brief NOTE about halfwords and "shifted" operands - * - * LOGICAL insns require UNSIGNED args in 0..65535, whether or not shifted - * - * ARITHMETIC insns require SIGNED args in -32768..32767, even when shifted - * - * as a special case: "lis/addis" also accepts UNSIGNED arguments in - * 0..65535 since it is often used immediately before "ori" to load a 32-bit - * constant (this is consistent with the GNU rs/6000 and PowerPC assemblers) - * - * thus: lis rD, expression@hi - * ori rD, rD, expression@lo ; load 32-bit constant - */ - -typedef unsigned int jit_insn; - -#ifndef LIGHTNING_DEBUG -#define _cr0 0 -#define _cr1 1 -#define _cr2 2 -#define _cr3 3 -#define _cr4 4 -#define _cr5 5 -#define _cr6 6 -#define _cr7 7 - -#define _lt 0 -#define _gt 1 -#define _eq 2 -#define _so 3 -#define _un 3 - -#define _d16(D) (_ck_d(16,(_jit_UL(D)-_jit_UL(_jit.x.pc))) & ~3) -#define _d26(D) (_ck_d(26,(_jit_UL(D)-_jit_UL(_jit.x.pc))) & ~3) - -/* primitive instruction forms [1, Section A.4] */ - -#define _FB( OP, BD,AA,LK ) (_jit_I_noinc((_u6(OP)<<26)| _d26(BD)| (_u1(AA)<<1)|_u1(LK)), _jit.x.pc++, 0) -#define _FBA( OP, BD,AA,LK ) _jit_I((_u6(OP)<<26)| (_u26(BD)&~3)| (_u1(AA)<<1)|_u1(LK)) -#define _BB( OP,BO,BI, BD,AA,LK ) (_jit_I_noinc((_u6(OP)<<26)|(_u5(BO)<<21)|(_u5(BI)<<16)| _d16(BD)| (_u1(AA)<<1)|_u1(LK)), _jit.x.pc++, 0) -#define _D( OP,RD,RA, DD ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _s16(DD) ) -#define _Du( OP,RD,RA, DD ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _u16(DD) ) -#define _Ds( OP,RD,RA, DD ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _su16(DD) ) -#define _X( OP,RD,RA,RB, XO,RC ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)| (_u10(XO)<<1)|_u1(RC)) -#define _XL( OP,BO,BI, XO,LK ) _jit_I((_u6(OP)<<26)|(_u5(BO)<<21)|(_u5(BI)<<16)|( _u5(00)<<11)| (_u10(XO)<<1)|_u1(LK)) -#define _XFX( OP,RD, SR,XO ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)| (_u10(SR)<<11)| (_u10(XO)<<1)|_u1(00)) -#define _XO( OP,RD,RA,RB,OE,XO,RC ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)|(_u1(OE)<<10)|( _u9(XO)<<1)|_u1(RC)) -#define _M( OP,RS,RA,SH,MB,ME,RC ) _jit_I((_u6(OP)<<26)|(_u5(RS)<<21)|(_u5(RA)<<16)|( _u5(SH)<<11)|(_u5(MB)<< 6)|( _u5(ME)<<1)|_u1(RC)) - - -/* special purpose registers (form XFX) [1, Section 8.2, page 8-138] */ - -#define SPR_LR ((8<<5)|(0)) - -/* +++ intrinsic instructions */ - -#define ADDrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 0) -#define ADD_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 1) -#define ADDCrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 10, 0) -#define ADDC_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 10, 1) -#define ADDErrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 138, 0) -#define ADDE_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 138, 1) -#define ADDOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 0) -#define ADDO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 1) -#define ADDIrri(RD, RA, IMM) _D (14, RD, RA, IMM) -#define ADDICrri(RD, RA, IMM) _D (12, RD, RA, IMM) -#define ADDIC_rri(RD, RA, IMM) _D (13, RD, RA, IMM) -#define ADDISrri(RD, RA, IMM) _Ds (15, RD, RA, IMM) - -#define ANDrrr(RA, RS, RB) _X (31, RS, RA, RB, 28, 0) -#define AND_rrr(RA, RS, RB) _X (31, RS, RA, RB, 28, 1) -#define ANDCrrr(RA, RS, RB) _X (31, RS, RA, RB, 60, 0) -#define ANDC_rrr(RA, RS, RB) _X (31, RS, RA, RB, 60, 1) -#define ANDI_rri(RA, RS, IMM) _Du (28, RS, RA, IMM) -#define ANDIS_rri(RA, RS, IMM) _Du (29, RS, RA, IMM) - -#define Bi(BD) _FB (18, BD, 0, 0) -#define BAi(BD) _FBA (18, BD, 1, 0) -#define BLi(BD) _FB (18, BD, 0, 1) -#define BLAi(BD) _FBA (18, BD, 1, 1) - -#define BCiii(BO,BI,BD) _BB (16, BO, BI, BD, 0, 0) -#define BCAiii(BO,BI,BD) _BB (16, BO, BI, BD, 1, 0) -#define BCLiii(BO,BI,BD) _BB (16, BO, BI, BD, 0, 1) -#define BCLAiii(BO,BI,BD) _BB (16, BO, BI, BD, 1, 1) - -#define BCCTRii(BO,BI) _XL (19, BO, BI, 528, 0) -#define BCCTRLii(BO,BI) _XL (19, BO, BI, 528, 1) - -#define BCLRii(BO,BI) _XL (19, BO, BI, 16, 0) -#define BCLRLii(BO,BI) _XL (19, BO, BI, 16, 1) - -#define CMPiirr(CR, LL, RA, RB) _X (31, ((CR)<<2)|(LL), RA, RB, 0, 0) -#define CMPIiiri(CR, LL, RA, IMM) _D (11, ((CR)<<2)|(LL), RA, IMM) - -#define CMPLiirr(CR, LL, RA, RB) _X (31, ((CR)<<2)|(LL), RA, RB, 32, 0) -#define CMPLIiiri(CR, LL, RA, IMM) _D (10, ((CR)<<2)|(LL), RA, IMM) - -#define CRANDiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 257, 0) -#define CRANDCiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 129, 0) -#define CREQViii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 289, 0) -#define CRNANDiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 225, 0) -#define CRNORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 33, 0) -#define CRORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 449, 0) -#define CRORCiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 417, 0) -#define CRXORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 193, 0) - -#define DCBSTrr(RA,RB) _X (31, 00, RA, RB, 54, 0) - -#define DIVWrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 491, 0) -#define DIVW_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 491, 1) -#define DIVWOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 491, 0) -#define DIVWO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 491, 1) - -#define DIVWUrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 459, 0) -#define DIVWU_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 459, 1) -#define DIVWUOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 459, 0) -#define DIVWUO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 459, 1) - -#define EQVrrr(Ra,RS,RB) _X (31, RS, RA, RB, 284, 0) -#define EQV_rrr(Ra,RS,RB) _X (31, RS, RA, RB, 284, 1) - -#define EXTSBrr(RA,RS) _X (31, RS, RA, 0, 954, 0) -#define EXTSB_rr(RA,RS) _X (31, RS, RA, 0, 954, 1) - -#define EXTSHrr(RA,RS) _X (31, RS, RA, 0, 922, 0) -#define EXTSH_rr(RA,RS) _X (31, RS, RA, 0, 922, 1) - -#define ICBIrr(RA,RB) _X (31, 00, RA, RB, 982, 0) - -#define ISYNC() _X (19, 00, 00, 00, 150, 0) - -#define LBZrm(RD,ID,RA) _D (34, RD, RA, ID) -#define LBZUrm(RD,ID,RA) _D (35, RD, RA, ID) -#define LBZUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 119, 0) -#define LBZXrrr(RD,RA,RB) _X (31, RD, RA, RB, 87, 0) - -#define LHArm(RD,ID,RA) _D (42, RD, RA, ID) -#define LHAUrm(RD,ID,RA) _D (43, RD, RA, ID) -#define LHAUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 375, 0) -#define LHAXrrr(RD,RA,RB) _X (31, RD, RA, RB, 343, 0) -#define LHBRXrrr(RD,RA,RB) _X (31, RD, RA, RB, 790, 0) - -#define LHZrm(RD,ID,RA) _D (40, RD, RA, ID) -#define LHZUrm(RD,ID,RA) _D (41, RD, RA, ID) -#define LHZUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 311, 0) -#define LHZXrrr(RD,RA,RB) _X (31, RD, RA, RB, 279, 0) - -#define LMWrm(RD,ID,RA) _D (46, RD, RA, ID) - -#define LWBRXrrr(RD,RA,RB) _X (31, RD, RA, RB, 534, 0) - -#define LWZrm(RD, DISP, RA) _D (32, RD, RA, DISP) -#define LWZUrm(RD, DISP, RA) _D (33, RD, RA, DISP) -#define LWZUXrrr(RD, RA, RB) _X (31, RD, RA, RB, 56, 0) -#define LWZXrrr(RD, RA, RB) _X (31, RD, RA, RB, 23, 0) - -#define MCRFii(CD,CS) _X (19, ((CD)<<2), ((CS)<<2), 0, 0, 0) - -#define MFCRr(RD) _X (31, RD, 0, 0, 19, 0) -#define MCRXRi(RD) _XFX (31, (RD)<<2, 0, 512) - -#define MFSPRri(RD, SPR) _XFX (31, RD, (SPR)<<5, 339) -#define MTSPRir(SPR, RS) _XFX (31, RS, (SPR)<<5, 467) - -#define MULHWrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 75, 0) -#define MULHW_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 75, 1) -#define MULHWUrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 11, 0) -#define MULHWU_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 11, 1) - -#define MULLIrri(RD,RA,IM) _D (07, RD, RA, IM) - -#define MULLWrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 235, 0) -#define MULLW_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 235, 1) -#define MULLWOrrr(RD,RA,RB) _XO (31, RD, RA, RB, 1, 235, 0) -#define MULLWO_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 1, 235, 1) - -#define NANDrrr(RA,RS,RB) _X (31, RS, RA, RB, 476, 0) -#define NAND_rrr(RA,RS,RB) _X (31, RS, RA, RB, 476, 1) - -#define NEGrr(RD,RA) _XO (31, RD, RA, 0, 0, 104, 0) -#define NEG_rr(RD,RA) _XO (31, RD, RA, 0, 0, 104, 1) -#define NEGOrr(RD,RA) _XO (31, RD, RA, 0, 1, 104, 0) -#define NEGO_rr(RD,RA) _XO (31, RD, RA, 0, 1, 104, 1) - -#define NORrrr(RA,RS,RB) _X (31, RS, RA, RB, 124, 0) -#define NOR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 124, 1) - -#define ORrrr(RA,RS,RB) _X (31, RS, RA, RB, 444, 0) -#define OR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 444, 1) -#define ORCrrr(RA,RS,RB) _X (31, RS, RA, RB, 412, 0) -#define ORC_rrr(RA,RS,RB) _X (31, RS, RA, RB, 412, 1) -#define ORIrri(RA,RS,IM) _Du (24, RS, RA, IM) -#define ORISrri(RA,RS,IM) _Du (25, RS, RA, IM) - -#define RLWIMIrriii(RA,RS,SH,MB,ME) _M (20, RS, RA, SH, MB, ME, 0) -#define RLWIMI_rriii(RA,RS,SH,MB,ME) _M (20, RS, RA, SH, MB, ME, 1) - -#define RLWINMrriii(RA,RS,SH,MB,ME) _M (21, RS, RA, SH, MB, ME, 0) -#define RLWINM_rriii(RA,RS,SH,MB,ME) _M (21, RS, RA, SH, MB, ME, 1) - -#define RLWNMrrrii(RA,RS,RB,MB,ME) _M (23, RS, RA, RB, MB, ME, 0) -#define RLWNM_rrrii(RA,RS,RB,MB,ME) _M (23, RS, RA, RB, MB, ME, 1) - -#define SLWrrr(RA,RS,RB) _X (31, RS, RA, RB, 24, 0) -#define SLW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 24, 1) - -#define SRAWrrr(RA,RS,RB) _X (31, RS, RA, RB, 792, 0) -#define SRAW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 792, 1) - -#define SRAWIrri(RD, RS, SH) _X (31, RS, RD, SH, 824, 0) -#define SRAWI_rri(RD, RS, SH) _X (31, RS, RD, SH, 824, 1) - -#define SRWrrr(RA,RS,RB) _X (31, RS, RA, RB, 536, 0) -#define SRW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 536, 1) - -#define STBrm(RS,ID,RA) _D (38, RS, RA, ID) -#define STBUrm(RS,ID,RA) _D (39, RS, RA, ID) -#define STBUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 247, 0) -#define STBXrrr(RS,RA,RB) _X (31, RS, RA, RB, 215, 0) - -#define STHrm(RS,ID,RA) _D (44, RS, RA, ID) -#define STHUrm(RS,ID,RA) _D (45, RS, RA, ID) -#define STHBRXrrr(RS,RA,RB) _X (31, RS, RA, RB, 918, 0) -#define STHUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 439, 0) -#define STHXrrr(RS,RA,RB) _X (31, RS, RA, RB, 407, 0) - -#define STMWrm(RS,ID,RA) _D (47, RS, RA, ID) - -#define STWrm(RS,ID,RA) _D (36, RS, RA, ID) -#define STWBRXrrr(RS,RA,RB) _X (31, RS, RA, RB, 662, 0) -#define STWCXrrr(RS,RA,RB) _X (31, RS, RA, RB, 150, 0) -#define STWCX_rrr(RS,RA,RB) _X (31, RS, RA, RB, 150, 1) -#define STWUrm(RS,ID,RA) _D (37, RS, RA, ID) -#define STWUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 183, 0) -#define STWXrrr(RS,RA,RB) _X (31, RS, RA, RB, 151, 0) - -#define SUBFrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 0) -#define SUBF_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 1) -#define SUBFrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 0) -#define SUBF_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 1) -#define SUBFErrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 136, 0) -#define SUBFE_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 136, 1) -#define SUBFCrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 8, 0) -#define SUBFC_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 8, 1) -#define SUBFCOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 8, 0) -#define SUBFCO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 8, 1) -#define SUBFICrri(RD, RA, IMM) _D (8, RD, RA, IMM) - -#define ADDrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 0) -#define ADDOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 0) -#define ADDIrri(RD, RA, IMM) _D (14, RD, RA, IMM) -#define ADDISrri(RD, RA, IMM) _Ds (15, RD, RA, IMM) - -#define SYNC() _X (31, 00, 00, 00, 598, 0) - -#define TWirr(TO,RA,RB) _X (31, TO, RA, RB, 4, 0) -#define TWIiri(TO,RA,IM) _D (03, TO, RA, IM) - -#define XORrrr(RA,RS,RB) _X (31, RS, RA, RB, 316, 0) -#define XOR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 316, 1) -#define XORIrri(RA,RS,IM) _Du (26, RS, RA, IM) -#define XORISrri(RA,RS,IM) _Du (27, RS, RA, IM) - -/* simplified mnemonics [1, Appendix F] */ - -#define MOVEIri2(R,H,L) (LISri(R,H), (L ? ORIrri(R,R,L) : 0)) -#define MOVEIri(R,I) (_siP(16,I) ? LIri(R,I) : \ - MOVEIri2(R, _HI(I), _LO(I)) ) - -#define SUBIrri(RD,RA,IM) ADDIrri(RD,RA,-_LO((IM))) /* [1, Section F.2.1] */ -#define SUBISrri(RD,RA,IM) ADDISrri(RD,RA,-_LO((IM))) -#define SUBICrri(RD,RA,IM) ADDICrri(RD,RA,-_LO((IM))) -#define SUBIC_rri(RD,RA,IM) ADDIC_rri(RD,RA,-_LO((IM))) - -#define SUBrrr(RD,RA,RB) SUBFrrr(RD,RB,RA) /* [1, Section F.2.2] */ -#define SUBOrrr(RD,RA,RB) SUBFOrrr(RD,RB,RA) -#define SUB_rrr(RD,RA,RB) SUBF_rrr(RD,RB,RA) -#define SUBCrrr(RD,RA,RB) SUBFCrrr(RD,RB,RA) -#define SUBCOrrr(RD,RA,RB) SUBFCOrrr(RD,RB,RA) -#define SUBC_rrr(RD,RA,RB) SUBFC_rrr(RD,RB,RA) -#define SUBErrr(RD,RA,RB) SUBFErrr(RD,RB,RA) -#define SUBE_rrr(RD,RA,RB) SUBFE_rrr(RD,RB,RA) - -#define CMPWIiri(C,RA,IM) CMPIiiri(C,0,RA,IM) /* [1, Table F-2] */ -#define CMPWirr(C,RA,RB) CMPiirr(C,0,RA,RB) -#define CMPLWIiri(C,RA,IM) CMPLIiiri(C,0,RA,IM) -#define CMPLWirr(C,RA,RB) CMPLiirr(C,0,RA,RB) - -#define CMPWIri(RA,IM) CMPWIiri(0,RA,IM) /* with implicit _cr0 */ -#define CMPWrr(RA,RB) CMPWirr(0,RA,RB) -#define CMPLWIri(RA,IM) CMPLWIiri(0,RA,IM) -#define CMPLWrr(RA,RB) CMPLWirr(0,RA,RB) - -#define EXTLWIrrii(RA,RS,N,B) RLWINMrriii(RA, RS, B, 0, (N)-1) /* [1, Table F-3] */ -#define EXTRWIrrii(RA,RS,N,B) RLWINMrriii(RA, RS, (B)+(N), 32-(N), 31) -#define INSLWIrrii(RA,RS,N,B) RLWIMIrriii(RA, RS, 32-(B), B, (B)+(N)-1) -#define INSRWIrrii(RA,RS,N,B) RLWIMIrriii(RA, RS, 32-((B)+(N)), B, (B)+(N)-1) -#define ROTLWIrri(RA,RS,N) RLWINMrriii(RA, RS, N, 0, 31) -#define ROTRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 32-(N), 0, 31) -#define ROTLWrrr(RA,RS,RB) RLWNMrrrii( RA, RS, RB, 0, 31) -#define SLWIrri(RA,RS,N) RLWINMrriii(RA, RS, N, 0, 31-(N)) -#define SRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 32-(N), N, 31) -#define CLRLWIrri(RA,RS,N) RLWINMrriii(RA, RS, 0, N, 31) -#define CLRRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 0, 0, 31-(N)) -#define CLRLSLWIrrii(RA,RS,B,N) RLWINMrriii(RA, RS, N, (B)-(N), 31-(N)) - - -/* 9 below inverts the branch condition and the branch prediction. - * This has an incestuous knowledge of JIT_AUX */ -#define BC_EXT(A, C, D) (_siP(16, _jit_UL(D)-_jit_UL(_jit.x.pc)) \ - ? BCiii((A), (C), (D)) \ - : (BCiii((A)^9, (C), _jit.x.pc+5), \ - LISri(JIT_AUX,_HI(D)), \ - ORIrri(JIT_AUX,JIT_AUX,_LO(D)), \ - MTLRr(JIT_AUX), BLR() )) - -#define B_EXT(D) (_siP(16, _jit_UL(D)-_jit_UL(_jit.x.pc)) \ - ? Bi((D)) \ - : (LISri(JIT_AUX,_HI(D)), \ - ORIrri(JIT_AUX,JIT_AUX,_LO(D)), \ - MTLRr(JIT_AUX), BLR()) ) - -#define BTii(C,D) BC_EXT(12, C, D) /* [1, Table F-5] */ -#define BFii(C,D) BC_EXT( 4, C, D) -#define BDNZi(D) BCiii(16, 0, D) -#define BDNZTii(C,D) BC_EXT( 8, C, D) -#define BDNZFii(C,D) BC_EXT( 0, C, D) -#define BDZi(D) BCiii(18, 0, D) -#define BDZTii(C,D) BC_EXT(10, C, D) -#define BDZFii(C,D) BC_EXT( 2, C, D) - -#define BCTR() BCCTRii(20, 0) /* [1, Table F-6] */ -#define BCTRL() BCCTRLii(20, 0) - -#define BLR() BCLRii(20, 0) /* [1, Table F-6] */ -#define BLRL() BCLRLii(20, 0) - - -#define BLTLRi(CR) BCLRii(12, ((CR)<<2)+0) /* [1, Table F-10] */ -#define BLELRi(CR) BCLRii( 4, ((CR)<<2)+1) -#define BEQLRi(CR) BCLRii(12, ((CR)<<2)+2) -#define BGELRi(CR) BCLRii( 4, ((CR)<<2)+0) -#define BGTLRi(CR) BCLRii(12, ((CR)<<2)+1) -#define BNLLRi(CR) BCLRii( 4, ((CR)<<2)+0) -#define BNELRi(CR) BCLRii( 4, ((CR)<<2)+2) -#define BNGLRi(CR) BCLRii( 4, ((CR)<<2)+1) -#define BSOLRi(CR) BCLRii(12, ((CR)<<2)+3) -#define BNSLRi(CR) BCLRii( 4, ((CR)<<2)+3) -#define BUNLRi(CR) BCLRii(12, ((CR)<<2)+3) -#define BNULRi(CR) BCLRii( 4, ((CR)<<2)+3) - -#define BLTLRLi(CR) BCLRLii(12, ((CR)<<2)+0) /* [1, Table F-10] */ -#define BLELRLi(CR) BCLRLii( 4, ((CR)<<2)+1) -#define BEQLRLi(CR) BCLRLii(12, ((CR)<<2)+2) -#define BGELRLi(CR) BCLRLii( 4, ((CR)<<2)+0) -#define BGTLRLi(CR) BCLRLii(12, ((CR)<<2)+1) -#define BNLLRLi(CR) BCLRLii( 4, ((CR)<<2)+0) -#define BNELRLi(CR) BCLRLii( 4, ((CR)<<2)+2) -#define BNGLRLi(CR) BCLRLii( 4, ((CR)<<2)+1) -#define BSOLRLi(CR) BCLRLii(12, ((CR)<<2)+3) -#define BNSLRLi(CR) BCLRLii( 4, ((CR)<<2)+3) -#define BUNLRLi(CR) BCLRLii(12, ((CR)<<2)+3) -#define BNULRLi(CR) BCLRLii( 4, ((CR)<<2)+3) - -#define BLTCTRi(CR) BCCTRii(12, ((CR)<<2)+0) /* [1, Table F-10] */ -#define BLECTRi(CR) BCCTRii( 4, ((CR)<<2)+1) -#define BEQCTRi(CR) BCCTRii(12, ((CR)<<2)+2) -#define BGECTRi(CR) BCCTRii( 4, ((CR)<<2)+0) -#define BGTCTRi(CR) BCCTRii(12, ((CR)<<2)+1) -#define BNLCTRi(CR) BCCTRii( 4, ((CR)<<2)+0) -#define BNECTRi(CR) BCCTRii( 4, ((CR)<<2)+2) -#define BNGCTRi(CR) BCCTRii( 4, ((CR)<<2)+1) -#define BSOCTRi(CR) BCCTRii(12, ((CR)<<2)+3) -#define BNSCTRi(CR) BCCTRii( 4, ((CR)<<2)+3) -#define BUNCTRi(CR) BCCTRii(12, ((CR)<<2)+3) -#define BNUCTRi(CR) BCCTRii( 4, ((CR)<<2)+3) - -#define BLTCTRLi(CR) BCCTRLii(12, ((CR)<<2)+0) /* [1, Table F-10] */ -#define BLECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+1) -#define BEQCTRLi(CR) BCCTRLii(12, ((CR)<<2)+2) -#define BGECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+0) -#define BGTCTRLi(CR) BCCTRLii(12, ((CR)<<2)+1) -#define BNLCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+0) -#define BNECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+2) -#define BNGCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+1) -#define BSOCTRLi(CR) BCCTRLii(12, ((CR)<<2)+3) -#define BNSCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+3) -#define BUNCTRLi(CR) BCCTRLii(12, ((CR)<<2)+3) -#define BNUCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+3) - - -#define BLTLR() BLTLRi(0) /* with implicit _cr0 */ -#define BLELR() BLELRi(0) -#define BEQLR() BEQLRi(0) -#define BGELR() BGELRi(0) -#define BGTLR() BGTLRi(0) -#define BNLLR() BNLLRi(0) -#define BNELR() BNELRi(0) -#define BNGLR() BNGLRi(0) -#define BSOLR() BSOLRi(0) -#define BNSLR() BNSLRi(0) -#define BUNLR() BUNLRi(0) -#define BNULR() BNULRi(0) - -#define BLTLRL() BLTLRLi(0) -#define BLELRL() BLELRLi(0) -#define BEQLRL() BEQLRLi(0) -#define BGELRL() BGELRLi(0) -#define BGTLRL() BGTLRLi(0) -#define BNLLRL() BNLLRLi(0) -#define BNELRL() BNELRLi(0) -#define BNGLRL() BNGLRLi(0) -#define BSOLRL() BSOLRLi(0) -#define BNSLRL() BNSLRLi(0) -#define BUNLRL() BUNLRLi(0) -#define BNULRL() BNULRLi(0) - -#define BLTCTR() BLTCTRi(0) -#define BLECTR() BLECTRi(0) -#define BEQCTR() BEQCTRi(0) -#define BGECTR() BGECTRi(0) -#define BGTCTR() BGTCTRi(0) -#define BNLCTR() BNLCTRi(0) -#define BNECTR() BNECTRi(0) -#define BNGCTR() BNGCTRi(0) -#define BSOCTR() BSOCTRi(0) -#define BNSCTR() BNSCTRi(0) -#define BUNCTR() BUNCTRi(0) -#define BNUCTR() BNUCTRi(0) - -#define BLTCTRL() BLTCTRLi(0) -#define BLECTRL() BLECTRLi(0) -#define BEQCTRL() BEQCTRLi(0) -#define BGECTRL() BGECTRLi(0) -#define BGTCTRL() BGTCTRLi(0) -#define BNLCTRL() BNLCTRLi(0) -#define BNECTRL() BNECTRLi(0) -#define BNGCTRL() BNGCTRLi(0) -#define BSOCTRL() BSOCTRLi(0) -#define BNSCTRL() BNSCTRLi(0) -#define BUNCTRL() BUNCTRLi(0) -#define BNUCTRL() BNUCTRLi(0) - - -#define BLTii(C,D) BC_EXT(12, ((C)<<2)+0, D) /* [1, Table F-11] */ -#define BNLii(C,D) BC_EXT( 4, ((C)<<2)+0, D) -#define BGEii(C,D) BC_EXT( 4, ((C)<<2)+0, D) -#define BGTii(C,D) BC_EXT(12, ((C)<<2)+1, D) -#define BNGii(C,D) BC_EXT( 4, ((C)<<2)+1, D) -#define BLEii(C,D) BC_EXT( 4, ((C)<<2)+1, D) -#define BEQii(C,D) BC_EXT(12, ((C)<<2)+2, D) -#define BNEii(C,D) BC_EXT( 4, ((C)<<2)+2, D) -#define BSOii(C,D) BC_EXT(12, ((C)<<2)+3, D) -#define BNSii(C,D) BC_EXT( 4, ((C)<<2)+3, D) -#define BUNii(C,D) BC_EXT(12, ((C)<<2)+3, D) -#define BNUii(C,D) BC_EXT( 4, ((C)<<2)+3, D) - -#define BLTi(D) BLTii(0,D) /* with implicit _cr0 */ -#define BLEi(D) BLEii(0,D) -#define BEQi(D) BEQii(0,D) -#define BGEi(D) BGEii(0,D) -#define BGTi(D) BGTii(0,D) -#define BNLi(D) BNLii(0,D) -#define BNEi(D) BNEii(0,D) -#define BNGi(D) BNGii(0,D) -#define BSOi(D) BSOii(0,D) -#define BNSi(D) BNSii(0,D) -#define BUNi(D) BUNii(0,D) -#define BNUi(D) BNUii(0,D) - -#define BLTLii(C,D) BCLiii(12, ((C)<<2)+0, D) /* [1, Table F-??] */ -#define BLELii(C,D) BCLiii( 4, ((C)<<2)+1, D) -#define BEQLii(C,D) BCLiii(12, ((C)<<2)+2, D) -#define BGELii(C,D) BCLiii( 4, ((C)<<2)+0, D) -#define BGTLii(C,D) BCLiii(12, ((C)<<2)+1, D) -#define BNLLii(C,D) BCLiii( 4, ((C)<<2)+0, D) -#define BNELii(C,D) BCLiii( 4, ((C)<<2)+2, D) -#define BNGLii(C,D) BCLiii( 4, ((C)<<2)+1, D) -#define BSOLii(C,D) BCLiii(12, ((C)<<2)+3, D) -#define BNSLii(C,D) BCLiii( 4, ((C)<<2)+3, D) -#define BUNLii(C,D) BCLiii(12, ((C)<<2)+3, D) -#define BNULii(C,D) BCLiii( 4, ((C)<<2)+3, D) - -#define BLTLi(D) BLTLii(0,D) /* with implicit _cr0 */ -#define BLELi(D) BLELii(0,D) -#define BEQLi(D) BEQLii(0,D) -#define BGELi(D) BGELii(0,D) -#define BGTLi(D) BGTLii(0,D) -#define BNLLi(D) BNLLii(0,D) -#define BNELi(D) BNELii(0,D) -#define BNGLi(D) BNGLii(0,D) -#define BSOLi(D) BSOLii(0,D) -#define BNSLi(D) BNSLii(0,D) -#define BUNLi(D) BUNLii(0,D) -#define BNULi(D) BNULii(0,D) - -/* Note: there are many tens of other simplified branches that are not (yet?) defined here */ - -#define CRSETi(BX) CREQViii(BX, BX, BX) /* [1, Table F-15] */ -#define CRCLRi(BX) CRXORiii(BX, BX, BX) -#define CRMOVEii(BX,BY) CRORiii(BX, BY, BY) -#define CRNOTii(BX,BY) CRNORiii(BX, BY, BY) - -#define MTLRr(RS) MTSPRir(8, RS) /* [1, Table F-20] */ -#define MFLRr(RD) MFSPRri(RD, 8) -#define MTCTRr(RS) MTSPRir(9, RS) -#define MFCTRr(RD) MFSPRri(RD, 9) -#define MTXERr(RS) MTSPRir(1, RS) -#define MFXERr(RD) MFSPRri(RD, 1) - -#define NOP() ORIrri(0, 0, 0) /* [1, Section F.9] */ -#define LIri(RD,IM) ADDIrri(RD, 0, IM) -#define LISri(RD,IM) ADDISrri(RD, 0, IM) -#define LArm(RD,D,RA) ADDIrri(RD, RA, D) -#define LArrr(RD,RB,RA) ADDIrrr(RD, RA, RB) -#define MRrr(RA,RS) ORrrr(RA, RS, RS) -#define NOTrr(RA,RS) NORrrr(RA, RS, RS) - -/* alternative parenthesised forms of extended indexed load/store insns */ - -#define LBZUrx(RD,RA,RB) LBZUXrrr(RD,RA,RB) -#define LBZrx(RD,RA,RB) LBZXrrr(RD,RA,RB) -#define LHAUrx(RD,RA,RB) LHAUXrrr(RD,RA,RB) -#define LHArx(RD,RA,RB) LHAXrrr(RD,RA,RB) -#define LHBRrx(RD,RA,RB) LHBRXrrr(RD,RA,RB) -#define LHZUrx(RD,RA,RB) LHZUXrrr(RD,RA,RB) -#define LHZrx(RD,RA,RB) LHZXrrr(RD,RA,RB) -#define LWBRrx(RD,RA,RB) LWBRXrrr(RD,RA,RB) -#define LWZUrx(RD, RA, RB) LWZUXrrr(RD, RA, RB) -#define LWZrx(RD, RA, RB) LWZXrrr(RD, RA, RB) -#define STBUrx(RD,RA,RB) STBUXrrr(RD,RA,RB) -#define STBrx(RD,RA,RB) STBXrrr(RD,RA,RB) -#define STHBRrx(RS,RA,RB) STHBRXrrr(RS,RA,RB) -#define STHUrx(RS,RA,RB) STHUXrrr(RS,RA,RB) -#define STHrx(RS,RA,RB) STHXrrr(RS,RA,RB) -#define STWBRrx(RS,RA,RB) STWBRXrrr(RS,RA,RB) -#define STWCrx(RS,RA,RB) STWCXrrr(RS,RA,RB) -#define STWCX_rx(RS,RA,RB) STWCX_rrr(RS,RA,RB) -#define STWUrx(RS,RA,RB) STWUXrrr(RS,RA,RB) -#define STWrx(RS,RA,RB) STWXrrr(RS,RA,RB) -#define LArx(RD,RB,RA) LArrr(RD,RB,RA) - - -#define _LO(I) (_jit_UL(I) & _MASK(16)) -#define _HI(I) (_jit_UL(I) >> (16)) - -#define _A(OP,RD,RA,RB,RC,XO,RCx) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)|_u5(RC)<<6|(_u5(XO)<<1)|_u1(RCx)) - -#define LFDrri(RD,RA,imm) _D(50,RD,RA,imm) -#define LFDUrri(RD,RA,imm) _D(51,RD,RA,imm) -#define LFDUxrrr(RD,RA,RB) _X(31,RD,RA,RB,631,0) -#define LFDxrrr(RD,RA,RB) _X(31,RD,RA,RB,599,0) - -#define LFSrri(RD,RA,imm) _D(48,RD,RA,imm) -#define LFSUrri(RD,RA,imm) _D(49,RD,RA,imm) -#define LFSUxrrr(RD,RA,RB) _X(31,RD,RA,RB,567,0) -#define LFSxrrr(RD,RA,RB) _X(31,RD,RA,RB,535,0) - -#define STFDrri(RS,RA,imm) _D(54,RS,RA,imm) -#define STFDUrri(RS,RA,imm) _D(55,RS,RA,imm) -#define STFDUxrrr(RS,RA,RB) _X(31,RS,RA,RB,759,0) -#define STFDxrrr(RS,RA,RB) _X(31,RS,RA,RB,727,0) - -#define STFSrri(RS,RA,imm) _D(52,RS,RA,imm) -#define STFSUrri(RS,RA,imm) _D(53,RS,RA,imm) -#define STFSUxrrr(RS,RA,RB) _X(31,RS,RA,RB,695,0) -#define STFSxrrr(RS,RA,RB) _X(31,RS,RA,RB,663,0) -#define STFIWXrrr(RS,RA,RB) _X(31,RS,RA,RB,983,0) - -#define FADDDrrr(RD,RA,RB) _A(63,RD,RA,RB,0,21,0) -#define FADDSrrr(RD,RA,RB) _A(59,RD,RA,RB,0,21,0) -#define FSUBDrrr(RD,RA,RB) _A(63,RD,RA,RB,0,20,0) -#define FSUBSrrr(RD,RA,RB) _A(59,RD,RA,RB,0,20,0) -#define FMULDrrr(RD,RA,RC) _A(63,RD,RA,0,RC,25,0) -#define FMULSrrr(RD,RA,RC) _A(59,RD,RA,0,RC,25,0) -#define FDIVDrrr(RD,RA,RB) _A(63,RD,RA,RB,0,18,0) -#define FDIVSrrr(RD,RA,RB) _A(59,RD,RA,RB,0,25,0) -#define FSQRTDrr(RD,RB) _A(63,RD,0,RB,0,22,0) -#define FSQRTSrr(RD,RB) _A(59,RD,0,RB,0,22,0) -#define FSELrrrr(RD,RA,RB,RC) _A(63,RD,RA,RB,RC,23,0) -#define FCTIWrr(RD,RB) _X(63,RD,0,RB,14,0) -#define FCTIWZrr(RD,RB) _X(63,RD,0,RB,15,0) -#define FRSPrr(RD,RB) _X(63,RD,0,RB,12,0) -#define FABSrr(RD,RB) _X(63,RD,0,RB,264,0) -#define FNABSrr(RD,RB) _X(63,RD,0,RB,136,0) -#define FNEGrr(RD,RB) _X(63,RD,0,RB,40,0) -#define FMOVErr(RD,RB) _X(63,RD,0,RB,72,0) -#define FCMPOrrr(CR,RA,RB) _X(63,_u3((CR)<<2),RA,RB,32,0) -#define FCMPUrrr(CR,RA,RB) _X(63,_u3((CR)<<2),RA,RB,0,0) -#define MTFSFIri(CR,IMM) _X(63,_u5((CR)<<2),0,_u5((IMM)<<1),134,0) - -/*** References: - * - * [1] "PowerPC Microprocessor Family: The Programming Environments For 32-Bit Microprocessors", Motorola, 1997. - */ - - -#endif -#endif /* __ccg_asm_ppc_h */ diff --git a/src/runtime/c/pgf/lightning/ppc/core.h b/src/runtime/c/pgf/lightning/ppc/core.h deleted file mode 100644 index 14eaae336..000000000 --- a/src/runtime/c/pgf/lightning/ppc/core.h +++ /dev/null @@ -1,298 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer (PowerPC version) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - - -#ifndef __lightning_core_h -#define __lightning_core_h - -struct jit_local_state { - int nextarg_puti; /* number of integer args */ - int nextarg_putf; /* number of float args */ - int nextarg_putd; /* number of double args */ - int nextarg_geti; /* Next r20-r25 reg. to be read */ - int nextarg_getd; /* The FP args are picked up from FPR1 -> FPR10 */ - int nbArgs; /* Number of arguments for the prolog */ -}; - -#define JIT_SP 1 -#define JIT_RET 3 -#define JIT_R_NUM 3 -#define JIT_V_NUM 7 -#define JIT_R(i) (9+(i)) -#define JIT_V(i) (31-(i)) -#define JIT_AUX JIT_V(JIT_V_NUM) /* for 32-bit operands & shift counts */ - -#define jit_pfx_start() (_jit.jitl.trampolines) -#define jit_pfx_end() (_jit.jitl.free) - -/* If possible, use the `small' instruction (rd, rs, imm) - * else load imm into r26 and use the `big' instruction (rd, rs, r26) - */ -#define jit_chk_ims(imm, small, big) (_siP(16,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) ) -#define jit_chk_imu(imm, small, big) (_uiP(16,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) ) -#define jit_chk_imu15(imm, small, big) (_uiP(15,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) ) - -#define jit_big_ims(imm, big) (MOVEIri(JIT_AUX, imm), (big)) -#define jit_big_imu(imm, big) (MOVEIri(JIT_AUX, imm), (big)) - -/* Helper macros for branches */ -#define jit_s_brai(rs, is, jmp) (jit_chk_ims (is, CMPWIri(rs, is), CMPWrr(rs, JIT_AUX)), jmp, _jit.x.pc) -#define jit_s_brar(s1, s2, jmp) ( CMPWrr(s1, s2), jmp, _jit.x.pc) -#define jit_u_brai(rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), jmp, _jit.x.pc) -#define jit_u_brar(s1, s2, jmp) ( CMPLWrr(s1, s2), jmp, _jit.x.pc) - -/* Helper macros for boolean tests. */ -#define jit_sbooli(d, rs, is, jmp) (jit_chk_ims (is, CMPWIri (rs, is), CMPWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp))) -#define jit_sboolr(d, s1, s2, jmp) ( CMPWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp))) -#define jit_sbooli2(d, rs, is, jmp) (jit_chk_ims (is, CMPWIri (rs, is), CMPWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1)) -#define jit_sboolr2(d, s1, s2, jmp) ( CMPWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1)) -#define jit_ubooli(d, rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp))) -#define jit_uboolr(d, s1, s2, jmp) ( CMPLWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp))) -#define jit_ubooli2(d, rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1)) -#define jit_uboolr2(d, s1, s2, jmp) ( CMPLWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1)) - -/* modulus with immediate - * movei r26, imm - * mtlr r31 - * divw r31, rs, r26 (or divwu) - * mullw r31, r31, r26 - * sub rs, rs, r26 - * mflr r31 - */ - -#define _jit_mod(div, rs, imm) (MOVEIri(JIT_AUX, (imm)), MTLRr(31), (div), \ - MULLWrrr(31, 31, JIT_AUX), SUBrrr((rs), (rs), JIT_AUX), \ - MFLRr(31)) - -/* Patch a movei instruction made of a LIS at lis_pc and an ORI at ori_pc. */ -#define jit_patch_movei(lis_pc, ori_pc, dest) \ - (*(lis_pc) &= ~_MASK(16), *(lis_pc) |= _HI(dest), \ - *(ori_pc) &= ~_MASK(16), *(ori_pc) |= _LO(dest)) \ - -/* Patch a branch instruction */ -#define jit_patch_branch(jump_pc,pv) \ - (*(jump_pc) &= ~_MASK(16) | 3, \ - *(jump_pc) |= (_jit_UL(pv) - _jit_UL(jump_pc)) & _MASK(16)) - -#define jit_patch_ucbranch(jump_pc,pv) \ - (*(jump_pc) &= ~_MASK(26) | 3, \ - (*(jump_pc) |= (_jit_UL((pv)) - _jit_UL(jump_pc)) & _MASK(26))) - -#define _jit_b_encoding (18 << 26) -#define _jit_blr_encoding ((19 << 26) | (20 << 21) | (00 << 16) | (00 << 11) | (16 << 1)) -#define _jit_is_ucbranch(a) (((*(a) & (63<<26)) == _jit_b_encoding)) - -#define jit_patch_at(jump_pc, value) ( \ - ((*(jump_pc - 1) & ~1) == _jit_blr_encoding) \ - ? jit_patch_movei(((jump_pc) - 4), ((jump_pc) - 3), (value)) \ - : ( _jit_is_ucbranch((jump_pc) - 1) \ - ? jit_patch_ucbranch((jump_pc) - 1, (value)) \ - : jit_patch_branch((jump_pc) - 1, (value)))) - -#define jit_patch_movi(movi_pc, val) \ - jit_patch_movei((movi_pc) - 2, (movi_pc) - 1, (val)) - -#define jit_arg_c() (_jitl.nextarg_geti--) -#define jit_arg_i() (_jitl.nextarg_geti--) -#define jit_arg_l() (_jitl.nextarg_geti--) -#define jit_arg_p() (_jitl.nextarg_geti--) -#define jit_arg_s() (_jitl.nextarg_geti--) -#define jit_arg_uc() (_jitl.nextarg_geti--) -#define jit_arg_ui() (_jitl.nextarg_geti--) -#define jit_arg_ul() (_jitl.nextarg_geti--) -#define jit_arg_us() (_jitl.nextarg_geti--) - -/* Check Mach-O-Runtime documentation: Must skip GPR(s) whenever "corresponding" FPR is used */ -#define jit_arg_f() (_jitl.nextarg_geti-- ,_jitl.nextarg_getd++) -#define jit_arg_d() (_jitl.nextarg_geti-=2,_jitl.nextarg_getd++) - -#define jit_addi_i(d, rs, is) jit_chk_ims((is), ADDICrri((d), (rs), (is)), ADDrrr((d), (rs), JIT_AUX)) -#define jit_addr_i(d, s1, s2) ADDrrr((d), (s1), (s2)) -#define jit_addci_i(d, rs, is) jit_chk_ims((is), ADDICrri((d), (rs), (is)), ADDCrrr((d), (rs), JIT_AUX)) -#define jit_addcr_i(d, s1, s2) ADDCrrr((d), (s1), (s2)) -#define jit_addxi_i(d, rs, is) (MOVEIri(JIT_AUX, (is)), ADDErrr((d), (rs), JIT_AUX)) -#define jit_addxr_i(d, s1, s2) ADDErrr((d), (s1), (s2)) -#define jit_andi_i(d, rs, is) jit_chk_imu((is), ANDI_rri((d), (rs), (is)), ANDrrr((d), (rs), JIT_AUX)) -#define jit_andr_i(d, s1, s2) ANDrrr((d), (s1), (s2)) -#define jit_bmsi_i(label, rs, is) (jit_chk_imu((is), ANDI_rri(JIT_AUX, (rs), (is)), AND_rrr(JIT_AUX, (rs), JIT_AUX)), BGTi((label)), _jit.x.pc) -#define jit_bmci_i(label, rs, is) (jit_chk_imu((is), ANDI_rri(JIT_AUX, (rs), (is)), AND_rrr(JIT_AUX, (rs), JIT_AUX)), BEQi((label)), _jit.x.pc) -#define jit_bmsr_i(label, s1, s2) ( AND_rrr(JIT_AUX, (s1), (s2)), BGTi((label)), _jit.x.pc) -#define jit_bmcr_i(label, s1, s2) ( AND_rrr(JIT_AUX, (s1), (s2)), BEQi((label)), _jit.x.pc) -#define jit_beqi_i(label, rs, is) jit_s_brai((rs), (is), BEQi((label)) ) -#define jit_beqr_i(label, s1, s2) jit_s_brar((s1), (s2), BEQi((label)) ) -#define jit_bgei_i(label, rs, is) jit_s_brai((rs), (is), BGEi((label)) ) -#define jit_bgei_ui(label, rs, is) jit_u_brai((rs), (is), BGEi((label)) ) -#define jit_bger_i(label, s1, s2) jit_s_brar((s1), (s2), BGEi((label)) ) -#define jit_bger_ui(label, s1, s2) jit_u_brar((s1), (s2), BGEi((label)) ) -#define jit_bgti_i(label, rs, is) jit_s_brai((rs), (is), BGTi((label)) ) -#define jit_bgti_ui(label, rs, is) jit_u_brai((rs), (is), BGTi((label)) ) -#define jit_bgtr_i(label, s1, s2) jit_s_brar((s1), (s2), BGTi((label)) ) -#define jit_bgtr_ui(label, s1, s2) jit_u_brar((s1), (s2), BGTi((label)) ) -#define jit_blei_i(label, rs, is) jit_s_brai((rs), (is), BLEi((label)) ) -#define jit_blei_ui(label, rs, is) jit_u_brai((rs), (is), BLEi((label)) ) -#define jit_bler_i(label, s1, s2) jit_s_brar((s1), (s2), BLEi((label)) ) -#define jit_bler_ui(label, s1, s2) jit_u_brar((s1), (s2), BLEi((label)) ) -#define jit_blti_i(label, rs, is) jit_s_brai((rs), (is), BLTi((label)) ) -#define jit_blti_ui(label, rs, is) jit_u_brai((rs), (is), BLTi((label)) ) -#define jit_bltr_i(label, s1, s2) jit_s_brar((s1), (s2), BLTi((label)) ) -#define jit_bltr_ui(label, s1, s2) jit_u_brar((s1), (s2), BLTi((label)) ) -#define jit_bnei_i(label, rs, is) jit_s_brai((rs), (is), BNEi((label)) ) -#define jit_bner_i(label, s1, s2) jit_s_brar((s1), (s2), BNEi((label)) ) -#define jit_boaddi_i(label, rs, is) (MOVEIri(JIT_AUX, (is)), ADDOrrr((rs), (rs), JIT_AUX), MCRXRi(0), BGTi((label)), _jit.x.pc) /* GT = bit 1 of XER = OV */ -#define jit_bosubi_i(label, rs, is) (MOVEIri(JIT_AUX, (is)), SUBCOrrr((rs), (rs), JIT_AUX), MCRXRi(0), BGTi((label)), _jit.x.pc) -#define jit_boaddr_i(label, s1, s2) ( ADDOrrr((s1), (s1), (s2)), MCRXRi(0), BGTi((label)), _jit.x.pc) -#define jit_bosubr_i(label, s1, s2) ( SUBCOrrr((s1), (s1), (s2)), MCRXRi(0), BGTi((label)), _jit.x.pc) -#define jit_boaddi_ui(label, rs, is) (jit_chk_ims ((is), ADDICri((rs), (rs), is), ADDCrr((rs), JIT_AUX)), MCRXRi(0), BEQi((label)), _jit.x.pc) /* EQ = bit 2 of XER = CA */ -#define jit_bosubi_ui(label, rs, is) (jit_chk_ims ((is), SUBICri((rs), (rs), is), SUBCrr((rs), JIT_AUX)), MCRXRi(0), BEQi((label)), _jit.x.pc) -#define jit_boaddr_ui(label, s1, s2) ( ADDCrr((s1), (s1), (s2)), MCRXRi(0), BEQi((label)), _jit.x.pc) -#define jit_bosubr_ui(label, s1, s2) ( SUBCrr((s1), (s1), (s2)), MCRXRi(0), BEQi((label)), _jit.x.pc) -#define jit_calli(label) (jit_movi_p(JIT_AUX, (label)), MTCTRr(JIT_AUX), BCTRL(), _jitl.nextarg_puti = _jitl.nextarg_putf = _jitl.nextarg_putd = 0, _jit.x.pc) -#define jit_callr(reg) (MTCTRr(reg), BCTRL()) -#define jit_divi_i(d, rs, is) jit_big_ims((is), DIVWrrr ((d), (rs), JIT_AUX)) -#define jit_divi_ui(d, rs, is) jit_big_imu((is), DIVWUrrr((d), (rs), JIT_AUX)) -#define jit_divr_i(d, s1, s2) DIVWrrr ((d), (s1), (s2)) -#define jit_divr_ui(d, s1, s2) DIVWUrrr((d), (s1), (s2)) -#define jit_eqi_i(d, rs, is) (jit_chk_ims((is), SUBIrri(JIT_AUX, (rs), (is)), SUBrrr(JIT_AUX, (rs), JIT_AUX)), SUBFICrri((d), JIT_AUX, 0), ADDErrr((d), (d), JIT_AUX)) -#define jit_eqr_i(d, s1, s2) (SUBrrr(JIT_AUX, (s1), (s2)), SUBFICrri((d), JIT_AUX, 0), ADDErrr((d), (d), JIT_AUX)) -#define jit_extr_c_i(d, rs) EXTSBrr((d), (rs)) -#define jit_extr_s_i(d, rs) EXTSHrr((d), (rs)) -#define jit_gei_i(d, rs, is) jit_sbooli2((d), (rs), (is), _lt) -#define jit_gei_ui(d, rs, is) jit_ubooli2((d), (rs), (is), _lt) -#define jit_ger_i(d, s1, s2) jit_sboolr2((d), (s1), (s2), _lt) -#define jit_ger_ui(d, s1, s2) jit_uboolr2((d), (s1), (s2), _lt) -#define jit_gti_i(d, rs, is) jit_sbooli ((d), (rs), (is), _gt) -#define jit_gti_ui(d, rs, is) jit_ubooli ((d), (rs), (is), _gt) -#define jit_gtr_i(d, s1, s2) jit_sboolr ((d), (s1), (s2), _gt) -#define jit_gtr_ui(d, s1, s2) jit_uboolr ((d), (s1), (s2), _gt) -#define jit_hmuli_i(d, rs, is) jit_big_ims((is), MULHWrrr ((d), (rs), JIT_AUX)) -#define jit_hmuli_ui(d, rs, is) jit_big_imu((is), MULHWUrrr((d), (rs), JIT_AUX)) -#define jit_hmulr_i(d, s1, s2) MULHWrrr ((d), (s1), (s2)) -#define jit_hmulr_ui(d, s1, s2) MULHWUrrr((d), (s1), (s2)) -#define jit_jmpi(label) (B_EXT((label)), _jit.x.pc) -#define jit_jmpr(reg) (MTLRr(reg), BLR()) -#define jit_ldxi_c(d, rs, is) (jit_ldxi_uc((d), (rs), (is)), jit_extr_c_i((d), (d))) -#define jit_ldxr_c(d, s1, s2) (jit_ldxr_uc((d), (s1), (s2)), jit_extr_c_i((d), (d))) -#define jit_ldxi_i(d, rs, is) jit_chk_ims((d), LWZrm((d), (is), (rs)), LWZrx((d), JIT_AUX, (rs))) -#define jit_ldxi_s(d, rs, is) jit_chk_ims((d), LHArm((d), (is), (rs)), LHArx((d), JIT_AUX, (rs))) -#define jit_ldxi_uc(d, rs, is) jit_chk_ims((d), LBZrm((d), (is), (rs)), LBZrx((d), JIT_AUX, (rs))) -#define jit_ldxi_us(d, rs, is) jit_chk_ims((d), LHZrm((d), (is), (rs)), LHZrx((d), JIT_AUX, (rs))) -#define jit_ldxr_i(d, s1, s2) LWZrx((d), (s1), (s2)) -#define jit_ldxr_s(d, s1, s2) LHArx((d), (s1), (s2)) -#define jit_ldxr_uc(d, s1, s2) LBZrx((d), (s1), (s2)) -#define jit_ldxr_us(d, s1, s2) LHZrx((d), (s1), (s2)) -#define jit_lei_i(d, rs, is) jit_sbooli2((d), (rs), (is), _gt ) -#define jit_lei_ui(d, rs, is) jit_ubooli2((d), (rs), (is), _gt ) -#define jit_ler_i(d, s1, s2) jit_sboolr2((d), (s1), (s2), _gt ) -#define jit_ler_ui(d, s1, s2) jit_uboolr2((d), (s1), (s2), _gt ) -#define jit_lshi_i(d, rs, is) SLWIrri((d), (rs), (is)) -#define jit_lshr_i(d, s1, s2) (ANDI_rri(JIT_AUX, (s2), 31), SLWrrr ((d), (s1), JIT_AUX)) -#define jit_lti_i(d, rs, is) jit_sbooli ((d), (rs), (is), _lt ) -#define jit_lti_ui(d, rs, is) jit_ubooli ((d), (rs), (is), _lt ) -#define jit_ltr_i(d, s1, s2) jit_sboolr ((d), (s1), (s2), _lt ) -#define jit_ltr_ui(d, s1, s2) jit_uboolr ((d), (s1), (s2), _lt ) -#define jit_modi_i(d, rs, is) _jit_mod(jit_divi_i (31, (rs), JIT_AUX), (rs), (is)) -#define jit_modi_ui(d, rs, is) _jit_mod(jit_divi_ui(31, (rs), JIT_AUX), (rs), (is)) -#define jit_modr_i(d, s1, s2) (DIVWrrr(JIT_AUX, (s1), (s2)), MULLWrrr(JIT_AUX, JIT_AUX, (s2)), SUBrrr((d), (s1), JIT_AUX)) -#define jit_modr_ui(d, s1, s2) (DIVWUrrr(JIT_AUX, (s1), (s2)), MULLWrrr(JIT_AUX, JIT_AUX, (s2)), SUBrrr((d), (s1), JIT_AUX)) -#define jit_movi_i(d, is) MOVEIri((d), (is)) -#define jit_movi_p(d, is) (LISri((d), _HI((is))),ORIrri((d),(d),_LO((is))),_jit.x.pc) - -#define jit_movr_i(d, rs) MRrr((d), (rs)) -#define jit_muli_i(d, rs, is) jit_chk_ims ((is), MULLIrri((d), (rs), (is)), MULLWrrr((d), (rs), JIT_AUX)) -#define jit_muli_ui(d, rs, is) jit_chk_imu15((is), MULLIrri((d), (rs), (is)), MULLWrrr((d), (rs), JIT_AUX)) -#define jit_mulr_i(d, s1, s2) MULLWrrr((d), (s1), (s2)) -#define jit_mulr_ui(d, s1, s2) MULLWrrr((d), (s1), (s2)) -#define jit_nei_i(d, rs, is) (jit_chk_ims((is), SUBIrri(JIT_AUX, (rs), (is)), SUBrrr(JIT_AUX, (rs), JIT_AUX)), ADDICrri((d), JIT_AUX, -1), SUBFErrr((d), (d), JIT_AUX)) -#define jit_ner_i(d, s1, s2) (SUBrrr(JIT_AUX, (s1), (s2)), ADDICrri((d), JIT_AUX, -1), SUBFErrr((d), (d), JIT_AUX)) -#define jit_nop() NOP() -#define jit_ori_i(d, rs, is) jit_chk_imu((is), ORIrri((d), (rs), (is)), ORrrr((d), (rs), JIT_AUX)) -#define jit_orr_i(d, s1, s2) ORrrr((d), (s1), (s2)) -#define jit_popr_i(rs) (LWZrm((rs), 0, 1), ADDIrri(1, 1, 4)) -#define jit_prepare_i(numi) (_jitl.nextarg_puti = numi) -#define jit_prepare_f(numf) (_jitl.nextarg_putf = numf) -#define jit_prepare_d(numd) (_jitl.nextarg_putd = numd) -#define jit_prolog(n) _jit_prolog(&_jit, (n)) -#define jit_pushr_i(rs) STWUrm((rs), -4, 1) -#define jit_pusharg_i(rs) (--_jitl.nextarg_puti, MRrr((3 + _jitl.nextarg_putd * 2 + _jitl.nextarg_putf + _jitl.nextarg_puti), (rs))) -#define jit_ret() _jit_epilog(&_jit) -#define jit_retval_i(rd) MRrr((rd), 3) -#define jit_rsbi_i(d, rs, is) jit_chk_ims((is), SUBFICrri((d), (rs), (is)), SUBFCrrr((d), (rs), JIT_AUX)) -#define jit_rshi_i(d, rs, is) SRAWIrri((d), (rs), (is)) -#define jit_rshi_ui(d, rs, is) SRWIrri ((d), (rs), (is)) -#define jit_rshr_i(d, s1, s2) (ANDI_rri(JIT_AUX, (s2), 31), SRAWrrr ((d), (s1), JIT_AUX)) -#define jit_rshr_ui(d, s1, s2) (ANDI_rri(JIT_AUX, (s2), 31), SRWrrr ((d), (s1), JIT_AUX)) -#define jit_stxi_c(id, rd, rs) jit_chk_ims((id), STBrm((rs), (id), (rd)), STBrx((rs), (rd), JIT_AUX)) -#define jit_stxi_i(id, rd, rs) jit_chk_ims((id), STWrm((rs), (id), (rd)), STWrx((rs), (rd), JIT_AUX)) -#define jit_stxi_s(id, rd, rs) jit_chk_ims((id), STHrm((rs), (id), (rd)), STHrx((rs), (rd), JIT_AUX)) -#define jit_stxr_c(d1, d2, rs) STBrx((rs), (d1), (d2)) -#define jit_stxr_i(d1, d2, rs) STWrx((rs), (d1), (d2)) -#define jit_stxr_s(d1, d2, rs) STHrx((rs), (d1), (d2)) -#define jit_subr_i(d, s1, s2) SUBrrr((d), (s1), (s2)) -#define jit_subcr_i(d, s1, s2) SUBCrrr((d), (s1), (s2)) -#define jit_subxi_i(d, rs, is) jit_big_ims((is), SUBErrr((d), (rs), JIT_AUX)) -#define jit_subxr_i(d, s1, s2) SUBErrr((d), (s1), (s2)) -#define jit_xori_i(d, rs, is) jit_chk_imu((is), XORIrri((d), (rs), (is)), XORrrr((d), (rs), JIT_AUX)) -#define jit_xorr_i(d, s1, s2) XORrrr((d), (s1), (s2)) - -/* Cannot use JIT_RZERO because having 0 in a register field on the PowerPC - * does not mean `a register whose value is 0', but rather `no register at - * all' */ - -#define jit_negr_i(d, rs) jit_rsbi_i((d), (rs), 0) -#define jit_negr_l(d, rs) jit_rsbi_l((d), (rs), 0) -#define jit_ldr_c(rd, rs) jit_ldxr_c((rd), 0, (rs)) -#define jit_str_c(rd, rs) jit_stxr_c(0, (rd), (rs)) -#define jit_ldr_s(rd, rs) jit_ldxr_s((rd), 0, (rs)) -#define jit_str_s(rd, rs) jit_stxr_s(0, (rd), (rs)) -#define jit_ldr_i(rd, rs) jit_ldxr_i((rd), 0, (rs)) -#define jit_str_i(rd, rs) jit_stxr_i(0, (rd), (rs)) -#define jit_ldr_uc(rd, rs) jit_ldxr_uc((rd), 0, (rs)) -#define jit_ldr_us(rd, rs) jit_ldxr_us((rd), 0, (rs)) - -/* e.g. - * 0x01234567 _HA << 16 = 0x01230000 _LA = 0x00004567 _HA << 16 + LA = 0x01234567 - * 0x89abcdef _HA << 16 = 0x89ac0000 _LA = 0xffffcdef _HA << 16 + LA = 0x89abcdef - */ -#define _HA(addr) ((_jit_UL(addr) >> 16) + (_jit_US(_jit_UL(addr)) >> 15)) -#define _LA(addr) (_jit_UL(addr) - (_HA(addr) << 16)) - -#define jit_ldi_c(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_c((rd), JIT_AUX, _LA(is))) -#define jit_sti_c(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_c(_LA(id), JIT_AUX, (rs))) -#define jit_ldi_s(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_s((rd), JIT_AUX, _LA(is))) -#define jit_sti_s(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_s(_LA(id), JIT_AUX, (rs))) -#define jit_ldi_i(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_i((rd), JIT_AUX, _LA(is))) -#define jit_sti_i(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_i(_LA(id), JIT_AUX, (rs))) -#define jit_ldi_uc(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_uc((rd), JIT_AUX, _LA(is))) -#define jit_ldi_us(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_us((rd), JIT_AUX, _LA(is))) - -#endif /* __lightning_core_h */ diff --git a/src/runtime/c/pgf/lightning/ppc/fp.h b/src/runtime/c/pgf/lightning/ppc/fp.h deleted file mode 100644 index 32541deb2..000000000 --- a/src/runtime/c/pgf/lightning/ppc/fp.h +++ /dev/null @@ -1,211 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler & support macros for the Sparc math unit - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - - -#ifndef __lightning_asm_fp_h -#define __lightning_asm_fp_h - - -#define JIT_FPR_NUM 6 -#define JIT_FPR(i) (8+(i)) - -#define JIT_FPFR 0 - -/* Make space for 1 or 2 words, store address in REG */ -#define jit_data(REG, D1) (_FBA (18, 8, 0, 1), _jit_L(D1), MFLRr(REG)) - -#define jit_addr_d(rd,s1,s2) FADDDrrr((rd),(s1),(s2)) -#define jit_subr_d(rd,s1,s2) FSUBDrrr((rd),(s1),(s2)) -#define jit_mulr_d(rd,s1,s2) FMULDrrr((rd),(s1),(s2)) -#define jit_divr_d(rd,s1,s2) FDIVDrrr((rd),(s1),(s2)) - -#define jit_addr_f(rd,s1,s2) FADDSrrr((rd),(s1),(s2)) -#define jit_subr_f(rd,s1,s2) FSUBSrrr((rd),(s1),(s2)) -#define jit_mulr_f(rd,s1,s2) FMULSrrr((rd),(s1),(s2)) -#define jit_divr_f(rd,s1,s2) FDIVSrrr((rd),(s1),(s2)) - -#define jit_movr_d(rd,rs) ( (rd) == (rs) ? 0 : FMOVErr((rd),(rs))) -#define jit_movi_d(reg0,d) do { \ - double _v = (d); \ - _FBA (18, 12, 0, 1); \ - memcpy(_jit.x.uc_pc, &_v, sizeof (double)); \ - _jit.x.uc_pc += sizeof (double); \ - MFLRr (JIT_AUX); \ - jit_ldxi_d((reg0), JIT_AUX, 0); \ - } while(0) - - -#define jit_movr_f(rd,rs) ( (rd) == (rs) ? 0 : FMOVErr((rd),(rs))) -#define jit_movi_f(reg0,f) do { \ - float _v = (f); \ - _FBA (18, 8, 0, 1); \ - memcpy(_jit.x.uc_pc, &_v, sizeof (float)); \ - _jit.x.uc_pc += sizeof (float); \ - MFLRr (JIT_AUX); \ - jit_ldxi_f((reg0), JIT_AUX, 0); \ - } while(0) - - -#define jit_abs_d(rd,rs) FABSrr((rd),(rs)) -#define jit_negr_d(rd,rs) FNEGrr((rd),(rs)) -#define jit_sqrt_d(rd,rs) FSQRTDrr((rd),(rs)) - - -#define jit_ldxi_f(reg0, rs, is) (_siP(16,(is)) ? LFSrri((reg0),(rs),(is)) : (MOVEIri(JIT_AUX,(is)),LFSxrrr((reg0),(rs),JIT_AUX))) -#define jit_ldxi_d(reg0, rs, is) (_siP(16,(is)) ? LFDrri((reg0),(rs),(is)) : (MOVEIri(JIT_AUX,(is)),LFDxrrr((reg0),(rs),JIT_AUX))) -#define jit_ldxr_f(reg0, s1, s2) LFSxrrr((reg0),(s1),(s2)) -#define jit_ldxr_d(reg0, s1, s2) LFDxrrr((reg0),(s1),(s2)) -#define jit_ldi_f(reg0, is) (_siP(16,(is)) ? LFSrri((reg0),0,(is)) : (MOVEIri(JIT_AUX,(is)),LFSrri((reg0),JIT_AUX,0))) -#define jit_ldi_d(reg0, is) (_siP(16,(is)) ? LFDrri((reg0),0,(is)) : (MOVEIri(JIT_AUX,(is)),LFDrri((reg0),JIT_AUX,0))) -#define jit_ldr_f(reg0, rs) LFSrri((reg0),(rs),0) -#define jit_ldr_d(reg0, rs) LFDrri((reg0),(rs),0) -#define jit_stxi_f(id, rd, reg0) (_siP(16,(id)) ? STFSrri((reg0),(rd),(id)) : (MOVEIri(JIT_AUX,(id)),STFSrri((reg0),(rd),JIT_AUX))) -#define jit_stxi_d(id, rd, reg0) (_siP(16,(id)) ? STFDrri((reg0),(rd),(id)) : (MOVEIri(JIT_AUX,(id)),STFDrri((reg0),(rd),JIT_AUX))) -#define jit_stxr_f(d1, d2, reg0) STFSxrrr((reg0),(d1),(d2)) -#define jit_stxr_d(d1, d2, reg0) STFDxrrr((reg0),(d1),(d2)) -#define jit_sti_f(id, reg0) (_siP(16,(id)) ? STFSrri((reg0),0,(id)) : (MOVEIri(JIT_AUX,(id)),STFSrri((reg0),JIT_AUX,0))) -#define jit_sti_d(id, reg0) (_siP(16,(id)) ? STFDrri((reg0),0,(id)) : (MOVEIri(JIT_AUX,(id)),STFDrri((reg0),JIT_AUX,0))) -#define jit_str_f(rd, reg0) STFSrri((reg0),(rd),0) -#define jit_str_d(rd, reg0) STFDrri((reg0),(rd),0) - -#define jit_fpboolr(d, s1, s2, rcbit) ( \ - FCMPOrrr(_cr0,(s1),(s2)), \ - MFCRr((d)), \ - EXTRWIrrii((d), (d), 1, (rcbit))) - -#define jit_fpboolr_neg(d, s1, s2,rcbit) ( \ - FCMPOrrr(_cr0,(s1),(s2)), \ - MFCRr((d)), \ - EXTRWIrrii((d), (d), 1, (rcbit)), \ - XORIrri((d), (d), 1)) - -#define jit_fpboolur(d, s1, s2, rcbit) ( \ - FCMPUrrr(_cr0,(s1),(s2)), \ - MFCRr((d)), \ - EXTRWIrrii((d), (d), 1, (rcbit))) - -#define jit_fpboolur_neg(d, s1, s2,rcbit) ( \ - FCMPUrrr(_cr0,(s1),(s2)), \ - MFCRr((d)), \ - EXTRWIrrii((d), (d), 1, (rcbit)), \ - XORIrri((d), (d), 1)) - -#define jit_fpboolur_or(d, s1, s2, bit1, bit2) (\ - FCMPUrrr(_cr0,(s1),(s2)), \ - CRORiii((bit1), (bit1), (bit2)), \ - MFCRr((d)), \ - EXTRWIrrii((d), (d), 1, (bit1))) - -#define jit_gtr_d(d, s1, s2) jit_fpboolr ((d),(s1),(s2),_gt) -#define jit_ger_d(d, s1, s2) jit_fpboolr_neg((d),(s1),(s2),_lt) -#define jit_ltr_d(d, s1, s2) jit_fpboolr ((d),(s1),(s2),_lt) -#define jit_ler_d(d, s1, s2) jit_fpboolr_neg((d),(s1),(s2),_gt) -#define jit_eqr_d(d, s1, s2) jit_fpboolr ((d),(s1),(s2),_eq) -#define jit_ner_d(d, s1, s2) jit_fpboolr_neg((d),(s1),(s2),_eq) -#define jit_unordr_d(d, s1, s2) jit_fpboolur ((d),(s1),(s2),_un) -#define jit_ordr_d(d, s1, s2) jit_fpboolur_neg((d),(s1),(s2),_un) -#define jit_unler_d(d, s1, s2) jit_fpboolur_neg ((d), (s1), (s2), _gt) -#define jit_unltr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _un, _lt) -#define jit_unger_d(d, s1, s2) jit_fpboolur_neg ((d), (s1), (s2), _lt) -#define jit_ungtr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _un, _gt) -#define jit_ltgtr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _gt, _lt) -#define jit_uneqr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _un, _eq) - -#define jit_fpbr(d, s1, s2, rcbit) ( \ - FCMPOrrr(_cr0,(s1),(s2)), \ - BTii ((rcbit), (d))) - -#define jit_fpbr_neg(d, s1, s2,rcbit) ( \ - FCMPOrrr(_cr0,(s1),(s2)), \ - BFii ((rcbit), (d))) - -#define jit_fpbur(d, s1, s2, rcbit) ( \ - FCMPUrrr(_cr0,(s1),(s2)), \ - BTii ((rcbit), (d))) - -#define jit_fpbur_neg(d, s1, s2,rcbit) ( \ - FCMPUrrr(_cr0,(s1),(s2)), \ - BFii ((rcbit), (d))) - -#define jit_fpbur_or(d, s1, s2, bit1, bit2) ( \ - FCMPUrrr(_cr0,(s1),(s2)), \ - CRORiii((bit1), (bit1), (bit2)), \ - BTii ((bit1), (d))) - -#define jit_bgtr_d(d, s1, s2) jit_fpbr ((d),(s1),(s2),_gt) -#define jit_bger_d(d, s1, s2) jit_fpbr_neg((d),(s1),(s2),_lt) -#define jit_bltr_d(d, s1, s2) jit_fpbr ((d),(s1),(s2),_lt) -#define jit_bler_d(d, s1, s2) jit_fpbr_neg((d),(s1),(s2),_gt) -#define jit_beqr_d(d, s1, s2) jit_fpbr ((d),(s1),(s2),_eq) -#define jit_bner_d(d, s1, s2) jit_fpbr_neg((d),(s1),(s2),_eq) -#define jit_bunordr_d(d, s1, s2) jit_fpbur ((d),(s1),(s2),_un) -#define jit_bordr_d(d, s1, s2) jit_fpbur_neg((d),(s1),(s2),_un) -#define jit_bunler_d(d, s1, s2) jit_fpbur_neg ((d), (s1), (s2), _gt) -#define jit_bunltr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _un, _lt) -#define jit_bunger_d(d, s1, s2) jit_fpbur_neg ((d), (s1), (s2), _lt) -#define jit_bungtr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _un, _gt) -#define jit_bltgtr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _gt, _lt) -#define jit_buneqr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _un, _eq) - -#define jit_getarg_f(rd, ofs) jit_movr_f((rd),(ofs)) -#define jit_getarg_d(rd, ofs) jit_movr_d((rd),(ofs)) -#define jit_pusharg_d(rs) (_jitl.nextarg_putd--,jit_movr_d((_jitl.nextarg_putf+_jitl.nextarg_putd+1), (rs))) -#define jit_pusharg_f(rs) (_jitl.nextarg_putf--,jit_movr_f((_jitl.nextarg_putf+_jitl.nextarg_putd+1), (rs))) -#define jit_retval_d(op1) jit_movr_d(1, (op1)) -#define jit_retval_f(op1) jit_movr_f(1, (op1)) - - -#define jit_floorr_d_i(rd,rs) (MTFSFIri(7,3), \ - FCTIWrr(7,(rs)), \ - MOVEIri(JIT_AUX,-4), \ - STFIWXrrr(7,JIT_SP,JIT_AUX), \ - LWZrm((rd),-4,JIT_SP)) - -#define jit_ceilr_d_i(rd,rs) (MTFSFIri(7,2), \ - FCTIWrr(7,(rs)), \ - MOVEIri(JIT_AUX,-4), \ - STFIWXrrr(7,JIT_SP,JIT_AUX), \ - LWZrm((rd),-4,JIT_SP)) - -#define jit_roundr_d_i(rd,rs) (MTFSFIri(7,0), \ - FCTIWrr(7,(rs)), \ - MOVEIri(JIT_AUX,-4), \ - STFIWXrrr(7,JIT_SP,JIT_AUX), \ - LWZrm((rd),-4,JIT_SP)) - -#define jit_truncr_d_i(rd,rs) (FCTIWZrr(7,(rs)), \ - MOVEIri(JIT_AUX,-4), \ - STFIWXrrr(7,JIT_SP,JIT_AUX), \ - LWZrm((rd),-4,JIT_SP)) - -#endif /* __lightning_asm_h */ diff --git a/src/runtime/c/pgf/lightning/ppc/funcs.h b/src/runtime/c/pgf/lightning/ppc/funcs.h deleted file mode 100644 index 37e2b38f3..000000000 --- a/src/runtime/c/pgf/lightning/ppc/funcs.h +++ /dev/null @@ -1,164 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer inline functions (PowerPC) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_funcs_h -#define __lightning_funcs_h - -#if !defined(__GNUC__) && !defined(__GNUG__) -#error Go get GNU C, I do not know how to flush the cache -#error with this compiler. -#else -static void -jit_flush_code(void *start, void *end) -{ -#ifndef LIGHTNING_CROSS - register char *ddest, *idest; - - static int cache_line_size; - if (cache_line_size == 0) { - char buffer[8192]; - int i, probe; - - /* Find out the size of a cache line by zeroing one */ - memset(buffer, 0xFF, 8192); - __asm__ __volatile__ ("dcbz 0,%0" : : "r"(buffer + 4096)); - - /* Probe for the beginning of the cache line. */ - for(i = 0, probe = 4096; probe; probe >>= 1) - if (buffer[i | probe] != 0x00) - i |= probe; - - /* i is now just before the start of the cache line */ - i++; - for(cache_line_size = 1; i + cache_line_size < 8192; cache_line_size <<= 1) - if (buffer[i + cache_line_size] != 0x00) - break; - } - - start -= ((long) start) & (cache_line_size - 1); - end -= ((long) end) & (cache_line_size - 1); - - /* Force data cache write-backs */ - for (ddest = (char *) start; ddest <= (char *) end; ddest += cache_line_size) { - __asm__ __volatile__ ("dcbst 0,%0" : : "r"(ddest)); - } - __asm__ __volatile__ ("sync" : : ); - - /* Now invalidate the instruction cache */ - for (idest = (char *) start; idest <= (char *) end; idest += cache_line_size) { - __asm__ __volatile__ ("icbi 0,%0" : : "r"(idest)); - } - __asm__ __volatile__ ("isync" : : ); -#endif /* !LIGHTNING_CROSS */ -} -#endif /* __GNUC__ || __GNUG__ */ - -#define _jit (*jit) - -static void -_jit_epilog(jit_state *jit) -{ - int n = _jitl.nbArgs; - int frame_size, ofs; - int first_saved_reg = JIT_AUX - n; - int num_saved_regs = 32 - first_saved_reg; - - frame_size = 24 + 32 + num_saved_regs * 4; /* r24..r31 + args */ - frame_size += 15; /* the stack must be quad-word */ - frame_size &= ~15; /* aligned */ - -#ifdef _CALL_DARWIN - LWZrm(0, frame_size + 8, 1); /* lwz r0, x+8(r1) (ret.addr.) */ -#else - LWZrm(0, frame_size + 4, 1); /* lwz r0, x+4(r1) (ret.addr.) */ -#endif - MTLRr(0); /* mtspr LR, r0 */ - - ofs = frame_size - num_saved_regs * 4; - LMWrm(first_saved_reg, ofs, 1); /* lmw rI, ofs(r1) */ - ADDIrri(1, 1, frame_size); /* addi r1, r1, x */ - BLR(); /* blr */ -} - -/* Emit a prolog for a function. - Upon entrance to the trampoline: - - LR = address where the real code for the function lies - - R3-R8 = parameters - Upon finishing the trampoline: - - R0 = return address for the function - - R25-R20 = parameters (order is reversed, 1st argument is R25) - - The +32 in frame_size computation is to accound for the parameter area of - a function frame. - - On PPC the frame must have space to host the arguments of any callee. - However, as it currently stands, the argument to jit_trampoline (n) is - the number of arguments of the caller we generate. Therefore, the - callee can overwrite a part of the stack (saved register area when it - flushes its own parameter on the stack. The addition of a constant - offset = 32 is enough to hold eight 4 bytes arguments. This is less - than perfect but is a reasonable work around for now. - Better solution must be investigated. */ -static void -_jit_prolog(jit_state *jit, int n) -{ - int frame_size; - int ofs, i; - int first_saved_reg = JIT_AUX - n; - int num_saved_regs = 32 - first_saved_reg; - - _jitl.nextarg_geti = JIT_AUX - 1; - _jitl.nextarg_getd = 1; - _jitl.nbArgs = n; - - frame_size = 24 + 32 + num_saved_regs * 4; /* r27..r31 + args */ - frame_size += 15; /* the stack must be quad-word */ - frame_size &= ~15; /* aligned */ - - MFLRr(0); - STWUrm(1, -frame_size, 1); /* stwu r1, -x(r1) */ - - ofs = frame_size - num_saved_regs * 4; - STMWrm(first_saved_reg, ofs, 1); /* stmw rI, ofs(r1) */ -#ifdef _CALL_DARWIN - STWrm(0, frame_size + 8, 1); /* stw r0, x+8(r1) */ -#else - STWrm(0, frame_size + 4, 1); /* stw r0, x+4(r1) */ -#endif - for (i = 0; i < n; i++) - MRrr(JIT_AUX-1-i, 3+i); /* save parameters below r24 */ -} - -#undef _jit - -#endif /* __lightning_funcs_h */ diff --git a/src/runtime/c/pgf/lightning/sparc/asm.h b/src/runtime/c/pgf/lightning/sparc/asm.h deleted file mode 100644 index a8c544c4f..000000000 --- a/src/runtime/c/pgf/lightning/sparc/asm.h +++ /dev/null @@ -1,383 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler for the SPARC - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 1999, 2000, 2001, 2002 Ian Piumarta - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - - - -#ifndef __lightning_asm_h -#define __lightning_asm_h - - -/* = [0-9]+ -> add i, one parameter (imm) - * = % -> add r, one parameter (imm or _Rr(imm) ) - * %g -> add r, one parameter (imm or _Rg(imm) ) - * %o -> add r, one parameter (imm+8 or _Ro(imm) ) - * %l -> add r, one parameter (imm+16 or _Rl(imm) ) - * %i -> add r, one parameter (imm+24 or _Ri(imm) ) - * = () -> add m, two parameters (reg,imm) - * = () -> add x, two parameters (reg,reg) - */ - - -typedef unsigned int jit_insn; - -#ifndef LIGHTNING_DEBUG -#define _d30(BD) ((_jit_UL(BD) - _jit_UL(_jit.x.pc))>>2) -#define _d22(BD) _ck_d(22, _d30(BD)) - -#define _HI(I) (_jit_UL(I) >> (10)) -#define _LO(I) (_jit_UL(I) & _MASK(10)) - -/* register names */ - -#define _y 0 -#define _psr 1 - -#define _Rr(N) ( 0+(N)) -#define _Rg(N) ( 0+(N)) -#define _Ro(N) ( 8+(N)) -#define _Rl(N) (16+(N)) -#define _Ri(N) (24+(N)) - -/* instruction formats -- Figure 5-1, page 44 in */ -/* SPARC International, "The SPARC Architecture Manual, Version 8", Prentice-Hall, 1992. */ - -#define _0i(RD, OP2, IMM) _jit_I((0<<30)| (_u5(RD)<<25)|(_u3(OP2)<<22)| _u22(IMM)) -#define _0( A, CC, OP2, DSP) _jit_I((0<<30)|(_u1(A)<<29)|(_u4(CC)<<25)|(_u3(OP2)<<22)| _d22(DSP)) -#define _0d( A, CC, OP2, DSP) _jit_I((0<<30)|(_u1(A)<<29)|(_u4(CC)<<25)|(_u3(OP2)<<22)| _u22(DSP)) - -#define _1( DSP) _jit_I((1<<30)| _d30(DSP)) - -#define _2( RD, OP3, RS1, I, ASI, RS2) _jit_I((2<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)|(_u8(ASI)<<5)|_u5 (RS2)) -#define _2i(RD, OP3, RS1, I, IMM) _jit_I((2<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)| _s13(IMM)) -#define _2f(RD, OP3, RS1, OPF, RS2) _jit_I((2<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)| (_u9(OPF)<<5)|_u5 (RS2)) - -#define _3( RD, OP3, RS1, I, ASI, RS2) _jit_I((3<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)|(_u8(ASI)<<5)|_u5 (RS2)) -#define _3i(RD, OP3, RS1, I, IMM) _jit_I((3<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)| _s13(IMM)) - -#define _FP1(RD, RS1, OPF, RS2) _2f((RD), 52, (RS1), (OPF), (RS2)) -#define _FP2(RD, RS1, OPF, RS2) _2f((RD), 53, (RS1), (OPF), (RS2)) - -/* basic instructions [Section B, page 87] */ - -#define ADDrrr(RS1, RS2, RD) _2 ((RD), 0, (RS1), 0, 0, (RS2)) -#define ADDrir(RS1, IMM, RD) _2i ((RD), 0, (RS1), 1, (IMM)) -#define ADDCCrrr(RS1, RS2, RD) _2 ((RD), 16, (RS1), 0, 0, (RS2)) -#define ADDCCrir(RS1, IMM, RD) _2i ((RD), 16, (RS1), 1, (IMM)) -#define ADDXrrr(RS1, RS2, RD) _2 ((RD), 8, (RS1), 0, 0, (RS2)) -#define ADDXrir(RS1, IMM, RD) _2i ((RD), 8, (RS1), 1, (IMM)) -#define ADDXCCrrr(RS1, RS2, RD) _2 ((RD), 24, (RS1), 0, 0, (RS2)) -#define ADDXCCrir(RS1, IMM, RD) _2i ((RD), 24, (RS1), 1, (IMM)) -#define ANDrrr(RS1, RS2, RD) _2 ((RD), 1, (RS1), 0, 0, (RS2)) -#define ANDrir(RS1, IMM, RD) _2i ((RD), 1, (RS1), 1, (IMM)) -#define ANDCCrrr(RS1, RS2, RD) _2 ((RD), 17, (RS1), 0, 0, (RS2)) -#define ANDCCrir(RS1, IMM, RD) _2i ((RD), 17, (RS1), 1, (IMM)) - -#define BNi(DISP) _0 (0, 0, 2, (DISP)) -#define BN_Ai(DISP) _0 (1, 0, 2, (DISP)) -#define BEi(DISP) _0 (0, 1, 2, (DISP)) -#define BE_Ai(DISP) _0 (1, 1, 2, (DISP)) -#define BLEi(DISP) _0 (0, 2, 2, (DISP)) -#define BLE_Ai(DISP) _0 (1, 2, 2, (DISP)) -#define BLi(DISP) _0 (0, 3, 2, (DISP)) -#define BL_Ai(DISP) _0 (1, 3, 2, (DISP)) -#define BLEUi(DISP) _0 (0, 4, 2, (DISP)) -#define BLEU_Ai(DISP) _0 (1, 4, 2, (DISP)) -#define BCSi(DISP) _0 (0, 5, 2, (DISP)) -#define BCS_Ai(DISP) _0 (1, 5, 2, (DISP)) -#define BNEGi(DISP) _0 (0, 6, 2, (DISP)) -#define BNEG_Ai(DISP) _0 (1, 6, 2, (DISP)) -#define BVSi(DISP) _0 (0, 7, 2, (DISP)) -#define BVS_Ai(DISP) _0 (1, 7, 2, (DISP)) -#define BAi(DISP) _0 (0, 8, 2, (DISP)) -#define BA_Ai(DISP) _0 (1, 8, 2, (DISP)) -#define BNEi(DISP) _0 (0, 9, 2, (DISP)) -#define BNE_Ai(DISP) _0 (1, 9, 2, (DISP)) -#define BGi(DISP) _0 (0, 10, 2, (DISP)) -#define BG_Ai(DISP) _0 (1, 10, 2, (DISP)) -#define BGEi(DISP) _0 (0, 11, 2, (DISP)) -#define BGE_Ai(DISP) _0 (1, 11, 2, (DISP)) -#define BGUi(DISP) _0 (0, 12, 2, (DISP)) -#define BGU_Ai(DISP) _0 (1, 12, 2, (DISP)) -#define BCCi(DISP) _0 (0, 13, 2, (DISP)) -#define BCC_Ai(DISP) _0 (1, 13, 2, (DISP)) -#define BPOSi(DISP) _0 (0, 14, 2, (DISP)) -#define BPOS_Ai(DISP) _0 (1, 14, 2, (DISP)) -#define BVCi(DISP) _0 (0, 15, 2, (DISP)) -#define BVC_Ai(DISP) _0 (1, 15, 2, (DISP)) - -#define CALLi(DISP) _1 ((DISP)) - -#define FLUSHrr(RS1, RS2) _2 (0, 0x3b, (RS1), 0, 0, (RS2)) -#define FLUSHir(IMM, RS1) _2i (0, 0x3b, (RS1), 1, (IMM)) - -#define JMPLxr(RS1, RS2, RD) _2 ((RD), 56, (RS1), 0, 0, (RS2)) -#define JMPLmr(RS1, IMM, RD) _2i ((RD), 56, (RS1), 1, (IMM)) - -#define LDxr(RS1, RS2, RD) _3 ((RD), 0, (RS1), 0, 0, (RS2)) -#define LDmr(RS1, IMM, RD) _3i ((RD), 0, (RS1), 1, (IMM)) -#define LDUBxr(RS1, RS2, RD) _3 ((RD), 1, (RS1), 0, 0, (RS2)) -#define LDUBmr(RS1, IMM, RD) _3i ((RD), 1, (RS1), 1, (IMM)) -#define LDUHxr(RS1, RS2, RD) _3 ((RD), 2, (RS1), 0, 0, (RS2)) -#define LDUHmr(RS1, IMM, RD) _3i ((RD), 2, (RS1), 1, (IMM)) -#define LDDxr(RS1, RS2, RD) _3 ((RD), 3, (RS1), 0, 0, (RS2)) -#define LDDmr(RS1, IMM, RD) _3i ((RD), 3, (RS1), 1, (IMM)) -#define LDSBxr(RS1, RS2, RD) _3 ((RD), 9, (RS1), 0, 0, (RS2)) -#define LDSBmr(RS1, IMM, RD) _3i ((RD), 9, (RS1), 1, (IMM)) -#define LDSHxr(RS1, RS2, RD) _3 ((RD), 10, (RS1), 0, 0, (RS2)) -#define LDSHmr(RS1, IMM, RD) _3i ((RD), 10, (RS1), 1, (IMM)) - -#define ORrrr(RS1, RS2, RD) _2 ((RD), 2, (RS1), 0, 0, (RS2)) -#define ORrir(RS1, IMM, RD) _2i ((RD), 2, (RS1), 1, (IMM)) -#define ORCCrrr(RS1, RS2, RD) _2 ((RD), 18, (RS1), 0, 0, (RS2)) -#define ORCCrir(RS1, IMM, RD) _2i ((RD), 18, (RS1), 1, (IMM)) - -#define RDir(RS, RD) _2 ((RD), (RS)|0x28, 0, 0, 0,0) -#define RESTORErrr(RS1, RS2, RD) _2 ((RD), 61, (RS1), 0, 0, (RS2)) -#define RESTORErir(RS1, IMM, RD) _2i ((RD), 61, (RS1), 1, (IMM)) - -#define SAVErrr(RS1, RS2, RD) _2 ((RD), 60, (RS1), 0, 0, (RS2)) -#define SAVErir(RS1, IMM, RD) _2i ((RD), 60, (RS1), 1, (IMM)) -#define SDIVrrr(RS1, RS2, RD) _2 ((RD), 15, (RS1), 0, 0, (RS2)) -#define SDIVrir(RS1, IMM, RD) _2i ((RD), 15, (RS1), 1, (IMM)) -#define SDIVCCrrr(RS1, RS2, RD) _2 ((RD), 31, (RS1), 0, 0, (RS2)) -#define SDIVCCrir(RS1, IMM, RD) _2i ((RD), 31, (RS1), 1, (IMM)) -#define SETHIir(IMM, RD) _0i ((RD), 4, (IMM)) -#define SLLrrr(RS1, RS2, RD) _2 ((RD), 37, (RS1), 0, 0, (RS2)) -#define SLLrir(RS1, IMM, RD) _2i ((RD), 37, (RS1), 1, (IMM)) -#define SMULrrr(RS1, RS2, RD) _2 ((RD), 11, (RS1), 0, 0, (RS2)) -#define SMULrir(RS1, IMM, RD) _2i ((RD), 11, (RS1), 1, (IMM)) -#define SMULCCrrr(RS1, RS2, RD) _2 ((RD), 27, (RS1), 0, 0, (RS2)) -#define SMULCCrir(RS1, IMM, RD) _2i ((RD), 27, (RS1), 1, (IMM)) -#define SRArrr(RS1, RS2, RD) _2 ((RD), 39, (RS1), 0, 0, (RS2)) -#define SRArir(RS1, IMM, RD) _2i ((RD), 39, (RS1), 1, (IMM)) -#define SRLrrr(RS1, RS2, RD) _2 ((RD), 38, (RS1), 0, 0, (RS2)) -#define SRLrir(RS1, IMM, RD) _2i ((RD), 38, (RS1), 1, (IMM)) -#define STrx(RS, RD1, RD2) _3 ((RS), 4, (RD1), 0, 0, (RD2)) -#define STrm(RS, RD, IMM) _3i ((RS), 4, (RD), 1, (IMM)) -#define STBrx(RS, RD1, RD2) _3 ((RS), 5, (RD1), 0, 0, (RD2)) -#define STBrm(RS, RD, IMM) _3i ((RS), 5, (RD), 1, (IMM)) -#define STBAR() _0i (0, 0x28, 15, 0, 0) -#define STHrx(RS, RD1, RD2) _3 ((RS), 6, (RD1), 0, 0, (RD2)) -#define STHrm(RS, RD, IMM) _3i ((RS), 6, (RD), 1, (IMM)) -#define STDrx(RS, RD1, RD2) _3 ((RS), 7, (RD1), 0, 0, (RD2)) -#define STDrm(RS, RD, IMM) _3i ((RS), 7, (RD), 1, (IMM)) -#define SUBrrr(RS1, RS2, RD) _2 ((RD), 4, (RS1), 0, 0, (RS2)) -#define SUBrir(RS1, IMM, RD) _2i ((RD), 4, (RS1), 1, (IMM)) -#define SUBCCrrr(RS1, RS2, RD) _2 ((RD), 20, (RS1), 0, 0, (RS2)) -#define SUBCCrir(RS1, IMM, RD) _2i ((RD), 20, (RS1), 1, (IMM)) -#define SUBXrrr(RS1, RS2, RD) _2 ((RD), 12, (RS1), 0, 0, (RS2)) -#define SUBXrir(RS1, IMM, RD) _2i ((RD), 12, (RS1), 1, (IMM)) -#define SUBXCCrrr(RS1, RS2, RD) _2 ((RD), 28, (RS1), 0, 0, (RS2)) -#define SUBXCCrir(RS1, IMM, RD) _2i ((RD), 28, (RS1), 1, (IMM)) - -#define UDIVrrr(RS1, RS2, RD) _2 ((RD), 14, (RS1), 0, 0, (RS2)) -#define UDIVrir(RS1, IMM, RD) _2i ((RD), 14, (RS1), 1, (IMM)) -#define UDIVCCrrr(RS1, RS2, RD) _2 ((RD), 30, (RS1), 0, 0, (RS2)) -#define UDIVCCrir(RS1, IMM, RD) _2i ((RD), 30, (RS1), 1, (IMM)) -#define UMULrrr(RS1, RS2, RD) _2 ((RD), 10, (RS1), 0, 0, (RS2)) -#define UMULrir(RS1, IMM, RD) _2i ((RD), 10, (RS1), 1, (IMM)) -#define UMULCCrrr(RS1, RS2, RD) _2 ((RD), 26, (RS1), 0, 0, (RS2)) -#define UMULCCrir(RS1, IMM, RD) _2i ((RD), 26, (RS1), 1, (IMM)) - -#define WRrri(RS1, RS2, RD) _2 (0, (RD)|0x30, RS1, 0, 0, (RS2)) -#define WRrii(RS1, IMM, RD) _2i (0, (RD)|0x30, RS1, 1, (IMM)) - -#define XORrrr(RS1, RS2, RD) _2 ((RD), 3, (RS1), 0, 0, (RS2)) -#define XORrir(RS1, IMM, RD) _2i ((RD), 3, (RS1), 1, (IMM)) -#define XORCCrrr(RS1, RS2, RD) _2 ((RD), 19, (RS1), 0, 0, (RS2)) -#define XORCCrir(RS1, IMM, RD) _2i ((RD), 19, (RS1), 1, (IMM)) - -/* synonyms */ - -#define Bi(DISP) BAi((DISP)) -#define B_Ai(DISP) BA_Ai((DISP)) -#define BNZi(DISP) BNEi((DISP)) -#define BNZ_Ai(DISP) BNE_Ai((DISP)) -#define BZi(DISP) BEi((DISP)) -#define BZ_Ai(DISP) BE_Ai((DISP)) -#define BGEUi(DISP) BCCi((DISP)) -#define BGEU_Ai(DISP) BCC_Ai((DISP)) -#define BLUi(DISP) BCSi((DISP)) -#define BLU_Ai(DISP) BCS_Ai((DISP)) - -#define LDUWxr(RS1, RS2, RD) LDxr((RS1), (RS2), (RD)) -#define LDUWmr(RS1, IMM, RD) LDmr((RS1), (IMM), (RD)) -#define LDSWxr(RS1, RS2, RD) LDxr((RS1), (RS2), (RD)) -#define LDSWmr(RS1, IMM, RD) LDmr((RS1), (IMM), (RD)) - -#define STWrx(RS, RD1, RD2) STrx((RS), (RD1), (RD2)) -#define STWrm(RS, RD, IMM) STrm((RS), (RD), (IMM)) - -/* synthetic instructions [Table A-1, page 85] */ - -#define BCLRrr(R,S) ANDNrrr((R), (S), (S)) -#define BCLRir(I,R) ANDNrir((R), (I), (R)) -#define BSETrr(R,S) ORrrr((R), (S), (S)) -#define BSETir(I,R) ORrir((R), (I), (R)) -#define BTOGrr(R,S) XORrrr((R), (S), (S)) -#define BTOGir(I,R) XORrir((R), (I), (R)) -#define BTSTrr(R,S) ANDCCrrr((R), (S), 0) -#define BTSTir(I,R) ANDCCrir((R), (I), 0) - -#define CALLm(R,I) JMPLmr((R), (I), _Ro(7)) -#define CALLx(R,S) JMPLxr((R), (S), _Ro(7)) - -#define CLRr(R) ORrrr(0, 0, (R)) -#define CLRBm(R,I) STBrm(0, (R), (I)) -#define CLRBx(R,S) STBrm(0, (R), (S)) -#define CLRHm(R,I) STHrm(0, (R), (I)) -#define CLRHx(R,S) STHrm(0, (R), (S)) -#define CLRm(R,I) STrm(0, (R), (I)) -#define CLRx(R,S) STrm(0, (R), (S)) - -#define CMPrr(RS1, RS2) SUBCCrrr((RS1), (RS2), 0) -#define CMPri(RS1, IMM) SUBCCrir((RS1), (IMM), 0) - -#define DECr(R) SUBrir((R), 1, (R)) -#define DECir(I,R) SUBrir((R), (I), (R)) -#define DECCCr(R) SUBCCrir((R), 1, (R)) -#define DECCCir(I,R) SUBCCrir((R), (I), (R)) - -#define INCr(R) ADDrir((R), 1, (R)) -#define INCir(I,R) ADDrir((R), (I), (R)) -#define INCCCr(R) ADDCCrir((R), 1, (R)) -#define INCCCir(I,R) ADDCCrir((R), (I), (R)) - -#define JMPm(R,I) JMPLmr((R), (I), 0) -#define JMPx(R,S) JMPLxr((R), (S), 0) - -#define MOVrr(R,S) ORrrr(0, (R), (S)) -#define MOVir(I, R) ORrir(0, (I), (R)) - -#define NEGrr(R,S) SUBrrr(0, (R), (S)) -#define NEGr(R) SUBrrr(0, (R), (R)) -#define NOP() SETHIir(0, 0) - -#define NOTrr(R,S) XNORrrr((R), 0, (S)) -#define NOTr(R) XNORrrr((R), 0, (R)) - -#define RESTORE() RESTORErrr(0, 0, 0) -#define RET() JMPLmr(_Ri(7),8 ,0) -#define RETL() JMPLmr(_Ro(7),8 ,0) - -#define SAVE() SAVErrr(0, 0, 0) -#define SETir(I,R) (_siP(13,(I)) ? MOVir((I),(R)) : SETir2(_HI(I), _LO(I), (R))) -#define SETir2(H,L,R) (SETHIir(H,R), (L ? ORrir(R,L,R) : 0)) - -/* BNZ,a executes the delay instruction if NZ (so skips if Z) - * BZ,a executes the delay instruction if Z (so skips if NZ). */ -#define SKIPZ() _0d (1, 9, 2, 2) /* BNZ,a .+8 */ -#define SKIPNZ() _0d (1, 1, 2, 2) /* BZ,a .+8 */ -#define SKIP() _0d (1, 0, 2, 0) /* BN,a . */ - -#define TSTr(R) ORCCrrr(0, (R), 0) - -#define WRii(IMM, RD) WRrii(0, (IMM), (RD)) -#define WRri(RS2, RD) WRrri(0, (RS2), (RD)) - -#define LDFSRx(RS1, RS2) _3 (0, 33, (RS1), 0, 0, (RS2)) -#define LDFSRm(RS1, IMM) _3i (0, 33, (RS1), 1, (IMM)) -#define STFSRx(RD1, RD2) _3 (0, 37, (RD1), 0, 0, (RD2)) -#define STFSRm(RD, IMM) _3i (0, 37, (RD), 1, (IMM)) - -#define FITODrr(FRS, FRD) _FP1((FRD), 0, 200, (FRS)) -#define FITOSrr(FRS, FRD) _FP1((FRD), 0, 196, (FRS)) -#define FDTOIrr(FRS, FRD) _FP1((FRD), 0, 210, (FRS)) -#define FSTOIrr(FRS, FRD) _FP1((FRD), 0, 209, (FRS)) -#define FSTODrr(FRS, FRD) _FP1((FRD), 0, 201, (FRS)) -#define FDTOSrr(FRS, FRD) _FP1((FRD), 0, 198, (FRS)) -#define FMOVSrr(FRS, FRD) _FP1((FRD), 0, 1, (FRS)) -#define FNEGSrr(FRS, FRD) _FP1((FRD), 0, 5, (FRS)) -#define FABSSrr(FRS, FRD) _FP1((FRD), 0, 9, (FRS)) -#define FMOVDrr(FRS, FRD) _FP1((FRD), 0, 2, (FRS)) -#define FNEGDrr(FRS, FRD) _FP1((FRD), 0, 6, (FRS)) -#define FABSDrr(FRS, FRD) _FP1((FRD), 0, 10, (FRS)) -#define FSQRTDrr(FRS, FRD) _FP1((FRD), 0, 42, (FRS)) -#define FSQRTSrr(FRS, FRD) _FP1((FRD), 0, 41, (FRS)) - -#define FADDSrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 65, (FRS2)) -#define FSUBSrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 69, (FRS2)) -#define FMULSrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 73, (FRS2)) -#define FDIVSrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 77, (FRS2)) - -#define FADDDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 66, (FRS2)) -#define FSUBDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 70, (FRS2)) -#define FMULDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 74, (FRS2)) -#define FDIVDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 78, (FRS2)) - -#define FCMPSrr(FRS1, FRS2) _FP2(0, (FRS1), 81, (FRS2)) -#define FCMPDrr(FRS1, FRS2) _FP2(0, (FRS1), 82, (FRS2)) - -#define LDFxr(RS1, RS2, RD) _3 ((RD), 32, (RS1), 0, 0, (RS2)) -#define LDFmr(RS1, IMM, RD) _3i ((RD), 32, (RS1), 1, (IMM)) -#define LDDFxr(RS1, RS2, RD) _3 ((RD), 35, (RS1), 0, 0, (RS2)) -#define LDDFmr(RS1, IMM, RD) _3i ((RD), 35, (RS1), 1, (IMM)) -#define STFrx(RS, RD1, RD2) _3 ((RS), 36, (RD1), 0, 0, (RD2)) -#define STFrm(RS, RD1, IMM) _3i ((RS), 36, (RD1), 1, (IMM)) -#define STDFrx(RS, RD1, RD2) _3 ((RS), 39, (RD1), 0, 0, (RD2)) -#define STDFrm(RS, RD1, IMM) _3i ((RS), 39, (RD1), 1, (IMM)) - -#define FBNi(DISP) _0 (0, 0, 6, (DISP)) -#define FBN_Ai(DISP) _0 (1, 0, 6, (DISP)) -#define FBNEi(DISP) _0 (0, 1, 6, (DISP)) -#define FBNE_Ai(DISP) _0 (1, 1, 6, (DISP)) -#define FBLGi(DISP) _0 (0, 2, 6, (DISP)) -#define FBLG_Ai(DISP) _0 (1, 2, 6, (DISP)) -#define FBULi(DISP) _0 (0, 3, 6, (DISP)) -#define FBUL_Ai(DISP) _0 (1, 3, 6, (DISP)) -#define FBLi(DISP) _0 (0, 4, 6, (DISP)) -#define FBL_Ai(DISP) _0 (1, 4, 6, (DISP)) -#define FBUGi(DISP) _0 (0, 5, 6, (DISP)) -#define FBUG_Ai(DISP) _0 (1, 5, 6, (DISP)) -#define FBGi(DISP) _0 (0, 6, 6, (DISP)) -#define FBG_Ai(DISP) _0 (1, 6, 6, (DISP)) -#define FBUi(DISP) _0 (0, 7, 6, (DISP)) -#define FBU_Ai(DISP) _0 (1, 7, 6, (DISP)) -#define FBAi(DISP) _0 (0, 8, 6, (DISP)) -#define FBA_Ai(DISP) _0 (1, 8, 6, (DISP)) -#define FBEi(DISP) _0 (0, 9, 6, (DISP)) -#define FBE_Ai(DISP) _0 (1, 9, 6, (DISP)) -#define FBUEi(DISP) _0 (0, 10, 6, (DISP)) -#define FBUE_Ai(DISP) _0 (1, 10, 6, (DISP)) -#define FBGEi(DISP) _0 (0, 11, 6, (DISP)) -#define FBGE_Ai(DISP) _0 (1, 11, 6, (DISP)) -#define FBUGEi(DISP) _0 (0, 12, 6, (DISP)) -#define FBUGE_Ai(DISP) _0 (1, 12, 6, (DISP)) -#define FBLEi(DISP) _0 (0, 13, 6, (DISP)) -#define FBLE_Ai(DISP) _0 (1, 13, 6, (DISP)) -#define FBULEi(DISP) _0 (0, 14, 6, (DISP)) -#define FBULE_Ai(DISP) _0 (1, 14, 6, (DISP)) -#define FBOi(DISP) _0 (0, 15, 6, (DISP)) -#define FBO_Ai(DISP) _0 (1, 15, 6, (DISP)) - -#endif -#endif /* __ccg_asm_sparc_h */ diff --git a/src/runtime/c/pgf/lightning/sparc/core.h b/src/runtime/c/pgf/lightning/sparc/core.h deleted file mode 100644 index 7912a3b18..000000000 --- a/src/runtime/c/pgf/lightning/sparc/core.h +++ /dev/null @@ -1,265 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer (Sparc version) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - -#ifndef __lightning_core_h -#define __lightning_core_h - -#define JIT_R_NUM 3 -#define JIT_V_NUM 6 -#define JIT_R(i) ((i) ? _Rl((i) - 1) : _Rg(2)) -#define JIT_V(i) _Rl((i)+2) - -#define JIT_BIG _Rg(1) /* %g1 used to make 32-bit operands */ -#define JIT_BIG2 _Ro(7) /* %o7 used to make 32-bit compare operands */ -#define JIT_SP _Ro(6) -#define JIT_RZERO _Rg(0) -#define JIT_RET _Ri(0) - -/* Delay slot scheduling: jmp generates branches with annulled delay - * slots; we toggle the annul bit if we can fill the slot. CALLs and - * cond. branches have a different meaning for the annul bit, so we - * automatically generate a NOP and eventually copy the delay insn onto - * it. Delay slots in RET are already used for RESTORE, so we don't - * schedule them. - * - * ,--- _jit.x.pc - * insn X X before - * cmp branch insn X X after (branch) - * `--- _jit.x.pc - * call insn insn X after (call) - * `--- _jit.x.pc - */ - -struct jit_local_state { - int nextarg_put; /* Next %o reg. to be written */ - int nextarg_get; /* Next %i reg. to be read */ - jit_insn delay; -}; - -#define jit_fill_delay_after(branch) (_jitl.delay = *--_jit.x.pc, \ - ((branch) == _jit.x.pc /* check if NOP was inserted */ \ - ? (_jit.x.pc[-1] ^= 1<<29) /* no if branch, toggle annul bit */ \ - : (_jit.x.pc[-1] = _jitl.delay)), /* yes if call, replace NOP with delay insn */ \ - *_jit.x.pc = _jitl.delay, _jit.x.pc - 1) /* return addr of delay insn */ - -/* If possible, use the `small' instruction (rs, imm, rd) - * else load imm into %l6 and use the `big' instruction (rs, %l6, rd) - * jit_chk_imm2 uses %l7 instead of %l6 to avoid conflicts when using delay slots - */ -#define jit_chk_imm(imm, small, big) (_siP(13,(imm)) ? (small) : (SETir((imm), JIT_BIG), (big)) ) -#define jit_chk_imm2(imm, small, big) (_siP(13,(imm)) ? (small) : (SETir((imm), JIT_BIG2), (big)) ) - -/* Helper macros for branches */ -#define jit_branchi(rs, is, jmp, nop) (jit_chk_imm2(is, CMPri(rs, is), CMPrr(rs, JIT_BIG2)), jmp, nop, _jit.x.pc - 1) -#define jit_branchr(s1, s2, jmp, nop) ( CMPrr(s1, s2), jmp, nop, _jit.x.pc - 1) - -/* Helper macros for boolean tests -- delay slot sets d to 1; - * taken branch leaves it to 1, not-taken branch resets it to 0 */ -#define jit_booli(d, rs, is, jmp) (jit_chk_imm (is, CMPri(rs, is), CMPrr(rs, JIT_BIG)), jmp, MOVir(1, (d)), MOVir(0, (d))) -#define jit_boolr(d, s1, s2, jmp) ( CMPrr(s1, s2), jmp, MOVir(1, (d)), MOVir(0, (d))) - -/* Helper macros for division - * The architecture specifies that there must be 3 instructions between * - * a y register write and a use of it for correct results. */ -#define jit_prepare_y(rs, is) (SRArir(rs, 31, JIT_BIG), WRri(JIT_BIG, _y), NOP(), NOP(), NOP(), _jit.x.pc -= jit_immsize(is)) -#define jit_clr_y(rs, is) ( WRri(0, _y), NOP(), NOP(), NOP(), _jit.x.pc -= jit_immsize(is)) - -#define jit_modr(jit_div, jit_mul, d, s1, s2) \ - (jit_div (JIT_BIG, s1, s2), \ - jit_mul (JIT_BIG, JIT_BIG, s2), \ - jit_subr_i (d, s1, JIT_BIG)) - -#define jit_modi(jit_divi, jit_muli, jit_divr, jit_mulr, d, rs, is) \ - (_siP(13,(imm)) \ - ? (jit_divi (JIT_BIG, rs, is), \ - jit_muli (JIT_BIG, JIT_BIG, is), \ - jit_subr_i (d, rs, JIT_BIG)) \ - : (SETir ((is), JIT_BIG2), \ - jit_modr (jit_divr, jit_mulr, d, rs, JIT_BIG2))) - -/* How many instruction are needed to put imm in a register. */ -#define jit_immsize(imm) (!(imm) ? 0 : \ - (!_siP((imm), 13) && ((imm) & 0x3ff) ? 2 : 1)) - - -/* branch instructions return the address of the *delay* instruction -- this - * is just a helper macro that makes jit_patch more readable. - */ -#define jit_patch_(jump_pc,pv) \ - (*jump_pc &= ~_MASK(22), \ - *jump_pc |= ((_jit_UL((pv)) - _jit_UL(jump_pc)) >> 2) & _MASK(22)) - -#define jit_patch_set(sethi_pc, or_pc, dest) \ - (*(sethi_pc) &= ~_MASK(22), *(sethi_pc) |= _HI(dest), \ - *(or_pc) &= ~_MASK(13), *(or_pc) |= _LO(dest)) \ - -#define jit_patch_movi(movi_pc, val) \ - jit_patch_set((movi_pc) - 2, (movi_pc) - 1, (val)) - -#define jit_arg_c() (_jitl.nextarg_get++) -#define jit_arg_i() (_jitl.nextarg_get++) -#define jit_arg_l() (_jitl.nextarg_get++) -#define jit_arg_p() (_jitl.nextarg_get++) -#define jit_arg_s() (_jitl.nextarg_get++) -#define jit_arg_uc() (_jitl.nextarg_get++) -#define jit_arg_ui() (_jitl.nextarg_get++) -#define jit_arg_ul() (_jitl.nextarg_get++) -#define jit_arg_us() (_jitl.nextarg_get++) -#define jit_addi_i(d, rs, is) jit_chk_imm((is), ADDrir((rs), (is), (d)), ADDrrr((rs), JIT_BIG, (d))) -#define jit_addr_i(d, s1, s2) ADDrrr((s1), (s2), (d)) -#define jit_addci_i(d, rs, is) jit_chk_imm((is), ADDCCrir((rs), (is), (d)), ADDCCrrr((rs), JIT_BIG, (d))) -#define jit_addcr_i(d, s1, s2) ADDCCrrr((s1), (s2), (d)) -#define jit_addxi_i(d, rs, is) jit_chk_imm((is), ADDXCCrir((rs), (is), (d)), ADDXCCrrr((rs), JIT_BIG, (d))) -#define jit_addxr_i(d, s1, s2) ADDXCCrrr((s1), (s2), (d)) -#define jit_andi_i(d, rs, is) jit_chk_imm((is), ANDrir((rs), (is), (d)), ANDrrr((rs), JIT_BIG, (d))) -#define jit_andr_i(d, s1, s2) ANDrrr((s1), (s2), (d)) -#define jit_beqi_i(label, rs, is) jit_branchi((rs), (is), BEi((label)), NOP() ) -#define jit_beqr_i(label, s1, s2) jit_branchr((s1), (s2), BEi((label)), NOP() ) -#define jit_bgei_i(label, rs, is) jit_branchi((rs), (is), BGEi((label)), NOP() ) -#define jit_bgei_ui(label, rs, is) jit_branchi((rs), (is), BGEUi((label)), NOP() ) -#define jit_bger_i(label, s1, s2) jit_branchr((s1), (s2), BGEi((label)), NOP() ) -#define jit_bger_ui(label, s1, s2) jit_branchr((s1), (s2), BGEUi((label)), NOP() ) -#define jit_bgti_i(label, rs, is) jit_branchi((rs), (is), BGi((label)), NOP() ) -#define jit_bgti_ui(label, rs, is) jit_branchi((rs), (is), BGUi((label)), NOP() ) -#define jit_bgtr_i(label, s1, s2) jit_branchr((s1), (s2), BGi((label)), NOP() ) -#define jit_bgtr_ui(label, s1, s2) jit_branchr((s1), (s2), BGUi((label)), NOP() ) -#define jit_blei_i(label, rs, is) jit_branchi((rs), (is), BLEi((label)), NOP() ) -#define jit_blei_ui(label, rs, is) jit_branchi((rs), (is), BLEUi((label)), NOP() ) -#define jit_bler_i(label, s1, s2) jit_branchr((s1), (s2), BLEi((label)), NOP() ) -#define jit_bler_ui(label, s1, s2) jit_branchr((s1), (s2), BLEUi((label)), NOP() ) -#define jit_blti_i(label, rs, is) jit_branchi((rs), (is), BLi((label)), NOP() ) -#define jit_blti_ui(label, rs, is) jit_branchi((rs), (is), BLUi((label)), NOP() ) -#define jit_bltr_i(label, s1, s2) jit_branchr((s1), (s2), BLi((label)), NOP() ) -#define jit_bltr_ui(label, s1, s2) jit_branchr((s1), (s2), BLUi((label)), NOP() ) -#define jit_bnei_i(label, rs, is) jit_branchi((rs), (is), BNEi((label)), NOP() ) -#define jit_bner_i(label, s1, s2) jit_branchr((s1), (s2), BNEi((label)), NOP() ) -#define jit_bmsi_i(label, rs, is) (jit_chk_imm((is), BTSTir((is), (rs)), BTSTrr((rs), JIT_BIG)), BNEi((label)), NOP(), _jit.x.pc - 1) -#define jit_bmci_i(label, rs, is) (jit_chk_imm((is), BTSTir((is), (rs)), BTSTrr((rs), JIT_BIG)), BEi((label)), NOP(), _jit.x.pc - 1) -#define jit_bmsr_i(label, s1, s2) ( BTSTrr((s1), (s2)), BNEi((label)), NOP(), _jit.x.pc - 1) -#define jit_bmcr_i(label, s1, s2) ( BTSTrr((s1), (s2)), BEi((label)), NOP(), _jit.x.pc - 1) -#define jit_boaddi_i(label, rs, is) (jit_chk_imm((is), ADDCCrir((rs), (is), (rs)), ADDCCrrr((rs), JIT_BIG, (rs))), BVSi((label)), NOP(), _jit.x.pc - 1) -#define jit_bosubi_i(label, rs, is) (jit_chk_imm((is), SUBCCrir((rs), (is), (rs)), SUBCCrrr((rs), JIT_BIG, (rs))), BVSi((label)), NOP(), _jit.x.pc - 1) -#define jit_boaddr_i(label, s1, s2) ( ADDCCrrr((s1), (s2), (s1)), BVSi((label)), NOP(), _jit.x.pc - 1) -#define jit_bosubr_i(label, s1, s2) ( SUBCCrrr((s1), (s2), (s1)), BVSi((label)), NOP(), _jit.x.pc - 1) -#define jit_boaddi_ui(label, rs, is) (jit_chk_imm((is), ADDCCrir((rs), (is), (rs)), ADDCCrrr((rs), JIT_BIG, (rs))), BCSi((label)), NOP(), _jit.x.pc - 1) -#define jit_bosubi_ui(label, rs, is) (jit_chk_imm((is), SUBCCrir((rs), (is), (rs)), SUBCCrrr((rs), JIT_BIG, (rs))), BCSi((label)), NOP(), _jit.x.pc - 1) -#define jit_boaddr_ui(label, s1, s2) ( ADDCCrrr((s1), (s2), (s1)), BCSi((label)), NOP(), _jit.x.pc - 1) -#define jit_bosubr_ui(label, s1, s2) ( SUBCCrrr((s1), (s2), (s1)), BCSi((label)), NOP(), _jit.x.pc - 1) -#define jit_calli(label) (CALLi(label), NOP(), _jit.x.pc - 1) -#define jit_callr(reg) (CALLx((reg), 0), NOP()) - -#define jit_divi_i(d, rs, is) (jit_prepare_y((rs), 0x12345678), SETir((is), JIT_BIG), SDIVrrr((rs), JIT_BIG, (d)) ) -#define jit_divi_ui(d, rs, is) (jit_clr_y((rs), 0x12345678), SETir((is), JIT_BIG), UDIVrrr((rs), JIT_BIG, (d)) ) -#define jit_divr_i(d, s1, s2) (jit_prepare_y((s1), 0), SDIVrrr((s1), (s2), (d))) -#define jit_divr_ui(d, s1, s2) (jit_clr_y((s1), 0), UDIVrrr((s1), (s2), (d))) -#define jit_eqi_i(d, rs, is) jit_chk_imm((is), \ - (SUBCCrir((rs), (is), (d)), ADDXCCrir((d), -1, JIT_BIG), SUBXrir(0,-1,(d))),\ - jit_eqr_i(d, rs, JIT_BIG)) -#define jit_eqr_i(d, s1, s2) (SUBCCrrr((s1), (s2), (d)), ADDXCCrir((d), -1, JIT_BIG), SUBXrir(0,-1,(d))) -#define jit_nei_i(d, rs, is) jit_chk_imm((is), \ - (SUBCCrir((rs), (is), (d)), ADDXCCrir((d), -1, JIT_BIG), ADDXrrr(0,0,(d))),\ - jit_ner_i(d, rs, JIT_BIG)) -#define jit_ner_i(d, s1, s2) (SUBCCrrr((s1), (s2), (d)), ADDXCCrir((d), -1, JIT_BIG), ADDXrrr(0,0,(d))) -#define jit_gei_i(d, rs, is) jit_booli ((d), (rs), (is), BGEi(_jit.x.pc + 3) ) -#define jit_gei_ui(d, rs, is) jit_booli ((d), (rs), (is), BGEUi(_jit.x.pc + 3)) -#define jit_ger_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BGEi(_jit.x.pc + 3) ) -#define jit_ger_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BGEUi(_jit.x.pc + 3)) -#define jit_gti_i(d, rs, is) jit_booli ((d), (rs), (is), BGi(_jit.x.pc + 3) ) -#define jit_gti_ui(d, rs, is) jit_booli ((d), (rs), (is), BGUi(_jit.x.pc + 3) ) -#define jit_gtr_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BGi(_jit.x.pc + 3) ) -#define jit_gtr_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BGUi(_jit.x.pc + 3) ) -#define jit_hmuli_i(d, rs, is) (jit_muli_i (JIT_BIG, (rs), (is)), RDir (_y, (d))) -#define jit_hmuli_ui(d, rs, is) (jit_muli_ui(JIT_BIG, (rs), (is)), RDir (_y, (d))) -#define jit_hmulr_i(d, s1, s2) (jit_mulr_i (JIT_BIG, (s1), (s2)), RDir (_y, (d))) -#define jit_hmulr_ui(d, s1, s2) (jit_mulr_ui(JIT_BIG, (s1), (s2)), RDir (_y, (d))) -#define jit_jmpi(label) (BA_Ai((label)), _jit.x.pc) -#define jit_jmpr(reg) (JMPx(JIT_RZERO, (reg)), NOP(), _jit.x.pc - 1) -#define jit_ldxi_c(d, rs, is) jit_chk_imm((is), LDSBmr((rs), (is), (d)), LDSBxr((rs), JIT_BIG, (d))) -#define jit_ldxi_i(d, rs, is) jit_chk_imm((is), LDSWmr((rs), (is), (d)), LDSWxr((rs), JIT_BIG, (d))) -#define jit_ldxi_s(d, rs, is) jit_chk_imm((is), LDSHmr((rs), (is), (d)), LDSHxr((rs), JIT_BIG, (d))) -#define jit_ldxi_uc(d, rs, is) jit_chk_imm((is), LDUBmr((rs), (is), (d)), LDUBxr((rs), JIT_BIG, (d))) -#define jit_ldxi_us(d, rs, is) jit_chk_imm((is), LDUHmr((rs), (is), (d)), LDUHxr((rs), JIT_BIG, (d))) -#define jit_ldxr_c(d, s1, s2) LDSBxr((s1), (s2), (d)) -#define jit_ldxr_i(d, s1, s2) LDSWxr((s1), (s2), (d)) -#define jit_ldxr_s(d, s1, s2) LDSHxr((s1), (s2), (d)) -#define jit_ldxr_uc(d, s1, s2) LDUBxr((s1), (s2), (d)) -#define jit_ldxr_us(d, s1, s2) LDUHxr((s1), (s2), (d)) -#define jit_lei_i(d, rs, is) jit_booli ((d), (rs), (is), BLEi(_jit.x.pc + 3) ) -#define jit_lei_ui(d, rs, is) jit_booli ((d), (rs), (is), BLEUi(_jit.x.pc + 3)) -#define jit_ler_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BLEi(_jit.x.pc + 3) ) -#define jit_ler_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BLEUi(_jit.x.pc + 3)) -#define jit_lshi_i(d, rs, is) SLLrir((rs), (is), (d)) -#define jit_lshr_i(d, r1, r2) SLLrrr((r1), (r2), (d)) -#define jit_lti_i(d, rs, is) jit_booli ((d), (rs), (is), BLi(_jit.x.pc + 3) ) -#define jit_lti_ui(d, rs, is) jit_booli ((d), (rs), (is), BLUi(_jit.x.pc + 3) ) -#define jit_ltr_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BLi(_jit.x.pc + 3) ) -#define jit_ltr_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BLUi(_jit.x.pc + 3) ) -#define jit_modi_i(d, rs, is) jit_modi(jit_divi_i, jit_muli_i, jit_divr_i, jit_mulr_i, (d), (rs), (is)) -#define jit_modi_ui(d, rs, is) jit_modi(jit_divi_ui, jit_muli_ui, jit_divr_ui, jit_mulr_ui, (d), (rs), (is)) -#define jit_modr_i(d, s1, s2) jit_modr(jit_divr_i, jit_mulr_i, (d), (s1), (s2)) -#define jit_modr_ui(d, s1, s2) jit_modr(jit_divr_ui, jit_mulr_ui, (d), (s1), (s2)) -#define jit_movi_i(d, is) SETir((is), (d)) -#define jit_movi_p(d, is) (SETir2(_HI((is)), _LO((is)), (d)), _jit.x.pc) -#define jit_movr_i(d, rs) MOVrr((rs), (d)) -#define jit_muli_i(d, rs, is) jit_chk_imm((is), SMULrir((rs), (is), (d)), SMULrrr((rs), JIT_BIG, (d))) -#define jit_muli_ui(d, rs, is) jit_chk_imm((is), UMULrir((rs), (is), (d)), UMULrrr((rs), JIT_BIG, (d))) -#define jit_mulr_i(d, s1, s2) SMULrrr((s1), (s2), (d)) -#define jit_mulr_ui(d, s1, s2) UMULrrr((s1), (s2), (d)) -#define jit_nop() NOP() -#define jit_ori_i(d, rs, is) jit_chk_imm((is), ORrir((rs), (is), (d)), ORrrr((rs), JIT_BIG, (d))) -#define jit_orr_i(d, s1, s2) ORrrr((s1), (s2), (d)) -#define jit_patch_at(delay_pc, pv) jit_patch_ (((delay_pc) - 1) , (pv)) -#define jit_popr_i(rs) (LDmr(JIT_SP, 0, (rs)), ADDrir(JIT_SP, 8, JIT_SP)) -#define jit_prepare_i(num) (_jitl.nextarg_put += (num)) -#define jit_prolog(numargs) (SAVErir(JIT_SP, -120, JIT_SP), _jitl.nextarg_get = _Ri(0)) -#define jit_pushr_i(rs) (STrm((rs), JIT_SP, -8), SUBrir(JIT_SP, 8, JIT_SP)) -#define jit_pusharg_i(rs) (--_jitl.nextarg_put, MOVrr((rs), _Ro(_jitl.nextarg_put))) -#define jit_ret() (RET(), RESTORE()) -#define jit_retval_i(rd) MOVrr(_Ro(0), (rd)) -#define jit_rshi_i(d, rs, is) SRArir((rs), (is), (d)) -#define jit_rshi_ui(d, rs, is) SRLrir((rs), (is), (d)) -#define jit_rshr_i(d, r1, r2) SRArrr((r1), (r2), (d)) -#define jit_rshr_ui(d, r1, r2) SRLrrr((r1), (r2), (d)) -#define jit_stxi_c(id, rd, rs) jit_chk_imm((id), STBrm((rs), (rd), (id)), STBrx((rs), (rd), JIT_BIG)) -#define jit_stxi_i(id, rd, rs) jit_chk_imm((id), STWrm((rs), (rd), (id)), STWrx((rs), (rd), JIT_BIG)) -#define jit_stxi_s(id, rd, rs) jit_chk_imm((id), STHrm((rs), (rd), (id)), STHrx((rs), (rd), JIT_BIG)) -#define jit_stxr_c(d1, d2, rs) STBrx((rs), (d1), (d2)) -#define jit_stxr_i(d1, d2, rs) STWrx((rs), (d1), (d2)) -#define jit_stxr_s(d1, d2, rs) STHrx((rs), (d1), (d2)) -#define jit_subr_i(d, s1, s2) SUBrrr((s1), (s2), (d)) -#define jit_subcr_i(d, s1, s2) SUBCCrrr((s1), (s2), (d)) -#define jit_subxi_i(d, rs, is) jit_chk_imm((is), SUBXCCrir((rs), (is), (d)), SUBXCCrrr((rs), JIT_BIG, (d))) -#define jit_subxr_i(d, s1, s2) SUBXCCrrr((s1), (s2), (d)) -#define jit_xori_i(d, rs, is) jit_chk_imm((is), XORrir((rs), (is), (d)), XORrrr((rs), JIT_BIG, (d))) -#define jit_xorr_i(d, s1, s2) XORrrr((s1), (s2), (d)) - -#endif /* __lightning_core_h */ diff --git a/src/runtime/c/pgf/lightning/sparc/fp.h b/src/runtime/c/pgf/lightning/sparc/fp.h deleted file mode 100644 index f22578d1a..000000000 --- a/src/runtime/c/pgf/lightning/sparc/fp.h +++ /dev/null @@ -1,222 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Run-time assembler & support macros for the PowerPC math unit - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002, 2004 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - - -#ifndef __lightning_asm_fp_h -#define __lightning_asm_fp_h - -#include - -#define JIT_FPR_NUM 6 -#define JIT_FPR(i) (30-(i)*2) -#define JIT_FPTMP 18 - -#define jit_addr_f(rd,s1,s2) FADDSrrr((s1), (s2), (rd)) -#define jit_subr_f(rd,s1,s2) FSUBSrrr((s1), (s2), (rd)) -#define jit_mulr_f(rd,s1,s2) FMULSrrr((s1), (s2), (rd)) -#define jit_divr_f(rd,s1,s2) FDIVSrrr((s1), (s2), (rd)) - -#define jit_addr_d(rd,s1,s2) FADDDrrr((s1), (s2), (rd)) -#define jit_subr_d(rd,s1,s2) FSUBDrrr((s1), (s2), (rd)) -#define jit_mulr_d(rd,s1,s2) FMULDrrr((s1), (s2), (rd)) -#define jit_divr_d(rd,s1,s2) FDIVDrrr((s1), (s2), (rd)) - -#define jit_movr_f(rd,rs) FMOVSrr((rs), (rd)) -#define jit_abs_d(rd,rs) FABSSrr((rs), (rd)) -#define jit_negr_d(rd,rs) FNEGSrr((rs), (rd)) -#define jit_sqrt_d(rd,rs) FSQRTSrr((rs), (rd)) -#define jit_movr_d(rd,rs) FMOVDrr((rs), (rd)) -#define jit_abs_f(rd,rs) FABSDrr((rs), (rd)) -#define jit_negr_f(rd,rs) FNEGDrr((rs), (rd)) -#define jit_sqrt_f(rd,rs) FSQRTDrr((rs), (rd)) -#define jit_extr_f_d(rs, rd) FSTODrr((rs), (rd)) -#define jit_extr_d_f(rs, rd) FDTOSrr((rs), (rd)) - -#define jit_movi_f(rd,immf) \ - do { \ - float _v = (immf); \ - _1(_jit.x.pc + 3), LDFmr(_Ro(7), 8, (rd)); \ - memcpy(_jit.x.uc_pc, &_v, sizeof (float)); \ - _jit.x.uc_pc += sizeof (float); \ - } while(0) - -#define jit_movi_d(rd,immd) \ - do { \ - double _v = (immd); \ - if ((long)_jit.x.pc & 4) NOP(); \ - _1(_jit.x.pc + 4); \ - LDDFmr(_Ro(7), 8, (rd)); \ - memcpy(_jit.x.uc_pc, &_v, sizeof (double)); \ - _jit.x.uc_pc += sizeof (double); \ - } while(0) - - -#define jit_ldxi_f(rd, rs, is) jit_chk_imm((is), LDFmr((rs), (is), (rd)), LDFxr((rs), JIT_BIG, (rd))) -#define jit_ldxi_d(rd, rs, is) jit_chk_imm((is), LDDFmr((rs), (is), (rd)), LDDFxr((rs), JIT_BIG, (rd))) -#define jit_ldxr_f(rd, s1, s2) LDFxr((s1), (s2), (rd)) -#define jit_ldxr_d(rd, s1, s2) LDDFxr((s1), (s2), (rd)) -#define jit_stxi_f(id, rd, rs) jit_chk_imm((id), STFrm((rs), (rd), (id)), STFrx((rs), (rd), JIT_BIG)) -#define jit_stxi_d(id, rd, rs) jit_chk_imm((id), STDFrm((rs), (rd), (id)), STDFrx((rs), (rd), JIT_BIG)) -#define jit_stxr_f(d1, d2, rs) STFrx((rs), (d1), (d2)) -#define jit_stxr_d(d1, d2, rs) STDFrx((rs), (d1), (d2)) - -#define jit_truncr_f_i(rd, rs) ( \ - _1(_jit.x.pc + 3), \ - FSTOIrr((rs), JIT_FPTMP), \ - NOP(), \ - STFrm(JIT_FPTMP, _Ro(7), 8), \ - LDmr(_Ro(7), 8, (rd))) - -#define jit_truncr_d_i(rd, rs) ( \ - _1(_jit.x.pc + 3), \ - FDTOIrr((rs), JIT_FPTMP), \ - NOP(), \ - STFrm(JIT_FPTMP, _Ro(7), 8), \ - LDmr(_Ro(7), 8, (rd))) - -#define jit_extr_i_d(rd, rs) (_1 (_jit.x.pc + 3), NOP(), NOP(), STrm((rs), _Ro(7), 8), LDFmr(_Ro(7), 8, (rd)), FITODrr((rd), (rd))) -#define jit_extr_i_f(rd, rs) (_1 (_jit.x.pc + 3), NOP(), NOP(), STrm((rs), _Ro(7), 8), LDFmr(_Ro(7), 8, (rd)), FITOSrr((rd), (rd))) - -#define jit_do_round_f(rd, rs, fixup, mode) do { \ - jit_movi_f (JIT_FPTMP, fixup); \ - _1(_jit.x.pc + 4); \ - SETHIir(_HI(mode << 29), JIT_BIG); \ - NOP(); \ - NOP(); \ - STFSRm(_Ro(7), 8); /* store fsr */ \ - LDmr(_Ro(7), 8, rd); \ - XORrrr(rd, JIT_BIG, JIT_BIG); /* adjust mode */ \ - STrm(JIT_BIG, _Ro(7), 12); \ - LDFSRm(_Ro(7), 12); /* load fsr */ \ - FADDSrrr ((rs), JIT_FPTMP, JIT_FPTMP); \ - LDFSRm(_Ro(7), 8); \ - FSTOIrr(JIT_FPTMP, JIT_FPTMP); \ - STFrm(JIT_FPTMP, _Ro(7), 8); \ - LDmr(_Ro(7), 8, (rd)); \ - ADDCCrrr ((rd), (rd), 0); \ - SUBXrrr ((rd), 0, (rd)); \ - } while (0); - -#define jit_do_round_d(rd, rs, fixup, mode) do { \ - jit_movi_d (JIT_FPTMP, fixup); \ - _1(_jit.x.pc + 4); \ - SETHIir(_HI(mode << 29), JIT_BIG); \ - NOP(); \ - NOP(); \ - STFSRm(_Ro(7), 8); /* store fsr */ \ - LDmr(_Ro(7), 8, rd); \ - XORrrr(rd, JIT_BIG, JIT_BIG); /* adjust mode */ \ - STrm(JIT_BIG, _Ro(7), 12); \ - LDFSRm(_Ro(7), 12); /* load fsr */ \ - FADDDrrr ((rs), JIT_FPTMP, JIT_FPTMP); \ - LDFSRm(_Ro(7), 8); \ - FDTOIrr(JIT_FPTMP, JIT_FPTMP); \ - STFrm(JIT_FPTMP, _Ro(7), 8); \ - LDmr(_Ro(7), 8, (rd)); \ - ADDCCrrr ((rd), (rd), 0); \ - SUBXrrr ((rd), 0, (rd)); \ - } while (0); - -#define jit_roundr_f_i(rd, rs) do { \ - jit_movi_f (JIT_FPTMP, 0.5); \ - FADDSrrr ((rs), JIT_FPTMP, JIT_FPTMP); \ - jit_truncr_f_i ((rd), JIT_FPTMP); \ - ADDCCrrr ((rd), (rd), 0); \ - SUBXrrr ((rd), 0, (rd)); \ - } while (0) - -#define jit_roundr_d_i(rd, rs) do { \ - jit_movi_d (JIT_FPTMP, 0.5); \ - FADDDrrr ((rs), JIT_FPTMP, JIT_FPTMP); \ - jit_truncr_d_i ((rd), JIT_FPTMP); \ - ADDCCrrr ((rd), (rd), 0); \ - SUBXrrr ((rd), 0, (rd)); \ - } while (0) - -#define jit_ceilr_f_i(rd, rs) \ - jit_do_round_f ((rd), (rs), 1.0f - FLT_EPSILON, 3) - -#define jit_ceilr_d_i(rd, rs) \ - jit_do_round_d ((rd), (rs), 1.0 - DBL_EPSILON, 3) - -#define jit_floorr_f_i(rd, rs) \ - jit_do_round_f ((rd), (rs), FLT_EPSILON, 2) - -#define jit_floorr_d_i(rd, rs) \ - jit_do_round_d ((rd), (rs), DBL_EPSILON, 2) - -#define jit_ltr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBLi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ltr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBLi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ler_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBLEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ler_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBLEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_eqr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_eqr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ner_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBNEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ner_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBNEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ger_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBGEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ger_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBGEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_gtr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBGi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_gtr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBGi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_unltr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBULi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_unltr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBULi(_jit.x.pc + 3), MOVir (1, (d), MOVir (0, (d))) -#define jit_unler_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBULEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_unler_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBULEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_uneqr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBUEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_uneqr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBUEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ltgtr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBLGi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ltgtr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBLGi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_unger_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBUGEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_unger_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBUGEi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ungtr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBUGi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ungtr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBUGi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ordr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBOi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_ordr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBOi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_unordr_d(d, s1, s2) (FCMPDrr ((s1), (s2)), FBUi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) -#define jit_unordr_f(d, s1, s2) (FCMPSrr ((s1), (s2)), FBUi(_jit.x.pc + 3), MOVir (1, (d)), MOVir (0, (d))) - -#define jit_prepare_f(num) (_jitl.nextarg_put += (num)) -#define jit_prepare_d(num) (_jitl.nextarg_put += 2 * (num)) - -#define jit_arg_f() (_jitl.nextarg_get++) -#define jit_arg_d() (_jitl.nextarg_get += _jitl.nextarg_get & 1, _jitl.nextarg_get += 2, _jitl.nextarg_get - 2) - -#define jit_getarg_f(rd, ofs) (STrm(ofs, _Ri(6), -24), LDFmr (_Ri(6), -24, (rd))) -#define jit_getarg_d(rd, ofs) (STDrm(ofs, _Ri(6), -24), LDDFmr (_Ri(6), -24, (rd))) - -#define jit_pusharg_f(rs) (STFrm((rs), _Ri(6), -24), --_jitl.nextarg_put, LDmr (_Ri(6), -24, _Ro(_jitl.nextarg_put))) -#define jit_pusharg_d(rs) (STDFrm((rs), _Ri(6), -24), _jitl.nextarg_put -= 2, LDmr (_Ri(6), -24, _Ro(_jitl.nextarg_put))) - -#define jit_retval_f(rs) jit_movr_f(0, rs) -#define jit_retval_d(rs) jit_movr_d(0, rs) - -#endif /* __lightning_asm_fp_h */ diff --git a/src/runtime/c/pgf/lightning/sparc/funcs.h b/src/runtime/c/pgf/lightning/sparc/funcs.h deleted file mode 100644 index 8fd9e1001..000000000 --- a/src/runtime/c/pgf/lightning/sparc/funcs.h +++ /dev/null @@ -1,65 +0,0 @@ -/******************************** -*- C -*- **************************** - * - * Platform-independent layer inline functions (Sparc) - * - ***********************************************************************/ - - -/*********************************************************************** - * - * Copyright 2000, 2001, 2002 Free Software Foundation, Inc. - * Written by Paolo Bonzini. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with GNU lightning; see the file COPYING.LESSER; if not, write to the - * Free Software Foundation, 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. - * - ***********************************************************************/ - - - -#ifndef __lightning_funcs_h -#define __lightning_funcs_h - -#if !defined(__GNUC__) && !defined(__GNUG__) -#error Go get GNU C, I do not know how to flush the cache -#error with this compiler. -#else -/* Why doesn't this compile?!? - * static void - * jit_flush_code(start, end) - * void *start; - * void *end; - */ - -static void -jit_flush_code(void* start, void* end) -{ -#ifndef LIGHTNING_CROSS - register char *dest; - - __asm__ __volatile__ ("stbar"); - for (dest = (char *)start; dest <= (char *)end; dest += 4) { - __asm__ __volatile__ ("flush %0"::"r"(dest)); - } - - /* [SPARC Architecture Manual v8, page 139, implementation note #5] */ - __asm__ __volatile__ ("nop; nop; nop; nop; nop"); -#endif -} -#endif - -#endif /* __lightning_core_h */ diff --git a/src/runtime/c/pgf/linearizer.c b/src/runtime/c/pgf/linearizer.c deleted file mode 100644 index d48bdde18..000000000 --- a/src/runtime/c/pgf/linearizer.c +++ /dev/null @@ -1,1246 +0,0 @@ -#include "data.h" -#include "linearizer.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -//#define PGF_LINEARIZER_DEBUG - -static void -pgf_lzr_add_overl_entry(PgfCncOverloadMap* overl_table, - PgfCCat* ccat, void* entry, - GuPool *pool) -{ - GuBuf* entries = - gu_map_get(overl_table, ccat, GuBuf*); - if (entries == NULL) { - entries = gu_new_buf(void*, pool); - gu_map_put(overl_table, ccat, GuBuf*, entries); - } - - gu_buf_push(entries, void*, entry); -} - -PGF_API void -pgf_lzr_index(PgfConcr* concr, - PgfCCat* ccat, PgfProduction prod, - bool is_lexical, - GuPool *pool) -{ - void* data = gu_variant_data(prod); - switch (gu_variant_tag(prod)) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papply = data; - PgfCncOverloadMap* overl_table = - gu_map_get(concr->fun_indices, papply->fun->absfun->name, - PgfCncOverloadMap*); - if (!overl_table) { - overl_table = gu_new_addr_map(PgfCCat*, GuBuf*, &gu_null_struct, pool); - gu_map_put(concr->fun_indices, - papply->fun->absfun->name, PgfCncOverloadMap*, overl_table); - } - pgf_lzr_add_overl_entry(overl_table, ccat, papply, pool); - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = data; - pgf_lzr_add_overl_entry(concr->coerce_idx, ccat, pcoerce, pool); - break; - } - default: - gu_impossible(); - } -} - -typedef struct { - PgfConcr* concr; - GuChoice* ch; - PgfExpr expr; - int fid; - GuEnum en; -} PgfCnc; - - -#ifdef PGF_LINEARIZER_DEBUG -static void -pgf_print_cnc_tree_vars(size_t n_vars, PgfPrintContext* context, - GuOut* out, GuExn* err) -{ - if (n_vars > 0) { - gu_putc('\\', out, err); - for (;;) { - gu_string_write(context->name, out, err); - n_vars--; - - if (n_vars > 0) - gu_putc(',', out, err); - else - break; - } - gu_puts(" -> ", out, err); - } -} - -PGF_INTERNAL void -pgf_print_cnc_tree(PgfCncTree ctree, GuOut* out, GuExn* err) -{ - GuVariantInfo ti = gu_variant_open(ctree); - switch (ti.tag) { - case PGF_CNC_TREE_APP: { - PgfCncTreeApp* capp = ti.data; - if (capp->n_vars+capp->n_args > 0) gu_putc('(', out, err); - pgf_print_cnc_tree_vars(capp->n_vars, capp->context, out, err); - gu_printf(out, err, "F%d", capp->fun->funid); - for (size_t i = 0; i < capp->n_args; i++) { - gu_putc(' ', out, err); - pgf_print_cnc_tree(capp->args[i], out, err); - } - if (capp->n_vars+capp->n_args > 0) gu_putc(')', out, err); - break; - } - case PGF_CNC_TREE_CHUNKS: { - PgfCncTreeChunks* chunks = ti.data; - if (chunks->n_vars+chunks->n_args > 0) gu_putc('(', out, err); - pgf_print_cnc_tree_vars(chunks->n_vars, chunks->context, out, err); - if (chunks->id > 0) - gu_printf(out, err, "?%d", chunks->id); - else - gu_putc('?', out, err); - for (size_t i = 0; i < chunks->n_args; i++) { - gu_putc(' ', out, err); - pgf_print_cnc_tree(chunks->args[i], out, err); - } - if (chunks->n_vars+chunks->n_args > 0) gu_putc(')', out, err); - break; - } - case PGF_CNC_TREE_LIT: { - PgfCncTreeLit* clit = ti.data; - if (clit->n_vars > 0) gu_putc('(', out, err); - pgf_print_cnc_tree_vars(clit->n_vars, clit->context, out, err); - pgf_print_literal(clit->lit, out, err); - if (clit->n_vars > 0) gu_putc(')', out, err); - break; - } - case GU_VARIANT_NULL: - gu_puts("null", out, err); - break; - default: - gu_impossible(); - } -} -#endif - -static PgfCncTree -pgf_cnc_resolve(PgfCnc* cnc, - PgfPrintContext* context, PgfExpr expr, - PgfCCat* ccat, - GuPool* pool); - -static PgfCncTree -pgf_cnc_resolve_app(PgfCnc* cnc, - size_t n_vars, PgfPrintContext* context, - PgfCCat* ccat, GuBuf* buf, GuBuf* args, - GuPool* pool) -{ - GuChoiceMark mark = gu_choice_mark(cnc->ch); - int save_fid = cnc->fid; - - size_t n_args = gu_buf_length(args); - - PgfCncTree ret = gu_null_variant; - PgfCncTreeApp* capp = - gu_new_flex_variant(PGF_CNC_TREE_APP, - PgfCncTreeApp, - args, n_args, &ret, pool); - capp->ccat = ccat; - capp->n_vars = n_vars; - capp->context = context; - -redo:; - int index = gu_choice_next(cnc->ch, gu_buf_length(buf)); - if (index < 0) { - return gu_null_variant; - } - - PgfProductionApply* papply = - gu_buf_get(buf, PgfProductionApply*, index); - gu_assert(n_args == gu_seq_length(papply->args)); - - capp->fun = papply->fun; - capp->fid = 0; - capp->n_args = n_args; - - for (size_t i = 0; i < n_args; i++) { - PgfPArg* parg = gu_seq_index(papply->args, PgfPArg, i); - PgfExpr earg = gu_buf_get(args, PgfExpr, n_args-i-1); - - PgfCCat* ccat = NULL; - GuBuf* coercions = - gu_map_get(cnc->concr->coerce_idx, parg->ccat, GuBuf*); - if (coercions == NULL) { - ccat = parg->ccat; - } else { - int index = gu_choice_next(cnc->ch, gu_buf_length(coercions)); - if (index < 0) { - cnc->fid = save_fid; - gu_choice_reset(cnc->ch, mark); - if (!gu_choice_advance(cnc->ch)) - return gu_null_variant; - goto redo; - } - - PgfProductionCoerce* pcoerce = - gu_buf_get(coercions, PgfProductionCoerce*, index); - ccat = pcoerce->coerce; - } - - capp->args[i] = - pgf_cnc_resolve(cnc, context, earg, ccat, pool); - if (gu_variant_is_null(capp->args[i])) { - cnc->fid = save_fid; - gu_choice_reset(cnc->ch, mark); - if (!gu_choice_advance(cnc->ch)) - return gu_null_variant; - goto redo; - } - } - - capp->fid = cnc->fid++; - - return ret; -} - -static PgfCncTree -pgf_cnc_resolve_def(PgfCnc* cnc, - size_t n_vars, PgfPrintContext* context, - PgfCCat* ccat, GuString s, GuPool* pool) -{ - PgfCncTree lit = gu_null_variant; - PgfCncTree ret = gu_null_variant; - - PgfCncTreeLit* clit = - gu_new_variant(PGF_CNC_TREE_LIT, - PgfCncTreeLit, - &lit, pool); - clit->n_vars = 0; - clit->context = context; - clit->fid = cnc->fid++; - PgfLiteralStr* lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(s)+1, - &clit->lit, pool); - strcpy((char*) lit_str->val, (char*) s); - - if (ccat->lindefs == NULL) - return lit; - - int index = - gu_choice_next(cnc->ch, gu_seq_length(ccat->lindefs)); - if (index < 0) { - return ret; - } - PgfCncTreeApp* capp = - gu_new_flex_variant(PGF_CNC_TREE_APP, - PgfCncTreeApp, - args, 1, &ret, pool); - capp->ccat = ccat; - capp->fun = gu_seq_get(ccat->lindefs, PgfCncFun*, index); - capp->fid = cnc->fid++; - capp->n_vars = n_vars; - capp->context = context; - capp->n_args = 1; - capp->args[0] = lit; - - return ret; -} - -typedef struct { - GuMapItor fn; - int index; - PgfCCat* ccat; - GuBuf* buf; -} PgfCncItor; - -static void -pgf_cnc_cat_resolve_itor(GuMapItor* fn, const void* key, void* value, GuExn* err) -{ - PgfCncItor* clo = (PgfCncItor*) fn; - PgfCCat* ccat = (PgfCCat*) key; - GuBuf* buf = *((GuBuf**) value); - - if (clo->index == 0) { - clo->ccat = ccat; - clo->buf = buf; - } - - clo->index--; -} - -PGF_API PgfCncTree -pgf_lzr_wrap_linref(PgfCncTree ctree, GuPool* pool) -{ - GuVariantInfo cti = gu_variant_open(ctree); - switch (cti.tag) { - case PGF_CNC_TREE_APP: { - PgfCncTreeApp* capp = cti.data; - - assert(gu_seq_length(capp->ccat->linrefs) > 0); - - // here we must apply the linref function - PgfCncTree new_ctree; - PgfCncTreeApp* new_capp = - gu_new_flex_variant(PGF_CNC_TREE_APP, - PgfCncTreeApp, - args, 1, &new_ctree, pool); - new_capp->ccat = NULL; - new_capp->fun = gu_seq_get(capp->ccat->linrefs, PgfCncFun*, 0); - new_capp->fid = -1; - new_capp->n_vars = 0; - new_capp->context = NULL; - new_capp->n_args = 1; - new_capp->args[0] = ctree; - - ctree = new_ctree; - break; - } - } - - return ctree; -} - -static PgfCncTree -pgf_cnc_resolve(PgfCnc* cnc, - PgfPrintContext* context, PgfExpr expr, - PgfCCat* ccat, - GuPool* pool) -{ - PgfCncTree ret = gu_null_variant; - GuPool* tmp_pool = gu_new_pool(); - size_t n_vars = 0; - GuBuf* args = gu_new_buf(PgfExpr, tmp_pool); - - for (;;) { - GuVariantInfo i = gu_variant_open(expr); - switch (i.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* eabs = i.data; - - PgfPrintContext* new_context = gu_new(PgfPrintContext, pool); - new_context->name = eabs->id; - new_context->next = context; - context = new_context; - - n_vars++; - - expr = eabs->body; - break; - } - case PGF_EXPR_APP: { - PgfExprApp* eapp = i.data; - gu_buf_push(args, PgfExpr, eapp->arg); - expr = eapp->fun; - break; - } - case PGF_EXPR_LIT: { - PgfExprLit* elit = i.data; - PgfCncTreeLit* clit = - gu_new_variant(PGF_CNC_TREE_LIT, - PgfCncTreeLit, - &ret, pool); - clit->n_vars = n_vars; - clit->context = context; - clit->fid = cnc->fid++; - clit->lit = elit->lit; - goto done; - } - case PGF_EXPR_META: { - PgfExprMeta* emeta = i.data; - size_t n_args = gu_buf_length(args); - - PgfCncTree chunks_tree; - PgfCncTreeChunks* chunks = - gu_new_flex_variant(PGF_CNC_TREE_CHUNKS, - PgfCncTreeChunks, - args, n_args, &chunks_tree, pool); - chunks->id = emeta->id; - chunks->n_vars = n_vars; - chunks->context = context; - chunks->n_args = n_args; - - for (size_t i = 0; i < n_args; i++) { - PgfExpr earg = gu_buf_get(args, PgfExpr, n_args-i-1); - chunks->args[i] = pgf_cnc_resolve(cnc, context, earg, NULL, pool); - if (gu_variant_is_null(chunks->args[i])) { - ret = gu_null_variant; - goto done; - } - chunks->args[i] = - pgf_lzr_wrap_linref(chunks->args[i], pool); - } - - if (ccat == NULL) { - ret = chunks_tree; - goto done; - } - if (ccat->lindefs == NULL) { - goto done; - } - - int index = - gu_choice_next(cnc->ch, gu_seq_length(ccat->lindefs)); - if (index < 0) { - return ret; - } - PgfCncTreeApp* capp = - gu_new_flex_variant(PGF_CNC_TREE_APP, - PgfCncTreeApp, - args, 1, &ret, pool); - capp->ccat = ccat; - capp->fun = gu_seq_get(ccat->lindefs, PgfCncFun*, index); - capp->fid = cnc->fid++; - capp->n_vars = 0; - capp->context = context; - capp->n_args = 1; - capp->args[0] = chunks_tree; - - goto done; - } - case PGF_EXPR_FUN: { - PgfExprFun* efun = i.data; - - PgfCncOverloadMap* overl_table = - gu_map_get(cnc->concr->fun_indices, efun->fun, PgfCncOverloadMap*); - if (overl_table == NULL) { - if (ccat != NULL && ccat->lindefs == NULL) { - goto done; - } - - GuPool* tmp_pool = gu_local_pool(); - GuExn* err = gu_new_exn(tmp_pool); - GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - - gu_putc('[', out, err); - gu_string_write(efun->fun, out, err); - gu_putc(']', out, err); - GuString s = gu_string_buf_freeze(sbuf, tmp_pool); - - if (ccat != NULL) { - ret = pgf_cnc_resolve_def(cnc, n_vars, context, ccat, s, pool); - } else { - PgfCncTreeLit* clit = - gu_new_variant(PGF_CNC_TREE_LIT, - PgfCncTreeLit, - &ret, pool); - clit->n_vars = 0; - clit->context = context; - clit->fid = cnc->fid++; - PgfLiteralStr* lit = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(s)+1, - &clit->lit, pool); - strcpy(lit->val, s); - } - - gu_pool_free(tmp_pool); - goto done; - } - - if (ccat == NULL) { - size_t n_count = gu_map_count(overl_table); - GuChoiceMark mark = gu_choice_mark(cnc->ch); - -redo:; - int index = gu_choice_next(cnc->ch, n_count); - if (index < 0) { - goto done; - } - - PgfCncItor clo = { { pgf_cnc_cat_resolve_itor }, index, NULL, NULL }; - gu_map_iter(overl_table, &clo.fn, NULL); - assert(clo.ccat != NULL && clo.buf != NULL); - - ret = pgf_cnc_resolve_app(cnc, n_vars, context, clo.ccat, clo.buf, args, pool); - if (gu_variant_is_null(ret)) { - gu_choice_reset(cnc->ch, mark); - if (gu_choice_advance(cnc->ch)) - goto redo; - } - } else { - GuBuf* buf = - gu_map_get(overl_table, ccat, GuBuf*); - if (buf == NULL) { - goto done; - } - - ret = pgf_cnc_resolve_app(cnc, n_vars, context, ccat, buf, args, pool); - } - goto done; - } - case PGF_EXPR_VAR: { - PgfExprVar* evar = i.data; - - int index = evar->var; - PgfPrintContext* ctxt = context; - while (index > 0) { - assert (ctxt != NULL); - ctxt = ctxt->next; - index--; - } - - if (ccat != NULL && ccat->lindefs == NULL) { - goto done; - } - - if (ccat != NULL) { - ret = pgf_cnc_resolve_def(cnc, n_vars, context, ccat, ctxt->name, pool); - } else { - PgfCncTreeLit* clit = - gu_new_variant(PGF_CNC_TREE_LIT, - PgfCncTreeLit, - &ret, pool); - clit->n_vars = 0; - clit->context = context; - clit->fid = cnc->fid++; - PgfLiteralStr* lit = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(ctxt->name)+1, - &clit->lit, pool); - strcpy(lit->val, ctxt->name); - } - - goto done; - } - case PGF_EXPR_TYPED: { - PgfExprTyped* etyped = i.data; - expr = etyped->expr; - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* eimpl = i.data; - expr = eimpl->expr; - break; - } - default: - gu_impossible(); - } - } - -done: - gu_pool_free(tmp_pool); - return ret; -} - -static void -pgf_cnc_tree_enum_next(GuEnum* self, void* to, GuPool* pool) -{ - PgfCnc* lzn = gu_container(self, PgfCnc, en); - PgfCncTree* toc = to; - - if (lzn->ch == NULL) { - *toc = gu_null_variant; - return; - } - - lzn->fid = 0; - - GuChoiceMark mark = gu_choice_mark(lzn->ch); - *toc = pgf_cnc_resolve(lzn, NULL, lzn->expr, NULL, pool); - gu_choice_reset(lzn->ch, mark); - -#ifdef PGF_LINEARIZER_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - if (gu_variant_is_null(*toc)) - gu_puts("*nil*\n", out, err); - else { - pgf_print_cnc_tree(*toc, out, err); - gu_puts("\n", out, err); - } - gu_pool_free(tmp_pool); -#endif - - if (!gu_choice_advance(lzn->ch)) { - lzn->ch = NULL; - } -} - -PGF_API PgfCncTreeEnum* -pgf_lzr_concretize(PgfConcr* concr, PgfExpr expr, GuExn* err, GuPool* pool) -{ - if (concr->fun_indices == NULL || - concr->coerce_idx == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return NULL; - } - } - - PgfCnc* cnc = gu_new(PgfCnc, pool); - cnc->concr = concr; - cnc->expr = expr; - cnc->fid = 0; - cnc->ch = gu_new_choice(pool); - cnc->en.next = pgf_cnc_tree_enum_next; - return &cnc->en; -} - -typedef struct { - PgfConcr* concr; - PgfLinFuncs** funcs; - GuPool* tmp_pool; -} PgfLzr; - -static PgfLzr* -pgf_new_lzr(PgfConcr* concr, PgfLinFuncs** funcs, GuPool* tmp_pool) -{ - PgfLzr* lzr = gu_new(PgfLzr, tmp_pool); - lzr->concr = concr; - lzr->funcs = funcs; - lzr->tmp_pool = tmp_pool; - return lzr; -} - -typedef enum { - PGF_CACHED_BEGIN, - PGF_CACHED_END, - PGF_CACHED_BIND, - PGF_CACHED_CAPIT, - PGF_CACHED_ALL_CAPIT, - PGF_CACHED_NE -} PgfLzrCachedTag; - -typedef struct { - PgfLzrCachedTag tag; - PgfCId cat; - int fid; - GuString ann; - PgfCId fun; -} PgfLzrCached; - -typedef struct { - PgfLinFuncs* funcs; - PgfCncTreeApp* app; - PgfSymbolKP* kp; - GuBuf* events; - PgfLzr* lzr; - PgfLinFuncs** prev; -} PgfLzrCache; - -static void -pgf_lzr_linearize_symbols(PgfLzr* lzr, PgfCncTreeApp* fapp, - PgfSymbols* syms, uint16_t sym_idx); - -static void -pgf_lzr_linearize_tree(PgfLzr* lzr, PgfCncTree ctree, size_t lin_idx); - -static void -pgf_lzr_cache_flush(PgfLzrCache* cache, PgfSymbols* form) -{ - cache->lzr->funcs = cache->prev; - pgf_lzr_linearize_symbols(cache->lzr, cache->app, form, 0); - - size_t n_cached = gu_buf_length(cache->events); - for (size_t i = 0; i < n_cached; i++) { - PgfLzrCached* event = - gu_buf_index(cache->events, PgfLzrCached, i); - - switch (event->tag) { - case PGF_CACHED_BEGIN: - if ((*cache->lzr->funcs)->begin_phrase) { - (*cache->lzr->funcs)->begin_phrase( - cache->lzr->funcs, - event->cat, - event->fid, - event->ann, - event->fun); - } - break; - case PGF_CACHED_END: - if ((*cache->lzr->funcs)->end_phrase) { - (*cache->lzr->funcs)->end_phrase( - cache->lzr->funcs, - event->cat, - event->fid, - event->ann, - event->fun); - } - break; - case PGF_CACHED_BIND: - if ((*cache->lzr->funcs)->symbol_bind) { - (*cache->lzr->funcs)->symbol_bind(cache->lzr->funcs); - } - break; - case PGF_CACHED_CAPIT: - if ((*cache->lzr->funcs)->symbol_capit) { - (*cache->lzr->funcs)->symbol_capit(cache->lzr->funcs, PGF_CAPIT_FIRST); - } - break; - case PGF_CACHED_ALL_CAPIT: - if ((*cache->lzr->funcs)->symbol_capit) { - (*cache->lzr->funcs)->symbol_capit(cache->lzr->funcs, PGF_CAPIT_ALL); - } - break; - case PGF_CACHED_NE: - if ((*cache->lzr->funcs)->symbol_ne) { - (*cache->lzr->funcs)->symbol_ne(cache->lzr->funcs); - } - break; - } - } -} - -static void -pgf_lzr_cache_symbol_token(PgfLinFuncs** funcs, PgfToken tok) -{ - PgfLzrCache* cache = gu_container(funcs, PgfLzrCache, funcs); - - PgfSymbols* form = cache->kp->default_form; - for (size_t i = 0; i < cache->kp->n_forms; i++) { - GuStrings* prefixes = cache->kp->forms[i].prefixes; - size_t n_prefixes = gu_seq_length(prefixes); - for (size_t j = 0; j < n_prefixes; j++) { - GuString prefix = gu_seq_get(prefixes, GuString, j); - - if (gu_string_is_prefix(prefix, tok)) { - form = cache->kp->forms[i].form; - goto found; - } - } - } -found: - - pgf_lzr_cache_flush(cache, form); - if ((*cache->lzr->funcs)->symbol_token) { - (*cache->lzr->funcs)->symbol_token(cache->lzr->funcs, tok); - } -} - -static void -pgf_lzr_cache_begin_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfLzrCache* cache = gu_container(funcs, PgfLzrCache, funcs); - PgfLzrCached* event = gu_buf_extend(cache->events); - event->tag = PGF_CACHED_BEGIN; - event->cat = cat; - event->fid = fid; - event->ann = ann; - event->fun = fun; -} - -static void -pgf_lzr_cache_end_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfLzrCache* cache = gu_container(funcs, PgfLzrCache, funcs); - PgfLzrCached* event = gu_buf_extend(cache->events); - event->tag = PGF_CACHED_END; - event->cat = cat; - event->fid = fid; - event->ann = ann; - event->fun = fun; -} - -static void -pgf_lzr_cache_symbol_ne(PgfLinFuncs** funcs) -{ - PgfLzrCache* cache = gu_container(funcs, PgfLzrCache, funcs); - PgfLzrCached* event = gu_buf_extend(cache->events); - event->tag = PGF_CACHED_NE; -} - -static void -pgf_lzr_cache_symbol_bind(PgfLinFuncs** funcs) -{ - PgfLzrCache* cache = gu_container(funcs, PgfLzrCache, funcs); - PgfLzrCached* event = gu_buf_extend(cache->events); - event->tag = PGF_CACHED_BIND; -} - -static void -pgf_lzr_cache_symbol_capit(PgfLinFuncs** funcs, PgfCapitState capit) -{ - PgfLzrCache* cache = gu_container(funcs, PgfLzrCache, funcs); - PgfLzrCached* event = gu_buf_extend(cache->events); - event->tag = (capit == PGF_CAPIT_ALL) ? PGF_CACHED_ALL_CAPIT : PGF_CACHED_CAPIT; -} - -static void -pgf_lzr_cache_symbol_meta(PgfLinFuncs** funcs, PgfMetaId id) -{ - PgfLzrCache* cache = gu_container(funcs, PgfLzrCache, funcs); - - pgf_lzr_cache_flush(cache, cache->kp->default_form); - if ((*cache->lzr->funcs)->symbol_meta) { - (*cache->lzr->funcs)->symbol_meta(cache->lzr->funcs, id); - } -} - -static PgfLinFuncs pgf_lzr_cache_funcs = { - .symbol_token = pgf_lzr_cache_symbol_token, - .begin_phrase = pgf_lzr_cache_begin_phrase, - .end_phrase = pgf_lzr_cache_end_phrase, - .symbol_ne = pgf_lzr_cache_symbol_ne, - .symbol_bind = pgf_lzr_cache_symbol_bind, - .symbol_capit = pgf_lzr_cache_symbol_capit, - .symbol_meta = pgf_lzr_cache_symbol_meta -}; - -static void -pgf_lzr_linearize_var(PgfLzr* lzr, PgfCncTree ctree, size_t var_idx) -{ - GuVariantInfo cti = gu_variant_open(ctree); - - size_t n_vars = 0; - PgfPrintContext* context = NULL; - - switch (cti.tag) { - case PGF_CNC_TREE_APP: { - PgfCncTreeApp* fapp = cti.data; - n_vars = fapp->n_vars; - context = fapp->context; - break; - } - case PGF_CNC_TREE_CHUNKS: { - PgfCncTreeChunks* fchunks = cti.data; - n_vars = fchunks->n_vars; - context = fchunks->context; - break; - } - case PGF_CNC_TREE_LIT: { - PgfCncTreeLit* flit = cti.data; - n_vars = flit->n_vars; - context = flit->context; - break; - } - default: - gu_impossible(); - } - - n_vars -= var_idx+1; - while (n_vars > 0) { - context = context->next; - n_vars--; - } - - if ((*lzr->funcs)->symbol_token) { - (*lzr->funcs)->symbol_token(lzr->funcs, context->name); - } -} - -static void -pgf_lzr_linearize_symbols(PgfLzr* lzr, PgfCncTreeApp* fapp, - PgfSymbols* syms, uint16_t sym_idx) -{ - size_t nsyms = gu_seq_length(syms); - for (size_t i = sym_idx; i < nsyms; i++) { - PgfSymbol sym = gu_seq_get(syms, PgfSymbol, i); - GuVariantInfo sym_i = gu_variant_open(sym); - switch (sym_i.tag) { - case PGF_SYMBOL_CAT: - case PGF_SYMBOL_LIT: { - if (fapp == NULL) - return; - - PgfSymbolIdx* sidx = sym_i.data; - gu_assert((unsigned) sidx->d < fapp->n_args); - - PgfCncTree argf = fapp->args[sidx->d]; - pgf_lzr_linearize_tree(lzr, argf, sidx->r); - break; - } - case PGF_SYMBOL_VAR: { - if (fapp == NULL) - return; - - PgfSymbolIdx* sidx = sym_i.data; - gu_assert((unsigned) sidx->d < fapp->n_args); - - PgfCncTree argf = fapp->args[sidx->d]; - pgf_lzr_linearize_var(lzr, argf, sidx->r); - break; - } - case PGF_SYMBOL_KS: { - PgfSymbolKS* ks = sym_i.data; - if ((*lzr->funcs)->symbol_token) { - (*lzr->funcs)->symbol_token(lzr->funcs, ks->token); - } - break; - } - case PGF_SYMBOL_KP: { - // TODO: correct prefix-dependencies - PgfSymbolKP* kp = sym_i.data; - //gu_buf_push(pres, PgfSymbolKP*, kp); - PgfLzrCache* cache = gu_new(PgfLzrCache, lzr->tmp_pool); - cache->funcs = &pgf_lzr_cache_funcs; - cache->app = fapp; - cache->kp = kp; - cache->events= gu_new_buf(PgfLzrCached, lzr->tmp_pool); - cache->lzr = lzr; - cache->prev = lzr->funcs; - lzr->funcs = &cache->funcs; - break; - } - case PGF_SYMBOL_NE: { - if ((*lzr->funcs)->symbol_ne) { - (*lzr->funcs)->symbol_ne(lzr->funcs); - } - break; - } - case PGF_SYMBOL_BIND: - case PGF_SYMBOL_SOFT_BIND: { - if ((*lzr->funcs)->symbol_bind) { - (*lzr->funcs)->symbol_bind(lzr->funcs); - } - break; - } - case PGF_SYMBOL_SOFT_SPACE: { - // SOFT_SPACE should be just ignored in linearization - break; - } - case PGF_SYMBOL_CAPIT: - if ((*lzr->funcs)->symbol_capit) { - (*lzr->funcs)->symbol_capit(lzr->funcs, PGF_CAPIT_FIRST); - } - break; - case PGF_SYMBOL_ALL_CAPIT: - if ((*lzr->funcs)->symbol_capit) { - (*lzr->funcs)->symbol_capit(lzr->funcs, PGF_CAPIT_ALL); - } - break; - default: - gu_impossible(); - } - } -} - -static void -pgf_lzr_linearize_tree(PgfLzr* lzr, PgfCncTree ctree, size_t lin_idx) -{ - GuVariantInfo cti = gu_variant_open(ctree); - - switch (cti.tag) { - case PGF_CNC_TREE_APP: { - PgfCncTreeApp* fapp = cti.data; - PgfCncFun* fun = fapp->fun; - - if ((*lzr->funcs)->begin_phrase && fapp->ccat != NULL) { - (*lzr->funcs)->begin_phrase(lzr->funcs, - fapp->ccat->cnccat->abscat->name, - fapp->fid, fapp->ccat->cnccat->labels[lin_idx], - fun->absfun->name); - } - - gu_require(lin_idx < fun->n_lins); - pgf_lzr_linearize_symbols(lzr, fapp, fun->lins[lin_idx]->syms, 0); - - if ((*lzr->funcs)->end_phrase && fapp->ccat != NULL) { - (*lzr->funcs)->end_phrase(lzr->funcs, - fapp->ccat->cnccat->abscat->name, - fapp->fid, fapp->ccat->cnccat->labels[lin_idx], - fun->absfun->name); - } - break; - } - case PGF_CNC_TREE_CHUNKS: { - gu_require(lin_idx == 0); - PgfCncTreeChunks* fchunks = cti.data; - - if (fchunks->n_args == 0) { - if ((*lzr->funcs)->symbol_meta) { - (*lzr->funcs)->symbol_meta(lzr->funcs, fchunks->id); - } - } else { - for (size_t i = 0; i < fchunks->n_args; i++) { - pgf_lzr_linearize_tree(lzr, fchunks->args[i], 0); - } - } - break; - } - case PGF_CNC_TREE_LIT: { - gu_require(lin_idx == 0); - PgfCncTreeLit* flit = cti.data; - - PgfCId cat = - pgf_literal_cat(lzr->concr, flit->lit)->cnccat->abscat->name; - - if ((*lzr->funcs)->begin_phrase) { - (*lzr->funcs)->begin_phrase(lzr->funcs, - cat, flit->fid, "s", - ""); - } - - GuVariantInfo i = gu_variant_open(flit->lit); - PgfToken tok = NULL; - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lstr = i.data; - tok = lstr->val; - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lint = i.data; - tok = gu_format_string(lzr->tmp_pool, "%d", lint->val); - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lflt = i.data; - tok = gu_format_string(lzr->tmp_pool, "%lf", lflt->val); - break; - } - default: - gu_impossible(); - } - - if ((*lzr->funcs)->symbol_token) { - (*lzr->funcs)->symbol_token(lzr->funcs, tok); - } - - if ((*lzr->funcs)->end_phrase) { - (*lzr->funcs)->end_phrase(lzr->funcs, - cat, flit->fid, "s", - ""); - } - - break; - } - default: - gu_impossible(); - } -} - -PGF_API void -pgf_lzr_linearize(PgfConcr* concr, PgfCncTree ctree, size_t lin_idx, - PgfLinFuncs** funcs, GuPool* tmp_pool) -{ - PgfLzr* lzr = pgf_new_lzr(concr, funcs, tmp_pool); - pgf_lzr_linearize_tree(lzr, ctree, lin_idx); - - while (lzr->funcs != funcs) { - PgfLzrCache* cache = gu_container(lzr->funcs, PgfLzrCache, funcs); - pgf_lzr_cache_flush(cache, cache->kp->default_form); - } -} - -typedef struct PgfSimpleLin PgfSimpleLin; - -struct PgfSimpleLin { - PgfLinFuncs* funcs; - bool bind; - PgfCapitState capit; - GuOut* out; - GuExn* err; -}; - -static void -pgf_file_lzn_symbol_token(PgfLinFuncs** funcs, PgfToken tok) -{ - PgfSimpleLin* flin = gu_container(funcs, PgfSimpleLin, funcs); - if (!gu_ok(flin->err)) { - return; - } - - if (flin->bind) - flin->bind = false; - else { - gu_putc(' ', flin->out, flin->err); - if (flin->capit == PGF_CAPIT_NEXT) - flin->capit = PGF_CAPIT_NONE; - } - - switch (flin->capit) { - case PGF_CAPIT_NONE: - gu_string_write(tok, flin->out, flin->err); - break; - case PGF_CAPIT_FIRST: { - GuUCS c = gu_utf8_decode((const uint8_t**) &tok); - c = gu_ucs_to_upper(c); - gu_out_utf8(c, flin->out, flin->err); - gu_string_write(tok, flin->out, flin->err); - flin->capit = PGF_CAPIT_NONE; - break; - } - case PGF_CAPIT_ALL: - flin->capit = PGF_CAPIT_NEXT; - // continue - case PGF_CAPIT_NEXT: { - const uint8_t* p = (uint8_t*) tok; - while (*p) { - GuUCS c = gu_utf8_decode(&p); - c = gu_ucs_to_upper(c); - gu_out_utf8(c, flin->out, flin->err); - } - break; - } - } -} - -static void -pgf_file_lzn_symbol_ne(PgfLinFuncs** funcs) -{ - PgfSimpleLin* flin = gu_container(funcs, PgfSimpleLin, funcs); - gu_raise(flin->err, PgfLinNonExist); -} - -static void -pgf_file_lzn_symbol_bind(PgfLinFuncs** funcs) -{ - PgfSimpleLin* flin = gu_container(funcs, PgfSimpleLin, funcs); - flin->bind = true; -} - -static void -pgf_file_lzn_symbol_capit(PgfLinFuncs** funcs, PgfCapitState capit) -{ - PgfSimpleLin* flin = gu_container(funcs, PgfSimpleLin, funcs); - flin->capit = capit; -} - -static void -pgf_file_lzn_symbol_meta(PgfLinFuncs** funcs, PgfMetaId id) -{ - PgfSimpleLin* flin = gu_container(funcs, PgfSimpleLin, funcs); - if (!gu_ok(flin->err)) { - return; - } - - if (flin->bind) - flin->bind = false; - else { - gu_putc(' ', flin->out, flin->err); - if (flin->capit == PGF_CAPIT_NEXT) - flin->capit = PGF_CAPIT_NONE; - } - - gu_putc('?', flin->out, flin->err); - - switch (flin->capit) { - case PGF_CAPIT_FIRST: - flin->capit = PGF_CAPIT_NONE; - break; - case PGF_CAPIT_ALL: - flin->capit = PGF_CAPIT_NEXT; - break; - default:; - } -} - -static PgfLinFuncs pgf_file_lin_funcs = { - .symbol_token = pgf_file_lzn_symbol_token, - .begin_phrase = NULL, - .end_phrase = NULL, - .symbol_ne = pgf_file_lzn_symbol_ne, - .symbol_bind = pgf_file_lzn_symbol_bind, - .symbol_capit = pgf_file_lzn_symbol_capit, - .symbol_meta = pgf_file_lzn_symbol_meta -}; - -PGF_API void -pgf_lzr_linearize_simple(PgfConcr* concr, PgfCncTree ctree, size_t lin_idx, - GuOut* out, GuExn* err, - GuPool* tmp_pool) -{ - PgfSimpleLin flin = { - .funcs = &pgf_file_lin_funcs, - .bind = true, - .capit = PGF_CAPIT_NONE, - .out = out, - .err = err - }; - pgf_lzr_linearize(concr, ctree, lin_idx, &flin.funcs, tmp_pool); -} - -PGF_API void -pgf_lzr_get_table(PgfConcr* concr, PgfCncTree ctree, - size_t* n_lins, GuString** labels) -{ - static GuString s_label = "s"; - - GuVariantInfo cti = gu_variant_open(ctree); - - switch (cti.tag) { - case PGF_CNC_TREE_APP: { - PgfCncTreeApp* fapp = cti.data; - - PgfCncCat* cnccat = fapp->ccat->cnccat; - *n_lins = cnccat->n_lins; - *labels = cnccat->labels; - break; - } - case PGF_CNC_TREE_LIT: - case PGF_CNC_TREE_CHUNKS: { - *n_lins = 1; - *labels = &s_label; - break; - } - default: - gu_impossible(); - } - -} - -PGF_API void -pgf_linearize(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err) -{ - GuPool* tmp_pool = gu_local_pool(); - - GuEnum* cts = - pgf_lzr_concretize(concr, expr, err, tmp_pool); - if (!gu_ok(err)) { - gu_pool_free(tmp_pool); - return; - } - - PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool); - if (!gu_variant_is_null(ctree)) { - ctree = pgf_lzr_wrap_linref(ctree, tmp_pool); - pgf_lzr_linearize_simple(concr, ctree, 0, out, err, tmp_pool); - } - - gu_pool_free(tmp_pool); -} - -PGF_INTERNAL GuString -pgf_get_tokens(PgfSymbols* syms, uint16_t sym_idx, GuPool* pool) -{ - GuPool* tmp_pool = gu_new_pool(); - GuExn* err = gu_new_exn(tmp_pool); - GuStringBuf* sbuf = gu_new_string_buf(tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - - PgfSimpleLin flin = { - .funcs = &pgf_file_lin_funcs, - .bind = true, - .capit = false, - .out = out, - .err = err - }; - - PgfLzr* lzr = pgf_new_lzr(NULL, &flin.funcs, tmp_pool); - pgf_lzr_linearize_symbols(lzr, NULL, syms, sym_idx); - - while (lzr->funcs != &flin.funcs) { - PgfLzrCache* cache = gu_container(lzr->funcs, PgfLzrCache, funcs); - pgf_lzr_cache_flush(cache, cache->kp->default_form); - } - - GuString tokens = gu_ok(err) ? gu_string_buf_freeze(sbuf, pool) - : ""; - - gu_pool_free(tmp_pool); - - return tokens; -} diff --git a/src/runtime/c/pgf/linearizer.h b/src/runtime/c/pgf/linearizer.h deleted file mode 100644 index 93de33c06..000000000 --- a/src/runtime/c/pgf/linearizer.h +++ /dev/null @@ -1,126 +0,0 @@ -#ifndef PGF_LINEARIZER_H_ -#define PGF_LINEARIZER_H_ - -#include - -/// Linearization of abstract syntax trees. - -// -// PgfCncTree -// - -/// A concrete syntax tree -typedef GuVariant PgfCncTree; - -#ifdef PGF_DATA_H_ - -typedef enum { - PGF_CNC_TREE_APP, - PGF_CNC_TREE_CHUNKS, - PGF_CNC_TREE_LIT, -} PgfCncTreeTag; - -typedef struct { - PgfCCat* ccat; - PgfCncFun* fun; - int fid; - - size_t n_vars; - PgfPrintContext* context; - - size_t n_args; - PgfCncTree args[]; -} PgfCncTreeApp; - -typedef struct { - PgfMetaId id; - - size_t n_vars; - PgfPrintContext* context; - - size_t n_args; - PgfCncTree args[]; -} PgfCncTreeChunks; - -typedef struct { - size_t n_vars; - PgfPrintContext* context; - - int fid; - PgfLiteral lit; -} PgfCncTreeLit; - -#endif - -/// An enumeration of #PgfCncTree trees. -typedef GuEnum PgfCncTreeEnum; - -/// Begin enumerating concrete syntax variants. -PGF_API_DECL PgfCncTreeEnum* -pgf_lzr_concretize(PgfConcr* concr, PgfExpr expr, GuExn* err, GuPool* pool); - -typedef struct { - char nothing[0]; // Empty struct -} PgfLinNonExist; - -PGF_API_DECL PgfCncTree -pgf_lzr_wrap_linref(PgfCncTree ctree, GuPool* pool); - - - -typedef struct PgfLinFuncs PgfLinFuncs; - -typedef enum { - PGF_CAPIT_NONE, - PGF_CAPIT_FIRST, - PGF_CAPIT_ALL, - PGF_CAPIT_NEXT -} PgfCapitState; - -struct PgfLinFuncs -{ - /// Output tokens - void (*symbol_token)(PgfLinFuncs** self, PgfToken tok); - - /// Begin phrase - void (*begin_phrase)(PgfLinFuncs** self, PgfCId cat, int fid, GuString ann, PgfCId fun); - - /// End phrase - void (*end_phrase)(PgfLinFuncs** self, PgfCId cat, int fid, GuString ann, PgfCId fun); - - /// handling nonExist - void (*symbol_ne)(PgfLinFuncs** self); - - /// token binding - void (*symbol_bind)(PgfLinFuncs** self); - - /// capitalization - void (*symbol_capit)(PgfLinFuncs** self, PgfCapitState capit); - - /// meta variable - void (*symbol_meta)(PgfLinFuncs** self, PgfMetaId id); -}; - -/// Linearize a concrete syntax tree. -PGF_API_DECL void -pgf_lzr_linearize(PgfConcr* concr, PgfCncTree ctree, size_t lin_idx, - PgfLinFuncs** funcs, GuPool* tmp_pool); - -/// Linearize a concrete syntax tree as space-separated tokens. -PGF_API_DECL void -pgf_lzr_linearize_simple(PgfConcr* concr, PgfCncTree ctree, size_t lin_idx, - GuOut* out, GuExn* err, - GuPool* tmp_pool); - - -PGF_API_DECL void -pgf_lzr_get_table(PgfConcr* concr, PgfCncTree ctree, - size_t* n_lins, GuString** labels); - -#ifdef PGF_DATA_H_ -// Used internally in the parser -PGF_INTERNAL_DECL GuString -pgf_get_tokens(PgfSymbols* sym, uint16_t sym_idx, GuPool* pool); -#endif - -#endif diff --git a/src/runtime/c/pgf/literals.c b/src/runtime/c/pgf/literals.c deleted file mode 100644 index 83e4769a1..000000000 --- a/src/runtime/c/pgf/literals.c +++ /dev/null @@ -1,492 +0,0 @@ -#include -#include -#include -#include - - -static PgfExprProb* -pgf_match_string_lit(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString sentence, size_t* poffset, - GuPool *out_pool) -{ - if (strcmp(ann,"s") != 0) - return NULL; - - const uint8_t* buf = (uint8_t*) (sentence + *poffset); - const uint8_t* p = buf; - size_t len = 0; - while (*p && !gu_ucs_is_space(gu_utf8_decode(&p))) { - len = p - buf; - } - - if (len > 0) { - PgfExprProb* ep = gu_new(PgfExprProb, out_pool); - ep->prob = 0; - - PgfExprLit *expr_lit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &ep->expr, out_pool); - - PgfLiteralStr *lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, len+1, - &expr_lit->lit, out_pool); - memcpy(lit_str->val, buf, len); - lit_str->val[len] = 0; - - *poffset += len; - return ep; - } else { - return NULL; - } -} - -static void -pgf_predict_empty_next(GuEnum* self, void* to, GuPool* pool) -{ - *((PgfTokenProb**) to) = NULL; -} - -static GuEnum* -pgf_predict_empty(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString prefix, - GuPool *out_pool) -{ - GuEnum* en = gu_new(GuEnum, out_pool); - en->next = pgf_predict_empty_next; - return en; -} - -static PgfLiteralCallback pgf_string_literal_callback = - { pgf_match_string_lit, pgf_predict_empty } ; - - - -static PgfExprProb* -pgf_match_int_lit(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString sentence, size_t* poffset, - GuPool *out_pool) -{ - if (strcmp(ann,"s") != 0) - return NULL; - - const uint8_t* buf = (uint8_t*) (sentence + *poffset); - const uint8_t* p = buf; - size_t len = 0; - while (*p && !gu_ucs_is_space(gu_utf8_decode(&p))) { - len = p - buf; - } - - if (len > 0) { - GuPool* tmp_pool = gu_local_pool(); - PgfToken tok = gu_malloc(tmp_pool, len+1); - memcpy((char*) tok, buf, len); - ((char*) tok)[len] = 0; - - int val; - if (!gu_string_to_int(tok, &val)) { - gu_pool_free(tmp_pool); - return NULL; - } - - gu_pool_free(tmp_pool); - - PgfExprProb* ep = gu_new(PgfExprProb, out_pool); - ep->prob = 0; - - PgfExprLit *expr_lit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &ep->expr, out_pool); - PgfLiteralInt *lit_int = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &expr_lit->lit, out_pool); - lit_int->val = val; - - *poffset += len; - return ep; - } else { - return NULL; - } -} - -static PgfLiteralCallback pgf_int_literal_callback = - { pgf_match_int_lit, pgf_predict_empty } ; - - - -static PgfExprProb* -pgf_match_float_lit(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString sentence, size_t* poffset, - GuPool *out_pool) -{ - if (strcmp(ann,"s") != 0) - return NULL; - - const uint8_t* buf = (uint8_t*) (sentence + *poffset); - const uint8_t* p = buf; - size_t len = 0; - while (*p && !gu_ucs_is_space(gu_utf8_decode(&p))) { - len = p - buf; - } - - if (len > 0) { - GuPool* tmp_pool = gu_local_pool(); - PgfToken tok = gu_malloc(tmp_pool, len+1); - memcpy((char*) tok, buf, len); - ((char*) tok)[len] = 0; - - double val; - if (!gu_string_to_double(tok, &val)) { - gu_pool_free(tmp_pool); - return NULL; - } - - gu_pool_free(tmp_pool); - - PgfExprProb* ep = gu_new(PgfExprProb, out_pool); - ep->prob = 0; - - PgfExprLit *expr_lit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &ep->expr, out_pool); - PgfLiteralFlt *lit_flt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &expr_lit->lit, out_pool); - lit_flt->val = val; - - *poffset += len; - return ep; - } else { - return NULL; - } -} - -static PgfLiteralCallback pgf_float_literal_callback = - { pgf_match_float_lit, pgf_predict_empty } ; - -typedef struct { - PgfMorphoCallback callback; - PgfAbstr* abstract; - PgfExpr expr; - bool is_known; - GuPool* out_pool; -} PgfMatchMorphoCallback; - -static void -pgf_match_name_morpho_callback(PgfMorphoCallback* self_, - PgfCId lemma, GuString analysis, prob_t prob, - GuExn* err) -{ - PgfMatchMorphoCallback* self = - gu_container(self_, PgfMatchMorphoCallback, callback); - - PgfAbsFun* absfun = - gu_seq_binsearch(self->abstract->funs, pgf_absfun_order, PgfAbsFun, lemma); - if (absfun != NULL) { - if (strcmp(absfun->type->cid, "PN") == 0) { - self->expr = absfun->ep.expr; - } else if (strcmp(absfun->type->cid, "Weekday") == 0) { - PgfExprApp *expr_app = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &self->expr, self->out_pool); - GuString con = "weekdayPN"; - PgfExprFun *expr_fun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(con)+1, - &expr_app->fun, self->out_pool); - strcpy(expr_fun->fun, con); - expr_app->arg = absfun->ep.expr; - } else if (strcmp(absfun->type->cid, "Month") == 0) { - PgfExprApp *expr_app = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &self->expr, self->out_pool); - GuString con = "monthPN"; - PgfExprFun *expr_fun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(con)+1, - &expr_app->fun, self->out_pool); - strcpy(expr_fun->fun, con); - expr_app->arg = absfun->ep.expr; - } else { - self->is_known = true; - } - } -} - -static PgfExprProb* -pgf_match_name_lit(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString sentence, size_t* poffset, - GuPool *out_pool) -{ - if (strcmp(ann,"s") != 0) - return NULL; - - GuPool* tmp_pool = gu_local_pool(); - GuStringBuf *sbuf = gu_new_string_buf(tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - GuExn* err = gu_new_exn(tmp_pool); - - const uint8_t* buf = (uint8_t*) (sentence + *poffset); - const uint8_t* p = buf; - - int i = 0; - GuUCS ucs = gu_utf8_decode(&p); - while (gu_ucs_is_upper(ucs)) { - if (i > 0) - gu_putc(' ', out, err); - gu_out_utf8(ucs, out, err); - *poffset = p - ((uint8_t*) sentence); - - ucs = gu_utf8_decode(&p); - while (ucs != 0 && !gu_ucs_is_space(ucs)) { - gu_out_utf8(ucs, out, err); - *poffset = p - ((uint8_t*) sentence); - - ucs = gu_utf8_decode(&p); - } - - i++; - - while (gu_ucs_is_space(ucs)) - ucs = gu_utf8_decode(&p); - } - - PgfExprProb* ep = NULL; - if (i > 0) { - GuString name = gu_string_buf_freeze(sbuf, tmp_pool); - - // Detect I and I'm in English - GuString concr_name = pgf_concrete_name(concr); - size_t concr_name_len = strlen(concr_name); - if (concr_name_len >= 3 && strcmp(concr_name+concr_name_len-3,"Eng") == 0) { - if (strcmp(name, "I") == 0 || strcmp(name, "I'm") == 0) { - gu_pool_free(tmp_pool); - return NULL; - } - } - - PgfMatchMorphoCallback clo = { { pgf_match_name_morpho_callback }, - concr->abstr, - gu_null_variant, - false, - out_pool - }; - pgf_lookup_morpho(concr, name, &clo.callback, NULL); - - if (clo.is_known) { - return NULL; - } - - if (gu_variant_is_null(clo.expr)) { - PgfExprApp *expr_app1 = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &clo.expr, out_pool); - GuString con1 = "SymbPN"; - PgfExprFun *expr_fun1 = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(con1)+1, - &expr_app1->fun, out_pool); - strcpy(expr_fun1->fun, con1); - PgfExprApp *expr_app2 = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &expr_app1->arg, out_pool); - GuString con2 = "MkSymb"; - PgfExprFun *expr_fun2 = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(con2)+1, - &expr_app2->fun, out_pool); - strcpy(expr_fun2->fun, con2); - PgfExprLit *expr_lit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &expr_app2->arg, out_pool); - PgfLiteralStr *lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(name)+1, - &expr_lit->lit, out_pool); - strcpy(lit_str->val, name); - } - - ep = gu_new(PgfExprProb, out_pool); - ep->prob = 0; - ep->expr = clo.expr; - } - - gu_pool_free(tmp_pool); - - return ep; -} - -PGF_API PgfLiteralCallback pgf_nerc_literal_callback = - { pgf_match_name_lit, pgf_predict_empty } ; - -static void -pgf_match_unknown_morpho_callback(PgfMorphoCallback* self_, - PgfCId lemma, GuString analysis, prob_t prob, - GuExn* err) -{ - PgfMatchMorphoCallback* self = - gu_container(self_, PgfMatchMorphoCallback, callback); - self->is_known = true; -} - -static PgfExprProb* -pgf_match_unknown_lit(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString sentence, size_t* poffset, - GuPool *out_pool) -{ - const uint8_t* buf = (uint8_t*) (sentence + *poffset); - const uint8_t* p = buf; - - PgfExprProb* ep = NULL; - - GuUCS ucs = gu_utf8_decode(&p); - if (!gu_ucs_is_upper(ucs)) { - GuPool* tmp_pool = gu_local_pool(); - GuStringBuf *sbuf = gu_new_string_buf(tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - GuExn* err = gu_new_exn(tmp_pool); - - gu_out_utf8(ucs, out, err); - *poffset = p - ((uint8_t*) sentence); - - ucs = gu_utf8_decode(&p); - while (ucs != 0 && !gu_ucs_is_space(ucs)) { - gu_out_utf8(ucs, out, err); - *poffset = p - ((uint8_t*) sentence); - - ucs = gu_utf8_decode(&p); - } - - GuString word = gu_string_buf_freeze(sbuf, tmp_pool); - - PgfMatchMorphoCallback clo = { { pgf_match_unknown_morpho_callback }, - concr->abstr, - gu_null_variant, - false, - out_pool - }; - pgf_lookup_morpho(concr, word, &clo.callback, NULL); - - if (!clo.is_known) { - ep = gu_new(PgfExprProb, out_pool); - ep->prob = 0; - - PgfExprApp *expr_app = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &ep->expr, out_pool); - GuString con = "MkSymb"; - PgfExprFun *expr_fun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(con)+1, - &expr_app->fun, out_pool); - strcpy(expr_fun->fun, con); - PgfExprLit *expr_lit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &expr_app->arg, out_pool); - PgfLiteralStr *lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(word)+1, - &expr_lit->lit, out_pool); - strcpy(lit_str->val, word); - } - - gu_pool_free(tmp_pool); - } - - return ep; -} - -PGF_API PgfLiteralCallback pgf_unknown_literal_callback = - { pgf_match_unknown_lit, pgf_predict_empty } ; - -PgfCallbacksMap* -pgf_new_callbacks_map(PgfConcr* concr, GuPool *pool) -{ - int fid; - PgfCCat* ccat; - - PgfCallbacksMap* callbacks = - gu_new_addr_map(PgfCncCat*, PgfLiteralCallback*, &gu_null_struct, pool); - - fid = -1; - ccat = gu_map_get(concr->ccats, &fid, PgfCCat*); - if (ccat != NULL) - gu_map_put(callbacks, ccat->cnccat, - PgfLiteralCallback*, &pgf_string_literal_callback); - - fid = -2; - ccat = gu_map_get(concr->ccats, &fid, PgfCCat*); - if (ccat != NULL) - gu_map_put(callbacks, ccat->cnccat, - PgfLiteralCallback*, &pgf_int_literal_callback); - - fid = -3; - ccat = gu_map_get(concr->ccats, &fid, PgfCCat*); - if (ccat != NULL) - gu_map_put(callbacks, ccat->cnccat, - PgfLiteralCallback*, &pgf_float_literal_callback); - - return callbacks; -} - -void -pgf_callbacks_map_add_literal(PgfConcr* concr, PgfCallbacksMap* callbacks, - PgfCId cat, PgfLiteralCallback* callback) -{ - PgfCncCat* cnccat = - gu_map_get(concr->cnccats, cat, PgfCncCat*); - if (cnccat == NULL) - return; - - gu_map_put(callbacks, cnccat, - PgfLiteralCallback*, callback); -} - -PGF_INTERNAL PgfCCat* -pgf_literal_cat(PgfConcr* concr, PgfLiteral lit) -{ - int fid; - - switch (gu_variant_tag(lit)) { - case PGF_LITERAL_STR: - fid = -1; - break; - case PGF_LITERAL_INT: - fid = -2; - break; - case PGF_LITERAL_FLT: - fid = -3; - break; - default: - gu_impossible(); - return NULL; - } - - return gu_map_get(concr->ccats, &fid, PgfCCat*); -} diff --git a/src/runtime/c/pgf/literals.h b/src/runtime/c/pgf/literals.h deleted file mode 100644 index 5724fccef..000000000 --- a/src/runtime/c/pgf/literals.h +++ /dev/null @@ -1,15 +0,0 @@ -#ifndef PGF_LITERALS_H_ -#define PGF_LITERALS_H_ - -#include - -// literal for named entities recognition -PGF_API_DECL extern PgfLiteralCallback pgf_nerc_literal_callback; - -// literal for finding unknown words -PGF_API_DECL extern PgfLiteralCallback pgf_unknown_literal_callback; - -PGF_INTERNAL_DECL PgfCCat* -pgf_literal_cat(PgfConcr* concr, PgfLiteral lit); - -#endif // PGF_LITERALS_H_ diff --git a/src/runtime/c/pgf/lookup.c b/src/runtime/c/pgf/lookup.c deleted file mode 100644 index 5f9a8476c..000000000 --- a/src/runtime/c/pgf/lookup.c +++ /dev/null @@ -1,1057 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -//#define PGF_LOOKUP_DEBUG -//#define PGF_LINEARIZER_DEBUG - -typedef struct { - PgfAbsFun* fun; - size_t arg_idx; -} PgfAbsBottomUpEntry; - -typedef struct { - PgfAbsFun* fun; - size_t count; - PgfMetaId args[0]; -} PgfAbsProduction; - -#ifdef PGF_LOOKUP_DEBUG -static void -pgf_print_abs_production(PgfMetaId id, - PgfAbsProduction* prod, - GuOut* out, GuExn* err) -{ - gu_printf(out,err,"?%d = %s",id,prod->fun->name); - size_t n_hypos = gu_seq_length(prod->fun->type->hypos); - for (size_t i = 0; i < n_hypos; i++) { - gu_printf(out,err," ?%d", prod->args[i]); - } - gu_printf(out,err," <%d>\n",prod->count); -} - -static void -pgf_print_abs_productions(GuBuf* prods, - GuOut* out, GuExn* err) -{ - size_t n_prods = gu_buf_length(prods); - for (size_t id = 1; id < n_prods; id++) { - GuBuf* id_prods = gu_buf_get(prods, GuBuf*, id); - size_t n_id_prods = gu_buf_length(id_prods); - for (size_t i = 0; i < n_id_prods; i++) { - PgfAbsProduction* prod = - gu_buf_get(id_prods, PgfAbsProduction*, i); - pgf_print_abs_production(id, prod, out, err); - } - } -} -#endif - -#ifdef PGF_LINEARIZER_DEBUG -PGF_INTERNAL_DECL void -pgf_print_cnc_tree(PgfCncTree ctree, GuOut* out, GuExn* err); -#endif - -static void -pgf_lookup_index_syms(GuMap* lexicon_idx, PgfSymbols* syms, PgfAbsFun* absfun, GuPool* pool) { - size_t n_syms = gu_seq_length(syms); - for (size_t j = 0; j < n_syms; j++) { - PgfSymbol sym = gu_seq_get(syms, PgfSymbol, j); - GuVariantInfo i = gu_variant_open(sym); - switch (i.tag) { - case PGF_SYMBOL_KP: { - PgfSymbolKP* skp = (PgfSymbolKP*) i.data; - pgf_lookup_index_syms(lexicon_idx, skp->default_form, absfun, pool); - for (size_t k = 0; k < skp->n_forms; k++) { - pgf_lookup_index_syms(lexicon_idx, skp->forms[k].form, absfun, pool); - } - break; - } - case PGF_SYMBOL_KS: { - PgfSymbolKS* sks = (PgfSymbolKS*) i.data; - GuBuf* funs = gu_map_get(lexicon_idx, sks->token, GuBuf*); - if (funs == NULL) { - funs = gu_new_buf(PgfAbsFun*, pool); - gu_map_put(lexicon_idx, sks->token, GuBuf*, funs); - } - - bool found = false; - size_t n_funs = gu_buf_length(funs); - for (size_t l = 0; l < n_funs; l++) { - PgfAbsFun* absfun1 = gu_buf_get(funs, PgfAbsFun*, l); - if (absfun1 == absfun) { - found = true; - break; - } - } - if (!found) - gu_buf_push(funs, PgfAbsFun*, absfun); - break; - } - } - } -} - -typedef struct { - GuMap* function_idx; - GuMap* meta_ids; - GuBuf* spine; - GuPool* pool; -} PgfSpineBuilder; - -typedef struct { - PgfToken token; - size_t n_funs; - PgfAbsFun** funs; -} PgfInputToken; - -static PgfAbsProduction* -pgf_lookup_new_production(PgfAbsFun* fun, GuPool *pool) -{ - size_t n_hypos = gu_seq_length(fun->type->hypos); - PgfAbsProduction* prod = gu_new_flex(pool, PgfAbsProduction, args, n_hypos); - prod->fun = fun; - prod->count = 0; - for (size_t i = 0; i < n_hypos; i++) { - prod->args[i] = 0; - } - return prod; -} - -static void -pgf_lookup_add_production(PgfSpineBuilder* builder, PgfMetaId id, PgfAbsProduction* prod) -{ - GuBuf* prods = gu_buf_get(builder->spine, GuBuf*, id); - gu_buf_push(prods, PgfAbsProduction*, prod); -} - -static PgfMetaId -pgf_lookup_add_spine_nodes(PgfSpineBuilder* builder, PgfCId cat) { - PgfMetaId meta_id = gu_map_get(builder->meta_ids, cat, PgfMetaId); - if (meta_id != 0) { - return meta_id; - } - - meta_id = gu_buf_length(builder->spine); - gu_buf_push(builder->spine, GuBuf*, gu_new_buf(PgfAbsProduction*, builder->pool)); - - gu_map_put(builder->meta_ids, cat, PgfMetaId, meta_id); - - GuBuf* entries = gu_map_get(builder->function_idx, cat, GuBuf*); - if (entries != NULL) { - size_t n_entries = gu_buf_length(entries); - for (size_t i = 0; i < n_entries; i++) { - PgfAbsBottomUpEntry* entry = gu_buf_index(entries, PgfAbsBottomUpEntry, i); - - PgfMetaId id = pgf_lookup_add_spine_nodes(builder, entry->fun->type->cid); - - PgfAbsProduction* prod = pgf_lookup_new_production(entry->fun, builder->pool); - prod->args[entry->arg_idx] = meta_id; - - pgf_lookup_add_production(builder, id, prod); - } - } - - return meta_id; -} - -static void -pgf_lookup_add_spine_leaf(PgfSpineBuilder* builder, PgfAbsFun *fun) -{ - PgfMetaId id = pgf_lookup_add_spine_nodes(builder, fun->type->cid); - PgfAbsProduction* prod = pgf_lookup_new_production(fun, builder->pool); - prod->count = 1; - - pgf_lookup_add_production(builder, id, prod); -} - -static GuBuf* -pgf_lookup_build_spine(GuMap* function_idx, - PgfInputToken* tok, PgfType* typ, PgfMetaId* meta_id, - GuPool* pool) -{ - PgfSpineBuilder builder; - builder.function_idx = function_idx; - builder.meta_ids = gu_new_string_map(PgfMetaId, &gu_null_struct, pool); - builder.spine = gu_new_buf(GuBuf*, pool); - builder.pool = pool; - - gu_buf_push(builder.spine, GuBuf*, NULL); - - for (size_t i = 0; i < tok->n_funs; i++) { - pgf_lookup_add_spine_leaf(&builder, tok->funs[i]); - } - - *meta_id = gu_map_get(builder.meta_ids, typ->cid, PgfMetaId); - - return builder.spine; -} - -typedef PgfMetaId PgfPair[2]; - -static bool -pgf_pair_eq_fn(GuEquality* self, const void* p1, const void* p2) -{ - (void) self; - const PgfMetaId* ip1 = p1; - const PgfMetaId* ip2 = p2; - return (ip1[0] == ip2[0] && ip1[1] == ip2[1]); -} - -static GuHash -pgf_pair_hash_fn(GuHasher* self, const void* p) -{ - (void) self; - const PgfMetaId* ip = p; - return (GuHash) (((ip[1] & 0xFFFF) << 16) | (ip[0] & 0xFFFF)); -} - -static GuHasher -pgf_pair_hasher[1] = { - { - { pgf_pair_eq_fn }, - pgf_pair_hash_fn - } -}; - -static PgfMetaId -pgf_lookup_merge_cats(GuBuf* spine, GuMap* pairs, - PgfMetaId meta_id1, GuBuf* spine1, - PgfMetaId meta_id2, GuBuf* spine2, - GuPool* pool) -{ - if (meta_id1 == 0 && meta_id2 == 0) - return 0; - - PgfPair pair; - pair[0] = meta_id1; - pair[1] = meta_id2; - PgfMetaId meta_id = gu_map_get(pairs, &pair, PgfMetaId); - if (meta_id != 0) - return meta_id; - - meta_id = gu_buf_length(spine); - GuBuf* id_prods = gu_new_buf(PgfAbsProduction*, pool); - gu_buf_push(spine, GuBuf*, id_prods); - - gu_map_put(pairs, &pair, PgfMetaId, meta_id); - - GuBuf* id_prods1 = gu_buf_get(spine1, GuBuf*, meta_id1); - GuBuf* id_prods2 = gu_buf_get(spine2, GuBuf*, meta_id2); - size_t n_id_prods1 = (meta_id1 == 0) ? 0 : gu_buf_length(id_prods1); - size_t n_id_prods2 = (meta_id2 == 0) ? 0 : gu_buf_length(id_prods2); - - if (meta_id1 != 0) { - for (size_t i = 0; i < n_id_prods1; i++) { - PgfAbsProduction* prod1 = - gu_buf_get(id_prods1, PgfAbsProduction*, i); - int count = 0; - for (size_t j = 0; j < n_id_prods2; j++) { - PgfAbsProduction* prod2 = - gu_buf_get(id_prods2, PgfAbsProduction*, j); - if (prod1->fun == prod2->fun) { - PgfAbsProduction* prod = - pgf_lookup_new_production(prod1->fun, pool); - prod->count = prod1->count+prod2->count; - size_t n_hypos = gu_seq_length(prod->fun->type->hypos); - for (size_t l = 0; l < n_hypos; l++) { - prod->args[l] = - pgf_lookup_merge_cats(spine, pairs, - prod1->args[l], spine1, - prod2->args[l], spine2, - pool); - } - gu_buf_push(id_prods, PgfAbsProduction*, prod); - - count++; - } - } - - if (count == 0) { - PgfAbsProduction* prod = - pgf_lookup_new_production(prod1->fun, pool); - prod->count = prod1->count; - size_t n_hypos = gu_seq_length(prod->fun->type->hypos); - for (size_t l = 0; l < n_hypos; l++) { - prod->args[l] = - pgf_lookup_merge_cats(spine, pairs, - prod1->args[l], spine1, - 0, spine2, - pool); - } - gu_buf_push(id_prods, PgfAbsProduction*, prod); - } - } - } - - if (meta_id2 != 0) { - for (size_t i = 0; i < n_id_prods2; i++) { - PgfAbsProduction* prod2 = - gu_buf_get(id_prods2, PgfAbsProduction*, i); - bool found = false; - for (size_t j = 0; j < n_id_prods1; j++) { - PgfAbsProduction* prod1 = - gu_buf_get(id_prods1, PgfAbsProduction*, j); - if (prod1->fun == prod2->fun) { - found = true; - break; - } - } - - if (!found) { - PgfAbsProduction* prod = - pgf_lookup_new_production(prod2->fun, pool); - prod->count = prod2->count; - size_t n_hypos = gu_seq_length(prod->fun->type->hypos); - for (size_t l = 0; l < n_hypos; l++) { - prod->args[l] = - pgf_lookup_merge_cats(spine, pairs, - 0, spine1, - prod2->args[l], spine2, - pool); - } - gu_buf_push(id_prods, PgfAbsProduction*, prod); - } - } - } - - return meta_id; -} - -static GuBuf* -pgf_lookup_merge(PgfMetaId meta_id1, GuBuf* spine1, - PgfMetaId meta_id2, GuBuf* spine2, - PgfMetaId* meta_id, - GuPool* pool, GuPool* out_pool) -{ - GuBuf* spine = gu_new_buf(GuBuf*, out_pool); - gu_buf_push(spine, GuBuf*, NULL); - - GuMap* pairs = gu_new_map(PgfPair, pgf_pair_hasher, PgfMetaId, &gu_null_struct, pool); - - *meta_id = - pgf_lookup_merge_cats(spine, pairs, - meta_id1, spine1, - meta_id2, spine2, - out_pool); - - return spine; -} - -typedef struct { - PgfLinFuncs* funcs; - PgfConcr* concr; - GuBuf* join; - PgfMetaId start_id; - GuChoice* choice; - GuBuf* expr_tokens; - GuBuf* ctrees; - int max_fid; - PgfAbsFun** curr_absfun; - GuPool* pool; -} PgfLookupState; - -struct PgfItemConts { - size_t count; -}; - -typedef struct { - GuEnum en; - double max; - size_t index; - GuBuf* ctrees; - GuPool* out_pool; -} PgfLookupEnum; - -static void -gu_ccat_fini(GuFinalizer* fin) -{ - PgfCCat* cat = gu_container(fin, PgfCCat, fin); - if (cat->prods != NULL) - gu_seq_free(cat->prods); -} - -static PgfCCat* -pgf_lookup_new_ccat(PgfLookupState* st, PgfCCat* ccat) -{ - PgfCCat* new_ccat = gu_new_flex(st->pool, PgfCCat, fin, 1); - new_ccat->cnccat = ccat->cnccat; - new_ccat->lindefs = ccat->lindefs; - new_ccat->linrefs = ccat->linrefs; - new_ccat->viterbi_prob = 0; - new_ccat->fid = st->max_fid++; - new_ccat->conts = gu_new(PgfItemConts, st->pool); - new_ccat->conts->count = 0; - new_ccat->answers = NULL; - new_ccat->prods = NULL; - new_ccat->n_synprods = 0; - - new_ccat->fin[0].fn = gu_ccat_fini; - gu_pool_finally(st->pool, new_ccat->fin); - - return new_ccat; -} - -static PgfCCat* -pgf_lookup_concretize(PgfLookupState* st, GuMap* cache, PgfMetaId meta_id, PgfCCat *ccat); - -static PgfCCat* -pgf_lookup_concretize_coercions(PgfLookupState* st, GuMap* cache, - PgfMetaId meta_id, PgfCCat* ccat, - GuBuf* coercions) -{ - PgfPair pair; - pair[0] = meta_id; - pair[1] = ccat->fid; - PgfCCat** pnew_ccat = gu_map_find(cache, &pair); - if (pnew_ccat != NULL) - return *pnew_ccat; - - PgfCCat* new_ccat = NULL; - - size_t n_coercions = gu_buf_length(coercions); - for (size_t i = 0; i < n_coercions; i++) { - PgfProductionCoerce* pcoerce = - gu_buf_get(coercions, PgfProductionCoerce*, i); - - PgfCCat* new_coerce = - pgf_lookup_concretize(st, cache, meta_id, pcoerce->coerce); - if (new_coerce == NULL) - continue; - - if (new_ccat == NULL) { - new_ccat = pgf_lookup_new_ccat(st, ccat); - } - - PgfProduction cnc_prod; - PgfProductionCoerce* new_pcoerce = - gu_new_variant(PGF_PRODUCTION_COERCE, - PgfProductionCoerce, - &cnc_prod, st->pool); - new_pcoerce->coerce = new_coerce; - - size_t count = (new_coerce->conts == NULL) ? 0 : new_coerce->conts->count; - if (count > new_ccat->conts->count) { - new_ccat->conts->count = new_coerce->conts->count; - new_ccat->n_synprods = 0; - } - - if (new_ccat->prods == NULL || new_ccat->n_synprods >= gu_seq_length(new_ccat->prods)) { - new_ccat->prods = gu_realloc_seq(new_ccat->prods, PgfProduction, new_ccat->n_synprods+(n_coercions-i)); - } - - if (count == new_ccat->conts->count) { - gu_seq_set(new_ccat->prods, PgfProduction, new_ccat->n_synprods++, cnc_prod); - } - -#ifdef PGF_LOOKUP_DEBUG - { - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - gu_printf(out,err,"C%d -> _[C%d] <%d>\n",new_ccat->fid,new_coerce->fid,new_coerce->conts ? new_coerce->conts->count : 0); - gu_pool_free(tmp_pool); - } -#endif - } - - gu_map_put(cache, &pair, PgfCCat*, new_ccat); - - return new_ccat; -} - -static PgfCCat* -pgf_lookup_concretize(PgfLookupState* st, GuMap* cache, PgfMetaId meta_id, PgfCCat *ccat) -{ - if (meta_id == 0) { - // if there is no lindef for this ccat then we can't use it for - // linearization of a metavariable - if (ccat->lindefs == NULL || gu_seq_length(ccat->lindefs) == 0) - return NULL; - return ccat; - } - - PgfPair pair; - pair[0] = meta_id; - pair[1] = ccat->fid; - PgfCCat** pnew_ccat = gu_map_find(cache, &pair); - if (pnew_ccat != NULL) { - // check for loops - if (*pnew_ccat == (PgfCCat*) &gu_null_struct) - return NULL; - return *pnew_ccat; - } - - // put a marker to detect loops - gu_map_put(cache, &pair, PgfCCat*, (PgfCCat*) &gu_null_struct); - - PgfCCat* new_ccat = NULL; - - GuBuf* id_prods = gu_buf_get(st->join, GuBuf*, meta_id); - - size_t n_id_prods = gu_buf_length(id_prods); - for (size_t i = 0; i < n_id_prods; i++) { - PgfAbsProduction* prod = - gu_buf_get(id_prods, PgfAbsProduction*, i); - - PgfCncOverloadMap* overl_table = - gu_map_get(st->concr->fun_indices, prod->fun->name, PgfCncOverloadMap*); - if (overl_table == NULL) - continue; - - GuBuf* buf = - gu_map_get(overl_table, ccat, GuBuf*); - if (buf == NULL) - continue; - - size_t n_prods = gu_buf_length(buf); - for (size_t j = 0; j < n_prods; j++) { - PgfProductionApply* papply = - gu_buf_get(buf, PgfProductionApply*, j); - - size_t count = prod->count; - - size_t n_args = gu_seq_length(papply->args); - GuSeq* new_args = gu_new_seq(PgfPArg, n_args, st->pool); - for (size_t k = 0; k < n_args; k++) { - PgfPArg* parg = gu_seq_index(papply->args, PgfPArg, k); - PgfPArg* new_parg = gu_seq_index(new_args, PgfPArg, k); - - new_parg->hypos = parg->hypos; - - GuBuf* coercions = - gu_map_get(st->concr->coerce_idx, parg->ccat, GuBuf*); - if (coercions == NULL) { - new_parg->ccat = - pgf_lookup_concretize(st, cache, prod->args[k], parg->ccat); - } else { - new_parg->ccat = - pgf_lookup_concretize_coercions(st, cache, prod->args[k], parg->ccat, coercions); - } - - if (new_parg->ccat == NULL) - goto skip; - - if (new_parg->ccat->conts != NULL) - count += new_parg->ccat->conts->count; - } - - if (new_ccat == NULL) { - new_ccat = pgf_lookup_new_ccat(st, ccat); - } - - PgfProduction cnc_prod; - PgfProductionApply* new_papp = - gu_new_variant(PGF_PRODUCTION_APPLY, - PgfProductionApply, - &cnc_prod, st->pool); - new_papp->fun = papply->fun; - new_papp->args = new_args; - - if (count > new_ccat->conts->count) { - new_ccat->conts->count = count; - new_ccat->n_synprods = 0; - } - - if (new_ccat->prods == NULL || new_ccat->n_synprods >= gu_seq_length(new_ccat->prods)) { - new_ccat->prods = gu_realloc_seq(new_ccat->prods, PgfProduction, new_ccat->n_synprods+(n_prods-j)); - } - - if (count == new_ccat->conts->count) { - gu_seq_set(new_ccat->prods, PgfProduction, new_ccat->n_synprods++, cnc_prod); - } - -#ifdef PGF_LOOKUP_DEBUG - { - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - - gu_printf(out,err,"C%d -> F%d[",new_ccat->fid,new_papp->fun->funid); - - size_t n_args = gu_seq_length(new_papp->args); - for (size_t l = 0; l < n_args; l++) { - if (l > 0) - gu_putc(',',out,err); - - PgfPArg arg = gu_seq_get(new_papp->args, PgfPArg, l); - - if (arg.hypos != NULL) { - size_t n_hypos = gu_seq_length(arg.hypos); - for (size_t r = 0; r < n_hypos; r++) { - if (r > 0) - gu_putc(' ',out,err); - PgfCCat *hypo = gu_seq_get(arg.hypos, PgfCCat*, r); - gu_printf(out,err,"C%d",hypo->fid); - } - } - - gu_printf(out,err,"C%d",arg.ccat->fid); - } - gu_printf(out,err,"] <%d>\n", count); - gu_pool_free(tmp_pool); - } -#endif - -skip:; - } - } - - gu_map_put(cache, &pair, PgfCCat*, new_ccat); - - return new_ccat; -} - -static PgfCncTree -pgf_lookup_extract(PgfLookupState* st, PgfCCat* ccat) -{ - PgfCncTree ret; - - if (ccat->fid < st->concr->total_cats) { - int index = - gu_choice_next(st->choice, gu_seq_length(ccat->lindefs)); - - PgfCncTreeApp* capp = - gu_new_flex_variant(PGF_CNC_TREE_APP, - PgfCncTreeApp, - args, 1, &ret, st->pool); - capp->ccat = ccat; - capp->fun = gu_seq_get(ccat->lindefs, PgfCncFun*, index); - capp->fid = 0; - capp->n_vars = 0; - capp->context = NULL; - capp->n_args = 1; - - PgfCncTreeChunks* chunks = - gu_new_flex_variant(PGF_CNC_TREE_CHUNKS, - PgfCncTreeChunks, - args, 0, &capp->args[0], st->pool); - chunks->id = 0; - chunks->n_vars = 0; - chunks->context = NULL; - chunks->n_args = 0; - } else { - int index = - gu_choice_next(st->choice, ccat->n_synprods); - - PgfProduction prod = - gu_seq_get(ccat->prods, PgfProduction, index); - - GuVariantInfo i = gu_variant_open(prod); - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papply = i.data; - - size_t n_args = gu_seq_length(papply->args); - PgfCncTreeApp* capp = - gu_new_flex_variant(PGF_CNC_TREE_APP, - PgfCncTreeApp, - args, n_args, &ret, st->pool); - capp->ccat = ccat; - capp->fun = papply->fun; - capp->fid = 0; - capp->n_vars = 0; - capp->context = NULL; - capp->n_args = n_args; - - for (size_t i = 0; i < n_args; i++) { - PgfPArg* arg = gu_seq_index(papply->args, PgfPArg, i); - capp->args[i] = pgf_lookup_extract(st, arg->ccat); - } - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = i.data; - ret = pgf_lookup_extract(st, pcoerce->coerce); - break; - } - default: - gu_impossible(); - } - } - - return ret; -} - -static GuBuf* -pgf_lookup_tokenize(GuMap* lexicon_idx, GuString sentence, GuPool* pool) -{ - GuBuf* tokens = gu_new_buf(PgfInputToken, pool); - - GuUCS c = ' '; - const uint8_t* p = (const uint8_t*) sentence; - for (;;) { - while (gu_ucs_is_space(c)) { - c = gu_utf8_decode(&p); - } - if (c == 0) - break; - - const uint8_t* start = p-1; - while (c != 0 && !gu_ucs_is_space(c)) { - c = gu_utf8_decode(&p); - } - const uint8_t* end = p-1; - - PgfInputToken* tok = gu_buf_extend(tokens); - - size_t len = end-start; - tok->token = gu_malloc(pool, len+1); - memcpy((uint8_t*) tok->token, start, len); - ((uint8_t*) tok->token)[len] = 0; - - GuBuf* funs = gu_map_get(lexicon_idx, tok->token, GuBuf*); - if (funs != NULL) { - tok->n_funs = gu_buf_length(funs); - tok->funs = gu_buf_data(funs); - } else { - tok->n_funs = 0; - tok->funs = NULL; - } - } - - return tokens; -} - -static double -pgf_lookup_compute_kernel_helper(GuBuf* sentence_tokens, GuBuf* expr_tokens, - double* matrix, size_t i, size_t j) -{ - size_t dim = gu_buf_length(sentence_tokens)+1; - - double score = matrix[i + dim*j]; - - if (score < 0) { - score = 0; - for (size_t l = 0; l < i; l++) { - matrix[l + dim*j] = score; - for (size_t k = j; k > 0; k--) { - PgfInputToken* sentence_token = gu_buf_index(sentence_tokens, PgfInputToken, l); - PgfInputToken* expr_token = gu_buf_index(expr_tokens, PgfInputToken, k-1); - - if (sentence_token->token != NULL && expr_token->token != NULL && - strcmp(sentence_token->token, expr_token->token) == 0) { - score += 1 + pgf_lookup_compute_kernel_helper(sentence_tokens, expr_tokens, matrix, l, k-1); - } else { - bool match = false; - for (size_t i = 0; i < sentence_token->n_funs; i++) { - for (size_t j = 0; j < expr_token->n_funs; j++) { - if (sentence_token->funs[i] == expr_token->funs[j]) { - match = true; - goto done; - } - } - } - done: - if (match) { - score += 0.5 + pgf_lookup_compute_kernel_helper(sentence_tokens, expr_tokens, matrix, l, k-1); - } - } - } - } - matrix[i + dim*j] = score; - } - - return score; -} - -static double -pgf_lookup_compute_kernel(GuBuf* sentence_tokens, GuBuf* expr_tokens) -{ - size_t n_sentence_tokens = gu_buf_length(sentence_tokens); - size_t n_expr_tokens = gu_buf_length(expr_tokens); - size_t size = (n_sentence_tokens+1)*(n_expr_tokens+1); - double* matrix = alloca(size*sizeof(double)); - - for (size_t i = 0; i < size; i++) { - matrix[i] = -1; - } - - return - pgf_lookup_compute_kernel_helper(sentence_tokens,expr_tokens,matrix, - n_sentence_tokens,n_expr_tokens); -} - -typedef struct { - PgfCncTree ctree; - double score; -} PgfCncTreeScore; - -static void -pgf_lookup_ctree_to_expr(PgfCncTree ctree, PgfExprProb* ep, - GuPool* out_pool) -{ - size_t n_args = 0; - PgfCncTree* args = NULL; - - GuVariantInfo cti = gu_variant_open(ctree); - switch (cti.tag) { - case PGF_CNC_TREE_APP: { - PgfCncTreeApp* fapp = cti.data; - *ep = fapp->fun->absfun->ep; - n_args = fapp->n_args; - args = fapp->args; - break; - } - case PGF_CNC_TREE_CHUNKS: { - PgfCncTreeChunks* fchunks = cti.data; - n_args = fchunks->n_args; - args = fchunks->args; - - ep->expr = gu_new_variant_i(out_pool, - PGF_EXPR_META, PgfExprMeta, - .id = fchunks->id); - ep->prob = 0; - break; - } -/* case PGF_CNC_TREE_LIT: { - PgfCncTreeLit* flit = cti.data; - break; - }*/ - default: - gu_impossible(); - } - - if (gu_variant_is_null(ep->expr)) { - gu_assert(n_args==1); - pgf_lookup_ctree_to_expr(args[0], ep, out_pool); - } else { - for (size_t i = 0; i < n_args; i++) { - PgfExprProb ep_arg; - pgf_lookup_ctree_to_expr(args[i], &ep_arg, out_pool); - - - ep->expr = gu_new_variant_i(out_pool, - PGF_EXPR_APP, - PgfExprApp, - ep->expr, ep_arg.expr); - ep->prob += ep_arg.prob; - } - } -} - -static void -pgf_lookup_enum_next(GuEnum* self, void* to, GuPool* pool) -{ - PgfLookupEnum* st = gu_container(self, PgfLookupEnum, en); - PgfCncTreeScore* cts = NULL; - - while (st->index < gu_buf_length(st->ctrees)) { - cts = gu_buf_index(st->ctrees, PgfCncTreeScore, st->index); - st->index++; - if (cts->score == st->max) { - PgfExprProb* ep = gu_new(PgfExprProb, st->out_pool); - pgf_lookup_ctree_to_expr(cts->ctree, ep, st->out_pool); - *((PgfExprProb**) to) = ep; - return; - } - } - - *((PgfExprProb**) to) = NULL; -} - -static void -pgf_lookup_symbol_token(PgfLinFuncs** self, PgfToken token) -{ - PgfLookupState* st = gu_container(self, PgfLookupState, funcs); - PgfInputToken* tok = gu_buf_extend(st->expr_tokens); - tok->token = token; - tok->n_funs = st->curr_absfun ? 1 : 0; - tok->funs = st->curr_absfun; -} - -static void -pgf_lookup_begin_phrase(PgfLinFuncs** self, PgfCId cat, int fid, GuString ann, PgfCId funname) -{ - PgfLookupState* st = gu_container(self, PgfLookupState, funcs); - - PgfAbsFun* absfun = gu_seq_binsearch(st->concr->abstr->funs, pgf_absfun_order, PgfAbsFun, funname); - if (absfun != NULL) { - st->curr_absfun = gu_new(PgfAbsFun*, st->pool); - *st->curr_absfun = absfun; - } else { - st->curr_absfun = NULL; - } -} - -static void -pgf_lookup_end_phrase(PgfLinFuncs** self, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfLookupState* st = gu_container(self, PgfLookupState, funcs); - st->curr_absfun = NULL; -} - -static void -pgf_lookup_symbol_meta(PgfLinFuncs** self, PgfMetaId meta_id) -{ - PgfLookupState* st = gu_container(self, PgfLookupState, funcs); - PgfInputToken* tok = gu_buf_extend(st->expr_tokens); - tok->token = NULL; - tok->n_funs = 0; -} - -static PgfLinFuncs pgf_lookup_lin_funcs = { - .symbol_token = pgf_lookup_symbol_token, - .begin_phrase = pgf_lookup_begin_phrase, - .end_phrase = pgf_lookup_end_phrase, - .symbol_ne = NULL, - .symbol_bind = NULL, - .symbol_capit = NULL, - .symbol_meta = pgf_lookup_symbol_meta -}; - -PGF_API GuEnum* -pgf_lookup_sentence(PgfConcr* concr, PgfType* typ, GuString sentence, GuPool* pool, GuPool* out_pool) -{ - //// building search indices // - GuMap* lexicon_idx = gu_new_string_map(GuBuf*, &gu_null_struct, pool); - size_t n_cncfuns = gu_seq_length(concr->cncfuns); - for (size_t i = 0; i < n_cncfuns; i++) { - PgfCncFun* cncfun = gu_seq_get(concr->cncfuns, PgfCncFun*, i); - for (size_t lin_idx = 0; lin_idx < cncfun->n_lins; lin_idx++) { - pgf_lookup_index_syms(lexicon_idx, cncfun->lins[lin_idx]->syms, cncfun->absfun, pool); - } - } - - GuMap* function_idx = gu_new_string_map(GuBuf*, &gu_null_struct, pool); - size_t n_funs = gu_seq_length(concr->abstr->funs); - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* fun = gu_seq_index(concr->abstr->funs, PgfAbsFun, i); - - size_t n_hypos = gu_seq_length(fun->type->hypos); - for (size_t j = 0; j < n_hypos; j++) { - PgfHypo* hypo = gu_seq_index(fun->type->hypos, PgfHypo, j); - - GuBuf* funs = gu_map_get(function_idx, hypo->type->cid, GuBuf*); - if (funs == NULL) { - funs = gu_new_buf(PgfAbsBottomUpEntry, pool); - gu_map_put(function_idx, hypo->type->cid, GuBuf*, funs); - } - - PgfAbsBottomUpEntry* entry = gu_buf_extend(funs); - entry->fun = fun; - entry->arg_idx = j; - } - } - /////////////////////////////// - - GuPool *work_pool = gu_new_pool(); - - GuBuf* sentence_tokens = - pgf_lookup_tokenize(lexicon_idx, sentence, work_pool); - - PgfMetaId meta_id1 = 0; - GuBuf* join = gu_new_buf(GuBuf*, pool); - gu_buf_push(join, GuBuf*, NULL); - - size_t n_tokens = gu_buf_length(sentence_tokens); - for (size_t i = 0; i < n_tokens; i++) { - PgfInputToken* tok = gu_buf_index(sentence_tokens, PgfInputToken, i); - - PgfMetaId meta_id2 = 0; - GuBuf* spine = - pgf_lookup_build_spine(function_idx, - tok, typ, &meta_id2, - work_pool); - - join = pgf_lookup_merge(meta_id1, join, meta_id2, spine, &meta_id1, work_pool, pool); - } - -#ifdef PGF_LOOKUP_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - pgf_print_abs_productions(join, out, err); - gu_putc('\n',out,err); - gu_pool_free(tmp_pool); -#endif - - PgfLookupState st; - st.funcs = &pgf_lookup_lin_funcs; - st.concr = concr; - st.join = join; - st.start_id= meta_id1; - st.choice = gu_new_choice(work_pool); - st.expr_tokens=gu_new_buf(PgfInputToken, work_pool); - st.ctrees = gu_new_buf(PgfCncTreeScore, pool); - st.curr_absfun= NULL; - st.max_fid = concr->total_cats; - st.pool = pool; - - GuMap* cache = gu_new_map(PgfPair, pgf_pair_hasher, PgfCCat*, &gu_null_struct, pool); - - double sentence_value = - pgf_lookup_compute_kernel(sentence_tokens, sentence_tokens); - - double max = 0; - - PgfCncCat* cnccat = - gu_map_get(concr->cnccats, typ->cid, PgfCncCat*); - size_t n_ccats = (cnccat) ? gu_seq_length(cnccat->cats) : 0; - for (size_t i = 0; i < n_ccats; i++) { - PgfCCat* ccat = gu_seq_get(cnccat->cats, PgfCCat*, i); - PgfCCat* new_ccat = pgf_lookup_concretize(&st, cache, st.start_id, ccat); - if (new_ccat == NULL) - continue; - - GuChoiceMark mark = gu_choice_mark(st.choice); - - for (;;) { - PgfCncTreeScore* cts = gu_buf_extend(st.ctrees); - cts->ctree = - pgf_lookup_extract(&st, new_ccat); - - cts->ctree = pgf_lzr_wrap_linref(cts->ctree, st.pool); - pgf_lzr_linearize(concr, cts->ctree, 0, &st.funcs, st.pool); - - double value = pgf_lookup_compute_kernel(sentence_tokens, st.expr_tokens); - double expr_value = pgf_lookup_compute_kernel(st.expr_tokens, st.expr_tokens); - cts->score = - value / sqrt(sentence_value * expr_value); - - gu_buf_flush(st.expr_tokens); - -#ifdef PGF_LINEARIZER_DEBUG - { - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - pgf_lzr_linearize_simple(concr, cts->ctree, 0, - out, err, tmp_pool); - gu_putc('\n', out, err); - pgf_print_cnc_tree(cts->ctree, out, err); - gu_printf(out, err, " [%.1f/sqrt(%.1f*%.1f)=%f]\n\n", value, sentence_value, expr_value, cts->score); - gu_pool_free(tmp_pool); - } -#endif - - if (cts->score > max) { - max = cts->score; - } - - gu_choice_reset(st.choice, mark); - - if (!gu_choice_advance(st.choice)) - break; - } - } - - gu_pool_free(work_pool); - - - PgfLookupEnum* lenum = gu_new(PgfLookupEnum, pool); - lenum->en.next = pgf_lookup_enum_next; - lenum->max = max; - lenum->index = 0; - lenum->ctrees = st.ctrees; - lenum->out_pool= out_pool; - return &lenum->en; -} diff --git a/src/runtime/c/pgf/parser.c b/src/runtime/c/pgf/parser.c deleted file mode 100644 index 08ed74002..000000000 --- a/src/runtime/c/pgf/parser.c +++ /dev/null @@ -1,2482 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -//#define PGF_PARSER_DEBUG -//#define PGF_COUNTS_DEBUG -//#define PGF_RESULT_DEBUG - -typedef GuBuf PgfItemBuf; - -typedef struct PgfParseState PgfParseState; - -struct PgfItemConts { - PgfCCat* ccat; - size_t lin_idx; - PgfParseState* state; - prob_t outside_prob; - PgfItemBuf* items; - int ref_count; // how many items point to this cont? -}; - -typedef GuSeq PgfItemContss; -typedef GuMap PgfContsMap; -typedef GuMap PgfGenCatMap; -typedef GuMap PgfChunksMap; - -typedef GuBuf PgfCCatBuf; - -typedef struct { - PgfConcr* concr; - GuPool* pool; // this pool is used for structures internal to the parser - GuPool* out_pool; // this pool is used for the allocating the final abstract trees - GuString sentence; // the sentence to be parsed - bool case_sensitive; - GuBuf* expr_queue; // during the extraction of abstract trees we push them in this queue - int max_fid; - PgfParseState *before; - PgfParseState *after; - PgfToken prefix; - PgfTokenProb* tp; - PgfExprEnum en; // enumeration for the generated trees/tokens -#ifdef PGF_COUNTS_DEBUG - int item_full_count; - int item_real_count; - int ccat_full_count; - int prod_full_count; -#endif - PgfItem* free_item; - - prob_t heuristic_factor; - PgfCallbacksMap* callbacks; - PgfOracleCallback* oracle; -} PgfParsing; - -typedef enum { BIND_NONE, BIND_HARD, BIND_SOFT } BIND_TYPE; - -typedef struct { - PgfProductionIdx* idx; - size_t offset; - size_t sym_idx; -} PgfLexiconIdxEntry; - -typedef GuBuf PgfLexiconIdx; - -struct PgfParseState { - PgfParseState* next; - - PgfItemBuf* agenda; - PgfContsMap* conts_map; - PgfGenCatMap* generated_cats; - PgfChunksMap* chunks_map; - - bool needs_bind; - size_t start_offset; - size_t end_offset; - - prob_t viterbi_prob; - - PgfLexiconIdx* lexicon_idx; -}; - -typedef struct PgfAnswers { - GuBuf* conts; - GuBuf* exprs; - PgfCCat* ccat; - prob_t outside_prob; -} PgfAnswers; - -#define PGF_EXPR_CHUNK_STATE ((size_t) -1) - -typedef struct { - PgfAnswers* answers; - PgfExprProb ep; - union { - PgfPArgs* args; - PgfParseState* state; - }; - size_t arg_idx; // if the value is PGF_EXPR_CHUNK_STATE, then - // the relevant value above is state, not args. -} PgfExprState; - -typedef struct PgfItemBase PgfItemBase; - -struct PgfItem { - union { - PgfItemConts* conts; - PgfItem *next; // used to collect released items - }; - - PgfProduction prod; - PgfPArgs* args; - PgfSymbol curr_sym; - uint16_t sym_idx; - uint8_t alt_idx; // position in the pre alternative - uint8_t alt; // the number of the alternative - prob_t inside_prob; -}; - -static PgfSymbols* -pgf_collect_extern_tok(PgfParsing* ps, size_t start_offset, size_t end_offset) -{ - GuBuf* syms = gu_new_buf(PgfSymbol, ps->pool); - - const uint8_t* start = (uint8_t*) ps->sentence+start_offset; - const uint8_t* end = (uint8_t*) ps->sentence+end_offset; - - const uint8_t* p = start; - GuUCS ucs = gu_utf8_decode(&p); - while (start < end) { - size_t len = 0; - while (p <= end && !gu_ucs_is_space(ucs)) { - len = (p - start); - ucs = gu_utf8_decode(&p); - } - - PgfSymbol sym; - PgfSymbolKS* sks = (PgfSymbolKS*) - gu_alloc_variant(PGF_SYMBOL_KS, - sizeof(PgfSymbolKS)+len+1, - gu_alignof(PgfSymbolKS), - &sym, ps->pool); - memcpy((char*) sks->token, start, len); - ((char*) sks->token)[len] = 0; - gu_buf_push(syms, PgfSymbol, sym); - - start = p; - while (gu_ucs_is_space(ucs)) { - start = p; - ucs = gu_utf8_decode(&p); - } - } - - return gu_buf_data_seq(syms); -} - -#ifdef PGF_PARSER_DEBUG -PGF_INTERNAL void -pgf_print_fid(int fid, GuOut* out, GuExn* err); - -PGF_INTERNAL_DECL void -pgf_print_symbol(PgfSymbol sym, GuOut *out, GuExn *err); - -static void -pgf_item_symbols(PgfItem* item, - size_t* lin_idx, PgfSymbols** syms, - GuPool* pool) { - *lin_idx = item->conts->lin_idx; - - GuVariantInfo i = gu_variant_open(item->prod); - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = i.data; - *syms = papp->fun->lins[item->conts->lin_idx]->syms; - break; - } - case PGF_PRODUCTION_COERCE: { - PgfSymbol sym = - gu_new_variant_i(pool, PGF_SYMBOL_CAT, - PgfSymbolCat, - .d = 0, .r = item->conts->lin_idx); - *syms = gu_new_seq(PgfSymbol, 1, pool); - gu_seq_set(*syms, PgfSymbol, 0, sym); - break; - } - case PGF_PRODUCTION_EXTERN: { - PgfProductionExtern* pext = i.data; - *syms = pext->lins[item->conts->lin_idx]; - break; - } - default: - gu_impossible(); - } -} - -PGF_INTERNAL void -pgf_print_production_args(PgfPArgs* args, - GuOut* out, GuExn* err); - -PGF_INTERNAL void -pgf_print_production(int fid, PgfProduction prod, - GuOut *out, GuExn* err); - -static void -pgf_print_item_seq(PgfItem *item, - GuOut *out, GuExn* err, GuPool* pool) -{ - size_t lin_idx; - PgfSymbols* syms = NULL; - pgf_item_symbols(item, &lin_idx, &syms, pool); - - gu_printf(out, err, "%d : ",lin_idx); - - size_t index; - for (index = 0; index < gu_seq_length(syms); index++) { - if (item->sym_idx == index) - gu_printf(out, err, " . "); - - PgfSymbol sym = gu_seq_get(syms, PgfSymbol, index); - pgf_print_symbol(sym, out, err); - } - - if (item->sym_idx == index) - gu_printf(out, err, " ."); -} - -static void -pgf_print_range(PgfParseState* start, PgfParseState* end, GuOut* out, GuExn* err) -{ - gu_printf(out, err, "%d-%d", - (start != NULL) ? start->end_offset : 0, - (start == end) ? end->end_offset : end->start_offset); -} - -static void -pgf_print_item(PgfItem* item, PgfParseState* state, GuOut* out, GuExn* err, GuPool* pool) -{ - gu_putc('[', out, err); - pgf_print_range(item->conts->state, state, out, err); - gu_puts("; ", out, err); - pgf_print_fid(item->conts->ccat->fid, out, err); - gu_puts(" -> ", out, err); - - GuVariantInfo i = gu_variant_open(item->prod); - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = i.data; - PgfCncFun* fun = papp->fun; - gu_printf(out, err, "F%d(", fun->funid); - if (fun->ep != NULL) { - pgf_print_expr(fun->ep->expr, NULL, 0, out, err); - } else { - PgfPArg* parg = gu_seq_index(item->args, PgfPArg, 0); - gu_printf(out,err,"linref %s", parg->ccat->cnccat->abscat->name); - } - gu_printf(out, err, ")["); - pgf_print_production_args(item->args, out, err); - gu_printf(out, err, "]; "); - break; - } - case PGF_PRODUCTION_COERCE: { - gu_puts("_[", out, err); - pgf_print_fid(gu_seq_index(item->args, PgfPArg, 0)->ccat->fid, out, err); - gu_puts("]; ", out, err); - break; - } - case PGF_PRODUCTION_EXTERN: { - PgfProductionExtern* pext = i.data; - gu_printf(out, err, ""); - if (pext->ep != NULL) { - gu_printf(out, err, "("); - pgf_print_expr(pext->ep->expr, NULL, 0, out, err); - gu_printf(out, err, ")"); - } - gu_printf(out, err, "["); - pgf_print_production_args(item->args, out, err); - gu_printf(out, err, "]; "); - break; - } - default: - gu_impossible(); - } - - pgf_print_item_seq(item, out, err, pool); - gu_printf(out, err, "; %f+%f=%f]\n", - item->inside_prob, - item->conts->outside_prob, - item->inside_prob+item->conts->outside_prob); -} - -#ifdef PGF_RESULT_DEBUG -static void -pgf_print_expr_state(PgfExprState* st, - GuOut* out, GuExn* err, GuBuf* stack) -{ - gu_buf_push(stack, int, - (st->arg_idx != PGF_EXPR_CHUNK_STATE) ? - (gu_seq_length(st->args) - st->arg_idx - 1) : 0); - - if (gu_buf_length(st->answers->conts) > 0) { - PgfExprState* cont = gu_buf_get(st->answers->conts, PgfExprState*, 0); - if (cont != NULL) - pgf_print_expr_state(cont, out, err, stack); - } - - gu_puts(" (", out, err); - if (st->answers->ccat != NULL) { - pgf_print_fid(st->answers->ccat->fid,out,err); - gu_puts(":", out, err); - } - if (gu_variant_is_null(st->ep.expr)) - gu_puts("_", out, err); - else - pgf_print_expr(st->ep.expr, NULL, 0, out, err); -} - -static void -pgf_print_expr_state0(PgfExprState* st, - GuOut* out, GuExn* err, GuPool* tmp_pool) -{ - gu_printf(out, err, "[%f+%f=%f]", - st->ep.prob, - st->answers->outside_prob, - st->answers->outside_prob+st->ep.prob); - - size_t n_args = (st->arg_idx == PGF_EXPR_CHUNK_STATE) ? - 0 : gu_seq_length(st->args); - - GuBuf* stack = gu_new_buf(int, tmp_pool); - if (n_args > 0) - gu_buf_push(stack, int, n_args - st->arg_idx); - - if (gu_buf_length(st->answers->conts) > 0) { - PgfExprState* cont = - gu_buf_get(st->answers->conts, PgfExprState*, 0); - if (cont != NULL) - pgf_print_expr_state(cont, out, err, stack); - } - - if (n_args > 0) - gu_puts(" (", out, err); - else - gu_puts(" ", out, err); - - if (gu_variant_is_null(st->ep.expr)) - gu_puts("_", out, err); - else - pgf_print_expr(st->ep.expr, NULL, 0, out, err); - - size_t n_counts = gu_buf_length(stack); - for (size_t i = 0; i < n_counts; i++) { - int count = gu_buf_get(stack, int, i); - while (count-- > 0) - gu_puts(" ?", out, err); - - gu_puts(")", out, err); - } - gu_puts("\n", out, err); -} -#endif -#endif - -PGF_INTERNAL_DECL int -cmp_string(PgfCohortSpot* spot, GuString tok, - bool case_sensitive); - -PGF_INTERNAL_DECL bool -skip_space(GuString* psent, size_t* ppos); - -static int -cmp_item_prob(GuOrder* self, const void* a, const void* b) -{ - PgfItem *item1 = *((PgfItem **) a); - PgfItem *item2 = *((PgfItem **) b); - - prob_t prob1 = item1->inside_prob + item1->conts->outside_prob; - prob_t prob2 = item2->inside_prob + item2->conts->outside_prob; - - return (prob1>prob2) - (prob1ccat->fid < entry2->ccat->fid) - return -1; - else if (entry1->ccat->fid > entry2->ccat->fid) - return 1; - else if (entry1->lin_idx < entry2->lin_idx) - return -1; - else if (entry1->lin_idx > entry2->lin_idx) - return 1; - else - return 0; -} - -static GuOrder -pgf_production_idx_entry_order[1] = { { cmp_item_production_idx_entry } }; - -static inline PgfItemContss* -pgf_parsing_get_contss(PgfParseState* state, PgfCCat* cat, GuPool *pool) -{ - return gu_map_get(state->conts_map, cat, PgfItemContss*); -} - -static PgfItemConts* -pgf_parsing_get_conts(PgfParseState* state, - PgfCCat* ccat, size_t lin_idx, - GuPool *pool) -{ - gu_require(lin_idx < ccat->cnccat->n_lins); - - PgfItemContss* contss = - pgf_parsing_get_contss(state, ccat, pool); - if (contss == NULL) { - size_t n_lins = ccat->cnccat->n_lins; - contss = gu_new_seq(PgfItemConts*, n_lins, pool); - for (size_t i = 0; i < n_lins; i++) { - gu_seq_set(contss, PgfItemConts*, i, NULL); - } - gu_map_put(state->conts_map, ccat, PgfItemContss*, contss); - } - - PgfItemConts* conts = gu_seq_get(contss, PgfItemConts*, lin_idx); - if (!conts) { - conts = gu_new(PgfItemConts, pool); - conts->ccat = ccat; - conts->lin_idx = lin_idx; - conts->state = state; - conts->items = gu_new_buf(PgfItem*, pool); - conts->outside_prob = 0; - conts->ref_count = 0; - gu_seq_get(contss, PgfItemConts*, lin_idx) = conts; - } - return conts; -} - -static void -gu_ccat_fini(GuFinalizer* fin) -{ - PgfCCat* cat = gu_container(fin, PgfCCat, fin); - if (cat->prods != NULL) - gu_seq_free(cat->prods); -} - -static PgfCCat* -pgf_parsing_create_completed(PgfParsing* ps, PgfParseState* state, - PgfItemConts* conts, - prob_t viterbi_prob) -{ - PgfCCat* cat = gu_new_flex(ps->pool, PgfCCat, fin, 1); - cat->cnccat = conts->ccat->cnccat; - cat->lindefs = conts->ccat->lindefs; - cat->linrefs = conts->ccat->linrefs; - cat->viterbi_prob = viterbi_prob; - cat->fid = ps->max_fid++; - cat->chunk_count = (conts->ccat->fid == -5 || - conts->state->end_offset == state->end_offset); - cat->conts = conts; - cat->answers = NULL; - cat->prods = NULL; - cat->n_synprods = 0; - - gu_map_put(state->generated_cats, conts, PgfCCat*, cat); - - cat->fin[0].fn = gu_ccat_fini; - gu_pool_finally(ps->pool, cat->fin); - -#ifdef PGF_COUNTS_DEBUG - ps->ccat_full_count++; -#endif - - return cat; -} - -static PgfCCat* -pgf_parsing_get_completed(PgfParseState* state, PgfItemConts* conts) -{ - return gu_map_get(state->generated_cats, conts, PgfCCat*); -} - -static void -pgf_item_set_curr_symbol(PgfItem* item, GuPool* pool) -{ - GuVariantInfo i = gu_variant_open(item->prod); - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = i.data; - PgfCncFun* fun = papp->fun; - gu_assert(item->conts->lin_idx < fun->n_lins); - PgfSymbols* syms = fun->lins[item->conts->lin_idx]->syms; - gu_assert(item->sym_idx <= gu_seq_length(syms)); - if (item->sym_idx == gu_seq_length(syms)) { - item->curr_sym = gu_null_variant; - } else { - item->curr_sym = gu_seq_get(syms, PgfSymbol, item->sym_idx); - } - break; - } - case PGF_PRODUCTION_COERCE: { - gu_assert(item->sym_idx <= 1); - if (item->sym_idx == 1) { - item->curr_sym = gu_null_variant; - } else { - item->curr_sym = gu_new_variant_i(pool, PGF_SYMBOL_CAT, - PgfSymbolCat, - .d = 0, .r = item->conts->lin_idx); - } - break; - } - case PGF_PRODUCTION_EXTERN: { - PgfProductionExtern* pext = i.data; - - PgfSymbols* syms = pext->lins[item->conts->lin_idx]; - if (item->sym_idx == gu_seq_length(syms)) { - item->curr_sym = gu_null_variant; - } else { - item->curr_sym = gu_seq_get(syms, PgfSymbol, item->sym_idx); - } - break; - } - default: - gu_impossible(); - } -} - -static PgfItem* -pgf_new_item(PgfParsing* ps, PgfItemConts* conts, PgfProduction prod) -{ - PgfItem* item; - if (ps->free_item == NULL) - item = gu_new(PgfItem, ps->pool); - else { - item = ps->free_item; - ps->free_item = ps->free_item->next; - } - - GuVariantInfo pi = gu_variant_open(prod); - switch (pi.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = pi.data; - item->args = papp->args; - item->inside_prob = papp->fun->ep->prob; - - int n_args = gu_seq_length(item->args); - for (int i = 0; i < n_args; i++) { - PgfPArg *arg = gu_seq_index(item->args, PgfPArg, i); - item->inside_prob += arg->ccat->viterbi_prob; - } - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = pi.data; - item->args = gu_new_seq(PgfPArg, 1, ps->pool); - PgfPArg* parg = gu_seq_index(item->args, PgfPArg, 0); - parg->hypos = NULL; - parg->ccat = pcoerce->coerce; - item->inside_prob = pcoerce->coerce->viterbi_prob; - break; - } - case PGF_PRODUCTION_EXTERN: { - PgfProductionExtern* pext = pi.data; - item->args = gu_empty_seq(); - item->inside_prob = pext->ep->prob; - break; - } - default: - gu_impossible(); - } - item->conts = conts; - item->prod = prod; - item->curr_sym = gu_null_variant; - item->sym_idx = 0; - item->alt_idx = 0; - item->alt = 0; - - conts->ref_count++; - - pgf_item_set_curr_symbol(item, ps->pool); - -#ifdef PGF_COUNTS_DEBUG - ps->item_full_count++; - ps->item_real_count++; -#endif - - return item; -} - -static PgfItem* -pgf_item_copy(PgfItem* item, PgfParsing* ps) -{ - PgfItem* copy; - if (ps->free_item == NULL) - copy = gu_new(PgfItem, ps->pool); - else { - copy = ps->free_item; - ps->free_item = ps->free_item->next; - } - memcpy(copy, item, sizeof(PgfItem)); - -#ifdef PGF_COUNTS_DEBUG - ps->item_full_count++; - ps->item_real_count++; -#endif - - item->conts->ref_count++; - - return copy; -} - -static PgfItem* -pgf_item_update_arg(PgfItem* item, size_t d, PgfCCat *new_ccat, - PgfParsing *ps) -{ - PgfCCat *old_ccat = - gu_seq_index(item->args, PgfPArg, d)->ccat; - - PgfItem* new_item = pgf_item_copy(item, ps); - size_t nargs = gu_seq_length(item->args); - new_item->args = gu_new_seq(PgfPArg, nargs, ps->pool); - memcpy(gu_seq_data(new_item->args), gu_seq_data(item->args), - nargs * sizeof(PgfPArg)); - gu_seq_set(new_item->args, PgfPArg, d, - ((PgfPArg) { .hypos = NULL, .ccat = new_ccat })); - new_item->inside_prob += - new_ccat->viterbi_prob - old_ccat->viterbi_prob; - - return new_item; -} - -static void -pgf_item_advance(PgfItem* item, GuPool* pool) -{ - if (GU_LIKELY(item->alt == 0)) { - item->sym_idx++; - pgf_item_set_curr_symbol(item, pool); - } - else - item->alt_idx++; -} - -static void -pgf_item_free(PgfParsing* ps, PgfItem* item) -{ - PgfItemConts* conts = item->conts; - conts->ref_count--; - do { - if (conts->ref_count != 0) - break; - - conts = conts->ccat->conts; - } while (conts != NULL); - - if (conts == NULL) { - size_t n_items = gu_buf_length(item->conts->items); - for (size_t i = 0; i < n_items; i++) { - PgfItem* cont = gu_buf_get(item->conts->items, PgfItem*, i); - if (cont == NULL) - continue; - - pgf_item_free(ps, cont); - } - } - -#ifdef PGF_PARSER_DEBUG - memset(item, 0, sizeof(*item)); -#endif - item->next = ps->free_item; - ps->free_item = item; -#ifdef PGF_COUNTS_DEBUG - ps->item_real_count--; -#endif -} - -static void -pgf_result_predict(PgfParsing* ps, - PgfExprState* cont, PgfCCat* ccat, - prob_t outside_prob); - -static void -pgf_result_production(PgfParsing* ps, - PgfAnswers* answers, PgfProduction prod); - -static void -pgf_parsing_complete(PgfParsing* ps, PgfItem* item, PgfExprProb *ep); - -static void -pgf_parsing_push_production(PgfParsing* ps, PgfParseState* state, - PgfItemConts* conts, PgfProduction prod) -{ - PgfItem* item = - pgf_new_item(ps, conts, prod); - gu_buf_heap_push(state->agenda, pgf_item_prob_order, &item); -} - -static void -pgf_parsing_combine(PgfParsing* ps, - PgfParseState* before, PgfParseState* after, - PgfItem* cont, PgfCCat* cat, int lin_idx) -{ - PgfItem* item = NULL; - switch (gu_variant_tag(cont->curr_sym)) { - case PGF_SYMBOL_CAT: { - PgfSymbolCat* scat = gu_variant_data(cont->curr_sym); - item = pgf_item_update_arg(cont, scat->d, cat, ps); - break; - } - case PGF_SYMBOL_LIT: { - PgfSymbolLit* slit = gu_variant_data(cont->curr_sym); - item = pgf_item_update_arg(cont, slit->d, cat, ps); - break; - } - default: - gu_impossible(); - } - - pgf_item_advance(item, ps->pool); - gu_buf_heap_push(before->agenda, pgf_item_prob_order, &item); -} - -static PgfProduction -pgf_parsing_new_production(PgfItem* item, PgfExprProb *ep, GuPool *pool) -{ - GuVariantInfo i = gu_variant_open(item->prod); - PgfProduction prod = gu_null_variant; - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = i.data; - PgfProductionApply* new_papp = - gu_new_variant(PGF_PRODUCTION_APPLY, - PgfProductionApply, - &prod, pool); - new_papp->fun = papp->fun; - new_papp->args = item->args; - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* new_pcoerce = - gu_new_variant(PGF_PRODUCTION_COERCE, - PgfProductionCoerce, - &prod, pool); - PgfPArg* parg = gu_seq_index(item->args, PgfPArg, 0); - new_pcoerce->coerce = parg->ccat; - break; - } - case PGF_PRODUCTION_EXTERN: { - prod = item->prod; - break; - } - default: - gu_impossible(); - } - -#ifdef PGF_COUNTS_DEBUG - ps->prod_full_count++; -#endif - - return prod; -} - -static void -pgf_parsing_complete(PgfParsing* ps, PgfItem* item, PgfExprProb *ep) -{ - if (ps->oracle && ps->oracle->complete) { - // ask the oracle whether to complete - if (!ps->oracle->complete(ps->oracle, - item->conts->ccat->cnccat->abscat->name, - item->conts->ccat->cnccat->labels[item->conts->lin_idx], - ps->before->end_offset)) - return; - } - - PgfProduction prod = - pgf_parsing_new_production(item, ep, ps->pool); - - PgfCCat* tmp_ccat = pgf_parsing_get_completed(ps->before, item->conts); - PgfCCat* ccat = tmp_ccat; - if (ccat == NULL) { - ccat = pgf_parsing_create_completed(ps, ps->before, item->conts, item->inside_prob); - } - - if (ccat->prods == NULL || ccat->n_synprods >= gu_seq_length(ccat->prods)) { - ccat->prods = gu_realloc_seq(ccat->prods, PgfProduction, ccat->n_synprods+1); - } - gu_seq_set(ccat->prods, PgfProduction, ccat->n_synprods++, prod); - -#ifdef PGF_PARSER_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - if (tmp_ccat == NULL) { - gu_printf(out, err, "["); - pgf_print_range(item->conts->state, ps->before, out, err); - gu_puts("; ", out, err); - pgf_print_fid(item->conts->ccat->fid, out, err); - gu_printf(out, err, "; %d; ", - item->conts->lin_idx); - pgf_print_fid(ccat->fid, out, err); - gu_puts("] ", out, err); - pgf_print_fid(ccat->fid, out, err); - gu_printf(out, err, ".chunk_count=%d\n", ccat->chunk_count); - } - pgf_print_production(ccat->fid, prod, out, err); - gu_pool_free(tmp_pool); -#endif - - if (item->conts->ccat->fid == -5) { - if (ps->before->end_offset == strlen(ps->sentence)) { - PgfPArg* parg = gu_seq_index(item->args, PgfPArg, 0); - pgf_result_predict(ps, NULL, parg->ccat, 0); - } - return; - } else { - size_t i = gu_seq_length(item->args); - while (i > 0) { - PgfPArg* parg = gu_seq_index(item->args, PgfPArg, i-1); - - if (pgf_parsing_get_completed(ps->before, parg->ccat->conts) != NULL) { - parg->ccat->chunk_count++; - -#ifdef PGF_PARSER_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - pgf_print_fid(parg->ccat->fid, out, err); - gu_printf(out, err, ".chunk_count=%d\n", parg->ccat->chunk_count); - gu_pool_free(tmp_pool); -#endif - } - - i--; - } - } - - if (tmp_ccat != NULL) { - PgfItemContss* contss = - pgf_parsing_get_contss(ps->before, ccat, ps->pool); - if (contss != NULL) { - size_t n_contss = gu_seq_length(contss); - for (size_t i = 0; i < n_contss; i++) { - PgfItemConts* conts2 = gu_seq_get(contss, PgfItemConts*, i); - /* If there are continuations for - * linearization index i, then (cat, i) has - * already been predicted. Add the new - * production immediately to the agenda, - * i.e. process it. */ - if (conts2) { - pgf_parsing_push_production(ps, ps->before, conts2, prod); - } - } - } - - // The category has already been created. If it has also been - // predicted already, then process a new item for this production. - PgfParseState* state = ps->after; - while (state != NULL) { - PgfItemContss* contss = - pgf_parsing_get_contss(state, ccat, ps->pool); - if (contss != NULL) { - size_t n_contss = gu_seq_length(contss); - for (size_t i = 0; i < n_contss; i++) { - PgfItemConts* conts2 = gu_seq_get(contss, PgfItemConts*, i); - /* If there are continuations for - * linearization index i, then (cat, i) has - * already been predicted. Add the new - * production immediately to the agenda, - * i.e. process it. */ - if (conts2) { - pgf_parsing_push_production(ps, state, conts2, prod); - } - } - } - - state = state->next; - } - - if (ccat->answers != NULL) { - pgf_result_production(ps, ccat->answers, prod); - } - } else { - size_t n_conts = gu_buf_length(item->conts->items); - for (size_t i = 0; i < n_conts; i++) { - PgfItem* cont = gu_buf_get(item->conts->items, PgfItem*, i); - pgf_parsing_combine(ps, ps->before, ps->after, cont, ccat, item->conts->lin_idx); - } - } -} - -PGF_INTERNAL_DECL int -pgf_symbols_cmp(PgfCohortSpot* spot, - PgfSymbols* syms, size_t* sym_idx, - bool case_sensitive); - -static void -pgf_parsing_lookahead(PgfParsing *ps, PgfParseState* state, - int i, int j, ptrdiff_t min, ptrdiff_t max) -{ - // This is a variation of a binary search algorithm which - // can retrieve all prefixes of a string with minimal - // comparisons, i.e. there is no need to lookup every - // prefix separately. - - while (i <= j) { - int k = (i+j) / 2; - PgfSequence* seq = gu_seq_index(ps->concr->sequences, PgfSequence, k); - - PgfCohortSpot start = {0, ps->sentence + state->end_offset}; - PgfCohortSpot current = start; - size_t sym_idx = 0; - int cmp = pgf_symbols_cmp(¤t, seq->syms, &sym_idx, ps->case_sensitive); - if (cmp < 0) { - j = k-1; - } else if (cmp > 0) { - ptrdiff_t len = current.ptr - start.ptr; - - if (min <= len) - pgf_parsing_lookahead(ps, state, i, k-1, min, len); - - if (len+1 <= max) - pgf_parsing_lookahead(ps, state, k+1, j, len+1, max); - - break; - } else { - ptrdiff_t len = current.ptr - start.ptr; - - if (min <= len-1) - pgf_parsing_lookahead(ps, state, i, k-1, min, len-1); - - if (seq->idx != NULL) { - PgfLexiconIdxEntry* entry = gu_buf_extend(state->lexicon_idx); - entry->idx = seq->idx; - entry->offset = (size_t) (current.ptr - ps->sentence); - entry->sym_idx = sym_idx; - } - - if (len+1 <= max) - pgf_parsing_lookahead(ps, state, k+1, j, len+1, max); - - break; - } - } -} - -static PgfParseState* -pgf_new_parse_state(PgfParsing* ps, size_t start_offset, - BIND_TYPE bind_type, - prob_t viterbi_prob) -{ - PgfParseState** pstate; - if (ps->before == NULL && start_offset == 0) - pstate = &ps->before; - else { - if (bind_type != BIND_NONE) { - if (ps->before->start_offset == start_offset && - ps->before->end_offset == start_offset && - !ps->before->needs_bind) - return ps->before; - } else { - if (ps->before->start_offset == start_offset) - return ps->before; - } - - pstate = &ps->after; - while (*pstate != NULL) { - if (bind_type != BIND_NONE) { - if ((*pstate)->start_offset == start_offset && - (*pstate)->end_offset == start_offset && - !(*pstate)->needs_bind) - return *pstate; - } else { - if ((*pstate)->start_offset == start_offset) - return *pstate; - } - if ((*pstate)->start_offset > start_offset) - break; - pstate = &(*pstate)->next; - } - } - - size_t end_offset = start_offset; - GuString current = ps->sentence + end_offset; - size_t pos = 0; - while (skip_space(¤t, &pos)) { - end_offset++; - } - - if (bind_type == BIND_HARD && start_offset != end_offset) - return NULL; - - PgfParseState* state = gu_new(PgfParseState, ps->pool); - state->next = *pstate; - state->agenda = gu_new_buf(PgfItem*, ps->pool); - state->generated_cats = gu_new_addr_map(PgfItemConts*, PgfCCat*, &gu_null_struct, ps->pool); - state->conts_map = gu_new_addr_map(PgfCCat*, PgfItemContss*, &gu_null_struct, ps->pool); - state->chunks_map = NULL; - state->needs_bind = (bind_type == BIND_NONE) && - (start_offset == end_offset); - state->start_offset = start_offset; - state->end_offset = end_offset; - state->viterbi_prob = viterbi_prob; - state->lexicon_idx = - gu_new_buf(PgfLexiconIdxEntry, ps->pool); - - if (ps->before == NULL && start_offset == 0) - state->needs_bind = false; - - if (gu_seq_length(ps->concr->sequences) > 0) { - // Add epsilon lexical rules to the bottom up index - PgfSequence* seq = gu_seq_index(ps->concr->sequences, PgfSequence, 0); - if (gu_seq_length(seq->syms) == 0 && seq->idx != NULL) { - PgfLexiconIdxEntry* entry = gu_buf_extend(state->lexicon_idx); - entry->idx = seq->idx; - entry->offset = state->start_offset; - entry->sym_idx= 0; - } - - // Add non-epsilon lexical rules to the bottom up index - if (!state->needs_bind) { - pgf_parsing_lookahead(ps, state, - 0, gu_seq_length(ps->concr->sequences)-1, - 1, strlen(ps->sentence)-state->end_offset); - } - } - - *pstate = state; - - return state; -} - -static void -pgf_parsing_add_transition(PgfParsing* ps, PgfToken tok, PgfItem* item) -{ - PgfCohortSpot current = {0, ps->sentence + ps->before->end_offset}; - - if (ps->prefix != NULL && *current.ptr == 0) { - if (gu_string_is_prefix(ps->prefix, tok)) { - PgfProductionApply* papp = gu_variant_data(item->prod); - - ps->tp = gu_new(PgfTokenProb, ps->out_pool); - ps->tp->tok = tok; - ps->tp->cat = item->conts->ccat->cnccat->abscat->name; - ps->tp->fun = papp->fun->absfun->name; - ps->tp->prob = item->inside_prob + item->conts->outside_prob; - } - } else { - if (!ps->before->needs_bind && cmp_string(¤t, tok, ps->case_sensitive) == 0) { - PgfParseState* state = - pgf_new_parse_state(ps, (current.ptr - ps->sentence), - BIND_NONE, - item->inside_prob+item->conts->outside_prob); - gu_buf_heap_push(state->agenda, pgf_item_prob_order, &item); - } else { - pgf_item_free(ps, item); - } - } -} - -static void -pgf_parsing_predict_lexeme(PgfParsing* ps, PgfItemConts* conts, - PgfProductionIdxEntry* entry, - size_t offset, size_t sym_idx) -{ - GuVariantInfo i = { PGF_PRODUCTION_APPLY, entry->papp }; - PgfProduction prod = gu_variant_close(i); - PgfItem* item = - pgf_new_item(ps, conts, prod); - PgfSymbols* syms = entry->papp->fun->lins[conts->lin_idx]->syms; - item->sym_idx = sym_idx; - pgf_item_set_curr_symbol(item, ps->pool); - prob_t prob = item->inside_prob+item->conts->outside_prob; - PgfParseState* state = - pgf_new_parse_state(ps, offset, BIND_NONE, prob); - if (state->viterbi_prob > prob) { - state->viterbi_prob = prob; - } - gu_buf_heap_push(state->agenda, pgf_item_prob_order, &item); -} - -static void -pgf_parsing_td_predict(PgfParsing* ps, - PgfItem* item, PgfCCat* ccat, size_t lin_idx) -{ - PgfItemConts* conts = - pgf_parsing_get_conts(ps->before, ccat, lin_idx, ps->pool); - gu_buf_push(conts->items, PgfItem*, item); - - if (gu_buf_length(conts->items) == 1) { - /* First time we encounter this linearization - * of this category at the current position, - * so predict it. */ - - if (ps->oracle != NULL && ps->oracle->predict) { - // if there is an oracle ask him if this prediction is appropriate - if (!ps->oracle->predict(ps->oracle, - ccat->cnccat->abscat->name, - ccat->cnccat->labels[lin_idx], - ps->before->end_offset)) - return; - } - - conts->outside_prob = - item->inside_prob-conts->ccat->viterbi_prob+ - item->conts->outside_prob; - - if (ps->prefix != NULL) { - // We do completion: - // - top-down prediction for both syntactic and lexical rules - size_t n_prods; - if (ccat->fid < ps->concr->total_cats) // in grammar - n_prods = gu_seq_length(ccat->prods); - else - n_prods = ccat->n_synprods; - for (size_t i = 0; i < n_prods; i++) { - PgfProduction prod = - gu_seq_get(ccat->prods, PgfProduction, i); - pgf_parsing_push_production(ps, ps->before, conts, prod); - } - } else { - // Top-down prediction for syntactic rules - for (size_t i = 0; i < ccat->n_synprods; i++) { - PgfProduction prod = - gu_seq_get(ccat->prods, PgfProduction, i); - pgf_parsing_push_production(ps, ps->before, conts, prod); - } - - // Bottom-up prediction for lexical and epsilon rules - size_t n_idcs = gu_buf_length(ps->before->lexicon_idx); - for (size_t i = 0; i < n_idcs; i++) { - PgfLexiconIdxEntry* lentry = - gu_buf_index(ps->before->lexicon_idx, PgfLexiconIdxEntry, i); - - PgfProductionIdxEntry key; - key.ccat = ccat; - key.lin_idx = lin_idx; - key.papp = NULL; - PgfProductionIdxEntry* value = - gu_seq_binsearch(gu_buf_data_seq(lentry->idx), - pgf_production_idx_entry_order, - PgfProductionIdxEntry, &key); - - if (value != NULL) { - pgf_parsing_predict_lexeme(ps, conts, value, lentry->offset, lentry->sym_idx); - - PgfProductionIdxEntry* start = - gu_buf_data(lentry->idx); - PgfProductionIdxEntry* end = - start + gu_buf_length(lentry->idx)-1; - - PgfProductionIdxEntry* left = value-1; - while (left >= start && - value->ccat->fid == left->ccat->fid && - value->lin_idx == left->lin_idx) { - pgf_parsing_predict_lexeme(ps, conts, left, lentry->offset, lentry->sym_idx); - left--; - } - - PgfProductionIdxEntry* right = value+1; - while (right <= end && - value->ccat->fid == right->ccat->fid && - value->lin_idx == right->lin_idx) { - pgf_parsing_predict_lexeme(ps, conts, right, lentry->offset, lentry->sym_idx); - right++; - } - } - } - } - } - - /* If the category has already been completed, combine. */ - PgfCCat* completed = - pgf_parsing_get_completed(ps->before, conts); - if (completed) { - pgf_parsing_combine(ps, ps->before, ps->after, item, completed, lin_idx); - } - - PgfParseState* state = ps->after; - while (state != NULL) { - PgfCCat* completed = - pgf_parsing_get_completed(state, conts); - if (completed) { - pgf_parsing_combine(ps, state, state->next, item, completed, lin_idx); - } - - state = state->next; - } -} - -static void -pgf_parsing_symbol(PgfParsing* ps, PgfItem* item, PgfSymbol sym); - -static void -pgf_parsing_pre(PgfParsing* ps, PgfItem* item, PgfSymbols* syms) -{ - if (item->alt_idx < gu_seq_length(syms)) { - PgfSymbol sym = gu_seq_get(syms, PgfSymbol, item->alt_idx); - pgf_parsing_symbol(ps, item, sym); - } else { - item->alt = 0; - pgf_item_advance(item, ps->pool); - gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item); - } -} - -static void -pgf_parsing_symbol(PgfParsing* ps, PgfItem* item, PgfSymbol sym) -{ - switch (gu_variant_tag(sym)) { - case PGF_SYMBOL_CAT: { - PgfSymbolCat* scat = gu_variant_data(sym); - PgfPArg* parg = gu_seq_index(item->args, PgfPArg, scat->d); - - if (parg->ccat->prods == NULL) { - // empty category - pgf_item_free(ps, item); - return; - } - - pgf_parsing_td_predict(ps, item, parg->ccat, scat->r); - break; - } - case PGF_SYMBOL_KS: { - PgfSymbolKS* sks = gu_variant_data(sym); - pgf_item_advance(item, ps->pool); - pgf_parsing_add_transition(ps, sks->token, item); - break; - } - case PGF_SYMBOL_KP: { - PgfSymbolKP* skp = gu_variant_data(sym); - - if (item->alt == 0) { - PgfItem* new_item; - - new_item = pgf_item_copy(item, ps); - new_item->alt = 1; - new_item->alt_idx = 0; - pgf_parsing_pre(ps, new_item, skp->default_form); - - for (size_t i = 0; i < skp->n_forms; i++) { - PgfSymbols* syms = skp->forms[i].form; - PgfSymbols* syms2 = skp->default_form; - bool skip = false; /*pgf_tokens_equal(toks, toks2); - for (size_t j = 0; j < i; j++) { - PgfTokens* toks2 = skp->forms[j].form; - skip |= pgf_tokens_equal(toks, toks2); - }*/ - if (!skip) { - new_item = pgf_item_copy(item, ps); - new_item->alt = i+2; - new_item->alt_idx = 0; - pgf_parsing_pre(ps, new_item, syms); - } - } - } else { - PgfSymbols* syms = - (item->alt == 1) ? skp->default_form : - skp->forms[item->alt-2].form; - pgf_parsing_pre(ps, item, syms); - } - break; - } - case PGF_SYMBOL_LIT: { - PgfSymbolLit* slit = gu_variant_data(sym); - PgfPArg* parg = gu_seq_index(item->args, PgfPArg, slit->d); - - if (parg->ccat->fid >= ps->concr->total_cats) { - pgf_parsing_td_predict(ps, item, parg->ccat, slit->r); - } - else { - PgfItemConts* conts = - pgf_parsing_get_conts(ps->before, - parg->ccat, slit->r, - ps->pool); - gu_buf_push(conts->items, PgfItem*, item); - - if (gu_buf_length(conts->items) == 1) { - /* This is the first time when we encounter this - * literal category so we must call the callback */ - - bool match = false; - if (!ps->before->needs_bind) { - size_t start = ps->before->end_offset; - size_t offset = start; - PgfExprProb *ep = NULL; - - if (ps->oracle != NULL && ps->oracle->literal) { - ep = ps->oracle->literal(ps->oracle, - parg->ccat->cnccat->abscat->name, - parg->ccat->cnccat->labels[slit->r], - &offset, - ps->out_pool); - } else { - PgfLiteralCallback* callback = - gu_map_get(ps->callbacks, - parg->ccat->cnccat, - PgfLiteralCallback*); - - if (callback != NULL) { - ep = callback->match(callback, ps->concr, - parg->ccat->cnccat->labels[slit->r], - ps->sentence, &offset, - ps->out_pool); - } - } - - if (ep != NULL) { - PgfSymbols* syms = - pgf_collect_extern_tok(ps, start, offset); - - size_t n_lins = conts->ccat->cnccat->n_lins; - - PgfProduction prod; - PgfProductionExtern* pext = - gu_new_flex_variant(PGF_PRODUCTION_EXTERN, - PgfProductionExtern, - lins, n_lins, - &prod, ps->pool); - pext->ep = ep; - pext->n_lins = n_lins; - - for (size_t i = 0; i < n_lins; i++) { - pext->lins[i] = NULL; - } - pext->lins[conts->lin_idx] = syms; - - PgfItem* item = - pgf_new_item(ps, conts, prod); - item->curr_sym = gu_null_variant; - item->sym_idx = gu_seq_length(syms); - PgfParseState* state = - pgf_new_parse_state(ps, offset, BIND_NONE, - item->inside_prob+item->conts->outside_prob); - gu_buf_heap_push(state->agenda, pgf_item_prob_order, &item); - match = true; - } - } - - if (!match) { - pgf_item_free(ps, item); - } - } else { - /* If it has already been completed, combine. */ - - PgfCCat* completed = - pgf_parsing_get_completed(ps->before, conts); - if (completed) { - pgf_parsing_combine(ps, ps->before, ps->after, item, completed, slit->r); - } - - PgfParseState* state = ps->after; - while (state != NULL) { - PgfCCat* completed = - pgf_parsing_get_completed(state, conts); - if (completed) { - pgf_parsing_combine(ps, state, state->next, item, completed, slit->r); - } - - state = state->next; - } - } - } - break; - } - case PGF_SYMBOL_VAR: - // XXX TODO proper support - break; - case PGF_SYMBOL_NE: { - // Nothing can match with a non-existant token - pgf_item_free(ps, item); - break; - } - case PGF_SYMBOL_BIND: { - if (ps->before->start_offset == ps->before->end_offset && - ps->before->needs_bind) { - PgfParseState* state = - pgf_new_parse_state(ps, ps->before->end_offset, BIND_HARD, - item->inside_prob+item->conts->outside_prob); - if (state != NULL) { - pgf_item_advance(item, ps->pool); - gu_buf_heap_push(state->agenda, pgf_item_prob_order, &item); - } else { - pgf_item_free(ps, item); - } - } else { - pgf_item_free(ps, item); - } - break; - } - case PGF_SYMBOL_SOFT_BIND: - case PGF_SYMBOL_SOFT_SPACE: { - if (ps->before->start_offset == ps->before->end_offset) { - if (ps->before->needs_bind) { - PgfParseState* state = - pgf_new_parse_state(ps, ps->before->end_offset, BIND_HARD, - item->inside_prob+item->conts->outside_prob); - if (state != NULL) { - pgf_item_advance(item, ps->pool); - gu_buf_heap_push(state->agenda, pgf_item_prob_order, &item); - } else { - pgf_item_free(ps, item); - } - } else { - pgf_item_free(ps, item); - } - } else { - pgf_item_advance(item, ps->pool); - gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item); - } - break; - } - case PGF_SYMBOL_CAPIT: - case PGF_SYMBOL_ALL_CAPIT: { - printf("PGF_SYMBOL_CAPIT\n"); - pgf_item_advance(item, ps->pool); - pgf_parsing_symbol(ps, item, item->curr_sym); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_parsing_set_default_factors(PgfParsing* ps, PgfAbstr* abstr) -{ - PgfFlag* flag; - - flag = - gu_seq_binsearch(abstr->aflags, pgf_flag_order, PgfFlag, "heuristic_search_factor"); - if (flag != NULL) { - GuVariantInfo pi = gu_variant_open(flag->value); - gu_assert (pi.tag == PGF_LITERAL_FLT); - ps->heuristic_factor = ((PgfLiteralFlt*) pi.data)->val; - } -} - -PGF_INTERNAL_DECL bool -pgf_is_case_sensitive(PgfConcr* concr); - -static PgfParsing* -pgf_new_parsing(PgfConcr* concr, GuString sentence, - PgfCallbacksMap* callbacks, PgfOracleCallback* oracle, - GuPool* pool, GuPool* out_pool) -{ - PgfParsing* ps = gu_new(PgfParsing, pool); - ps->concr = concr; - ps->pool = pool; - ps->out_pool = out_pool; - ps->sentence = sentence; - ps->case_sensitive = pgf_is_case_sensitive(concr); - ps->expr_queue = gu_new_buf(PgfExprState*, pool); - ps->max_fid = concr->total_cats; - ps->before = NULL; - ps->after = NULL; -#ifdef PGF_COUNTS_DEBUG - ps->item_full_count = 0; - ps->item_real_count = 0; - ps->ccat_full_count = 0; - ps->prod_full_count = 0; -#endif - ps->prefix = NULL; - ps->tp = NULL; - ps->free_item = NULL; - ps->heuristic_factor = 0; - ps->callbacks = callbacks; - ps->oracle = oracle; - - pgf_parsing_set_default_factors(ps, concr->abstr); - - return ps; -} - -#ifdef PGF_COUNTS_DEBUG -static void -pgf_parsing_print_counts(PgfParsing* ps) -{ - printf("%d\t%d\t%d\t%d\n", - ps->item_full_count, - ps->item_real_count, - ps->ccat_full_count, - ps->prod_full_count); -} -#endif - -static int -cmp_expr_state(GuOrder* self, const void* a, const void* b) -{ - PgfExprState *s1 = *((PgfExprState **) a); - PgfExprState *s2 = *((PgfExprState **) b); - - prob_t prob1 = s1->answers->outside_prob+s1->ep.prob; - prob_t prob2 = s2->answers->outside_prob+s2->ep.prob; - - return (prob1>prob2) - (prob1pool); - st->answers = answers; - st->ep = *papp->fun->ep; - st->args = papp->args; - st->arg_idx = 0; - - size_t n_args = gu_seq_length(st->args); - for (size_t k = 0; k < n_args; k++) { - PgfPArg* parg = gu_seq_index(st->args, PgfPArg, k); - st->ep.prob += parg->ccat->viterbi_prob; - } - - gu_buf_heap_push(ps->expr_queue, &pgf_expr_state_order, &st); - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = pi.data; - - PgfCCat* ccat = pcoerce->coerce; - - PgfExprState *st = gu_new(PgfExprState, ps->pool); - st->answers = answers; - st->ep.expr = gu_null_variant; - st->ep.prob = ccat->viterbi_prob; - st->args = gu_empty_seq(); - st->arg_idx = 0; - - pgf_result_predict(ps, st, ccat, answers->outside_prob); - break; - } - case PGF_PRODUCTION_EXTERN: { - PgfProductionExtern* pext = pi.data; - - PgfExprState *st = gu_new(PgfExprState, ps->pool); - st->answers = answers; - st->ep = *pext->ep; - st->args = gu_empty_seq(); - st->arg_idx = 0; - - gu_buf_heap_push(ps->expr_queue, &pgf_expr_state_order, &st); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_result_predict(PgfParsing* ps, - PgfExprState* cont, PgfCCat* ccat, - prob_t outside_prob) -{ - PgfAnswers* answers = ccat->answers; - if (answers == NULL) { - answers = gu_new(PgfAnswers, ps->pool); - answers->conts = gu_new_buf(PgfExprState*, ps->pool); - answers->exprs = gu_new_buf(PgfExprProb*, ps->pool); - answers->outside_prob = outside_prob; - answers->ccat = ccat; - - ccat->answers = answers; - } - - gu_buf_push(answers->conts, PgfExprState*, cont); - - if (gu_buf_length(answers->conts) == 1) { - if (ccat->prods == NULL) - return; - - // Generation - for (size_t i = 0; i < ccat->n_synprods; i++) { - PgfProduction prod = - gu_seq_get(ccat->prods, PgfProduction, i); - pgf_result_production(ps, answers, prod); - } - } else { - size_t n_exprs = gu_buf_length(answers->exprs); - for (size_t i = 0; i < n_exprs; i++) { - PgfExprProb* ep = gu_buf_get(answers->exprs, PgfExprProb*, i); - - PgfExprState* st = gu_new(PgfExprState, ps->pool); - st->answers = cont->answers; - st->ep.expr = - gu_variant_is_null(cont->ep.expr) ? - ep->expr : - gu_new_variant_i(ps->out_pool, - PGF_EXPR_APP, PgfExprApp, - .fun = cont->ep.expr, - .arg = ep->expr); - st->ep.prob = cont->ep.prob+ep->prob; - - if (cont->arg_idx == PGF_EXPR_CHUNK_STATE) { - st->state = gu_map_get(cont->state->chunks_map, ccat, PgfParseState*); - st->arg_idx = PGF_EXPR_CHUNK_STATE; - } else { - st->args = cont->args; - st->arg_idx = cont->arg_idx+1; - } - - gu_buf_heap_push(ps->expr_queue, &pgf_expr_state_order, &st); - } - } -} - -static bool -pgf_parse_result_is_new(PgfExprState* st) -{ - // we have found a complete abstract tree but we must check - // whether this is not a duplication. Since the trees are - // generated in probability order it is enough to check only - // trees with the same probability. - - size_t i = gu_buf_length(st->answers->exprs); - while (i-- > 0) { - PgfExprProb* ep = - gu_buf_get(st->answers->exprs, PgfExprProb*, i); - - if (ep->prob < st->ep.prob) - break; - - if (pgf_expr_eq(ep->expr, st->ep.expr)) - return false; - } - - return true; -} - -static PgfParsing* -pgf_parsing_init(PgfConcr* concr, PgfCId cat, - GuString sentence, - double heuristic_factor, - PgfCallbacksMap* callbacks, PgfOracleCallback* oracle, - GuExn* err, GuPool* pool, GuPool* out_pool) -{ - PgfCncCat* cnccat = - gu_map_get(concr->cnccats, cat, PgfCncCat*); - if (!cnccat) { - GuExnData* exn = gu_raise(err, PgfExn); - exn->data = "Unknown start category"; - return NULL; - } - - PgfParsing* ps = - pgf_new_parsing(concr, sentence, callbacks, oracle, pool, out_pool); - - if (heuristic_factor >= 0) { - ps->heuristic_factor = heuristic_factor; - } - - PgfParseState* state = - pgf_new_parse_state(ps, 0, BIND_SOFT, 0); - - int fidString = -1; - PgfCCat* start_ccat = gu_new(PgfCCat, ps->pool); - start_ccat->cnccat = gu_map_get(concr->ccats, &fidString, PgfCCat*)->cnccat; - start_ccat->lindefs = NULL; - start_ccat->linrefs = NULL; - start_ccat->viterbi_prob = 0; - start_ccat->fid = -5; - start_ccat->chunk_count = 1; - start_ccat->conts = NULL; - start_ccat->answers = NULL; - start_ccat->prods = NULL; - start_ccat->n_synprods = 0; - - gu_assert(start_ccat->cnccat != NULL); - -#ifdef PGF_COUNTS_DEBUG - ps->ccat_full_count++; -#endif - - PgfItemConts* conts = - pgf_parsing_get_conts(state, start_ccat, 0, ps->pool); - gu_buf_push(conts->items, PgfItem*, NULL); - - size_t n_ccats = gu_seq_length(cnccat->cats); - for (size_t i = 0; i < n_ccats; i++) { - PgfCCat* ccat = gu_seq_get(cnccat->cats, PgfCCat*, i); - if (ccat != NULL) { - PgfPArgs* args = gu_new_seq(PgfPArg, 1, ps->pool); - gu_seq_set(args, PgfPArg, 0, ((PgfPArg) { .hypos = NULL, .ccat = ccat })); - - size_t n_funs = gu_seq_length(ccat->linrefs); - for (size_t j = 0; j < n_funs; j++) { - PgfProduction prod = gu_null_variant; - PgfProductionApply* new_papp = - gu_new_variant(PGF_PRODUCTION_APPLY, - PgfProductionApply, - &prod, pool); - new_papp->fun = gu_seq_get(ccat->linrefs, PgfCncFun*, j); - new_papp->args = args; - - PgfItem* item = gu_new(PgfItem, ps->pool); - item->args = args; - item->inside_prob = 0; - item->conts = conts; - item->prod = prod; - item->curr_sym = gu_null_variant; - item->sym_idx = 0; - item->alt_idx = 0; - item->alt = 0; - - conts->ref_count++; - - pgf_item_set_curr_symbol(item, ps->pool); - -#ifdef PGF_COUNTS_DEBUG - ps->item_full_count++; - ps->item_real_count++; -#endif - - gu_buf_heap_push(ps->before->agenda, pgf_item_prob_order, &item); - } - } - } - - return ps; -} - -static bool -pgf_parsing_proceed(PgfParsing* ps) -{ - bool has_progress = false; - - prob_t best_prob = INFINITY; - if (gu_buf_length(ps->expr_queue) > 0) { - best_prob = gu_buf_get(ps->expr_queue, PgfExprState*, 0)->ep.prob; - } - - PgfParseState* st = ps->before; - PgfParseState* last = NULL; - prob_t delta_prob = 0; - while (st != NULL) { - if (gu_buf_length(st->agenda) > 0) { - if (last != NULL) { - delta_prob += - (last->viterbi_prob-st->viterbi_prob) * - ps->heuristic_factor; - } - last = st; - - PgfItem* item = gu_buf_get(st->agenda, PgfItem*, 0); - prob_t item_prob = - item->inside_prob+item->conts->outside_prob+delta_prob; - if (item_prob < best_prob) { - best_prob = item_prob; - - while (st != ps->before) { - PgfParseState* tmp = ps->before->next; - ps->before->next = ps->after; - ps->after = ps->before; - ps->before = tmp; - } - - has_progress = true; - } - } - - st = st->next; - } - - if (has_progress) { - PgfItem* item; - gu_buf_heap_pop(ps->before->agenda, pgf_item_prob_order, &item); - -#ifdef PGF_PARSER_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - pgf_print_item(item, ps->before, out, err, tmp_pool); - gu_pool_free(tmp_pool); -#endif - - if (gu_variant_is_null(item->curr_sym)) { - pgf_parsing_complete(ps, item, NULL); - pgf_item_free(ps, item); - } else { - pgf_parsing_symbol(ps, item, item->curr_sym); - } - } - - while (ps->after != NULL) { - PgfParseState* tmp = ps->after->next; - ps->after->next = ps->before; - ps->before = ps->after; - ps->after = tmp; - } - - return has_progress; -} - -typedef struct { - GuMapItor fn; - PgfParsing* ps; - PgfExprState* st; -} PgfChunkCatItor; - -static void -pgf_iter_chunk_cat(GuMapItor* fn, - const void* key, void* value, - GuExn *err) -{ - PgfChunkCatItor* clo = (PgfChunkCatItor*) fn; - PgfCCat* ccat = (PgfCCat*) key; - - prob_t outside_prob = - clo->st->answers->outside_prob+ - clo->st->ep.prob+ - ccat->cnccat->abscat->prob; - - pgf_result_predict(clo->ps, clo->st, ccat, outside_prob); -} - -static PgfExprProb* -pgf_parse_result_next(PgfParsing* ps) -{ - for (;;) { - while (pgf_parsing_proceed(ps)); - - if (gu_buf_length(ps->expr_queue) == 0) - break; - - PgfExprState* st; - gu_buf_heap_pop(ps->expr_queue, &pgf_expr_state_order, &st); - -#ifdef PGF_PARSER_DEBUG -#ifdef PGF_RESULT_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - pgf_print_expr_state0(st, out, err, tmp_pool); - gu_pool_free(tmp_pool); -#endif -#endif - - if (st->arg_idx == PGF_EXPR_CHUNK_STATE) { - // here we look for chunks - - if (st->state == ps->before) { - if (pgf_parse_result_is_new(st)) { - gu_buf_push(st->answers->exprs, PgfExprProb*, &st->ep); - return &st->ep; - } - } else { - PgfChunkCatItor clo = { { pgf_iter_chunk_cat }, ps, st }; - if (st->state->chunks_map != NULL) - gu_map_iter(st->state->chunks_map, &clo.fn, NULL); - } - } else if (st->arg_idx < gu_seq_length(st->args)) { - // here we handle normal unfinished expression states - - PgfCCat* ccat = - gu_seq_index(st->args, PgfPArg, st->arg_idx)->ccat; - - if (ccat->fid < ps->concr->total_cats) { - // when argument was not used by the parser, - // we create a metavariable - PgfExpr meta = gu_new_variant_i(ps->out_pool, - PGF_EXPR_META, PgfExprMeta, - .id = 0); - - st->ep.expr = - gu_variant_is_null(st->ep.expr) ? - meta : - gu_new_variant_i(ps->out_pool, - PGF_EXPR_APP, PgfExprApp, - .fun = st->ep.expr, - .arg = meta); - st->arg_idx++; - gu_buf_heap_push(ps->expr_queue, &pgf_expr_state_order, &st); - } else { - prob_t outside_prob = - st->answers->outside_prob+ - st->ep.prob-ccat->viterbi_prob; - pgf_result_predict(ps, st, ccat, outside_prob); - } - } else if (pgf_parse_result_is_new(st)) { - gu_buf_push(st->answers->exprs, PgfExprProb*, &st->ep); - - size_t n_conts = gu_buf_length(st->answers->conts); - for (size_t i = 0; i < n_conts; i++) { - PgfExprState* st2 = gu_buf_get(st->answers->conts, PgfExprState*, i); - - if (st2 == NULL) { - return &st->ep; - } - - PgfExprState* st3 = gu_new(PgfExprState, ps->pool); - st3->answers = st2->answers; - st3->ep.expr = - gu_variant_is_null(st2->ep.expr) ? - st->ep.expr : - gu_new_variant_i(ps->out_pool, - PGF_EXPR_APP, PgfExprApp, - .fun = st2->ep.expr, - .arg = st->ep.expr); - if (st2->arg_idx == PGF_EXPR_CHUNK_STATE) { - st3->ep.prob = st2->ep.prob+st->answers->ccat->cnccat->abscat->prob + - st->ep.prob; - st3->state = gu_map_get(st2->state->chunks_map, st->answers->ccat, PgfParseState*); - st3->arg_idx = PGF_EXPR_CHUNK_STATE; - } else { - st3->ep.prob = st2->ep.prob-st->answers->ccat->viterbi_prob + - st->ep.prob; - st3->args = st2->args; - st3->arg_idx = st2->arg_idx+1; - } - - gu_buf_heap_push(ps->expr_queue, &pgf_expr_state_order, &st3); - } - } - } - - return NULL; -} - -static void -pgf_parse_result_enum_next(GuEnum* self, void* to, GuPool* pool) -{ - PgfParsing* ps = gu_container(self, PgfParsing, en); - *(PgfExprProb**)to = pgf_parse_result_next(ps); -} - -static PgfParseError* -pgf_parsing_new_exception(PgfParsing* ps, GuPool* pool) -{ - const uint8_t* p = (uint8_t*) ps->sentence; - const uint8_t* end = p + (ps->before ? ps->before->end_offset : 0); - - PgfParseError* err = gu_new(PgfParseError, pool); - err->incomplete= (*end == 0); - err->offset = 0; - err->token_ptr = (char*) p; - - while (p < end) { - if (gu_ucs_is_space(gu_utf8_decode(&p))) { - err->token_ptr = (char*) p; - } - err->offset++; - } - - if (err->incomplete) { - err->token_ptr = NULL; - err->token_len = 0; - return err; - } - - while (*p && !gu_ucs_is_space(gu_utf8_decode(&p))) { - end = p; - } - - err->token_len = ((char*)end)-err->token_ptr; - - return err; -} - -PGF_API GuEnum* -pgf_parse(PgfConcr* concr, PgfType* typ, GuString sentence, - GuExn* err, - GuPool* pool, GuPool* out_pool) -{ - PgfCallbacksMap* callbacks = pgf_new_callbacks_map(concr, out_pool); - return pgf_parse_with_heuristics(concr, typ, sentence, -1.0, callbacks, err, pool, out_pool); -} - -static void -pgf_iter_generated_cats(PgfParsing* ps, PgfParseState* next_state); - -static void -pgf_process_generated_cat(PgfParsing* ps, - PgfParseState* state, PgfParseState* next_state, - PgfCCat* ccat) -{ - bool just_coercions = true; - - PgfCCat* children[ccat->n_synprods]; - for (size_t i = 0; i < ccat->n_synprods; i++) { - PgfProduction prod = - gu_seq_get(ccat->prods, PgfProduction, i); - - children[i] = NULL; - - GuVariantInfo inf = gu_variant_open(prod); - switch (inf.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = inf.data; - - size_t j = gu_seq_length(papp->args); - while (j > 0) { - PgfPArg* parg = gu_seq_index(papp->args, PgfPArg, j-1); - - if (pgf_parsing_get_completed(state, parg->ccat->conts) != NULL && - ccat->conts->state->end_offset == parg->ccat->conts->state->end_offset) { - children[i] = parg->ccat; - break; - } - - j--; - } - - if (children[i] == NULL) { - just_coercions = false; - break; - } - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = inf.data; - children[i] = pcoerce->coerce; - break; - } - case PGF_PRODUCTION_EXTERN: - just_coercions = false; - } - } - - if (just_coercions) { - ccat->chunk_count++; - - for (size_t i = 0; i < ccat->n_synprods; i++) { - children[i]->chunk_count--; - -#ifdef PGF_PARSER_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - pgf_print_fid(children[i]->fid, out, err); - gu_printf(out, err, ".chunk_count=%d\n", children[i]->chunk_count); - gu_pool_free(tmp_pool); -#endif - - if (children[i]->chunk_count == 0) { - pgf_process_generated_cat(ps, state, next_state, children[i]); - } - } - } else { - PgfParseState* prev_state = ccat->conts->state; - if (prev_state->chunks_map == NULL) { - pgf_iter_generated_cats(ps, prev_state); - - if (prev_state->chunks_map == NULL) { - prev_state->chunks_map = - gu_new_addr_map(PgfCCat*, PgfParseState*, - &gu_null_struct, ps->pool); - } - } - -#ifdef PGF_PARSER_DEBUG - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - gu_printf(out, err, "[%d - ", prev_state->end_offset); - pgf_print_fid(ccat->fid, out, err); - gu_printf(out, err, " - %d]\n", next_state->start_offset); - gu_pool_free(tmp_pool); -#endif - - gu_map_put(prev_state->chunks_map, ccat, PgfParseState*, next_state); - } -} - -static void -pgf_iter_generated_cats(PgfParsing* ps, PgfParseState* next_state) -{ - size_t count = 0; - PgfParseState* state = next_state; - - for (;;) { - size_t i = 0; - PgfCCat* ccat; - PgfItemConts* conts; - while (gu_map_next(state->generated_cats, &i, (void**)&conts, &ccat)) { - if (ccat->chunk_count > 0) - continue; - - count++; - - pgf_process_generated_cat(ps, state, next_state, ccat); - } - - if (count > 0 || state->next == NULL) - break; - - state = state->next; - } -} - -PGF_API GuEnum* -pgf_parse_with_heuristics(PgfConcr* concr, PgfType* typ, GuString sentence, - double heuristics, - PgfCallbacksMap* callbacks, - GuExn* err, - GuPool* pool, GuPool* out_pool) -{ - if (concr->sequences == NULL || - concr->cnccats == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return NULL; - } - } - - // Begin parsing a sentence with the specified category - PgfParsing* ps = - pgf_parsing_init(concr, typ->cid, sentence, heuristics, callbacks, NULL, err, pool, out_pool); - if (ps == NULL) { - return NULL; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - - while (gu_buf_length(ps->expr_queue) == 0) { - if (!pgf_parsing_proceed(ps)) { - GuExnData* exn = gu_raise(err, PgfParseError); - exn->data = (void*) pgf_parsing_new_exception(ps, exn->pool); - - PgfExprState* st = gu_new(PgfExprState, ps->pool); - st->answers = gu_new(PgfAnswers, ps->pool); - st->answers->conts = gu_new_buf(PgfExprState*, ps->pool); - st->answers->exprs = gu_new_buf(PgfExprProb*, ps->pool); - st->answers->ccat = NULL; - st->answers->outside_prob = 0; - st->ep.expr = - gu_new_variant_i(ps->out_pool, - PGF_EXPR_META, PgfExprMeta, - .id = 0); - st->ep.prob = 0; - st->state = NULL; - st->arg_idx = PGF_EXPR_CHUNK_STATE; - - pgf_iter_generated_cats(ps, ps->before); - - PgfParseState* state = ps->before; - while (state != NULL) { - if (state->chunks_map != NULL) - st->state = state; - state = state->next; - } - - if (st->state != NULL) { - gu_buf_heap_push(ps->expr_queue, &pgf_expr_state_order, &st); - } - break; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - } - - // Now begin enumerating the resulting syntax trees - ps->en.next = pgf_parse_result_enum_next; - return &ps->en; -} - -PGF_API PgfParsing* -pgf_parse_to_chart(PgfConcr* concr, PgfType* typ, GuString sentence, - double heuristics, - PgfCallbacksMap* callbacks, - size_t n_roots, - GuExn* err, - GuPool* pool, GuPool* out_pool) -{ - if (concr->sequences == NULL || - concr->cnccats == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return NULL; - } - } - - // Begin parsing a sentence with the specified category - PgfParsing* ps = - pgf_parsing_init(concr, typ->cid, sentence, heuristics, callbacks, NULL, err, pool, out_pool); - if (ps == NULL) { - return NULL; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - - while (gu_buf_length(ps->expr_queue) < n_roots) { - if (!pgf_parsing_proceed(ps)) { - break; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - } - - return ps; -} - -PGF_API PgfCCats* -pgf_get_parse_roots(PgfParsing* ps, GuPool* pool) -{ - size_t n_cats = 0; - size_t n_states = gu_buf_length(ps->expr_queue); - GuSeq* roots = gu_new_seq(PgfCCat*, n_states, pool); - for (size_t i = 0; i < n_states; i++) { - PgfCCat* ccat = gu_buf_get(ps->expr_queue, PgfExprState*, i)->answers->ccat; - - bool found = false; - for (size_t j = 0; j < n_cats; j++) { - if (gu_seq_get(roots, PgfCCat*, j) == ccat) { - found = true; - break; - } - } - - if (!found) { - gu_seq_set(roots, PgfCCat*, n_cats, ccat); - n_cats++; - } - } - roots->len = n_cats; - return roots; -} - -PGF_API GuSeq* -pgf_ccat_to_range(PgfParsing* ps, PgfCCat* ccat, GuPool* pool) -{ - PgfParseState* state = ps->before; - GuBuf* buf = gu_new_buf(PgfParseRange, pool); - - while (ccat->conts != NULL) { - size_t start = ccat->conts->state->end_offset; - size_t end = start; - while (state != NULL) { - if (pgf_parsing_get_completed(state, ccat->conts) == ccat) { - if (state->start_offset >= start) - end = state->start_offset; - break; - } - state = state->next; - } - - if (start != end) { - PgfParseRange* range = gu_buf_extend(buf); - range->start = start; - range->end = end; - range->field = ccat->cnccat->labels[ccat->conts->lin_idx]; - } - - ccat = ccat->conts->ccat; - } - - return gu_buf_data_seq(buf); -} - -PGF_API PgfExprEnum* -pgf_parse_with_oracle(PgfConcr* concr, PgfType* typ, - GuString sentence, - PgfOracleCallback* oracle, - GuExn* err, - GuPool* pool, GuPool* out_pool) -{ - if (concr->sequences == NULL || - concr->cnccats == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return NULL; - } - } - - // Begin parsing a sentence with the specified category - PgfCallbacksMap* callbacks = pgf_new_callbacks_map(concr, out_pool); - PgfParsing* ps = - pgf_parsing_init(concr, typ->cid, sentence, -1, callbacks, oracle, err, pool, out_pool); - if (ps == NULL) { - return NULL; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - - while (gu_buf_length(ps->expr_queue) == 0) { - if (!pgf_parsing_proceed(ps)) { - GuExnData* exn = gu_raise(err, PgfParseError); - exn->data = (void*) pgf_parsing_new_exception(ps, exn->pool); - return NULL; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - } - - // Now begin enumerating the resulting syntax trees - ps->en.next = pgf_parse_result_enum_next; - return &ps->en; -} - -static void -pgf_parser_completions_next(GuEnum* self, void* to, GuPool* pool) -{ - PgfParsing* ps = - gu_container(self, PgfParsing, en); - - ps->tp = NULL; - while (ps->tp == NULL) { - if (!pgf_parsing_proceed(ps)) - break; - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - } - - *((PgfTokenProb**)to) = ps->tp; -} - -PGF_API GuEnum* -pgf_complete(PgfConcr* concr, PgfType* type, GuString sentence, - GuString prefix, GuExn *err, GuPool* pool) -{ - if (concr->sequences == NULL || - concr->cnccats == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return NULL; - } - } - - // Begin parsing a sentence with the specified category - PgfCallbacksMap* callbacks = - pgf_new_callbacks_map(concr, pool); - PgfParsing* ps = - pgf_parsing_init(concr, type->cid, sentence, -1.0, callbacks, NULL, err, pool, pool); - if (ps == NULL) { - return NULL; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - - size_t len = strlen(ps->sentence); - while (ps->before->end_offset < len) { - if (!pgf_parsing_proceed(ps)) { - GuExnData* exn = gu_raise(err, PgfParseError); - exn->data = (void*) pgf_parsing_new_exception(ps, exn->pool); - return NULL; - } - -#ifdef PGF_COUNTS_DEBUG - pgf_parsing_print_counts(ps); -#endif - } - - // Now begin enumerating the completions - ps->en.next = pgf_parser_completions_next; - ps->prefix = prefix; - ps->tp = NULL; - return &ps->en; -} - -PGF_API void -pgf_parser_index(PgfConcr* concr, - PgfCCat* ccat, PgfProduction prod, - bool is_lexical, - GuPool *pool) -{ - GuVariantInfo i = gu_variant_open(prod); - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = i.data; - - if (!is_lexical) - break; - - for (size_t lin_idx = 0; lin_idx < papp->fun->n_lins; lin_idx++) { - PgfSequence* seq = papp->fun->lins[lin_idx]; - - size_t i = gu_buf_length(seq->idx); - while (i > 0) { - PgfProductionIdxEntry* entry = - gu_buf_index(seq->idx, PgfProductionIdxEntry, i-1); - - if (entry->ccat->fid < ccat->fid) - break; - if (entry->lin_idx <= lin_idx) - break; - - i--; - } - - PgfProductionIdxEntry* entry = gu_buf_insert(seq->idx, i); - entry->ccat = ccat; - entry->lin_idx = lin_idx; - entry->papp = papp; - } - break; - } - case PGF_PRODUCTION_COERCE: - // Nothing to be done here - break; - default: - gu_impossible(); - } -} - -PGF_INTERNAL prob_t -pgf_ccat_set_viterbi_prob(PgfCCat* ccat) { - if (ccat->fid < 0) - return 0; - - if (ccat->viterbi_prob == 0) { // uninitialized - ccat->viterbi_prob = INFINITY; // set to infinity to avoid loops - - if (ccat->prods == NULL) - return INFINITY; - - prob_t viterbi_prob = INFINITY; - - size_t n_prods = gu_seq_length(ccat->prods); - for (size_t i = 0; i < n_prods; i++) { - PgfProduction prod = - gu_seq_get(ccat->prods, PgfProduction, i); - - prob_t prob = 0; - - GuVariantInfo inf = gu_variant_open(prod); - switch (inf.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = inf.data; - prob = papp->fun->ep->prob; - - size_t n_args = gu_seq_length(papp->args); - for (size_t j = 0; j < n_args; j++) { - PgfPArg* arg = gu_seq_index(papp->args, PgfPArg, j); - prob += pgf_ccat_set_viterbi_prob(arg->ccat); - } - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = inf.data; - prob = pgf_ccat_set_viterbi_prob(pcoerce->coerce); - break; - } - default: - gu_impossible(); - return 0; - } - - if (viterbi_prob > prob) - viterbi_prob = prob; - } - - ccat->viterbi_prob = viterbi_prob; - } - - return ccat->viterbi_prob; -} diff --git a/src/runtime/c/pgf/parseval.c b/src/runtime/c/pgf/parseval.c deleted file mode 100644 index 501430fda..000000000 --- a/src/runtime/c/pgf/parseval.c +++ /dev/null @@ -1,220 +0,0 @@ -#include -#include -#include -#include - -typedef struct { - int start, end; - PgfCId cat; - GuString ann; -} PgfPhrase; - -typedef struct { - PgfLinFuncs* funcs; - bool bind; - GuOut* out; - GuExn* err; - int pos; - GuBuf* marks; - GuBuf* phrases; - int found, matches; - GuPool* pool; -} PgfMetricsLznState; - -static void -pgf_metrics_put_space(PgfMetricsLznState* state) -{ - if (state->bind) - state->bind = false; - else { - if (state->out != NULL) - gu_putc(' ', state->out, state->err); - state->pos++; - } -} - -static void -pgf_metrics_lzn_symbol_token(PgfLinFuncs** funcs, PgfToken tok) -{ - PgfMetricsLznState* state = gu_container(funcs, PgfMetricsLznState, funcs); - - pgf_metrics_put_space(state); - if (state->out != NULL) - gu_string_write(tok, state->out, state->err); - - state->pos += strlen(tok); -} - -static void -pgf_metrics_lzn_begin_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfMetricsLznState* state = gu_container(funcs, PgfMetricsLznState, funcs); - gu_buf_push(state->marks, int, state->pos); -} - -static void -pgf_metrics_lzn_end_phrase1(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfMetricsLznState* state = gu_container(funcs, PgfMetricsLznState, funcs); - - int start = gu_buf_pop(state->marks, int); - int end = state->pos; - - if (start != end) { - PgfPhrase* phrase = gu_new(PgfPhrase, state->pool); - phrase->start = start; - phrase->end = end; - phrase->cat = cat; - phrase->ann = ann; - gu_buf_push(state->phrases, PgfPhrase*, phrase); - } -} - -static void -pgf_metrics_symbol_ne(PgfLinFuncs** funcs) -{ - PgfMetricsLznState* state = gu_container(funcs, PgfMetricsLznState, funcs); - gu_raise(state->err, PgfLinNonExist); -} - -static void -pgf_metrics_symbol_bind(PgfLinFuncs** funcs) -{ - PgfMetricsLznState* state = gu_container(funcs, PgfMetricsLznState, funcs); - state->bind = true; -} - -static void -pgf_metrics_lzn_end_phrase2(PgfLinFuncs** funcs, PgfCId cat, int fid, GuString ann, PgfCId fun) -{ - PgfMetricsLznState* state = gu_container(funcs, PgfMetricsLznState, funcs); - - int start = gu_buf_pop(state->marks, int); - int end = state->pos; - - if (start != end) { - size_t n_phrases = gu_buf_length(state->phrases); - for (size_t i = 0; i < n_phrases; i++) { - PgfPhrase* phrase = gu_buf_get(state->phrases, PgfPhrase*, i); - - if (phrase->start == start && - phrase->end == end && - strcmp(phrase->cat, cat) == 0 && - strcmp(phrase->ann, ann) == 0) { - state->matches++; - break; - } - } - - state->found++; - } -} - -static void -pgf_metrics_lzn_symbol_meta(PgfLinFuncs** funcs, PgfMetaId meta_id) -{ - PgfMetricsLznState* state = gu_container(funcs, PgfMetricsLznState, funcs); - - pgf_metrics_put_space(state); - if (state->out != NULL) - gu_putc('?', state->out, state->err); - - state->pos += 1; -} - -static PgfLinFuncs pgf_metrics_lin_funcs1 = { - .symbol_token = pgf_metrics_lzn_symbol_token, - .begin_phrase = pgf_metrics_lzn_begin_phrase, - .end_phrase = pgf_metrics_lzn_end_phrase1, - .symbol_ne = pgf_metrics_symbol_ne, - .symbol_bind = pgf_metrics_symbol_bind, - .symbol_capit = NULL, - .symbol_meta = pgf_metrics_lzn_symbol_meta -}; - -static PgfLinFuncs pgf_metrics_lin_funcs2 = { - .symbol_token = pgf_metrics_lzn_symbol_token, - .begin_phrase = pgf_metrics_lzn_begin_phrase, - .end_phrase = pgf_metrics_lzn_end_phrase2, - .symbol_ne = pgf_metrics_symbol_ne, - .symbol_bind = pgf_metrics_symbol_bind, - .symbol_capit = NULL, - .symbol_meta = pgf_metrics_lzn_symbol_meta -}; - -PGF_API bool -pgf_parseval(PgfConcr* concr, PgfExpr expr, PgfType* type, - double *precision, double *recall, double *exact) -{ - GuPool* pool = gu_new_pool(); - - GuExn* err = gu_new_exn(pool); - - GuEnum* en_lins1 = - pgf_lzr_concretize(concr, expr, err, pool); - if (!gu_ok(err)) { - gu_pool_free(pool); - return false; - } - - PgfCncTree ctree1 = gu_next(en_lins1, PgfCncTree, pool); - if (gu_variant_is_null(ctree1)) { - gu_pool_free(pool); - return false; - } - - GuStringBuf* sbuf = - gu_new_string_buf(pool); - - PgfMetricsLznState state; - state.bind = true; - state.out = gu_string_buf_out(sbuf); - state.err = gu_new_exn(pool); - state.funcs = &pgf_metrics_lin_funcs1; - state.pos = 0; - state.marks = gu_new_buf(int, pool); - state.phrases = gu_new_buf(PgfPhrase*, pool); - state.matches = 0; - state.found = 0; - state.pool = pool; - - pgf_lzr_linearize(concr, ctree1, 0, &state.funcs, pool); - if (!gu_ok(state.err)) { - gu_pool_free(pool); - return false; - } - - GuString sentence = - gu_string_buf_freeze(sbuf, pool); - - GuEnum* en_trees = - pgf_parse(concr, type, sentence, - state.err, pool, pool); - PgfExprProb* ep = gu_next(en_trees, PgfExprProb*, pool); - if (ep == NULL) { - gu_pool_free(pool); - return false; - } - - GuEnum* en_lins2 = - pgf_lzr_concretize(concr, ep->expr, err, pool); - PgfCncTree ctree2 = gu_next(en_lins2, PgfCncTree, pool); - if (gu_variant_is_null(ctree2)) { - gu_pool_free(pool); - return false; - } - - state.funcs = &pgf_metrics_lin_funcs2; - state.bind = true; - state.out = NULL; - state.pos = 0; - pgf_lzr_linearize(concr, ctree2, 0, &state.funcs, pool); - - *precision = ((double) state.matches)/((double) state.found); - *recall = ((double) state.matches)/((double) gu_buf_length(state.phrases)); - *exact = pgf_expr_eq(expr, ep->expr) ? 1 : 0; - - gu_pool_free(pool); - - return true; -} diff --git a/src/runtime/c/pgf/pgf.c b/src/runtime/c/pgf/pgf.c deleted file mode 100644 index d1cb0bd08..000000000 --- a/src/runtime/c/pgf/pgf.c +++ /dev/null @@ -1,338 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -PGF_API PgfPGF* -pgf_read(const char* fpath, - GuPool* pool, GuExn* err) -{ - FILE* infile = fopen(fpath, "rb"); - if (infile == NULL) { - gu_raise_errno(err); - return NULL; - } - - GuPool* tmp_pool = gu_new_pool(); - - // Create an input stream from the input file - GuIn* in = gu_file_in(infile, tmp_pool); - - PgfReader* rdr = pgf_new_reader(in, pool, tmp_pool, err); - PgfPGF* pgf = pgf_read_pgf(rdr); - pgf_reader_done(rdr, pgf); - - gu_pool_free(tmp_pool); - - fclose(infile); - return pgf; -} - -PGF_API PgfPGF* -pgf_read_in(GuIn* in, - GuPool* pool, GuPool* tmp_pool, GuExn* err) -{ - PgfReader* rdr = pgf_new_reader(in, pool, tmp_pool, err); - PgfPGF* pgf = pgf_read_pgf(rdr); - pgf_reader_done(rdr, pgf); - return pgf; -} - -PGF_API_DECL void -pgf_write(PgfPGF* pgf, size_t n_concrs, PgfConcr** concrs, const char* fpath, GuExn* err) -{ - FILE* outfile = fopen(fpath, "wb"); - if (outfile == NULL) { - gu_raise_errno(err); - return; - } - - GuPool* tmp_pool = gu_local_pool(); - - // Create an input stream from the input file - GuOut* out = gu_file_out(outfile, tmp_pool); - - PgfWriter* wtr = pgf_new_writer(out, tmp_pool, err); - pgf_write_pgf(pgf, n_concrs, concrs, wtr); - - gu_pool_free(tmp_pool); - - fclose(outfile); -} - -PGF_API void -pgf_concrete_save(PgfConcr* concr, const char* fpath, GuExn* err) -{ - FILE* outfile = fopen(fpath, "wb"); - if (outfile == NULL) { - gu_raise_errno(err); - return; - } - - GuPool* tmp_pool = gu_local_pool(); - - // Create an input stream from the input file - GuOut* out = gu_file_out(outfile, tmp_pool); - - PgfWriter* wtr = pgf_new_writer(out, tmp_pool, err); - pgf_write_concrete(concr, wtr, true); - - gu_pool_free(tmp_pool); - - fclose(outfile); -} - -PGF_API bool -pgf_have_same_abstract(PgfPGF *one, PgfPGF *two) -{ - if (strcmp(one->abstract.name, two->abstract.name) != 0) - return false; - - size_t n_cats = gu_seq_length(one->abstract.cats); - if (n_cats != gu_seq_length(two->abstract.cats)) - return false; - size_t n_funs = gu_seq_length(one->abstract.funs); - if (n_funs != gu_seq_length(two->abstract.funs)) - return false; - - for (size_t i = 0; i < n_cats; i++) { - PgfAbsCat* cat1 = gu_seq_index(one->abstract.cats, PgfAbsCat, i); - PgfAbsCat* cat2 = gu_seq_index(two->abstract.cats, PgfAbsCat, i); - - if (strcmp(cat1->name, cat2->name) != 0) - return false; - } - - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* fun1 = gu_seq_index(one->abstract.funs, PgfAbsFun, i); - PgfAbsFun* fun2 = gu_seq_index(two->abstract.funs, PgfAbsFun, i); - - if (strcmp(fun1->name, fun2->name) != 0) - return false; - - if (!pgf_type_eq(fun1->type, fun2->type)) - return false; - } - - return true; -} - -PGF_API GuString -pgf_abstract_name(PgfPGF* pgf) -{ - return pgf->abstract.name; -} - -PGF_API void -pgf_iter_languages(PgfPGF* pgf, GuMapItor* itor, GuExn* err) -{ - size_t n_concrs = gu_seq_length(pgf->concretes); - for (size_t i = 0; i < n_concrs; i++) { - PgfConcr* concr = gu_seq_index(pgf->concretes, PgfConcr, i); - itor->fn(itor, concr->name, &concr, err); - if (!gu_ok(err)) - break; - } -} - -PGF_API PgfConcr* -pgf_get_language(PgfPGF* pgf, PgfCId lang) -{ - return gu_seq_binsearch(pgf->concretes, pgf_concr_order, PgfConcr, lang); -} - -PGF_API GuString -pgf_concrete_name(PgfConcr* concr) -{ - return concr->name; -} - -PGF_API void -pgf_iter_categories(PgfPGF* pgf, GuMapItor* itor, GuExn* err) -{ - size_t n_cats = gu_seq_length(pgf->abstract.cats); - for (size_t i = 0; i < n_cats; i++) { - PgfAbsCat* cat = gu_seq_index(pgf->abstract.cats, PgfAbsCat, i); - itor->fn(itor, cat->name, &cat, err); - if (!gu_ok(err)) - break; - } -} - -PGF_API PgfType* -pgf_start_cat(PgfPGF* pgf, GuPool* pool) -{ - PgfFlag* flag = - gu_seq_binsearch(pgf->abstract.aflags, pgf_flag_order, PgfFlag, "startcat"); - - if (flag != NULL) { - GuVariantInfo i = gu_variant_open(flag->value); - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr *lstr = (PgfLiteralStr *) i.data; - - GuPool* tmp_pool = gu_local_pool(); - GuIn* in = gu_string_in(lstr->val,tmp_pool); - GuExn* err = gu_new_exn(tmp_pool); - PgfType *type = pgf_read_type(in, pool, tmp_pool, err); - if (!gu_ok(err)) - break; - gu_pool_free(tmp_pool); - return type; - } - } - } - - PgfType* type = gu_new_flex(pool, PgfType, exprs, 0); - type->hypos = gu_empty_seq(); - type->cid = "S"; - type->n_exprs = 0; - return type; -} - -PGF_API PgfHypos* -pgf_category_context(PgfPGF *gr, PgfCId catname) -{ - PgfAbsCat* abscat = - gu_seq_binsearch(gr->abstract.cats, pgf_abscat_order, PgfAbsCat, catname); - if (abscat == NULL) { - return NULL; - } - - return abscat->context; -} - -PGF_API prob_t -pgf_category_prob(PgfPGF* pgf, PgfCId catname) -{ - PgfAbsCat* abscat = - gu_seq_binsearch(pgf->abstract.cats, pgf_abscat_order, PgfAbsCat, catname); - if (abscat == NULL) - return INFINITY; - - return abscat->prob; -} - -PGF_API GuString* -pgf_category_fields(PgfConcr* concr, PgfCId catname, size_t *n_lins) -{ - PgfCncCat* cnccat = - gu_map_get(concr->cnccats, catname, PgfCncCat*); - if (!cnccat) { - *n_lins = 0; - return NULL; - } - - *n_lins = cnccat->n_lins; - return &cnccat->labels; -} - -PGF_API GuString -pgf_language_code(PgfConcr* concr) -{ - PgfFlag* flag = - gu_seq_binsearch(concr->cflags, pgf_flag_order, PgfFlag, "language"); - - if (flag == NULL) - return NULL; - - GuVariantInfo i = gu_variant_open(flag->value); - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr *lstr = (PgfLiteralStr *) i.data; - return lstr->val; - } - } - - return NULL; -} - -PGF_API void -pgf_iter_functions(PgfPGF* pgf, GuMapItor* itor, GuExn* err) -{ - size_t n_funs = gu_seq_length(pgf->abstract.funs); - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* fun = gu_seq_index(pgf->abstract.funs, PgfAbsFun, i); - itor->fn(itor, fun->name, &fun, err); - if (!gu_ok(err)) - break; - } -} - -PGF_API void -pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname, - GuMapItor* itor, GuExn* err) -{ - size_t n_funs = gu_seq_length(pgf->abstract.funs); - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* fun = gu_seq_index(pgf->abstract.funs, PgfAbsFun, i); - - if (strcmp(fun->type->cid, catname) == 0) { - itor->fn(itor, fun->name, &fun, err); - if (!gu_ok(err)) - break; - } - } -} - -PGF_API PgfType* -pgf_function_type(PgfPGF* pgf, PgfCId funname) -{ - PgfAbsFun* absfun = - gu_seq_binsearch(pgf->abstract.funs, pgf_absfun_order, PgfAbsFun, funname); - if (absfun == NULL) - return NULL; - - return absfun->type; -} - -PGF_API_DECL bool -pgf_function_is_constructor(PgfPGF* pgf, PgfCId funname) -{ - PgfAbsFun* absfun = - gu_seq_binsearch(pgf->abstract.funs, pgf_absfun_order, PgfAbsFun, funname); - if (absfun == NULL) - return false; - return (absfun->defns == NULL); -} - -PGF_API prob_t -pgf_function_prob(PgfPGF* pgf, PgfCId funname) -{ - PgfAbsFun* absfun = - gu_seq_binsearch(pgf->abstract.funs, pgf_absfun_order, PgfAbsFun, funname); - if (absfun == NULL) - return INFINITY; - - return absfun->ep.prob; -} - -PGF_API GuString -pgf_print_name(PgfConcr* concr, PgfCId id) -{ - PgfCId name = - gu_map_get(concr->printnames, id, GuString); - return name; -} - -PGF_API int -pgf_has_linearization(PgfConcr* concr, PgfCId id) -{ - PgfCncOverloadMap* overl_table = - gu_map_get(concr->fun_indices, id, PgfCncOverloadMap*); - return (overl_table != NULL); -} - -PGF_API PgfExprProb* -pgf_fun_get_ep(void* value) -{ - PgfAbsFun* absfun = *((PgfAbsFun**) value); - return &absfun->ep; -} diff --git a/src/runtime/c/pgf/pgf.h b/src/runtime/c/pgf/pgf.h deleted file mode 100644 index 0aad0981e..000000000 --- a/src/runtime/c/pgf/pgf.h +++ /dev/null @@ -1,291 +0,0 @@ -#ifndef PGF_H_ -#define PGF_H_ - -#include -#include -#include -#include -#include - -#if defined(_MSC_VER) - -#if defined(COMPILING_PGF) -#define PGF_API_DECL __declspec(dllexport) -#define PGF_API __declspec(dllexport) -#else -#define PGF_API_DECL __declspec(dllimport) -#define PGF_API ERROR_NOT_COMPILING_LIBPGF -#endif -#define PGF_INTERNAL_DECL -#define PGF_INTERNAL - -#else - -#define PGF_API_DECL -#define PGF_API - -#define PGF_INTERNAL_DECL __attribute__ ((visibility ("hidden"))) -#define PGF_INTERNAL __attribute__ ((visibility ("hidden"))) - -#endif - - -typedef GuString PgfCId; - -typedef GuString PgfToken; - -typedef struct PgfPGF PgfPGF; - -typedef struct PgfConcr PgfConcr; - -#include -#include - -typedef GuEnum PgfExprEnum; - -PGF_API_DECL PgfPGF* -pgf_read(const char* fpath, - GuPool* pool, GuExn* err); - -PGF_API_DECL PgfPGF* -pgf_read_in(GuIn* in, - GuPool* pool, GuPool* tmp_pool, GuExn* err); - -PGF_API_DECL void -pgf_concrete_load(PgfConcr* concr, GuIn* in, GuExn* err); - -PGF_API_DECL void -pgf_concrete_unload(PgfConcr* concr); - -PGF_API_DECL void -pgf_write(PgfPGF* pgf, size_t n_concrs, PgfConcr** concrs, const char* fpath, GuExn* err); - -PGF_API_DECL bool -pgf_have_same_abstract(PgfPGF *one, PgfPGF *two); - -PGF_API_DECL GuString -pgf_abstract_name(PgfPGF*); - -PGF_API_DECL void -pgf_iter_languages(PgfPGF*, GuMapItor* itor, GuExn* err); - -PGF_API_DECL PgfConcr* -pgf_get_language(PgfPGF*, PgfCId lang); - -PGF_API_DECL GuString -pgf_concrete_name(PgfConcr*); - -PGF_API_DECL GuString -pgf_language_code(PgfConcr* concr); - -PGF_API_DECL void -pgf_iter_categories(PgfPGF* pgf, GuMapItor* itor, GuExn* err); - -PGF_API_DECL PgfType* -pgf_start_cat(PgfPGF* pgf, GuPool* pool); - -PGF_API_DECL PgfHypos* -pgf_category_context(PgfPGF *gr, PgfCId catname); - -PGF_API_DECL prob_t -pgf_category_prob(PgfPGF* pgf, PgfCId catname); - -PGF_API GuString* -pgf_category_fields(PgfConcr* concr, PgfCId catname, size_t *n_lins); - -PGF_API_DECL void -pgf_iter_functions(PgfPGF* pgf, GuMapItor* itor, GuExn* err); - -PGF_API_DECL void -pgf_iter_functions_by_cat(PgfPGF* pgf, PgfCId catname, - GuMapItor* itor, GuExn* err); - -PGF_API_DECL PgfType* -pgf_function_type(PgfPGF* pgf, PgfCId funname); - -PGF_API_DECL bool -pgf_function_is_constructor(PgfPGF* pgf, PgfCId funname); - -PGF_API_DECL prob_t -pgf_function_prob(PgfPGF* pgf, PgfCId funname); - -PGF_API_DECL GuString -pgf_print_name(PgfConcr*, PgfCId id); - -PGF_API_DECL int -pgf_has_linearization(PgfConcr* concr, PgfCId id); - -PGF_API_DECL void -pgf_linearize(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err); - -typedef struct { - GuString phrase; - size_t n_fids; - int fids[]; -} PgfAlignmentPhrase; - -PGF_API_DECL GuSeq* -pgf_align_words(PgfConcr* concr, PgfExpr expr, - GuExn* err, GuPool* pool); - -PGF_API_DECL bool -pgf_parseval(PgfConcr* concr, PgfExpr expr, PgfType* type, - double *precision, double *recall, double *exact); - -PGF_API_DECL PgfExpr -pgf_compute(PgfPGF* pgf, PgfExpr expr, GuExn* err, - GuPool* pool, GuPool* out_pool); - -PGF_API_DECL PgfExprEnum* -pgf_generate_all(PgfPGF* pgf, PgfType* ty, - GuExn* err, GuPool* pool, GuPool* out_pool); - -typedef struct { - int incomplete; // equal to !=0 if the sentence is incomplete, 0 otherwise - size_t offset; - const char* token_ptr; - size_t token_len; -} PgfParseError; - -PGF_API_DECL PgfExprEnum* -pgf_parse(PgfConcr* concr, PgfType* typ, GuString sentence, - GuExn* err, GuPool* pool, GuPool* out_pool); - -PGF_API_DECL GuEnum* -pgf_lookup_sentence(PgfConcr* concr, PgfType* typ, GuString sentence, GuPool* pool, GuPool* out_pool); - -typedef struct PgfMorphoCallback PgfMorphoCallback; -struct PgfMorphoCallback { - void (*callback)(PgfMorphoCallback* self, - PgfCId lemma, GuString analysis, prob_t prob, - GuExn* err); -}; - -PGF_API_DECL void -pgf_lookup_morpho(PgfConcr *concr, GuString sentence, - PgfMorphoCallback* callback, GuExn* err); - -typedef struct { - size_t pos; // position in Unicode characters - GuString ptr; // pointer into the string -} PgfCohortSpot; - -typedef struct { - PgfCohortSpot start; - PgfCohortSpot end; - GuBuf* buf; -} PgfCohortRange; - -PGF_API_DECL GuEnum* -pgf_lookup_cohorts(PgfConcr *concr, GuString sentence, - PgfMorphoCallback* callback, - GuPool* pool, GuExn* err); - -typedef struct PgfFullFormEntry PgfFullFormEntry; - -PGF_API_DECL GuEnum* -pgf_fullform_lexicon(PgfConcr *concr, GuPool* pool); - -PGF_API_DECL GuString -pgf_fullform_get_string(PgfFullFormEntry* entry); - -PGF_API_DECL void -pgf_fullform_get_analyses(PgfFullFormEntry* entry, - PgfMorphoCallback* callback, GuExn* err); - -PGF_API_DECL GuEnum* -pgf_lookup_word_prefix(PgfConcr *concr, GuString prefix, - GuPool* pool, GuExn* err); - -typedef GuMap PgfCallbacksMap; - -PGF_API_DECL PgfExprEnum* -pgf_parse_with_heuristics(PgfConcr* concr, PgfType* typ, - GuString sentence, double heuristics, - PgfCallbacksMap* callbacks, - GuExn* err, - GuPool* pool, GuPool* out_pool); - -typedef struct { - size_t start; - size_t end; - GuString field; -} PgfParseRange; - -typedef struct PgfOracleCallback PgfOracleCallback; - -struct PgfOracleCallback { - bool (*predict) (PgfOracleCallback* self, - PgfCId cat, - GuString label, - size_t offset); - bool (*complete)(PgfOracleCallback* self, - PgfCId cat, - GuString label, - size_t offset); - PgfExprProb* (*literal)(PgfOracleCallback* self, - PgfCId cat, - GuString label, - size_t* poffset, - GuPool *out_pool); -}; - -PGF_API_DECL PgfExprEnum* -pgf_parse_with_oracle(PgfConcr* concr, PgfType* typ, - GuString sentence, - PgfOracleCallback* oracle, - GuExn* err, - GuPool* pool, GuPool* out_pool); - -typedef struct { - PgfToken tok; - PgfCId cat; - PgfCId fun; - prob_t prob; -} PgfTokenProb; - -PGF_API_DECL GuEnum* -pgf_complete(PgfConcr* concr, PgfType* type, GuString string, - GuString prefix, GuExn* err, GuPool* pool); - -typedef struct PgfLiteralCallback PgfLiteralCallback; - -struct PgfLiteralCallback { - PgfExprProb* (*match)(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString sentence, size_t* poffset, - GuPool *out_pool); - GuEnum* (*predict)(PgfLiteralCallback* self, PgfConcr* concr, - GuString ann, - GuString prefix, - GuPool *out_pool); -}; - -PGF_API_DECL PgfCallbacksMap* -pgf_new_callbacks_map(PgfConcr* concr, GuPool *pool); - -PGF_API_DECL void -pgf_callbacks_map_add_literal(PgfConcr* concr, PgfCallbacksMap* callbacks, - PgfCId cat, PgfLiteralCallback* callback); - -PGF_API_DECL void -pgf_print(PgfPGF* pgf, size_t n_concrs, PgfConcr** concrs, - GuOut* out, GuExn* err); - -PGF_API_DECL void -pgf_check_expr(PgfPGF* gr, PgfExpr* pe, PgfType* ty, - GuExn* exn, GuPool* pool); - -PGF_API_DECL PgfType* -pgf_infer_expr(PgfPGF* gr, PgfExpr* pe, - GuExn* exn, GuPool* pool); - -PGF_API_DECL void -pgf_check_type(PgfPGF* gr, PgfType** ty, - GuExn* exn, GuPool* pool); - -// internal -PGF_API_DECL PgfExprProb* -pgf_fun_get_ep(void* value); - -#endif // PGF_H_ diff --git a/src/runtime/c/pgf/printer.c b/src/runtime/c/pgf/printer.c deleted file mode 100644 index 1843bcbdb..000000000 --- a/src/runtime/c/pgf/printer.c +++ /dev/null @@ -1,438 +0,0 @@ -#include -#include - -typedef struct { - GuMapItor fn; - GuOut* out; -} PgfPrintFn; - -static void -pgf_print_flags(PgfFlags* flags, int indent, GuOut *out, GuExn* err) -{ - size_t n_flags = gu_seq_length(flags); - for (size_t i = 0; i < n_flags; i++) { - PgfFlag* flag = gu_seq_index(flags, PgfFlag, i); - - for (int k = 0; k < indent; k++) { - gu_putc(' ', out, err); - } - - gu_puts("flag ", out, err); - pgf_print_cid(flag->name, out, err); - gu_puts(" = ", out, err); - pgf_print_literal(flag->value, out, err); - gu_puts(";\n", out, err); - } -} - -static void -pgf_print_abscats(PgfAbsCats* abscats, GuOut *out, GuExn* err) -{ - size_t n_cats = gu_seq_length(abscats); - for (size_t i = 0; i < n_cats; i++) { - PgfAbsCat *abscat = gu_seq_index(abscats, PgfAbsCat, i); - - gu_puts(" cat ", out, err); - pgf_print_cid(abscat->name, out, err); - - PgfPrintContext* ctxt = NULL; - size_t n_hypos = gu_seq_length(abscat->context); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(abscat->context, PgfHypo, i); - gu_putc(' ', out, err); - ctxt = pgf_print_hypo(hypo, ctxt, 4, out, err); - } - - while (ctxt != NULL) { - PgfPrintContext* next = ctxt->next; - free(ctxt); - ctxt = next; - } - - gu_printf(out, err, " ; -- %f\n", abscat->prob); - } -} - -static void -pgf_print_absfuns(PgfAbsFuns* absfuns, GuOut *out, GuExn* err) -{ - size_t n_funs = gu_seq_length(absfuns); - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun *absfun = gu_seq_index(absfuns, PgfAbsFun, i); - - gu_puts((absfun->defns == NULL) ? " data " : " fun ", out, err); - pgf_print_cid(absfun->name, out, err); - gu_puts(" : ", out, err); - pgf_print_type(absfun->type, NULL, 0, out, err); - gu_printf(out, err, " ; -- %f\n", absfun->ep.prob); - } -} -static void -pgf_print_abstract(PgfAbstr* abstr, GuOut* out, GuExn* err) -{ - gu_puts("abstract ", out, err); - pgf_print_cid(abstr->name, out, err); - gu_puts(" {\n", out, err); - - pgf_print_flags(abstr->aflags, 2, out, err); - pgf_print_abscats(abstr->cats, out, err); - pgf_print_absfuns(abstr->funs, out, err); - - gu_puts("}\n", out, err); -} - -PGF_INTERNAL void -pgf_print_fid(int fid, GuOut* out, GuExn* err) -{ - if (fid == -1) - gu_puts("CString", out, err); - else if (fid == -2) - gu_puts("CInt", out, err); - else if (fid == -3) - gu_puts("CFloat", out, err); - else if (fid == -4) - gu_puts("CVar", out, err); - else if (fid == -5) - gu_puts("CStart", out, err); - else - gu_printf(out, err, "C%d", fid); -} - -PGF_INTERNAL void -pgf_print_production_args(PgfPArgs* args, - GuOut* out, GuExn* err) -{ - size_t n_args = gu_seq_length(args); - for (size_t j = 0; j < n_args; j++) { - if (j > 0) - gu_putc(',',out,err); - - PgfPArg arg = gu_seq_get(args, PgfPArg, j); - - if (arg.hypos != NULL && - gu_seq_length(arg.hypos) > 0) { - size_t n_hypos = gu_seq_length(arg.hypos); - for (size_t k = 0; k < n_hypos; k++) { - PgfCCat *hypo = gu_seq_get(arg.hypos, PgfCCat*, k); - pgf_print_fid(hypo->fid, out, err); - gu_putc(' ',out,err); - } - gu_puts("-> ",out,err); - } - - pgf_print_fid(arg.ccat->fid, out, err); - } -} - -PGF_INTERNAL void -pgf_print_production(int fid, PgfProduction prod, - GuOut *out, GuExn* err) -{ - pgf_print_fid(fid, out, err); - gu_puts(" -> ", out, err); - - GuVariantInfo i = gu_variant_open(prod); - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply* papp = i.data; - gu_printf(out,err,"F%d(",papp->fun->funid); - if (papp->fun->ep != NULL) { - pgf_print_expr(papp->fun->ep->expr, NULL, 0, out, err); - } else { - PgfPArg* parg = gu_seq_index(papp->args, PgfPArg, 0); - gu_printf(out,err,"linref %s", parg->ccat->cnccat->abscat->name); - } - gu_printf(out,err,")["); - pgf_print_production_args(papp->args,out,err); - gu_printf(out,err,"]\n"); - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = i.data; - gu_puts("_[",out,err); - pgf_print_fid(pcoerce->coerce->fid, out, err); - gu_puts("]\n",out,err); - break; - } - case PGF_PRODUCTION_EXTERN: { - PgfProductionExtern* pext = i.data; - gu_printf(out,err,"("); - pgf_print_expr(pext->ep->expr, NULL, 0, out, err); - gu_printf(out,err,")[]\n"); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_print_productions(GuMapItor* fn, const void* key, void* value, - GuExn* err) -{ - PgfPrintFn* clo = (PgfPrintFn*) fn; - int fid = *((int *) key); - PgfCCat* ccat = *((PgfCCat**) value); - GuOut *out = clo->out; - - if (ccat->prods != NULL) { - size_t n_prods = gu_seq_length(ccat->prods); - for (size_t i = 0; i < n_prods; i++) { - PgfProduction prod = gu_seq_get(ccat->prods, PgfProduction, i); - pgf_print_production(fid, prod, out, err); - } - } -} - -static void -pgf_print_lindefs(GuMapItor* fn, const void* key, void* value, - GuExn* err) -{ - PgfPrintFn* clo = (PgfPrintFn*) fn; - int fid = *((int *) key); - PgfCCat* ccat = *((PgfCCat**) value); - GuOut *out = clo->out; - - if (ccat->lindefs != NULL) { - size_t n_lindefs = gu_seq_length(ccat->lindefs); - for (size_t i = 0; i < n_lindefs; i++) { - PgfCncFun* fun = gu_seq_get(ccat->lindefs, PgfCncFun*, i); - gu_puts(" ",out,err); - pgf_print_fid(fid, out, err); - gu_printf(out,err," -> F%d[CVar]\n",fun->funid); - } - } -} - -static void -pgf_print_linrefs(GuMapItor* fn, const void* key, void* value, - GuExn* err) -{ - PgfPrintFn* clo = (PgfPrintFn*) fn; - int fid = *((int *) key); - PgfCCat* ccat = *((PgfCCat**) value); - GuOut *out = clo->out; - - if (ccat->linrefs != NULL) { - size_t n_linrefs = gu_seq_length(ccat->linrefs); - for (size_t i = 0; i < n_linrefs; i++) { - PgfCncFun* fun = gu_seq_get(ccat->linrefs, PgfCncFun*, i); - gu_printf(out,err," CVar -> F%d[",fun->funid); - pgf_print_fid(fid, out, err); - gu_puts("]\n", out, err); - } - } -} - -static void -pgf_print_cncfun(PgfCncFun *cncfun, PgfSequences* sequences, - GuOut *out, GuExn *err) -{ - gu_printf(out,err," F%d := (", cncfun->funid); - - for (size_t i = 0; i < cncfun->n_lins; i++) { - if (i > 0) gu_putc(',', out, err); - - PgfSequence* seq = cncfun->lins[i]; - gu_printf(out,err,"S%d", (seq - ((PgfSequence*) gu_seq_data(sequences)))); - } - - gu_puts(")", out, err); - - if (cncfun->absfun != NULL) { - gu_puts(" [", out, err); - pgf_print_cid(cncfun->absfun->name, out, err); - gu_puts("]", out, err); - } - - gu_puts("\n", out, err); -} - -static void -pgf_print_token(PgfToken tok, GuOut *out, GuExn *err) -{ - gu_putc('"', out, err); - gu_string_write(tok, out, err); - gu_putc('"', out, err); -} - -static void -pgf_print_symbols(PgfSymbols* syms, GuOut *out, GuExn *err); - -PGF_INTERNAL void -pgf_print_symbol(PgfSymbol sym, GuOut *out, GuExn *err) -{ - switch (gu_variant_tag(sym)) { - case PGF_SYMBOL_CAT: { - PgfSymbolCat* scat = gu_variant_data(sym); - gu_printf(out, err, "<%d,%d>", scat->d, scat->r); - break; - } - case PGF_SYMBOL_KS: { - PgfSymbolKS* sks = gu_variant_data(sym); - pgf_print_token(sks->token, out, err); - break; - } - case PGF_SYMBOL_KP: { - PgfSymbolKP* skp = gu_variant_data(sym); - - gu_puts("pre {", out, err); - pgf_print_symbols(skp->default_form, out, err); - - for (size_t i = 0; i < skp->n_forms; i++) { - gu_puts("; ", out, err); - pgf_print_symbols(skp->forms[i].form, out, err); - gu_puts(" / ", out, err); - - size_t n_prefixes = gu_seq_length(skp->forms[i].prefixes); - for (size_t j = 0; j < n_prefixes; j++) { - if (j > 0) gu_putc(' ', out, err); - - GuString prefix = gu_seq_get(skp->forms[i].prefixes, GuString, j); - gu_putc('"', out, err); - gu_string_write(prefix, out, err); - gu_putc('"', out, err); - } - } - - gu_puts("}", out, err); - break; - } - case PGF_SYMBOL_LIT: { - PgfSymbolLit *slit = gu_variant_data(sym); - gu_printf(out, err, "{%d,%d}", slit->d, slit->r); - break; - } - case PGF_SYMBOL_VAR: { - PgfSymbolVar *svar = gu_variant_data(sym); - gu_printf(out, err, "<%d,$%d>", svar->d, svar->r); - break; - } - case PGF_SYMBOL_NE: { - gu_puts("nonExist", out, err); - break; - } - case PGF_SYMBOL_BIND: { - gu_puts("BIND", out, err); - break; - } - case PGF_SYMBOL_SOFT_BIND: { - gu_puts("SOFT_BIND", out, err); - break; - } - case PGF_SYMBOL_SOFT_SPACE: { - gu_puts("SOFT_SPACE", out, err); - break; - } - case PGF_SYMBOL_CAPIT: { - gu_puts("CAPIT", out, err); - break; - } - case PGF_SYMBOL_ALL_CAPIT: { - gu_puts("ALL_CAPIT", out, err); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_print_symbols(PgfSymbols* syms, GuOut *out, GuExn *err) -{ - int n_syms = gu_seq_length(syms); - for (int i = 0; i < n_syms; i++) { - if (i > 0) gu_putc(' ', out, err); - - PgfSymbol sym = gu_seq_get(syms, PgfSymbol, i); - pgf_print_symbol(sym, out, err); - } -} - -static void -pgf_print_cnccat(GuMapItor* fn, const void* key, void* value, - GuExn* err) -{ - PgfPrintFn* clo = (PgfPrintFn*) fn; - PgfCId name = (PgfCId) key; - PgfCncCat* cnccat = *((PgfCncCat**) value); - GuOut *out = clo->out; - - gu_puts(" ", out, err); - pgf_print_cid(name, out, err); - gu_puts(" :=\n", out, err); - - PgfCCat *start = gu_seq_get(cnccat->cats, PgfCCat*, 0); - PgfCCat *end = gu_seq_get(cnccat->cats, PgfCCat*, gu_seq_length(cnccat->cats)-1); - - gu_puts(" range [", out, err); - pgf_print_fid(start->fid, out, err); - gu_puts("..", out, err); - pgf_print_fid(end->fid, out, err); - gu_puts("]\n", out, err); - - gu_puts(" labels [", out, err); - for (size_t i = 0; i < cnccat->n_lins; i++) { - if (i > 0) { - gu_puts("\n ", out, err); - } - - gu_string_write(cnccat->labels[i], out, err); - } - gu_puts("]\n", out, err); -} - -static void -pgf_print_concrete(PgfConcr* concr, GuOut* out, GuExn* err) -{ - gu_puts("concrete ", out, err); - pgf_print_cid(concr->name, out, err); - gu_puts(" {\n", out, err); - - pgf_print_flags(concr->cflags, 2, out, err); - - gu_puts(" productions\n", out, err); - PgfPrintFn clo2 = { { pgf_print_productions }, out }; - gu_map_iter(concr->ccats, &clo2.fn, err); - - gu_puts(" lindefs\n", out, err); - PgfPrintFn clo3 = { { pgf_print_lindefs }, out }; - gu_map_iter(concr->ccats, &clo3.fn, err); - - gu_puts(" linrefs\n", out, err); - PgfPrintFn clo4 = { { pgf_print_linrefs }, out }; - gu_map_iter(concr->ccats, &clo4.fn, err); - - gu_puts(" lin\n", out, err); - size_t n_funs = gu_seq_length(concr->cncfuns); - for (size_t i = 0; i < n_funs; i++) { - PgfCncFun* cncfun = gu_seq_get(concr->cncfuns, PgfCncFun*, i); - pgf_print_cncfun(cncfun, concr->sequences, out, err); - } - - gu_puts(" sequences\n", out, err); - size_t n_seqs = gu_seq_length(concr->sequences); - for (size_t i = 0; i < n_seqs; i++) { - gu_printf(out,err," S%d := ", i); - PgfSymbols* syms = gu_seq_index(concr->sequences, PgfSequence, i)->syms; - pgf_print_symbols(syms, out, err); - gu_putc('\n', out, err); - } - - gu_puts(" categories\n", out, err); - PgfPrintFn clo5 = { { pgf_print_cnccat }, out }; - gu_map_iter(concr->cnccats, &clo5.fn, err); - - gu_puts("}\n", out, err); -} - -PGF_API void -pgf_print(PgfPGF* pgf, size_t n_concrs, PgfConcr** concrs, GuOut* out, GuExn* err) -{ - pgf_print_flags(pgf->gflags, 0, out, err); - pgf_print_abstract(&pgf->abstract, out, err); - - for (size_t i = 0; i < n_concrs; i++) { - pgf_print_concrete(concrs[i], out, err); - } -} diff --git a/src/runtime/c/pgf/reader.c b/src/runtime/c/pgf/reader.c deleted file mode 100644 index d6c87e3e0..000000000 --- a/src/runtime/c/pgf/reader.c +++ /dev/null @@ -1,1379 +0,0 @@ -#include "data.h" -#include "expr.h" -#include "reasoner.h" -#include "reader.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#if defined(__MINGW32__) || defined(_MSC_VER) -#include -#endif - -// -// PgfReader -// - -typedef struct PgfReadTagExn PgfReadTagExn; - -struct PgfReadTagExn { - int tag; -}; - -PGF_INTERNAL uint8_t -pgf_read_tag(PgfReader* rdr) -{ - return gu_in_u8(rdr->in, rdr->err); -} - -PGF_INTERNAL uint32_t -pgf_read_uint(PgfReader* rdr) -{ - uint32_t u = 0; - int shift = 0; - uint8_t b = 0; - do { - b = gu_in_u8(rdr->in, rdr->err); - gu_return_on_exn(rdr->err, 0); - u |= (b & ~0x80) << shift; - shift += 7; - } while (b & 0x80); - return u; -} - -PGF_INTERNAL int32_t -pgf_read_int(PgfReader* rdr) -{ - uint32_t u = pgf_read_uint(rdr); - return gu_decode_2c32(u, rdr->err); -} - -PGF_INTERNAL size_t -pgf_read_len(PgfReader* rdr) -{ - int32_t len = pgf_read_int(rdr); - // It's crucial that we return 0 on failure, so the - // caller can proceed without checking for error - // immediately. - gu_return_on_exn(rdr->err, 0); - if (GU_UNLIKELY(len < 0)) { - GuExnData* err_data = gu_raise(rdr->err, PgfReadTagExn); - if (err_data) { - PgfReadTagExn* rtag = gu_new(PgfReadTagExn, err_data->pool); - rtag->tag = len; - err_data->data = rtag; - } - - return 0; - } - return len; -} - -PGF_INTERNAL PgfCId -pgf_read_cid(PgfReader* rdr, GuPool* pool) -{ - size_t len = pgf_read_len(rdr); - return gu_string_read_latin1(len, pool, rdr->in, rdr->err); -} - -PGF_INTERNAL GuString -pgf_read_string(PgfReader* rdr) -{ - size_t len = pgf_read_len(rdr); - return gu_string_read(len, rdr->opool, rdr->in, rdr->err); -} - -PGF_INTERNAL double -pgf_read_double(PgfReader* rdr) -{ - return gu_in_f64be(rdr->in, rdr->err); -} - -static void -pgf_read_tag_error(PgfReader* rdr) -{ - gu_impossible(); -} - -static PgfLiteral -pgf_read_literal(PgfReader* rdr) -{ - PgfLiteral lit = gu_null_variant; - - uint8_t tag = pgf_read_tag(rdr); - switch (tag) { - case PGF_LITERAL_STR: { - size_t len = pgf_read_len(rdr); - uint8_t* buf = alloca(len*6+1); - uint8_t* p = buf; - for (size_t i = 0; i < len; i++) { - gu_in_utf8_buf(&p, rdr->in, rdr->err); - gu_return_on_exn(rdr->err, gu_null_variant); - } - *p++ = 0; - - PgfLiteralStr *lit_str = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, p-buf, - &lit, rdr->opool); - strcpy((char*) lit_str->val, (char*) buf); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt *lit_int = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &lit, rdr->opool); - lit_int->val = pgf_read_int(rdr); - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt *lit_flt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &lit, rdr->opool); - lit_flt->val = pgf_read_double(rdr); - break; - } - default: - pgf_read_tag_error(rdr); - } - return lit; -} - -static PgfFlags* -pgf_read_flags(PgfReader* rdr) -{ - size_t n_flags = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfFlags* flags = gu_new_seq(PgfFlag, n_flags, rdr->opool); - for (size_t i = 0; i < n_flags; i++) { - PgfFlag* flag = gu_seq_index(flags, PgfFlag, i); - - flag->name = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, NULL); - - flag->value = pgf_read_literal(rdr); - gu_return_on_exn(rdr->err, NULL); - } - - return flags; -} - -static PgfType* -pgf_read_type_(PgfReader* rdr); - -static PgfExpr -pgf_read_expr_(PgfReader* rdr) -{ - PgfExpr expr = gu_null_variant; - - uint8_t tag = pgf_read_tag(rdr); - switch (tag) { - case PGF_EXPR_ABS:{ - PgfExprAbs *eabs = - gu_new_variant(PGF_EXPR_ABS, - PgfExprAbs, - &expr, rdr->opool); - - eabs->bind_type = pgf_read_tag(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - eabs->id = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - - eabs->body = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_EXPR_APP: { - PgfExprApp *eapp = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - &expr, rdr->opool); - - eapp->fun = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - eapp->arg = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_EXPR_LIT: { - PgfExprLit *elit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - &expr, rdr->opool); - elit->lit = pgf_read_literal(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_EXPR_META: { - PgfExprMeta *emeta = - gu_new_variant(PGF_EXPR_META, - PgfExprMeta, - &expr, rdr->opool); - emeta->id = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_EXPR_FUN: { - size_t len = pgf_read_len(rdr); - - PgfExprFun *efun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, len+1, - &expr, rdr->opool); - gu_in_bytes(rdr->in, (uint8_t*)efun->fun, len, rdr->err); - efun->fun[len] = 0; - - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_EXPR_VAR: { - PgfExprVar *evar = - gu_new_variant(PGF_EXPR_VAR, - PgfExprVar, - &expr, rdr->opool); - evar->var = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped *etyped = - gu_new_variant(PGF_EXPR_TYPED, - PgfExprTyped, - &expr, rdr->opool); - etyped->expr = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - etyped->type = pgf_read_type_(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg *eimpl = - gu_new_variant(PGF_EXPR_IMPL_ARG, - PgfExprImplArg, - &expr, rdr->opool); - eimpl->expr = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - default: - pgf_read_tag_error(rdr); - } - - return expr; -} - -static void -pgf_read_hypo(PgfReader* rdr, PgfHypo* hypo) -{ - hypo->bind_type = pgf_read_tag(rdr); - gu_return_on_exn(rdr->err, ); - - hypo->cid = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, ); - - hypo->type = pgf_read_type_(rdr); - gu_return_on_exn(rdr->err, ); -} - -static PgfType* -pgf_read_type_(PgfReader* rdr) -{ - size_t n_hypos = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - GuSeq* hypos = gu_new_seq(PgfHypo, n_hypos, rdr->opool); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(hypos, PgfHypo, i); - pgf_read_hypo(rdr, hypo); - gu_return_on_exn(rdr->err, NULL); - } - - PgfCId cid = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, NULL); - - size_t n_exprs = pgf_read_len(rdr); - - PgfType* type = gu_new_flex(rdr->opool, PgfType, exprs, n_exprs); - type->hypos = hypos; - type->cid = cid; - type->n_exprs = n_exprs; - - for (size_t i = 0; i < type->n_exprs; i++) { - type->exprs[i] = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, NULL); - } - - return type; -} - -static PgfPatt -pgf_read_patt(PgfReader* rdr) -{ - PgfPatt patt = gu_null_variant; - - uint8_t tag = pgf_read_tag(rdr); - switch (tag) { - case PGF_PATT_APP: { - PgfCId ctor = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - - size_t n_args = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - PgfPattApp *papp = - gu_new_flex_variant(PGF_PATT_APP, - PgfPattApp, - args, n_args, - &patt, rdr->opool); - papp->ctor = ctor; - papp->n_args = n_args; - - for (size_t i = 0; i < papp->n_args; i++) { - papp->args[i] = pgf_read_patt(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - } - break; - } - case PGF_PATT_VAR: { - PgfPattVar *papp = - gu_new_variant(PGF_PATT_VAR, - PgfPattVar, - &patt, rdr->opool); - papp->var = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_PATT_AS: { - PgfPattAs *pas = - gu_new_variant(PGF_PATT_AS, - PgfPattAs, - &patt, rdr->opool); - pas->var = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - - pas->patt = pgf_read_patt(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_PATT_WILD: { - PgfPattWild* pwild = - gu_new_variant(PGF_PATT_WILD, - PgfPattWild, - &patt, rdr->opool); - ((void) pwild); - break; - } - case PGF_PATT_LIT: { - PgfPattLit *plit = - gu_new_variant(PGF_PATT_LIT, - PgfPattLit, - &patt, rdr->opool); - plit->lit = pgf_read_literal(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_PATT_IMPL_ARG: { - PgfPattImplArg *pimpl = - gu_new_variant(PGF_PATT_IMPL_ARG, - PgfPattImplArg, - &patt, rdr->opool); - pimpl->patt = pgf_read_patt(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_PATT_TILDE: { - PgfPattTilde *ptilde = - gu_new_variant(PGF_PATT_TILDE, - PgfPattTilde, - &patt, rdr->opool); - ptilde->expr = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - default: - pgf_read_tag_error(rdr); - } - - return patt; -} - -static PgfAbsFun* -pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr, PgfAbsFun* absfun) -{ - size_t len = pgf_read_len(rdr); - - PgfExprFun *efun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, len+1, - &absfun->ep.expr, rdr->opool); - gu_in_bytes(rdr->in, (uint8_t*)efun->fun, len, rdr->err); - efun->fun[len] = 0; - absfun->name = efun->fun; - - gu_return_on_exn(rdr->err, NULL); - - absfun->type = pgf_read_type_(rdr); - gu_return_on_exn(rdr->err, NULL); - - absfun->arity = pgf_read_int(rdr); - - uint8_t tag = pgf_read_tag(rdr); - gu_return_on_exn(rdr->err, NULL); - switch (tag) { - case 0: - absfun->defns = NULL; - if (absfun->arity == 0) { - absfun->closure.code = abstr->eval_gates->evaluate_value; - absfun->closure.con = &absfun->closure.code; - } else { - absfun->closure.code = NULL; - } - break; - case 1: { - size_t length = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - absfun->defns = gu_new_seq(PgfEquation*, length, rdr->opool); - PgfEquation** data = gu_seq_data(absfun->defns); - for (size_t i = 0; i < length; i++) { - size_t n_patts = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfEquation *equ = - gu_malloc(rdr->opool, - sizeof(PgfEquation)+sizeof(PgfPatt)*n_patts); - equ->n_patts = n_patts; - for (size_t j = 0; j < n_patts; j++) { - equ->patts[j] = pgf_read_patt(rdr); - gu_return_on_exn(rdr->err, NULL); - } - equ->body = pgf_read_expr_(rdr); - gu_return_on_exn(rdr->err, NULL); - - data[i] = equ; - } - - // pgf_jit_function(rdr, abstr, absfun); - break; - } - default: - pgf_read_tag_error(rdr); - break; - } - - absfun->ep.prob = - log(pgf_read_double(rdr)); - - return absfun; -} - -static PgfAbsFuns* -pgf_read_absfuns(PgfReader* rdr, PgfAbstr* abstr) -{ - size_t n_funs = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfAbsFuns* absfuns = gu_new_seq(PgfAbsFun, n_funs, rdr->opool); - - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* absfun = gu_seq_index(absfuns, PgfAbsFun, i); - pgf_read_absfun(rdr, abstr, absfun); - gu_return_on_exn(rdr->err, NULL); - } - - return absfuns; -} - -static PgfAbsCat* -pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfAbsCat* abscat) -{ - abscat->name = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, NULL); - - size_t n_hypos = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - abscat->context = gu_new_seq(PgfHypo, n_hypos, rdr->opool); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(abscat->context, PgfHypo, i); - pgf_read_hypo(rdr, hypo); - gu_return_on_exn(rdr->err, NULL); - } - - pgf_jit_predicate(rdr, abstr, abscat); - - abscat->prob = - log(pgf_read_double(rdr)); - - return abscat; -} - -static PgfAbsCats* -pgf_read_abscats(PgfReader* rdr, PgfAbstr* abstr) -{ - size_t n_cats = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfAbsCats* abscats = gu_new_seq(PgfAbsCat, n_cats, rdr->opool); - - for (size_t i = 0; i < n_cats; i++) { - PgfAbsCat* abscat = gu_seq_index(abscats, PgfAbsCat, i); - pgf_read_abscat(rdr, abstr, abscat); - gu_return_on_exn(rdr->err, NULL); - } - - return abscats; -} - -static void -pgf_read_abstract(PgfReader* rdr, PgfAbstr* abstract) -{ - abstract->name = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, ); - - abstract->aflags = pgf_read_flags(rdr); - gu_return_on_exn(rdr->err, ); - - abstract->eval_gates = pgf_jit_gates(rdr); - - abstract->funs = pgf_read_absfuns(rdr, abstract); - gu_return_on_exn(rdr->err, ); - - abstract->cats = pgf_read_abscats(rdr, abstract); - gu_return_on_exn(rdr->err, ); - - abstract->abs_lin_fun = gu_new(PgfAbsFun, rdr->opool); - abstract->abs_lin_fun->name = "_"; - abstract->abs_lin_fun->type = gu_new(PgfType, rdr->opool); - abstract->abs_lin_fun->type->hypos = NULL; - abstract->abs_lin_fun->type->cid = "_"; - abstract->abs_lin_fun->type->n_exprs = 0; - abstract->abs_lin_fun->arity = 0; - abstract->abs_lin_fun->defns = NULL; - abstract->abs_lin_fun->ep.prob = INFINITY; - abstract->abs_lin_fun->ep.expr = gu_null_variant; -} - -static PgfCIdMap* -pgf_read_printnames(PgfReader* rdr) -{ - PgfCIdMap* printnames = gu_new_string_map(GuString, &gu_null_struct, rdr->opool); - - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - for (size_t i = 0; i < len; i++) { - PgfCId name = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, NULL); - - GuString printname = pgf_read_string(rdr); - gu_return_on_exn(rdr->err, NULL); - - gu_map_put(printnames, name, GuString, printname); - } - - return printnames; -} - -static PgfSymbols* -pgf_read_symbols(PgfReader* rdr); - -static void -pgf_read_alternative(PgfReader* rdr, PgfAlternative* alt) -{ - alt->form = pgf_read_symbols(rdr); - gu_return_on_exn(rdr->err,); - - size_t n_prefixes = pgf_read_len(rdr); - gu_return_on_exn(rdr->err,); - - alt->prefixes = gu_new_seq(GuString, n_prefixes, rdr->opool); - for (size_t i = 0; i < n_prefixes; i++) { - GuString prefix = pgf_read_string(rdr); - gu_return_on_exn(rdr->err,); - - gu_seq_set(alt->prefixes, GuString, i, prefix); - } -} - -static PgfSymbol -pgf_read_symbol(PgfReader* rdr) -{ - PgfSymbol sym = gu_null_variant; - - uint8_t tag = pgf_read_tag(rdr); - switch (tag) { - case PGF_SYMBOL_CAT: { - PgfSymbolCat *sym_cat = - gu_new_variant(PGF_SYMBOL_CAT, - PgfSymbolCat, - &sym, rdr->opool); - - sym_cat->d = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - sym_cat->r = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_LIT: { - PgfSymbolLit *sym_lit = - gu_new_variant(PGF_SYMBOL_LIT, - PgfSymbolLit, - &sym, rdr->opool); - - sym_lit->d = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - sym_lit->r = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_VAR: { - PgfSymbolVar *sym_var = - gu_new_variant(PGF_SYMBOL_VAR, - PgfSymbolVar, - &sym, rdr->opool); - - sym_var->d = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - sym_var->r = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_KS: { - size_t len = pgf_read_len(rdr); - uint8_t* buf = alloca(len*6+1); - uint8_t* p = buf; - for (size_t i = 0; i < len; i++) { - gu_in_utf8_buf(&p, rdr->in, rdr->err); - gu_return_on_exn(rdr->err, gu_null_variant); - } - *p++ = 0; - - PgfSymbolKS *sym_ks = - gu_new_flex_variant(PGF_SYMBOL_KS, - PgfSymbolKS, - token, p-buf, - &sym, rdr->opool); - strcpy((char*) sym_ks->token, (char*) buf); - break; - } - case PGF_SYMBOL_KP: { - PgfSymbols* default_form = pgf_read_symbols(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - size_t n_forms = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, gu_null_variant); - - PgfSymbolKP *sym_kp = - gu_new_flex_variant(PGF_SYMBOL_KP, - PgfSymbolKP, forms, n_forms, - &sym, rdr->opool); - sym_kp->default_form = default_form; - sym_kp->n_forms = n_forms; - - for (size_t i = 0; i < sym_kp->n_forms; i++) { - pgf_read_alternative(rdr, &sym_kp->forms[i]); - gu_return_on_exn(rdr->err, gu_null_variant); - } - break; - } - case PGF_SYMBOL_NE: { - gu_new_variant(PGF_SYMBOL_NE, - PgfSymbolNE, - &sym, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_BIND: { - gu_new_variant(PGF_SYMBOL_BIND, - PgfSymbolBIND, - &sym, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_SOFT_BIND: { - gu_new_variant(PGF_SYMBOL_SOFT_BIND, - PgfSymbolBIND, - &sym, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_SOFT_SPACE: { - gu_new_variant(PGF_SYMBOL_SOFT_SPACE, - PgfSymbolBIND, - &sym, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_CAPIT: { - gu_new_variant(PGF_SYMBOL_CAPIT, - PgfSymbolCAPIT, - &sym, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - case PGF_SYMBOL_ALL_CAPIT: { - gu_new_variant(PGF_SYMBOL_ALL_CAPIT, - PgfSymbolCAPIT, - &sym, rdr->opool); - gu_return_on_exn(rdr->err, gu_null_variant); - break; - } - default: - pgf_read_tag_error(rdr); - } - - return sym; -} - -static PgfSymbols* -pgf_read_symbols(PgfReader* rdr) -{ - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfSymbols* syms = gu_new_seq(PgfSymbol, len, rdr->opool); - - for (size_t i = 0; i < len; i++) { - PgfSymbol sym = pgf_read_symbol(rdr); - gu_return_on_exn(rdr->err, NULL); - gu_seq_set(syms, PgfSymbol, i, sym); - } - - return syms; -} - -static PgfSequences* -pgf_read_sequences(PgfReader* rdr) -{ - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfSequences* seqs = gu_new_seq(PgfSequence, len, rdr->opool); - - for (size_t i = 0; i < len; i++) { - PgfSymbols* syms = pgf_read_symbols(rdr); - gu_return_on_exn(rdr->err, NULL); - - gu_seq_index(seqs, PgfSequence, i)->syms = syms; - gu_seq_index(seqs, PgfSequence, i)->idx = NULL; - } - - return seqs; -} - -static PgfCncFun* -pgf_read_cncfun(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, int funid) -{ - PgfCId name = pgf_read_cid(rdr, rdr->tmp_pool); - gu_return_on_exn(rdr->err, NULL); - - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfAbsFun* absfun = - gu_seq_binsearch(abstr->funs, pgf_absfun_order, PgfAbsFun, name); - - PgfCncFun* cncfun = gu_new_flex(rdr->opool, PgfCncFun, lins, len); - cncfun->absfun = absfun; - cncfun->ep = (absfun == NULL) ? NULL : &absfun->ep; - cncfun->funid = funid; - cncfun->n_lins = len; - - for (size_t i = 0; i < len; i++) { - size_t seqid = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, NULL); - - if (seqid >= gu_seq_length(concr->sequences)) { - gu_raise(rdr->err, PgfReadExn); - return NULL; - } - - cncfun->lins[i] = gu_seq_index(concr->sequences, PgfSequence, seqid); - } - - return cncfun; -} - -static PgfCncFuns* -pgf_read_cncfuns(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr) -{ - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfCncFuns* cncfuns = gu_new_seq(PgfCncFun*, len, rdr->opool); - - for (size_t funid = 0; funid < len; funid++) { - PgfCncFun* cncfun = pgf_read_cncfun(rdr, abstr, concr, funid); - gu_return_on_exn(rdr->err, NULL); - - gu_seq_set(cncfuns, PgfCncFun*, funid, cncfun); - } - - return cncfuns; -} - -static PgfCCat* -pgf_read_fid(PgfReader* rdr, PgfConcr* concr) -{ - int fid = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfCCat* ccat = gu_map_get(concr->ccats, &fid, PgfCCat*); - if (!ccat) { - ccat = gu_new(PgfCCat, rdr->opool); - ccat->cnccat = NULL; - ccat->lindefs = NULL; - ccat->linrefs = NULL; - ccat->n_synprods = 0; - ccat->prods = NULL; - ccat->viterbi_prob = 0; - ccat->fid = fid; - ccat->chunk_count = 1; - ccat->conts = NULL; - ccat->answers = NULL; - - gu_map_put(concr->ccats, &fid, PgfCCat*, ccat); - } - - return ccat; -} - -static PgfCncFun* -pgf_read_funid(PgfReader* rdr, PgfConcr* concr) -{ - size_t funid = pgf_read_int(rdr); - gu_return_on_exn(rdr->err, NULL); - - if (funid >= gu_seq_length(concr->cncfuns)) { - gu_raise(rdr->err, PgfReadExn); - return NULL; - } - - return gu_seq_get(concr->cncfuns, PgfCncFun*, funid); -} - -static void -pgf_read_lindefs(PgfReader* rdr, PgfConcr* concr) -{ - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - for (size_t i = 0; i < len; i++) { - PgfCCat* ccat = pgf_read_fid(rdr, concr); - - size_t n_funs = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - ccat->lindefs = gu_new_seq(PgfCncFun*, n_funs, rdr->opool); - for (size_t j = 0; j < n_funs; j++) { - PgfCncFun* fun = pgf_read_funid(rdr, concr); - fun->absfun = concr->abstr->abs_lin_fun; - gu_seq_set(ccat->lindefs, PgfCncFun*, j, fun); - } - } -} - -static void -pgf_read_linrefs(PgfReader* rdr, PgfConcr* concr) -{ - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - for (size_t i = 0; i < len; i++) { - PgfCCat* ccat = pgf_read_fid(rdr, concr); - - size_t n_funs = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - ccat->linrefs = gu_new_seq(PgfCncFun*, n_funs, rdr->opool); - for (size_t j = 0; j < n_funs; j++) { - PgfCncFun* fun = pgf_read_funid(rdr, concr); - fun->absfun = concr->abstr->abs_lin_fun; - gu_seq_set(ccat->linrefs, PgfCncFun*, j, fun); - } - } -} - -static void -pgf_read_parg(PgfReader* rdr, PgfConcr* concr, PgfPArg* parg) -{ - size_t n_hoas = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - parg->hypos = gu_new_seq(PgfCCat*, n_hoas, rdr->opool); - for (size_t i = 0; i < n_hoas; i++) { - gu_seq_set(parg->hypos, PgfCCat*, i, pgf_read_fid(rdr, concr)); - gu_return_on_exn(rdr->err, ); - } - - parg->ccat = pgf_read_fid(rdr, concr); - gu_return_on_exn(rdr->err, ); -} - -static PgfPArgs* -pgf_read_pargs(PgfReader* rdr, PgfConcr* concr) -{ - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfPArgs* pargs = gu_new_seq(PgfPArg, len, rdr->opool); - for (size_t i = 0; i < len; i++) { - PgfPArg* parg = gu_seq_index(pargs, PgfPArg, i); - pgf_read_parg(rdr, concr, parg); - } - - return pargs; -} - -PGF_API bool -pgf_production_is_lexical(PgfProductionApply *papp, - GuBuf* non_lexical_buf, GuPool* pool) -{ - if (gu_seq_length(papp->args) > 0) - return false; - - for (size_t lin_idx = 0; lin_idx < papp->fun->n_lins; lin_idx++) { - PgfSequence* seq = papp->fun->lins[lin_idx]; - - if (seq->idx == NULL) { - size_t n_syms = gu_seq_length(seq->syms); - for (size_t i = 0; i < n_syms; i++) { - PgfSymbol sym = gu_seq_get(seq->syms, PgfSymbol, i); - GuVariantInfo inf = gu_variant_open(sym); - if (inf.tag == PGF_SYMBOL_KP || - inf.tag == PGF_SYMBOL_BIND || - inf.tag == PGF_SYMBOL_NE || - inf.tag == PGF_SYMBOL_SOFT_BIND || - inf.tag == PGF_SYMBOL_SOFT_SPACE || - inf.tag == PGF_SYMBOL_CAPIT || - inf.tag == PGF_SYMBOL_ALL_CAPIT) { - seq->idx = non_lexical_buf; - return false; - } - } - - seq->idx = gu_new_buf(PgfProductionIdxEntry, pool); - } if (seq->idx == non_lexical_buf) { - return false; - } - } - - return true; -} - -static void -pgf_read_production(PgfReader* rdr, PgfConcr* concr, - PgfCCat* ccat, size_t* top, size_t* bot) -{ - PgfProduction prod = gu_null_variant; - bool is_lexical = false; - - uint8_t tag = pgf_read_tag(rdr); - switch (tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply *papp = - gu_new_variant(PGF_PRODUCTION_APPLY, - PgfProductionApply, - &prod, rdr->opool); - - papp->fun = pgf_read_funid(rdr, concr); - gu_return_on_exn(rdr->err, ); - - papp->args = pgf_read_pargs(rdr, concr); - gu_return_on_exn(rdr->err, ); - - is_lexical = pgf_production_is_lexical(papp, rdr->non_lexical_buf, rdr->opool); - if (!is_lexical) - gu_seq_set(ccat->prods, PgfProduction, (*top)++, prod); - else - gu_seq_set(ccat->prods, PgfProduction, (*bot)--, prod); - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce *pcoerce = - gu_new_variant(PGF_PRODUCTION_COERCE, - PgfProductionCoerce, - &prod, rdr->opool); - - pcoerce->coerce = pgf_read_fid(rdr, concr); - gu_return_on_exn(rdr->err, ); - - gu_seq_set(ccat->prods, PgfProduction, (*top)++, prod); - break; - } - default: - pgf_read_tag_error(rdr); - } - - pgf_parser_index(concr, ccat, prod, is_lexical, rdr->opool); - pgf_lzr_index(concr, ccat, prod, is_lexical, rdr->opool); -} - -static void -pgf_read_ccats(PgfReader* rdr, PgfConcr* concr) -{ - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, ); - - for (size_t i = 0; i < len; i++) { - PgfCCat* ccat = pgf_read_fid(rdr, concr); - - size_t n_prods = pgf_read_len(rdr); - gu_return_on_exn(rdr->err,); - - ccat->prods = gu_new_seq(PgfProduction, n_prods, rdr->opool); - - size_t top = 0; - size_t bot = n_prods-1; - for (size_t i = 0; i < n_prods; i++) { - pgf_read_production(rdr, concr, ccat, &top, &bot); - gu_return_on_exn(rdr->err, ); - } - - ccat->n_synprods = top; - } -} - -static PgfCncCat* -pgf_read_cnccat(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, PgfCId name) -{ - int first = pgf_read_int(rdr); - int last = pgf_read_int(rdr); - int n_lins = pgf_read_len(rdr); - - PgfCncCat* cnccat = - gu_malloc(rdr->opool, sizeof(PgfCncCat)+n_lins*sizeof(GuString)); - - cnccat->abscat = - gu_seq_binsearch(abstr->cats, pgf_abscat_order, PgfAbsCat, name); - if (cnccat->abscat == NULL) { - fprintf(stderr, "Abstract category %s is missing\n", name); - gu_assert(cnccat->abscat != NULL); - } - - int len = last + 1 - first; - cnccat->cats = gu_new_seq(PgfCCat*, len, rdr->opool); - - for (int i = 0; i < len; i++) { - int fid = first + i; - PgfCCat* ccat = gu_map_get(concr->ccats, &fid, PgfCCat*); - if (!ccat) { - ccat = gu_new(PgfCCat, rdr->opool); - ccat->cnccat = NULL; - ccat->lindefs = NULL; - ccat->linrefs = NULL; - ccat->n_synprods = 0; - ccat->prods = NULL; - ccat->viterbi_prob = 0; - ccat->fid = fid; - ccat->chunk_count = 1; - ccat->conts = NULL; - ccat->answers = NULL; - - gu_map_put(concr->ccats, &fid, PgfCCat*, ccat); - } - gu_seq_set(cnccat->cats, PgfCCat*, i, ccat); - - ccat->cnccat = cnccat; - } - - cnccat->n_lins = n_lins; - for (size_t i = 0; i < cnccat->n_lins; i++) { - cnccat->labels[i] = pgf_read_string(rdr); - } - - return cnccat; -} - -static PgfCIdMap* -pgf_read_cnccats(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr) -{ - PgfCIdMap* cnccats = gu_new_string_map(PgfCncCat, &gu_null_struct, rdr->opool); - - size_t len = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - for (size_t i = 0; i < len; i++) { - PgfCId name = pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, NULL); - - PgfCncCat* cnccat = - pgf_read_cnccat(rdr, abstr, concr, name); - gu_return_on_exn(rdr->err, NULL); - - gu_map_put(cnccats, name, PgfCncCat*, cnccat); - } - - return cnccats; -} - -static void -pgf_ccat_set_cnccat(PgfCCat* ccat, PgfProduction prod) -{ - GuVariantInfo i = gu_variant_open(prod); - switch (i.tag) { - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce* pcoerce = i.data; - PgfCncCat* cnccat = pcoerce->coerce->cnccat; - if (!ccat->cnccat) { - ccat->cnccat = cnccat; - } else if (ccat->cnccat != cnccat) { - // XXX: real error - gu_impossible(); - } - break; - } - case PGF_PRODUCTION_APPLY: - // Shouldn't happen with current PGF. - // XXX: real error - gu_impossible(); - break; - default: - gu_impossible(); - } -} - -extern prob_t -pgf_ccat_set_viterbi_prob(PgfCCat* ccat); - -static void -pgf_read_ccat_cb(GuMapItor* fn, const void* key, void* value, GuExn* err) -{ - (void) (fn && key && err); - PgfCCat* ccat = *((PgfCCat**) value); - - if (ccat->prods == NULL) - return; - - size_t n_prods = gu_seq_length(ccat->prods); - for (size_t i = 0; i < n_prods; i++) { - PgfProduction prod = - gu_seq_get(ccat->prods, PgfProduction, i); - - if (!ccat->cnccat) { - pgf_ccat_set_cnccat(ccat, prod); - } - } - -// pgf_ccat_set_viterbi_prob(ccat); -} - -// The GF compiler needs to call this function when building in memory grammars. -PGF_API void -pgf_concrete_fix_internals(PgfConcr* concr) -{ - GuMapItor clo1 = { pgf_read_ccat_cb }; - gu_map_iter(concr->ccats, &clo1, NULL); -} - -static void -pgf_read_concrete_content(PgfReader* rdr, PgfConcr* concr) -{ - concr->printnames = - pgf_read_printnames(rdr); - gu_return_on_exn(rdr->err,); - - concr->sequences = - pgf_read_sequences(rdr); - gu_return_on_exn(rdr->err,); - - concr->cncfuns = - pgf_read_cncfuns(rdr, concr->abstr, concr); - gu_return_on_exn(rdr->err,); - - concr->ccats = - gu_new_int_map(PgfCCat*, &gu_null_struct, rdr->opool); - concr->fun_indices = gu_new_string_map(PgfCncOverloadMap*, &gu_null_struct, rdr->opool); - concr->coerce_idx = gu_new_addr_map(PgfCCat*, GuBuf*, &gu_null_struct, rdr->opool); - pgf_read_lindefs(rdr, concr); - pgf_read_linrefs(rdr, concr); - pgf_read_ccats(rdr, concr); - concr->cnccats = pgf_read_cnccats(rdr, concr->abstr, concr); - concr->total_cats = pgf_read_int(rdr); - - pgf_concrete_fix_internals(concr); -} - -static void -pgf_read_concrete_init_header(PgfConcr* concr) -{ - concr->printnames = NULL; - concr->sequences = NULL; - concr->cncfuns = NULL; - concr->ccats = NULL; - concr->fun_indices = NULL; - concr->coerce_idx = NULL; - concr->cnccats = NULL; - concr->total_cats = 0; -} - -static void -gu_concr_fini(GuFinalizer* fin) -{ - PgfConcr* concr = gu_container(fin, PgfConcr, fin); - - if (concr->pool != NULL) { - pgf_read_concrete_init_header(concr); - gu_pool_free(concr->pool); - concr->pool = NULL; - } -} - -static PgfConcr* -pgf_read_concrete(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, bool with_content) -{ - concr->name = - pgf_read_cid(rdr, rdr->opool); - gu_return_on_exn(rdr->err, NULL); - - concr->abstr = abstr; - - concr->cflags = - pgf_read_flags(rdr); - gu_return_on_exn(rdr->err, NULL); - - concr->pool = NULL; - - if (with_content) { - pgf_read_concrete_content(rdr, concr); - - concr->fin.fn = NULL; - } else { - pgf_read_concrete_init_header(concr); - - concr->fin.fn = gu_concr_fini; - gu_pool_finally(rdr->opool, &concr->fin); - } - gu_return_on_exn(rdr->err, NULL); - - return concr; -} - -PGF_API void -pgf_concrete_load(PgfConcr* concr, GuIn* in, GuExn* err) -{ - if (concr->fin.fn == NULL || concr->pool != NULL) - return; // already loaded - - GuPool* pool = gu_new_pool(); - GuPool* tmp_pool = gu_local_pool(); - - PgfReader* rdr = pgf_new_reader(in, pool, tmp_pool, err); - - PgfCId name = - pgf_read_cid(rdr, rdr->tmp_pool); - gu_return_on_exn(rdr->err, ); - - if (strcmp(name, concr->name) != 0) { - GuExnData* err_data = gu_raise(rdr->err, PgfExn); - if (err_data) { - err_data->data = "This file contains different concrete syntax"; - gu_pool_free(tmp_pool); - gu_pool_free(pool); - return; - } - } - - concr->pool = pool; - - pgf_read_flags(rdr); - if (gu_exn_is_raised(rdr->err)) - goto end; - - pgf_read_concrete_content(rdr, concr); - if (gu_exn_is_raised(rdr->err)) - goto end; - -end: - gu_pool_free(tmp_pool); -} - -PGF_API void -pgf_concrete_unload(PgfConcr* concr) -{ - if (concr->fin.fn == NULL) - return; - - gu_concr_fini(&concr->fin); -} - -static PgfConcrs* -pgf_read_concretes(PgfReader* rdr, PgfAbstr* abstr, bool with_content) -{ - size_t n_concrs = pgf_read_len(rdr); - gu_return_on_exn(rdr->err, NULL); - - PgfConcrs* concretes = gu_new_seq(PgfConcr, n_concrs, rdr->opool); - - for (size_t i = 0; i < n_concrs; i++) { - PgfConcr* concr = gu_seq_index(concretes, PgfConcr, i); - pgf_read_concrete(rdr, abstr, concr, with_content); - gu_return_on_exn(rdr->err, NULL); - } - - return concretes; -} - -PGF_INTERNAL PgfPGF* -pgf_read_pgf(PgfReader* rdr) { - PgfPGF* pgf = gu_new(PgfPGF, rdr->opool); - - pgf->major_version = gu_in_u16be(rdr->in, rdr->err); - gu_return_on_exn(rdr->err, NULL); - - pgf->minor_version = gu_in_u16be(rdr->in, rdr->err); - gu_return_on_exn(rdr->err, NULL); - - pgf->gflags = pgf_read_flags(rdr); - gu_return_on_exn(rdr->err, NULL); - - pgf_read_abstract(rdr, &pgf->abstract); - gu_return_on_exn(rdr->err, NULL); - - bool with_content = - (gu_seq_binsearch(pgf->gflags, pgf_flag_order, PgfFlag, "split") == NULL); - pgf->concretes = pgf_read_concretes(rdr, &pgf->abstract, with_content); - gu_return_on_exn(rdr->err, NULL); - - pgf->pool = rdr->opool; - - return pgf; -} - -PGF_INTERNAL PgfReader* -pgf_new_reader(GuIn* in, GuPool* opool, GuPool* tmp_pool, GuExn* err) -{ - PgfReader* rdr = gu_new(PgfReader, tmp_pool); - rdr->opool = opool; - rdr->tmp_pool = tmp_pool; - rdr->err = err; - rdr->in = in; - rdr->non_lexical_buf = gu_new_buf(PgfProductionIdxEntry, opool); - rdr->jit_state = pgf_new_jit(rdr); - return rdr; -} - -PGF_INTERNAL void -pgf_reader_done(PgfReader* rdr, PgfPGF* pgf) -{ - if (pgf == NULL) - return; - - pgf_jit_done(rdr, &pgf->abstract); -} diff --git a/src/runtime/c/pgf/reader.h b/src/runtime/c/pgf/reader.h deleted file mode 100644 index a5644e4d5..000000000 --- a/src/runtime/c/pgf/reader.h +++ /dev/null @@ -1,73 +0,0 @@ -#ifndef READER_H_ -#define READER_H_ - -#include -#include -#include - -// general reader interface - -typedef struct { - GuIn* in; - GuExn* err; - GuPool* opool; - GuPool* tmp_pool; - GuBuf* non_lexical_buf; - struct PgfJitState* jit_state; -} PgfReader; - -PGF_INTERNAL_DECL PgfReader* -pgf_new_reader(GuIn* in, GuPool* opool, GuPool* tmp_pool, GuExn* err); - -PGF_INTERNAL_DECL uint8_t -pgf_read_tag(PgfReader* rdr); - -PGF_INTERNAL_DECL uint32_t -pgf_read_uint(PgfReader* rdr); - -PGF_INTERNAL_DECL int32_t -pgf_read_int(PgfReader* rdr); - -PGF_INTERNAL_DECL GuString -pgf_read_string(PgfReader* rdr); - -PGF_INTERNAL_DECL double -pgf_read_double(PgfReader* rdr); - -PGF_INTERNAL_DECL size_t -pgf_read_len(PgfReader* rdr); - -PGF_INTERNAL_DECL PgfCId -pgf_read_cid(PgfReader* rdr, GuPool* pool); - -PGF_INTERNAL_DECL PgfPGF* -pgf_read_pgf(PgfReader* rdr); - -PGF_INTERNAL_DECL void -pgf_reader_done(PgfReader* rdr, PgfPGF* pgf); - - -// JIT specific interface -#ifdef PGF_REASONER_H_ - -typedef struct PgfJitState PgfJitState; - -PGF_INTERNAL_DECL PgfJitState* -pgf_new_jit(PgfReader* rdr); - -PGF_INTERNAL_DECL PgfEvalGates* -pgf_jit_gates(PgfReader* rdr); - -PGF_INTERNAL_DECL void -pgf_jit_predicate(PgfReader* rdr, PgfAbstr* abstr, - PgfAbsCat* abscat); - -PGF_INTERNAL_DECL void -pgf_jit_function(PgfReader* rdr, PgfAbstr* abstr, - PgfAbsFun* absfun); - -PGF_INTERNAL_DECL void -pgf_jit_done(PgfReader* state, PgfAbstr* abstr); - -#endif -#endif // READER_H_ diff --git a/src/runtime/c/pgf/reasoner.c b/src/runtime/c/pgf/reasoner.c deleted file mode 100644 index 67714519f..000000000 --- a/src/runtime/c/pgf/reasoner.c +++ /dev/null @@ -1,475 +0,0 @@ -#include -#include -#include -#include - -//#define PGF_REASONER_DEBUG - -typedef struct { - GuBuf* parents; - GuBuf* exprs; - prob_t outside_prob; -} PgfAnswers; - -#ifdef PGF_REASONER_DEBUG -typedef void (*PgfStatePrinter)(PgfReasoner* rs, PgfReasonerState* st, - GuOut* out, GuExn* err, - GuPool* tmp_pool); -#endif - -struct PgfReasonerState { - PgfClosure header; -#ifdef PGF_REASONER_DEBUG - PgfStatePrinter print; -#endif - prob_t prob; -}; - -struct PgfExprState { - // base must be the first field in order to be able to cast - // from PgfExprState to PgfReasonerState - PgfReasonerState base; - PgfAnswers* answers; - PgfExpr expr; -#ifdef PGF_REASONER_DEBUG - size_t n_args; - size_t arg_idx; -#endif -}; - -typedef struct { - // base must be the first field in order to be able to cast - // from PgfCombine1State to PgfReasonerState - PgfReasonerState base; - GuBuf* exprs; - PgfExprState* parent; - size_t n_choices; - size_t choice; -} PgfCombine1State; - -typedef struct { - // base must be the first field in order to be able to cast - // from PgfCombine2State to PgfReasonerState - PgfReasonerState base; - GuBuf* parents; - PgfExprProb* ep; - size_t n_choices; - size_t choice; -} PgfCombine2State; - -static int -cmp_expr_state(GuOrder* self, const void* a, const void* b) -{ - PgfReasonerState *st1 = *((PgfReasonerState **) a); - PgfReasonerState *st2 = *((PgfReasonerState **) b); - - if (st1->prob < st2->prob) - return -1; - else if (st1->prob > st2->prob) - return 1; - else - return 0; -} - -static GuOrder -pgf_expr_state_order = { cmp_expr_state }; - -#ifdef PGF_REASONER_DEBUG -static void -pgf_print_parent_state(PgfReasoner* rs, PgfExprState* st, - GuOut* out, GuExn* err, GuBuf* stack) -{ - gu_buf_push(stack, int, (st->n_args - st->arg_idx - 1)); - - PgfExprState* parent = gu_buf_get(st->answers->parents, PgfExprState*, 0); - if (&parent->base.header != rs->start) - pgf_print_parent_state(rs, parent, out, err, stack); - - gu_puts(" (", out, err); - pgf_print_expr(st->expr, NULL, 0, out, err); -} - -static void -pgf_print_expr_state(PgfReasoner* rs, PgfExprState* st, - GuOut* out, GuExn* err, GuPool* tmp_pool) -{ - gu_printf(out, err, "[%f] ", st->base.prob); - - GuBuf* stack = gu_new_buf(int, tmp_pool); - if (st->n_args > 0) - gu_buf_push(stack, int, st->n_args - st->arg_idx); - - PgfExprState* cont = - gu_buf_get(st->answers->parents, PgfExprState*, 0); - if (&cont->base.header != rs->start) - pgf_print_parent_state(rs, cont, out, err, stack); - - if (st->n_args > 0) - gu_puts(" (", out, err); - else - gu_puts(" ", out, err); - pgf_print_expr(st->expr, NULL, 0, out, err); - - size_t n_counts = gu_buf_length(stack); - for (size_t i = 0; i < n_counts; i++) { - int count = gu_buf_get(stack, int, i); - while (count-- > 0) - gu_puts(" ?", out, err); - - gu_puts(")", out, err); - } - gu_puts("\n", out, err); -} -#endif - -static PgfExprState* -pgf_combine1_to_expr(PgfCombine1State* st, GuPool* pool, GuPool* out_pool) { - PgfExprProb* ep = - gu_buf_get(st->exprs, PgfExprProb*, st->choice); - - PgfExprState* nst = gu_new(PgfExprState, pool); - nst->base.header.code = st->parent->base.header.code; - nst->base.prob = st->base.prob; - nst->answers = st->parent->answers; - nst->expr = - gu_new_variant_i(out_pool, PGF_EXPR_APP, - PgfExprApp, - .fun = st->parent->expr, - .arg = ep->expr); -#ifdef PGF_REASONER_DEBUG - nst->base.print = (PgfStatePrinter) pgf_print_expr_state; - nst->n_args = st->parent->n_args; - nst->arg_idx = st->parent->arg_idx+1; -#endif - - return nst; -} - -static PgfExprState* -pgf_combine2_to_expr(PgfReasoner* rs, PgfCombine2State* st, - GuPool* pool, GuPool* out_pool) -{ - PgfExprState* parent = - gu_buf_get(st->parents, PgfExprState*, st->choice); - if (&parent->base.header == rs->start) - return NULL; - - PgfExprState* nst = - gu_new(PgfExprState, pool); - nst->base.header.code = parent->base.header.code; - nst->base.prob = st->base.prob; - nst->answers = parent->answers; - nst->expr = - gu_new_variant_i(out_pool, PGF_EXPR_APP, - PgfExprApp, - .fun = parent->expr, - .arg = st->ep->expr); -#ifdef PGF_REASONER_DEBUG - nst->base.print = (PgfStatePrinter) pgf_print_expr_state; - nst->n_args = parent->n_args; - nst->arg_idx = parent->arg_idx+1; -#endif - - return nst; -} - -#ifdef PGF_REASONER_DEBUG -static void -pgf_print_combine1_state(PgfReasoner* rs, PgfCombine1State* st, - GuOut* out, GuExn* err, GuPool* tmp_pool) -{ - PgfExprState* nst = pgf_combine1_to_expr(st, tmp_pool, tmp_pool); - pgf_print_expr_state(rs, nst, out, err, tmp_pool); -} - -static void -pgf_print_combine2_state(PgfReasoner* rs, PgfCombine2State* st, - GuOut* out, GuExn* err, GuPool* tmp_pool) -{ - PgfExprState* nst = pgf_combine2_to_expr(rs, st, tmp_pool, tmp_pool); - if (nst != NULL) - pgf_print_expr_state(rs, nst, out, err, tmp_pool); -} -#endif - -PGF_INTERNAL void -pgf_reasoner_combine1(PgfReasoner* rs, PgfClosure* closure) -{ - PgfCombine1State* st = (PgfCombine1State*) closure; - PgfExprState* nst = pgf_combine1_to_expr(st, rs->pool, rs->out_pool); - rs->eval_gates->enter(rs, &nst->base.header); - - st->choice++; - - if (st->choice < st->n_choices) { - PgfExprProb* ep = - gu_buf_get(st->exprs, PgfExprProb*, st->choice); - - st->base.prob = st->parent->base.prob + ep->prob; - gu_buf_heap_push(rs->pqueue, &pgf_expr_state_order, &st); - } -} - -PGF_INTERNAL void -pgf_reasoner_try_first(PgfReasoner* rs, PgfExprState* parent, PgfAbsFun* absfun) -{ - PgfCId cat = absfun->type->cid; - - PgfAnswers* answers = gu_map_get(rs->table, cat, PgfAnswers*); - if (answers == NULL) { - answers = gu_new(PgfAnswers, rs->pool); - answers->parents = gu_new_buf(PgfExprState*, rs->pool); - answers->exprs = gu_new_buf(PgfExprProb*, rs->pool); - answers->outside_prob = parent->base.prob; - - gu_map_put(rs->table, cat, PgfAnswers*, answers); - } - - gu_buf_push(answers->parents, PgfExprState*, parent); - - if (gu_buf_length(answers->parents) == 1) { - PgfExprState* st = gu_new(PgfExprState, rs->pool); - st->base.header.code = absfun->predicate; - st->base.prob = answers->outside_prob + absfun->ep.prob; - st->answers = answers; - st->expr = absfun->ep.expr; -#ifdef PGF_REASONER_DEBUG - st->base.print = (PgfStatePrinter) pgf_print_expr_state; - st->n_args = gu_seq_length(absfun->type->hypos); - st->arg_idx = 0; -#endif - gu_buf_heap_push(rs->pqueue, &pgf_expr_state_order, &st); - } else { - size_t n_exprs = gu_buf_length(answers->exprs); - if (n_exprs > 0) { - PgfExprProb* ep = - gu_buf_get(answers->exprs, PgfExprProb*, 0); - - PgfCombine1State* nst = gu_new(PgfCombine1State, rs->pool); - nst->base.header.code = rs->eval_gates->combine1; - nst->base.prob = parent->base.prob + ep->prob; - nst->exprs = answers->exprs; - nst->choice = 0; - nst->n_choices = gu_buf_length(answers->exprs); - nst->parent = parent; -#ifdef PGF_REASONER_DEBUG - nst->base.print = (PgfStatePrinter) pgf_print_combine1_state; -#endif - gu_buf_heap_push(rs->pqueue, &pgf_expr_state_order, &nst); - } - } -} - -PGF_INTERNAL void -pgf_reasoner_try_else(PgfReasoner* rs, PgfExprState* prev, PgfAbsFun* absfun) -{ - PgfExprState *st = gu_new(PgfExprState, rs->pool); - st->base.header.code = absfun->predicate; - st->base.prob = prev->answers->outside_prob + absfun->ep.prob; - st->answers = prev->answers; - st->expr = absfun->ep.expr; -#ifdef PGF_REASONER_DEBUG - st->base.print = (PgfStatePrinter) pgf_print_expr_state; - st->n_args = gu_seq_length(absfun->type->hypos); - st->arg_idx = 0; -#endif - gu_buf_heap_push(rs->pqueue, &pgf_expr_state_order, &st); -} - -PGF_INTERNAL void -pgf_reasoner_combine2(PgfReasoner* rs, PgfClosure* closure) -{ - PgfCombine2State* st = (PgfCombine2State*) closure; - PgfExprState* nst = pgf_combine2_to_expr(rs, st, rs->pool, rs->out_pool); - if (nst != NULL) { - rs->eval_gates->enter(rs, &nst->base.header); - } - - st->choice++; - - if (st->choice < st->n_choices) { - PgfExprState* parent = - gu_buf_get(st->parents, PgfExprState*, st->choice); - - st->base.prob = parent->base.prob + st->ep->prob; - gu_buf_heap_push(rs->pqueue, &pgf_expr_state_order, &st); - } -} - -PGF_INTERNAL void -pgf_reasoner_complete(PgfReasoner* rs, PgfExprState* st) -{ - PgfExprProb* ep = gu_new(PgfExprProb, rs->out_pool); - ep->prob = st->base.prob - st->answers->outside_prob; - ep->expr = st->expr; - gu_buf_push(st->answers->exprs, PgfExprProb*, ep); - - PgfCombine2State* nst = gu_new(PgfCombine2State, rs->pool); - nst->base.header.code = rs->eval_gates->combine2; - nst->base.prob = st->base.prob; - nst->parents = st->answers->parents; - nst->choice = 0; - nst->n_choices = gu_buf_length(st->answers->parents); - nst->ep = ep; -#ifdef PGF_REASONER_DEBUG - nst->base.print = (PgfStatePrinter) pgf_print_combine2_state; -#endif - rs->eval_gates->enter(rs, &nst->base.header); -} - -PGF_INTERNAL void -pgf_reasoner_try_constant(PgfReasoner* rs, PgfExprState* prev, PgfAbsFun* absfun) -{ - pgf_reasoner_try_else(rs, prev, absfun); - pgf_reasoner_complete(rs, prev); -} - -static void -pgf_reasoner_mk_literal(PgfReasoner* rs, PgfExprState* parent, - GuString cat, PgfExpr expr) -{ - PgfAnswers* answers = gu_map_get(rs->table, cat, PgfAnswers*); - if (answers == NULL) { - answers = gu_new(PgfAnswers, rs->pool); - answers->parents = gu_new_buf(PgfExprState*, rs->pool); - answers->exprs = gu_new_buf(PgfExprProb*, rs->pool); - answers->outside_prob = parent->base.prob; - - gu_map_put(rs->table, cat, PgfAnswers*, answers); - } - - gu_buf_push(answers->parents, PgfExprState*, parent); - - if (gu_buf_length(answers->parents) == 1) { - PgfExprProb* ep = gu_new(PgfExprProb, rs->out_pool); - ep->prob = 0; - ep->expr = expr; - gu_buf_push(answers->exprs, PgfExprProb*, ep); - } - - if (&parent->base.header == rs->start) - return; - - PgfExprProb* ep = - gu_buf_get(answers->exprs, PgfExprProb*, 0); - - parent->expr = - gu_new_variant_i(rs->out_pool, - PGF_EXPR_APP, - PgfExprApp, - parent->expr, - ep->expr); -#ifdef PGF_REASONER_DEBUG - parent->arg_idx++; -#endif - parent->base.prob += ep->prob; - gu_buf_heap_push(rs->pqueue, &pgf_expr_state_order, &parent); -} - -PGF_INTERNAL void -pgf_reasoner_mk_string(PgfReasoner* rs, PgfExprState* parent) -{ - pgf_reasoner_mk_literal(rs, parent, "String", - pgf_expr_string("__mock_string__", rs->out_pool)); -} - -PGF_INTERNAL void -pgf_reasoner_mk_int(PgfReasoner* rs, PgfExprState* parent) -{ - pgf_reasoner_mk_literal(rs, parent, "Int", - pgf_expr_int(999, rs->out_pool)); -} - -PGF_INTERNAL void -pgf_reasoner_mk_float(PgfReasoner* rs, PgfExprState* parent) -{ - pgf_reasoner_mk_literal(rs, parent, "Float", - pgf_expr_float(999.99, rs->out_pool)); -} - -static PgfExprProb* -pgf_reasoner_next(PgfReasoner* rs) -{ - for (;;) { - if (rs->n_reported_exprs < gu_buf_length(rs->exprs)) { - return gu_buf_get(rs->exprs, PgfExprProb*, rs->n_reported_exprs++); - } - - if (gu_buf_length(rs->pqueue) == 0) - return NULL; - - PgfReasonerState* st; - gu_buf_heap_pop(rs->pqueue, &pgf_expr_state_order, &st); - -#ifdef PGF_REASONER_DEBUG - { - GuPool* tmp_pool = gu_new_pool(); - GuOut* out = gu_file_out(stderr, tmp_pool); - GuExn* err = gu_exn(tmp_pool); - st->print(rs, st, out, err, tmp_pool); - gu_pool_free(tmp_pool); - } -#endif - - rs->eval_gates->enter(rs, &st->header); - } -} - -static void -pgf_reasoner_enum_next(GuEnum* self, void* to, GuPool* pool) -{ - PgfReasoner* pr = gu_container(self, PgfReasoner, en); - *(PgfExprProb**)to = pgf_reasoner_next(pr); -} - -PGF_INTERNAL PgfReasoner* -pgf_new_reasoner(PgfPGF* pgf, GuExn* err, GuPool* pool, GuPool* out_pool) -{ - size_t n_cafs = - (pgf->abstract.eval_gates->cafs == NULL) - ? 0 : gu_seq_length(pgf->abstract.eval_gates->cafs); - - PgfReasoner* rs = gu_new_flex(pool, PgfReasoner, cafs, n_cafs); - rs->pool = pool, - rs->out_pool = out_pool; - rs->err = err; - rs->abstract = &pgf->abstract, - rs->table = gu_new_string_map(PgfAnswers*, &gu_null_struct, rs->pool), - - rs->start = NULL; - rs->eval_gates = pgf->abstract.eval_gates; - - rs->pqueue = gu_new_buf(PgfReasonerState*, rs->pool); - rs->exprs = gu_new_buf(PgfExprProb*, rs->pool); - rs->n_reported_exprs = 0; - rs->en.next = pgf_reasoner_enum_next; - - PgfFunction* cafs = gu_seq_data(rs->eval_gates->cafs); - for (size_t i = 0; i < n_cafs; i++) { - rs->cafs[i].header.code = cafs[i]; - rs->cafs[i].val = NULL; - } - - return rs; -} - -PGF_API PgfExprEnum* -pgf_generate_all(PgfPGF* pgf, PgfType* typ, GuExn* err, GuPool* pool, GuPool* out_pool) -{ - PgfReasoner* rs = pgf_new_reasoner(pgf, err, pool, out_pool); - - PgfAnswers* answers = gu_new(PgfAnswers, rs->pool); - answers->parents = gu_new_buf(PgfExprState*, rs->pool); - answers->exprs = rs->exprs; - answers->outside_prob = 0; - gu_map_put(rs->table, typ->cid, PgfAnswers*, answers); - - PgfAbsCat* abscat = gu_seq_binsearch(rs->abstract->cats, pgf_abscat_order, PgfAbsCat, typ->cid); - if (abscat != NULL) { - rs->start = gu_new(PgfClosure, rs->pool); - rs->start->code = abscat->predicate; - rs->eval_gates->enter(rs, rs->start); - } - - return &rs->en; -} diff --git a/src/runtime/c/pgf/reasoner.h b/src/runtime/c/pgf/reasoner.h deleted file mode 100644 index d0ed09c42..000000000 --- a/src/runtime/c/pgf/reasoner.h +++ /dev/null @@ -1,174 +0,0 @@ -#ifndef PGF_REASONER_H_ -#define PGF_REASONER_H_ - -typedef GuStringMap PgfAbswersMap; - -typedef struct PgfReasoner PgfReasoner; -typedef struct PgfReasonerState PgfReasonerState; -typedef struct PgfExprState PgfExprState; - -typedef struct { - PgfFunction code; -} PgfClosure; - -typedef struct { - PgfClosure header; - PgfClosure* val; -} PgfIndirection; - -typedef struct { - PgfLiteral lit; - GuBuf* consts; - void* enter_stack_ptr; -} PgfEvalAccum; - -struct PgfReasoner { - GuPool* pool; - GuPool* out_pool; - PgfAbstr* abstract; - PgfAbswersMap* table; - GuBuf* pqueue; - GuBuf* exprs; - size_t n_reported_exprs; - PgfClosure* start; - PgfEvalGates* eval_gates; // cached from pgf->abstr->eval_gates - GuExn* err; - void* enter_stack_ptr; - void* tmp; // for temporary register spills - PgfExprEnum en; - PgfIndirection cafs[]; // derived from gu_seq_data(pgf->abstr->eval_gates->cafs) -}; - -typedef struct PgfEnv PgfEnv; - -struct PgfEnv { - PgfEnv* next; - PgfClosure* closure; -}; - -typedef struct { - PgfClosure header; - PgfEnv* env; - PgfExpr expr; -} PgfExprThunk; - -typedef struct { - PgfClosure header; - PgfClosure* con; - PgfClosure* args[]; -} PgfValue; - -typedef struct { - PgfClosure header; - int level; -} PgfValueGen; - -typedef struct { - PgfClosure header; - PgfEnv* env; - PgfMetaId id; -} PgfValueMeta; - -typedef struct { - PgfClosure header; - PgfLiteral lit; -} PgfValueLit; - -typedef struct { - PgfClosure header; - PgfLiteral lit; - GuBuf* consts; -} PgfValueSum; - -typedef struct { - PgfClosure header; - PgfClosure* fun; - size_t n_args; - PgfClosure* args[]; -} PgfValuePAP; - -struct PgfEvalGates { - PgfFunction evaluate_expr_thunk; - PgfFunction evaluate_indirection; - PgfFunction evaluate_value; - PgfFunction evaluate_value_lit; - PgfFunction evaluate_value_pap; - PgfFunction evaluate_value_lambda; - PgfFunction evaluate_value_const; - PgfFunction evaluate_meta; - PgfFunction evaluate_gen; - PgfFunction evaluate_sum; - PgfFunction evaluate_caf; - - PgfFunction update_closure; - PgfFunction update_pap; - - PgfFunction mk_const; - - PgfFunction combine1; - PgfFunction combine2; - PgfFunction complete; - - PgfClosure* (*enter)(PgfReasoner* rs, PgfClosure* closure); - - GuFinalizer fin; - GuSeq* cafs; -}; - -PGF_INTERNAL_DECL PgfReasoner* -pgf_new_reasoner(PgfPGF* pgf, GuExn* err, GuPool* pool, GuPool* out_pool); - -PGF_INTERNAL_DECL void -pgf_reasoner_try_first(PgfReasoner* rs, PgfExprState* parent, PgfAbsFun* absfun); - -PGF_INTERNAL_DECL void -pgf_reasoner_try_else(PgfReasoner* rs, PgfExprState* prev, PgfAbsFun* absfun); - -PGF_INTERNAL_DECL void -pgf_reasoner_combine1(PgfReasoner* rs, PgfClosure* closure); - -PGF_INTERNAL_DECL void -pgf_reasoner_combine2(PgfReasoner* rs, PgfClosure* closure); - -PGF_INTERNAL_DECL void -pgf_reasoner_complete(PgfReasoner* rs, PgfExprState* st); - -PGF_INTERNAL_DECL void -pgf_reasoner_try_constant(PgfReasoner* rs, PgfExprState* prev, PgfAbsFun* absfun); - -PGF_INTERNAL_DECL void -pgf_reasoner_mk_string(PgfReasoner* rs, PgfExprState* parent); - -PGF_INTERNAL_DECL void -pgf_reasoner_mk_int(PgfReasoner* rs, PgfExprState* parent); - -PGF_INTERNAL_DECL void -pgf_reasoner_mk_float(PgfReasoner* rs, PgfExprState* parent); - -PGF_INTERNAL_DECL PgfClosure* -pgf_evaluate_expr_thunk(PgfReasoner* rs, PgfExprThunk* thunk); - -PGF_INTERNAL_DECL PgfClosure* -pgf_evaluate_lambda_application(PgfReasoner* rs, PgfExprThunk* lambda, - PgfClosure* arg); - -PGF_INTERNAL_DECL void -pgf_evaluate_accum_init_int(PgfReasoner* rs, - PgfEvalAccum* accum, int val); - -PGF_INTERNAL_DECL void -pgf_evaluate_accum_init_str(PgfReasoner* rs, - PgfEvalAccum* accum, GuString val); - -PGF_INTERNAL_DECL void -pgf_evaluate_accum_init_flt(PgfReasoner* rs, - PgfEvalAccum* accum, float val); - -PGF_INTERNAL_DECL void -pgf_evaluate_accum_add(PgfReasoner* rs, - PgfEvalAccum* accum, PgfClosure* closure); - -PGF_INTERNAL_DECL PgfClosure* -pgf_evaluate_accum_done(PgfReasoner* rs, PgfEvalAccum* accum); - -#endif diff --git a/src/runtime/c/pgf/scanner.c b/src/runtime/c/pgf/scanner.c deleted file mode 100644 index 7a91b5c7c..000000000 --- a/src/runtime/c/pgf/scanner.c +++ /dev/null @@ -1,583 +0,0 @@ -#include -#include -#include -#include - -PGF_INTERNAL int -cmp_string(PgfCohortSpot* spot, GuString tok, - bool case_sensitive) -{ - for (;;) { - GuUCS c2 = gu_utf8_decode((const uint8_t**) &tok); - if (c2 == 0) - return 0; - - const uint8_t* p = (uint8_t*) spot->ptr; - GuUCS c1 = gu_utf8_decode(&p); - if (c1 == 0) - return -1; - - if (!case_sensitive) { - c1 = gu_ucs_to_lower(c1); - c2 = gu_ucs_to_lower(c2); - } - - if (c1 != c2) - return (c1-c2); - - spot->ptr = (GuString) p; - spot->pos++; - } -} - -PGF_INTERNAL bool -skip_space(GuString* psent, size_t* ppos) -{ - const uint8_t* p = (uint8_t*) *psent; - if (!gu_ucs_is_space(gu_utf8_decode(&p))) - return false; - - *psent = (GuString) p; - (*ppos)++; - return true; -} - -PGF_INTERNAL int -pgf_symbols_cmp(PgfCohortSpot* spot, - PgfSymbols* syms, size_t* sym_idx, - bool case_sensitive) -{ - size_t n_syms = gu_seq_length(syms); - while (*sym_idx < n_syms) { - PgfSymbol sym = gu_seq_get(syms, PgfSymbol, *sym_idx); - - if (*sym_idx > 0) { - if (!skip_space(&spot->ptr,&spot->pos)) { - if (*spot->ptr == 0) - return -1; - return 1; - } - - while (*spot->ptr != 0) { - if (!skip_space(&spot->ptr,&spot->pos)) - break; - } - } - - GuVariantInfo inf = gu_variant_open(sym); - switch (inf.tag) { - case PGF_SYMBOL_CAT: - case PGF_SYMBOL_LIT: - case PGF_SYMBOL_VAR: { - if (*spot->ptr == 0) - return -1; - return 1; - } - case PGF_SYMBOL_KS: { - PgfSymbolKS* pks = inf.data; - if (*spot->ptr == 0) - return -1; - - int cmp = cmp_string(spot,pks->token, case_sensitive); - if (cmp != 0) - return cmp; - break; - } - case PGF_SYMBOL_KP: - case PGF_SYMBOL_BIND: - case PGF_SYMBOL_NE: - case PGF_SYMBOL_SOFT_BIND: - case PGF_SYMBOL_SOFT_SPACE: - case PGF_SYMBOL_CAPIT: - case PGF_SYMBOL_ALL_CAPIT: { - return -1; - } - default: - gu_impossible(); - } - - (*sym_idx)++; - } - - return 0; -} - -static void -pgf_morpho_iter(PgfProductionIdx* idx, - PgfMorphoCallback* callback, - GuExn* err) -{ - size_t n_entries = gu_buf_length(idx); - for (size_t i = 0; i < n_entries; i++) { - PgfProductionIdxEntry* entry = - gu_buf_index(idx, PgfProductionIdxEntry, i); - - PgfCId lemma = entry->papp->fun->absfun->name; - GuString analysis = entry->ccat->cnccat->labels[entry->lin_idx]; - - prob_t prob = entry->ccat->cnccat->abscat->prob + - entry->papp->fun->absfun->ep.prob; - callback->callback(callback, - lemma, analysis, prob, err); - if (!gu_ok(err)) - return; - } -} - -typedef struct { - GuOrder order; - bool case_sensitive; -} PgfSequenceOrder; - -PGF_INTERNAL bool -pgf_is_case_sensitive(PgfConcr* concr) -{ - PgfFlag* flag = - gu_seq_binsearch(concr->cflags, pgf_flag_order, PgfFlag, "case_sensitive"); - if (flag != NULL) { - GuVariantInfo inf = gu_variant_open(flag->value); - if (inf.tag == PGF_LITERAL_STR) { - PgfLiteralStr* lstr = inf.data; - if (strcmp(lstr->val, "off") == 0) - return false; - } - } - return true; -} - -static int -pgf_sequence_cmp_fn(GuOrder* order, const void* p1, const void* p2) -{ - PgfSequenceOrder* self = gu_container(order, PgfSequenceOrder, order); - - PgfCohortSpot spot = {0, (GuString) p1}; - - const PgfSequence* sp2 = p2; - - size_t sym_idx = 0; - int res = pgf_symbols_cmp(&spot, sp2->syms, &sym_idx, self->case_sensitive); - if (res == 0 && (*spot.ptr != 0 || sym_idx != gu_seq_length(sp2->syms))) { - res = 1; - } - - return res; -} - -PGF_API void -pgf_lookup_morpho(PgfConcr *concr, GuString sentence, - PgfMorphoCallback* callback, GuExn* err) -{ - if (concr->sequences == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return; - } - } - - size_t index = 0; - PgfSequenceOrder order = { { pgf_sequence_cmp_fn }, - pgf_is_case_sensitive(concr) }; - if (gu_seq_binsearch_index(concr->sequences, &order.order, - PgfSequence, (void*) sentence, - &index)) { - PgfSequence* seq = NULL; - - /* If the match is case-insensitive then there might be more - * matches around the current index. We must check the neighbour - * sequences for matching as well. - */ - - if (!order.case_sensitive) { - size_t i = index; - while (i > 0) { - seq = gu_seq_index(concr->sequences, PgfSequence, i-1); - - size_t sym_idx = 0; - PgfCohortSpot spot = {0, sentence}; - if (pgf_symbols_cmp(&spot, seq->syms, &sym_idx, order.case_sensitive) != 0) { - break; - } - - if (seq->idx != NULL) - pgf_morpho_iter(seq->idx, callback, err); - - i--; - } - } - - seq = gu_seq_index(concr->sequences, PgfSequence, index); - if (seq->idx != NULL) - pgf_morpho_iter(seq->idx, callback, err); - - if (!order.case_sensitive) { - size_t i = index+1; - while (i < gu_seq_length(concr->sequences)) { - seq = gu_seq_index(concr->sequences, PgfSequence, i); - - size_t sym_idx = 0; - PgfCohortSpot spot = {0, sentence}; - if (pgf_symbols_cmp(&spot, seq->syms, &sym_idx, order.case_sensitive) != 0) { - break; - } - - if (seq->idx != NULL) - pgf_morpho_iter(seq->idx, callback, err); - - i++; - } - } - } -} - -typedef struct { - GuEnum en; - PgfConcr* concr; - GuString sentence; - size_t len; - PgfMorphoCallback* callback; - GuExn* err; - bool case_sensitive; - GuBuf* spots; - GuBuf* skip_spots; - GuBuf* empty_buf; - GuBuf* found; -} PgfCohortsState; - -static int -cmp_cohort_spot(GuOrder* self, const void* a, const void* b) -{ - PgfCohortSpot *s1 = (PgfCohortSpot *) a; - PgfCohortSpot *s2 = (PgfCohortSpot *) b; - - return (s1->ptr-s2->ptr); -} - -static GuOrder -pgf_cohort_spot_order[1] = {{ cmp_cohort_spot }}; - -static void -pgf_lookup_cohorts_report_skip(PgfCohortsState *state, - PgfCohortSpot* spot) -{ - size_t n_spots = gu_buf_length(state->skip_spots); - for (size_t i = 0; i < n_spots; i++) { - PgfCohortSpot* skip_spot = - gu_buf_index(state->skip_spots, PgfCohortSpot, i); - - PgfCohortRange* range = gu_buf_insert(state->found, 0); - range->start = *skip_spot; - range->end = *spot; - range->buf = state->empty_buf; - } - gu_buf_flush(state->skip_spots); -} - -static void -pgf_lookup_cohorts_helper(PgfCohortsState *state, PgfCohortSpot* spot, - int i, int j, ptrdiff_t min, ptrdiff_t max) -{ - // This is a variation of a binary search algorithm which - // can retrieve all prefixes of a string with minimal - // comparisons, i.e. there is no need to lookup every - // prefix separately. - - while (i <= j) { - int k = (i+j) / 2; - PgfSequence* seq = gu_seq_index(state->concr->sequences, PgfSequence, k); - - PgfCohortSpot current = *spot; - - size_t sym_idx = 0; - int cmp = pgf_symbols_cmp(¤t, seq->syms, &sym_idx, state->case_sensitive); - if (cmp < 0) { - j = k-1; - } else if (cmp > 0) { - ptrdiff_t len = current.ptr - spot->ptr; - - if (min <= len) - pgf_lookup_cohorts_helper(state, spot, i, k-1, min, len); - - if (len+1 <= max) - pgf_lookup_cohorts_helper(state, spot, k+1, j, len+1, max); - - break; - } else { - ptrdiff_t len = current.ptr - spot->ptr; - - if (min <= len) - pgf_lookup_cohorts_helper(state, spot, i, k-1, min, len); - - if (seq->idx != NULL && gu_buf_length(seq->idx) > 0) { - // Report unknown words - pgf_lookup_cohorts_report_skip(state, spot); - - // Report the actual hit - PgfCohortRange* range = gu_buf_insert(state->found, 0); - range->start = *spot; - range->end = current; - range->buf = seq->idx; - - // Schedule the next search spot - while (*current.ptr != 0) { - if (!skip_space(¤t.ptr, ¤t.pos)) - break; - } - - gu_buf_heap_push(state->spots, pgf_cohort_spot_order, ¤t); - } - - if (len <= max) - pgf_lookup_cohorts_helper(state, spot, k+1, j, len, max); - - break; - } - } -} - -static void -pgf_lookup_cohorts_enum_next(GuEnum* self, void* to, GuPool* pool) -{ - PgfCohortsState* state = gu_container(self, PgfCohortsState, en); - - while (gu_buf_length(state->found) == 0 && - gu_buf_length(state->spots) > 0) { - PgfCohortSpot spot; - gu_buf_heap_pop(state->spots, pgf_cohort_spot_order, &spot); - - GuString next_ptr = state->sentence+state->len; - while (gu_buf_length(state->spots) > 0) { - GuString ptr = - gu_buf_index(state->spots, PgfCohortSpot, 0)->ptr; - if (ptr > spot.ptr) { - next_ptr = ptr; - break; - } - gu_buf_heap_pop(state->spots, pgf_cohort_spot_order, &spot); - } - - bool needs_report = true; - while (next_ptr > spot.ptr) { - pgf_lookup_cohorts_helper - (state, &spot, - 0, gu_seq_length(state->concr->sequences)-1, - 1, (state->sentence+state->len)-spot.ptr); - - // got a hit -> exit - if (gu_buf_length(state->found) > 0) - break; - - if (needs_report) { - // no hit, but the word must be reported as unknown. - gu_buf_push(state->skip_spots, PgfCohortSpot, spot); - needs_report = false; - } - - // skip one character - const uint8_t* ptr = (const uint8_t*) spot.ptr; - GuUCS c = gu_utf8_decode(&ptr); - if (gu_ucs_is_space(c)) { - // We have encounter a space and we must report - // a new unknown word. - pgf_lookup_cohorts_report_skip(state, &spot); - - spot.ptr = (GuString) ptr; - spot.pos++; - - // Schedule the next search spot - while (*spot.ptr != 0) { - if (!skip_space(&spot.ptr, &spot.pos)) - break; - } - - gu_buf_heap_push(state->spots, pgf_cohort_spot_order, &spot); - break; - } else { - spot.ptr = (GuString) ptr; - spot.pos++; - } - } - } - - PgfCohortSpot end_spot = {state->len, state->sentence+state->len}; - pgf_lookup_cohorts_report_skip(state, &end_spot); - - PgfCohortRange* pRes = (PgfCohortRange*)to; - - if (gu_buf_length(state->found) == 0) { - pRes->start.pos = 0; - pRes->start.ptr = NULL; - pRes->end.pos = 0; - pRes->end.ptr = NULL; - pRes->buf = NULL; - } else for (;;) { - *pRes = gu_buf_pop(state->found, PgfCohortRange); - pgf_morpho_iter(pRes->buf, state->callback, state->err); - - if (gu_buf_length(state->found) <= 0) - break; - - PgfCohortRange* last = - gu_buf_index_last(state->found, PgfCohortRange); - if (last->start.ptr != pRes->start.ptr || - last->end.ptr != pRes->end.ptr) - break; - } -} - -PGF_API GuEnum* -pgf_lookup_cohorts(PgfConcr *concr, GuString sentence, - PgfMorphoCallback* callback, - GuPool* pool, GuExn* err) -{ - if (concr->sequences == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return NULL; - } - } - - PgfCohortsState* state = gu_new(PgfCohortsState, pool); - state->en.next = pgf_lookup_cohorts_enum_next; - state->concr = concr; - state->sentence = sentence; - state->len = strlen(sentence); - state->callback = callback; - state->err = err; - state->case_sensitive= pgf_is_case_sensitive(concr); - state->spots = gu_new_buf(PgfCohortSpot, pool); - state->skip_spots = gu_new_buf(PgfCohortSpot, pool); - state->empty_buf = gu_new_buf(PgfProductionIdxEntry, pool); - state->found = gu_new_buf(PgfCohortRange, pool); - - PgfCohortSpot spot = {0,sentence}; - while (*spot.ptr != 0) { - if (!skip_space(&spot.ptr, &spot.pos)) - break; - } - - gu_buf_heap_push(state->spots, pgf_cohort_spot_order, &spot); - - return &state->en; -} - -typedef struct { - GuEnum en; - PgfSequences* sequences; - GuString prefix; - size_t seq_idx; - bool case_sensitive; -} PgfFullFormState; - -struct PgfFullFormEntry { - GuString tokens; - PgfProductionIdx* idx; -}; - -static void -gu_fullform_enum_next(GuEnum* self, void* to, GuPool* pool) -{ - PgfFullFormState* st = gu_container(self, PgfFullFormState, en); - PgfFullFormEntry* entry = NULL; - - if (st->sequences != NULL) { - size_t n_seqs = gu_seq_length(st->sequences); - while (st->seq_idx < n_seqs) { - PgfSequence* seq = gu_seq_index(st->sequences, PgfSequence, st->seq_idx); - GuString tokens = pgf_get_tokens(seq->syms, 0, pool); - - PgfCohortSpot spot = {0, st->prefix}; - if (cmp_string(&spot, tokens, st->case_sensitive) > 0 || *spot.ptr != 0) { - st->seq_idx = n_seqs; - break; - } - - if (*tokens != 0 && seq->idx != NULL) { - entry = gu_new(PgfFullFormEntry, pool); - entry->tokens = tokens; - entry->idx = seq->idx; - - st->seq_idx++; - break; - } - - st->seq_idx++; - } - } - - *((PgfFullFormEntry**) to) = entry; -} - -PGF_API GuEnum* -pgf_fullform_lexicon(PgfConcr *concr, GuPool* pool) -{ - PgfFullFormState* st = gu_new(PgfFullFormState, pool); - st->en.next = gu_fullform_enum_next; - st->sequences = concr->sequences; - st->prefix = ""; - st->seq_idx = 0; - st->case_sensitive = true; - return &st->en; -} - -PGF_API GuString -pgf_fullform_get_string(PgfFullFormEntry* entry) -{ - return entry->tokens; -} - -PGF_API void -pgf_fullform_get_analyses(PgfFullFormEntry* entry, - PgfMorphoCallback* callback, GuExn* err) -{ - pgf_morpho_iter(entry->idx, callback, err); -} - -PGF_API GuEnum* -pgf_lookup_word_prefix(PgfConcr *concr, GuString prefix, - GuPool* pool, GuExn* err) -{ - if (concr->sequences == NULL) { - GuExnData* err_data = gu_raise(err, PgfExn); - if (err_data) { - err_data->data = "The concrete syntax is not loaded"; - return NULL; - } - } - - PgfFullFormState* state = gu_new(PgfFullFormState, pool); - state->en.next = gu_fullform_enum_next; - state->sequences = concr->sequences; - state->prefix = prefix; - state->seq_idx = 0; - state->case_sensitive = pgf_is_case_sensitive(concr); - - PgfSequenceOrder order = { { pgf_sequence_cmp_fn }, - state->case_sensitive }; - if (!gu_seq_binsearch_index(concr->sequences, &order.order, - PgfSequence, (void*) prefix, - &state->seq_idx)) { - state->seq_idx++; - } else if (!state->case_sensitive) { - /* If the match is case-insensitive then there might be more - * matches around the current index. Since we scroll down - * anyway, it is enough to search upwards now. - */ - - while (state->seq_idx > 0) { - PgfSequence* seq = - gu_seq_index(concr->sequences, PgfSequence, state->seq_idx-1); - - size_t sym_idx = 0; - PgfCohortSpot spot = {0, state->prefix}; - if (pgf_symbols_cmp(&spot, seq->syms, &sym_idx, state->case_sensitive) > 0 || *spot.ptr != 0) { - break; - } - - state->seq_idx--; - } - } - - return &state->en; -} diff --git a/src/runtime/c/pgf/typechecker.c b/src/runtime/c/pgf/typechecker.c deleted file mode 100644 index f998120ee..000000000 --- a/src/runtime/c/pgf/typechecker.c +++ /dev/null @@ -1,588 +0,0 @@ -#include "pgf.h" -#include "data.h" -#include "gu/mem.h" -#include "gu/string.h" - -typedef struct PgfCFHypos PgfCFHypos; -struct PgfCFHypos { - PgfType* ty; - PgfCFHypos* next; -}; - -typedef struct PgfContext PgfContext; -struct PgfContext { - PgfCId var; - PgfType* ty; - PgfContext* next; -}; - -typedef struct { - PgfCFHypos* hypos; - PgfCId cat; -} PgfCFType; - -typedef struct { - PgfAbstr* abstr; - GuExn* exn; - GuPool* pool; - GuPool* tmp_pool; - PgfMetaId meta_id; -} PgfTypeChecker; - -static PgfCFType null_cf_type = { .hypos = NULL, .cat = NULL }; - -static PgfCFType -pgf_ty2cfty(PgfTypeChecker* checker, PgfType* ty) -{ - PgfCFHypos* hypos = NULL; - size_t n_hypos = gu_seq_length(ty->hypos); - while (n_hypos-- > 0) { - PgfHypo* hypo = gu_seq_index(ty->hypos, PgfHypo, n_hypos); - - PgfCFHypos* new_hypos = gu_new(PgfCFHypos, checker->tmp_pool); - new_hypos->ty = hypo->type; - new_hypos->next = hypos; - hypos = new_hypos; - } - return ((PgfCFType) { .hypos = hypos, .cat = ty->cid }); -} - -static PgfType* -pgf_cfty2ty(PgfTypeChecker* checker, PgfCFType cf_ty) -{ - PgfCFHypos* hypos; - - size_t n_hypos = 0; - hypos = cf_ty.hypos; - while (hypos != NULL) { - n_hypos++; - hypos = hypos->next; - } - - PgfType* ty = gu_new(PgfType, checker->pool); - ty->hypos = gu_new_seq(PgfHypo, n_hypos, checker->pool); - ty->cid = cf_ty.cat; - ty->n_exprs = 0; - - size_t i = 0; - hypos = cf_ty.hypos; - while (hypos != NULL) { - PgfHypo* hypo = gu_seq_index(ty->hypos, PgfHypo, i++); - hypo->bind_type = PGF_BIND_TYPE_EXPLICIT; - hypo->cid = "_"; - hypo->type = pgf_cfty2ty(checker, pgf_ty2cfty(checker, hypos->ty)); - hypos = hypos->next; - } - - return ty; -} - -static PgfPrintContext* -pgf_tc_mk_print_context(PgfTypeChecker* checker, PgfContext* ctxt) -{ - PgfPrintContext* pctxt = NULL; - PgfPrintContext** pprev = &pctxt; - - while (ctxt != NULL) { - PgfPrintContext* new_pctxt = - gu_new(PgfPrintContext, checker->tmp_pool); - new_pctxt->name = ctxt->var; - new_pctxt->next = NULL; - - *pprev = new_pctxt; - pprev = &new_pctxt->next; - - ctxt = ctxt->next; - } - - return pctxt; -} - -static void -pgf_tc_err_cannot_infer(PgfTypeChecker* checker, PgfContext* ctxt, PgfExpr e) -{ - GuStringBuf* sbuf = gu_new_string_buf(checker->tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - GuExn* err = gu_exn(checker->tmp_pool); - - gu_puts("Cannot infer the type of expression ", out, err); - pgf_print_expr(e, pgf_tc_mk_print_context(checker, ctxt), 0, out, err); - - GuExnData* exn = gu_raise(checker->exn, PgfTypeError); - exn->data = (void*) - gu_string_buf_freeze(sbuf, exn->pool); -} - -static void -pgf_tc_err_exp_fun_type_1(PgfTypeChecker* checker, PgfContext* ctxt, - PgfExpr e, PgfType* ty) -{ - GuStringBuf* sbuf = gu_new_string_buf(checker->tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - GuExn* err = gu_exn(checker->tmp_pool); - - PgfPrintContext* pctxt = pgf_tc_mk_print_context(checker, ctxt); - gu_puts("The expression ", out, err); - pgf_print_expr(e, pctxt, 0, out, err); - gu_puts(" is of function type but ", out, err); - pgf_print_type(ty, pctxt, 0, out, err); - gu_puts(" is expected", out, err); - - GuExnData* exn = gu_raise(checker->exn, PgfTypeError); - exn->data = (void*) - gu_string_buf_freeze(sbuf, exn->pool); -} - -static void -pgf_tc_err_exp_fun_type_2(PgfTypeChecker* checker, PgfContext* ctxt, - PgfExpr e, PgfType* ty) -{ - GuStringBuf* sbuf = gu_new_string_buf(checker->tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - GuExn* err = gu_exn(checker->tmp_pool); - - PgfPrintContext* pctxt = pgf_tc_mk_print_context(checker, ctxt); - gu_puts("A function type is expected for the expression ", out, err); - pgf_print_expr(e, pctxt, 0, out, err); - gu_puts(" instead of type ", out, err); - pgf_print_type(ty, pctxt, 0, out, err); - - GuExnData* exn = gu_raise(checker->exn, PgfTypeError); - exn->data = (void*) - gu_string_buf_freeze(sbuf, exn->pool); -} - -static void -pgf_tc_err_n_args(PgfTypeChecker* checker, - PgfAbsCat* abs_cat, size_t n_args) -{ - GuExnData* exn = gu_raise(checker->exn, PgfTypeError); - exn->data = (void*) - gu_format_string(exn->pool, - "The category %s has %d indices but %d are given", - abs_cat->name, - gu_seq_length(abs_cat->context), - n_args); -} - -static void -pgf_tc_err_type_mismatch(PgfTypeChecker* checker, - PgfContext* ctxt, - PgfExpr e, PgfCFType ty1, PgfCFType ty2) -{ - GuStringBuf* sbuf = gu_new_string_buf(checker->tmp_pool); - GuOut* out = gu_string_buf_out(sbuf); - GuExn* err = gu_exn(checker->tmp_pool); - - PgfPrintContext* pctxt = pgf_tc_mk_print_context(checker, ctxt); - gu_puts("The expected type of the expression ", out, err); - pgf_print_expr(e, pctxt, 0, out, err); - gu_puts(" is ", out, err); - pgf_print_type(pgf_cfty2ty(checker, ty1), pctxt, 0, out, err); - gu_puts(" but ", out, err); - pgf_print_type(pgf_cfty2ty(checker, ty2), pctxt, 0, out, err); - gu_puts(" is infered", out, err); - - GuExnData* exn = gu_raise(checker->exn, PgfTypeError); - exn->data = (void*) - gu_string_buf_freeze(sbuf, exn->pool); -} - -static bool -pgf_unify_types(PgfTypeChecker* checker, PgfCFType ty1, PgfCFType ty2) -{ - if (strcmp(ty1.cat, ty2.cat) != 0) - return false; - - while (ty1.hypos != NULL && ty2.hypos != NULL) { - if (!pgf_unify_types(checker, - pgf_ty2cfty(checker, ty1.hypos->ty), - pgf_ty2cfty(checker, ty2.hypos->ty))) - return false; - - ty1.hypos = ty1.hypos->next; - ty2.hypos = ty2.hypos->next; - } - - if (ty1.hypos != NULL || ty2.hypos != NULL) - return false; - - return true; -} - -static PgfCFType -pgf_inf_expr(PgfTypeChecker* checker, PgfContext* ctxt, PgfExpr* pe); - -static void -pgf_tc_expr(PgfTypeChecker* checker, - PgfContext* ctxt, PgfExpr* pe, PgfCFType ty) -{ - GuVariantInfo i = gu_variant_open(*pe); - switch (i.tag) { - case PGF_EXPR_ABS: { - PgfExprAbs* eabs = i.data; - - if (ty.hypos == NULL) { - pgf_tc_err_exp_fun_type_1(checker, ctxt, *pe, pgf_cfty2ty(checker, ty)); - return; - } - - PgfContext* new_ctxt = gu_new(PgfContext, checker->tmp_pool); - new_ctxt->var = eabs->id; - new_ctxt->ty = ty.hypos->ty; - new_ctxt->next = ctxt; - - PgfExprAbs* new_eabs = - gu_new_variant(PGF_EXPR_ABS, - PgfExprAbs, - pe, checker->pool); - new_eabs->bind_type = eabs->bind_type; - new_eabs->id = gu_string_copy(eabs->id, checker->pool); - new_eabs->body = eabs->body; - - PgfCFType new_ty = { .hypos = ty.hypos->next, .cat = ty.cat }; - pgf_tc_expr(checker, new_ctxt, &new_eabs->body, new_ty); - break; - } - case PGF_EXPR_LIT: - case PGF_EXPR_APP: - case PGF_EXPR_FUN: - case PGF_EXPR_VAR: - case PGF_EXPR_TYPED: { - PgfCFType inf_ty = - pgf_inf_expr(checker, ctxt, pe); - if (!gu_ok(checker->exn)) - return; - if (!pgf_unify_types(checker, ty, inf_ty)) { - pgf_tc_err_type_mismatch(checker, ctxt, *pe, ty, inf_ty); - return; - } - break; - } - case PGF_EXPR_META: { - PgfExprMeta* new_emeta = - gu_new_variant(PGF_EXPR_META, - PgfExprMeta, - pe, checker->pool); - new_emeta->id = checker->meta_id++; - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* eimpl = i.data; - - PgfExprImplArg* new_eimpl = - gu_new_variant(PGF_EXPR_IMPL_ARG, - PgfExprImplArg, - pe, checker->pool); - new_eimpl->expr = eimpl->expr; - pgf_tc_expr(checker, ctxt, &new_eimpl->expr, ty); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_tc_type(PgfTypeChecker* checker, PgfType** pty) -{ - PgfType* ty = *pty; - - PgfAbsCat* abs_cat = - gu_seq_binsearch(checker->abstr->cats, pgf_abscat_order, PgfAbsCat, ty->cid); - if (abs_cat == NULL) { - GuExnData* exn = gu_raise(checker->exn, PgfExn); - exn->data = (void*) - gu_format_string(exn->pool, - "Unknown category \"%s\"", ty->cid); - return; - } - - PgfContext* ctxt = NULL; - - size_t n_hypos = gu_seq_length(ty->hypos); - PgfHypos* new_hypos = gu_new_seq(PgfHypo, n_hypos, checker->pool); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(ty->hypos, PgfHypo, i); - PgfHypo* new_hypo = gu_seq_index(new_hypos, PgfHypo, i); - - new_hypo->bind_type = hypo->bind_type; - new_hypo->cid = gu_string_copy(hypo->cid, checker->pool); - new_hypo->type = hypo->type; - - pgf_tc_type(checker, &new_hypo->type); - if (!gu_ok(checker->exn)) - return; - - PgfContext* new_ctxt = gu_new(PgfContext, checker->tmp_pool); - new_ctxt->var = hypo->cid; - new_ctxt->ty = hypo->type; - new_ctxt->next = ctxt; - ctxt = new_ctxt; - } - - PgfType *new_ty = - gu_new_flex(checker->pool, PgfType, exprs, ty->n_exprs); - new_ty->hypos = new_hypos; - new_ty->cid = gu_string_copy(ty->cid, checker->pool); - new_ty->n_exprs = ty->n_exprs; - - if (gu_seq_length(abs_cat->context) != ty->n_exprs) { - pgf_tc_err_n_args(checker, abs_cat, ty->n_exprs); - return; - } - - for (size_t i = 0; i < ty->n_exprs; i++) { - PgfHypo* hypo = gu_seq_index(abs_cat->context, PgfHypo, i); - - new_ty->exprs[i] = ty->exprs[i]; - pgf_tc_expr(checker, ctxt, &new_ty->exprs[i], pgf_ty2cfty(checker, hypo->type)); - if (!gu_ok(checker->exn)) - return; - } - - *pty = new_ty; -} - -static PgfCFType -pgf_inf_expr(PgfTypeChecker* checker, PgfContext* ctxt, PgfExpr* pe) -{ - GuVariantInfo i = gu_variant_open(*pe); - switch (i.tag) { - case PGF_EXPR_ABS: { - pgf_tc_err_cannot_infer(checker, ctxt, *pe); - return null_cf_type; - } - case PGF_EXPR_APP: { - PgfExprApp* eapp = i.data; - - PgfExprApp* new_eapp = - gu_new_variant(PGF_EXPR_APP, - PgfExprApp, - pe, checker->pool); - new_eapp->fun = eapp->fun; - new_eapp->arg = eapp->arg; - - PgfCFType fun_ty = - pgf_inf_expr(checker, ctxt, &new_eapp->fun); - if (!gu_ok(checker->exn)) - return null_cf_type; - if (fun_ty.hypos == NULL) { - pgf_tc_err_exp_fun_type_2(checker, - ctxt, - eapp->fun, pgf_cfty2ty(checker, fun_ty)); - return null_cf_type; - } - - pgf_tc_expr(checker, ctxt, &new_eapp->arg, pgf_ty2cfty(checker, fun_ty.hypos->ty)); - return ((PgfCFType) { .hypos = fun_ty.hypos->next, - .cat = fun_ty.cat - }); - } - case PGF_EXPR_LIT: { - PgfExprLit* elit = i.data; - - PgfExprLit* new_elit = - gu_new_variant(PGF_EXPR_LIT, - PgfExprLit, - pe, checker->pool); - - GuVariantInfo i = gu_variant_open(elit->lit); - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr* lstr = i.data; - - PgfLiteralStr* new_lstr = - gu_new_flex_variant(PGF_LITERAL_STR, - PgfLiteralStr, - val, strlen(lstr->val)+1, - &new_elit->lit, checker->pool); - strcpy(new_lstr->val, lstr->val); - - return ((PgfCFType) { .hypos = NULL, .cat = "String" }); - } - case PGF_LITERAL_INT: { - PgfLiteralInt* lint = i.data; - - PgfLiteralInt* new_lint = - gu_new_variant(PGF_LITERAL_INT, - PgfLiteralInt, - &new_elit->lit, checker->pool); - new_lint->val = lint->val; - - return ((PgfCFType) { .hypos = NULL, .cat = "Int" }); - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt* lflt = i.data; - - PgfLiteralFlt* new_lflt = - gu_new_variant(PGF_LITERAL_FLT, - PgfLiteralFlt, - &new_elit->lit, checker->pool); - new_lflt->val = lflt->val; - - return ((PgfCFType) { .hypos = NULL, .cat = "Float" }); - } - default: - gu_impossible(); - } - break; - } - case PGF_EXPR_META: { - pgf_tc_err_cannot_infer(checker, ctxt, *pe); - return null_cf_type; - } - case PGF_EXPR_FUN: { - PgfExprFun* efun = i.data; - - PgfType* ty = NULL; - - int var = 0; - PgfContext* var_ctxt = ctxt; - while (var_ctxt != NULL) { - if (strcmp(var_ctxt->var, efun->fun) == 0) { - PgfExprVar* new_evar = - gu_new_variant(PGF_EXPR_VAR, - PgfExprVar, - pe, checker->pool); - new_evar->var = var; - ty = var_ctxt->ty; - break; - } - - var++; - var_ctxt = var_ctxt->next; - } - - if (ty == NULL) { - PgfAbsFun* abs_fun = - gu_seq_binsearch(checker->abstr->funs, pgf_absfun_order, PgfAbsFun, efun->fun); - if (abs_fun == NULL) { - GuExnData* exn = gu_raise(checker->exn, PgfExn); - exn->data = (void*) - gu_format_string(exn->pool, - "Unknown function \"%s\"", efun->fun); - return null_cf_type; - } else { - PgfExprFun *new_efun = - gu_new_flex_variant(PGF_EXPR_FUN, - PgfExprFun, - fun, strlen(efun->fun)+1, - pe, checker->pool); - strcpy(new_efun->fun, efun->fun); - ty = abs_fun->type; - } - } - - return pgf_ty2cfty(checker, ty); - } - case PGF_EXPR_VAR: { - PgfExprVar* evar = i.data; - - int var = evar->var; - PgfContext* var_ctxt = ctxt; - assert(var_ctxt != NULL); - while (var > 0) { - var--; - var_ctxt = var_ctxt->next; - assert(var_ctxt != NULL); - } - - return pgf_ty2cfty(checker, var_ctxt->ty); - } - case PGF_EXPR_TYPED: { - PgfExprTyped* etyped = i.data; - - PgfExprTyped* new_etyped = - gu_new_variant(PGF_EXPR_TYPED, - PgfExprTyped, - pe, checker->pool); - new_etyped->expr = etyped->expr; - new_etyped->type = etyped->type; - - pgf_tc_type(checker, &new_etyped->type); - if (!gu_ok(checker->exn)) - return null_cf_type; - - PgfCFType cf_ty = pgf_ty2cfty(checker, new_etyped->type); - - pgf_tc_expr(checker, ctxt, &new_etyped->expr, cf_ty); - return cf_ty; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg* eimpl = i.data; - - PgfExprImplArg* new_eimpl = - gu_new_variant(PGF_EXPR_IMPL_ARG, - PgfExprImplArg, - pe, checker->pool); - new_eimpl->expr = eimpl->expr; - return pgf_inf_expr(checker, ctxt, &new_eimpl->expr); - } - default: - gu_impossible(); - } - - return null_cf_type; -} - -PGF_API void -pgf_check_expr(PgfPGF* gr, PgfExpr* pe, PgfType* ty, - GuExn* exn, GuPool* pool) -{ - GuPool* tmp_pool = gu_new_pool(); - - PgfTypeChecker* checker = gu_new(PgfTypeChecker, tmp_pool); - checker->abstr = &gr->abstract; - checker->exn = exn; - checker->pool = pool; - checker->tmp_pool = tmp_pool; - checker->meta_id = 1; - - pgf_tc_expr(checker, NULL, pe, pgf_ty2cfty(checker, ty)); - - gu_pool_free(tmp_pool); -} - -PGF_API PgfType* -pgf_infer_expr(PgfPGF* gr, PgfExpr* pe, - GuExn* exn, GuPool* pool) -{ - GuPool* tmp_pool = gu_new_pool(); - - PgfTypeChecker* checker = gu_new(PgfTypeChecker, tmp_pool); - checker->abstr = &gr->abstract; - checker->exn = exn; - checker->pool = pool; - checker->tmp_pool = tmp_pool; - checker->meta_id = 1; - - PgfCFType cf_ty = pgf_inf_expr(checker, NULL, pe); - - PgfType* ty = NULL; - if (gu_ok(exn)) { - ty = pgf_cfty2ty(checker, cf_ty); - } - - gu_pool_free(tmp_pool); - - return ty; -} - -PGF_API void -pgf_check_type(PgfPGF* gr, PgfType** pty, - GuExn* exn, GuPool* pool) -{ - GuPool* tmp_pool = gu_new_pool(); - - PgfTypeChecker* checker = gu_new(PgfTypeChecker, tmp_pool); - checker->abstr = &gr->abstract; - checker->exn = exn; - checker->pool = pool; - checker->tmp_pool = tmp_pool; - checker->meta_id = 1; - - pgf_tc_type(checker, pty); - - gu_pool_free(tmp_pool); -} diff --git a/src/runtime/c/pgf/writer.c b/src/runtime/c/pgf/writer.c deleted file mode 100644 index ff6101155..000000000 --- a/src/runtime/c/pgf/writer.c +++ /dev/null @@ -1,913 +0,0 @@ -#include "data.h" -#include "expr.h" -#include "writer.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#if defined(__MINGW32__) || defined(_MSC_VER) -#include -#endif - -// -// PgfWriter -// - -struct PgfWriter { - GuOut* out; - GuExn* err; -}; - -PGF_INTERNAL void -pgf_write_tag(uint8_t tag, PgfWriter* wtr) -{ - gu_out_u8(wtr->out, tag, wtr->err); -} - -PGF_INTERNAL void -pgf_write_uint(uint32_t val, PgfWriter* wtr) -{ - for (;;) { - uint8_t b = val & 0x7F; - val = val >> 7; - if (val == 0) { - gu_out_u8(wtr->out, b, wtr->err); - break; - } else { - gu_out_u8(wtr->out, b | 0x80, wtr->err); - gu_return_on_exn(wtr->err, ); - } - } -} - -PGF_INTERNAL void -pgf_write_int(int32_t val, PgfWriter* wtr) -{ - pgf_write_uint((uint32_t) val, wtr); -} - -PGF_INTERNAL void -pgf_write_len(size_t len, PgfWriter* wtr) -{ - pgf_write_int(len, wtr); -} - -PGF_INTERNAL void -pgf_write_cid(PgfCId id, PgfWriter* wtr) -{ - size_t len = strlen(id); - pgf_write_len(len, wtr); - gu_return_on_exn(wtr->err, ); - gu_out_bytes(wtr->out, (uint8_t*) id, len, wtr->err); -} - -PGF_INTERNAL void -pgf_write_string(GuString val, PgfWriter* wtr) -{ - size_t len = 0; - const uint8_t* buf = (const uint8_t*) val; - const uint8_t* p = buf; - while (gu_utf8_decode(&p) != 0) - len++; - - pgf_write_len(len, wtr); - gu_return_on_exn(wtr->err, ); - gu_out_bytes(wtr->out, (uint8_t*) val, (p-buf)-1, wtr->err); -} - -PGF_INTERNAL void -pgf_write_double(double val, PgfWriter* wtr) -{ - gu_out_f64be(wtr->out, val, wtr->err); -} - -static void -pgf_write_literal(PgfLiteral lit, PgfWriter* wtr) -{ - GuVariantInfo i = gu_variant_open(lit); - pgf_write_tag(i.tag, wtr); - gu_return_on_exn(wtr->err, ); - switch (i.tag) { - case PGF_LITERAL_STR: { - PgfLiteralStr *lstr = i.data; - pgf_write_string(lstr->val, wtr); - break; - } - case PGF_LITERAL_INT: { - PgfLiteralInt *lint = i.data; - pgf_write_int(lint->val, wtr); - break; - } - case PGF_LITERAL_FLT: { - PgfLiteralFlt *lflt = i.data; - pgf_write_double(lflt->val, wtr); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_write_flags(PgfFlags* flags, PgfWriter* wtr) -{ - size_t n_flags = gu_seq_length(flags); - pgf_write_len(n_flags, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < n_flags; i++) { - PgfFlag* flag = gu_seq_index(flags, PgfFlag, i); - - pgf_write_cid(flag->name, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_literal(flag->value, wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_type_(PgfType* type, PgfWriter* wtr); - -static void -pgf_write_expr_(PgfExpr expr, PgfWriter* wtr) -{ - GuVariantInfo i = gu_variant_open(expr); - pgf_write_tag(i.tag, wtr); - gu_return_on_exn(wtr->err, ); - switch (i.tag) { - case PGF_EXPR_ABS:{ - PgfExprAbs *eabs = i.data; - - pgf_write_tag(eabs->bind_type, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_cid(eabs->id, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_expr_(eabs->body, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_EXPR_APP: { - PgfExprApp *eapp = i.data; - - pgf_write_expr_(eapp->fun, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_expr_(eapp->arg, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_EXPR_LIT: { - PgfExprLit *elit = i.data; - pgf_write_literal(elit->lit, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_EXPR_META: { - PgfExprMeta *emeta = i.data; - pgf_write_int(emeta->id, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_EXPR_FUN: { - PgfExprFun *efun = i.data; - pgf_write_cid(efun->fun, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_EXPR_VAR: { - PgfExprVar *evar = i.data; - pgf_write_int(evar->var, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_EXPR_TYPED: { - PgfExprTyped *etyped = i.data; - pgf_write_expr_(etyped->expr, wtr); - gu_return_on_exn(wtr->err, ); - pgf_write_type_(etyped->type, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_EXPR_IMPL_ARG: { - PgfExprImplArg *eimpl = i.data; - pgf_write_expr_(eimpl->expr, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_write_hypo(PgfHypo* hypo, PgfWriter* wtr) -{ - pgf_write_tag(hypo->bind_type, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_cid(hypo->cid, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_type_(hypo->type, wtr); - gu_return_on_exn(wtr->err, ); -} - -static void -pgf_write_type_(PgfType* type, PgfWriter* wtr) -{ - size_t n_hypos = gu_seq_length(type->hypos); - pgf_write_len(n_hypos, wtr); - gu_return_on_exn(wtr->err, ); - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(type->hypos, PgfHypo, i); - pgf_write_hypo(hypo, wtr); - gu_return_on_exn(wtr->err, ); - } - - pgf_write_cid(type->cid, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_len(type->n_exprs, wtr); - - for (size_t i = 0; i < type->n_exprs; i++) { - pgf_write_expr_(type->exprs[i], wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_patt(PgfPatt patt, PgfWriter* wtr) -{ - GuVariantInfo i = gu_variant_open(patt); - switch (i.tag) { - case PGF_PATT_APP: { - PgfPattApp *papp = i.data; - pgf_write_cid(papp->ctor, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_len(papp->n_args, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < papp->n_args; i++) { - pgf_write_patt(papp->args[i], wtr); - gu_return_on_exn(wtr->err, ); - } - break; - } - case PGF_PATT_VAR: { - PgfPattVar *papp = i.data; - pgf_write_cid(papp->var, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_PATT_AS: { - PgfPattAs *pas = i.data; - pgf_write_cid(pas->var, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_patt(pas->patt, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_PATT_WILD: { - PgfPattWild* pwild = i.data; - ((void) pwild); - break; - } - case PGF_PATT_LIT: { - PgfPattLit *plit = i.data; - pgf_write_literal(plit->lit, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_PATT_IMPL_ARG: { - PgfPattImplArg *pimpl = i.data; - pgf_write_patt(pimpl->patt, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_PATT_TILDE: { - PgfPattTilde *ptilde = i.data; - pgf_write_expr_(ptilde->expr, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_write_absfun(PgfAbsFun* absfun, PgfWriter* wtr) -{ - pgf_write_cid(absfun->name,wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_type_(absfun->type, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_int(absfun->arity, wtr); - - pgf_write_tag((absfun->defns == NULL) ? 0 : 1, wtr); - gu_return_on_exn(wtr->err, ); - - if (absfun->defns != NULL) { - size_t length = gu_seq_length(absfun->defns); - pgf_write_len(length, wtr); - gu_return_on_exn(wtr->err, ); - - PgfEquation** data = gu_seq_data(absfun->defns); - for (size_t i = 0; i < length; i++) { - PgfEquation *equ = data[i]; - - pgf_write_len(equ->n_patts, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t j = 0; j < equ->n_patts; j++) { - pgf_write_patt(equ->patts[j], wtr); - gu_return_on_exn(wtr->err, ); - } - pgf_write_expr_(equ->body, wtr); - gu_return_on_exn(wtr->err, ); - } - } - - pgf_write_double(exp(-absfun->ep.prob), wtr); -} - -static void -pgf_write_absfuns(PgfAbsFuns* absfuns, PgfWriter* wtr) -{ - size_t n_funs = gu_seq_length(absfuns); - pgf_write_len(n_funs, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* absfun = gu_seq_index(absfuns, PgfAbsFun, i); - pgf_write_absfun(absfun, wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_abscat(PgfAbsCat* abscat, PgfAbstr* abstr, PgfWriter* wtr) -{ - pgf_write_cid(abscat->name, wtr); - gu_return_on_exn(wtr->err, ); - - size_t n_hypos = gu_seq_length(abscat->context); - pgf_write_len(n_hypos, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < n_hypos; i++) { - PgfHypo* hypo = gu_seq_index(abscat->context, PgfHypo, i); - pgf_write_hypo(hypo, wtr); - gu_return_on_exn(wtr->err, ); - } - - size_t n_count = 0; - size_t n_funs = gu_seq_length(abstr->funs); - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* fun = gu_seq_index(abstr->funs, PgfAbsFun, i); - - if (strcmp(fun->type->cid, abscat->name) == 0) { - n_count++; - } - } - pgf_write_len(n_count, wtr); - for (size_t i = 0; i < n_funs; i++) { - PgfAbsFun* fun = gu_seq_index(abstr->funs, PgfAbsFun, i); - - if (strcmp(fun->type->cid, abscat->name) == 0) { - gu_out_f64be(wtr->out, exp(-fun->ep.prob), wtr->err); // ignore - gu_return_on_exn(wtr->err, ); - - pgf_write_cid(fun->name, wtr); - gu_return_on_exn(wtr->err, ); - } - } - - pgf_write_double(exp(-abscat->prob), wtr); -} - -static void -pgf_write_abscats(PgfAbsCats* abscats, PgfAbstr* abstr, PgfWriter* wtr) -{ - size_t n_cats = gu_seq_length(abscats); - pgf_write_len(n_cats, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < n_cats; i++) { - PgfAbsCat* abscat = gu_seq_index(abscats, PgfAbsCat, i); - pgf_write_abscat(abscat, abstr, wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_abstract(PgfAbstr* abstr, PgfWriter* wtr) -{ - pgf_write_cid(abstr->name, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_flags(abstr->aflags, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_absfuns(abstr->funs, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_abscats(abstr->cats, abstr, wtr); - gu_return_on_exn(wtr->err, ); -} - -typedef struct { - GuMapItor itor; - PgfWriter* wtr; -} PgfWriterIter; - -static void -pgf_write_printname(GuMapItor* self, const void* key, void* value, GuExn *err) -{ - PgfWriterIter* itor = gu_container(self, PgfWriterIter, itor); - PgfCId id = key; - GuString name = value; - - pgf_write_cid(id, itor->wtr); - gu_return_on_exn(err, ); - - pgf_write_string(name, itor->wtr); - gu_return_on_exn(err, ); -} - -static void -pgf_write_printnames(PgfCIdMap* printnames, PgfWriter* wtr) -{ - pgf_write_len(gu_map_count(printnames), wtr); - gu_return_on_exn(wtr->err, ); - - PgfWriterIter itor; - itor.itor.fn = pgf_write_printname; - itor.wtr = wtr; - gu_map_iter(printnames, &itor.itor, wtr->err); - gu_return_on_exn(wtr->err, ); -} - -static void -pgf_write_symbols(PgfSymbols*, PgfWriter* wtr); - -static void -pgf_write_alternative(PgfAlternative* alt, PgfWriter* wtr) -{ - pgf_write_symbols(alt->form, wtr); - gu_return_on_exn(wtr->err,); - - size_t n_prefixes = gu_seq_length(alt->prefixes); - pgf_write_len(n_prefixes, wtr); - gu_return_on_exn(wtr->err,); - - for (size_t i = 0; i < n_prefixes; i++) { - GuString prefix = gu_seq_get(alt->prefixes, GuString, i); - - pgf_write_string(prefix, wtr); - gu_return_on_exn(wtr->err,); - } -} - -static void -pgf_write_symbol(PgfSymbol sym, PgfWriter* wtr) -{ - GuVariantInfo i = gu_variant_open(sym); - - pgf_write_tag(i.tag, wtr); - switch (i.tag) { - case PGF_SYMBOL_CAT: { - PgfSymbolCat *sym_cat = i.data; - - pgf_write_int(sym_cat->d, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_int(sym_cat->r, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_SYMBOL_LIT: { - PgfSymbolLit *sym_lit = i.data; - - pgf_write_int(sym_lit->d, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_int(sym_lit->r, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_SYMBOL_VAR: { - PgfSymbolVar *sym_var = i.data; - - pgf_write_int(sym_var->d, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_int(sym_var->r, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_SYMBOL_KS: { - PgfSymbolKS *sym_ks = i.data; - pgf_write_string(sym_ks->token, wtr); - break; - } - case PGF_SYMBOL_KP: { - PgfSymbolKP *sym_kp = i.data; - pgf_write_symbols(sym_kp->default_form, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_len(sym_kp->n_forms, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < sym_kp->n_forms; i++) { - pgf_write_alternative(&sym_kp->forms[i], wtr); - gu_return_on_exn(wtr->err, ); - } - break; - } - case PGF_SYMBOL_NE: - case PGF_SYMBOL_BIND: - case PGF_SYMBOL_SOFT_BIND: - case PGF_SYMBOL_SOFT_SPACE: - case PGF_SYMBOL_CAPIT: - case PGF_SYMBOL_ALL_CAPIT: { - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_write_symbols(PgfSymbols* syms, PgfWriter* wtr) -{ - size_t len = gu_seq_length(syms); - pgf_write_len(len, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < len; i++) { - PgfSymbol sym = gu_seq_get(syms, PgfSymbol, i); - pgf_write_symbol(sym, wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_sequences(PgfSequences* seqs, PgfWriter* wtr) -{ - size_t len = gu_seq_length(seqs); - pgf_write_len(len, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < len; i++) { - PgfSymbols* syms = gu_seq_index(seqs, PgfSequence, i)->syms; - pgf_write_symbols(syms, wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_cncfun(PgfCncFun* cncfun, PgfConcr* concr, PgfWriter* wtr) -{ - pgf_write_cid(cncfun->absfun->name, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_len(cncfun->n_lins, wtr); - gu_return_on_exn(wtr->err, ); - - PgfSequence* data = gu_seq_data(concr->sequences); - for (size_t i = 0; i < cncfun->n_lins; i++) { - size_t seq_id = (cncfun->lins[i] - data); - - pgf_write_int(seq_id, wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_cncfuns(PgfCncFuns* cncfuns, PgfConcr* concr, PgfWriter* wtr) -{ - size_t len = gu_seq_length(cncfuns); - pgf_write_len(len, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t funid = 0; funid < len; funid++) { - PgfCncFun* cncfun = gu_seq_get(cncfuns, PgfCncFun*, funid); - - pgf_write_cncfun(cncfun, concr, wtr); - gu_return_on_exn(wtr->err, ); - } -} - -static void -pgf_write_fid(PgfCCat* ccat, PgfWriter* wtr) -{ - pgf_write_int(ccat->fid, wtr); - gu_return_on_exn(wtr->err, ); -} - -static void -pgf_write_funid(PgfCncFun* cncfun, PgfWriter* wtr) -{ - pgf_write_int(cncfun->funid, wtr); - gu_return_on_exn(wtr->err, ); -} - -typedef struct { - GuMapItor itor; - PgfWriter* wtr; - bool do_count; - bool do_defs; - size_t count; -} PgfLinDefRefIter; - -static void -pgf_write_ccat_lindefrefs(GuMapItor* self, const void* key, void* value, GuExn *err) -{ - PgfLinDefRefIter* itor = gu_container(self, PgfLinDefRefIter, itor); - PgfCCat* ccat = *((PgfCCat**) value); - - PgfCncFuns* funs = (itor->do_defs) ? ccat->lindefs : ccat->linrefs; - if (funs != NULL) { - if (itor->do_count) { - itor->count++; - } else { - pgf_write_fid(ccat, itor->wtr); - gu_return_on_exn(err, ); - - size_t n_funs = gu_seq_length(funs); - pgf_write_len(n_funs, itor->wtr); - gu_return_on_exn(err, ); - - for (size_t j = 0; j < n_funs; j++) { - PgfCncFun* fun = gu_seq_get(funs, PgfCncFun*, j); - pgf_write_funid(fun, itor->wtr); - } - } - } -} - -static void -pgf_write_lindefs(PgfWriter* wtr, PgfConcr* concr) -{ - PgfLinDefRefIter itor; - itor.itor.fn = pgf_write_ccat_lindefrefs; - itor.wtr = wtr; - itor.do_count= true; - itor.do_defs = true; - itor.count = 0; - gu_map_iter(concr->ccats, &itor.itor, wtr->err); - - pgf_write_len(itor.count, wtr); - gu_return_on_exn(wtr->err, ); - - itor.do_count = false; - gu_map_iter(concr->ccats, &itor.itor, wtr->err); - gu_return_on_exn(wtr->err, ); -} - -static void -pgf_write_linrefs(PgfWriter* wtr, PgfConcr* concr) -{ - PgfLinDefRefIter itor; - itor.itor.fn = pgf_write_ccat_lindefrefs; - itor.wtr = wtr; - itor.do_count= true; - itor.do_defs = false; - itor.count = 0; - gu_map_iter(concr->ccats, &itor.itor, wtr->err); - - pgf_write_len(itor.count, wtr); - gu_return_on_exn(wtr->err, ); - - itor.do_count = false; - gu_map_iter(concr->ccats, &itor.itor, wtr->err); - gu_return_on_exn(wtr->err, ); -} - -static void -pgf_write_parg(PgfPArg* parg, PgfWriter* wtr) -{ - size_t n_hoas = gu_seq_length(parg->hypos); - pgf_write_len(n_hoas, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < n_hoas; i++) { - PgfCCat* ccat = gu_seq_get(parg->hypos, PgfCCat*, i); - pgf_write_fid(ccat, wtr); - gu_return_on_exn(wtr->err, ); - } - - pgf_write_fid(parg->ccat, wtr); - gu_return_on_exn(wtr->err, ); -} - -static void -pgf_write_pargs(PgfPArgs* pargs, PgfWriter* wtr) -{ - size_t len = gu_seq_length(pargs); - pgf_write_len(len, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < len; i++) { - PgfPArg* parg = gu_seq_index(pargs, PgfPArg, i); - pgf_write_parg(parg, wtr); - } -} - -static void -pgf_write_production(PgfProduction prod, PgfWriter* wtr) -{ - GuVariantInfo i = gu_variant_open(prod); - pgf_write_tag(i.tag, wtr); - switch (i.tag) { - case PGF_PRODUCTION_APPLY: { - PgfProductionApply *papp = i.data; - - pgf_write_funid(papp->fun, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_pargs(papp->args, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - case PGF_PRODUCTION_COERCE: { - PgfProductionCoerce *pcoerce = i.data; - - pgf_write_fid(pcoerce->coerce, wtr); - gu_return_on_exn(wtr->err, ); - break; - } - default: - gu_impossible(); - } -} - -static void -pgf_write_ccat(GuMapItor* self, const void* key, void* value, GuExn *err) -{ - PgfWriterIter* itor = gu_container(self, PgfWriterIter, itor); - PgfCCat* ccat = *((PgfCCat**) value); - - pgf_write_fid(ccat, itor->wtr); - gu_return_on_exn(err, ); - - size_t n_prods = ccat->prods ? gu_seq_length(ccat->prods) : 0; - pgf_write_len(n_prods, itor->wtr); - gu_return_on_exn(err, ); - - for (size_t i = 0; i < n_prods; i++) { - PgfProduction prod = gu_seq_get(ccat->prods, PgfProduction, i); - pgf_write_production(prod, itor->wtr); - gu_return_on_exn(err, ); - } -} - -static void -pgf_write_ccats(GuMap* ccats, PgfWriter* wtr) -{ - pgf_write_len(gu_map_count(ccats), wtr); - gu_return_on_exn(wtr->err, ); - - PgfWriterIter itor; - itor.itor.fn = pgf_write_ccat; - itor.wtr = wtr; - gu_map_iter(ccats, &itor.itor, wtr->err); -} - -static void -pgf_write_cnccat(PgfCncCat* cnccat, PgfWriter* wtr) -{ - size_t len = gu_seq_length(cnccat->cats); - PgfCCat* first = gu_seq_get(cnccat->cats, PgfCCat*, 0); - PgfCCat* last = gu_seq_get(cnccat->cats, PgfCCat*, len-1); - pgf_write_fid(first,wtr); - pgf_write_fid(last,wtr); - pgf_write_len(cnccat->n_lins, wtr); - - for (size_t i = 0; i < cnccat->n_lins; i++) { - pgf_write_string(cnccat->labels[i], wtr); - } -} - -static void -pgf_write_cnccat_iter(GuMapItor* self, const void* key, void* value, GuExn *err) -{ - PgfWriterIter* itor = gu_container(self, PgfWriterIter, itor); - PgfCncCat* cnccat = *((PgfCncCat**) value); - - pgf_write_cid(cnccat->abscat->name, itor->wtr); - gu_return_on_exn(err, ); - - pgf_write_cnccat(cnccat, itor->wtr); -} - -static void -pgf_write_cnccats(PgfCIdMap* cnccats, PgfWriter* wtr) -{ - pgf_write_len(gu_map_count(cnccats), wtr); - gu_return_on_exn(wtr->err, ); - - PgfWriterIter itor; - itor.itor.fn = pgf_write_cnccat_iter; - itor.wtr = wtr; - gu_map_iter(cnccats, &itor.itor, wtr->err); -} - -static void -pgf_write_concrete_content(PgfConcr* concr, PgfWriter* wtr) -{ - pgf_write_printnames(concr->printnames, wtr); - gu_return_on_exn(wtr->err,); - - pgf_write_sequences(concr->sequences, wtr); - gu_return_on_exn(wtr->err,); - - pgf_write_cncfuns(concr->cncfuns, concr, wtr); - gu_return_on_exn(wtr->err,); - - pgf_write_lindefs(wtr, concr); - pgf_write_linrefs(wtr, concr); - pgf_write_ccats(concr->ccats, wtr); - pgf_write_cnccats(concr->cnccats, wtr); - pgf_write_int(concr->total_cats, wtr); -} - -PGF_INTERNAL void -pgf_write_concrete(PgfConcr* concr, PgfWriter* wtr, bool with_content) -{ - if (with_content && - (concr->sequences == NULL || concr->cncfuns == NULL || - concr->ccats == NULL || concr->cnccats == NULL)) { - // the syntax is not loaded so we must skip it. - return; - } - - pgf_write_cid(concr->name, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_flags(concr->cflags, wtr); - gu_return_on_exn(wtr->err, ); - - if (with_content) { - pgf_write_concrete_content(concr, wtr); - } - gu_return_on_exn(wtr->err, ); -} - -static void -pgf_write_concretes(size_t n_concrs, PgfConcr** concrs, PgfWriter* wtr, bool with_content) -{ - pgf_write_len(n_concrs, wtr); - gu_return_on_exn(wtr->err, ); - - for (size_t i = 0; i < n_concrs; i++) { - pgf_write_concrete(concrs[i], wtr, with_content); - gu_return_on_exn(wtr->err, ); - } -} - -PGF_INTERNAL void -pgf_write_pgf(PgfPGF* pgf, size_t n_concrs, PgfConcr** concrs, PgfWriter* wtr) { - gu_out_u16be(wtr->out, pgf->major_version, wtr->err); - gu_return_on_exn(wtr->err, ); - - gu_out_u16be(wtr->out, pgf->minor_version, wtr->err); - gu_return_on_exn(wtr->err, ); - - pgf_write_flags(pgf->gflags, wtr); - gu_return_on_exn(wtr->err, ); - - pgf_write_abstract(&pgf->abstract, wtr); - gu_return_on_exn(wtr->err, ); - - bool with_content = - (gu_seq_binsearch(pgf->gflags, pgf_flag_order, PgfFlag, "split") == NULL); - pgf_write_concretes(n_concrs, concrs, wtr, with_content); - gu_return_on_exn(wtr->err, ); -} - -PGF_INTERNAL PgfWriter* -pgf_new_writer(GuOut* out, GuPool* pool, GuExn* err) -{ - PgfWriter* wtr = gu_new(PgfWriter, pool); - wtr->out = out; - wtr->err = err; - return wtr; -} - diff --git a/src/runtime/c/pgf/writer.h b/src/runtime/c/pgf/writer.h deleted file mode 100644 index 8552e6c68..000000000 --- a/src/runtime/c/pgf/writer.h +++ /dev/null @@ -1,42 +0,0 @@ -#ifndef WRITER_H_ -#define WRITER_H_ - -#include -#include -#include - -// the writer interface - -typedef struct PgfWriter PgfWriter; - -PGF_INTERNAL_DECL PgfWriter* -pgf_new_writer(GuOut* out, GuPool* pool, GuExn* err); - -PGF_INTERNAL_DECL void -pgf_write_tag(uint8_t tag, PgfWriter* wtr); - -PGF_INTERNAL_DECL void -pgf_write_uint(uint32_t val, PgfWriter* wtr); - -PGF_INTERNAL_DECL void -pgf_write_int(int32_t val, PgfWriter* wtr); - -PGF_INTERNAL_DECL void -pgf_write_string(GuString val, PgfWriter* wtr); - -PGF_INTERNAL_DECL void -pgf_write_double(double val, PgfWriter* wtr); - -PGF_INTERNAL_DECL void -pgf_write_len(size_t len, PgfWriter* wtr); - -PGF_INTERNAL_DECL void -pgf_write_cid(PgfCId id, PgfWriter* wtr); - -PGF_INTERNAL void -pgf_write_concrete(PgfConcr* concr, PgfWriter* wtr, bool with_content); - -PGF_INTERNAL_DECL void -pgf_write_pgf(PgfPGF* pgf, size_t n_concrs, PgfConcr** concrs, PgfWriter* wtr); - -#endif // WRITER_H_ diff --git a/src/runtime/c/reader.cxx b/src/runtime/c/reader.cxx new file mode 100644 index 000000000..6e6768ffa --- /dev/null +++ b/src/runtime/c/reader.cxx @@ -0,0 +1,190 @@ +#include "data.h" +#include "reader.h" +#include +#include + +PgfReader::PgfReader(std::istream *in) +{ + this->in = in; +} + +uint8_t PgfReader::read_uint8() +{ + uint8_t b; + in->read((char*) &b, sizeof(b)); + if (in->eof()) + throw pgf_error("reached end of file while reading a grammar"); + if (in->fail()) + throw std::system_error(errno, std::generic_category()); + + return b; +} + +uint16_t PgfReader::read_u16be() +{ + uint8_t buf[2]; + in->read((char*) &buf, sizeof(buf)); + if (in->eof()) + throw pgf_error("reached end of file while reading a grammar"); + if (in->fail()) + throw std::system_error(errno, std::generic_category()); + + return (((uint16_t) buf[0]) << 8 | buf[1]); +} + +uint64_t PgfReader::read_u64be() +{ + uint8_t buf[8]; + in->read((char*) &buf, sizeof(buf)); + if (in->eof()) + throw pgf_error("reached end of file while reading a grammar"); + if (in->fail()) + throw std::system_error(errno, std::generic_category()); + + return (((uint64_t) buf[0]) << 56 | + ((uint64_t) buf[1]) << 48 | + ((uint64_t) buf[2]) << 40 | + ((uint64_t) buf[3]) << 32 | + ((uint64_t) buf[4]) << 24 | + ((uint64_t) buf[5]) << 16 | + ((uint64_t) buf[6]) << 8 | + ((uint64_t) buf[7])); +} + +double PgfReader::read_double() +{ + uint64_t u = read_u64be(); + + bool sign = u >> 63; + unsigned rawexp = u >> 52 & 0x7ff; + uint64_t mantissa = u & 0xfffffffffffff; + double ret; + + if (rawexp == 0x7ff) { + ret = (mantissa == 0) ? INFINITY : NAN; + } else { + uint64_t m = rawexp ? 1ULL << 52 | mantissa : mantissa << 1; + ret = ldexp((double) m, rawexp - 1075); + } + return sign ? copysign(ret, -1.0) : ret; +} + +uint64_t PgfReader::read_uint() +{ + uint64_t u = 0; + int shift = 0; + uint8_t b = 0; + do { + b = read_uint8(); + u |= (b & ~0x80) << shift; + shift += 7; + } while (b & 0x80); + return u; +} + +moffset PgfReader::read_name(size_t size) +{ + size_t len = read_len(); + + char* buf = (char*) alloca(len*6+1); + char* p = buf; + for (size_t i = 0; i < len; i++) { + uint8_t c = read_uint8(); + *(p++) = (char) c; + + if (c < 0x80) { + continue; + } + if (c < 0xc2) { + throw pgf_error("utf8 decoding error"); + } + + int len = (c < 0xe0 ? 1 : + c < 0xf0 ? 2 : + c < 0xf8 ? 3 : + c < 0xfc ? 4 : + 5 + ); + // If reading the extra bytes causes EOF, it is an encoding + // error, not a legitimate end of character stream. + in->read(p, len); + if (in->eof()) + throw pgf_error("utf8 decoding error"); + if (in->fail()) + throw std::system_error(errno, std::generic_category()); + + p += len; + } + *p++ = 0; + + moffset offs = current_db->malloc(size+(p-buf)); + strcpy((char*) (current_base+offs+size), buf); + + return offs; +} + +template +Namespace PgfReader::read_namespace(ref (PgfReader::*read_value)()) +{ + size_t len = read_len(); + Namespace nmsp = 0; + for (size_t i = 0; i < len; i++) { + ref value = (this->*read_value)(); + nmsp = namespace_insert(nmsp, value); + } + return nmsp; +} + +PgfLiteral PgfReader::read_literal() +{ + PgfLiteral lit = 0; + + uint8_t tag = read_tag(); + switch (tag) { + case PGF_LITERAL_STR: { + ref lit_str = + read_name(offsetof(PgfLiteralStr,val)); + lit = variant_close(lit_str,PGF_LITERAL_STR); + break; + } + case PGF_LITERAL_INT: { + ref lit_int = + current_db->malloc(); + lit_int->val = read_int(); + lit = variant_close(lit_int,PGF_LITERAL_INT); + break; + } + case PGF_LITERAL_FLT: { + ref lit_flt = + current_db->malloc(); + lit_flt->val = read_double(); + lit = variant_close(lit_flt,PGF_LITERAL_FLT); + break; + } + default: + throw pgf_error("tag error"); + } + return lit; +} + +ref PgfReader::read_flag() +{ + ref flag = read_name(); + flag->value = read_literal(); + return flag; +} + +void PgfReader::read_abstract(PgfAbstr* abstract) +{ + abstract->name = read_name(0); + abstract->aflags = read_namespace(&PgfReader::read_flag); +} + +void PgfReader::read_pgf(PgfPGFRoot *pgf) +{ + pgf->major_version = read_u16be(); + pgf->minor_version = read_u16be(); + pgf->gflags = read_namespace(&PgfReader::read_flag); + + read_abstract(&pgf->abstract); +} diff --git a/src/runtime/c/reader.h b/src/runtime/c/reader.h new file mode 100644 index 000000000..def79dd64 --- /dev/null +++ b/src/runtime/c/reader.h @@ -0,0 +1,43 @@ +#ifndef READER_H_ +#define READER_H_ + +#include +#include +#include "db.h" + +// reader for PGF files + +class PGF_INTERNAL_DECL PgfReader +{ +public: + PgfReader(std::istream *in); + + uint8_t read_uint8(); + uint16_t read_u16be(); + uint64_t read_u64be(); + double read_double(); + uint64_t read_uint(); + int64_t read_int() { return (int64_t) read_uint(); }; + uint8_t read_tag() { return read_uint8(); } + size_t read_len() { return (size_t) read_uint(); }; + + template + ref read_name() { return read_name(offsetof(V,name)); }; + + template + Namespace read_namespace(ref (PgfReader::*read_value)()); + + PgfLiteral read_literal(); + ref read_flag(); + + void read_abstract(PgfAbstr* abstract); + + void read_pgf(PgfPGFRoot* pgf); + +private: + std::istream *in; + + moffset read_name(size_t size); +}; + +#endif diff --git a/src/runtime/c/setup.sh b/src/runtime/c/setup.sh deleted file mode 100755 index fdc8f7aec..000000000 --- a/src/runtime/c/setup.sh +++ /dev/null @@ -1,21 +0,0 @@ - -# Executable version of INSTALL - -command="$1" -shift - -case "$command" in - configure) - [ `uname` != Darwin ] || glibtoolize - autoreconf -i - ./configure "$@" - ;; - build) - make -j "$@" - ;; - copy|install) - make install "$@" - ;; - *) - echo "Usage: setup.sh [configure|build|copy|install] ..." -esac diff --git a/src/runtime/c/variant.h b/src/runtime/c/variant.h new file mode 100644 index 000000000..4795fca48 --- /dev/null +++ b/src/runtime/c/variant.h @@ -0,0 +1,12 @@ +#ifndef VARIANT_H_ +#define VARIANT_H_ + +typedef uintptr_t variant; + +template +variant variant_close(ref r, uint8_t tag) +{ + return (((moffset) r) | tag); +} + +#endif /* VARIANT_H_ */