| // 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 <u.h> |
| #include <libc.h> |
| #include <bio.h> |
| #include <link.h> |
| #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; i<s->np; i++) { |
| print(" %.2ux", s->p[i]); |
| if(i%16 == 15) |
| print("\n %.6ux", i+1); |
| } |
| if(i%16) |
| print("\n"); |
| |
| for(i=0; i<s->nr; 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<Ymax; i++) |
| ycover[i*Ymax + i] = 1; |
| |
| ycover[Yi0*Ymax + Yi8] = 1; |
| ycover[Yi1*Ymax + Yi8] = 1; |
| |
| ycover[Yi0*Ymax + Yi32] = 1; |
| ycover[Yi1*Ymax + Yi32] = 1; |
| ycover[Yi8*Ymax + Yi32] = 1; |
| |
| ycover[Yal*Ymax + Yrb] = 1; |
| ycover[Ycl*Ymax + Yrb] = 1; |
| ycover[Yax*Ymax + Yrb] = 1; |
| ycover[Ycx*Ymax + Yrb] = 1; |
| ycover[Yrx*Ymax + Yrb] = 1; |
| |
| ycover[Yax*Ymax + Yrx] = 1; |
| ycover[Ycx*Ymax + Yrx] = 1; |
| |
| ycover[Yax*Ymax + Yrl] = 1; |
| ycover[Ycx*Ymax + Yrl] = 1; |
| ycover[Yrx*Ymax + Yrl] = 1; |
| |
| ycover[Yf0*Ymax + Yrf] = 1; |
| |
| ycover[Yal*Ymax + Ymb] = 1; |
| ycover[Ycl*Ymax + Ymb] = 1; |
| ycover[Yax*Ymax + Ymb] = 1; |
| ycover[Ycx*Ymax + Ymb] = 1; |
| ycover[Yrx*Ymax + Ymb] = 1; |
| ycover[Yrb*Ymax + Ymb] = 1; |
| ycover[Ym*Ymax + Ymb] = 1; |
| |
| ycover[Yax*Ymax + Yml] = 1; |
| ycover[Ycx*Ymax + Yml] = 1; |
| ycover[Yrx*Ymax + Yml] = 1; |
| ycover[Yrl*Ymax + Yml] = 1; |
| ycover[Ym*Ymax + Yml] = 1; |
| |
| ycover[Yax*Ymax + Ymm] = 1; |
| ycover[Ycx*Ymax + Ymm] = 1; |
| ycover[Yrx*Ymax + Ymm] = 1; |
| ycover[Yrl*Ymax + Ymm] = 1; |
| ycover[Ym*Ymax + Ymm] = 1; |
| ycover[Ymr*Ymax + Ymm] = 1; |
| |
| ycover[Ym*Ymax + Yxm] = 1; |
| ycover[Yxr*Ymax + Yxm] = 1; |
| |
| for(i=0; i<D_NONE; i++) { |
| reg[i] = -1; |
| if(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; |
| |