Free games for graphing calculators: NumWorks, TI-Nspire CX, Casio fx-CG50 and soon TI-84 Plus CE. Balatro, Celeste, Hollow Knight, Minecraft and more.
C calculatorcalculator-gamescasiochesscrossy-roaddrive-madfx-cg50gamesgeometry-dashgraphing-calculatorndlessnumworksnumworks-appsnumworks-calculatornumworks-gamenumworks-gamestetristi-84-plus-ceti-nspire
Retro-Go: gwenesis' Mega Drive core, run on the computer
Mason3632434ca8c8891
diff --git a/games/retrogo/Makefile b/games/retrogo/Makefileindex 316eec49..96e3b65c 100644--- a/games/retrogo/Makefile+++ b/games/retrogo/Makefile@@ -22,13 +22,14 @@ NES_SRC = $(addprefix src/nes/,nes6502.c nes_ppu.c nes_mmc.c mmclist.c nes_apu.c$(sort $(wildcard src/nes/mappers/*.c))SMS_SRC = src/sms/z80.c src/sms/sms.c src/sms/coleco_bios.cGW_SRC = $(addprefix src/gw/,gw.c gw_state.c gw_system.c sm510base.c sm510core.c sm510op.c sm511core.c sm500core.c sm500op.c sm5acore.c)-CORE_SRC = $(GB_SRC) $(NES_SRC) $(SMS_SRC) $(GW_SRC)+MD_SRC = $(addprefix src/md/,md.c md_z80.c m68kcpu.c gwenesis_bus.c gwenesis_io.c gwenesis_vdp_mem.c gwenesis_vdp_gfx.c)+CORE_SRC = $(GB_SRC) $(NES_SRC) $(SMS_SRC) $(GW_SRC) $(MD_SRC)APP_SRC = src/main.c src/romtable.c src/pack.c-CORE_H = $(wildcard src/*.h src/gb/*.h src/nes/*.h src/sms/*.h src/gw/*.h)+CORE_H = $(wildcard src/*.h src/gb/*.h src/nes/*.h src/sms/*.h src/gw/*.h src/md/*.h) $(BUILD_DIR)/m68k_tab.hHEADERS = $(CORE_H) ../common/epsilon_app.h ../common/epsilon_files.h ../common/np_text.h \../../launcher/src/gfx.h ../../launcher/src/np.h ../../launcher/src/font.h-CFLAGS = -std=gnu11 $(shell $(NWLINK) eadk-cflags-device) -Isrc/nes+CFLAGS = -std=gnu11 $(shell $(NWLINK) eadk-cflags-device) -Isrc/nes -I$(BUILD_DIR)CFLAGS += -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-implicit-fallthrough -Wno-missing-field-initializers# (gnuboy and nofrendo as they were written)CFLAGS += -Wno-old-style-declaration -Wno-misleading-indentation -Wno-unused-but-set-variable -Wno-maybe-uninitialized@@ -67,6 +68,14 @@ $(BUILD_DIR)/font_data.o: ../../launcher/src/font_data.c ../../launcher/src/font$(BUILD_DIR)/xfont.o: ../../launcher/src/xfont.c ../../launcher/src/np_xfont.h $(HEADERS)$(Q) $(CC) $(CFLAGS) -Os -c $< -o $@+# the 68000's opcode table (gwenesis' Musashi), made from its list of opcodes+$(BUILD_DIR)/m68k_tab.h: tools/m68ktab.py src/md/m68kops.h+ @mkdir -p $(BUILD_DIR)+ $(Q) $(PY) tools/m68ktab.py src/md/m68kops.h $@+# (gwenesis as it was written; its asserts off, as in Retro-Go)+$(patsubst src/%.c,$(BUILD_DIR)/%.o,$(MD_SRC)) $(patsubst src/%.c,$(BUILD_DIR)/mod/%.o,$(MD_SRC)): CFLAGS += -DNDEBUG \+ -Wno-unused-function -Wno-unused-variable -Wno-parentheses -Wno-unused-value -Wno-return-type -Wno-pointer-sign+# the games: tools/romtable.py makes the table, empty or with ROMS. It runs at every build and leaves# the file as it is when it wouldn't change, so nothing is linked again for nothing.$(BUILD_DIR)/roms.o: FORCE@@ -106,7 +115,7 @@ $(BUILD_DIR)/sim-module.o: $(CORE_SRC) $(APP_SRC) $(HEADERS)# ------------------------------------------------------------------ tests on this computerHOST_CC = cc-HOST_CFLAGS = -std=gnu11 -Isrc/nes -O1 -g -fsanitize=address,undefined -fno-sanitize-recover=undefined \+HOST_CFLAGS = -std=gnu11 -Isrc/nes -I$(BUILD_DIR) -O1 -g -fsanitize=address,undefined -fno-sanitize-recover=undefined -fno-sanitize=alignment,shift \-Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-implicit-fallthrough -Wno-missing-field-initializersTEST_ROMS ?= $(HOME)/Documents/Assets/gamesrc/retrogo/roms$(BUILD_DIR)/host/core: tests/host_core.c $(CORE_SRC) $(CORE_H)diff --git a/games/retrogo/src/md/LICENSE b/games/retrogo/src/md/LICENSEnew file mode 100644index 00000000..0ad25db4--- /dev/null+++ b/games/retrogo/src/md/LICENSE@@ -0,0 +1,661 @@+ GNU AFFERO GENERAL PUBLIC LICENSE+ Version 3, 19 November 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++ Preamble++ The GNU Affero General Public License is a free, copyleft license for+software and other kinds of works, specifically designed to ensure+cooperation with the community in the case of network server software.++ The licenses for most software and other practical works are designed+to take away your freedom to share and change the works. By contrast,+our General Public Licenses are intended to guarantee your freedom to+share and change all versions of a program--to make sure it remains free+software for all its users.++ When we speak of free software, we are referring to freedom, not+price. Our General Public Licenses are designed to make sure that you+have the freedom to distribute copies of free software (and charge for+them if you wish), that you receive source code or can get it if you+want it, that you can change the software or use pieces of it in new+free programs, and that you know you can do these things.++ Developers that use our General Public Licenses protect your rights+with two steps: (1) assert copyright on the software, and (2) offer+you this License which gives you legal permission to copy, distribute+and/or modify the software.++ A secondary benefit of defending all users' freedom is that+improvements made in alternate versions of the program, if they+receive widespread use, become available for other developers to+incorporate. Many developers of free software are heartened and+encouraged by the resulting cooperation. However, in the case of+software used on network servers, this result may fail to come about.+The GNU General Public License permits making a modified version and+letting the public access it on a server without ever releasing its+source code to the public.++ The GNU Affero General Public License is designed specifically to+ensure that, in such cases, the modified source code becomes available+to the community. It requires the operator of a network server to+provide the source code of the modified version running there to the+users of that server. Therefore, public use of a modified version, on+a publicly accessible server, gives the public access to the source+code of the modified version.++ An older license, called the Affero General Public License and+published by Affero, was designed to accomplish similar goals. This is+a different license, not a version of the Affero GPL, but Affero has+released a new version of the Affero GPL which permits relicensing under+this license.++ The precise terms and conditions for copying, distribution and+modification follow.++ TERMS AND CONDITIONS++ 0. Definitions.++ "This License" refers to version 3 of the GNU Affero General Public License.++ "Copyright" also means copyright-like laws that apply to other kinds of+works, such as semiconductor masks.++ "The Program" refers to any copyrightable work licensed under this+License. Each licensee is addressed as "you". "Licensees" and+"recipients" may be individuals or organizations.++ To "modify" a work means to copy from or adapt all or part of the work+in a fashion requiring copyright permission, other than the making of an+exact copy. The resulting work is called a "modified version" of the+earlier work or a work "based on" the earlier work.++ A "covered work" means either the unmodified Program or a work based+on the Program.++ To "propagate" a work means to do anything with it that, without+permission, would make you directly or secondarily liable for+infringement under applicable copyright law, except executing it on a+computer or modifying a private copy. Propagation includes copying,+distribution (with or without modification), making available to the+public, and in some countries other activities as well.++ To "convey" a work means any kind of propagation that enables other+parties to make or receive copies. Mere interaction with a user through+a computer network, with no transfer of a copy, is not conveying.++ An interactive user interface displays "Appropriate Legal Notices"+to the extent that it includes a convenient and prominently visible+feature that (1) displays an appropriate copyright notice, and (2)+tells the user that there is no warranty for the work (except to the+extent that warranties are provided), that licensees may convey the+work under this License, and how to view a copy of this License. If+the interface presents a list of user commands or options, such as a+menu, a prominent item in the list meets this criterion.++ 1. Source Code.++ The "source code" for a work means the preferred form of the work+for making modifications to it. "Object code" means any non-source+form of a work.++ A "Standard Interface" means an interface that either is an official+standard defined by a recognized standards body, or, in the case of+interfaces specified for a particular programming language, one that+is widely used among developers working in that language.++ The "System Libraries" of an executable work include anything, other+than the work as a whole, that (a) is included in the normal form of+packaging a Major Component, but which is not part of that Major+Component, and (b) serves only to enable use of the work with that+Major Component, or to implement a Standard Interface for which an+implementation is available to the public in source code form. A+"Major Component", in this context, means a major essential component+(kernel, window system, and so on) of the specific operating system+(if any) on which the executable work runs, or a compiler used to+produce the work, or an object code interpreter used to run it.++ The "Corresponding Source" for a work in object code form means all+the source code needed to generate, install, and (for an executable+work) run the object code and to modify the work, including scripts to+control those activities. However, it does not include the work's+System Libraries, or general-purpose tools or generally available free+programs which are used unmodified in performing those activities but+which are not part of the work. For example, Corresponding Source+includes interface definition files associated with source files for+the work, and the source code for shared libraries and dynamically+linked subprograms that the work is specifically designed to require,+such as by intimate data communication or control flow between those+subprograms and other parts of the work.++ The Corresponding Source need not include anything that users+can regenerate automatically from other parts of the Corresponding+Source.++ The Corresponding Source for a work in source code form is that+same work.++ 2. Basic Permissions.++ All rights granted under this License are granted for the term of+copyright on the Program, and are irrevocable provided the stated+conditions are met. This License explicitly affirms your unlimited+permission to run the unmodified Program. The output from running a+covered work is covered by this License only if the output, given its+content, constitutes a covered work. This License acknowledges your+rights of fair use or other equivalent, as provided by copyright law.++ You may make, run and propagate covered works that you do not+convey, without conditions so long as your license otherwise remains+in force. You may convey covered works to others for the sole purpose+of having them make modifications exclusively for you, or provide you+with facilities for running those works, provided that you comply with+the terms of this License in conveying all material for which you do+not control copyright. Those thus making or running the covered works+for you must do so exclusively on your behalf, under your direction+and control, on terms that prohibit them from making any copies of+your copyrighted material outside their relationship with you.++ Conveying under any other circumstances is permitted solely under+the conditions stated below. Sublicensing is not allowed; section 10+makes it unnecessary.++ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.++ No covered work shall be deemed part of an effective technological+measure under any applicable law fulfilling obligations under article+11 of the WIPO copyright treaty adopted on 20 December 1996, or+similar laws prohibiting or restricting circumvention of such+measures.++ When you convey a covered work, you waive any legal power to forbid+circumvention of technological measures to the extent such circumvention+is effected by exercising rights under this License with respect to+the covered work, and you disclaim any intention to limit operation or+modification of the work as a means of enforcing, against the work's+users, your or third parties' legal rights to forbid circumvention of+technological measures.++ 4. Conveying Verbatim Copies.++ You may convey verbatim copies of the Program's source code as you+receive it, in any medium, provided that you conspicuously and+appropriately publish on each copy an appropriate copyright notice;+keep intact all notices stating that this License and any+non-permissive terms added in accord with section 7 apply to the code;+keep intact all notices of the absence of any warranty; and give all+recipients a copy of this License along with the Program.++ You may charge any price or no price for each copy that you convey,+and you may offer support or warranty protection for a fee.++ 5. Conveying Modified Source Versions.++ You may convey a work based on the Program, or the modifications to+produce it from the Program, in the form of source code under the+terms of section 4, provided that you also meet all of these conditions:++ a) The work must carry prominent notices stating that you modified+ it, and giving a relevant date.++ b) The work must carry prominent notices stating that it is+ released under this License and any conditions added under section+ 7. This requirement modifies the requirement in section 4 to+ "keep intact all notices".++ c) You must license the entire work, as a whole, under this+ License to anyone who comes into possession of a copy. This+ License will therefore apply, along with any applicable section 7+ additional terms, to the whole of the work, and all its parts,+ regardless of how they are packaged. This License gives no+ permission to license the work in any other way, but it does not+ invalidate such permission if you have separately received it.++ d) If the work has interactive user interfaces, each must display+ Appropriate Legal Notices; however, if the Program has interactive+ interfaces that do not display Appropriate Legal Notices, your+ work need not make them do so.++ A compilation of a covered work with other separate and independent+works, which are not by their nature extensions of the covered work,+and which are not combined with it such as to form a larger program,+in or on a volume of a storage or distribution medium, is called an+"aggregate" if the compilation and its resulting copyright are not+used to limit the access or legal rights of the compilation's users+beyond what the individual works permit. Inclusion of a covered work+in an aggregate does not cause this License to apply to the other+parts of the aggregate.++ 6. Conveying Non-Source Forms.++ You may convey a covered work in object code form under the terms+of sections 4 and 5, provided that you also convey the+machine-readable Corresponding Source under the terms of this License,+in one of these ways:++ a) Convey the object code in, or embodied in, a physical product+ (including a physical distribution medium), accompanied by the+ Corresponding Source fixed on a durable physical medium+ customarily used for software interchange.++ b) Convey the object code in, or embodied in, a physical product+ (including a physical distribution medium), accompanied by a+ written offer, valid for at least three years and valid for as+ long as you offer spare parts or customer support for that product+ model, to give anyone who possesses the object code either (1) a+ copy of the Corresponding Source for all the software in the+ product that is covered by this License, on a durable physical+ medium customarily used for software interchange, for a price no+ more than your reasonable cost of physically performing this+ conveying of source, or (2) access to copy the+ Corresponding Source from a network server at no charge.++ c) Convey individual copies of the object code with a copy of the+ written offer to provide the Corresponding Source. This+ alternative is allowed only occasionally and noncommercially, and+ only if you received the object code with such an offer, in accord+ with subsection 6b.++ d) Convey the object code by offering access from a designated+ place (gratis or for a charge), and offer equivalent access to the+ Corresponding Source in the same way through the same place at no+ further charge. You need not require recipients to copy the+ Corresponding Source along with the object code. If the place to+ copy the object code is a network server, the Corresponding Source+ may be on a different server (operated by you or a third party)+ that supports equivalent copying facilities, provided you maintain+ clear directions next to the object code saying where to find the+ Corresponding Source. Regardless of what server hosts the+ Corresponding Source, you remain obligated to ensure that it is+ available for as long as needed to satisfy these requirements.++ e) Convey the object code using peer-to-peer transmission, provided+ you inform other peers where the object code and Corresponding+ Source of the work are being offered to the general public at no+ charge under subsection 6d.++ A separable portion of the object code, whose source code is excluded+from the Corresponding Source as a System Library, need not be+included in conveying the object code work.++ A "User Product" is either (1) a "consumer product", which means any+tangible personal property which is normally used for personal, family,+or household purposes, or (2) anything designed or sold for incorporation+into a dwelling. In determining whether a product is a consumer product,+doubtful cases shall be resolved in favor of coverage. For a particular+product received by a particular user, "normally used" refers to a+typical or common use of that class of product, regardless of the status+of the particular user or of the way in which the particular user+actually uses, or expects or is expected to use, the product. A product+is a consumer product regardless of whether the product has substantial+commercial, industrial or non-consumer uses, unless such uses represent+the only significant mode of use of the product.++ "Installation Information" for a User Product means any methods,+procedures, authorization keys, or other information required to install+and execute modified versions of a covered work in that User Product from+a modified version of its Corresponding Source. The information must+suffice to ensure that the continued functioning of the modified object+code is in no case prevented or interfered with solely because+modification has been made.++ If you convey an object code work under this section in, or with, or+specifically for use in, a User Product, and the conveying occurs as+part of a transaction in which the right of possession and use of the+User Product is transferred to the recipient in perpetuity or for a+fixed term (regardless of how the transaction is characterized), the+Corresponding Source conveyed under this section must be accompanied+by the Installation Information. But this requirement does not apply+if neither you nor any third party retains the ability to install+modified object code on the User Product (for example, the work has+been installed in ROM).++ The requirement to provide Installation Information does not include a+requirement to continue to provide support service, warranty, or updates+for a work that has been modified or installed by the recipient, or for+the User Product in which it has been modified or installed. Access to a+network may be denied when the modification itself materially and+adversely affects the operation of the network or violates the rules and+protocols for communication across the network.++ Corresponding Source conveyed, and Installation Information provided,+in accord with this section must be in a format that is publicly+documented (and with an implementation available to the public in+source code form), and must require no special password or key for+unpacking, reading or copying.++ 7. Additional Terms.++ "Additional permissions" are terms that supplement the terms of this+License by making exceptions from one or more of its conditions.+Additional permissions that are applicable to the entire Program shall+be treated as though they were included in this License, to the extent+that they are valid under applicable law. If additional permissions+apply only to part of the Program, that part may be used separately+under those permissions, but the entire Program remains governed by+this License without regard to the additional permissions.++ When you convey a copy of a covered work, you may at your option+remove any additional permissions from that copy, or from any part of+it. (Additional permissions may be written to require their own+removal in certain cases when you modify the work.) You may place+additional permissions on material, added by you to a covered work,+for which you have or can give appropriate copyright permission.++ Notwithstanding any other provision of this License, for material you+add to a covered work, you may (if authorized by the copyright holders of+that material) supplement the terms of this License with terms:++ a) Disclaiming warranty or limiting liability differently from the+ terms of sections 15 and 16 of this License; or++ b) Requiring preservation of specified reasonable legal notices or+ author attributions in that material or in the Appropriate Legal+ Notices displayed by works containing it; or++ c) Prohibiting misrepresentation of the origin of that material, or+ requiring that modified versions of such material be marked in+ reasonable ways as different from the original version; or++ d) Limiting the use for publicity purposes of names of licensors or+ authors of the material; or++ e) Declining to grant rights under trademark law for use of some+ trade names, trademarks, or service marks; or++ f) Requiring indemnification of licensors and authors of that+ material by anyone who conveys the material (or modified versions of+ it) with contractual assumptions of liability to the recipient, for+ any liability that these contractual assumptions directly impose on+ those licensors and authors.++ All other non-permissive additional terms are considered "further+restrictions" within the meaning of section 10. If the Program as you+received it, or any part of it, contains a notice stating that it is+governed by this License along with a term that is a further+restriction, you may remove that term. If a license document contains+a further restriction but permits relicensing or conveying under this+License, you may add to a covered work material governed by the terms+of that license document, provided that the further restriction does+not survive such relicensing or conveying.++ If you add terms to a covered work in accord with this section, you+must place, in the relevant source files, a statement of the+additional terms that apply to those files, or a notice indicating+where to find the applicable terms.++ Additional terms, permissive or non-permissive, may be stated in the+form of a separately written license, or stated as exceptions;+the above requirements apply either way.++ 8. Termination.++ You may not propagate or modify a covered work except as expressly+provided under this License. Any attempt otherwise to propagate or+modify it is void, and will automatically terminate your rights under+this License (including any patent licenses granted under the third+paragraph of section 11).++ However, if you cease all violation of this License, then your+license from a particular copyright holder is reinstated (a)+provisionally, unless and until the copyright holder explicitly and+finally terminates your license, and (b) permanently, if the copyright+holder fails to notify you of the violation by some reasonable means+prior to 60 days after the cessation.++ Moreover, your license from a particular copyright holder is+reinstated permanently if the copyright holder notifies you of the+violation by some reasonable means, this is the first time you have+received notice of violation of this License (for any work) from that+copyright holder, and you cure the violation prior to 30 days after+your receipt of the notice.++ Termination of your rights under this section does not terminate the+licenses of parties who have received copies or rights from you under+this License. If your rights have been terminated and not permanently+reinstated, you do not qualify to receive new licenses for the same+material under section 10.++ 9. Acceptance Not Required for Having Copies.++ You are not required to accept this License in order to receive or+run a copy of the Program. Ancillary propagation of a covered work+occurring solely as a consequence of using peer-to-peer transmission+to receive a copy likewise does not require acceptance. However,+nothing other than this License grants you permission to propagate or+modify any covered work. These actions infringe copyright if you do+not accept this License. Therefore, by modifying or propagating a+covered work, you indicate your acceptance of this License to do so.++ 10. Automatic Licensing of Downstream Recipients.++ Each time you convey a covered work, the recipient automatically+receives a license from the original licensors, to run, modify and+propagate that work, subject to this License. You are not responsible+for enforcing compliance by third parties with this License.++ An "entity transaction" is a transaction transferring control of an+organization, or substantially all assets of one, or subdividing an+organization, or merging organizations. If propagation of a covered+work results from an entity transaction, each party to that+transaction who receives a copy of the work also receives whatever+licenses to the work the party's predecessor in interest had or could+give under the previous paragraph, plus a right to possession of the+Corresponding Source of the work from the predecessor in interest, if+the predecessor has it or can get it with reasonable efforts.++ You may not impose any further restrictions on the exercise of the+rights granted or affirmed under this License. For example, you may+not impose a license fee, royalty, or other charge for exercise of+rights granted under this License, and you may not initiate litigation+(including a cross-claim or counterclaim in a lawsuit) alleging that+any patent claim is infringed by making, using, selling, offering for+sale, or importing the Program or any portion of it.++ 11. Patents.++ A "contributor" is a copyright holder who authorizes use under this+License of the Program or a work on which the Program is based. The+work thus licensed is called the contributor's "contributor version".++ A contributor's "essential patent claims" are all patent claims+owned or controlled by the contributor, whether already acquired or+hereafter acquired, that would be infringed by some manner, permitted+by this License, of making, using, or selling its contributor version,+but do not include claims that would be infringed only as a+consequence of further modification of the contributor version. For+purposes of this definition, "control" includes the right to grant+patent sublicenses in a manner consistent with the requirements of+this License.++ Each contributor grants you a non-exclusive, worldwide, royalty-free+patent license under the contributor's essential patent claims, to+make, use, sell, offer for sale, import and otherwise run, modify and+propagate the contents of its contributor version.++ In the following three paragraphs, a "patent license" is any express+agreement or commitment, however denominated, not to enforce a patent+(such as an express permission to practice a patent or covenant not to+sue for patent infringement). To "grant" such a patent license to a+party means to make such an agreement or commitment not to enforce a+patent against the party.++ If you convey a covered work, knowingly relying on a patent license,+and the Corresponding Source of the work is not available for anyone+to copy, free of charge and under the terms of this License, through a+publicly available network server or other readily accessible means,+then you must either (1) cause the Corresponding Source to be so+available, or (2) arrange to deprive yourself of the benefit of the+patent license for this particular work, or (3) arrange, in a manner+consistent with the requirements of this License, to extend the patent+license to downstream recipients. "Knowingly relying" means you have+actual knowledge that, but for the patent license, your conveying the+covered work in a country, or your recipient's use of the covered work+in a country, would infringe one or more identifiable patents in that+country that you have reason to believe are valid.++ If, pursuant to or in connection with a single transaction or+arrangement, you convey, or propagate by procuring conveyance of, a+covered work, and grant a patent license to some of the parties+receiving the covered work authorizing them to use, propagate, modify+or convey a specific copy of the covered work, then the patent license+you grant is automatically extended to all recipients of the covered+work and works based on it.++ A patent license is "discriminatory" if it does not include within+the scope of its coverage, prohibits the exercise of, or is+conditioned on the non-exercise of one or more of the rights that are+specifically granted under this License. You may not convey a covered+work if you are a party to an arrangement with a third party that is+in the business of distributing software, under which you make payment+to the third party based on the extent of your activity of conveying+the work, and under which the third party grants, to any of the+parties who would receive the covered work from you, a discriminatory+patent license (a) in connection with copies of the covered work+conveyed by you (or copies made from those copies), or (b) primarily+for and in connection with specific products or compilations that+contain the covered work, unless you entered into that arrangement,+or that patent license was granted, prior to 28 March 2007.++ Nothing in this License shall be construed as excluding or limiting+any implied license or other defenses to infringement that may+otherwise be available to you under applicable patent law.++ 12. No Surrender of Others' Freedom.++ If conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License. If you cannot convey a+covered work so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you may+not convey it at all. For example, if you agree to terms that obligate you+to collect a royalty for further conveying from those to whom you convey+the Program, the only way you could satisfy both those terms and this+License would be to refrain entirely from conveying the Program.++ 13. Remote Network Interaction; Use with the GNU General Public License.++ Notwithstanding any other provision of this License, if you modify the+Program, your modified version must prominently offer all users+interacting with it remotely through a computer network (if your version+supports such interaction) an opportunity to receive the Corresponding+Source of your version by providing access to the Corresponding Source+from a network server at no charge, through some standard or customary+means of facilitating copying of software. This Corresponding Source+shall include the Corresponding Source for any work covered by version 3+of the GNU General Public License that is incorporated pursuant to the+following paragraph.++ Notwithstanding any other provision of this License, you have+permission to link or combine any covered work with a work licensed+under version 3 of the GNU General Public License into a single+combined work, and to convey the resulting work. The terms of this+License will continue to apply to the part which is the covered work,+but the work with which it is combined will remain governed by version+3 of the GNU General Public License.++ 14. Revised Versions of this License.++ The Free Software Foundation may publish revised and/or new versions of+the GNU Affero General Public License from time to time. Such new versions+will be similar in spirit to the present version, but may differ in detail to+address new problems or concerns.++ Each version is given a distinguishing version number. If the+Program specifies that a certain numbered version of the GNU Affero General+Public License "or any later version" applies to it, you have the+option of following the terms and conditions either of that numbered+version or of any later version published by the Free Software+Foundation. If the Program does not specify a version number of the+GNU Affero General Public License, you may choose any version ever published+by the Free Software Foundation.++ If the Program specifies that a proxy can decide which future+versions of the GNU Affero General Public License can be used, that proxy's+public statement of acceptance of a version permanently authorizes you+to choose that version for the Program.++ Later license versions may give you additional or different+permissions. However, no additional obligations are imposed on any+author or copyright holder as a result of your choosing to follow a+later version.++ 15. Disclaimer of Warranty.++ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++ 16. Limitation of Liability.++ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF+SUCH DAMAGES.++ 17. Interpretation of Sections 15 and 16.++ If the disclaimer of warranty and limitation of liability provided+above cannot be given local legal effect according to their terms,+reviewing courts shall apply local law that most closely approximates+an absolute waiver of all civil liability in connection with the+Program, unless a warranty or assumption of liability accompanies a+copy of the Program in return for a fee.++ END OF TERMS AND CONDITIONS++ How to Apply These Terms to Your New Programs++ If you develop a new program, and you want it to be of the greatest+possible use to the public, the best way to achieve this is to make it+free software which everyone can redistribute and change under these terms.++ To do so, attach the following notices to the program. It is safest+to attach them to the start of each source file to most effectively+state the exclusion of warranty; and each file should have at least+the "copyright" line and a pointer to where the full notice is found.++ <one line to give the program's name and a brief idea of what it does.>+ Copyright (C) <year> <name of author>++ This program is free software: you can redistribute it and/or modify+ it under the terms of the GNU Affero General Public License as published+ by the Free Software Foundation, either version 3 of the License, or+ (at your option) any later version.++ This program is distributed in the hope that it will be useful,+ but WITHOUT ANY WARRANTY; without even the implied warranty of+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+ GNU Affero General Public License for more details.++ You should have received a copy of the GNU Affero General Public License+ along with this program. If not, see <https://www.gnu.org/licenses/>.++Also add information on how to contact you by electronic and paper mail.++ If your software can interact with users remotely through a computer+network, you should also make sure that it provides a way for users to+get its source. For example, if your program is a web application, its+interface could display a "Source" link that leads users to an archive+of the code. There are many ways you could offer source, and different+solutions will be better for different programs; see section 13 for the+specific requirements.++ You should also get your employer (if you work as a programmer) or school,+if any, to sign a "copyright disclaimer" for the program, if necessary.+For more information on this, and how to apply and follow the GNU AGPL, see+<https://www.gnu.org/licenses/>.diff --git a/games/retrogo/src/md/gwenesis_bus.c b/games/retrogo/src/md/gwenesis_bus.cnew file mode 100644index 00000000..6889ddae--- /dev/null+++ b/games/retrogo/src/md/gwenesis_bus.c@@ -0,0 +1,688 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#include <stdio.h>+#include <stdint.h>+#include <string.h>+#include <assert.h>+#include <ctype.h>++#include "m68k.h"++#include "z80inst.h"+#include "gwenesis_bus.h"+#include "gwenesis_io.h"+#include "gwenesis_vdp.h"+#include "gwenesis_savestate.h"++/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound+ chips' writes go nowhere; and nothing printed) */+#define YM2612Read(clk) 0+#define YM2612Write(a, v, clk) ((void)0)+#define YM2612Init() ((void)0)+#define YM2612Config(x) ((void)0)+#define YM2612ResetChip() ((void)0)+#define gwenesis_SN76489_Write(v, clk) ((void)0)+#define gwenesis_SN76489_Init(a, b, c) ((void)0)+#define gwenesis_SN76489_Reset() ((void)0)+#define printf(...) ((void)0)+#define vfprintf(...) ((void)0)+/* (the Z80's 8 KB of RAM in two pages of 4 KB, md.c) */+extern unsigned char *md_zram[2];+#define ZRAM_AT(a) (md_zram[((a) >> 12) & 1][(a) & 0xFFF])++#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0+ #pragma GCC optimize("Ofast")+#endif++#define BUS_DISABLE_LOGGING 1++#if !BUS_DISABLE_LOGGING+#include <stdarg.h>+void bus_log(const char *subs, const char *fmt, ...) {+ extern int frame_counter;+ extern int scan_line;++ va_list va;++ printf("%06d:%03d :[%s] vc:%04x hc:%04x hv:%04x ", frame_counter, scan_line, subs,gwenesis_vdp_vcounter(),gwenesis_vdp_hcounter(),gwenesis_vdp_hvcounter());++ va_start(va, fmt);+ vfprintf(stdout, fmt, va);+ va_end(va);+ printf("\n");+}+#else+ #define bus_log(...) do {} while(0)+#endif++// Setup M68k memories ROM & RAM+#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0++#include "rom_manager.h"+unsigned char *M68K_RAM=(void *)(uint32_t)(0); // 68K RAM+#else++unsigned char *ROM_DATA; // 68K Main Program (uncompressed)+unsigned int md_rom_mask; // (NumPlay: the ROM's size rounded up to a power of two, less one)+#endif+++// Setup Z80 Memory+unsigned char TMSS[0x4];+extern unsigned short gwenesis_vdp_status;++// TMSS+int tmss_state = 0;+int tmss_count = 0;++/******************************************************************************+ *+ * Load a Sega Genesis Cartridge into CPU Memory+ *+ ******************************************************************************/+++#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0++void load_cartridge()+{+ // Clear all volatile memory+ memset(M68K_RAM, 0, MAX_RAM_SIZE);+ memset(ZRAM, 0, MAX_Z80_RAM_SIZE);++ // Set Z80 Memory as Z80_RAM+ z80_set_memory(ZRAM);++ z80_pulse_reset();++ set_region();++}+#else++void load_cartridge(unsigned char *buffer, size_t size)+{+ /* (NumPlay: the RAMs are cleared by md.c, which places them; the ROM is read in place, made+ plain and its bytes swapped when it went in, tools/romtable.py) */+ z80_pulse_reset();+ ROM_DATA = buffer;+ md_rom_mask = 1;+ while (md_rom_mask < size) md_rom_mask <<= 1;+ md_rom_mask--;+ set_region();+}++#endif++/******************************************************************************+ *+ * Power ON the CPU+ * Initialize 68K, Z80 and YM2612 Cores+ *+ ******************************************************************************/+void power_on() {+ // Set M68K CPU as original MOTOROLA 68000+ //m68k_set_cpu_type(M68K_CPU_TYPE_68000);+ // Initialize M68K CPU+ m68k_init();+ // Initialize Z80 CPU+ z80_start();+ // Initialize YM2612 chip+ YM2612Init();+ YM2612Config(9);+ // Initialize PSG SN76489 chip+ //CLOCK_NTSC = 3579545,+ //CLOCK_PAL = 3546895,+ // CLOCK_NTSC_SMS1 = 3579527++// if (mode_pal) {+// gwenesis_SN76489_Init(3546895, GWENESIS_AUDIO_BUFFER_LENGTH_PAL*50,AUDIO_FREQ_DIVISOR);+// } else{+// gwenesis_SN76489_Init(3579545, GWENESIS_AUDIO_BUFFER_LENGTH_NTSC*60,AUDIO_FREQ_DIVISOR);+// }++ gwenesis_SN76489_Init(3579545, 888*60,AUDIO_FREQ_DIVISOR);++}++/******************************************************************************+ *+ * Reset the CPU Emulation+ * Send a pulse reset to 68K, Z80 and YM2612 Cores+ *+ ******************************************************************************/+void reset_emulation() {+ // Send a reset pulse to Z80 CPU+ z80_pulse_reset();+ // Send a reset pulse to Z80 M68K+ m68k_pulse_reset();+ // Send a reset pulse to YM2612 chip+ YM2612ResetChip();+ // Send a reset pulse to SEGA 315-5313 chip+ gwenesis_vdp_reset();+ gwenesis_SN76489_Reset();+}++/******************************************************************************+ *+ * Set Region+ * Look at ROM to set console compatible region+ *+ ******************************************************************************/+void set_region()+{+ /*+ old style : JUE characters+ J : Domestic 60Hz (Asia)+ U : Oversea 60Hz (USA)+ E : Oversea 50Hz (Europe)++ new style : 1st character+ bit 0 : +1 Domestic 60Hz (Asia)+ bit 1 : +2 Domestc 50Hz (Asia)+ bit 2: +4 Oversea 60Hz (USA)+ bit 3: +4 Oversea 50Hz (Europe)+ */++ // extern int mode_pal;++ int country = 0;++ char rom_str[3];++ printf("ROM game : ");+ for (int j=0; j < 48;j++) printf("%c",(char)FETCH8ROM(0x150+j));+ printf("\n");++ rom_str[0]=FETCH8ROM(0x1F0);+ rom_str[1]=FETCH8ROM(0x1F1);+ rom_str[2]=FETCH8ROM(0x1F2);++ printf("ROM region:%c%c%c (0x%02x 0x%02x 0x%02x)\n", rom_str[0],rom_str[1],rom_str[2],rom_str[0],rom_str[1],rom_str[2]);++ /* from Gens */+ if (!memcmp(rom_str, "eur", 3)) country |= 8;+ else if (!memcmp(rom_str, "EUR", 3)) country |= 8;+ else if (!memcmp(rom_str, "Europe", 3)) country |= 8;+ else if (!memcmp(rom_str, "jap", 3)) country |= 1;+ else if (!memcmp(rom_str, "JAP", 3)) country |= 1;+ else if (!memcmp(rom_str, "usa", 3)) country |= 4;+ else if (!memcmp(rom_str, "USA", 3)) country |= 4;+ else+ {+ int i;+ unsigned char c;++ /* look for each characters */+ for(i = 0; i < 3; i++)+ {+ c = rom_str[i];++ if (c == 'U') country |= 4;+ else if (c == 'E' || c == 'e' ) country |= 8;+ else if (c == 'J' || c == 'j' ) country |= 1;+ else if (c == 'K' || c == 'k' ) country |= 1;+ else if (c < 16) country |= c;+ else if ((c >= '0') && (c <= '9')) country |= c - '0';+ else if ((c >= 'A') && (c <= 'F')) country |= c - 'A' + 10;+ }+ }+ printf("country code=%01x : ",country);+ /* set default console region (USA > EUROPE > JAPAN) */+ /*+ IO REG0 : MODE VMOD DISK RSV VER3 VER2 VER1 VER0+ MODE (R) 0: Domestic Model+ 1: Overseas Model+ VMOD (R) 0: NTSC CPU clock 7.67 MHz+ 1: PAL CPU clock 7.60 MHz+ */++ /* USA 60Hz*/+ if (country & 4){+ printf("Oversea-NTSC USA 60Hz\n");+ gwenesis_io_set_reg(0, 0x81);+ // gwenesis_vdp_status &= 0xFFFE;+ // mode_pal = 0;+ return;+ }+ /* EUROPE 50Hz */+ if (country & 8){+ printf("Oversea-PAL Europe 50Hz\n");+ gwenesis_io_set_reg(0, 0xC1);+ // gwenesis_vdp_status |= 0x1;+ //mode_pal = 1;+ return;+ }+ /* set Asia 60HZ */+ if (country & 1){+ printf("Domestic-NTSC Asia 60Hz\n");+ gwenesis_io_set_reg(0, 0x1);+ // gwenesis_vdp_status &= 0xFFFE;+ //mode_pal = 0;+ return;+ }+ printf("Oversea-NTSC USA 60Hz no detection>> default mode\n");+ gwenesis_io_set_reg(0, 0x81);+ // gwenesis_vdp_status &= 0xFFFE;+ // mode_pal = 0;++}+/******************************************************************************+ *+ * Main memory address mapper+ * Map all main memory region address for CPU program+ * 68K Access to Z80 Memory+ *+ ******************************************************************************/+static inline unsigned int gwenesis_bus_map_z80_address(unsigned int address) {++ unsigned int range = (address & 0xF000);+ switch (range) {+ case 0:+ case 0x1000:+ return Z80_RAM_ADDR;+ case 0x2000:+ case 0x3000:+ return Z80_RAM_ADDR1K;+ case 0x4000:+ return Z80_YM2612_ADDR;+ case 0x6000:+ return Z80_BANK_ADDR;+ case 0x7000:+ return Z80_SN76489_ADDR;+ default:+ bus_log(__FUNCTION__,"no map Z80 %x",address);+ assert(0);+ return NONE;+ }+}++/******************************************************************************+ *+ * IO memory address mapper+ * Map all input/output region address for CPU program+ *+ ******************************************************************************/+static inline unsigned int gwenesis_bus_map_io_address(unsigned int address)+{+ unsigned int range = (address & 0x1000) ;+ switch (range) {+ case 0: return IO_CTRL;+ case 0x1000: return Z80_CTRL;+ default:+ // if (address >= 0xa14000 && address < 0xa11404)+ // return (tmss_state == 0) ? TMSS_CTRL : NONE;+ bus_log(__FUNCTION__,"no map io %x",address);++ return NONE;+ }+}++/******************************************************************************+ *+ * Main memory address mapper+ * Map all main memory region address for CPU program+ *+ ******************************************************************************/++static inline+unsigned int gwenesis_bus_map_address(unsigned int address) {+ // Mask address page+ unsigned int range = (address & 0xFF0000) >> 16;++ // Check mask and select memory type+ if (range < 0x80) // ROM ADDRESS 0x000000 - 0x3FFFFF+ return ROM_ADDR;++ else if (range == 0xA0) // Z80 ADDRESS 0xA00000 - 0xA0FFFF+ return gwenesis_bus_map_z80_address(address);+++ else if (range == 0xA1) // IO ADDRESS 0xA10000 - 0xA1FFFF+ return gwenesis_bus_map_io_address(address);++ else if (range == 0xC0) // VDP ADDRESS 0xC00000 - 0xDFFFFFF+ return VDP_ADDR;+ else if (range == 0xFF) // RAM ADDRESS 0xE00000 - 0xFFFFFFF+ return RAM_ADDR;+ // If not a valid address return 0+ bus_log(__FUNCTION__,"M68K > ?? unnmap address %x", address);+ //assert(0);+ return NONE;+}+/******************************************************************************+ *+ * Main read address routine+ * Write an value to memory mapped on specified address+ *+ ******************************************************************************/+static inline unsigned int gwenesis_bus_read_memory_8(unsigned int address) {+ bus_log(__FUNCTION__,"read8 %x", address);++ switch (gwenesis_bus_map_address(address)) {++ case VDP_ADDR:+ return gwenesis_vdp_read_memory_8(address);++ case ROM_ADDR:+ return FETCH8ROM(address);++ case RAM_ADDR:+ return FETCH8RAM(address);++ case IO_CTRL:+ return gwenesis_io_read_ctrl(address & 0x1F);++ case Z80_CTRL:+ return z80_read_ctrl(address & 0xFFFF);++ case Z80_RAM_ADDR:+ case Z80_RAM_ADDR1K:+ return ZRAM_AT(address);++ case Z80_YM2612_ADDR:+ return YM2612Read(m68k_cycles_master());++ case Z80_SN76489_ADDR:+ return 0xff;++ case Z80_BANK_ADDR:+ return 0xff;++ case TMSS_CTRL:+ bus_log(__FUNCTION__,"TMS");+ if (tmss_state == 0)+ return TMSS[address & 0x4];+ return 0xFF;++ default:+ bus_log(__FUNCTION__," default read 8 %x", address);+ return 0x00;+ }+ return 0x00;+}++static inline unsigned int gwenesis_bus_read_memory_16(unsigned int address) {+ bus_log(__FUNCTION__,"read16 %x", address);+ unsigned int ret_value;++ switch (gwenesis_bus_map_address(address)) {++ case VDP_ADDR:+ return gwenesis_vdp_read_memory_16(address);++ case RAM_ADDR:+ return FETCH16RAM(address);++ case ROM_ADDR:+ return FETCH16ROM(address);++ case IO_CTRL:+ return gwenesis_io_read_ctrl(address & 0x1F);++ case Z80_CTRL:+ // ret_value = z80_read_ctrl(address & 0xFFFF);+ // return ret_value | ret_value << 8;+ address &=0xFFFF;+ return (z80_read_ctrl(address) << 8) | z80_read_ctrl(address | 1);+++ case Z80_RAM_ADDR:+ case Z80_RAM_ADDR1K:+ return ZRAM_AT(address) | (ZRAM_AT(address) << 8);++ case Z80_YM2612_ADDR:+ ret_value = YM2612Read(m68k_cycles_master());+ return ret_value | ret_value << 8;+++ case Z80_SN76489_ADDR:+ return 0xff;++ case Z80_BANK_ADDR:+ return 0xff;++ default:+ bus_log(__FUNCTION__,"read mem 16 default %x", address);+ return (gwenesis_bus_read_memory_8(address) << 8) |+ gwenesis_bus_read_memory_8(address + 1);+ }+ return 0x00;+}++/******************************************************************************+ *+ * Main write address routine+ * Write an value to memory mapped on specified address+ *+ ******************************************************************************/+static inline void gwenesis_bus_write_memory_8(unsigned int address,+ unsigned int value) {+ bus_log(__FUNCTION__,"write8 @%x:%x", address,value);++ switch (gwenesis_bus_map_address(address)) {++ case VDP_ADDR:+ gwenesis_vdp_write_memory_16(address & ~1, (value << 8) | value);+ return;++ case RAM_ADDR:+ WRITE8RAM(address, value);+ return;++ case IO_CTRL:+ gwenesis_io_write_ctrl(address & 0x1F, value);+ return;++ case Z80_CTRL:+ z80_write_ctrl(address & 0x1FFF, value);+ return;++ case Z80_RAM_ADDR:+ case Z80_RAM_ADDR1K:+ ZRAM_AT(address) = value;+ return;++ case Z80_YM2612_ADDR:+ bus_log(__FUNCTION__,"CPUZ80PSG8 ,m68kclk= %d", m68k_cycles_master());+ YM2612Write(address & 0x3, value & 0Xff,m68k_cycles_master());+ return;++ case Z80_SN76489_ADDR:+ bus_log(__FUNCTION__,"CPUZ80FM8 ,m68kclk= %d", m68k_cycles_master());+ gwenesis_SN76489_Write( value & 0Xff, m68k_cycles_master());+ return;++ case Z80_BANK_ADDR:+ //TODO+ return;++ case TMSS_CTRL:++ if (tmss_state == 0) {+ TMSS[address & 0x4] = value;+ tmss_count++;+ if (tmss_count == 4)+ tmss_state = 1;+ }+ return;++++ default:+ //printf("write(%x, %x)\n", address, value);+ return;+ }+ return;+}++static inline void gwenesis_bus_write_memory_16(unsigned int address,+ unsigned int value) {+ bus_log(__FUNCTION__,"write16 @%x:%x", address,value);++ switch (gwenesis_bus_map_address(address)) {++ case VDP_ADDR:+ gwenesis_vdp_write_memory_16(address, value);+ return;++ case RAM_ADDR:+ WRITE16RAM(address, value);+ return;++ case Z80_RAM_ADDR:+ case Z80_RAM_ADDR1K:+ ZRAM_AT(address) = value >> 8;+ return;++ case IO_CTRL:+ gwenesis_io_write_ctrl(address & 0x1F, value);+ return;++ case Z80_CTRL:+ z80_write_ctrl(address & 0xFFFF, value >> 8) ;+ return;++ case Z80_YM2612_ADDR:+ bus_log(__FUNCTION__,"CZYM16 ,mclk=%d", m68k_cycles_master());+ YM2612Write(address & 0x3, value >> 8,m68k_cycles_master() );+ return;++ case Z80_SN76489_ADDR:+ bus_log(__FUNCTION__,"CZSN16 ,mclk=%d", m68k_cycles_master());+ gwenesis_SN76489_Write(value >> 8,m68k_cycles_master() );+ return;++ default:+ bus_log(__FUNCTION__,"write mem 16 default %x ", address);+ gwenesis_bus_write_memory_8(address, (value >> 8) & 0xff);+ gwenesis_bus_write_memory_8(address + 1, (value)&0xff);++ return;+ }+ return;+}++/******************************************************************************+ *+ * 68K CPU read address R8+ * Read an address from memory mapped and return value as byte+ *+ ******************************************************************************/+unsigned int m68k_read_memory_8(unsigned int address)+{+ // if ((address & 0xFF0000 ) == 0xFF0000) return FETCH8RAM(address);+ return gwenesis_bus_read_memory_8(address);+}++/******************************************************************************+ *+ * 68K CPU read address R16+ * Read an address from memory mapped and return value as word+ *+ ******************************************************************************/+ unsigned int m68k_read_memory_16(unsigned int address)+{+ // if ((address & 0xFF0000 ) == 0xFF0000) return FETCH16RAM(address);+ return gwenesis_bus_read_memory_16(address);+}++/******************************************************************************+ *+ * 68K CPU read address R32+ * Read an address from memory mapped and return value as long+ *+ ******************************************************************************/+ unsigned int m68k_read_memory_32(unsigned int address)+{+ // if ((address & 0xFF0000 ) == 0xFF0000) return FETCH32RAM(address);+ return (gwenesis_bus_read_memory_16(address) << 16) | gwenesis_bus_read_memory_16(address + 2);+}++/******************************************************************************+ *+ * 68K CPU write address W8+ * Write an value as byte to memory mapped on specified address+ *+ ******************************************************************************/+void m68k_write_memory_8(unsigned int address, unsigned int value) {+ // if ((address & 0xFF0000) == 0xFF0000) {+ // WRITE8RAM(address, value);+ // return;+ // }+ gwenesis_bus_write_memory_8(address, value);+ return;+}++/******************************************************************************+ *+ * 68K CPU write address W16+ * Write an value as word to memory mapped on specified address+ *+ ******************************************************************************/+void m68k_write_memory_16(unsigned int address, unsigned int value) {+ // if ((address & 0xFF0000) == 0xFF0000) {+ // WRITE16RAM(address, value);+ // return;+ // }+ gwenesis_bus_write_memory_16(address, value);+ return;+}+/******************************************************************************+ *+ * 68K CPU write address W32+ * Write an value as word to memory mapped on specified address+ *+ ******************************************************************************/+void m68k_write_memory_32(unsigned int address, unsigned int value) {++ // if ((address & 0xFF0000) == 0xFF0000) {+ // WRITE32RAM(address, value);+ // return;+ // }+ gwenesis_bus_write_memory_16(address, (value >> 16) & 0xffff);+ gwenesis_bus_write_memory_16(address + 2, (value)&0xffff);++ return;+}++unsigned int m68k_read_disassembler_16(unsigned int address)+{+ return m68k_read_memory_16(address);+}+unsigned int m68k_read_disassembler_32(unsigned int address)+{+ return m68k_read_memory_32(address);+}++void gwenesis_bus_save_state() {+ SaveState* state;+ state = saveGwenesisStateOpenForWrite("bus");+ /* (the RAMs are parts of the state of their own, md.c) */+ saveGwenesisStateSetBuffer(state, "TMSS", TMSS, sizeof(TMSS));+ saveGwenesisStateSet(state, "tmss_state", tmss_state);+ saveGwenesisStateSet(state, "tmss_count", tmss_count);+}++void gwenesis_bus_load_state() {+ SaveState* state = saveGwenesisStateOpenForRead("bus");+ saveGwenesisStateGetBuffer(state, "TMSS", TMSS, sizeof(TMSS));+ tmss_state = saveGwenesisStateGet(state, "tmss_state");+ tmss_count = saveGwenesisStateGet(state, "tmss_count");+}\ No newline at end of filediff --git a/games/retrogo/src/md/gwenesis_bus.h b/games/retrogo/src/md/gwenesis_bus.hnew file mode 100644index 00000000..43ddc9ff--- /dev/null+++ b/games/retrogo/src/md/gwenesis_bus.h@@ -0,0 +1,101 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#ifndef _gwenesis_bus_H_+#define _gwenesis_bus_H_++#pragma once++#include <stdio.h>+#include <string.h>++#define MAX_ROM_SIZE 0x800000+#define MAX_RAM_SIZE 0x10000+#define MAX_Z80_RAM_SIZE 8192++// NTSC PAL timings+#define MCLOCK_PAL 53203424+#define MCLOCK_NTSC 53693175++#define MCYCLES_PER_FRAME_NTSC 896040+#define MCYCLES_PER_FRAME_PAL 1067040+#define LINES_PER_FRAME_NTSC 262+#define LINES_PER_FRAME_PAL 313++#define GWENESIS_REFRESH_RATE_NTSC 60+#define GWENESIS_AUDIO_FREQ_NTSC 53267++#define GWENESIS_REFRESH_RATE_PAL 50+#define GWENESIS_AUDIO_FREQ_PAL 52781++#define GWENESIS_AUDIO_ACCURATE 1++#define Z80_FREQ_DIVISOR 14 // Frequency divisor to Z80 clock+#define VDP_CYCLES_PER_LINE 3420// VDP Cycles per Line+#define SCREEN_WIDTH 320++#define AUDIO_FREQ_DIVISOR 1009+#define GWENESIS_AUDIO_BUFFER_LENGTH_NTSC 888+#define GWENESIS_AUDIO_BUFFER_LENGTH_PAL 1056++/* Audio buffer length */++enum mapped_address+{+ NONE = 0,+ ROM_ADDR,+ ROM_ADDR_MIRROR,+ Z80_RAM_ADDR,+ Z80_RAM_ADDR1K,+ Z80_YM2612_ADDR,+ Z80_BANK_ADDR,+ Z80_VDP_ADDR,+ Z80_SN76489_ADDR,+ IO_CTRL,+ Z80_CTRL,+ TMSS_CTRL,+ VDP_ADDR,+ RAM_ADDR+};++enum gwenesis_bus_pad_button+{+ PAD_UP,+ PAD_DOWN,+ PAD_LEFT,+ PAD_RIGHT,+ PAD_B,+ PAD_C,+ PAD_A,+ PAD_S+};++#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0+void load_cartridge();+#else+void load_cartridge(unsigned char *buffer, size_t size);+#endif++void power_on();+void reset_emulation();+void set_region();++void gwenesis_bus_save_state();+void gwenesis_bus_load_state();++#endif\ No newline at end of filediff --git a/games/retrogo/src/md/gwenesis_io.c b/games/retrogo/src/md/gwenesis_io.cnew file mode 100644index 00000000..2f8d2b1c--- /dev/null+++ b/games/retrogo/src/md/gwenesis_io.c@@ -0,0 +1,252 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#include <stddef.h>+#include <stdio.h>+#include <string.h>+#include "gwenesis_io.h"+#include "gwenesis_savestate.h"++/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound+ chips' writes go nowhere; and nothing printed) */+#define YM2612Read(clk) 0+#define YM2612Write(a, v, clk) ((void)0)+#define YM2612Init() ((void)0)+#define YM2612Config(x) ((void)0)+#define YM2612ResetChip() ((void)0)+#define gwenesis_SN76489_Write(v, clk) ((void)0)+#define gwenesis_SN76489_Init(a, b, c) ((void)0)+#define gwenesis_SN76489_Reset() ((void)0)+#define printf(...) ((void)0)+#define vfprintf(...) ((void)0)++unsigned char button_state[3]= {0xff,0xff,0xff};++/* Button mapping+ 7 6 5 4 3 2 1 0+Start A B C R L D U+*/+static unsigned char gwenesis_io_pad_state[3] = {0x33,0x33,0x33};++#define GWENESIS_IO_VERSION 0x81 /* oversea NTSC model version 81 */+/*+$A10003 : MODE VMOD DISK RSV VER3 VER2 VER1 VER0+MODE (R) 0: Domestic Model+ 1: Overseas Model+VMOD (R) 0: NTSC CPU clock 7.67 MHz+ 1: PAL CPU clock 7.60 MHz+RSV (R) Currently not used+VER3-0 (R) MEGA DRIVE version is indicated by $0-$F. The present hardware version is indicated by $0.+$A10003 : DATA 1 ( CTRL1 )+$A10005 : DATA 2 ( CTRL2 )+$A10007 : DATA 3 ( EXP )+$A10009 : CTRL 1+$A1000B : CTRL 2+$A1000D : CTRL 3+$A1000F : TxDATA 1+$A10011 : RxDATA 1+$A10013 : S-CTRL 1+$A10015 : TxDATA 2+$A10017 : RxDATA 2+$A10019 : S-CTRL 2+$A1001B : TxDATA 3+$A1001D : RxDATA 3+$A1001F : S-CTRL 3++DATA shows the status of each port. The I/O direction of each bit is set by CTRL and S-CTRL.+DATA = PD7 PD6 PD5 PD4 PD3 PD2 PD1 PD0++PD7 (RW)+PD6 (RW) TH+PD5 (RW) TR+PD4 (RW) TL+PD3 (RW) RIGHT+PD2 (RW) LEFT+PD1 (RW) DOWN+PD0 (RW) UP++TH = 0+PD7 0+PD6 TH=0+PD5 Start+PD4 A+PD3 0+PD2 0+PD1 DOWN+PD0 UP++TH = 1+PD7 0+PD6 TH=1+PD5 B+PD4 C+PD3 RIGHT+PD2 LEFT+PD1 DOWN+PD0 UP+++CTRL designates the I/O direction of each port and the INTERRUPT CONTROL of TH.+CTRL = INT PC6 PC5 PC4 PC3 PC2 PC1 PC0++INT (RW) 0: TH-INT PROHIBITED+ 1: TH-INT ALLOWED+PC6 (RW) 0: PD6 INPUT MODE+ 1: OUTPUT MODE+PC5 (RW) 0: PD5 INPUT MODE+ 1: OUTPUT MODE+PC4 (RW) 0: PD4 INPUT MODE+ 1: OUTPUT MODE+PC3 (RW) 0: PD3 INPUT MODE+ 1: OUTPUT MODE+PC2 (RW) 0: PD2 INPUT MODE+ 1: OUTPUT MODE+PC1 (RW) 0: PD1 INPUT MODE+ 1: OUTPUT MODE+PC0 (RW) 0: PD0 INPUT MODE+ 1: OUTPUT MODE++S-CTRL is for the status, etc. of each port's mode change, baud rate and SERIAL.++S-CTRL = BPS1 BPS0 SIN SOUT RINT RERR RRDY TFUL++SIN (RW) 0: TR-PARALLEL MODE+ 1: SERIAL IN+SOUT (RW) 0: TL-PARALLEL MODE+ 1: SERIAL OUT+RINT (RW) 0: Rxd READY INTERRUPT PROHIBITED+ 1: Rxd READY INTERRUPT ALLOWED+RERR (R) 0:+ 1: Rxd ERROR+RRDY (R) 0:+ 1: Rxd READY+TFUL (R) 0:+ 1: Txd FULL+*/++unsigned char io_reg[16] = {GWENESIS_IO_VERSION, /* 0x1 Version */+ 0x7f, 0x7f, 0x7f, /* 0x3-5-7 JOYPAD DATA 1 2 & EXT */+ 0x00, 0x00, 0x00, /* 0x9-A-C JOYPAD CTRL 1 2 & EXT */+ 0xff, 0, 0, /* PORT 1 */+ 0xff, 0, 0, /* PORT 2 */+ 0xff, 0, 0}; /* PORT 3 */++void gwenesis_io_pad_release_button(int pad, int button)+{+ button_state[pad] |= (1 << button);+}++void gwenesis_io_pad_press_button(int pad, int button)+{+ button_state[pad] &= ~(1 << button);+}++static inline void gwenesis_io_pad_write(int pad, int value)+{+ unsigned char mask = io_reg[pad + 4];++ gwenesis_io_pad_state[pad] &= ~mask;+ gwenesis_io_pad_state[pad] |= value & mask;++}++static inline unsigned char gwenesis_io_pad_read(int pad)+{+ unsigned char value;++ /* get host button */+ gwenesis_io_get_buttons();++ value = gwenesis_io_pad_state[pad] & 0x40;+ value |= 0x3f;++ if (value & 0x40)+ {+ value &= (button_state[pad] & 0x3f);+ }+ else+ {+ value &= ((button_state[pad] & 3) | ((button_state[pad] >> 2) & 0x30));+ }+ return value;+}++void gwenesis_io_write_ctrl(unsigned int address, unsigned int value)+{++ address >>= 1;++ // JOYPAD DATA+ if (address >= 0x1 && address <= 0x3)+ {++ io_reg[address] = value;+ gwenesis_io_pad_write(address - 1, value);+ return;+ }+ // JOYPAD CTRL+ else if (address >= 0x4 && address <= 0x6)+ {+ if (io_reg[address] != value)+ {+ io_reg[address] = value;+ gwenesis_io_pad_write(address - 4, io_reg[address - 3]);+ }+ return;+ }++ return;+}++unsigned int gwenesis_io_read_ctrl(unsigned int address)+{+ address >>= 1;+ if (address >= 0x1 && address < 0x4)+ {+ unsigned char mask = 0x80 | io_reg[address + 3];+ unsigned char value;+ value = io_reg[address] & mask;+ value |= gwenesis_io_pad_read(address - 1) & ~mask;++ return value;+ }+ else+ {+ return io_reg[address];+ }+}++void gwenesis_io_set_reg(unsigned int reg, unsigned int value) {+ io_reg[reg] = value;+ return;+}++void gwenesis_io_save_state() {+ SaveState* state;+ state = saveGwenesisStateOpenForWrite("io");+ saveGwenesisStateSetBuffer(state, "button_state", button_state, sizeof(button_state));+ saveGwenesisStateSetBuffer(state, "gwenesis_io_pad_state", gwenesis_io_pad_state, sizeof(gwenesis_io_pad_state));+ saveGwenesisStateSetBuffer(state, "io_reg", io_reg, sizeof(io_reg));+}++void gwenesis_io_load_state() {+ SaveState* state = saveGwenesisStateOpenForRead("io");+ saveGwenesisStateGetBuffer(state, "button_state", button_state, sizeof(button_state));+ saveGwenesisStateGetBuffer(state, "gwenesis_io_pad_state", gwenesis_io_pad_state, sizeof(gwenesis_io_pad_state));+ saveGwenesisStateGetBuffer(state, "io_reg", io_reg, sizeof(io_reg));+}diff --git a/games/retrogo/src/md/gwenesis_io.h b/games/retrogo/src/md/gwenesis_io.hnew file mode 100644index 00000000..a1a1b753--- /dev/null+++ b/games/retrogo/src/md/gwenesis_io.h@@ -0,0 +1,36 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#ifndef _gwenesis_io_H_+#define _gwenesis_io_H_++#pragma once++void gwenesis_io_pad_press_button(int pad, int button);+void gwenesis_io_pad_release_button(int pad, int button);++void gwenesis_io_write_ctrl(unsigned int address, unsigned int value);+unsigned int gwenesis_io_read_ctrl(unsigned int address);++void gwenesis_io_set_reg(unsigned int reg, unsigned int value);+void gwenesis_io_get_buttons();++void gwenesis_io_save_state();+void gwenesis_io_load_state();++#endif\ No newline at end of filediff --git a/games/retrogo/src/md/gwenesis_savestate.h b/games/retrogo/src/md/gwenesis_savestate.hnew file mode 100644index 00000000..0709ec8b--- /dev/null+++ b/games/retrogo/src/md/gwenesis_savestate.h@@ -0,0 +1,45 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#ifndef _gwenesis_savestate_H_+#define _gwenesis_savestate_H_++#pragma once++#include <stdio.h>+#include <string.h>+#include <stdbool.h>++typedef struct SaveState SaveState;++bool initLoadGwenesisState(unsigned char *srcBuffer);+int saveGwenesisState(unsigned char *destBuffer, int save_size);+int loadGwenesisState(unsigned char *srcBuffer);++SaveState* saveGwenesisStateOpenForRead(const char* fileName);+SaveState* saveGwenesisStateOpenForWrite(const char* fileName);++int saveGwenesisStateGet(SaveState* state, const char* tagName);+void saveGwenesisStateSet(SaveState* state, const char* tagName, int value);++void saveGwenesisStateGetBuffer(SaveState* state, const char* tagName, void* buffer, int length);+void saveGwenesisStateSetBuffer(SaveState* state, const char* tagName, void* buffer, int length);++void gwenesis_save_state();+void gwenesis_load_state();+#endif\ No newline at end of filediff --git a/games/retrogo/src/md/gwenesis_vdp.h b/games/retrogo/src/md/gwenesis_vdp.hnew file mode 100644index 00000000..dcdaa6ef--- /dev/null+++ b/games/retrogo/src/md/gwenesis_vdp.h@@ -0,0 +1,153 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#ifndef _gwenesis_vdp_H_+#define _gwenesis_vdp_H_++#pragma once++#define BIT(v, idx) (((v) >> (idx)) & 1)+#define BITS(v, idx, n) (((v) >> (idx)) & ((1 << (n)) - 1))++// VDP registers+#define REG0_DISABLE_DISPLAY (gwenesis_vdp_regs[0] & 1)+#define REG0_HVLATCH BIT(gwenesis_vdp_regs[0], 1)+#define REG0_LINE_INTERRUPT BIT(gwenesis_vdp_regs[0], 4)+#define REG1_PAL BIT(gwenesis_vdp_regs[1], 3)+#define REG1_240_LINE ((gwenesis_vdp_regs[1] & 0x08) >> 3)+#define REG1_DMA_ENABLED BIT(gwenesis_vdp_regs[1], 4)+#define REG1_VBLANK_INTERRUPT BIT(gwenesis_vdp_regs[1], 5)+#define REG1_DISP_ENABLED BIT(gwenesis_vdp_regs[1], 6)+#define REG2_NAMETABLE_A (BITS(gwenesis_vdp_regs[2], 3, 3) << 13)+#define REG3_NAMETABLE_W BITS(gwenesis_vdp_regs[3], 1, 5)+#define REG4_NAMETABLE_B (BITS(gwenesis_vdp_regs[4], 0, 3) << 13)+//#define REG5_SAT_ADDRESS ((gwenesis_vdp_regs[5] & (mode_h40 ? 0x7E : 0x7F)) << 9)+//#define REG5_SAT_SIZE (mode_h40 ? (1 << 10) : (1 << 9))+#define REG5_SAT_ADDRESS ((gwenesis_vdp_regs[5] & ((gwenesis_vdp_regs[12] & 0x01) ? 0x7E : 0x7F)) << 9)+#define REG5_SAT_SIZE ((gwenesis_vdp_regs[12] & 0x01) ? (1 << 10) : (1 << 9))+#define REG10_LINE_COUNTER BITS(gwenesis_vdp_regs[10], 0, 8)+#define REG10_COLUMN_COUNTER BITS(gwenesis_vdp_regs[10], 8, 15)+#define REG11_HSCROLL_MODE ((gwenesis_vdp_regs[11] & 3))+#define REG11_VSCROLL_MODE ((gwenesis_vdp_regs[11] & 4) >> 2)+#define REG12_RS0 (gwenesis_vdp_regs[12] & 0x80) >> 7+#define REG12_RS1 (gwenesis_vdp_regs[12] & 0x01) >> 0+#define REG12_MODE_H40 (gwenesis_vdp_regs[12] & 1)+#define REG13_HSCROLL_ADDRESS (gwenesis_vdp_regs[13] << 10)+#define REG15_DMA_INCREMENT gwenesis_vdp_regs[15]+#define REG16_UNUSED1 ((gwenesis_vdp_regs[16] & 0xc0) >> 6)+#define REG16_VSCROLL_SIZE ((gwenesis_vdp_regs[16] >> 4) & 3)+#define REG16_UNUSED2 ((gwenesis_vdp_regs[16] & 0x0c) >> 2)+#define REG16_HSCROLL_SIZE (gwenesis_vdp_regs[16] & 3)+#define REG17_WINDOW_HPOS BITS(gwenesis_vdp_regs[17], 0, 5)+#define REG17_WINDOW_RIGHT ((gwenesis_vdp_regs[17] & 0x80) >> 7)+#define REG18_WINDOW_DOWN ((gwenesis_vdp_regs[0x12] & 0x80) >> 7)+#define REG18_WINDOW_VPOS BITS(gwenesis_vdp_regs[18], 0, 5)+#define REG19_DMA_LENGTH (gwenesis_vdp_regs[19] | (gwenesis_vdp_regs[20] << 8))+#define REG21_DMA_SRCADDR_LOW (gwenesis_vdp_regs[21] | (gwenesis_vdp_regs[22] << 8))+#define REG23_DMA_SRCADDR_HIGH ((gwenesis_vdp_regs[23] & 0x7F) << 16)+#define REG23_DMA_TYPE BITS(gwenesis_vdp_regs[23], 6, 2)++//VDP status register+#define STATUS_FIFO_EMPTY (1 << 9)+#define STATUS_FIFO_FULL (1 << 8)+#define STATUS_VIRQPENDING (1 << 7)+#define STATUS_SPRITEOVERFLOW (1 << 6)+#define STATUS_SPRITECOLLISION (1 << 5)+#define STATUS_ODDFRAME (1 << 4)+#define STATUS_VBLANK (1 << 3)+#define STATUS_HBLANK (1 << 2)+#define STATUS_DMAPROGRESS (1 << 1)+#define STATUS_PAL (1 << 0)++#define VRAM_MAX_SIZE 0x10000 // VRAM maximum size+#define CRAM_MAX_SIZE 0x40 // CRAM maximum size+#define VSRAM_MAX_SIZE 0x40 // VSRAM maximum size+#define SAT_CACHE_MAX_SIZE 0x400 // SAT CACHE maximum size+#define REG_SIZE 0x20 // REGISTERS total+#define FIFO_SIZE 0x4 // FIFO maximum size++#define COLOR_3B_TO_8B(c) (((c) << 5) | ((c) << 2) | ((c) >> 1))+#define CRAM_R(c) COLOR_3B_TO_8B(BITS((c), 1, 3))+#define CRAM_G(c) COLOR_3B_TO_8B(BITS((c), 5, 3))+#define CRAM_B(c) COLOR_3B_TO_8B(BITS((c), 9, 3))++#define MODE_SHI BITS(gwenesis_vdp_regs[12], 3, 1)++#define SHADOW_COLOR(r,g,b) \+ do { r >>= 1; g >>= 1; b >>= 1; } while (0)+#define HIGHLIGHT_COLOR(r,g,b) \+ do { SHADOW_COLOR(r,g,b); r |= 0x80; g |= 0x80; b |= 0x80; } while(0)++// While we draw the planes, we use bit 0x80 on each pixel to save the+// high-priority flag, so that we can later prioritize.+#define PIXATTR_HIPRI 0x80+#define PIXATTR_LOWPRI 0x00+#define PIXATTR_SPRITE 0x40+#define PIXATTR_SPRITE_HIPRI 0xC0+++// After mixing code, we use free bits 0x80 and 0x40 to indicate the+// shadow/highlight effect to apply on each pixel. Notice that we use+// 0x80 to indicate normal drawing and 0x00 to indicate shadowing,+// which does match exactly the semantic of PIXATTR_HIPRI. This simplifies+// mixing code quite a bit.+#define SHI_NORMAL(x) ((x) | 0x80)+#define SHI_HIGHLIGHT(x) ((x) | 0x40)+#define SHI_SHADOW(x) ((x) & 0x3F)++#define SHI_IS_SHADOW(x) (!((x) & 0x80))+#define SHI_IS_HIGHLIGHT(x) ((x) & 0x40)++void gwenesis_vdp_reset();+void gwenesis_vdp_set_hblank();+void gwenesis_vdp_clear_hblank();+void gwenesis_vdp_set_vblank();+void gwenesis_vdp_clear_vblank();++unsigned int gwenesis_vdp_get_reg(int reg);+void gwenesis_vdp_set_reg(int reg, unsigned char value);++unsigned int gwenesis_vdp_read_memory_8(unsigned int address);+unsigned int gwenesis_vdp_read_memory_16(unsigned int address);++void gwenesis_vdp_write_memory_8(unsigned int address, unsigned int value);+void gwenesis_vdp_write_memory_16(unsigned int address, unsigned int value);++void gwenesis_vdp_set_buffers(unsigned char *screen_buffer, unsigned char *scaled_buffer);+void gwenesis_vdp_set_buffer(unsigned short *ptr_screen_buffer);+void gwenesis_vdp_render_line(int line);++void gwenesis_vdp_render_config();++unsigned int gwenesis_vdp_get_status();+void gwenesis_vdp_get_debug_status(char *s);+unsigned short gwenesis_vdp_get_cram(int index);+void gwenesis_vdp_get_vram(unsigned char *raw_buffer, int palette);+void gwenesis_vdp_get_vram_raw(unsigned char *raw_buffer);+void gwenesis_vdp_get_cram_raw(unsigned char *raw_buffer);++int gwenesis_vdp_vcounter();+int gwenesis_vdp_hcounter();+unsigned short gwenesis_vdp_hvcounter();++void gwenesis_vdp_gfx_save_state();+void gwenesis_vdp_gfx_load_state();+void gwenesis_vdp_mem_save_state();+void gwenesis_vdp_mem_load_state();++#endif\ No newline at end of filediff --git a/games/retrogo/src/md/gwenesis_vdp_gfx.c b/games/retrogo/src/md/gwenesis_vdp_gfx.cnew file mode 100644index 00000000..4b25f0de--- /dev/null+++ b/games/retrogo/src/md/gwenesis_vdp_gfx.c@@ -0,0 +1,1139 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#include <stdio.h>+#include <string.h>+#include <stdbool.h>+#include "m68k.h"+#include "gwenesis_vdp.h"+#include "gwenesis_io.h"+#include "gwenesis_bus.h"+#include "gwenesis_savestate.h"++/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound+ chips' writes go nowhere; and nothing printed) */+#define YM2612Read(clk) 0+#define YM2612Write(a, v, clk) ((void)0)+#define YM2612Init() ((void)0)+#define YM2612Config(x) ((void)0)+#define YM2612ResetChip() ((void)0)+#define gwenesis_SN76489_Write(v, clk) ((void)0)+#define gwenesis_SN76489_Init(a, b, c) ((void)0)+#define gwenesis_SN76489_Reset() ((void)0)+#define printf(...) ((void)0)+#define vfprintf(...) ((void)0)++//#include <assert.h>++#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0+ #pragma GCC optimize("Ofast")+#endif++#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0++typedef unsigned char uint8_t;+typedef unsigned short uint16_t;+#include "stm32h7b0xx.h"+extern unsigned char* VRAM;++#else++#include <stdint.h>+extern unsigned char *VRAM;++#endif++extern unsigned short CRAM[]; // CRAM - Palettes+extern unsigned char SAT_CACHE[]__attribute__((aligned(4))); // Sprite cache+extern unsigned char gwenesis_vdp_regs[]; // Registers++extern unsigned short CRAM565[]; // CRAM - Palettes++extern unsigned short VSRAM[]; // VSRAM - Scrolling++// Define screen buffers: original and scaled for host RGB+unsigned char *screen, *scaled_screen;++// Define screen buffers for embedded 565 format+static uint8_t *screen_buffer_line=0;+static uint8_t *screen_buffer=0;++ // Overflow is the maximum size we can draw outside to avoid+ // wasting time and code in clipping. The maximum object is a 4x4 sprite,+ // so 32 pixels (on both side) is enough.++enum { PIX_OVERFLOW = 32 };++static uint8_t render_buffer[SCREEN_WIDTH + PIX_OVERFLOW*2];+static uint8_t sprite_buffer[SCREEN_WIDTH + PIX_OVERFLOW*2];++// Define VIDEO MODE+static int mode_h40;+int mode_pal;++// Define screen W/H+int screen_width;+int screen_height;++int gwenesis_H32upscaler;++int sprite_overflow;+bool sprite_collision;++// Window Plane and A plane spearation+static int base_w;+static int PlanA_firstcol;+static int PlanA_lastcol;++static int Window_firstcol;+static int Window_lastcol;++// 16 bits access to VRAM+// #define FETCH16VRAM(A) ({size_t addr = (A); (VRAM[addr+1]) | (VRAM[addr] << 8);})+#define FETCH16VRAM(A) ( (VRAM[(A)+1]) | (VRAM[(A)] << 8) )+#define VDP_GFX_DISABLE_LOGGING 1++#if !VDP_GFX_DISABLE_LOGGING+#include <stdarg.h>+void vdpg_log(const char *subs, const char *fmt, ...) {+ extern int frame_counter;+ extern int scan_line;++ va_list va;++ printf("%06d:%03d :[%s] vc:%03x hc:%03x", frame_counter, scan_line, subs,gwenesis_vdp_vcounter(),gwenesis_vdp_hcounter());++ va_start(va, fmt);+ vfprintf(stdout, fmt, va);+ va_end(va);+ printf("\n");+}+#else+ #define vdpg_log(...) do {} while(0)+#endif+/******************************************************************************+ *+ * set screen buffers in which the rendering occurs+ * Set original and scaled screen buffer for host+ *+ ******************************************************************************/+//host+void gwenesis_vdp_set_buffers(unsigned char *screen_buffer, unsigned char *scaled_buffer)+{+ screen = screen_buffer;+ scaled_screen = scaled_buffer;+}+//embedded+void gwenesis_vdp_set_buffer(unsigned short *ptr_screen_buffer)+{+ screen_buffer_line = ptr_screen_buffer;+ screen_buffer = ptr_screen_buffer;+}++/******************************************************************************+ *+ * Draw Sprite character /8pixels in row+ * without checking overdraw for pixels collision detection+ * with Horizontal flip variation+ * for Shadow/highlight :+ * draw in fresh line buffer using draw_pattern_xxfliph_sprite(..)+ * otherwise:+ * draw over dirty planes using draw_pattern_xxfliph_sprite_over_planes(..)+ *+ ******************************************************************************/++ #define PIX0(P) ( ((P) & 0x000000F0 ) >> 4 )+ #define PIX1(P) ( ((P) & 0x0000000F ) >> 0 )+ #define PIX2(P) ( ((P) & 0x0000F000 ) >> 12 )+ #define PIX3(P) ( ((P) & 0x00000F00 ) >> 8 )+ #define PIX4(P) ( ((P) & 0x00F00000 ) >> 20 )+ #define PIX5(P) ( ((P) & 0x000F0000 ) >> 16 )+ #define PIX6(P) ( ((P) & 0xF0000000 ) >> 28 )+ #define PIX7(P) ( ((P) & 0x0F000000 ) >> 24 )++static inline __attribute__((always_inline))+void draw_pattern_nofliph_sprite(uint8_t *scr, uint32_t p, uint8_t attrs)+{+ if (p == 0) return;++ /* not transparent pixel to write AND not already a sprite*/+ if (((PIX0(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX0(p));+ if (((PIX1(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX1(p));+ if (((PIX2(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX2(p));+ if (((PIX3(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX3(p));+ if (((PIX4(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX4(p));+ if (((PIX5(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX5(p));+ if (((PIX6(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX6(p));+ if (((PIX7(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX7(p));+}++static inline __attribute__((always_inline))+void draw_pattern_fliph_sprite(uint8_t *scr, uint32_t p, uint8_t attrs)+{+ if (p == 0) return;++ /* not transparent pixel to write AND not already a sprite*/+ if (((PIX7(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX7(p));+ if (((PIX6(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX6(p));+ if (((PIX5(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX5(p));+ if (((PIX4(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX4(p));+ if (((PIX3(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX3(p));+ if (((PIX2(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX2(p));+ if (((PIX1(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX1(p));+ if (((PIX0(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX0(p));++}++static inline __attribute__((always_inline))+void draw_pattern_nofliph_sprite_over_planes(uint8_t *scr, uint32_t p, uint8_t attrs)+{+ if (p == 0) return;++ /* High priority */+ if (attrs & PIXATTR_HIPRI) {++ /* not transparent pixel to write AND not already a sprite*/+ if (((PIX0(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX0(p));+ if (((PIX1(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX1(p));+ if (((PIX2(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX2(p));+ if (((PIX3(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX3(p));+ if (((PIX4(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX4(p));+ if (((PIX5(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX5(p));+ if (((PIX6(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX6(p));+ if (((PIX7(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX7(p));++ }+ /* Low priority */+ else {++ /* not transparent pixel to write AND not already a sprite or higher priority*/+ if (((PIX0(p))) && ((scr[0] & PIXATTR_SPRITE_HIPRI) == 0)) scr[0] = attrs | (PIX0(p));+ if (((PIX1(p))) && ((scr[1] & PIXATTR_SPRITE_HIPRI) == 0)) scr[1] = attrs | (PIX1(p));+ if (((PIX2(p))) && ((scr[2] & PIXATTR_SPRITE_HIPRI) == 0)) scr[2] = attrs | (PIX2(p));+ if (((PIX3(p))) && ((scr[3] & PIXATTR_SPRITE_HIPRI) == 0)) scr[3] = attrs | (PIX3(p));+ if (((PIX4(p))) && ((scr[4] & PIXATTR_SPRITE_HIPRI) == 0)) scr[4] = attrs | (PIX4(p));+ if (((PIX5(p))) && ((scr[5] & PIXATTR_SPRITE_HIPRI) == 0)) scr[5] = attrs | (PIX5(p));+ if (((PIX6(p))) && ((scr[6] & PIXATTR_SPRITE_HIPRI) == 0)) scr[6] = attrs | (PIX6(p));+ if (((PIX7(p))) && ((scr[7] & PIXATTR_SPRITE_HIPRI) == 0)) scr[7] = attrs | (PIX7(p));++ }+}++static inline __attribute__((always_inline))+void draw_pattern_fliph_sprite_over_planes(uint8_t *scr, uint32_t p, uint8_t attrs)+{+ if (p == 0) return;++ /* High priority */+ if (attrs & PIXATTR_HIPRI) {++ /* not transparent pixel to write AND not already a sprite*/+ if (((PIX7(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX7(p));+ if (((PIX6(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX6(p));+ if (((PIX5(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX5(p));+ if (((PIX4(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX4(p));+ if (((PIX3(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX3(p));+ if (((PIX2(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX2(p));+ if (((PIX1(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX1(p));+ if (((PIX0(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX0(p));++ }+ /* Low priority */+ else {++ /* not transparent pixel to write AND not already a sprite or higher priority*/+ if (((PIX7(p))) && ((scr[0] & PIXATTR_SPRITE_HIPRI) == 0)) scr[0] = attrs | (PIX7(p));+ if (((PIX6(p))) && ((scr[1] & PIXATTR_SPRITE_HIPRI) == 0)) scr[1] = attrs | (PIX6(p));+ if (((PIX5(p))) && ((scr[2] & PIXATTR_SPRITE_HIPRI) == 0)) scr[2] = attrs | (PIX5(p));+ if (((PIX4(p))) && ((scr[3] & PIXATTR_SPRITE_HIPRI) == 0)) scr[3] = attrs | (PIX4(p));+ if (((PIX3(p))) && ((scr[4] & PIXATTR_SPRITE_HIPRI) == 0)) scr[4] = attrs | (PIX3(p));+ if (((PIX2(p))) && ((scr[5] & PIXATTR_SPRITE_HIPRI) == 0)) scr[5] = attrs | (PIX2(p));+ if (((PIX1(p))) && ((scr[6] & PIXATTR_SPRITE_HIPRI) == 0)) scr[6] = attrs | (PIX1(p));+ if (((PIX0(p))) && ((scr[7] & PIXATTR_SPRITE_HIPRI) == 0)) scr[7] = attrs | (PIX0(p));++ }++}++/******************************************************************************+ *+ * Draw characters/8pixels in row+ * without checking overdraw for pixels collision detection+ * with Horizontal flip variation for plane A & B+ *+ ******************************************************************************/+++static inline __attribute__((always_inline)) void+draw_pattern_nofliph_planeB(uint8_t *scr, uint32_t p, uint8_t attrs) {++ const uint8_t back = gwenesis_vdp_regs[7];++ if (p == 0) {++ scr[0] = back;+ scr[1] = back;+ scr[2] = back;+ scr[3] = back;+ scr[4] = back;+ scr[5] = back;+ scr[6] = back;+ scr[7] = back;++ return;+ }++ scr[0] = PIX0(p) ? attrs | (PIX0(p)) : back;+ scr[1] = PIX1(p) ? attrs | (PIX1(p)) : back;+ scr[2] = PIX2(p) ? attrs | (PIX2(p)) : back;+ scr[3] = PIX3(p) ? attrs | (PIX3(p)) : back;+ scr[4] = PIX4(p) ? attrs | (PIX4(p)) : back;+ scr[5] = PIX5(p) ? attrs | (PIX5(p)) : back;+ scr[6] = PIX6(p) ? attrs | (PIX6(p)) : back;+ scr[7] = PIX7(p) ? attrs | (PIX7(p)) : back;+}++static inline __attribute__((always_inline)) void+draw_pattern_fliph_planeB(uint8_t *scr, uint32_t p, uint8_t attrs) {++ const uint8_t back = gwenesis_vdp_regs[7];+ if (p == 0) {++ scr[0] = back;+ scr[1] = back;+ scr[2] = back;+ scr[3] = back;+ scr[4] = back;+ scr[5] = back;+ scr[6] = back;+ scr[7] = back;++ return;+ }++ scr[0] = PIX7(p) ? attrs | (PIX7(p)) : back;+ scr[1] = PIX6(p) ? attrs | (PIX6(p)) : back;+ scr[2] = PIX5(p) ? attrs | (PIX5(p)) : back;+ scr[3] = PIX4(p) ? attrs | (PIX4(p)) : back;+ scr[4] = PIX3(p) ? attrs | (PIX3(p)) : back;+ scr[5] = PIX2(p) ? attrs | (PIX2(p)) : back;+ scr[6] = PIX1(p) ? attrs | (PIX1(p)) : back;+ scr[7] = PIX0(p) ? attrs | (PIX0(p)) : back;+++}++static inline __attribute__((always_inline)) void+draw_pattern_nofliph_planeAoverB(uint8_t *scr, uint32_t p, uint8_t attrs) {++ if (p == 0) return;++ if (attrs & PIXATTR_HIPRI) {++ if (PIX0(p)) scr[0] = attrs | (PIX0(p));+ if (PIX1(p)) scr[1] = attrs | (PIX1(p));+ if (PIX2(p)) scr[2] = attrs | (PIX2(p));+ if (PIX3(p)) scr[3] = attrs | (PIX3(p));+ if (PIX4(p)) scr[4] = attrs | (PIX4(p));+ if (PIX5(p)) scr[5] = attrs | (PIX5(p));+ if (PIX6(p)) scr[6] = attrs | (PIX6(p));+ if (PIX7(p)) scr[7] = attrs | (PIX7(p));++ } else {++ if (PIX0(p) && ((scr[0] & PIXATTR_HIPRI) == 0)) scr[0] = attrs | (PIX0(p));+ if (PIX1(p) && ((scr[1] & PIXATTR_HIPRI) == 0)) scr[1] = attrs | (PIX1(p));+ if (PIX2(p) && ((scr[2] & PIXATTR_HIPRI) == 0)) scr[2] = attrs | (PIX2(p));+ if (PIX3(p) && ((scr[3] & PIXATTR_HIPRI) == 0)) scr[3] = attrs | (PIX3(p));+ if (PIX4(p) && ((scr[4] & PIXATTR_HIPRI) == 0)) scr[4] = attrs | (PIX4(p));+ if (PIX5(p) && ((scr[5] & PIXATTR_HIPRI) == 0)) scr[5] = attrs | (PIX5(p));+ if (PIX6(p) && ((scr[6] & PIXATTR_HIPRI) == 0)) scr[6] = attrs | (PIX6(p));+ if (PIX7(p) && ((scr[7] & PIXATTR_HIPRI) == 0)) scr[7] = attrs | (PIX7(p));++ }+}++static inline __attribute__((always_inline)) void+draw_pattern_fliph_planeAoverB(uint8_t *scr, uint32_t p, uint8_t attrs) {++ if (p == 0) return;++ if (attrs & PIXATTR_HIPRI) {++ if (PIX7(p)) scr[0] = attrs | (PIX7(p));+ if (PIX6(p)) scr[1] = attrs | (PIX6(p));+ if (PIX5(p)) scr[2] = attrs | (PIX5(p));+ if (PIX4(p)) scr[3] = attrs | (PIX4(p));+ if (PIX3(p)) scr[4] = attrs | (PIX3(p));+ if (PIX2(p)) scr[5] = attrs | (PIX2(p));+ if (PIX1(p)) scr[6] = attrs | (PIX1(p));+ if (PIX0(p)) scr[7] = attrs | (PIX0(p));++ } else {++ if (PIX7(p) && ((scr[0] & PIXATTR_HIPRI) == 0)) scr[0] = attrs | (PIX7(p));+ if (PIX6(p) && ((scr[1] & PIXATTR_HIPRI) == 0)) scr[1] = attrs | (PIX6(p));+ if (PIX5(p) && ((scr[2] & PIXATTR_HIPRI) == 0)) scr[2] = attrs | (PIX5(p));+ if (PIX4(p) && ((scr[3] & PIXATTR_HIPRI) == 0)) scr[3] = attrs | (PIX4(p));+ if (PIX3(p) && ((scr[4] & PIXATTR_HIPRI) == 0)) scr[4] = attrs | (PIX3(p));+ if (PIX2(p) && ((scr[5] & PIXATTR_HIPRI) == 0)) scr[5] = attrs | (PIX2(p));+ if (PIX1(p) && ((scr[6] & PIXATTR_HIPRI) == 0)) scr[6] = attrs | (PIX1(p));+ if (PIX0(p) && ((scr[7] & PIXATTR_HIPRI) == 0)) scr[7] = attrs | (PIX0(p));++ }++}++/******************************************************************************+ *+ * Draw characters/8pixels in row+ * with/without checking overdraw for pixels collision detection+ * used for sprites and planes drawing+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+void draw_pattern_sprite(uint8_t *scr, uint16_t name, int paty) {++ // uint16_t pat_addr = name << 5; //name * 32;+ // uint8_t pat_palette = BITS(name, 13, 2);+ // //unsigned int is_pat_pri = name & 0x8000;+ // uint8_t *pattern = VRAM + pat_addr;+ // uint8_t attrs = (pat_palette << 4) | ((name & 0x8000) ? PIXATTR_SPRITE_HIPRI : PIXATTR_SPRITE);+ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8) + PIXATTR_SPRITE;++ unsigned int pattern;++ // Vertical flip ?+ // if (name & 0x1000)+ // pattern += (7 - paty) * 4;+ // else+ // pattern += paty * 4;++ // unsigned int pattern;++ // Vertical flip ?+ if (name & 0x1000)+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;+ else+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));++ // Horizontal flip ?+ if (name & 0x0800)+ draw_pattern_fliph_sprite(scr, pattern, attrs);+ else+ draw_pattern_nofliph_sprite(scr, pattern, attrs);+}++static inline __attribute__((always_inline))+void draw_pattern_sprite_over_planes(uint8_t *scr, uint16_t name, int paty) {++ // uint16_t pat_addr = name << 5 ; //* 32;+ // int pat_palette = BITS(name, 13, 2);+ // int is_pat_pri = name & 0x8000;+ // uint8_t *pattern = VRAM + pat_addr;+ // uint8_t attrs = (pat_palette << 4) | (is_pat_pri ? PIXATTR_SPRITE_HIPRI : PIXATTR_SPRITE);++ // Vertical flip ?+ // if (name & 0x1000)+ // pattern += (7 - paty) * 4;+ // else+ // pattern += paty * 4;++ //uint8_t attrs = ( (name & 0x6000 ) >> 9 ) | ((name & 0x8000) ? PIXATTR_SPRITE_HIPRI : PIXATTR_SPRITE);+ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8) + PIXATTR_SPRITE;+ //uint8_t attrs = ( (name >>9) & 0x70 ) | PIXATTR_SPRITE;++ unsigned int pattern;++ // Vertical flip ?+ if (name & 0x1000)+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;+ else+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));++ // Horizontal flip ?+ if (name & 0x0800)+ draw_pattern_fliph_sprite_over_planes (scr, pattern, attrs);+ else+ draw_pattern_nofliph_sprite_over_planes (scr, pattern, attrs);+}++static inline __attribute__((always_inline))+void draw_pattern_planeB(uint8_t *scr, uint16_t name, int paty) {+ // uint16_t pat_addr = name << 5; // * 32;+ // uint8_t pat_palette = BITS(name, 13, 2);+ // unsigned int is_pat_pri = name & 0x8000;+ //uint8_t *pattern = VRAM + pat_addr;++ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8);++ unsigned int pattern;++ // Vertical flip ?+ if (name & 0x1000)+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;+ else+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));++// if ((*(unsigned int *)pattern) == 0 ) return;+ // uint8_t *pattern = VRAM + ((name << 5) & 0xFFFF); //) pat_addr;+ //uint32_t pattern = VRAM[(name & 0x07FF) << 5]; //) pat_addr;++ // Horizontal flip ?+ if (name & 0x0800)+ draw_pattern_fliph_planeB(scr, pattern, attrs);++ else+ draw_pattern_nofliph_planeB(scr, pattern, attrs);++}++static inline __attribute__((always_inline))+void draw_pattern_planeA(uint8_t *scr, uint16_t name, int paty) {+ // uint16_t pat_addr = name << 5; //* 32;+ // uint8_t pat_palette = BITS(name, 13, 2);+ // unsigned int is_pat_pri = name & 0x8000;+ // uint8_t *pattern = VRAM + pat_addr;++ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8);+++++ unsigned int pattern;++ // Vertical flip ?+ // if (name & 0x1000)+ // pattern += (7 - paty) * 4;+ // else+ // pattern += paty * 4;++ // Vertical flip ?+ if (name & 0x1000)+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;+ else+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));++ // Horizontal flip ?+ if (name & 0x0800)+ draw_pattern_fliph_planeAoverB(scr, pattern, attrs);++ else+ draw_pattern_nofliph_planeAoverB(scr, pattern, attrs);++}++static uint16_t ntwidth_x2;+static uint16_t ntw_mask, nth_mask;++/******************************************************************************+ *+ * Return the Horizontal scrolling+ *+ ******************************************************************************/++static inline __attribute__((always_inline))+unsigned int get_hscroll_vram(int line)+{++ int mode = REG11_HSCROLL_MODE;+ unsigned int table = REG13_HSCROLL_ADDRESS ;+ int idx;++ switch (mode)+ {+ case 0: // Full screen scrolling+ idx = 0;+ break;+ case 1: // First 8 lines+ idx = (line & 7);+ break;+ case 2: // Every row+ idx = (line & ~7);+ break;+ case 3: // Every line+ idx = line;+ break;+ }++ return table + idx*4;+}+/******************************************************************************+ *+ * Render PLANE B on screen line+ *+ ******************************************************************************/+ //__attribute__((optimize("unroll-loops")))+static inline __attribute__((always_inline))+void draw_line_b(int line)+{+ uint8_t *scr = &render_buffer[PIX_OVERFLOW];++ unsigned int ntaddr = REG4_NAMETABLE_B;+ uint16_t scrollx=FETCH16VRAM(get_hscroll_vram(line) + 2) & 0x3FF;+ uint16_t *vsram = &VSRAM[1];+ uint8_t *end = scr + screen_width;++ //bool column_scrolling = BIT(gwenesis_vdp_regs[11], 2);+ const unsigned int column_scrolling = gwenesis_vdp_regs[11] & 0x4;++ // Invert horizontal scrolling (because it goes right, but we need to offset+ // of the first screen pixel)+ scrollx = -scrollx;+ uint8_t col = (scrollx >> 3) & ntw_mask;+ uint8_t patx = scrollx & 7;++ unsigned int numcell = 0;+ scr -= patx;+ while (scr < end) {+ // Calculate vertical scrolling for the current line+ uint16_t scrolly = *vsram + line;+ uint8_t row = (scrolly >> 3) & nth_mask;+ uint8_t paty = scrolly & 7;++ // unsigned int nt = ntaddr + row * (2 * ntwidth);+ unsigned int nt = ntaddr + row * ntwidth_x2;++ draw_pattern_planeB(scr, FETCH16VRAM(nt + col * 2), paty);+ col = (col + 1) & ntw_mask;+ scr += 8;+ numcell++;++ // If per-column scrolling is active, increment VSRAM pointer+ if (column_scrolling && (numcell & 1) == 0)+ vsram += 2;+ }+}+/******************************************************************************+ *+ * Render PLANE A and Window on screen line+ *+ ******************************************************************************/+//_attribute__((optimize("unroll-loops")))+static inline __attribute__((always_inline))+void draw_line_aw(int line) {++ uint8_t *scr = &render_buffer[PIX_OVERFLOW];++ unsigned int ntaddr = REG2_NAMETABLE_A;+ uint16_t scrollx=FETCH16VRAM(get_hscroll_vram(line) + 0) & 0x3FF;+ uint16_t *vsram = &VSRAM[0];++ // Check if we are in the window region only+ // if it's the case, we cancel the plane A drawing+ int Window_line = REG18_WINDOW_VPOS * 8;+ //bool window_down = BIT(gwenesis_vdp_regs[18], 7);+ int window_down = gwenesis_vdp_regs[18] & 0x80;++ int PlanA_first = PlanA_firstcol;+ int PlanA_last = PlanA_lastcol;+ int Window_last = Window_lastcol;+ int Window_first = Window_firstcol;++ if (window_down) {+ if (line > Window_line) {+ PlanA_first = PlanA_last = 0;+ Window_last = screen_width;+ Window_first = 0;+ }+ } else {++ if (line < Window_line) {+ PlanA_first = PlanA_last = 0;+ Window_last = screen_width;+ Window_first = 0;+ }+ }++ // First draw A plane+ uint8_t *pos = scr + PlanA_first; // scr + screen_width;+ uint8_t *end = scr + PlanA_last; // scr + screen_width++ //bool column_scrolling = BIT(gwenesis_vdp_regs[11], 2);+ const unsigned int column_scrolling = gwenesis_vdp_regs[11] & 0x4;++ // Invert horizontal scrolling (because it goes right, but we need to offset+ // of the first screen pixel)+ scrollx = -scrollx;+ uint8_t col = (scrollx >> 3) & ntw_mask;+ uint8_t patx = scrollx & 7;++ unsigned int numcell = 0;+ pos -= patx;+ while (pos < end) {+ // Calculate vertical scrolling for the current line+ uint16_t scrolly = *vsram + line;+ uint8_t row = (scrolly >> 3) & nth_mask;+ uint8_t paty = scrolly & 7;++ // unsigned int nt = ntaddr + row * (2 * ntwidth);+ unsigned int nt = ntaddr + row * ntwidth_x2;++ draw_pattern_planeA(pos, FETCH16VRAM(nt + col * 2), paty);++ col = (col + 1) & ntw_mask;+ pos += 8;+ numcell++;++ // If per-column scrolling is active, increment VSRAM pointer+ if (column_scrolling && (numcell & 1) == 0)+ vsram += 2;+ }++ // Second Draw Window Plane+ int row = line >> 3;+ int paty = line & 7;+ //int wdwidth = (screen_width == 320 ? 64 : 32);+ //unsigned int nt = base_w + row * 2 * wdwidth + Window_first / 4;++ int wdwidth_x2 = (screen_width == 320 ? 128 : 64);++ unsigned int nt = base_w + row * wdwidth_x2 + Window_first / 4;++ /* (NumPlay: the window drawn from its own first column, not from plane A's end: a window on+ the left was drawn past the line) */+ uint8_t *w = scr + Window_first;+ for (int i = Window_first / 8; i < Window_last / 8; ++i) {+ draw_pattern_planeA(w, FETCH16VRAM(nt), paty);+ nt += 2;+ w += 8;+ }+}++/******************************************************************************+ *+ * Render SPRITES on screen line+ *+ ******************************************************************************/++//__attribute__((optimize("unroll-loops")))+static inline __attribute__((always_inline))+void draw_sprites_over_planes(int line)+{+ uint8_t *scr;++ scr = &render_buffer[PIX_OVERFLOW];++ // uint8_t mask = mode_h40 ? 0x7E : 0x7F;+ // uint8_t *start_table = VRAM + ((gwenesis_vdp_regs[5] & mask) << 9);++ uint8_t *start_table = VRAM + REG5_SAT_ADDRESS;++ // This is both the size of the table as seen by the VDP+ // *and* the maximum number of sprites that are processed+ // (important in case of infinite loops in links).+ const int SPRITE_TABLE_SIZE = (screen_width == 320) ? 80 : 64;+ const int MAX_SPRITES_PER_LINE = (screen_width == 320) ? 20 : 16;+ const int MAX_PIXELS_PER_LINE = (screen_width == 320) ? 320 : 256;++ bool masking = false, one_sprite_nonzero = false; // overdraw = false;+ int sidx = 0, num_sprites = 0, num_pixels = 0;+ for (int i = 0; (i < SPRITE_TABLE_SIZE) && sidx < (SPRITE_TABLE_SIZE); ++i)+ {+ uint8_t *table = start_table + sidx*8;+ uint8_t *cache = SAT_CACHE + sidx*8;+ //uint8_t *cache = start_table + sidx*8;+++ int sy = ((cache[0] & 0x3) << 8) | cache[1];+ int sx = ((table[6] & 0x3) << 8) | table[7];+ uint16_t name = (table[4] << 8) | table[5];+++ int sh = BITS(cache[2], 0, 2) + 1;+ int link = BITS(cache[3], 0, 7);++ int isflipv = table[4] & 0x10;+ int isfliph = table[4] & 0x8;++ int sw = BITS(table[2], 2, 2) + 1;++ sy -= 128;+ if ((line >= sy) && (line < sy+sh*8))+ {+ // Sprite masking: a sprite on column 0 masks+ // any lower-priority sprite, but with the following conditions+ // * it only works from the second visible sprite on each line+ // * if the previous line had a sprite pixel overflow, it+ // works even on the first sprite+ // Notice that we need to continue parsing the table after masking+ // to see if we reach a pixel overflow (because it would affect masking+ // on next line).+ if (sx == 0)+ {+ if (one_sprite_nonzero || (sprite_overflow == line-1))+ masking = true;+ }+ else+ one_sprite_nonzero = true;++ int row = (line - sy) >> 3;+ int paty = (line - sy) & 7;+ if (isflipv)+ row = sh - row - 1;++ sx -= 128;+ if ((sx > (-sw * 8)) && (sx < screen_width) && !masking) {++ name += row;++ if (isfliph) {+ name += sh * (sw - 1);+ for (int p = 0; (p < sw) && (num_pixels < MAX_PIXELS_PER_LINE); p++) {++ draw_pattern_sprite_over_planes(scr + sx + p * 8, name, paty);+ name -= sh;+ num_pixels += 8;++ }+ } else {+ for (int p = 0; (p < sw) && (num_pixels < MAX_PIXELS_PER_LINE); p++) {++ draw_pattern_sprite_over_planes(scr + sx + p * 8, name, paty);+ name += sh;+ num_pixels += 8;++ }+ }+ }+ else+ num_pixels += sw*8;++ if (num_pixels >= MAX_PIXELS_PER_LINE)+ {+ sprite_overflow = line;+ break;+ }+ if (++num_sprites >= MAX_SPRITES_PER_LINE)+ break;+ }++ if (link == 0) break;+ sidx = link;+ }++ // if (overdraw)+ // sprite_collision = true;+}+static inline __attribute__((always_inline))+void draw_sprites(int line)+{+ uint8_t *scr;++ scr = &sprite_buffer[PIX_OVERFLOW];++ // uint8_t mask = mode_h40 ? 0x7E : 0x7F;+ // uint8_t *start_table = VRAM + ((gwenesis_vdp_regs[5] & mask) << 9);++ uint8_t *start_table = VRAM + REG5_SAT_ADDRESS;++ // This is both the size of the table as seen by the VDP+ // *and* the maximum number of sprites that are processed+ // (important in case of infinite loops in links).+ const int SPRITE_TABLE_SIZE = (screen_width == 320) ? 80 : 64;+ const int MAX_SPRITES_PER_LINE = (screen_width == 320) ? 20 : 16;+ const int MAX_PIXELS_PER_LINE = (screen_width == 320) ? 320 : 256;++ bool masking = false, one_sprite_nonzero = false; // overdraw = false;+ int sidx = 0, num_sprites = 0, num_pixels = 0;+ for (int i = 0; i < SPRITE_TABLE_SIZE && sidx < SPRITE_TABLE_SIZE; ++i) {+ uint8_t *table = start_table + sidx * 8;+ uint8_t *cache = start_table + sidx * 8;++ //uint8_t *cache = SAT_CACHE + sidx * 8;++ int sy = ((cache[0] & 0x3) << 8) | cache[1];+ int sx = ((table[6] & 0x3) << 8) | table[7];+ uint16_t name = (table[4] << 8) | table[5];++ int sh = BITS(cache[2], 0, 2) + 1;+ int link = BITS(cache[3], 0, 7);++ int isflipv = table[4] & 0x10;+ int isfliph = table[4] & 0x8;++ int sw = BITS(table[2], 2, 2) + 1;++ sy -= 128;+ if (line >= sy && line < sy + sh * 8) {+ // Sprite masking: a sprite on column 0 masks+ // any lower-priority sprite, but with the following conditions+ // * it only works from the second visible sprite on each line+ // * if the previous line had a sprite pixel overflow, it+ // works even on the first sprite+ // Notice that we need to continue parsing the table after masking+ // to see if we reach a pixel overflow (because it would affect masking+ // on next line).+ if (sx == 0) {+ if (one_sprite_nonzero || sprite_overflow == line - 1)+ masking = true;+ } else+ one_sprite_nonzero = true;++ int row = (line - sy) >> 3;+ int paty = (line - sy) & 7;+ if (isflipv)+ row = sh - row - 1;++ sx -= 128;+ if (sx > -sw * 8 && sx < screen_width && !masking) {++ name += row;++ if (isfliph) {+ name += sh * (sw - 1);+ for (int p = 0; p < sw && num_pixels < MAX_PIXELS_PER_LINE; p++) {++ draw_pattern_sprite(scr + sx + p * 8, name, paty);+ name -= sh;+ num_pixels += 8;+ }+ } else {+ for (int p = 0; p < sw && num_pixels < MAX_PIXELS_PER_LINE; p++) {++ draw_pattern_sprite(scr + sx + p * 8, name, paty);+ name += sh;+ num_pixels += 8;+ }+ }+ } else+ num_pixels += sw * 8;++ if (num_pixels >= MAX_PIXELS_PER_LINE) {+ sprite_overflow = line;+ break;+ }+ if (++num_sprites >= MAX_SPRITES_PER_LINE)+ break;+ }++ if (link == 0)+ break;+ sidx = link;+ }++ // if (overdraw)+ // sprite_collision = true;+}+/******************************************************************************+ *+ * Parse PLANE A/B size,scrolling at the start of image rendering+ *+ ******************************************************************************/+//static unsigned short current_line[320];++void gwenesis_vdp_render_config()+{+ mode_h40 = REG12_MODE_H40;+ mode_pal = REG1_PAL;++ int ntwidth = BITS(gwenesis_vdp_regs[16], 0, 2);+ int ntheight = BITS(gwenesis_vdp_regs[16], 4, 2);+ ntwidth = (ntwidth + 1) * 32;+ ntheight = (ntheight + 1) * 32;+ ntw_mask = ntwidth - 1;+ nth_mask = ntheight - 1;+ ntwidth_x2= ntwidth *2;++ // Window & A planes separation++ if (mode_h40)+ base_w = ((REG3_NAMETABLE_W & 0x1e) << 11);+ else+ base_w = ((REG3_NAMETABLE_W & 0x1f) << 11);+++ bool window_right = BIT(gwenesis_vdp_regs[17], 7);++ // int window_is_bugged = 0;+ PlanA_firstcol = 0;+ PlanA_lastcol = screen_width;++ Window_firstcol = 0;+ Window_lastcol = 0;++ if (window_right) {++ Window_firstcol = REG17_WINDOW_HPOS * 16;+ Window_lastcol = screen_width;++ if (Window_firstcol > Window_lastcol)+ Window_firstcol = Window_lastcol;++ PlanA_firstcol = 0;+ PlanA_lastcol = Window_firstcol;++ } else {+ Window_firstcol = 0;+ Window_lastcol = REG17_WINDOW_HPOS * 16;+ if (Window_lastcol > screen_width)+ Window_lastcol = screen_width;++ PlanA_firstcol = Window_lastcol;+ PlanA_lastcol = screen_width;+ // if (Window_lastcol != 0)+ // window_is_bugged = 1;+ }+}++/******************************************************************************+ *+ * Render a line on screen+ * Get selected line and render it on screen processing each plane.+ *+ ******************************************************************************/++//#define CONV(b) ((0b11 1110 0000 0000 0000 0000 0000 & b)>>10) | ((0b00000 1111 1100 0000 0000 & b)>>5) | ((0b0000000000011111 & b))+//#define SPACE(c) ((0b00 0000 0000 1111 1000 0000 0000 & c)<<10) | ((0b00000 0000 0111 1110 0000 & c)<<5) | ((0b0000000000011111 & c))++#define CONV(b) ((0x3e00000 & b)>>10) | ((0xfc00 & b)>>5) | ((0x1f & b))+#define SPACE(c) ((0xe800 & c)<<10) | ((0x7e0 & c)<<5) | ((0x1f & c))++/* Function unused++__attribute__((optimize("unroll-loops"))) static void+blit_4to5_line(uint16_t *in, uint16_t *out) {++ uint16_t *src_row = in;+ uint16_t *dest_row = out;+ for (int x_src = 0, x_dst = 0; x_src < 256; x_src += 4, x_dst += 5) {+ uint32_t b0 = SPACE(src_row[x_src]);+ uint32_t b1 = SPACE(src_row[x_src + 1]);+ uint32_t b2 = SPACE(src_row[x_src + 2]);+ uint32_t b3 = SPACE(src_row[x_src + 3]);++ dest_row[x_dst] = CONV(b0);+ dest_row[x_dst + 1] = CONV((b0 + b0 + b0 + b1) >> 2);+ dest_row[x_dst + 2] = CONV((b1 + b2) >> 1);+ dest_row[x_dst + 3] = CONV((b2 + b2 + b2 + b3) >> 2);+ dest_row[x_dst + 4] = CONV(b3);+ }+}+*/++/* (NumPlay: the line in RGB565, with the shadow and highlight modes as gwenesis' computer+ version draws them, handed to Retro-Go's screens, rg_line) */+void rg_line(int y, const uint16_t *px);+static uint16_t md_line[SCREEN_WIDTH];++void gwenesis_vdp_render_line(int line)+{+ mode_h40 = REG12_MODE_H40;++ // interlace mode not implemented+ if (BITS(gwenesis_vdp_regs[12], 1, 2) != 0)+ return;++ if (line >= (REG1_PAL ? 240 : 224))+ return;++ uint16_t *out = md_line;+ if (REG0_DISABLE_DISPLAY) {+ memset(out, 0, sizeof md_line);+ rg_line(line, out);+ return;+ }++ uint8_t *pb = &render_buffer[PIX_OVERFLOW];+ uint8_t *ps = &sprite_buffer[PIX_OVERFLOW];++ if (MODE_SHI)+ memset(ps, 0, 320);++ draw_line_b(line);+ draw_line_aw(line);++ if (MODE_SHI)+ draw_sprites(line);+ else+ draw_sprites_over_planes(line);++ /* Mode Highlight/shadow is enabled */+ if (MODE_SHI) {+ for (int x = 0; x < screen_width; x++) {+ uint8_t plane = pb[x];+ uint8_t sprite = ps[x];+ uint16_t rgb565;++ if ((plane & 0xC0) < (sprite & 0xC0) ) {+ switch (sprite & 0x3F) {+ // Palette=3, Sprite=14 :> draw plane, force highlight+ case 0x3E:+ rgb565 = 0x8410 | ((CRAM565[plane] >> 1) & 0x7BEF);+ break;+ // Palette=3, Sprite=15 :> draw plane, force shadow+ case 0x3F:+ rgb565 = (CRAM565[plane] >> 1) & 0x7BEF;+ break;+ // draw sprite, normal+ default:+ rgb565 = CRAM565[sprite];+ break;+ }+ } else {+ rgb565 = CRAM565[plane];+ }+ out[x] = rgb565;+ }++ /* Normal mode*/+ } else {+ for (int x = 0; x < screen_width; x++)+ out[x] = CRAM565[pb[x]];+ }+ rg_line(line, out);+}++void gwenesis_vdp_gfx_save_state() {+ /*+ SaveState* state;+ state = saveGwenesisStateOpenForWrite("vdp_gfx");+ saveGwenesisStateSetBuffer(state, "render_buffer", render_buffer, sizeof(render_buffer));+ saveGwenesisStateSetBuffer(state, "sprite_buffer", sprite_buffer, sizeof(sprite_buffer));+ saveGwenesisStateSet(state, "mode_h40", mode_h40);+ saveGwenesisStateSet(state, "mode_pal", mode_pal);+ saveGwenesisStateSet(state, "screen_width", screen_width);+ saveGwenesisStateSet(state, "screen_height", screen_height);+ saveGwenesisStateSet(state, "sprite_overflow", sprite_overflow);+ saveGwenesisStateSet(state, "sprite_collision", sprite_collision);+ saveGwenesisStateSet(state, "base_w", base_w);+ saveGwenesisStateSet(state, "PlanA_firstcol", PlanA_firstcol);+ saveGwenesisStateSet(state, "PlanA_lastcol", PlanA_lastcol);+ saveGwenesisStateSet(state, "Window_firstcol", Window_firstcol);+ saveGwenesisStateSet(state, "Window_lastcol", Window_lastcol);+ */+}++void gwenesis_vdp_gfx_load_state() {+ /*+ SaveState* state = saveGwenesisStateOpenForRead("vdp_gfx");+ saveGwenesisStateGetBuffer(state, "render_buffer", render_buffer, sizeof(render_buffer));+ saveGwenesisStateGetBuffer(state, "sprite_buffer", sprite_buffer, sizeof(sprite_buffer));+ mode_h40 = saveGwenesisStateGet(state, "mode_h40");+ mode_pal = saveGwenesisStateGet(state, "mode_pal");+ screen_width = saveGwenesisStateGet(state, "screen_width");+ screen_height = saveGwenesisStateGet(state, "screen_height");+ sprite_overflow = saveGwenesisStateGet(state, "sprite_overflow");+ sprite_collision = saveGwenesisStateGet(state, "sprite_collision");+ base_w = saveGwenesisStateGet(state, "base_w");+ PlanA_firstcol = saveGwenesisStateGet(state, "PlanA_firstcol");+ PlanA_lastcol = saveGwenesisStateGet(state, "PlanA_lastcol");+ Window_firstcol = saveGwenesisStateGet(state, "Window_firstcol");+ Window_lastcol = saveGwenesisStateGet(state, "Window_lastcol");+ */+}diff --git a/games/retrogo/src/md/gwenesis_vdp_mem.c b/games/retrogo/src/md/gwenesis_vdp_mem.cnew file mode 100644index 00000000..4e0949e4--- /dev/null+++ b/games/retrogo/src/md/gwenesis_vdp_mem.c@@ -0,0 +1,1043 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/++#include <stdint.h>+#include <stdio.h>+#include <string.h>+#include <stdbool.h>+#include "m68k.h"+#include "gwenesis_vdp.h"+#include "gwenesis_io.h"+#include "gwenesis_bus.h"+#include "gwenesis_savestate.h"++/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound+ chips' writes go nowhere; and nothing printed) */+#define YM2612Read(clk) 0+#define YM2612Write(a, v, clk) ((void)0)+#define YM2612Init() ((void)0)+#define YM2612Config(x) ((void)0)+#define YM2612ResetChip() ((void)0)+#define gwenesis_SN76489_Write(v, clk) ((void)0)+#define gwenesis_SN76489_Init(a, b, c) ((void)0)+#define gwenesis_SN76489_Reset() ((void)0)+#define printf(...) ((void)0)+#define vfprintf(...) ((void)0)++#include <assert.h>++#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0+ #pragma GCC optimize("Ofast")+#endif++#define VDP_MEM_DISABLE_LOGGING 1++#if !VDP_MEM_DISABLE_LOGGING+#include <stdarg.h>+void vdpm_log(const char *subs, const char *fmt, ...) {+ extern int frame_counter;+ extern int scan_line;++ va_list va;++ printf("%06d:%03d :[%s] vc:%04x hc:%04x hv:%04x ", frame_counter, scan_line, subs,gwenesis_vdp_vcounter(),gwenesis_vdp_hcounter(),gwenesis_vdp_hvcounter());++ va_start(va, fmt);+ vfprintf(stdout, fmt, va);+ va_end(va);+ printf("\n");+}+#else+ #define vdpm_log(...) do {} while(0)+#endif++//#define _DMA_TRACE_++/* Setup VDP Memories */+++#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0+ extern uint8_t emulator_framebuffer[1024*64];+ unsigned char* VRAM = &emulator_framebuffer[0];+#else+ unsigned char *VRAM;+#endif++unsigned short CRAM[CRAM_MAX_SIZE]; // CRAM - Palettes+unsigned char SAT_CACHE[SAT_CACHE_MAX_SIZE]; // Sprite cache+unsigned char gwenesis_vdp_regs[REG_SIZE]; // Registers+unsigned short fifo[FIFO_SIZE]; // Fifo+unsigned short CRAM565[CRAM_MAX_SIZE * 4]; // CRAM - Palettes+unsigned short VSRAM[VSRAM_MAX_SIZE]; // VSRAM - Scrolling++// Define VDP control code and set initial code+static unsigned char code_reg = 0;+// Define VDP control address and set initial address+static unsigned short address_reg = 0;+// Define VDP control pending and set initial state+int command_word_pending = 0;+// Define VDP status and set initial status value+unsigned short gwenesis_vdp_status = 0x3C00;++extern int scan_line;++// Define DMA+//static unsigned int dma_length;+//static unsigned int dma_source;+// Define and set DMA FILL pending as initial state+ int dma_fill_pending = 0;++// Define HVCounter latch and set initial state+static int hvcounter_latch = 0;+static int hvcounter_latched = 0;++int hint_pending;+++// Define VIDEO MODE+extern int mode_pal;++extern int sprite_overflow;+extern bool sprite_collision;++// Store last address r/w+//static unsigned int gwenesis_vdp_laddress_r=0;+//unsigned int gwenesis_vdp_laddress_w=0;++//static int DMA_RUN=0;++// 16 bits access to VRAM+#define FETCH16(A) ( ( (*(unsigned short *)&VRAM[(A)]) >> 8 ) | ( (*(unsigned short *)&VRAM[(A)]) << 8 ) )+++/******************************************************************************+ *+ * SEGA 315-5313 Reset+ * Clear all volatile memory+ *+ ******************************************************************************/++int m68k_irq_acked(int irq) {++ /* VINT has higher priority (Fatal Rewind) */+ if (REG1_VBLANK_INTERRUPT && (gwenesis_vdp_status & STATUS_VIRQPENDING))+ {+ /* Clear VINT pending flag */+ gwenesis_vdp_status &= ~STATUS_VIRQPENDING;++ if (hint_pending && REG0_LINE_INTERRUPT)+ m68k_set_irq(4);+ else+ m68k_set_irq(0);++ }+ else+ {+ /* Clear HINT pending flag */+ hint_pending = 0;++ /* Update IRQ status */+ m68k_set_irq(0);+ }++ return M68K_INT_ACK_AUTOVECTOR;+}+++void gwenesis_vdp_reset() {+ memset(VRAM, 0, VRAM_MAX_SIZE);+ memset(SAT_CACHE, 0, sizeof(SAT_CACHE));+ memset(CRAM, 0, sizeof(CRAM));+ memset(CRAM565, 0, sizeof(CRAM565));+ memset(VSRAM, 0, sizeof(VSRAM));+ memset(gwenesis_vdp_regs, 0, sizeof(gwenesis_vdp_regs));+ command_word_pending = 0;+ address_reg = 0;+ code_reg = 0;+ hint_pending = 0;+ // _vcounter = 0;+ gwenesis_vdp_status = 0x3C00;+ // //line_counter_interrupt = 0;+ hvcounter_latched = 0;++ // register the M68K interrupt+ m68k_set_int_ack_callback(m68k_irq_acked);+}+++/******************************************************************************+ *+ * SEGA 315-5313 HCOUNTER+ * Process SEGA 315-5313 HCOUNTER based on M68K Cycles+ *+ ******************************************************************************/+//static inline __attribute__((always_inline))+int gwenesis_vdp_hcounter()+{+ int mclk = m68k_cycles_run() ;+ int pixclk;++ // Accurate 9-bit hcounter emulation, from timing posted here:+ // http://gendev.spritesmind.net/forum/viewtopic.php?p=17683#17683+ if (REG12_MODE_H40)+ {+ pixclk = mclk * 420 / VDP_CYCLES_PER_LINE;+ pixclk += 0xD;+ if (pixclk >= 0x16D)+ pixclk += 0x1C9 - 0x16D;+ }+ else+ {+ pixclk = mclk * 342 / VDP_CYCLES_PER_LINE;+ pixclk += 0xB;+ if (pixclk >= 0x128)+ pixclk += 0x1D2 - 0x128;+ }++ return pixclk & 0x1FF;+}++/******************************************************************************+ *+ * SEGA 315-5313 VCOUNTER+ * Process SEGA 315-5313 VCOUNTER based on M68K Cycles+ *+ ******************************************************************************/+//static inline __attribute__((always_inline))+int gwenesis_vdp_vcounter()+{++ int vc = scan_line;+ int VERSION_PAL = gwenesis_vdp_status & 1;++ /*+ if (VERSION_PAL && mode_pal && (vc >= 0x10B))+ vc += 0x1D2 - 0x10B;+ else if (VERSION_PAL && (mode_pal==0) && (vc >= 0x103))+ vc += 0x1CA - 0x103;+ else if ((VERSION_PAL ==0 ) && (vc >= 0xEB))+ vc += 0x1E5 - 0xEB;+ assert(vc < 0x200);+ */+ if (VERSION_PAL && mode_pal && (vc >= 267))+ vc = scan_line - 58;+ else if (VERSION_PAL && (mode_pal==0) && (vc >= 259))+ vc = scan_line - 42;+ else if ((VERSION_PAL == 0 ) && (vc >= 235))+ vc = scan_line -6;+ assert(vc < 0x200);++ // printf("VERSION_PAL:%d , mode_pal:%d,line:%d,vc:%d\n",VERSION_PAL,mode_pal,scan_line,vc);+ return vc;+}+/******************************************************************************+ *+ * SEGA 315-5313 HVCOUNTER+ * Process SEGA 315-5313 HVCOUNTER based on HCOUNTER and VCOUNTER+ *+ ******************************************************************************/+//static inline __attribute__((always_inline))+unsigned short gwenesis_vdp_hvcounter()+{+ /* H/V Counter */+ if (hvcounter_latched == 1)+ return hvcounter_latch;++ int hc = gwenesis_vdp_hcounter();+ int vc = gwenesis_vdp_vcounter();+ assert(vc < 512);+ assert(hc < 512);++ return ((vc & 0xFF) << 8) | (hc >> 1);++}++//static inline __attribute__((always_inline))+bool vblank(void)+{+ int vc = gwenesis_vdp_vcounter();+ // printf("vc=%d,REG1_DISP_ENABLED=%d,VBLAN?%d\n",vc,REG1_DISP_ENABLED,+ // mode_pal?((vc >= 0xF0) && (vc < 0x1FF)):((vc >= 0xE0) && (vc < 0x1FF)));++ if (REG1_DISP_ENABLED ==0)+ return true;++ if (mode_pal)+ return ((vc >= 0xF0) && (vc < 0x1FF));+ else+ return ((vc >= 0xE0) && (vc < 0x1FF));++}++/******************************************************************************+ *+ * SEGA 315-5313 Set Register+ * Write an value to specified register+ *+ ******************************************************************************/+static inline __attribute__((always_inline)) void gwenesis_vdp_register_w(int reg, unsigned char value)+{+ // Mode4 is not emulated yet. Anyway, access to registers > 0xA is blocked.+ if ((BIT(gwenesis_vdp_regs[0x1], 2)==0) && reg > 0xA)+ return;++ gwenesis_vdp_regs[reg] = value;+ vdpm_log(__FUNCTION__, "reg:%02d <- %02x", reg, value);+++ // Writing a register clear the first command word+ // (see sonic3d intro wrong colors, and vdpfifotesting)+ code_reg &= ~0x3;+ address_reg &= ~0x3FFF;++ switch (reg)+ {+ case 0:++ if (REG0_HVLATCH && (hvcounter_latched == 0))+ {+ hvcounter_latch = gwenesis_vdp_hvcounter();+ hvcounter_latched = 1;+ //printf("HVcounter latched:%x\n",hvcounter_latch);+ }+ else if ((REG0_HVLATCH ==0) && (hvcounter_latched == 1)){+ //printf("HVcounter released\n");+ hvcounter_latched = 0;+ }++ break;+ }+}++/******************************************************************************+ *+ * Simulate FIFO+ *+ ******************************************************************************/+ static inline __attribute__((always_inline))+void push_fifo(unsigned int value)+{+ fifo[3] = fifo[2];+ fifo[2] = fifo[1];+ fifo[1] = fifo[0];+ fifo[0] = value;+}++/******************************************************************************+ *+ * SEGA 315-5313 VRAM Write+ * Write an value to VRAM on specified address+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+void gwenesis_vdp_vram_write(unsigned int address, unsigned int value)+{+ VRAM[address] = value;++ // Update internal SAT Cache+ // used in Castlevania Bloodlines+ if (address >= REG5_SAT_ADDRESS && address < REG5_SAT_ADDRESS + REG5_SAT_SIZE)+ SAT_CACHE[address - REG5_SAT_ADDRESS] = value;+}++static inline __attribute__((always_inline))+unsigned short status_register_r(void)+{+ unsigned short status = gwenesis_vdp_status; // & 0xF800;+ // unsigned short status = gwenesis_vdp_status;// & 0xFC00;++ int hc = gwenesis_vdp_hcounter();+ // int vc = gwenesis_vdp_vcounter();++ // TODO: FIFO not emulated+ status |= STATUS_FIFO_EMPTY;++ // VBLANK bit+ if (vblank())+ status |= STATUS_VBLANK;++ // HBLANK bit (see Nemesis doc, as linked in hcounter())+ if (REG12_MODE_H40)+ {+ if (hc < 0xA || hc >= 0x166)+ status |= STATUS_HBLANK;+ }+ else+ {+ if (hc < 0x9 || hc >= 0x126)+ status |= STATUS_HBLANK;+ }++ if (sprite_overflow)+ status |= STATUS_SPRITEOVERFLOW;+ if (sprite_collision)+ status |= STATUS_SPRITECOLLISION;++ if (mode_pal)+ status |= STATUS_PAL;++ // reading the status clears the pending flag for command words+ command_word_pending = 0;++ //gwenesis_vdp_status = status;++ // printf("VDP status read:%04X H?%d V?%d line=%d\n",status, status & STATUS_HBLANK ,status & STATUS_VBLANK,scan_line);+ return status;+}+/******************************************************************************+ *+ * SEGA 315-5313 Get Register+ * Read an value from specified register+ *+ ******************************************************************************/+unsigned int gwenesis_vdp_get_reg(int reg)+{+ return gwenesis_vdp_regs[reg];+}++/******************************************************************************+ *+ * SEGA 315-5313 DMA Fill+ * DMA process to fill memory+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+void gwenesis_vdp_dma_fill(unsigned short value)+{+ //vdpm_log(__FUNCTION__,"@%x len:%x val:%x",REG21_DMA_SRCADDR_LOW,REG19_DMA_LENGTH,value);+ int dma_length = REG19_DMA_LENGTH;++ // This address is not required for fills,+ // but it's still updated by the DMA engine.+ unsigned short src_addr_low = REG21_DMA_SRCADDR_LOW;++ if (dma_length == 0)+ dma_length = 0xFFFF;++ /*+ vdpm_log(__FUNCTION__, "DMA %s fill: dst:%04x, length:%d, increment:%d, value=%02x",+ (code_reg&0xF)==1 ? "VRAM" : ( (code_reg&0xF)==3 ? "CRAM" : "VSRAM"),+ address_reg, dma_length, REG15_DMA_INCREMENT, value>>8);+ */++ switch (code_reg & 0xF) {+ case 0x1:+ do {+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value >> 8);+ address_reg += REG15_DMA_INCREMENT;+ src_addr_low++;+ } while (--dma_length);+ break;+ case 0x3: // undocumented and buggy, see vdpfifotesting+ do {+ CRAM[(address_reg & 0x7f) >> 1] = fifo[3];++ unsigned short pixel;+ // Blue >> 9 << 2+ pixel = (fifo[3] & 0xe00) >> 7;+ // Green >> 5 << 5 << 3+ pixel |= (fifo[3] & 0x0e0) << 3;+ // Red >>1 << 11 << 2+ pixel |= (fifo[3] & 0x00e) << 12;++ // pixel_shadow = pixel >> 1;+ // pixel_highlight = pixel_shadow | 0x8410;++ // Normal pixel values when SHI is not enabled+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;++ address_reg += REG15_DMA_INCREMENT;+ src_addr_low++;+ } while (--dma_length);+ break;+ case 0x5: // undocumented and buggy, see vdpfifotesting:+ do {+ VSRAM[(address_reg & 0x7f) >> 1] = fifo[3] & 0x03FF;+ address_reg += REG15_DMA_INCREMENT;+ src_addr_low++;+ } while (--dma_length);+ break;+ default:+ printf("Invalid code during DMA fill\n");+ }+++ // Clear DMA length at the end of transfer+ gwenesis_vdp_regs[19] = gwenesis_vdp_regs[20] = 0;++ // Update DMA source address after end of transfer+ gwenesis_vdp_regs[21] = src_addr_low & 0xFF;+ gwenesis_vdp_regs[22] = src_addr_low >> 8;++ // gwenesis_vdp_regs[21] = src_addr_low >> 1 & 0xFF;+ // gwenesis_vdp_regs[22] = src_addr_low >> 9 & 0xFF;+ // gwenesis_vdp_regs[23] = src_addr_low >> 17 & 0xFF;++}++/******************************************************************************+ *+ * SEGA 315-5313 DMA M68K+ * DMA process to copy from m68k to memory+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+void gwenesis_vdp_dma_m68k()+{++ int dma_length = REG19_DMA_LENGTH;++ // This address is not required for fills,+ // but it's still updated by the DMA engine.+ unsigned short src_addr_low = REG21_DMA_SRCADDR_LOW;+ unsigned int src_addr_high = REG23_DMA_SRCADDR_HIGH;+ unsigned int src_addr = (src_addr_high | src_addr_low) << 1;+ unsigned int value;++ if (dma_length == 0)+ dma_length = 0xFFFF;++ /*+ vdpm_log(__FUNCTION__,"DMA M68k->%s copy: src:%04x, dst:%04x, length:%d, increment:%d",+ (code_reg&0xF)==1 ? "VRAM" : ( (code_reg&0xF)==3 ? "CRAM" : "VSRAM"),+ (src_addr_high | src_addr_low) << 1, address_reg, dma_length, REG15_DMA_INCREMENT);+ */++ /* Source is :+ 68K_RAM if dma_source_high == 0x00FF : FETCH16RAM(dma_source_low << 1)+ 68K_ROM otherwise : FETCH16ROM((dma_source_high | dma_source_low) << 1))+ */++ /* Source is 68K RAM */+ if ( src_addr & 0x800000) {++ switch (code_reg & 0xF) {++ case 0x1: // dest is VRAM+ do {+ value = FETCH16RAM( src_addr );+ push_fifo(value);+ gwenesis_vdp_vram_write((address_reg)&0xFFFF, value >> 8);+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value & 0xFF);+ address_reg += REG15_DMA_INCREMENT;+ src_addr += 2;+ } while (--dma_length);+ break;++ case 0x3: // dest is CRAM+ do {+ value = FETCH16RAM( src_addr );+ push_fifo(value);+ CRAM[(address_reg & 0x7f) >> 1] = value;++ unsigned short pixel;+ // unsigned short pixel_shadow, pixel_highlight;+ // Blue >> 9 << 2+ pixel = (value & 0xe00) >> 7;+ // Green >> 5 << 5 << 3+ pixel |= (value & 0x0e0) << 3;+ // Red >>1 << 11 << 2+ pixel |= (value & 0x00e) << 12;++ // Normal pixel values when SHI is not enabled+ // add mirror 0x80 when high priority flag is set+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;++ address_reg += REG15_DMA_INCREMENT;+ src_addr += 2;+ } while (--dma_length);+ break;++ case 0x5: // dest is VSRAM++ do {+ value = FETCH16RAM( src_addr );+ push_fifo(value);+ VSRAM[(address_reg & 0x7f) >> 1] = value & 0x03FF;+ address_reg += REG15_DMA_INCREMENT;+ src_addr += 2;+ } while (--dma_length);+ break;+ default: // dest in unknown+ break;+ }++ /* source is 68K ROM */+ } else {++ // unsigned int dma_source_address = (dma_source_high | dma_source_low) << 1;++ switch (code_reg & 0xF) {++ case 0x1: // dest is VRAM++ do {+ value = FETCH16ROM(src_addr);+ push_fifo(value);+ gwenesis_vdp_vram_write((address_reg)&0xFFFF, value >> 8);+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value & 0xFF);+ address_reg += REG15_DMA_INCREMENT;+ src_addr += 2;+ } while (--dma_length);+ break;++ case 0x3: // dest is CRAM++ do {+ value = FETCH16ROM(src_addr);+ push_fifo(value);+ CRAM[(address_reg & 0x7f) >> 1] = value;++ unsigned short pixel;+ // unsigned short pixel_shadow, pixel_highlight;+ // Blue >> 9 << 2+ pixel = (value & 0xe00) >> 7;+ // Green >> 5 << 5 << 3+ pixel |= (value & 0x0e0) << 3;+ // Red >>1 << 11 << 2+ pixel |= (value & 0x00e) << 12;++ // pixel_shadow = pixel >> 1;+ // pixel_highlight = pixel_shadow | 0x8410;++ // Normal pixel values when SHI is not enabled+ // add mirror 0x80 when high priority flag is set+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;++ address_reg += REG15_DMA_INCREMENT;+ src_addr += 2;+ } while (--dma_length);+ break;++ case 0x5: // dest is VSRAM++ do {+ value = FETCH16ROM(src_addr);+ push_fifo(value);+ VSRAM[(address_reg & 0x7f) >> 1] = value & 0x03FF;+ address_reg += REG15_DMA_INCREMENT;+ src_addr += 2;+ } while (--dma_length);+ break;+ default: // dest in unknown+ break;+ }++ }++ // Update DMA source address after end of transfer+ gwenesis_vdp_regs[21] = src_addr & 0xFF; //src_addr_low & 0xFF;+ gwenesis_vdp_regs[22] = (src_addr >> 8 ) & 0xFF; //src_addr_low >> 8;++ // Clear DMA length at the end of transfer+ gwenesis_vdp_regs[19] = gwenesis_vdp_regs[20] = 0;++}+/******************************************************************************+ *+ * SEGA 315-5313 DMA Copy+ * DMA process to copy from memory to memory+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+void gwenesis_vdp_dma_copy()+{+ // DMA_RUN=1;++ int dma_length = REG19_DMA_LENGTH;+ unsigned short src_addr_low = REG21_DMA_SRCADDR_LOW;+ //vdpm_log(__FUNCTION__,"length:%x src:%x",dma_length,src_addr_low);++ do+ {+ unsigned short value = VRAM[src_addr_low ^ 1];+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value);++ address_reg += REG15_DMA_INCREMENT;+ src_addr_low++;+ } while (--dma_length);++ // Update DMA source address after end of transfer+ gwenesis_vdp_regs[21] = src_addr_low & 0xFF;+ gwenesis_vdp_regs[22] = src_addr_low >> 8;++ // Clear DMA length at the end of transfer+ gwenesis_vdp_regs[19] = gwenesis_vdp_regs[20] = 0;++}++/******************************************************************************+ *+ * SEGA 315-5313 read data R16+ * Read an data value from mapped memory on specified address+ * and return as word+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+unsigned int gwenesis_vdp_read_data_port_16()+{+ enum+ {+ CRAM_BITMASK = 0x0EEE,+ VSRAM_BITMASK = 0x07FF,+ VRAM8_BITMASK = 0x00FF+ };+ unsigned int value;+ command_word_pending = 0;++ //if (code_reg & 1) /* check if write is set */+ // {+ switch (code_reg & 0xF)+ {+ case 0x0:+ // No byteswapping here+ value = VRAM[(address_reg)&0xFFFE] << 8;+ value |= VRAM[(address_reg | 1) & 0xFFFF];+ address_reg += REG15_DMA_INCREMENT;+ address_reg &= 0xFFFF;+ //vdpm_log(__FUNCTION__,"%04x",value);++ return value;+ case 0x4:+ if (((address_reg & 0x7f) >> 1) >= 0x28)+ value = VSRAM[0];+ else+ value = VSRAM[(address_reg & 0x7f) >> 1];+ value = (value & VSRAM_BITMASK) | (fifo[3] & ~VSRAM_BITMASK);+ address_reg += REG15_DMA_INCREMENT;+ address_reg &= 0x7F;+ // vdpm_log(__FUNCTION__,"%04x",value);++ return value;+ case 0x8:+ value = CRAM[(address_reg & 0x7f) >> 1];+ value = (value & CRAM_BITMASK) | (fifo[3] & ~CRAM_BITMASK);+ address_reg += REG15_DMA_INCREMENT;+ address_reg &= 0x7F;+ // vdpm_log(__FUNCTION__,"%04x",value);++ return value;+ case 0xC: /* 8-Bit memory access */+ value = VRAM[(address_reg ^ 1) & 0xFFFF];+ value = (value & VRAM8_BITMASK) | (fifo[3] & ~VRAM8_BITMASK);+ address_reg += REG15_DMA_INCREMENT;+ address_reg &= 0xFFFF;+ // vdpm_log(__FUNCTION__,"%04x",value);++ return value;+ default:+ printf("unhandled gwenesis_vdp_read_data_port_16(%x)\n", address_reg);+ return 0xFF;+ }+ // }+ // return 0x00;+}+++/******************************************************************************+ *+ * SEGA 315-5313 write to control port+ * Write an control value to SEGA 315-5313 control port+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+void gwenesis_vdp_control_port_write(unsigned int value)+{+ //vdpm_log(__FUNCTION__,"%04x",value);++ if (command_word_pending == 1) {+ // second half of the command word+ code_reg &= ~0x3C;+ code_reg |= (value >> 2) & 0x3C;+ address_reg &= 0x3FFF;+ address_reg |= value << 14;+ command_word_pending = 0;+ //vdpm_log(__FUNCTION__,"command word 2nd code:%x address:%x", code_reg, address_reg);+++ // DMA trigger+ if (code_reg & (1<<5)) {++ // Check master DMA enable, otherwise skip+ if (REG1_DMA_ENABLED == 0)+ return;++ // gwenesis_vdp_status |= 0x2;+ switch (REG23_DMA_TYPE) {+ case 0:+ case 1:++ gwenesis_vdp_dma_m68k();+ break;++ case 2:++ // VRAM fill will trigger on next data port write+ dma_fill_pending = 1;+ break;++ case 3:++ gwenesis_vdp_dma_copy();+ break;+ }+ }+ return;+ }+ if ((value >> 14) == 2) {++ gwenesis_vdp_register_w((value >> 8) & 0x1F, value & 0xFF);+ return;+ }++ // Anything else is treated as first half of the command word+ // We directly update the code reg and address reg+ code_reg &= ~0x3;+ code_reg |= value >> 14;+ address_reg &= ~0x3FFF;+ address_reg |= value & 0x3FFF;+ command_word_pending = 1;+ // vdpm_log(__FUNCTION__,"command word 1st code:%x address:%x", code_reg, address_reg);+}++/******************************************************************************+ *+ * SEGA 315-5313 write data W16+ * Write an data value to mapped memory on specified address+ *+ ******************************************************************************/+static inline __attribute__((always_inline))+void gwenesis_vdp_write_data_port_16(unsigned int value)+{+ vdpm_log(__FUNCTION__,"%04x",value);++ command_word_pending = 0;++ push_fifo(value);++ switch (code_reg & 0xF)+ {+ case 0x1: /* VRAM write */+ //vdpm_log(__FUNCTION__,"VRAM write : addr:%x increment:%d value:%04x",+ // address_reg, REG15_DMA_INCREMENT, value);+ gwenesis_vdp_vram_write(address_reg& 0xFFFF, (value >> 8) & 0xFF);+ gwenesis_vdp_vram_write((address_reg^1)& 0xFFFF, (value)&0xFF);+ address_reg += REG15_DMA_INCREMENT;+ address_reg &= 0xFFFF;++ break;+ case 0x3: /* CRAM write */+ //vdpm_log(__FUNCTION__,"CRAM write : addr:%x increment:%d value:%04x",+ // address_reg, REG15_DMA_INCREMENT, value);+ CRAM[(address_reg & 0x7f) >> 1] = value;++ unsigned short pixel;+ //unsigned short pixel_shadow,pixel_highlight;++ // Blue >> 9 << 2+ pixel = (value & 0xe00) >> 7;+ // Green >> 5 << 5 << 3+ pixel |= (value & 0x0e0) << 3;+ // Red >>1 << 11 << 2+ pixel |= (value & 0x00e) << 12;++ // Normal pixel values when SHI is not enabled+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;++ address_reg += REG15_DMA_INCREMENT;+ address_reg &= 0xFFFF;++ break;+ case 0x5: /* VSRAM write */+ //vdpm_log(__FUNCTION__,"VSRAM write : addr:%x increment:%d value:%04x",+ // address_reg, REG15_DMA_INCREMENT, value);+ // printf("write dataport 16: VSRAM@%04x:%04x\n",address_reg,value);+ VSRAM[(address_reg & 0x7f) >> 1] = value & 0X03FF;+ address_reg += REG15_DMA_INCREMENT;+ address_reg &= 0xFFFF;+ break;+ case 0x0:+ case 0x4:+ case 0x8: // Write operation after setting up+ // Makes Compatible with Alladin and Ecco 2+ break;+ case 0x9: // VDP FIFO TEST+ break;+ default:+ printf("VDP Data Port invalid");+ }++ /* if a DMA is scheduled, do it */+ if (dma_fill_pending)+ {+ dma_fill_pending = 0;+ gwenesis_vdp_dma_fill(value);+ return;+ }+}++/******************************************************************************+ *+ * SEGA 315-5313 Get Status+ * Return current VDP Status+ *+ ******************************************************************************/+unsigned int gwenesis_vdp_get_status()+{+ return gwenesis_vdp_status;+}+++/******************************************************************************+ *+ * SEGA 315-5313 read from memory R8+ * Read an value from mapped memory on specified address+ * and return as byte+ *+ ******************************************************************************/+ //static inline+unsigned int gwenesis_vdp_read_memory_8(unsigned int address)+{+ unsigned int ret = gwenesis_vdp_read_memory_16(address & ~1);+ if (address & 1)+ return ret & 0xFF;++ // vdpm_log(__FUNCTION__,"%04x : %04x",address,ret);++ return ret >> 8;+}++/******************************************************************************+ *+ * SEGA 315-5313 read from memory R16+ * Read an value from mapped memory on specified address+ * and return as word+ *+ ******************************************************************************/+ //static inline+unsigned int gwenesis_vdp_read_memory_16(unsigned int address)+{++ address &= 0x1F;++ if (address < 0X4)+ return gwenesis_vdp_read_data_port_16();+ else if (address < 0x8)+ return status_register_r();+ else if (address < 0xf)+ return gwenesis_vdp_hvcounter();+ else+ return 0xff;++}++/******************************************************************************+ *+ * SEGA 315-5313 write to memory W8+ * Write an byte value to mapped memory on specified address+ *+ ******************************************************************************/+ //static inline+void gwenesis_vdp_write_memory_8(unsigned int address, unsigned int value)+{+ gwenesis_vdp_write_memory_16(address & ~1, (value << 8) | value);++}++/******************************************************************************+ *+ * SEGA 315-5313 write to memory W16+ * Write an word value to mapped memory on specified address+ *+ ******************************************************************************/+ //static inline+ extern int system_clock;+void gwenesis_vdp_write_memory_16(unsigned int address, unsigned int value) {+ address = address & 0x1F;++ if (address < 0x4) {+ gwenesis_vdp_write_data_port_16(value);+ return;+ }+ if (address < 0x8) {+ gwenesis_vdp_control_port_write(value);+ return;+ }+ if (address < 0x18) { // PSG 8 bits write+ vdpm_log(__FUNCTION__,"PSG sclk=%d,mclk=%d", system_clock, m68k_cycles_master());+ gwenesis_SN76489_Write(value, m68k_cycles_master());++ return;+ }+ // UNHANDLED+ printf("unhandled gwenesis_vdp_write(%x, %x)\n", address, value);++}++void gwenesis_vdp_mem_save_state() {+ SaveState* state;+ state = saveGwenesisStateOpenForWrite("vdp_mem");++ /* (VRAM: a part of the state of its own, md.c) */+ saveGwenesisStateSetBuffer(state, "CRAM", CRAM, sizeof(CRAM));+ saveGwenesisStateSetBuffer(state, "SAT_CACHE", SAT_CACHE, sizeof(SAT_CACHE));+ saveGwenesisStateSetBuffer(state, "gwenesis_vdp_regs", gwenesis_vdp_regs, sizeof(gwenesis_vdp_regs));+ saveGwenesisStateSetBuffer(state, "fifo", fifo, sizeof(fifo));+ saveGwenesisStateSetBuffer(state, "CRAM565", CRAM565, sizeof(CRAM565));+ saveGwenesisStateSetBuffer(state, "VSRAM", VSRAM, sizeof(VSRAM));+ saveGwenesisStateSet(state, "code_reg", code_reg);+ saveGwenesisStateSet(state, "address_reg", address_reg);+ saveGwenesisStateSet(state, "command_word_pending", command_word_pending);+ saveGwenesisStateSet(state, "gwenesis_vdp_status", gwenesis_vdp_status);+ saveGwenesisStateSet(state, "dma_fill_pending", dma_fill_pending);+ saveGwenesisStateSet(state, "hvcounter_latch", hvcounter_latch);+ saveGwenesisStateSet(state, "hvcounter_latched", hvcounter_latched);+ saveGwenesisStateSet(state, "hint_pending", hint_pending);+}++void gwenesis_vdp_mem_load_state() {+ SaveState* state = saveGwenesisStateOpenForRead("vdp_mem");++ saveGwenesisStateGetBuffer(state, "CRAM", CRAM, sizeof(CRAM));+ saveGwenesisStateGetBuffer(state, "SAT_CACHE", SAT_CACHE, sizeof(SAT_CACHE));+ saveGwenesisStateGetBuffer(state, "gwenesis_vdp_regs", gwenesis_vdp_regs, sizeof(gwenesis_vdp_regs));+ saveGwenesisStateGetBuffer(state, "fifo", fifo, sizeof(fifo));+ saveGwenesisStateGetBuffer(state, "CRAM565", CRAM565, sizeof(CRAM565));+ saveGwenesisStateGetBuffer(state, "VSRAM", VSRAM, sizeof(VSRAM));+ code_reg = saveGwenesisStateGet(state, "code_reg");+ address_reg = saveGwenesisStateGet(state, "address_reg");+ command_word_pending = saveGwenesisStateGet(state, "command_word_pending");+ gwenesis_vdp_status = saveGwenesisStateGet(state, "gwenesis_vdp_status");+ dma_fill_pending = saveGwenesisStateGet(state, "dma_fill_pending");+ hvcounter_latch = saveGwenesisStateGet(state, "hvcounter_latch");+ hvcounter_latched = saveGwenesisStateGet(state, "hvcounter_latched");+ hint_pending = saveGwenesisStateGet(state, "hint_pending");+}\ No newline at end of filediff --git a/games/retrogo/src/md/m68k.h b/games/retrogo/src/md/m68k.hnew file mode 100644index 00000000..f400d3db--- /dev/null+++ b/games/retrogo/src/md/m68k.h@@ -0,0 +1,482 @@+#ifndef M68K__HEADER+#define M68K__HEADER++/* ======================================================================== */+/* ========================= LICENSING & COPYRIGHT ======================== */+/* ======================================================================== */+/*+ * MUSASHI+ * Version 3.32+ *+ * A portable Motorola M680x0 processor emulation engine.+ * Copyright Karl Stenerud. All rights reserved.+ *+ * This code may be freely used for non-commercial purposes as long as this+ * copyright notice remains unaltered in the source code and any binary files+ * containing this code in compiled form.+ *+ * All other licensing terms must be negotiated with the author+ * (Karl Stenerud).+ *+ * The latest version of this code can be obtained at:+ * http://kstenerud.cjb.net+ */++ /* Modified by Eke-Eke for Genesis Plus GX:++ - removed unused stuff to reduce memory usage / optimize execution (multiple CPU types support, NMI support, ...)+ - moved stuff to compile statically in a single object file+ - implemented support for global cycle count (shared by 68k & Z80 CPU)+ - added support for interrupt latency (Sesame's Street Counting Cafe, Fatal Rewind)+ - added proper cycle use on reset+ - added cycle accurate timings for MUL/DIV instructions (thanks to Jorge Cwik !)+ - fixed undocumented flags for DIV instructions (Blood Shot)+ - fixed undocumented behaviors for ABCD/SBCD/NBCD instructions (thanks to flamewing for his test ROM)+ - improved auto-vectored interrupts acknowledge cycle timing accuracy+ - added MAIN-CPU & SUB-CPU support for Mega CD emulation++ */++/* ======================================================================== */+/* ================================ INCLUDES ============================== */+/* ======================================================================== */++#include <setjmp.h>+#include "macros.h"+#ifdef HOOK_CPU+#include "cpuhook.h"+#endif++/* ======================================================================== */+/* ==================== ARCHITECTURE-DEPENDANT DEFINES ==================== */+/* ======================================================================== */++/* Check for > 32bit sizes */+#if UINT_MAX > 0xffffffff+ #define M68K_INT_GT_32_BIT 1+#else+ #define M68K_INT_GT_32_BIT 0+#endif++/* Data types used in this emulation core */+#undef sint8+#undef sint16+#undef sint32+#undef sint64+#undef uint8+#undef uint16+#undef uint32+#undef uint64+#undef sint+#undef uint++#define sint8 signed char /* ASG: changed from char to signed char */+#define sint16 signed short+#define sint32 signed int /* AWJ: changed from long to int */+#define uint8 unsigned char+#define uint16 unsigned short+#define uint32 unsigned int /* AWJ: changed from long to int */++/* signed and unsigned int must be at least 32 bits wide */+#define sint signed int+#define uint unsigned int+++#if M68K_USE_64_BIT+#define sint64 signed long long+#define uint64 unsigned long long+#else+#define sint64 sint32+#define uint64 uint32+#endif /* M68K_USE_64_BIT */++++/* Allow for architectures that don't have 8-bit sizes */+/*#if UCHAR_MAX == 0xff*/+ #define MAKE_INT_8(A) (sint8)(A)+/*#else+ #undef sint8+ #define sint8 signed int+ #undef uint8+ #define uint8 unsigned int+ INLINE sint MAKE_INT_8(uint value)+ {+ return (value & 0x80) ? value | ~0xff : value & 0xff;+ }*/+/*#endif *//* UCHAR_MAX == 0xff */+++/* Allow for architectures that don't have 16-bit sizes */+/*#if USHRT_MAX == 0xffff*/+ #define MAKE_INT_16(A) (sint16)(A)+/*#else+ #undef sint16+ #define sint16 signed int+ #undef uint16+ #define uint16 unsigned int+ INLINE sint MAKE_INT_16(uint value)+ {+ return (value & 0x8000) ? value | ~0xffff : value & 0xffff;+ }*/+/*#endif *//* USHRT_MAX == 0xffff */+++/* Allow for architectures that don't have 32-bit sizes */+/*#if UINT_MAX == 0xffffffff*/+ #define MAKE_INT_32(A) (sint32)(A)+/*#else+ #undef sint32+ #define sint32 signed int+ #undef uint32+ #define uint32 unsigned int+ INLINE sint MAKE_INT_32(uint value)+ {+ return (value & 0x80000000) ? value | ~0xffffffff : value & 0xffffffff;+ }*/+/*#endif *//* UINT_MAX == 0xffffffff */++++/* ======================================================================== */+/* ============================ GENERAL DEFINES =========================== */+/*** BZHXX ***/+#ifndef FALSE+#define FALSE 0+#define TRUE 1+#endif++#define ROM_SWAP+#define RAM_SWAP++// 16/32 bits acces to RAM/ROM++#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0++ extern unsigned char *ROM_DATA;+ extern unsigned char *M68K_RAM;+#else++ extern unsigned char *ROM_DATA;+ /* (NumPlay: the 68000's 64 KB of RAM in 16 pages of 4 KB, wherever the calculator has room) */+ extern unsigned char *md_ram[16];+#endif++/* (NumPlay: nothing read past the ROM's size rounded up to a power of two) */+extern unsigned int md_rom_mask;+#define FETCH8ROM(A) ((ROM_DATA[((A) ^ 1) & md_rom_mask]))+#define FETCH16ROM(A) ((*(unsigned short *)&ROM_DATA[(A) & md_rom_mask]))+#define FETCH32ROM(A) ( (*(unsigned int *)&ROM_DATA[(A) & md_rom_mask] << 16) | (*(unsigned int *)&ROM_DATA[(A) & md_rom_mask] >> 16) )++#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0++/* Direct access to ITCRAM as M68KRAM on STM32H7 mapped at 0x0 !! */+#define FETCH8RAM(A) (*(unsigned char *)(((A)&0XFFFF) ^ 1))+#define FETCH16RAM(A) (*(unsigned short *)((A)&0XFFFF))+#define FETCH32RAM(A) (((*(unsigned int *)((A)&0XFFFF)) << 16) | ((*(unsigned int *)((A)&0XFFFF)) >> 16))++#define WRITE8RAM(A, V) ((*(unsigned char *)(((A)&0XFFFF) ^ 1)) = (V))+#define WRITE16RAM(A, V) ((*(unsigned short *)( (A)&0XFFFF)) = (V))+#define WRITE32RAM(A, V) ((*(unsigned int *)( (A)&0XFFFF)) = (((V) << 16) | ((V) >> 16)))+#else++/* (the words swapped as gwenesis keeps them; a long word is two words, maybe in two pages) */+#define MD_RAM16(A) (*(unsigned short *)&md_ram[((A) >> 12) & 15][(A) & 0xFFE])+#define FETCH8RAM(A) (md_ram[((A) >> 12) & 15][((A) ^ 1) & 0xFFF])+#define FETCH16RAM(A) (MD_RAM16(A))+#define FETCH32RAM(A) (((unsigned int)MD_RAM16(A) << 16) | MD_RAM16((A) + 2))++#define WRITE8RAM(A, V) (md_ram[((A) >> 12) & 15][((A) ^ 1) & 0xFFF] = (V))+#define WRITE16RAM(A, V) (MD_RAM16(A) = (unsigned short)(V))+#define WRITE32RAM(A, V) (MD_RAM16(A) = (unsigned short)((V) >> 16), MD_RAM16((A) + 2) = (unsigned short)(V))++#endif++#define m68k_read_immediate_16(A) ( ( (A) & 0x800000) ? FETCH16RAM((A)) : FETCH16ROM((A)) )+#define m68k_read_immediate_32(A) ( ( (A) & 0x800000) ? FETCH32RAM((A)) : FETCH32ROM((A)) )++#define m68k_read_pcrelative_8(A) ( FETCH8ROM((A)) )+#define m68k_read_pcrelative_16(A) ( FETCH16ROM((A)) )+#define m68k_read_pcrelative_32(A) ( FETCH32ROM((A)) )++/* Read from anywhere */+unsigned int m68k_read_memory_8(unsigned int address);+unsigned int m68k_read_memory_16(unsigned int address);+unsigned int m68k_read_memory_32(unsigned int address);++/* Read data immediately following the PC */+// unsigned int m68k_read_immediate_16(unsigned int address);+// unsigned int m68k_read_immediate_32(unsigned int address);++/* Read data relative to the PC */+//unsigned int m68k_read_pcrelative_8(unsigned int address);+//unsigned int m68k_read_pcrelative_16(unsigned int address);+//unsigned int m68k_read_pcrelative_32(unsigned int address);++/* Memory access for the disassembler */+unsigned int m68k_read_disassembler_8 (unsigned int address);+unsigned int m68k_read_disassembler_16 (unsigned int address);+unsigned int m68k_read_disassembler_32 (unsigned int address);++/* Write to anywhere */+void m68k_write_memory_8(unsigned int address, unsigned int value);+void m68k_write_memory_16(unsigned int address, unsigned int value);+void m68k_write_memory_32(unsigned int address, unsigned int value);++/*** BZHXX ***/+/* ======================================================================== */++/* There are 7 levels of interrupt to the 68K.+ * A transition from < 7 to 7 will cause a non-maskable interrupt (NMI).+ */+#define M68K_IRQ_NONE 0+#define M68K_IRQ_1 1+#define M68K_IRQ_2 2+#define M68K_IRQ_3 3+#define M68K_IRQ_4 4+#define M68K_IRQ_5 5+#define M68K_IRQ_6 6+#define M68K_IRQ_7 7+++/* Special interrupt acknowledge values.+ * Use these as special returns from the interrupt acknowledge callback+ * (specified later in this header).+ */++/* Causes an interrupt autovector (0x18 + interrupt level) to be taken.+ * This happens in a real 68K if VPA or AVEC is asserted during an interrupt+ * acknowledge cycle instead of DTACK.+ */+#define M68K_INT_ACK_AUTOVECTOR 0xffffffff++/* Causes the spurious interrupt vector (0x18) to be taken+ * This happens in a real 68K if BERR is asserted during the interrupt+ * acknowledge cycle (i.e. no devices responded to the acknowledge).+ */+#define M68K_INT_ACK_SPURIOUS 0xfffffffe+++/* Registers used by m68k_get_reg() and m68k_set_reg() */+typedef enum+{+ /* Real registers */+ M68K_REG_D0, /* Data registers */+ M68K_REG_D1,+ M68K_REG_D2,+ M68K_REG_D3,+ M68K_REG_D4,+ M68K_REG_D5,+ M68K_REG_D6,+ M68K_REG_D7,+ M68K_REG_A0, /* Address registers */+ M68K_REG_A1,+ M68K_REG_A2,+ M68K_REG_A3,+ M68K_REG_A4,+ M68K_REG_A5,+ M68K_REG_A6,+ M68K_REG_A7,+ M68K_REG_PC, /* Program Counter */+ M68K_REG_SR, /* Status Register */+ M68K_REG_SP, /* The current Stack Pointer (located in A7) */+ M68K_REG_USP, /* User Stack Pointer */+ M68K_REG_ISP, /* Interrupt Stack Pointer */++#if M68K_EMULATE_PREFETCH+ /* Assumed registers */+ /* These are cheat registers which emulate the 1-longword prefetch+ * present in the 68000 and 68010.+ */+ M68K_REG_PREF_ADDR, /* Last prefetch address */+ M68K_REG_PREF_DATA, /* Last prefetch data */+#endif++ /* Convenience registers */+ M68K_REG_IR /* Instruction register */+} m68k_register_t;+++/* 68k memory map structure */+typedef struct+{+ unsigned char *base; /* memory-based access (ROM, RAM) */+ unsigned int (*read8)(unsigned int address); /* I/O byte read access */+ unsigned int (*read16)(unsigned int address); /* I/O word read access */+ void (*write8)(unsigned int address, unsigned int data); /* I/O byte write access */+ void (*write16)(unsigned int address, unsigned int data); /* I/O word write access */+} cpu_memory_map;++/* 68k idle loop detection */+typedef struct+{+ uint pc;+ uint cycle;+ uint detected;+} cpu_idle_t;++typedef struct+{+ cpu_memory_map memory_map[256]; /* memory mapping */++ cpu_idle_t poll; /* polling detection */++ uint cycles; /* current master cycle count */+ uint cycle_end; /* aimed master cycle count for current execution frame */++ uint dar[16]; /* Data and Address Registers */+ uint pc; /* Program Counter */+ uint sp[5]; /* User and Interrupt Stack Pointers */+ uint ir; /* Instruction Register */+ uint t1_flag; /* Trace 1 */+ uint s_flag; /* Supervisor */+ uint x_flag; /* Extend */+ uint n_flag; /* Negative */+ uint not_z_flag; /* Zero, inverted for speedups */+ uint v_flag; /* Overflow */+ uint c_flag; /* Carry */+ uint int_mask; /* I0-I2 */+ uint int_level; /* State of interrupt pins IPL0-IPL2 -- ASG: changed from ints_pending */+ uint stopped; /* Stopped state */++ uint pref_addr; /* Last prefetch address */+ uint pref_data; /* Data in the prefetch queue */++ uint instr_mode; /* Stores whether we are in instruction mode or group 0/1 exception mode */+ uint run_mode; /* Stores whether we are processing a reset, bus error, address error, or something else */+ uint aerr_enabled; /* Enables/deisables address error checks at runtime */+ jmp_buf aerr_trap; /* Address error jump */+ uint aerr_address; /* Address error location */+ uint aerr_write_mode; /* Address error write mode */+ uint aerr_fc; /* Address error FC code */++ uint tracing; /* Tracing enable flag */++ uint address_space; /* Current FC code */++#ifdef M68K_OVERCLOCK_SHIFT+ int cycle_ratio;+#endif++ /* Callbacks to host */+ int (*int_ack_callback)(int int_line); /* Interrupt Acknowledge */+ void (*reset_instr_callback)(void); /* Called when a RESET instruction is encountered */+ int (*tas_instr_callback)(void); /* Called when a TAS instruction is encountered, allows / disallows writeback */+ void (*set_fc_callback)(unsigned int new_fc); /* Called when the CPU function code changes */+} m68ki_cpu_core;++/* CPU cores */+extern m68ki_cpu_core m68k;++/* ======================================================================== */+/* ============================== CALLBACKS =============================== */+/* ======================================================================== */++/* These functions allow you to set callbacks to the host when specific events+ * occur. Note that you must enable the corresponding value in m68kconf.h+ * in order for these to do anything useful.+ * Note: I have defined default callbacks which are used if you have enabled+ * the corresponding #define in m68kconf.h but either haven't assigned a+ * callback or have assigned a callback of NULL.+ */++#if M68K_EMULATE_INT_ACK == OPT_ON+/* Set the callback for an interrupt acknowledge.+ * You must enable M68K_EMULATE_INT_ACK in m68kconf.h.+ * The CPU will call the callback with the interrupt level being acknowledged.+ * The host program must return either a vector from 0x02-0xff, or one of the+ * special interrupt acknowledge values specified earlier in this header.+ * If this is not implemented, the CPU will always assume an autovectored+ * interrupt, and will automatically clear the interrupt request when it+ * services the interrupt.+ * Default behavior: return M68K_INT_ACK_AUTOVECTOR.+ */+void m68k_set_int_ack_callback(int (*callback)(int int_level));+#endif++#if M68K_EMULATE_RESET == OPT_ON+/* Set the callback for the RESET instruction.+ * You must enable M68K_EMULATE_RESET in m68kconf.h.+ * The CPU calls this callback every time it encounters a RESET instruction.+ * Default behavior: do nothing.+ */+void m68k_set_reset_instr_callback(void (*callback)(void));+#endif++#if M68K_TAS_HAS_CALLBACK == OPT_ON+/* Set the callback for the TAS instruction.+ * You must enable M68K_TAS_HAS_CALLBACK in m68kconf.h.+ * The CPU calls this callback every time it encounters a TAS instruction.+ * Default behavior: return 1, allow writeback.+ */+void m68k_set_tas_instr_callback(int (*callback)(void));+#endif++#if M68K_EMULATE_FC == OPT_ON+/* Set the callback for CPU function code changes.+ * You must enable M68K_EMULATE_FC in m68kconf.h.+ * The CPU calls this callback with the function code before every memory+ * access to set the CPU's function code according to what kind of memory+ * access it is (supervisor/user, program/data and such).+ * Default behavior: do nothing.+ */+void m68k_set_fc_callback(void (*callback)(unsigned int new_fc));+#endif+++/* ======================================================================== */+/* ====================== FUNCTIONS TO ACCESS THE CPU ===================== */+/* ======================================================================== */++/* Do whatever initialisations the core requires. Should be called+ * at least once at init time.+ */+extern void m68k_init(void);++/* Pulse the RESET pin on the CPU.+ * You *MUST* reset the CPU at least once to initialize the emulation+ */+extern void m68k_pulse_reset(void);++/* Run until given cycle count is reached */+extern void m68k_run(unsigned int cycles);++/* Get current instruction execution time */+extern int m68k_cycles(void);++/* Number of cycles run so far from start of frame */+extern int m68k_cycles_master(void);++/* Number of cycles run so far from run call */+extern int m68k_cycles_run(void);++/* Set the IPL0-IPL2 pins on the CPU (IRQ).+ * A transition from < 7 to 7 will cause a non-maskable interrupt (NMI).+ * Setting IRQ to 0 will clear an interrupt request.+ */+extern void m68k_set_irq(unsigned int int_level);+extern void m68k_set_irq_delay(unsigned int int_level);+extern void m68k_update_irq(unsigned int mask);++/* Halt the CPU as if you pulsed the HALT pin. */+extern void m68k_pulse_halt(void);+extern void m68k_clear_halt(void);++/* Peek at the internals of a CPU context. This can either be a context+ * retrieved using m68k_get_context() or the currently running context.+ * If context is NULL, the currently running CPU context will be used.+ */+extern unsigned int m68k_get_reg(m68k_register_t reg);++/* Poke values into the internals of the currently running CPU context */+extern void m68k_set_reg(m68k_register_t reg, unsigned int value);++/* Load/Save state of CPU */+extern void gwenesis_m68k_save_state();+extern void gwenesis_m68k_load_state();++/* ======================================================================== */+/* ============================== END OF FILE ============================= */+/* ======================================================================== */++#endif /* M68K__HEADER */diff --git a/games/retrogo/src/md/m68kconf.h b/games/retrogo/src/md/m68kconf.hnew file mode 100644index 00000000..bec6d017--- /dev/null+++ b/games/retrogo/src/md/m68kconf.h@@ -0,0 +1,93 @@+#ifndef M68KCONF__HEADER+#define M68KCONF__HEADER++/* ======================================================================== */+/* ======================== MAIN 68K CONFIGURATION ======================== */+/* ======================================================================== */++/* Configuration switches.+ * Use OPT_SPECIFY_HANDLER for configuration options that allow callbacks.+ * OPT_SPECIFY_HANDLER causes the core to link directly to the function+ * or macro you specify, rather than using callback functions whose pointer+ * must be passed in using m68k_set_xxx_callback().+ */+#define OPT_OFF 0+#define OPT_ON 1+#define OPT_SPECIFY_HANDLER 2++/* If ON, the CPU will call m68k_write_32_pd() when it executes move.l with a+ * predecrement destination EA mode instead of m68k_write_32().+ * To simulate real 68k behavior, m68k_write_32_pd() must first write the high+ * word to [address+2], and then write the low word to [address].+ */+#define M68K_SIMULATE_PD_WRITES OPT_OFF++/* If ON, CPU will call the interrupt acknowledge callback when it services an+ * interrupt.+ * If off, all interrupts will be autovectored and all interrupt requests will+ * auto-clear when the interrupt is serviced.+ */+#define M68K_EMULATE_INT_ACK OPT_ON //OPT_SPECIFY_HANDLER+#define M68K_INT_ACK_CALLBACK(A) your_int_ack_handler_function(A)++/* If ON, CPU will call the output reset callback when it encounters a reset+ * instruction.+ */+#define M68K_EMULATE_RESET OPT_OFF+#define M68K_RESET_CALLBACK() your_reset_handler_function()++/* If ON, CPU will call the callback when it encounters a tas+ * instruction.+ */+#define M68K_TAS_HAS_CALLBACK OPT_OFF+#define M68K_TAS_CALLBACK() your_tas_handler_function()++/* If ON, CPU will call the set fc callback on every memory access to+ * differentiate between user/supervisor, program/data access like a real+ * 68000 would. This should be enabled and the callback should be set if you+ * want to properly emulate the m68010 or higher. (moves uses function codes+ * to read/write data from different address spaces)+ */+#define M68K_EMULATE_FC OPT_OFF+#define M68K_SET_FC_CALLBACK(A) your_set_fc_handler_function(A)++/* If ON, the CPU will monitor the trace flags and take trace exceptions+ */+#define M68K_EMULATE_TRACE OPT_OFF++/* If ON, the CPU will emulate the 4-byte prefetch queue of a real 68000 */+#define M68K_EMULATE_PREFETCH OPT_OFF++/* If ON, the CPU will generate address error exceptions if it tries to+ * access a word or longword at an odd address.+ * NOTE: This is only emulated properly for 68000 mode.+ */+#define M68K_EMULATE_ADDRESS_ERROR OPT_ON++/* If ON and previous option is also ON, address error exceptions will+ also be checked when fetching instructions. Disabling this can help+ speeding up emulation while still emulating address error exceptions+ on other memory access if needed.+ * NOTE: This is only emulated properly for 68000 mode.+ */+#define M68K_CHECK_PC_ADDRESS_ERROR OPT_OFF+++/* ----------------------------- COMPATIBILITY ---------------------------- */++/* The following options set optimizations that violate the current ANSI+ * standard, but will be compliant under the forthcoming C9X standard.+ */+++/* If ON, the enulation core will use 64-bit integers to speed up some+ * operations.+*/+#define M68K_USE_64_BIT OPT_OFF+++/* ======================================================================== */+/* ============================== END OF FILE ============================= */+/* ======================================================================== */++#endif /* M68KCONF__HEADER */diff --git a/games/retrogo/src/md/m68kcpu.c b/games/retrogo/src/md/m68kcpu.cnew file mode 100644index 00000000..3079d321--- /dev/null+++ b/games/retrogo/src/md/m68kcpu.c@@ -0,0 +1,462 @@+/* ======================================================================== */+/* MAIN 68K CORE */+/* ======================================================================== */++extern int vdp_68k_irq_ack(int int_level);++#define m68ki_cpu m68k+#define MUL (7)++/* ======================================================================== */+/* ================================ INCLUDES ============================== */+/* ======================================================================== */++/* (NumPlay: the opcode table made at build time by tools/m68ktab.py, a 16-bit number for each+ opcode instead of a pointer, the same handlers and cycles as gwenesis' own table) */+#include "m68k_tab.h"++#include "m68kconf.h"+#include "m68kcpu.h"+#include "m68kops.h"+#include "gwenesis_savestate.h"++/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound+ chips' writes go nowhere; and nothing printed) */+#define YM2612Read(clk) 0+#define YM2612Write(a, v, clk) ((void)0)+#define YM2612Init() ((void)0)+#define YM2612Config(x) ((void)0)+#define YM2612ResetChip() ((void)0)+#define gwenesis_SN76489_Write(v, clk) ((void)0)+#define gwenesis_SN76489_Init(a, b, c) ((void)0)+#define gwenesis_SN76489_Reset() ((void)0)+#define printf(...) ((void)0)+#define vfprintf(...) ((void)0)++/* ======================================================================== */+/* ================================= DATA ================================= */+/* ======================================================================== */+++static int irq_latency;++m68ki_cpu_core m68k;+++/* ======================================================================== */+/* =============================== CALLBACKS ============================== */+/* ======================================================================== */++/* Default callbacks used if the callback hasn't been set yet, or if the+ * callback is set to NULL+ */++#if M68K_EMULATE_INT_ACK == OPT_ON+/* Interrupt acknowledge */+static int default_int_ack_callback(int int_level)+{+ CPU_INT_LEVEL = 0;+ return M68K_INT_ACK_AUTOVECTOR;+}+#endif++#if M68K_EMULATE_RESET == OPT_ON+/* Called when a reset instruction is executed */+static void default_reset_instr_callback(void)+{+}+#endif++#if M68K_TAS_HAS_CALLBACK == OPT_ON+/* Called when a tas instruction is executed */+static int default_tas_instr_callback(void)+{+ return 1; // allow writeback+}+#endif++#if M68K_EMULATE_FC == OPT_ON+/* Called every time there's bus activity (read/write to/from memory */+static void default_set_fc_callback(unsigned int new_fc)+{+}+#endif+++/* ======================================================================== */+/* ================================= API ================================== */+/* ======================================================================== */++/* Access the internals of the CPU */+unsigned int m68k_get_reg(m68k_register_t regnum)+{+ switch(regnum)+ {+ case M68K_REG_D0: return m68ki_cpu.dar[0];+ case M68K_REG_D1: return m68ki_cpu.dar[1];+ case M68K_REG_D2: return m68ki_cpu.dar[2];+ case M68K_REG_D3: return m68ki_cpu.dar[3];+ case M68K_REG_D4: return m68ki_cpu.dar[4];+ case M68K_REG_D5: return m68ki_cpu.dar[5];+ case M68K_REG_D6: return m68ki_cpu.dar[6];+ case M68K_REG_D7: return m68ki_cpu.dar[7];+ case M68K_REG_A0: return m68ki_cpu.dar[8];+ case M68K_REG_A1: return m68ki_cpu.dar[9];+ case M68K_REG_A2: return m68ki_cpu.dar[10];+ case M68K_REG_A3: return m68ki_cpu.dar[11];+ case M68K_REG_A4: return m68ki_cpu.dar[12];+ case M68K_REG_A5: return m68ki_cpu.dar[13];+ case M68K_REG_A6: return m68ki_cpu.dar[14];+ case M68K_REG_A7: return m68ki_cpu.dar[15];+ case M68K_REG_PC: return MASK_OUT_ABOVE_32(m68ki_cpu.pc);+ case M68K_REG_SR: return m68ki_cpu.t1_flag |+ (m68ki_cpu.s_flag << 11) |+ m68ki_cpu.int_mask |+ ((m68ki_cpu.x_flag & XFLAG_SET) >> 4) |+ ((m68ki_cpu.n_flag & NFLAG_SET) >> 4) |+ ((!m68ki_cpu.not_z_flag) << 2) |+ ((m68ki_cpu.v_flag & VFLAG_SET) >> 6) |+ ((m68ki_cpu.c_flag & CFLAG_SET) >> 8);+ case M68K_REG_SP: return m68ki_cpu.dar[15];+ case M68K_REG_USP: return m68ki_cpu.s_flag ? m68ki_cpu.sp[0] : m68ki_cpu.dar[15];+ case M68K_REG_ISP: return m68ki_cpu.s_flag ? m68ki_cpu.dar[15] : m68ki_cpu.sp[4];+#if M68K_EMULATE_PREFETCH+ case M68K_REG_PREF_ADDR: return m68ki_cpu.pref_addr;+ case M68K_REG_PREF_DATA: return m68ki_cpu.pref_data;+#endif+ case M68K_REG_IR: return m68ki_cpu.ir;+ default: return 0;+ }+}++void m68k_set_reg(m68k_register_t regnum, unsigned int value)+{+ switch(regnum)+ {+ case M68K_REG_D0: REG_D[0] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_D1: REG_D[1] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_D2: REG_D[2] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_D3: REG_D[3] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_D4: REG_D[4] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_D5: REG_D[5] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_D6: REG_D[6] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_D7: REG_D[7] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A0: REG_A[0] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A1: REG_A[1] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A2: REG_A[2] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A3: REG_A[3] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A4: REG_A[4] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A5: REG_A[5] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A6: REG_A[6] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_A7: REG_A[7] = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_PC: m68ki_jump(MASK_OUT_ABOVE_32(value)); return;+ case M68K_REG_SR: m68ki_set_sr(value); return;+ case M68K_REG_SP: REG_SP = MASK_OUT_ABOVE_32(value); return;+ case M68K_REG_USP: if(FLAG_S)+ REG_USP = MASK_OUT_ABOVE_32(value);+ else+ REG_SP = MASK_OUT_ABOVE_32(value);+ return;+ case M68K_REG_ISP: if(FLAG_S)+ REG_SP = MASK_OUT_ABOVE_32(value);+ else+ REG_ISP = MASK_OUT_ABOVE_32(value);+ return;+ case M68K_REG_IR: REG_IR = MASK_OUT_ABOVE_16(value); return;+#if M68K_EMULATE_PREFETCH+ case M68K_REG_PREF_ADDR: CPU_PREF_ADDR = MASK_OUT_ABOVE_32(value); return;+#endif+ default: return;+ }+}++/* Set the callbacks */+#if M68K_EMULATE_INT_ACK == OPT_ON+void m68k_set_int_ack_callback(int (*callback)(int int_level))+{+ CALLBACK_INT_ACK = callback ? callback : default_int_ack_callback;+}+#endif++#if M68K_EMULATE_RESET == OPT_ON+void m68k_set_reset_instr_callback(void (*callback)(void))+{+ CALLBACK_RESET_INSTR = callback ? callback : default_reset_instr_callback;+}+#endif++#if M68K_TAS_HAS_CALLBACK == OPT_ON+void m68k_set_tas_instr_callback(int (*callback)(void))+{+ CALLBACK_TAS_INSTR = callback ? callback : default_tas_instr_callback;+}+#endif++#if M68K_EMULATE_FC == OPT_ON+void m68k_set_fc_callback(void (*callback)(unsigned int new_fc))+{+ CALLBACK_SET_FC = callback ? callback : default_set_fc_callback;+}+#endif++#ifdef LOGERROR++extern void error(char *format, ...);+extern uint16 v_counter;+#endif++/* ASG: rewrote so that the int_level is a mask of the IPL0/IPL1/IPL2 bits */+/* KS: Modified so that IPL* bits match with mask positions in the SR+ * and cleaned out remenants of the interrupt controller.+ */+void m68k_update_irq(unsigned int mask)+{+ /* Update IRQ level */+ CPU_INT_LEVEL |= (mask << 8);++#ifdef LOGERROR+ error("[%d(%d)][%d(%d)] m68k IRQ Level = %d(0x%02x) (%x)\n", v_counter, m68k.cycles/3420, m68k.cycles, m68k.cycles%3420,CPU_INT_LEVEL>>8,FLAG_INT_MASK,m68k_get_reg(M68K_REG_PC));+#endif+}++void m68k_set_irq(unsigned int int_level)+{+ /* Set IRQ level */+ CPU_INT_LEVEL = int_level << 8;++#ifdef LOGERROR+ error("[%d(%d)][%d(%d)] m68k IRQ Level = %d(0x%02x) (%x)\n", v_counter, m68k.cycles/3420, m68k.cycles, m68k.cycles%3420,CPU_INT_LEVEL>>8,FLAG_INT_MASK,m68k_get_reg(M68K_REG_PC));+#endif+}++/* IRQ latency (Fatal Rewind, Sesame's Street Counting Cafe)*/+void m68k_set_irq_delay(unsigned int int_level)+{+ /* Prevent reentrance */+ if (!irq_latency)+ {+ /* This is always triggered from MOVE instructions (VDP CTRL port write) */+ /* We just make sure this is not a MOVE.L instruction as we could be in */+ /* the middle of its execution (first memory write). */+ if ((REG_IR & 0xF000) != 0x2000)+ {+ /* Finish executing current instruction */+ USE_CYCLES(CYC_INSTRUCTION(REG_IR));++ /* One instruction delay before interrupt */+ irq_latency = 1;+ m68ki_trace_t1() /* auto-disable (see m68kcpu.h) */+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */+ REG_IR = m68ki_read_imm_16();+ m68ki_pair_handler[m68ki_opcode_pair[REG_IR]]();+ m68ki_exception_if_trace() /* auto-disable (see m68kcpu.h) */+ irq_latency = 0;+ }++ /* Set IRQ level */+ CPU_INT_LEVEL = int_level << 8;+ }++#ifdef LOGERROR+ error("[%d(%d)][%d(%d)] m68k IRQ Level = %d(0x%02x) (%x)\n", v_counter, m68k.cycles/3420, m68k.cycles, m68k.cycles%3420,CPU_INT_LEVEL>>8,FLAG_INT_MASK,m68k_get_reg(M68K_REG_PC));+#endif++ /* Check interrupt mask to process IRQ */+ m68ki_check_interrupts(); /* Level triggered (IRQ) */+}++void m68k_run(unsigned int cycles)+{+ // printf("m68K_run current_cycles=%d add=%d STOP=%x\n",m68k.cycles,cycles,CPU_STOPPED);++ /* Make sure CPU is not already ahead */+ if (m68k.cycles >= cycles)+ {+ return;+ }++ /* Check interrupt mask to process IRQ if needed */+ m68ki_check_interrupts();++ /* Make sure we're not stopped */+ if (CPU_STOPPED)+ {+ m68k.cycles = cycles;+ return;+ }++ /* Save end cycles count for when CPU is stopped */+ m68k.cycle_end = cycles;++ /* Return point for when we have an address error (TODO: use goto) */+ m68ki_set_address_error_trap() /* auto-disable (see m68kcpu.h) */++#ifdef LOGERROR+ error("[%d][%d] m68k run to %d cycles (%x), irq mask = %x (%x)\n", v_counter, m68k.cycles, cycles, m68k.pc,FLAG_INT_MASK, CPU_INT_LEVEL);+#endif++ while (m68k.cycles < cycles)+ {+ /* Set tracing accodring to T1. */+ m68ki_trace_t1() /* auto-disable (see m68kcpu.h) */++ /* Set the address space for reads */+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */++#ifdef HOOK_CPU+ /* Trigger execution hook */+ if (cpu_hook)+ cpu_hook(HOOK_M68K_E, 0, REG_PC, 0);+#endif++ /* Decode next instruction */+ REG_IR = m68ki_read_imm_16();++// printf("PC=%x IR=%x CYCLES=%d \n",m68k.pc,REG_IR,CYC_INSTRUCTION(REG_IR));++ /* Execute instruction */+ m68ki_pair_handler[m68ki_opcode_pair[REG_IR]]();+ USE_CYCLES(CYC_INSTRUCTION(REG_IR));++ /* Trace m68k_exception, if necessary */+ m68ki_exception_if_trace(); /* auto-disable (see m68kcpu.h) */+ }+}++int m68k_cycles(void)+{+ return CYC_INSTRUCTION(REG_IR);+}++int m68k_cycles_run(void)+{+ return m68k.cycle_end - m68k.cycles;+}++int m68k_cycles_master(void)+{+ return m68k.cycles;+}++void m68k_init(void)+{+#ifdef BUILD_TABLES+ static uint emulation_initialized = 0;++ /* The first call to this function initializes the opcode handler jump table */+ if(!emulation_initialized)+ {+ m68ki_build_opcode_table();+ emulation_initialized = 1;+ }+#endif++#ifdef M68K_OVERCLOCK_SHIFT+ m68k.cycle_ratio = 1 << M68K_OVERCLOCK_SHIFT;+#endif++#if M68K_EMULATE_INT_ACK == OPT_ON+ m68k_set_int_ack_callback(NULL);+#endif+#if M68K_EMULATE_RESET == OPT_ON+ m68k_set_reset_instr_callback(NULL);+#endif+#if M68K_TAS_HAS_CALLBACK == OPT_ON+ m68k_set_tas_instr_callback(NULL);+#endif+#if M68K_EMULATE_FC == OPT_ON+ m68k_set_fc_callback(NULL);+#endif+}++/* Pulse the RESET line on the CPU */+void m68k_pulse_reset(void)+{+ /* Clear all stop levels */+ CPU_STOPPED = 0;+#if M68K_EMULATE_ADDRESS_ERROR+ CPU_RUN_MODE = RUN_MODE_BERR_AERR_RESET;+#endif++ /* Turn off tracing */+ FLAG_T1 = 0;+ m68ki_clear_trace()++ /* Interrupt mask to level 7 */+ FLAG_INT_MASK = 0x0700;+ CPU_INT_LEVEL = 0;+ irq_latency = 0;++ /* Go to supervisor mode */+ m68ki_set_s_flag(SFLAG_SET);++ /* Invalidate the prefetch queue */+#if M68K_EMULATE_PREFETCH+ /* Set to arbitrary number since our first fetch is from 0 */+ CPU_PREF_ADDR = 0x1000;+#endif /* M68K_EMULATE_PREFETCH */++ /* Read the initial stack pointer and program counter */+ m68ki_jump(0);+ REG_SP = m68ki_read_imm_32();+ REG_PC = m68ki_read_imm_32();+ m68ki_jump(REG_PC);++#if M68K_EMULATE_ADDRESS_ERROR+ CPU_RUN_MODE = RUN_MODE_NORMAL;+#endif++ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_RESET]);+}++void m68k_pulse_halt(void)+{+ /* Pulse the HALT line on the CPU */+ CPU_STOPPED |= STOP_LEVEL_HALT;+}++void m68k_clear_halt(void)+{+ /* Clear the HALT line on the CPU */+ CPU_STOPPED &= ~STOP_LEVEL_HALT;+}++void gwenesis_m68k_save_state() {+ SaveState *state;+ state = saveGwenesisStateOpenForWrite("m68k");++ saveGwenesisStateSetBuffer(state, "REG_D", REG_D, sizeof(REG_D));+ saveGwenesisStateSet(state, "SR", m68ki_get_sr());+ saveGwenesisStateSet(state, "REG_PC", REG_PC);+ saveGwenesisStateSet(state, "REG_SP", REG_SP);+ saveGwenesisStateSet(state, "REG_USP", REG_USP);+ saveGwenesisStateSet(state, "REG_ISP", REG_ISP);+ saveGwenesisStateSet(state, "REG_IR", REG_IR);++ saveGwenesisStateSet(state, "m68k_cycle_end", m68k.cycle_end);+ saveGwenesisStateSet(state, "m68k_cycles", m68k.cycles);+ saveGwenesisStateSet(state, "m68k_int_level", m68k.int_level);+ saveGwenesisStateSet(state, "m68k_stopped", m68k.stopped);+}++void gwenesis_m68k_load_state() {+ SaveState *state = saveGwenesisStateOpenForRead("m68k");+ saveGwenesisStateGetBuffer(state, "REG_D", REG_D, sizeof(REG_D));++ m68ki_set_sr(saveGwenesisStateGet(state, "SR"));+ REG_PC = saveGwenesisStateGet(state, "REG_PC");+ REG_SP = saveGwenesisStateGet(state, "REG_SP");+ REG_USP = saveGwenesisStateGet(state, "REG_USP");+ REG_ISP = saveGwenesisStateGet(state, "REG_ISP");+ REG_IR = saveGwenesisStateGet(state, "REG_IR");++ m68k.cycle_end = saveGwenesisStateGet(state, "m68k_cycle_end");+ m68k.cycles = saveGwenesisStateGet(state, "m68k_cycles");+ m68k.int_level = saveGwenesisStateGet(state, "m68k_int_level");+ m68k.stopped = saveGwenesisStateGet(state, "m68k_stopped");++}++/* ======================================================================== */+/* ============================== END OF FILE ============================= */+/* ======================================================================== */diff --git a/games/retrogo/src/md/m68kcpu.h b/games/retrogo/src/md/m68kcpu.hnew file mode 100644index 00000000..634e5004--- /dev/null+++ b/games/retrogo/src/md/m68kcpu.h@@ -0,0 +1,1505 @@+#ifndef M68KCPU__HEADER+#define M68KCPU__HEADER++/* ======================================================================== */+/* GENERIC 68K CORE */+/* ======================================================================== */++#include <stdio.h>+#include <stdlib.h>+#include <limits.h>++#if M68K_EMULATE_ADDRESS_ERROR+#include <setjmp.h>+#endif /* M68K_EMULATE_ADDRESS_ERROR */++#include "m68k.h"++/* ======================================================================== */+/* ============================ GENERAL DEFINES =========================== */+/* ======================================================================== */++/* Exception Vectors handled by emulation */+#define EXCEPTION_RESET 0+#define EXCEPTION_BUS_ERROR 2 /* This one is not emulated! */+#define EXCEPTION_ADDRESS_ERROR 3 /* This one is partially emulated (doesn't stack a proper frame yet) */+#define EXCEPTION_ILLEGAL_INSTRUCTION 4+#define EXCEPTION_ZERO_DIVIDE 5+#define EXCEPTION_CHK 6+#define EXCEPTION_TRAPV 7+#define EXCEPTION_PRIVILEGE_VIOLATION 8+#define EXCEPTION_TRACE 9+#define EXCEPTION_1010 10+#define EXCEPTION_1111 11+#define EXCEPTION_FORMAT_ERROR 14+#define EXCEPTION_UNINITIALIZED_INTERRUPT 15+#define EXCEPTION_SPURIOUS_INTERRUPT 24+#define EXCEPTION_INTERRUPT_AUTOVECTOR 24+#define EXCEPTION_TRAP_BASE 32++/* Function codes set by CPU during data/address bus activity */+#define FUNCTION_CODE_USER_DATA 1+#define FUNCTION_CODE_USER_PROGRAM 2+#define FUNCTION_CODE_SUPERVISOR_DATA 5+#define FUNCTION_CODE_SUPERVISOR_PROGRAM 6+#define FUNCTION_CODE_CPU_SPACE 7++/* Different ways to stop the CPU */+#define STOP_LEVEL_STOP 1+#define STOP_LEVEL_HALT 2++/* Used for 68000 address error processing */+#if M68K_EMULATE_ADDRESS_ERROR+#define INSTRUCTION_YES 0+#define INSTRUCTION_NO 0x08+#define MODE_READ 0x10+#define MODE_WRITE 0++#define RUN_MODE_NORMAL 0+#define RUN_MODE_BERR_AERR_RESET 1+#endif++#ifndef NULL+#define NULL ((void*)0)+#endif++/* ======================================================================== */+/* ================================ MACROS ================================ */+/* ======================================================================== */+++/* ---------------------------- General Macros ---------------------------- */++/* Bit Isolation Macros */+#define BIT_0(A) ((A) & 0x00000001)+#define BIT_1(A) ((A) & 0x00000002)+#define BIT_2(A) ((A) & 0x00000004)+#define BIT_3(A) ((A) & 0x00000008)+#define BIT_4(A) ((A) & 0x00000010)+#define BIT_5(A) ((A) & 0x00000020)+#define BIT_6(A) ((A) & 0x00000040)+#define BIT_7(A) ((A) & 0x00000080)+#define BIT_8(A) ((A) & 0x00000100)+#define BIT_9(A) ((A) & 0x00000200)+#define BIT_A(A) ((A) & 0x00000400)+#define BIT_B(A) ((A) & 0x00000800)+#define BIT_C(A) ((A) & 0x00001000)+#define BIT_D(A) ((A) & 0x00002000)+#define BIT_E(A) ((A) & 0x00004000)+#define BIT_F(A) ((A) & 0x00008000)+#define BIT_10(A) ((A) & 0x00010000)+#define BIT_11(A) ((A) & 0x00020000)+#define BIT_12(A) ((A) & 0x00040000)+#define BIT_13(A) ((A) & 0x00080000)+#define BIT_14(A) ((A) & 0x00100000)+#define BIT_15(A) ((A) & 0x00200000)+#define BIT_16(A) ((A) & 0x00400000)+#define BIT_17(A) ((A) & 0x00800000)+#define BIT_18(A) ((A) & 0x01000000)+#define BIT_19(A) ((A) & 0x02000000)+#define BIT_1A(A) ((A) & 0x04000000)+#define BIT_1B(A) ((A) & 0x08000000)+#define BIT_1C(A) ((A) & 0x10000000)+#define BIT_1D(A) ((A) & 0x20000000)+#define BIT_1E(A) ((A) & 0x40000000)+#define BIT_1F(A) ((A) & 0x80000000)++/* Get the most significant bit for specific sizes */+#define GET_MSB_8(A) ((A) & 0x80)+#define GET_MSB_9(A) ((A) & 0x100)+#define GET_MSB_16(A) ((A) & 0x8000)+#define GET_MSB_17(A) ((A) & 0x10000)+#define GET_MSB_32(A) ((A) & 0x80000000)+#if M68K_USE_64_BIT+#define GET_MSB_33(A) ((A) & 0x100000000)+#endif /* M68K_USE_64_BIT */++/* Isolate nibbles */+#define LOW_NIBBLE(A) ((A) & 0x0f)+#define HIGH_NIBBLE(A) ((A) & 0xf0)++/* These are used to isolate 8, 16, and 32 bit sizes */+#define MASK_OUT_ABOVE_2(A) ((A) & 3)+#define MASK_OUT_ABOVE_8(A) ((A) & 0xff)+#define MASK_OUT_ABOVE_16(A) ((A) & 0xffff)+#define MASK_OUT_BELOW_2(A) ((A) & ~3)+#define MASK_OUT_BELOW_8(A) ((A) & ~0xff)+#define MASK_OUT_BELOW_16(A) ((A) & ~0xffff)++/* No need to mask if we are 32 bit */+#if M68K_INT_GT_32_BIT || M68K_USE_64_BIT+ #define MASK_OUT_ABOVE_32(A) ((A) & 0xffffffff)+ #define MASK_OUT_BELOW_32(A) ((A) & ~0xffffffff)+#else+ #define MASK_OUT_ABOVE_32(A) (A)+ #define MASK_OUT_BELOW_32(A) 0+#endif /* M68K_INT_GT_32_BIT || M68K_USE_64_BIT */++/* Simulate address lines of 68k family */+#define ADDRESS_68K(A) ((A)&CPU_ADDRESS_MASK)+++/* Shift & Rotate Macros. */+#define LSL(A, C) ((A) << (C))+#define LSR(A, C) ((A) >> (C))++/* Some > 32-bit optimizations */+#if M68K_INT_GT_32_BIT+ /* Shift left and right */+ #define LSR_32(A, C) ((A) >> (C))+ #define LSL_32(A, C) ((A) << (C))+#else+ /* We have to do this because the morons at ANSI decided that shifts+ * by >= data size are undefined.+ */+ #define LSR_32(A, C) ((C) < 32 ? (A) >> (C) : 0)+ #define LSL_32(A, C) ((C) < 32 ? (A) << (C) : 0)+#endif /* M68K_INT_GT_32_BIT */++#if M68K_USE_64_BIT+ #define LSL_32_64(A, C) ((A) << (C))+ #define LSR_32_64(A, C) ((A) >> (C))+ #define ROL_33_64(A, C) (LSL_32_64(A, C) | LSR_32_64(A, 33-(C)))+ #define ROR_33_64(A, C) (LSR_32_64(A, C) | LSL_32_64(A, 33-(C)))+#endif /* M68K_USE_64_BIT */++#define ROL_8(A, C) MASK_OUT_ABOVE_8(LSL(A, C) | LSR(A, 8-(C)))+#define ROL_9(A, C) (LSL(A, C) | LSR(A, 9-(C)))+#define ROL_16(A, C) MASK_OUT_ABOVE_16(LSL(A, C) | LSR(A, 16-(C)))+#define ROL_17(A, C) (LSL(A, C) | LSR(A, 17-(C)))+#define ROL_32(A, C) MASK_OUT_ABOVE_32(LSL_32(A, C) | LSR_32(A, 32-(C)))+#define ROL_33(A, C) (LSL_32(A, C) | LSR_32(A, 33-(C)))++#define ROR_8(A, C) MASK_OUT_ABOVE_8(LSR(A, C) | LSL(A, 8-(C)))+#define ROR_9(A, C) (LSR(A, C) | LSL(A, 9-(C)))+#define ROR_16(A, C) MASK_OUT_ABOVE_16(LSR(A, C) | LSL(A, 16-(C)))+#define ROR_17(A, C) (LSR(A, C) | LSL(A, 17-(C)))+#define ROR_32(A, C) MASK_OUT_ABOVE_32(LSR_32(A, C) | LSL_32(A, 32-(C)))+#define ROR_33(A, C) (LSR_32(A, C) | LSL_32(A, 33-(C)))++++/* ------------------------------ CPU Access ------------------------------ */++/* Access the CPU registers */+#define REG_DA m68ki_cpu.dar /* easy access to data and address regs */+#define REG_D m68ki_cpu.dar+#define REG_A (m68ki_cpu.dar+8)+#define REG_PC m68ki_cpu.pc+#define REG_SP_BASE m68ki_cpu.sp+#define REG_USP m68ki_cpu.sp[0]+#define REG_ISP m68ki_cpu.sp[4]+#define REG_SP m68ki_cpu.dar[15]+#define REG_IR m68ki_cpu.ir++#define FLAG_T1 m68ki_cpu.t1_flag+#define FLAG_S m68ki_cpu.s_flag+#define FLAG_X m68ki_cpu.x_flag+#define FLAG_N m68ki_cpu.n_flag+#define FLAG_Z m68ki_cpu.not_z_flag+#define FLAG_V m68ki_cpu.v_flag+#define FLAG_C m68ki_cpu.c_flag+#define FLAG_INT_MASK m68ki_cpu.int_mask++#define CPU_INT_LEVEL m68ki_cpu.int_level /* ASG: changed from CPU_INTS_PENDING */+#define CPU_STOPPED m68ki_cpu.stopped+#if M68K_EMULATE_PREFETCH+#define CPU_PREF_ADDR m68ki_cpu.pref_addr+#define CPU_PREF_DATA m68ki_cpu.pref_data+#endif+#define CPU_ADDRESS_MASK 0x00ffffff+#if M68K_EMULATE_ADDRESS_ERROR+#define CPU_INSTR_MODE m68ki_cpu.instr_mode+#define CPU_RUN_MODE m68ki_cpu.run_mode+#endif++#define CYC_INSTRUCTION(ir) (m68ki_pair_cycles[m68ki_opcode_pair[ir]])+#define CYC_EXCEPTION m68ki_exception_cycle_table+#define CYC_BCC_NOTAKE_B ( -2 * MUL)+#define CYC_BCC_NOTAKE_W ( 2 * MUL)+#define CYC_DBCC_F_NOEXP ( -2 * MUL)+#define CYC_DBCC_F_EXP ( 2 * MUL)+#define CYC_SCC_R_TRUE ( 2 * MUL)+#define CYC_MOVEM_W ( 4 * MUL)+#define CYC_MOVEM_L ( 8 * MUL)+#define CYC_SHIFT ( 2 * MUL)+#define CYC_RESET (132 * MUL)++#if M68K_EMULATE_INT_ACK == OPT_ON+#define CALLBACK_INT_ACK m68ki_cpu.int_ack_callback+#endif+#if M68K_EMULATE_RESET == OPT_ON+#define CALLBACK_RESET_INSTR m68ki_cpu.reset_instr_callback+#endif+#if M68K_TAS_HAS_CALLBACK == OPT_ON+#define CALLBACK_TAS_INSTR m68ki_cpu.tas_instr_callback+#endif+#if M68K_EMULATE_FC == OPT_ON+#define CALLBACK_SET_FC m68ki_cpu.set_fc_callback+#endif+++/* ----------------------------- Configuration ---------------------------- */++/* These defines are dependant on the configuration defines in m68kconf.h */++/* Enable or disable callback functions */+#if M68K_EMULATE_INT_ACK+ #if M68K_EMULATE_INT_ACK == OPT_SPECIFY_HANDLER+ #define m68ki_int_ack(A) M68K_INT_ACK_CALLBACK(A);+ #else+ #define m68ki_int_ack(A) CALLBACK_INT_ACK(A);+ #endif+#else+ /* Default action is to used autovector mode, which is most common */+ #define m68ki_int_ack(A) M68K_INT_ACK_AUTOVECTOR+#endif /* M68K_EMULATE_INT_ACK */++#if M68K_EMULATE_RESET+ #if M68K_EMULATE_RESET == OPT_SPECIFY_HANDLER+ #define m68ki_output_reset() M68K_RESET_CALLBACK();+ #else+ #define m68ki_output_reset() CALLBACK_RESET_INSTR();+ #endif+#else+ #define m68ki_output_reset()+#endif /* M68K_EMULATE_RESET */++#if M68K_TAS_HAS_CALLBACK+ #if M68K_TAS_HAS_CALLBACK == OPT_SPECIFY_HANDLER+ #define m68ki_tas_callback() M68K_TAS_CALLBACK()+ #else+ #define m68ki_tas_callback() CALLBACK_TAS_INSTR()+ #endif+#else+ #define m68ki_tas_callback() 0+#endif /* M68K_TAS_HAS_CALLBACK */+++/* Enable or disable function code emulation */+#if M68K_EMULATE_FC+ #if M68K_EMULATE_FC == OPT_SPECIFY_HANDLER+ #define m68ki_set_fc(A) M68K_SET_FC_CALLBACK(A);+ #else+ #define m68ki_set_fc(A) CALLBACK_SET_FC(A);+ #endif+ #define m68ki_use_data_space() m68ki_cpu.address_space = FUNCTION_CODE_USER_DATA;+ #define m68ki_use_program_space() m68ki_cpu.address_space = FUNCTION_CODE_USER_PROGRAM;+ #define m68ki_get_address_space() m68ki_cpu.address_space+#else+ #define m68ki_set_fc(A)+ #define m68ki_use_data_space()+ #define m68ki_use_program_space()+ #define m68ki_get_address_space() FUNCTION_CODE_USER_DATA+#endif /* M68K_EMULATE_FC */+++/* Enable or disable trace emulation */+#if M68K_EMULATE_TRACE+ /* Initiates trace checking before each instruction (t1) */+ #define m68ki_trace_t1() m68ki_cpu.tracing = FLAG_T1;+ /* Clear all tracing */+ #define m68ki_clear_trace() m68ki_cpu.tracing = 0;+ /* Cause a trace exception if we are tracing */+ #define m68ki_exception_if_trace() if(m68ki_cpu.tracing) m68ki_exception_trace();+#else+ #define m68ki_trace_t1()+ #define m68ki_clear_trace()+ #define m68ki_exception_if_trace()+#endif /* M68K_EMULATE_TRACE */+++/* Enable or disable Address error emulation */+#if M68K_EMULATE_ADDRESS_ERROR+ #define m68ki_set_address_error_trap() \+ if(setjmp(m68ki_cpu.aerr_trap) != 0) \+ { \+ m68ki_exception_address_error(); \+ }++ #define m68ki_check_address_error(ADDR, WRITE_MODE, FC) \+ if((ADDR)&1) \+ { \+ if (m68ki_cpu.aerr_enabled) \+ { \+ m68ki_cpu.aerr_address = ADDR; \+ m68ki_cpu.aerr_write_mode = WRITE_MODE; \+ m68ki_cpu.aerr_fc = FC; \+ longjmp(m68ki_cpu.aerr_trap, 1); \+ } \+ }+#else+ #define m68ki_set_address_error_trap()+ #define m68ki_check_address_error(ADDR, WRITE_MODE, FC)+#endif /* M68K_ADDRESS_ERROR */+++/* -------------------------- EA / Operand Access ------------------------- */++/*+ * The general instruction format follows this pattern:+ * .... XXX. .... .YYY+ * where XXX is register X and YYY is register Y+ */++/* Data Register Isolation */+#define DX (REG_D[(REG_IR >> 9) & 7])+#define DY (REG_D[REG_IR & 7])++/* Address Register Isolation */+#define AX (REG_A[(REG_IR >> 9) & 7])+#define AY (REG_A[REG_IR & 7])++/* Effective Address Calculations */+#define EA_AY_AI_8() AY /* address register indirect */+#define EA_AY_AI_16() EA_AY_AI_8()+#define EA_AY_AI_32() EA_AY_AI_8()+#define EA_AY_PI_8() (AY++) /* postincrement (size = byte) */+#define EA_AY_PI_16() ((AY+=2)-2) /* postincrement (size = word) */+#define EA_AY_PI_32() ((AY+=4)-4) /* postincrement (size = long) */+#define EA_AY_PD_8() (--AY) /* predecrement (size = byte) */+#define EA_AY_PD_16() (AY-=2) /* predecrement (size = word) */+#define EA_AY_PD_32() (AY-=4) /* predecrement (size = long) */+#define EA_AY_DI_8() (AY+MAKE_INT_16(m68ki_read_imm_16())) /* displacement */+#define EA_AY_DI_16() EA_AY_DI_8()+#define EA_AY_DI_32() EA_AY_DI_8()+#define EA_AY_IX_8() m68ki_get_ea_ix(AY) /* indirect + index */+#define EA_AY_IX_16() EA_AY_IX_8()+#define EA_AY_IX_32() EA_AY_IX_8()++#define EA_AX_AI_8() AX+#define EA_AX_AI_16() EA_AX_AI_8()+#define EA_AX_AI_32() EA_AX_AI_8()+#define EA_AX_PI_8() (AX++)+#define EA_AX_PI_16() ((AX+=2)-2)+#define EA_AX_PI_32() ((AX+=4)-4)+#define EA_AX_PD_8() (--AX)+#define EA_AX_PD_16() (AX-=2)+#define EA_AX_PD_32() (AX-=4)+#define EA_AX_DI_8() (AX+MAKE_INT_16(m68ki_read_imm_16()))+#define EA_AX_DI_16() EA_AX_DI_8()+#define EA_AX_DI_32() EA_AX_DI_8()+#define EA_AX_IX_8() m68ki_get_ea_ix(AX)+#define EA_AX_IX_16() EA_AX_IX_8()+#define EA_AX_IX_32() EA_AX_IX_8()++#define EA_A7_PI_8() ((REG_A[7]+=2)-2)+#define EA_A7_PD_8() (REG_A[7]-=2)++#define EA_AW_8() MAKE_INT_16(m68ki_read_imm_16()) /* absolute word */+#define EA_AW_16() EA_AW_8()+#define EA_AW_32() EA_AW_8()+#define EA_AL_8() m68ki_read_imm_32() /* absolute long */+#define EA_AL_16() EA_AL_8()+#define EA_AL_32() EA_AL_8()+#define EA_PCDI_8() m68ki_get_ea_pcdi() /* pc indirect + displacement */+#define EA_PCDI_16() EA_PCDI_8()+#define EA_PCDI_32() EA_PCDI_8()+#define EA_PCIX_8() m68ki_get_ea_pcix() /* pc indirect + index */+#define EA_PCIX_16() EA_PCIX_8()+#define EA_PCIX_32() EA_PCIX_8()+++#define OPER_I_8() m68ki_read_imm_8()+#define OPER_I_16() m68ki_read_imm_16()+#define OPER_I_32() m68ki_read_imm_32()+++/* --------------------------- Status Register ---------------------------- */++/* Flag Calculation Macros */+#define CFLAG_8(A) (A)+#define CFLAG_16(A) ((A)>>8)++#if M68K_INT_GT_32_BIT+ #define CFLAG_ADD_32(S, D, R) ((R)>>24)+ #define CFLAG_SUB_32(S, D, R) ((R)>>24)+#else+ #define CFLAG_ADD_32(S, D, R) (((S & D) | (~R & (S | D)))>>23)+ #define CFLAG_SUB_32(S, D, R) (((S & R) | (~D & (S | R)))>>23)+#endif /* M68K_INT_GT_32_BIT */++#define VFLAG_ADD_8(S, D, R) ((S^R) & (D^R))+#define VFLAG_ADD_16(S, D, R) (((S^R) & (D^R))>>8)+#define VFLAG_ADD_32(S, D, R) (((S^R) & (D^R))>>24)++#define VFLAG_SUB_8(S, D, R) ((S^D) & (R^D))+#define VFLAG_SUB_16(S, D, R) (((S^D) & (R^D))>>8)+#define VFLAG_SUB_32(S, D, R) (((S^D) & (R^D))>>24)++#define NFLAG_8(A) (A)+#define NFLAG_16(A) ((A)>>8)+#define NFLAG_32(A) ((A)>>24)+#define NFLAG_64(A) ((A)>>56)++#define ZFLAG_8(A) MASK_OUT_ABOVE_8(A)+#define ZFLAG_16(A) MASK_OUT_ABOVE_16(A)+#define ZFLAG_32(A) MASK_OUT_ABOVE_32(A)+++/* Flag values */+#define NFLAG_SET 0x80+#define NFLAG_CLEAR 0+#define CFLAG_SET 0x100+#define CFLAG_CLEAR 0+#define XFLAG_SET 0x100+#define XFLAG_CLEAR 0+#define VFLAG_SET 0x80+#define VFLAG_CLEAR 0+#define ZFLAG_SET 0+#define ZFLAG_CLEAR 0xffffffff+#define SFLAG_SET 4+#define SFLAG_CLEAR 0++/* Turn flag values into 1 or 0 */+#define XFLAG_AS_1() ((FLAG_X>>8)&1)+#define NFLAG_AS_1() ((FLAG_N>>7)&1)+#define VFLAG_AS_1() ((FLAG_V>>7)&1)+#define ZFLAG_AS_1() (!FLAG_Z)+#define CFLAG_AS_1() ((FLAG_C>>8)&1)+++/* Conditions */+#define COND_CS() (FLAG_C&0x100)+#define COND_CC() (!COND_CS())+#define COND_VS() (FLAG_V&0x80)+#define COND_VC() (!COND_VS())+#define COND_NE() FLAG_Z+#define COND_EQ() (!COND_NE())+#define COND_MI() (FLAG_N&0x80)+#define COND_PL() (!COND_MI())+#define COND_LT() ((FLAG_N^FLAG_V)&0x80)+#define COND_GE() (!COND_LT())+#define COND_HI() (COND_CC() && COND_NE())+#define COND_LS() (COND_CS() || COND_EQ())+#define COND_GT() (COND_GE() && COND_NE())+#define COND_LE() (COND_LT() || COND_EQ())++/* Reversed conditions */+#define COND_NOT_CS() COND_CC()+#define COND_NOT_CC() COND_CS()+#define COND_NOT_VS() COND_VC()+#define COND_NOT_VC() COND_VS()+#define COND_NOT_NE() COND_EQ()+#define COND_NOT_EQ() COND_NE()+#define COND_NOT_MI() COND_PL()+#define COND_NOT_PL() COND_MI()+#define COND_NOT_LT() COND_GE()+#define COND_NOT_GE() COND_LT()+#define COND_NOT_HI() COND_LS()+#define COND_NOT_LS() COND_HI()+#define COND_NOT_GT() COND_LE()+#define COND_NOT_LE() COND_GT()++/* Not real conditions, but here for convenience */+#define COND_XS() (FLAG_X&0x100)+#define COND_XC() (!COND_XS)+++/* Get the condition code register */+#define m68ki_get_ccr() ((COND_XS() >> 4) | \+ (COND_MI() >> 4) | \+ (COND_EQ() << 2) | \+ (COND_VS() >> 6) | \+ (COND_CS() >> 8))++/* Get the status register */+#define m68ki_get_sr() ( FLAG_T1 | \+ (FLAG_S << 11) | \+ FLAG_INT_MASK | \+ m68ki_get_ccr())++++/* ---------------------------- Cycle Counting ---------------------------- */++#ifdef M68K_OVERCLOCK_SHIFT+#define USE_CYCLES(A) m68ki_cpu.cycles += ((A) * m68ki_cpu.cycle_ratio) >> M68K_OVERCLOCK_SHIFT+#else+#define USE_CYCLES(A) m68ki_cpu.cycles += (A)+#endif+#define SET_CYCLES(A) m68ki_cpu.cycles = (A)+++/* ======================================================================== */+/* =========================== UTILITY FUNCTIONS ========================== */+/* ======================================================================== */++void gwenesis_m68k_save_state();+void gwenesis_m68k_load_state();++/* ----------------------------- Read / Write ----------------------------- */++/*** BZHXX ***/+/* Read data immediately following the PC */+//#define m68k_read_immediate_16(address) *(uint16 *)(m68ki_cpu.memory_map[((address)>>16)&0xff].base + ((address) & 0xffff))+//#define m68k_read_immediate_32(address) (m68k_read_immediate_16(address) << 16) | (m68k_read_immediate_16(address+2))++/* Read data relative to the PC */+//#define m68k_read_pcrelative_8(address) READ_BYTE(m68ki_cpu.memory_map[((address)>>16)&0xff].base, (address) & 0xffff)+//#define m68k_read_pcrelative_16(address) m68k_read_immediate_16(address)+//#define m68k_read_pcrelative_32(address) m68k_read_immediate_32(address)++/* map read immediate 8 to read immediate 16 */+#define m68ki_read_imm_8() MASK_OUT_ABOVE_8(m68ki_read_imm_16())++/* Map PC-relative reads */+#define m68ki_read_pcrel_8(A) m68k_read_pcrelative_8(A)+#define m68ki_read_pcrel_16(A) m68k_read_pcrelative_16(A)+#define m68ki_read_pcrel_32(A) m68k_read_pcrelative_32(A)+++/* ======================================================================== */+/* =============================== PROTOTYPES ============================= */+/* ======================================================================== */++/* Used by shift & rotate instructions */+static const uint8 m68ki_shift_8_table[65] =+{+ 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xff, 0xff, 0xff,+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,+ 0xff, 0xff, 0xff, 0xff, 0xff+};++static const uint16 m68ki_shift_16_table[65] =+{+ 0x0000, 0x8000, 0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00,+ 0xff80, 0xffc0, 0xffe0, 0xfff0, 0xfff8, 0xfffc, 0xfffe, 0xffff, 0xffff,+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,+ 0xffff, 0xffff+};++static const uint m68ki_shift_32_table[65] =+{+ 0x00000000, 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 0xf8000000,+ 0xfc000000, 0xfe000000, 0xff000000, 0xff800000, 0xffc00000, 0xffe00000,+ 0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, 0xffff8000,+ 0xffffc000, 0xffffe000, 0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,+ 0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, 0xfffffff8,+ 0xfffffffc, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff+};+++/* Number of clock cycles to use for exception processing.+ * I used 4 for any vectors that are undocumented for processing times.+ */+static const uint16 m68ki_exception_cycle_table[256] =+{+ 40*MUL, /* 0: Reset - Initial Stack Pointer */+ 4*MUL, /* 1: Reset - Initial Program Counter */+ 50*MUL, /* 2: Bus Error (unemulated) */+ 50*MUL, /* 3: Address Error (unemulated) */+ 34*MUL, /* 4: Illegal Instruction */+ 38*MUL, /* 5: Divide by Zero -- ASG: changed from 42 */+ 40*MUL, /* 6: CHK -- ASG: chanaged from 44 */+ 34*MUL, /* 7: TRAPV */+ 34*MUL, /* 8: Privilege Violation */+ 34*MUL, /* 9: Trace */+ 4*MUL, /* 10: 1010 */+ 4*MUL, /* 11: 1111 */+ 4*MUL, /* 12: RESERVED */+ 4*MUL, /* 13: Coprocessor Protocol Violation (unemulated) */+ 4*MUL, /* 14: Format Error */+ 44*MUL, /* 15: Uninitialized Interrupt */+ 4*MUL, /* 16: RESERVED */+ 4*MUL, /* 17: RESERVED */+ 4*MUL, /* 18: RESERVED */+ 4*MUL, /* 19: RESERVED */+ 4*MUL, /* 20: RESERVED */+ 4*MUL, /* 21: RESERVED */+ 4*MUL, /* 22: RESERVED */+ 4*MUL, /* 23: RESERVED */+ 44*MUL, /* 24: Spurious Interrupt */+ 54*MUL, /* 25: Level 1 Interrupt Autovector */+ 54*MUL, /* 26: Level 2 Interrupt Autovector */+ 54*MUL, /* 27: Level 3 Interrupt Autovector */+ 54*MUL, /* 28: Level 4 Interrupt Autovector */+ 54*MUL, /* 29: Level 5 Interrupt Autovector */+ 54*MUL, /* 30: Level 6 Interrupt Autovector */+ 54*MUL, /* 31: Level 7 Interrupt Autovector */+ 34*MUL, /* 32: TRAP #0 -- ASG: chanaged from 38 */+ 34*MUL, /* 33: TRAP #1 */+ 34*MUL, /* 34: TRAP #2 */+ 34*MUL, /* 35: TRAP #3 */+ 34*MUL, /* 36: TRAP #4 */+ 34*MUL, /* 37: TRAP #5 */+ 34*MUL, /* 38: TRAP #6 */+ 34*MUL, /* 39: TRAP #7 */+ 34*MUL, /* 40: TRAP #8 */+ 34*MUL, /* 41: TRAP #9 */+ 34*MUL, /* 42: TRAP #10 */+ 34*MUL, /* 43: TRAP #11 */+ 34*MUL, /* 44: TRAP #12 */+ 34*MUL, /* 45: TRAP #13 */+ 34*MUL, /* 46: TRAP #14 */+ 34*MUL, /* 47: TRAP #15 */+ 4*MUL, /* 48: FP Branch or Set on Unknown Condition (unemulated) */+ 4*MUL, /* 49: FP Inexact Result (unemulated) */+ 4*MUL, /* 50: FP Divide by Zero (unemulated) */+ 4*MUL, /* 51: FP Underflow (unemulated) */+ 4*MUL, /* 52: FP Operand Error (unemulated) */+ 4*MUL, /* 53: FP Overflow (unemulated) */+ 4*MUL, /* 54: FP Signaling NAN (unemulated) */+ 4*MUL, /* 55: FP Unimplemented Data Type (unemulated) */+ 4*MUL, /* 56: MMU Configuration Error (unemulated) */+ 4*MUL, /* 57: MMU Illegal Operation Error (unemulated) */+ 4*MUL, /* 58: MMU Access Level Violation Error (unemulated) */+ 4*MUL, /* 59: RESERVED */+ 4*MUL, /* 60: RESERVED */+ 4*MUL, /* 61: RESERVED */+ 4*MUL, /* 62: RESERVED */+ 4*MUL, /* 63: RESERVED */+ /* 64-255: User Defined */+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL+};++/* Read data immediately after the program counter */+INLINE uint m68ki_read_imm_16(void);+INLINE uint m68ki_read_imm_32(void);++/* Read from the current address space */+INLINE uint m68ki_read_8(uint address);+INLINE uint m68ki_read_16(uint address);+INLINE uint m68ki_read_32(uint address);++/* Write to the current data space */+INLINE void m68ki_write_8(uint address, uint value);+INLINE void m68ki_write_16(uint address, uint value);+INLINE void m68ki_write_32(uint address, uint value);++/* Indexed and PC-relative ea fetching */+INLINE uint m68ki_get_ea_pcdi(void);+INLINE uint m68ki_get_ea_pcix(void);+INLINE uint m68ki_get_ea_ix(uint An);++/* Operand fetching */+INLINE uint OPER_AY_AI_8(void);+INLINE uint OPER_AY_AI_16(void);+INLINE uint OPER_AY_AI_32(void);+INLINE uint OPER_AY_PI_8(void);+INLINE uint OPER_AY_PI_16(void);+INLINE uint OPER_AY_PI_32(void);+INLINE uint OPER_AY_PD_8(void);+INLINE uint OPER_AY_PD_16(void);+INLINE uint OPER_AY_PD_32(void);+INLINE uint OPER_AY_DI_8(void);+INLINE uint OPER_AY_DI_16(void);+INLINE uint OPER_AY_DI_32(void);+INLINE uint OPER_AY_IX_8(void);+INLINE uint OPER_AY_IX_16(void);+INLINE uint OPER_AY_IX_32(void);++INLINE uint OPER_AX_AI_8(void);+INLINE uint OPER_AX_AI_16(void);+INLINE uint OPER_AX_AI_32(void);+INLINE uint OPER_AX_PI_8(void);+INLINE uint OPER_AX_PI_16(void);+INLINE uint OPER_AX_PI_32(void);+INLINE uint OPER_AX_PD_8(void);+INLINE uint OPER_AX_PD_16(void);+INLINE uint OPER_AX_PD_32(void);+INLINE uint OPER_AX_DI_8(void);+INLINE uint OPER_AX_DI_16(void);+INLINE uint OPER_AX_DI_32(void);+INLINE uint OPER_AX_IX_8(void);+INLINE uint OPER_AX_IX_16(void);+INLINE uint OPER_AX_IX_32(void);++INLINE uint OPER_A7_PI_8(void);+INLINE uint OPER_A7_PD_8(void);++INLINE uint OPER_AW_8(void);+INLINE uint OPER_AW_16(void);+INLINE uint OPER_AW_32(void);+INLINE uint OPER_AL_8(void);+INLINE uint OPER_AL_16(void);+INLINE uint OPER_AL_32(void);+INLINE uint OPER_PCDI_8(void);+INLINE uint OPER_PCDI_16(void);+INLINE uint OPER_PCDI_32(void);+INLINE uint OPER_PCIX_8(void);+INLINE uint OPER_PCIX_16(void);+INLINE uint OPER_PCIX_32(void);++/* Stack operations */+INLINE void m68ki_push_16(uint value);+INLINE void m68ki_push_32(uint value);+INLINE uint m68ki_pull_16(void);+INLINE uint m68ki_pull_32(void);++/* Program flow operations */+INLINE void m68ki_jump(uint new_pc);+INLINE void m68ki_jump_vector(uint vector);+INLINE void m68ki_branch_8(uint offset);+INLINE void m68ki_branch_16(uint offset);+INLINE void m68ki_branch_32(uint offset);++/* Status register operations. */+INLINE void m68ki_set_s_flag(uint value); /* Only bit 2 of value should be set (i.e. 4 or 0) */+INLINE void m68ki_set_ccr(uint value); /* set the condition code register */+INLINE void m68ki_set_sr(uint value); /* set the status register */++/* Exception processing */+INLINE uint m68ki_init_exception(void); /* Initial exception processing */+INLINE void m68ki_stack_frame_3word(uint pc, uint sr); /* Stack various frame types */+#if M68K_EMULATE_ADDRESS_ERROR+INLINE void m68ki_stack_frame_buserr(uint sr);+#endif+INLINE void m68ki_exception_trap(uint vector);+INLINE void m68ki_exception_trapN(uint vector);+#if M68K_EMULATE_TRACE+INLINE void m68ki_exception_trace(void);+#endif+static void m68ki_exception_privilege_violation(void); /* do not inline in order to reduce function size and allow inlining of read/write functions by the compile */+INLINE void m68ki_exception_1010(void);+INLINE void m68ki_exception_1111(void);+INLINE void m68ki_exception_illegal(void);+#if M68K_EMULATE_ADDRESS_ERROR+INLINE void m68ki_exception_address_error(void);+#endif+INLINE void m68ki_exception_interrupt(uint int_level);+INLINE void m68ki_check_interrupts(void); /* ASG: check for interrupts */++/* ======================================================================== */+/* =========================== UTILITY FUNCTIONS ========================== */+/* ======================================================================== */+++/* ---------------------------- Read Immediate ---------------------------- */++/* Handles all immediate reads, does address error check, function code setting,+ * and prefetching if they are enabled in m68kconf.h+ */+INLINE uint m68ki_read_imm_16(void)+{+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */+#if M68K_CHECK_PC_ADDRESS_ERROR+ m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */+#endif+#if M68K_EMULATE_PREFETCH+ if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)+ {+ CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);+ CPU_PREF_DATA = m68k_read_immediate_32(CPU_PREF_ADDR);+ }+ REG_PC += 2;+ return MASK_OUT_ABOVE_16(CPU_PREF_DATA >> ((2-((REG_PC-2)&2))<<3));+#else+ uint pc = REG_PC;+ REG_PC += 2;+ return m68k_read_immediate_16(pc);+#endif /* M68K_EMULATE_PREFETCH */+}++INLINE uint m68ki_read_imm_32(void)+{+#if M68K_EMULATE_PREFETCH+ uint temp_val;++ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */+#if M68K_CHECK_PC_ADDRESS_ERROR+ m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */+#endif+ if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)+ {+ CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);+ CPU_PREF_DATA = m68k_read_immediate_32(CPU_PREF_ADDR);+ }+ temp_val = CPU_PREF_DATA;+ REG_PC += 2;+ if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)+ {+ CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);+ CPU_PREF_DATA = m68k_read_immediate_32(CPU_PREF_ADDR);+ temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | (CPU_PREF_DATA >> 16));+ }+ REG_PC += 2;++ return temp_val;+#else+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */+#if M68K_CHECK_PC_ADDRESS_ERROR+ m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */+#endif+ uint pc = REG_PC;+ REG_PC += 4;+ return m68k_read_immediate_32(pc);+#endif /* M68K_EMULATE_PREFETCH */+}++++/* ------------------------- Top level read/write ------------------------- */++/* Handles all memory accesses (except for immediate reads if they are+ * configured to use separate functions in m68kconf.h).+ * All memory accesses must go through these top level functions.+ * These functions will also check for address error and set the function+ * code if they are enabled in m68kconf.h.+ */+ /*** BZHXX ***/++INLINE uint m68ki_read_8(uint address)+{++ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */++ if (ADDRESS_68K(address) < 0x800000) return FETCH8ROM(ADDRESS_68K(address));+ if (ADDRESS_68K(address) >= 0xFF0000) return FETCH8RAM(ADDRESS_68K(address));+ return m68k_read_memory_8(ADDRESS_68K(address));++}++INLINE uint m68ki_read_16(uint address)+{++ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */++ if (ADDRESS_68K(address) < 0x800000) return FETCH16ROM(ADDRESS_68K(address));+ if (ADDRESS_68K(address) >= 0xFF0000) return FETCH16RAM(ADDRESS_68K(address));+ return m68k_read_memory_16(ADDRESS_68K(address));++}++INLINE uint m68ki_read_32(uint address)+{++ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */+ if (ADDRESS_68K(address) < 0x800000) return FETCH32ROM(ADDRESS_68K(address));+ if (ADDRESS_68K(address) >= 0xFF0000) return FETCH32RAM(ADDRESS_68K(address));+ return m68k_read_memory_32(ADDRESS_68K(address));+}++INLINE void m68ki_write_8(uint address, uint value)+{++ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */+ if (ADDRESS_68K(address) >= 0xFF0000) {+ WRITE8RAM(ADDRESS_68K(address), value);+ } else+ m68k_write_memory_8(ADDRESS_68K(address), value);+}++INLINE void m68ki_write_16(uint address, uint value)+{++ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */+ if (ADDRESS_68K(address) >= 0xFF0000) {+ WRITE16RAM(ADDRESS_68K(address), value);+ } else+ m68k_write_memory_16(ADDRESS_68K(address), value);+}++INLINE void m68ki_write_32(uint address, uint value)+{++ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */+ if (ADDRESS_68K(address) >= 0xFF0000) {+ WRITE32RAM(ADDRESS_68K(address), value);+ } else+ m68k_write_memory_32(ADDRESS_68K(address), value);+}+++#if 0+INLINE uint m68ki_read_8(uint address)+{+ cpu_memory_map *temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];+ uint val;++ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */++ if (temp->read8) val = (*temp->read8)(ADDRESS_68K(address));+ else val = READ_BYTE(temp->base, (address) & 0xffff);++#ifdef HOOK_CPU+ if (cpu_hook)+ cpu_hook(HOOK_M68K_R, 1, address, val);+#endif++ return val;+}++INLINE uint m68ki_read_16(uint address)+{+ cpu_memory_map *temp;+ uint val;++ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */+ m68ki_check_address_error(address, MODE_READ, FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */++ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];+ if (temp->read16) val = (*temp->read16)(ADDRESS_68K(address));+ else val = *(uint16 *)(temp->base + ((address) & 0xffff));++#ifdef HOOK_CPU+ if (cpu_hook)+ cpu_hook(HOOK_M68K_R, 2, address, val);+#endif++ return val;+}++INLINE uint m68ki_read_32(uint address)+{+ cpu_memory_map *temp;+ uint val;++ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */+ m68ki_check_address_error(address, MODE_READ, FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */++ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];+ if (temp->read16) val = ((*temp->read16)(ADDRESS_68K(address)) << 16) | ((*temp->read16)(ADDRESS_68K(address + 2)));+ else val = m68k_read_immediate_32(address);++#ifdef HOOK_CPU+ if (cpu_hook)+ cpu_hook(HOOK_M68K_R, 4, address, val);+#endif++ return val;+}++INLINE void m68ki_write_8(uint address, uint value)+{+ cpu_memory_map *temp;++ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */++#ifdef HOOK_CPU+ if (cpu_hook)+ cpu_hook(HOOK_M68K_W, 1, address, value);+#endif++ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];+ if (temp->write8) (*temp->write8)(ADDRESS_68K(address),value);+ else WRITE_BYTE(temp->base, (address) & 0xffff, value);+}++INLINE void m68ki_write_16(uint address, uint value)+{+ cpu_memory_map *temp;++ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */+ m68ki_check_address_error(address, MODE_WRITE, FLAG_S | FUNCTION_CODE_USER_DATA); /* auto-disable (see m68kcpu.h) */++#ifdef HOOK_CPU+ if (cpu_hook)+ cpu_hook(HOOK_M68K_W, 2, address, value);+#endif++ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];+ if (temp->write16) (*temp->write16)(ADDRESS_68K(address),value);+ else *(uint16 *)(temp->base + ((address) & 0xffff)) = value;+}++INLINE void m68ki_write_32(uint address, uint value)+{+ cpu_memory_map *temp;++ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */+ m68ki_check_address_error(address, MODE_WRITE, FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */++#ifdef HOOK_CPU+ if (cpu_hook)+ cpu_hook(HOOK_M68K_W, 4, address, value);+#endif++ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];+ if (temp->write16) (*temp->write16)(ADDRESS_68K(address),value>>16);+ else *(uint16 *)(temp->base + ((address) & 0xffff)) = value >> 16;++ temp = &m68ki_cpu.memory_map[((address + 2)>>16)&0xff];+ if (temp->write16) (*temp->write16)(ADDRESS_68K(address+2),value&0xffff);+ else *(uint16 *)(temp->base + ((address + 2) & 0xffff)) = value;+}+#endif++/* --------------------- Effective Address Calculation -------------------- */++/* The program counter relative addressing modes cause operands to be+ * retrieved from program space, not data space.+ */+INLINE uint m68ki_get_ea_pcdi(void)+{+ uint old_pc = REG_PC;+ m68ki_use_program_space() /* auto-disable */+ return old_pc + MAKE_INT_16(m68ki_read_imm_16());+}+++INLINE uint m68ki_get_ea_pcix(void)+{+ m68ki_use_program_space() /* auto-disable */+ return m68ki_get_ea_ix(REG_PC);+}++/* Indexed addressing modes are encoded as follows:+ *+ * Base instruction format:+ * F E D C B A 9 8 7 6 | 5 4 3 | 2 1 0+ * x x x x x x x x x x | 1 1 0 | BASE REGISTER (An)+ *+ * Base instruction format for destination EA in move instructions:+ * F E D C | B A 9 | 8 7 6 | 5 4 3 2 1 0+ * x x x x | BASE REG | 1 1 0 | X X X X X X (An)+ *+ * Brief extension format:+ * F | E D C | B | A 9 | 8 | 7 6 5 4 3 2 1 0+ * D/A | REGISTER | W/L | SCALE | 0 | DISPLACEMENT+ *+ * Full extension format:+ * F E D C B A 9 8 7 6 5 4 3 2 1 0+ * D/A | REGISTER | W/L | SCALE | 1 | BS | IS | BD SIZE | 0 | I/IS+ * BASE DISPLACEMENT (0, 16, 32 bit) (bd)+ * OUTER DISPLACEMENT (0, 16, 32 bit) (od)+ *+ * D/A: 0 = Dn, 1 = An (Xn)+ * W/L: 0 = W (sign extend), 1 = L (.SIZE)+ * SCALE: 00=1, 01=2, 10=4, 11=8 (*SCALE)+ * BS: 0=add base reg, 1=suppress base reg (An suppressed)+ * IS: 0=add index, 1=suppress index (Xn suppressed)+ * BD SIZE: 00=reserved, 01=NULL, 10=Word, 11=Long (size of bd)+ *+ * IS I/IS Operation+ * 0 000 No Memory Indirect+ * 0 001 indir prex with null outer+ * 0 010 indir prex with word outer+ * 0 011 indir prex with long outer+ * 0 100 reserved+ * 0 101 indir postx with null outer+ * 0 110 indir postx with word outer+ * 0 111 indir postx with long outer+ * 1 000 no memory indirect+ * 1 001 mem indir with null outer+ * 1 010 mem indir with word outer+ * 1 011 mem indir with long outer+ * 1 100-111 reserved+ */+INLINE uint m68ki_get_ea_ix(uint An)+{+ /* An = base register */+ uint extension = m68ki_read_imm_16();++ uint Xn = 0; /* Index register */++ /* Calculate index */+ Xn = REG_DA[extension>>12]; /* Xn */+ if(!BIT_B(extension)) /* W/L */+ Xn = MAKE_INT_16(Xn);++ /* Add base register and displacement and return */+ return An + Xn + MAKE_INT_8(extension);+}+++/* Fetch operands */+INLINE uint OPER_AY_AI_8(void) {uint ea = EA_AY_AI_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AY_AI_16(void) {uint ea = EA_AY_AI_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AY_AI_32(void) {uint ea = EA_AY_AI_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AY_PI_8(void) {uint ea = EA_AY_PI_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AY_PI_16(void) {uint ea = EA_AY_PI_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AY_PI_32(void) {uint ea = EA_AY_PI_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AY_PD_8(void) {uint ea = EA_AY_PD_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AY_PD_16(void) {uint ea = EA_AY_PD_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AY_PD_32(void) {uint ea = EA_AY_PD_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AY_DI_8(void) {uint ea = EA_AY_DI_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AY_DI_16(void) {uint ea = EA_AY_DI_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AY_DI_32(void) {uint ea = EA_AY_DI_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AY_IX_8(void) {uint ea = EA_AY_IX_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AY_IX_16(void) {uint ea = EA_AY_IX_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AY_IX_32(void) {uint ea = EA_AY_IX_32(); return m68ki_read_32(ea);}++INLINE uint OPER_AX_AI_8(void) {uint ea = EA_AX_AI_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AX_AI_16(void) {uint ea = EA_AX_AI_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AX_AI_32(void) {uint ea = EA_AX_AI_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AX_PI_8(void) {uint ea = EA_AX_PI_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AX_PI_16(void) {uint ea = EA_AX_PI_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AX_PI_32(void) {uint ea = EA_AX_PI_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AX_PD_8(void) {uint ea = EA_AX_PD_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AX_PD_16(void) {uint ea = EA_AX_PD_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AX_PD_32(void) {uint ea = EA_AX_PD_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AX_DI_8(void) {uint ea = EA_AX_DI_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AX_DI_16(void) {uint ea = EA_AX_DI_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AX_DI_32(void) {uint ea = EA_AX_DI_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AX_IX_8(void) {uint ea = EA_AX_IX_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AX_IX_16(void) {uint ea = EA_AX_IX_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AX_IX_32(void) {uint ea = EA_AX_IX_32(); return m68ki_read_32(ea);}++INLINE uint OPER_A7_PI_8(void) {uint ea = EA_A7_PI_8(); return m68ki_read_8(ea); }+INLINE uint OPER_A7_PD_8(void) {uint ea = EA_A7_PD_8(); return m68ki_read_8(ea); }++INLINE uint OPER_AW_8(void) {uint ea = EA_AW_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AW_16(void) {uint ea = EA_AW_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AW_32(void) {uint ea = EA_AW_32(); return m68ki_read_32(ea);}+INLINE uint OPER_AL_8(void) {uint ea = EA_AL_8(); return m68ki_read_8(ea); }+INLINE uint OPER_AL_16(void) {uint ea = EA_AL_16(); return m68ki_read_16(ea);}+INLINE uint OPER_AL_32(void) {uint ea = EA_AL_32(); return m68ki_read_32(ea);}+INLINE uint OPER_PCDI_8(void) {uint ea = EA_PCDI_8(); return m68ki_read_pcrel_8(ea); }+INLINE uint OPER_PCDI_16(void) {uint ea = EA_PCDI_16(); return m68ki_read_pcrel_16(ea);}+INLINE uint OPER_PCDI_32(void) {uint ea = EA_PCDI_32(); return m68ki_read_pcrel_32(ea);}+INLINE uint OPER_PCIX_8(void) {uint ea = EA_PCIX_8(); return m68ki_read_pcrel_8(ea); }+INLINE uint OPER_PCIX_16(void) {uint ea = EA_PCIX_16(); return m68ki_read_pcrel_16(ea);}+INLINE uint OPER_PCIX_32(void) {uint ea = EA_PCIX_32(); return m68ki_read_pcrel_32(ea);}++++/* ---------------------------- Stack Functions --------------------------- */++/* Push/pull data from the stack */+INLINE void m68ki_push_16(uint value)+{+ REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2);+ m68ki_write_16(REG_SP, value);+}++INLINE void m68ki_push_32(uint value)+{+ REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4);+ m68ki_write_32(REG_SP, value);+}++INLINE uint m68ki_pull_16(void)+{+ uint sp = REG_SP;+ REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2);+ return m68ki_read_16(sp);+}++INLINE uint m68ki_pull_32(void)+{+ uint sp = REG_SP;+ REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4);+ return m68ki_read_32(sp);+}++++/* ----------------------------- Program Flow ----------------------------- */++/* Jump to a new program location or vector.+ * These functions will also call the pc_changed callback if it was enabled+ * in m68kconf.h.+ */+INLINE void m68ki_jump(uint new_pc)+{+ REG_PC = new_pc;+}++INLINE void m68ki_jump_vector(uint vector)+{+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */+ REG_PC = m68ki_read_32(vector<<2);+}+++/* Branch to a new memory location.+ * The 32-bit branch will call pc_changed if it was enabled in m68kconf.h.+ * So far I've found no problems with not calling pc_changed for 8 or 16+ * bit branches.+ */+INLINE void m68ki_branch_8(uint offset)+{+ REG_PC += MAKE_INT_8(offset);+}++INLINE void m68ki_branch_16(uint offset)+{+ REG_PC += MAKE_INT_16(offset);+}++INLINE void m68ki_branch_32(uint offset)+{+ REG_PC += offset;+}++++/* ---------------------------- Status Register --------------------------- */++/* Set the S flag and change the active stack pointer.+ * Note that value MUST be 4 or 0.+ */+INLINE void m68ki_set_s_flag(uint value)+{+ /* Backup the old stack pointer */+ REG_SP_BASE[FLAG_S] = REG_SP;+ /* Set the S flag */+ FLAG_S = value;+ /* Set the new stack pointer */+ REG_SP = REG_SP_BASE[FLAG_S];+}+++/* Set the condition code register */+INLINE void m68ki_set_ccr(uint value)+{+ FLAG_X = BIT_4(value) << 4;+ FLAG_N = BIT_3(value) << 4;+ FLAG_Z = !BIT_2(value);+ FLAG_V = BIT_1(value) << 6;+ FLAG_C = BIT_0(value) << 8;+}+++/* Set the status register and check for interrupts */+INLINE void m68ki_set_sr(uint value)+{+ /* Set the status register */+ FLAG_T1 = BIT_F(value);+ FLAG_INT_MASK = value & 0x0700;+ m68ki_set_ccr(value);+ m68ki_set_s_flag((value >> 11) & 4);++ /* Check current IRQ status */+ m68ki_check_interrupts();+}+++/* ------------------------- Exception Processing ------------------------- */++/* Initiate exception processing */+INLINE uint m68ki_init_exception(void)+{+ /* Save the old status register */+ uint sr = m68ki_get_sr();++ /* Turn off trace flag, clear pending traces */+ FLAG_T1 = 0;+ m68ki_clear_trace()++ /* Enter supervisor mode */+ m68ki_set_s_flag(SFLAG_SET);++ return sr;+}++/* 3 word stack frame (68000 only) */+INLINE void m68ki_stack_frame_3word(uint pc, uint sr)+{+ m68ki_push_32(pc);+ m68ki_push_16(sr);+}++#if M68K_EMULATE_ADDRESS_ERROR+/* Bus error stack frame (68000 only).+ */+INLINE void m68ki_stack_frame_buserr(uint sr)+{+ m68ki_push_32(REG_PC);+ m68ki_push_16(sr);+ m68ki_push_16(REG_IR);+ m68ki_push_32(m68ki_cpu.aerr_address); /* access address */+ /* 0 0 0 0 0 0 0 0 0 0 0 R/W I/N FC+ * R/W 0 = write, 1 = read+ * I/N 0 = instruction, 1 = not+ * FC 3-bit function code+ */+ m68ki_push_16(m68ki_cpu.aerr_write_mode | CPU_INSTR_MODE | m68ki_cpu.aerr_fc);+}+#endif++/* Used for Group 2 exceptions.+ */+INLINE void m68ki_exception_trap(uint vector)+{+ uint sr = m68ki_init_exception();++ m68ki_stack_frame_3word(REG_PC, sr);++ m68ki_jump_vector(vector);++ /* Use up some clock cycles */+ USE_CYCLES(CYC_EXCEPTION[vector]);+}++/* Trap#n stacks a 0 frame but behaves like group2 otherwise */+INLINE void m68ki_exception_trapN(uint vector)+{+ uint sr = m68ki_init_exception();+ m68ki_stack_frame_3word(REG_PC, sr);+ m68ki_jump_vector(vector);++ /* Use up some clock cycles */+ USE_CYCLES(CYC_EXCEPTION[vector]);+}++#if M68K_EMULATE_TRACE+/* Exception for trace mode */+INLINE void m68ki_exception_trace(void)+{+ uint sr = m68ki_init_exception();++ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON+ CPU_INSTR_MODE = INSTRUCTION_NO;+ #endif /* M68K_EMULATE_ADDRESS_ERROR */++ m68ki_stack_frame_3word(REG_PC, sr);+ m68ki_jump_vector(EXCEPTION_TRACE);++ /* Trace nullifies a STOP instruction */+ CPU_STOPPED &= ~STOP_LEVEL_STOP;++ /* Use up some clock cycles */+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_TRACE]);+}+#endif++/* Exception for privilege violation */+static void m68ki_exception_privilege_violation(void)+{+ uint sr = m68ki_init_exception();++ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON+ CPU_INSTR_MODE = INSTRUCTION_NO;+ #endif /* M68K_EMULATE_ADDRESS_ERROR */++ m68ki_stack_frame_3word(REG_PC-2, sr);+ m68ki_jump_vector(EXCEPTION_PRIVILEGE_VIOLATION);++ /* Use up some clock cycles and undo the instruction's cycles */+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_PRIVILEGE_VIOLATION] - CYC_INSTRUCTION(REG_IR));+}++/* Exception for A-Line instructions */+INLINE void m68ki_exception_1010(void)+{+ uint sr = m68ki_init_exception();+ m68ki_stack_frame_3word(REG_PC-2, sr);+ m68ki_jump_vector(EXCEPTION_1010);++ /* Use up some clock cycles and undo the instruction's cycles */+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1010] - CYC_INSTRUCTION(REG_IR));+}++/* Exception for F-Line instructions */+INLINE void m68ki_exception_1111(void)+{+ uint sr = m68ki_init_exception();+ m68ki_stack_frame_3word(REG_PC-2, sr);+ m68ki_jump_vector(EXCEPTION_1111);++ /* Use up some clock cycles and undo the instruction's cycles */+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1111] - CYC_INSTRUCTION(REG_IR));+}++/* Exception for illegal instructions */+INLINE void m68ki_exception_illegal(void)+{+ uint sr = m68ki_init_exception();++ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON+ CPU_INSTR_MODE = INSTRUCTION_NO;+ #endif /* M68K_EMULATE_ADDRESS_ERROR */++ m68ki_stack_frame_3word(REG_PC-2, sr);+ m68ki_jump_vector(EXCEPTION_ILLEGAL_INSTRUCTION);++ /* Use up some clock cycles and undo the instruction's cycles */+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_ILLEGAL_INSTRUCTION] - CYC_INSTRUCTION(REG_IR));+}+++#if M68K_EMULATE_ADDRESS_ERROR+/* Exception for address error */+INLINE void m68ki_exception_address_error(void)+{+ uint sr = m68ki_init_exception();++ /* If we were processing a bus error, address error, or reset,+ * this is a catastrophic failure.+ * Halt the CPU+ */+ if(CPU_RUN_MODE == RUN_MODE_BERR_AERR_RESET)+ {+ CPU_STOPPED = STOP_LEVEL_HALT;+ SET_CYCLES(m68ki_cpu.cycle_end - CYC_INSTRUCTION(REG_IR));+ return;+ }+ CPU_RUN_MODE = RUN_MODE_BERR_AERR_RESET;++ /* Note: This is implemented for 68000 only! */+ m68ki_stack_frame_buserr(sr);++ m68ki_jump_vector(EXCEPTION_ADDRESS_ERROR);++ /* Use up some clock cycles and undo the instruction's cycles */+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_ADDRESS_ERROR] - CYC_INSTRUCTION(REG_IR));+}+#endif++/* Service an interrupt request and start exception processing */+INLINE void m68ki_exception_interrupt(uint int_level)+{+ uint vector, sr, new_pc;++ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON+ CPU_INSTR_MODE = INSTRUCTION_NO;+ #endif /* M68K_EMULATE_ADDRESS_ERROR */++ /* Turn off the stopped state */+ CPU_STOPPED &= STOP_LEVEL_HALT;++ /* If we are halted, don't do anything */+ if(CPU_STOPPED)+ return;++ /* Always use the autovectors. */+ vector = EXCEPTION_INTERRUPT_AUTOVECTOR+int_level;++ /* Start exception processing */+ sr = m68ki_init_exception();++ /* Set the interrupt mask to the level of the one being serviced */+ FLAG_INT_MASK = int_level<<8;++ /* Acknowledge the interrupt */+ m68ki_int_ack(int_level);++ /* Get the new PC */+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */+ new_pc = m68ki_read_32(vector<<2);++ /* If vector is uninitialized, call the uninitialized interrupt vector */+ if(new_pc == 0)+ new_pc = m68ki_read_32((EXCEPTION_UNINITIALIZED_INTERRUPT<<2));++ /* Generate a stack frame */+ m68ki_stack_frame_3word(REG_PC, sr);++ m68ki_jump(new_pc);++ /* Update cycle count now */+ USE_CYCLES(CYC_EXCEPTION[vector]);+}++/* ASG: Check for interrupts */+INLINE void m68ki_check_interrupts(void)+{+ if(CPU_INT_LEVEL > FLAG_INT_MASK)+ m68ki_exception_interrupt(CPU_INT_LEVEL>>8);+}+++/* ======================================================================== */+/* ============================== END OF FILE ============================= */+/* ======================================================================== */++#endif /* M68KCPU__HEADER */diff --git a/games/retrogo/src/md/m68kops.h b/games/retrogo/src/md/m68kops.hnew file mode 100644index 00000000..6847b3fb--- /dev/null+++ b/games/retrogo/src/md/m68kops.h@@ -0,0 +1,25487 @@++/* ======================================================================== */+/* ============== CYCLE-ACCURATE DIV/MUL EXECUTION ======================== */+/* ======================================================================== */++INLINE void UseDivuCycles(uint32 dst, uint32 src)+{+ int i;++ /* minimum cycle time */+ uint mcycles = 38 * MUL;++ /* 16-bit divisor */+ src <<= 16;++ /* 16-bit dividend */+ for (i=0; i<15; i++)+ {+ /* check if carry bit set */+ if ((sint32) dst < 0)+ {+ /* shift dividend and apply divisor */+ dst <<= 1;+ dst -= src;+ }+ else+ {+ /* shift dividend and add two cycles */+ dst <<= 1;+ mcycles += (2 * MUL);++ if (dst >= src)+ {+ /* apply divisor and remove one cycle */+ dst -= src;+ mcycles -= 1 * MUL;+ }+ }+ }++ USE_CYCLES(mcycles << 1);+}++INLINE void UseDivsCycles(sint32 dst, sint16 src)+{+ /* minimum cycle time */+ uint mcycles = 6 * MUL;++ /* negative dividend */+ if (dst < 0) mcycles += 1 * MUL;++ if ((abs(dst) >> 16) < abs(src))+ {+ int i;++ /* absolute quotient */+ uint32 quotient = abs(dst) / abs(src);++ /* add default cycle time */+ mcycles += (55 * MUL);++ /* positive divisor */+ if (src >= 0)+ {+ /* check dividend sign */+ if (dst >= 0) mcycles -= 1 * MUL;+ else mcycles += 1 * MUL;+ }++ /* check higher 15-bits of quotient */+ for (i=0; i<15; i++)+ {+ quotient >>= 1;+ if (!(quotient & 1)) mcycles += 1 * MUL;+ }+ }+ else+ {+ /* absolute overflow */+ mcycles += (2 * MUL);+ }++ USE_CYCLES(mcycles << 1);+}++INLINE void UseMuluCycles(uint16 src)+{+ /* minimum cycle time */+ uint mcycles = 38 * MUL;++ /* count number of bits set to 1 */+ while (src)+ {+ if (src & 1) mcycles += (2 * MUL);+ src >>= 1;+ }++ /* 38 + 2*N */+ USE_CYCLES(mcycles);+}++INLINE void UseMulsCycles(sint16 src)+{+ /* minimum cycle time */+ uint mcycles = 38 * MUL;++ /* detect 01 or 10 patterns */+ sint32 tmp = src << 1;+ tmp = (tmp ^ src) & 0xFFFF;++ /* count number of bits set to 1 */+ while (tmp)+ {+ if (tmp & 1) mcycles += (2 * MUL);+ tmp >>= 1;+ }++ /* 38 + 2*N */+ USE_CYCLES(mcycles);+}+++/* ======================================================================== */+/* ========================= INSTRUCTION HANDLERS ========================= */+/* ======================================================================== */+++static void m68k_op_1010(void)+{+ m68ki_exception_1010();+}++/* (NumPlay: line F too, as the table has every opcode) */+static void m68k_op_1111(void)+{+ m68ki_exception_1111();+}++static void m68k_op_abcd_8_rr(void)+{+ uint* r_dst = &DX;+ uint src = DY;+ uint dst = *r_dst;+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();+ uint corf = 0;++ if(res > 9)+ corf = 6;+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);+ FLAG_V = ~res; /* Undefined V behavior */++ res += corf;+ FLAG_X = FLAG_C = (res > 0x9f) << 8;+ if(FLAG_C)+ res -= 0xa0;++ FLAG_V &= res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+}+++static void m68k_op_abcd_8_mm_ax7(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();+ uint corf = 0;++ if(res > 9)+ corf = 6;+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);+ FLAG_V = ~res; /* Undefined V behavior */++ res += corf;+ FLAG_X = FLAG_C = (res > 0x9f) << 8;+ if(FLAG_C)+ res -= 0xa0;++ FLAG_V &= res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_abcd_8_mm_ay7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();+ uint corf = 0;++ if(res > 9)+ corf = 6;+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);+ FLAG_V = ~res; /* Undefined V behavior */++ res += corf;+ FLAG_X = FLAG_C = (res > 0x9f) << 8;+ if(FLAG_C)+ res -= 0xa0;++ FLAG_V &= res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_abcd_8_mm_axy7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();+ uint corf = 0;++ if(res > 9)+ corf = 6;+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);+ FLAG_V = ~res; /* Undefined V behavior */++ res += corf;+ FLAG_X = FLAG_C = (res > 0x9f) << 8;+ if(FLAG_C)+ res -= 0xa0;++ FLAG_V &= res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_abcd_8_mm(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();+ uint corf = 0;++ if(res > 9)+ corf = 6;+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);+ FLAG_V = ~res; /* Undefined V behavior */++ res += corf;+ FLAG_X = FLAG_C = (res > 0x9f) << 8;+ if(FLAG_C)+ res -= 0xa0;++ FLAG_V &= res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_add_8_er_d(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_8(DY);+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_pi7(void)+{+ uint* r_dst = &DX;+ uint src = OPER_A7_PI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_pd7(void)+{+ uint* r_dst = &DX;+ uint src = OPER_A7_PD_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_8_er_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_d(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(DY);+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_a(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(AY);+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_16_er_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_add_32_er_d(void)+{+ uint* r_dst = &DX;+ uint src = DY;+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_a(void)+{+ uint* r_dst = &DX;+ uint src = AY;+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_32_er_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_add_8_re_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_di(void)+{+ uint ea = EA_AY_DI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_aw(void)+{+ uint ea = EA_AW_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_8_re_al(void)+{+ uint ea = EA_AL_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_add_16_re_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_add_16_re_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_add_16_re_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_add_16_re_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_add_16_re_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_add_16_re_aw(void)+{+ uint ea = EA_AW_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_add_16_re_al(void)+{+ uint ea = EA_AL_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_add_32_re_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_add_32_re_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_add_32_re_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_add_32_re_di(void)+{+ uint ea = EA_AY_DI_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_add_32_re_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_add_32_re_aw(void)+{+ uint ea = EA_AW_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_add_32_re_al(void)+{+ uint ea = EA_AL_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_adda_16_d(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(DY));+}+++static void m68k_op_adda_16_a(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(AY));+}+++static void m68k_op_adda_16_ai(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_AI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_pi(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_PI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_pd(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_PD_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_di(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_DI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_ix(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_IX_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_aw(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AW_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_al(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AL_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_pcdi(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_PCDI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_pcix(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_PCIX_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_16_i(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_I_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);+}+++static void m68k_op_adda_32_d(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + DY);+}+++static void m68k_op_adda_32_a(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + AY);+}+++static void m68k_op_adda_32_ai(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_AI_32() + *r_dst);+}+++static void m68k_op_adda_32_pi(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_PI_32() + *r_dst);+}+++static void m68k_op_adda_32_pd(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_PD_32() + *r_dst);+}+++static void m68k_op_adda_32_di(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_DI_32() + *r_dst);+}+++static void m68k_op_adda_32_ix(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_IX_32() + *r_dst);+}+++static void m68k_op_adda_32_aw(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_AW_32() + *r_dst);+}+++static void m68k_op_adda_32_al(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_AL_32() + *r_dst);+}+++static void m68k_op_adda_32_pcdi(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_PCDI_32() + *r_dst);+}+++static void m68k_op_adda_32_pcix(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_PCIX_32() + *r_dst);+}+++static void m68k_op_adda_32_i(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(OPER_I_32() + *r_dst);+}+++static void m68k_op_addi_8_d(void)+{+ uint* r_dst = &DY;+ uint src = OPER_I_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_addi_8_ai(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_AI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_pi(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_pi7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_pd(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_pd7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_di(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_DI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_ix(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_IX_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_aw(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AW_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_8_al(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AL_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addi_16_d(void)+{+ uint* r_dst = &DY;+ uint src = OPER_I_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_addi_16_ai(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_AI_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addi_16_pi(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PI_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addi_16_pd(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PD_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addi_16_di(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_DI_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addi_16_ix(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_IX_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addi_16_aw(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AW_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addi_16_al(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AL_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addi_32_d(void)+{+ uint* r_dst = &DY;+ uint src = OPER_I_32();+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_addi_32_ai(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_AI_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addi_32_pi(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PI_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addi_32_pd(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PD_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addi_32_di(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_DI_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addi_32_ix(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_IX_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addi_32_aw(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AW_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addi_32_al(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AL_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addq_8_d(void)+{+ uint* r_dst = &DY;+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_addq_8_ai(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_AI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_pi(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_pi7(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_A7_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_pd(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_pd7(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_di(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_DI_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_ix(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_IX_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_aw(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AW_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_8_al(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AL_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_addq_16_d(void)+{+ uint* r_dst = &DY;+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_addq_16_a(void)+{+ uint* r_dst = &AY;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1);+}+++static void m68k_op_addq_16_ai(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_AI_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addq_16_pi(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PI_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addq_16_pd(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PD_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addq_16_di(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_DI_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addq_16_ix(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_IX_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addq_16_aw(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AW_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addq_16_al(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AL_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst;++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_addq_32_d(void)+{+ uint* r_dst = &DY;+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint dst = *r_dst;+ uint res = src + dst;++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_addq_32_a(void)+{+ uint* r_dst = &AY;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1);+}+++static void m68k_op_addq_32_ai(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_AI_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;+++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addq_32_pi(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PI_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;+++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addq_32_pd(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PD_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;+++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addq_32_di(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_DI_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;+++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addq_32_ix(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_IX_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;+++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addq_32_aw(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AW_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;+++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addq_32_al(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AL_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst;+++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_addx_8_rr(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_8(DY);+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+}+++static void m68k_op_addx_16_rr(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(DY);+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+}+++static void m68k_op_addx_32_rr(void)+{+ uint* r_dst = &DX;+ uint src = DY;+ uint dst = *r_dst;+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ *r_dst = res;+}+++static void m68k_op_addx_8_mm_ax7(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_addx_8_mm_ay7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_addx_8_mm_axy7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_addx_8_mm(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_V = VFLAG_ADD_8(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_8(res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_addx_16_mm(void)+{+ uint src = OPER_AY_PD_16();+ uint ea = EA_AX_PD_16();+ uint dst = m68ki_read_16(ea);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_V = VFLAG_ADD_16(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_16(res);++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_addx_32_mm(void)+{+ uint src = OPER_AY_PD_32();+ uint ea = EA_AX_PD_32();+ uint dst = m68ki_read_32(ea);+ uint res = src + dst + XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_ADD_32(src, dst, res);+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_and_8_er_d(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (DY | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_ai(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_AI_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_pi(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_PI_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_pi7(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_A7_PI_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_pd(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_PD_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_pd7(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_A7_PD_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_di(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_DI_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_ix(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_IX_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_aw(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AW_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_al(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AL_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_pcdi(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_PCDI_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_pcix(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_PCIX_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_er_i(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_I_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_d(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (DY | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_ai(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_AI_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_pi(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_PI_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_pd(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_PD_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_di(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_DI_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_ix(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_IX_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_aw(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AW_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_al(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AL_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_pcdi(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_PCDI_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_pcix(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_PCIX_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_16_er_i(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_I_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_d(void)+{+ FLAG_Z = DX &= DY;++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_ai(void)+{+ FLAG_Z = DX &= OPER_AY_AI_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_pi(void)+{+ FLAG_Z = DX &= OPER_AY_PI_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_pd(void)+{+ FLAG_Z = DX &= OPER_AY_PD_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_di(void)+{+ FLAG_Z = DX &= OPER_AY_DI_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_ix(void)+{+ FLAG_Z = DX &= OPER_AY_IX_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_aw(void)+{+ FLAG_Z = DX &= OPER_AW_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_al(void)+{+ FLAG_Z = DX &= OPER_AL_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_pcdi(void)+{+ FLAG_Z = DX &= OPER_PCDI_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_pcix(void)+{+ FLAG_Z = DX &= OPER_PCIX_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_32_er_i(void)+{+ FLAG_Z = DX &= OPER_I_32();++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_and_8_re_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_di(void)+{+ uint ea = EA_AY_DI_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_aw(void)+{+ uint ea = EA_AW_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_8_re_al(void)+{+ uint ea = EA_AL_8();+ uint res = DX & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_and_16_re_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint res = DX & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_and_16_re_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint res = DX & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_and_16_re_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint res = DX & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_and_16_re_di(void)+{+ uint ea = EA_AY_DI_16();+ uint res = DX & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_and_16_re_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint res = DX & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_and_16_re_aw(void)+{+ uint ea = EA_AW_16();+ uint res = DX & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_and_16_re_al(void)+{+ uint ea = EA_AL_16();+ uint res = DX & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_and_32_re_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint res = DX & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_and_32_re_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint res = DX & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_and_32_re_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint res = DX & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_and_32_re_di(void)+{+ uint ea = EA_AY_DI_32();+ uint res = DX & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_and_32_re_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint res = DX & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_and_32_re_aw(void)+{+ uint ea = EA_AW_32();+ uint res = DX & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_and_32_re_al(void)+{+ uint ea = EA_AL_32();+ uint res = DX & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_8_d(void)+{+ FLAG_Z = MASK_OUT_ABOVE_8(DY &= (OPER_I_8() | 0xffffff00));++ FLAG_N = NFLAG_8(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_andi_8_ai(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_AI_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_pi(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PI_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_pi7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PI_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_pd(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PD_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_pd7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PD_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_di(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_DI_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_ix(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_IX_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_aw(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AW_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_8_al(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AL_8();+ uint res = src & m68ki_read_8(ea);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_andi_16_d(void)+{+ FLAG_Z = MASK_OUT_ABOVE_16(DY &= (OPER_I_16() | 0xffff0000));++ FLAG_N = NFLAG_16(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_andi_16_ai(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_AI_16();+ uint res = src & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_andi_16_pi(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PI_16();+ uint res = src & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_andi_16_pd(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PD_16();+ uint res = src & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_andi_16_di(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_DI_16();+ uint res = src & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_andi_16_ix(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_IX_16();+ uint res = src & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_andi_16_aw(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AW_16();+ uint res = src & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_andi_16_al(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AL_16();+ uint res = src & m68ki_read_16(ea);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_andi_32_d(void)+{+ FLAG_Z = DY &= (OPER_I_32());++ FLAG_N = NFLAG_32(FLAG_Z);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_andi_32_ai(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_AI_32();+ uint res = src & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_32_pi(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PI_32();+ uint res = src & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_32_pd(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PD_32();+ uint res = src & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_32_di(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_DI_32();+ uint res = src & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_32_ix(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_IX_32();+ uint res = src & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_32_aw(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AW_32();+ uint res = src & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_32_al(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AL_32();+ uint res = src & m68ki_read_32(ea);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_andi_16_toc(void)+{+ m68ki_set_ccr(m68ki_get_ccr() & OPER_I_16());+}+++static void m68k_op_andi_16_tos(void)+{+ if(FLAG_S)+ {+ uint src = OPER_I_16();+ m68ki_set_sr(m68ki_get_sr() & src);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_asr_8_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ if(GET_MSB_8(src))+ res |= m68ki_shift_8_table[shift];++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_X = FLAG_C = src << (9-shift);+}+++static void m68k_op_asr_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ if(GET_MSB_16(src))+ res |= m68ki_shift_16_table[shift];++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_X = FLAG_C = src << (9-shift);+}+++static void m68k_op_asr_32_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = *r_dst;+ uint res = src >> shift;++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ if(GET_MSB_32(src))+ res |= m68ki_shift_32_table[shift];++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_X = FLAG_C = src << (9-shift);+}+++static void m68k_op_asr_8_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 8)+ {+ if(GET_MSB_8(src))+ res |= m68ki_shift_8_table[shift];++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_X = FLAG_C = src << (9-shift);+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ if(GET_MSB_8(src))+ {+ *r_dst |= 0xff;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_SET;+ FLAG_Z = ZFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst &= 0xffffff00;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_8(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_asr_16_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 16)+ {+ if(GET_MSB_16(src))+ res |= m68ki_shift_16_table[shift];++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;+ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ if(GET_MSB_16(src))+ {+ *r_dst |= 0xffff;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_SET;+ FLAG_Z = ZFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst &= 0xffff0000;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_16(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_asr_32_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = *r_dst;+ uint res = src >> shift;++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 32)+ {+ if(GET_MSB_32(src))+ res |= m68ki_shift_32_table[shift];++ *r_dst = res;++ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ if(GET_MSB_32(src))+ {+ *r_dst = 0xffffffff;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_SET;+ FLAG_Z = ZFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst = 0;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_32(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_asr_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ if(GET_MSB_16(src))+ res |= 0x8000;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = FLAG_X = src << 8;+}+++static void m68k_op_asr_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ if(GET_MSB_16(src))+ res |= 0x8000;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = FLAG_X = src << 8;+}+++static void m68k_op_asr_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ if(GET_MSB_16(src))+ res |= 0x8000;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = FLAG_X = src << 8;+}+++static void m68k_op_asr_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ if(GET_MSB_16(src))+ res |= 0x8000;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = FLAG_X = src << 8;+}+++static void m68k_op_asr_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ if(GET_MSB_16(src))+ res |= 0x8000;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = FLAG_X = src << 8;+}+++static void m68k_op_asr_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ if(GET_MSB_16(src))+ res |= 0x8000;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = FLAG_X = src << 8;+}+++static void m68k_op_asr_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ if(GET_MSB_16(src))+ res |= 0x8000;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = FLAG_X = src << 8;+}+++static void m68k_op_asl_8_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = MASK_OUT_ABOVE_8(src << shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_X = FLAG_C = src << shift;+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ src &= m68ki_shift_8_table[shift + 1];+ FLAG_V = (!(src == 0 || (src == m68ki_shift_8_table[shift + 1] && shift < 8)))<<7;+}+++static void m68k_op_asl_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = MASK_OUT_ABOVE_16(src << shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> (8-shift);+ src &= m68ki_shift_16_table[shift + 1];+ FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7;+}+++static void m68k_op_asl_32_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32(src << shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> (24-shift);+ src &= m68ki_shift_32_table[shift + 1];+ FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7;+}+++static void m68k_op_asl_8_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = MASK_OUT_ABOVE_8(src << shift);++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 8)+ {+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+ FLAG_X = FLAG_C = src << shift;+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ src &= m68ki_shift_8_table[shift + 1];+ FLAG_V = (!(src == 0 || src == m68ki_shift_8_table[shift + 1]))<<7;+ return;+ }++ *r_dst &= 0xffffff00;+ FLAG_X = FLAG_C = ((shift == 8 ? src & 1 : 0))<<8;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = (!(src == 0))<<7;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_8(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_asl_16_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = MASK_OUT_ABOVE_16(src << shift);++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 16)+ {+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ FLAG_X = FLAG_C = (src << shift) >> 8;+ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ src &= m68ki_shift_16_table[shift + 1];+ FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7;+ return;+ }++ *r_dst &= 0xffff0000;+ FLAG_X = FLAG_C = ((shift == 16 ? src & 1 : 0))<<8;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = (!(src == 0))<<7;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_16(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_asl_32_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32(src << shift);++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 32)+ {+ *r_dst = res;+ FLAG_X = FLAG_C = (src >> (32 - shift)) << 8;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ src &= m68ki_shift_32_table[shift + 1];+ FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7;+ return;+ }++ *r_dst = 0;+ FLAG_X = FLAG_C = ((shift == 32 ? src & 1 : 0))<<8;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = (!(src == 0))<<7;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_32(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_asl_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ src &= 0xc000;+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;+}+++static void m68k_op_asl_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ src &= 0xc000;+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;+}+++static void m68k_op_asl_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ src &= 0xc000;+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;+}+++static void m68k_op_asl_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ src &= 0xc000;+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;+}+++static void m68k_op_asl_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ src &= 0xc000;+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;+}+++static void m68k_op_asl_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ src &= 0xc000;+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;+}+++static void m68k_op_asl_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ src &= 0xc000;+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;+}+++static void m68k_op_bhi_8(void)+{+ if(COND_HI())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bls_8(void)+{+ if(COND_LS())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bcc_8(void)+{+ if(COND_CC())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bcs_8(void)+{+ if(COND_CS())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bne_8(void)+{+ if(COND_NE())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_beq_8(void)+{+ if(COND_EQ())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bvc_8(void)+{+ if(COND_VC())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bvs_8(void)+{+ if(COND_VS())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bpl_8(void)+{+ if(COND_PL())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bmi_8(void)+{+ if(COND_MI())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bge_8(void)+{+ if(COND_GE())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_blt_8(void)+{+ if(COND_LT())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bgt_8(void)+{+ if(COND_GT())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_ble_8(void)+{+ if(COND_LE())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bhi_16(void)+{+ if(COND_HI())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bls_16(void)+{+ if(COND_LS())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bcc_16(void)+{+ if(COND_CC())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bcs_16(void)+{+ if(COND_CS())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bne_16(void)+{+ if(COND_NE())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_beq_16(void)+{+ if(COND_EQ())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bvc_16(void)+{+ if(COND_VC())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bvs_16(void)+{+ if(COND_VS())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bpl_16(void)+{+ if(COND_PL())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bmi_16(void)+{+ if(COND_MI())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bge_16(void)+{+ if(COND_GE())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_blt_16(void)+{+ if(COND_LT())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bgt_16(void)+{+ if(COND_GT())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_ble_16(void)+{+ if(COND_LE())+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_BCC_NOTAKE_W);+}+++static void m68k_op_bhi_32(void)+{+ if(COND_HI())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bls_32(void)+{+ if(COND_LS())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bcc_32(void)+{+ if(COND_CC())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bcs_32(void)+{+ if(COND_CS())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bne_32(void)+{+ if(COND_NE())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_beq_32(void)+{+ if(COND_EQ())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bvc_32(void)+{+ if(COND_VC())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bvs_32(void)+{+ if(COND_VS())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bpl_32(void)+{+ if(COND_PL())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bmi_32(void)+{+ if(COND_MI())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bge_32(void)+{+ if(COND_GE())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_blt_32(void)+{+ if(COND_LT())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bgt_32(void)+{+ if(COND_GT())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_ble_32(void)+{+ if(COND_LE())+ {+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+ return;+ }+ USE_CYCLES(CYC_BCC_NOTAKE_B);+}+++static void m68k_op_bchg_32_r_d(void)+{+ uint* r_dst = &DY;+ uint mask = 1 << (DX & 0x1f);++ FLAG_Z = *r_dst & mask;+ *r_dst ^= mask;+}+++static void m68k_op_bchg_8_r_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_di(void)+{+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_aw(void)+{+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_r_al(void)+{+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_32_s_d(void)+{+ uint* r_dst = &DY;+ uint mask = 1 << (OPER_I_8() & 0x1f);++ FLAG_Z = *r_dst & mask;+ *r_dst ^= mask;+}+++static void m68k_op_bchg_8_s_ai(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_pi(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_pi7(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_pd(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_pd7(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_di(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_ix(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_aw(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bchg_8_s_al(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src ^ mask);+}+++static void m68k_op_bclr_32_r_d(void)+{+ uint* r_dst = &DY;+ uint mask = 1 << (DX & 0x1f);++ FLAG_Z = *r_dst & mask;+ *r_dst &= ~mask;+}+++static void m68k_op_bclr_8_r_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_di(void)+{+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_aw(void)+{+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_r_al(void)+{+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_32_s_d(void)+{+ uint* r_dst = &DY;+ uint mask = 1 << (OPER_I_8() & 0x1f);++ FLAG_Z = *r_dst & mask;+ *r_dst &= ~mask;+}+++static void m68k_op_bclr_8_s_ai(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_pi(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_pi7(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_pd(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_pd7(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_di(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_ix(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_aw(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bclr_8_s_al(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src & ~mask);+}+++static void m68k_op_bra_8(void)+{+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+}+++static void m68k_op_bra_16(void)+{+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+}+++static void m68k_op_bra_32(void)+{+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+}+++static void m68k_op_bset_32_r_d(void)+{+ uint* r_dst = &DY;+ uint mask = 1 << (DX & 0x1f);++ FLAG_Z = *r_dst & mask;+ *r_dst |= mask;+}+++static void m68k_op_bset_8_r_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_di(void)+{+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_aw(void)+{+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_r_al(void)+{+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);+ uint mask = 1 << (DX & 7);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_32_s_d(void)+{+ uint* r_dst = &DY;+ uint mask = 1 << (OPER_I_8() & 0x1f);++ FLAG_Z = *r_dst & mask;+ *r_dst |= mask;+}+++static void m68k_op_bset_8_s_ai(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_pi(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_pi7(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_pd(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_pd7(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_di(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_ix(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_aw(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bset_8_s_al(void)+{+ uint mask = 1 << (OPER_I_8() & 7);+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);++ FLAG_Z = src & mask;+ m68ki_write_8(ea, src | mask);+}+++static void m68k_op_bsr_8(void)+{+ m68ki_push_32(REG_PC);+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+}+++static void m68k_op_bsr_16(void)+{+ uint offset = OPER_I_16();+ m68ki_push_32(REG_PC);+ REG_PC -= 2;+ m68ki_branch_16(offset);+}+++static void m68k_op_bsr_32(void)+{+ m68ki_push_32(REG_PC);+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));+}+++static void m68k_op_btst_32_r_d(void)+{+ FLAG_Z = DY & (1 << (DX & 0x1f));+}+++static void m68k_op_btst_8_r_ai(void)+{+ FLAG_Z = OPER_AY_AI_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_pi(void)+{+ FLAG_Z = OPER_AY_PI_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_pi7(void)+{+ FLAG_Z = OPER_A7_PI_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_pd(void)+{+ FLAG_Z = OPER_AY_PD_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_pd7(void)+{+ FLAG_Z = OPER_A7_PD_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_di(void)+{+ FLAG_Z = OPER_AY_DI_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_ix(void)+{+ FLAG_Z = OPER_AY_IX_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_aw(void)+{+ FLAG_Z = OPER_AW_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_al(void)+{+ FLAG_Z = OPER_AL_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_pcdi(void)+{+ FLAG_Z = OPER_PCDI_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_pcix(void)+{+ FLAG_Z = OPER_PCIX_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_8_r_i(void)+{+ FLAG_Z = OPER_I_8() & (1 << (DX & 7));+}+++static void m68k_op_btst_32_s_d(void)+{+ FLAG_Z = DY & (1 << (OPER_I_8() & 0x1f));+}+++static void m68k_op_btst_8_s_ai(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_AY_AI_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_pi(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_AY_PI_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_pi7(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_A7_PI_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_pd(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_AY_PD_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_pd7(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_A7_PD_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_di(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_AY_DI_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_ix(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_AY_IX_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_aw(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_AW_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_al(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_AL_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_pcdi(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_PCDI_8() & (1 << bit);+}+++static void m68k_op_btst_8_s_pcix(void)+{+ uint bit = OPER_I_8() & 7;++ FLAG_Z = OPER_PCIX_8() & (1 << bit);+}+++static void m68k_op_chk_16_d(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(DY);++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_ai(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_AY_AI_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_pi(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_AY_PI_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_pd(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_AY_PD_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_di(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_AY_DI_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_ix(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_AY_IX_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_aw(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_AW_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_al(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_AL_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_pcdi(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_PCDI_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_pcix(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_PCIX_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_chk_16_i(void)+{+ sint src = MAKE_INT_16(DX);+ sint bound = MAKE_INT_16(OPER_I_16());++ FLAG_Z = ZFLAG_16(src); /* Undocumented */+ FLAG_V = VFLAG_CLEAR; /* Undocumented */+ FLAG_C = CFLAG_CLEAR; /* Undocumented */++ if(src >= 0 && src <= bound)+ {+ return;+ }+ FLAG_N = (src < 0)<<7;+ m68ki_exception_trap(EXCEPTION_CHK);+}+++static void m68k_op_clr_8_d(void)+{+ DY &= 0xffffff00;++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_8_al(void)+{+ m68ki_write_8(EA_AL_8(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_d(void)+{+ DY &= 0xffff0000;++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_ai(void)+{+ m68ki_write_16(EA_AY_AI_16(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_pi(void)+{+ m68ki_write_16(EA_AY_PI_16(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_pd(void)+{+ m68ki_write_16(EA_AY_PD_16(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_di(void)+{+ m68ki_write_16(EA_AY_DI_16(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_ix(void)+{+ m68ki_write_16(EA_AY_IX_16(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_aw(void)+{+ m68ki_write_16(EA_AW_16(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_16_al(void)+{+ m68ki_write_16(EA_AL_16(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_d(void)+{+ DY = 0;++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_ai(void)+{+ m68ki_write_32(EA_AY_AI_32(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_pi(void)+{+ m68ki_write_32(EA_AY_PI_32(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_pd(void)+{+ m68ki_write_32(EA_AY_PD_32(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_di(void)+{+ m68ki_write_32(EA_AY_DI_32(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_ix(void)+{+ m68ki_write_32(EA_AY_IX_32(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_aw(void)+{+ m68ki_write_32(EA_AW_32(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_clr_32_al(void)+{+ m68ki_write_32(EA_AL_32(), 0);++ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+}+++static void m68k_op_cmp_8_d(void)+{+ uint src = MASK_OUT_ABOVE_8(DY);+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_ai(void)+{+ uint src = OPER_AY_AI_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_pi(void)+{+ uint src = OPER_AY_PI_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_pi7(void)+{+ uint src = OPER_A7_PI_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_pd(void)+{+ uint src = OPER_AY_PD_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_pd7(void)+{+ uint src = OPER_A7_PD_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_di(void)+{+ uint src = OPER_AY_DI_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_ix(void)+{+ uint src = OPER_AY_IX_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_aw(void)+{+ uint src = OPER_AW_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_al(void)+{+ uint src = OPER_AL_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_pcdi(void)+{+ uint src = OPER_PCDI_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_pcix(void)+{+ uint src = OPER_PCIX_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_8_i(void)+{+ uint src = OPER_I_8();+ uint dst = MASK_OUT_ABOVE_8(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmp_16_d(void)+{+ uint src = MASK_OUT_ABOVE_16(DY);+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_a(void)+{+ uint src = MASK_OUT_ABOVE_16(AY);+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_ai(void)+{+ uint src = OPER_AY_AI_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_pi(void)+{+ uint src = OPER_AY_PI_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_pd(void)+{+ uint src = OPER_AY_PD_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_di(void)+{+ uint src = OPER_AY_DI_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_ix(void)+{+ uint src = OPER_AY_IX_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_aw(void)+{+ uint src = OPER_AW_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_al(void)+{+ uint src = OPER_AL_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_pcdi(void)+{+ uint src = OPER_PCDI_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_pcix(void)+{+ uint src = OPER_PCIX_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_16_i(void)+{+ uint src = OPER_I_16();+ uint dst = MASK_OUT_ABOVE_16(DX);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmp_32_d(void)+{+ uint src = DY;+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_a(void)+{+ uint src = AY;+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_ai(void)+{+ uint src = OPER_AY_AI_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_pi(void)+{+ uint src = OPER_AY_PI_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_pd(void)+{+ uint src = OPER_AY_PD_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_di(void)+{+ uint src = OPER_AY_DI_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_ix(void)+{+ uint src = OPER_AY_IX_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_aw(void)+{+ uint src = OPER_AW_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_al(void)+{+ uint src = OPER_AL_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_pcdi(void)+{+ uint src = OPER_PCDI_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_pcix(void)+{+ uint src = OPER_PCIX_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmp_32_i(void)+{+ uint src = OPER_I_32();+ uint dst = DX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_d(void)+{+ uint src = MAKE_INT_16(DY);+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_a(void)+{+ uint src = MAKE_INT_16(AY);+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_ai(void)+{+ uint src = MAKE_INT_16(OPER_AY_AI_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_pi(void)+{+ uint src = MAKE_INT_16(OPER_AY_PI_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_pd(void)+{+ uint src = MAKE_INT_16(OPER_AY_PD_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_di(void)+{+ uint src = MAKE_INT_16(OPER_AY_DI_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_ix(void)+{+ uint src = MAKE_INT_16(OPER_AY_IX_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_aw(void)+{+ uint src = MAKE_INT_16(OPER_AW_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_al(void)+{+ uint src = MAKE_INT_16(OPER_AL_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_pcdi(void)+{+ uint src = MAKE_INT_16(OPER_PCDI_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_pcix(void)+{+ uint src = MAKE_INT_16(OPER_PCIX_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_16_i(void)+{+ uint src = MAKE_INT_16(OPER_I_16());+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_d(void)+{+ uint src = DY;+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_a(void)+{+ uint src = AY;+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_ai(void)+{+ uint src = OPER_AY_AI_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_pi(void)+{+ uint src = OPER_AY_PI_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_pd(void)+{+ uint src = OPER_AY_PD_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_di(void)+{+ uint src = OPER_AY_DI_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_ix(void)+{+ uint src = OPER_AY_IX_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_aw(void)+{+ uint src = OPER_AW_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_al(void)+{+ uint src = OPER_AL_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_pcdi(void)+{+ uint src = OPER_PCDI_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_pcix(void)+{+ uint src = OPER_PCIX_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpa_32_i(void)+{+ uint src = OPER_I_32();+ uint dst = AX;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_8_d(void)+{+ uint src = OPER_I_8();+ uint dst = MASK_OUT_ABOVE_8(DY);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_ai(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_AY_AI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_pi(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_AY_PI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_pi7(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_A7_PI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_pd(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_AY_PD_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_pd7(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_A7_PD_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_di(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_AY_DI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_ix(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_AY_IX_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_aw(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_AW_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_8_al(void)+{+ uint src = OPER_I_8();+ uint dst = OPER_AL_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpi_16_d(void)+{+ uint src = OPER_I_16();+ uint dst = MASK_OUT_ABOVE_16(DY);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_16_ai(void)+{+ uint src = OPER_I_16();+ uint dst = OPER_AY_AI_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_16_pi(void)+{+ uint src = OPER_I_16();+ uint dst = OPER_AY_PI_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_16_pd(void)+{+ uint src = OPER_I_16();+ uint dst = OPER_AY_PD_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_16_di(void)+{+ uint src = OPER_I_16();+ uint dst = OPER_AY_DI_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_16_ix(void)+{+ uint src = OPER_I_16();+ uint dst = OPER_AY_IX_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_16_aw(void)+{+ uint src = OPER_I_16();+ uint dst = OPER_AW_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_16_al(void)+{+ uint src = OPER_I_16();+ uint dst = OPER_AL_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpi_32_d(void)+{+ uint src = OPER_I_32();+ uint dst = DY;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_32_ai(void)+{+ uint src = OPER_I_32();+ uint dst = OPER_AY_AI_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_32_pi(void)+{+ uint src = OPER_I_32();+ uint dst = OPER_AY_PI_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_32_pd(void)+{+ uint src = OPER_I_32();+ uint dst = OPER_AY_PD_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_32_di(void)+{+ uint src = OPER_I_32();+ uint dst = OPER_AY_DI_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_32_ix(void)+{+ uint src = OPER_I_32();+ uint dst = OPER_AY_IX_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_32_aw(void)+{+ uint src = OPER_I_32();+ uint dst = OPER_AW_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpi_32_al(void)+{+ uint src = OPER_I_32();+ uint dst = OPER_AL_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_cmpm_8_ax7(void)+{+ uint src = OPER_AY_PI_8();+ uint dst = OPER_A7_PI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpm_8_ay7(void)+{+ uint src = OPER_A7_PI_8();+ uint dst = OPER_AX_PI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpm_8_axy7(void)+{+ uint src = OPER_A7_PI_8();+ uint dst = OPER_A7_PI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpm_8(void)+{+ uint src = OPER_AY_PI_8();+ uint dst = OPER_AX_PI_8();+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_C = CFLAG_8(res);+}+++static void m68k_op_cmpm_16(void)+{+ uint src = OPER_AY_PI_16();+ uint dst = OPER_AX_PI_16();+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_C = CFLAG_16(res);+}+++static void m68k_op_cmpm_32(void)+{+ uint src = OPER_AY_PI_32();+ uint dst = OPER_AX_PI_32();+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_C = CFLAG_SUB_32(src, dst, res);+}+++static void m68k_op_dbt_16(void)+{+ REG_PC += 2;+}+++static void m68k_op_dbf_16(void)+{+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+}+++static void m68k_op_dbhi_16(void)+{+ if(COND_NOT_HI())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbls_16(void)+{+ if(COND_NOT_LS())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbcc_16(void)+{+ if(COND_NOT_CC())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbcs_16(void)+{+ if(COND_NOT_CS())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbne_16(void)+{+ if(COND_NOT_NE())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbeq_16(void)+{+ if(COND_NOT_EQ())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbvc_16(void)+{+ if(COND_NOT_VC())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbvs_16(void)+{+ if(COND_NOT_VS())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbpl_16(void)+{+ if(COND_NOT_PL())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbmi_16(void)+{+ if(COND_NOT_MI())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbge_16(void)+{+ if(COND_NOT_GE())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dblt_16(void)+{+ if(COND_NOT_LT())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dbgt_16(void)+{+ if(COND_NOT_GT())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_dble_16(void)+{+ if(COND_NOT_LE())+ {+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ if(res != 0xffff)+ {+ uint offset = OPER_I_16();+ REG_PC -= 2;+ m68ki_branch_16(offset);+ USE_CYCLES(CYC_DBCC_F_NOEXP);++ /* reset idle loop detection */+ m68ki_cpu.poll.detected = 0;+ return;+ }+ REG_PC += 2;+ USE_CYCLES(CYC_DBCC_F_EXP);+ return;+ }+ REG_PC += 2;+}+++static void m68k_op_divs_16_d(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(DY);+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_ai(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_AI_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_pi(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_PI_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_pd(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_PD_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_di(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_DI_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_ix(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_IX_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_aw(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AW_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_al(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AL_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_pcdi(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_PCDI_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_pcix(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_PCIX_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divs_16_i(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_I_16());+ sint quotient;+ sint remainder;++ if(src != 0)+ {+ UseDivsCycles(*r_dst,src);++ if((uint32)*r_dst == 0x80000000 && src == -1)+ {+ FLAG_Z = 0;+ FLAG_N = NFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = 0;+ return;+ }++ quotient = MAKE_INT_32(*r_dst) / src;+ remainder = MAKE_INT_32(*r_dst) % src;++ if(quotient == MAKE_INT_16(quotient))+ {+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_d(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(DY);++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_divu_16_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_16();++ if(src != 0)+ {+ uint quotient = *r_dst / src;+ uint remainder = *r_dst % src;++ if(quotient < 0x10000)+ {+ UseDivuCycles(*r_dst,src);+ FLAG_Z = quotient;+ FLAG_N = NFLAG_16(quotient);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));+ return;+ }+ USE_CYCLES(MUL * 10);+ FLAG_V = VFLAG_SET;+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */+ FLAG_C = CFLAG_CLEAR;+ return;+ }+ FLAG_C = CFLAG_CLEAR;+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);+}+++static void m68k_op_eor_8_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY ^= MASK_OUT_ABOVE_8(DX));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_di(void)+{+ uint ea = EA_AY_DI_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_aw(void)+{+ uint ea = EA_AW_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_8_al(void)+{+ uint ea = EA_AL_8();+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY ^= MASK_OUT_ABOVE_16(DX));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_aw(void)+{+ uint ea = EA_AW_16();+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_16_al(void)+{+ uint ea = EA_AL_16();+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_d(void)+{+ uint res = DY ^= DX;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint res = DX ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint res = DX ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint res = DX ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_di(void)+{+ uint ea = EA_AY_DI_32();+ uint res = DX ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint res = DX ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_aw(void)+{+ uint ea = EA_AW_32();+ uint res = DX ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eor_32_al(void)+{+ uint ea = EA_AL_32();+ uint res = DX ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY ^= OPER_I_8());++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_ai(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_AI_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_pi(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PI_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_pi7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PI_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_pd(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PD_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_pd7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PD_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_di(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_DI_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_ix(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_IX_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_aw(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AW_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_8_al(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AL_8();+ uint res = src ^ m68ki_read_8(ea);++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY ^= OPER_I_16());++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_ai(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_AI_16();+ uint res = src ^ m68ki_read_16(ea);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_pi(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PI_16();+ uint res = src ^ m68ki_read_16(ea);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_pd(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PD_16();+ uint res = src ^ m68ki_read_16(ea);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_di(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_DI_16();+ uint res = src ^ m68ki_read_16(ea);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_ix(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_IX_16();+ uint res = src ^ m68ki_read_16(ea);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_aw(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AW_16();+ uint res = src ^ m68ki_read_16(ea);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_al(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AL_16();+ uint res = src ^ m68ki_read_16(ea);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_d(void)+{+ uint res = DY ^= OPER_I_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_ai(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_AI_32();+ uint res = src ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_pi(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PI_32();+ uint res = src ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_pd(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PD_32();+ uint res = src ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_di(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_DI_32();+ uint res = src ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_ix(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_IX_32();+ uint res = src ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_aw(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AW_32();+ uint res = src ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_32_al(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AL_32();+ uint res = src ^ m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_eori_16_toc(void)+{+ m68ki_set_ccr(m68ki_get_ccr() ^ OPER_I_16());+}+++static void m68k_op_eori_16_tos(void)+{+ if(FLAG_S)+ {+ uint src = OPER_I_16();+ m68ki_set_sr(m68ki_get_sr() ^ src);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_exg_32_dd(void)+{+ uint* reg_a = &DX;+ uint* reg_b = &DY;+ uint tmp = *reg_a;+ *reg_a = *reg_b;+ *reg_b = tmp;+}+++static void m68k_op_exg_32_aa(void)+{+ uint* reg_a = &AX;+ uint* reg_b = &AY;+ uint tmp = *reg_a;+ *reg_a = *reg_b;+ *reg_b = tmp;+}+++static void m68k_op_exg_32_da(void)+{+ uint* reg_a = &DX;+ uint* reg_b = &AY;+ uint tmp = *reg_a;+ *reg_a = *reg_b;+ *reg_b = tmp;+}+++static void m68k_op_ext_16(void)+{+ uint* r_dst = &DY;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | MASK_OUT_ABOVE_8(*r_dst) | (GET_MSB_8(*r_dst) ? 0xff00 : 0);++ FLAG_N = NFLAG_16(*r_dst);+ FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_ext_32(void)+{+ uint* r_dst = &DY;++ *r_dst = MASK_OUT_ABOVE_16(*r_dst) | (GET_MSB_16(*r_dst) ? 0xffff0000 : 0);++ FLAG_N = NFLAG_32(*r_dst);+ FLAG_Z = *r_dst;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_illegal(void)+{+ m68ki_exception_illegal();+}+++static void m68k_op_jmp_32_ai(void)+{+ m68ki_jump(EA_AY_AI_32());+}+++static void m68k_op_jmp_32_di(void)+{+ m68ki_jump(EA_AY_DI_32());+}+++static void m68k_op_jmp_32_ix(void)+{+ m68ki_jump(EA_AY_IX_32());+}+++static void m68k_op_jmp_32_aw(void)+{+ m68ki_jump(EA_AW_32());+}+++static void m68k_op_jmp_32_al(void)+{+ m68ki_jump(EA_AL_32());+}+++static void m68k_op_jmp_32_pcdi(void)+{+ m68ki_jump(EA_PCDI_32());+}+++static void m68k_op_jmp_32_pcix(void)+{+ m68ki_jump(EA_PCIX_32());+}+++static void m68k_op_jsr_32_ai(void)+{+ uint ea = EA_AY_AI_32();+ m68ki_push_32(REG_PC);+ m68ki_jump(ea);+}+++static void m68k_op_jsr_32_di(void)+{+ uint ea = EA_AY_DI_32();+ m68ki_push_32(REG_PC);+ m68ki_jump(ea);+}+++static void m68k_op_jsr_32_ix(void)+{+ uint ea = EA_AY_IX_32();+ m68ki_push_32(REG_PC);+ m68ki_jump(ea);+}+++static void m68k_op_jsr_32_aw(void)+{+ uint ea = EA_AW_32();+ m68ki_push_32(REG_PC);+ m68ki_jump(ea);+}+++static void m68k_op_jsr_32_al(void)+{+ uint ea = EA_AL_32();+ m68ki_push_32(REG_PC);+ m68ki_jump(ea);+}+++static void m68k_op_jsr_32_pcdi(void)+{+ uint ea = EA_PCDI_32();+ m68ki_push_32(REG_PC);+ m68ki_jump(ea);+}+++static void m68k_op_jsr_32_pcix(void)+{+ uint ea = EA_PCIX_32();+ m68ki_push_32(REG_PC);+ m68ki_jump(ea);+}+++static void m68k_op_lea_32_ai(void)+{+ AX = EA_AY_AI_32();+}+++static void m68k_op_lea_32_di(void)+{+ AX = EA_AY_DI_32();+}+++static void m68k_op_lea_32_ix(void)+{+ AX = EA_AY_IX_32();+}+++static void m68k_op_lea_32_aw(void)+{+ AX = EA_AW_32();+}+++static void m68k_op_lea_32_al(void)+{+ AX = EA_AL_32();+}+++static void m68k_op_lea_32_pcdi(void)+{+ AX = EA_PCDI_32();+}+++static void m68k_op_lea_32_pcix(void)+{+ AX = EA_PCIX_32();+}+++static void m68k_op_link_16_a7(void)+{+ REG_A[7] -= 4;+ m68ki_write_32(REG_A[7], REG_A[7]);+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));+}+++static void m68k_op_link_16(void)+{+ uint* r_dst = &AY;++ m68ki_push_32(*r_dst);+ *r_dst = REG_A[7];+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));+}+++static void m68k_op_lsr_8_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_X = FLAG_C = src << (9-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_X = FLAG_C = src << (9-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_32_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = *r_dst;+ uint res = src >> shift;++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_X = FLAG_C = src << (9-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_8_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift <= 8)+ {+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+ FLAG_X = FLAG_C = src << (9-shift);+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst &= 0xffffff00;+ FLAG_X = XFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_8(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = src >> shift;++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift <= 16)+ {+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst &= 0xffff0000;+ FLAG_X = XFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_16(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_32_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = *r_dst;+ uint res = src >> shift;++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 32)+ {+ *r_dst = res;+ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst = 0;+ FLAG_X = FLAG_C = (shift == 32 ? GET_MSB_32(src)>>23 : 0);+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_32(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_C = FLAG_X = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_C = FLAG_X = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_C = FLAG_X = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_C = FLAG_X = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_C = FLAG_X = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_C = FLAG_X = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsr_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = src >> 1;++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = res;+ FLAG_C = FLAG_X = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_8_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = MASK_OUT_ABOVE_8(src << shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src << shift;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = MASK_OUT_ABOVE_16(src << shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> (8-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_32_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32(src << shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> (24-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_8_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = MASK_OUT_ABOVE_8(src << shift);++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift <= 8)+ {+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+ FLAG_X = FLAG_C = src << shift;+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst &= 0xffffff00;+ FLAG_X = XFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_8(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = MASK_OUT_ABOVE_16(src << shift);++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift <= 16)+ {+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ FLAG_X = FLAG_C = (src << shift) >> 8;+ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst &= 0xffff0000;+ FLAG_X = XFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_16(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_32_r(void)+{+ uint* r_dst = &DY;+ uint shift = DX & 0x3f;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32(src << shift);++ if(shift != 0)+ {+ USE_CYCLES(shift * CYC_SHIFT);++ if(shift < 32)+ {+ *r_dst = res;+ FLAG_X = FLAG_C = (src >> (32 - shift)) << 8;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ *r_dst = 0;+ FLAG_X = FLAG_C = ((shift == 32 ? src & 1 : 0))<<8;+ FLAG_N = NFLAG_CLEAR;+ FLAG_Z = ZFLAG_SET;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_32(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_lsl_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(src << 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_X = FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_move_8_d_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_di(void)+{+ uint res = OPER_AY_DI_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_aw(void)+{+ uint res = OPER_AW_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_al(void)+{+ uint res = OPER_AL_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_d_i(void)+{+ uint res = OPER_I_8();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_8_ai_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ai_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_AX_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi7_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pi_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_AX_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd7_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_pd_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_AX_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_di_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_AX_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_ix_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_AX_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_aw_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_ai(void)+{+ uint res = OPER_AY_AI_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_pi(void)+{+ uint res = OPER_AY_PI_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_pi7(void)+{+ uint res = OPER_A7_PI_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_pd(void)+{+ uint res = OPER_AY_PD_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_pd7(void)+{+ uint res = OPER_A7_PD_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_di(void)+{+ uint res = OPER_AY_DI_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_ix(void)+{+ uint res = OPER_AY_IX_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_aw(void)+{+ uint res = OPER_AW_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_al(void)+{+ uint res = OPER_AL_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_pcdi(void)+{+ uint res = OPER_PCDI_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_pcix(void)+{+ uint res = OPER_PCIX_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_8_al_i(void)+{+ uint res = OPER_I_8();+ uint ea = EA_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_8(ea, res);+}+++static void m68k_op_move_16_d_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_di(void)+{+ uint res = OPER_AY_DI_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_aw(void)+{+ uint res = OPER_AW_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_al(void)+{+ uint res = OPER_AL_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_d_i(void)+{+ uint res = OPER_I_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_16_ai_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_di(void)+{+ uint res = OPER_AY_DI_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_aw(void)+{+ uint res = OPER_AW_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_al(void)+{+ uint res = OPER_AL_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ai_i(void)+{+ uint res = OPER_I_16();+ uint ea = EA_AX_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_di(void)+{+ uint res = OPER_AY_DI_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_aw(void)+{+ uint res = OPER_AW_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_al(void)+{+ uint res = OPER_AL_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pi_i(void)+{+ uint res = OPER_I_16();+ uint ea = EA_AX_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_di(void)+{+ uint res = OPER_AY_DI_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_aw(void)+{+ uint res = OPER_AW_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_al(void)+{+ uint res = OPER_AL_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_pd_i(void)+{+ uint res = OPER_I_16();+ uint ea = EA_AX_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_di(void)+{+ uint res = OPER_AY_DI_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_aw(void)+{+ uint res = OPER_AW_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_al(void)+{+ uint res = OPER_AL_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_di_i(void)+{+ uint res = OPER_I_16();+ uint ea = EA_AX_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_di(void)+{+ uint res = OPER_AY_DI_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_aw(void)+{+ uint res = OPER_AW_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_al(void)+{+ uint res = OPER_AL_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_ix_i(void)+{+ uint res = OPER_I_16();+ uint ea = EA_AX_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_di(void)+{+ uint res = OPER_AY_DI_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_aw(void)+{+ uint res = OPER_AW_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_al(void)+{+ uint res = OPER_AL_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_aw_i(void)+{+ uint res = OPER_I_16();+ uint ea = EA_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_a(void)+{+ uint res = MASK_OUT_ABOVE_16(AY);+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_ai(void)+{+ uint res = OPER_AY_AI_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_pi(void)+{+ uint res = OPER_AY_PI_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_pd(void)+{+ uint res = OPER_AY_PD_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_di(void)+{+ uint res = OPER_AY_DI_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_ix(void)+{+ uint res = OPER_AY_IX_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_aw(void)+{+ uint res = OPER_AW_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_al(void)+{+ uint res = OPER_AL_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_pcdi(void)+{+ uint res = OPER_PCDI_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_pcix(void)+{+ uint res = OPER_PCIX_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_16_al_i(void)+{+ uint res = OPER_I_16();+ uint ea = EA_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea, res);+}+++static void m68k_op_move_32_d_d(void)+{+ uint res = DY;+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_a(void)+{+ uint res = AY;+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_di(void)+{+ uint res = OPER_AY_DI_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_aw(void)+{+ uint res = OPER_AW_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_al(void)+{+ uint res = OPER_AL_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_d_i(void)+{+ uint res = OPER_I_32();+ uint* r_dst = &DX;++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_move_32_ai_d(void)+{+ uint res = DY;+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_a(void)+{+ uint res = AY;+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_di(void)+{+ uint res = OPER_AY_DI_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_aw(void)+{+ uint res = OPER_AW_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_al(void)+{+ uint res = OPER_AL_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ai_i(void)+{+ uint res = OPER_I_32();+ uint ea = EA_AX_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_d(void)+{+ uint res = DY;+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_a(void)+{+ uint res = AY;+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_di(void)+{+ uint res = OPER_AY_DI_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_aw(void)+{+ uint res = OPER_AW_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_al(void)+{+ uint res = OPER_AL_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pi_i(void)+{+ uint res = OPER_I_32();+ uint ea = EA_AX_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_pd_d(void)+{+ uint res = DY;+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_a(void)+{+ uint res = AY;+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_di(void)+{+ uint res = OPER_AY_DI_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_aw(void)+{+ uint res = OPER_AW_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_al(void)+{+ uint res = OPER_AL_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_pd_i(void)+{+ uint res = OPER_I_32();+ uint ea = EA_AX_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_16(ea+2, res & 0xFFFF );+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );+}+++static void m68k_op_move_32_di_d(void)+{+ uint res = DY;+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_a(void)+{+ uint res = AY;+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_di(void)+{+ uint res = OPER_AY_DI_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_aw(void)+{+ uint res = OPER_AW_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_al(void)+{+ uint res = OPER_AL_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_di_i(void)+{+ uint res = OPER_I_32();+ uint ea = EA_AX_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_d(void)+{+ uint res = DY;+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_a(void)+{+ uint res = AY;+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_di(void)+{+ uint res = OPER_AY_DI_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_aw(void)+{+ uint res = OPER_AW_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_al(void)+{+ uint res = OPER_AL_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_ix_i(void)+{+ uint res = OPER_I_32();+ uint ea = EA_AX_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_d(void)+{+ uint res = DY;+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_a(void)+{+ uint res = AY;+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_di(void)+{+ uint res = OPER_AY_DI_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_aw(void)+{+ uint res = OPER_AW_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_al(void)+{+ uint res = OPER_AL_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_aw_i(void)+{+ uint res = OPER_I_32();+ uint ea = EA_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_d(void)+{+ uint res = DY;+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_a(void)+{+ uint res = AY;+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_ai(void)+{+ uint res = OPER_AY_AI_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_pi(void)+{+ uint res = OPER_AY_PI_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_pd(void)+{+ uint res = OPER_AY_PD_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_di(void)+{+ uint res = OPER_AY_DI_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_ix(void)+{+ uint res = OPER_AY_IX_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_aw(void)+{+ uint res = OPER_AW_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_al(void)+{+ uint res = OPER_AL_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_pcdi(void)+{+ uint res = OPER_PCDI_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_pcix(void)+{+ uint res = OPER_PCIX_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_move_32_al_i(void)+{+ uint res = OPER_I_32();+ uint ea = EA_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ m68ki_write_32(ea, res);+}+++static void m68k_op_movea_16_d(void)+{+ AX = MAKE_INT_16(DY);+}+++static void m68k_op_movea_16_a(void)+{+ AX = MAKE_INT_16(AY);+}+++static void m68k_op_movea_16_ai(void)+{+ AX = MAKE_INT_16(OPER_AY_AI_16());+}+++static void m68k_op_movea_16_pi(void)+{+ AX = MAKE_INT_16(OPER_AY_PI_16());+}+++static void m68k_op_movea_16_pd(void)+{+ AX = MAKE_INT_16(OPER_AY_PD_16());+}+++static void m68k_op_movea_16_di(void)+{+ AX = MAKE_INT_16(OPER_AY_DI_16());+}+++static void m68k_op_movea_16_ix(void)+{+ AX = MAKE_INT_16(OPER_AY_IX_16());+}+++static void m68k_op_movea_16_aw(void)+{+ AX = MAKE_INT_16(OPER_AW_16());+}+++static void m68k_op_movea_16_al(void)+{+ AX = MAKE_INT_16(OPER_AL_16());+}+++static void m68k_op_movea_16_pcdi(void)+{+ AX = MAKE_INT_16(OPER_PCDI_16());+}+++static void m68k_op_movea_16_pcix(void)+{+ AX = MAKE_INT_16(OPER_PCIX_16());+}+++static void m68k_op_movea_16_i(void)+{+ AX = MAKE_INT_16(OPER_I_16());+}+++static void m68k_op_movea_32_d(void)+{+ AX = DY;+}+++static void m68k_op_movea_32_a(void)+{+ AX = AY;+}+++static void m68k_op_movea_32_ai(void)+{+ AX = OPER_AY_AI_32();+}+++static void m68k_op_movea_32_pi(void)+{+ AX = OPER_AY_PI_32();+}+++static void m68k_op_movea_32_pd(void)+{+ AX = OPER_AY_PD_32();+}+++static void m68k_op_movea_32_di(void)+{+ AX = OPER_AY_DI_32();+}+++static void m68k_op_movea_32_ix(void)+{+ AX = OPER_AY_IX_32();+}+++static void m68k_op_movea_32_aw(void)+{+ AX = OPER_AW_32();+}+++static void m68k_op_movea_32_al(void)+{+ AX = OPER_AL_32();+}+++static void m68k_op_movea_32_pcdi(void)+{+ AX = OPER_PCDI_32();+}+++static void m68k_op_movea_32_pcix(void)+{+ AX = OPER_PCIX_32();+}+++static void m68k_op_movea_32_i(void)+{+ AX = OPER_I_32();+}++static void m68k_op_move_16_toc_d(void)+{+ m68ki_set_ccr(DY);+}+++static void m68k_op_move_16_toc_ai(void)+{+ m68ki_set_ccr(OPER_AY_AI_16());+}+++static void m68k_op_move_16_toc_pi(void)+{+ m68ki_set_ccr(OPER_AY_PI_16());+}+++static void m68k_op_move_16_toc_pd(void)+{+ m68ki_set_ccr(OPER_AY_PD_16());+}+++static void m68k_op_move_16_toc_di(void)+{+ m68ki_set_ccr(OPER_AY_DI_16());+}+++static void m68k_op_move_16_toc_ix(void)+{+ m68ki_set_ccr(OPER_AY_IX_16());+}+++static void m68k_op_move_16_toc_aw(void)+{+ m68ki_set_ccr(OPER_AW_16());+}+++static void m68k_op_move_16_toc_al(void)+{+ m68ki_set_ccr(OPER_AL_16());+}+++static void m68k_op_move_16_toc_pcdi(void)+{+ m68ki_set_ccr(OPER_PCDI_16());+}+++static void m68k_op_move_16_toc_pcix(void)+{+ m68ki_set_ccr(OPER_PCIX_16());+}+++static void m68k_op_move_16_toc_i(void)+{+ m68ki_set_ccr(OPER_I_16());+}+++static void m68k_op_move_16_frs_d(void)+{+ DY = MASK_OUT_BELOW_16(DY) | m68ki_get_sr();+}+++static void m68k_op_move_16_frs_ai(void)+{+ uint ea = EA_AY_AI_16();+ m68ki_write_16(ea, m68ki_get_sr());+}+++static void m68k_op_move_16_frs_pi(void)+{+ uint ea = EA_AY_PI_16();+ m68ki_write_16(ea, m68ki_get_sr());+}+++static void m68k_op_move_16_frs_pd(void)+{+ uint ea = EA_AY_PD_16();+ m68ki_write_16(ea, m68ki_get_sr());+}+++static void m68k_op_move_16_frs_di(void)+{+ uint ea = EA_AY_DI_16();+ m68ki_write_16(ea, m68ki_get_sr());+}+++static void m68k_op_move_16_frs_ix(void)+{+ uint ea = EA_AY_IX_16();+ m68ki_write_16(ea, m68ki_get_sr());+}+++static void m68k_op_move_16_frs_aw(void)+{+ uint ea = EA_AW_16();+ m68ki_write_16(ea, m68ki_get_sr());+}+++static void m68k_op_move_16_frs_al(void)+{+ uint ea = EA_AL_16();+ m68ki_write_16(ea, m68ki_get_sr());+}+++static void m68k_op_move_16_tos_d(void)+{+ if(FLAG_S)+ {+ m68ki_set_sr(DY);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_ai(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_AY_AI_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_pi(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_AY_PI_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_pd(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_AY_PD_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_di(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_AY_DI_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_ix(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_AY_IX_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_aw(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_AW_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_al(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_AL_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_pcdi(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_PCDI_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_pcix(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_PCIX_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_16_tos_i(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_I_16();+ m68ki_set_sr(new_sr);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_32_fru(void)+{+ if(FLAG_S)+ {+ AY = REG_USP;+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_move_32_tou(void)+{+ if(FLAG_S)+ {+ REG_USP = AY;+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_movem_16_re_pd(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = AY;+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ ea -= 2;+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[15-i]));+ count++;+ }+ AY = ea;++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_re_ai(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_AI_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_re_di(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_DI_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_re_ix(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_IX_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_re_aw(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AW_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_re_al(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AL_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_32_re_pd(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = AY;+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ ea -= 4;+ m68ki_write_16(ea+2, REG_DA[15-i] & 0xFFFF );+ m68ki_write_16(ea, (REG_DA[15-i] >> 16) & 0xFFFF );+ count++;+ }+ AY = ea;++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_re_ai(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_AI_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_32(ea, REG_DA[i]);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_re_di(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_DI_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_32(ea, REG_DA[i]);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_re_ix(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_IX_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_32(ea, REG_DA[i]);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_re_aw(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AW_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_32(ea, REG_DA[i]);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_re_al(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AL_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ m68ki_write_32(ea, REG_DA[i]);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_16_er_pi(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = AY;+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));+ ea += 2;+ count++;+ }+ AY = ea;++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_er_pcdi(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_PCDI_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(ea)));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_er_pcix(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_PCIX_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(ea)));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_er_ai(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_AI_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_er_di(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_DI_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_er_ix(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_IX_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_er_aw(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AW_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_16_er_al(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AL_16();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));+ ea += 2;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_W);+}+++static void m68k_op_movem_32_er_pi(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = AY;+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_32(ea);+ ea += 4;+ count++;+ }+ AY = ea;++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_er_pcdi(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_PCDI_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_pcrel_32(ea);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_er_pcix(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_PCIX_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_pcrel_32(ea);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_er_ai(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_AI_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_32(ea);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_er_di(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_DI_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_32(ea);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_er_ix(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AY_IX_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_32(ea);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_er_aw(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AW_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_32(ea);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movem_32_er_al(void)+{+ uint i = 0;+ uint register_list = OPER_I_16();+ uint ea = EA_AL_32();+ uint count = 0;++ for(; i < 16; i++)+ if(register_list & (1 << i))+ {+ REG_DA[i] = m68ki_read_32(ea);+ ea += 4;+ count++;+ }++ USE_CYCLES(count * CYC_MOVEM_L);+}+++static void m68k_op_movep_16_re(void)+{+ uint ea = EA_AY_DI_16();+ uint src = DX;++ m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 8));+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src));+}+++static void m68k_op_movep_32_re(void)+{+ uint ea = EA_AY_DI_32();+ uint src = DX;++ m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 24));+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 16));+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 8));+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src));+}+++static void m68k_op_movep_16_er(void)+{+ uint ea = EA_AY_DI_16();+ uint* r_dst = &DX;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | ((m68ki_read_8(ea) << 8) + m68ki_read_8(ea + 2));+}+++static void m68k_op_movep_32_er(void)+{+ uint ea = EA_AY_DI_32();++ DX = (m68ki_read_8(ea) << 24) + (m68ki_read_8(ea + 2) << 16)+ + (m68ki_read_8(ea + 4) << 8) + m68ki_read_8(ea + 6);+}+++static void m68k_op_moveq_32(void)+{+ uint res = DX = MAKE_INT_8(MASK_OUT_ABOVE_8(REG_IR));++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_d(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(DY);+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_ai(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_AI_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_pi(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_PI_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_pd(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_PD_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_di(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_DI_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_ix(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AY_IX_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_aw(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AW_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_al(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_AL_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_pcdi(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_PCDI_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_pcix(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_PCIX_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_muls_16_i(void)+{+ uint* r_dst = &DX;+ sint src = MAKE_INT_16(OPER_I_16());+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));++ UseMulsCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_d(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(DY);+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_mulu_16_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_16();+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);++ UseMuluCycles(src);++ *r_dst = res;++ FLAG_Z = res;+ FLAG_N = NFLAG_32(res);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_nbcd_8_d(void)+{+ uint* r_dst = &DY;+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_di(void)+{+ uint ea = EA_AY_DI_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_aw(void)+{+ uint ea = EA_AW_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_nbcd_8_al(void)+{+ uint ea = EA_AL_8();+ uint dst = m68ki_read_8(ea);+ uint res = -dst - XFLAG_AS_1();++ if(res)+ {+ FLAG_V = res; /* Undefined V behavior */++ if(((res|dst) & 0x0f) == 0x0)+ res = (res & 0xf0) + 6;++ res = MASK_OUT_ABOVE_8(res+0x9a);++ FLAG_V &= ~res; /* Undefined V behavior part II */++ m68ki_write_8(ea, res);++ FLAG_Z |= res;+ FLAG_C = CFLAG_SET;+ FLAG_X = XFLAG_SET;+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ }+ else+ {+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ FLAG_X = XFLAG_CLEAR;+ FLAG_N = NFLAG_CLEAR;+ }+}+++static void m68k_op_neg_8_d(void)+{+ uint* r_dst = &DY;+ uint res = 0 - MASK_OUT_ABOVE_8(*r_dst);++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = *r_dst & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_neg_8_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_di(void)+{+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_aw(void)+{+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_8_al(void)+{+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_8(res);+ FLAG_C = FLAG_X = CFLAG_8(res);+ FLAG_V = src & res;+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_neg_16_d(void)+{+ uint* r_dst = &DY;+ uint res = 0 - MASK_OUT_ABOVE_16(*r_dst);++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (*r_dst & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_neg_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (src & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_neg_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (src & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_neg_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (src & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_neg_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (src & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_neg_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (src & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_neg_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (src & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_neg_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_16(res);+ FLAG_C = FLAG_X = CFLAG_16(res);+ FLAG_V = (src & res)>>8;+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_neg_32_d(void)+{+ uint* r_dst = &DY;+ uint res = 0 - *r_dst;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(*r_dst, 0, res);+ FLAG_V = (*r_dst & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_neg_32_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_neg_32_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_neg_32_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_neg_32_di(void)+{+ uint ea = EA_AY_DI_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_neg_32_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_neg_32_aw(void)+{+ uint ea = EA_AW_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_neg_32_al(void)+{+ uint ea = EA_AL_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - src;++ FLAG_N = NFLAG_32(res);+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_negx_8_d(void)+{+ uint* r_dst = &DY;+ uint res = 0 - MASK_OUT_ABOVE_8(*r_dst) - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = *r_dst & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+}+++static void m68k_op_negx_8_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_di(void)+{+ uint ea = EA_AY_DI_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_aw(void)+{+ uint ea = EA_AW_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_8_al(void)+{+ uint ea = EA_AL_8();+ uint src = m68ki_read_8(ea);+ uint res = 0 - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = src & res;++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_negx_16_d(void)+{+ uint* r_dst = &DY;+ uint res = 0 - MASK_OUT_ABOVE_16(*r_dst) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (*r_dst & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+}+++static void m68k_op_negx_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (src & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_negx_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (src & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_negx_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (src & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_negx_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (src & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_negx_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (src & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_negx_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (src & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_negx_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = (src & res)>>8;++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_negx_32_d(void)+{+ uint* r_dst = &DY;+ uint res = 0 - MASK_OUT_ABOVE_32(*r_dst) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(*r_dst, 0, res);+ FLAG_V = (*r_dst & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ *r_dst = res;+}+++static void m68k_op_negx_32_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_negx_32_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_negx_32_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_negx_32_di(void)+{+ uint ea = EA_AY_DI_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_negx_32_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_negx_32_aw(void)+{+ uint ea = EA_AW_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_negx_32_al(void)+{+ uint ea = EA_AL_32();+ uint src = m68ki_read_32(ea);+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);+ FLAG_V = (src & res)>>24;++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_nop(void)+{+}+++static void m68k_op_not_8_d(void)+{+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_8(~*r_dst);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_di(void)+{+ uint ea = EA_AY_DI_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_aw(void)+{+ uint ea = EA_AW_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_8_al(void)+{+ uint ea = EA_AL_8();+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_d(void)+{+ uint* r_dst = &DY;+ uint res = MASK_OUT_ABOVE_16(~*r_dst);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_aw(void)+{+ uint ea = EA_AW_16();+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_16_al(void)+{+ uint ea = EA_AL_16();+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_d(void)+{+ uint* r_dst = &DY;+ uint res = *r_dst = MASK_OUT_ABOVE_32(~*r_dst);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_di(void)+{+ uint ea = EA_AY_DI_32();+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_aw(void)+{+ uint ea = EA_AW_32();+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_not_32_al(void)+{+ uint ea = EA_AL_32();+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_d(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= MASK_OUT_ABOVE_8(DY)));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_ai(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_AI_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_pi(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_PI_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_pi7(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_A7_PI_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_pd(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_PD_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_pd7(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_A7_PD_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_di(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_DI_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_ix(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_IX_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_aw(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AW_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_al(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AL_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_pcdi(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_PCDI_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_pcix(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_PCIX_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_er_i(void)+{+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_I_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_d(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= MASK_OUT_ABOVE_16(DY)));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_ai(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_AI_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_pi(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_PI_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_pd(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_PD_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_di(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_DI_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_ix(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_IX_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_aw(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AW_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_al(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AL_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_pcdi(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_PCDI_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_pcix(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_PCIX_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_er_i(void)+{+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_I_16()));++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_d(void)+{+ uint res = DX |= DY;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_ai(void)+{+ uint res = DX |= OPER_AY_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_pi(void)+{+ uint res = DX |= OPER_AY_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_pd(void)+{+ uint res = DX |= OPER_AY_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_di(void)+{+ uint res = DX |= OPER_AY_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_ix(void)+{+ uint res = DX |= OPER_AY_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_aw(void)+{+ uint res = DX |= OPER_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_al(void)+{+ uint res = DX |= OPER_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_pcdi(void)+{+ uint res = DX |= OPER_PCDI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_pcix(void)+{+ uint res = DX |= OPER_PCIX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_er_i(void)+{+ uint res = DX |= OPER_I_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_di(void)+{+ uint ea = EA_AY_DI_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_aw(void)+{+ uint ea = EA_AW_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_8_re_al(void)+{+ uint ea = EA_AL_8();+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_re_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_re_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_re_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_re_di(void)+{+ uint ea = EA_AY_DI_16();+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_re_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_re_aw(void)+{+ uint ea = EA_AW_16();+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_16_re_al(void)+{+ uint ea = EA_AL_16();+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_re_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint res = DX | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_re_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint res = DX | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_re_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint res = DX | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_re_di(void)+{+ uint ea = EA_AY_DI_32();+ uint res = DX | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_re_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint res = DX | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_re_aw(void)+{+ uint ea = EA_AW_32();+ uint res = DX | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_or_32_re_al(void)+{+ uint ea = EA_AL_32();+ uint res = DX | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_d(void)+{+ uint res = MASK_OUT_ABOVE_8((DY |= OPER_I_8()));++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_ai(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_AI_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_pi(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PI_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_pi7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PI_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_pd(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PD_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_pd7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PD_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_di(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_DI_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_ix(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_IX_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_aw(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AW_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_8_al(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AL_8();+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));++ m68ki_write_8(ea, res);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY |= OPER_I_16());++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_ai(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_AI_16();+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_pi(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PI_16();+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_pd(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PD_16();+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_di(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_DI_16();+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_ix(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_IX_16();+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_aw(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AW_16();+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_al(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AL_16();+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_d(void)+{+ uint res = DY |= OPER_I_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_ai(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_AI_32();+ uint res = src | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_pi(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PI_32();+ uint res = src | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_pd(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PD_32();+ uint res = src | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_di(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_DI_32();+ uint res = src | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_ix(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_IX_32();+ uint res = src | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_aw(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AW_32();+ uint res = src | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_32_al(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AL_32();+ uint res = src | m68ki_read_32(ea);++ m68ki_write_32(ea, res);++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ori_16_toc(void)+{+ m68ki_set_ccr(m68ki_get_ccr() | OPER_I_16());+}+++static void m68k_op_ori_16_tos(void)+{+ if(FLAG_S)+ {+ uint src = OPER_I_16();+ m68ki_set_sr(m68ki_get_sr() | src);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_pea_32_ai(void)+{+ uint ea = EA_AY_AI_32();++ m68ki_push_32(ea);+}+++static void m68k_op_pea_32_di(void)+{+ uint ea = EA_AY_DI_32();++ m68ki_push_32(ea);+}+++static void m68k_op_pea_32_ix(void)+{+ uint ea = EA_AY_IX_32();++ m68ki_push_32(ea);+}+++static void m68k_op_pea_32_aw(void)+{+ uint ea = EA_AW_32();++ m68ki_push_32(ea);+}+++static void m68k_op_pea_32_al(void)+{+ uint ea = EA_AL_32();++ m68ki_push_32(ea);+}+++static void m68k_op_pea_32_pcdi(void)+{+ uint ea = EA_PCDI_32();++ m68ki_push_32(ea);+}+++static void m68k_op_pea_32_pcix(void)+{+ uint ea = EA_PCIX_32();++ m68ki_push_32(ea);+}+++static void m68k_op_reset(void)+{+ if(FLAG_S)+ {+ m68ki_output_reset() /* auto-disable (see m68kcpu.h) */+ USE_CYCLES(CYC_RESET);+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_ror_8_s(void)+{+ uint* r_dst = &DY;+ uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint shift = orig_shift & 7;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROR_8(src, shift);++ if(orig_shift != 0)+ USE_CYCLES(orig_shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = src << (9-orig_shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = ROR_16(src, shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << (9-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_32_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint64 src = *r_dst;+ uint res = ROR_32(src, shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = src << (9-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_8_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift & 7;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROR_8(src, shift);++ if(orig_shift != 0)+ {+ USE_CYCLES(orig_shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+ FLAG_C = src << (8-((shift-1)&7));+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_8(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift & 15;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = ROR_16(src, shift);++ if(orig_shift != 0)+ {+ USE_CYCLES(orig_shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ FLAG_C = (src >> ((shift - 1) & 15)) << 8;+ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_16(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_32_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift & 31;+ uint64 src = *r_dst;+ uint res = ROR_32(src, shift);++ if(orig_shift != 0)+ {+ USE_CYCLES(orig_shift * CYC_SHIFT);++ *r_dst = res;+ FLAG_C = (src >> ((shift - 1) & 31)) << 8;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_32(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_16(src, 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_16(src, 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_16(src, 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_16(src, 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_16(src, 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_16(src, 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_ror_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_16(src, 1);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src << 8;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_8_s(void)+{+ uint* r_dst = &DY;+ uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint shift = orig_shift & 7;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROL_8(src, shift);++ if(orig_shift != 0)+ USE_CYCLES(orig_shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_C = src << orig_shift;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = ROL_16(src, shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> (8-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_32_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint64 src = *r_dst;+ uint res = ROL_32(src, shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_C = src >> (24-shift);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_8_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift & 7;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROL_8(src, shift);++ if(orig_shift != 0)+ {+ USE_CYCLES(orig_shift * CYC_SHIFT);++ if(shift != 0)+ {+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+ FLAG_C = src << shift;+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }+ FLAG_C = (src & 1)<<8;+ FLAG_N = NFLAG_8(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_8(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift & 15;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, shift));++ if(orig_shift != 0)+ {+ USE_CYCLES(orig_shift * CYC_SHIFT);++ if(shift != 0)+ {+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ FLAG_C = (src << shift) >> 8;+ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }+ FLAG_C = (src & 1)<<8;+ FLAG_N = NFLAG_16(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_16(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_32_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift & 31;+ uint64 src = *r_dst;+ uint res = ROL_32(src, shift);++ if(orig_shift != 0)+ {+ USE_CYCLES(orig_shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_C = (src >> ((32 - shift) & 0x1f)) << 8;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = CFLAG_CLEAR;+ FLAG_N = NFLAG_32(src);+ FLAG_Z = src;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rol_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_C = src >> 7;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_8_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROR_9(src | (XFLAG_AS_1() << 8), shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res;+ res = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_32_s(void)+{+#if M68K_USE_64_BIT++ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint64 src = *r_dst;+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ res = ROR_33_64(res, shift);++ FLAG_C = FLAG_X = res >> 24;+ res = MASK_OUT_ABOVE_32(res);++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;++#else++ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift)));+ uint new_x_flag = src & (1 << (shift - 1));++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_C = FLAG_X = (new_x_flag != 0)<<8;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;++#endif+}+++static void m68k_op_roxr_8_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;++ if(orig_shift != 0)+ {+ uint shift = orig_shift % 9;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROR_9(src | (XFLAG_AS_1() << 8), shift);++ USE_CYCLES(orig_shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res;+ res = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_8(*r_dst);+ FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;++ if(orig_shift != 0)+ {+ uint shift = orig_shift % 17;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), shift);++ USE_CYCLES(orig_shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_16(*r_dst);+ FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_32_r(void)+{+#if M68K_USE_64_BIT++ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;++ if(orig_shift != 0)+ {+ uint shift = orig_shift % 33;+ uint64 src = *r_dst;+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);++ res = ROR_33_64(res, shift);++ USE_CYCLES(orig_shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res >> 24;+ res = MASK_OUT_ABOVE_32(res);++ *r_dst = res;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_32(*r_dst);+ FLAG_Z = *r_dst;+ FLAG_V = VFLAG_CLEAR;++#else++ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift % 33;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift)));+ uint new_x_flag = src & (1 << (shift - 1));++ if(orig_shift != 0)+ USE_CYCLES(orig_shift * CYC_SHIFT);++ if(shift != 0)+ {+ *r_dst = res;+ FLAG_X = (new_x_flag != 0)<<8;+ }+ else+ res = src;+ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;++#endif+}+++static void m68k_op_roxr_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxr_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_8_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROL_9(src | (XFLAG_AS_1() << 8), shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res;+ res = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_s(void)+{+ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), shift);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_32_s(void)+{+#if M68K_USE_64_BIT++ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint64 src = *r_dst;+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ res = ROL_33_64(res, shift);++ FLAG_C = FLAG_X = res >> 24;+ res = MASK_OUT_ABOVE_32(res);++ *r_dst = res;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;++#else++ uint* r_dst = &DY;+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1)));+ uint new_x_flag = src & (1 << (32 - shift));++ if(shift != 0)+ USE_CYCLES(shift * CYC_SHIFT);++ *r_dst = res;++ FLAG_C = FLAG_X = (new_x_flag != 0)<<8;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;++#endif+}+++static void m68k_op_roxl_8_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+++ if(orig_shift != 0)+ {+ uint shift = orig_shift % 9;+ uint src = MASK_OUT_ABOVE_8(*r_dst);+ uint res = ROL_9(src | (XFLAG_AS_1() << 8), shift);++ USE_CYCLES(orig_shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res;+ res = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_8(*r_dst);+ FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_r(void)+{+ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;++ if(orig_shift != 0)+ {+ uint shift = orig_shift % 17;+ uint src = MASK_OUT_ABOVE_16(*r_dst);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), shift);++ USE_CYCLES(orig_shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_16(*r_dst);+ FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_32_r(void)+{+#if M68K_USE_64_BIT++ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;++ if(orig_shift != 0)+ {+ uint shift = orig_shift % 33;+ uint64 src = *r_dst;+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);++ res = ROL_33_64(res, shift);++ USE_CYCLES(orig_shift * CYC_SHIFT);++ FLAG_C = FLAG_X = res >> 24;+ res = MASK_OUT_ABOVE_32(res);++ *r_dst = res;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ return;+ }++ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_32(*r_dst);+ FLAG_Z = *r_dst;+ FLAG_V = VFLAG_CLEAR;++#else++ uint* r_dst = &DY;+ uint orig_shift = DX & 0x3f;+ uint shift = orig_shift % 33;+ uint src = *r_dst;+ uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1)));+ uint new_x_flag = src & (1 << (32 - shift));++ if(orig_shift != 0)+ USE_CYCLES(orig_shift * CYC_SHIFT);++ if(shift != 0)+ {+ *r_dst = res;+ FLAG_X = (new_x_flag != 0)<<8;+ }+ else+ res = src;+ FLAG_C = FLAG_X;+ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;++#endif+}+++static void m68k_op_roxl_16_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = m68ki_read_16(ea);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = m68ki_read_16(ea);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = m68ki_read_16(ea);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_aw(void)+{+ uint ea = EA_AW_16();+ uint src = m68ki_read_16(ea);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_roxl_16_al(void)+{+ uint ea = EA_AL_16();+ uint src = m68ki_read_16(ea);+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);++ FLAG_C = FLAG_X = res >> 8;+ res = MASK_OUT_ABOVE_16(res);++ m68ki_write_16(ea, res);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_rte_32(void)+{+ if(FLAG_S)+ {+ uint new_sr;+ uint new_pc;++ new_sr = m68ki_pull_16();+ new_pc = m68ki_pull_32();+ m68ki_jump(new_pc);+ m68ki_set_sr(new_sr);++#if M68K_EMULATE_ADDRESS_ERROR+ CPU_INSTR_MODE = INSTRUCTION_YES;+ CPU_RUN_MODE = RUN_MODE_NORMAL;+#endif++ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_rtr_32(void)+{+ m68ki_set_ccr(m68ki_pull_16());+ m68ki_jump(m68ki_pull_32());+}+++static void m68k_op_rts_32(void)+{+ m68ki_jump(m68ki_pull_32());+}+++static void m68k_op_sbcd_8_rr(void)+{+ uint* r_dst = &DX;+ uint src = DY;+ uint dst = *r_dst;+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();+ uint corf = 0;++ if(res > 0xf)+ corf = 6;++ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);+ FLAG_V = res; /* Undefined V behavior */++ if(res > 0xff)+ {+ res += 0xa0;+ FLAG_X = FLAG_C = CFLAG_SET;+ }+ else if(res < corf)+ FLAG_X = FLAG_C = CFLAG_SET;+ else+ FLAG_X = FLAG_C = 0;++ res = MASK_OUT_ABOVE_8(res-corf);++ FLAG_V &= ~res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+}+++static void m68k_op_sbcd_8_mm_ax7(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();+ uint corf = 0;++ if(res > 0xf)+ corf = 6;+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);+ FLAG_V = res; /* Undefined V behavior */++ if(res > 0xff)+ {+ res += 0xa0;+ FLAG_X = FLAG_C = CFLAG_SET;+ }+ else if(res < corf)+ FLAG_X = FLAG_C = CFLAG_SET;+ else+ FLAG_X = FLAG_C = 0;++ res = MASK_OUT_ABOVE_8(res-corf);++ FLAG_V &= ~res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_sbcd_8_mm_ay7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();+ uint corf = 0;++ if(res > 0xf)+ corf = 6;+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);+ FLAG_V = res; /* Undefined V behavior */++ if(res > 0xff)+ {+ res += 0xa0;+ FLAG_X = FLAG_C = CFLAG_SET;+ }+ else if(res < corf)+ FLAG_X = FLAG_C = CFLAG_SET;+ else+ FLAG_X = FLAG_C = 0;++ res = MASK_OUT_ABOVE_8(res-corf);++ FLAG_V &= ~res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_sbcd_8_mm_axy7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();+ uint corf = 0;++ if(res > 0xf)+ corf = 6;+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);+ FLAG_V = res; /* Undefined V behavior */++ if(res > 0xff)+ {+ res += 0xa0;+ FLAG_X = FLAG_C = CFLAG_SET;+ }+ else if(res < corf)+ FLAG_X = FLAG_C = CFLAG_SET;+ else+ FLAG_X = FLAG_C = 0;++ res = MASK_OUT_ABOVE_8(res-corf);++ FLAG_V &= ~res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_sbcd_8_mm(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();+ uint corf = 0;++ if(res > 0xf)+ corf = 6;+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);+ FLAG_V = res; /* Undefined V behavior */++ if(res > 0xff)+ {+ res += 0xa0;+ FLAG_X = FLAG_C = CFLAG_SET;+ }+ else if(res < corf)+ FLAG_X = FLAG_C = CFLAG_SET;+ else+ FLAG_X = FLAG_C = 0;++ res = MASK_OUT_ABOVE_8(res-corf);++ FLAG_V &= ~res; /* Undefined V behavior part II */+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_st_8_d(void)+{+ DY |= 0xff;+}+++static void m68k_op_st_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), 0xff);+}+++static void m68k_op_st_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), 0xff);+}+++static void m68k_op_st_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), 0xff);+}+++static void m68k_op_st_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), 0xff);+}+++static void m68k_op_st_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), 0xff);+}+++static void m68k_op_st_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), 0xff);+}+++static void m68k_op_st_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), 0xff);+}+++static void m68k_op_st_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), 0xff);+}+++static void m68k_op_st_8_al(void)+{+ m68ki_write_8(EA_AL_8(), 0xff);+}+++static void m68k_op_sf_8_d(void)+{+ DY &= 0xffffff00;+}+++static void m68k_op_sf_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), 0);+}+++static void m68k_op_sf_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), 0);+}+++static void m68k_op_sf_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), 0);+}+++static void m68k_op_sf_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), 0);+}+++static void m68k_op_sf_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), 0);+}+++static void m68k_op_sf_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), 0);+}+++static void m68k_op_sf_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), 0);+}+++static void m68k_op_sf_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), 0);+}+++static void m68k_op_sf_8_al(void)+{+ m68ki_write_8(EA_AL_8(), 0);+}+++static void m68k_op_shi_8_d(void)+{+ if(COND_HI())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_sls_8_d(void)+{+ if(COND_LS())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_scc_8_d(void)+{+ if(COND_CC())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_scs_8_d(void)+{+ if(COND_CS())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_sne_8_d(void)+{+ if(COND_NE())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_seq_8_d(void)+{+ if(COND_EQ())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_svc_8_d(void)+{+ if(COND_VC())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_svs_8_d(void)+{+ if(COND_VS())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_spl_8_d(void)+{+ if(COND_PL())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_smi_8_d(void)+{+ if(COND_MI())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_sge_8_d(void)+{+ if(COND_GE())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_slt_8_d(void)+{+ if(COND_LT())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_sgt_8_d(void)+{+ if(COND_GT())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_sle_8_d(void)+{+ if(COND_LE())+ {+ DY |= 0xff;+ USE_CYCLES(CYC_SCC_R_TRUE);+ return;+ }+ DY &= 0xffffff00;+}+++static void m68k_op_shi_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_shi_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_HI() ? 0xff : 0);+}+++static void m68k_op_sls_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_sls_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_LS() ? 0xff : 0);+}+++static void m68k_op_scc_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scc_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_CC() ? 0xff : 0);+}+++static void m68k_op_scs_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_scs_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_CS() ? 0xff : 0);+}+++static void m68k_op_sne_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_sne_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_NE() ? 0xff : 0);+}+++static void m68k_op_seq_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_seq_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_EQ() ? 0xff : 0);+}+++static void m68k_op_svc_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svc_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_VC() ? 0xff : 0);+}+++static void m68k_op_svs_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_svs_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_VS() ? 0xff : 0);+}+++static void m68k_op_spl_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_spl_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_PL() ? 0xff : 0);+}+++static void m68k_op_smi_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_smi_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_MI() ? 0xff : 0);+}+++static void m68k_op_sge_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_sge_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_GE() ? 0xff : 0);+}+++static void m68k_op_slt_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_slt_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_LT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sgt_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_GT() ? 0xff : 0);+}+++static void m68k_op_sle_8_ai(void)+{+ m68ki_write_8(EA_AY_AI_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_pi(void)+{+ m68ki_write_8(EA_AY_PI_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_pi7(void)+{+ m68ki_write_8(EA_A7_PI_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_pd(void)+{+ m68ki_write_8(EA_AY_PD_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_pd7(void)+{+ m68ki_write_8(EA_A7_PD_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_di(void)+{+ m68ki_write_8(EA_AY_DI_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_ix(void)+{+ m68ki_write_8(EA_AY_IX_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_aw(void)+{+ m68ki_write_8(EA_AW_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_sle_8_al(void)+{+ m68ki_write_8(EA_AL_8(), COND_LE() ? 0xff : 0);+}+++static void m68k_op_stop(void)+{+ if(FLAG_S)+ {+ uint new_sr = OPER_I_16();+ CPU_STOPPED |= STOP_LEVEL_STOP;+ m68ki_set_sr(new_sr);+ if (CPU_STOPPED)+ {+ SET_CYCLES(m68ki_cpu.cycle_end - 4*MUL);+ }+ return;+ }+ m68ki_exception_privilege_violation();+}+++static void m68k_op_sub_8_er_d(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_8(DY);+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_pi7(void)+{+ uint* r_dst = &DX;+ uint src = OPER_A7_PI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_pd7(void)+{+ uint* r_dst = &DX;+ uint src = OPER_A7_PD_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_8_er_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_d(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(DY);+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_a(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(AY);+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_16_er_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_sub_32_er_d(void)+{+ uint* r_dst = &DX;+ uint src = DY;+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_a(void)+{+ uint* r_dst = &DX;+ uint src = AY;+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_ai(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_AI_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_pi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PI_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_pd(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_PD_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_di(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_DI_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_ix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AY_IX_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_aw(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AW_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_al(void)+{+ uint* r_dst = &DX;+ uint src = OPER_AL_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_pcdi(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCDI_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_pcix(void)+{+ uint* r_dst = &DX;+ uint src = OPER_PCIX_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_32_er_i(void)+{+ uint* r_dst = &DX;+ uint src = OPER_I_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_sub_8_re_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_di(void)+{+ uint ea = EA_AY_DI_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_aw(void)+{+ uint ea = EA_AW_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_8_re_al(void)+{+ uint ea = EA_AL_8();+ uint src = MASK_OUT_ABOVE_8(DX);+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_sub_16_re_ai(void)+{+ uint ea = EA_AY_AI_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_sub_16_re_pi(void)+{+ uint ea = EA_AY_PI_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_sub_16_re_pd(void)+{+ uint ea = EA_AY_PD_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_sub_16_re_di(void)+{+ uint ea = EA_AY_DI_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_sub_16_re_ix(void)+{+ uint ea = EA_AY_IX_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_sub_16_re_aw(void)+{+ uint ea = EA_AW_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_sub_16_re_al(void)+{+ uint ea = EA_AL_16();+ uint src = MASK_OUT_ABOVE_16(DX);+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_sub_32_re_ai(void)+{+ uint ea = EA_AY_AI_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_sub_32_re_pi(void)+{+ uint ea = EA_AY_PI_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_sub_32_re_pd(void)+{+ uint ea = EA_AY_PD_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_sub_32_re_di(void)+{+ uint ea = EA_AY_DI_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_sub_32_re_ix(void)+{+ uint ea = EA_AY_IX_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_sub_32_re_aw(void)+{+ uint ea = EA_AW_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_sub_32_re_al(void)+{+ uint ea = EA_AL_32();+ uint src = DX;+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_suba_16_d(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(DY));+}+++static void m68k_op_suba_16_a(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(AY));+}+++static void m68k_op_suba_16_ai(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_AI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_pi(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_PI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_pd(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_PD_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_di(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_DI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_ix(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AY_IX_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_aw(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AW_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_al(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_AL_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_pcdi(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_PCDI_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_pcix(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_PCIX_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_16_i(void)+{+ uint* r_dst = &AX;+ uint src = MAKE_INT_16(OPER_I_16());++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_d(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - DY);+}+++static void m68k_op_suba_32_a(void)+{+ uint* r_dst = &AX;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - AY);+}+++static void m68k_op_suba_32_ai(void)+{+ uint* r_dst = &AX;+ uint src = OPER_AY_AI_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_pi(void)+{+ uint* r_dst = &AX;+ uint src = OPER_AY_PI_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_pd(void)+{+ uint* r_dst = &AX;+ uint src = OPER_AY_PD_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_di(void)+{+ uint* r_dst = &AX;+ uint src = OPER_AY_DI_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_ix(void)+{+ uint* r_dst = &AX;+ uint src = OPER_AY_IX_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_aw(void)+{+ uint* r_dst = &AX;+ uint src = OPER_AW_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_al(void)+{+ uint* r_dst = &AX;+ uint src = OPER_AL_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_pcdi(void)+{+ uint* r_dst = &AX;+ uint src = OPER_PCDI_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_pcix(void)+{+ uint* r_dst = &AX;+ uint src = OPER_PCIX_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_suba_32_i(void)+{+ uint* r_dst = &AX;+ uint src = OPER_I_32();++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);+}+++static void m68k_op_subi_8_d(void)+{+ uint* r_dst = &DY;+ uint src = OPER_I_8();+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_subi_8_ai(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_AI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_pi(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_pi7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_pd(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_pd7(void)+{+ uint src = OPER_I_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_di(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_DI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_ix(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AY_IX_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_aw(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AW_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_8_al(void)+{+ uint src = OPER_I_8();+ uint ea = EA_AL_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subi_16_d(void)+{+ uint* r_dst = &DY;+ uint src = OPER_I_16();+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_subi_16_ai(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_AI_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subi_16_pi(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PI_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subi_16_pd(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_PD_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subi_16_di(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_DI_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subi_16_ix(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AY_IX_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subi_16_aw(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AW_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subi_16_al(void)+{+ uint src = OPER_I_16();+ uint ea = EA_AL_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subi_32_d(void)+{+ uint* r_dst = &DY;+ uint src = OPER_I_32();+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_subi_32_ai(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_AI_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subi_32_pi(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PI_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subi_32_pd(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_PD_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subi_32_di(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_DI_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subi_32_ix(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AY_IX_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subi_32_aw(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AW_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subi_32_al(void)+{+ uint src = OPER_I_32();+ uint ea = EA_AL_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subq_8_d(void)+{+ uint* r_dst = &DY;+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;+}+++static void m68k_op_subq_8_ai(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_AI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_pi(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_pi7(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_A7_PI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_pd(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_pd7(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_di(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_DI_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_ix(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_IX_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_aw(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AW_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_8_al(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AL_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_8(res);+ FLAG_Z = MASK_OUT_ABOVE_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ m68ki_write_8(ea, FLAG_Z);+}+++static void m68k_op_subq_16_d(void)+{+ uint* r_dst = &DY;+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;+}+++static void m68k_op_subq_16_a(void)+{+ uint* r_dst = &AY;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1));+}+++static void m68k_op_subq_16_ai(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_AI_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subq_16_pi(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PI_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subq_16_pd(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PD_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subq_16_di(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_DI_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subq_16_ix(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_IX_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subq_16_aw(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AW_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subq_16_al(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AL_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_16(res);+ FLAG_Z = MASK_OUT_ABOVE_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ m68ki_write_16(ea, FLAG_Z);+}+++static void m68k_op_subq_32_d(void)+{+ uint* r_dst = &DY;+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint dst = *r_dst;+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ *r_dst = FLAG_Z;+}+++static void m68k_op_subq_32_a(void)+{+ uint* r_dst = &AY;++ *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1));+}+++static void m68k_op_subq_32_ai(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_AI_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subq_32_pi(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PI_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subq_32_pd(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_PD_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subq_32_di(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_DI_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subq_32_ix(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AY_IX_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subq_32_aw(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AW_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subq_32_al(void)+{+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;+ uint ea = EA_AL_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = MASK_OUT_ABOVE_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ m68ki_write_32(ea, FLAG_Z);+}+++static void m68k_op_subx_8_rr(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_8(DY);+ uint dst = MASK_OUT_ABOVE_8(*r_dst);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;+}+++static void m68k_op_subx_16_rr(void)+{+ uint* r_dst = &DX;+ uint src = MASK_OUT_ABOVE_16(DY);+ uint dst = MASK_OUT_ABOVE_16(*r_dst);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;+}+++static void m68k_op_subx_32_rr(void)+{+ uint* r_dst = &DX;+ uint src = DY;+ uint dst = *r_dst;+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ *r_dst = res;+}+++static void m68k_op_subx_8_mm_ax7(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_subx_8_mm_ay7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_subx_8_mm_axy7(void)+{+ uint src = OPER_A7_PD_8();+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_subx_8_mm(void)+{+ uint src = OPER_AY_PD_8();+ uint ea = EA_AX_PD_8();+ uint dst = m68ki_read_8(ea);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_8(res);+ FLAG_X = FLAG_C = CFLAG_8(res);+ FLAG_V = VFLAG_SUB_8(src, dst, res);++ res = MASK_OUT_ABOVE_8(res);+ FLAG_Z |= res;++ m68ki_write_8(ea, res);+}+++static void m68k_op_subx_16_mm(void)+{+ uint src = OPER_AY_PD_16();+ uint ea = EA_AX_PD_16();+ uint dst = m68ki_read_16(ea);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_16(res);+ FLAG_X = FLAG_C = CFLAG_16(res);+ FLAG_V = VFLAG_SUB_16(src, dst, res);++ res = MASK_OUT_ABOVE_16(res);+ FLAG_Z |= res;++ m68ki_write_16(ea, res);+}+++static void m68k_op_subx_32_mm(void)+{+ uint src = OPER_AY_PD_32();+ uint ea = EA_AX_PD_32();+ uint dst = m68ki_read_32(ea);+ uint res = dst - src - XFLAG_AS_1();++ FLAG_N = NFLAG_32(res);+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);+ FLAG_V = VFLAG_SUB_32(src, dst, res);++ res = MASK_OUT_ABOVE_32(res);+ FLAG_Z |= res;++ m68ki_write_32(ea, res);+}+++static void m68k_op_swap_32(void)+{+ uint* r_dst = &DY;++ FLAG_Z = MASK_OUT_ABOVE_32(*r_dst<<16);+ *r_dst = (*r_dst>>16) | FLAG_Z;++ FLAG_Z = *r_dst;+ FLAG_N = NFLAG_32(*r_dst);+ FLAG_C = CFLAG_CLEAR;+ FLAG_V = VFLAG_CLEAR;+}+++static void m68k_op_tas_8_d(void)+{+ uint* r_dst = &DY;++ FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);+ FLAG_N = NFLAG_8(*r_dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+ *r_dst |= 0x80;+}+++static void m68k_op_tas_8_ai(void)+{+ uint ea = EA_AY_AI_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_pi(void)+{+ uint ea = EA_AY_PI_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_pi7(void)+{+ uint ea = EA_A7_PI_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_pd(void)+{+ uint ea = EA_AY_PD_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_pd7(void)+{+ uint ea = EA_A7_PD_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_di(void)+{+ uint ea = EA_AY_DI_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_ix(void)+{+ uint ea = EA_AY_IX_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_aw(void)+{+ uint ea = EA_AW_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_tas_8_al(void)+{+ uint ea = EA_AL_8();+ uint dst = m68ki_read_8(ea);++ FLAG_Z = dst;+ FLAG_N = NFLAG_8(dst);+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;++ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback+ disabled in order to function properly. Some Amiga software may also rely+ on this, but only when accessing specific addresses so additional functionality+ will be needed. */+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);+}+++static void m68k_op_trap(void)+{+ /* Trap#n stacks exception frame type 0 */+ m68ki_exception_trapN(EXCEPTION_TRAP_BASE + (REG_IR & 0xf)); /* HJB 990403 */+}+++static void m68k_op_trapv(void)+{+ if(COND_VC())+ {+ return;+ }+ m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */+}+++static void m68k_op_tst_8_d(void)+{+ uint res = MASK_OUT_ABOVE_8(DY);++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_ai(void)+{+ uint res = OPER_AY_AI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_pi(void)+{+ uint res = OPER_AY_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_pi7(void)+{+ uint res = OPER_A7_PI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_pd(void)+{+ uint res = OPER_AY_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_pd7(void)+{+ uint res = OPER_A7_PD_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_di(void)+{+ uint res = OPER_AY_DI_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_ix(void)+{+ uint res = OPER_AY_IX_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_aw(void)+{+ uint res = OPER_AW_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_8_al(void)+{+ uint res = OPER_AL_8();++ FLAG_N = NFLAG_8(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_d(void)+{+ uint res = MASK_OUT_ABOVE_16(DY);++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_ai(void)+{+ uint res = OPER_AY_AI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_pi(void)+{+ uint res = OPER_AY_PI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_pd(void)+{+ uint res = OPER_AY_PD_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_di(void)+{+ uint res = OPER_AY_DI_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_ix(void)+{+ uint res = OPER_AY_IX_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_aw(void)+{+ uint res = OPER_AW_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_16_al(void)+{+ uint res = OPER_AL_16();++ FLAG_N = NFLAG_16(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_d(void)+{+ uint res = DY;++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_ai(void)+{+ uint res = OPER_AY_AI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_pi(void)+{+ uint res = OPER_AY_PI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_pd(void)+{+ uint res = OPER_AY_PD_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_di(void)+{+ uint res = OPER_AY_DI_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_ix(void)+{+ uint res = OPER_AY_IX_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_aw(void)+{+ uint res = OPER_AW_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_tst_32_al(void)+{+ uint res = OPER_AL_32();++ FLAG_N = NFLAG_32(res);+ FLAG_Z = res;+ FLAG_V = VFLAG_CLEAR;+ FLAG_C = CFLAG_CLEAR;+}+++static void m68k_op_unlk_32_a7(void)+{+ REG_A[7] = m68ki_read_32(REG_A[7]);+}+++static void m68k_op_unlk_32(void)+{+ uint* r_dst = &AY;++ REG_A[7] = *r_dst;+ *r_dst = m68ki_pull_32();+}+++/* ======================================================================== */+/* ========================= OPCODE TABLE BUILDER ========================= */+/* ======================================================================== */++#ifndef BUILD_TABLES+ /* (NumPlay: the table is m68k_tab.h, made by tools/m68ktab.py) */+#else++/* This is used to generate the opcode handler jump table */+typedef struct+{+ void (*opcode_handler)(void); /* handler function */+ unsigned int mask; /* mask on opcode */+ unsigned int match; /* what to match after masking */+ unsigned char cycles; /* cycles each cpu type takes */+} opcode_handler_struct;++/* opcode handler jump table */+static void (*m68ki_instruction_jump_table[0x10000])(void);++/* Opcode handler table */+static const opcode_handler_struct m68k_opcode_handler_table[] =+{+/* function mask match cyc */+ {m68k_op_1010 , 0xf000, 0xa000, 4},+ {m68k_op_1111 , 0xf000, 0xf000, 4},+ {m68k_op_moveq_32 , 0xf100, 0x7000, 4},+ {m68k_op_bra_8 , 0xff00, 0x6000, 10},+ {m68k_op_bsr_8 , 0xff00, 0x6100, 18},+ {m68k_op_bhi_8 , 0xff00, 0x6200, 10},+ {m68k_op_bls_8 , 0xff00, 0x6300, 10},+ {m68k_op_bcc_8 , 0xff00, 0x6400, 10},+ {m68k_op_bcs_8 , 0xff00, 0x6500, 10},+ {m68k_op_bne_8 , 0xff00, 0x6600, 10},+ {m68k_op_beq_8 , 0xff00, 0x6700, 10},+ {m68k_op_bvc_8 , 0xff00, 0x6800, 10},+ {m68k_op_bvs_8 , 0xff00, 0x6900, 10},+ {m68k_op_bpl_8 , 0xff00, 0x6a00, 10},+ {m68k_op_bmi_8 , 0xff00, 0x6b00, 10},+ {m68k_op_bge_8 , 0xff00, 0x6c00, 10},+ {m68k_op_blt_8 , 0xff00, 0x6d00, 10},+ {m68k_op_bgt_8 , 0xff00, 0x6e00, 10},+ {m68k_op_ble_8 , 0xff00, 0x6f00, 10},+ {m68k_op_btst_32_r_d , 0xf1f8, 0x0100, 6},+ {m68k_op_movep_16_er , 0xf1f8, 0x0108, 16},+ {m68k_op_btst_8_r_ai , 0xf1f8, 0x0110, 8},+ {m68k_op_btst_8_r_pi , 0xf1f8, 0x0118, 8},+ {m68k_op_btst_8_r_pd , 0xf1f8, 0x0120, 10},+ {m68k_op_btst_8_r_di , 0xf1f8, 0x0128, 12},+ {m68k_op_btst_8_r_ix , 0xf1f8, 0x0130, 14},+ {m68k_op_bchg_32_r_d , 0xf1f8, 0x0140, 8},+ {m68k_op_movep_32_er , 0xf1f8, 0x0148, 24},+ {m68k_op_bchg_8_r_ai , 0xf1f8, 0x0150, 12},+ {m68k_op_bchg_8_r_pi , 0xf1f8, 0x0158, 12},+ {m68k_op_bchg_8_r_pd , 0xf1f8, 0x0160, 14},+ {m68k_op_bchg_8_r_di , 0xf1f8, 0x0168, 16},+ {m68k_op_bchg_8_r_ix , 0xf1f8, 0x0170, 18},+ {m68k_op_bclr_32_r_d , 0xf1f8, 0x0180, 10},+ {m68k_op_movep_16_re , 0xf1f8, 0x0188, 16},+ {m68k_op_bclr_8_r_ai , 0xf1f8, 0x0190, 12},+ {m68k_op_bclr_8_r_pi , 0xf1f8, 0x0198, 12},+ {m68k_op_bclr_8_r_pd , 0xf1f8, 0x01a0, 14},+ {m68k_op_bclr_8_r_di , 0xf1f8, 0x01a8, 16},+ {m68k_op_bclr_8_r_ix , 0xf1f8, 0x01b0, 18},+ {m68k_op_bset_32_r_d , 0xf1f8, 0x01c0, 8},+ {m68k_op_movep_32_re , 0xf1f8, 0x01c8, 24},+ {m68k_op_bset_8_r_ai , 0xf1f8, 0x01d0, 12},+ {m68k_op_bset_8_r_pi , 0xf1f8, 0x01d8, 12},+ {m68k_op_bset_8_r_pd , 0xf1f8, 0x01e0, 14},+ {m68k_op_bset_8_r_di , 0xf1f8, 0x01e8, 16},+ {m68k_op_bset_8_r_ix , 0xf1f8, 0x01f0, 18},+ {m68k_op_move_8_d_d , 0xf1f8, 0x1000, 4},+ {m68k_op_move_8_d_ai , 0xf1f8, 0x1010, 8},+ {m68k_op_move_8_d_pi , 0xf1f8, 0x1018, 8},+ {m68k_op_move_8_d_pd , 0xf1f8, 0x1020, 10},+ {m68k_op_move_8_d_di , 0xf1f8, 0x1028, 12},+ {m68k_op_move_8_d_ix , 0xf1f8, 0x1030, 14},+ {m68k_op_move_8_ai_d , 0xf1f8, 0x1080, 8},+ {m68k_op_move_8_ai_ai , 0xf1f8, 0x1090, 12},+ {m68k_op_move_8_ai_pi , 0xf1f8, 0x1098, 12},+ {m68k_op_move_8_ai_pd , 0xf1f8, 0x10a0, 14},+ {m68k_op_move_8_ai_di , 0xf1f8, 0x10a8, 16},+ {m68k_op_move_8_ai_ix , 0xf1f8, 0x10b0, 18},+ {m68k_op_move_8_pi_d , 0xf1f8, 0x10c0, 8},+ {m68k_op_move_8_pi_ai , 0xf1f8, 0x10d0, 12},+ {m68k_op_move_8_pi_pi , 0xf1f8, 0x10d8, 12},+ {m68k_op_move_8_pi_pd , 0xf1f8, 0x10e0, 14},+ {m68k_op_move_8_pi_di , 0xf1f8, 0x10e8, 16},+ {m68k_op_move_8_pi_ix , 0xf1f8, 0x10f0, 18},+ {m68k_op_move_8_pd_d , 0xf1f8, 0x1100, 8},+ {m68k_op_move_8_pd_ai , 0xf1f8, 0x1110, 12},+ {m68k_op_move_8_pd_pi , 0xf1f8, 0x1118, 12},+ {m68k_op_move_8_pd_pd , 0xf1f8, 0x1120, 14},+ {m68k_op_move_8_pd_di , 0xf1f8, 0x1128, 16},+ {m68k_op_move_8_pd_ix , 0xf1f8, 0x1130, 18},+ {m68k_op_move_8_di_d , 0xf1f8, 0x1140, 12},+ {m68k_op_move_8_di_ai , 0xf1f8, 0x1150, 16},+ {m68k_op_move_8_di_pi , 0xf1f8, 0x1158, 16},+ {m68k_op_move_8_di_pd , 0xf1f8, 0x1160, 18},+ {m68k_op_move_8_di_di , 0xf1f8, 0x1168, 20},+ {m68k_op_move_8_di_ix , 0xf1f8, 0x1170, 22},+ {m68k_op_move_8_ix_d , 0xf1f8, 0x1180, 14},+ {m68k_op_move_8_ix_ai , 0xf1f8, 0x1190, 18},+ {m68k_op_move_8_ix_pi , 0xf1f8, 0x1198, 18},+ {m68k_op_move_8_ix_pd , 0xf1f8, 0x11a0, 20},+ {m68k_op_move_8_ix_di , 0xf1f8, 0x11a8, 22},+ {m68k_op_move_8_ix_ix , 0xf1f8, 0x11b0, 24},+ {m68k_op_move_32_d_d , 0xf1f8, 0x2000, 4},+ {m68k_op_move_32_d_a , 0xf1f8, 0x2008, 4},+ {m68k_op_move_32_d_ai , 0xf1f8, 0x2010, 12},+ {m68k_op_move_32_d_pi , 0xf1f8, 0x2018, 12},+ {m68k_op_move_32_d_pd , 0xf1f8, 0x2020, 14},+ {m68k_op_move_32_d_di , 0xf1f8, 0x2028, 16},+ {m68k_op_move_32_d_ix , 0xf1f8, 0x2030, 18},+ {m68k_op_movea_32_d , 0xf1f8, 0x2040, 4},+ {m68k_op_movea_32_a , 0xf1f8, 0x2048, 4},+ {m68k_op_movea_32_ai , 0xf1f8, 0x2050, 12},+ {m68k_op_movea_32_pi , 0xf1f8, 0x2058, 12},+ {m68k_op_movea_32_pd , 0xf1f8, 0x2060, 14},+ {m68k_op_movea_32_di , 0xf1f8, 0x2068, 16},+ {m68k_op_movea_32_ix , 0xf1f8, 0x2070, 18},+ {m68k_op_move_32_ai_d , 0xf1f8, 0x2080, 12},+ {m68k_op_move_32_ai_a , 0xf1f8, 0x2088, 12},+ {m68k_op_move_32_ai_ai , 0xf1f8, 0x2090, 20},+ {m68k_op_move_32_ai_pi , 0xf1f8, 0x2098, 20},+ {m68k_op_move_32_ai_pd , 0xf1f8, 0x20a0, 22},+ {m68k_op_move_32_ai_di , 0xf1f8, 0x20a8, 24},+ {m68k_op_move_32_ai_ix , 0xf1f8, 0x20b0, 26},+ {m68k_op_move_32_pi_d , 0xf1f8, 0x20c0, 12},+ {m68k_op_move_32_pi_a , 0xf1f8, 0x20c8, 12},+ {m68k_op_move_32_pi_ai , 0xf1f8, 0x20d0, 20},+ {m68k_op_move_32_pi_pi , 0xf1f8, 0x20d8, 20},+ {m68k_op_move_32_pi_pd , 0xf1f8, 0x20e0, 22},+ {m68k_op_move_32_pi_di , 0xf1f8, 0x20e8, 24},+ {m68k_op_move_32_pi_ix , 0xf1f8, 0x20f0, 26},+ {m68k_op_move_32_pd_d , 0xf1f8, 0x2100, 12},+ {m68k_op_move_32_pd_a , 0xf1f8, 0x2108, 12},+ {m68k_op_move_32_pd_ai , 0xf1f8, 0x2110, 20},+ {m68k_op_move_32_pd_pi , 0xf1f8, 0x2118, 20},+ {m68k_op_move_32_pd_pd , 0xf1f8, 0x2120, 22},+ {m68k_op_move_32_pd_di , 0xf1f8, 0x2128, 24},+ {m68k_op_move_32_pd_ix , 0xf1f8, 0x2130, 26},+ {m68k_op_move_32_di_d , 0xf1f8, 0x2140, 16},+ {m68k_op_move_32_di_a , 0xf1f8, 0x2148, 16},+ {m68k_op_move_32_di_ai , 0xf1f8, 0x2150, 24},+ {m68k_op_move_32_di_pi , 0xf1f8, 0x2158, 24},+ {m68k_op_move_32_di_pd , 0xf1f8, 0x2160, 26},+ {m68k_op_move_32_di_di , 0xf1f8, 0x2168, 28},+ {m68k_op_move_32_di_ix , 0xf1f8, 0x2170, 30},+ {m68k_op_move_32_ix_d , 0xf1f8, 0x2180, 18},+ {m68k_op_move_32_ix_a , 0xf1f8, 0x2188, 18},+ {m68k_op_move_32_ix_ai , 0xf1f8, 0x2190, 26},+ {m68k_op_move_32_ix_pi , 0xf1f8, 0x2198, 26},+ {m68k_op_move_32_ix_pd , 0xf1f8, 0x21a0, 28},+ {m68k_op_move_32_ix_di , 0xf1f8, 0x21a8, 30},+ {m68k_op_move_32_ix_ix , 0xf1f8, 0x21b0, 32},+ {m68k_op_move_16_d_d , 0xf1f8, 0x3000, 4},+ {m68k_op_move_16_d_a , 0xf1f8, 0x3008, 4},+ {m68k_op_move_16_d_ai , 0xf1f8, 0x3010, 8},+ {m68k_op_move_16_d_pi , 0xf1f8, 0x3018, 8},+ {m68k_op_move_16_d_pd , 0xf1f8, 0x3020, 10},+ {m68k_op_move_16_d_di , 0xf1f8, 0x3028, 12},+ {m68k_op_move_16_d_ix , 0xf1f8, 0x3030, 14},+ {m68k_op_movea_16_d , 0xf1f8, 0x3040, 4},+ {m68k_op_movea_16_a , 0xf1f8, 0x3048, 4},+ {m68k_op_movea_16_ai , 0xf1f8, 0x3050, 8},+ {m68k_op_movea_16_pi , 0xf1f8, 0x3058, 8},+ {m68k_op_movea_16_pd , 0xf1f8, 0x3060, 10},+ {m68k_op_movea_16_di , 0xf1f8, 0x3068, 12},+ {m68k_op_movea_16_ix , 0xf1f8, 0x3070, 14},+ {m68k_op_move_16_ai_d , 0xf1f8, 0x3080, 8},+ {m68k_op_move_16_ai_a , 0xf1f8, 0x3088, 8},+ {m68k_op_move_16_ai_ai , 0xf1f8, 0x3090, 12},+ {m68k_op_move_16_ai_pi , 0xf1f8, 0x3098, 12},+ {m68k_op_move_16_ai_pd , 0xf1f8, 0x30a0, 14},+ {m68k_op_move_16_ai_di , 0xf1f8, 0x30a8, 16},+ {m68k_op_move_16_ai_ix , 0xf1f8, 0x30b0, 18},+ {m68k_op_move_16_pi_d , 0xf1f8, 0x30c0, 8},+ {m68k_op_move_16_pi_a , 0xf1f8, 0x30c8, 8},+ {m68k_op_move_16_pi_ai , 0xf1f8, 0x30d0, 12},+ {m68k_op_move_16_pi_pi , 0xf1f8, 0x30d8, 12},+ {m68k_op_move_16_pi_pd , 0xf1f8, 0x30e0, 14},+ {m68k_op_move_16_pi_di , 0xf1f8, 0x30e8, 16},+ {m68k_op_move_16_pi_ix , 0xf1f8, 0x30f0, 18},+ {m68k_op_move_16_pd_d , 0xf1f8, 0x3100, 8},+ {m68k_op_move_16_pd_a , 0xf1f8, 0x3108, 8},+ {m68k_op_move_16_pd_ai , 0xf1f8, 0x3110, 12},+ {m68k_op_move_16_pd_pi , 0xf1f8, 0x3118, 12},+ {m68k_op_move_16_pd_pd , 0xf1f8, 0x3120, 14},+ {m68k_op_move_16_pd_di , 0xf1f8, 0x3128, 16},+ {m68k_op_move_16_pd_ix , 0xf1f8, 0x3130, 18},+ {m68k_op_move_16_di_d , 0xf1f8, 0x3140, 12},+ {m68k_op_move_16_di_a , 0xf1f8, 0x3148, 12},+ {m68k_op_move_16_di_ai , 0xf1f8, 0x3150, 16},+ {m68k_op_move_16_di_pi , 0xf1f8, 0x3158, 16},+ {m68k_op_move_16_di_pd , 0xf1f8, 0x3160, 18},+ {m68k_op_move_16_di_di , 0xf1f8, 0x3168, 20},+ {m68k_op_move_16_di_ix , 0xf1f8, 0x3170, 22},+ {m68k_op_move_16_ix_d , 0xf1f8, 0x3180, 14},+ {m68k_op_move_16_ix_a , 0xf1f8, 0x3188, 14},+ {m68k_op_move_16_ix_ai , 0xf1f8, 0x3190, 18},+ {m68k_op_move_16_ix_pi , 0xf1f8, 0x3198, 18},+ {m68k_op_move_16_ix_pd , 0xf1f8, 0x31a0, 20},+ {m68k_op_move_16_ix_di , 0xf1f8, 0x31a8, 22},+ {m68k_op_move_16_ix_ix , 0xf1f8, 0x31b0, 24},+ {m68k_op_chk_16_d , 0xf1f8, 0x4180, 10},+ {m68k_op_chk_16_ai , 0xf1f8, 0x4190, 14},+ {m68k_op_chk_16_pi , 0xf1f8, 0x4198, 14},+ {m68k_op_chk_16_pd , 0xf1f8, 0x41a0, 16},+ {m68k_op_chk_16_di , 0xf1f8, 0x41a8, 18},+ {m68k_op_chk_16_ix , 0xf1f8, 0x41b0, 20},+ {m68k_op_lea_32_ai , 0xf1f8, 0x41d0, 4},+ {m68k_op_lea_32_di , 0xf1f8, 0x41e8, 8},+ {m68k_op_lea_32_ix , 0xf1f8, 0x41f0, 12},+ {m68k_op_addq_8_d , 0xf1f8, 0x5000, 4},+ {m68k_op_addq_8_ai , 0xf1f8, 0x5010, 12},+ {m68k_op_addq_8_pi , 0xf1f8, 0x5018, 12},+ {m68k_op_addq_8_pd , 0xf1f8, 0x5020, 14},+ {m68k_op_addq_8_di , 0xf1f8, 0x5028, 16},+ {m68k_op_addq_8_ix , 0xf1f8, 0x5030, 18},+ {m68k_op_addq_16_d , 0xf1f8, 0x5040, 4},+ {m68k_op_addq_16_a , 0xf1f8, 0x5048, 8}, /* see Yacht.txt */+ {m68k_op_addq_16_ai , 0xf1f8, 0x5050, 12},+ {m68k_op_addq_16_pi , 0xf1f8, 0x5058, 12},+ {m68k_op_addq_16_pd , 0xf1f8, 0x5060, 14},+ {m68k_op_addq_16_di , 0xf1f8, 0x5068, 16},+ {m68k_op_addq_16_ix , 0xf1f8, 0x5070, 18},+ {m68k_op_addq_32_d , 0xf1f8, 0x5080, 8},+ {m68k_op_addq_32_a , 0xf1f8, 0x5088, 8},+ {m68k_op_addq_32_ai , 0xf1f8, 0x5090, 20},+ {m68k_op_addq_32_pi , 0xf1f8, 0x5098, 20},+ {m68k_op_addq_32_pd , 0xf1f8, 0x50a0, 22},+ {m68k_op_addq_32_di , 0xf1f8, 0x50a8, 24},+ {m68k_op_addq_32_ix , 0xf1f8, 0x50b0, 26},+ {m68k_op_subq_8_d , 0xf1f8, 0x5100, 4},+ {m68k_op_subq_8_ai , 0xf1f8, 0x5110, 12},+ {m68k_op_subq_8_pi , 0xf1f8, 0x5118, 12},+ {m68k_op_subq_8_pd , 0xf1f8, 0x5120, 14},+ {m68k_op_subq_8_di , 0xf1f8, 0x5128, 16},+ {m68k_op_subq_8_ix , 0xf1f8, 0x5130, 18},+ {m68k_op_subq_16_d , 0xf1f8, 0x5140, 4},+ {m68k_op_subq_16_a , 0xf1f8, 0x5148, 8},+ {m68k_op_subq_16_ai , 0xf1f8, 0x5150, 12},+ {m68k_op_subq_16_pi , 0xf1f8, 0x5158, 12},+ {m68k_op_subq_16_pd , 0xf1f8, 0x5160, 14},+ {m68k_op_subq_16_di , 0xf1f8, 0x5168, 16},+ {m68k_op_subq_16_ix , 0xf1f8, 0x5170, 18},+ {m68k_op_subq_32_d , 0xf1f8, 0x5180, 8},+ {m68k_op_subq_32_a , 0xf1f8, 0x5188, 8},+ {m68k_op_subq_32_ai , 0xf1f8, 0x5190, 20},+ {m68k_op_subq_32_pi , 0xf1f8, 0x5198, 20},+ {m68k_op_subq_32_pd , 0xf1f8, 0x51a0, 22},+ {m68k_op_subq_32_di , 0xf1f8, 0x51a8, 24},+ {m68k_op_subq_32_ix , 0xf1f8, 0x51b0, 26},+ {m68k_op_or_8_er_d , 0xf1f8, 0x8000, 4},+ {m68k_op_or_8_er_ai , 0xf1f8, 0x8010, 8},+ {m68k_op_or_8_er_pi , 0xf1f8, 0x8018, 8},+ {m68k_op_or_8_er_pd , 0xf1f8, 0x8020, 10},+ {m68k_op_or_8_er_di , 0xf1f8, 0x8028, 12},+ {m68k_op_or_8_er_ix , 0xf1f8, 0x8030, 14},+ {m68k_op_or_16_er_d , 0xf1f8, 0x8040, 4},+ {m68k_op_or_16_er_ai , 0xf1f8, 0x8050, 8},+ {m68k_op_or_16_er_pi , 0xf1f8, 0x8058, 8},+ {m68k_op_or_16_er_pd , 0xf1f8, 0x8060, 10},+ {m68k_op_or_16_er_di , 0xf1f8, 0x8068, 12},+ {m68k_op_or_16_er_ix , 0xf1f8, 0x8070, 14},+ {m68k_op_or_32_er_d , 0xf1f8, 0x8080, 8},+ {m68k_op_or_32_er_ai , 0xf1f8, 0x8090, 14},+ {m68k_op_or_32_er_pi , 0xf1f8, 0x8098, 14},+ {m68k_op_or_32_er_pd , 0xf1f8, 0x80a0, 16},+ {m68k_op_or_32_er_di , 0xf1f8, 0x80a8, 18},+ {m68k_op_or_32_er_ix , 0xf1f8, 0x80b0, 20},+ {m68k_op_divu_16_d , 0xf1f8, 0x80c0, 0},+ {m68k_op_divu_16_ai , 0xf1f8, 0x80d0, 4},+ {m68k_op_divu_16_pi , 0xf1f8, 0x80d8, 4},+ {m68k_op_divu_16_pd , 0xf1f8, 0x80e0, 6},+ {m68k_op_divu_16_di , 0xf1f8, 0x80e8, 8},+ {m68k_op_divu_16_ix , 0xf1f8, 0x80f0, 10},+ {m68k_op_sbcd_8_rr , 0xf1f8, 0x8100, 6},+ {m68k_op_sbcd_8_mm , 0xf1f8, 0x8108, 18},+ {m68k_op_or_8_re_ai , 0xf1f8, 0x8110, 12},+ {m68k_op_or_8_re_pi , 0xf1f8, 0x8118, 12},+ {m68k_op_or_8_re_pd , 0xf1f8, 0x8120, 14},+ {m68k_op_or_8_re_di , 0xf1f8, 0x8128, 16},+ {m68k_op_or_8_re_ix , 0xf1f8, 0x8130, 18},+ {m68k_op_or_16_re_ai , 0xf1f8, 0x8150, 12},+ {m68k_op_or_16_re_pi , 0xf1f8, 0x8158, 12},+ {m68k_op_or_16_re_pd , 0xf1f8, 0x8160, 14},+ {m68k_op_or_16_re_di , 0xf1f8, 0x8168, 16},+ {m68k_op_or_16_re_ix , 0xf1f8, 0x8170, 18},+ {m68k_op_or_32_re_ai , 0xf1f8, 0x8190, 20},+ {m68k_op_or_32_re_pi , 0xf1f8, 0x8198, 20},+ {m68k_op_or_32_re_pd , 0xf1f8, 0x81a0, 22},+ {m68k_op_or_32_re_di , 0xf1f8, 0x81a8, 24},+ {m68k_op_or_32_re_ix , 0xf1f8, 0x81b0, 26},+ {m68k_op_divs_16_d , 0xf1f8, 0x81c0, 0},+ {m68k_op_divs_16_ai , 0xf1f8, 0x81d0, 4},+ {m68k_op_divs_16_pi , 0xf1f8, 0x81d8, 4},+ {m68k_op_divs_16_pd , 0xf1f8, 0x81e0, 6},+ {m68k_op_divs_16_di , 0xf1f8, 0x81e8, 8},+ {m68k_op_divs_16_ix , 0xf1f8, 0x81f0, 10},+ {m68k_op_sub_8_er_d , 0xf1f8, 0x9000, 4},+ {m68k_op_sub_8_er_ai , 0xf1f8, 0x9010, 8},+ {m68k_op_sub_8_er_pi , 0xf1f8, 0x9018, 8},+ {m68k_op_sub_8_er_pd , 0xf1f8, 0x9020, 10},+ {m68k_op_sub_8_er_di , 0xf1f8, 0x9028, 12},+ {m68k_op_sub_8_er_ix , 0xf1f8, 0x9030, 14},+ {m68k_op_sub_16_er_d , 0xf1f8, 0x9040, 4},+ {m68k_op_sub_16_er_a , 0xf1f8, 0x9048, 4},+ {m68k_op_sub_16_er_ai , 0xf1f8, 0x9050, 8},+ {m68k_op_sub_16_er_pi , 0xf1f8, 0x9058, 8},+ {m68k_op_sub_16_er_pd , 0xf1f8, 0x9060, 10},+ {m68k_op_sub_16_er_di , 0xf1f8, 0x9068, 12},+ {m68k_op_sub_16_er_ix , 0xf1f8, 0x9070, 14},+ {m68k_op_sub_32_er_d , 0xf1f8, 0x9080, 8},+ {m68k_op_sub_32_er_a , 0xf1f8, 0x9088, 8},+ {m68k_op_sub_32_er_ai , 0xf1f8, 0x9090, 14},+ {m68k_op_sub_32_er_pi , 0xf1f8, 0x9098, 14},+ {m68k_op_sub_32_er_pd , 0xf1f8, 0x90a0, 16},+ {m68k_op_sub_32_er_di , 0xf1f8, 0x90a8, 18},+ {m68k_op_sub_32_er_ix , 0xf1f8, 0x90b0, 20},+ {m68k_op_suba_16_d , 0xf1f8, 0x90c0, 8},+ {m68k_op_suba_16_a , 0xf1f8, 0x90c8, 8},+ {m68k_op_suba_16_ai , 0xf1f8, 0x90d0, 12},+ {m68k_op_suba_16_pi , 0xf1f8, 0x90d8, 12},+ {m68k_op_suba_16_pd , 0xf1f8, 0x90e0, 14},+ {m68k_op_suba_16_di , 0xf1f8, 0x90e8, 16},+ {m68k_op_suba_16_ix , 0xf1f8, 0x90f0, 18},+ {m68k_op_subx_8_rr , 0xf1f8, 0x9100, 4},+ {m68k_op_subx_8_mm , 0xf1f8, 0x9108, 18},+ {m68k_op_sub_8_re_ai , 0xf1f8, 0x9110, 12},+ {m68k_op_sub_8_re_pi , 0xf1f8, 0x9118, 12},+ {m68k_op_sub_8_re_pd , 0xf1f8, 0x9120, 14},+ {m68k_op_sub_8_re_di , 0xf1f8, 0x9128, 16},+ {m68k_op_sub_8_re_ix , 0xf1f8, 0x9130, 18},+ {m68k_op_subx_16_rr , 0xf1f8, 0x9140, 4},+ {m68k_op_subx_16_mm , 0xf1f8, 0x9148, 18},+ {m68k_op_sub_16_re_ai , 0xf1f8, 0x9150, 12},+ {m68k_op_sub_16_re_pi , 0xf1f8, 0x9158, 12},+ {m68k_op_sub_16_re_pd , 0xf1f8, 0x9160, 14},+ {m68k_op_sub_16_re_di , 0xf1f8, 0x9168, 16},+ {m68k_op_sub_16_re_ix , 0xf1f8, 0x9170, 18},+ {m68k_op_subx_32_rr , 0xf1f8, 0x9180, 8},+ {m68k_op_subx_32_mm , 0xf1f8, 0x9188, 30},+ {m68k_op_sub_32_re_ai , 0xf1f8, 0x9190, 20},+ {m68k_op_sub_32_re_pi , 0xf1f8, 0x9198, 20},+ {m68k_op_sub_32_re_pd , 0xf1f8, 0x91a0, 22},+ {m68k_op_sub_32_re_di , 0xf1f8, 0x91a8, 24},+ {m68k_op_sub_32_re_ix , 0xf1f8, 0x91b0, 26},+ {m68k_op_suba_32_d , 0xf1f8, 0x91c0, 8},+ {m68k_op_suba_32_a , 0xf1f8, 0x91c8, 8},+ {m68k_op_suba_32_ai , 0xf1f8, 0x91d0, 14},+ {m68k_op_suba_32_pi , 0xf1f8, 0x91d8, 14},+ {m68k_op_suba_32_pd , 0xf1f8, 0x91e0, 16},+ {m68k_op_suba_32_di , 0xf1f8, 0x91e8, 18},+ {m68k_op_suba_32_ix , 0xf1f8, 0x91f0, 20},+ {m68k_op_cmp_8_d , 0xf1f8, 0xb000, 4},+ {m68k_op_cmp_8_ai , 0xf1f8, 0xb010, 8},+ {m68k_op_cmp_8_pi , 0xf1f8, 0xb018, 8},+ {m68k_op_cmp_8_pd , 0xf1f8, 0xb020, 10},+ {m68k_op_cmp_8_di , 0xf1f8, 0xb028, 12},+ {m68k_op_cmp_8_ix , 0xf1f8, 0xb030, 14},+ {m68k_op_cmp_16_d , 0xf1f8, 0xb040, 4},+ {m68k_op_cmp_16_a , 0xf1f8, 0xb048, 4},+ {m68k_op_cmp_16_ai , 0xf1f8, 0xb050, 8},+ {m68k_op_cmp_16_pi , 0xf1f8, 0xb058, 8},+ {m68k_op_cmp_16_pd , 0xf1f8, 0xb060, 10},+ {m68k_op_cmp_16_di , 0xf1f8, 0xb068, 12},+ {m68k_op_cmp_16_ix , 0xf1f8, 0xb070, 14},+ {m68k_op_cmp_32_d , 0xf1f8, 0xb080, 6},+ {m68k_op_cmp_32_a , 0xf1f8, 0xb088, 6},+ {m68k_op_cmp_32_ai , 0xf1f8, 0xb090, 14},+ {m68k_op_cmp_32_pi , 0xf1f8, 0xb098, 14},+ {m68k_op_cmp_32_pd , 0xf1f8, 0xb0a0, 16},+ {m68k_op_cmp_32_di , 0xf1f8, 0xb0a8, 18},+ {m68k_op_cmp_32_ix , 0xf1f8, 0xb0b0, 20},+ {m68k_op_cmpa_16_d , 0xf1f8, 0xb0c0, 6},+ {m68k_op_cmpa_16_a , 0xf1f8, 0xb0c8, 6},+ {m68k_op_cmpa_16_ai , 0xf1f8, 0xb0d0, 10},+ {m68k_op_cmpa_16_pi , 0xf1f8, 0xb0d8, 10},+ {m68k_op_cmpa_16_pd , 0xf1f8, 0xb0e0, 12},+ {m68k_op_cmpa_16_di , 0xf1f8, 0xb0e8, 14},+ {m68k_op_cmpa_16_ix , 0xf1f8, 0xb0f0, 16},+ {m68k_op_eor_8_d , 0xf1f8, 0xb100, 4},+ {m68k_op_cmpm_8 , 0xf1f8, 0xb108, 12},+ {m68k_op_eor_8_ai , 0xf1f8, 0xb110, 12},+ {m68k_op_eor_8_pi , 0xf1f8, 0xb118, 12},+ {m68k_op_eor_8_pd , 0xf1f8, 0xb120, 14},+ {m68k_op_eor_8_di , 0xf1f8, 0xb128, 16},+ {m68k_op_eor_8_ix , 0xf1f8, 0xb130, 18},+ {m68k_op_eor_16_d , 0xf1f8, 0xb140, 4},+ {m68k_op_cmpm_16 , 0xf1f8, 0xb148, 12},+ {m68k_op_eor_16_ai , 0xf1f8, 0xb150, 12},+ {m68k_op_eor_16_pi , 0xf1f8, 0xb158, 12},+ {m68k_op_eor_16_pd , 0xf1f8, 0xb160, 14},+ {m68k_op_eor_16_di , 0xf1f8, 0xb168, 16},+ {m68k_op_eor_16_ix , 0xf1f8, 0xb170, 18},+ {m68k_op_eor_32_d , 0xf1f8, 0xb180, 8},+ {m68k_op_cmpm_32 , 0xf1f8, 0xb188, 20},+ {m68k_op_eor_32_ai , 0xf1f8, 0xb190, 20},+ {m68k_op_eor_32_pi , 0xf1f8, 0xb198, 20},+ {m68k_op_eor_32_pd , 0xf1f8, 0xb1a0, 22},+ {m68k_op_eor_32_di , 0xf1f8, 0xb1a8, 24},+ {m68k_op_eor_32_ix , 0xf1f8, 0xb1b0, 26},+ {m68k_op_cmpa_32_d , 0xf1f8, 0xb1c0, 6},+ {m68k_op_cmpa_32_a , 0xf1f8, 0xb1c8, 6},+ {m68k_op_cmpa_32_ai , 0xf1f8, 0xb1d0, 14},+ {m68k_op_cmpa_32_pi , 0xf1f8, 0xb1d8, 14},+ {m68k_op_cmpa_32_pd , 0xf1f8, 0xb1e0, 16},+ {m68k_op_cmpa_32_di , 0xf1f8, 0xb1e8, 18},+ {m68k_op_cmpa_32_ix , 0xf1f8, 0xb1f0, 20},+ {m68k_op_and_8_er_d , 0xf1f8, 0xc000, 4},+ {m68k_op_and_8_er_ai , 0xf1f8, 0xc010, 8},+ {m68k_op_and_8_er_pi , 0xf1f8, 0xc018, 8},+ {m68k_op_and_8_er_pd , 0xf1f8, 0xc020, 10},+ {m68k_op_and_8_er_di , 0xf1f8, 0xc028, 12},+ {m68k_op_and_8_er_ix , 0xf1f8, 0xc030, 14},+ {m68k_op_and_16_er_d , 0xf1f8, 0xc040, 4},+ {m68k_op_and_16_er_ai , 0xf1f8, 0xc050, 8},+ {m68k_op_and_16_er_pi , 0xf1f8, 0xc058, 8},+ {m68k_op_and_16_er_pd , 0xf1f8, 0xc060, 10},+ {m68k_op_and_16_er_di , 0xf1f8, 0xc068, 12},+ {m68k_op_and_16_er_ix , 0xf1f8, 0xc070, 14},+ {m68k_op_and_32_er_d , 0xf1f8, 0xc080, 8},+ {m68k_op_and_32_er_ai , 0xf1f8, 0xc090, 14},+ {m68k_op_and_32_er_pi , 0xf1f8, 0xc098, 14},+ {m68k_op_and_32_er_pd , 0xf1f8, 0xc0a0, 16},+ {m68k_op_and_32_er_di , 0xf1f8, 0xc0a8, 18},+ {m68k_op_and_32_er_ix , 0xf1f8, 0xc0b0, 20},+ {m68k_op_mulu_16_d , 0xf1f8, 0xc0c0, 0},+ {m68k_op_mulu_16_ai , 0xf1f8, 0xc0d0, 4},+ {m68k_op_mulu_16_pi , 0xf1f8, 0xc0d8, 4},+ {m68k_op_mulu_16_pd , 0xf1f8, 0xc0e0, 6},+ {m68k_op_mulu_16_di , 0xf1f8, 0xc0e8, 8},+ {m68k_op_mulu_16_ix , 0xf1f8, 0xc0f0, 10},+ {m68k_op_abcd_8_rr , 0xf1f8, 0xc100, 6},+ {m68k_op_abcd_8_mm , 0xf1f8, 0xc108, 18},+ {m68k_op_and_8_re_ai , 0xf1f8, 0xc110, 12},+ {m68k_op_and_8_re_pi , 0xf1f8, 0xc118, 12},+ {m68k_op_and_8_re_pd , 0xf1f8, 0xc120, 14},+ {m68k_op_and_8_re_di , 0xf1f8, 0xc128, 16},+ {m68k_op_and_8_re_ix , 0xf1f8, 0xc130, 18},+ {m68k_op_exg_32_dd , 0xf1f8, 0xc140, 6},+ {m68k_op_exg_32_aa , 0xf1f8, 0xc148, 6},+ {m68k_op_and_16_re_ai , 0xf1f8, 0xc150, 12},+ {m68k_op_and_16_re_pi , 0xf1f8, 0xc158, 12},+ {m68k_op_and_16_re_pd , 0xf1f8, 0xc160, 14},+ {m68k_op_and_16_re_di , 0xf1f8, 0xc168, 16},+ {m68k_op_and_16_re_ix , 0xf1f8, 0xc170, 18},+ {m68k_op_exg_32_da , 0xf1f8, 0xc188, 6},+ {m68k_op_and_32_re_ai , 0xf1f8, 0xc190, 20},+ {m68k_op_and_32_re_pi , 0xf1f8, 0xc198, 20},+ {m68k_op_and_32_re_pd , 0xf1f8, 0xc1a0, 22},+ {m68k_op_and_32_re_di , 0xf1f8, 0xc1a8, 24},+ {m68k_op_and_32_re_ix , 0xf1f8, 0xc1b0, 26},+ {m68k_op_muls_16_d , 0xf1f8, 0xc1c0, 0},+ {m68k_op_muls_16_ai , 0xf1f8, 0xc1d0, 4},+ {m68k_op_muls_16_pi , 0xf1f8, 0xc1d8, 4},+ {m68k_op_muls_16_pd , 0xf1f8, 0xc1e0, 6},+ {m68k_op_muls_16_di , 0xf1f8, 0xc1e8, 8},+ {m68k_op_muls_16_ix , 0xf1f8, 0xc1f0, 10},+ {m68k_op_add_8_er_d , 0xf1f8, 0xd000, 4},+ {m68k_op_add_8_er_ai , 0xf1f8, 0xd010, 8},+ {m68k_op_add_8_er_pi , 0xf1f8, 0xd018, 8},+ {m68k_op_add_8_er_pd , 0xf1f8, 0xd020, 10},+ {m68k_op_add_8_er_di , 0xf1f8, 0xd028, 12},+ {m68k_op_add_8_er_ix , 0xf1f8, 0xd030, 14},+ {m68k_op_add_16_er_d , 0xf1f8, 0xd040, 4},+ {m68k_op_add_16_er_a , 0xf1f8, 0xd048, 4},+ {m68k_op_add_16_er_ai , 0xf1f8, 0xd050, 8},+ {m68k_op_add_16_er_pi , 0xf1f8, 0xd058, 8},+ {m68k_op_add_16_er_pd , 0xf1f8, 0xd060, 10},+ {m68k_op_add_16_er_di , 0xf1f8, 0xd068, 12},+ {m68k_op_add_16_er_ix , 0xf1f8, 0xd070, 14},+ {m68k_op_add_32_er_d , 0xf1f8, 0xd080, 8},+ {m68k_op_add_32_er_a , 0xf1f8, 0xd088, 8},+ {m68k_op_add_32_er_ai , 0xf1f8, 0xd090, 14},+ {m68k_op_add_32_er_pi , 0xf1f8, 0xd098, 14},+ {m68k_op_add_32_er_pd , 0xf1f8, 0xd0a0, 16},+ {m68k_op_add_32_er_di , 0xf1f8, 0xd0a8, 18},+ {m68k_op_add_32_er_ix , 0xf1f8, 0xd0b0, 20},+ {m68k_op_adda_16_d , 0xf1f8, 0xd0c0, 8},+ {m68k_op_adda_16_a , 0xf1f8, 0xd0c8, 8},+ {m68k_op_adda_16_ai , 0xf1f8, 0xd0d0, 12},+ {m68k_op_adda_16_pi , 0xf1f8, 0xd0d8, 12},+ {m68k_op_adda_16_pd , 0xf1f8, 0xd0e0, 14},+ {m68k_op_adda_16_di , 0xf1f8, 0xd0e8, 16},+ {m68k_op_adda_16_ix , 0xf1f8, 0xd0f0, 18},+ {m68k_op_addx_8_rr , 0xf1f8, 0xd100, 4},+ {m68k_op_addx_8_mm , 0xf1f8, 0xd108, 18},+ {m68k_op_add_8_re_ai , 0xf1f8, 0xd110, 12},+ {m68k_op_add_8_re_pi , 0xf1f8, 0xd118, 12},+ {m68k_op_add_8_re_pd , 0xf1f8, 0xd120, 14},+ {m68k_op_add_8_re_di , 0xf1f8, 0xd128, 16},+ {m68k_op_add_8_re_ix , 0xf1f8, 0xd130, 18},+ {m68k_op_addx_16_rr , 0xf1f8, 0xd140, 4},+ {m68k_op_addx_16_mm , 0xf1f8, 0xd148, 18},+ {m68k_op_add_16_re_ai , 0xf1f8, 0xd150, 12},+ {m68k_op_add_16_re_pi , 0xf1f8, 0xd158, 12},+ {m68k_op_add_16_re_pd , 0xf1f8, 0xd160, 14},+ {m68k_op_add_16_re_di , 0xf1f8, 0xd168, 16},+ {m68k_op_add_16_re_ix , 0xf1f8, 0xd170, 18},+ {m68k_op_addx_32_rr , 0xf1f8, 0xd180, 8},+ {m68k_op_addx_32_mm , 0xf1f8, 0xd188, 30},+ {m68k_op_add_32_re_ai , 0xf1f8, 0xd190, 20},+ {m68k_op_add_32_re_pi , 0xf1f8, 0xd198, 20},+ {m68k_op_add_32_re_pd , 0xf1f8, 0xd1a0, 22},+ {m68k_op_add_32_re_di , 0xf1f8, 0xd1a8, 24},+ {m68k_op_add_32_re_ix , 0xf1f8, 0xd1b0, 26},+ {m68k_op_adda_32_d , 0xf1f8, 0xd1c0, 8},+ {m68k_op_adda_32_a , 0xf1f8, 0xd1c8, 8},+ {m68k_op_adda_32_ai , 0xf1f8, 0xd1d0, 14},+ {m68k_op_adda_32_pi , 0xf1f8, 0xd1d8, 14},+ {m68k_op_adda_32_pd , 0xf1f8, 0xd1e0, 16},+ {m68k_op_adda_32_di , 0xf1f8, 0xd1e8, 18},+ {m68k_op_adda_32_ix , 0xf1f8, 0xd1f0, 20},+ {m68k_op_asr_8_s , 0xf1f8, 0xe000, 6},+ {m68k_op_lsr_8_s , 0xf1f8, 0xe008, 6},+ {m68k_op_roxr_8_s , 0xf1f8, 0xe010, 6},+ {m68k_op_ror_8_s , 0xf1f8, 0xe018, 6},+ {m68k_op_asr_8_r , 0xf1f8, 0xe020, 6},+ {m68k_op_lsr_8_r , 0xf1f8, 0xe028, 6},+ {m68k_op_roxr_8_r , 0xf1f8, 0xe030, 6},+ {m68k_op_ror_8_r , 0xf1f8, 0xe038, 6},+ {m68k_op_asr_16_s , 0xf1f8, 0xe040, 6},+ {m68k_op_lsr_16_s , 0xf1f8, 0xe048, 6},+ {m68k_op_roxr_16_s , 0xf1f8, 0xe050, 6},+ {m68k_op_ror_16_s , 0xf1f8, 0xe058, 6},+ {m68k_op_asr_16_r , 0xf1f8, 0xe060, 6},+ {m68k_op_lsr_16_r , 0xf1f8, 0xe068, 6},+ {m68k_op_roxr_16_r , 0xf1f8, 0xe070, 6},+ {m68k_op_ror_16_r , 0xf1f8, 0xe078, 6},+ {m68k_op_asr_32_s , 0xf1f8, 0xe080, 8},+ {m68k_op_lsr_32_s , 0xf1f8, 0xe088, 8},+ {m68k_op_roxr_32_s , 0xf1f8, 0xe090, 8},+ {m68k_op_ror_32_s , 0xf1f8, 0xe098, 8},+ {m68k_op_asr_32_r , 0xf1f8, 0xe0a0, 8},+ {m68k_op_lsr_32_r , 0xf1f8, 0xe0a8, 8},+ {m68k_op_roxr_32_r , 0xf1f8, 0xe0b0, 8},+ {m68k_op_ror_32_r , 0xf1f8, 0xe0b8, 8},+ {m68k_op_asl_8_s , 0xf1f8, 0xe100, 6},+ {m68k_op_lsl_8_s , 0xf1f8, 0xe108, 6},+ {m68k_op_roxl_8_s , 0xf1f8, 0xe110, 6},+ {m68k_op_rol_8_s , 0xf1f8, 0xe118, 6},+ {m68k_op_asl_8_r , 0xf1f8, 0xe120, 6},+ {m68k_op_lsl_8_r , 0xf1f8, 0xe128, 6},+ {m68k_op_roxl_8_r , 0xf1f8, 0xe130, 6},+ {m68k_op_rol_8_r , 0xf1f8, 0xe138, 6},+ {m68k_op_asl_16_s , 0xf1f8, 0xe140, 6},+ {m68k_op_lsl_16_s , 0xf1f8, 0xe148, 6},+ {m68k_op_roxl_16_s , 0xf1f8, 0xe150, 6},+ {m68k_op_rol_16_s , 0xf1f8, 0xe158, 6},+ {m68k_op_asl_16_r , 0xf1f8, 0xe160, 6},+ {m68k_op_lsl_16_r , 0xf1f8, 0xe168, 6},+ {m68k_op_roxl_16_r , 0xf1f8, 0xe170, 6},+ {m68k_op_rol_16_r , 0xf1f8, 0xe178, 6},+ {m68k_op_asl_32_s , 0xf1f8, 0xe180, 8},+ {m68k_op_lsl_32_s , 0xf1f8, 0xe188, 8},+ {m68k_op_roxl_32_s , 0xf1f8, 0xe190, 8},+ {m68k_op_rol_32_s , 0xf1f8, 0xe198, 8},+ {m68k_op_asl_32_r , 0xf1f8, 0xe1a0, 8},+ {m68k_op_lsl_32_r , 0xf1f8, 0xe1a8, 8},+ {m68k_op_roxl_32_r , 0xf1f8, 0xe1b0, 8},+ {m68k_op_rol_32_r , 0xf1f8, 0xe1b8, 8},+ {m68k_op_trap , 0xfff0, 0x4e40, 4},+ {m68k_op_btst_8_r_pi7 , 0xf1ff, 0x011f, 8},+ {m68k_op_btst_8_r_pd7 , 0xf1ff, 0x0127, 10},+ {m68k_op_btst_8_r_aw , 0xf1ff, 0x0138, 12},+ {m68k_op_btst_8_r_al , 0xf1ff, 0x0139, 16},+ {m68k_op_btst_8_r_pcdi , 0xf1ff, 0x013a, 12},+ {m68k_op_btst_8_r_pcix , 0xf1ff, 0x013b, 14},+ {m68k_op_btst_8_r_i , 0xf1ff, 0x013c, 10},+ {m68k_op_bchg_8_r_pi7 , 0xf1ff, 0x015f, 12},+ {m68k_op_bchg_8_r_pd7 , 0xf1ff, 0x0167, 14},+ {m68k_op_bchg_8_r_aw , 0xf1ff, 0x0178, 16},+ {m68k_op_bchg_8_r_al , 0xf1ff, 0x0179, 20},+ {m68k_op_bclr_8_r_pi7 , 0xf1ff, 0x019f, 12},+ {m68k_op_bclr_8_r_pd7 , 0xf1ff, 0x01a7, 14},+ {m68k_op_bclr_8_r_aw , 0xf1ff, 0x01b8, 16},+ {m68k_op_bclr_8_r_al , 0xf1ff, 0x01b9, 20},+ {m68k_op_bset_8_r_pi7 , 0xf1ff, 0x01df, 12},+ {m68k_op_bset_8_r_pd7 , 0xf1ff, 0x01e7, 14},+ {m68k_op_bset_8_r_aw , 0xf1ff, 0x01f8, 16},+ {m68k_op_bset_8_r_al , 0xf1ff, 0x01f9, 20},+ {m68k_op_move_8_d_pi7 , 0xf1ff, 0x101f, 8},+ {m68k_op_move_8_d_pd7 , 0xf1ff, 0x1027, 10},+ {m68k_op_move_8_d_aw , 0xf1ff, 0x1038, 12},+ {m68k_op_move_8_d_al , 0xf1ff, 0x1039, 16},+ {m68k_op_move_8_d_pcdi , 0xf1ff, 0x103a, 12},+ {m68k_op_move_8_d_pcix , 0xf1ff, 0x103b, 14},+ {m68k_op_move_8_d_i , 0xf1ff, 0x103c, 8},+ {m68k_op_move_8_ai_pi7 , 0xf1ff, 0x109f, 12},+ {m68k_op_move_8_ai_pd7 , 0xf1ff, 0x10a7, 14},+ {m68k_op_move_8_ai_aw , 0xf1ff, 0x10b8, 16},+ {m68k_op_move_8_ai_al , 0xf1ff, 0x10b9, 20},+ {m68k_op_move_8_ai_pcdi , 0xf1ff, 0x10ba, 16},+ {m68k_op_move_8_ai_pcix , 0xf1ff, 0x10bb, 18},+ {m68k_op_move_8_ai_i , 0xf1ff, 0x10bc, 12},+ {m68k_op_move_8_pi_pi7 , 0xf1ff, 0x10df, 12},+ {m68k_op_move_8_pi_pd7 , 0xf1ff, 0x10e7, 14},+ {m68k_op_move_8_pi_aw , 0xf1ff, 0x10f8, 16},+ {m68k_op_move_8_pi_al , 0xf1ff, 0x10f9, 20},+ {m68k_op_move_8_pi_pcdi , 0xf1ff, 0x10fa, 16},+ {m68k_op_move_8_pi_pcix , 0xf1ff, 0x10fb, 18},+ {m68k_op_move_8_pi_i , 0xf1ff, 0x10fc, 12},+ {m68k_op_move_8_pd_pi7 , 0xf1ff, 0x111f, 12},+ {m68k_op_move_8_pd_pd7 , 0xf1ff, 0x1127, 14},+ {m68k_op_move_8_pd_aw , 0xf1ff, 0x1138, 16},+ {m68k_op_move_8_pd_al , 0xf1ff, 0x1139, 20},+ {m68k_op_move_8_pd_pcdi , 0xf1ff, 0x113a, 16},+ {m68k_op_move_8_pd_pcix , 0xf1ff, 0x113b, 18},+ {m68k_op_move_8_pd_i , 0xf1ff, 0x113c, 12},+ {m68k_op_move_8_di_pi7 , 0xf1ff, 0x115f, 16},+ {m68k_op_move_8_di_pd7 , 0xf1ff, 0x1167, 18},+ {m68k_op_move_8_di_aw , 0xf1ff, 0x1178, 20},+ {m68k_op_move_8_di_al , 0xf1ff, 0x1179, 24},+ {m68k_op_move_8_di_pcdi , 0xf1ff, 0x117a, 20},+ {m68k_op_move_8_di_pcix , 0xf1ff, 0x117b, 22},+ {m68k_op_move_8_di_i , 0xf1ff, 0x117c, 16},+ {m68k_op_move_8_ix_pi7 , 0xf1ff, 0x119f, 18},+ {m68k_op_move_8_ix_pd7 , 0xf1ff, 0x11a7, 20},+ {m68k_op_move_8_ix_aw , 0xf1ff, 0x11b8, 22},+ {m68k_op_move_8_ix_al , 0xf1ff, 0x11b9, 26},+ {m68k_op_move_8_ix_pcdi , 0xf1ff, 0x11ba, 22},+ {m68k_op_move_8_ix_pcix , 0xf1ff, 0x11bb, 24},+ {m68k_op_move_8_ix_i , 0xf1ff, 0x11bc, 18},+ {m68k_op_move_32_d_aw , 0xf1ff, 0x2038, 16},+ {m68k_op_move_32_d_al , 0xf1ff, 0x2039, 20},+ {m68k_op_move_32_d_pcdi , 0xf1ff, 0x203a, 16},+ {m68k_op_move_32_d_pcix , 0xf1ff, 0x203b, 18},+ {m68k_op_move_32_d_i , 0xf1ff, 0x203c, 12},+ {m68k_op_movea_32_aw , 0xf1ff, 0x2078, 16},+ {m68k_op_movea_32_al , 0xf1ff, 0x2079, 20},+ {m68k_op_movea_32_pcdi , 0xf1ff, 0x207a, 16},+ {m68k_op_movea_32_pcix , 0xf1ff, 0x207b, 18},+ {m68k_op_movea_32_i , 0xf1ff, 0x207c, 12},+ {m68k_op_move_32_ai_aw , 0xf1ff, 0x20b8, 24},+ {m68k_op_move_32_ai_al , 0xf1ff, 0x20b9, 28},+ {m68k_op_move_32_ai_pcdi , 0xf1ff, 0x20ba, 24},+ {m68k_op_move_32_ai_pcix , 0xf1ff, 0x20bb, 26},+ {m68k_op_move_32_ai_i , 0xf1ff, 0x20bc, 20},+ {m68k_op_move_32_pi_aw , 0xf1ff, 0x20f8, 24},+ {m68k_op_move_32_pi_al , 0xf1ff, 0x20f9, 28},+ {m68k_op_move_32_pi_pcdi , 0xf1ff, 0x20fa, 24},+ {m68k_op_move_32_pi_pcix , 0xf1ff, 0x20fb, 26},+ {m68k_op_move_32_pi_i , 0xf1ff, 0x20fc, 20},+ {m68k_op_move_32_pd_aw , 0xf1ff, 0x2138, 24},+ {m68k_op_move_32_pd_al , 0xf1ff, 0x2139, 28},+ {m68k_op_move_32_pd_pcdi , 0xf1ff, 0x213a, 24},+ {m68k_op_move_32_pd_pcix , 0xf1ff, 0x213b, 26},+ {m68k_op_move_32_pd_i , 0xf1ff, 0x213c, 20},+ {m68k_op_move_32_di_aw , 0xf1ff, 0x2178, 28},+ {m68k_op_move_32_di_al , 0xf1ff, 0x2179, 32},+ {m68k_op_move_32_di_pcdi , 0xf1ff, 0x217a, 28},+ {m68k_op_move_32_di_pcix , 0xf1ff, 0x217b, 30},+ {m68k_op_move_32_di_i , 0xf1ff, 0x217c, 24},+ {m68k_op_move_32_ix_aw , 0xf1ff, 0x21b8, 30},+ {m68k_op_move_32_ix_al , 0xf1ff, 0x21b9, 34},+ {m68k_op_move_32_ix_pcdi , 0xf1ff, 0x21ba, 30},+ {m68k_op_move_32_ix_pcix , 0xf1ff, 0x21bb, 32},+ {m68k_op_move_32_ix_i , 0xf1ff, 0x21bc, 26},+ {m68k_op_move_16_d_aw , 0xf1ff, 0x3038, 12},+ {m68k_op_move_16_d_al , 0xf1ff, 0x3039, 16},+ {m68k_op_move_16_d_pcdi , 0xf1ff, 0x303a, 12},+ {m68k_op_move_16_d_pcix , 0xf1ff, 0x303b, 14},+ {m68k_op_move_16_d_i , 0xf1ff, 0x303c, 8},+ {m68k_op_movea_16_aw , 0xf1ff, 0x3078, 12},+ {m68k_op_movea_16_al , 0xf1ff, 0x3079, 16},+ {m68k_op_movea_16_pcdi , 0xf1ff, 0x307a, 12},+ {m68k_op_movea_16_pcix , 0xf1ff, 0x307b, 14},+ {m68k_op_movea_16_i , 0xf1ff, 0x307c, 8},+ {m68k_op_move_16_ai_aw , 0xf1ff, 0x30b8, 16},+ {m68k_op_move_16_ai_al , 0xf1ff, 0x30b9, 20},+ {m68k_op_move_16_ai_pcdi , 0xf1ff, 0x30ba, 16},+ {m68k_op_move_16_ai_pcix , 0xf1ff, 0x30bb, 18},+ {m68k_op_move_16_ai_i , 0xf1ff, 0x30bc, 12},+ {m68k_op_move_16_pi_aw , 0xf1ff, 0x30f8, 16},+ {m68k_op_move_16_pi_al , 0xf1ff, 0x30f9, 20},+ {m68k_op_move_16_pi_pcdi , 0xf1ff, 0x30fa, 16},+ {m68k_op_move_16_pi_pcix , 0xf1ff, 0x30fb, 18},+ {m68k_op_move_16_pi_i , 0xf1ff, 0x30fc, 12},+ {m68k_op_move_16_pd_aw , 0xf1ff, 0x3138, 16},+ {m68k_op_move_16_pd_al , 0xf1ff, 0x3139, 20},+ {m68k_op_move_16_pd_pcdi , 0xf1ff, 0x313a, 16},+ {m68k_op_move_16_pd_pcix , 0xf1ff, 0x313b, 18},+ {m68k_op_move_16_pd_i , 0xf1ff, 0x313c, 12},+ {m68k_op_move_16_di_aw , 0xf1ff, 0x3178, 20},+ {m68k_op_move_16_di_al , 0xf1ff, 0x3179, 24},+ {m68k_op_move_16_di_pcdi , 0xf1ff, 0x317a, 20},+ {m68k_op_move_16_di_pcix , 0xf1ff, 0x317b, 22},+ {m68k_op_move_16_di_i , 0xf1ff, 0x317c, 16},+ {m68k_op_move_16_ix_aw , 0xf1ff, 0x31b8, 22},+ {m68k_op_move_16_ix_al , 0xf1ff, 0x31b9, 26},+ {m68k_op_move_16_ix_pcdi , 0xf1ff, 0x31ba, 22},+ {m68k_op_move_16_ix_pcix , 0xf1ff, 0x31bb, 24},+ {m68k_op_move_16_ix_i , 0xf1ff, 0x31bc, 18},+ {m68k_op_chk_16_aw , 0xf1ff, 0x41b8, 18},+ {m68k_op_chk_16_al , 0xf1ff, 0x41b9, 22},+ {m68k_op_chk_16_pcdi , 0xf1ff, 0x41ba, 18},+ {m68k_op_chk_16_pcix , 0xf1ff, 0x41bb, 20},+ {m68k_op_chk_16_i , 0xf1ff, 0x41bc, 14},+ {m68k_op_lea_32_aw , 0xf1ff, 0x41f8, 8},+ {m68k_op_lea_32_al , 0xf1ff, 0x41f9, 12},+ {m68k_op_lea_32_pcdi , 0xf1ff, 0x41fa, 8},+ {m68k_op_lea_32_pcix , 0xf1ff, 0x41fb, 12},+ {m68k_op_addq_8_pi7 , 0xf1ff, 0x501f, 12},+ {m68k_op_addq_8_pd7 , 0xf1ff, 0x5027, 14},+ {m68k_op_addq_8_aw , 0xf1ff, 0x5038, 16},+ {m68k_op_addq_8_al , 0xf1ff, 0x5039, 20},+ {m68k_op_addq_16_aw , 0xf1ff, 0x5078, 16},+ {m68k_op_addq_16_al , 0xf1ff, 0x5079, 20},+ {m68k_op_addq_32_aw , 0xf1ff, 0x50b8, 24},+ {m68k_op_addq_32_al , 0xf1ff, 0x50b9, 28},+ {m68k_op_subq_8_pi7 , 0xf1ff, 0x511f, 12},+ {m68k_op_subq_8_pd7 , 0xf1ff, 0x5127, 14},+ {m68k_op_subq_8_aw , 0xf1ff, 0x5138, 16},+ {m68k_op_subq_8_al , 0xf1ff, 0x5139, 20},+ {m68k_op_subq_16_aw , 0xf1ff, 0x5178, 16},+ {m68k_op_subq_16_al , 0xf1ff, 0x5179, 20},+ {m68k_op_subq_32_aw , 0xf1ff, 0x51b8, 24},+ {m68k_op_subq_32_al , 0xf1ff, 0x51b9, 28},+ {m68k_op_or_8_er_pi7 , 0xf1ff, 0x801f, 8},+ {m68k_op_or_8_er_pd7 , 0xf1ff, 0x8027, 10},+ {m68k_op_or_8_er_aw , 0xf1ff, 0x8038, 12},+ {m68k_op_or_8_er_al , 0xf1ff, 0x8039, 16},+ {m68k_op_or_8_er_pcdi , 0xf1ff, 0x803a, 12},+ {m68k_op_or_8_er_pcix , 0xf1ff, 0x803b, 14},+ {m68k_op_or_8_er_i , 0xf1ff, 0x803c, 8},+ {m68k_op_or_16_er_aw , 0xf1ff, 0x8078, 12},+ {m68k_op_or_16_er_al , 0xf1ff, 0x8079, 16},+ {m68k_op_or_16_er_pcdi , 0xf1ff, 0x807a, 12},+ {m68k_op_or_16_er_pcix , 0xf1ff, 0x807b, 14},+ {m68k_op_or_16_er_i , 0xf1ff, 0x807c, 8},+ {m68k_op_or_32_er_aw , 0xf1ff, 0x80b8, 18},+ {m68k_op_or_32_er_al , 0xf1ff, 0x80b9, 22},+ {m68k_op_or_32_er_pcdi , 0xf1ff, 0x80ba, 18},+ {m68k_op_or_32_er_pcix , 0xf1ff, 0x80bb, 20},+ {m68k_op_or_32_er_i , 0xf1ff, 0x80bc, 16},+ {m68k_op_divu_16_aw , 0xf1ff, 0x80f8, 8},+ {m68k_op_divu_16_al , 0xf1ff, 0x80f9, 12},+ {m68k_op_divu_16_pcdi , 0xf1ff, 0x80fa, 8},+ {m68k_op_divu_16_pcix , 0xf1ff, 0x80fb, 10},+ {m68k_op_divu_16_i , 0xf1ff, 0x80fc, 4},+ {m68k_op_sbcd_8_mm_ay7 , 0xf1ff, 0x810f, 18},+ {m68k_op_or_8_re_pi7 , 0xf1ff, 0x811f, 12},+ {m68k_op_or_8_re_pd7 , 0xf1ff, 0x8127, 14},+ {m68k_op_or_8_re_aw , 0xf1ff, 0x8138, 16},+ {m68k_op_or_8_re_al , 0xf1ff, 0x8139, 20},+ {m68k_op_or_16_re_aw , 0xf1ff, 0x8178, 16},+ {m68k_op_or_16_re_al , 0xf1ff, 0x8179, 20},+ {m68k_op_or_32_re_aw , 0xf1ff, 0x81b8, 24},+ {m68k_op_or_32_re_al , 0xf1ff, 0x81b9, 28},+ {m68k_op_divs_16_aw , 0xf1ff, 0x81f8, 8},+ {m68k_op_divs_16_al , 0xf1ff, 0x81f9, 12},+ {m68k_op_divs_16_pcdi , 0xf1ff, 0x81fa, 8},+ {m68k_op_divs_16_pcix , 0xf1ff, 0x81fb, 10},+ {m68k_op_divs_16_i , 0xf1ff, 0x81fc, 4},+ {m68k_op_sub_8_er_pi7 , 0xf1ff, 0x901f, 8},+ {m68k_op_sub_8_er_pd7 , 0xf1ff, 0x9027, 10},+ {m68k_op_sub_8_er_aw , 0xf1ff, 0x9038, 12},+ {m68k_op_sub_8_er_al , 0xf1ff, 0x9039, 16},+ {m68k_op_sub_8_er_pcdi , 0xf1ff, 0x903a, 12},+ {m68k_op_sub_8_er_pcix , 0xf1ff, 0x903b, 14},+ {m68k_op_sub_8_er_i , 0xf1ff, 0x903c, 8},+ {m68k_op_sub_16_er_aw , 0xf1ff, 0x9078, 12},+ {m68k_op_sub_16_er_al , 0xf1ff, 0x9079, 16},+ {m68k_op_sub_16_er_pcdi , 0xf1ff, 0x907a, 12},+ {m68k_op_sub_16_er_pcix , 0xf1ff, 0x907b, 14},+ {m68k_op_sub_16_er_i , 0xf1ff, 0x907c, 8},+ {m68k_op_sub_32_er_aw , 0xf1ff, 0x90b8, 18},+ {m68k_op_sub_32_er_al , 0xf1ff, 0x90b9, 22},+ {m68k_op_sub_32_er_pcdi , 0xf1ff, 0x90ba, 18},+ {m68k_op_sub_32_er_pcix , 0xf1ff, 0x90bb, 20},+ {m68k_op_sub_32_er_i , 0xf1ff, 0x90bc, 16},+ {m68k_op_suba_16_aw , 0xf1ff, 0x90f8, 16},+ {m68k_op_suba_16_al , 0xf1ff, 0x90f9, 20},+ {m68k_op_suba_16_pcdi , 0xf1ff, 0x90fa, 16},+ {m68k_op_suba_16_pcix , 0xf1ff, 0x90fb, 18},+ {m68k_op_suba_16_i , 0xf1ff, 0x90fc, 12},+ {m68k_op_subx_8_mm_ay7 , 0xf1ff, 0x910f, 18},+ {m68k_op_sub_8_re_pi7 , 0xf1ff, 0x911f, 12},+ {m68k_op_sub_8_re_pd7 , 0xf1ff, 0x9127, 14},+ {m68k_op_sub_8_re_aw , 0xf1ff, 0x9138, 16},+ {m68k_op_sub_8_re_al , 0xf1ff, 0x9139, 20},+ {m68k_op_sub_16_re_aw , 0xf1ff, 0x9178, 16},+ {m68k_op_sub_16_re_al , 0xf1ff, 0x9179, 20},+ {m68k_op_sub_32_re_aw , 0xf1ff, 0x91b8, 24},+ {m68k_op_sub_32_re_al , 0xf1ff, 0x91b9, 28},+ {m68k_op_suba_32_aw , 0xf1ff, 0x91f8, 18},+ {m68k_op_suba_32_al , 0xf1ff, 0x91f9, 22},+ {m68k_op_suba_32_pcdi , 0xf1ff, 0x91fa, 18},+ {m68k_op_suba_32_pcix , 0xf1ff, 0x91fb, 20},+ {m68k_op_suba_32_i , 0xf1ff, 0x91fc, 16},+ {m68k_op_cmp_8_pi7 , 0xf1ff, 0xb01f, 8},+ {m68k_op_cmp_8_pd7 , 0xf1ff, 0xb027, 10},+ {m68k_op_cmp_8_aw , 0xf1ff, 0xb038, 12},+ {m68k_op_cmp_8_al , 0xf1ff, 0xb039, 16},+ {m68k_op_cmp_8_pcdi , 0xf1ff, 0xb03a, 12},+ {m68k_op_cmp_8_pcix , 0xf1ff, 0xb03b, 14},+ {m68k_op_cmp_8_i , 0xf1ff, 0xb03c, 8},+ {m68k_op_cmp_16_aw , 0xf1ff, 0xb078, 12},+ {m68k_op_cmp_16_al , 0xf1ff, 0xb079, 16},+ {m68k_op_cmp_16_pcdi , 0xf1ff, 0xb07a, 12},+ {m68k_op_cmp_16_pcix , 0xf1ff, 0xb07b, 14},+ {m68k_op_cmp_16_i , 0xf1ff, 0xb07c, 8},+ {m68k_op_cmp_32_aw , 0xf1ff, 0xb0b8, 18},+ {m68k_op_cmp_32_al , 0xf1ff, 0xb0b9, 22},+ {m68k_op_cmp_32_pcdi , 0xf1ff, 0xb0ba, 18},+ {m68k_op_cmp_32_pcix , 0xf1ff, 0xb0bb, 20},+ {m68k_op_cmp_32_i , 0xf1ff, 0xb0bc, 14},+ {m68k_op_cmpa_16_aw , 0xf1ff, 0xb0f8, 14},+ {m68k_op_cmpa_16_al , 0xf1ff, 0xb0f9, 18},+ {m68k_op_cmpa_16_pcdi , 0xf1ff, 0xb0fa, 14},+ {m68k_op_cmpa_16_pcix , 0xf1ff, 0xb0fb, 16},+ {m68k_op_cmpa_16_i , 0xf1ff, 0xb0fc, 10},+ {m68k_op_cmpm_8_ay7 , 0xf1ff, 0xb10f, 12},+ {m68k_op_eor_8_pi7 , 0xf1ff, 0xb11f, 12},+ {m68k_op_eor_8_pd7 , 0xf1ff, 0xb127, 14},+ {m68k_op_eor_8_aw , 0xf1ff, 0xb138, 16},+ {m68k_op_eor_8_al , 0xf1ff, 0xb139, 20},+ {m68k_op_eor_16_aw , 0xf1ff, 0xb178, 16},+ {m68k_op_eor_16_al , 0xf1ff, 0xb179, 20},+ {m68k_op_eor_32_aw , 0xf1ff, 0xb1b8, 24},+ {m68k_op_eor_32_al , 0xf1ff, 0xb1b9, 28},+ {m68k_op_cmpa_32_aw , 0xf1ff, 0xb1f8, 18},+ {m68k_op_cmpa_32_al , 0xf1ff, 0xb1f9, 22},+ {m68k_op_cmpa_32_pcdi , 0xf1ff, 0xb1fa, 18},+ {m68k_op_cmpa_32_pcix , 0xf1ff, 0xb1fb, 20},+ {m68k_op_cmpa_32_i , 0xf1ff, 0xb1fc, 14},+ {m68k_op_and_8_er_pi7 , 0xf1ff, 0xc01f, 8},+ {m68k_op_and_8_er_pd7 , 0xf1ff, 0xc027, 10},+ {m68k_op_and_8_er_aw , 0xf1ff, 0xc038, 12},+ {m68k_op_and_8_er_al , 0xf1ff, 0xc039, 16},+ {m68k_op_and_8_er_pcdi , 0xf1ff, 0xc03a, 12},+ {m68k_op_and_8_er_pcix , 0xf1ff, 0xc03b, 14},+ {m68k_op_and_8_er_i , 0xf1ff, 0xc03c, 8},+ {m68k_op_and_16_er_aw , 0xf1ff, 0xc078, 12},+ {m68k_op_and_16_er_al , 0xf1ff, 0xc079, 16},+ {m68k_op_and_16_er_pcdi , 0xf1ff, 0xc07a, 12},+ {m68k_op_and_16_er_pcix , 0xf1ff, 0xc07b, 14},+ {m68k_op_and_16_er_i , 0xf1ff, 0xc07c, 8},+ {m68k_op_and_32_er_aw , 0xf1ff, 0xc0b8, 18},+ {m68k_op_and_32_er_al , 0xf1ff, 0xc0b9, 22},+ {m68k_op_and_32_er_pcdi , 0xf1ff, 0xc0ba, 18},+ {m68k_op_and_32_er_pcix , 0xf1ff, 0xc0bb, 20},+ {m68k_op_and_32_er_i , 0xf1ff, 0xc0bc, 16},+ {m68k_op_mulu_16_aw , 0xf1ff, 0xc0f8, 8},+ {m68k_op_mulu_16_al , 0xf1ff, 0xc0f9, 12},+ {m68k_op_mulu_16_pcdi , 0xf1ff, 0xc0fa, 8},+ {m68k_op_mulu_16_pcix , 0xf1ff, 0xc0fb, 10},+ {m68k_op_mulu_16_i , 0xf1ff, 0xc0fc, 4},+ {m68k_op_abcd_8_mm_ay7 , 0xf1ff, 0xc10f, 18},+ {m68k_op_and_8_re_pi7 , 0xf1ff, 0xc11f, 12},+ {m68k_op_and_8_re_pd7 , 0xf1ff, 0xc127, 14},+ {m68k_op_and_8_re_aw , 0xf1ff, 0xc138, 16},+ {m68k_op_and_8_re_al , 0xf1ff, 0xc139, 20},+ {m68k_op_and_16_re_aw , 0xf1ff, 0xc178, 16},+ {m68k_op_and_16_re_al , 0xf1ff, 0xc179, 20},+ {m68k_op_and_32_re_aw , 0xf1ff, 0xc1b8, 24},+ {m68k_op_and_32_re_al , 0xf1ff, 0xc1b9, 28},+ {m68k_op_muls_16_aw , 0xf1ff, 0xc1f8, 8},+ {m68k_op_muls_16_al , 0xf1ff, 0xc1f9, 12},+ {m68k_op_muls_16_pcdi , 0xf1ff, 0xc1fa, 8},+ {m68k_op_muls_16_pcix , 0xf1ff, 0xc1fb, 10},+ {m68k_op_muls_16_i , 0xf1ff, 0xc1fc, 4},+ {m68k_op_add_8_er_pi7 , 0xf1ff, 0xd01f, 8},+ {m68k_op_add_8_er_pd7 , 0xf1ff, 0xd027, 10},+ {m68k_op_add_8_er_aw , 0xf1ff, 0xd038, 12},+ {m68k_op_add_8_er_al , 0xf1ff, 0xd039, 16},+ {m68k_op_add_8_er_pcdi , 0xf1ff, 0xd03a, 12},+ {m68k_op_add_8_er_pcix , 0xf1ff, 0xd03b, 14},+ {m68k_op_add_8_er_i , 0xf1ff, 0xd03c, 8},+ {m68k_op_add_16_er_aw , 0xf1ff, 0xd078, 12},+ {m68k_op_add_16_er_al , 0xf1ff, 0xd079, 16},+ {m68k_op_add_16_er_pcdi , 0xf1ff, 0xd07a, 12},+ {m68k_op_add_16_er_pcix , 0xf1ff, 0xd07b, 14},+ {m68k_op_add_16_er_i , 0xf1ff, 0xd07c, 8},+ {m68k_op_add_32_er_aw , 0xf1ff, 0xd0b8, 18},+ {m68k_op_add_32_er_al , 0xf1ff, 0xd0b9, 22},+ {m68k_op_add_32_er_pcdi , 0xf1ff, 0xd0ba, 18},+ {m68k_op_add_32_er_pcix , 0xf1ff, 0xd0bb, 20},+ {m68k_op_add_32_er_i , 0xf1ff, 0xd0bc, 16},+ {m68k_op_adda_16_aw , 0xf1ff, 0xd0f8, 16},+ {m68k_op_adda_16_al , 0xf1ff, 0xd0f9, 20},+ {m68k_op_adda_16_pcdi , 0xf1ff, 0xd0fa, 16},+ {m68k_op_adda_16_pcix , 0xf1ff, 0xd0fb, 18},+ {m68k_op_adda_16_i , 0xf1ff, 0xd0fc, 12},+ {m68k_op_addx_8_mm_ay7 , 0xf1ff, 0xd10f, 18},+ {m68k_op_add_8_re_pi7 , 0xf1ff, 0xd11f, 12},+ {m68k_op_add_8_re_pd7 , 0xf1ff, 0xd127, 14},+ {m68k_op_add_8_re_aw , 0xf1ff, 0xd138, 16},+ {m68k_op_add_8_re_al , 0xf1ff, 0xd139, 20},+ {m68k_op_add_16_re_aw , 0xf1ff, 0xd178, 16},+ {m68k_op_add_16_re_al , 0xf1ff, 0xd179, 20},+ {m68k_op_add_32_re_aw , 0xf1ff, 0xd1b8, 24},+ {m68k_op_add_32_re_al , 0xf1ff, 0xd1b9, 28},+ {m68k_op_adda_32_aw , 0xf1ff, 0xd1f8, 18},+ {m68k_op_adda_32_al , 0xf1ff, 0xd1f9, 22},+ {m68k_op_adda_32_pcdi , 0xf1ff, 0xd1fa, 18},+ {m68k_op_adda_32_pcix , 0xf1ff, 0xd1fb, 20},+ {m68k_op_adda_32_i , 0xf1ff, 0xd1fc, 16},+ {m68k_op_ori_8_d , 0xfff8, 0x0000, 8},+ {m68k_op_ori_8_ai , 0xfff8, 0x0010, 16},+ {m68k_op_ori_8_pi , 0xfff8, 0x0018, 16},+ {m68k_op_ori_8_pd , 0xfff8, 0x0020, 18},+ {m68k_op_ori_8_di , 0xfff8, 0x0028, 20},+ {m68k_op_ori_8_ix , 0xfff8, 0x0030, 22},+ {m68k_op_ori_16_d , 0xfff8, 0x0040, 8},+ {m68k_op_ori_16_ai , 0xfff8, 0x0050, 16},+ {m68k_op_ori_16_pi , 0xfff8, 0x0058, 16},+ {m68k_op_ori_16_pd , 0xfff8, 0x0060, 18},+ {m68k_op_ori_16_di , 0xfff8, 0x0068, 20},+ {m68k_op_ori_16_ix , 0xfff8, 0x0070, 22},+ {m68k_op_ori_32_d , 0xfff8, 0x0080, 16},+ {m68k_op_ori_32_ai , 0xfff8, 0x0090, 28},+ {m68k_op_ori_32_pi , 0xfff8, 0x0098, 28},+ {m68k_op_ori_32_pd , 0xfff8, 0x00a0, 30},+ {m68k_op_ori_32_di , 0xfff8, 0x00a8, 32},+ {m68k_op_ori_32_ix , 0xfff8, 0x00b0, 34},+ {m68k_op_andi_8_d , 0xfff8, 0x0200, 8},+ {m68k_op_andi_8_ai , 0xfff8, 0x0210, 16},+ {m68k_op_andi_8_pi , 0xfff8, 0x0218, 16},+ {m68k_op_andi_8_pd , 0xfff8, 0x0220, 18},+ {m68k_op_andi_8_di , 0xfff8, 0x0228, 20},+ {m68k_op_andi_8_ix , 0xfff8, 0x0230, 22},+ {m68k_op_andi_16_d , 0xfff8, 0x0240, 8},+ {m68k_op_andi_16_ai , 0xfff8, 0x0250, 16},+ {m68k_op_andi_16_pi , 0xfff8, 0x0258, 16},+ {m68k_op_andi_16_pd , 0xfff8, 0x0260, 18},+ {m68k_op_andi_16_di , 0xfff8, 0x0268, 20},+ {m68k_op_andi_16_ix , 0xfff8, 0x0270, 22},+ {m68k_op_andi_32_d , 0xfff8, 0x0280, 16}, /* see Yacht.txt */+ {m68k_op_andi_32_ai , 0xfff8, 0x0290, 28},+ {m68k_op_andi_32_pi , 0xfff8, 0x0298, 28},+ {m68k_op_andi_32_pd , 0xfff8, 0x02a0, 30},+ {m68k_op_andi_32_di , 0xfff8, 0x02a8, 32},+ {m68k_op_andi_32_ix , 0xfff8, 0x02b0, 34},+ {m68k_op_subi_8_d , 0xfff8, 0x0400, 8},+ {m68k_op_subi_8_ai , 0xfff8, 0x0410, 16},+ {m68k_op_subi_8_pi , 0xfff8, 0x0418, 16},+ {m68k_op_subi_8_pd , 0xfff8, 0x0420, 18},+ {m68k_op_subi_8_di , 0xfff8, 0x0428, 20},+ {m68k_op_subi_8_ix , 0xfff8, 0x0430, 22},+ {m68k_op_subi_16_d , 0xfff8, 0x0440, 8},+ {m68k_op_subi_16_ai , 0xfff8, 0x0450, 16},+ {m68k_op_subi_16_pi , 0xfff8, 0x0458, 16},+ {m68k_op_subi_16_pd , 0xfff8, 0x0460, 18},+ {m68k_op_subi_16_di , 0xfff8, 0x0468, 20},+ {m68k_op_subi_16_ix , 0xfff8, 0x0470, 22},+ {m68k_op_subi_32_d , 0xfff8, 0x0480, 16},+ {m68k_op_subi_32_ai , 0xfff8, 0x0490, 28},+ {m68k_op_subi_32_pi , 0xfff8, 0x0498, 28},+ {m68k_op_subi_32_pd , 0xfff8, 0x04a0, 30},+ {m68k_op_subi_32_di , 0xfff8, 0x04a8, 32},+ {m68k_op_subi_32_ix , 0xfff8, 0x04b0, 34},+ {m68k_op_addi_8_d , 0xfff8, 0x0600, 8},+ {m68k_op_addi_8_ai , 0xfff8, 0x0610, 16},+ {m68k_op_addi_8_pi , 0xfff8, 0x0618, 16},+ {m68k_op_addi_8_pd , 0xfff8, 0x0620, 18},+ {m68k_op_addi_8_di , 0xfff8, 0x0628, 20},+ {m68k_op_addi_8_ix , 0xfff8, 0x0630, 22},+ {m68k_op_addi_16_d , 0xfff8, 0x0640, 8},+ {m68k_op_addi_16_ai , 0xfff8, 0x0650, 16},+ {m68k_op_addi_16_pi , 0xfff8, 0x0658, 16},+ {m68k_op_addi_16_pd , 0xfff8, 0x0660, 18},+ {m68k_op_addi_16_di , 0xfff8, 0x0668, 20},+ {m68k_op_addi_16_ix , 0xfff8, 0x0670, 22},+ {m68k_op_addi_32_d , 0xfff8, 0x0680, 16},+ {m68k_op_addi_32_ai , 0xfff8, 0x0690, 28},+ {m68k_op_addi_32_pi , 0xfff8, 0x0698, 28},+ {m68k_op_addi_32_pd , 0xfff8, 0x06a0, 30},+ {m68k_op_addi_32_di , 0xfff8, 0x06a8, 32},+ {m68k_op_addi_32_ix , 0xfff8, 0x06b0, 34},+ {m68k_op_btst_32_s_d , 0xfff8, 0x0800, 10},+ {m68k_op_btst_8_s_ai , 0xfff8, 0x0810, 12},+ {m68k_op_btst_8_s_pi , 0xfff8, 0x0818, 12},+ {m68k_op_btst_8_s_pd , 0xfff8, 0x0820, 14},+ {m68k_op_btst_8_s_di , 0xfff8, 0x0828, 16},+ {m68k_op_btst_8_s_ix , 0xfff8, 0x0830, 18},+ {m68k_op_bchg_32_s_d , 0xfff8, 0x0840, 12},+ {m68k_op_bchg_8_s_ai , 0xfff8, 0x0850, 16},+ {m68k_op_bchg_8_s_pi , 0xfff8, 0x0858, 16},+ {m68k_op_bchg_8_s_pd , 0xfff8, 0x0860, 18},+ {m68k_op_bchg_8_s_di , 0xfff8, 0x0868, 20},+ {m68k_op_bchg_8_s_ix , 0xfff8, 0x0870, 22},+ {m68k_op_bclr_32_s_d , 0xfff8, 0x0880, 14},+ {m68k_op_bclr_8_s_ai , 0xfff8, 0x0890, 16},+ {m68k_op_bclr_8_s_pi , 0xfff8, 0x0898, 16},+ {m68k_op_bclr_8_s_pd , 0xfff8, 0x08a0, 18},+ {m68k_op_bclr_8_s_di , 0xfff8, 0x08a8, 20},+ {m68k_op_bclr_8_s_ix , 0xfff8, 0x08b0, 22},+ {m68k_op_bset_32_s_d , 0xfff8, 0x08c0, 12},+ {m68k_op_bset_8_s_ai , 0xfff8, 0x08d0, 16},+ {m68k_op_bset_8_s_pi , 0xfff8, 0x08d8, 16},+ {m68k_op_bset_8_s_pd , 0xfff8, 0x08e0, 18},+ {m68k_op_bset_8_s_di , 0xfff8, 0x08e8, 20},+ {m68k_op_bset_8_s_ix , 0xfff8, 0x08f0, 22},+ {m68k_op_eori_8_d , 0xfff8, 0x0a00, 8},+ {m68k_op_eori_8_ai , 0xfff8, 0x0a10, 16},+ {m68k_op_eori_8_pi , 0xfff8, 0x0a18, 16},+ {m68k_op_eori_8_pd , 0xfff8, 0x0a20, 18},+ {m68k_op_eori_8_di , 0xfff8, 0x0a28, 20},+ {m68k_op_eori_8_ix , 0xfff8, 0x0a30, 22},+ {m68k_op_eori_16_d , 0xfff8, 0x0a40, 8},+ {m68k_op_eori_16_ai , 0xfff8, 0x0a50, 16},+ {m68k_op_eori_16_pi , 0xfff8, 0x0a58, 16},+ {m68k_op_eori_16_pd , 0xfff8, 0x0a60, 18},+ {m68k_op_eori_16_di , 0xfff8, 0x0a68, 20},+ {m68k_op_eori_16_ix , 0xfff8, 0x0a70, 22},+ {m68k_op_eori_32_d , 0xfff8, 0x0a80, 16},+ {m68k_op_eori_32_ai , 0xfff8, 0x0a90, 28},+ {m68k_op_eori_32_pi , 0xfff8, 0x0a98, 28},+ {m68k_op_eori_32_pd , 0xfff8, 0x0aa0, 30},+ {m68k_op_eori_32_di , 0xfff8, 0x0aa8, 32},+ {m68k_op_eori_32_ix , 0xfff8, 0x0ab0, 34},+ {m68k_op_cmpi_8_d , 0xfff8, 0x0c00, 8},+ {m68k_op_cmpi_8_ai , 0xfff8, 0x0c10, 12},+ {m68k_op_cmpi_8_pi , 0xfff8, 0x0c18, 12},+ {m68k_op_cmpi_8_pd , 0xfff8, 0x0c20, 14},+ {m68k_op_cmpi_8_di , 0xfff8, 0x0c28, 16},+ {m68k_op_cmpi_8_ix , 0xfff8, 0x0c30, 18},+ {m68k_op_cmpi_16_d , 0xfff8, 0x0c40, 8},+ {m68k_op_cmpi_16_ai , 0xfff8, 0x0c50, 12},+ {m68k_op_cmpi_16_pi , 0xfff8, 0x0c58, 12},+ {m68k_op_cmpi_16_pd , 0xfff8, 0x0c60, 14},+ {m68k_op_cmpi_16_di , 0xfff8, 0x0c68, 16},+ {m68k_op_cmpi_16_ix , 0xfff8, 0x0c70, 18},+ {m68k_op_cmpi_32_d , 0xfff8, 0x0c80, 14},+ {m68k_op_cmpi_32_ai , 0xfff8, 0x0c90, 20},+ {m68k_op_cmpi_32_pi , 0xfff8, 0x0c98, 20},+ {m68k_op_cmpi_32_pd , 0xfff8, 0x0ca0, 22},+ {m68k_op_cmpi_32_di , 0xfff8, 0x0ca8, 24},+ {m68k_op_cmpi_32_ix , 0xfff8, 0x0cb0, 26},+ {m68k_op_move_8_aw_d , 0xfff8, 0x11c0, 12},+ {m68k_op_move_8_aw_ai , 0xfff8, 0x11d0, 16},+ {m68k_op_move_8_aw_pi , 0xfff8, 0x11d8, 16},+ {m68k_op_move_8_aw_pd , 0xfff8, 0x11e0, 18},+ {m68k_op_move_8_aw_di , 0xfff8, 0x11e8, 20},+ {m68k_op_move_8_aw_ix , 0xfff8, 0x11f0, 22},+ {m68k_op_move_8_al_d , 0xfff8, 0x13c0, 16},+ {m68k_op_move_8_al_ai , 0xfff8, 0x13d0, 20},+ {m68k_op_move_8_al_pi , 0xfff8, 0x13d8, 20},+ {m68k_op_move_8_al_pd , 0xfff8, 0x13e0, 22},+ {m68k_op_move_8_al_di , 0xfff8, 0x13e8, 24},+ {m68k_op_move_8_al_ix , 0xfff8, 0x13f0, 26},+ {m68k_op_move_8_pi7_d , 0xfff8, 0x1ec0, 8},+ {m68k_op_move_8_pi7_ai , 0xfff8, 0x1ed0, 12},+ {m68k_op_move_8_pi7_pi , 0xfff8, 0x1ed8, 12},+ {m68k_op_move_8_pi7_pd , 0xfff8, 0x1ee0, 14},+ {m68k_op_move_8_pi7_di , 0xfff8, 0x1ee8, 16},+ {m68k_op_move_8_pi7_ix , 0xfff8, 0x1ef0, 18},+ {m68k_op_move_8_pd7_d , 0xfff8, 0x1f00, 8},+ {m68k_op_move_8_pd7_ai , 0xfff8, 0x1f10, 12},+ {m68k_op_move_8_pd7_pi , 0xfff8, 0x1f18, 12},+ {m68k_op_move_8_pd7_pd , 0xfff8, 0x1f20, 14},+ {m68k_op_move_8_pd7_di , 0xfff8, 0x1f28, 16},+ {m68k_op_move_8_pd7_ix , 0xfff8, 0x1f30, 18},+ {m68k_op_move_32_aw_d , 0xfff8, 0x21c0, 16},+ {m68k_op_move_32_aw_a , 0xfff8, 0x21c8, 16},+ {m68k_op_move_32_aw_ai , 0xfff8, 0x21d0, 24},+ {m68k_op_move_32_aw_pi , 0xfff8, 0x21d8, 24},+ {m68k_op_move_32_aw_pd , 0xfff8, 0x21e0, 26},+ {m68k_op_move_32_aw_di , 0xfff8, 0x21e8, 28},+ {m68k_op_move_32_aw_ix , 0xfff8, 0x21f0, 30},+ {m68k_op_move_32_al_d , 0xfff8, 0x23c0, 20},+ {m68k_op_move_32_al_a , 0xfff8, 0x23c8, 20},+ {m68k_op_move_32_al_ai , 0xfff8, 0x23d0, 28},+ {m68k_op_move_32_al_pi , 0xfff8, 0x23d8, 28},+ {m68k_op_move_32_al_pd , 0xfff8, 0x23e0, 30},+ {m68k_op_move_32_al_di , 0xfff8, 0x23e8, 32},+ {m68k_op_move_32_al_ix , 0xfff8, 0x23f0, 34},+ {m68k_op_move_16_aw_d , 0xfff8, 0x31c0, 12},+ {m68k_op_move_16_aw_a , 0xfff8, 0x31c8, 12},+ {m68k_op_move_16_aw_ai , 0xfff8, 0x31d0, 16},+ {m68k_op_move_16_aw_pi , 0xfff8, 0x31d8, 16},+ {m68k_op_move_16_aw_pd , 0xfff8, 0x31e0, 18},+ {m68k_op_move_16_aw_di , 0xfff8, 0x31e8, 20},+ {m68k_op_move_16_aw_ix , 0xfff8, 0x31f0, 22},+ {m68k_op_move_16_al_d , 0xfff8, 0x33c0, 16},+ {m68k_op_move_16_al_a , 0xfff8, 0x33c8, 16},+ {m68k_op_move_16_al_ai , 0xfff8, 0x33d0, 20},+ {m68k_op_move_16_al_pi , 0xfff8, 0x33d8, 20},+ {m68k_op_move_16_al_pd , 0xfff8, 0x33e0, 22},+ {m68k_op_move_16_al_di , 0xfff8, 0x33e8, 24},+ {m68k_op_move_16_al_ix , 0xfff8, 0x33f0, 26},+ {m68k_op_negx_8_d , 0xfff8, 0x4000, 4},+ {m68k_op_negx_8_ai , 0xfff8, 0x4010, 12},+ {m68k_op_negx_8_pi , 0xfff8, 0x4018, 12},+ {m68k_op_negx_8_pd , 0xfff8, 0x4020, 14},+ {m68k_op_negx_8_di , 0xfff8, 0x4028, 16},+ {m68k_op_negx_8_ix , 0xfff8, 0x4030, 18},+ {m68k_op_negx_16_d , 0xfff8, 0x4040, 4},+ {m68k_op_negx_16_ai , 0xfff8, 0x4050, 12},+ {m68k_op_negx_16_pi , 0xfff8, 0x4058, 12},+ {m68k_op_negx_16_pd , 0xfff8, 0x4060, 14},+ {m68k_op_negx_16_di , 0xfff8, 0x4068, 16},+ {m68k_op_negx_16_ix , 0xfff8, 0x4070, 18},+ {m68k_op_negx_32_d , 0xfff8, 0x4080, 6},+ {m68k_op_negx_32_ai , 0xfff8, 0x4090, 20},+ {m68k_op_negx_32_pi , 0xfff8, 0x4098, 20},+ {m68k_op_negx_32_pd , 0xfff8, 0x40a0, 22},+ {m68k_op_negx_32_di , 0xfff8, 0x40a8, 24},+ {m68k_op_negx_32_ix , 0xfff8, 0x40b0, 26},+ {m68k_op_move_16_frs_d , 0xfff8, 0x40c0, 6},+ {m68k_op_move_16_frs_ai , 0xfff8, 0x40d0, 12},+ {m68k_op_move_16_frs_pi , 0xfff8, 0x40d8, 12},+ {m68k_op_move_16_frs_pd , 0xfff8, 0x40e0, 14},+ {m68k_op_move_16_frs_di , 0xfff8, 0x40e8, 16},+ {m68k_op_move_16_frs_ix , 0xfff8, 0x40f0, 18},+ {m68k_op_clr_8_d , 0xfff8, 0x4200, 4},+ {m68k_op_clr_8_ai , 0xfff8, 0x4210, 12},+ {m68k_op_clr_8_pi , 0xfff8, 0x4218, 12},+ {m68k_op_clr_8_pd , 0xfff8, 0x4220, 14},+ {m68k_op_clr_8_di , 0xfff8, 0x4228, 16},+ {m68k_op_clr_8_ix , 0xfff8, 0x4230, 18},+ {m68k_op_clr_16_d , 0xfff8, 0x4240, 4},+ {m68k_op_clr_16_ai , 0xfff8, 0x4250, 12},+ {m68k_op_clr_16_pi , 0xfff8, 0x4258, 12},+ {m68k_op_clr_16_pd , 0xfff8, 0x4260, 14},+ {m68k_op_clr_16_di , 0xfff8, 0x4268, 16},+ {m68k_op_clr_16_ix , 0xfff8, 0x4270, 18},+ {m68k_op_clr_32_d , 0xfff8, 0x4280, 6},+ {m68k_op_clr_32_ai , 0xfff8, 0x4290, 20},+ {m68k_op_clr_32_pi , 0xfff8, 0x4298, 20},+ {m68k_op_clr_32_pd , 0xfff8, 0x42a0, 22},+ {m68k_op_clr_32_di , 0xfff8, 0x42a8, 24},+ {m68k_op_clr_32_ix , 0xfff8, 0x42b0, 26},+ {m68k_op_neg_8_d , 0xfff8, 0x4400, 4},+ {m68k_op_neg_8_ai , 0xfff8, 0x4410, 12},+ {m68k_op_neg_8_pi , 0xfff8, 0x4418, 12},+ {m68k_op_neg_8_pd , 0xfff8, 0x4420, 14},+ {m68k_op_neg_8_di , 0xfff8, 0x4428, 16},+ {m68k_op_neg_8_ix , 0xfff8, 0x4430, 18},+ {m68k_op_neg_16_d , 0xfff8, 0x4440, 4},+ {m68k_op_neg_16_ai , 0xfff8, 0x4450, 12},+ {m68k_op_neg_16_pi , 0xfff8, 0x4458, 12},+ {m68k_op_neg_16_pd , 0xfff8, 0x4460, 14},+ {m68k_op_neg_16_di , 0xfff8, 0x4468, 16},+ {m68k_op_neg_16_ix , 0xfff8, 0x4470, 18},+ {m68k_op_neg_32_d , 0xfff8, 0x4480, 6},+ {m68k_op_neg_32_ai , 0xfff8, 0x4490, 20},+ {m68k_op_neg_32_pi , 0xfff8, 0x4498, 20},+ {m68k_op_neg_32_pd , 0xfff8, 0x44a0, 22},+ {m68k_op_neg_32_di , 0xfff8, 0x44a8, 24},+ {m68k_op_neg_32_ix , 0xfff8, 0x44b0, 26},+ {m68k_op_move_16_toc_d , 0xfff8, 0x44c0, 12},+ {m68k_op_move_16_toc_ai , 0xfff8, 0x44d0, 16},+ {m68k_op_move_16_toc_pi , 0xfff8, 0x44d8, 16},+ {m68k_op_move_16_toc_pd , 0xfff8, 0x44e0, 18},+ {m68k_op_move_16_toc_di , 0xfff8, 0x44e8, 20},+ {m68k_op_move_16_toc_ix , 0xfff8, 0x44f0, 22},+ {m68k_op_not_8_d , 0xfff8, 0x4600, 4},+ {m68k_op_not_8_ai , 0xfff8, 0x4610, 12},+ {m68k_op_not_8_pi , 0xfff8, 0x4618, 12},+ {m68k_op_not_8_pd , 0xfff8, 0x4620, 14},+ {m68k_op_not_8_di , 0xfff8, 0x4628, 16},+ {m68k_op_not_8_ix , 0xfff8, 0x4630, 18},+ {m68k_op_not_16_d , 0xfff8, 0x4640, 4},+ {m68k_op_not_16_ai , 0xfff8, 0x4650, 12},+ {m68k_op_not_16_pi , 0xfff8, 0x4658, 12},+ {m68k_op_not_16_pd , 0xfff8, 0x4660, 14},+ {m68k_op_not_16_di , 0xfff8, 0x4668, 16},+ {m68k_op_not_16_ix , 0xfff8, 0x4670, 18},+ {m68k_op_not_32_d , 0xfff8, 0x4680, 6},+ {m68k_op_not_32_ai , 0xfff8, 0x4690, 20},+ {m68k_op_not_32_pi , 0xfff8, 0x4698, 20},+ {m68k_op_not_32_pd , 0xfff8, 0x46a0, 22},+ {m68k_op_not_32_di , 0xfff8, 0x46a8, 24},+ {m68k_op_not_32_ix , 0xfff8, 0x46b0, 26},+ {m68k_op_move_16_tos_d , 0xfff8, 0x46c0, 12},+ {m68k_op_move_16_tos_ai , 0xfff8, 0x46d0, 16},+ {m68k_op_move_16_tos_pi , 0xfff8, 0x46d8, 16},+ {m68k_op_move_16_tos_pd , 0xfff8, 0x46e0, 18},+ {m68k_op_move_16_tos_di , 0xfff8, 0x46e8, 20},+ {m68k_op_move_16_tos_ix , 0xfff8, 0x46f0, 22},+ {m68k_op_nbcd_8_d , 0xfff8, 0x4800, 6},+ {m68k_op_nbcd_8_ai , 0xfff8, 0x4810, 12},+ {m68k_op_nbcd_8_pi , 0xfff8, 0x4818, 12},+ {m68k_op_nbcd_8_pd , 0xfff8, 0x4820, 14},+ {m68k_op_nbcd_8_di , 0xfff8, 0x4828, 16},+ {m68k_op_nbcd_8_ix , 0xfff8, 0x4830, 18},+ {m68k_op_swap_32 , 0xfff8, 0x4840, 4},+ {m68k_op_pea_32_ai , 0xfff8, 0x4850, 12},+ {m68k_op_pea_32_di , 0xfff8, 0x4868, 16},+ {m68k_op_pea_32_ix , 0xfff8, 0x4870, 20},+ {m68k_op_ext_16 , 0xfff8, 0x4880, 4},+ {m68k_op_movem_16_re_ai , 0xfff8, 0x4890, 8},+ {m68k_op_movem_16_re_pd , 0xfff8, 0x48a0, 8},+ {m68k_op_movem_16_re_di , 0xfff8, 0x48a8, 12},+ {m68k_op_movem_16_re_ix , 0xfff8, 0x48b0, 14},+ {m68k_op_ext_32 , 0xfff8, 0x48c0, 4},+ {m68k_op_movem_32_re_ai , 0xfff8, 0x48d0, 8},+ {m68k_op_movem_32_re_pd , 0xfff8, 0x48e0, 8},+ {m68k_op_movem_32_re_di , 0xfff8, 0x48e8, 12},+ {m68k_op_movem_32_re_ix , 0xfff8, 0x48f0, 14},+ {m68k_op_tst_8_d , 0xfff8, 0x4a00, 4},+ {m68k_op_tst_8_ai , 0xfff8, 0x4a10, 8},+ {m68k_op_tst_8_pi , 0xfff8, 0x4a18, 8},+ {m68k_op_tst_8_pd , 0xfff8, 0x4a20, 10},+ {m68k_op_tst_8_di , 0xfff8, 0x4a28, 12},+ {m68k_op_tst_8_ix , 0xfff8, 0x4a30, 14},+ {m68k_op_tst_16_d , 0xfff8, 0x4a40, 4},+ {m68k_op_tst_16_ai , 0xfff8, 0x4a50, 8},+ {m68k_op_tst_16_pi , 0xfff8, 0x4a58, 8},+ {m68k_op_tst_16_pd , 0xfff8, 0x4a60, 10},+ {m68k_op_tst_16_di , 0xfff8, 0x4a68, 12},+ {m68k_op_tst_16_ix , 0xfff8, 0x4a70, 14},+ {m68k_op_tst_32_d , 0xfff8, 0x4a80, 4},+ {m68k_op_tst_32_ai , 0xfff8, 0x4a90, 12},+ {m68k_op_tst_32_pi , 0xfff8, 0x4a98, 12},+ {m68k_op_tst_32_pd , 0xfff8, 0x4aa0, 14},+ {m68k_op_tst_32_di , 0xfff8, 0x4aa8, 16},+ {m68k_op_tst_32_ix , 0xfff8, 0x4ab0, 18},+ {m68k_op_tas_8_d , 0xfff8, 0x4ac0, 4},+ {m68k_op_tas_8_ai , 0xfff8, 0x4ad0, 14}, /* see Yacht.txt */+ {m68k_op_tas_8_pi , 0xfff8, 0x4ad8, 14}, /* see Yacht.txt */+ {m68k_op_tas_8_pd , 0xfff8, 0x4ae0, 16}, /* see Yacht.txt */+ {m68k_op_tas_8_di , 0xfff8, 0x4ae8, 18}, /* see Yacht.txt */+ {m68k_op_tas_8_ix , 0xfff8, 0x4af0, 20}, /* see Yacht.txt */+ {m68k_op_movem_16_er_ai , 0xfff8, 0x4c90, 12},+ {m68k_op_movem_16_er_pi , 0xfff8, 0x4c98, 12},+ {m68k_op_movem_16_er_di , 0xfff8, 0x4ca8, 16},+ {m68k_op_movem_16_er_ix , 0xfff8, 0x4cb0, 18},+ {m68k_op_movem_32_er_ai , 0xfff8, 0x4cd0, 12},+ {m68k_op_movem_32_er_pi , 0xfff8, 0x4cd8, 12},+ {m68k_op_movem_32_er_di , 0xfff8, 0x4ce8, 16},+ {m68k_op_movem_32_er_ix , 0xfff8, 0x4cf0, 18},+ {m68k_op_link_16 , 0xfff8, 0x4e50, 16},+ {m68k_op_unlk_32 , 0xfff8, 0x4e58, 12},+ {m68k_op_move_32_tou , 0xfff8, 0x4e60, 4},+ {m68k_op_move_32_fru , 0xfff8, 0x4e68, 4},+ {m68k_op_jsr_32_ai , 0xfff8, 0x4e90, 16},+ {m68k_op_jsr_32_di , 0xfff8, 0x4ea8, 18},+ {m68k_op_jsr_32_ix , 0xfff8, 0x4eb0, 22},+ {m68k_op_jmp_32_ai , 0xfff8, 0x4ed0, 8},+ {m68k_op_jmp_32_di , 0xfff8, 0x4ee8, 10},+ {m68k_op_jmp_32_ix , 0xfff8, 0x4ef0, 14},+ {m68k_op_st_8_d , 0xfff8, 0x50c0, 6},+ {m68k_op_dbt_16 , 0xfff8, 0x50c8, 12},+ {m68k_op_st_8_ai , 0xfff8, 0x50d0, 12},+ {m68k_op_st_8_pi , 0xfff8, 0x50d8, 12},+ {m68k_op_st_8_pd , 0xfff8, 0x50e0, 14},+ {m68k_op_st_8_di , 0xfff8, 0x50e8, 16},+ {m68k_op_st_8_ix , 0xfff8, 0x50f0, 18},+ {m68k_op_sf_8_d , 0xfff8, 0x51c0, 4},+ {m68k_op_dbf_16 , 0xfff8, 0x51c8, 12},+ {m68k_op_sf_8_ai , 0xfff8, 0x51d0, 12},+ {m68k_op_sf_8_pi , 0xfff8, 0x51d8, 12},+ {m68k_op_sf_8_pd , 0xfff8, 0x51e0, 14},+ {m68k_op_sf_8_di , 0xfff8, 0x51e8, 16},+ {m68k_op_sf_8_ix , 0xfff8, 0x51f0, 18},+ {m68k_op_shi_8_d , 0xfff8, 0x52c0, 4},+ {m68k_op_dbhi_16 , 0xfff8, 0x52c8, 12},+ {m68k_op_shi_8_ai , 0xfff8, 0x52d0, 12},+ {m68k_op_shi_8_pi , 0xfff8, 0x52d8, 12},+ {m68k_op_shi_8_pd , 0xfff8, 0x52e0, 14},+ {m68k_op_shi_8_di , 0xfff8, 0x52e8, 16},+ {m68k_op_shi_8_ix , 0xfff8, 0x52f0, 18},+ {m68k_op_sls_8_d , 0xfff8, 0x53c0, 4},+ {m68k_op_dbls_16 , 0xfff8, 0x53c8, 12},+ {m68k_op_sls_8_ai , 0xfff8, 0x53d0, 12},+ {m68k_op_sls_8_pi , 0xfff8, 0x53d8, 12},+ {m68k_op_sls_8_pd , 0xfff8, 0x53e0, 14},+ {m68k_op_sls_8_di , 0xfff8, 0x53e8, 16},+ {m68k_op_sls_8_ix , 0xfff8, 0x53f0, 18},+ {m68k_op_scc_8_d , 0xfff8, 0x54c0, 4},+ {m68k_op_dbcc_16 , 0xfff8, 0x54c8, 12},+ {m68k_op_scc_8_ai , 0xfff8, 0x54d0, 12},+ {m68k_op_scc_8_pi , 0xfff8, 0x54d8, 12},+ {m68k_op_scc_8_pd , 0xfff8, 0x54e0, 14},+ {m68k_op_scc_8_di , 0xfff8, 0x54e8, 16},+ {m68k_op_scc_8_ix , 0xfff8, 0x54f0, 18},+ {m68k_op_scs_8_d , 0xfff8, 0x55c0, 4},+ {m68k_op_dbcs_16 , 0xfff8, 0x55c8, 12},+ {m68k_op_scs_8_ai , 0xfff8, 0x55d0, 12},+ {m68k_op_scs_8_pi , 0xfff8, 0x55d8, 12},+ {m68k_op_scs_8_pd , 0xfff8, 0x55e0, 14},+ {m68k_op_scs_8_di , 0xfff8, 0x55e8, 16},+ {m68k_op_scs_8_ix , 0xfff8, 0x55f0, 18},+ {m68k_op_sne_8_d , 0xfff8, 0x56c0, 4},+ {m68k_op_dbne_16 , 0xfff8, 0x56c8, 12},+ {m68k_op_sne_8_ai , 0xfff8, 0x56d0, 12},+ {m68k_op_sne_8_pi , 0xfff8, 0x56d8, 12},+ {m68k_op_sne_8_pd , 0xfff8, 0x56e0, 14},+ {m68k_op_sne_8_di , 0xfff8, 0x56e8, 16},+ {m68k_op_sne_8_ix , 0xfff8, 0x56f0, 18},+ {m68k_op_seq_8_d , 0xfff8, 0x57c0, 4},+ {m68k_op_dbeq_16 , 0xfff8, 0x57c8, 12},+ {m68k_op_seq_8_ai , 0xfff8, 0x57d0, 12},+ {m68k_op_seq_8_pi , 0xfff8, 0x57d8, 12},+ {m68k_op_seq_8_pd , 0xfff8, 0x57e0, 14},+ {m68k_op_seq_8_di , 0xfff8, 0x57e8, 16},+ {m68k_op_seq_8_ix , 0xfff8, 0x57f0, 18},+ {m68k_op_svc_8_d , 0xfff8, 0x58c0, 4},+ {m68k_op_dbvc_16 , 0xfff8, 0x58c8, 12},+ {m68k_op_svc_8_ai , 0xfff8, 0x58d0, 12},+ {m68k_op_svc_8_pi , 0xfff8, 0x58d8, 12},+ {m68k_op_svc_8_pd , 0xfff8, 0x58e0, 14},+ {m68k_op_svc_8_di , 0xfff8, 0x58e8, 16},+ {m68k_op_svc_8_ix , 0xfff8, 0x58f0, 18},+ {m68k_op_svs_8_d , 0xfff8, 0x59c0, 4},+ {m68k_op_dbvs_16 , 0xfff8, 0x59c8, 12},+ {m68k_op_svs_8_ai , 0xfff8, 0x59d0, 12},+ {m68k_op_svs_8_pi , 0xfff8, 0x59d8, 12},+ {m68k_op_svs_8_pd , 0xfff8, 0x59e0, 14},+ {m68k_op_svs_8_di , 0xfff8, 0x59e8, 16},+ {m68k_op_svs_8_ix , 0xfff8, 0x59f0, 18},+ {m68k_op_spl_8_d , 0xfff8, 0x5ac0, 4},+ {m68k_op_dbpl_16 , 0xfff8, 0x5ac8, 12},+ {m68k_op_spl_8_ai , 0xfff8, 0x5ad0, 12},+ {m68k_op_spl_8_pi , 0xfff8, 0x5ad8, 12},+ {m68k_op_spl_8_pd , 0xfff8, 0x5ae0, 14},+ {m68k_op_spl_8_di , 0xfff8, 0x5ae8, 16},+ {m68k_op_spl_8_ix , 0xfff8, 0x5af0, 18},+ {m68k_op_smi_8_d , 0xfff8, 0x5bc0, 4},+ {m68k_op_dbmi_16 , 0xfff8, 0x5bc8, 12},+ {m68k_op_smi_8_ai , 0xfff8, 0x5bd0, 12},+ {m68k_op_smi_8_pi , 0xfff8, 0x5bd8, 12},+ {m68k_op_smi_8_pd , 0xfff8, 0x5be0, 14},+ {m68k_op_smi_8_di , 0xfff8, 0x5be8, 16},+ {m68k_op_smi_8_ix , 0xfff8, 0x5bf0, 18},+ {m68k_op_sge_8_d , 0xfff8, 0x5cc0, 4},+ {m68k_op_dbge_16 , 0xfff8, 0x5cc8, 12},+ {m68k_op_sge_8_ai , 0xfff8, 0x5cd0, 12},+ {m68k_op_sge_8_pi , 0xfff8, 0x5cd8, 12},+ {m68k_op_sge_8_pd , 0xfff8, 0x5ce0, 14},+ {m68k_op_sge_8_di , 0xfff8, 0x5ce8, 16},+ {m68k_op_sge_8_ix , 0xfff8, 0x5cf0, 18},+ {m68k_op_slt_8_d , 0xfff8, 0x5dc0, 4},+ {m68k_op_dblt_16 , 0xfff8, 0x5dc8, 12},+ {m68k_op_slt_8_ai , 0xfff8, 0x5dd0, 12},+ {m68k_op_slt_8_pi , 0xfff8, 0x5dd8, 12},+ {m68k_op_slt_8_pd , 0xfff8, 0x5de0, 14},+ {m68k_op_slt_8_di , 0xfff8, 0x5de8, 16},+ {m68k_op_slt_8_ix , 0xfff8, 0x5df0, 18},+ {m68k_op_sgt_8_d , 0xfff8, 0x5ec0, 4},+ {m68k_op_dbgt_16 , 0xfff8, 0x5ec8, 12},+ {m68k_op_sgt_8_ai , 0xfff8, 0x5ed0, 12},+ {m68k_op_sgt_8_pi , 0xfff8, 0x5ed8, 12},+ {m68k_op_sgt_8_pd , 0xfff8, 0x5ee0, 14},+ {m68k_op_sgt_8_di , 0xfff8, 0x5ee8, 16},+ {m68k_op_sgt_8_ix , 0xfff8, 0x5ef0, 18},+ {m68k_op_sle_8_d , 0xfff8, 0x5fc0, 4},+ {m68k_op_dble_16 , 0xfff8, 0x5fc8, 12},+ {m68k_op_sle_8_ai , 0xfff8, 0x5fd0, 12},+ {m68k_op_sle_8_pi , 0xfff8, 0x5fd8, 12},+ {m68k_op_sle_8_pd , 0xfff8, 0x5fe0, 14},+ {m68k_op_sle_8_di , 0xfff8, 0x5fe8, 16},+ {m68k_op_sle_8_ix , 0xfff8, 0x5ff0, 18},+ {m68k_op_sbcd_8_mm_ax7 , 0xfff8, 0x8f08, 18},+ {m68k_op_subx_8_mm_ax7 , 0xfff8, 0x9f08, 18},+ {m68k_op_cmpm_8_ax7 , 0xfff8, 0xbf08, 12},+ {m68k_op_abcd_8_mm_ax7 , 0xfff8, 0xcf08, 18},+ {m68k_op_addx_8_mm_ax7 , 0xfff8, 0xdf08, 18},+ {m68k_op_asr_16_ai , 0xfff8, 0xe0d0, 12},+ {m68k_op_asr_16_pi , 0xfff8, 0xe0d8, 12},+ {m68k_op_asr_16_pd , 0xfff8, 0xe0e0, 14},+ {m68k_op_asr_16_di , 0xfff8, 0xe0e8, 16},+ {m68k_op_asr_16_ix , 0xfff8, 0xe0f0, 18},+ {m68k_op_asl_16_ai , 0xfff8, 0xe1d0, 12},+ {m68k_op_asl_16_pi , 0xfff8, 0xe1d8, 12},+ {m68k_op_asl_16_pd , 0xfff8, 0xe1e0, 14},+ {m68k_op_asl_16_di , 0xfff8, 0xe1e8, 16},+ {m68k_op_asl_16_ix , 0xfff8, 0xe1f0, 18},+ {m68k_op_lsr_16_ai , 0xfff8, 0xe2d0, 12},+ {m68k_op_lsr_16_pi , 0xfff8, 0xe2d8, 12},+ {m68k_op_lsr_16_pd , 0xfff8, 0xe2e0, 14},+ {m68k_op_lsr_16_di , 0xfff8, 0xe2e8, 16},+ {m68k_op_lsr_16_ix , 0xfff8, 0xe2f0, 18},+ {m68k_op_lsl_16_ai , 0xfff8, 0xe3d0, 12},+ {m68k_op_lsl_16_pi , 0xfff8, 0xe3d8, 12},+ {m68k_op_lsl_16_pd , 0xfff8, 0xe3e0, 14},+ {m68k_op_lsl_16_di , 0xfff8, 0xe3e8, 16},+ {m68k_op_lsl_16_ix , 0xfff8, 0xe3f0, 18},+ {m68k_op_roxr_16_ai , 0xfff8, 0xe4d0, 12},+ {m68k_op_roxr_16_pi , 0xfff8, 0xe4d8, 12},+ {m68k_op_roxr_16_pd , 0xfff8, 0xe4e0, 14},+ {m68k_op_roxr_16_di , 0xfff8, 0xe4e8, 16},+ {m68k_op_roxr_16_ix , 0xfff8, 0xe4f0, 18},+ {m68k_op_roxl_16_ai , 0xfff8, 0xe5d0, 12},+ {m68k_op_roxl_16_pi , 0xfff8, 0xe5d8, 12},+ {m68k_op_roxl_16_pd , 0xfff8, 0xe5e0, 14},+ {m68k_op_roxl_16_di , 0xfff8, 0xe5e8, 16},+ {m68k_op_roxl_16_ix , 0xfff8, 0xe5f0, 18},+ {m68k_op_ror_16_ai , 0xfff8, 0xe6d0, 12},+ {m68k_op_ror_16_pi , 0xfff8, 0xe6d8, 12},+ {m68k_op_ror_16_pd , 0xfff8, 0xe6e0, 14},+ {m68k_op_ror_16_di , 0xfff8, 0xe6e8, 16},+ {m68k_op_ror_16_ix , 0xfff8, 0xe6f0, 18},+ {m68k_op_rol_16_ai , 0xfff8, 0xe7d0, 12},+ {m68k_op_rol_16_pi , 0xfff8, 0xe7d8, 12},+ {m68k_op_rol_16_pd , 0xfff8, 0xe7e0, 14},+ {m68k_op_rol_16_di , 0xfff8, 0xe7e8, 16},+ {m68k_op_rol_16_ix , 0xfff8, 0xe7f0, 18},+ {m68k_op_ori_8_pi7 , 0xffff, 0x001f, 16},+ {m68k_op_ori_8_pd7 , 0xffff, 0x0027, 18},+ {m68k_op_ori_8_aw , 0xffff, 0x0038, 20},+ {m68k_op_ori_8_al , 0xffff, 0x0039, 24},+ {m68k_op_ori_16_toc , 0xffff, 0x003c, 20},+ {m68k_op_ori_16_aw , 0xffff, 0x0078, 20},+ {m68k_op_ori_16_al , 0xffff, 0x0079, 24},+ {m68k_op_ori_16_tos , 0xffff, 0x007c, 20},+ {m68k_op_ori_32_aw , 0xffff, 0x00b8, 32},+ {m68k_op_ori_32_al , 0xffff, 0x00b9, 36},+ {m68k_op_andi_8_pi7 , 0xffff, 0x021f, 16},+ {m68k_op_andi_8_pd7 , 0xffff, 0x0227, 18},+ {m68k_op_andi_8_aw , 0xffff, 0x0238, 20},+ {m68k_op_andi_8_al , 0xffff, 0x0239, 24},+ {m68k_op_andi_16_toc , 0xffff, 0x023c, 20},+ {m68k_op_andi_16_aw , 0xffff, 0x0278, 20},+ {m68k_op_andi_16_al , 0xffff, 0x0279, 24},+ {m68k_op_andi_16_tos , 0xffff, 0x027c, 20},+ {m68k_op_andi_32_aw , 0xffff, 0x02b8, 32},+ {m68k_op_andi_32_al , 0xffff, 0x02b9, 36},+ {m68k_op_subi_8_pi7 , 0xffff, 0x041f, 16},+ {m68k_op_subi_8_pd7 , 0xffff, 0x0427, 18},+ {m68k_op_subi_8_aw , 0xffff, 0x0438, 20},+ {m68k_op_subi_8_al , 0xffff, 0x0439, 24},+ {m68k_op_subi_16_aw , 0xffff, 0x0478, 20},+ {m68k_op_subi_16_al , 0xffff, 0x0479, 24},+ {m68k_op_subi_32_aw , 0xffff, 0x04b8, 32},+ {m68k_op_subi_32_al , 0xffff, 0x04b9, 36},+ {m68k_op_addi_8_pi7 , 0xffff, 0x061f, 16},+ {m68k_op_addi_8_pd7 , 0xffff, 0x0627, 18},+ {m68k_op_addi_8_aw , 0xffff, 0x0638, 20},+ {m68k_op_addi_8_al , 0xffff, 0x0639, 24},+ {m68k_op_addi_16_aw , 0xffff, 0x0678, 20},+ {m68k_op_addi_16_al , 0xffff, 0x0679, 24},+ {m68k_op_addi_32_aw , 0xffff, 0x06b8, 32},+ {m68k_op_addi_32_al , 0xffff, 0x06b9, 36},+ {m68k_op_btst_8_s_pi7 , 0xffff, 0x081f, 12},+ {m68k_op_btst_8_s_pd7 , 0xffff, 0x0827, 14},+ {m68k_op_btst_8_s_aw , 0xffff, 0x0838, 16},+ {m68k_op_btst_8_s_al , 0xffff, 0x0839, 20},+ {m68k_op_btst_8_s_pcdi , 0xffff, 0x083a, 16},+ {m68k_op_btst_8_s_pcix , 0xffff, 0x083b, 18},+ {m68k_op_bchg_8_s_pi7 , 0xffff, 0x085f, 16},+ {m68k_op_bchg_8_s_pd7 , 0xffff, 0x0867, 18},+ {m68k_op_bchg_8_s_aw , 0xffff, 0x0878, 20},+ {m68k_op_bchg_8_s_al , 0xffff, 0x0879, 24},+ {m68k_op_bclr_8_s_pi7 , 0xffff, 0x089f, 16},+ {m68k_op_bclr_8_s_pd7 , 0xffff, 0x08a7, 18},+ {m68k_op_bclr_8_s_aw , 0xffff, 0x08b8, 20},+ {m68k_op_bclr_8_s_al , 0xffff, 0x08b9, 24},+ {m68k_op_bset_8_s_pi7 , 0xffff, 0x08df, 16},+ {m68k_op_bset_8_s_pd7 , 0xffff, 0x08e7, 18},+ {m68k_op_bset_8_s_aw , 0xffff, 0x08f8, 20},+ {m68k_op_bset_8_s_al , 0xffff, 0x08f9, 24},+ {m68k_op_eori_8_pi7 , 0xffff, 0x0a1f, 16},+ {m68k_op_eori_8_pd7 , 0xffff, 0x0a27, 18},+ {m68k_op_eori_8_aw , 0xffff, 0x0a38, 20},+ {m68k_op_eori_8_al , 0xffff, 0x0a39, 24},+ {m68k_op_eori_16_toc , 0xffff, 0x0a3c, 20},+ {m68k_op_eori_16_aw , 0xffff, 0x0a78, 20},+ {m68k_op_eori_16_al , 0xffff, 0x0a79, 24},+ {m68k_op_eori_16_tos , 0xffff, 0x0a7c, 20},+ {m68k_op_eori_32_aw , 0xffff, 0x0ab8, 32},+ {m68k_op_eori_32_al , 0xffff, 0x0ab9, 36},+ {m68k_op_cmpi_8_pi7 , 0xffff, 0x0c1f, 12},+ {m68k_op_cmpi_8_pd7 , 0xffff, 0x0c27, 14},+ {m68k_op_cmpi_8_aw , 0xffff, 0x0c38, 16},+ {m68k_op_cmpi_8_al , 0xffff, 0x0c39, 20},+ {m68k_op_cmpi_16_aw , 0xffff, 0x0c78, 16},+ {m68k_op_cmpi_16_al , 0xffff, 0x0c79, 20},+ {m68k_op_cmpi_32_aw , 0xffff, 0x0cb8, 24},+ {m68k_op_cmpi_32_al , 0xffff, 0x0cb9, 28},+ {m68k_op_move_8_aw_pi7 , 0xffff, 0x11df, 16},+ {m68k_op_move_8_aw_pd7 , 0xffff, 0x11e7, 18},+ {m68k_op_move_8_aw_aw , 0xffff, 0x11f8, 20},+ {m68k_op_move_8_aw_al , 0xffff, 0x11f9, 24},+ {m68k_op_move_8_aw_pcdi , 0xffff, 0x11fa, 20},+ {m68k_op_move_8_aw_pcix , 0xffff, 0x11fb, 22},+ {m68k_op_move_8_aw_i , 0xffff, 0x11fc, 16},+ {m68k_op_move_8_al_pi7 , 0xffff, 0x13df, 20},+ {m68k_op_move_8_al_pd7 , 0xffff, 0x13e7, 22},+ {m68k_op_move_8_al_aw , 0xffff, 0x13f8, 24},+ {m68k_op_move_8_al_al , 0xffff, 0x13f9, 28},+ {m68k_op_move_8_al_pcdi , 0xffff, 0x13fa, 24},+ {m68k_op_move_8_al_pcix , 0xffff, 0x13fb, 26},+ {m68k_op_move_8_al_i , 0xffff, 0x13fc, 20},+ {m68k_op_move_8_pi7_pi7 , 0xffff, 0x1edf, 12},+ {m68k_op_move_8_pi7_pd7 , 0xffff, 0x1ee7, 14},+ {m68k_op_move_8_pi7_aw , 0xffff, 0x1ef8, 16},+ {m68k_op_move_8_pi7_al , 0xffff, 0x1ef9, 20},+ {m68k_op_move_8_pi7_pcdi , 0xffff, 0x1efa, 16},+ {m68k_op_move_8_pi7_pcix , 0xffff, 0x1efb, 18},+ {m68k_op_move_8_pi7_i , 0xffff, 0x1efc, 12},+ {m68k_op_move_8_pd7_pi7 , 0xffff, 0x1f1f, 12},+ {m68k_op_move_8_pd7_pd7 , 0xffff, 0x1f27, 14},+ {m68k_op_move_8_pd7_aw , 0xffff, 0x1f38, 16},+ {m68k_op_move_8_pd7_al , 0xffff, 0x1f39, 20},+ {m68k_op_move_8_pd7_pcdi , 0xffff, 0x1f3a, 16},+ {m68k_op_move_8_pd7_pcix , 0xffff, 0x1f3b, 18},+ {m68k_op_move_8_pd7_i , 0xffff, 0x1f3c, 12},+ {m68k_op_move_32_aw_aw , 0xffff, 0x21f8, 28},+ {m68k_op_move_32_aw_al , 0xffff, 0x21f9, 32},+ {m68k_op_move_32_aw_pcdi , 0xffff, 0x21fa, 28},+ {m68k_op_move_32_aw_pcix , 0xffff, 0x21fb, 30},+ {m68k_op_move_32_aw_i , 0xffff, 0x21fc, 24},+ {m68k_op_move_32_al_aw , 0xffff, 0x23f8, 32},+ {m68k_op_move_32_al_al , 0xffff, 0x23f9, 36},+ {m68k_op_move_32_al_pcdi , 0xffff, 0x23fa, 32},+ {m68k_op_move_32_al_pcix , 0xffff, 0x23fb, 34},+ {m68k_op_move_32_al_i , 0xffff, 0x23fc, 28},+ {m68k_op_move_16_aw_aw , 0xffff, 0x31f8, 20},+ {m68k_op_move_16_aw_al , 0xffff, 0x31f9, 24},+ {m68k_op_move_16_aw_pcdi , 0xffff, 0x31fa, 20},+ {m68k_op_move_16_aw_pcix , 0xffff, 0x31fb, 22},+ {m68k_op_move_16_aw_i , 0xffff, 0x31fc, 16},+ {m68k_op_move_16_al_aw , 0xffff, 0x33f8, 24},+ {m68k_op_move_16_al_al , 0xffff, 0x33f9, 28},+ {m68k_op_move_16_al_pcdi , 0xffff, 0x33fa, 24},+ {m68k_op_move_16_al_pcix , 0xffff, 0x33fb, 26},+ {m68k_op_move_16_al_i , 0xffff, 0x33fc, 20},+ {m68k_op_negx_8_pi7 , 0xffff, 0x401f, 12},+ {m68k_op_negx_8_pd7 , 0xffff, 0x4027, 14},+ {m68k_op_negx_8_aw , 0xffff, 0x4038, 16},+ {m68k_op_negx_8_al , 0xffff, 0x4039, 20},+ {m68k_op_negx_16_aw , 0xffff, 0x4078, 16},+ {m68k_op_negx_16_al , 0xffff, 0x4079, 20},+ {m68k_op_negx_32_aw , 0xffff, 0x40b8, 24},+ {m68k_op_negx_32_al , 0xffff, 0x40b9, 28},+ {m68k_op_move_16_frs_aw , 0xffff, 0x40f8, 16},+ {m68k_op_move_16_frs_al , 0xffff, 0x40f9, 20},+ {m68k_op_clr_8_pi7 , 0xffff, 0x421f, 12},+ {m68k_op_clr_8_pd7 , 0xffff, 0x4227, 14},+ {m68k_op_clr_8_aw , 0xffff, 0x4238, 16},+ {m68k_op_clr_8_al , 0xffff, 0x4239, 20},+ {m68k_op_clr_16_aw , 0xffff, 0x4278, 16},+ {m68k_op_clr_16_al , 0xffff, 0x4279, 20},+ {m68k_op_clr_32_aw , 0xffff, 0x42b8, 24},+ {m68k_op_clr_32_al , 0xffff, 0x42b9, 28},+ {m68k_op_neg_8_pi7 , 0xffff, 0x441f, 12},+ {m68k_op_neg_8_pd7 , 0xffff, 0x4427, 14},+ {m68k_op_neg_8_aw , 0xffff, 0x4438, 16},+ {m68k_op_neg_8_al , 0xffff, 0x4439, 20},+ {m68k_op_neg_16_aw , 0xffff, 0x4478, 16},+ {m68k_op_neg_16_al , 0xffff, 0x4479, 20},+ {m68k_op_neg_32_aw , 0xffff, 0x44b8, 24},+ {m68k_op_neg_32_al , 0xffff, 0x44b9, 28},+ {m68k_op_move_16_toc_aw , 0xffff, 0x44f8, 20},+ {m68k_op_move_16_toc_al , 0xffff, 0x44f9, 24},+ {m68k_op_move_16_toc_pcdi , 0xffff, 0x44fa, 20},+ {m68k_op_move_16_toc_pcix , 0xffff, 0x44fb, 22},+ {m68k_op_move_16_toc_i , 0xffff, 0x44fc, 16},+ {m68k_op_not_8_pi7 , 0xffff, 0x461f, 12},+ {m68k_op_not_8_pd7 , 0xffff, 0x4627, 14},+ {m68k_op_not_8_aw , 0xffff, 0x4638, 16},+ {m68k_op_not_8_al , 0xffff, 0x4639, 20},+ {m68k_op_not_16_aw , 0xffff, 0x4678, 16},+ {m68k_op_not_16_al , 0xffff, 0x4679, 20},+ {m68k_op_not_32_aw , 0xffff, 0x46b8, 24},+ {m68k_op_not_32_al , 0xffff, 0x46b9, 28},+ {m68k_op_move_16_tos_aw , 0xffff, 0x46f8, 20},+ {m68k_op_move_16_tos_al , 0xffff, 0x46f9, 24},+ {m68k_op_move_16_tos_pcdi , 0xffff, 0x46fa, 20},+ {m68k_op_move_16_tos_pcix , 0xffff, 0x46fb, 22},+ {m68k_op_move_16_tos_i , 0xffff, 0x46fc, 16},+ {m68k_op_nbcd_8_pi7 , 0xffff, 0x481f, 12},+ {m68k_op_nbcd_8_pd7 , 0xffff, 0x4827, 14},+ {m68k_op_nbcd_8_aw , 0xffff, 0x4838, 16},+ {m68k_op_nbcd_8_al , 0xffff, 0x4839, 20},+ {m68k_op_pea_32_aw , 0xffff, 0x4878, 16},+ {m68k_op_pea_32_al , 0xffff, 0x4879, 20},+ {m68k_op_pea_32_pcdi , 0xffff, 0x487a, 16},+ {m68k_op_pea_32_pcix , 0xffff, 0x487b, 20},+ {m68k_op_movem_16_re_aw , 0xffff, 0x48b8, 12},+ {m68k_op_movem_16_re_al , 0xffff, 0x48b9, 16},+ {m68k_op_movem_32_re_aw , 0xffff, 0x48f8, 12},+ {m68k_op_movem_32_re_al , 0xffff, 0x48f9, 16},+ {m68k_op_tst_8_pi7 , 0xffff, 0x4a1f, 8},+ {m68k_op_tst_8_pd7 , 0xffff, 0x4a27, 10},+ {m68k_op_tst_8_aw , 0xffff, 0x4a38, 12},+ {m68k_op_tst_8_al , 0xffff, 0x4a39, 16},+ {m68k_op_tst_16_aw , 0xffff, 0x4a78, 12},+ {m68k_op_tst_16_al , 0xffff, 0x4a79, 16},+ {m68k_op_tst_32_aw , 0xffff, 0x4ab8, 16},+ {m68k_op_tst_32_al , 0xffff, 0x4ab9, 20},+ {m68k_op_tas_8_pi7 , 0xffff, 0x4adf, 14}, /* see Yacht.txt */+ {m68k_op_tas_8_pd7 , 0xffff, 0x4ae7, 16}, /* see Yacht.txt */+ {m68k_op_tas_8_aw , 0xffff, 0x4af8, 18}, /* see Yacht.txt */+ {m68k_op_tas_8_al , 0xffff, 0x4af9, 22}, /* see Yacht.txt */+ {m68k_op_illegal , 0xffff, 0x4afc, 4},+ {m68k_op_movem_16_er_aw , 0xffff, 0x4cb8, 16},+ {m68k_op_movem_16_er_al , 0xffff, 0x4cb9, 20},+ {m68k_op_movem_16_er_pcdi , 0xffff, 0x4cba, 16},+ {m68k_op_movem_16_er_pcix , 0xffff, 0x4cbb, 18},+ {m68k_op_movem_32_er_aw , 0xffff, 0x4cf8, 16},+ {m68k_op_movem_32_er_al , 0xffff, 0x4cf9, 20},+ {m68k_op_movem_32_er_pcdi , 0xffff, 0x4cfa, 16},+ {m68k_op_movem_32_er_pcix , 0xffff, 0x4cfb, 18},+ {m68k_op_link_16_a7 , 0xffff, 0x4e57, 16},+ {m68k_op_unlk_32_a7 , 0xffff, 0x4e5f, 12},+ {m68k_op_reset , 0xffff, 0x4e70, 0},+ {m68k_op_nop , 0xffff, 0x4e71, 4},+ {m68k_op_stop , 0xffff, 0x4e72, 4},+ {m68k_op_rte_32 , 0xffff, 0x4e73, 20},+ {m68k_op_rts_32 , 0xffff, 0x4e75, 16},+ {m68k_op_trapv , 0xffff, 0x4e76, 4},+ {m68k_op_rtr_32 , 0xffff, 0x4e77, 20},+ {m68k_op_jsr_32_aw , 0xffff, 0x4eb8, 18},+ {m68k_op_jsr_32_al , 0xffff, 0x4eb9, 20},+ {m68k_op_jsr_32_pcdi , 0xffff, 0x4eba, 18},+ {m68k_op_jsr_32_pcix , 0xffff, 0x4ebb, 22},+ {m68k_op_jmp_32_aw , 0xffff, 0x4ef8, 10},+ {m68k_op_jmp_32_al , 0xffff, 0x4ef9, 12},+ {m68k_op_jmp_32_pcdi , 0xffff, 0x4efa, 10},+ {m68k_op_jmp_32_pcix , 0xffff, 0x4efb, 14},+ {m68k_op_st_8_pi7 , 0xffff, 0x50df, 12},+ {m68k_op_st_8_pd7 , 0xffff, 0x50e7, 14},+ {m68k_op_st_8_aw , 0xffff, 0x50f8, 16},+ {m68k_op_st_8_al , 0xffff, 0x50f9, 20},+ {m68k_op_sf_8_pi7 , 0xffff, 0x51df, 12},+ {m68k_op_sf_8_pd7 , 0xffff, 0x51e7, 14},+ {m68k_op_sf_8_aw , 0xffff, 0x51f8, 16},+ {m68k_op_sf_8_al , 0xffff, 0x51f9, 20},+ {m68k_op_shi_8_pi7 , 0xffff, 0x52df, 12},+ {m68k_op_shi_8_pd7 , 0xffff, 0x52e7, 14},+ {m68k_op_shi_8_aw , 0xffff, 0x52f8, 16},+ {m68k_op_shi_8_al , 0xffff, 0x52f9, 20},+ {m68k_op_sls_8_pi7 , 0xffff, 0x53df, 12},+ {m68k_op_sls_8_pd7 , 0xffff, 0x53e7, 14},+ {m68k_op_sls_8_aw , 0xffff, 0x53f8, 16},+ {m68k_op_sls_8_al , 0xffff, 0x53f9, 20},+ {m68k_op_scc_8_pi7 , 0xffff, 0x54df, 12},+ {m68k_op_scc_8_pd7 , 0xffff, 0x54e7, 14},+ {m68k_op_scc_8_aw , 0xffff, 0x54f8, 16},+ {m68k_op_scc_8_al , 0xffff, 0x54f9, 20},+ {m68k_op_scs_8_pi7 , 0xffff, 0x55df, 12},+ {m68k_op_scs_8_pd7 , 0xffff, 0x55e7, 14},+ {m68k_op_scs_8_aw , 0xffff, 0x55f8, 16},+ {m68k_op_scs_8_al , 0xffff, 0x55f9, 20},+ {m68k_op_sne_8_pi7 , 0xffff, 0x56df, 12},+ {m68k_op_sne_8_pd7 , 0xffff, 0x56e7, 14},+ {m68k_op_sne_8_aw , 0xffff, 0x56f8, 16},+ {m68k_op_sne_8_al , 0xffff, 0x56f9, 20},+ {m68k_op_seq_8_pi7 , 0xffff, 0x57df, 12},+ {m68k_op_seq_8_pd7 , 0xffff, 0x57e7, 14},+ {m68k_op_seq_8_aw , 0xffff, 0x57f8, 16},+ {m68k_op_seq_8_al , 0xffff, 0x57f9, 20},+ {m68k_op_svc_8_pi7 , 0xffff, 0x58df, 12},+ {m68k_op_svc_8_pd7 , 0xffff, 0x58e7, 14},+ {m68k_op_svc_8_aw , 0xffff, 0x58f8, 16},+ {m68k_op_svc_8_al , 0xffff, 0x58f9, 20},+ {m68k_op_svs_8_pi7 , 0xffff, 0x59df, 12},+ {m68k_op_svs_8_pd7 , 0xffff, 0x59e7, 14},+ {m68k_op_svs_8_aw , 0xffff, 0x59f8, 16},+ {m68k_op_svs_8_al , 0xffff, 0x59f9, 20},+ {m68k_op_spl_8_pi7 , 0xffff, 0x5adf, 12},+ {m68k_op_spl_8_pd7 , 0xffff, 0x5ae7, 14},+ {m68k_op_spl_8_aw , 0xffff, 0x5af8, 16},+ {m68k_op_spl_8_al , 0xffff, 0x5af9, 20},+ {m68k_op_smi_8_pi7 , 0xffff, 0x5bdf, 12},+ {m68k_op_smi_8_pd7 , 0xffff, 0x5be7, 14},+ {m68k_op_smi_8_aw , 0xffff, 0x5bf8, 16},+ {m68k_op_smi_8_al , 0xffff, 0x5bf9, 20},+ {m68k_op_sge_8_pi7 , 0xffff, 0x5cdf, 12},+ {m68k_op_sge_8_pd7 , 0xffff, 0x5ce7, 14},+ {m68k_op_sge_8_aw , 0xffff, 0x5cf8, 16},+ {m68k_op_sge_8_al , 0xffff, 0x5cf9, 20},+ {m68k_op_slt_8_pi7 , 0xffff, 0x5ddf, 12},+ {m68k_op_slt_8_pd7 , 0xffff, 0x5de7, 14},+ {m68k_op_slt_8_aw , 0xffff, 0x5df8, 16},+ {m68k_op_slt_8_al , 0xffff, 0x5df9, 20},+ {m68k_op_sgt_8_pi7 , 0xffff, 0x5edf, 12},+ {m68k_op_sgt_8_pd7 , 0xffff, 0x5ee7, 14},+ {m68k_op_sgt_8_aw , 0xffff, 0x5ef8, 16},+ {m68k_op_sgt_8_al , 0xffff, 0x5ef9, 20},+ {m68k_op_sle_8_pi7 , 0xffff, 0x5fdf, 12},+ {m68k_op_sle_8_pd7 , 0xffff, 0x5fe7, 14},+ {m68k_op_sle_8_aw , 0xffff, 0x5ff8, 16},+ {m68k_op_sle_8_al , 0xffff, 0x5ff9, 20},+ {m68k_op_bra_16 , 0xffff, 0x6000, 10},+ {m68k_op_bra_32 , 0xffff, 0x60ff, 10},+ {m68k_op_bsr_16 , 0xffff, 0x6100, 18},+ {m68k_op_bsr_32 , 0xffff, 0x61ff, 18},+ {m68k_op_bhi_16 , 0xffff, 0x6200, 10},+ {m68k_op_bhi_32 , 0xffff, 0x62ff, 10},+ {m68k_op_bls_16 , 0xffff, 0x6300, 10},+ {m68k_op_bls_32 , 0xffff, 0x63ff, 10},+ {m68k_op_bcc_16 , 0xffff, 0x6400, 10},+ {m68k_op_bcc_32 , 0xffff, 0x64ff, 10},+ {m68k_op_bcs_16 , 0xffff, 0x6500, 10},+ {m68k_op_bcs_32 , 0xffff, 0x65ff, 10},+ {m68k_op_bne_16 , 0xffff, 0x6600, 10},+ {m68k_op_bne_32 , 0xffff, 0x66ff, 10},+ {m68k_op_beq_16 , 0xffff, 0x6700, 10},+ {m68k_op_beq_32 , 0xffff, 0x67ff, 10},+ {m68k_op_bvc_16 , 0xffff, 0x6800, 10},+ {m68k_op_bvc_32 , 0xffff, 0x68ff, 10},+ {m68k_op_bvs_16 , 0xffff, 0x6900, 10},+ {m68k_op_bvs_32 , 0xffff, 0x69ff, 10},+ {m68k_op_bpl_16 , 0xffff, 0x6a00, 10},+ {m68k_op_bpl_32 , 0xffff, 0x6aff, 10},+ {m68k_op_bmi_16 , 0xffff, 0x6b00, 10},+ {m68k_op_bmi_32 , 0xffff, 0x6bff, 10},+ {m68k_op_bge_16 , 0xffff, 0x6c00, 10},+ {m68k_op_bge_32 , 0xffff, 0x6cff, 10},+ {m68k_op_blt_16 , 0xffff, 0x6d00, 10},+ {m68k_op_blt_32 , 0xffff, 0x6dff, 10},+ {m68k_op_bgt_16 , 0xffff, 0x6e00, 10},+ {m68k_op_bgt_32 , 0xffff, 0x6eff, 10},+ {m68k_op_ble_16 , 0xffff, 0x6f00, 10},+ {m68k_op_ble_32 , 0xffff, 0x6fff, 10},+ {m68k_op_sbcd_8_mm_axy7 , 0xffff, 0x8f0f, 18},+ {m68k_op_subx_8_mm_axy7 , 0xffff, 0x9f0f, 18},+ {m68k_op_cmpm_8_axy7 , 0xffff, 0xbf0f, 12},+ {m68k_op_abcd_8_mm_axy7 , 0xffff, 0xcf0f, 18},+ {m68k_op_addx_8_mm_axy7 , 0xffff, 0xdf0f, 18},+ {m68k_op_asr_16_aw , 0xffff, 0xe0f8, 16},+ {m68k_op_asr_16_al , 0xffff, 0xe0f9, 20},+ {m68k_op_asl_16_aw , 0xffff, 0xe1f8, 16},+ {m68k_op_asl_16_al , 0xffff, 0xe1f9, 20},+ {m68k_op_lsr_16_aw , 0xffff, 0xe2f8, 16},+ {m68k_op_lsr_16_al , 0xffff, 0xe2f9, 20},+ {m68k_op_lsl_16_aw , 0xffff, 0xe3f8, 16},+ {m68k_op_lsl_16_al , 0xffff, 0xe3f9, 20},+ {m68k_op_roxr_16_aw , 0xffff, 0xe4f8, 16},+ {m68k_op_roxr_16_al , 0xffff, 0xe4f9, 20},+ {m68k_op_roxl_16_aw , 0xffff, 0xe5f8, 16},+ {m68k_op_roxl_16_al , 0xffff, 0xe5f9, 20},+ {m68k_op_ror_16_aw , 0xffff, 0xe6f8, 16},+ {m68k_op_ror_16_al , 0xffff, 0xe6f9, 20},+ {m68k_op_rol_16_aw , 0xffff, 0xe7f8, 16},+ {m68k_op_rol_16_al , 0xffff, 0xe7f9, 20},+ {0, 0, 0, 0}+};+++/* Build the opcode handler jump table */+static void m68ki_build_opcode_table(void)+{+ const opcode_handler_struct *ostruct;+ int instr;+ int i;+ int j;++ for(i = 0; i < 0x10000; i++)+ {+ /* default to illegal */+ m68ki_instruction_jump_table[i] = m68k_op_illegal;+ m68ki_cycles[i] = 4;+ }++ ostruct = &m68k_opcode_handler_table[0];+ while(ostruct->mask != 0xff00)+ {+ for(i = 0;i < 0x10000;i++)+ {+ if((i & ostruct->mask) == ostruct->match)+ {+ m68ki_instruction_jump_table[i] = ostruct->opcode_handler;+ m68ki_cycles[i] = ostruct->cycles * MUL;+ }+ }+ ostruct++;+ }+ while(ostruct->mask == 0xff00)+ {+ for(i = 0;i <= 0xff;i++)+ {+ m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler;+ m68ki_cycles[ostruct->match | i] = ostruct->cycles * MUL;+ }+ ostruct++;+ }+ while(ostruct->mask == 0xf1f8)+ {+ for(i = 0;i < 8;i++)+ {+ for(j = 0;j < 8;j++)+ {+ instr = ostruct->match | (i << 9) | j;+ m68ki_instruction_jump_table[instr] = ostruct->opcode_handler;+ m68ki_cycles[instr] = ostruct->cycles * MUL;+ }+ }+ ostruct++;+ }+ while(ostruct->mask == 0xfff0)+ {+ for(i = 0;i <= 0x0f;i++)+ {+ m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler;+ m68ki_cycles[ostruct->match | i] = ostruct->cycles * MUL;+ }+ ostruct++;+ }+ while(ostruct->mask == 0xf1ff)+ {+ for(i = 0;i <= 0x07;i++)+ {+ m68ki_instruction_jump_table[ostruct->match | (i << 9)] = ostruct->opcode_handler;+ m68ki_cycles[ostruct->match | (i << 9)] = ostruct->cycles * MUL;+ }+ ostruct++;+ }+ while(ostruct->mask == 0xfff8)+ {+ for(i = 0;i <= 0x07;i++)+ {+ m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler;+ m68ki_cycles[ostruct->match | i] = ostruct->cycles * MUL;+ }+ ostruct++;+ }+ while(ostruct->mask == 0xffff)+ {+ m68ki_instruction_jump_table[ostruct->match] = ostruct->opcode_handler;+ m68ki_cycles[ostruct->match] = ostruct->cycles * MUL;+ ostruct++;+ }+}++#endif++/* ======================================================================== */+/* ============================== END OF FILE ============================= */+/* ======================================================================== */++diff --git a/games/retrogo/src/md/macros.h b/games/retrogo/src/md/macros.hnew file mode 100644index 00000000..9b4223cd--- /dev/null+++ b/games/retrogo/src/md/macros.h@@ -0,0 +1,70 @@+#ifndef _MACROS_H_+#define _MACROS_H_++#ifdef LSB_FIRST++#define READ_BYTE(BASE, ADDR) (BASE)[(ADDR)^1]++#define READ_WORD(BASE, ADDR) (((BASE)[ADDR]<<8) | (BASE)[(ADDR)+1])++#define READ_WORD_LONG(BASE, ADDR) (((BASE)[(ADDR)+1]<<24) | \+ ((BASE)[(ADDR)]<<16) | \+ ((BASE)[(ADDR)+3]<<8) | \+ (BASE)[(ADDR)+2])++#define WRITE_BYTE(BASE, ADDR, VAL) (BASE)[(ADDR)^1] = (VAL)&0xff++#define WRITE_WORD(BASE, ADDR, VAL) (BASE)[ADDR] = ((VAL)>>8) & 0xff; \+ (BASE)[(ADDR)+1] = (VAL)&0xff++#define WRITE_WORD_LONG(BASE, ADDR, VAL) (BASE)[(ADDR+1)] = ((VAL)>>24) & 0xff; \+ (BASE)[(ADDR)] = ((VAL)>>16)&0xff; \+ (BASE)[(ADDR+3)] = ((VAL)>>8)&0xff; \+ (BASE)[(ADDR+2)] = (VAL)&0xff++#else++#define READ_BYTE(BASE, ADDR) (BASE)[ADDR]+#define READ_WORD(BASE, ADDR) *(uint16 *)((BASE) + (ADDR))+#define READ_WORD_LONG(BASE, ADDR) *(uint32 *)((BASE) + (ADDR))+#define WRITE_BYTE(BASE, ADDR, VAL) (BASE)[ADDR] = VAL & 0xff+#define WRITE_WORD(BASE, ADDR, VAL) *(uint16 *)((BASE) + (ADDR)) = VAL & 0xffff+#define WRITE_WORD_LONG(BASE, ADDR, VAL) *(uint32 *)((BASE) + (ADDR)) = VAL & 0xffffffff+#endif++/* C89 compatibility */+#ifndef M_PI+#define M_PI 3.14159265358979323846264338327f+#endif /* M_PI */++/* Set to your compiler's static inline keyword to enable it, or+ * set it to blank to disable it.+ * If you define INLINE in makefile or osd.h, it will override this value.+ * NOTE: not enabling inline functions will SEVERELY slow down emulation.+ */+#ifndef INLINE+#define INLINE static __inline__+#endif /* INLINE */++/* Alignment macros for cross compiler compatibility */+#if defined(_MSC_VER)+#define ALIGNED_(x) __declspec(align(x))+#elif defined(__GNUC__)+#define ALIGNED_(x) __attribute__ ((aligned(x)))+#endif++/* Default CD image file access (read-only) functions */+/* If you need to override default stdio.h functions with custom filesystem API,+ redefine following macros in platform specific include file (osd.h) or Makefile+*/+#ifndef cdStream+#define cdStream FILE+#define cdStreamOpen(fname) fopen(fname, "rb")+#define cdStreamClose fclose+#define cdStreamRead fread+#define cdStreamSeek fseek+#define cdStreamTell ftell+#define cdStreamGets fgets+#endif++#endif /* _MACROS_H_ */diff --git a/games/retrogo/src/md/md.c b/games/retrogo/src/md/md.cnew file mode 100644index 00000000..718acb42--- /dev/null+++ b/games/retrogo/src/md/md.c@@ -0,0 +1,196 @@+/* The Mega Drive for Retro-Go's screens: gwenesis' machine run a frame at a time, as Retro-Go's+ * gwenesis main does (its 68000 and Z80 line by line, the VDP's interrupts, a line drawn+ * when the frame is), the picture handed line by line to rg_line.+ *+ * The calculator hasn't the RAM for gwenesis' frame buffer, nor in one piece for the 68000's+ * 64 KB of RAM besides the 64 KB of video RAM: the video RAM is in Retro-Go's heap, the RAMs in+ * pages of 4 KB (m68k.h, gwenesis_bus.c), and the picture goes out a line at a time.+ *+ * Based on gwenesis by bzhxx (GPL-3.0-or-later, see LICENSE) and Retro-Go's main for it. */+#include <string.h>+#include "md.h"+#include "m68k.h"+#include "gwenesis_bus.h"+#include "gwenesis_io.h"+#include "gwenesis_vdp.h"+#include "gwenesis_savestate.h"+#include "z80inst.h"++unsigned char *VRAM; /* (gwenesis_vdp_mem.c's) */+unsigned char *md_ram[16], *md_zram[2];+extern unsigned char gwenesis_vdp_regs[];+extern unsigned short gwenesis_vdp_status;+extern int screen_width, screen_height, hint_pending;+extern unsigned short CRAM565[];+void gwenesis_m68k_save_state(void), gwenesis_m68k_load_state(void);+void gwenesis_io_save_state(void), gwenesis_io_load_state(void);+void gwenesis_bus_save_state(void), gwenesis_bus_load_state(void);+void gwenesis_vdp_mem_save_state(void), gwenesis_vdp_mem_load_state(void);+void power_on(void), reset_emulation(void);++int system_clock, scan_line; /* (the frame's master clock and line, as gwenesis' main keeps them) */+static bool z80_on = true;++/* ---- the state: the parts gwenesis saves by name, here one after another in a block */+#define MISC_SIZE 3072+static uint8_t *misc;+static uint32_t misc_at, misc_size;+struct SaveState { int unused; };+static SaveState the_state;+SaveState *saveGwenesisStateOpenForRead(const char *name) { (void)name; return &the_state; }+SaveState *saveGwenesisStateOpenForWrite(const char *name) { (void)name; return &the_state; }+static void misc_put(const void *p, uint32_t n) {+ if (misc_at + n <= MISC_SIZE) memcpy(misc + misc_at, p, n);+ misc_at += n;+}+static void misc_get(void *p, uint32_t n) {+ if (misc_at + n <= MISC_SIZE) memcpy(p, misc + misc_at, n);+ else memset(p, 0, n);+ misc_at += n;+}+void saveGwenesisStateSet(SaveState *s, const char *tag, int v) { (void)s, (void)tag; misc_put(&v, 4); }+int saveGwenesisStateGet(SaveState *s, const char *tag) {+ int v;+ (void)s, (void)tag;+ misc_get(&v, 4);+ return v;+}+void saveGwenesisStateSetBuffer(SaveState *s, const char *tag, void *p, int n) { (void)s, (void)tag; misc_put(p, (uint32_t)n); }+void saveGwenesisStateGetBuffer(SaveState *s, const char *tag, void *p, int n) { (void)s, (void)tag; misc_get(p, (uint32_t)n); }++static void save_misc(void) {+ misc_at = 0;+ gwenesis_m68k_save_state();+ gwenesis_io_save_state();+ gwenesis_bus_save_state();+ gwenesis_vdp_mem_save_state();+ gwenesis_z80inst_save_state();+ misc_size = misc_at;+}++static void clear_rams(void) {+ for (int i = 0; i < 16; i++) memset(md_ram[i], 0, MD_PAGE);+ for (int i = 0; i < 2; i++) memset(md_zram[i], 0, MD_PAGE);+}++int md_load(const uint8_t *data, uint32_t size) {+ if (size < 0x200 || size > 0x400000) return RG_ERR_ROM;+ rg_alloc_reset();+ VRAM = rg_alloc(0x10000);+ misc = rg_alloc(MISC_SIZE);+ if (!VRAM || !misc) return RG_ERR_MEMORY;+ for (int i = 0; i < 16; i++)+ if (!(md_ram[i] = rg_alloc_page())) return RG_ERR_MEMORY;+ for (int i = 0; i < 2; i++)+ if (!(md_zram[i] = rg_alloc_page())) return RG_ERR_MEMORY;+ clear_rams();+ load_cartridge((unsigned char *)(uintptr_t)data, size);+ power_on();+ reset_emulation();+ save_misc();+ return RG_OK;+}++void md_reset(bool hard) {+ if (hard) {+ clear_rams();+ memset(VRAM, 0, 0x10000);+ power_on();+ reset_emulation();+ } else {+ m68k_pulse_reset();+ z80_pulse_reset();+ }+}++void md_set_z80(bool on) { z80_on = on; }++void gwenesis_io_get_buttons(void) {} /* (the pad is set before each frame, md_set_pad) */++void md_set_pad(int pad) {+ /* (gwenesis' buttons: up, down, left, right, C, B, A, Start; Retro-Go's A is C, its Select A) */+ static const uint8_t bits[8] = {RG_PAD_UP, RG_PAD_DOWN, RG_PAD_LEFT, RG_PAD_RIGHT,+ RG_PAD_A, RG_PAD_B, RG_PAD_SELECT, RG_PAD_START};+ for (int i = 0; i < 8; i++) {+ if (pad & bits[i]) gwenesis_io_pad_press_button(0, (unsigned char)i);+ else gwenesis_io_pad_release_button(0, (unsigned char)i);+ }+}++void md_view(int *x, int *y, int *w, int *h) {+ *x = 0, *y = 0;+ *w = REG12_MODE_H40 ? 320 : 256;+ *h = REG1_PAL ? 240 : 224;+}++uint32_t md_frame_us(void) { return REG1_PAL ? 20000 : 16667; }++void md_run_frame(bool draw) {+ int lines_per_frame = REG1_PAL ? LINES_PER_FRAME_PAL : LINES_PER_FRAME_NTSC;+ int hint_counter = gwenesis_vdp_regs[10];+ screen_width = REG12_MODE_H40 ? 320 : 256;+ screen_height = REG1_PAL ? 240 : 224;+ gwenesis_vdp_render_config();+ system_clock = 0;+ zclk = z80_on ? 0 : 0x1000000;+ scan_line = 0;+ while (scan_line < lines_per_frame) {+ m68k_run(system_clock + VDP_CYCLES_PER_LINE);+ z80_run(system_clock + VDP_CYCLES_PER_LINE);+ if (draw && scan_line < screen_height) gwenesis_vdp_render_line(scan_line);+ /* (on these lines the line counter is reloaded) */+ if (scan_line == 0 || scan_line > screen_height) hint_counter = REG10_LINE_COUNTER;+ if (--hint_counter < 0) {+ if (REG0_LINE_INTERRUPT != 0 && scan_line <= screen_height) {+ hint_pending = 1;+ if ((gwenesis_vdp_status & STATUS_VIRQPENDING) == 0) m68k_update_irq(4);+ }+ hint_counter = REG10_LINE_COUNTER;+ }+ scan_line++;+ /* the vertical blank from the end of the last line drawn */+ if (scan_line == screen_height) {+ if (REG1_VBLANK_INTERRUPT != 0) {+ gwenesis_vdp_status |= STATUS_VIRQPENDING;+ m68k_set_irq(6);+ }+ z80_irq_line(1);+ }+ if (scan_line == screen_height + 1) z80_irq_line(0);+ system_clock += VDP_CYCLES_PER_LINE;+ }+ m68k.cycles -= system_clock;+}++/* the picture again from the video RAM as it is now (under the menus) */+void md_redraw(void) {+ screen_width = REG12_MODE_H40 ? 320 : 256;+ screen_height = REG1_PAL ? 240 : 224;+ gwenesis_vdp_render_config();+ for (int y = 0; y < screen_height; y++) gwenesis_vdp_render_line(y);+}++int md_state_chunks(rg_chunk_t *out) {+ save_misc();+ int n = 0;+ out[n++] = (rg_chunk_t){misc, misc_size};+ out[n++] = (rg_chunk_t){VRAM, 0x8000};+ out[n++] = (rg_chunk_t){VRAM + 0x8000, 0x8000};+ for (int i = 0; i < 16; i++) out[n++] = (rg_chunk_t){md_ram[i], MD_PAGE};+ for (int i = 0; i < 2; i++) out[n++] = (rg_chunk_t){md_zram[i], MD_PAGE};+ return n;+}++void md_state_loaded(void) {+ misc_at = 0;+ gwenesis_m68k_load_state();+ gwenesis_io_load_state();+ gwenesis_bus_load_state();+ gwenesis_vdp_mem_load_state();+ gwenesis_z80inst_load_state();+ /* (whatever the state held: an interrupt level the 68000 has, clocks inside a frame) */+ m68k.int_level &= 0x700, m68k.int_mask &= 0x700, m68k.stopped &= 3;+ if (m68k.cycles > 0x100000) m68k.cycles = 0;+ if (m68k.cycle_end > 0x100000) m68k.cycle_end = 0;+ if (zclk < 0 || zclk > 0x1000000) zclk = 0;+}diff --git a/games/retrogo/src/md/md.h b/games/retrogo/src/md/md.hnew file mode 100644index 00000000..7c63ef17--- /dev/null+++ b/games/retrogo/src/md/md.h@@ -0,0 +1,32 @@+/* The Sega Mega Drive (Genesis), as gwenesis runs it (its 68000, Musashi, its VDP and its+ * ports), with NumPlay's Z80, for Retro-Go's screens. No sound: the calculator has no speaker. */+#ifndef MD_H+#define MD_H+#include "../rg.h"++#define MD_WIDTH 320+#define MD_HEIGHT 240++/* the RAMs (64 KB for the 68000, 8 KB for the Z80) in pages of MD_PAGE bytes, from rg_alloc_page+ (main.c: the heap, then the RAM after the app's own, then a buffer on main's stack) */+#define MD_PAGE 4096+void *rg_alloc_page(void);++/* a game read in place, plain and its bytes swapped in pairs (tools/romtable.py). RG_OK or an+ RG_ERR_ code. */+int md_load(const uint8_t *data, uint32_t size);+/* hard: switched off and on; soft: the console's reset button */+void md_reset(bool hard);+void md_run_frame(bool draw);+void md_set_pad(int rg_pad);+/* whether the Z80 runs (Retro-Go's "Z80 emulation": it only plays the sound, most games run+ without it) */+void md_set_z80(bool on);+/* the picture: 256 or 320 wide, 224 or 240 high */+void md_view(int *x, int *y, int *w, int *h);+/* a frame's length in microseconds: 60 a second, 50 for a game in its PAL mode */+uint32_t md_frame_us(void);+void md_redraw(void);+int md_state_chunks(rg_chunk_t *out);+void md_state_loaded(void);+#endifdiff --git a/games/retrogo/src/md/md_z80.c b/games/retrogo/src/md/md_z80.cnew file mode 100644index 00000000..51f9be97--- /dev/null+++ b/games/retrogo/src/md/md_z80.c@@ -0,0 +1,125 @@+/* The Mega Drive's Z80: NumPlay's (superzazu's z80, ../sms/z80.c, MIT License), built a second+ * time with the Mega Drive's memory, behind the calls gwenesis makes to its own Z80 (z80inst.h).+ * Its 8 KB of RAM (twice, 0000-3FFF), the sound chips (read as ready: no sound here), the bank+ * register (6000) and a 32 KB window into the 68000's memory (8000-FFFF).+ *+ * The control of the Z80 (bus request, reset) and the timing are gwenesis' z80inst.c's+ * (GPL-3.0-or-later, see LICENSE). */+#include <stdint.h>+#include <string.h>++/* ---- the Z80 itself, under other names */+uint8_t md_z80_read(uint16_t addr);+#define Z80_READ(a) md_z80_read(a)+#define z80_rmap md_z80_rmap+#define z80_bus_write md_z80_bus_write+#define z80_bus_in md_z80_bus_in+#define z80_bus_out md_z80_bus_out+#define z80_init md_z80_init+#define z80_run md_z80_exec+#define z80_gen_nmi md_z80_gen_nmi+#define z80_fix md_z80_fix+#define exec_opcode md_exec_opcode+#define exec_opcode_ddfd md_exec_opcode_ddfd+#define exec_opcode_cb md_exec_opcode_cb+#define exec_opcode_dcb md_exec_opcode_dcb+#define exec_opcode_ed md_exec_opcode_ed+#include "../sms/z80.c"+#undef z80_run+#undef z80_init+#undef z80_fix++#include "m68k.h"+#include "z80inst.h"+#include "gwenesis_bus.h"+#include "gwenesis_savestate.h"++extern unsigned char *md_zram[2];+#define ZRAM_AT(a) (md_zram[((a) >> 12) & 1][(a) & 0xFFF])++/* the machine around it, saved with it */+static struct {+ z80 cpu;+ int32_t bus_ack, reset, reset_once, bank;+} zs;+int zclk;++uint8_t md_z80_read(uint16_t a) {+ if (a < 0x4000) return ZRAM_AT(a);+ if (a < 0x6000) return 0; /* (the YM2612's status: ready) */+ if (a < 0x8000) return 0xFF;+ return (uint8_t)m68k_read_memory_8(((uint32_t)zs.bank << 15) | (a & 0x7FFF));+}+void md_z80_bus_write(uint16_t a, uint8_t v) {+ if (a < 0x4000) ZRAM_AT(a) = v;+ else if (a == 0x6000) zs.bank = ((zs.bank >> 1) | (v & 1) << 8) & 0x1FF;+ else if (a >= 0x8000) m68k_write_memory_8(((uint32_t)zs.bank << 15) | (a & 0x7FFF), v);+ /* (the YM2612 at 4000-5FFF and the PSG at 7F11: no sound) */+}+uint8_t md_z80_bus_in(uint8_t port) { (void)port; return 0xFF; }+void md_z80_bus_out(uint8_t port, uint8_t val) { (void)port, (void)val; }++void z80_start(void) {+ md_z80_init(&zs.cpu);+ zs.reset = 1, zs.reset_once = 0, zs.bus_ack = 0, zclk = 0;+}+void z80_pulse_reset(void) {+ uint8_t line = zs.cpu.irq_line;+ md_z80_init(&zs.cpu);+ zs.cpu.irq_line = line;+}+void z80_set_memory(unsigned char *buffer) { (void)buffer; }++/* runs the Z80 up to the master clock `target` (it runs at a 14th of it) */+void z80_run(int target) {+ if (zclk >= target) return;+ int slice = target - zclk;+ if (zs.reset_once == 1 && zs.bus_ack == 0 && zs.reset == 0) {+ uint32_t n = (uint32_t)(slice / Z80_FREQ_DIVISOR);+ zs.cpu.cyc = 0;+ md_z80_exec(&zs.cpu, n);+ zclk = target + (int)(zs.cpu.cyc - n) * Z80_FREQ_DIVISOR;+ } else {+ zclk = target;+ }+}+static void z80_sync(void) { z80_run(m68k_cycles_master()); }++void z80_write_ctrl(unsigned int address, unsigned int value) {+ z80_sync();+ if (address == 0x1100) { /* BUSREQ */+ zs.bus_ack = value ? 1 : 0;+ } else if (address == 0x1200) { /* RESET */+ if (value == 0) {+ zs.reset = 1;+ } else {+ z80_pulse_reset();+ zs.reset = 0, zs.reset_once = 1;+ }+ }+}+unsigned int z80_read_ctrl(unsigned int address) {+ z80_sync();+ if (address == 0x1100) return zs.bus_ack == 1 ? 0 : 1;+ if (address == 0x1200) return (unsigned)zs.reset;+ if (address == 0x1101 || address == 0x1201) return 0;+ return 0xFF;+}+void z80_irq_line(unsigned int value) {+ if (zs.reset_once == 0) return;+ zs.cpu.irq_line = value ? 1 : 0;+}++void gwenesis_z80inst_save_state(void) {+ SaveState *s = saveGwenesisStateOpenForWrite("z80");+ saveGwenesisStateSetBuffer(s, "z80", &zs, sizeof zs);+ saveGwenesisStateSet(s, "zclk", zclk);+}+void gwenesis_z80inst_load_state(void) {+ SaveState *s = saveGwenesisStateOpenForRead("z80");+ saveGwenesisStateGetBuffer(s, "z80", &zs, sizeof zs);+ zclk = saveGwenesisStateGet(s, "zclk");+ md_z80_fix(&zs.cpu);+ zs.bank &= 0x1FF;+ zs.bus_ack = zs.bus_ack != 0, zs.reset = zs.reset != 0, zs.reset_once = zs.reset_once != 0;+}diff --git a/games/retrogo/src/md/z80inst.h b/games/retrogo/src/md/z80inst.hnew file mode 100644index 00000000..9e7a09b2--- /dev/null+++ b/games/retrogo/src/md/z80inst.h@@ -0,0 +1,47 @@+/*+Gwenesis : Genesis & megadrive Emulator.++This program is free software: you can redistribute it and/or modify it under+the terms of the GNU General Public License as published by the Free Software+Foundation, either version 3 of the License, or (at your option) any later+version.+This program is distributed in the hope that it will be useful, but WITHOUT+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.+You should have received a copy of the GNU General Public License along with+this program. If not, see <http://www.gnu.org/licenses/>.++__author__ = "bzhxx"+__contact__ = "https://github.com/bzhxx"+__license__ = "GPLv3"++*/+#ifndef _Z80_INTERFACE_H_+#define _Z80_INTERFACE_H_++/* (NumPlay: md_z80.c; its own name, as the Master System's Z80 has a z80_run) */+#define z80_run md_z80_run++void z80_write_ctrl(unsigned int address, unsigned int value);+unsigned int z80_read_ctrl(unsigned int address);+void z80_start();+void z80_pulse_reset();+void z80_execute(unsigned int target);+void z80_run(int target);+extern int zclk;++void gwenesis_z80inst_save_state();+void gwenesis_z80inst_load_state();++void z80_set_memory(unsigned char *buffer);++void z80_write_memory_8(unsigned int address, unsigned int value);+void z80_write_memory_16(unsigned int address, unsigned int value);+unsigned int z80_read_memory_16(unsigned int address);+unsigned int z80_read_memory_8(unsigned int address);+void z80_irq_line(unsigned int value);++void gwenesis_z80inst_save_state();+void gwenesis_z80inst_load_state();++#endif\ No newline at end of filediff --git a/games/retrogo/src/rg.h b/games/retrogo/src/rg.hindex 8b61d190..270b6dfe 100644--- a/games/retrogo/src/rg.h+++ b/games/retrogo/src/rg.h@@ -23,7 +23,7 @@ typedef struct {void *at;uint32_t size;} rg_chunk_t;-#define RG_MAX_CHUNKS 16+#define RG_MAX_CHUNKS 24 /* (the Mega Drive: 21) *//* The cores' failures when loading a game, shown by the screens. */enum {diff --git a/games/retrogo/src/sms/z80.c b/games/retrogo/src/sms/z80.cindex e426ce8d..67f8b5c6 100644--- a/games/retrogo/src/sms/z80.c+++ b/games/retrogo/src/sms/z80.c@@ -77,10 +77,17 @@ static const uint8_t cyc_ddfd[256] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 15, 4, 4, 4, 4,// get bit "n" of number "val"#define GET_BIT(n, val) (((val) >> (n)) & 1)+#ifndef Z80_READstatic inline uint8_t rb(z80* const z, uint16_t addr) {(void)z;return z80_rmap[addr >> 10][addr & 0x3FF];}+#else /* (the Mega Drive's Z80, md/md_z80.c: its own reads) */+static inline uint8_t rb(z80* const z, uint16_t addr) {+ (void)z;+ return Z80_READ(addr);+}+#endifstatic inline void wb(z80* const z, uint16_t addr, uint8_t val) {(void)z;diff --git a/games/retrogo/tests/host_core.c b/games/retrogo/tests/host_core.cindex b9192807..c6a8655e 100644--- a/games/retrogo/tests/host_core.c+++ b/games/retrogo/tests/host_core.c@@ -1,7 +1,8 @@/* Retro-Go's emulators on a computer: runs a ROM for some frames, with random keys if asked,* and writes the last frame as a PPM picture.* host_core ROM FRAMES OUT.ppm [SEED] [SCRIPT] (SEED: random pad presses; 0 for none)- * The system comes from the file's extension (.gb .gbc .nes .sms .gg .sg .col .gw). */+ * The system comes from the file's extension (.gb .gbc .nes .sms .gg .sg .col .gw, .md .gen .bin:+ * a Mega Drive game, plain, its bytes swapped here as tools/romtable.py does). */#include <stdio.h>#include <stdlib.h>#include <string.h>@@ -11,15 +12,17 @@#include "../src/nes/nes_core.h"#include "../src/sms/sms.h"#include "../src/gw/gw.h"+#include "../src/md/md.h"static uint8_t heap[RG_HEAP_SIZE] __attribute__((aligned(8)));static uint32_t used;+static int pages_used;bool rg_drawing = true;#define FW 320 /* (the widest picture: the Game & Watch's) */static uint16_t frame[FW * 240];static int lines_seen;/* the three emulators behind the same few calls */-static enum { GB, NES, SMS, GW } kind;+static enum { GB, NES, SMS, GW, MD } kind;void *rg_alloc(uint32_t size) {size = (size + 7) & ~7u;@@ -29,29 +32,46 @@ void *rg_alloc(uint32_t size) {memset(p, 0, size);return p;}-void rg_alloc_reset(void) { used = 0; }+void rg_alloc_reset(void) { used = 0, pages_used = 0; }+/* (the Mega Drive's RAM pages: on the calculator from three places, here from a block of their own) */+static uint8_t pages[18 * 4096] __attribute__((aligned(8)));+void *rg_alloc_page(void) {+ if (used + 4096 <= sizeof heap) return rg_alloc(4096);+ if (pages_used >= 18) return NULL;+ memset(pages + pages_used * 4096, 0, 4096);+ return pages + 4096 * pages_used++;+}void rg_line(int y, const uint16_t *px) {if (y < 0 || y >= 240) {fprintf(stderr, "line %d out of the picture\n", y);abort();}- memcpy(frame + y * FW, px, (size_t)(kind == GB ? 160 : kind == GW ? 320 : 256) * 2);+ int vx, vy, vw, vh;+ if (kind == MD) md_view(&vx, &vy, &vw, &vh);+ memcpy(frame + y * FW, px, (size_t)(kind == GB ? 160 : kind == GW ? 320 : kind == MD ? vw : 256) * 2);lines_seen++;}/* the ROM, read only as the calculator's flash is: a write into it stops the test (and a readpast its end too: the page after it isn't there) */-static uint8_t *load(const char *path, uint32_t *size) {+static uint8_t *load(const char *path, uint32_t *size, bool md) {FILE *f = fopen(path, "rb");if (!f) return NULL;fseek(f, 0, SEEK_END);long n = ftell(f);fseek(f, 0, SEEK_SET);size_t pages = ((size_t)n + 4095) / 4096 * 4096 + 4096;+ if (md) { /* (the Mega Drive core reads up to the size rounded up to a power of two) */+ size_t p2 = 4096;+ while (p2 < (size_t)n) p2 <<= 1;+ pages = p2 + 4096;+ }uint8_t *d = mmap(NULL, pages, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);if (d == MAP_FAILED || fread(d, 1, (size_t)n, f) != (size_t)n) return NULL;fclose(f);+ if (md)+ for (long i = 0; i + 1 < n; i += 2) { uint8_t t = d[i]; d[i] = d[i + 1], d[i + 1] = t; }mprotect(d, pages - 4096, PROT_READ);mprotect(d + pages - 4096, 4096, PROT_NONE);*size = (uint32_t)n;@@ -69,36 +89,49 @@ static uint32_t crc32(const uint8_t *p, uint32_t n) {/* (the Game & Watch: the pad in the low byte, its console's buttons, GW_KEY_*, in the next) */static void set_pad(int p) {- kind == NES ? nes_set_pad(p) : kind == SMS ? sms_set_pad(p) : kind == GW ? gw_set_pad(p & 0xFF, p >> 8) : gb_set_pad(p);+ kind == NES ? nes_set_pad(p) : kind == SMS ? sms_set_pad(p) : kind == GW ? gw_set_pad(p & 0xFF, p >> 8)+ : kind == MD ? md_set_pad(p) : gb_set_pad(p);}+static int draw_every = 1, frame_no; /* (DRAW=n: one frame drawn in n, as the frame skipping does) */static void run_frame(void) {- kind == NES ? nes_run_frame(true) : kind == SMS ? sms_run_frame(true) : kind == GW ? gw_run_frame(true) : gb_run_frame(true);+ bool d = ++frame_no % draw_every == 0;+ kind == NES ? nes_run_frame(d) : kind == SMS ? sms_run_frame(d) : kind == GW ? gw_run_frame(d)+ : kind == MD ? md_run_frame(d) : gb_run_frame(d);}static int chunks(rg_chunk_t *c) {- return kind == NES ? nes_state_chunks(c) : kind == SMS ? sms_state_chunks(c) : kind == GW ? gw_state_chunks(c) : gb_state_chunks(c);+ return kind == NES ? nes_state_chunks(c) : kind == SMS ? sms_state_chunks(c) : kind == GW ? gw_state_chunks(c)+ : kind == MD ? md_state_chunks(c) : gb_state_chunks(c);}static void loaded(void) {- kind == NES ? nes_state_loaded() : kind == SMS ? sms_state_loaded() : kind == GW ? gw_state_loaded() : gb_state_loaded();+ kind == NES ? nes_state_loaded() : kind == SMS ? sms_state_loaded() : kind == GW ? gw_state_loaded()+ : kind == MD ? md_state_loaded() : gb_state_loaded();+}+static void redraw(void) {+ kind == NES ? nes_redraw() : kind == SMS ? sms_redraw() : kind == GW ? gw_redraw() : kind == MD ? md_redraw() : gb_redraw();}-static void redraw(void) { kind == NES ? nes_redraw() : kind == SMS ? sms_redraw() : kind == GW ? gw_redraw() : gb_redraw(); }static void view(int *x, int *y, int *w, int *h) {if (kind == SMS) sms_view(x, y, w, h);+ else if (kind == MD) md_view(x, y, w, h);else *x = 0, *y = 0, *w = kind == NES ? 256 : kind == GW ? 320 : 160, *h = kind == GB ? 144 : 240;}int main(int argc, char **argv) {if (argc < 4) return fprintf(stderr, "usage: host_core ROM FRAMES OUT.ppm [SEED] [SCRIPT]\n"), 2;uint32_t size;- uint8_t *rom = load(argv[1], &size);+ const char *ext0 = strrchr(argv[1], '.');+ bool md = ext0 && (!strcmp(ext0, ".md") || !strcmp(ext0, ".gen") || !strcmp(ext0, ".bin"));+ uint8_t *rom = load(argv[1], &size, md);+ if (getenv("DRAW")) draw_every = atoi(getenv("DRAW")) > 0 ? atoi(getenv("DRAW")) : 1;if (!rom) return fprintf(stderr, "can't read %s\n", argv[1]), 1;int frames = atoi(argv[2]);unsigned seed = argc > 4 ? (unsigned)atoi(argv[4]) : 0;const char *ext = strrchr(argv[1], '.');bool col = ext && !strcmp(ext, ".col");kind = ext && !strcmp(ext, ".nes") ? NES : ext && (!strcmp(ext, ".sms") || !strcmp(ext, ".gg") || !strcmp(ext, ".sg") || col) ? SMS- : ext && !strcmp(ext, ".gw") ? GW : GB;+ : ext && !strcmp(ext, ".gw") ? GW : md ? MD : GB;int r = kind == NES ? nes_load(rom, size): kind == GW ? gw_load(rom, size)+ : kind == MD ? md_load(rom, size): kind == SMS ? sms_load(rom, size, crc32(rom, size),!strcmp(ext, ".gg") ? SMS_GG : !strcmp(ext, ".sg") ? SMS_SG : col ? SMS_CV : SMS_SMS): gb_load(rom, size);@@ -128,7 +161,7 @@ int main(int argc, char **argv) {if (getenv("STATE")) {rg_chunk_t parts[RG_MAX_CHUNKS];int n = chunks(parts);- static uint8_t copy[RG_HEAP_SIZE + 65536];+ static uint8_t copy[RG_HEAP_SIZE + 18 * 4096 + 65536];uint32_t at = 0;for (int i = 0; i < n; i++) memcpy(copy + at, parts[i].at, parts[i].size), at += parts[i].size;static uint16_t first[FW * 240];diff --git a/games/retrogo/tools/m68ktab.py b/games/retrogo/tools/m68ktab.pynew file mode 100644index 00000000..18a33019--- /dev/null+++ b/games/retrogo/tools/m68ktab.py@@ -0,0 +1,89 @@+#!/usr/bin/env python3+"""The 68000's opcode table for gwenesis' Musashi (src/md/m68kops.h), small.++Musashi builds a table of 65536 handlers (a function pointer each, 256 KB on the calculator) and+65536 cycle counts from its list of opcode patterns (m68k_opcode_handler_table, the builder+m68ki_build_opcode_table under BUILD_TABLES). This does the same here, at build time, and writes+each opcode as a 16-bit number of one of the (handler, cycles) pairs instead: 128 KB of table and+a short list of pairs.++ m68ktab.py src/md/m68kops.h OUT.h"""+import re+import sys++MUL = 7 # (m68kcpu.c: the cycles in the master clock's)+++def patterns(src):+ body = src[src.index("m68k_opcode_handler_table[] =") :]+ body = body[: body.index("{0, 0, 0, 0}")]+ return [(m.group(1), int(m.group(2), 16), int(m.group(3), 16), int(m.group(4)))+ for m in re.finditer(r"\{(m68k_op_\w+)\s*,\s*0x([0-9a-fA-F]+),\s*0x([0-9a-fA-F]+),\s*(\d+)\}", body)]+++def build(pats):+ """m68ki_build_opcode_table, as it is: the general patterns first, then the special masks"""+ handler, cycles = ["m68k_op_illegal"] * 0x10000, [0] * 0x10000 # (illegal: 0, as gwenesis' own table has it)+ k = 0++ def put(i, p):+ handler[i], cycles[i] = p[0], p[3] * MUL++ while k < len(pats) and pats[k][1] != 0xFF00:+ p = pats[k]+ for i in range(0x10000):+ if i & p[1] == p[2]:+ put(i, p)+ k += 1+ while k < len(pats) and pats[k][1] == 0xFF00:+ for i in range(0x100):+ put(pats[k][2] | i, pats[k])+ k += 1+ while k < len(pats) and pats[k][1] == 0xF1F8:+ for i in range(8):+ for j in range(8):+ put(pats[k][2] | i << 9 | j, pats[k])+ k += 1+ while k < len(pats) and pats[k][1] == 0xFFF0:+ for i in range(0x10):+ put(pats[k][2] | i, pats[k])+ k += 1+ while k < len(pats) and pats[k][1] == 0xF1FF:+ for i in range(8):+ put(pats[k][2] | i << 9, pats[k])+ k += 1+ while k < len(pats) and pats[k][1] == 0xFFF8:+ for i in range(8):+ put(pats[k][2] | i, pats[k])+ k += 1+ while k < len(pats) and pats[k][1] == 0xFFFF:+ put(pats[k][2], pats[k])+ k += 1+ if k != len(pats):+ sys.exit(f"m68ktab: pattern {pats[k]} not taken")+ return handler, cycles+++def main():+ src = open(sys.argv[1], encoding="latin-1").read()+ handler, cycles = build(patterns(src))+ pairs, index = {}, []+ for h, c in zip(handler, cycles):+ index.append(pairs.setdefault((h, c), len(pairs)))+ names = sorted(pairs, key=pairs.get)+ out = ["/* Made by tools/m68ktab.py from src/md/m68kops.h: the 68000's opcodes, each the number of",+ " * its (handler, cycles) pair. */",+ "".join(f"static void {h}(void);\n" for h in sorted({h for h, _ in names})),+ f"static void (*const m68ki_pair_handler[{len(names)}])(void) = {{",+ ",".join(h for h, _ in names), "};",+ f"static const unsigned char m68ki_pair_cycles[{len(names)}] = {{",+ ",".join(str(c) for _, c in names), "};",+ "static const unsigned short m68ki_opcode_pair[0x10000] = {"]+ out += [",".join(str(v) for v in index[k:k + 64]) + "," for k in range(0, 0x10000, 64)]+ out.append("};")+ open(sys.argv[2], "w").write("\n".join(out) + "\n")+ print(f"M68K {sys.argv[2]}: {len(names)} handler and cycle pairs")+++if __name__ == "__main__":+ main()