// Inferno utils/8l/span.c // http://code.google.com/p/inferno-os/source/browse/utils/8l/span.c // // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) // Portions Copyright © 1997-1999 Vita Nuova Limited // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) // Portions Copyright © 2004,2006 Bruce Ellis // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others // Portions Copyright © 2009 The Go Authors. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. // Instruction layout. #include #include #include #include #include "../cmd/8l/8.out.h" #include "../runtime/stack.h" enum { MaxAlign = 32, // max data alignment FuncAlign = 16 }; typedef struct Optab Optab; struct Optab { short as; uchar* ytab; uchar prefix; uchar op[13]; }; enum { Yxxx = 0, Ynone, Yi0, Yi1, Yi8, Yi32, Yiauto, Yal, Ycl, Yax, Ycx, Yrb, Yrl, Yrf, Yf0, Yrx, Ymb, Yml, Ym, Ybr, Ycol, Ytls, Ycs, Yss, Yds, Yes, Yfs, Ygs, Ygdtr, Yidtr, Yldtr, Ymsw, Ytask, Ycr0, Ycr1, Ycr2, Ycr3, Ycr4, Ycr5, Ycr6, Ycr7, Ydr0, Ydr1, Ydr2, Ydr3, Ydr4, Ydr5, Ydr6, Ydr7, Ytr0, Ytr1, Ytr2, Ytr3, Ytr4, Ytr5, Ytr6, Ytr7, Ymr, Ymm, Yxr, Yxm, Ymax, Zxxx = 0, Zlit, Zlitm_r, Z_rp, Zbr, Zcall, Zcallcon, Zcallind, Zcallindreg, Zib_, Zib_rp, Zibo_m, Zil_, Zil_rp, Zilo_m, Zjmp, Zjmpcon, Zloop, Zm_o, Zm_r, Zm2_r, Zm_r_xm, Zm_r_i_xm, Zaut_r, Zo_m, Zpseudo, Zr_m, Zr_m_xm, Zr_m_i_xm, Zrp_, Z_ib, Z_il, Zm_ibo, Zm_ilo, Zib_rr, Zil_rr, Zclr, Zibm_r, /* mmx1,mmx2/mem64,imm8 */ Zbyte, Zmov, Zmax, Px = 0, Pe = 0x66, /* operand escape */ Pm = 0x0f, /* 2byte opcode escape */ Pq = 0xff, /* both escape */ Pb = 0xfe, /* byte operands */ Pf2 = 0xf2, /* xmm escape 1 */ Pf3 = 0xf3, /* xmm escape 2 */ }; static uchar ycover[Ymax*Ymax]; static int reg[D_NONE]; static void asmins(Link *ctxt, Prog *p); static uchar ynone[] = { Ynone, Ynone, Zlit, 1, 0 }; static uchar ytext[] = { Ymb, Yi32, Zpseudo,1, 0 }; static uchar ynop[] = { Ynone, Ynone, Zpseudo,0, Ynone, Yiauto, Zpseudo,0, Ynone, Yml, Zpseudo,0, Ynone, Yrf, Zpseudo,0, Yiauto, Ynone, Zpseudo,0, Ynone, Yxr, Zpseudo,0, Yml, Ynone, Zpseudo,0, Yrf, Ynone, Zpseudo,0, Yxr, Ynone, Zpseudo,1, 0 }; static uchar yfuncdata[] = { Yi32, Ym, Zpseudo, 0, 0 }; static uchar ypcdata[] = { Yi32, Yi32, Zpseudo, 0, 0, }; static uchar yxorb[] = { Yi32, Yal, Zib_, 1, Yi32, Ymb, Zibo_m, 2, Yrb, Ymb, Zr_m, 1, Ymb, Yrb, Zm_r, 1, 0 }; static uchar yxorl[] = { Yi8, Yml, Zibo_m, 2, Yi32, Yax, Zil_, 1, Yi32, Yml, Zilo_m, 2, Yrl, Yml, Zr_m, 1, Yml, Yrl, Zm_r, 1, 0 }; static uchar yaddl[] = { Yi8, Yml, Zibo_m, 2, Yi32, Yax, Zil_, 1, Yi32, Yml, Zilo_m, 2, Yrl, Yml, Zr_m, 1, Yml, Yrl, Zm_r, 1, 0 }; static uchar yincb[] = { Ynone, Ymb, Zo_m, 2, 0 }; static uchar yincl[] = { Ynone, Yrl, Z_rp, 1, Ynone, Yml, Zo_m, 2, 0 }; static uchar ycmpb[] = { Yal, Yi32, Z_ib, 1, Ymb, Yi32, Zm_ibo, 2, Ymb, Yrb, Zm_r, 1, Yrb, Ymb, Zr_m, 1, 0 }; static uchar ycmpl[] = { Yml, Yi8, Zm_ibo, 2, Yax, Yi32, Z_il, 1, Yml, Yi32, Zm_ilo, 2, Yml, Yrl, Zm_r, 1, Yrl, Yml, Zr_m, 1, 0 }; static uchar yshb[] = { Yi1, Ymb, Zo_m, 2, Yi32, Ymb, Zibo_m, 2, Ycx, Ymb, Zo_m, 2, 0 }; static uchar yshl[] = { Yi1, Yml, Zo_m, 2, Yi32, Yml, Zibo_m, 2, Ycl, Yml, Zo_m, 2, Ycx, Yml, Zo_m, 2, 0 }; static uchar ytestb[] = { Yi32, Yal, Zib_, 1, Yi32, Ymb, Zibo_m, 2, Yrb, Ymb, Zr_m, 1, Ymb, Yrb, Zm_r, 1, 0 }; static uchar ytestl[] = { Yi32, Yax, Zil_, 1, Yi32, Yml, Zilo_m, 2, Yrl, Yml, Zr_m, 1, Yml, Yrl, Zm_r, 1, 0 }; static uchar ymovb[] = { Yrb, Ymb, Zr_m, 1, Ymb, Yrb, Zm_r, 1, Yi32, Yrb, Zib_rp, 1, Yi32, Ymb, Zibo_m, 2, 0 }; static uchar ymovw[] = { Yrl, Yml, Zr_m, 1, Yml, Yrl, Zm_r, 1, Yi0, Yrl, Zclr, 1+2, // Yi0, Yml, Zibo_m, 2, // shorter but slower AND $0,dst Yi32, Yrl, Zil_rp, 1, Yi32, Yml, Zilo_m, 2, Yiauto, Yrl, Zaut_r, 1, 0 }; static uchar ymovl[] = { Yrl, Yml, Zr_m, 1, Yml, Yrl, Zm_r, 1, Yi0, Yrl, Zclr, 1+2, // Yi0, Yml, Zibo_m, 2, // shorter but slower AND $0,dst Yi32, Yrl, Zil_rp, 1, Yi32, Yml, Zilo_m, 2, Yml, Yxr, Zm_r_xm, 2, // XMM MOVD (32 bit) Yxr, Yml, Zr_m_xm, 2, // XMM MOVD (32 bit) Yiauto, Yrl, Zaut_r, 1, 0 }; static uchar ymovq[] = { Yml, Yxr, Zm_r_xm, 2, 0 }; static uchar ym_rl[] = { Ym, Yrl, Zm_r, 1, 0 }; static uchar yrl_m[] = { Yrl, Ym, Zr_m, 1, 0 }; static uchar ymb_rl[] = { Ymb, Yrl, Zm_r, 1, 0 }; static uchar yml_rl[] = { Yml, Yrl, Zm_r, 1, 0 }; static uchar yrb_mb[] = { Yrb, Ymb, Zr_m, 1, 0 }; static uchar yrl_ml[] = { Yrl, Yml, Zr_m, 1, 0 }; static uchar yml_mb[] = { Yrb, Ymb, Zr_m, 1, Ymb, Yrb, Zm_r, 1, 0 }; static uchar yxchg[] = { Yax, Yrl, Z_rp, 1, Yrl, Yax, Zrp_, 1, Yrl, Yml, Zr_m, 1, Yml, Yrl, Zm_r, 1, 0 }; static uchar ydivl[] = { Yml, Ynone, Zm_o, 2, 0 }; static uchar ydivb[] = { Ymb, Ynone, Zm_o, 2, 0 }; static uchar yimul[] = { Yml, Ynone, Zm_o, 2, Yi8, Yrl, Zib_rr, 1, Yi32, Yrl, Zil_rr, 1, 0 }; static uchar ybyte[] = { Yi32, Ynone, Zbyte, 1, 0 }; static uchar yin[] = { Yi32, Ynone, Zib_, 1, Ynone, Ynone, Zlit, 1, 0 }; static uchar yint[] = { Yi32, Ynone, Zib_, 1, 0 }; static uchar ypushl[] = { Yrl, Ynone, Zrp_, 1, Ym, Ynone, Zm_o, 2, Yi8, Ynone, Zib_, 1, Yi32, Ynone, Zil_, 1, 0 }; static uchar ypopl[] = { Ynone, Yrl, Z_rp, 1, Ynone, Ym, Zo_m, 2, 0 }; static uchar ybswap[] = { Ynone, Yrl, Z_rp, 1, 0, }; static uchar yscond[] = { Ynone, Ymb, Zo_m, 2, 0 }; static uchar yjcond[] = { Ynone, Ybr, Zbr, 0, Yi0, Ybr, Zbr, 0, Yi1, Ybr, Zbr, 1, 0 }; static uchar yloop[] = { Ynone, Ybr, Zloop, 1, 0 }; static uchar ycall[] = { Ynone, Yml, Zcallindreg, 0, Yrx, Yrx, Zcallindreg, 2, Ynone, Ycol, Zcallind, 2, Ynone, Ybr, Zcall, 0, Ynone, Yi32, Zcallcon, 1, 0 }; static uchar yduff[] = { Ynone, Yi32, Zcall, 1, 0 }; static uchar yjmp[] = { Ynone, Yml, Zo_m, 2, Ynone, Ybr, Zjmp, 0, Ynone, Yi32, Zjmpcon, 1, 0 }; static uchar yfmvd[] = { Ym, Yf0, Zm_o, 2, Yf0, Ym, Zo_m, 2, Yrf, Yf0, Zm_o, 2, Yf0, Yrf, Zo_m, 2, 0 }; static uchar yfmvdp[] = { Yf0, Ym, Zo_m, 2, Yf0, Yrf, Zo_m, 2, 0 }; static uchar yfmvf[] = { Ym, Yf0, Zm_o, 2, Yf0, Ym, Zo_m, 2, 0 }; static uchar yfmvx[] = { Ym, Yf0, Zm_o, 2, 0 }; static uchar yfmvp[] = { Yf0, Ym, Zo_m, 2, 0 }; static uchar yfcmv[] = { Yrf, Yf0, Zm_o, 2, 0 }; static uchar yfadd[] = { Ym, Yf0, Zm_o, 2, Yrf, Yf0, Zm_o, 2, Yf0, Yrf, Zo_m, 2, 0 }; static uchar yfaddp[] = { Yf0, Yrf, Zo_m, 2, 0 }; static uchar yfxch[] = { Yf0, Yrf, Zo_m, 2, Yrf, Yf0, Zm_o, 2, 0 }; static uchar ycompp[] = { Yf0, Yrf, Zo_m, 2, /* botch is really f0,f1 */ 0 }; static uchar ystsw[] = { Ynone, Ym, Zo_m, 2, Ynone, Yax, Zlit, 1, 0 }; static uchar ystcw[] = { Ynone, Ym, Zo_m, 2, Ym, Ynone, Zm_o, 2, 0 }; static uchar ysvrs[] = { Ynone, Ym, Zo_m, 2, Ym, Ynone, Zm_o, 2, 0 }; static uchar ymskb[] = { Yxr, Yrl, Zm_r_xm, 2, Ymr, Yrl, Zm_r_xm, 1, 0 }; static uchar yxm[] = { Yxm, Yxr, Zm_r_xm, 1, 0 }; static uchar yxcvm1[] = { Yxm, Yxr, Zm_r_xm, 2, Yxm, Ymr, Zm_r_xm, 2, 0 }; static uchar yxcvm2[] = { Yxm, Yxr, Zm_r_xm, 2, Ymm, Yxr, Zm_r_xm, 2, 0 }; static uchar yxmq[] = { Yxm, Yxr, Zm_r_xm, 2, 0 }; static uchar yxr[] = { Yxr, Yxr, Zm_r_xm, 1, 0 }; static uchar yxr_ml[] = { Yxr, Yml, Zr_m_xm, 1, 0 }; static uchar yxcmp[] = { Yxm, Yxr, Zm_r_xm, 1, 0 }; static uchar yxcmpi[] = { Yxm, Yxr, Zm_r_i_xm, 2, 0 }; static uchar yxmov[] = { Yxm, Yxr, Zm_r_xm, 1, Yxr, Yxm, Zr_m_xm, 1, 0 }; static uchar yxcvfl[] = { Yxm, Yrl, Zm_r_xm, 1, 0 }; static uchar yxcvlf[] = { Yml, Yxr, Zm_r_xm, 1, 0 }; /* static uchar yxcvfq[] = { Yxm, Yrl, Zm_r_xm, 2, 0 }; static uchar yxcvqf[] = { Yml, Yxr, Zm_r_xm, 2, 0 }; */ static uchar yxrrl[] = { Yxr, Yrl, Zm_r, 1, 0 }; static uchar yprefetch[] = { Ym, Ynone, Zm_o, 2, 0, }; static uchar yaes[] = { Yxm, Yxr, Zlitm_r, 2, 0 }; static uchar yinsrd[] = { Yml, Yxr, Zibm_r, 2, 0 }; static uchar ymshufb[] = { Yxm, Yxr, Zm2_r, 2, 0 }; static Optab optab[] = /* as, ytab, andproto, opcode */ { { AXXX }, { AAAA, ynone, Px, {0x37} }, { AAAD, ynone, Px, {0xd5,0x0a} }, { AAAM, ynone, Px, {0xd4,0x0a} }, { AAAS, ynone, Px, {0x3f} }, { AADCB, yxorb, Pb, {0x14,0x80,(02),0x10,0x10} }, { AADCL, yxorl, Px, {0x83,(02),0x15,0x81,(02),0x11,0x13} }, { AADCW, yxorl, Pe, {0x83,(02),0x15,0x81,(02),0x11,0x13} }, { AADDB, yxorb, Px, {0x04,0x80,(00),0x00,0x02} }, { AADDL, yaddl, Px, {0x83,(00),0x05,0x81,(00),0x01,0x03} }, { AADDW, yaddl, Pe, {0x83,(00),0x05,0x81,(00),0x01,0x03} }, { AADJSP }, { AANDB, yxorb, Pb, {0x24,0x80,(04),0x20,0x22} }, { AANDL, yxorl, Px, {0x83,(04),0x25,0x81,(04),0x21,0x23} }, { AANDW, yxorl, Pe, {0x83,(04),0x25,0x81,(04),0x21,0x23} }, { AARPL, yrl_ml, Px, {0x63} }, { ABOUNDL, yrl_m, Px, {0x62} }, { ABOUNDW, yrl_m, Pe, {0x62} }, { ABSFL, yml_rl, Pm, {0xbc} }, { ABSFW, yml_rl, Pq, {0xbc} }, { ABSRL, yml_rl, Pm, {0xbd} }, { ABSRW, yml_rl, Pq, {0xbd} }, { ABTL, yml_rl, Pm, {0xa3} }, { ABTW, yml_rl, Pq, {0xa3} }, { ABTCL, yml_rl, Pm, {0xbb} }, { ABTCW, yml_rl, Pq, {0xbb} }, { ABTRL, yml_rl, Pm, {0xb3} }, { ABTRW, yml_rl, Pq, {0xb3} }, { ABTSL, yml_rl, Pm, {0xab} }, { ABTSW, yml_rl, Pq, {0xab} }, { ABYTE, ybyte, Px, {1} }, { ACALL, ycall, Px, {0xff,(02),0xff,(0x15),0xe8} }, { ACLC, ynone, Px, {0xf8} }, { ACLD, ynone, Px, {0xfc} }, { ACLI, ynone, Px, {0xfa} }, { ACLTS, ynone, Pm, {0x06} }, { ACMC, ynone, Px, {0xf5} }, { ACMPB, ycmpb, Pb, {0x3c,0x80,(07),0x38,0x3a} }, { ACMPL, ycmpl, Px, {0x83,(07),0x3d,0x81,(07),0x39,0x3b} }, { ACMPW, ycmpl, Pe, {0x83,(07),0x3d,0x81,(07),0x39,0x3b} }, { ACMPSB, ynone, Pb, {0xa6} }, { ACMPSL, ynone, Px, {0xa7} }, { ACMPSW, ynone, Pe, {0xa7} }, { ADAA, ynone, Px, {0x27} }, { ADAS, ynone, Px, {0x2f} }, { ADATA }, { ADECB, yincb, Pb, {0xfe,(01)} }, { ADECL, yincl, Px, {0x48,0xff,(01)} }, { ADECW, yincl, Pe, {0x48,0xff,(01)} }, { ADIVB, ydivb, Pb, {0xf6,(06)} }, { ADIVL, ydivl, Px, {0xf7,(06)} }, { ADIVW, ydivl, Pe, {0xf7,(06)} }, { AENTER }, /* botch */ { AGLOBL }, { AGOK }, { AHISTORY }, { AHLT, ynone, Px, {0xf4} }, { AIDIVB, ydivb, Pb, {0xf6,(07)} }, { AIDIVL, ydivl, Px, {0xf7,(07)} }, { AIDIVW, ydivl, Pe, {0xf7,(07)} }, { AIMULB, ydivb, Pb, {0xf6,(05)} }, { AIMULL, yimul, Px, {0xf7,(05),0x6b,0x69} }, { AIMULW, yimul, Pe, {0xf7,(05),0x6b,0x69} }, { AINB, yin, Pb, {0xe4,0xec} }, { AINL, yin, Px, {0xe5,0xed} }, { AINW, yin, Pe, {0xe5,0xed} }, { AINCB, yincb, Pb, {0xfe,(00)} }, { AINCL, yincl, Px, {0x40,0xff,(00)} }, { AINCW, yincl, Pe, {0x40,0xff,(00)} }, { AINSB, ynone, Pb, {0x6c} }, { AINSL, ynone, Px, {0x6d} }, { AINSW, ynone, Pe, {0x6d} }, { AINT, yint, Px, {0xcd} }, { AINTO, ynone, Px, {0xce} }, { AIRETL, ynone, Px, {0xcf} }, { AIRETW, ynone, Pe, {0xcf} }, { AJCC, yjcond, Px, {0x73,0x83,(00)} }, { AJCS, yjcond, Px, {0x72,0x82} }, { AJCXZL, yloop, Px, {0xe3} }, { AJCXZW, yloop, Px, {0xe3} }, { AJEQ, yjcond, Px, {0x74,0x84} }, { AJGE, yjcond, Px, {0x7d,0x8d} }, { AJGT, yjcond, Px, {0x7f,0x8f} }, { AJHI, yjcond, Px, {0x77,0x87} }, { AJLE, yjcond, Px, {0x7e,0x8e} }, { AJLS, yjcond, Px, {0x76,0x86} }, { AJLT, yjcond, Px, {0x7c,0x8c} }, { AJMI, yjcond, Px, {0x78,0x88} }, { AJMP, yjmp, Px, {0xff,(04),0xeb,0xe9} }, { AJNE, yjcond, Px, {0x75,0x85} }, { AJOC, yjcond, Px, {0x71,0x81,(00)} }, { AJOS, yjcond, Px, {0x70,0x80,(00)} }, { AJPC, yjcond, Px, {0x7b,0x8b} }, { AJPL, yjcond, Px, {0x79,0x89} }, { AJPS, yjcond, Px, {0x7a,0x8a} }, { ALAHF, ynone, Px, {0x9f} }, { ALARL, yml_rl, Pm, {0x02} }, { ALARW, yml_rl, Pq, {0x02} }, { ALEAL, ym_rl, Px, {0x8d} }, { ALEAW, ym_rl, Pe, {0x8d} }, { ALEAVEL, ynone, Px, {0xc9} }, { ALEAVEW, ynone, Pe, {0xc9} }, { ALOCK, ynone, Px, {0xf0} }, { ALODSB, ynone, Pb, {0xac} }, { ALODSL, ynone, Px, {0xad} }, { ALODSW, ynone, Pe, {0xad} }, { ALONG, ybyte, Px, {4} }, { ALOOP, yloop, Px, {0xe2} }, { ALOOPEQ, yloop, Px, {0xe1} }, { ALOOPNE, yloop, Px, {0xe0} }, { ALSLL, yml_rl, Pm, {0x03 } }, { ALSLW, yml_rl, Pq, {0x03 } }, { AMOVB, ymovb, Pb, {0x88,0x8a,0xb0,0xc6,(00)} }, { AMOVL, ymovl, Px, {0x89,0x8b,0x31,0x83,(04),0xb8,0xc7,(00),Pe,0x6e,Pe,0x7e,0} }, { AMOVW, ymovw, Pe, {0x89,0x8b,0x31,0x83,(04),0xb8,0xc7,(00),0} }, { AMOVQ, ymovq, Pf3, {0x7e} }, { AMOVBLSX, ymb_rl, Pm, {0xbe} }, { AMOVBLZX, ymb_rl, Pm, {0xb6} }, { AMOVBWSX, ymb_rl, Pq, {0xbe} }, { AMOVBWZX, ymb_rl, Pq, {0xb6} }, { AMOVWLSX, yml_rl, Pm, {0xbf} }, { AMOVWLZX, yml_rl, Pm, {0xb7} }, { AMOVSB, ynone, Pb, {0xa4} }, { AMOVSL, ynone, Px, {0xa5} }, { AMOVSW, ynone, Pe, {0xa5} }, { AMULB, ydivb, Pb, {0xf6,(04)} }, { AMULL, ydivl, Px, {0xf7,(04)} }, { AMULW, ydivl, Pe, {0xf7,(04)} }, { ANAME }, { ANEGB, yscond, Px, {0xf6,(03)} }, { ANEGL, yscond, Px, {0xf7,(03)} }, { ANEGW, yscond, Pe, {0xf7,(03)} }, { ANOP, ynop, Px, {0,0} }, { ANOTB, yscond, Px, {0xf6,(02)} }, { ANOTL, yscond, Px, {0xf7,(02)} }, { ANOTW, yscond, Pe, {0xf7,(02)} }, { AORB, yxorb, Pb, {0x0c,0x80,(01),0x08,0x0a} }, { AORL, yxorl, Px, {0x83,(01),0x0d,0x81,(01),0x09,0x0b} }, { AORW, yxorl, Pe, {0x83,(01),0x0d,0x81,(01),0x09,0x0b} }, { AOUTB, yin, Pb, {0xe6,0xee} }, { AOUTL, yin, Px, {0xe7,0xef} }, { AOUTW, yin, Pe, {0xe7,0xef} }, { AOUTSB, ynone, Pb, {0x6e} }, { AOUTSL, ynone, Px, {0x6f} }, { AOUTSW, ynone, Pe, {0x6f} }, { APAUSE, ynone, Px, {0xf3,0x90} }, { APOPAL, ynone, Px, {0x61} }, { APOPAW, ynone, Pe, {0x61} }, { APOPFL, ynone, Px, {0x9d} }, { APOPFW, ynone, Pe, {0x9d} }, { APOPL, ypopl, Px, {0x58,0x8f,(00)} }, { APOPW, ypopl, Pe, {0x58,0x8f,(00)} }, { APUSHAL, ynone, Px, {0x60} }, { APUSHAW, ynone, Pe, {0x60} }, { APUSHFL, ynone, Px, {0x9c} }, { APUSHFW, ynone, Pe, {0x9c} }, { APUSHL, ypushl, Px, {0x50,0xff,(06),0x6a,0x68} }, { APUSHW, ypushl, Pe, {0x50,0xff,(06),0x6a,0x68} }, { ARCLB, yshb, Pb, {0xd0,(02),0xc0,(02),0xd2,(02)} }, { ARCLL, yshl, Px, {0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02)} }, { ARCLW, yshl, Pe, {0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02)} }, { ARCRB, yshb, Pb, {0xd0,(03),0xc0,(03),0xd2,(03)} }, { ARCRL, yshl, Px, {0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03)} }, { ARCRW, yshl, Pe, {0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03)} }, { AREP, ynone, Px, {0xf3} }, { AREPN, ynone, Px, {0xf2} }, { ARET, ynone, Px, {0xc3} }, { AROLB, yshb, Pb, {0xd0,(00),0xc0,(00),0xd2,(00)} }, { AROLL, yshl, Px, {0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00)} }, { AROLW, yshl, Pe, {0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00)} }, { ARORB, yshb, Pb, {0xd0,(01),0xc0,(01),0xd2,(01)} }, { ARORL, yshl, Px, {0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01)} }, { ARORW, yshl, Pe, {0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01)} }, { ASAHF, ynone, Px, {0x9e} }, { ASALB, yshb, Pb, {0xd0,(04),0xc0,(04),0xd2,(04)} }, { ASALL, yshl, Px, {0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04)} }, { ASALW, yshl, Pe, {0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04)} }, { ASARB, yshb, Pb, {0xd0,(07),0xc0,(07),0xd2,(07)} }, { ASARL, yshl, Px, {0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07)} }, { ASARW, yshl, Pe, {0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07)} }, { ASBBB, yxorb, Pb, {0x1c,0x80,(03),0x18,0x1a} }, { ASBBL, yxorl, Px, {0x83,(03),0x1d,0x81,(03),0x19,0x1b} }, { ASBBW, yxorl, Pe, {0x83,(03),0x1d,0x81,(03),0x19,0x1b} }, { ASCASB, ynone, Pb, {0xae} }, { ASCASL, ynone, Px, {0xaf} }, { ASCASW, ynone, Pe, {0xaf} }, { ASETCC, yscond, Pm, {0x93,(00)} }, { ASETCS, yscond, Pm, {0x92,(00)} }, { ASETEQ, yscond, Pm, {0x94,(00)} }, { ASETGE, yscond, Pm, {0x9d,(00)} }, { ASETGT, yscond, Pm, {0x9f,(00)} }, { ASETHI, yscond, Pm, {0x97,(00)} }, { ASETLE, yscond, Pm, {0x9e,(00)} }, { ASETLS, yscond, Pm, {0x96,(00)} }, { ASETLT, yscond, Pm, {0x9c,(00)} }, { ASETMI, yscond, Pm, {0x98,(00)} }, { ASETNE, yscond, Pm, {0x95,(00)} }, { ASETOC, yscond, Pm, {0x91,(00)} }, { ASETOS, yscond, Pm, {0x90,(00)} }, { ASETPC, yscond, Pm, {0x9b,(00)} }, { ASETPL, yscond, Pm, {0x99,(00)} }, { ASETPS, yscond, Pm, {0x9a,(00)} }, { ACDQ, ynone, Px, {0x99} }, { ACWD, ynone, Pe, {0x99} }, { ASHLB, yshb, Pb, {0xd0,(04),0xc0,(04),0xd2,(04)} }, { ASHLL, yshl, Px, {0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04)} }, { ASHLW, yshl, Pe, {0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04)} }, { ASHRB, yshb, Pb, {0xd0,(05),0xc0,(05),0xd2,(05)} }, { ASHRL, yshl, Px, {0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05)} }, { ASHRW, yshl, Pe, {0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05)} }, { ASTC, ynone, Px, {0xf9} }, { ASTD, ynone, Px, {0xfd} }, { ASTI, ynone, Px, {0xfb} }, { ASTOSB, ynone, Pb, {0xaa} }, { ASTOSL, ynone, Px, {0xab} }, { ASTOSW, ynone, Pe, {0xab} }, { ASUBB, yxorb, Pb, {0x2c,0x80,(05),0x28,0x2a} }, { ASUBL, yaddl, Px, {0x83,(05),0x2d,0x81,(05),0x29,0x2b} }, { ASUBW, yaddl, Pe, {0x83,(05),0x2d,0x81,(05),0x29,0x2b} }, { ASYSCALL, ynone, Px, {0xcd,100} }, { ATESTB, ytestb, Pb, {0xa8,0xf6,(00),0x84,0x84} }, { ATESTL, ytestl, Px, {0xa9,0xf7,(00),0x85,0x85} }, { ATESTW, ytestl, Pe, {0xa9,0xf7,(00),0x85,0x85} }, { ATEXT, ytext, Px }, { AVERR, ydivl, Pm, {0x00,(04)} }, { AVERW, ydivl, Pm, {0x00,(05)} }, { AWAIT, ynone, Px, {0x9b} }, { AWORD, ybyte, Px, {2} }, { AXCHGB, yml_mb, Pb, {0x86,0x86} }, { AXCHGL, yxchg, Px, {0x90,0x90,0x87,0x87} }, { AXCHGW, yxchg, Pe, {0x90,0x90,0x87,0x87} }, { AXLAT, ynone, Px, {0xd7} }, { AXORB, yxorb, Pb, {0x34,0x80,(06),0x30,0x32} }, { AXORL, yxorl, Px, {0x83,(06),0x35,0x81,(06),0x31,0x33} }, { AXORW, yxorl, Pe, {0x83,(06),0x35,0x81,(06),0x31,0x33} }, { AFMOVB, yfmvx, Px, {0xdf,(04)} }, { AFMOVBP, yfmvp, Px, {0xdf,(06)} }, { AFMOVD, yfmvd, Px, {0xdd,(00),0xdd,(02),0xd9,(00),0xdd,(02)} }, { AFMOVDP, yfmvdp, Px, {0xdd,(03),0xdd,(03)} }, { AFMOVF, yfmvf, Px, {0xd9,(00),0xd9,(02)} }, { AFMOVFP, yfmvp, Px, {0xd9,(03)} }, { AFMOVL, yfmvf, Px, {0xdb,(00),0xdb,(02)} }, { AFMOVLP, yfmvp, Px, {0xdb,(03)} }, { AFMOVV, yfmvx, Px, {0xdf,(05)} }, { AFMOVVP, yfmvp, Px, {0xdf,(07)} }, { AFMOVW, yfmvf, Px, {0xdf,(00),0xdf,(02)} }, { AFMOVWP, yfmvp, Px, {0xdf,(03)} }, { AFMOVX, yfmvx, Px, {0xdb,(05)} }, { AFMOVXP, yfmvp, Px, {0xdb,(07)} }, { AFCOMB }, { AFCOMBP }, { AFCOMD, yfadd, Px, {0xdc,(02),0xd8,(02),0xdc,(02)} }, /* botch */ { AFCOMDP, yfadd, Px, {0xdc,(03),0xd8,(03),0xdc,(03)} }, /* botch */ { AFCOMDPP, ycompp, Px, {0xde,(03)} }, { AFCOMF, yfmvx, Px, {0xd8,(02)} }, { AFCOMFP, yfmvx, Px, {0xd8,(03)} }, { AFCOMI, yfmvx, Px, {0xdb,(06)} }, { AFCOMIP, yfmvx, Px, {0xdf,(06)} }, { AFCOML, yfmvx, Px, {0xda,(02)} }, { AFCOMLP, yfmvx, Px, {0xda,(03)} }, { AFCOMW, yfmvx, Px, {0xde,(02)} }, { AFCOMWP, yfmvx, Px, {0xde,(03)} }, { AFUCOM, ycompp, Px, {0xdd,(04)} }, { AFUCOMI, ycompp, Px, {0xdb,(05)} }, { AFUCOMIP, ycompp, Px, {0xdf,(05)} }, { AFUCOMP, ycompp, Px, {0xdd,(05)} }, { AFUCOMPP, ycompp, Px, {0xda,(13)} }, { AFADDDP, yfaddp, Px, {0xde,(00)} }, { AFADDW, yfmvx, Px, {0xde,(00)} }, { AFADDL, yfmvx, Px, {0xda,(00)} }, { AFADDF, yfmvx, Px, {0xd8,(00)} }, { AFADDD, yfadd, Px, {0xdc,(00),0xd8,(00),0xdc,(00)} }, { AFMULDP, yfaddp, Px, {0xde,(01)} }, { AFMULW, yfmvx, Px, {0xde,(01)} }, { AFMULL, yfmvx, Px, {0xda,(01)} }, { AFMULF, yfmvx, Px, {0xd8,(01)} }, { AFMULD, yfadd, Px, {0xdc,(01),0xd8,(01),0xdc,(01)} }, { AFSUBDP, yfaddp, Px, {0xde,(05)} }, { AFSUBW, yfmvx, Px, {0xde,(04)} }, { AFSUBL, yfmvx, Px, {0xda,(04)} }, { AFSUBF, yfmvx, Px, {0xd8,(04)} }, { AFSUBD, yfadd, Px, {0xdc,(04),0xd8,(04),0xdc,(05)} }, { AFSUBRDP, yfaddp, Px, {0xde,(04)} }, { AFSUBRW, yfmvx, Px, {0xde,(05)} }, { AFSUBRL, yfmvx, Px, {0xda,(05)} }, { AFSUBRF, yfmvx, Px, {0xd8,(05)} }, { AFSUBRD, yfadd, Px, {0xdc,(05),0xd8,(05),0xdc,(04)} }, { AFDIVDP, yfaddp, Px, {0xde,(07)} }, { AFDIVW, yfmvx, Px, {0xde,(06)} }, { AFDIVL, yfmvx, Px, {0xda,(06)} }, { AFDIVF, yfmvx, Px, {0xd8,(06)} }, { AFDIVD, yfadd, Px, {0xdc,(06),0xd8,(06),0xdc,(07)} }, { AFDIVRDP, yfaddp, Px, {0xde,(06)} }, { AFDIVRW, yfmvx, Px, {0xde,(07)} }, { AFDIVRL, yfmvx, Px, {0xda,(07)} }, { AFDIVRF, yfmvx, Px, {0xd8,(07)} }, { AFDIVRD, yfadd, Px, {0xdc,(07),0xd8,(07),0xdc,(06)} }, { AFXCHD, yfxch, Px, {0xd9,(01),0xd9,(01)} }, { AFFREE }, { AFLDCW, ystcw, Px, {0xd9,(05),0xd9,(05)} }, { AFLDENV, ystcw, Px, {0xd9,(04),0xd9,(04)} }, { AFRSTOR, ysvrs, Px, {0xdd,(04),0xdd,(04)} }, { AFSAVE, ysvrs, Px, {0xdd,(06),0xdd,(06)} }, { AFSTCW, ystcw, Px, {0xd9,(07),0xd9,(07)} }, { AFSTENV, ystcw, Px, {0xd9,(06),0xd9,(06)} }, { AFSTSW, ystsw, Px, {0xdd,(07),0xdf,0xe0} }, { AF2XM1, ynone, Px, {0xd9, 0xf0} }, { AFABS, ynone, Px, {0xd9, 0xe1} }, { AFCHS, ynone, Px, {0xd9, 0xe0} }, { AFCLEX, ynone, Px, {0xdb, 0xe2} }, { AFCOS, ynone, Px, {0xd9, 0xff} }, { AFDECSTP, ynone, Px, {0xd9, 0xf6} }, { AFINCSTP, ynone, Px, {0xd9, 0xf7} }, { AFINIT, ynone, Px, {0xdb, 0xe3} }, { AFLD1, ynone, Px, {0xd9, 0xe8} }, { AFLDL2E, ynone, Px, {0xd9, 0xea} }, { AFLDL2T, ynone, Px, {0xd9, 0xe9} }, { AFLDLG2, ynone, Px, {0xd9, 0xec} }, { AFLDLN2, ynone, Px, {0xd9, 0xed} }, { AFLDPI, ynone, Px, {0xd9, 0xeb} }, { AFLDZ, ynone, Px, {0xd9, 0xee} }, { AFNOP, ynone, Px, {0xd9, 0xd0} }, { AFPATAN, ynone, Px, {0xd9, 0xf3} }, { AFPREM, ynone, Px, {0xd9, 0xf8} }, { AFPREM1, ynone, Px, {0xd9, 0xf5} }, { AFPTAN, ynone, Px, {0xd9, 0xf2} }, { AFRNDINT, ynone, Px, {0xd9, 0xfc} }, { AFSCALE, ynone, Px, {0xd9, 0xfd} }, { AFSIN, ynone, Px, {0xd9, 0xfe} }, { AFSINCOS, ynone, Px, {0xd9, 0xfb} }, { AFSQRT, ynone, Px, {0xd9, 0xfa} }, { AFTST, ynone, Px, {0xd9, 0xe4} }, { AFXAM, ynone, Px, {0xd9, 0xe5} }, { AFXTRACT, ynone, Px, {0xd9, 0xf4} }, { AFYL2X, ynone, Px, {0xd9, 0xf1} }, { AFYL2XP1, ynone, Px, {0xd9, 0xf9} }, { AEND }, { ADYNT_ }, { AINIT_ }, { ASIGNAME }, { ACMPXCHGB, yrb_mb, Pm, {0xb0} }, { ACMPXCHGL, yrl_ml, Pm, {0xb1} }, { ACMPXCHGW, yrl_ml, Pm, {0xb1} }, { ACMPXCHG8B, yscond, Pm, {0xc7,(01)} }, { ACPUID, ynone, Pm, {0xa2} }, { ARDTSC, ynone, Pm, {0x31} }, { AXADDB, yrb_mb, Pb, {0x0f,0xc0} }, { AXADDL, yrl_ml, Pm, {0xc1} }, { AXADDW, yrl_ml, Pe, {0x0f,0xc1} }, { ACMOVLCC, yml_rl, Pm, {0x43} }, { ACMOVLCS, yml_rl, Pm, {0x42} }, { ACMOVLEQ, yml_rl, Pm, {0x44} }, { ACMOVLGE, yml_rl, Pm, {0x4d} }, { ACMOVLGT, yml_rl, Pm, {0x4f} }, { ACMOVLHI, yml_rl, Pm, {0x47} }, { ACMOVLLE, yml_rl, Pm, {0x4e} }, { ACMOVLLS, yml_rl, Pm, {0x46} }, { ACMOVLLT, yml_rl, Pm, {0x4c} }, { ACMOVLMI, yml_rl, Pm, {0x48} }, { ACMOVLNE, yml_rl, Pm, {0x45} }, { ACMOVLOC, yml_rl, Pm, {0x41} }, { ACMOVLOS, yml_rl, Pm, {0x40} }, { ACMOVLPC, yml_rl, Pm, {0x4b} }, { ACMOVLPL, yml_rl, Pm, {0x49} }, { ACMOVLPS, yml_rl, Pm, {0x4a} }, { ACMOVWCC, yml_rl, Pq, {0x43} }, { ACMOVWCS, yml_rl, Pq, {0x42} }, { ACMOVWEQ, yml_rl, Pq, {0x44} }, { ACMOVWGE, yml_rl, Pq, {0x4d} }, { ACMOVWGT, yml_rl, Pq, {0x4f} }, { ACMOVWHI, yml_rl, Pq, {0x47} }, { ACMOVWLE, yml_rl, Pq, {0x4e} }, { ACMOVWLS, yml_rl, Pq, {0x46} }, { ACMOVWLT, yml_rl, Pq, {0x4c} }, { ACMOVWMI, yml_rl, Pq, {0x48} }, { ACMOVWNE, yml_rl, Pq, {0x45} }, { ACMOVWOC, yml_rl, Pq, {0x41} }, { ACMOVWOS, yml_rl, Pq, {0x40} }, { ACMOVWPC, yml_rl, Pq, {0x4b} }, { ACMOVWPL, yml_rl, Pq, {0x49} }, { ACMOVWPS, yml_rl, Pq, {0x4a} }, { AFCMOVCC, yfcmv, Px, {0xdb,(00)} }, { AFCMOVCS, yfcmv, Px, {0xda,(00)} }, { AFCMOVEQ, yfcmv, Px, {0xda,(01)} }, { AFCMOVHI, yfcmv, Px, {0xdb,(02)} }, { AFCMOVLS, yfcmv, Px, {0xda,(02)} }, { AFCMOVNE, yfcmv, Px, {0xdb,(01)} }, { AFCMOVNU, yfcmv, Px, {0xdb,(03)} }, { AFCMOVUN, yfcmv, Px, {0xda,(03)} }, { ALFENCE, ynone, Pm, {0xae,0xe8} }, { AMFENCE, ynone, Pm, {0xae,0xf0} }, { ASFENCE, ynone, Pm, {0xae,0xf8} }, { AEMMS, ynone, Pm, {0x77} }, { APREFETCHT0, yprefetch, Pm, {0x18,(01)} }, { APREFETCHT1, yprefetch, Pm, {0x18,(02)} }, { APREFETCHT2, yprefetch, Pm, {0x18,(03)} }, { APREFETCHNTA, yprefetch, Pm, {0x18,(00)} }, { ABSWAPL, ybswap, Pm, {0xc8} }, { AUNDEF, ynone, Px, {0x0f, 0x0b} }, { AADDPD, yxm, Pq, {0x58} }, { AADDPS, yxm, Pm, {0x58} }, { AADDSD, yxm, Pf2, {0x58} }, { AADDSS, yxm, Pf3, {0x58} }, { AANDNPD, yxm, Pq, {0x55} }, { AANDNPS, yxm, Pm, {0x55} }, { AANDPD, yxm, Pq, {0x54} }, { AANDPS, yxm, Pq, {0x54} }, { ACMPPD, yxcmpi, Px, {Pe,0xc2} }, { ACMPPS, yxcmpi, Pm, {0xc2,0} }, { ACMPSD, yxcmpi, Px, {Pf2,0xc2} }, { ACMPSS, yxcmpi, Px, {Pf3,0xc2} }, { ACOMISD, yxcmp, Pe, {0x2f} }, { ACOMISS, yxcmp, Pm, {0x2f} }, { ACVTPL2PD, yxcvm2, Px, {Pf3,0xe6,Pe,0x2a} }, { ACVTPL2PS, yxcvm2, Pm, {0x5b,0,0x2a,0,} }, { ACVTPD2PL, yxcvm1, Px, {Pf2,0xe6,Pe,0x2d} }, { ACVTPD2PS, yxm, Pe, {0x5a} }, { ACVTPS2PL, yxcvm1, Px, {Pe,0x5b,Pm,0x2d} }, { ACVTPS2PD, yxm, Pm, {0x5a} }, { ACVTSD2SL, yxcvfl, Pf2, {0x2d} }, { ACVTSD2SS, yxm, Pf2, {0x5a} }, { ACVTSL2SD, yxcvlf, Pf2, {0x2a} }, { ACVTSL2SS, yxcvlf, Pf3, {0x2a} }, { ACVTSS2SD, yxm, Pf3, {0x5a} }, { ACVTSS2SL, yxcvfl, Pf3, {0x2d} }, { ACVTTPD2PL, yxcvm1, Px, {Pe,0xe6,Pe,0x2c} }, { ACVTTPS2PL, yxcvm1, Px, {Pf3,0x5b,Pm,0x2c} }, { ACVTTSD2SL, yxcvfl, Pf2, {0x2c} }, { ACVTTSS2SL, yxcvfl, Pf3, {0x2c} }, { ADIVPD, yxm, Pe, {0x5e} }, { ADIVPS, yxm, Pm, {0x5e} }, { ADIVSD, yxm, Pf2, {0x5e} }, { ADIVSS, yxm, Pf3, {0x5e} }, { AMASKMOVOU, yxr, Pe, {0xf7} }, { AMAXPD, yxm, Pe, {0x5f} }, { AMAXPS, yxm, Pm, {0x5f} }, { AMAXSD, yxm, Pf2, {0x5f} }, { AMAXSS, yxm, Pf3, {0x5f} }, { AMINPD, yxm, Pe, {0x5d} }, { AMINPS, yxm, Pm, {0x5d} }, { AMINSD, yxm, Pf2, {0x5d} }, { AMINSS, yxm, Pf3, {0x5d} }, { AMOVAPD, yxmov, Pe, {0x28,0x29} }, { AMOVAPS, yxmov, Pm, {0x28,0x29} }, { AMOVO, yxmov, Pe, {0x6f,0x7f} }, { AMOVOU, yxmov, Pf3, {0x6f,0x7f} }, { AMOVHLPS, yxr, Pm, {0x12} }, { AMOVHPD, yxmov, Pe, {0x16,0x17} }, { AMOVHPS, yxmov, Pm, {0x16,0x17} }, { AMOVLHPS, yxr, Pm, {0x16} }, { AMOVLPD, yxmov, Pe, {0x12,0x13} }, { AMOVLPS, yxmov, Pm, {0x12,0x13} }, { AMOVMSKPD, yxrrl, Pq, {0x50} }, { AMOVMSKPS, yxrrl, Pm, {0x50} }, { AMOVNTO, yxr_ml, Pe, {0xe7} }, { AMOVNTPD, yxr_ml, Pe, {0x2b} }, { AMOVNTPS, yxr_ml, Pm, {0x2b} }, { AMOVSD, yxmov, Pf2, {0x10,0x11} }, { AMOVSS, yxmov, Pf3, {0x10,0x11} }, { AMOVUPD, yxmov, Pe, {0x10,0x11} }, { AMOVUPS, yxmov, Pm, {0x10,0x11} }, { AMULPD, yxm, Pe, {0x59} }, { AMULPS, yxm, Ym, {0x59} }, { AMULSD, yxm, Pf2, {0x59} }, { AMULSS, yxm, Pf3, {0x59} }, { AORPD, yxm, Pq, {0x56} }, { AORPS, yxm, Pm, {0x56} }, { APADDQ, yxm, Pe, {0xd4} }, { APAND, yxm, Pe, {0xdb} }, { APCMPEQB, yxmq, Pe, {0x74} }, { APMAXSW, yxm, Pe, {0xee} }, { APMAXUB, yxm, Pe, {0xde} }, { APMINSW, yxm, Pe, {0xea} }, { APMINUB, yxm, Pe, {0xda} }, { APMOVMSKB, ymskb, Px, {Pe,0xd7,0xd7} }, { APSADBW, yxm, Pq, {0xf6} }, { APSUBB, yxm, Pe, {0xf8} }, { APSUBL, yxm, Pe, {0xfa} }, { APSUBQ, yxm, Pe, {0xfb} }, { APSUBSB, yxm, Pe, {0xe8} }, { APSUBSW, yxm, Pe, {0xe9} }, { APSUBUSB, yxm, Pe, {0xd8} }, { APSUBUSW, yxm, Pe, {0xd9} }, { APSUBW, yxm, Pe, {0xf9} }, { APUNPCKHQDQ, yxm, Pe, {0x6d} }, { APUNPCKLQDQ, yxm, Pe, {0x6c} }, { APXOR, yxm, Pe, {0xef} }, { ARCPPS, yxm, Pm, {0x53} }, { ARCPSS, yxm, Pf3, {0x53} }, { ARSQRTPS, yxm, Pm, {0x52} }, { ARSQRTSS, yxm, Pf3, {0x52} }, { ASQRTPD, yxm, Pe, {0x51} }, { ASQRTPS, yxm, Pm, {0x51} }, { ASQRTSD, yxm, Pf2, {0x51} }, { ASQRTSS, yxm, Pf3, {0x51} }, { ASUBPD, yxm, Pe, {0x5c} }, { ASUBPS, yxm, Pm, {0x5c} }, { ASUBSD, yxm, Pf2, {0x5c} }, { ASUBSS, yxm, Pf3, {0x5c} }, { AUCOMISD, yxcmp, Pe, {0x2e} }, { AUCOMISS, yxcmp, Pm, {0x2e} }, { AUNPCKHPD, yxm, Pe, {0x15} }, { AUNPCKHPS, yxm, Pm, {0x15} }, { AUNPCKLPD, yxm, Pe, {0x14} }, { AUNPCKLPS, yxm, Pm, {0x14} }, { AXORPD, yxm, Pe, {0x57} }, { AXORPS, yxm, Pm, {0x57} }, { AAESENC, yaes, Pq, {0x38,0xdc,(0)} }, { APINSRD, yinsrd, Pq, {0x3a, 0x22, (00)} }, { APSHUFB, ymshufb,Pq, {0x38, 0x00} }, { AUSEFIELD, ynop, Px, {0,0} }, { ATYPE }, { AFUNCDATA, yfuncdata, Px, {0,0} }, { APCDATA, ypcdata, Px, {0,0} }, { ACHECKNIL }, { AVARDEF }, { AVARKILL }, { ADUFFCOPY, yduff, Px, {0xe8} }, { ADUFFZERO, yduff, Px, {0xe8} }, {0} }; static int32 vaddr(Link*, Addr*, Reloc*); // single-instruction no-ops of various lengths. // constructed by hand and disassembled with gdb to verify. // see http://www.agner.org/optimize/optimizing_assembly.pdf for discussion. static uchar nop[][16] = { {0x90}, {0x66, 0x90}, {0x0F, 0x1F, 0x00}, {0x0F, 0x1F, 0x40, 0x00}, {0x0F, 0x1F, 0x44, 0x00, 0x00}, {0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00}, {0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00}, {0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00}, // Native Client rejects the repeated 0x66 prefix. // {0x66, 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00}, }; static void fillnop(uchar *p, int n) { int m; while(n > 0) { m = n; if(m > nelem(nop)) m = nelem(nop); memmove(p, nop[m-1], m); p += m; n -= m; } } static int32 naclpad(Link *ctxt, LSym *s, int32 c, int32 pad) { symgrow(ctxt, s, c+pad); fillnop(s->p+c, pad); return c+pad; } static void instinit(void); void span8(Link *ctxt, LSym *s) { Prog *p, *q; int32 c, v, loop; uchar *bp; int n, m, i; ctxt->cursym = s; if(s->text == nil || s->text->link == nil) return; if(ycover[0] == 0) instinit(); for(p = s->text; p != nil; p = p->link) { n = 0; if(p->to.type == D_BRANCH) if(p->pcond == nil) p->pcond = p; if((q = p->pcond) != nil) if(q->back != 2) n = 1; p->back = n; if(p->as == AADJSP) { p->to.type = D_SP; v = -p->from.offset; p->from.offset = v; p->as = AADDL; if(v < 0) { p->as = ASUBL; v = -v; p->from.offset = v; } if(v == 0) p->as = ANOP; } } for(p = s->text; p != nil; p = p->link) { p->back = 2; // use short branches first time through if((q = p->pcond) != nil && (q->back & 2)) p->back |= 1; // backward jump if(p->as == AADJSP) { p->to.type = D_SP; v = -p->from.offset; p->from.offset = v; p->as = AADDL; if(v < 0) { p->as = ASUBL; v = -v; p->from.offset = v; } if(v == 0) p->as = ANOP; } } n = 0; do { loop = 0; memset(s->r, 0, s->nr*sizeof s->r[0]); s->nr = 0; s->np = 0; c = 0; for(p = s->text; p != nil; p = p->link) { if(ctxt->headtype == Hnacl && p->isize > 0) { static LSym *deferreturn; if(deferreturn == nil) deferreturn = linklookup(ctxt, "runtime.deferreturn", 0); // pad everything to avoid crossing 32-byte boundary if((c>>5) != ((c+p->isize-1)>>5)) c = naclpad(ctxt, s, c, -c&31); // pad call deferreturn to start at 32-byte boundary // so that subtracting 5 in jmpdefer will jump back // to that boundary and rerun the call. if(p->as == ACALL && p->to.sym == deferreturn) c = naclpad(ctxt, s, c, -c&31); // pad call to end at 32-byte boundary if(p->as == ACALL) c = naclpad(ctxt, s, c, -(c+p->isize)&31); // the linker treats REP and STOSQ as different instructions // but in fact the REP is a prefix on the STOSQ. // make sure REP has room for 2 more bytes, so that // padding will not be inserted before the next instruction. if(p->as == AREP && (c>>5) != ((c+3-1)>>5)) c = naclpad(ctxt, s, c, -c&31); // same for LOCK. // various instructions follow; the longest is 4 bytes. // give ourselves 8 bytes so as to avoid surprises. if(p->as == ALOCK && (c>>5) != ((c+8-1)>>5)) c = naclpad(ctxt, s, c, -c&31); } p->pc = c; // process forward jumps to p for(q = p->comefrom; q != nil; q = q->forwd) { v = p->pc - (q->pc + q->mark); if(q->back & 2) { // short if(v > 127) { loop++; q->back ^= 2; } if(q->as == AJCXZW) s->p[q->pc+2] = v; else s->p[q->pc+1] = v; } else { bp = s->p + q->pc + q->mark - 4; *bp++ = v; *bp++ = v>>8; *bp++ = v>>16; *bp = v>>24; } } p->comefrom = nil; p->pc = c; asmins(ctxt, p); m = ctxt->andptr-ctxt->and; if(p->isize != m) { p->isize = m; loop++; } symgrow(ctxt, s, p->pc+m); memmove(s->p+p->pc, ctxt->and, m); p->mark = m; c += m; } if(++n > 20) { ctxt->diag("span must be looping"); sysfatal("bad code"); } } while(loop); if(ctxt->headtype == Hnacl) c = naclpad(ctxt, s, c, -c&31); c += -c&(FuncAlign-1); s->size = c; if(0 /* debug['a'] > 1 */) { print("span1 %s %lld (%d tries)\n %.6ux", s->name, s->size, n, 0); for(i=0; inp; i++) { print(" %.2ux", s->p[i]); if(i%16 == 15) print("\n %.6ux", i+1); } if(i%16) print("\n"); for(i=0; inr; i++) { Reloc *r; r = &s->r[i]; print(" rel %#.4ux/%d %s%+lld\n", r->off, r->siz, r->sym->name, r->add); } } } static void instinit(void) { int i; for(i=1; optab[i].as; i++) if(i != optab[i].as) sysfatal("phase error in optab: at %A found %A", i, optab[i].as); for(i=0; i= D_AL && i <= D_BH) reg[i] = (i-D_AL) & 7; if(i >= D_AX && i <= D_DI) reg[i] = (i-D_AX) & 7; if(i >= D_F0 && i <= D_F0+7) reg[i] = (i-D_F0) & 7; if(i >= D_X0 && i <= D_X0+7) reg[i] = (i-D_X0) & 7; } } static int prefixof(Link *ctxt, Addr *a) { switch(a->type) { case D_INDIR+D_CS: return 0x2e; case D_INDIR+D_DS: return 0x3e; case D_INDIR+D_ES: return 0x26; case D_INDIR+D_FS: return 0x64; case D_INDIR+D_GS: return 0x65; case D_INDIR+D_TLS: // NOTE: Systems listed here should be only systems that // support direct TLS references like 8(TLS) implemented as // direct references from FS or GS. Systems that require // the initial-exec model, where you load the TLS base into // a register and then index from that register, do not reach // this code and should not be listed. switch(ctxt->headtype) { default: sysfatal("unknown TLS base register for %s", headstr(ctxt->headtype)); case Hdarwin: case Hdragonfly: case Hfreebsd: case Hnetbsd: case Hopenbsd: return 0x65; // GS } } return 0; } static int oclass(Addr *a) { int32 v; if((a->type >= D_INDIR && a->type < 2*D_INDIR) || a->index != D_NONE) { if(a->index != D_NONE && a->scale == 0) { if(a->type == D_ADDR) { switch(a->index) { case D_EXTERN: case D_STATIC: return Yi32; case D_AUTO: case D_PARAM: return Yiauto; } return Yxxx; } //if(a->type == D_INDIR+D_ADDR) // print("*Ycol\n"); return Ycol; } return Ym; } switch(a->type) { case D_AL: return Yal; case D_AX: return Yax; case D_CL: case D_DL: case D_BL: case D_AH: case D_CH: case D_DH: case D_BH: return Yrb; case D_CX: return Ycx; case D_DX: case D_BX: return Yrx; case D_SP: case D_BP: case D_SI: case D_DI: return Yrl; case D_F0+0: return Yf0; case D_F0+1: case D_F0+2: case D_F0+3: case D_F0+4: case D_F0+5: case D_F0+6: case D_F0+7: return Yrf; case D_X0+0: case D_X0+1: case D_X0+2: case D_X0+3: case D_X0+4: case D_X0+5: case D_X0+6: case D_X0+7: return Yxr; case D_NONE: return Ynone; case D_CS: return Ycs; case D_SS: return Yss; case D_DS: return Yds; case D_ES: return Yes; case D_FS: return Yfs; case D_GS: return Ygs; case D_TLS: return Ytls; case D_GDTR: return Ygdtr; case D_IDTR: return Yidtr; case D_LDTR: return Yldtr; case D_MSW: return Ymsw; case D_TASK: return Ytask; case D_CR+0: return Ycr0; case D_CR+1: return Ycr1; case D_CR+2: return Ycr2; case D_CR+3: return Ycr3; case D_CR+4: return Ycr4; case D_CR+5: return Ycr5; case D_CR+6: return Ycr6; case D_CR+7: return Ycr7; case D_DR+0: return Ydr0; case D_DR+1: return Ydr1; case D_DR+2: return Ydr2; case D_DR+3: return Ydr3; case D_DR+4: return Ydr4; case D_DR+5: return Ydr5; case D_DR+6: return Ydr6; case D_DR+7: return Ydr7; case D_TR+0: return Ytr0; case D_TR+1: return Ytr1; case D_TR+2: return Ytr2; case D_TR+3: return Ytr3; case D_TR+4: return Ytr4; case D_TR+5: return Ytr5; case D_TR+6: return Ytr6; case D_TR+7: return Ytr7; case D_EXTERN: case D_STATIC: case D_AUTO: case D_PARAM: return Ym; case D_CONST: case D_CONST2: case D_ADDR: if(a->sym == nil) { v = a->offset; if(v == 0) return Yi0; if(v == 1) return Yi1; if(v >= -128 && v <= 127) return Yi8; } return Yi32; case D_BRANCH: return Ybr; } return Yxxx; } static void asmidx(Link *ctxt, int scale, int index, int base) { int i; switch(index) { default: goto bad; case D_NONE: i = 4 << 3; goto bas; case D_AX: case D_CX: case D_DX: case D_BX: case D_BP: case D_SI: case D_DI: i = reg[index] << 3; break; } switch(scale) { default: goto bad; case 1: break; case 2: i |= (1<<6); break; case 4: i |= (2<<6); break; case 8: i |= (3<<6); break; } bas: switch(base) { default: goto bad; case D_NONE: /* must be mod=00 */ i |= 5; break; case D_AX: case D_CX: case D_DX: case D_BX: case D_SP: case D_BP: case D_SI: case D_DI: i |= reg[base]; break; } *ctxt->andptr++ = i; return; bad: ctxt->diag("asmidx: bad address %d,%d,%d", scale, index, base); *ctxt->andptr++ = 0; return; } static void put4(Link *ctxt, int32 v) { ctxt->andptr[0] = v; ctxt->andptr[1] = v>>8; ctxt->andptr[2] = v>>16; ctxt->andptr[3] = v>>24; ctxt->andptr += 4; } static void relput4(Link *ctxt, Prog *p, Addr *a) { vlong v; Reloc rel, *r; v = vaddr(ctxt, a, &rel); if(rel.siz != 0) { if(rel.siz != 4) ctxt->diag("bad reloc"); r = addrel(ctxt->cursym); *r = rel; r->off = p->pc + ctxt->andptr - ctxt->and; } put4(ctxt, v); } static int32 vaddr(Link *ctxt, Addr *a, Reloc *r) { int t; int32 v; LSym *s; if(r != nil) memset(r, 0, sizeof *r); t = a->type; v = a->offset; if(t == D_ADDR) t = a->index; switch(t) { case D_STATIC: case D_EXTERN: s = a->sym; if(s != nil) { if(r == nil) { ctxt->diag("need reloc for %D", a); sysfatal("bad code"); } r->type = R_ADDR; r->siz = 4; r->off = -1; r->sym = s; r->add = v; v = 0; } break; case D_INDIR+D_TLS: if(r == nil) { ctxt->diag("need reloc for %D", a); sysfatal("bad code"); } r->type = R_TLS_LE; r->siz = 4; r->off = -1; // caller must fill in r->add = v; v = 0; break; } return v; } static void asmand(Link *ctxt, Addr *a, int r) { int32 v; int t, scale; Reloc rel; v = a->offset; t = a->type; rel.siz = 0; if(a->index != D_NONE && a->index != D_TLS) { if(t < D_INDIR || t >= 2*D_INDIR) { switch(t) { default: goto bad; case D_STATIC: case D_EXTERN: t = D_NONE; v = vaddr(ctxt, a, &rel); break; case D_AUTO: case D_PARAM: t = D_SP; break; } } else t -= D_INDIR; if(t == D_NONE) { *ctxt->andptr++ = (0 << 6) | (4 << 0) | (r << 3); asmidx(ctxt, a->scale, a->index, t); goto putrelv; } if(v == 0 && rel.siz == 0 && t != D_BP) { *ctxt->andptr++ = (0 << 6) | (4 << 0) | (r << 3); asmidx(ctxt, a->scale, a->index, t); return; } if(v >= -128 && v < 128 && rel.siz == 0) { *ctxt->andptr++ = (1 << 6) | (4 << 0) | (r << 3); asmidx(ctxt, a->scale, a->index, t); *ctxt->andptr++ = v; return; } *ctxt->andptr++ = (2 << 6) | (4 << 0) | (r << 3); asmidx(ctxt, a->scale, a->index, t); goto putrelv; } if(t >= D_AL && t <= D_F7 || t >= D_X0 && t <= D_X7) { if(v) goto bad; *ctxt->andptr++ = (3 << 6) | (reg[t] << 0) | (r << 3); return; } scale = a->scale; if(t < D_INDIR || t >= 2*D_INDIR) { switch(a->type) { default: goto bad; case D_STATIC: case D_EXTERN: t = D_NONE; v = vaddr(ctxt, a, &rel); break; case D_AUTO: case D_PARAM: t = D_SP; break; } scale = 1; } else t -= D_INDIR; if(t == D_TLS) v = vaddr(ctxt, a, &rel); if(t == D_NONE || (D_CS <= t && t <= D_GS) || t == D_TLS) { *ctxt->andptr++ = (0 << 6) | (5 << 0) | (r << 3); goto putrelv; } if(t == D_SP) { if(v == 0 && rel.siz == 0) { *ctxt->andptr++ = (0 << 6) | (4 << 0) | (r << 3); asmidx(ctxt, scale, D_NONE, t); return; } if(v >= -128 && v < 128 && rel.siz == 0) { *ctxt->andptr++ = (1 << 6) | (4 << 0) | (r << 3); asmidx(ctxt, scale, D_NONE, t); *ctxt->andptr++ = v; return; } *ctxt->andptr++ = (2 << 6) | (4 << 0) | (r << 3); asmidx(ctxt, scale, D_NONE, t); goto putrelv; } if(t >= D_AX && t <= D_DI) { if(a->index == D_TLS) { memset(&rel, 0, sizeof rel); rel.type = R_TLS_IE; rel.siz = 4; rel.sym = nil; rel.add = v; v = 0; } if(v == 0 && rel.siz == 0 && t != D_BP) { *ctxt->andptr++ = (0 << 6) | (reg[t] << 0) | (r << 3); return; } if(v >= -128 && v < 128 && rel.siz == 0) { ctxt->andptr[0] = (1 << 6) | (reg[t] << 0) | (r << 3); ctxt->andptr[1] = v; ctxt->andptr += 2; return; } *ctxt->andptr++ = (2 << 6) | (reg[t] << 0) | (r << 3); goto putrelv; } goto bad; putrelv: if(rel.siz != 0) { Reloc *r; if(rel.siz != 4) { ctxt->diag("bad rel"); goto bad; } r = addrel(ctxt->cursym); *r = rel; r->off = ctxt->curp->pc + ctxt->andptr - ctxt->and; } put4(ctxt, v); return; bad: ctxt->diag("asmand: bad address %D", a); return; } enum { E = 0xff, }; static uchar ymovtab[] = { /* push */ APUSHL, Ycs, Ynone, 0, 0x0e,E,0,0, APUSHL, Yss, Ynone, 0, 0x16,E,0,0, APUSHL, Yds, Ynone, 0, 0x1e,E,0,0, APUSHL, Yes, Ynone, 0, 0x06,E,0,0, APUSHL, Yfs, Ynone, 0, 0x0f,0xa0,E,0, APUSHL, Ygs, Ynone, 0, 0x0f,0xa8,E,0, APUSHW, Ycs, Ynone, 0, Pe,0x0e,E,0, APUSHW, Yss, Ynone, 0, Pe,0x16,E,0, APUSHW, Yds, Ynone, 0, Pe,0x1e,E,0, APUSHW, Yes, Ynone, 0, Pe,0x06,E,0, APUSHW, Yfs, Ynone, 0, Pe,0x0f,0xa0,E, APUSHW, Ygs, Ynone, 0, Pe,0x0f,0xa8,E, /* pop */ APOPL, Ynone, Yds, 0, 0x1f,E,0,0, APOPL, Ynone, Yes, 0, 0x07,E,0,0, APOPL, Ynone, Yss, 0, 0x17,E,0,0, APOPL, Ynone, Yfs, 0, 0x0f,0xa1,E,0, APOPL, Ynone, Ygs, 0, 0x0f,0xa9,E,0, APOPW, Ynone, Yds, 0, Pe,0x1f,E,0, APOPW, Ynone, Yes, 0, Pe,0x07,E,0, APOPW, Ynone, Yss, 0, Pe,0x17,E,0, APOPW, Ynone, Yfs, 0, Pe,0x0f,0xa1,E, APOPW, Ynone, Ygs, 0, Pe,0x0f,0xa9,E, /* mov seg */ AMOVW, Yes, Yml, 1, 0x8c,0,0,0, AMOVW, Ycs, Yml, 1, 0x8c,1,0,0, AMOVW, Yss, Yml, 1, 0x8c,2,0,0, AMOVW, Yds, Yml, 1, 0x8c,3,0,0, AMOVW, Yfs, Yml, 1, 0x8c,4,0,0, AMOVW, Ygs, Yml, 1, 0x8c,5,0,0, AMOVW, Yml, Yes, 2, 0x8e,0,0,0, AMOVW, Yml, Ycs, 2, 0x8e,1,0,0, AMOVW, Yml, Yss, 2, 0x8e,2,0,0, AMOVW, Yml, Yds, 2, 0x8e,3,0,0, AMOVW, Yml, Yfs, 2, 0x8e,4,0,0, AMOVW, Yml, Ygs, 2, 0x8e,5,0,0, /* mov cr */ AMOVL, Ycr0, Yml, 3, 0x0f,0x20,0,0, AMOVL, Ycr2, Yml, 3, 0x0f,0x20,2,0, AMOVL, Ycr3, Yml, 3, 0x0f,0x20,3,0, AMOVL, Ycr4, Yml, 3, 0x0f,0x20,4,0, AMOVL, Yml, Ycr0, 4, 0x0f,0x22,0,0, AMOVL, Yml, Ycr2, 4, 0x0f,0x22,2,0, AMOVL, Yml, Ycr3, 4, 0x0f,0x22,3,0, AMOVL, Yml, Ycr4, 4, 0x0f,0x22,4,0, /* mov dr */ AMOVL, Ydr0, Yml, 3, 0x0f,0x21,0,0, AMOVL, Ydr6, Yml, 3, 0x0f,0x21,6,0, AMOVL, Ydr7, Yml, 3, 0x0f,0x21,7,0, AMOVL, Yml, Ydr0, 4, 0x0f,0x23,0,0, AMOVL, Yml, Ydr6, 4, 0x0f,0x23,6,0, AMOVL, Yml, Ydr7, 4, 0x0f,0x23,7,0, /* mov tr */ AMOVL, Ytr6, Yml, 3, 0x0f,0x24,6,0, AMOVL, Ytr7, Yml, 3, 0x0f,0x24,7,0, AMOVL, Yml, Ytr6, 4, 0x0f,0x26,6,E, AMOVL, Yml, Ytr7, 4, 0x0f,0x26,7,E, /* lgdt, sgdt, lidt, sidt */ AMOVL, Ym, Ygdtr, 4, 0x0f,0x01,2,0, AMOVL, Ygdtr, Ym, 3, 0x0f,0x01,0,0, AMOVL, Ym, Yidtr, 4, 0x0f,0x01,3,0, AMOVL, Yidtr, Ym, 3, 0x0f,0x01,1,0, /* lldt, sldt */ AMOVW, Yml, Yldtr, 4, 0x0f,0x00,2,0, AMOVW, Yldtr, Yml, 3, 0x0f,0x00,0,0, /* lmsw, smsw */ AMOVW, Yml, Ymsw, 4, 0x0f,0x01,6,0, AMOVW, Ymsw, Yml, 3, 0x0f,0x01,4,0, /* ltr, str */ AMOVW, Yml, Ytask, 4, 0x0f,0x00,3,0, AMOVW, Ytask, Yml, 3, 0x0f,0x00,1,0, /* load full pointer */ AMOVL, Yml, Ycol, 5, 0,0,0,0, AMOVW, Yml, Ycol, 5, Pe,0,0,0, /* double shift */ ASHLL, Ycol, Yml, 6, 0xa4,0xa5,0,0, ASHRL, Ycol, Yml, 6, 0xac,0xad,0,0, /* extra imul */ AIMULW, Yml, Yrl, 7, Pq,0xaf,0,0, AIMULL, Yml, Yrl, 7, Pm,0xaf,0,0, /* load TLS base pointer */ AMOVL, Ytls, Yrl, 8, 0,0,0,0, 0 }; // byteswapreg returns a byte-addressable register (AX, BX, CX, DX) // which is not referenced in a->type. // If a is empty, it returns BX to account for MULB-like instructions // that might use DX and AX. static int byteswapreg(Link *ctxt, Addr *a) { int cana, canb, canc, cand; cana = canb = canc = cand = 1; switch(a->type) { case D_NONE: cana = cand = 0; break; case D_AX: case D_AL: case D_AH: case D_INDIR+D_AX: cana = 0; break; case D_BX: case D_BL: case D_BH: case D_INDIR+D_BX: canb = 0; break; case D_CX: case D_CL: case D_CH: case D_INDIR+D_CX: canc = 0; break; case D_DX: case D_DL: case D_DH: case D_INDIR+D_DX: cand = 0; break; } switch(a->index) { case D_AX: cana = 0; break; case D_BX: canb = 0; break; case D_CX: canc = 0; break; case D_DX: cand = 0; break; } if(cana) return D_AX; if(canb) return D_BX; if(canc) return D_CX; if(cand) return D_DX; ctxt->diag("impossible byte register"); sysfatal("bad code"); return 0; } static void subreg(Prog *p, int from, int to) { if(0 /* debug['Q'] */) print("\n%P s/%R/%R/\n", p, from, to); if(p->from.type == from) { p->from.type = to; p->ft = 0; } if(p->to.type == from) { p->to.type = to; p->tt = 0; } if(p->from.index == from) { p->from.index = to; p->ft = 0; } if(p->to.index == from) { p->to.index = to; p->tt = 0; } from += D_INDIR; if(p->from.type == from) { p->from.type = to+D_INDIR; p->ft = 0; } if(p->to.type == from) { p->to.type = to+D_INDIR; p->tt = 0; } if(0 /* debug['Q'] */) print("%P\n", p); } static int mediaop(Link *ctxt, Optab *o, int op, int osize, int z) { switch(op){ case Pm: case Pe: case Pf2: case Pf3: if(osize != 1){ if(op != Pm) *ctxt->andptr++ = op; *ctxt->andptr++ = Pm; op = o->op[++z]; break; } default: if(ctxt->andptr == ctxt->and || ctxt->and[ctxt->andptr - ctxt->and - 1] != Pm) *ctxt->andptr++ = Pm; break; } *ctxt->andptr++ = op; return z; } static void doasm(Link *ctxt, Prog *p) { Optab *o; Prog *q, pp; uchar *t; int z, op, ft, tt, breg; int32 v, pre; Reloc rel, *r; Addr *a; ctxt->curp = p; // TODO pre = prefixof(ctxt, &p->from); if(pre) *ctxt->andptr++ = pre; pre = prefixof(ctxt, &p->to); if(pre) *ctxt->andptr++ = pre; if(p->ft == 0) p->ft = oclass(&p->from); if(p->tt == 0) p->tt = oclass(&p->to); ft = p->ft * Ymax; tt = p->tt * Ymax; o = &optab[p->as]; t = o->ytab; if(t == 0) { ctxt->diag("asmins: noproto %P", p); return; } for(z=0; *t; z+=t[3],t+=4) if(ycover[ft+t[0]]) if(ycover[tt+t[1]]) goto found; goto domov; found: switch(o->prefix) { case Pq: /* 16 bit escape and opcode escape */ *ctxt->andptr++ = Pe; *ctxt->andptr++ = Pm; break; case Pf2: /* xmm opcode escape */ case Pf3: *ctxt->andptr++ = o->prefix; *ctxt->andptr++ = Pm; break; case Pm: /* opcode escape */ *ctxt->andptr++ = Pm; break; case Pe: /* 16 bit escape */ *ctxt->andptr++ = Pe; break; case Pb: /* botch */ break; } op = o->op[z]; switch(t[2]) { default: ctxt->diag("asmins: unknown z %d %P", t[2], p); return; case Zpseudo: break; case Zlit: for(; op = o->op[z]; z++) *ctxt->andptr++ = op; break; case Zlitm_r: for(; op = o->op[z]; z++) *ctxt->andptr++ = op; asmand(ctxt, &p->from, reg[p->to.type]); break; case Zm_r: *ctxt->andptr++ = op; asmand(ctxt, &p->from, reg[p->to.type]); break; case Zm2_r: *ctxt->andptr++ = op; *ctxt->andptr++ = o->op[z+1]; asmand(ctxt, &p->from, reg[p->to.type]); break; case Zm_r_xm: mediaop(ctxt, o, op, t[3], z); asmand(ctxt, &p->from, reg[p->to.type]); break; case Zm_r_i_xm: mediaop(ctxt, o, op, t[3], z); asmand(ctxt, &p->from, reg[p->to.type]); *ctxt->andptr++ = p->to.offset; break; case Zibm_r: while ((op = o->op[z++]) != 0) *ctxt->andptr++ = op; asmand(ctxt, &p->from, reg[p->to.type]); *ctxt->andptr++ = p->to.offset; break; case Zaut_r: *ctxt->andptr++ = 0x8d; /* leal */ if(p->from.type != D_ADDR) ctxt->diag("asmins: Zaut sb type ADDR"); p->from.type = p->from.index; p->from.index = D_NONE; p->ft = 0; asmand(ctxt, &p->from, reg[p->to.type]); p->from.index = p->from.type; p->from.type = D_ADDR; p->ft = 0; break; case Zm_o: *ctxt->andptr++ = op; asmand(ctxt, &p->from, o->op[z+1]); break; case Zr_m: *ctxt->andptr++ = op; asmand(ctxt, &p->to, reg[p->from.type]); break; case Zr_m_xm: mediaop(ctxt, o, op, t[3], z); asmand(ctxt, &p->to, reg[p->from.type]); break; case Zr_m_i_xm: mediaop(ctxt, o, op, t[3], z); asmand(ctxt, &p->to, reg[p->from.type]); *ctxt->andptr++ = p->from.offset; break; case Zcallindreg: r = addrel(ctxt->cursym); r->off = p->pc; r->type = R_CALLIND; r->siz = 0; // fallthrough case Zo_m: *ctxt->andptr++ = op; asmand(ctxt, &p->to, o->op[z+1]); break; case Zm_ibo: *ctxt->andptr++ = op; asmand(ctxt, &p->from, o->op[z+1]); *ctxt->andptr++ = vaddr(ctxt, &p->to, nil); break; case Zibo_m: *ctxt->andptr++ = op; asmand(ctxt, &p->to, o->op[z+1]); *ctxt->andptr++ = vaddr(ctxt, &p->from, nil); break; case Z_ib: case Zib_: if(t[2] == Zib_) a = &p->from; else a = &p->to; v = vaddr(ctxt, a, nil); *ctxt->andptr++ = op; *ctxt->andptr++ = v; break; case Zib_rp: *ctxt->andptr++ = op + reg[p->to.type]; *ctxt->andptr++ = vaddr(ctxt, &p->from, nil); break; case Zil_rp: *ctxt->andptr++ = op + reg[p->to.type]; if(o->prefix == Pe) { v = vaddr(ctxt, &p->from, nil); *ctxt->andptr++ = v; *ctxt->andptr++ = v>>8; } else relput4(ctxt, p, &p->from); break; case Zib_rr: *ctxt->andptr++ = op; asmand(ctxt, &p->to, reg[p->to.type]); *ctxt->andptr++ = vaddr(ctxt, &p->from, nil); break; case Z_il: case Zil_: if(t[2] == Zil_) a = &p->from; else a = &p->to; *ctxt->andptr++ = op; if(o->prefix == Pe) { v = vaddr(ctxt, a, nil); *ctxt->andptr++ = v; *ctxt->andptr++ = v>>8; } else relput4(ctxt, p, a); break; case Zm_ilo: case Zilo_m: *ctxt->andptr++ = op; if(t[2] == Zilo_m) { a = &p->from; asmand(ctxt, &p->to, o->op[z+1]); } else { a = &p->to; asmand(ctxt, &p->from, o->op[z+1]); } if(o->prefix == Pe) { v = vaddr(ctxt, a, nil); *ctxt->andptr++ = v; *ctxt->andptr++ = v>>8; } else relput4(ctxt, p, a); break; case Zil_rr: *ctxt->andptr++ = op; asmand(ctxt, &p->to, reg[p->to.type]); if(o->prefix == Pe) { v = vaddr(ctxt, &p->from, nil); *ctxt->andptr++ = v; *ctxt->andptr++ = v>>8; } else relput4(ctxt, p, &p->from); break; case Z_rp: *ctxt->andptr++ = op + reg[p->to.type]; break; case Zrp_: *ctxt->andptr++ = op + reg[p->from.type]; break; case Zclr: *ctxt->andptr++ = op; asmand(ctxt, &p->to, reg[p->to.type]); break; case Zcall: if(p->to.sym == nil) { ctxt->diag("call without target"); sysfatal("bad code"); } *ctxt->andptr++ = op; r = addrel(ctxt->cursym); r->off = p->pc + ctxt->andptr - ctxt->and; r->type = R_CALL; r->siz = 4; r->sym = p->to.sym; r->add = p->to.offset; put4(ctxt, 0); break; case Zbr: case Zjmp: case Zloop: if(p->to.sym != nil) { if(t[2] != Zjmp) { ctxt->diag("branch to ATEXT"); sysfatal("bad code"); } *ctxt->andptr++ = o->op[z+1]; r = addrel(ctxt->cursym); r->off = p->pc + ctxt->andptr - ctxt->and; r->sym = p->to.sym; r->type = R_PCREL; r->siz = 4; put4(ctxt, 0); break; } // Assumes q is in this function. // Fill in backward jump now. q = p->pcond; if(q == nil) { ctxt->diag("jmp/branch/loop without target"); sysfatal("bad code"); } if(p->back & 1) { v = q->pc - (p->pc + 2); if(v >= -128) { if(p->as == AJCXZW) *ctxt->andptr++ = 0x67; *ctxt->andptr++ = op; *ctxt->andptr++ = v; } else if(t[2] == Zloop) { ctxt->diag("loop too far: %P", p); } else { v -= 5-2; if(t[2] == Zbr) { *ctxt->andptr++ = 0x0f; v--; } *ctxt->andptr++ = o->op[z+1]; *ctxt->andptr++ = v; *ctxt->andptr++ = v>>8; *ctxt->andptr++ = v>>16; *ctxt->andptr++ = v>>24; } break; } // Annotate target; will fill in later. p->forwd = q->comefrom; q->comefrom = p; if(p->back & 2) { // short if(p->as == AJCXZW) *ctxt->andptr++ = 0x67; *ctxt->andptr++ = op; *ctxt->andptr++ = 0; } else if(t[2] == Zloop) { ctxt->diag("loop too far: %P", p); } else { if(t[2] == Zbr) *ctxt->andptr++ = 0x0f; *ctxt->andptr++ = o->op[z+1]; *ctxt->andptr++ = 0; *ctxt->andptr++ = 0; *ctxt->andptr++ = 0; *ctxt->andptr++ = 0; } break; case Zcallcon: case Zjmpcon: if(t[2] == Zcallcon) *ctxt->andptr++ = op; else *ctxt->andptr++ = o->op[z+1]; r = addrel(ctxt->cursym); r->off = p->pc + ctxt->andptr - ctxt->and; r->type = R_PCREL; r->siz = 4; r->add = p->to.offset; put4(ctxt, 0); break; case Zcallind: *ctxt->andptr++ = op; *ctxt->andptr++ = o->op[z+1]; r = addrel(ctxt->cursym); r->off = p->pc + ctxt->andptr - ctxt->and; r->type = R_ADDR; r->siz = 4; r->add = p->to.offset; r->sym = p->to.sym; put4(ctxt, 0); break; case Zbyte: v = vaddr(ctxt, &p->from, &rel); if(rel.siz != 0) { rel.siz = op; r = addrel(ctxt->cursym); *r = rel; r->off = p->pc + ctxt->andptr - ctxt->and; } *ctxt->andptr++ = v; if(op > 1) { *ctxt->andptr++ = v>>8; if(op > 2) { *ctxt->andptr++ = v>>16; *ctxt->andptr++ = v>>24; } } break; case Zmov: goto domov; } return; domov: for(t=ymovtab; *t; t+=8) if(p->as == t[0]) if(ycover[ft+t[1]]) if(ycover[tt+t[2]]) goto mfound; bad: /* * here, the assembly has failed. * if its a byte instruction that has * unaddressable registers, try to * exchange registers and reissue the * instruction with the operands renamed. */ pp = *p; z = p->from.type; if(z >= D_BP && z <= D_DI) { if((breg = byteswapreg(ctxt, &p->to)) != D_AX) { *ctxt->andptr++ = 0x87; /* xchg lhs,bx */ asmand(ctxt, &p->from, reg[breg]); subreg(&pp, z, breg); doasm(ctxt, &pp); *ctxt->andptr++ = 0x87; /* xchg lhs,bx */ asmand(ctxt, &p->from, reg[breg]); } else { *ctxt->andptr++ = 0x90 + reg[z]; /* xchg lsh,ax */ subreg(&pp, z, D_AX); doasm(ctxt, &pp); *ctxt->andptr++ = 0x90 + reg[z]; /* xchg lsh,ax */ } return; } z = p->to.type; if(z >= D_BP && z <= D_DI) { if((breg = byteswapreg(ctxt, &p->from)) != D_AX) { *ctxt->andptr++ = 0x87; /* xchg rhs,bx */ asmand(ctxt, &p->to, reg[breg]); subreg(&pp, z, breg); doasm(ctxt, &pp); *ctxt->andptr++ = 0x87; /* xchg rhs,bx */ asmand(ctxt, &p->to, reg[breg]); } else { *ctxt->andptr++ = 0x90 + reg[z]; /* xchg rsh,ax */ subreg(&pp, z, D_AX); doasm(ctxt, &pp); *ctxt->andptr++ = 0x90 + reg[z]; /* xchg rsh,ax */ } return; } ctxt->diag("doasm: notfound t2=%ux from=%ux to=%ux %P", t[2], p->from.type, p->to.type, p); return; mfound: switch(t[3]) { default: ctxt->diag("asmins: unknown mov %d %P", t[3], p); break; case 0: /* lit */ for(z=4; t[z]!=E; z++) *ctxt->andptr++ = t[z]; break; case 1: /* r,m */ *ctxt->andptr++ = t[4]; asmand(ctxt, &p->to, t[5]); break; case 2: /* m,r */ *ctxt->andptr++ = t[4]; asmand(ctxt, &p->from, t[5]); break; case 3: /* r,m - 2op */ *ctxt->andptr++ = t[4]; *ctxt->andptr++ = t[5]; asmand(ctxt, &p->to, t[6]); break; case 4: /* m,r - 2op */ *ctxt->andptr++ = t[4]; *ctxt->andptr++ = t[5]; asmand(ctxt, &p->from, t[6]); break; case 5: /* load full pointer, trash heap */ if(t[4]) *ctxt->andptr++ = t[4]; switch(p->to.index) { default: goto bad; case D_DS: *ctxt->andptr++ = 0xc5; break; case D_SS: *ctxt->andptr++ = 0x0f; *ctxt->andptr++ = 0xb2; break; case D_ES: *ctxt->andptr++ = 0xc4; break; case D_FS: *ctxt->andptr++ = 0x0f; *ctxt->andptr++ = 0xb4; break; case D_GS: *ctxt->andptr++ = 0x0f; *ctxt->andptr++ = 0xb5; break; } asmand(ctxt, &p->from, reg[p->to.type]); break; case 6: /* double shift */ z = p->from.type; switch(z) { default: goto bad; case D_CONST: *ctxt->andptr++ = 0x0f; *ctxt->andptr++ = t[4]; asmand(ctxt, &p->to, reg[p->from.index]); *ctxt->andptr++ = p->from.offset; break; case D_CL: case D_CX: *ctxt->andptr++ = 0x0f; *ctxt->andptr++ = t[5]; asmand(ctxt, &p->to, reg[p->from.index]); break; } break; case 7: /* imul rm,r */ if(t[4] == Pq) { *ctxt->andptr++ = Pe; *ctxt->andptr++ = Pm; } else *ctxt->andptr++ = t[4]; *ctxt->andptr++ = t[5]; asmand(ctxt, &p->from, reg[p->to.type]); break; case 8: /* mov tls, r */ // NOTE: The systems listed here are the ones that use the "TLS initial exec" model, // where you load the TLS base register into a register and then index off that // register to access the actual TLS variables. Systems that allow direct TLS access // are handled in prefixof above and should not be listed here. switch(ctxt->headtype) { default: sysfatal("unknown TLS base location for %s", headstr(ctxt->headtype)); case Hlinux: case Hnacl: // ELF TLS base is 0(GS). pp.from = p->from; pp.from.type = D_INDIR+D_GS; pp.from.offset = 0; pp.from.index = D_NONE; pp.from.scale = 0; *ctxt->andptr++ = 0x65; // GS *ctxt->andptr++ = 0x8B; asmand(ctxt, &pp.from, reg[p->to.type]); break; case Hplan9: if(ctxt->plan9privates == nil) ctxt->plan9privates = linklookup(ctxt, "_privates", 0); memset(&pp.from, 0, sizeof pp.from); pp.from.type = D_EXTERN; pp.from.sym = ctxt->plan9privates; pp.from.offset = 0; pp.from.index = D_NONE; *ctxt->andptr++ = 0x8B; asmand(ctxt, &pp.from, reg[p->to.type]); break; case Hwindows: // Windows TLS base is always 0x14(FS). pp.from = p->from; pp.from.type = D_INDIR+D_FS; pp.from.offset = 0x14; pp.from.index = D_NONE; pp.from.scale = 0; *ctxt->andptr++ = 0x64; // FS *ctxt->andptr++ = 0x8B; asmand(ctxt, &pp.from, reg[p->to.type]); break; } break; } } static uchar naclret[] = { 0x5d, // POPL BP // 0x8b, 0x7d, 0x00, // MOVL (BP), DI - catch return to invalid address, for debugging 0x83, 0xe5, 0xe0, // ANDL $~31, BP 0xff, 0xe5, // JMP BP }; static void asmins(Link *ctxt, Prog *p) { Reloc *r; ctxt->andptr = ctxt->and; if(p->as == AUSEFIELD) { r = addrel(ctxt->cursym); r->off = 0; r->sym = p->from.sym; r->type = R_USEFIELD; r->siz = 0; return; } if(ctxt->headtype == Hnacl) { switch(p->as) { case ARET: memmove(ctxt->andptr, naclret, sizeof naclret); ctxt->andptr += sizeof naclret; return; case ACALL: case AJMP: if(D_AX <= p->to.type && p->to.type <= D_DI) { *ctxt->andptr++ = 0x83; *ctxt->andptr++ = 0xe0 | (p->to.type - D_AX); *ctxt->andptr++ = 0xe0; } break; case AINT: *ctxt->andptr++ = 0xf4; return; } } doasm(ctxt, p); if(ctxt->andptr > ctxt->and+sizeof ctxt->and) { print("and[] is too short - %ld byte instruction\n", ctxt->andptr - ctxt->and); sysfatal("bad code"); } }