github.com/xushiwei/go@v0.0.0-20130601165731-2b9d83f45bc9/src/cmd/6l/optab.c (about)

     1  // Inferno utils/6l/optab.c
     2  // http://code.google.com/p/inferno-os/source/browse/utils/6l/optab.c
     3  //
     4  //	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
     5  //	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
     6  //	Portions Copyright © 1997-1999 Vita Nuova Limited
     7  //	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
     8  //	Portions Copyright © 2004,2006 Bruce Ellis
     9  //	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
    10  //	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
    11  //	Portions Copyright © 2009 The Go Authors.  All rights reserved.
    12  //
    13  // Permission is hereby granted, free of charge, to any person obtaining a copy
    14  // of this software and associated documentation files (the "Software"), to deal
    15  // in the Software without restriction, including without limitation the rights
    16  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    17  // copies of the Software, and to permit persons to whom the Software is
    18  // furnished to do so, subject to the following conditions:
    19  //
    20  // The above copyright notice and this permission notice shall be included in
    21  // all copies or substantial portions of the Software.
    22  //
    23  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    24  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    25  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
    26  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    27  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    28  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    29  // THE SOFTWARE.
    30  
    31  #include	"l.h"
    32  
    33  uchar	ynone[] =
    34  {
    35  	Ynone,	Ynone,	Zlit,	1,
    36  	0
    37  };
    38  uchar	ytext[] =
    39  {
    40  	Ymb,	Yi64,	Zpseudo,1,
    41  	0
    42  };
    43  uchar	ynop[] =
    44  {
    45  	Ynone,	Ynone,	Zpseudo,1,
    46  	Ynone,	Yml,	Zpseudo,1,
    47  	Ynone,	Yrf,	Zpseudo,1,
    48  	Yml,	Ynone,	Zpseudo,1,
    49  	Yrf,	Ynone,	Zpseudo,1,
    50  	0
    51  };
    52  uchar	yxorb[] =
    53  {
    54  	Yi32,	Yal,	Zib_,	1,
    55  	Yi32,	Ymb,	Zibo_m,	2,
    56  	Yrb,	Ymb,	Zr_m,	1,
    57  	Ymb,	Yrb,	Zm_r,	1,
    58  	0
    59  };
    60  uchar	yxorl[] =
    61  {
    62  	Yi8,	Yml,	Zibo_m,	2,
    63  	Yi32,	Yax,	Zil_,	1,
    64  	Yi32,	Yml,	Zilo_m,	2,
    65  	Yrl,	Yml,	Zr_m,	1,
    66  	Yml,	Yrl,	Zm_r,	1,
    67  	0
    68  };
    69  uchar	yaddl[] =
    70  {
    71  	Yi8,	Yml,	Zibo_m,	2,
    72  	Yi32,	Yax,	Zil_,	1,
    73  	Yi32,	Yml,	Zilo_m,	2,
    74  	Yrl,	Yml,	Zr_m,	1,
    75  	Yml,	Yrl,	Zm_r,	1,
    76  	0
    77  };
    78  uchar	yincb[] =
    79  {
    80  	Ynone,	Ymb,	Zo_m,	2,
    81  	0
    82  };
    83  uchar	yincw[] =
    84  {
    85  	Ynone,	Yml,	Zo_m,	2,
    86  	0
    87  };
    88  uchar	yincl[] =
    89  {
    90  	Ynone,	Yml,	Zo_m,	2,
    91  	0
    92  };
    93  uchar	ycmpb[] =
    94  {
    95  	Yal,	Yi32,	Z_ib,	1,
    96  	Ymb,	Yi32,	Zm_ibo,	2,
    97  	Ymb,	Yrb,	Zm_r,	1,
    98  	Yrb,	Ymb,	Zr_m,	1,
    99  	0
   100  };
   101  uchar	ycmpl[] =
   102  {
   103  	Yml,	Yi8,	Zm_ibo,	2,
   104  	Yax,	Yi32,	Z_il,	1,
   105  	Yml,	Yi32,	Zm_ilo,	2,
   106  	Yml,	Yrl,	Zm_r,	1,
   107  	Yrl,	Yml,	Zr_m,	1,
   108  	0
   109  };
   110  uchar	yshb[] =
   111  {
   112  	Yi1,	Ymb,	Zo_m,	2,
   113  	Yi32,	Ymb,	Zibo_m,	2,
   114  	Ycx,	Ymb,	Zo_m,	2,
   115  	0
   116  };
   117  uchar	yshl[] =
   118  {
   119  	Yi1,	Yml,	Zo_m,	2,
   120  	Yi32,	Yml,	Zibo_m,	2,
   121  	Ycl,	Yml,	Zo_m,	2,
   122  	Ycx,	Yml,	Zo_m,	2,
   123  	0
   124  };
   125  uchar	ytestb[] =
   126  {
   127  	Yi32,	Yal,	Zib_,	1,
   128  	Yi32,	Ymb,	Zibo_m,	2,
   129  	Yrb,	Ymb,	Zr_m,	1,
   130  	Ymb,	Yrb,	Zm_r,	1,
   131  	0
   132  };
   133  uchar	ytestl[] =
   134  {
   135  	Yi32,	Yax,	Zil_,	1,
   136  	Yi32,	Yml,	Zilo_m,	2,
   137  	Yrl,	Yml,	Zr_m,	1,
   138  	Yml,	Yrl,	Zm_r,	1,
   139  	0
   140  };
   141  uchar	ymovb[] =
   142  {
   143  	Yrb,	Ymb,	Zr_m,	1,
   144  	Ymb,	Yrb,	Zm_r,	1,
   145  	Yi32,	Yrb,	Zib_rp,	1,
   146  	Yi32,	Ymb,	Zibo_m,	2,
   147  	0
   148  };
   149  uchar	ymbs[] =
   150  {
   151  	Ymb,	Ynone,	Zm_o,	2,
   152  	0
   153  };
   154  uchar	ybtl[] =
   155  {
   156  	Yi8,	Yml,	Zibo_m,	2,
   157  	Yrl,	Yml,	Zr_m,	1,
   158  	0
   159  };
   160  uchar	ymovw[] =
   161  {
   162  	Yrl,	Yml,	Zr_m,	1,
   163  	Yml,	Yrl,	Zm_r,	1,
   164  	Yi0,	Yrl,	Zclr,	1,
   165  	Yi32,	Yrl,	Zil_rp,	1,
   166  	Yi32,	Yml,	Zilo_m,	2,
   167  	Yiauto,	Yrl,	Zaut_r,	2,
   168  	0
   169  };
   170  uchar	ymovl[] =
   171  {
   172  	Yrl,	Yml,	Zr_m,	1,
   173  	Yml,	Yrl,	Zm_r,	1,
   174  	Yi0,	Yrl,	Zclr,	1,
   175  	Yi32,	Yrl,	Zil_rp,	1,
   176  	Yi32,	Yml,	Zilo_m,	2,
   177  	Yml,	Ymr,	Zm_r_xm,	1,	// MMX MOVD
   178  	Ymr,	Yml,	Zr_m_xm,	1,	// MMX MOVD
   179  	Yml,	Yxr,	Zm_r_xm,	2,	// XMM MOVD (32 bit)
   180  	Yxr,	Yml,	Zr_m_xm,	2,	// XMM MOVD (32 bit)
   181  	Yiauto,	Yrl,	Zaut_r,	2,
   182  	0
   183  };
   184  uchar	yret[] =
   185  {
   186  	Ynone,	Ynone,	Zo_iw,	1,
   187  	Yi32,	Ynone,	Zo_iw,	1,
   188  	0
   189  };
   190  uchar	ymovq[] =
   191  {
   192  	Yrl,	Yml,	Zr_m,	1,	// 0x89
   193  	Yml,	Yrl,	Zm_r,	1,	// 0x8b
   194  	Yi0,	Yrl,	Zclr,	1,	// 0x31
   195  	Ys32,	Yrl,	Zilo_m,	2,	// 32 bit signed 0xc7,(0)
   196  	Yi64,	Yrl,	Ziq_rp,	1,	// 0xb8 -- 32/64 bit immediate
   197  	Yi32,	Yml,	Zilo_m,	2,	// 0xc7,(0)
   198  	Ym,	Ymr,	Zm_r_xm_nr,	1,	// MMX MOVQ (shorter encoding)
   199  	Ymr,	Ym,	Zr_m_xm_nr,	1,	// MMX MOVQ
   200  	Ymm,	Ymr,	Zm_r_xm,	1,	// MMX MOVD
   201  	Ymr,	Ymm,	Zr_m_xm,	1,	// MMX MOVD
   202  	Yxr,	Ymr,	Zm_r_xm_nr,	2,	// MOVDQ2Q
   203  	Yxm,	Yxr,	Zm_r_xm_nr,	2, // MOVQ xmm1/m64 -> xmm2
   204  	Yxr,	Yxm,	Zr_m_xm_nr,	2, // MOVQ xmm1 -> xmm2/m64
   205  	Yml,	Yxr,	Zm_r_xm,	2,	// MOVD xmm load
   206  	Yxr,	Yml,	Zr_m_xm,	2,	// MOVD xmm store
   207  	Yiauto,	Yrl,	Zaut_r,	2,	// built-in LEAQ
   208  	0
   209  };
   210  uchar	ym_rl[] =
   211  {
   212  	Ym,	Yrl,	Zm_r,	1,
   213  	0
   214  };
   215  uchar	yrl_m[] =
   216  {
   217  	Yrl,	Ym,	Zr_m,	1,
   218  	0
   219  };
   220  uchar	ymb_rl[] =
   221  {
   222  	Ymb,	Yrl,	Zmb_r,	1,
   223  	0
   224  };
   225  uchar	yml_rl[] =
   226  {
   227  	Yml,	Yrl,	Zm_r,	1,
   228  	0
   229  };
   230  uchar	yrl_ml[] =
   231  {
   232  	Yrl,	Yml,	Zr_m,	1,
   233  	0
   234  };
   235  uchar	yml_mb[] =
   236  {
   237  	Yrb,	Ymb,	Zr_m,	1,
   238  	Ymb,	Yrb,	Zm_r,	1,
   239  	0
   240  };
   241  uchar	yrb_mb[] =
   242  {
   243  	Yrb,	Ymb,	Zr_m,	1,
   244  	0
   245  };
   246  uchar	yml_ml[] =
   247  {
   248  	Yrl,	Yml,	Zr_m,	1,
   249  	Yml,	Yrl,	Zm_r,	1,
   250  	0
   251  };
   252  uchar	ydivl[] =
   253  {
   254  	Yml,	Ynone,	Zm_o,	2,
   255  	0
   256  };
   257  uchar	ydivb[] =
   258  {
   259  	Ymb,	Ynone,	Zm_o,	2,
   260  	0
   261  };
   262  uchar	yimul[] =
   263  {
   264  	Yml,	Ynone,	Zm_o,	2,
   265  	Yi8,	Yrl,	Zib_rr,	1,
   266  	Yi32,	Yrl,	Zil_rr,	1,
   267  	Yml,	Yrl,	Zm_r,	2,
   268  	0
   269  };
   270  uchar	yimul3[] =
   271  {
   272  	Yml,	Yrl,	Zibm_r,	2,
   273  	0
   274  };
   275  uchar	ybyte[] =
   276  {
   277  	Yi64,	Ynone,	Zbyte,	1,
   278  	0
   279  };
   280  uchar	yin[] =
   281  {
   282  	Yi32,	Ynone,	Zib_,	1,
   283  	Ynone,	Ynone,	Zlit,	1,
   284  	0
   285  };
   286  uchar	yint[] =
   287  {
   288  	Yi32,	Ynone,	Zib_,	1,
   289  	0
   290  };
   291  uchar	ypushl[] =
   292  {
   293  	Yrl,	Ynone,	Zrp_,	1,
   294  	Ym,	Ynone,	Zm_o,	2,
   295  	Yi8,	Ynone,	Zib_,	1,
   296  	Yi32,	Ynone,	Zil_,	1,
   297  	0
   298  };
   299  uchar	ypopl[] =
   300  {
   301  	Ynone,	Yrl,	Z_rp,	1,
   302  	Ynone,	Ym,	Zo_m,	2,
   303  	0
   304  };
   305  uchar	ybswap[] =
   306  {
   307  	Ynone,	Yrl,	Z_rp,	2,
   308  	0,
   309  };
   310  uchar	yscond[] =
   311  {
   312  	Ynone,	Ymb,	Zo_m,	2,
   313  	0
   314  };
   315  uchar	yjcond[] =
   316  {
   317  	Ynone,	Ybr,	Zbr,	0,
   318  	Yi0,	Ybr,	Zbr,	0,
   319  	Yi1,	Ybr,	Zbr,	1,
   320  	0
   321  };
   322  uchar	yloop[] =
   323  {
   324  	Ynone,	Ybr,	Zloop,	1,
   325  	0
   326  };
   327  uchar	ycall[] =
   328  {
   329  	Ynone,	Yml,	Zo_m64,	0,
   330  	Yrx,	Yrx,	Zo_m64,	2,
   331  	Ynone,	Ybr,	Zcall,	1,
   332  	0
   333  };
   334  uchar	yjmp[] =
   335  {
   336  	Ynone,	Yml,	Zo_m64,	2,
   337  	Ynone,	Ybr,	Zjmp,	1,
   338  	0
   339  };
   340  
   341  uchar	yfmvd[] =
   342  {
   343  	Ym,	Yf0,	Zm_o,	2,
   344  	Yf0,	Ym,	Zo_m,	2,
   345  	Yrf,	Yf0,	Zm_o,	2,
   346  	Yf0,	Yrf,	Zo_m,	2,
   347  	0
   348  };
   349  uchar	yfmvdp[] =
   350  {
   351  	Yf0,	Ym,	Zo_m,	2,
   352  	Yf0,	Yrf,	Zo_m,	2,
   353  	0
   354  };
   355  uchar	yfmvf[] =
   356  {
   357  	Ym,	Yf0,	Zm_o,	2,
   358  	Yf0,	Ym,	Zo_m,	2,
   359  	0
   360  };
   361  uchar	yfmvx[] =
   362  {
   363  	Ym,	Yf0,	Zm_o,	2,
   364  	0
   365  };
   366  uchar	yfmvp[] =
   367  {
   368  	Yf0,	Ym,	Zo_m,	2,
   369  	0
   370  };
   371  uchar	yfadd[] =
   372  {
   373  	Ym,	Yf0,	Zm_o,	2,
   374  	Yrf,	Yf0,	Zm_o,	2,
   375  	Yf0,	Yrf,	Zo_m,	2,
   376  	0
   377  };
   378  uchar	yfaddp[] =
   379  {
   380  	Yf0,	Yrf,	Zo_m,	2,
   381  	0
   382  };
   383  uchar	yfxch[] =
   384  {
   385  	Yf0,	Yrf,	Zo_m,	2,
   386  	Yrf,	Yf0,	Zm_o,	2,
   387  	0
   388  };
   389  uchar	ycompp[] =
   390  {
   391  	Yf0,	Yrf,	Zo_m,	2,	/* botch is really f0,f1 */
   392  	0
   393  };
   394  uchar	ystsw[] =
   395  {
   396  	Ynone,	Ym,	Zo_m,	2,
   397  	Ynone,	Yax,	Zlit,	1,
   398  	0
   399  };
   400  uchar	ystcw[] =
   401  {
   402  	Ynone,	Ym,	Zo_m,	2,
   403  	Ym,	Ynone,	Zm_o,	2,
   404  	0
   405  };
   406  uchar	ysvrs[] =
   407  {
   408  	Ynone,	Ym,	Zo_m,	2,
   409  	Ym,	Ynone,	Zm_o,	2,
   410  	0
   411  };
   412  uchar	ymm[] = 
   413  {
   414  	Ymm,	Ymr,	Zm_r_xm,	1,
   415  	Yxm,	Yxr,	Zm_r_xm,	2,
   416  	0
   417  };
   418  uchar	yxm[] = 
   419  {
   420  	Yxm,	Yxr,	Zm_r_xm,	1,
   421  	0
   422  };
   423  uchar	yxcvm1[] = 
   424  {
   425  	Yxm,	Yxr,	Zm_r_xm,	2,
   426  	Yxm,	Ymr,	Zm_r_xm,	2,
   427  	0
   428  };
   429  uchar	yxcvm2[] =
   430  {
   431  	Yxm,	Yxr,	Zm_r_xm,	2,
   432  	Ymm,	Yxr,	Zm_r_xm,	2,
   433  	0
   434  };
   435  uchar	yxmq[] = 
   436  {
   437  	Yxm,	Yxr,	Zm_r_xm,	2,
   438  	0
   439  };
   440  uchar	yxr[] = 
   441  {
   442  	Yxr,	Yxr,	Zm_r_xm,	1,
   443  	0
   444  };
   445  uchar	yxr_ml[] =
   446  {
   447  	Yxr,	Yml,	Zr_m_xm,	1,
   448  	0
   449  };
   450  uchar	ymr[] =
   451  {
   452  	Ymr,	Ymr,	Zm_r,	1,
   453  	0
   454  };
   455  uchar	ymr_ml[] =
   456  {
   457  	Ymr,	Yml,	Zr_m_xm,	1,
   458  	0
   459  };
   460  uchar	yxcmp[] =
   461  {
   462  	Yxm,	Yxr, Zm_r_xm,	1,
   463  	0
   464  };
   465  uchar	yxcmpi[] =
   466  {
   467  	Yxm,	Yxr, Zm_r_i_xm,	2,
   468  	0
   469  };
   470  uchar	yxmov[] =
   471  {
   472  	Yxm,	Yxr,	Zm_r_xm,	1,
   473  	Yxr,	Yxm,	Zr_m_xm,	1,
   474  	0
   475  };
   476  uchar	yxcvfl[] = 
   477  {
   478  	Yxm,	Yrl,	Zm_r_xm,	1,
   479  	0
   480  };
   481  uchar	yxcvlf[] =
   482  {
   483  	Yml,	Yxr,	Zm_r_xm,	1,
   484  	0
   485  };
   486  uchar	yxcvfq[] = 
   487  {
   488  	Yxm,	Yrl,	Zm_r_xm,	2,
   489  	0
   490  };
   491  uchar	yxcvqf[] =
   492  {
   493  	Yml,	Yxr,	Zm_r_xm,	2,
   494  	0
   495  };
   496  uchar	yps[] = 
   497  {
   498  	Ymm,	Ymr,	Zm_r_xm,	1,
   499  	Yi8,	Ymr,	Zibo_m_xm,	2,
   500  	Yxm,	Yxr,	Zm_r_xm,	2,
   501  	Yi8,	Yxr,	Zibo_m_xm,	3,
   502  	0
   503  };
   504  uchar	yxrrl[] =
   505  {
   506  	Yxr,	Yrl,	Zm_r,	1,
   507  	0
   508  };
   509  uchar	ymfp[] =
   510  {
   511  	Ymm,	Ymr,	Zm_r_3d,	1,
   512  	0,
   513  };
   514  uchar	ymrxr[] =
   515  {
   516  	Ymr,	Yxr,	Zm_r,	1,
   517  	Yxm,	Yxr,	Zm_r_xm,	1,
   518  	0
   519  };
   520  uchar	ymshuf[] =
   521  {
   522  	Ymm,	Ymr,	Zibm_r,	2,
   523  	0
   524  };
   525  uchar	ymshufb[] =
   526  {
   527  	Yxm,	Yxr,	Zm2_r,	2,
   528  	0
   529  };
   530  uchar	yxshuf[] =
   531  {
   532  	Yxm,	Yxr,	Zibm_r,	2,
   533  	0
   534  };
   535  uchar	yextrw[] =
   536  {
   537  	Yxr,	Yrl,	Zibm_r,	2,
   538  	0
   539  };
   540  uchar	yinsrw[] =
   541  {
   542  	Yml,	Yxr,	Zibm_r,	2,
   543  	0
   544  };
   545  uchar	yinsr[] =
   546  {
   547  	Ymm,	Yxr,	Zibm_r,	3,
   548  	0
   549  };
   550  uchar	ypsdq[] =
   551  {
   552  	Yi8,	Yxr,	Zibo_m,	2,
   553  	0
   554  };
   555  uchar	ymskb[] =
   556  {
   557  	Yxr,	Yrl,	Zm_r_xm,	2,
   558  	Ymr,	Yrl,	Zm_r_xm,	1,
   559  	0
   560  };
   561  uchar	ycrc32l[] =
   562  {
   563  	Yml,	Yrl,	Zlitm_r,	0,
   564  };
   565  uchar	yprefetch[] =
   566  {
   567  	Ym,	Ynone,	Zm_o,	2,
   568  	0,
   569  };
   570  uchar	yaes[] =
   571  {
   572  	Yxm,	Yxr,	Zlitm_r,	2,
   573  	0
   574  };
   575  uchar	yaes2[] =
   576  {
   577  	Yxm,	Yxr,	Zibm_r,	2,
   578  	0
   579  };
   580  
   581  /*
   582   * You are doasm, holding in your hand a Prog* with p->as set to, say, ACRC32,
   583   * and p->from and p->to as operands (Adr*).  The linker scans optab to find
   584   * the entry with the given p->as and then looks through the ytable for that
   585   * instruction (the second field in the optab struct) for a line whose first
   586   * two values match the Ytypes of the p->from and p->to operands.  The function
   587   * oclass in span.c computes the specific Ytype of an operand and then the set
   588   * of more general Ytypes that it satisfies is implied by the ycover table, set
   589   * up in instinit.  For example, oclass distinguishes the constants 0 and 1
   590   * from the more general 8-bit constants, but instinit says
   591   *
   592   *        ycover[Yi0*Ymax + Ys32] = 1;
   593   *        ycover[Yi1*Ymax + Ys32] = 1;
   594   *        ycover[Yi8*Ymax + Ys32] = 1;
   595   *
   596   * which means that Yi0, Yi1, and Yi8 all count as Ys32 (signed 32)
   597   * if that's what an instruction can handle.
   598   *
   599   * In parallel with the scan through the ytable for the appropriate line, there
   600   * is a z pointer that starts out pointing at the strange magic byte list in
   601   * the Optab struct.  With each step past a non-matching ytable line, z
   602   * advances by the 4th entry in the line.  When a matching line is found, that
   603   * z pointer has the extra data to use in laying down the instruction bytes.
   604   * The actual bytes laid down are a function of the 3rd entry in the line (that
   605   * is, the Ztype) and the z bytes.
   606   *
   607   * For example, let's look at AADDL.  The optab line says:
   608   *        { AADDL,        yaddl,  Px, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
   609   *
   610   * and yaddl says
   611   *        uchar   yaddl[] =
   612   *        {
   613   *                Yi8,    Yml,    Zibo_m, 2,
   614   *                Yi32,   Yax,    Zil_,   1,
   615   *                Yi32,   Yml,    Zilo_m, 2,
   616   *                Yrl,    Yml,    Zr_m,   1,
   617   *                Yml,    Yrl,    Zm_r,   1,
   618   *                0
   619   *        };
   620   *
   621   * so there are 5 possible types of ADDL instruction that can be laid down, and
   622   * possible states used to lay them down (Ztype and z pointer, assuming z
   623   * points at {0x83,(00),0x05,0x81,(00),0x01,0x03}) are:
   624   *
   625   *        Yi8, Yml -> Zibo_m, z (0x83, 00)
   626   *        Yi32, Yax -> Zil_, z+2 (0x05)
   627   *        Yi32, Yml -> Zilo_m, z+2+1 (0x81, 0x00)
   628   *        Yrl, Yml -> Zr_m, z+2+1+2 (0x01)
   629   *        Yml, Yrl -> Zm_r, z+2+1+2+1 (0x03)
   630   *
   631   * The Pconstant in the optab line controls the prefix bytes to emit.  That's
   632   * relatively straightforward as this program goes.
   633   *
   634   * The switch on t[2] in doasm implements the various Z cases.  Zibo_m, for
   635   * example, is an opcode byte (z[0]) then an asmando (which is some kind of
   636   * encoded addressing mode for the Yml arg), and then a single immediate byte.
   637   * Zilo_m is the same but a long (32-bit) immediate.
   638   */
   639  Optab optab[] =
   640  /*	as, ytab, andproto, opcode */
   641  {
   642  	{ AXXX },
   643  	{ AAAA,		ynone,	P32, 0x37 },
   644  	{ AAAD,		ynone,	P32, 0xd5,0x0a },
   645  	{ AAAM,		ynone,	P32, 0xd4,0x0a },
   646  	{ AAAS,		ynone,	P32, 0x3f },
   647  	{ AADCB,	yxorb,	Pb, 0x14,0x80,(02),0x10,0x10 },
   648  	{ AADCL,	yxorl,	Px, 0x83,(02),0x15,0x81,(02),0x11,0x13 },
   649  	{ AADCQ,	yxorl,	Pw, 0x83,(02),0x15,0x81,(02),0x11,0x13 },
   650  	{ AADCW,	yxorl,	Pe, 0x83,(02),0x15,0x81,(02),0x11,0x13 },
   651  	{ AADDB,	yxorb,	Pb, 0x04,0x80,(00),0x00,0x02 },
   652  	{ AADDL,	yaddl,	Px, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
   653  	{ AADDPD,	yxm,	Pq, 0x58 },
   654  	{ AADDPS,	yxm,	Pm, 0x58 },
   655  	{ AADDQ,	yaddl,	Pw, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
   656  	{ AADDSD,	yxm,	Pf2, 0x58 },
   657  	{ AADDSS,	yxm,	Pf3, 0x58 },
   658  	{ AADDW,	yaddl,	Pe, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
   659  	{ AADJSP },
   660  	{ AANDB,	yxorb,	Pb, 0x24,0x80,(04),0x20,0x22 },
   661  	{ AANDL,	yxorl,	Px, 0x83,(04),0x25,0x81,(04),0x21,0x23 },
   662  	{ AANDNPD,	yxm,	Pq, 0x55 },
   663  	{ AANDNPS,	yxm,	Pm, 0x55 },
   664  	{ AANDPD,	yxm,	Pq, 0x54 },
   665  	{ AANDPS,	yxm,	Pq, 0x54 },
   666  	{ AANDQ,	yxorl,	Pw, 0x83,(04),0x25,0x81,(04),0x21,0x23 },
   667  	{ AANDW,	yxorl,	Pe, 0x83,(04),0x25,0x81,(04),0x21,0x23 },
   668  	{ AARPL,	yrl_ml,	P32, 0x63 },
   669  	{ ABOUNDL,	yrl_m,	P32, 0x62 },
   670  	{ ABOUNDW,	yrl_m,	Pe, 0x62 },
   671  	{ ABSFL,	yml_rl,	Pm, 0xbc },
   672  	{ ABSFQ,	yml_rl,	Pw, 0x0f,0xbc },
   673  	{ ABSFW,	yml_rl,	Pq, 0xbc },
   674  	{ ABSRL,	yml_rl,	Pm, 0xbd },
   675  	{ ABSRQ,	yml_rl,	Pw, 0x0f,0xbd },
   676  	{ ABSRW,	yml_rl,	Pq, 0xbd },
   677  	{ ABSWAPL,	ybswap,	Px, 0x0f,0xc8 },
   678  	{ ABSWAPQ,	ybswap,	Pw, 0x0f,0xc8 },
   679  	{ ABTCL,	ybtl,	Pm, 0xba,(07),0xbb },
   680  	{ ABTCQ,	ybtl,	Pw, 0x0f,0xba,(07),0x0f,0xbb },
   681  	{ ABTCW,	ybtl,	Pq, 0xba,(07),0xbb },
   682  	{ ABTL,		ybtl,	Pm, 0xba,(04),0xa3 },
   683  	{ ABTQ,		ybtl,	Pw, 0x0f,0xba,(04),0x0f,0xa3},
   684  	{ ABTRL,	ybtl,	Pm, 0xba,(06),0xb3 },
   685  	{ ABTRQ,	ybtl,	Pw, 0x0f,0xba,(06),0x0f,0xb3 },
   686  	{ ABTRW,	ybtl,	Pq, 0xba,(06),0xb3 },
   687  	{ ABTSL,	ybtl,	Pm, 0xba,(05),0xab  },
   688  	{ ABTSQ,	ybtl,	Pw, 0x0f,0xba,(05),0x0f,0xab },
   689  	{ ABTSW,	ybtl,	Pq, 0xba,(05),0xab  },
   690  	{ ABTW,		ybtl,	Pq, 0xba,(04),0xa3 },
   691  	{ ABYTE,	ybyte,	Px, 1 },
   692  	{ ACALL,	ycall,	Px, 0xff,(02),0xe8 },
   693  	{ ACDQ,		ynone,	Px, 0x99 },
   694  	{ ACLC,		ynone,	Px, 0xf8 },
   695  	{ ACLD,		ynone,	Px, 0xfc },
   696  	{ ACLI,		ynone,	Px, 0xfa },
   697  	{ ACLTS,	ynone,	Pm, 0x06 },
   698  	{ ACMC,		ynone,	Px, 0xf5 },
   699  	{ ACMOVLCC,	yml_rl,	Pm, 0x43 },
   700  	{ ACMOVLCS,	yml_rl,	Pm, 0x42 },
   701  	{ ACMOVLEQ,	yml_rl,	Pm, 0x44 },
   702  	{ ACMOVLGE,	yml_rl,	Pm, 0x4d },
   703  	{ ACMOVLGT,	yml_rl,	Pm, 0x4f },
   704  	{ ACMOVLHI,	yml_rl,	Pm, 0x47 },
   705  	{ ACMOVLLE,	yml_rl,	Pm, 0x4e },
   706  	{ ACMOVLLS,	yml_rl,	Pm, 0x46 },
   707  	{ ACMOVLLT,	yml_rl,	Pm, 0x4c },
   708  	{ ACMOVLMI,	yml_rl,	Pm, 0x48 },
   709  	{ ACMOVLNE,	yml_rl,	Pm, 0x45 },
   710  	{ ACMOVLOC,	yml_rl,	Pm, 0x41 },
   711  	{ ACMOVLOS,	yml_rl,	Pm, 0x40 },
   712  	{ ACMOVLPC,	yml_rl,	Pm, 0x4b },
   713  	{ ACMOVLPL,	yml_rl,	Pm, 0x49 },
   714  	{ ACMOVLPS,	yml_rl,	Pm, 0x4a },
   715  	{ ACMOVQCC,	yml_rl,	Pw, 0x0f,0x43 },
   716  	{ ACMOVQCS,	yml_rl,	Pw, 0x0f,0x42 },
   717  	{ ACMOVQEQ,	yml_rl,	Pw, 0x0f,0x44 },
   718  	{ ACMOVQGE,	yml_rl,	Pw, 0x0f,0x4d },
   719  	{ ACMOVQGT,	yml_rl,	Pw, 0x0f,0x4f },
   720  	{ ACMOVQHI,	yml_rl,	Pw, 0x0f,0x47 },
   721  	{ ACMOVQLE,	yml_rl,	Pw, 0x0f,0x4e },
   722  	{ ACMOVQLS,	yml_rl,	Pw, 0x0f,0x46 },
   723  	{ ACMOVQLT,	yml_rl,	Pw, 0x0f,0x4c },
   724  	{ ACMOVQMI,	yml_rl,	Pw, 0x0f,0x48 },
   725  	{ ACMOVQNE,	yml_rl,	Pw, 0x0f,0x45 },
   726  	{ ACMOVQOC,	yml_rl,	Pw, 0x0f,0x41 },
   727  	{ ACMOVQOS,	yml_rl,	Pw, 0x0f,0x40 },
   728  	{ ACMOVQPC,	yml_rl,	Pw, 0x0f,0x4b },
   729  	{ ACMOVQPL,	yml_rl,	Pw, 0x0f,0x49 },
   730  	{ ACMOVQPS,	yml_rl,	Pw, 0x0f,0x4a },
   731  	{ ACMOVWCC,	yml_rl,	Pq, 0x43 },
   732  	{ ACMOVWCS,	yml_rl,	Pq, 0x42 },
   733  	{ ACMOVWEQ,	yml_rl,	Pq, 0x44 },
   734  	{ ACMOVWGE,	yml_rl,	Pq, 0x4d },
   735  	{ ACMOVWGT,	yml_rl,	Pq, 0x4f },
   736  	{ ACMOVWHI,	yml_rl,	Pq, 0x47 },
   737  	{ ACMOVWLE,	yml_rl,	Pq, 0x4e },
   738  	{ ACMOVWLS,	yml_rl,	Pq, 0x46 },
   739  	{ ACMOVWLT,	yml_rl,	Pq, 0x4c },
   740  	{ ACMOVWMI,	yml_rl,	Pq, 0x48 },
   741  	{ ACMOVWNE,	yml_rl,	Pq, 0x45 },
   742  	{ ACMOVWOC,	yml_rl,	Pq, 0x41 },
   743  	{ ACMOVWOS,	yml_rl,	Pq, 0x40 },
   744  	{ ACMOVWPC,	yml_rl,	Pq, 0x4b },
   745  	{ ACMOVWPL,	yml_rl,	Pq, 0x49 },
   746  	{ ACMOVWPS,	yml_rl,	Pq, 0x4a },
   747  	{ ACMPB,	ycmpb,	Pb, 0x3c,0x80,(07),0x38,0x3a },
   748  	{ ACMPL,	ycmpl,	Px, 0x83,(07),0x3d,0x81,(07),0x39,0x3b },
   749  	{ ACMPPD,	yxcmpi,	Px, Pe,0xc2 },
   750  	{ ACMPPS,	yxcmpi,	Pm, 0xc2,0 },
   751  	{ ACMPQ,	ycmpl,	Pw, 0x83,(07),0x3d,0x81,(07),0x39,0x3b },
   752  	{ ACMPSB,	ynone,	Pb, 0xa6 },
   753  	{ ACMPSD,	yxcmpi,	Px, Pf2,0xc2 },
   754  	{ ACMPSL,	ynone,	Px, 0xa7 },
   755  	{ ACMPSQ,	ynone,	Pw, 0xa7 },
   756  	{ ACMPSS,	yxcmpi,	Px, Pf3,0xc2 },
   757  	{ ACMPSW,	ynone,	Pe, 0xa7 },
   758  	{ ACMPW,	ycmpl,	Pe, 0x83,(07),0x3d,0x81,(07),0x39,0x3b },
   759  	{ ACOMISD,	yxcmp,	Pe, 0x2f },
   760  	{ ACOMISS,	yxcmp,	Pm, 0x2f },
   761  	{ ACPUID,	ynone,	Pm, 0xa2 },
   762  	{ ACVTPL2PD,	yxcvm2,	Px, Pf3,0xe6,Pe,0x2a },
   763  	{ ACVTPL2PS,	yxcvm2,	Pm, 0x5b,0,0x2a,0, },
   764  	{ ACVTPD2PL,	yxcvm1,	Px, Pf2,0xe6,Pe,0x2d },
   765  	{ ACVTPD2PS,	yxm,	Pe, 0x5a },
   766  	{ ACVTPS2PL,	yxcvm1, Px, Pe,0x5b,Pm,0x2d },
   767  	{ ACVTPS2PD,	yxm,	Pm, 0x5a },
   768  	{ API2FW,	ymfp,	Px, 0x0c },
   769  	{ ACVTSD2SL,	yxcvfl, Pf2, 0x2d },
   770  	{ ACVTSD2SQ,	yxcvfq, Pw, Pf2,0x2d },
   771  	{ ACVTSD2SS,	yxm,	Pf2, 0x5a },
   772  	{ ACVTSL2SD,	yxcvlf, Pf2, 0x2a },
   773  	{ ACVTSQ2SD,	yxcvqf, Pw, Pf2,0x2a },
   774  	{ ACVTSL2SS,	yxcvlf, Pf3, 0x2a },
   775  	{ ACVTSQ2SS,	yxcvqf, Pw, Pf3,0x2a },
   776  	{ ACVTSS2SD,	yxm,	Pf3, 0x5a },
   777  	{ ACVTSS2SL,	yxcvfl, Pf3, 0x2d },
   778  	{ ACVTSS2SQ,	yxcvfq, Pw, Pf3,0x2d },
   779  	{ ACVTTPD2PL,	yxcvm1,	Px, Pe,0xe6,Pe,0x2c },
   780  	{ ACVTTPS2PL,	yxcvm1,	Px, Pf3,0x5b,Pm,0x2c },
   781  	{ ACVTTSD2SL,	yxcvfl, Pf2, 0x2c },
   782  	{ ACVTTSD2SQ,	yxcvfq, Pw, Pf2,0x2c },
   783  	{ ACVTTSS2SL,	yxcvfl,	Pf3, 0x2c },
   784  	{ ACVTTSS2SQ,	yxcvfq, Pw, Pf3,0x2c },
   785  	{ ACWD,		ynone,	Pe, 0x99 },
   786  	{ ACQO,		ynone,	Pw, 0x99 },
   787  	{ ADAA,		ynone,	P32, 0x27 },
   788  	{ ADAS,		ynone,	P32, 0x2f },
   789  	{ ADATA },
   790  	{ ADECB,	yincb,	Pb, 0xfe,(01) },
   791  	{ ADECL,	yincl,	Px, 0xff,(01) },
   792  	{ ADECQ,	yincl,	Pw, 0xff,(01) },
   793  	{ ADECW,	yincw,	Pe, 0xff,(01) },
   794  	{ ADIVB,	ydivb,	Pb, 0xf6,(06) },
   795  	{ ADIVL,	ydivl,	Px, 0xf7,(06) },
   796  	{ ADIVPD,	yxm,	Pe, 0x5e },
   797  	{ ADIVPS,	yxm,	Pm, 0x5e },
   798  	{ ADIVQ,	ydivl,	Pw, 0xf7,(06) },
   799  	{ ADIVSD,	yxm,	Pf2, 0x5e },
   800  	{ ADIVSS,	yxm,	Pf3, 0x5e },
   801  	{ ADIVW,	ydivl,	Pe, 0xf7,(06) },
   802  	{ AEMMS,	ynone,	Pm, 0x77 },
   803  	{ AENTER },				/* botch */
   804  	{ AFXRSTOR,	ysvrs,	Pm, 0xae,(01),0xae,(01) },
   805  	{ AFXSAVE,	ysvrs,	Pm, 0xae,(00),0xae,(00) },
   806  	{ AFXRSTOR64,	ysvrs,	Pw, 0x0f,0xae,(01),0x0f,0xae,(01) },
   807  	{ AFXSAVE64,	ysvrs,	Pw, 0x0f,0xae,(00),0x0f,0xae,(00) },
   808  	{ AGLOBL },
   809  	{ AGOK },
   810  	{ AHISTORY },
   811  	{ AHLT,		ynone,	Px, 0xf4 },
   812  	{ AIDIVB,	ydivb,	Pb, 0xf6,(07) },
   813  	{ AIDIVL,	ydivl,	Px, 0xf7,(07) },
   814  	{ AIDIVQ,	ydivl,	Pw, 0xf7,(07) },
   815  	{ AIDIVW,	ydivl,	Pe, 0xf7,(07) },
   816  	{ AIMULB,	ydivb,	Pb, 0xf6,(05) },
   817  	{ AIMULL,	yimul,	Px, 0xf7,(05),0x6b,0x69,Pm,0xaf },
   818  	{ AIMULQ,	yimul,	Pw, 0xf7,(05),0x6b,0x69,Pm,0xaf },
   819  	{ AIMULW,	yimul,	Pe, 0xf7,(05),0x6b,0x69,Pm,0xaf },
   820  	{ AIMUL3Q,	yimul3,	Pw, 0x6b,(00) },
   821  	{ AINB,		yin,	Pb, 0xe4,0xec },
   822  	{ AINCB,	yincb,	Pb, 0xfe,(00) },
   823  	{ AINCL,	yincl,	Px, 0xff,(00) },
   824  	{ AINCQ,	yincl,	Pw, 0xff,(00) },
   825  	{ AINCW,	yincw,	Pe, 0xff,(00) },
   826  	{ AINL,		yin,	Px, 0xe5,0xed },
   827  	{ AINSB,	ynone,	Pb, 0x6c },
   828  	{ AINSL,	ynone,	Px, 0x6d },
   829  	{ AINSW,	ynone,	Pe, 0x6d },
   830  	{ AINT,		yint,	Px, 0xcd },
   831  	{ AINTO,	ynone,	P32, 0xce },
   832  	{ AINW,		yin,	Pe, 0xe5,0xed },
   833  	{ AIRETL,	ynone,	Px, 0xcf },
   834  	{ AIRETQ,	ynone,	Pw, 0xcf },
   835  	{ AIRETW,	ynone,	Pe, 0xcf },
   836  	{ AJCC,		yjcond,	Px, 0x73,0x83,(00) },
   837  	{ AJCS,		yjcond,	Px, 0x72,0x82 },
   838  	{ AJCXZL,	yloop,	Px, 0xe3 },
   839  	{ AJCXZQ,	yloop,	Px, 0xe3 },
   840  	{ AJEQ,		yjcond,	Px, 0x74,0x84 },
   841  	{ AJGE,		yjcond,	Px, 0x7d,0x8d },
   842  	{ AJGT,		yjcond,	Px, 0x7f,0x8f },
   843  	{ AJHI,		yjcond,	Px, 0x77,0x87 },
   844  	{ AJLE,		yjcond,	Px, 0x7e,0x8e },
   845  	{ AJLS,		yjcond,	Px, 0x76,0x86 },
   846  	{ AJLT,		yjcond,	Px, 0x7c,0x8c },
   847  	{ AJMI,		yjcond,	Px, 0x78,0x88 },
   848  	{ AJMP,		yjmp,	Px, 0xff,(04),0xeb,0xe9 },
   849  	{ AJNE,		yjcond,	Px, 0x75,0x85 },
   850  	{ AJOC,		yjcond,	Px, 0x71,0x81,(00) },
   851  	{ AJOS,		yjcond,	Px, 0x70,0x80,(00) },
   852  	{ AJPC,		yjcond,	Px, 0x7b,0x8b },
   853  	{ AJPL,		yjcond,	Px, 0x79,0x89 },
   854  	{ AJPS,		yjcond,	Px, 0x7a,0x8a },
   855  	{ ALAHF,	ynone,	Px, 0x9f },
   856  	{ ALARL,	yml_rl,	Pm, 0x02 },
   857  	{ ALARW,	yml_rl,	Pq, 0x02 },
   858  	{ ALDMXCSR,	ysvrs,	Pm, 0xae,(02),0xae,(02) },
   859  	{ ALEAL,	ym_rl,	Px, 0x8d },
   860  	{ ALEAQ,	ym_rl,	Pw, 0x8d },
   861  	{ ALEAVEL,	ynone,	P32, 0xc9 },
   862  	{ ALEAVEQ,	ynone,	Py, 0xc9 },
   863  	{ ALEAVEW,	ynone,	Pe, 0xc9 },
   864  	{ ALEAW,	ym_rl,	Pe, 0x8d },
   865  	{ ALOCK,	ynone,	Px, 0xf0 },
   866  	{ ALODSB,	ynone,	Pb, 0xac },
   867  	{ ALODSL,	ynone,	Px, 0xad },
   868  	{ ALODSQ,	ynone,	Pw, 0xad },
   869  	{ ALODSW,	ynone,	Pe, 0xad },
   870  	{ ALONG,	ybyte,	Px, 4 },
   871  	{ ALOOP,	yloop,	Px, 0xe2 },
   872  	{ ALOOPEQ,	yloop,	Px, 0xe1 },
   873  	{ ALOOPNE,	yloop,	Px, 0xe0 },
   874  	{ ALSLL,	yml_rl,	Pm, 0x03  },
   875  	{ ALSLW,	yml_rl,	Pq, 0x03  },
   876  	{ AMASKMOVOU,	yxr,	Pe, 0xf7 },
   877  	{ AMASKMOVQ,	ymr,	Pm, 0xf7 },
   878  	{ AMAXPD,	yxm,	Pe, 0x5f },
   879  	{ AMAXPS,	yxm,	Pm, 0x5f },
   880  	{ AMAXSD,	yxm,	Pf2, 0x5f },
   881  	{ AMAXSS,	yxm,	Pf3, 0x5f },
   882  	{ AMINPD,	yxm,	Pe, 0x5d },
   883  	{ AMINPS,	yxm,	Pm, 0x5d },
   884  	{ AMINSD,	yxm,	Pf2, 0x5d },
   885  	{ AMINSS,	yxm,	Pf3, 0x5d },
   886  	{ AMOVAPD,	yxmov,	Pe, 0x28,0x29 },
   887  	{ AMOVAPS,	yxmov,	Pm, 0x28,0x29 },
   888  	{ AMOVB,	ymovb,	Pb, 0x88,0x8a,0xb0,0xc6,(00) },
   889  	{ AMOVBLSX,	ymb_rl,	Pm, 0xbe },
   890  	{ AMOVBLZX,	ymb_rl,	Pm, 0xb6 },
   891  	{ AMOVBQSX,	ymb_rl,	Pw, 0x0f,0xbe },
   892  	{ AMOVBQZX,	ymb_rl,	Pw, 0x0f,0xb6 },
   893  	{ AMOVBWSX,	ymb_rl,	Pq, 0xbe },
   894  	{ AMOVBWZX,	ymb_rl,	Pq, 0xb6 },
   895  	{ AMOVO,	yxmov,	Pe, 0x6f,0x7f },
   896  	{ AMOVOU,	yxmov,	Pf3, 0x6f,0x7f },
   897  	{ AMOVHLPS,	yxr,	Pm, 0x12 },
   898  	{ AMOVHPD,	yxmov,	Pe, 0x16,0x17 },
   899  	{ AMOVHPS,	yxmov,	Pm, 0x16,0x17 },
   900  	{ AMOVL,	ymovl,	Px, 0x89,0x8b,0x31,0xb8,0xc7,(00),0x6e,0x7e,Pe,0x6e,Pe,0x7e },
   901  	{ AMOVLHPS,	yxr,	Pm, 0x16 },
   902  	{ AMOVLPD,	yxmov,	Pe, 0x12,0x13 },
   903  	{ AMOVLPS,	yxmov,	Pm, 0x12,0x13 },
   904  	{ AMOVLQSX,	yml_rl,	Pw, 0x63 },
   905  	{ AMOVLQZX,	yml_rl,	Px, 0x8b },
   906  	{ AMOVMSKPD,	yxrrl,	Pq, 0x50 },
   907  	{ AMOVMSKPS,	yxrrl,	Pm, 0x50 },
   908  	{ AMOVNTO,	yxr_ml,	Pe, 0xe7 },
   909  	{ AMOVNTPD,	yxr_ml,	Pe, 0x2b },
   910  	{ AMOVNTPS,	yxr_ml,	Pm, 0x2b },
   911  	{ AMOVNTQ,	ymr_ml,	Pm, 0xe7 },
   912  	{ AMOVQ,	ymovq,	Pw, 0x89, 0x8b, 0x31, 0xc7,(00), 0xb8, 0xc7,(00), 0x6f, 0x7f, 0x6e, 0x7e, Pf2,0xd6, Pf3,0x7e, Pe,0xd6, Pe,0x6e, Pe,0x7e },
   913  	{ AMOVQOZX,	ymrxr,	Pf3, 0xd6,0x7e },
   914  	{ AMOVSB,	ynone,	Pb, 0xa4 },
   915  	{ AMOVSD,	yxmov,	Pf2, 0x10,0x11 },
   916  	{ AMOVSL,	ynone,	Px, 0xa5 },
   917  	{ AMOVSQ,	ynone,	Pw, 0xa5 },
   918  	{ AMOVSS,	yxmov,	Pf3, 0x10,0x11 },
   919  	{ AMOVSW,	ynone,	Pe, 0xa5 },
   920  	{ AMOVUPD,	yxmov,	Pe, 0x10,0x11 },
   921  	{ AMOVUPS,	yxmov,	Pm, 0x10,0x11 },
   922  	{ AMOVW,	ymovw,	Pe, 0x89,0x8b,0x31,0xb8,0xc7,(00) },
   923  	{ AMOVWLSX,	yml_rl,	Pm, 0xbf },
   924  	{ AMOVWLZX,	yml_rl,	Pm, 0xb7 },
   925  	{ AMOVWQSX,	yml_rl,	Pw, 0x0f,0xbf },
   926  	{ AMOVWQZX,	yml_rl,	Pw, 0x0f,0xb7 },
   927  	{ AMULB,	ydivb,	Pb, 0xf6,(04) },
   928  	{ AMULL,	ydivl,	Px, 0xf7,(04) },
   929  	{ AMULPD,	yxm,	Pe, 0x59 },
   930  	{ AMULPS,	yxm,	Ym, 0x59 },
   931  	{ AMULQ,	ydivl,	Pw, 0xf7,(04) },
   932  	{ AMULSD,	yxm,	Pf2, 0x59 },
   933  	{ AMULSS,	yxm,	Pf3, 0x59 },
   934  	{ AMULW,	ydivl,	Pe, 0xf7,(04) },
   935  	{ ANAME },
   936  	{ ANEGB,	yscond,	Pb, 0xf6,(03) },
   937  	{ ANEGL,	yscond,	Px, 0xf7,(03) },
   938  	{ ANEGQ,	yscond,	Pw, 0xf7,(03) },
   939  	{ ANEGW,	yscond,	Pe, 0xf7,(03) },
   940  	{ ANOP,		ynop,	Px, 0,0 },
   941  	{ ANOTB,	yscond,	Pb, 0xf6,(02) },
   942  	{ ANOTL,	yscond,	Px, 0xf7,(02) },
   943  	{ ANOTQ,	yscond,	Pw, 0xf7,(02) },
   944  	{ ANOTW,	yscond,	Pe, 0xf7,(02) },
   945  	{ AORB,		yxorb,	Pb, 0x0c,0x80,(01),0x08,0x0a },
   946  	{ AORL,		yxorl,	Px, 0x83,(01),0x0d,0x81,(01),0x09,0x0b },
   947  	{ AORPD,	yxm,	Pq, 0x56 },
   948  	{ AORPS,	yxm,	Pm, 0x56 },
   949  	{ AORQ,		yxorl,	Pw, 0x83,(01),0x0d,0x81,(01),0x09,0x0b },
   950  	{ AORW,		yxorl,	Pe, 0x83,(01),0x0d,0x81,(01),0x09,0x0b },
   951  	{ AOUTB,	yin,	Pb, 0xe6,0xee },
   952  	{ AOUTL,	yin,	Px, 0xe7,0xef },
   953  	{ AOUTSB,	ynone,	Pb, 0x6e },
   954  	{ AOUTSL,	ynone,	Px, 0x6f },
   955  	{ AOUTSW,	ynone,	Pe, 0x6f },
   956  	{ AOUTW,	yin,	Pe, 0xe7,0xef },
   957  	{ APACKSSLW,	ymm,	Py, 0x6b,Pe,0x6b },
   958  	{ APACKSSWB,	ymm,	Py, 0x63,Pe,0x63 },
   959  	{ APACKUSWB,	ymm,	Py, 0x67,Pe,0x67 },
   960  	{ APADDB,	ymm,	Py, 0xfc,Pe,0xfc },
   961  	{ APADDL,	ymm,	Py, 0xfe,Pe,0xfe },
   962  	{ APADDQ,	yxm,	Pe, 0xd4 },
   963  	{ APADDSB,	ymm,	Py, 0xec,Pe,0xec },
   964  	{ APADDSW,	ymm,	Py, 0xed,Pe,0xed },
   965  	{ APADDUSB,	ymm,	Py, 0xdc,Pe,0xdc },
   966  	{ APADDUSW,	ymm,	Py, 0xdd,Pe,0xdd },
   967  	{ APADDW,	ymm,	Py, 0xfd,Pe,0xfd },
   968  	{ APAND,	ymm,	Py, 0xdb,Pe,0xdb },
   969  	{ APANDN,	ymm,	Py, 0xdf,Pe,0xdf },
   970  	{ APAUSE,	ynone,	Px, 0xf3,0x90 },
   971  	{ APAVGB,	ymm,	Py, 0xe0,Pe,0xe0 },
   972  	{ APAVGW,	ymm,	Py, 0xe3,Pe,0xe3 },
   973  	{ APCMPEQB,	ymm,	Py, 0x74,Pe,0x74 },
   974  	{ APCMPEQL,	ymm,	Py, 0x76,Pe,0x76 },
   975  	{ APCMPEQW,	ymm,	Py, 0x75,Pe,0x75 },
   976  	{ APCMPGTB,	ymm,	Py, 0x64,Pe,0x64 },
   977  	{ APCMPGTL,	ymm,	Py, 0x66,Pe,0x66 },
   978  	{ APCMPGTW,	ymm,	Py, 0x65,Pe,0x65 },
   979  	{ APEXTRW,	yextrw,	Pq, 0xc5,(00) },
   980  	{ APF2IL,	ymfp,	Px, 0x1d },
   981  	{ APF2IW,	ymfp,	Px, 0x1c },
   982  	{ API2FL,	ymfp,	Px, 0x0d },
   983  	{ APFACC,	ymfp,	Px, 0xae },
   984  	{ APFADD,	ymfp,	Px, 0x9e },
   985  	{ APFCMPEQ,	ymfp,	Px, 0xb0 },
   986  	{ APFCMPGE,	ymfp,	Px, 0x90 },
   987  	{ APFCMPGT,	ymfp,	Px, 0xa0 },
   988  	{ APFMAX,	ymfp,	Px, 0xa4 },
   989  	{ APFMIN,	ymfp,	Px, 0x94 },
   990  	{ APFMUL,	ymfp,	Px, 0xb4 },
   991  	{ APFNACC,	ymfp,	Px, 0x8a },
   992  	{ APFPNACC,	ymfp,	Px, 0x8e },
   993  	{ APFRCP,	ymfp,	Px, 0x96 },
   994  	{ APFRCPIT1,	ymfp,	Px, 0xa6 },
   995  	{ APFRCPI2T,	ymfp,	Px, 0xb6 },
   996  	{ APFRSQIT1,	ymfp,	Px, 0xa7 },
   997  	{ APFRSQRT,	ymfp,	Px, 0x97 },
   998  	{ APFSUB,	ymfp,	Px, 0x9a },
   999  	{ APFSUBR,	ymfp,	Px, 0xaa },
  1000  	{ APINSRW,	yinsrw,	Pq, 0xc4,(00) },
  1001  	{ APINSRD,	yinsr,	Pq, 0x3a, 0x22, (00) },
  1002  	{ APINSRQ,	yinsr,	Pq3, 0x3a, 0x22, (00) },
  1003  	{ APMADDWL,	ymm,	Py, 0xf5,Pe,0xf5 },
  1004  	{ APMAXSW,	yxm,	Pe, 0xee },
  1005  	{ APMAXUB,	yxm,	Pe, 0xde },
  1006  	{ APMINSW,	yxm,	Pe, 0xea },
  1007  	{ APMINUB,	yxm,	Pe, 0xda },
  1008  	{ APMOVMSKB,	ymskb,	Px, Pe,0xd7,0xd7 },
  1009  	{ APMULHRW,	ymfp,	Px, 0xb7 },
  1010  	{ APMULHUW,	ymm,	Py, 0xe4,Pe,0xe4 },
  1011  	{ APMULHW,	ymm,	Py, 0xe5,Pe,0xe5 },
  1012  	{ APMULLW,	ymm,	Py, 0xd5,Pe,0xd5 },
  1013  	{ APMULULQ,	ymm,	Py, 0xf4,Pe,0xf4 },
  1014  	{ APOPAL,	ynone,	P32, 0x61 },
  1015  	{ APOPAW,	ynone,	Pe, 0x61 },
  1016  	{ APOPFL,	ynone,	P32, 0x9d },
  1017  	{ APOPFQ,	ynone,	Py, 0x9d },
  1018  	{ APOPFW,	ynone,	Pe, 0x9d },
  1019  	{ APOPL,	ypopl,	P32, 0x58,0x8f,(00) },
  1020  	{ APOPQ,	ypopl,	Py, 0x58,0x8f,(00) },
  1021  	{ APOPW,	ypopl,	Pe, 0x58,0x8f,(00) },
  1022  	{ APOR,		ymm,	Py, 0xeb,Pe,0xeb },
  1023  	{ APSADBW,	yxm,	Pq, 0xf6 },
  1024  	{ APSHUFHW,	yxshuf,	Pf3, 0x70,(00) },
  1025  	{ APSHUFL,	yxshuf,	Pq, 0x70,(00) },
  1026  	{ APSHUFLW,	yxshuf,	Pf2, 0x70,(00) },
  1027  	{ APSHUFW,	ymshuf,	Pm, 0x70,(00) },
  1028  	{ APSHUFB,	ymshufb,Pq, 0x38, 0x00 },
  1029  	{ APSLLO,	ypsdq,	Pq, 0x73,(07) },
  1030  	{ APSLLL,	yps,	Py, 0xf2, 0x72,(06), Pe,0xf2, Pe,0x72,(06) },
  1031  	{ APSLLQ,	yps,	Py, 0xf3, 0x73,(06), Pe,0xf3, Pe,0x73,(06) },
  1032  	{ APSLLW,	yps,	Py, 0xf1, 0x71,(06), Pe,0xf1, Pe,0x71,(06) },
  1033  	{ APSRAL,	yps,	Py, 0xe2, 0x72,(04), Pe,0xe2, Pe,0x72,(04) },
  1034  	{ APSRAW,	yps,	Py, 0xe1, 0x71,(04), Pe,0xe1, Pe,0x71,(04) },
  1035  	{ APSRLO,	ypsdq,	Pq, 0x73,(03) },
  1036  	{ APSRLL,	yps,	Py, 0xd2, 0x72,(02), Pe,0xd2, Pe,0x72,(02) },
  1037  	{ APSRLQ,	yps,	Py, 0xd3, 0x73,(02), Pe,0xd3, Pe,0x73,(02) },
  1038  	{ APSRLW,	yps,	Py, 0xd1, 0x71,(02), Pe,0xe1, Pe,0x71,(02) },
  1039  	{ APSUBB,	yxm,	Pe, 0xf8 },
  1040  	{ APSUBL,	yxm,	Pe, 0xfa },
  1041  	{ APSUBQ,	yxm,	Pe, 0xfb },
  1042  	{ APSUBSB,	yxm,	Pe, 0xe8 },
  1043  	{ APSUBSW,	yxm,	Pe, 0xe9 },
  1044  	{ APSUBUSB,	yxm,	Pe, 0xd8 },
  1045  	{ APSUBUSW,	yxm,	Pe, 0xd9 },
  1046  	{ APSUBW,	yxm,	Pe, 0xf9 },
  1047  	{ APSWAPL,	ymfp,	Px, 0xbb },
  1048  	{ APUNPCKHBW,	ymm,	Py, 0x68,Pe,0x68 },
  1049  	{ APUNPCKHLQ,	ymm,	Py, 0x6a,Pe,0x6a },
  1050  	{ APUNPCKHQDQ,	yxm,	Pe, 0x6d },
  1051  	{ APUNPCKHWL,	ymm,	Py, 0x69,Pe,0x69 },
  1052  	{ APUNPCKLBW,	ymm,	Py, 0x60,Pe,0x60 },
  1053  	{ APUNPCKLLQ,	ymm,	Py, 0x62,Pe,0x62 },
  1054  	{ APUNPCKLQDQ,	yxm,	Pe, 0x6c },
  1055  	{ APUNPCKLWL,	ymm,	Py, 0x61,Pe,0x61 },
  1056  	{ APUSHAL,	ynone,	P32, 0x60 },
  1057  	{ APUSHAW,	ynone,	Pe, 0x60 },
  1058  	{ APUSHFL,	ynone,	P32, 0x9c },
  1059  	{ APUSHFQ,	ynone,	Py, 0x9c },
  1060  	{ APUSHFW,	ynone,	Pe, 0x9c },
  1061  	{ APUSHL,	ypushl,	P32, 0x50,0xff,(06),0x6a,0x68 },
  1062  	{ APUSHQ,	ypushl,	Py, 0x50,0xff,(06),0x6a,0x68 },
  1063  	{ APUSHW,	ypushl,	Pe, 0x50,0xff,(06),0x6a,0x68 },
  1064  	{ APXOR,	ymm,	Py, 0xef,Pe,0xef },
  1065  	{ AQUAD,	ybyte,	Px, 8 },
  1066  	{ ARCLB,	yshb,	Pb, 0xd0,(02),0xc0,(02),0xd2,(02) },
  1067  	{ ARCLL,	yshl,	Px, 0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02) },
  1068  	{ ARCLQ,	yshl,	Pw, 0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02) },
  1069  	{ ARCLW,	yshl,	Pe, 0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02) },
  1070  	{ ARCPPS,	yxm,	Pm, 0x53 },
  1071  	{ ARCPSS,	yxm,	Pf3, 0x53 },
  1072  	{ ARCRB,	yshb,	Pb, 0xd0,(03),0xc0,(03),0xd2,(03) },
  1073  	{ ARCRL,	yshl,	Px, 0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03) },
  1074  	{ ARCRQ,	yshl,	Pw, 0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03) },
  1075  	{ ARCRW,	yshl,	Pe, 0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03) },
  1076  	{ AREP,		ynone,	Px, 0xf3 },
  1077  	{ AREPN,	ynone,	Px, 0xf2 },
  1078  	{ ARET,		ynone,	Px, 0xc3 },
  1079  	{ ARETFW,	yret,	Pe, 0xcb,0xca },
  1080  	{ ARETFL,	yret,	Px, 0xcb,0xca },
  1081  	{ ARETFQ,	yret,	Pw, 0xcb,0xca },
  1082  	{ AROLB,	yshb,	Pb, 0xd0,(00),0xc0,(00),0xd2,(00) },
  1083  	{ AROLL,	yshl,	Px, 0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00) },
  1084  	{ AROLQ,	yshl,	Pw, 0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00) },
  1085  	{ AROLW,	yshl,	Pe, 0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00) },
  1086  	{ ARORB,	yshb,	Pb, 0xd0,(01),0xc0,(01),0xd2,(01) },
  1087  	{ ARORL,	yshl,	Px, 0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01) },
  1088  	{ ARORQ,	yshl,	Pw, 0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01) },
  1089  	{ ARORW,	yshl,	Pe, 0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01) },
  1090  	{ ARSQRTPS,	yxm,	Pm, 0x52 },
  1091  	{ ARSQRTSS,	yxm,	Pf3, 0x52 },
  1092  	{ ASAHF,	ynone,	Px, 0x86,0xe0,0x50,0x9d },	/* XCHGB AH,AL; PUSH AX; POPFL */
  1093  	{ ASALB,	yshb,	Pb, 0xd0,(04),0xc0,(04),0xd2,(04) },
  1094  	{ ASALL,	yshl,	Px, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
  1095  	{ ASALQ,	yshl,	Pw, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
  1096  	{ ASALW,	yshl,	Pe, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
  1097  	{ ASARB,	yshb,	Pb, 0xd0,(07),0xc0,(07),0xd2,(07) },
  1098  	{ ASARL,	yshl,	Px, 0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07) },
  1099  	{ ASARQ,	yshl,	Pw, 0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07) },
  1100  	{ ASARW,	yshl,	Pe, 0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07) },
  1101  	{ ASBBB,	yxorb,	Pb, 0x1c,0x80,(03),0x18,0x1a },
  1102  	{ ASBBL,	yxorl,	Px, 0x83,(03),0x1d,0x81,(03),0x19,0x1b },
  1103  	{ ASBBQ,	yxorl,	Pw, 0x83,(03),0x1d,0x81,(03),0x19,0x1b },
  1104  	{ ASBBW,	yxorl,	Pe, 0x83,(03),0x1d,0x81,(03),0x19,0x1b },
  1105  	{ ASCASB,	ynone,	Pb, 0xae },
  1106  	{ ASCASL,	ynone,	Px, 0xaf },
  1107  	{ ASCASQ,	ynone,	Pw, 0xaf },
  1108  	{ ASCASW,	ynone,	Pe, 0xaf },
  1109  	{ ASETCC,	yscond,	Pm, 0x93,(00) },
  1110  	{ ASETCS,	yscond,	Pm, 0x92,(00) },
  1111  	{ ASETEQ,	yscond,	Pm, 0x94,(00) },
  1112  	{ ASETGE,	yscond,	Pm, 0x9d,(00) },
  1113  	{ ASETGT,	yscond,	Pm, 0x9f,(00) },
  1114  	{ ASETHI,	yscond,	Pm, 0x97,(00) },
  1115  	{ ASETLE,	yscond,	Pm, 0x9e,(00) },
  1116  	{ ASETLS,	yscond,	Pm, 0x96,(00) },
  1117  	{ ASETLT,	yscond,	Pm, 0x9c,(00) },
  1118  	{ ASETMI,	yscond,	Pm, 0x98,(00) },
  1119  	{ ASETNE,	yscond,	Pm, 0x95,(00) },
  1120  	{ ASETOC,	yscond,	Pm, 0x91,(00) },
  1121  	{ ASETOS,	yscond,	Pm, 0x90,(00) },
  1122  	{ ASETPC,	yscond,	Pm, 0x96,(00) },
  1123  	{ ASETPL,	yscond,	Pm, 0x99,(00) },
  1124  	{ ASETPS,	yscond,	Pm, 0x9a,(00) },
  1125  	{ ASHLB,	yshb,	Pb, 0xd0,(04),0xc0,(04),0xd2,(04) },
  1126  	{ ASHLL,	yshl,	Px, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
  1127  	{ ASHLQ,	yshl,	Pw, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
  1128  	{ ASHLW,	yshl,	Pe, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
  1129  	{ ASHRB,	yshb,	Pb, 0xd0,(05),0xc0,(05),0xd2,(05) },
  1130  	{ ASHRL,	yshl,	Px, 0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05) },
  1131  	{ ASHRQ,	yshl,	Pw, 0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05) },
  1132  	{ ASHRW,	yshl,	Pe, 0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05) },
  1133  	{ ASHUFPD,	yxshuf,	Pq, 0xc6,(00) },
  1134  	{ ASHUFPS,	yxshuf,	Pm, 0xc6,(00) },
  1135  	{ ASQRTPD,	yxm,	Pe, 0x51 },
  1136  	{ ASQRTPS,	yxm,	Pm, 0x51 },
  1137  	{ ASQRTSD,	yxm,	Pf2, 0x51 },
  1138  	{ ASQRTSS,	yxm,	Pf3, 0x51 },
  1139  	{ ASTC,		ynone,	Px, 0xf9 },
  1140  	{ ASTD,		ynone,	Px, 0xfd },
  1141  	{ ASTI,		ynone,	Px, 0xfb },
  1142  	{ ASTMXCSR,	ysvrs,	Pm, 0xae,(03),0xae,(03) },
  1143  	{ ASTOSB,	ynone,	Pb, 0xaa },
  1144  	{ ASTOSL,	ynone,	Px, 0xab },
  1145  	{ ASTOSQ,	ynone,	Pw, 0xab },
  1146  	{ ASTOSW,	ynone,	Pe, 0xab },
  1147  	{ ASUBB,	yxorb,	Pb, 0x2c,0x80,(05),0x28,0x2a },
  1148  	{ ASUBL,	yaddl,	Px, 0x83,(05),0x2d,0x81,(05),0x29,0x2b },
  1149  	{ ASUBPD,	yxm,	Pe, 0x5c },
  1150  	{ ASUBPS,	yxm,	Pm, 0x5c },
  1151  	{ ASUBQ,	yaddl,	Pw, 0x83,(05),0x2d,0x81,(05),0x29,0x2b },
  1152  	{ ASUBSD,	yxm,	Pf2, 0x5c },
  1153  	{ ASUBSS,	yxm,	Pf3, 0x5c },
  1154  	{ ASUBW,	yaddl,	Pe, 0x83,(05),0x2d,0x81,(05),0x29,0x2b },
  1155  	{ ASWAPGS,	ynone,	Pm, 0x01,0xf8 },
  1156  	{ ASYSCALL,	ynone,	Px, 0x0f,0x05 },	/* fast syscall */
  1157  	{ ATESTB,	ytestb,	Pb, 0xa8,0xf6,(00),0x84,0x84 },
  1158  	{ ATESTL,	ytestl,	Px, 0xa9,0xf7,(00),0x85,0x85 },
  1159  	{ ATESTQ,	ytestl,	Pw, 0xa9,0xf7,(00),0x85,0x85 },
  1160  	{ ATESTW,	ytestl,	Pe, 0xa9,0xf7,(00),0x85,0x85 },
  1161  	{ ATEXT,	ytext,	Px },
  1162  	{ AUCOMISD,	yxcmp,	Pe, 0x2e },
  1163  	{ AUCOMISS,	yxcmp,	Pm, 0x2e },
  1164  	{ AUNPCKHPD,	yxm,	Pe, 0x15 },
  1165  	{ AUNPCKHPS,	yxm,	Pm, 0x15 },
  1166  	{ AUNPCKLPD,	yxm,	Pe, 0x14 },
  1167  	{ AUNPCKLPS,	yxm,	Pm, 0x14 },
  1168  	{ AVERR,	ydivl,	Pm, 0x00,(04) },
  1169  	{ AVERW,	ydivl,	Pm, 0x00,(05) },
  1170  	{ AWAIT,	ynone,	Px, 0x9b },
  1171  	{ AWORD,	ybyte,	Px, 2 },
  1172  	{ AXCHGB,	yml_mb,	Pb, 0x86,0x86 },
  1173  	{ AXCHGL,	yml_ml,	Px, 0x87,0x87 },
  1174  	{ AXCHGQ,	yml_ml,	Pw, 0x87,0x87 },
  1175  	{ AXCHGW,	yml_ml,	Pe, 0x87,0x87 },
  1176  	{ AXLAT,	ynone,	Px, 0xd7 },
  1177  	{ AXORB,	yxorb,	Pb, 0x34,0x80,(06),0x30,0x32 },
  1178  	{ AXORL,	yxorl,	Px, 0x83,(06),0x35,0x81,(06),0x31,0x33 },
  1179  	{ AXORPD,	yxm,	Pe, 0x57 },
  1180  	{ AXORPS,	yxm,	Pm, 0x57 },
  1181  	{ AXORQ,	yxorl,	Pw, 0x83,(06),0x35,0x81,(06),0x31,0x33 },
  1182  	{ AXORW,	yxorl,	Pe, 0x83,(06),0x35,0x81,(06),0x31,0x33 },
  1183  
  1184  	{ AFMOVB,	yfmvx,	Px, 0xdf,(04) },
  1185  	{ AFMOVBP,	yfmvp,	Px, 0xdf,(06) },
  1186  	{ AFMOVD,	yfmvd,	Px, 0xdd,(00),0xdd,(02),0xd9,(00),0xdd,(02) },
  1187  	{ AFMOVDP,	yfmvdp,	Px, 0xdd,(03),0xdd,(03) },
  1188  	{ AFMOVF,	yfmvf,	Px, 0xd9,(00),0xd9,(02) },
  1189  	{ AFMOVFP,	yfmvp,	Px, 0xd9,(03) },
  1190  	{ AFMOVL,	yfmvf,	Px, 0xdb,(00),0xdb,(02) },
  1191  	{ AFMOVLP,	yfmvp,	Px, 0xdb,(03) },
  1192  	{ AFMOVV,	yfmvx,	Px, 0xdf,(05) },
  1193  	{ AFMOVVP,	yfmvp,	Px, 0xdf,(07) },
  1194  	{ AFMOVW,	yfmvf,	Px, 0xdf,(00),0xdf,(02) },
  1195  	{ AFMOVWP,	yfmvp,	Px, 0xdf,(03) },
  1196  	{ AFMOVX,	yfmvx,	Px, 0xdb,(05) },
  1197  	{ AFMOVXP,	yfmvp,	Px, 0xdb,(07) },
  1198  
  1199  	{ AFCOMB },
  1200  	{ AFCOMBP },
  1201  	{ AFCOMD,	yfadd,	Px, 0xdc,(02),0xd8,(02),0xdc,(02) },	/* botch */
  1202  	{ AFCOMDP,	yfadd,	Px, 0xdc,(03),0xd8,(03),0xdc,(03) },	/* botch */
  1203  	{ AFCOMDPP,	ycompp,	Px, 0xde,(03) },
  1204  	{ AFCOMF,	yfmvx,	Px, 0xd8,(02) },
  1205  	{ AFCOMFP,	yfmvx,	Px, 0xd8,(03) },
  1206  	{ AFCOML,	yfmvx,	Px, 0xda,(02) },
  1207  	{ AFCOMLP,	yfmvx,	Px, 0xda,(03) },
  1208  	{ AFCOMW,	yfmvx,	Px, 0xde,(02) },
  1209  	{ AFCOMWP,	yfmvx,	Px, 0xde,(03) },
  1210  
  1211  	{ AFUCOM,	ycompp,	Px, 0xdd,(04) },
  1212  	{ AFUCOMP,	ycompp, Px, 0xdd,(05) },
  1213  	{ AFUCOMPP,	ycompp,	Px, 0xda,(13) },
  1214  
  1215  	{ AFADDDP,	yfaddp,	Px, 0xde,(00) },
  1216  	{ AFADDW,	yfmvx,	Px, 0xde,(00) },
  1217  	{ AFADDL,	yfmvx,	Px, 0xda,(00) },
  1218  	{ AFADDF,	yfmvx,	Px, 0xd8,(00) },
  1219  	{ AFADDD,	yfadd,	Px, 0xdc,(00),0xd8,(00),0xdc,(00) },
  1220  
  1221  	{ AFMULDP,	yfaddp,	Px, 0xde,(01) },
  1222  	{ AFMULW,	yfmvx,	Px, 0xde,(01) },
  1223  	{ AFMULL,	yfmvx,	Px, 0xda,(01) },
  1224  	{ AFMULF,	yfmvx,	Px, 0xd8,(01) },
  1225  	{ AFMULD,	yfadd,	Px, 0xdc,(01),0xd8,(01),0xdc,(01) },
  1226  
  1227  	{ AFSUBDP,	yfaddp,	Px, 0xde,(05) },
  1228  	{ AFSUBW,	yfmvx,	Px, 0xde,(04) },
  1229  	{ AFSUBL,	yfmvx,	Px, 0xda,(04) },
  1230  	{ AFSUBF,	yfmvx,	Px, 0xd8,(04) },
  1231  	{ AFSUBD,	yfadd,	Px, 0xdc,(04),0xd8,(04),0xdc,(05) },
  1232  
  1233  	{ AFSUBRDP,	yfaddp,	Px, 0xde,(04) },
  1234  	{ AFSUBRW,	yfmvx,	Px, 0xde,(05) },
  1235  	{ AFSUBRL,	yfmvx,	Px, 0xda,(05) },
  1236  	{ AFSUBRF,	yfmvx,	Px, 0xd8,(05) },
  1237  	{ AFSUBRD,	yfadd,	Px, 0xdc,(05),0xd8,(05),0xdc,(04) },
  1238  
  1239  	{ AFDIVDP,	yfaddp,	Px, 0xde,(07) },
  1240  	{ AFDIVW,	yfmvx,	Px, 0xde,(06) },
  1241  	{ AFDIVL,	yfmvx,	Px, 0xda,(06) },
  1242  	{ AFDIVF,	yfmvx,	Px, 0xd8,(06) },
  1243  	{ AFDIVD,	yfadd,	Px, 0xdc,(06),0xd8,(06),0xdc,(07) },
  1244  
  1245  	{ AFDIVRDP,	yfaddp,	Px, 0xde,(06) },
  1246  	{ AFDIVRW,	yfmvx,	Px, 0xde,(07) },
  1247  	{ AFDIVRL,	yfmvx,	Px, 0xda,(07) },
  1248  	{ AFDIVRF,	yfmvx,	Px, 0xd8,(07) },
  1249  	{ AFDIVRD,	yfadd,	Px, 0xdc,(07),0xd8,(07),0xdc,(06) },
  1250  
  1251  	{ AFXCHD,	yfxch,	Px, 0xd9,(01),0xd9,(01) },
  1252  	{ AFFREE },
  1253  	{ AFLDCW,	ystcw,	Px, 0xd9,(05),0xd9,(05) },
  1254  	{ AFLDENV,	ystcw,	Px, 0xd9,(04),0xd9,(04) },
  1255  	{ AFRSTOR,	ysvrs,	Px, 0xdd,(04),0xdd,(04) },
  1256  	{ AFSAVE,	ysvrs,	Px, 0xdd,(06),0xdd,(06) },
  1257  	{ AFSTCW,	ystcw,	Px, 0xd9,(07),0xd9,(07) },
  1258  	{ AFSTENV,	ystcw,	Px, 0xd9,(06),0xd9,(06) },
  1259  	{ AFSTSW,	ystsw,	Px, 0xdd,(07),0xdf,0xe0 },
  1260  	{ AF2XM1,	ynone,	Px, 0xd9, 0xf0 },
  1261  	{ AFABS,	ynone,	Px, 0xd9, 0xe1 },
  1262  	{ AFCHS,	ynone,	Px, 0xd9, 0xe0 },
  1263  	{ AFCLEX,	ynone,	Px, 0xdb, 0xe2 },
  1264  	{ AFCOS,	ynone,	Px, 0xd9, 0xff },
  1265  	{ AFDECSTP,	ynone,	Px, 0xd9, 0xf6 },
  1266  	{ AFINCSTP,	ynone,	Px, 0xd9, 0xf7 },
  1267  	{ AFINIT,	ynone,	Px, 0xdb, 0xe3 },
  1268  	{ AFLD1,	ynone,	Px, 0xd9, 0xe8 },
  1269  	{ AFLDL2E,	ynone,	Px, 0xd9, 0xea },
  1270  	{ AFLDL2T,	ynone,	Px, 0xd9, 0xe9 },
  1271  	{ AFLDLG2,	ynone,	Px, 0xd9, 0xec },
  1272  	{ AFLDLN2,	ynone,	Px, 0xd9, 0xed },
  1273  	{ AFLDPI,	ynone,	Px, 0xd9, 0xeb },
  1274  	{ AFLDZ,	ynone,	Px, 0xd9, 0xee },
  1275  	{ AFNOP,	ynone,	Px, 0xd9, 0xd0 },
  1276  	{ AFPATAN,	ynone,	Px, 0xd9, 0xf3 },
  1277  	{ AFPREM,	ynone,	Px, 0xd9, 0xf8 },
  1278  	{ AFPREM1,	ynone,	Px, 0xd9, 0xf5 },
  1279  	{ AFPTAN,	ynone,	Px, 0xd9, 0xf2 },
  1280  	{ AFRNDINT,	ynone,	Px, 0xd9, 0xfc },
  1281  	{ AFSCALE,	ynone,	Px, 0xd9, 0xfd },
  1282  	{ AFSIN,	ynone,	Px, 0xd9, 0xfe },
  1283  	{ AFSINCOS,	ynone,	Px, 0xd9, 0xfb },
  1284  	{ AFSQRT,	ynone,	Px, 0xd9, 0xfa },
  1285  	{ AFTST,	ynone,	Px, 0xd9, 0xe4 },
  1286  	{ AFXAM,	ynone,	Px, 0xd9, 0xe5 },
  1287  	{ AFXTRACT,	ynone,	Px, 0xd9, 0xf4 },
  1288  	{ AFYL2X,	ynone,	Px, 0xd9, 0xf1 },
  1289  	{ AFYL2XP1,	ynone,	Px, 0xd9, 0xf9 },
  1290  
  1291  	{ ACMPXCHGB,	yrb_mb,	Pb, 0x0f,0xb0 },
  1292  	{ ACMPXCHGL,	yrl_ml,	Px, 0x0f,0xb1 },
  1293  	{ ACMPXCHGW,	yrl_ml,	Pe, 0x0f,0xb1 },
  1294  	{ ACMPXCHGQ,	yrl_ml,	Pw, 0x0f,0xb1 },
  1295  	{ ACMPXCHG8B,	yscond,	Pm, 0xc7,(01) },
  1296  	{ AINVD,	ynone,	Pm, 0x08 },
  1297  	{ AINVLPG,	ymbs,	Pm, 0x01,(07) },
  1298  	{ ALFENCE,	ynone,	Pm, 0xae,0xe8 },
  1299  	{ AMFENCE,	ynone,	Pm, 0xae,0xf0 },
  1300  	{ AMOVNTIL,	yrl_ml,	Pm, 0xc3 },
  1301  	{ AMOVNTIQ,	yrl_ml, Pw, 0x0f,0xc3 },
  1302  	{ ARDMSR,	ynone,	Pm, 0x32 },
  1303  	{ ARDPMC,	ynone,	Pm, 0x33 },
  1304  	{ ARDTSC,	ynone,	Pm, 0x31 },
  1305  	{ ARSM,		ynone,	Pm, 0xaa },
  1306  	{ ASFENCE,	ynone,	Pm, 0xae,0xf8 },
  1307  	{ ASYSRET,	ynone,	Pm, 0x07 },
  1308  	{ AWBINVD,	ynone,	Pm, 0x09 },
  1309  	{ AWRMSR,	ynone,	Pm, 0x30 },
  1310  
  1311  	{ AXADDB,	yrb_mb,	Pb, 0x0f,0xc0 },
  1312  	{ AXADDL,	yrl_ml,	Px, 0x0f,0xc1 },
  1313  	{ AXADDQ,	yrl_ml,	Pw, 0x0f,0xc1 },
  1314  	{ AXADDW,	yrl_ml,	Pe, 0x0f,0xc1 },
  1315  
  1316  	{ ACRC32B,       ycrc32l,Px, 0xf2,0x0f,0x38,0xf0,0 },
  1317  	{ ACRC32Q,       ycrc32l,Pw, 0xf2,0x0f,0x38,0xf1,0 },
  1318  	
  1319  	{ APREFETCHT0,	yprefetch,	Pm,	0x18,(01) },
  1320  	{ APREFETCHT1,	yprefetch,	Pm,	0x18,(02) },
  1321  	{ APREFETCHT2,	yprefetch,	Pm,	0x18,(03) },
  1322  	{ APREFETCHNTA,	yprefetch,	Pm,	0x18,(00) },
  1323  	
  1324  	{ AMOVQL,	yrl_ml,	Px, 0x89 },
  1325  
  1326  	{ AUNDEF,		ynone,	Px, 0x0f, 0x0b },
  1327  
  1328  	{ AAESENC,	yaes,	Pq, 0x38,0xdc,(0) },
  1329  	{ AAESENCLAST,	yaes,	Pq, 0x38,0xdd,(0) },
  1330  	{ AAESDEC,	yaes,	Pq, 0x38,0xde,(0) },
  1331  	{ AAESDECLAST,	yaes,	Pq, 0x38,0xdf,(0) },
  1332  	{ AAESIMC,	yaes,	Pq, 0x38,0xdb,(0) },
  1333  	{ AAESKEYGENASSIST,	yaes2,	Pq, 0x3a,0xdf,(0) },
  1334  
  1335  	{ APSHUFD,	yaes2,	Pq,	0x70,(0) },
  1336  
  1337  	{ AUSEFIELD,	ynop,	Px, 0,0 },
  1338  	{ ALOCALS },
  1339  	{ ATYPE },
  1340  
  1341  	{ AEND },
  1342  	0
  1343  };
  1344  
  1345  Optab*	opindex[ALAST+1];
  1346  
  1347  /*
  1348  AMOVD	0f 6e/r	mmx,reg/mem32[mem64-rex?]
  1349  AMOVD	0f 7e/r	reg/mem32[64],mmx	STORE
  1350  AMOVQ	0f 6f/r	mmx1,mmx2/mem64
  1351  AMOVQ	0f 7f/r	mmx1/mem64,mmx2
  1352  */