Open64: osprey/common/targ_info/isa/x8664/isa

00001 /*
00002  *  Copyright (C) 2007, 2008 PathScale, LLC.  All Rights Reserved.
00003  */
00004 
00005 /*
00006  *  Copyright (C) 2007 QLogic Corporation.  All Rights Reserved.
00007  */
00008 
00009 /*
00010  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00011  */
00012 
00013 /*
00014 
00015   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00016 
00017   This program is free software; you can redistribute it and/or modify it
00018   under the terms of version 2 of the GNU General Public License as
00019   published by the Free Software Foundation.
00020 
00021   This program is distributed in the hope that it would be useful, but
00022   WITHOUT ANY WARRANTY; without even the implied warranty of
00023   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00024 
00025   Further, this software is distributed without any warranty that it is
00026   free of the rightful claim of any third person regarding infringement 
00027   or the like.  Any license provided herein, whether implied or 
00028   otherwise, applies only to this software file.  Patent licenses, if 
00029   any, provided herein do not apply to combinations of this program with 
00030   other software, or any other product whatsoever.  
00031 
00032   You should have received a copy of the GNU General Public License along
00033   with this program; if not, write the Free Software Foundation, Inc., 59
00034   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00035 
00036   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00037   Mountain View, CA 94043, or:
00038 
00039   http://www.sgi.com
00040 
00041   For further information regarding this notice, see:
00042 
00043   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00044 
00045 */
00046 
00047 //
00048 // Generate an ISA containing and group TOPS with similar operands/results 
00049 // format.
00051 // The instructions are listed below in the order as shown below. 
00052 //
00053 //   1. Real and pseudo instructions
00054 //   2. Simulated instructions.
00055 //
00056 // Within each category, the instructions are arranged roughly in order
00057 // of increasing numbers of operands.
00059 //
00060 //  $Revision: 1.177 $
00061 //  $Date: 05/11/11 10:44:29-08:00 $
00062 //  $Author: tkong@hyalite.keyresearch $
00063 //  $Source: common/targ_info/isa/x8664/SCCS/s.isa_operands.cxx $
00064 
00065 #include "topcode.h"
00066 #include "isa_operands_gen.h"
00067 
00068 main()
00069 {
00070   ISA_Operands_Begin("x8664");
00071 
00072   /* Literals... */
00073 
00074   const OPERAND_VALUE_TYPE simm8 =
00075     ISA_Lit_Opnd_Type_Create("simm8",  8,  SIGNED,   LC_simm8);
00076   const OPERAND_VALUE_TYPE uimm8 =
00077     ISA_Lit_Opnd_Type_Create("uimm8",  8,  UNSIGNED, LC_uimm8);
00078   const OPERAND_VALUE_TYPE simm16 =
00079     ISA_Lit_Opnd_Type_Create("simm16", 16, SIGNED,   LC_simm16);
00080   const OPERAND_VALUE_TYPE uimm16 =
00081     ISA_Lit_Opnd_Type_Create("uimm16", 16, UNSIGNED, LC_uimm16);
00082   const OPERAND_VALUE_TYPE simm32 =
00083     ISA_Lit_Opnd_Type_Create("simm32", 32, SIGNED,   LC_simm32);
00084   const OPERAND_VALUE_TYPE uimm32 =
00085     ISA_Lit_Opnd_Type_Create("uimm32", 32, UNSIGNED, LC_uimm32);
00086   const OPERAND_VALUE_TYPE simm64 =
00087     ISA_Lit_Opnd_Type_Create("simm64",  64, SIGNED,  LC_simm64);
00088   const OPERAND_VALUE_TYPE pcrel32 =
00089     ISA_Lit_Opnd_Type_Create("pcrel32", 32, SIGNED, LC_pcrel32);
00090 
00091 
00092   /* Registers... */
00093 
00094   const OPERAND_VALUE_TYPE int64 =
00095     ISA_Reg_Opnd_Type_Create("int64", ISA_REGISTER_CLASS_integer,
00096            ISA_REGISTER_SUBCLASS_UNDEFINED,
00097            64, SIGNED, INVALID);
00098   const OPERAND_VALUE_TYPE int32 =
00099     ISA_Reg_Opnd_Type_Create("int32", ISA_REGISTER_CLASS_integer,
00100            ISA_REGISTER_SUBCLASS_UNDEFINED,
00101            32, SIGNED, INVALID);
00102   const OPERAND_VALUE_TYPE int16 =
00103     ISA_Reg_Opnd_Type_Create("int16", ISA_REGISTER_CLASS_integer,
00104            ISA_REGISTER_SUBCLASS_UNDEFINED,
00105            16, SIGNED, INVALID);
00106   const OPERAND_VALUE_TYPE int8 =
00107     ISA_Reg_Opnd_Type_Create("int8", ISA_REGISTER_CLASS_integer,
00108            ISA_REGISTER_SUBCLASS_UNDEFINED,
00109            8, SIGNED, INVALID);
00110   const OPERAND_VALUE_TYPE rax =
00111     ISA_Reg_Opnd_Type_Create("rax", ISA_REGISTER_CLASS_integer,
00112            ISA_REGISTER_SUBCLASS_rax,
00113            64, SIGNED, INVALID);
00114   const OPERAND_VALUE_TYPE eax =
00115     ISA_Reg_Opnd_Type_Create("eax", ISA_REGISTER_CLASS_integer,
00116            ISA_REGISTER_SUBCLASS_rax,
00117            32, SIGNED, INVALID);
00118   const OPERAND_VALUE_TYPE ax =
00119     ISA_Reg_Opnd_Type_Create("ax", ISA_REGISTER_CLASS_integer,
00120            ISA_REGISTER_SUBCLASS_rax,
00121            16, SIGNED, INVALID);
00122   const OPERAND_VALUE_TYPE al =
00123     ISA_Reg_Opnd_Type_Create("al", ISA_REGISTER_CLASS_integer,
00124            ISA_REGISTER_SUBCLASS_rax,
00125            8, SIGNED, INVALID);
00126   const OPERAND_VALUE_TYPE rdx =
00127     ISA_Reg_Opnd_Type_Create("rdx", ISA_REGISTER_CLASS_integer,
00128            ISA_REGISTER_SUBCLASS_rdx,
00129            64, SIGNED, INVALID);
00130   const OPERAND_VALUE_TYPE edx =
00131     ISA_Reg_Opnd_Type_Create("edx", ISA_REGISTER_CLASS_integer,
00132            ISA_REGISTER_SUBCLASS_rdx,
00133            32, SIGNED, INVALID);
00134   const OPERAND_VALUE_TYPE cl =
00135     ISA_Reg_Opnd_Type_Create("cl", ISA_REGISTER_CLASS_integer,
00136            ISA_REGISTER_SUBCLASS_rcx,
00137            8, SIGNED, INVALID);
00138   const OPERAND_VALUE_TYPE rsp =
00139     ISA_Reg_Opnd_Type_Create("rsp", ISA_REGISTER_CLASS_integer,
00140            ISA_REGISTER_SUBCLASS_rsp,
00141            64, SIGNED, INVALID);
00142   const OPERAND_VALUE_TYPE esp =
00143     ISA_Reg_Opnd_Type_Create("esp", ISA_REGISTER_CLASS_integer,
00144            ISA_REGISTER_SUBCLASS_rsp,
00145            32, SIGNED, INVALID);
00146   const OPERAND_VALUE_TYPE rbp =
00147     ISA_Reg_Opnd_Type_Create("rbp", ISA_REGISTER_CLASS_integer,
00148            ISA_REGISTER_SUBCLASS_rbp,
00149            64, SIGNED, INVALID);
00150   const OPERAND_VALUE_TYPE r11 =
00151     ISA_Reg_Opnd_Type_Create("r11", ISA_REGISTER_CLASS_integer,
00152            ISA_REGISTER_SUBCLASS_r11,
00153            64, SIGNED, INVALID);
00154   const OPERAND_VALUE_TYPE fp64 =
00155     ISA_Reg_Opnd_Type_Create("fp64", ISA_REGISTER_CLASS_float,
00156            ISA_REGISTER_SUBCLASS_UNDEFINED,
00157            64, SIGNED, INVALID);
00158   const OPERAND_VALUE_TYPE fp128 =
00159     ISA_Reg_Opnd_Type_Create("fp128", ISA_REGISTER_CLASS_float,
00160            ISA_REGISTER_SUBCLASS_UNDEFINED,
00161            128, SIGNED, INVALID);
00162   const OPERAND_VALUE_TYPE x87 =
00163     ISA_Reg_Opnd_Type_Create("x87", ISA_REGISTER_CLASS_x87,
00164            ISA_REGISTER_SUBCLASS_UNDEFINED,
00165            128, SIGNED, INVALID);
00166   const OPERAND_VALUE_TYPE rflags =
00167     ISA_Reg_Opnd_Type_Create("rflags", ISA_REGISTER_CLASS_rflags,
00168            ISA_REGISTER_SUBCLASS_UNDEFINED,
00169            64, UNSIGNED, INVALID);
00170   const OPERAND_VALUE_TYPE eflags =
00171     ISA_Reg_Opnd_Type_Create("eflags", ISA_REGISTER_CLASS_rflags,
00172            ISA_REGISTER_SUBCLASS_UNDEFINED,
00173            32, UNSIGNED, INVALID);
00174   const OPERAND_VALUE_TYPE x87_cw =
00175     ISA_Reg_Opnd_Type_Create("x87_cw", ISA_REGISTER_CLASS_x87_cw,
00176            ISA_REGISTER_SUBCLASS_UNDEFINED,
00177            16, UNSIGNED, INVALID);
00178 
00179   const OPERAND_VALUE_TYPE mmx =
00180     ISA_Reg_Opnd_Type_Create("mmx", ISA_REGISTER_CLASS_mmx,
00181                              ISA_REGISTER_SUBCLASS_UNDEFINED,
00182                              64, SIGNED, INVALID);
00183   /* Enums */
00184 
00185   const OPERAND_VALUE_TYPE pfhint =
00186     ISA_Enum_Opnd_Type_Create("pfhint", 8, UNSIGNED, EC_pfhint);
00187 
00188   /* Operand uses... */
00189 
00190   // a qualifying predicate
00191   const OPERAND_USE_TYPE predicate = Create_Operand_Use("predicate");
00192   // a base address (for memory insts)
00193   const OPERAND_USE_TYPE base = Create_Operand_Use("base");
00194   // an index added to a base
00195   const OPERAND_USE_TYPE index = Create_Operand_Use("index");
00196   // a scale to be multiplied with index 
00197   const OPERAND_USE_TYPE scale = Create_Operand_Use("scale");
00198   // an offset added to a base (implies immed val)
00199   const OPERAND_USE_TYPE offset = Create_Operand_Use("offset");
00200   // the target of a branch
00201   const OPERAND_USE_TYPE target = Create_Operand_Use("target");
00202   // value to be stored
00203   const OPERAND_USE_TYPE storeval = Create_Operand_Use("storeval");
00204   // first/left operand or result of an alu operator
00205   const OPERAND_USE_TYPE opnd1 = Create_Operand_Use("opnd1");
00206   // second/right operand of an alu operator
00207   const OPERAND_USE_TYPE opnd2 = Create_Operand_Use("opnd2");
00208   // third operand of an alu operator
00209   const OPERAND_USE_TYPE opnd3 = Create_Operand_Use("opnd3");
00210   // addend/subtrahend operand of a madd
00211   const OPERAND_USE_TYPE maddend = Create_Operand_Use("maddend");
00212 
00213   Instruction_Group("no operand",
00214         TOP_nop,
00215         TOP_noop,
00216         TOP_enter,
00217         TOP_ret,
00218         TOP_asm,
00219         TOP_begin_pregtn,
00220         TOP_end_pregtn,
00221         TOP_fwd_bar,
00222         TOP_bwd_bar,
00223         TOP_mfence,
00224         TOP_lfence,
00225         TOP_sfence,
00226         TOP_emms,
00227         TOP_UNDEFINED);
00228 
00229   Instruction_Group("ret imm16",
00230         TOP_reti,
00231         TOP_UNDEFINED);
00232   Operand( 0, simm16, opnd1 );
00233 
00234   Instruction_Group("int load imm32",
00235         TOP_ldc32,
00236         TOP_UNDEFINED);
00237   Result(0, int32);
00238   Operand(0, simm32, opnd1);
00239 
00240   Instruction_Group("int load imm64",
00241         TOP_ldc64,
00242         TOP_movabsq,
00243         TOP_UNDEFINED);
00244   Result(0, int64);
00245   Operand(0, simm64, opnd1);
00246 
00247   Instruction_Group( "int8 arithmetic",
00248          TOP_and8,
00249          TOP_or8,
00250          TOP_xor8,
00251          TOP_UNDEFINED);
00252   Result(0, int8);
00253   Operand(0, int8, opnd1);
00254   Operand(1, int8, opnd2);
00255 
00256 
00257   Instruction_Group( "int16 arithmetic",
00258          TOP_and16,
00259          TOP_or16,
00260          TOP_xor16,
00261          TOP_UNDEFINED);
00262   Result(0, int16);
00263   Operand(0, int16, opnd1);
00264   Operand(1, int16, opnd2);
00265 
00266   Instruction_Group( "int32 arithmetic",
00267          TOP_add32,
00268          TOP_adc32,
00269          TOP_and32,
00270          TOP_or32,
00271          TOP_sub32,
00272          TOP_sbb32,
00273          TOP_xor32,
00274          TOP_UNDEFINED);
00275   Result(0, int32);
00276   Operand(0, int32, opnd1);
00277   Operand(1, int32, opnd2);
00278 
00279   Instruction_Group( "int64 arithmetic",
00280          TOP_add64,
00281          TOP_and64,
00282          TOP_or64,
00283          TOP_sub64,
00284          TOP_xor64,
00285          TOP_UNDEFINED);
00286   Result(0, int64);
00287   Operand(0, int64, opnd1);
00288   Operand(1, int64, opnd2);
00289 
00290   Instruction_Group( "vector arithmetic",
00291            TOP_mul128v16,
00292          TOP_add128v8,
00293          TOP_add128v16,
00294          TOP_add128v32,
00295          TOP_add128v64,
00296          TOP_fadd128v32,
00297          TOP_fadd128v64,
00298          TOP_fhadd128v32,
00299          TOP_fhadd128v64,
00300          TOP_faddsub128v32,
00301          TOP_faddsub128v64,
00302          TOP_sub128v8,
00303          TOP_sub128v16,
00304          TOP_sub128v32,
00305          TOP_sub128v64,
00306          TOP_fsub128v32,
00307          TOP_fsub128v64,
00308          TOP_fhsub128v32,
00309          TOP_fhsub128v64,
00310          TOP_and128v8,
00311          TOP_and128v16,
00312          TOP_and128v32,
00313          TOP_and128v64,
00314          TOP_fand128v32,
00315          TOP_fand128v64,
00316          TOP_or128v8,
00317          TOP_or128v16,
00318          TOP_or128v32,
00319          TOP_or128v64,
00320          TOP_for128v32,
00321          TOP_for128v64,
00322          TOP_xor128v8,
00323          TOP_xor128v16,
00324          TOP_xor128v32,
00325          TOP_xor128v64,
00326          TOP_fxor128v32,
00327          TOP_fxor128v64,
00328          TOP_xorps,
00329          TOP_xorpd,
00330          TOP_orps,
00331          TOP_orpd,
00332          TOP_andps,
00333          TOP_andpd,
00334          TOP_fmax128v32,
00335          TOP_fmax128v64,
00336          TOP_fmin128v32,
00337          TOP_fmin128v64,
00338          TOP_fdiv128v32,
00339          TOP_fdiv128v64,
00340          TOP_fmul128v32,
00341          TOP_fmul128v64,
00342          TOP_subus128v16,
00343          TOP_cmpgt128v8,
00344          TOP_cmpgt128v16,
00345          TOP_cmpgt128v32,
00346          TOP_cmpeq128v8,
00347          TOP_cmpeq128v16,
00348          TOP_cmpeq128v32,
00349          TOP_max128v8,
00350          TOP_max128v16,
00351          TOP_min128v8,
00352          TOP_min128v16,
00353          TOP_UNDEFINED);
00354   Result(0, fp128);
00355   Operand(0, fp128, opnd1);
00356   Operand(1, fp128, opnd2);
00357 
00358   Instruction_Group( "vector arithmetic mem opnd",
00359          TOP_addx128v8,
00360          TOP_addx128v16,
00361          TOP_addx128v32,
00362          TOP_addx128v64,
00363          TOP_faddx128v32,
00364          TOP_faddx128v64,
00365          TOP_fhaddx128v32,
00366          TOP_fhaddx128v64,
00367          TOP_faddsubx128v32,
00368          TOP_faddsubx128v64,
00369          TOP_andx128v8,
00370          TOP_andx128v16,
00371          TOP_andx128v32,
00372          TOP_andx128v64,
00373          TOP_fandx128v32,
00374          TOP_fandx128v64,
00375          TOP_orx128v8,
00376          TOP_orx128v16,
00377          TOP_orx128v32,
00378          TOP_orx128v64,
00379          TOP_forx128v32,
00380          TOP_forx128v64,
00381          TOP_xorx128v8,
00382          TOP_xorx128v16,
00383          TOP_xorx128v32,
00384          TOP_xorx128v64,
00385          TOP_fxorx128v32,
00386          TOP_fxorx128v64,
00387          TOP_fmaxx128v32,
00388          TOP_fmaxx128v64,
00389          TOP_fminx128v32,
00390          TOP_fminx128v64,
00391          TOP_fdivx128v32,
00392          TOP_fdivx128v64,
00393          TOP_fmulx128v32,
00394          TOP_fmulx128v64,
00395          TOP_subx128v8,
00396          TOP_subx128v16,
00397          TOP_subx128v32,
00398          TOP_subx128v64,
00399          TOP_fsubx128v32,
00400          TOP_fsubx128v64,
00401          TOP_fhsubx128v32,
00402                TOP_fhsubx128v64,
00403                TOP_cmpgtx128v8,
00404                TOP_cmpgtx128v16,
00405                TOP_cmpgtx128v32,
00406                TOP_cmpeqx128v8,
00407                TOP_cmpeqx128v16,
00408                TOP_cmpeqx128v32,
00409                TOP_maxx128v8,
00410                TOP_maxx128v16,
00411                TOP_minx128v8,
00412                TOP_minx128v16,
00413          TOP_UNDEFINED);
00414   Result(0, fp128);
00415   Operand(0, fp128, opnd1);
00416   Operand(1, int64, base);
00417   Operand(2, simm32, offset);
00418   
00419   Instruction_Group( "vector arithmetic mem opnd w/ scaled index",
00420          TOP_addxx128v8,
00421          TOP_addxx128v16,
00422          TOP_addxx128v32,
00423          TOP_addxx128v64,
00424          TOP_faddxx128v32,
00425          TOP_faddxx128v64,
00426          TOP_fhaddxx128v32,
00427          TOP_fhaddxx128v64,
00428          TOP_faddsubxx128v32,
00429          TOP_faddsubxx128v64,
00430          TOP_andxx128v8,
00431          TOP_andxx128v16,
00432          TOP_andxx128v32,
00433          TOP_andxx128v64,
00434          TOP_fandxx128v32,
00435          TOP_fandxx128v64,
00436          TOP_orxx128v8,
00437          TOP_orxx128v16,
00438          TOP_orxx128v32,
00439          TOP_orxx128v64,
00440          TOP_forxx128v32,
00441          TOP_forxx128v64,
00442          TOP_xorxx128v8,
00443          TOP_xorxx128v16,
00444          TOP_xorxx128v32,
00445          TOP_xorxx128v64,
00446          TOP_fxorxx128v32,
00447          TOP_fxorxx128v64,
00448          TOP_fmaxxx128v32,
00449          TOP_fmaxxx128v64,
00450          TOP_fminxx128v32,
00451          TOP_fminxx128v64,
00452          TOP_fdivxx128v32,
00453          TOP_fdivxx128v64,
00454          TOP_fmulxx128v32,
00455          TOP_fmulxx128v64,
00456          TOP_subxx128v8,
00457          TOP_subxx128v16,
00458          TOP_subxx128v32,
00459          TOP_subxx128v64,
00460          TOP_fsubxx128v32,
00461          TOP_fsubxx128v64,
00462          TOP_fhsubxx128v32,
00463          TOP_fhsubxx128v64,
00464                TOP_cmpgtxx128v8,
00465                TOP_cmpgtxx128v16,
00466                TOP_cmpgtxx128v32,
00467                TOP_cmpeqxx128v8,
00468                TOP_cmpeqxx128v16,
00469                TOP_cmpeqxx128v32,
00470                TOP_maxxx128v8,
00471                TOP_maxxx128v16,
00472                TOP_minxx128v8,
00473                TOP_minxx128v16,
00474          TOP_UNDEFINED);
00475   Result(0, fp128);
00476   Operand(0, fp128, opnd1);
00477   Operand(1, int64, base);
00478   Operand(2, int64, index);
00479   Operand(3, uimm8, scale);
00480   Operand(4, simm32, offset);
00481   
00482   Instruction_Group( "vector arithmetic mem opnd w/ scaled index w/o base",
00483          TOP_addxxx128v8,
00484          TOP_addxxx128v16,
00485          TOP_addxxx128v32,
00486          TOP_addxxx128v64,
00487          TOP_faddxxx128v32,
00488          TOP_faddxxx128v64,
00489          TOP_fhaddxxx128v32,
00490          TOP_fhaddxxx128v64,
00491          TOP_faddsubxxx128v32,
00492          TOP_faddsubxxx128v64,
00493          TOP_andxxx128v8,
00494          TOP_andxxx128v16,
00495          TOP_andxxx128v32,
00496          TOP_andxxx128v64,
00497          TOP_fandxxx128v32,
00498          TOP_fandxxx128v64,
00499          TOP_orxxx128v8,
00500          TOP_orxxx128v16,
00501          TOP_orxxx128v32,
00502          TOP_orxxx128v64,
00503          TOP_forxxx128v32,
00504          TOP_forxxx128v64,
00505          TOP_xorxxx128v8,
00506          TOP_xorxxx128v16,
00507          TOP_xorxxx128v32,
00508          TOP_xorxxx128v64,
00509          TOP_fxorxxx128v32,
00510          TOP_fxorxxx128v64,
00511          TOP_fmaxxxx128v32,
00512          TOP_fmaxxxx128v64,
00513          TOP_fminxxx128v32,
00514          TOP_fminxxx128v64,
00515          TOP_fdivxxx128v32,
00516          TOP_fdivxxx128v64,
00517          TOP_fmulxxx128v32,
00518          TOP_fmulxxx128v64,
00519          TOP_subxxx128v8,
00520          TOP_subxxx128v16,
00521          TOP_subxxx128v32,
00522          TOP_subxxx128v64,
00523          TOP_fsubxxx128v32,
00524          TOP_fsubxxx128v64,
00525          TOP_fhsubxxx128v32,
00526          TOP_fhsubxxx128v64,
00527                TOP_cmpgtxxx128v8,
00528                TOP_cmpgtxxx128v16,
00529                TOP_cmpgtxxx128v32,
00530                TOP_cmpeqxxx128v8,
00531                TOP_cmpeqxxx128v16,
00532                TOP_cmpeqxxx128v32,
00533                TOP_maxxxx128v8,
00534                TOP_maxxxx128v16,
00535                TOP_minxxx128v8,
00536                TOP_minxxx128v16,
00537          TOP_UNDEFINED);
00538   Result(0, fp128);
00539   Operand(0, fp128, opnd1);
00540   Operand(1, int64, index);
00541   Operand(2, uimm8, scale);
00542   Operand(3, simm32, offset);
00543 
00544   Instruction_Group( "int8 arithmetic mem opnd",
00545          TOP_xorx8,
00546          TOP_orx8,
00547          TOP_andx8,
00548          TOP_UNDEFINED);
00549   Result(0, int8);
00550   Operand(0, int8, opnd1);
00551   Operand(1, int64, base);
00552   Operand(2, simm32, offset);
00553 
00554   Instruction_Group( "int16 arithmetic mem opnd",
00555          TOP_xorx16,
00556          TOP_orx16,
00557          TOP_andx16,
00558          TOP_UNDEFINED);
00559   Result(0, int16);
00560   Operand(0, int16, opnd1);
00561   Operand(1, int64, base);
00562   Operand(2, simm32, offset);
00563 
00564   Instruction_Group( "int32 arithmetic mem opnd",
00565          TOP_addx32,
00566          TOP_subx32,
00567          TOP_xorx32,
00568          TOP_orx32,
00569          TOP_andx32,
00570          TOP_UNDEFINED);
00571   Result(0, int32);
00572   Operand(0, int32, opnd1);
00573   Operand(1, int64, base);
00574   Operand(2, simm32, offset);
00575 
00576   Instruction_Group( "int64 arithmetic mem opnd",
00577          TOP_addx64,
00578          TOP_subx64,
00579          TOP_xorx64,
00580          TOP_orx64,
00581          TOP_andx64,
00582          TOP_UNDEFINED);
00583   Result(0, int64);
00584   Operand(0, int64, opnd1);
00585   Operand(1, int64, base);
00586   Operand(2, simm32, offset);
00587 
00588   Instruction_Group( "int8 arithmetic mem opnd w/ scaled index",
00589          TOP_xorxx8,
00590          TOP_orxx8,
00591          TOP_andxx8,
00592          TOP_UNDEFINED);
00593   Result(0, int8);
00594   Operand(0, int8,  opnd1);
00595   Operand(1, int64, base);
00596   Operand(2, int64, index);
00597   Operand(3, uimm8, scale);
00598   Operand(4, simm32, offset);
00599 
00600   Instruction_Group( "int16 arithmetic mem opnd w/ scaled index",
00601          TOP_xorxx16,
00602          TOP_orxx16,
00603          TOP_andxx16,
00604          TOP_UNDEFINED);
00605   Result(0, int16);
00606   Operand(0, int16, opnd1);
00607   Operand(1, int64, base);
00608   Operand(2, int64, index);
00609   Operand(3, uimm8, scale);
00610   Operand(4, simm32, offset);
00611 
00612   Instruction_Group( "int32 arithmetic mem opnd w/ scaled index",
00613          TOP_addxx32,
00614          TOP_subxx32,
00615          TOP_xorxx32,
00616          TOP_orxx32,
00617          TOP_andxx32,
00618          TOP_UNDEFINED);
00619   Result(0, int32);
00620   Operand(0, int32, opnd1);
00621   Operand(1, int64, base);
00622   Operand(2, int64, index);
00623   Operand(3, uimm8, scale);
00624   Operand(4, simm32, offset);
00625 
00626   Instruction_Group( "int64 arithmetic mem opnd w/ scaled index",
00627          TOP_addxx64,
00628          TOP_subxx64,
00629          TOP_xorxx64,
00630          TOP_orxx64,
00631          TOP_andxx64,
00632          TOP_UNDEFINED);
00633   Result(0, int64);
00634   Operand(0, int64, opnd1);
00635   Operand(1, int64, base);
00636   Operand(2, int64, index);
00637   Operand(3, uimm8, scale);
00638   Operand(4, simm32, offset);
00639 
00640   Instruction_Group( "int8 arithmetic mem opnd w/ scaled index w/o base",
00641          TOP_xorxxx8,
00642          TOP_orxxx8,
00643          TOP_andxxx8,
00644          TOP_UNDEFINED);
00645   Result(0, int8);
00646   Operand(0, int8,  opnd1);
00647   Operand(1, int64, index);
00648   Operand(2, uimm8, scale);
00649   Operand(3, simm32, offset);
00650 
00651   Instruction_Group( "int16 arithmetic mem opnd w/ scaled index w/o base",
00652          TOP_xorxxx16,
00653          TOP_orxxx16,
00654          TOP_andxxx16,
00655          TOP_UNDEFINED);
00656   Result(0, int16);
00657   Operand(0, int16, opnd1);
00658   Operand(1, int64, index);
00659   Operand(2, uimm8, scale);
00660   Operand(3, simm32, offset);
00661 
00662   Instruction_Group( "int32 arithmetic mem opnd w/ scaled index w/o base",
00663          TOP_addxxx32,
00664          TOP_subxxx32,
00665          TOP_xorxxx32,
00666          TOP_orxxx32,
00667          TOP_andxxx32,
00668          TOP_UNDEFINED);
00669   Result(0, int32);
00670   Operand(0, int32, opnd1);
00671   Operand(1, int64, index);
00672   Operand(2, uimm8, scale);
00673   Operand(3, simm32, offset);
00674 
00675   Instruction_Group( "int64 arithmetic mem opnd w/ scaled index w/o base",
00676          TOP_addxxx64,
00677          TOP_subxxx64,
00678          TOP_xorxxx64,
00679          TOP_orxxx64,
00680          TOP_andxxx64,
00681          TOP_UNDEFINED);
00682   Result(0, int64);
00683   Operand(0, int64, opnd1);
00684   Operand(1, int64, index);
00685   Operand(2, uimm8, scale);
00686   Operand(3, simm32, offset);
00687 
00688   Instruction_Group( "unary int8 arithmetic",
00689            TOP_inc8,
00690          TOP_dec8,
00691          TOP_UNDEFINED);
00692   Result(0, int8);
00693   Operand(0, int8, opnd1);
00694 
00695   Instruction_Group( "unary int16 arithmetic",
00696            TOP_inc16,
00697            TOP_dec16,
00698          TOP_UNDEFINED);
00699   Result(0, int16);
00700   Operand(0, int16, opnd1);
00701 
00702   Instruction_Group( "unary int32 arithmetic",
00703          TOP_neg32,
00704          TOP_not32,
00705            TOP_inc32,
00706          TOP_dec32,
00707          TOP_UNDEFINED);
00708   Result(0, int32);
00709   Operand(0, int32, opnd1);
00710 
00711   Instruction_Group( "unary int64 arithmetic",
00712          TOP_neg64,
00713          TOP_not64,
00714          TOP_inc64,
00715          TOP_dec64,
00716          TOP_UNDEFINED);
00717   Result(0, int64);
00718   Operand(0, int64, opnd1);
00719 
00720   Instruction_Group("int32 arithmetic with simm",
00721         TOP_xori32,
00722         TOP_ori32,
00723         TOP_andi32,
00724         TOP_addi32,
00725         TOP_adci32,
00726         TOP_subi32,
00727         TOP_sbbi32,
00728         TOP_imuli32,
00729         TOP_UNDEFINED);
00730   Result(0, int32);
00731   Operand(0, int32, opnd1);
00732   Operand(1, simm32, opnd2);
00733   
00734   Instruction_Group("int64 arithmetic with simm",
00735         TOP_xori64,
00736         TOP_ori64,
00737         TOP_andi64,
00738         TOP_addi64,
00739         TOP_subi64,
00740         TOP_imuli64,
00741         TOP_UNDEFINED);
00742   Result(0, int64);
00743   Operand(0, int64, opnd1);
00744   Operand(1, simm32, opnd2);
00745 
00746   Instruction_Group("int8 load w/o base or index (movabs)",
00747         TOP_ld8_abs,
00748         TOP_UNDEFINED);
00749   Result(0, al);
00750   Operand(0, simm64, offset);
00751 
00752   Instruction_Group("int16 load w/o base or index (movabs)",
00753         TOP_ld16_abs,
00754         TOP_UNDEFINED);
00755   Result(0, ax);
00756   Operand(0, simm64, offset);
00757 
00758   Instruction_Group("int32 load w/o base or index (movabs)",
00759         TOP_ld32_abs,
00760         TOP_UNDEFINED);
00761   Result(0, eax);
00762   Operand(0, simm64, offset);
00763 
00764   Instruction_Group("int32 load w/o base or index",
00765         TOP_ld8_32_n32,
00766         TOP_ldu8_32_n32,
00767         TOP_ld16_32_n32,
00768         TOP_ldu16_32_n32,
00769         TOP_ld32_n32,
00770         TOP_UNDEFINED);
00771   Result(0, int32);
00772   Operand(0, simm32, offset);
00773 
00774   Instruction_Group("int64 load w/o base or index",
00775         TOP_ld64_off,
00776         TOP_ld8_64_off,
00777         TOP_ldu8_64_off,
00778         TOP_ld16_64_off,
00779         TOP_ldu16_64_off,
00780         TOP_ld32_64_off,
00781         TOP_UNDEFINED);
00782   Result(0, int64);
00783   Operand(0, simm32, offset);
00784 
00785   Instruction_Group("int64 load w/o base or index (movabs)",
00786         TOP_ld64_abs,
00787         TOP_UNDEFINED);
00788   Result(0, rax);
00789   Operand(0, simm64, offset);
00790 
00791   Instruction_Group("int32 load",
00792         TOP_ld8_32,
00793         TOP_ldu8_32,
00794         TOP_ld16_32,
00795         TOP_ldu16_32,
00796         TOP_ld32,
00797         TOP_UNDEFINED);
00798   Result(0, int32);
00799   Operand(0, int64, base);
00800   Operand(1, simm32, offset);
00801 
00802   Instruction_Group("int64 load",
00803         TOP_ld8_64,
00804         TOP_ldu8_64,
00805         TOP_ld16_64,
00806         TOP_ldu16_64,
00807         TOP_ld32_64,
00808         TOP_ld64,
00809         TOP_UNDEFINED);
00810   Result(0, int64);
00811   Operand(0, int64, base);
00812   Operand(1, simm32, offset);
00813 
00814   Instruction_Group("int32 load from %gs segment w/o base or index",
00815         TOP_ld32_gs_seg_off,
00816         TOP_UNDEFINED);
00817   Result(0, int32);
00818   Operand(0, simm32, offset);
00819 
00820   Instruction_Group("int64 load from %fs segment w/o base or index",
00821         TOP_ld64_fs_seg_off,
00822         TOP_UNDEFINED);
00823   Result(0, int64);
00824   Operand(0, simm32, offset);
00825 
00826   Instruction_Group("int8 store w/o base or index (movabs)",
00827         TOP_store8_abs,
00828         TOP_UNDEFINED);
00829   Operand(0, al, storeval);
00830   Operand(1, simm64, offset);
00831 
00832   Instruction_Group("int8 store w/o base or index",
00833         TOP_store8_n32,
00834         TOP_UNDEFINED);
00835   Operand(0, int8, storeval);
00836   Operand(1, simm32, offset);
00837 
00838   Instruction_Group("int16 store w/o base or index (movabs)",
00839         TOP_store16_abs,
00840         TOP_UNDEFINED);
00841   Operand(0, ax, storeval);
00842   Operand(1, simm64, offset);
00843 
00844   Instruction_Group("int16 store w/o base or index",
00845         TOP_store16_n32,
00846         TOP_UNDEFINED);
00847   Operand(0, int16, storeval);
00848   Operand(1, simm32, offset);
00849 
00850   Instruction_Group("int32 store w/o base or index (movabs)",
00851         TOP_store32_abs,
00852         TOP_UNDEFINED);
00853   Operand(0, eax, storeval);
00854   Operand(1, simm64, offset);
00855 
00856   Instruction_Group("int32 store w/o base or index",
00857         TOP_store32_n32,
00858         TOP_UNDEFINED);
00859   Operand(0, int32, storeval);
00860   Operand(1, simm32, offset);
00861 
00862   Instruction_Group("int64 store w/o base or index",
00863         TOP_store64_off,
00864         TOP_UNDEFINED);
00865   Operand(0, int64, storeval);
00866   Operand(1, simm32, offset);
00867 
00868   Instruction_Group("int64 store w/o base or index (movabs)",
00869         TOP_store64_abs,
00870         TOP_UNDEFINED);
00871   Operand(0, rax, storeval);
00872   Operand(1, simm64, offset);
00873 
00874   Instruction_Group("int8 store",
00875         TOP_store8,
00876         TOP_UNDEFINED);
00877   Operand(0, int8, storeval);
00878   Operand(1, int64, base);
00879   Operand(2, simm32, offset);
00880 
00881   Instruction_Group("int16 store",
00882         TOP_store16,
00883         TOP_UNDEFINED);
00884   Operand(0, int16, storeval);
00885   Operand(1, int64, base);
00886   Operand(2, simm32, offset);
00887 
00888   Instruction_Group("int32 store",
00889         TOP_store32,
00890         TOP_storenti32,
00891         TOP_UNDEFINED);
00892   Operand(0, int32, storeval);
00893   Operand(1, int64, base);
00894   Operand(2, simm32, offset);
00895 
00896   Instruction_Group("int64 store",
00897         TOP_store64,
00898         TOP_storenti64,
00899         TOP_UNDEFINED);
00900   Operand(0, int64, storeval);
00901   Operand(1, int64, base);
00902   Operand(2, simm32, offset);
00903 
00904   Instruction_Group("prefetch",
00905         TOP_prefetch,
00906         TOP_prefetchw,
00907         TOP_prefetcht0,
00908         TOP_prefetcht1,
00909         TOP_prefetchnta,
00910         TOP_UNDEFINED);
00911   Operand(0, pfhint);
00912   Operand(1, int64, base);
00913   Operand(2, simm32, offset);
00914 
00915   Instruction_Group("prefetchx",
00916         TOP_prefetchx,
00917         TOP_prefetchwx,
00918         TOP_prefetcht0x,
00919         TOP_prefetcht1x,
00920         TOP_prefetchntax,
00921         TOP_UNDEFINED);
00922   Operand(0, pfhint);
00923   Operand(1, int64, base);
00924   Operand(2, simm32, offset);
00925   Operand(3, int64, index);
00926   Operand(4, uimm8, scale);
00927 
00928   Instruction_Group("prefetchxx",
00929         TOP_prefetchxx,
00930         TOP_prefetchwxx,
00931         TOP_prefetcht0xx,
00932         TOP_prefetcht1xx,
00933         TOP_prefetchntaxx,
00934         TOP_UNDEFINED);
00935   Operand(0, pfhint);
00936   Operand(1, int64, index);
00937   Operand(2, uimm8, scale);
00938   Operand(3, simm32, offset);
00939 
00940   Instruction_Group("int8_32 mov",
00941         TOP_movsbl,
00942         TOP_movzbl,
00943         TOP_UNDEFINED);
00944   Result(0, int32);
00945   Operand(0, int8, opnd1);
00946 
00947   Instruction_Group("int16_32 mov",
00948         TOP_movswl,
00949         TOP_movzwl,
00950         TOP_UNDEFINED);
00951   Result(0, int32);
00952   Operand(0, int16, opnd1);
00953 
00954   Instruction_Group("int8_64 mov",
00955         TOP_movsbq,
00956         TOP_movzbq,
00957         TOP_UNDEFINED);
00958   Result(0, int64);
00959   Operand(0, int8, opnd1);
00960 
00961   Instruction_Group("int16_64 mov",
00962         TOP_movswq,
00963         TOP_movzwq,
00964         TOP_UNDEFINED);
00965   Result(0, int64);
00966   Operand(0, int16, opnd1);
00967 
00968   Instruction_Group("int32_64 sign-ext mov",
00969         TOP_movslq,
00970         TOP_UNDEFINED);
00971   Result(0, int64);
00972   Operand(0, int32, opnd1);
00973 
00974   // Print the result as a 32-bit register even though the result is 64-bit,
00975   // since CG emits mov32 for movzlq.  mov32 expects a 32-bit result.
00976   Instruction_Group("int32_64 zero-ext mov",
00977         TOP_movzlq,
00978         TOP_UNDEFINED);
00979   Result(0, int32);
00980   Operand(0, int32, opnd1);
00981 
00982   Instruction_Group("int32 mov",
00983         TOP_mov32,
00984         TOP_UNDEFINED);
00985   Result(0, int32);
00986   Operand(0, int32, opnd1);
00987 
00988   Instruction_Group("int64 mov",
00989         TOP_mov64,
00990         TOP_UNDEFINED);
00991   Result(0, int64);
00992   Operand(0, int64, opnd1);
00993 
00994   Instruction_Group("int32 mult",
00995         TOP_imul32,
00996         TOP_UNDEFINED);
00997   Result(0, int32);
00998   Operand(0, int32, opnd1);
00999   Operand(1, int32, opnd2);
01000 
01001   Instruction_Group("int64 mult",
01002         TOP_imul64,
01003         TOP_UNDEFINED);
01004   Result(0, int64);
01005   Operand(0, int64, opnd1);
01006   Operand(1, int64, opnd2);
01007 
01008   Instruction_Group("int32 mult uses eax and edx registers",
01009         TOP_mul32,
01010         TOP_imulx32,
01011         TOP_UNDEFINED);
01012   Result(0, eax);
01013   Result(1, edx);
01014   Operand(0, eax, opnd1);
01015   Operand(1, int32, opnd2);
01016 
01017   Instruction_Group("int64 mult uses rax and rdx registers",
01018         TOP_imulx64,
01019         TOP_mulx64,
01020         TOP_UNDEFINED);
01021   Result(0, rax);
01022   Result(1, rdx);
01023   Operand(0, rax, opnd1);
01024   Operand(1, int64, opnd2);
01025 
01026   Instruction_Group("div32",
01027         TOP_div32,
01028         TOP_UNDEFINED);
01029   Result(0, eax);
01030   Result(1, edx);
01031   Operand(0, eax, opnd1);
01032   Operand(1, edx, opnd2);
01033   Operand(2, int32, opnd3);
01034 
01035   Instruction_Group("div64",
01036         TOP_div64,
01037         TOP_UNDEFINED);
01038   Result(0, rax);
01039   Result(1, rdx);
01040   Operand(0, rax, opnd1);
01041   Operand(1, rdx, opnd2);
01042   Operand(2, int64, opnd3);
01043 
01044   Instruction_Group("idiv32",
01045         TOP_idiv32,
01046         TOP_UNDEFINED);
01047   Result(0, eax);
01048   Result(1, edx);
01049   Operand(0, eax, opnd1);
01050   Operand(1, edx, opnd2);
01051   Operand(2, int32, opnd3);
01052 
01053   Instruction_Group("idiv64",
01054         TOP_idiv64,
01055         TOP_UNDEFINED);
01056   Result(0, rax);
01057   Result(1, rdx);
01058   Operand(0, rax, opnd1);
01059   Operand(1, rdx, opnd2);
01060   Operand(2, int64, opnd3);
01061 
01062   Instruction_Group("int8 set",
01063         TOP_setb,
01064         TOP_setae,
01065         TOP_setp,
01066         TOP_setnp,
01067         TOP_sete,
01068         TOP_setne,
01069         TOP_setbe,
01070         TOP_seta,
01071         TOP_setl,
01072         TOP_setge,
01073         TOP_setle,
01074         TOP_setg,
01075         TOP_UNDEFINED);
01076   Result(0, int8);
01077   Operand(0, rflags, opnd1);
01078 
01079   Instruction_Group("cond int mov",
01080         TOP_cmovb,
01081         TOP_cmovae,
01082         TOP_cmovp,
01083         TOP_cmovnp,
01084         TOP_cmove,
01085         TOP_cmovne,
01086         TOP_cmovbe,
01087         TOP_cmova,
01088         TOP_cmovl,
01089         TOP_cmovge,
01090         TOP_cmovle,
01091         TOP_cmovg,
01092         TOP_cmovs,
01093         TOP_cmovns,
01094         TOP_UNDEFINED);
01095   Result(0, int64);
01096   Operand(0, int64,  opnd1);
01097   Operand(1, rflags, opnd2);
01098 
01099   Instruction_Group("cond x87 mov",
01100         TOP_fcmovb,
01101         TOP_fcmovbe,
01102         TOP_fcmovnb,
01103         TOP_fcmovnbe,
01104         TOP_fcmove,
01105         TOP_fcmovne,
01106         TOP_fcmovu,
01107         TOP_fcmovnu,
01108         TOP_UNDEFINED);
01109   Result(0, x87);
01110   Operand(0, x87,  opnd1);
01111   Operand(1, rflags, opnd2);
01112 
01113   Instruction_Group("fp 2 fp",
01114         TOP_movsd,
01115         TOP_movss,
01116         TOP_cvtss2sd,
01117         TOP_cvtsd2ss,
01118         TOP_UNDEFINED);
01119   Result(0, fp64);
01120   Operand(0, fp64, opnd1);
01121 
01122   Instruction_Group("vector cvt",
01123         TOP_cvtdq2pd,
01124         TOP_cvtdq2ps,
01125         TOP_cvtps2pd,
01126         TOP_cvtpd2ps,
01127         TOP_UNDEFINED);
01128   Result(0, fp128);
01129   Operand(0, fp128, opnd1);
01130 
01131   Instruction_Group("vector cvt w/ trunc",
01132         TOP_cvtps2dq,
01133         TOP_cvttps2dq,
01134         TOP_cvtpd2dq,
01135         TOP_cvttpd2dq,
01136         TOP_UNDEFINED);
01137   Result(0, fp128);
01138   Operand(0, fp128, opnd1);
01139 
01140   Instruction_Group("vector cvt I",
01141         TOP_cvtdq2pd_x,
01142         TOP_cvtdq2ps_x,
01143         TOP_cvtps2pd_x,
01144         TOP_cvtpd2ps_x,
01145         TOP_UNDEFINED);
01146   Result(0, fp128);
01147   Operand(0, int64, base);
01148   Operand(1, simm32, offset);
01149 
01150   Instruction_Group("vector cvt w/ trunc I",
01151         TOP_cvtps2dq_x,
01152         TOP_cvttps2dq_x,
01153         TOP_cvttpd2dq_x,
01154         TOP_UNDEFINED);
01155   Result(0, fp128);
01156   Operand(0, int64, base);
01157   Operand(1, simm32, offset);
01158 
01159   Instruction_Group("vector cvt II",
01160         TOP_cvtdq2pd_xx,
01161         TOP_cvtdq2ps_xx,
01162         TOP_cvtps2pd_xx,
01163         TOP_cvtpd2ps_xx,
01164         TOP_UNDEFINED);
01165   Result(0, fp128);
01166   Operand(0, int64, base);
01167   Operand(1, int64, index);
01168   Operand(2, uimm8, scale);
01169   Operand(3, simm32, offset); 
01170 
01171   Instruction_Group("vector cvt w/ trunc II",
01172         TOP_cvtps2dq_xx,
01173         TOP_cvttps2dq_xx,
01174         TOP_cvttpd2dq_xx,
01175         TOP_UNDEFINED);
01176   Result(0, fp128);
01177   Operand(0, int64, base);
01178   Operand(1, int64, index);
01179   Operand(2, uimm8, scale);
01180   Operand(3, simm32, offset); 
01181 
01182   Instruction_Group("vector cvt III",
01183         TOP_cvtdq2pd_xxx,
01184         TOP_cvtdq2ps_xxx,
01185         TOP_cvtps2pd_xxx,
01186         TOP_cvtpd2ps_xxx,
01187         TOP_UNDEFINED);
01188   Result(0, fp128);
01189   Operand(0, int64, index);
01190   Operand(1, uimm8, scale);
01191   Operand(2, simm32, offset);
01192 
01193   Instruction_Group("vector cvt w/ trunc III",
01194         TOP_cvtps2dq_xxx,
01195         TOP_cvttps2dq_xxx,
01196         TOP_cvttpd2dq_xxx,
01197         TOP_UNDEFINED);
01198   Result(0, fp128);
01199   Operand(0, int64, index);
01200   Operand(1, uimm8, scale);
01201   Operand(2, simm32, offset);
01202 
01203   Instruction_Group("int32 2 float",
01204           TOP_movg2x,
01205         TOP_cvtsi2sd,
01206         TOP_cvtsi2ss,
01207         TOP_UNDEFINED);
01208   Result(0, fp64);
01209   Operand(0, int32, opnd1);
01210 
01211   Instruction_Group("int64 2 float",
01212           TOP_movg2x64,
01213         TOP_cvtsi2sdq,
01214         TOP_cvtsi2ssq,
01215         TOP_UNDEFINED);
01216   Result(0, fp64);
01217   Operand(0, int64, opnd1);
01218 
01219   Instruction_Group("fp 2 int32",
01220           TOP_movx2g,
01221         TOP_cvtss2si,
01222         TOP_cvtsd2si,
01223         TOP_cvttss2si,
01224         TOP_cvttsd2si,
01225         TOP_UNDEFINED);
01226   Result(0, int32);
01227   Operand(0, fp64, opnd1);
01228 
01229   Instruction_Group("fp 2 int64",
01230         TOP_movx2g64,
01231         TOP_cvtss2siq,
01232         TOP_cvtsd2siq,
01233         TOP_cvttss2siq,
01234         TOP_cvttsd2siq,
01235         TOP_UNDEFINED);
01236   Result(0, int64);
01237   Operand(0, fp64, opnd1);
01238 
01239   Instruction_Group("shifts8",
01240         TOP_rori8,
01241         TOP_roli8,
01242         TOP_UNDEFINED);
01243   Result(0, int8);
01244   Operand(0, int8, opnd1);
01245   Operand(1, uimm8, opnd2);
01246 
01247   Instruction_Group("shifts16",
01248         TOP_rori16,
01249         TOP_roli16,
01250         TOP_UNDEFINED);
01251   Result(0, int16);
01252   Operand(0, int16, opnd1);
01253   Operand(1, uimm8, opnd2);
01254 
01255   Instruction_Group("shifts32",
01256         TOP_sari32,
01257         TOP_shli32,
01258         TOP_shri32,
01259         TOP_rori32,
01260         TOP_roli32,
01261         TOP_UNDEFINED);
01262   Result(0, int32);
01263   Operand(0, int32, opnd1);
01264   Operand(1, uimm8, opnd2);
01265 
01266   Instruction_Group("shifts64",
01267         TOP_sari64,
01268         TOP_shli64,
01269         TOP_shri64,
01270         TOP_rori64,
01271         TOP_roli64,
01272         TOP_UNDEFINED);
01273   Result(0, int64);
01274   Operand(0, int64, opnd1);
01275   Operand(1, uimm8, opnd2);
01276 
01277   Instruction_Group("variable shifts32",
01278         TOP_sar32,
01279         TOP_shl32,
01280         TOP_shr32,
01281         TOP_ror8,
01282         TOP_ror16,
01283         TOP_ror32,
01284         TOP_rol8,
01285         TOP_rol16,
01286         TOP_rol32,
01287         TOP_UNDEFINED);
01288   Result(0, int32);
01289   Operand(0, int32, opnd1);
01290   Operand(1, cl,    opnd2);
01291 
01292   Instruction_Group("variable shift left double",
01293         TOP_shld32,
01294         TOP_shrd32,
01295         TOP_UNDEFINED);
01296   Result(0, int32);
01297   Operand(0, int32, opnd1);
01298   Operand(1, int32, opnd2);
01299   Operand(2, cl,    opnd3);
01300 
01301   Instruction_Group("shift left double",
01302         TOP_shldi32,
01303         TOP_shrdi32,
01304         TOP_UNDEFINED);
01305   Result(0, int32);
01306   Operand(0, int32, opnd1);
01307   Operand(1, int32, opnd2);
01308   Operand(2, uimm8, opnd3);
01309 
01310   Instruction_Group("variable shifts64",
01311         TOP_sar64,
01312         TOP_shl64,
01313         TOP_shr64,
01314         TOP_ror64,
01315         TOP_rol64,
01316         TOP_UNDEFINED);
01317   Result(0, int64);
01318   Operand(0, int64, opnd1);
01319   Operand(1, cl,    opnd2);
01320 
01321   Instruction_Group("sign32 extend",
01322         TOP_cltd,
01323         TOP_UNDEFINED);
01324   Result(0, eax);
01325   Result(1, edx);
01326   Operand(0, eax, opnd1);
01327 
01328 
01329   Instruction_Group("sign64 extend",
01330         TOP_cqto,
01331         TOP_UNDEFINED);
01332   Result(0, rax);
01333   Result(1, rdx);
01334   Operand(0, rax, opnd1);
01335 
01336   Instruction_Group("float load w/o base or index",
01337         TOP_ldsd_n32,
01338         TOP_ldss_n32,
01339         TOP_UNDEFINED);
01340   Result(0, fp64);
01341   Operand(0, simm32, offset);
01342 
01343   Instruction_Group("float load",
01344         TOP_ldsd,
01345         TOP_ldss,
01346         TOP_UNDEFINED);
01347   Result(0, fp64);
01348   Operand(0, int64, base);
01349   Operand(1, simm32, offset);
01350 
01351   Instruction_Group("float convert",
01352         TOP_cvtsd2ss_x,
01353         TOP_cvtsi2sd_x,
01354         TOP_cvtsi2ss_x,
01355         TOP_cvtsi2sdq_x,
01356         TOP_cvtsi2ssq_x,
01357         TOP_UNDEFINED);
01358   Result(0, fp64);
01359   Operand(0, int64, base);
01360   Operand(1, simm32, offset);
01361 
01362   Instruction_Group("x87-stack float load",
01363         TOP_fld,
01364         TOP_UNDEFINED);
01365   Operand(0, x87);
01366 
01367   Instruction_Group("x87 float load",
01368         TOP_flds,
01369         TOP_fldl,
01370         TOP_fldt,
01371         TOP_filds,
01372         TOP_fildl,
01373         TOP_fildll,
01374         TOP_UNDEFINED);
01375   Result(0, x87);
01376   Operand(0, int64, base);
01377   Operand(1, simm32, offset);
01378 
01379   Instruction_Group("x87 float load w/o index or base",
01380         TOP_flds_n32,
01381         TOP_fldl_n32,
01382         TOP_fldt_n32,
01383         TOP_UNDEFINED);
01384   Result(0, x87);
01385   Operand(0, simm32, offset);
01386 
01387   Instruction_Group("x87 control-word load",
01388         TOP_fldcw,
01389         TOP_UNDEFINED);
01390   Result(0, x87_cw);
01391   Operand(0, int64, base);
01392   Operand(1, simm32, offset);
01393 
01394   Instruction_Group("x87 control-word store",
01395         TOP_fnstcw,
01396         TOP_UNDEFINED);
01397   Operand(0, x87_cw, storeval);
01398   Operand(1, int64, base);
01399   Operand(2, simm32, offset);
01400 
01401   Instruction_Group("float load vector w/o base or index",
01402         TOP_lddqa_n32,
01403         TOP_lddqu_n32,
01404         TOP_ldapd_n32,
01405         TOP_ldupd_n32,
01406         TOP_ldaps_n32,
01407         TOP_ldups_n32,
01408         TOP_ldlps_n32,
01409         TOP_ldhps_n32,
01410         TOP_ldlpd_n32,
01411         TOP_ldhpd_n32,
01412         TOP_UNDEFINED);
01413   Result(0, fp128);
01414   Operand(0, simm32, offset);
01415 
01416   Instruction_Group("float load vector",
01417         TOP_lddqa,
01418         TOP_lddqu,
01419         TOP_ldhps,
01420         TOP_ldlps,
01421         TOP_ldhpd,
01422         TOP_ldlpd,
01423         TOP_ldapd,
01424         TOP_ldaps,
01425         TOP_ldupd,
01426         TOP_ldups,
01427         TOP_fmovsldupx,
01428         TOP_fmovshdupx,
01429         TOP_fmovddupx,
01430         TOP_UNDEFINED);
01431   Result(0, fp128);
01432   Operand(0, int64, base);
01433   Operand(1, simm32, offset);
01434 
01435   Instruction_Group("float store w/o base or index",
01436         TOP_stsd_n32,
01437         TOP_stss_n32,
01438         TOP_UNDEFINED);
01439   Operand(0, fp64, storeval);
01440   Operand(1, simm32, offset);
01441 
01442   Instruction_Group("float store",
01443         TOP_stsd,
01444         TOP_stntsd,
01445         TOP_stss,
01446         TOP_stntss,
01447         TOP_UNDEFINED);
01448   Operand(0, fp64, storeval);
01449   Operand(1, int64, base);
01450   Operand(2, simm32, offset);
01451 
01452   Instruction_Group("float store vector w/o base or index",
01453         TOP_stdqa_n32,
01454         TOP_stdqu_n32,
01455         TOP_stapd_n32,
01456         TOP_staps_n32,
01457         TOP_stlps_n32,
01458         TOP_sthps_n32,
01459         TOP_stlpd_n32,
01460         TOP_sthpd_n32,
01461         TOP_UNDEFINED);
01462   Operand(0, fp128, storeval);
01463   Operand(1, simm32, offset);
01464 
01465   Instruction_Group("float store vector",
01466         TOP_stdqa,
01467         TOP_stdqu,
01468         TOP_sthpd,
01469         TOP_stlpd,
01470         TOP_sthps,
01471         TOP_stlps,
01472         TOP_stapd,
01473         TOP_staps,
01474         TOP_stupd,
01475         TOP_stups,
01476         TOP_stntpd,
01477         TOP_stntps,
01478         TOP_storenti128,
01479         TOP_storelpd,
01480         TOP_UNDEFINED);
01481   Operand(0, fp128, storeval);
01482   Operand(1, int64, base);
01483   Operand(2, simm32, offset);
01484 
01485   Instruction_Group("x87 float store",
01486         TOP_fistps,
01487         TOP_fistpl,
01488         TOP_fistpll,
01489         TOP_fists,
01490         TOP_fistl,
01491         TOP_fisttps,
01492         TOP_fisttpl,
01493         TOP_fisttpll,
01494         TOP_UNDEFINED);
01495   Operand(0, x87, storeval);
01496   Operand(1, int64, base);
01497   Operand(2, simm32, offset);
01498 
01499   Instruction_Group("x87 store and pop",
01500         TOP_fst,
01501         TOP_fstp,
01502         TOP_UNDEFINED);
01503   Operand(0, x87, opnd1);
01504 
01505   Instruction_Group("x87 float store",
01506         TOP_fstps,
01507         TOP_fstpl,
01508         TOP_fstpt,
01509         TOP_fsts,
01510         TOP_fstl,
01511         TOP_UNDEFINED);
01512   Operand(0, x87, storeval);
01513   Operand(1, int64, base);
01514   Operand(2, simm32, offset);
01515 
01516   Instruction_Group("x87 float store w/o base or index",
01517         TOP_fstps_n32,
01518         TOP_fstpl_n32,
01519         TOP_fstpt_n32,
01520         TOP_fsts_n32,
01521         TOP_fstl_n32,
01522         TOP_UNDEFINED);
01523   Operand(0, x87, storeval);
01524   Operand(1, simm32, offset);
01525 
01526   Instruction_Group("unpack",
01527         TOP_unpckhps,
01528         TOP_unpcklps,
01529         TOP_unpckhpd,
01530         TOP_unpcklpd,
01531         TOP_punpcklbw,
01532         TOP_punpcklwd,
01533         TOP_punpckldq,
01534         TOP_UNDEFINED);
01535   Result(0, fp128);
01536   Operand(0, fp128, opnd1);
01537   Operand(1, fp128, opnd2);
01538 
01539   Instruction_Group("shuffle",
01540         TOP_shufps,
01541         TOP_shufpd,
01542         TOP_UNDEFINED);
01543   Result(0, fp128);
01544   Operand(0, fp128, opnd1);
01545   Operand(1, fp128, opnd2);
01546   Operand(2, uimm8, opnd3);
01547 
01548   Instruction_Group("shuffle-int",
01549         TOP_pshufd,
01550         TOP_pshufw,
01551         TOP_pshuflw,
01552         TOP_pshufhw,
01553         TOP_UNDEFINED);
01554   Result(0, fp128);
01555   Operand(0, fp128, opnd1);
01556   Operand(1, uimm8, opnd3);
01557 
01558   Instruction_Group("move-high-low",
01559         TOP_movlhps,
01560         TOP_movhlps,
01561         TOP_UNDEFINED);
01562   Result(0, fp128);
01563   Operand(0, fp128, opnd1);
01564 
01565   Instruction_Group("packed shifts w/ immediate",
01566         TOP_psrldq,
01567         TOP_psrlq128v64, // psrlq with immediate
01568         TOP_pslldq,
01569         TOP_UNDEFINED);
01570   Result(0, fp128);
01571   Operand(0, fp128, opnd1);
01572   Operand(1, simm8, opnd2);
01573 
01574   Instruction_Group("packed shifts",
01575         TOP_psllw,
01576         TOP_pslld,
01577         TOP_psllq,
01578         TOP_psrlw,
01579         TOP_psrld,
01580         TOP_psrlq,
01581         TOP_psraw,
01582         TOP_psrad,
01583         TOP_UNDEFINED);
01584   Result(0, fp128);
01585   Operand(0, fp128, opnd1);
01586   Operand(1, fp128, opnd2);
01587 
01588   Instruction_Group("float load indexed",
01589         TOP_UNDEFINED);
01590   Result(0, fp64);
01591   Operand(0, int64, base);
01592   Operand(1, int64);
01593 
01594   Instruction_Group("float store indexed",
01595         TOP_UNDEFINED);
01596   Operand(0, fp64, storeval);
01597   Operand(1, int64, base);
01598   Operand(2, int64);
01599 
01600   Instruction_Group("float arithmetic",
01601         TOP_andnps,
01602         TOP_andnpd,
01603         TOP_addsd,
01604         TOP_addss,
01605         TOP_divsd,
01606         TOP_divss,
01607         TOP_subsd,
01608         TOP_subss,
01609         TOP_maxsd,
01610         TOP_maxss,
01611         TOP_minsd,
01612         TOP_minss,
01613         TOP_mulsd,
01614         TOP_mulss,
01615         TOP_UNDEFINED);
01616   Result(0, fp64);
01617   Operand(0, fp64, opnd1);
01618   Operand(1, fp64, opnd2);
01619 
01620   Instruction_Group("x87 float exchange",
01621         TOP_fxch,
01622         TOP_UNDEFINED);
01623   Operand(0, x87, opnd1);
01624 
01625   Instruction_Group("x87 float arithmetic",
01626         TOP_fadd,
01627         TOP_faddp,
01628         TOP_fsub,
01629         TOP_fsubp,
01630         TOP_fsubr,
01631         TOP_fsubrp,
01632         TOP_fmul,
01633         TOP_fmulp,
01634         TOP_fdiv,
01635         TOP_fdivp,
01636         TOP_fdivr,
01637         TOP_fdivrp,
01638         TOP_UNDEFINED);
01639   Result( 0, x87 );
01640   Operand(0, x87, opnd1);
01641   Operand(1, x87, opnd2);
01642 
01643   Instruction_Group("float arithmetic mem operand",
01644         TOP_divxss,
01645         TOP_divxsd,
01646         TOP_addxss,
01647         TOP_addxsd,
01648         TOP_subxss,
01649         TOP_subxsd,
01650         TOP_mulxss,
01651         TOP_mulxsd,
01652         TOP_UNDEFINED);
01653   Result(0, fp64);
01654   Operand(0, fp64, opnd1);
01655   Operand(1, int64, base);
01656   Operand(2, simm32, offset);
01657 
01658   Instruction_Group("float arithmetic mem operand w/ scaled-index",
01659         TOP_divxxss,
01660         TOP_divxxsd,
01661         TOP_addxxss,
01662         TOP_addxxsd,
01663         TOP_subxxss,
01664         TOP_subxxsd,
01665         TOP_mulxxsd,
01666         TOP_mulxxss,
01667         TOP_UNDEFINED);
01668   Result(0, fp64);
01669   Operand(0, fp64, opnd1);
01670   Operand(1, int64, base);
01671   Operand(2, int64, index);
01672   Operand(3, uimm8, scale);
01673   Operand(4, simm32, offset);
01674 
01675   Instruction_Group("float arithmetic mem operand w/ scaled-index w/o base",
01676         TOP_divxxxss,
01677         TOP_divxxxsd,
01678         TOP_addxxxss,
01679         TOP_addxxxsd,
01680         TOP_subxxxss,
01681         TOP_subxxxsd,
01682         TOP_mulxxxsd,
01683         TOP_mulxxxss,
01684         TOP_UNDEFINED);
01685   Result(0, fp64);
01686   Operand(0, fp64, opnd1);
01687   Operand(1, int64, index);
01688   Operand(2, uimm8, scale);
01689   Operand(3, simm32, offset);
01690 
01691   Instruction_Group("float unary arithmetic",
01692         TOP_sqrtsd,
01693         TOP_sqrtss,
01694         TOP_rsqrtss,
01695         TOP_rcpss,
01696         TOP_UNDEFINED);
01697   Result(0, fp64);
01698   Operand(0, fp64, opnd1);
01699 
01700   Instruction_Group("float unary arithmetic extended",
01701         TOP_frsqrt128v32,
01702         TOP_frcp128v32,
01703         TOP_fsqrt128v32,
01704         TOP_fsqrt128v64,
01705         TOP_UNDEFINED);
01706   Result(0, fp128);
01707   Operand(0, fp128, opnd1);
01708 
01709   Instruction_Group("xmm to xmm",
01710         TOP_movdq,
01711         TOP_movapd,
01712         TOP_movaps,
01713         TOP_fmovsldup,
01714         TOP_fmovshdup,
01715         TOP_fmovddup,
01716         TOP_UNDEFINED);
01717   Result(0, fp128);
01718   Operand(0, fp128, opnd1);
01719 
01720   Instruction_Group("x87 load const",
01721         TOP_fldz,
01722         TOP_UNDEFINED);
01723   Result( 0, x87 );
01724 
01725   Instruction_Group("x87 to x87",
01726         TOP_fmov,
01727         TOP_fabs,
01728         TOP_fsqrt,
01729         TOP_fchs,
01730         TOP_frndint,
01731         TOP_fcos,
01732         TOP_fsin,
01733         TOP_UNDEFINED);
01734   Result(0, x87);
01735   Operand(0, x87, opnd1);
01736 
01737   Instruction_Group("float madd",
01738         TOP_UNDEFINED);
01739   Result(0, fp64);
01740   Operand(0, fp64, opnd1);
01741   Operand(1, fp64, opnd2);
01742   Operand(2, fp64, maddend);
01743 
01744   Instruction_Group("conditional jump",
01745         TOP_jb,
01746         TOP_jae,
01747         TOP_je,
01748         TOP_jne,
01749         TOP_jbe,
01750         TOP_ja,
01751         TOP_jge,
01752         TOP_jl,
01753         TOP_jle,
01754         TOP_jg,
01755         TOP_jcxz,
01756         TOP_jecxz,
01757         TOP_jrcxz,
01758         TOP_jp,
01759         TOP_jnp,
01760         TOP_js,
01761         TOP_jns,
01762         TOP_UNDEFINED);
01763   Operand(0, rflags,  opnd1);
01764   Operand(1, pcrel32, target);
01765 
01766   Instruction_Group("pop32",
01767         TOP_popl,
01768         TOP_UNDEFINED);
01769   Result(0, int32);
01770   Result(1, esp);
01771   Operand(0, int32, opnd1);
01772 
01773   Instruction_Group("pop64",
01774         TOP_popq,
01775         TOP_UNDEFINED);
01776   Result(0, int64);
01777   Result(1, rsp);
01778   Operand(0, int64, opnd1);
01779 
01780   Instruction_Group("push32",
01781         TOP_pushl,
01782         TOP_UNDEFINED);
01783   Result(0, esp);
01784   Operand(0, int32, opnd1);
01785   Operand(1, int32, opnd1);
01786 
01787   Instruction_Group("push64",
01788         TOP_pushq,
01789         TOP_UNDEFINED);
01790   Result(0, rsp);
01791   Operand(0, int64, opnd1);
01792   Operand(1, int64, opnd1);
01793 
01794   Instruction_Group("int8 compare/test with simm",
01795         TOP_cmpi8,
01796         TOP_UNDEFINED);
01797   Result(0,  eflags);
01798   Operand(0, int8,  opnd1);
01799   Operand(1, simm32, opnd2);
01800 
01801   Instruction_Group("int16 compare/test with simm",
01802         TOP_cmpi16,
01803         TOP_UNDEFINED);
01804   Result(0,  eflags);
01805   Operand(0, int16,  opnd1);
01806   Operand(1, simm32, opnd2);
01807 
01808   Instruction_Group("int32 compare/test with simm",
01809         TOP_testi32,
01810         TOP_cmpi32,
01811         TOP_UNDEFINED);
01812   Result(0,  eflags);
01813   Operand(0, int32,  opnd1);
01814   Operand(1, simm32, opnd2);
01815 
01816   Instruction_Group("int64 compare/test with simm",
01817         TOP_testi64,
01818         TOP_cmpi64,
01819         TOP_UNDEFINED);
01820   Result(0, rflags);
01821   Operand(0, int64,  opnd1);
01822   Operand(1, simm32, opnd2);
01823 
01824   Instruction_Group("int compare/test with simm and mem opnd",
01825         TOP_cmpxi8,
01826         TOP_cmpxi16,
01827         TOP_cmpxi32,
01828         TOP_UNDEFINED );
01829   Result(0,  eflags);
01830   Operand(0, int64, base);
01831   Operand(1, simm32, offset);
01832   Operand(2, simm32, opnd2);
01833 
01834   Instruction_Group("int64 compare/test with simm and mem opnd",
01835         TOP_cmpxi64,
01836         TOP_UNDEFINED );
01837   Result(0,  rflags);
01838   Operand(0, int64, base);
01839   Operand(1, simm32, offset);
01840   Operand(2, simm32, opnd2);
01841 
01842   Instruction_Group("int compare/test with simm and mem opnd scaled-index",
01843         TOP_cmpxxi8,
01844         TOP_cmpxxi16,
01845         TOP_cmpxxi32,
01846         TOP_UNDEFINED );
01847   Result(0,  eflags);
01848   Operand(0, int64, base);
01849   Operand(1, int64, index);
01850   Operand(2, uimm8, scale);
01851   Operand(3, simm32, offset);
01852   Operand(4, simm32, opnd2);
01853 
01854   Instruction_Group("int64 compare/test with simm and mem opnd scaled-index",
01855         TOP_cmpxxi64,
01856         TOP_UNDEFINED );
01857   Result(0,  rflags);
01858   Operand(0, int64, base);
01859   Operand(1, int64, index);
01860   Operand(2, uimm8, scale);
01861   Operand(3, simm32, offset);
01862   Operand(4, simm32, opnd2);
01863 
01864   Instruction_Group("int compare/test with simm and mem opnd scaled-index w/o base",
01865         TOP_cmpxxxi8,
01866         TOP_cmpxxxi16,
01867         TOP_cmpxxxi32,
01868         TOP_UNDEFINED );
01869   Result(0,  eflags);
01870   Operand(0, int64, index);
01871   Operand(1, uimm8, scale);
01872   Operand(2, simm32, offset);
01873   Operand(3, simm32, opnd2);
01874 
01875   Instruction_Group("int64 compare/test with simm and mem opnd scaled-index w/o base",
01876         TOP_cmpxxxi64,
01877         TOP_UNDEFINED );
01878   Result(0,  rflags);
01879   Operand(0, int64, index);
01880   Operand(1, uimm8, scale);
01881   Operand(2, simm32, offset);
01882   Operand(3, simm32, opnd2);
01883 
01884   Instruction_Group("int8 compare/test",
01885           TOP_cmp8,
01886         TOP_UNDEFINED);
01887   Result(0,  eflags);
01888   Operand(0, int8, opnd1);
01889   Operand(1, int8, opnd2);
01890 
01891   Instruction_Group("int16 compare/test",
01892         TOP_cmp16,
01893         TOP_UNDEFINED);
01894   Result(0,  eflags);
01895   Operand(0, int16, opnd1);
01896   Operand(1, int16, opnd2);
01897 
01898   Instruction_Group("int32 compare/test",
01899         TOP_cmp32,
01900         TOP_test32,
01901         TOP_UNDEFINED);
01902   Result(0,  eflags);
01903   Operand(0, int32, opnd1);
01904   Operand(1, int32, opnd2);
01905 
01906   Instruction_Group("int64 compare/test",
01907         TOP_cmp64,
01908         TOP_test64,
01909         TOP_UNDEFINED);
01910   Result(0,  rflags);
01911   Operand(0, int64, opnd1);
01912   Operand(1, int64, opnd2);
01913 
01914    Instruction_Group("int8 compare/test mem opnd",
01915           TOP_cmpx8,
01916         TOP_UNDEFINED);
01917   Result(0,  eflags);
01918   Operand(0, int8, opnd1);
01919   Operand(1, int64, base);
01920   Operand(2, simm32, offset);
01921 
01922   Instruction_Group("int16 compare/test mem opnd",
01923         TOP_cmpx16,
01924         TOP_UNDEFINED);
01925   Result(0,  eflags);
01926   Operand(0, int16, opnd1);
01927   Operand(1, int64, base);
01928   Operand(2, simm32, offset);
01929 
01930   Instruction_Group("int32 compare/test mem opnd",
01931         TOP_cmpx32,
01932         TOP_testx32,
01933         TOP_UNDEFINED);
01934   Result(0,  eflags);
01935   Operand(0, int32, opnd1);
01936   Operand(1, int64, base);
01937   Operand(2, simm32, offset);
01938 
01939   Instruction_Group("int64 compare/test mem opnd",
01940         TOP_cmpx64,
01941         TOP_testx64,
01942         TOP_UNDEFINED);
01943   Result(0, rflags);
01944   Operand(0, int64, opnd1);
01945   Operand(1, int64, base);
01946   Operand(2, simm32, offset);
01947 
01948   Instruction_Group("int8 compare/test mem opnd w/ scaled-index",
01949           TOP_cmpxx8,
01950         TOP_UNDEFINED);
01951   Result(0,  eflags);
01952   Operand(0, int8, opnd1);
01953   Operand(1, int64, base);
01954   Operand(2, int64, index);
01955   Operand(3, uimm8, scale);
01956   Operand(4, simm32, offset);
01957 
01958   Instruction_Group("int16 compare/test mem opnd w/ scaled-index",
01959         TOP_cmpxx16,
01960         TOP_UNDEFINED);
01961   Result(0,  eflags);
01962   Operand(0, int16, opnd1);
01963   Operand(1, int64, base);
01964   Operand(2, int64, index);
01965   Operand(3, uimm8, scale);
01966   Operand(4, simm32, offset);
01967 
01968   Instruction_Group("int32 compare/test mem opnd w/ scaled-index",
01969         TOP_cmpxx32,
01970         TOP_testxx32,
01971         TOP_UNDEFINED);
01972   Result(0,  eflags);
01973   Operand(0, int32, opnd1);
01974   Operand(1, int64, base);
01975   Operand(2, int64, index);
01976   Operand(3, uimm8, scale);
01977   Operand(4, simm32, offset);
01978 
01979   Instruction_Group("int64 compare/test mem opnd w/ scaled-index",
01980         TOP_cmpxx64,
01981         TOP_testxx64,
01982         TOP_UNDEFINED);
01983   Result(0, rflags);
01984   Operand(0, int64, opnd1);
01985   Operand(1, int64, base);
01986   Operand(2, int64, index);
01987   Operand(3, uimm8, scale);
01988   Operand(4, simm32, offset);
01989 
01990   Instruction_Group("int8 compare/test mem opnd w/ scaled-index w/o base",
01991           TOP_cmpxxx8,
01992         TOP_UNDEFINED);
01993   Result(0,  eflags);
01994   Operand(0, int8, opnd1);
01995   Operand(1, int64, index);
01996   Operand(2, uimm8, scale);
01997   Operand(3, simm32, offset);
01998 
01999   Instruction_Group("int16 compare/test mem opnd w/ scaled-index w/o base",
02000         TOP_cmpxxx16,
02001         TOP_UNDEFINED);
02002   Result(0,  eflags);
02003   Operand(0, int16, opnd1);
02004   Operand(1, int64, index);
02005   Operand(2, uimm8, scale);
02006   Operand(3, simm32, offset);
02007 
02008   Instruction_Group("int32 compare/test mem opnd w/ scaled-index w/o base",
02009         TOP_cmpxxx32,
02010         TOP_testxxx32,
02011         TOP_UNDEFINED);
02012   Result(0,  eflags);
02013   Operand(0, int32, opnd1);
02014   Operand(1, int64, index);
02015   Operand(2, uimm8, scale);
02016   Operand(3, simm32, offset);
02017 
02018   Instruction_Group("int64 compare/test mem opnd w/ scaled-index w/o base",
02019         TOP_cmpxxx64,
02020         TOP_testxxx64,
02021         TOP_UNDEFINED);
02022   Result(0, rflags);
02023   Operand(0, int64, opnd1);
02024   Operand(1, int64, index);
02025   Operand(2, uimm8, scale);
02026   Operand(3, simm32, offset);
02027 
02028   Instruction_Group("fp ordered compare",
02029         TOP_comisd,
02030         TOP_comiss,
02031         TOP_UNDEFINED);
02032   Result(0, rflags);
02033   Operand(0, fp64, opnd1);
02034   Operand(1, fp64, opnd2);
02035 
02036   Instruction_Group("fp ordered compare mem opnd",
02037         TOP_comixsd,
02038         TOP_comixss,
02039         TOP_UNDEFINED);
02040   Result(0, rflags);
02041   Operand(0, fp64, opnd1);
02042   Operand(1, int64, base);
02043   Operand(2, simm32, offset);
02044 
02045   Instruction_Group("fp ordered compare mem opnd w/ scaled-index",
02046         TOP_comixxsd,
02047         TOP_comixxss,
02048         TOP_UNDEFINED);
02049   Result(0, rflags);
02050   Operand(0, fp64, opnd1);
02051   Operand(1, int64, base);
02052   Operand(2, int64, index);
02053   Operand(3, uimm8, scale);
02054   Operand(4, simm32, offset);
02055 
02056   Instruction_Group("fp ordered compare mem opnd w/ scaled-index w/o base",
02057         TOP_comixxxsd,
02058         TOP_comixxxss,
02059         TOP_UNDEFINED);
02060   Result(0, rflags);
02061   Operand(0, fp64, opnd1);
02062   Operand(1, int64, index);
02063   Operand(2, uimm8, scale);
02064   Operand(3, simm32, offset);
02065 
02066   Instruction_Group("x87 fp compare",
02067         TOP_fucomi,
02068         TOP_fucomip,
02069         TOP_UNDEFINED);
02070   Result(0, rflags);
02071   Operand(0, x87,  opnd1);
02072   Operand(1, x87,  opnd2);
02073 
02074   Instruction_Group("fp compare",
02075         TOP_cmpss,
02076         TOP_cmpsd,
02077         TOP_UNDEFINED);
02078   Result(0, fp64);
02079   Operand(0, fp64,  opnd1);
02080   Operand(1, fp64,  opnd2);
02081   Operand(2, simm8, opnd3);
02082 
02083   Instruction_Group("fp compare I",
02084         TOP_cmpeqss,
02085         TOP_cmpltss,
02086         TOP_cmpless,
02087         TOP_cmpunordss,
02088         TOP_cmpneqss,
02089         TOP_cmpnltss,
02090         TOP_cmpnless,
02091         TOP_cmpordss,
02092         TOP_UNDEFINED);
02093   Result(0, fp64);
02094   Operand(0, fp64,  opnd1);
02095   Operand(1, fp64,  opnd2);
02096 
02097   Instruction_Group("fp vector compare",
02098         TOP_cmpps,
02099         TOP_cmppd,
02100         TOP_UNDEFINED);
02101   Result(0, fp128);
02102   Operand(0, fp128,  opnd1);
02103   Operand(1, fp128,  opnd2);
02104   Operand(2, simm8, opnd3);
02105 
02106   Instruction_Group("fp vector compare I",
02107         TOP_cmpeqps,
02108         TOP_cmpltps,
02109         TOP_cmpleps,
02110         TOP_cmpunordps,
02111         TOP_cmpneqps,
02112         TOP_cmpnltps,
02113         TOP_cmpnleps,
02114         TOP_cmpordps,
02115         TOP_UNDEFINED);
02116   Result(0, fp128);
02117   Operand(0, fp128,  opnd1);
02118   Operand(1, fp128,  opnd2);
02119 
02120   Instruction_Group("load32 effective addr",
02121         TOP_lea32,
02122         TOP_UNDEFINED);
02123   Result(0, int32);
02124   Operand(0, int64, base);
02125   Operand(1, simm32, offset);
02126 
02127   Instruction_Group("load64 effective addr",
02128         TOP_lea64,
02129         TOP_UNDEFINED);
02130   Result(0, int64);
02131   Operand(0, int64, base);
02132   Operand(1, simm32, offset);
02133 
02134   Instruction_Group("load32 effective addr w/ indx",
02135         TOP_leax32,
02136         TOP_UNDEFINED);
02137   Result(0, int32);
02138   Operand(0, int64, base);
02139   Operand(1, int64, index);
02140   Operand(2, uimm8, scale);
02141   Operand(3, simm32, offset);
02142 
02143   Instruction_Group("load64 effective addr w/ indx",
02144         TOP_leax64,
02145         TOP_UNDEFINED);
02146   Result(0, int64);
02147   Operand(0, int64, base);
02148   Operand(1, int64, index);
02149   Operand(2, uimm8, scale);
02150   Operand(3, simm32, offset);
02151 
02152   Instruction_Group("load32 effective addr w/ indx w/o base",
02153         TOP_leaxx32,
02154         TOP_UNDEFINED);
02155   Result(0, int32);
02156   Operand(0, int64, index);
02157   Operand(1, uimm8, scale);
02158   Operand(2, simm32, offset);
02159 
02160   Instruction_Group("load64 effective addr w/ indx w/o base",
02161         TOP_leaxx64,
02162         TOP_UNDEFINED);
02163   Result(0, int64);
02164   Operand(0, int64, index);
02165   Operand(1, uimm8, scale);
02166   Operand(2, simm32, offset);
02167 
02168   Instruction_Group("int32 load w/ indx",
02169         TOP_ldx32,
02170         TOP_ldx8_32,
02171         TOP_ldxu8_32,
02172         TOP_ldx16_32,
02173         TOP_ldxu16_32,
02174         TOP_UNDEFINED);
02175   Result(0, int32);
02176   Operand(0, int64, base);
02177   Operand(1, simm32, offset);
02178   Operand(2, int64, index);
02179   Operand(3, uimm8, scale);
02180 
02181   Instruction_Group("int64 load w/ indx",
02182         TOP_ldx64,
02183         TOP_ldx8_64,
02184         TOP_ldxu8_64,
02185         TOP_ldx16_64,
02186         TOP_ldxu16_64,
02187         TOP_ldx32_64,
02188         TOP_UNDEFINED);
02189   Result(0, int64);
02190   Operand(0, int64, base);
02191   Operand(1, simm32, offset);
02192   Operand(2, int64, index);
02193   Operand(3, uimm8, scale);
02194 
02195   Instruction_Group("int32 load w/ indx w/o base",
02196         TOP_ldxx32,
02197         TOP_ldxx8_32,
02198         TOP_ldxxu8_32,
02199         TOP_ldxx16_32,
02200         TOP_ldxxu16_32,
02201         TOP_UNDEFINED);
02202   Result(0, int32);
02203   Operand(0, int64, index);
02204   Operand(1, uimm8, scale);
02205   Operand(2, simm32, offset);
02206 
02207   Instruction_Group("int64 load w/ indx w/o base",
02208         TOP_ldxx64,
02209         TOP_ldxx8_64,
02210         TOP_ldxxu8_64,
02211         TOP_ldxx16_64,
02212         TOP_ldxxu16_64,
02213         TOP_ldxx32_64,
02214         TOP_UNDEFINED);
02215   Result(0, int64);
02216   Operand(0, int64, index);
02217   Operand(1, uimm8, scale);
02218   Operand(2, simm32, offset);
02219 
02220   Instruction_Group("int8 store w/ indx",
02221         TOP_storex8,
02222         TOP_UNDEFINED);
02223   Operand(0, int8, storeval);
02224   Operand(1, int64, base);
02225   Operand(2, simm32, offset);
02226   Operand(3, int64, index);
02227   Operand(4, uimm8, scale);
02228 
02229   Instruction_Group("int16 store w/ indx",
02230         TOP_storex16,
02231         TOP_UNDEFINED);
02232   Operand(0, int16, storeval);
02233   Operand(1, int64, base);
02234   Operand(2, simm32, offset);
02235   Operand(3, int64, index);
02236   Operand(4, uimm8, scale);
02237 
02238   Instruction_Group("int32 store w/ indx",
02239         TOP_storex32,
02240         TOP_storentix32,
02241         TOP_UNDEFINED);
02242   Operand(0, int32, storeval);
02243   Operand(1, int64, base);
02244   Operand(2, simm32, offset);
02245   Operand(3, int64, index);
02246   Operand(4, uimm8, scale);
02247 
02248   Instruction_Group("int64 store w/ indx",
02249         TOP_storex64,
02250         TOP_storentix64,
02251         TOP_UNDEFINED);
02252   Operand(0, int64, storeval);
02253   Operand(1, int64, base);
02254   Operand(2, simm32, offset);
02255   Operand(3, int64, index);
02256   Operand(4, uimm8, scale);
02257 
02258   Instruction_Group("int8 store w/ indx w/o base",
02259         TOP_storexx8,
02260         TOP_UNDEFINED);
02261   Operand(0, int8, storeval);
02262   Operand(1, int64, index);
02263   Operand(2, uimm8, scale);
02264   Operand(3, simm32, offset);
02265 
02266   Instruction_Group("int16 store w/ indx w/o base",
02267         TOP_storexx16,
02268         TOP_UNDEFINED);
02269   Operand(0, int16, storeval);
02270   Operand(1, int64, index);
02271   Operand(2, uimm8, scale);
02272   Operand(3, simm32, offset);
02273 
02274   Instruction_Group("int32 store w/ indx w/o base",
02275         TOP_storexx32,
02276         TOP_storentixx32,
02277         TOP_UNDEFINED);
02278   Operand(0, int32, storeval);
02279   Operand(1, int64, index);
02280   Operand(2, uimm8, scale);
02281   Operand(3, simm32, offset);
02282 
02283   Instruction_Group("int64 store w/ indx w/o base",
02284         TOP_storexx64,
02285         TOP_storentixx64,
02286         TOP_UNDEFINED);
02287   Operand(0, int64, storeval);
02288   Operand(1, int64, index);
02289   Operand(2, uimm8, scale);
02290   Operand(3, simm32, offset);
02291 
02292   Instruction_Group("fp load w/ indx",
02293         TOP_ldssx,
02294         TOP_ldsdx,
02295         TOP_UNDEFINED);
02296   Result(0,  fp64);
02297   Operand(0, int64, base);
02298   Operand(1, simm32, offset);
02299   Operand(2, int64, index);
02300   Operand(3, uimm8, scale);
02301 
02302   Instruction_Group("fp convert w/ indx",
02303         TOP_cvtsd2ss_xx,
02304         TOP_cvtsi2sd_xx,
02305         TOP_cvtsi2ss_xx,
02306         TOP_cvtsi2sdq_xx,
02307         TOP_cvtsi2ssq_xx,
02308         TOP_UNDEFINED);
02309   Result(0,  fp64);
02310   Operand(0, int64, base);
02311   Operand(1, int64, index);
02312   Operand(2, uimm8, scale);
02313   Operand(3, simm32, offset);
02314 
02315   Instruction_Group("fp load vector w/ indx",
02316         TOP_lddqax,
02317         TOP_lddqux,
02318         TOP_ldhpsx,
02319         TOP_ldlpsx,
02320         TOP_ldhpdx,
02321         TOP_ldlpdx,
02322         TOP_ldapdx,
02323         TOP_ldapsx,
02324         TOP_fmovsldupxx,
02325         TOP_fmovshdupxx,
02326         TOP_fmovddupxx,
02327         TOP_UNDEFINED);
02328   Result(0,  fp128);
02329   Operand(0, int64, base);
02330   Operand(1, simm32, offset);
02331   Operand(2, int64, index);
02332   Operand(3, uimm8, scale);
02333 
02334   Instruction_Group("fp load w/ indx w/o base",
02335         TOP_ldssxx,
02336         TOP_ldsdxx,
02337         TOP_UNDEFINED);
02338   Result(0,  fp64);
02339   Operand(0, int64, index);
02340   Operand(1, uimm8, scale);
02341   Operand(2, simm32, offset);
02342 
02343   Instruction_Group("fp convert w/ indx w/o base",
02344         TOP_cvtsd2ss_xxx,
02345         TOP_cvtsi2sd_xxx,
02346         TOP_cvtsi2ss_xxx,
02347         TOP_cvtsi2sdq_xxx,
02348         TOP_cvtsi2ssq_xxx,
02349         TOP_UNDEFINED);
02350   Result(0,  fp64);
02351   Operand(0, int64, index);
02352   Operand(1, uimm8, scale);
02353   Operand(2, simm32, offset);
02354 
02355   Instruction_Group("fp load vector w/ indx w/o base",
02356         TOP_lddqaxx,
02357         TOP_lddquxx,
02358         TOP_ldhpsxx,
02359         TOP_ldlpsxx,
02360         TOP_ldhpdxx,
02361         TOP_ldlpdxx,
02362         TOP_ldapdxx,
02363         TOP_ldapsxx,
02364         TOP_fmovsldupxxx,
02365         TOP_fmovshdupxxx,
02366         TOP_fmovddupxxx,
02367         TOP_UNDEFINED);
02368   Result(0,  fp128);
02369   Operand(0, int64, index);
02370   Operand(1, uimm8, scale);
02371   Operand(2, simm32, offset);
02372 
02373   Instruction_Group("fp store w/ indx",
02374         TOP_stssx,
02375         TOP_stntssx,
02376         TOP_stsdx,
02377         TOP_stntsdx,
02378         TOP_UNDEFINED);
02379   Operand(0, fp64, storeval);
02380   Operand(1, int64, base);
02381   Operand(2, simm32, offset);
02382   Operand(3, int64, index);
02383   Operand(4, uimm8, scale);
02384 
02385   Instruction_Group("fp store vector w/ indx",
02386         TOP_stdqax,
02387         TOP_stdqux,
02388         TOP_sthpdx,
02389         TOP_stlpdx,
02390         TOP_sthpsx,
02391         TOP_stlpsx,
02392         TOP_stapsx,
02393         TOP_stapdx,
02394         TOP_stntpdx,
02395         TOP_stntpsx,
02396         TOP_UNDEFINED);
02397   Operand(0, fp128, storeval);
02398   Operand(1, int64, base);
02399   Operand(2, simm32, offset);
02400   Operand(3, int64, index);
02401   Operand(4, uimm8, scale);
02402 
02403   Instruction_Group("fp store w/ indx w/o base",
02404         TOP_stssxx,
02405         TOP_stntssxx,
02406         TOP_stsdxx,
02407         TOP_stntsdxx,
02408         TOP_UNDEFINED);
02409   Operand(0, fp64, storeval);
02410   Operand(1, int64, index);
02411   Operand(2, uimm8, scale);
02412   Operand(3, simm32, offset);
02413 
02414   Instruction_Group("fp store vector w/ indx w/o base",
02415         TOP_stdqaxx,
02416         TOP_stdquxx,
02417         TOP_sthpdxx,
02418         TOP_stlpdxx,
02419         TOP_sthpsxx,
02420         TOP_stlpsxx,
02421         TOP_stapsxx,
02422         TOP_stapdxx,
02423         TOP_stntpdxx,
02424         TOP_stntpsxx,
02425         TOP_UNDEFINED);
02426   Operand(0, fp128, storeval);
02427   Operand(1, int64, index);
02428   Operand(2, uimm8, scale);
02429   Operand(3, simm32, offset);
02430 
02431   Instruction_Group("jump",
02432         TOP_jmp,
02433         TOP_call,
02434         TOP_UNDEFINED);
02435   Operand(0, pcrel32, target);
02436 
02437   Instruction_Group("jump register",
02438         TOP_ijmp,
02439         TOP_icall,
02440         TOP_UNDEFINED);
02441   Operand(0, int64, target);
02442 
02443 
02444   Instruction_Group("jump mem",
02445         TOP_ijmpx,
02446         TOP_icallx,
02447         TOP_stmxcsr,
02448         TOP_ldmxcsr,
02449         TOP_UNDEFINED);
02450   Operand(0, int64, base);
02451   Operand(1, simm32, offset);
02452 
02453   Instruction_Group("jump mem w/ scaled index",
02454         TOP_ijmpxx,
02455         TOP_icallxx,
02456         TOP_UNDEFINED);
02457   Operand(0, int64, base);
02458   Operand(1, int64, index);
02459   Operand(2, uimm8, scale);
02460   Operand(3, simm32, offset);
02461 
02462   Instruction_Group("jump mem w/ scaled index w/o base",
02463         TOP_ijmpxxx,
02464         TOP_icallxxx,
02465         TOP_UNDEFINED);
02466   Operand(0, int64, index);
02467   Operand(1, uimm8, scale);
02468   Operand(2, simm32, offset);
02469 
02470   Instruction_Group("label",
02471         TOP_label,
02472         TOP_UNDEFINED);
02473   Operand(0, pcrel32);
02474   Relocatable(0);
02475 
02476   Instruction_Group("spadjust",
02477         TOP_spadjust,
02478         TOP_UNDEFINED);
02479   Result(0, int64);
02480   Operand(0, int64, opnd1);
02481   Operand(1, simm16, opnd2);
02482 
02483   Instruction_Group("savexmms",
02484           TOP_savexmms,
02485         TOP_UNDEFINED);
02486   Operand(0, rax, opnd1); 
02487   Operand(1, uimm8);  // gives number of xmm parameters left in vararg part
02488   Operand(2, int64, base);  
02489   Operand(3, simm32, offset); // offset for the first save
02490   Operand(4, pcrel32, target); // label after the savexmms
02491   Operand(5, r11);
02492 
02493   Instruction_Group("intrncall",
02494         TOP_intrncall,
02495         TOP_UNDEFINED);
02496   Result(0, int64);
02497   Operand(0, uimm16); // the intrinsic ID
02498 
02499   Instruction_Group("pregtn tuple",
02500         TOP_UNDEFINED);
02501   Result(0, int64);
02502   Operand(0, uimm16);
02503 
02504   Instruction_Group("leave",
02505         TOP_leave,
02506         TOP_UNDEFINED);
02507   Result(0, rsp);
02508   Operand(0, rbp, opnd1);
02509 
02510   Instruction_Group("zero32",
02511         TOP_zero32,
02512         TOP_UNDEFINED);
02513   Result(0, int32);
02514 
02515   Instruction_Group("zero64",
02516         TOP_zero64,
02517         TOP_UNDEFINED);
02518   Result(0, int64);
02519 
02520   Instruction_Group("xzero",
02521         TOP_xzero32,
02522         TOP_xzero64,
02523         TOP_UNDEFINED);
02524   Result(0, fp64);
02525 
02526   Instruction_Group("xzerov",
02527         TOP_xzero128v32,
02528         TOP_xzero128v64,
02529         TOP_UNDEFINED);
02530   Result(0, fp128);
02531 
02532   Instruction_Group( "int8 arithmetic lock",
02533          TOP_lock_add8,
02534          TOP_lock_and8,
02535          TOP_lock_or8,
02536          TOP_lock_xor8,
02537          TOP_lock_sub8,
02538          TOP_UNDEFINED);
02539   Operand(0, int8, opnd1);
02540   Operand(1, int64, base);
02541   Operand(2, simm32, offset);
02542 
02543   Instruction_Group( "int16 arithmetic lock",
02544          TOP_lock_add16,
02545          TOP_lock_and16,
02546          TOP_lock_or16,
02547          TOP_lock_xor16,
02548          TOP_lock_sub16,
02549          TOP_UNDEFINED);
02550   Operand(0, int16, opnd1);
02551   Operand(1, int64, base);
02552   Operand(2, simm32, offset);
02553 
02554   Instruction_Group( "int32 arithmetic lock",
02555          TOP_lock_add32,
02556          TOP_lock_adc32,
02557          TOP_lock_and32,
02558          TOP_lock_or32,
02559          TOP_lock_xor32,
02560          TOP_lock_sub32,
02561          TOP_UNDEFINED);
02562   Operand(0, int32, opnd1);
02563   Operand(1, int64, base);
02564   Operand(2, simm32, offset);
02565 
02566   Instruction_Group( "int64 arithmetic lock",
02567          TOP_lock_add64,
02568          TOP_lock_and64,
02569          TOP_lock_or64,
02570          TOP_lock_xor64,
02571          TOP_lock_sub64,
02572          TOP_UNDEFINED);
02573   Operand(0, int64, opnd1);
02574   Operand(1, int64, base);
02575   Operand(2, simm32, offset);
02576 
02577   Instruction_Group("int8 compare & exchange mem opnd lock",
02578         TOP_lock_cmpxchg8,
02579         TOP_UNDEFINED);
02580   Result(0,  eflags);
02581   Operand(0, eax, opnd1);
02582   Operand(1, int8, opnd2);
02583   Operand(2, int64, base);
02584   Operand(3, simm32, offset);
02585 
02586   Instruction_Group("int16 compare & exchange mem opnd lock",
02587         TOP_lock_cmpxchg16,
02588         TOP_UNDEFINED);
02589   Result(0,  eflags);
02590   Operand(0, eax, opnd1);
02591   Operand(1, int16, opnd2);
02592   Operand(2, int64, base);
02593   Operand(3, simm32, offset);
02594 
02595   Instruction_Group("int32 compare & exchange mem opnd lock",
02596         TOP_lock_cmpxchg32,
02597         TOP_UNDEFINED);
02598   Result(0,  eflags);
02599   Operand(0, eax, opnd1);
02600   Operand(1, int32, opnd2);
02601   Operand(2, int64, base);
02602   Operand(3, simm32, offset);
02603 
02604   Instruction_Group("int64 compare & exchange mem opnd lock",
02605         TOP_lock_cmpxchg64,
02606         TOP_UNDEFINED);
02607   Result(0,  rflags);
02608   Operand(0, rax, opnd1);
02609   Operand(1, int64, opnd2);
02610   Operand(2, int64, base);
02611   Operand(3, simm32, offset);
02612 
02613   Instruction_Group("int8 exchange arithmetic lock",
02614         TOP_lock_xadd8,
02615         TOP_UNDEFINED);
02616   Result(0, int8);
02617   Operand(0, int8, opnd1);
02618   Operand(1, int64, base);
02619   Operand(2, simm32, offset);
02620 
02621   Instruction_Group("int16 exchange arithmetic lock",
02622         TOP_lock_xadd16,
02623         TOP_UNDEFINED);
02624   Result(0, int16);
02625   Operand(0, int16, opnd1);
02626   Operand(1, int64, base);
02627   Operand(2, simm32, offset);
02628 
02629   Instruction_Group("int32 exchange arithmetic lock",
02630         TOP_lock_xadd32,
02631         TOP_UNDEFINED);
02632   Result(0, int32);
02633   Operand(0, int32, opnd1);
02634   Operand(1, int64, base);
02635   Operand(2, simm32, offset);
02636 
02637   Instruction_Group("int64 exchange arithmetic lock",
02638         TOP_lock_xadd64,
02639         TOP_UNDEFINED);
02640   Result(0, int64);
02641   Operand(0, int64, opnd1);
02642   Operand(1, int64, base);
02643   Operand(2, simm32, offset);
02644 
02645   Instruction_Group( "bsf32",
02646                      TOP_bsf32,
02647                      TOP_bsr32,
02648                      TOP_UNDEFINED);
02649   Result(0, int32);
02650   Operand(0, int32, opnd1);
02651 
02652   Instruction_Group( "bsf64",
02653                      TOP_bsf64,
02654                      TOP_bsr64,
02655                      TOP_UNDEFINED);
02656   Result(0, int64);
02657   Operand(0, int64, opnd1);
02658 
02659   Instruction_Group("int64 load to mmx",
02660         TOP_ld64_2m,
02661         TOP_UNDEFINED);
02662   Result(0, mmx);
02663   Operand(0, int64, base);
02664   Operand(1, simm32, offset);
02665 
02666   Instruction_Group("int64 load to mmx w/o base or index",
02667         TOP_ld64_2m_n32,
02668         TOP_UNDEFINED);
02669   Result(0, mmx);
02670   Operand(0, simm32, offset);
02671 
02672   Instruction_Group("int64 store from mmx",
02673         TOP_store64_fm,
02674         TOP_storent64_fm,
02675         TOP_UNDEFINED);
02676   Operand(0, mmx, storeval);
02677   Operand(1, int64, base);
02678   Operand(2, simm32, offset);
02679 
02680   Instruction_Group("int64 store from mmx w/o base or index",
02681         TOP_store64_fm_n32,
02682         TOP_UNDEFINED);
02683   Operand(0, mmx, storeval);
02684   Operand(1, simm32, offset);
02685 
02686   Instruction_Group("int64 mov between mmx",
02687         TOP_mov64_m,
02688         TOP_UNDEFINED);
02689   Result(0, mmx);
02690   Operand(0, mmx, opnd1);
02691 
02692   Instruction_Group("mmx packed move",
02693                     TOP_pmovmskb,
02694                     TOP_UNDEFINED);
02695   Result(0, int32);
02696   Operand(0, mmx, opnd1);
02697 
02698   Instruction_Group("sse packed move",
02699                     TOP_pmovmskb128,
02700                     TOP_UNDEFINED);
02701   Result(0, int32);
02702   Operand(0, fp128, opnd1);
02703 
02704   Instruction_Group("packed word modification",
02705         TOP_pextrw,
02706         TOP_UNDEFINED);
02707   Result(0, int32);
02708   Operand(0, mmx, opnd1);
02709   Operand(1, uimm8, opnd2);
02710 
02711   Instruction_Group("packed word insertion",
02712         TOP_pinsrw,
02713         TOP_UNDEFINED);
02714   Result(0, mmx);
02715   Operand(0, int32, opnd1);
02716   Operand(1, uimm8, opnd2);
02717 
02718   Instruction_Group( "mmx vector arithmetic",
02719          TOP_add64v8,
02720          TOP_add64v16,
02721          TOP_add64v32,
02722          TOP_sub64v8,
02723          TOP_sub64v16,
02724          TOP_sub64v32,
02725          TOP_paddsb,
02726          TOP_paddsw,
02727          TOP_paddq,
02728          TOP_psubsb,
02729          TOP_psubsw,
02730          TOP_paddusb,
02731          TOP_paddusw,
02732          TOP_psubusb,
02733          TOP_psubusw,
02734          TOP_pmullw,
02735          TOP_pmulhw,
02736          TOP_pmaddwd,
02737          TOP_pcmpeqb,
02738          TOP_pcmpeqw,
02739          TOP_pcmpeqd,
02740          TOP_pcmpgtb,
02741          TOP_pcmpgtw,
02742          TOP_pcmpgtd,
02743          TOP_punpckhbw,
02744          TOP_punpckhwd,
02745          TOP_punpckhdq,
02746          TOP_punpckl64v8,
02747          TOP_punpckl64v16,
02748          TOP_punpckl64v32,
02749          TOP_packsswb,
02750          TOP_packssdw,
02751          TOP_packuswb,
02752          TOP_pmulhuw,
02753          TOP_pavgb,
02754          TOP_pavgw,
02755          TOP_psadbw,
02756          TOP_max64v8,
02757          TOP_max64v16,
02758          TOP_min64v8,
02759          TOP_min64v16,
02760          TOP_UNDEFINED);
02761   Result(0, mmx);
02762   Operand(0, mmx, opnd1);
02763   Operand(1, mmx, opnd2);
02764 
02765   Instruction_Group("MMX shuffle-int",
02766         TOP_pshufw64v16,
02767         TOP_UNDEFINED);
02768   Result(0, mmx);
02769   Operand(0, mmx, opnd1);
02770   Operand(1, uimm8, opnd3);
02771 
02772 
02773   Instruction_Group( "mov int32 2 mmx",
02774                      TOP_movi32_2m,
02775                      TOP_UNDEFINED);
02776   Result(0, mmx);
02777   Operand(0, int32, opnd1);
02778 
02779   Instruction_Group( "mov int64 2 mmx",
02780                      TOP_movi64_2m,
02781                      TOP_UNDEFINED);
02782   Result(0, mmx);
02783   Operand(0, int64, opnd1);
02784 
02785   Instruction_Group( "mov mmx 2 int32",
02786                      TOP_movm_2i32,
02787                      TOP_UNDEFINED);
02788   Result(0, int32);
02789   Operand(0, mmx, opnd1);
02790 
02791   Instruction_Group( "mov mmx 2 int64",
02792                      TOP_movm_2i64,
02793                      TOP_UNDEFINED);
02794   Result(0, int64);
02795   Operand(0, mmx, opnd1);
02796 
02797   Instruction_Group( "mov mmx 2 sse",
02798                      TOP_movq2dq,
02799                      TOP_UNDEFINED);
02800   Result(0, fp64);
02801   Operand(0, mmx, opnd1);
02802 
02803   Instruction_Group( "mov sse 2 mmx",
02804                      TOP_movdq2q,
02805                      TOP_UNDEFINED);
02806   Result(0, mmx);
02807   Operand(0, fp64, opnd1);
02808 
02809   Instruction_Group("packed mmx arith",
02810            TOP_psllw_mmx,
02811            TOP_pslld_mmx,
02812            TOP_psrlw_mmx,
02813            TOP_psrld_mmx,
02814            TOP_psraw_mmx,
02815            TOP_psrad_mmx,
02816            TOP_pand_mmx,
02817            TOP_pandn_mmx,
02818            TOP_por_mmx,
02819            TOP_pxor_mmx,
02820                      TOP_UNDEFINED);
02821   Result(0, mmx);
02822   Operand(0, mmx, opnd1);
02823   Operand(1, mmx, opnd2);
02824 
02825   Instruction_Group( "vector cvt sse ps/pd 2 mmx pi",
02826          TOP_cvtps2pi,
02827          TOP_cvttps2pi,
02828          TOP_cvtpd2pi,
02829          TOP_cvttpd2pi,
02830                      TOP_UNDEFINED);
02831   Result(0, mmx);
02832   Operand(0, fp128, opnd1);
02833 
02834   Instruction_Group( "vector cvt mmx pi 2 sse ps/pd",
02835          TOP_cvtpi2ps,
02836          TOP_cvtpi2pd,
02837                      TOP_UNDEFINED);
02838   Result(0, fp128);
02839   Operand(0, mmx, opnd1);
02840 
02841   Instruction_Group("int64 load to sse",
02842         TOP_ld64_2sse,
02843         TOP_UNDEFINED);
02844   Result(0, fp64);
02845   Operand(0, int64, base);
02846   Operand(1, simm32, offset);
02847 
02848   Instruction_Group("int64 load to sse w/o base or index",
02849         TOP_ld64_2sse_n32,
02850         TOP_UNDEFINED);
02851   Result(0, fp64);
02852   Operand(0, simm32, offset);
02853 
02854   Instruction_Group("int64 store from sse",
02855         TOP_store64_fsse,
02856         TOP_UNDEFINED);
02857   Operand(0, fp64, storeval);
02858   Operand(1, int64, base);
02859   Operand(2, simm32, offset);
02860 
02861   Instruction_Group("int64 store from sse w/o base or index",
02862         TOP_store64_fsse_n32,
02863         TOP_UNDEFINED);
02864   Operand(0, fp64, storeval);
02865   Operand(1, simm32, offset);
02866 
02867   Instruction_Group("fp128 2 int32",
02868         TOP_movmskpd,
02869         TOP_movmskps,
02870         TOP_UNDEFINED);
02871   Result(0, int32);
02872   Operand(0, fp128, opnd1);
02873 
02874   Instruction_Group("maskmov mmx",
02875         TOP_maskmovq,
02876         TOP_UNDEFINED);
02877   Operand(0, mmx, opnd1);
02878   Operand(1, mmx, opnd2);
02879 
02880   Instruction_Group("maskmov sse",
02881         TOP_maskmovdqu,
02882         TOP_UNDEFINED);
02883   Operand(0, fp128, opnd1);
02884   Operand(1, fp128, opnd2);
02885 
02886   Instruction_Group("extract field xmm",
02887                     TOP_extrq,
02888                     TOP_UNDEFINED);
02889   Result(0, fp128);
02890   Operand(0, fp128, opnd1);
02891   Operand(1, fp128, opnd2);
02892 
02893   Instruction_Group("insert field xmm",
02894                     TOP_insertq,
02895                     TOP_UNDEFINED);
02896   Result(0, fp128);
02897   Operand(0, fp128, opnd1);
02898   Operand(1, fp128, opnd2);
02899 
02900   
02901   ISA_Operands_End();
02902   return 0;
02903 }
osprey/common/targ_info/isa/x8664/isa_operands.cxx
