blob: 0c0cc0454853001f714aff513ac4827ce89d460d [file] [log] [blame]
// Inferno utils/6l/span.c
// http://code.google.com/p/inferno-os/source/browse/utils/6l/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.
package x86
import (
"cmd/internal/obj"
"fmt"
"log"
"strings"
)
// Instruction layout.
const (
MaxAlign = 32 // max data alignment
// Loop alignment constants:
// want to align loop entry to LoopAlign-byte boundary,
// and willing to insert at most MaxLoopPad bytes of NOP to do so.
// We define a loop entry as the target of a backward jump.
//
// gcc uses MaxLoopPad = 10 for its 'generic x86-64' config,
// and it aligns all jump targets, not just backward jump targets.
//
// As of 6/1/2012, the effect of setting MaxLoopPad = 10 here
// is very slight but negative, so the alignment is disabled by
// setting MaxLoopPad = 0. The code is here for reference and
// for future experiments.
//
LoopAlign = 16
MaxLoopPad = 0
FuncAlign = 16
)
type Optab struct {
as int16
ytab []ytab
prefix uint8
op [23]uint8
}
type ytab struct {
from uint8
from3 uint8
to uint8
zcase uint8
zoffset uint8
}
type Movtab struct {
as int16
ft uint8
f3t uint8
tt uint8
code uint8
op [4]uint8
}
const (
Yxxx = iota
Ynone
Yi0 // $0
Yi1 // $1
Yi8 // $x, x fits in int8
Yu8 // $x, x fits in uint8
Yu7 // $x, x in 0..127 (fits in both int8 and uint8)
Ys32
Yi32
Yi64
Yiauto
Yal
Ycl
Yax
Ycx
Yrb
Yrl
Yrl32 // Yrl on 32-bit system
Yrf
Yf0
Yrx
Ymb
Yml
Ym
Ybr
Ycs
Yss
Yds
Yes
Yfs
Ygs
Ygdtr
Yidtr
Yldtr
Ymsw
Ytask
Ycr0
Ycr1
Ycr2
Ycr3
Ycr4
Ycr5
Ycr6
Ycr7
Ycr8
Ydr0
Ydr1
Ydr2
Ydr3
Ydr4
Ydr5
Ydr6
Ydr7
Ytr0
Ytr1
Ytr2
Ytr3
Ytr4
Ytr5
Ytr6
Ytr7
Ymr
Ymm
Yxr
Yxm
Ytls
Ytextsize
Yindir
Ymax
)
const (
Zxxx = iota
Zlit
Zlitm_r
Z_rp
Zbr
Zcall
Zcallcon
Zcallduff
Zcallind
Zcallindreg
Zib_
Zib_rp
Zibo_m
Zibo_m_xm
Zil_
Zil_rp
Ziq_rp
Zilo_m
Ziqo_m
Zjmp
Zjmpcon
Zloop
Zo_iw
Zm_o
Zm_r
Zm2_r
Zm_r_xm
Zm_r_i_xm
Zm_r_3d
Zm_r_xm_nr
Zr_m_xm_nr
Zibm_r /* mmx1,mmx2/mem64,imm8 */
Zmb_r
Zaut_r
Zo_m
Zo_m64
Zpseudo
Zr_m
Zr_m_xm
Zrp_
Z_ib
Z_il
Zm_ibo
Zm_ilo
Zib_rr
Zil_rr
Zclr
Zbyte
Zmax
)
const (
Px = 0
Px1 = 1 // symbolic; exact value doesn't matter
P32 = 0x32 /* 32-bit only */
Pe = 0x66 /* operand escape */
Pm = 0x0f /* 2byte opcode escape */
Pq = 0xff /* both escapes: 66 0f */
Pb = 0xfe /* byte operands */
Pf2 = 0xf2 /* xmm escape 1: f2 0f */
Pf3 = 0xf3 /* xmm escape 2: f3 0f */
Pq3 = 0x67 /* xmm escape 3: 66 48 0f */
Pw = 0x48 /* Rex.w */
Pw8 = 0x90 // symbolic; exact value doesn't matter
Py = 0x80 /* defaults to 64-bit mode */
Py1 = 0x81 // symbolic; exact value doesn't matter
Py3 = 0x83 // symbolic; exact value doesn't matter
Rxf = 1 << 9 /* internal flag for Rxr on from */
Rxt = 1 << 8 /* internal flag for Rxr on to */
Rxw = 1 << 3 /* =1, 64-bit operand size */
Rxr = 1 << 2 /* extend modrm reg */
Rxx = 1 << 1 /* extend sib index */
Rxb = 1 << 0 /* extend modrm r/m, sib base, or opcode reg */
Maxand = 10 /* in -a output width of the byte codes */
)
var ycover [Ymax * Ymax]uint8
var reg [MAXREG]int
var regrex [MAXREG + 1]int
var ynone = []ytab{
{Ynone, Ynone, Ynone, Zlit, 1},
}
var ysahf = []ytab{
{Ynone, Ynone, Ynone, Zlit, 2},
{Ynone, Ynone, Ynone, Zlit, 1},
}
var ytext = []ytab{
{Ymb, Ynone, Ytextsize, Zpseudo, 0},
{Ymb, Yi32, Ytextsize, Zpseudo, 1},
}
var ynop = []ytab{
{Ynone, Ynone, Ynone, Zpseudo, 0},
{Ynone, Ynone, Yiauto, Zpseudo, 0},
{Ynone, Ynone, Yml, Zpseudo, 0},
{Ynone, Ynone, Yrf, Zpseudo, 0},
{Ynone, Ynone, Yxr, Zpseudo, 0},
{Yiauto, Ynone, Ynone, Zpseudo, 0},
{Yml, Ynone, Ynone, Zpseudo, 0},
{Yrf, Ynone, Ynone, Zpseudo, 0},
{Yxr, Ynone, Ynone, Zpseudo, 1},
}
var yfuncdata = []ytab{
{Yi32, Ynone, Ym, Zpseudo, 0},
}
var ypcdata = []ytab{
{Yi32, Ynone, Yi32, Zpseudo, 0},
}
var yxorb = []ytab{
{Yi32, Ynone, Yal, Zib_, 1},
{Yi32, Ynone, Ymb, Zibo_m, 2},
{Yrb, Ynone, Ymb, Zr_m, 1},
{Ymb, Ynone, Yrb, Zm_r, 1},
}
var yxorl = []ytab{
{Yi8, Ynone, Yml, Zibo_m, 2},
{Yi32, Ynone, Yax, Zil_, 1},
{Yi32, Ynone, Yml, Zilo_m, 2},
{Yrl, Ynone, Yml, Zr_m, 1},
{Yml, Ynone, Yrl, Zm_r, 1},
}
var yaddl = []ytab{
{Yi8, Ynone, Yml, Zibo_m, 2},
{Yi32, Ynone, Yax, Zil_, 1},
{Yi32, Ynone, Yml, Zilo_m, 2},
{Yrl, Ynone, Yml, Zr_m, 1},
{Yml, Ynone, Yrl, Zm_r, 1},
}
var yincb = []ytab{
{Ynone, Ynone, Ymb, Zo_m, 2},
}
var yincw = []ytab{
{Ynone, Ynone, Yml, Zo_m, 2},
}
var yincl = []ytab{
{Ynone, Ynone, Yrl, Z_rp, 1},
{Ynone, Ynone, Yml, Zo_m, 2},
}
var yincq = []ytab{
{Ynone, Ynone, Yml, Zo_m, 2},
}
var ycmpb = []ytab{
{Yal, Ynone, Yi32, Z_ib, 1},
{Ymb, Ynone, Yi32, Zm_ibo, 2},
{Ymb, Ynone, Yrb, Zm_r, 1},
{Yrb, Ynone, Ymb, Zr_m, 1},
}
var ycmpl = []ytab{
{Yml, Ynone, Yi8, Zm_ibo, 2},
{Yax, Ynone, Yi32, Z_il, 1},
{Yml, Ynone, Yi32, Zm_ilo, 2},
{Yml, Ynone, Yrl, Zm_r, 1},
{Yrl, Ynone, Yml, Zr_m, 1},
}
var yshb = []ytab{
{Yi1, Ynone, Ymb, Zo_m, 2},
{Yi32, Ynone, Ymb, Zibo_m, 2},
{Ycx, Ynone, Ymb, Zo_m, 2},
}
var yshl = []ytab{
{Yi1, Ynone, Yml, Zo_m, 2},
{Yi32, Ynone, Yml, Zibo_m, 2},
{Ycl, Ynone, Yml, Zo_m, 2},
{Ycx, Ynone, Yml, Zo_m, 2},
}
var ytestb = []ytab{
{Yi32, Ynone, Yal, Zib_, 1},
{Yi32, Ynone, Ymb, Zibo_m, 2},
{Yrb, Ynone, Ymb, Zr_m, 1},
{Ymb, Ynone, Yrb, Zm_r, 1},
}
var ytestl = []ytab{
{Yi32, Ynone, Yax, Zil_, 1},
{Yi32, Ynone, Yml, Zilo_m, 2},
{Yrl, Ynone, Yml, Zr_m, 1},
{Yml, Ynone, Yrl, Zm_r, 1},
}
var ymovb = []ytab{
{Yrb, Ynone, Ymb, Zr_m, 1},
{Ymb, Ynone, Yrb, Zm_r, 1},
{Yi32, Ynone, Yrb, Zib_rp, 1},
{Yi32, Ynone, Ymb, Zibo_m, 2},
}
var ymbs = []ytab{
{Ymb, Ynone, Ynone, Zm_o, 2},
}
var ybtl = []ytab{
{Yi8, Ynone, Yml, Zibo_m, 2},
{Yrl, Ynone, Yml, Zr_m, 1},
}
var ymovw = []ytab{
{Yrl, Ynone, Yml, Zr_m, 1},
{Yml, Ynone, Yrl, Zm_r, 1},
{Yi0, Ynone, Yrl, Zclr, 1},
{Yi32, Ynone, Yrl, Zil_rp, 1},
{Yi32, Ynone, Yml, Zilo_m, 2},
{Yiauto, Ynone, Yrl, Zaut_r, 2},
}
var ymovl = []ytab{
{Yrl, Ynone, Yml, Zr_m, 1},
{Yml, Ynone, Yrl, Zm_r, 1},
{Yi0, Ynone, Yrl, Zclr, 1},
{Yi32, Ynone, Yrl, Zil_rp, 1},
{Yi32, Ynone, Yml, Zilo_m, 2},
{Yml, Ynone, Ymr, Zm_r_xm, 1}, // MMX MOVD
{Ymr, Ynone, Yml, Zr_m_xm, 1}, // MMX MOVD
{Yml, Ynone, Yxr, Zm_r_xm, 2}, // XMM MOVD (32 bit)
{Yxr, Ynone, Yml, Zr_m_xm, 2}, // XMM MOVD (32 bit)
{Yiauto, Ynone, Yrl, Zaut_r, 2},
}
var yret = []ytab{
{Ynone, Ynone, Ynone, Zo_iw, 1},
{Yi32, Ynone, Ynone, Zo_iw, 1},
}
var ymovq = []ytab{
// valid in 32-bit mode
{Ym, Ynone, Ymr, Zm_r_xm_nr, 1}, // 0x6f MMX MOVQ (shorter encoding)
{Ymr, Ynone, Ym, Zr_m_xm_nr, 1}, // 0x7f MMX MOVQ
{Yxr, Ynone, Ymr, Zm_r_xm_nr, 2}, // Pf2, 0xd6 MOVDQ2Q
{Yxm, Ynone, Yxr, Zm_r_xm_nr, 2}, // Pf3, 0x7e MOVQ xmm1/m64 -> xmm2
{Yxr, Ynone, Yxm, Zr_m_xm_nr, 2}, // Pe, 0xd6 MOVQ xmm1 -> xmm2/m64
// valid only in 64-bit mode, usually with 64-bit prefix
{Yrl, Ynone, Yml, Zr_m, 1}, // 0x89
{Yml, Ynone, Yrl, Zm_r, 1}, // 0x8b
{Yi0, Ynone, Yrl, Zclr, 1}, // 0x31
{Ys32, Ynone, Yrl, Zilo_m, 2}, // 32 bit signed 0xc7,(0)
{Yi64, Ynone, Yrl, Ziq_rp, 1}, // 0xb8 -- 32/64 bit immediate
{Yi32, Ynone, Yml, Zilo_m, 2}, // 0xc7,(0)
{Ymm, Ynone, Ymr, Zm_r_xm, 1}, // 0x6e MMX MOVD
{Ymr, Ynone, Ymm, Zr_m_xm, 1}, // 0x7e MMX MOVD
{Yml, Ynone, Yxr, Zm_r_xm, 2}, // Pe, 0x6e MOVD xmm load
{Yxr, Ynone, Yml, Zr_m_xm, 2}, // Pe, 0x7e MOVD xmm store
{Yiauto, Ynone, Yrl, Zaut_r, 1}, // 0 built-in LEAQ
}
var ym_rl = []ytab{
{Ym, Ynone, Yrl, Zm_r, 1},
}
var yrl_m = []ytab{
{Yrl, Ynone, Ym, Zr_m, 1},
}
var ymb_rl = []ytab{
{Ymb, Ynone, Yrl, Zmb_r, 1},
}
var yml_rl = []ytab{
{Yml, Ynone, Yrl, Zm_r, 1},
}
var yrl_ml = []ytab{
{Yrl, Ynone, Yml, Zr_m, 1},
}
var yml_mb = []ytab{
{Yrb, Ynone, Ymb, Zr_m, 1},
{Ymb, Ynone, Yrb, Zm_r, 1},
}
var yrb_mb = []ytab{
{Yrb, Ynone, Ymb, Zr_m, 1},
}
var yxchg = []ytab{
{Yax, Ynone, Yrl, Z_rp, 1},
{Yrl, Ynone, Yax, Zrp_, 1},
{Yrl, Ynone, Yml, Zr_m, 1},
{Yml, Ynone, Yrl, Zm_r, 1},
}
var ydivl = []ytab{
{Yml, Ynone, Ynone, Zm_o, 2},
}
var ydivb = []ytab{
{Ymb, Ynone, Ynone, Zm_o, 2},
}
var yimul = []ytab{
{Yml, Ynone, Ynone, Zm_o, 2},
{Yi8, Ynone, Yrl, Zib_rr, 1},
{Yi32, Ynone, Yrl, Zil_rr, 1},
{Yml, Ynone, Yrl, Zm_r, 2},
}
var yimul3 = []ytab{
{Yi8, Yml, Yrl, Zibm_r, 2},
}
var ybyte = []ytab{
{Yi64, Ynone, Ynone, Zbyte, 1},
}
var yin = []ytab{
{Yi32, Ynone, Ynone, Zib_, 1},
{Ynone, Ynone, Ynone, Zlit, 1},
}
var yint = []ytab{
{Yi32, Ynone, Ynone, Zib_, 1},
}
var ypushl = []ytab{
{Yrl, Ynone, Ynone, Zrp_, 1},
{Ym, Ynone, Ynone, Zm_o, 2},
{Yi8, Ynone, Ynone, Zib_, 1},
{Yi32, Ynone, Ynone, Zil_, 1},
}
var ypopl = []ytab{
{Ynone, Ynone, Yrl, Z_rp, 1},
{Ynone, Ynone, Ym, Zo_m, 2},
}
var ybswap = []ytab{
{Ynone, Ynone, Yrl, Z_rp, 2},
}
var yscond = []ytab{
{Ynone, Ynone, Ymb, Zo_m, 2},
}
var yjcond = []ytab{
{Ynone, Ynone, Ybr, Zbr, 0},
{Yi0, Ynone, Ybr, Zbr, 0},
{Yi1, Ynone, Ybr, Zbr, 1},
}
var yloop = []ytab{
{Ynone, Ynone, Ybr, Zloop, 1},
}
var ycall = []ytab{
{Ynone, Ynone, Yml, Zcallindreg, 0},
{Yrx, Ynone, Yrx, Zcallindreg, 2},
{Ynone, Ynone, Yindir, Zcallind, 2},
{Ynone, Ynone, Ybr, Zcall, 0},
{Ynone, Ynone, Yi32, Zcallcon, 1},
}
var yduff = []ytab{
{Ynone, Ynone, Yi32, Zcallduff, 1},
}
var yjmp = []ytab{
{Ynone, Ynone, Yml, Zo_m64, 2},
{Ynone, Ynone, Ybr, Zjmp, 0},
{Ynone, Ynone, Yi32, Zjmpcon, 1},
}
var yfmvd = []ytab{
{Ym, Ynone, Yf0, Zm_o, 2},
{Yf0, Ynone, Ym, Zo_m, 2},
{Yrf, Ynone, Yf0, Zm_o, 2},
{Yf0, Ynone, Yrf, Zo_m, 2},
}
var yfmvdp = []ytab{
{Yf0, Ynone, Ym, Zo_m, 2},
{Yf0, Ynone, Yrf, Zo_m, 2},
}
var yfmvf = []ytab{
{Ym, Ynone, Yf0, Zm_o, 2},
{Yf0, Ynone, Ym, Zo_m, 2},
}
var yfmvx = []ytab{
{Ym, Ynone, Yf0, Zm_o, 2},
}
var yfmvp = []ytab{
{Yf0, Ynone, Ym, Zo_m, 2},
}
var yfcmv = []ytab{
{Yrf, Ynone, Yf0, Zm_o, 2},
}
var yfadd = []ytab{
{Ym, Ynone, Yf0, Zm_o, 2},
{Yrf, Ynone, Yf0, Zm_o, 2},
{Yf0, Ynone, Yrf, Zo_m, 2},
}
var yfaddp = []ytab{
{Yf0, Ynone, Yrf, Zo_m, 2},
}
var yfxch = []ytab{
{Yf0, Ynone, Yrf, Zo_m, 2},
{Yrf, Ynone, Yf0, Zm_o, 2},
}
var ycompp = []ytab{
{Yf0, Ynone, Yrf, Zo_m, 2}, /* botch is really f0,f1 */
}
var ystsw = []ytab{
{Ynone, Ynone, Ym, Zo_m, 2},
{Ynone, Ynone, Yax, Zlit, 1},
}
var ystcw = []ytab{
{Ynone, Ynone, Ym, Zo_m, 2},
{Ym, Ynone, Ynone, Zm_o, 2},
}
var ysvrs = []ytab{
{Ynone, Ynone, Ym, Zo_m, 2},
{Ym, Ynone, Ynone, Zm_o, 2},
}
var ymm = []ytab{
{Ymm, Ynone, Ymr, Zm_r_xm, 1},
{Yxm, Ynone, Yxr, Zm_r_xm, 2},
}
var yxm = []ytab{
{Yxm, Ynone, Yxr, Zm_r_xm, 1},
}
var yxcvm1 = []ytab{
{Yxm, Ynone, Yxr, Zm_r_xm, 2},
{Yxm, Ynone, Ymr, Zm_r_xm, 2},
}
var yxcvm2 = []ytab{
{Yxm, Ynone, Yxr, Zm_r_xm, 2},
{Ymm, Ynone, Yxr, Zm_r_xm, 2},
}
/*
var yxmq = []ytab{
{Yxm, Ynone, Yxr, Zm_r_xm, 2},
}
*/
var yxr = []ytab{
{Yxr, Ynone, Yxr, Zm_r_xm, 1},
}
var yxr_ml = []ytab{
{Yxr, Ynone, Yml, Zr_m_xm, 1},
}
var ymr = []ytab{
{Ymr, Ynone, Ymr, Zm_r, 1},
}
var ymr_ml = []ytab{
{Ymr, Ynone, Yml, Zr_m_xm, 1},
}
var yxcmp = []ytab{
{Yxm, Ynone, Yxr, Zm_r_xm, 1},
}
var yxcmpi = []ytab{
{Yxm, Yxr, Yi8, Zm_r_i_xm, 2},
}
var yxmov = []ytab{
{Yxm, Ynone, Yxr, Zm_r_xm, 1},
{Yxr, Ynone, Yxm, Zr_m_xm, 1},
}
var yxcvfl = []ytab{
{Yxm, Ynone, Yrl, Zm_r_xm, 1},
}
var yxcvlf = []ytab{
{Yml, Ynone, Yxr, Zm_r_xm, 1},
}
var yxcvfq = []ytab{
{Yxm, Ynone, Yrl, Zm_r_xm, 2},
}
var yxcvqf = []ytab{
{Yml, Ynone, Yxr, Zm_r_xm, 2},
}
var yps = []ytab{
{Ymm, Ynone, Ymr, Zm_r_xm, 1},
{Yi8, Ynone, Ymr, Zibo_m_xm, 2},
{Yxm, Ynone, Yxr, Zm_r_xm, 2},
{Yi8, Ynone, Yxr, Zibo_m_xm, 3},
}
var yxrrl = []ytab{
{Yxr, Ynone, Yrl, Zm_r, 1},
}
var ymfp = []ytab{
{Ymm, Ynone, Ymr, Zm_r_3d, 1},
}
var ymrxr = []ytab{
{Ymr, Ynone, Yxr, Zm_r, 1},
{Yxm, Ynone, Yxr, Zm_r_xm, 1},
}
var ymshuf = []ytab{
{Yi8, Ymm, Ymr, Zibm_r, 2},
}
var ymshufb = []ytab{
{Yxm, Ynone, Yxr, Zm2_r, 2},
}
var yxshuf = []ytab{
{Yu8, Yxm, Yxr, Zibm_r, 2},
}
var yextrw = []ytab{
{Yu8, Yxr, Yrl, Zibm_r, 2},
}
var yinsrw = []ytab{
{Yu8, Yml, Yxr, Zibm_r, 2},
}
var yinsr = []ytab{
{Yu8, Ymm, Yxr, Zibm_r, 3},
}
var ypsdq = []ytab{
{Yi8, Ynone, Yxr, Zibo_m, 2},
}
var ymskb = []ytab{
{Yxr, Ynone, Yrl, Zm_r_xm, 2},
{Ymr, Ynone, Yrl, Zm_r_xm, 1},
}
var ycrc32l = []ytab{
{Yml, Ynone, Yrl, Zlitm_r, 0},
}
var yprefetch = []ytab{
{Ym, Ynone, Ynone, Zm_o, 2},
}
var yaes = []ytab{
{Yxm, Ynone, Yxr, Zlitm_r, 2},
}
var yaes2 = []ytab{
{Yu8, Yxm, Yxr, Zibm_r, 2},
}
/*
* You are doasm, holding in your hand a Prog* with p->as set to, say, ACRC32,
* and p->from and p->to as operands (Addr*). The linker scans optab to find
* the entry with the given p->as and then looks through the ytable for that
* instruction (the second field in the optab struct) for a line whose first
* two values match the Ytypes of the p->from and p->to operands. The function
* oclass in span.c computes the specific Ytype of an operand and then the set
* of more general Ytypes that it satisfies is implied by the ycover table, set
* up in instinit. For example, oclass distinguishes the constants 0 and 1
* from the more general 8-bit constants, but instinit says
*
* ycover[Yi0*Ymax + Ys32] = 1;
* ycover[Yi1*Ymax + Ys32] = 1;
* ycover[Yi8*Ymax + Ys32] = 1;
*
* which means that Yi0, Yi1, and Yi8 all count as Ys32 (signed 32)
* if that's what an instruction can handle.
*
* In parallel with the scan through the ytable for the appropriate line, there
* is a z pointer that starts out pointing at the strange magic byte list in
* the Optab struct. With each step past a non-matching ytable line, z
* advances by the 4th entry in the line. When a matching line is found, that
* z pointer has the extra data to use in laying down the instruction bytes.
* The actual bytes laid down are a function of the 3rd entry in the line (that
* is, the Ztype) and the z bytes.
*
* For example, let's look at AADDL. The optab line says:
* { AADDL, yaddl, Px, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
*
* and yaddl says
* 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
* };
*
* so there are 5 possible types of ADDL instruction that can be laid down, and
* possible states used to lay them down (Ztype and z pointer, assuming z
* points at {0x83,(00),0x05,0x81,(00),0x01,0x03}) are:
*
* Yi8, Yml -> Zibo_m, z (0x83, 00)
* Yi32, Yax -> Zil_, z+2 (0x05)
* Yi32, Yml -> Zilo_m, z+2+1 (0x81, 0x00)
* Yrl, Yml -> Zr_m, z+2+1+2 (0x01)
* Yml, Yrl -> Zm_r, z+2+1+2+1 (0x03)
*
* The Pconstant in the optab line controls the prefix bytes to emit. That's
* relatively straightforward as this program goes.
*
* The switch on t[2] in doasm implements the various Z cases. Zibo_m, for
* example, is an opcode byte (z[0]) then an asmando (which is some kind of
* encoded addressing mode for the Yml arg), and then a single immediate byte.
* Zilo_m is the same but a long (32-bit) immediate.
*/
var optab =
/* as, ytab, andproto, opcode */
[]Optab{
Optab{obj.AXXX, nil, 0, [23]uint8{}},
Optab{AAAA, ynone, P32, [23]uint8{0x37}},
Optab{AAAD, ynone, P32, [23]uint8{0xd5, 0x0a}},
Optab{AAAM, ynone, P32, [23]uint8{0xd4, 0x0a}},
Optab{AAAS, ynone, P32, [23]uint8{0x3f}},
Optab{AADCB, yxorb, Pb, [23]uint8{0x14, 0x80, 02, 0x10, 0x10}},
Optab{AADCL, yxorl, Px, [23]uint8{0x83, 02, 0x15, 0x81, 02, 0x11, 0x13}},
Optab{AADCQ, yxorl, Pw, [23]uint8{0x83, 02, 0x15, 0x81, 02, 0x11, 0x13}},
Optab{AADCW, yxorl, Pe, [23]uint8{0x83, 02, 0x15, 0x81, 02, 0x11, 0x13}},
Optab{AADDB, yxorb, Pb, [23]uint8{0x04, 0x80, 00, 0x00, 0x02}},
Optab{AADDL, yaddl, Px, [23]uint8{0x83, 00, 0x05, 0x81, 00, 0x01, 0x03}},
Optab{AADDPD, yxm, Pq, [23]uint8{0x58}},
Optab{AADDPS, yxm, Pm, [23]uint8{0x58}},
Optab{AADDQ, yaddl, Pw, [23]uint8{0x83, 00, 0x05, 0x81, 00, 0x01, 0x03}},
Optab{AADDSD, yxm, Pf2, [23]uint8{0x58}},
Optab{AADDSS, yxm, Pf3, [23]uint8{0x58}},
Optab{AADDW, yaddl, Pe, [23]uint8{0x83, 00, 0x05, 0x81, 00, 0x01, 0x03}},
Optab{AADJSP, nil, 0, [23]uint8{}},
Optab{AANDB, yxorb, Pb, [23]uint8{0x24, 0x80, 04, 0x20, 0x22}},
Optab{AANDL, yxorl, Px, [23]uint8{0x83, 04, 0x25, 0x81, 04, 0x21, 0x23}},
Optab{AANDNPD, yxm, Pq, [23]uint8{0x55}},
Optab{AANDNPS, yxm, Pm, [23]uint8{0x55}},
Optab{AANDPD, yxm, Pq, [23]uint8{0x54}},
Optab{AANDPS, yxm, Pq, [23]uint8{0x54}},
Optab{AANDQ, yxorl, Pw, [23]uint8{0x83, 04, 0x25, 0x81, 04, 0x21, 0x23}},
Optab{AANDW, yxorl, Pe, [23]uint8{0x83, 04, 0x25, 0x81, 04, 0x21, 0x23}},
Optab{AARPL, yrl_ml, P32, [23]uint8{0x63}},
Optab{ABOUNDL, yrl_m, P32, [23]uint8{0x62}},
Optab{ABOUNDW, yrl_m, Pe, [23]uint8{0x62}},
Optab{ABSFL, yml_rl, Pm, [23]uint8{0xbc}},
Optab{ABSFQ, yml_rl, Pw, [23]uint8{0x0f, 0xbc}},
Optab{ABSFW, yml_rl, Pq, [23]uint8{0xbc}},
Optab{ABSRL, yml_rl, Pm, [23]uint8{0xbd}},
Optab{ABSRQ, yml_rl, Pw, [23]uint8{0x0f, 0xbd}},
Optab{ABSRW, yml_rl, Pq, [23]uint8{0xbd}},
Optab{ABSWAPL, ybswap, Px, [23]uint8{0x0f, 0xc8}},
Optab{ABSWAPQ, ybswap, Pw, [23]uint8{0x0f, 0xc8}},
Optab{ABTCL, ybtl, Pm, [23]uint8{0xba, 07, 0xbb}},
Optab{ABTCQ, ybtl, Pw, [23]uint8{0x0f, 0xba, 07, 0x0f, 0xbb}},
Optab{ABTCW, ybtl, Pq, [23]uint8{0xba, 07, 0xbb}},
Optab{ABTL, ybtl, Pm, [23]uint8{0xba, 04, 0xa3}},
Optab{ABTQ, ybtl, Pw, [23]uint8{0x0f, 0xba, 04, 0x0f, 0xa3}},
Optab{ABTRL, ybtl, Pm, [23]uint8{0xba, 06, 0xb3}},
Optab{ABTRQ, ybtl, Pw, [23]uint8{0x0f, 0xba, 06, 0x0f, 0xb3}},
Optab{ABTRW, ybtl, Pq, [23]uint8{0xba, 06, 0xb3}},
Optab{ABTSL, ybtl, Pm, [23]uint8{0xba, 05, 0xab}},
Optab{ABTSQ, ybtl, Pw, [23]uint8{0x0f, 0xba, 05, 0x0f, 0xab}},
Optab{ABTSW, ybtl, Pq, [23]uint8{0xba, 05, 0xab}},
Optab{ABTW, ybtl, Pq, [23]uint8{0xba, 04, 0xa3}},
Optab{ABYTE, ybyte, Px, [23]uint8{1}},
Optab{obj.ACALL, ycall, Px, [23]uint8{0xff, 02, 0xff, 0x15, 0xe8}},
Optab{ACDQ, ynone, Px, [23]uint8{0x99}},
Optab{ACLC, ynone, Px, [23]uint8{0xf8}},
Optab{ACLD, ynone, Px, [23]uint8{0xfc}},
Optab{ACLI, ynone, Px, [23]uint8{0xfa}},
Optab{ACLTS, ynone, Pm, [23]uint8{0x06}},
Optab{ACMC, ynone, Px, [23]uint8{0xf5}},
Optab{ACMOVLCC, yml_rl, Pm, [23]uint8{0x43}},
Optab{ACMOVLCS, yml_rl, Pm, [23]uint8{0x42}},
Optab{ACMOVLEQ, yml_rl, Pm, [23]uint8{0x44}},
Optab{ACMOVLGE, yml_rl, Pm, [23]uint8{0x4d}},
Optab{ACMOVLGT, yml_rl, Pm, [23]uint8{0x4f}},
Optab{ACMOVLHI, yml_rl, Pm, [23]uint8{0x47}},
Optab{ACMOVLLE, yml_rl, Pm, [23]uint8{0x4e}},
Optab{ACMOVLLS, yml_rl, Pm, [23]uint8{0x46}},
Optab{ACMOVLLT, yml_rl, Pm, [23]uint8{0x4c}},
Optab{ACMOVLMI, yml_rl, Pm, [23]uint8{0x48}},
Optab{ACMOVLNE, yml_rl, Pm, [23]uint8{0x45}},
Optab{ACMOVLOC, yml_rl, Pm, [23]uint8{0x41}},
Optab{ACMOVLOS, yml_rl, Pm, [23]uint8{0x40}},
Optab{ACMOVLPC, yml_rl, Pm, [23]uint8{0x4b}},
Optab{ACMOVLPL, yml_rl, Pm, [23]uint8{0x49}},
Optab{ACMOVLPS, yml_rl, Pm, [23]uint8{0x4a}},
Optab{ACMOVQCC, yml_rl, Pw, [23]uint8{0x0f, 0x43}},
Optab{ACMOVQCS, yml_rl, Pw, [23]uint8{0x0f, 0x42}},
Optab{ACMOVQEQ, yml_rl, Pw, [23]uint8{0x0f, 0x44}},
Optab{ACMOVQGE, yml_rl, Pw, [23]uint8{0x0f, 0x4d}},
Optab{ACMOVQGT, yml_rl, Pw, [23]uint8{0x0f, 0x4f}},
Optab{ACMOVQHI, yml_rl, Pw, [23]uint8{0x0f, 0x47}},
Optab{ACMOVQLE, yml_rl, Pw, [23]uint8{0x0f, 0x4e}},
Optab{ACMOVQLS, yml_rl, Pw, [23]uint8{0x0f, 0x46}},
Optab{ACMOVQLT, yml_rl, Pw, [23]uint8{0x0f, 0x4c}},
Optab{ACMOVQMI, yml_rl, Pw, [23]uint8{0x0f, 0x48}},
Optab{ACMOVQNE, yml_rl, Pw, [23]uint8{0x0f, 0x45}},
Optab{ACMOVQOC, yml_rl, Pw, [23]uint8{0x0f, 0x41}},
Optab{ACMOVQOS, yml_rl, Pw, [23]uint8{0x0f, 0x40}},
Optab{ACMOVQPC, yml_rl, Pw, [23]uint8{0x0f, 0x4b}},
Optab{ACMOVQPL, yml_rl, Pw, [23]uint8{0x0f, 0x49}},
Optab{ACMOVQPS, yml_rl, Pw, [23]uint8{0x0f, 0x4a}},
Optab{ACMOVWCC, yml_rl, Pq, [23]uint8{0x43}},
Optab{ACMOVWCS, yml_rl, Pq, [23]uint8{0x42}},
Optab{ACMOVWEQ, yml_rl, Pq, [23]uint8{0x44}},
Optab{ACMOVWGE, yml_rl, Pq, [23]uint8{0x4d}},
Optab{ACMOVWGT, yml_rl, Pq, [23]uint8{0x4f}},
Optab{ACMOVWHI, yml_rl, Pq, [23]uint8{0x47}},
Optab{ACMOVWLE, yml_rl, Pq, [23]uint8{0x4e}},
Optab{ACMOVWLS, yml_rl, Pq, [23]uint8{0x46}},
Optab{ACMOVWLT, yml_rl, Pq, [23]uint8{0x4c}},
Optab{ACMOVWMI, yml_rl, Pq, [23]uint8{0x48}},
Optab{ACMOVWNE, yml_rl, Pq, [23]uint8{0x45}},
Optab{ACMOVWOC, yml_rl, Pq, [23]uint8{0x41}},
Optab{ACMOVWOS, yml_rl, Pq, [23]uint8{0x40}},
Optab{ACMOVWPC, yml_rl, Pq, [23]uint8{0x4b}},
Optab{ACMOVWPL, yml_rl, Pq, [23]uint8{0x49}},
Optab{ACMOVWPS, yml_rl, Pq, [23]uint8{0x4a}},
Optab{ACMPB, ycmpb, Pb, [23]uint8{0x3c, 0x80, 07, 0x38, 0x3a}},
Optab{ACMPL, ycmpl, Px, [23]uint8{0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b}},
Optab{ACMPPD, yxcmpi, Px, [23]uint8{Pe, 0xc2}},
Optab{ACMPPS, yxcmpi, Pm, [23]uint8{0xc2, 0}},
Optab{ACMPQ, ycmpl, Pw, [23]uint8{0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b}},
Optab{ACMPSB, ynone, Pb, [23]uint8{0xa6}},
Optab{ACMPSD, yxcmpi, Px, [23]uint8{Pf2, 0xc2}},
Optab{ACMPSL, ynone, Px, [23]uint8{0xa7}},
Optab{ACMPSQ, ynone, Pw, [23]uint8{0xa7}},
Optab{ACMPSS, yxcmpi, Px, [23]uint8{Pf3, 0xc2}},
Optab{ACMPSW, ynone, Pe, [23]uint8{0xa7}},
Optab{ACMPW, ycmpl, Pe, [23]uint8{0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b}},
Optab{ACOMISD, yxcmp, Pe, [23]uint8{0x2f}},
Optab{ACOMISS, yxcmp, Pm, [23]uint8{0x2f}},
Optab{ACPUID, ynone, Pm, [23]uint8{0xa2}},
Optab{ACVTPL2PD, yxcvm2, Px, [23]uint8{Pf3, 0xe6, Pe, 0x2a}},
Optab{ACVTPL2PS, yxcvm2, Pm, [23]uint8{0x5b, 0, 0x2a, 0}},
Optab{ACVTPD2PL, yxcvm1, Px, [23]uint8{Pf2, 0xe6, Pe, 0x2d}},
Optab{ACVTPD2PS, yxm, Pe, [23]uint8{0x5a}},
Optab{ACVTPS2PL, yxcvm1, Px, [23]uint8{Pe, 0x5b, Pm, 0x2d}},
Optab{ACVTPS2PD, yxm, Pm, [23]uint8{0x5a}},
Optab{API2FW, ymfp, Px, [23]uint8{0x0c}},
Optab{ACVTSD2SL, yxcvfl, Pf2, [23]uint8{0x2d}},
Optab{ACVTSD2SQ, yxcvfq, Pw, [23]uint8{Pf2, 0x2d}},
Optab{ACVTSD2SS, yxm, Pf2, [23]uint8{0x5a}},
Optab{ACVTSL2SD, yxcvlf, Pf2, [23]uint8{0x2a}},
Optab{ACVTSQ2SD, yxcvqf, Pw, [23]uint8{Pf2, 0x2a}},
Optab{ACVTSL2SS, yxcvlf, Pf3, [23]uint8{0x2a}},
Optab{ACVTSQ2SS, yxcvqf, Pw, [23]uint8{Pf3, 0x2a}},
Optab{ACVTSS2SD, yxm, Pf3, [23]uint8{0x5a}},
Optab{ACVTSS2SL, yxcvfl, Pf3, [23]uint8{0x2d}},
Optab{ACVTSS2SQ, yxcvfq, Pw, [23]uint8{Pf3, 0x2d}},
Optab{ACVTTPD2PL, yxcvm1, Px, [23]uint8{Pe, 0xe6, Pe, 0x2c}},
Optab{ACVTTPS2PL, yxcvm1, Px, [23]uint8{Pf3, 0x5b, Pm, 0x2c}},
Optab{ACVTTSD2SL, yxcvfl, Pf2, [23]uint8{0x2c}},
Optab{ACVTTSD2SQ, yxcvfq, Pw, [23]uint8{Pf2, 0x2c}},
Optab{ACVTTSS2SL, yxcvfl, Pf3, [23]uint8{0x2c}},
Optab{ACVTTSS2SQ, yxcvfq, Pw, [23]uint8{Pf3, 0x2c}},
Optab{ACWD, ynone, Pe, [23]uint8{0x99}},
Optab{ACQO, ynone, Pw, [23]uint8{0x99}},
Optab{ADAA, ynone, P32, [23]uint8{0x27}},
Optab{ADAS, ynone, P32, [23]uint8{0x2f}},
Optab{obj.ADATA, nil, 0, [23]uint8{}},
Optab{ADECB, yincb, Pb, [23]uint8{0xfe, 01}},
Optab{ADECL, yincl, Px1, [23]uint8{0x48, 0xff, 01}},
Optab{ADECQ, yincq, Pw, [23]uint8{0xff, 01}},
Optab{ADECW, yincw, Pe, [23]uint8{0xff, 01}},
Optab{ADIVB, ydivb, Pb, [23]uint8{0xf6, 06}},
Optab{ADIVL, ydivl, Px, [23]uint8{0xf7, 06}},
Optab{ADIVPD, yxm, Pe, [23]uint8{0x5e}},
Optab{ADIVPS, yxm, Pm, [23]uint8{0x5e}},
Optab{ADIVQ, ydivl, Pw, [23]uint8{0xf7, 06}},
Optab{ADIVSD, yxm, Pf2, [23]uint8{0x5e}},
Optab{ADIVSS, yxm, Pf3, [23]uint8{0x5e}},
Optab{ADIVW, ydivl, Pe, [23]uint8{0xf7, 06}},
Optab{AEMMS, ynone, Pm, [23]uint8{0x77}},
Optab{AENTER, nil, 0, [23]uint8{}}, /* botch */
Optab{AFXRSTOR, ysvrs, Pm, [23]uint8{0xae, 01, 0xae, 01}},
Optab{AFXSAVE, ysvrs, Pm, [23]uint8{0xae, 00, 0xae, 00}},
Optab{AFXRSTOR64, ysvrs, Pw, [23]uint8{0x0f, 0xae, 01, 0x0f, 0xae, 01}},
Optab{AFXSAVE64, ysvrs, Pw, [23]uint8{0x0f, 0xae, 00, 0x0f, 0xae, 00}},
Optab{obj.AGLOBL, nil, 0, [23]uint8{}},
Optab{AHLT, ynone, Px, [23]uint8{0xf4}},
Optab{AIDIVB, ydivb, Pb, [23]uint8{0xf6, 07}},
Optab{AIDIVL, ydivl, Px, [23]uint8{0xf7, 07}},
Optab{AIDIVQ, ydivl, Pw, [23]uint8{0xf7, 07}},
Optab{AIDIVW, ydivl, Pe, [23]uint8{0xf7, 07}},
Optab{AIMULB, ydivb, Pb, [23]uint8{0xf6, 05}},
Optab{AIMULL, yimul, Px, [23]uint8{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},
Optab{AIMULQ, yimul, Pw, [23]uint8{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},
Optab{AIMULW, yimul, Pe, [23]uint8{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},
Optab{AIMUL3Q, yimul3, Pw, [23]uint8{0x6b, 00}},
Optab{AINB, yin, Pb, [23]uint8{0xe4, 0xec}},
Optab{AINCB, yincb, Pb, [23]uint8{0xfe, 00}},
Optab{AINCL, yincl, Px1, [23]uint8{0x40, 0xff, 00}},
Optab{AINCQ, yincq, Pw, [23]uint8{0xff, 00}},
Optab{AINCW, yincw, Pe, [23]uint8{0xff, 00}},
Optab{AINL, yin, Px, [23]uint8{0xe5, 0xed}},
Optab{AINSB, ynone, Pb, [23]uint8{0x6c}},
Optab{AINSL, ynone, Px, [23]uint8{0x6d}},
Optab{AINSW, ynone, Pe, [23]uint8{0x6d}},
Optab{AINT, yint, Px, [23]uint8{0xcd}},
Optab{AINTO, ynone, P32, [23]uint8{0xce}},
Optab{AINW, yin, Pe, [23]uint8{0xe5, 0xed}},
Optab{AIRETL, ynone, Px, [23]uint8{0xcf}},
Optab{AIRETQ, ynone, Pw, [23]uint8{0xcf}},
Optab{AIRETW, ynone, Pe, [23]uint8{0xcf}},
Optab{AJCC, yjcond, Px, [23]uint8{0x73, 0x83, 00}},
Optab{AJCS, yjcond, Px, [23]uint8{0x72, 0x82}},
Optab{AJCXZL, yloop, Px, [23]uint8{0xe3}},
Optab{AJCXZW, yloop, Px, [23]uint8{0xe3}},
Optab{AJCXZQ, yloop, Px, [23]uint8{0xe3}},
Optab{AJEQ, yjcond, Px, [23]uint8{0x74, 0x84}},
Optab{AJGE, yjcond, Px, [23]uint8{0x7d, 0x8d}},
Optab{AJGT, yjcond, Px, [23]uint8{0x7f, 0x8f}},
Optab{AJHI, yjcond, Px, [23]uint8{0x77, 0x87}},
Optab{AJLE, yjcond, Px, [23]uint8{0x7e, 0x8e}},
Optab{AJLS, yjcond, Px, [23]uint8{0x76, 0x86}},
Optab{AJLT, yjcond, Px, [23]uint8{0x7c, 0x8c}},
Optab{AJMI, yjcond, Px, [23]uint8{0x78, 0x88}},
Optab{obj.AJMP, yjmp, Px, [23]uint8{0xff, 04, 0xeb, 0xe9}},
Optab{AJNE, yjcond, Px, [23]uint8{0x75, 0x85}},
Optab{AJOC, yjcond, Px, [23]uint8{0x71, 0x81, 00}},
Optab{AJOS, yjcond, Px, [23]uint8{0x70, 0x80, 00}},
Optab{AJPC, yjcond, Px, [23]uint8{0x7b, 0x8b}},
Optab{AJPL, yjcond, Px, [23]uint8{0x79, 0x89}},
Optab{AJPS, yjcond, Px, [23]uint8{0x7a, 0x8a}},
Optab{ALAHF, ynone, Px, [23]uint8{0x9f}},
Optab{ALARL, yml_rl, Pm, [23]uint8{0x02}},
Optab{ALARW, yml_rl, Pq, [23]uint8{0x02}},
Optab{ALDMXCSR, ysvrs, Pm, [23]uint8{0xae, 02, 0xae, 02}},
Optab{ALEAL, ym_rl, Px, [23]uint8{0x8d}},
Optab{ALEAQ, ym_rl, Pw, [23]uint8{0x8d}},
Optab{ALEAVEL, ynone, P32, [23]uint8{0xc9}},
Optab{ALEAVEQ, ynone, Py, [23]uint8{0xc9}},
Optab{ALEAVEW, ynone, Pe, [23]uint8{0xc9}},
Optab{ALEAW, ym_rl, Pe, [23]uint8{0x8d}},
Optab{ALOCK, ynone, Px, [23]uint8{0xf0}},
Optab{ALODSB, ynone, Pb, [23]uint8{0xac}},
Optab{ALODSL, ynone, Px, [23]uint8{0xad}},
Optab{ALODSQ, ynone, Pw, [23]uint8{0xad}},
Optab{ALODSW, ynone, Pe, [23]uint8{0xad}},
Optab{ALONG, ybyte, Px, [23]uint8{4}},
Optab{ALOOP, yloop, Px, [23]uint8{0xe2}},
Optab{ALOOPEQ, yloop, Px, [23]uint8{0xe1}},
Optab{ALOOPNE, yloop, Px, [23]uint8{0xe0}},
Optab{ALSLL, yml_rl, Pm, [23]uint8{0x03}},
Optab{ALSLW, yml_rl, Pq, [23]uint8{0x03}},
Optab{AMASKMOVOU, yxr, Pe, [23]uint8{0xf7}},
Optab{AMASKMOVQ, ymr, Pm, [23]uint8{0xf7}},
Optab{AMAXPD, yxm, Pe, [23]uint8{0x5f}},
Optab{AMAXPS, yxm, Pm, [23]uint8{0x5f}},
Optab{AMAXSD, yxm, Pf2, [23]uint8{0x5f}},
Optab{AMAXSS, yxm, Pf3, [23]uint8{0x5f}},
Optab{AMINPD, yxm, Pe, [23]uint8{0x5d}},
Optab{AMINPS, yxm, Pm, [23]uint8{0x5d}},
Optab{AMINSD, yxm, Pf2, [23]uint8{0x5d}},
Optab{AMINSS, yxm, Pf3, [23]uint8{0x5d}},
Optab{AMOVAPD, yxmov, Pe, [23]uint8{0x28, 0x29}},
Optab{AMOVAPS, yxmov, Pm, [23]uint8{0x28, 0x29}},
Optab{AMOVB, ymovb, Pb, [23]uint8{0x88, 0x8a, 0xb0, 0xc6, 00}},
Optab{AMOVBLSX, ymb_rl, Pm, [23]uint8{0xbe}},
Optab{AMOVBLZX, ymb_rl, Pm, [23]uint8{0xb6}},
Optab{AMOVBQSX, ymb_rl, Pw, [23]uint8{0x0f, 0xbe}},
Optab{AMOVBQZX, ymb_rl, Pm, [23]uint8{0xb6}},
Optab{AMOVBWSX, ymb_rl, Pq, [23]uint8{0xbe}},
Optab{AMOVBWZX, ymb_rl, Pq, [23]uint8{0xb6}},
Optab{AMOVO, yxmov, Pe, [23]uint8{0x6f, 0x7f}},
Optab{AMOVOU, yxmov, Pf3, [23]uint8{0x6f, 0x7f}},
Optab{AMOVHLPS, yxr, Pm, [23]uint8{0x12}},
Optab{AMOVHPD, yxmov, Pe, [23]uint8{0x16, 0x17}},
Optab{AMOVHPS, yxmov, Pm, [23]uint8{0x16, 0x17}},
Optab{AMOVL, ymovl, Px, [23]uint8{0x89, 0x8b, 0x31, 0xb8, 0xc7, 00, 0x6e, 0x7e, Pe, 0x6e, Pe, 0x7e, 0}},
Optab{AMOVLHPS, yxr, Pm, [23]uint8{0x16}},
Optab{AMOVLPD, yxmov, Pe, [23]uint8{0x12, 0x13}},
Optab{AMOVLPS, yxmov, Pm, [23]uint8{0x12, 0x13}},
Optab{AMOVLQSX, yml_rl, Pw, [23]uint8{0x63}},
Optab{AMOVLQZX, yml_rl, Px, [23]uint8{0x8b}},
Optab{AMOVMSKPD, yxrrl, Pq, [23]uint8{0x50}},
Optab{AMOVMSKPS, yxrrl, Pm, [23]uint8{0x50}},
Optab{AMOVNTO, yxr_ml, Pe, [23]uint8{0xe7}},
Optab{AMOVNTPD, yxr_ml, Pe, [23]uint8{0x2b}},
Optab{AMOVNTPS, yxr_ml, Pm, [23]uint8{0x2b}},
Optab{AMOVNTQ, ymr_ml, Pm, [23]uint8{0xe7}},
Optab{AMOVQ, ymovq, Pw8, [23]uint8{0x6f, 0x7f, Pf2, 0xd6, Pf3, 0x7e, Pe, 0xd6, 0x89, 0x8b, 0x31, 0xc7, 00, 0xb8, 0xc7, 00, 0x6e, 0x7e, Pe, 0x6e, Pe, 0x7e, 0}},
Optab{AMOVQOZX, ymrxr, Pf3, [23]uint8{0xd6, 0x7e}},
Optab{AMOVSB, ynone, Pb, [23]uint8{0xa4}},
Optab{AMOVSD, yxmov, Pf2, [23]uint8{0x10, 0x11}},
Optab{AMOVSL, ynone, Px, [23]uint8{0xa5}},
Optab{AMOVSQ, ynone, Pw, [23]uint8{0xa5}},
Optab{AMOVSS, yxmov, Pf3, [23]uint8{0x10, 0x11}},
Optab{AMOVSW, ynone, Pe, [23]uint8{0xa5}},
Optab{AMOVUPD, yxmov, Pe, [23]uint8{0x10, 0x11}},
Optab{AMOVUPS, yxmov, Pm, [23]uint8{0x10, 0x11}},
Optab{AMOVW, ymovw, Pe, [23]uint8{0x89, 0x8b, 0x31, 0xb8, 0xc7, 00, 0}},
Optab{AMOVWLSX, yml_rl, Pm, [23]uint8{0xbf}},
Optab{AMOVWLZX, yml_rl, Pm, [23]uint8{0xb7}},
Optab{AMOVWQSX, yml_rl, Pw, [23]uint8{0x0f, 0xbf}},
Optab{AMOVWQZX, yml_rl, Pw, [23]uint8{0x0f, 0xb7}},
Optab{AMULB, ydivb, Pb, [23]uint8{0xf6, 04}},
Optab{AMULL, ydivl, Px, [23]uint8{0xf7, 04}},
Optab{AMULPD, yxm, Pe, [23]uint8{0x59}},
Optab{AMULPS, yxm, Ym, [23]uint8{0x59}},
Optab{AMULQ, ydivl, Pw, [23]uint8{0xf7, 04}},
Optab{AMULSD, yxm, Pf2, [23]uint8{0x59}},
Optab{AMULSS, yxm, Pf3, [23]uint8{0x59}},
Optab{AMULW, ydivl, Pe, [23]uint8{0xf7, 04}},
Optab{ANEGB, yscond, Pb, [23]uint8{0xf6, 03}},
Optab{ANEGL, yscond, Px, [23]uint8{0xf7, 03}},
Optab{ANEGQ, yscond, Pw, [23]uint8{0xf7, 03}},
Optab{ANEGW, yscond, Pe, [23]uint8{0xf7, 03}},
Optab{obj.ANOP, ynop, Px, [23]uint8{0, 0}},
Optab{ANOTB, yscond, Pb, [23]uint8{0xf6, 02}},
Optab{ANOTL, yscond, Px, [23]uint8{0xf7, 02}}, // TODO(rsc): yscond is wrong here.
Optab{ANOTQ, yscond, Pw, [23]uint8{0xf7, 02}},
Optab{ANOTW, yscond, Pe, [23]uint8{0xf7, 02}},
Optab{AORB, yxorb, Pb, [23]uint8{0x0c, 0x80, 01, 0x08, 0x0a}},
Optab{AORL, yxorl, Px, [23]uint8{0x83, 01, 0x0d, 0x81, 01, 0x09, 0x0b}},
Optab{AORPD, yxm, Pq, [23]uint8{0x56}},
Optab{AORPS, yxm, Pm, [23]uint8{0x56}},
Optab{AORQ, yxorl, Pw, [23]uint8{0x83, 01, 0x0d, 0x81, 01, 0x09, 0x0b}},
Optab{AORW, yxorl, Pe, [23]uint8{0x83, 01, 0x0d, 0x81, 01, 0x09, 0x0b}},
Optab{AOUTB, yin, Pb, [23]uint8{0xe6, 0xee}},
Optab{AOUTL, yin, Px, [23]uint8{0xe7, 0xef}},
Optab{AOUTSB, ynone, Pb, [23]uint8{0x6e}},
Optab{AOUTSL, ynone, Px, [23]uint8{0x6f}},
Optab{AOUTSW, ynone, Pe, [23]uint8{0x6f}},
Optab{AOUTW, yin, Pe, [23]uint8{0xe7, 0xef}},
Optab{APACKSSLW, ymm, Py1, [23]uint8{0x6b, Pe, 0x6b}},
Optab{APACKSSWB, ymm, Py1, [23]uint8{0x63, Pe, 0x63}},
Optab{APACKUSWB, ymm, Py1, [23]uint8{0x67, Pe, 0x67}},
Optab{APADDB, ymm, Py1, [23]uint8{0xfc, Pe, 0xfc}},
Optab{APADDL, ymm, Py1, [23]uint8{0xfe, Pe, 0xfe}},
Optab{APADDQ, yxm, Pe, [23]uint8{0xd4}},
Optab{APADDSB, ymm, Py1, [23]uint8{0xec, Pe, 0xec}},
Optab{APADDSW, ymm, Py1, [23]uint8{0xed, Pe, 0xed}},
Optab{APADDUSB, ymm, Py1, [23]uint8{0xdc, Pe, 0xdc}},
Optab{APADDUSW, ymm, Py1, [23]uint8{0xdd, Pe, 0xdd}},
Optab{APADDW, ymm, Py1, [23]uint8{0xfd, Pe, 0xfd}},
Optab{APAND, ymm, Py1, [23]uint8{0xdb, Pe, 0xdb}},
Optab{APANDN, ymm, Py1, [23]uint8{0xdf, Pe, 0xdf}},
Optab{APAUSE, ynone, Px, [23]uint8{0xf3, 0x90}},
Optab{APAVGB, ymm, Py1, [23]uint8{0xe0, Pe, 0xe0}},
Optab{APAVGW, ymm, Py1, [23]uint8{0xe3, Pe, 0xe3}},
Optab{APCMPEQB, ymm, Py1, [23]uint8{0x74, Pe, 0x74}},
Optab{APCMPEQL, ymm, Py1, [23]uint8{0x76, Pe, 0x76}},
Optab{APCMPEQW, ymm, Py1, [23]uint8{0x75, Pe, 0x75}},
Optab{APCMPGTB, ymm, Py1, [23]uint8{0x64, Pe, 0x64}},
Optab{APCMPGTL, ymm, Py1, [23]uint8{0x66, Pe, 0x66}},
Optab{APCMPGTW, ymm, Py1, [23]uint8{0x65, Pe, 0x65}},
Optab{APEXTRW, yextrw, Pq, [23]uint8{0xc5, 00}},
Optab{APF2IL, ymfp, Px, [23]uint8{0x1d}},
Optab{APF2IW, ymfp, Px, [23]uint8{0x1c}},
Optab{API2FL, ymfp, Px, [23]uint8{0x0d}},
Optab{APFACC, ymfp, Px, [23]uint8{0xae}},
Optab{APFADD, ymfp, Px, [23]uint8{0x9e}},
Optab{APFCMPEQ, ymfp, Px, [23]uint8{0xb0}},
Optab{APFCMPGE, ymfp, Px, [23]uint8{0x90}},
Optab{APFCMPGT, ymfp, Px, [23]uint8{0xa0}},
Optab{APFMAX, ymfp, Px, [23]uint8{0xa4}},
Optab{APFMIN, ymfp, Px, [23]uint8{0x94}},
Optab{APFMUL, ymfp, Px, [23]uint8{0xb4}},
Optab{APFNACC, ymfp, Px, [23]uint8{0x8a}},
Optab{APFPNACC, ymfp, Px, [23]uint8{0x8e}},
Optab{APFRCP, ymfp, Px, [23]uint8{0x96}},
Optab{APFRCPIT1, ymfp, Px, [23]uint8{0xa6}},
Optab{APFRCPI2T, ymfp, Px, [23]uint8{0xb6}},
Optab{APFRSQIT1, ymfp, Px, [23]uint8{0xa7}},
Optab{APFRSQRT, ymfp, Px, [23]uint8{0x97}},
Optab{APFSUB, ymfp, Px, [23]uint8{0x9a}},
Optab{APFSUBR, ymfp, Px, [23]uint8{0xaa}},
Optab{APINSRW, yinsrw, Pq, [23]uint8{0xc4, 00}},
Optab{APINSRD, yinsr, Pq, [23]uint8{0x3a, 0x22, 00}},
Optab{APINSRQ, yinsr, Pq3, [23]uint8{0x3a, 0x22, 00}},
Optab{APMADDWL, ymm, Py1, [23]uint8{0xf5, Pe, 0xf5}},
Optab{APMAXSW, yxm, Pe, [23]uint8{0xee}},
Optab{APMAXUB, yxm, Pe, [23]uint8{0xde}},
Optab{APMINSW, yxm, Pe, [23]uint8{0xea}},
Optab{APMINUB, yxm, Pe, [23]uint8{0xda}},
Optab{APMOVMSKB, ymskb, Px, [23]uint8{Pe, 0xd7, 0xd7}},
Optab{APMULHRW, ymfp, Px, [23]uint8{0xb7}},
Optab{APMULHUW, ymm, Py1, [23]uint8{0xe4, Pe, 0xe4}},
Optab{APMULHW, ymm, Py1, [23]uint8{0xe5, Pe, 0xe5}},
Optab{APMULLW, ymm, Py1, [23]uint8{0xd5, Pe, 0xd5}},
Optab{APMULULQ, ymm, Py1, [23]uint8{0xf4, Pe, 0xf4}},
Optab{APOPAL, ynone, P32, [23]uint8{0x61}},
Optab{APOPAW, ynone, Pe, [23]uint8{0x61}},
Optab{APOPFL, ynone, P32, [23]uint8{0x9d}},
Optab{APOPFQ, ynone, Py, [23]uint8{0x9d}},
Optab{APOPFW, ynone, Pe, [23]uint8{0x9d}},
Optab{APOPL, ypopl, P32, [23]uint8{0x58, 0x8f, 00}},
Optab{APOPQ, ypopl, Py, [23]uint8{0x58, 0x8f, 00}},
Optab{APOPW, ypopl, Pe, [23]uint8{0x58, 0x8f, 00}},
Optab{APOR, ymm, Py1, [23]uint8{0xeb, Pe, 0xeb}},
Optab{APSADBW, yxm, Pq, [23]uint8{0xf6}},
Optab{APSHUFHW, yxshuf, Pf3, [23]uint8{0x70, 00}},
Optab{APSHUFL, yxshuf, Pq, [23]uint8{0x70, 00}},
Optab{APSHUFLW, yxshuf, Pf2, [23]uint8{0x70, 00}},
Optab{APSHUFW, ymshuf, Pm, [23]uint8{0x70, 00}},
Optab{APSHUFB, ymshufb, Pq, [23]uint8{0x38, 0x00}},
Optab{APSLLO, ypsdq, Pq, [23]uint8{0x73, 07}},
Optab{APSLLL, yps, Py3, [23]uint8{0xf2, 0x72, 06, Pe, 0xf2, Pe, 0x72, 06}},
Optab{APSLLQ, yps, Py3, [23]uint8{0xf3, 0x73, 06, Pe, 0xf3, Pe, 0x73, 06}},
Optab{APSLLW, yps, Py3, [23]uint8{0xf1, 0x71, 06, Pe, 0xf1, Pe, 0x71, 06}},
Optab{APSRAL, yps, Py3, [23]uint8{0xe2, 0x72, 04, Pe, 0xe2, Pe, 0x72, 04}},
Optab{APSRAW, yps, Py3, [23]uint8{0xe1, 0x71, 04, Pe, 0xe1, Pe, 0x71, 04}},
Optab{APSRLO, ypsdq, Pq, [23]uint8{0x73, 03}},
Optab{APSRLL, yps, Py3, [23]uint8{0xd2, 0x72, 02, Pe, 0xd2, Pe, 0x72, 02}},
Optab{APSRLQ, yps, Py3, [23]uint8{0xd3, 0x73, 02, Pe, 0xd3, Pe, 0x73, 02}},
Optab{APSRLW, yps, Py3, [23]uint8{0xd1, 0x71, 02, Pe, 0xe1, Pe, 0x71, 02}},
Optab{APSUBB, yxm, Pe, [23]uint8{0xf8}},
Optab{APSUBL, yxm, Pe, [23]uint8{0xfa}},
Optab{APSUBQ, yxm, Pe, [23]uint8{0xfb}},
Optab{APSUBSB, yxm, Pe, [23]uint8{0xe8}},
Optab{APSUBSW, yxm, Pe, [23]uint8{0xe9}},
Optab{APSUBUSB, yxm, Pe, [23]uint8{0xd8}},
Optab{APSUBUSW, yxm, Pe, [23]uint8{0xd9}},
Optab{APSUBW, yxm, Pe, [23]uint8{0xf9}},
Optab{APSWAPL, ymfp, Px, [23]uint8{0xbb}},
Optab{APUNPCKHBW, ymm, Py1, [23]uint8{0x68, Pe, 0x68}},
Optab{APUNPCKHLQ, ymm, Py1, [23]uint8{0x6a, Pe, 0x6a}},
Optab{APUNPCKHQDQ, yxm, Pe, [23]uint8{0x6d}},
Optab{APUNPCKHWL, ymm, Py1, [23]uint8{0x69, Pe, 0x69}},
Optab{APUNPCKLBW, ymm, Py1, [23]uint8{0x60, Pe, 0x60}},
Optab{APUNPCKLLQ, ymm, Py1, [23]uint8{0x62, Pe, 0x62}},
Optab{APUNPCKLQDQ, yxm, Pe, [23]uint8{0x6c}},
Optab{APUNPCKLWL, ymm, Py1, [23]uint8{0x61, Pe, 0x61}},
Optab{APUSHAL, ynone, P32, [23]uint8{0x60}},
Optab{APUSHAW, ynone, Pe, [23]uint8{0x60}},
Optab{APUSHFL, ynone, P32, [23]uint8{0x9c}},
Optab{APUSHFQ, ynone, Py, [23]uint8{0x9c}},
Optab{APUSHFW, ynone, Pe, [23]uint8{0x9c}},
Optab{APUSHL, ypushl, P32, [23]uint8{0x50, 0xff, 06, 0x6a, 0x68}},
Optab{APUSHQ, ypushl, Py, [23]uint8{0x50, 0xff, 06, 0x6a, 0x68}},
Optab{APUSHW, ypushl, Pe, [23]uint8{0x50, 0xff, 06, 0x6a, 0x68}},
Optab{APXOR, ymm, Py1, [23]uint8{0xef, Pe, 0xef}},
Optab{AQUAD, ybyte, Px, [23]uint8{8}},
Optab{ARCLB, yshb, Pb, [23]uint8{0xd0, 02, 0xc0, 02, 0xd2, 02}},
Optab{ARCLL, yshl, Px, [23]uint8{0xd1, 02, 0xc1, 02, 0xd3, 02, 0xd3, 02}},
Optab{ARCLQ, yshl, Pw, [23]uint8{0xd1, 02, 0xc1, 02, 0xd3, 02, 0xd3, 02}},
Optab{ARCLW, yshl, Pe, [23]uint8{0xd1, 02, 0xc1, 02, 0xd3, 02, 0xd3, 02}},
Optab{ARCPPS, yxm, Pm, [23]uint8{0x53}},
Optab{ARCPSS, yxm, Pf3, [23]uint8{0x53}},
Optab{ARCRB, yshb, Pb, [23]uint8{0xd0, 03, 0xc0, 03, 0xd2, 03}},
Optab{ARCRL, yshl, Px, [23]uint8{0xd1, 03, 0xc1, 03, 0xd3, 03, 0xd3, 03}},
Optab{ARCRQ, yshl, Pw, [23]uint8{0xd1, 03, 0xc1, 03, 0xd3, 03, 0xd3, 03}},
Optab{ARCRW, yshl, Pe, [23]uint8{0xd1, 03, 0xc1, 03, 0xd3, 03, 0xd3, 03}},
Optab{AREP, ynone, Px, [23]uint8{0xf3}},
Optab{AREPN, ynone, Px, [23]uint8{0xf2}},
Optab{obj.ARET, ynone, Px, [23]uint8{0xc3}},
Optab{ARETFW, yret, Pe, [23]uint8{0xcb, 0xca}},
Optab{ARETFL, yret, Px, [23]uint8{0xcb, 0xca}},
Optab{ARETFQ, yret, Pw, [23]uint8{0xcb, 0xca}},
Optab{AROLB, yshb, Pb, [23]uint8{0xd0, 00, 0xc0, 00, 0xd2, 00}},
Optab{AROLL, yshl, Px, [23]uint8{0xd1, 00, 0xc1, 00, 0xd3, 00, 0xd3, 00}},
Optab{AROLQ, yshl, Pw, [23]uint8{0xd1, 00, 0xc1, 00, 0xd3, 00, 0xd3, 00}},
Optab{AROLW, yshl, Pe, [23]uint8{0xd1, 00, 0xc1, 00, 0xd3, 00, 0xd3, 00}},
Optab{ARORB, yshb, Pb, [23]uint8{0xd0, 01, 0xc0, 01, 0xd2, 01}},
Optab{ARORL, yshl, Px, [23]uint8{0xd1, 01, 0xc1, 01, 0xd3, 01, 0xd3, 01}},
Optab{ARORQ, yshl, Pw, [23]uint8{0xd1, 01, 0xc1, 01, 0xd3, 01, 0xd3, 01}},
Optab{ARORW, yshl, Pe, [23]uint8{0xd1, 01, 0xc1, 01, 0xd3, 01, 0xd3, 01}},
Optab{ARSQRTPS, yxm, Pm, [23]uint8{0x52}},
Optab{ARSQRTSS, yxm, Pf3, [23]uint8{0x52}},
Optab{ASAHF, ynone, Px1, [23]uint8{0x9e, 00, 0x86, 0xe0, 0x50, 0x9d}}, /* XCHGB AH,AL; PUSH AX; POPFL */
Optab{ASALB, yshb, Pb, [23]uint8{0xd0, 04, 0xc0, 04, 0xd2, 04}},
Optab{ASALL, yshl, Px, [23]uint8{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
Optab{ASALQ, yshl, Pw, [23]uint8{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
Optab{ASALW, yshl, Pe, [23]uint8{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
Optab{ASARB, yshb, Pb, [23]uint8{0xd0, 07, 0xc0, 07, 0xd2, 07}},
Optab{ASARL, yshl, Px, [23]uint8{0xd1, 07, 0xc1, 07, 0xd3, 07, 0xd3, 07}},
Optab{ASARQ, yshl, Pw, [23]uint8{0xd1, 07, 0xc1, 07, 0xd3, 07, 0xd3, 07}},
Optab{ASARW, yshl, Pe, [23]uint8{0xd1, 07, 0xc1, 07, 0xd3, 07, 0xd3, 07}},
Optab{ASBBB, yxorb, Pb, [23]uint8{0x1c, 0x80, 03, 0x18, 0x1a}},
Optab{ASBBL, yxorl, Px, [23]uint8{0x83, 03, 0x1d, 0x81, 03, 0x19, 0x1b}},
Optab{ASBBQ, yxorl, Pw, [23]uint8{0x83, 03, 0x1d, 0x81, 03, 0x19, 0x1b}},
Optab{ASBBW, yxorl, Pe, [23]uint8{0x83, 03, 0x1d, 0x81, 03, 0x19, 0x1b}},
Optab{ASCASB, ynone, Pb, [23]uint8{0xae}},
Optab{ASCASL, ynone, Px, [23]uint8{0xaf}},
Optab{ASCASQ, ynone, Pw, [23]uint8{0xaf}},
Optab{ASCASW, ynone, Pe, [23]uint8{0xaf}},
Optab{ASETCC, yscond, Pb, [23]uint8{0x0f, 0x93, 00}},
Optab{ASETCS, yscond, Pb, [23]uint8{0x0f, 0x92, 00}},
Optab{ASETEQ, yscond, Pb, [23]uint8{0x0f, 0x94, 00}},
Optab{ASETGE, yscond, Pb, [23]uint8{0x0f, 0x9d, 00}},
Optab{ASETGT, yscond, Pb, [23]uint8{0x0f, 0x9f, 00}},
Optab{ASETHI, yscond, Pb, [23]uint8{0x0f, 0x97, 00}},
Optab{ASETLE, yscond, Pb, [23]uint8{0x0f, 0x9e, 00}},
Optab{ASETLS, yscond, Pb, [23]uint8{0x0f, 0x96, 00}},
Optab{ASETLT, yscond, Pb, [23]uint8{0x0f, 0x9c, 00}},
Optab{ASETMI, yscond, Pb, [23]uint8{0x0f, 0x98, 00}},
Optab{ASETNE, yscond, Pb, [23]uint8{0x0f, 0x95, 00}},
Optab{ASETOC, yscond, Pb, [23]uint8{0x0f, 0x91, 00}},
Optab{ASETOS, yscond, Pb, [23]uint8{0x0f, 0x90, 00}},
Optab{ASETPC, yscond, Pb, [23]uint8{0x0f, 0x9b, 00}},
Optab{ASETPL, yscond, Pb, [23]uint8{0x0f, 0x99, 00}},
Optab{ASETPS, yscond, Pb, [23]uint8{0x0f, 0x9a, 00}},
Optab{ASHLB, yshb, Pb, [23]uint8{0xd0, 04, 0xc0, 04, 0xd2, 04}},
Optab{ASHLL, yshl, Px, [23]uint8{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
Optab{ASHLQ, yshl, Pw, [23]uint8{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
Optab{ASHLW, yshl, Pe, [23]uint8{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
Optab{ASHRB, yshb, Pb, [23]uint8{0xd0, 05, 0xc0, 05, 0xd2, 05}},
Optab{ASHRL, yshl, Px, [23]uint8{0xd1, 05, 0xc1, 05, 0xd3, 05, 0xd3, 05}},
Optab{ASHRQ, yshl, Pw, [23]uint8{0xd1, 05, 0xc1, 05, 0xd3, 05, 0xd3, 05}},
Optab{ASHRW, yshl, Pe, [23]uint8{0xd1, 05, 0xc1, 05, 0xd3, 05, 0xd3, 05}},
Optab{ASHUFPD, yxshuf, Pq, [23]uint8{0xc6, 00}},
Optab{ASHUFPS, yxshuf, Pm, [23]uint8{0xc6, 00}},
Optab{ASQRTPD, yxm, Pe, [23]uint8{0x51}},
Optab{ASQRTPS, yxm, Pm, [23]uint8{0x51}},
Optab{ASQRTSD, yxm, Pf2, [23]uint8{0x51}},
Optab{ASQRTSS, yxm, Pf3, [23]uint8{0x51}},
Optab{ASTC, ynone, Px, [23]uint8{0xf9}},
Optab{ASTD, ynone, Px, [23]uint8{0xfd}},
Optab{ASTI, ynone, Px, [23]uint8{0xfb}},
Optab{ASTMXCSR, ysvrs, Pm, [23]uint8{0xae, 03, 0xae, 03}},
Optab{ASTOSB, ynone, Pb, [23]uint8{0xaa}},
Optab{ASTOSL, ynone, Px, [23]uint8{0xab}},
Optab{ASTOSQ, ynone, Pw, [23]uint8{0xab}},
Optab{ASTOSW, ynone, Pe, [23]uint8{0xab}},
Optab{ASUBB, yxorb, Pb, [23]uint8{0x2c, 0x80, 05, 0x28, 0x2a}},
Optab{ASUBL, yaddl, Px, [23]uint8{0x83, 05, 0x2d, 0x81, 05, 0x29, 0x2b}},
Optab{ASUBPD, yxm, Pe, [23]uint8{0x5c}},
Optab{ASUBPS, yxm, Pm, [23]uint8{0x5c}},
Optab{ASUBQ, yaddl, Pw, [23]uint8{0x83, 05, 0x2d, 0x81, 05, 0x29, 0x2b}},
Optab{ASUBSD, yxm, Pf2, [23]uint8{0x5c}},
Optab{ASUBSS, yxm, Pf3, [23]uint8{0x5c}},
Optab{ASUBW, yaddl, Pe, [23]uint8{0x83, 05, 0x2d, 0x81, 05, 0x29, 0x2b}},
Optab{ASWAPGS, ynone, Pm, [23]uint8{0x01, 0xf8}},
Optab{ASYSCALL, ynone, Px, [23]uint8{0x0f, 0x05}}, /* fast syscall */
Optab{ATESTB, ytestb, Pb, [23]uint8{0xa8, 0xf6, 00, 0x84, 0x84}},
Optab{ATESTL, ytestl, Px, [23]uint8{0xa9, 0xf7, 00, 0x85, 0x85}},
Optab{ATESTQ, ytestl, Pw, [23]uint8{0xa9, 0xf7, 00, 0x85, 0x85}},
Optab{ATESTW, ytestl, Pe, [23]uint8{0xa9, 0xf7, 00, 0x85, 0x85}},
Optab{obj.ATEXT, ytext, Px, [23]uint8{}},
Optab{AUCOMISD, yxcmp, Pe, [23]uint8{0x2e}},
Optab{AUCOMISS, yxcmp, Pm, [23]uint8{0x2e}},
Optab{AUNPCKHPD, yxm, Pe, [23]uint8{0x15}},
Optab{AUNPCKHPS, yxm, Pm, [23]uint8{0x15}},
Optab{AUNPCKLPD, yxm, Pe, [23]uint8{0x14}},
Optab{AUNPCKLPS, yxm, Pm, [23]uint8{0x14}},
Optab{AVERR, ydivl, Pm, [23]uint8{0x00, 04}},
Optab{AVERW, ydivl, Pm, [23]uint8{0x00, 05}},
Optab{AWAIT, ynone, Px, [23]uint8{0x9b}},
Optab{AWORD, ybyte, Px, [23]uint8{2}},
Optab{AXCHGB, yml_mb, Pb, [23]uint8{0x86, 0x86}},
Optab{AXCHGL, yxchg, Px, [23]uint8{0x90, 0x90, 0x87, 0x87}},
Optab{AXCHGQ, yxchg, Pw, [23]uint8{0x90, 0x90, 0x87, 0x87}},
Optab{AXCHGW, yxchg, Pe, [23]uint8{0x90, 0x90, 0x87, 0x87}},
Optab{AXLAT, ynone, Px, [23]uint8{0xd7}},
Optab{AXORB, yxorb, Pb, [23]uint8{0x34, 0x80, 06, 0x30, 0x32}},
Optab{AXORL, yxorl, Px, [23]uint8{0x83, 06, 0x35, 0x81, 06, 0x31, 0x33}},
Optab{AXORPD, yxm, Pe, [23]uint8{0x57}},
Optab{AXORPS, yxm, Pm, [23]uint8{0x57}},
Optab{AXORQ, yxorl, Pw, [23]uint8{0x83, 06, 0x35, 0x81, 06, 0x31, 0x33}},
Optab{AXORW, yxorl, Pe, [23]uint8{0x83, 06, 0x35, 0x81, 06, 0x31, 0x33}},
Optab{AFMOVB, yfmvx, Px, [23]uint8{0xdf, 04}},
Optab{AFMOVBP, yfmvp, Px, [23]uint8{0xdf, 06}},
Optab{AFMOVD, yfmvd, Px, [23]uint8{0xdd, 00, 0xdd, 02, 0xd9, 00, 0xdd, 02}},
Optab{AFMOVDP, yfmvdp, Px, [23]uint8{0xdd, 03, 0xdd, 03}},
Optab{AFMOVF, yfmvf, Px, [23]uint8{0xd9, 00, 0xd9, 02}},
Optab{AFMOVFP, yfmvp, Px, [23]uint8{0xd9, 03}},
Optab{AFMOVL, yfmvf, Px, [23]uint8{0xdb, 00, 0xdb, 02}},
Optab{AFMOVLP, yfmvp, Px, [23]uint8{0xdb, 03}},
Optab{AFMOVV, yfmvx, Px, [23]uint8{0xdf, 05}},
Optab{AFMOVVP, yfmvp, Px, [23]uint8{0xdf, 07}},
Optab{AFMOVW, yfmvf, Px, [23]uint8{0xdf, 00, 0xdf, 02}},
Optab{AFMOVWP, yfmvp, Px, [23]uint8{0xdf, 03}},
Optab{AFMOVX, yfmvx, Px, [23]uint8{0xdb, 05}},
Optab{AFMOVXP, yfmvp, Px, [23]uint8{0xdb, 07}},
Optab{AFCMOVCC, yfcmv, Px, [23]uint8{0xdb, 00}},
Optab{AFCMOVCS, yfcmv, Px, [23]uint8{0xda, 00}},
Optab{AFCMOVEQ, yfcmv, Px, [23]uint8{0xda, 01}},
Optab{AFCMOVHI, yfcmv, Px, [23]uint8{0xdb, 02}},
Optab{AFCMOVLS, yfcmv, Px, [23]uint8{0xda, 02}},
Optab{AFCMOVNE, yfcmv, Px, [23]uint8{0xdb, 01}},
Optab{AFCMOVNU, yfcmv, Px, [23]uint8{0xdb, 03}},
Optab{AFCMOVUN, yfcmv, Px, [23]uint8{0xda, 03}},
Optab{AFCOMB, nil, 0, [23]uint8{}},
Optab{AFCOMBP, nil, 0, [23]uint8{}},
Optab{AFCOMD, yfadd, Px, [23]uint8{0xdc, 02, 0xd8, 02, 0xdc, 02}}, /* botch */
Optab{AFCOMDP, yfadd, Px, [23]uint8{0xdc, 03, 0xd8, 03, 0xdc, 03}}, /* botch */
Optab{AFCOMDPP, ycompp, Px, [23]uint8{0xde, 03}},
Optab{AFCOMF, yfmvx, Px, [23]uint8{0xd8, 02}},
Optab{AFCOMFP, yfmvx, Px, [23]uint8{0xd8, 03}},
Optab{AFCOMI, yfmvx, Px, [23]uint8{0xdb, 06}},
Optab{AFCOMIP, yfmvx, Px, [23]uint8{0xdf, 06}},
Optab{AFCOML, yfmvx, Px, [23]uint8{0xda, 02}},
Optab{AFCOMLP, yfmvx, Px, [23]uint8{0xda, 03}},
Optab{AFCOMW, yfmvx, Px, [23]uint8{0xde, 02}},
Optab{AFCOMWP, yfmvx, Px, [23]uint8{0xde, 03}},
Optab{AFUCOM, ycompp, Px, [23]uint8{0xdd, 04}},
Optab{AFUCOMI, ycompp, Px, [23]uint8{0xdb, 05}},
Optab{AFUCOMIP, ycompp, Px, [23]uint8{0xdf, 05}},
Optab{AFUCOMP, ycompp, Px, [23]uint8{0xdd, 05}},
Optab{AFUCOMPP, ycompp, Px, [23]uint8{0xda, 13}},
Optab{AFADDDP, yfaddp, Px, [23]uint8{0xde, 00}},
Optab{AFADDW, yfmvx, Px, [23]uint8{0xde, 00}},
Optab{AFADDL, yfmvx, Px, [23]uint8{0xda, 00}},
Optab{AFADDF, yfmvx, Px, [23]uint8{0xd8, 00}},
Optab{AFADDD, yfadd, Px, [23]uint8{0xdc, 00, 0xd8, 00, 0xdc, 00}},
Optab{AFMULDP, yfaddp, Px, [23]uint8{0xde, 01}},
Optab{AFMULW, yfmvx, Px, [23]uint8{0xde, 01}},
Optab{AFMULL, yfmvx, Px, [23]uint8{0xda, 01}},
Optab{AFMULF, yfmvx, Px, [23]uint8{0xd8, 01}},
Optab{AFMULD, yfadd, Px, [23]uint8{0xdc, 01, 0xd8, 01, 0xdc, 01}},
Optab{AFSUBDP, yfaddp, Px, [23]uint8{0xde, 05}},
Optab{AFSUBW, yfmvx, Px, [23]uint8{0xde, 04}},
Optab{AFSUBL, yfmvx, Px, [23]uint8{0xda, 04}},
Optab{AFSUBF, yfmvx, Px, [23]uint8{0xd8, 04}},
Optab{AFSUBD, yfadd, Px, [23]uint8{0xdc, 04, 0xd8, 04, 0xdc, 05}},
Optab{AFSUBRDP, yfaddp, Px, [23]uint8{0xde, 04}},
Optab{AFSUBRW, yfmvx, Px, [23]uint8{0xde, 05}},
Optab{AFSUBRL, yfmvx, Px, [23]uint8{0xda, 05}},
Optab{AFSUBRF, yfmvx, Px, [23]uint8{0xd8, 05}},
Optab{AFSUBRD, yfadd, Px, [23]uint8{0xdc, 05, 0xd8, 05, 0xdc, 04}},
Optab{AFDIVDP, yfaddp, Px, [23]uint8{0xde, 07}},
Optab{AFDIVW, yfmvx, Px, [23]uint8{0xde, 06}},
Optab{AFDIVL, yfmvx, Px, [23]uint8{0xda, 06}},
Optab{AFDIVF, yfmvx, Px, [23]uint8{0xd8, 06}},
Optab{AFDIVD, yfadd, Px, [23]uint8{0xdc, 06, 0xd8, 06, 0xdc, 07}},
Optab{AFDIVRDP, yfaddp, Px, [23]uint8{0xde, 06}},
Optab{AFDIVRW, yfmvx, Px, [23]uint8{0xde, 07}},
Optab{AFDIVRL, yfmvx, Px, [23]uint8{0xda, 07}},
Optab{AFDIVRF, yfmvx, Px, [23]uint8{0xd8, 07}},
Optab{AFDIVRD, yfadd, Px, [23]uint8{0xdc, 07, 0xd8, 07, 0xdc, 06}},
Optab{AFXCHD, yfxch, Px, [23]uint8{0xd9, 01, 0xd9, 01}},
Optab{AFFREE, nil, 0, [23]uint8{}},
Optab{AFLDCW, ystcw, Px, [23]uint8{0xd9, 05, 0xd9, 05}},
Optab{AFLDENV, ystcw, Px, [23]uint8{0xd9, 04, 0xd9, 04}},
Optab{AFRSTOR, ysvrs, Px, [23]uint8{0xdd, 04, 0xdd, 04}},
Optab{AFSAVE, ysvrs, Px, [23]uint8{0xdd, 06, 0xdd, 06}},
Optab{AFSTCW, ystcw, Px, [23]uint8{0xd9, 07, 0xd9, 07}},
Optab{AFSTENV, ystcw, Px, [23]uint8{0xd9, 06, 0xd9, 06}},
Optab{AFSTSW, ystsw, Px, [23]uint8{0xdd, 07, 0xdf, 0xe0}},
Optab{AF2XM1, ynone, Px, [23]uint8{0xd9, 0xf0}},
Optab{AFABS, ynone, Px, [23]uint8{0xd9, 0xe1}},
Optab{AFCHS, ynone, Px, [23]uint8{0xd9, 0xe0}},
Optab{AFCLEX, ynone, Px, [23]uint8{0xdb, 0xe2}},
Optab{AFCOS, ynone, Px, [23]uint8{0xd9, 0xff}},
Optab{AFDECSTP, ynone, Px, [23]uint8{0xd9, 0xf6}},
Optab{AFINCSTP, ynone, Px, [23]uint8{0xd9, 0xf7}},
Optab{AFINIT, ynone, Px, [23]uint8{0xdb, 0xe3}},
Optab{AFLD1, ynone, Px, [23]uint8{0xd9, 0xe8}},
Optab{AFLDL2E, ynone, Px, [23]uint8{0xd9, 0xea}},
Optab{AFLDL2T, ynone, Px, [23]uint8{0xd9, 0xe9}},
Optab{AFLDLG2, ynone, Px, [23]uint8{0xd9, 0xec}},
Optab{AFLDLN2, ynone, Px, [23]uint8{0xd9, 0xed}},
Optab{AFLDPI, ynone, Px, [23]uint8{0xd9, 0xeb}},
Optab{AFLDZ, ynone, Px, [23]uint8{0xd9, 0xee}},
Optab{AFNOP, ynone, Px, [23]uint8{0xd9, 0xd0}},
Optab{AFPATAN, ynone, Px, [23]uint8{0xd9, 0xf3}},
Optab{AFPREM, ynone, Px, [23]uint8{0xd9, 0xf8}},
Optab{AFPREM1, ynone, Px, [23]uint8{0xd9, 0xf5}},
Optab{AFPTAN, ynone, Px, [23]uint8{0xd9, 0xf2}},
Optab{AFRNDINT, ynone, Px, [23]uint8{0xd9, 0xfc}},
Optab{AFSCALE, ynone, Px, [23]uint8{0xd9, 0xfd}},
Optab{AFSIN, ynone, Px, [23]uint8{0xd9, 0xfe}},
Optab{AFSINCOS, ynone, Px, [23]uint8{0xd9, 0xfb}},
Optab{AFSQRT, ynone, Px, [23]uint8{0xd9, 0xfa}},
Optab{AFTST, ynone, Px, [23]uint8{0xd9, 0xe4}},
Optab{AFXAM, ynone, Px, [23]uint8{0xd9, 0xe5}},
Optab{AFXTRACT, ynone, Px, [23]uint8{0xd9, 0xf4}},
Optab{AFYL2X, ynone, Px, [23]uint8{0xd9, 0xf1}},
Optab{AFYL2XP1, ynone, Px, [23]uint8{0xd9, 0xf9}},
Optab{ACMPXCHGB, yrb_mb, Pb, [23]uint8{0x0f, 0xb0}},
Optab{ACMPXCHGL, yrl_ml, Px, [23]uint8{0x0f, 0xb1}},
Optab{ACMPXCHGW, yrl_ml, Pe, [23]uint8{0x0f, 0xb1}},
Optab{ACMPXCHGQ, yrl_ml, Pw, [23]uint8{0x0f, 0xb1}},
Optab{ACMPXCHG8B, yscond, Pm, [23]uint8{0xc7, 01}},
Optab{AINVD, ynone, Pm, [23]uint8{0x08}},
Optab{AINVLPG, ymbs, Pm, [23]uint8{0x01, 07}},
Optab{ALFENCE, ynone, Pm, [23]uint8{0xae, 0xe8}},
Optab{AMFENCE, ynone, Pm, [23]uint8{0xae, 0xf0}},
Optab{AMOVNTIL, yrl_ml, Pm, [23]uint8{0xc3}},
Optab{AMOVNTIQ, yrl_ml, Pw, [23]uint8{0x0f, 0xc3}},
Optab{ARDMSR, ynone, Pm, [23]uint8{0x32}},
Optab{ARDPMC, ynone, Pm, [23]uint8{0x33}},
Optab{ARDTSC, ynone, Pm, [23]uint8{0x31}},
Optab{ARSM, ynone, Pm, [23]uint8{0xaa}},
Optab{ASFENCE, ynone, Pm, [23]uint8{0xae, 0xf8}},
Optab{ASYSRET, ynone, Pm, [23]uint8{0x07}},
Optab{AWBINVD, ynone, Pm, [23]uint8{0x09}},
Optab{AWRMSR, ynone, Pm, [23]uint8{0x30}},
Optab{AXADDB, yrb_mb, Pb, [23]uint8{0x0f, 0xc0}},
Optab{AXADDL, yrl_ml, Px, [23]uint8{0x0f, 0xc1}},
Optab{AXADDQ, yrl_ml, Pw, [23]uint8{0x0f, 0xc1}},
Optab{AXADDW, yrl_ml, Pe, [23]uint8{0x0f, 0xc1}},
Optab{ACRC32B, ycrc32l, Px, [23]uint8{0xf2, 0x0f, 0x38, 0xf0, 0}},
Optab{ACRC32Q, ycrc32l, Pw, [23]uint8{0xf2, 0x0f, 0x38, 0xf1, 0}},
Optab{APREFETCHT0, yprefetch, Pm, [23]uint8{0x18, 01}},
Optab{APREFETCHT1, yprefetch, Pm, [23]uint8{0x18, 02}},
Optab{APREFETCHT2, yprefetch, Pm, [23]uint8{0x18, 03}},
Optab{APREFETCHNTA, yprefetch, Pm, [23]uint8{0x18, 00}},
Optab{AMOVQL, yrl_ml, Px, [23]uint8{0x89}},
Optab{obj.AUNDEF, ynone, Px, [23]uint8{0x0f, 0x0b}},
Optab{AAESENC, yaes, Pq, [23]uint8{0x38, 0xdc, 0}},
Optab{AAESENCLAST, yaes, Pq, [23]uint8{0x38, 0xdd, 0}},
Optab{AAESDEC, yaes, Pq, [23]uint8{0x38, 0xde, 0}},
Optab{AAESDECLAST, yaes, Pq, [23]uint8{0x38, 0xdf, 0}},
Optab{AAESIMC, yaes, Pq, [23]uint8{0x38, 0xdb, 0}},
Optab{AAESKEYGENASSIST, yaes2, Pq, [23]uint8{0x3a, 0xdf, 0}},
Optab{APSHUFD, yxshuf, Pq, [23]uint8{0x70, 0}},
Optab{APCLMULQDQ, yxshuf, Pq, [23]uint8{0x3a, 0x44, 0}},
Optab{obj.AUSEFIELD, ynop, Px, [23]uint8{0, 0}},
Optab{obj.ATYPE, nil, 0, [23]uint8{}},
Optab{obj.AFUNCDATA, yfuncdata, Px, [23]uint8{0, 0}},
Optab{obj.APCDATA, ypcdata, Px, [23]uint8{0, 0}},
Optab{obj.ACHECKNIL, nil, 0, [23]uint8{}},
Optab{obj.AVARDEF, nil, 0, [23]uint8{}},
Optab{obj.AVARKILL, nil, 0, [23]uint8{}},
Optab{obj.ADUFFCOPY, yduff, Px, [23]uint8{0xe8}},
Optab{obj.ADUFFZERO, yduff, Px, [23]uint8{0xe8}},
Optab{obj.AEND, nil, 0, [23]uint8{}},
Optab{0, nil, 0, [23]uint8{}},
}
var opindex [(ALAST + 1) & obj.AMask]*Optab
// isextern reports whether s describes an external symbol that must avoid pc-relative addressing.
// This happens on systems like Solaris that call .so functions instead of system calls.
// It does not seem to be necessary for any other systems. This is probably working
// around a Solaris-specific bug that should be fixed differently, but we don't know
// what that bug is. And this does fix it.
func isextern(s *obj.LSym) bool {
// All the Solaris dynamic imports from libc.so begin with "libc_".
return strings.HasPrefix(s.Name, "libc_")
}
// 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.
var nop = [][16]uint8{
[16]uint8{0x90},
[16]uint8{0x66, 0x90},
[16]uint8{0x0F, 0x1F, 0x00},
[16]uint8{0x0F, 0x1F, 0x40, 0x00},
[16]uint8{0x0F, 0x1F, 0x44, 0x00, 0x00},
[16]uint8{0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00},
[16]uint8{0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00},
[16]uint8{0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
[16]uint8{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},
func fillnop(p []byte, n int) {
var m int
for n > 0 {
m = n
if m > len(nop) {
m = len(nop)
}
copy(p[:m], nop[m-1][:m])
p = p[m:]
n -= m
}
}
func naclpad(ctxt *obj.Link, s *obj.LSym, c int32, pad int32) int32 {
obj.Symgrow(ctxt, s, int64(c)+int64(pad))
fillnop(s.P[c:], int(pad))
return c + pad
}
func spadjop(ctxt *obj.Link, p *obj.Prog, l int, q int) int {
if p.Mode != 64 || ctxt.Arch.Ptrsize == 4 {
return l
}
return q
}
func span6(ctxt *obj.Link, s *obj.LSym) {
ctxt.Cursym = s
if s.P != nil {
return
}
if ycover[0] == 0 {
instinit()
}
var v int32
for p := ctxt.Cursym.Text; p != nil; p = p.Link {
if p.To.Type == obj.TYPE_BRANCH {
if p.Pcond == nil {
p.Pcond = p
}
}
if p.As == AADJSP {
p.To.Type = obj.TYPE_REG
p.To.Reg = REG_SP
v = int32(-p.From.Offset)
p.From.Offset = int64(v)
p.As = int16(spadjop(ctxt, p, AADDL, AADDQ))
if v < 0 {
p.As = int16(spadjop(ctxt, p, ASUBL, ASUBQ))
v = -v
p.From.Offset = int64(v)
}
if v == 0 {
p.As = obj.ANOP
}
}
}
var q *obj.Prog
for p := s.Text; p != nil; p = p.Link {
p.Back = 2 // use short branches first time through
q = p.Pcond
if q != nil && (q.Back&2 != 0) {
p.Back |= 1 // backward jump
q.Back |= 4 // loop head
}
if p.As == AADJSP {
p.To.Type = obj.TYPE_REG
p.To.Reg = REG_SP
v = int32(-p.From.Offset)
p.From.Offset = int64(v)
p.As = int16(spadjop(ctxt, p, AADDL, AADDQ))
if v < 0 {
p.As = int16(spadjop(ctxt, p, ASUBL, ASUBQ))
v = -v
p.From.Offset = int64(v)
}
if v == 0 {
p.As = obj.ANOP
}
}
}
n := 0
var bp []byte
var c int32
var i int
var loop int32
var m int
var p *obj.Prog
for {
loop = 0
for i = 0; i < len(s.R); i++ {
s.R[i] = obj.Reloc{}
}
s.R = s.R[:0]
s.P = s.P[:0]
c = 0
for p = s.Text; p != nil; p = p.Link {
if ctxt.Headtype == obj.Hnacl && p.Isize > 0 {
var deferreturn *obj.LSym
if deferreturn == nil {
deferreturn = obj.Linklookup(ctxt, "runtime.deferreturn", 0)
}
// pad everything to avoid crossing 32-byte boundary
if c>>5 != (c+int32(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 == obj.ACALL && p.To.Sym == deferreturn {
c = naclpad(ctxt, s, c, -c&31)
}
// pad call to end at 32-byte boundary
if p.As == obj.ACALL {
c = naclpad(ctxt, s, c, -(c+int32(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 || p.As == AREPN) && 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)
}
}
if (p.Back&4 != 0) && c&(LoopAlign-1) != 0 {
// pad with NOPs
v = -c & (LoopAlign - 1)
if v <= MaxLoopPad {
obj.Symgrow(ctxt, s, int64(c)+int64(v))
fillnop(s.P[c:], int(v))
c += v
}
}
p.Pc = int64(c)
// process forward jumps to p
for q = p.Comefrom; q != nil; q = q.Forwd {
v = int32(p.Pc - (q.Pc + int64(q.Mark)))
if q.Back&2 != 0 { // short
if v > 127 {
loop++
q.Back ^= 2
}
if q.As == AJCXZL {
s.P[q.Pc+2] = byte(v)
} else {
s.P[q.Pc+1] = byte(v)
}
} else {
bp = s.P[q.Pc+int64(q.Mark)-4:]
bp[0] = byte(v)
bp = bp[1:]
bp[0] = byte(v >> 8)
bp = bp[1:]
bp[0] = byte(v >> 16)
bp = bp[1:]
bp[0] = byte(v >> 24)
}
}
p.Comefrom = nil
p.Pc = int64(c)
asmins(ctxt, p)
m = -cap(ctxt.Andptr) + cap(ctxt.And[:])
if int(p.Isize) != m {
p.Isize = uint8(m)
loop++
}
obj.Symgrow(ctxt, s, p.Pc+int64(m))
copy(s.P[p.Pc:][:m], ctxt.And[:m])
p.Mark = uint16(m)
c += int32(m)
}
n++
if n > 20 {
ctxt.Diag("span must be looping")
log.Fatalf("loop")
}
if loop == 0 {
break
}
}
if ctxt.Headtype == obj.Hnacl {
c = naclpad(ctxt, s, c, -c&31)
}
c += -c & (FuncAlign - 1)
s.Size = int64(c)
if false { /* debug['a'] > 1 */
fmt.Printf("span1 %s %d (%d tries)\n %.6x", s.Name, s.Size, n, 0)
var i int
for i = 0; i < len(s.P); i++ {
fmt.Printf(" %.2x", s.P[i])
if i%16 == 15 {
fmt.Printf("\n %.6x", uint(i+1))
}
}
if i%16 != 0 {
fmt.Printf("\n")
}
for i := 0; i < len(s.R); i++ {
r := &s.R[i]
fmt.Printf(" rel %#.4x/%d %s%+d\n", uint32(r.Off), r.Siz, r.Sym.Name, r.Add)
}
}
}
func instinit() {
var c int
for i := 1; optab[i].as != 0; i++ {
c = int(optab[i].as)
if opindex[c&obj.AMask] != nil {
log.Fatalf("phase error in optab: %d (%v)", i, obj.Aconv(c))
}
opindex[c&obj.AMask] = &optab[i]
}
for i := 0; i < Ymax; i++ {
ycover[i*Ymax+i] = 1
}
ycover[Yi0*Ymax+Yi8] = 1
ycover[Yi1*Ymax+Yi8] = 1
ycover[Yu7*Ymax+Yi8] = 1
ycover[Yi0*Ymax+Yu7] = 1
ycover[Yi1*Ymax+Yu7] = 1
ycover[Yi0*Ymax+Yu8] = 1
ycover[Yi1*Ymax+Yu8] = 1
ycover[Yu7*Ymax+Yu8] = 1
ycover[Yi0*Ymax+Ys32] = 1
ycover[Yi1*Ymax+Ys32] = 1
ycover[Yu7*Ymax+Ys32] = 1
ycover[Yu8*Ymax+Ys32] = 1
ycover[Yi8*Ymax+Ys32] = 1
ycover[Yi0*Ymax+Yi32] = 1
ycover[Yi1*Ymax+Yi32] = 1
ycover[Yu7*Ymax+Yi32] = 1
ycover[Yu8*Ymax+Yi32] = 1
ycover[Yi8*Ymax+Yi32] = 1
ycover[Ys32*Ymax+Yi32] = 1
ycover[Yi0*Ymax+Yi64] = 1
ycover[Yi1*Ymax+Yi64] = 1
ycover[Yu7*Ymax+Yi64] = 1
ycover[Yu8*Ymax+Yi64] = 1
ycover[Yi8*Ymax+Yi64] = 1
ycover[Ys32*Ymax+Yi64] = 1
ycover[Yi32*Ymax+Yi64] = 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[Yrl*Ymax+Yrb] = 1 // but not Yrl32
ycover[Ycl*Ymax+Ycx] = 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[Yrl32*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[Yrl*Ymax+Ymb] = 1 // but not Yrl32
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[Yrl32*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[Yrl32*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 < MAXREG; i++ {
reg[i] = -1
if i >= REG_AL && i <= REG_R15B {
reg[i] = (i - REG_AL) & 7
if i >= REG_SPB && i <= REG_DIB {
regrex[i] = 0x40
}
if i >= REG_R8B && i <= REG_R15B {
regrex[i] = Rxr | Rxx | Rxb
}
}
if i >= REG_AH && i <= REG_BH {
reg[i] = 4 + ((i - REG_AH) & 7)
}
if i >= REG_AX && i <= REG_R15 {
reg[i] = (i - REG_AX) & 7
if i >= REG_R8 {
regrex[i] = Rxr | Rxx | Rxb
}
}
if i >= REG_F0 && i <= REG_F0+7 {
reg[i] = (i - REG_F0) & 7
}
if i >= REG_M0 && i <= REG_M0+7 {
reg[i] = (i - REG_M0) & 7
}
if i >= REG_X0 && i <= REG_X0+15 {
reg[i] = (i - REG_X0) & 7
if i >= REG_X0+8 {
regrex[i] = Rxr | Rxx | Rxb
}
}
if i >= REG_CR+8 && i <= REG_CR+15 {
regrex[i] = Rxr
}
}
}
func prefixof(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
if a.Reg < REG_CS && a.Index < REG_CS { // fast path
return 0
}
if a.Type == obj.TYPE_MEM && a.Name == obj.NAME_NONE {
switch a.Reg {
case REG_CS:
return 0x2e
case REG_DS:
return 0x3e
case REG_ES:
return 0x26
case REG_FS:
return 0x64
case REG_GS:
return 0x65
case REG_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.
if p.Mode == 32 {
switch ctxt.Headtype {
default:
log.Fatalf("unknown TLS base register for %s", obj.Headstr(ctxt.Headtype))
case obj.Hdarwin,
obj.Hdragonfly,
obj.Hfreebsd,
obj.Hnetbsd,
obj.Hopenbsd:
return 0x65 // GS
}
}
switch ctxt.Headtype {
default:
log.Fatalf("unknown TLS base register for %s", obj.Headstr(ctxt.Headtype))
case obj.Hlinux:
if ctxt.Flag_shared != 0 {
log.Fatalf("unknown TLS base register for linux with -shared")
} else {
return 0x64 // FS
}
case obj.Hdragonfly,
obj.Hfreebsd,
obj.Hnetbsd,
obj.Hopenbsd,
obj.Hsolaris:
return 0x64 // FS
case obj.Hdarwin:
return 0x65 // GS
}
}
}
if p.Mode == 32 {
return 0
}
switch a.Index {
case REG_CS:
return 0x2e
case REG_DS:
return 0x3e
case REG_ES:
return 0x26
case REG_TLS:
if ctxt.Flag_shared != 0 {
// When building for inclusion into a shared library, an instruction of the form
// MOV 0(CX)(TLS*1), AX
// becomes
// mov %fs:(%rcx), %rax
// which assumes that the correct TLS offset has been loaded into %rcx (today
// there is only one TLS variable -- g -- so this is OK). When not building for
// a shared library the instruction does not require a prefix.
if a.Offset != 0 {
log.Fatalf("cannot handle non-0 offsets to TLS")
}
return 0x64
}
case REG_FS:
return 0x64
case REG_GS:
return 0x65
}
return 0
}
func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
switch a.Type {
case obj.TYPE_NONE:
return Ynone
case obj.TYPE_BRANCH:
return Ybr
case obj.TYPE_INDIR:
if a.Name != obj.NAME_NONE && a.Reg == REG_NONE && a.Index == REG_NONE && a.Scale == 0 {
return Yindir
}
return Yxxx
case obj.TYPE_MEM:
return Ym
case obj.TYPE_ADDR:
switch a.Name {
case obj.NAME_EXTERN,
obj.NAME_GOTREF,
obj.NAME_STATIC:
if a.Sym != nil && isextern(a.Sym) || p.Mode == 32 {
return Yi32
}
return Yiauto // use pc-relative addressing
case obj.NAME_AUTO,
obj.NAME_PARAM:
return Yiauto
}
// TODO(rsc): DUFFZERO/DUFFCOPY encoding forgot to set a->index
// and got Yi32 in an earlier version of this code.
// Keep doing that until we fix yduff etc.
if a.Sym != nil && strings.HasPrefix(a.Sym.Name, "runtime.duff") {
return Yi32
}
if a.Sym != nil || a.Name != obj.NAME_NONE {
ctxt.Diag("unexpected addr: %v", obj.Dconv(p, a))
}
fallthrough
// fall through
case obj.TYPE_CONST:
if a.Sym != nil {
ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, a))
}
v := a.Offset
if p.Mode == 32 {
v = int64(int32(v))
}
if v == 0 {
return Yi0
}
if v == 1 {
return Yi1
}
if v >= 0 && v <= 127 {
return Yu7
}
if v >= 0 && v <= 255 {
return Yu8
}
if v >= -128 && v <= 127 {
return Yi8
}
if p.Mode == 32 {
return Yi32
}
l := int32(v)
if int64(l) == v {
return Ys32 /* can sign extend */
}
if v>>32 == 0 {
return Yi32 /* unsigned */
}
return Yi64
case obj.TYPE_TEXTSIZE:
return Ytextsize
}
if a.Type != obj.TYPE_REG {
ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, a))
return Yxxx
}
switch a.Reg {
case REG_AL:
return Yal
case REG_AX:
return Yax
/*
case REG_SPB:
*/
case REG_BPB,
REG_SIB,
REG_DIB,
REG_R8B,
REG_R9B,
REG_R10B,
REG_R11B,
REG_R12B,
REG_R13B,
REG_R14B,
REG_R15B:
if ctxt.Asmode != 64 {
return Yxxx
}
fallthrough
case REG_DL,
REG_BL,
REG_AH,
REG_CH,
REG_DH,
REG_BH:
return Yrb
case REG_CL:
return Ycl
case REG_CX:
return Ycx
case REG_DX, REG_BX:
return Yrx
case REG_R8, /* not really Yrl */
REG_R9,
REG_R10,
REG_R11,
REG_R12,
REG_R13,
REG_R14,
REG_R15:
if ctxt.Asmode != 64 {
return Yxxx
}
fallthrough
case REG_SP, REG_BP, REG_SI, REG_DI:
if p.Mode == 32 {
return Yrl32
}
return Yrl
case REG_F0 + 0:
return Yf0
case REG_F0 + 1,
REG_F0 + 2,
REG_F0 + 3,
REG_F0 + 4,
REG_F0 + 5,
REG_F0 + 6,
REG_F0 + 7:
return Yrf
case REG_M0 + 0,
REG_M0 + 1,
REG_M0 + 2,
REG_M0 + 3,
REG_M0 + 4,
REG_M0 + 5,
REG_M0 + 6,
REG_M0 + 7:
return Ymr
case REG_X0 + 0,
REG_X0 + 1,
REG_X0 + 2,
REG_X0 + 3,
REG_X0 + 4,
REG_X0 + 5,
REG_X0 + 6,
REG_X0 + 7,
REG_X0 + 8,
REG_X0 + 9,
REG_X0 + 10,
REG_X0 + 11,
REG_X0 + 12,
REG_X0 + 13,
REG_X0 + 14,
REG_X0 + 15:
return Yxr
case REG_CS:
return Ycs
case REG_SS:
return Yss
case REG_DS:
return Yds
case REG_ES:
return Yes
case REG_FS:
return Yfs
case REG_GS:
return Ygs
case REG_TLS:
return Ytls
case REG_GDTR:
return Ygdtr
case REG_IDTR:
return Yidtr
case REG_LDTR:
return Yldtr
case REG_MSW:
return Ymsw
case REG_TASK:
return Ytask
case REG_CR + 0:
return Ycr0
case REG_CR + 1:
return Ycr1
case REG_CR + 2:
return Ycr2
case REG_CR + 3:
return Ycr3
case REG_CR + 4:
return Ycr4
case REG_CR + 5:
return Ycr5
case REG_CR + 6:
return Ycr6
case REG_CR + 7:
return Ycr7
case REG_CR + 8:
return Ycr8
case REG_DR + 0:
return Ydr0
case REG_DR + 1:
return Ydr1
case REG_DR + 2:
return Ydr2
case REG_DR + 3:
return Ydr3
case REG_DR + 4:
return Ydr4
case REG_DR + 5:
return Ydr5
case REG_DR + 6:
return Ydr6
case REG_DR + 7:
return Ydr7
case REG_TR + 0:
return Ytr0
case REG_TR + 1:
return Ytr1
case REG_TR + 2:
return Ytr2
case REG_TR + 3:
return Ytr3
case REG_TR + 4:
return Ytr4
case REG_TR + 5:
return Ytr5
case REG_TR + 6:
return Ytr6
case REG_TR + 7:
return Ytr7
}
return Yxxx
}
func asmidx(ctxt *obj.Link, scale int, index int, base int) {
var i int
switch index {
default:
goto bad
case REG_NONE:
i = 4 << 3
goto bas
case REG_R8,
REG_R9,
REG_R10,
REG_R11,
REG_R12,
REG_R13,
REG_R14,
REG_R15:
if ctxt.Asmode != 64 {
goto bad
}
fallthrough
case REG_AX,
REG_CX,
REG_DX,
REG_BX,
REG_BP,
REG_SI,
REG_DI:
i = reg[index] << 3
}
switch scale {
default:
goto bad
case 1:
break
case 2:
i |= 1 << 6
case 4:
i |= 2 << 6
case 8:
i |= 3 << 6
}
bas:
switch base {
default:
goto bad
case REG_NONE: /* must be mod=00 */
i |= 5
case REG_R8,
REG_R9,
REG_R10,
REG_R11,
REG_R12,
REG_R13,
REG_R14,
REG_R15:
if ctxt.Asmode != 64 {
goto bad
}
fallthrough
case REG_AX,
REG_CX,
REG_DX,
REG_BX,
REG_SP,
REG_BP,
REG_SI,
REG_DI:
i |= reg[base]
}
ctxt.Andptr[0] = byte(i)
ctxt.Andptr = ctxt.Andptr[1:]
return
bad:
ctxt.Diag("asmidx: bad address %d/%d/%d", scale, index, base)
ctxt.Andptr[0] = 0
ctxt.Andptr = ctxt.Andptr[1:]
return
}
func put4(ctxt *obj.Link, v int32) {
ctxt.Andptr[0] = byte(v)
ctxt.Andptr[1] = byte(v >> 8)
ctxt.Andptr[2] = byte(v >> 16)
ctxt.Andptr[3] = byte(v >> 24)
ctxt.Andptr = ctxt.Andptr[4:]
}
func relput4(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
var rel obj.Reloc
v := vaddr(ctxt, p, a, &rel)
if rel.Siz != 0 {
if rel.Siz != 4 {
ctxt.Diag("bad reloc")
}
r := obj.Addrel(ctxt.Cursym)
*r = rel
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
}
put4(ctxt, int32(v))
}
func put8(ctxt *obj.Link, v int64) {
ctxt.Andptr[0] = byte(v)
ctxt.Andptr[1] = byte(v >> 8)
ctxt.Andptr[2] = byte(v >> 16)
ctxt.Andptr[3] = byte(v >> 24)
ctxt.Andptr[4] = byte(v >> 32)
ctxt.Andptr[5] = byte(v >> 40)
ctxt.Andptr[6] = byte(v >> 48)
ctxt.Andptr[7] = byte(v >> 56)
ctxt.Andptr = ctxt.Andptr[8:]
}
/*
static void
relput8(Prog *p, Addr *a)
{
vlong v;
Reloc rel, *r;
v = vaddr(ctxt, p, a, &rel);
if(rel.siz != 0) {
r = addrel(ctxt->cursym);
*r = rel;
r->siz = 8;
r->off = p->pc + ctxt->andptr - ctxt->and;
}
put8(ctxt, v);
}
*/
func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
if r != nil {
*r = obj.Reloc{}
}
switch a.Name {
case obj.NAME_STATIC,
obj.NAME_GOTREF,
obj.NAME_EXTERN:
s := a.Sym
if r == nil {
ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
log.Fatalf("reloc")
}
if a.Name == obj.NAME_GOTREF {
r.Siz = 4
r.Type = obj.R_GOTPCREL
} else if isextern(s) || p.Mode != 64 {
r.Siz = 4
r.Type = obj.R_ADDR
} else {
r.Siz = 4
r.Type = obj.R_PCREL
}
r.Off = -1 // caller must fill in
r.Sym = s
r.Add = a.Offset
return 0
}
if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS {
if r == nil {
ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
log.Fatalf("reloc")
}
r.Type = obj.R_TLS_LE
r.Siz = 4
r.Off = -1 // caller must fill in
r.Add = a.Offset
return 0
}
return a.Offset
}
func asmandsz(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int, rex int, m64 int) {
var base int
var rel obj.Reloc
rex &= 0x40 | Rxr
v := int32(a.Offset)
rel.Siz = 0
switch a.Type {
case obj.TYPE_ADDR:
if a.Name == obj.NAME_NONE {
ctxt.Diag("unexpected TYPE_ADDR with NAME_NONE")
}
if a.Index == REG_TLS {
ctxt.Diag("unexpected TYPE_ADDR with index==REG_TLS")
}
goto bad
case obj.TYPE_REG:
if a.Reg < REG_AL || REG_X0+15 < a.Reg {
goto bad
}
if v != 0 {
goto bad
}
ctxt.Andptr[0] = byte(3<<6 | reg[a.Reg]<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Rexflag |= regrex[a.Reg]&(0x40|Rxb) | rex
return
}
if a.Type != obj.TYPE_MEM {
goto bad
}
if a.Index != REG_NONE && a.Index != REG_TLS {
base := int(a.Reg)
switch a.Name {
case obj.NAME_EXTERN,
obj.NAME_GOTREF,
obj.NAME_STATIC:
if !isextern(a.Sym) && p.Mode == 64 {
goto bad
}
base = REG_NONE
v = int32(vaddr(ctxt, p, a, &rel))
case obj.NAME_AUTO,
obj.NAME_PARAM:
base = REG_SP
}
ctxt.Rexflag |= regrex[int(a.Index)]&Rxx | regrex[base]&Rxb | rex
if base == REG_NONE {
ctxt.Andptr[0] = byte(0<<6 | 4<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
asmidx(ctxt, int(a.Scale), int(a.Index), base)
goto putrelv
}
if v == 0 && rel.Siz == 0 && base != REG_BP && base != REG_R13 {
ctxt.Andptr[0] = byte(0<<6 | 4<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
asmidx(ctxt, int(a.Scale), int(a.Index), base)
return
}
if v >= -128 && v < 128 && rel.Siz == 0 {
ctxt.Andptr[0] = byte(1<<6 | 4<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
asmidx(ctxt, int(a.Scale), int(a.Index), base)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
return
}
ctxt.Andptr[0] = byte(2<<6 | 4<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
asmidx(ctxt, int(a.Scale), int(a.Index), base)
goto putrelv
}
base = int(a.Reg)
switch a.Name {
case obj.NAME_STATIC,
obj.NAME_GOTREF,
obj.NAME_EXTERN:
if a.Sym == nil {
ctxt.Diag("bad addr: %v", p)
}
base = REG_NONE
v = int32(vaddr(ctxt, p, a, &rel))
case obj.NAME_AUTO,
obj.NAME_PARAM:
base = REG_SP
}
if base == REG_TLS {
v = int32(vaddr(ctxt, p, a, &rel))
}
ctxt.Rexflag |= regrex[base]&Rxb | rex
if base == REG_NONE || (REG_CS <= base && base <= REG_GS) || base == REG_TLS {
if (a.Sym == nil || !isextern(a.Sym)) && base == REG_NONE && (a.Name == obj.NAME_STATIC || a.Name == obj.NAME_EXTERN || a.Name == obj.NAME_GOTREF) || p.Mode != 64 {
if a.Name == obj.NAME_GOTREF && (a.Offset != 0 || a.Index != 0 || a.Scale != 0) {
ctxt.Diag("%v has offset against gotref", p)
}
ctxt.Andptr[0] = byte(0<<6 | 5<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
goto putrelv
}
/* temporary */
ctxt.Andptr[0] = byte(0<<6 | 4<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:] /* sib present */
ctxt.Andptr[0] = 0<<6 | 4<<3 | 5<<0
ctxt.Andptr = ctxt.Andptr[1:] /* DS:d32 */
goto putrelv
}
if base == REG_SP || base == REG_R12 {
if v == 0 {
ctxt.Andptr[0] = byte(0<<6 | reg[base]<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
asmidx(ctxt, int(a.Scale), REG_NONE, base)
return
}
if v >= -128 && v < 128 {
ctxt.Andptr[0] = byte(1<<6 | reg[base]<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
asmidx(ctxt, int(a.Scale), REG_NONE, base)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
return
}
ctxt.Andptr[0] = byte(2<<6 | reg[base]<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
asmidx(ctxt, int(a.Scale), REG_NONE, base)
goto putrelv
}
if REG_AX <= base && base <= REG_R15 {
if a.Index == REG_TLS && ctxt.Flag_shared == 0 {
rel = obj.Reloc{}
rel.Type = obj.R_TLS_LE
rel.Siz = 4
rel.Sym = nil
rel.Add = int64(v)
v = 0
}
if v == 0 && rel.Siz == 0 && base != REG_BP && base != REG_R13 {
ctxt.Andptr[0] = byte(0<<6 | reg[base]<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
return
}
if v >= -128 && v < 128 && rel.Siz == 0 {
ctxt.Andptr[0] = byte(1<<6 | reg[base]<<0 | r<<3)
ctxt.Andptr[1] = byte(v)
ctxt.Andptr = ctxt.Andptr[2:]
return
}
ctxt.Andptr[0] = byte(2<<6 | reg[base]<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
goto putrelv
}
goto bad
putrelv:
if rel.Siz != 0 {
if rel.Siz != 4 {
ctxt.Diag("bad rel")
goto bad
}
r := obj.Addrel(ctxt.Cursym)
*r = rel
r.Off = int32(ctxt.Curp.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
}
put4(ctxt, v)
return
bad:
ctxt.Diag("asmand: bad address %v", obj.Dconv(p, a))
return
}
func asmand(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, ra *obj.Addr) {
asmandsz(ctxt, p, a, reg[ra.Reg], regrex[ra.Reg], 0)
}
func asmando(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, o int) {
asmandsz(ctxt, p, a, o, 0, 0)
}
func bytereg(a *obj.Addr, t *uint8) {
if a.Type == obj.TYPE_REG && a.Index == REG_NONE && (REG_AX <= a.Reg && a.Reg <= REG_R15) {
a.Reg += REG_AL - REG_AX
*t = 0
}
}
func unbytereg(a *obj.Addr, t *uint8) {
if a.Type == obj.TYPE_REG && a.Index == REG_NONE && (REG_AL <= a.Reg && a.Reg <= REG_R15B) {
a.Reg += REG_AX - REG_AL
*t = 0
}
}
const (
E = 0xff
)
var ymovtab = []Movtab{
/* push */
Movtab{APUSHL, Ycs, Ynone, Ynone, 0, [4]uint8{0x0e, E, 0, 0}},
Movtab{APUSHL, Yss, Ynone, Ynone, 0, [4]uint8{0x16, E, 0, 0}},
Movtab{APUSHL, Yds, Ynone, Ynone, 0, [4]uint8{0x1e, E, 0, 0}},
Movtab{APUSHL, Yes, Ynone, Ynone, 0, [4]uint8{0x06, E, 0, 0}},
Movtab{APUSHL, Yfs, Ynone, Ynone, 0, [4]uint8{0x0f, 0xa0, E, 0}},
Movtab{APUSHL, Ygs, Ynone, Ynone, 0, [4]uint8{0x0f, 0xa8, E, 0}},
Movtab{APUSHQ, Yfs, Ynone, Ynone, 0, [4]uint8{0x0f, 0xa0, E, 0}},
Movtab{APUSHQ, Ygs, Ynone, Ynone, 0, [4]uint8{0x0f, 0xa8, E, 0}},
Movtab{APUSHW, Ycs, Ynone, Ynone, 0, [4]uint8{Pe, 0x0e, E, 0}},
Movtab{APUSHW, Yss, Ynone, Ynone, 0, [4]uint8{Pe, 0x16, E, 0}},
Movtab{APUSHW, Yds, Ynone, Ynone, 0, [4]uint8{Pe, 0x1e, E, 0}},
Movtab{APUSHW, Yes, Ynone, Ynone, 0, [4]uint8{Pe, 0x06, E, 0}},
Movtab{APUSHW, Yfs, Ynone, Ynone, 0, [4]uint8{Pe, 0x0f, 0xa0, E}},
Movtab{APUSHW, Ygs, Ynone, Ynone, 0, [4]uint8{Pe, 0x0f, 0xa8, E}},
/* pop */
Movtab{APOPL, Ynone, Ynone, Yds, 0, [4]uint8{0x1f, E, 0, 0}},
Movtab{APOPL, Ynone, Ynone, Yes, 0, [4]uint8{0x07, E, 0, 0}},
Movtab{APOPL, Ynone, Ynone, Yss, 0, [4]uint8{0x17, E, 0, 0}},
Movtab{APOPL, Ynone, Ynone, Yfs, 0, [4]uint8{0x0f, 0xa1, E, 0}},
Movtab{APOPL, Ynone, Ynone, Ygs, 0, [4]uint8{0x0f, 0xa9, E, 0}},
Movtab{APOPQ, Ynone, Ynone, Yfs, 0, [4]uint8{0x0f, 0xa1, E, 0}},
Movtab{APOPQ, Ynone, Ynone, Ygs, 0, [4]uint8{0x0f, 0xa9, E, 0}},
Movtab{APOPW, Ynone, Ynone, Yds, 0, [4]uint8{Pe, 0x1f, E, 0}},
Movtab{APOPW, Ynone, Ynone, Yes, 0, [4]uint8{Pe, 0x07, E, 0}},
Movtab{APOPW, Ynone, Ynone, Yss, 0, [4]uint8{Pe, 0x17, E, 0}},
Movtab{APOPW, Ynone, Ynone, Yfs, 0, [4]uint8{Pe, 0x0f, 0xa1, E}},
Movtab{APOPW, Ynone, Ynone, Ygs, 0, [4]uint8{Pe, 0x0f, 0xa9, E}},
/* mov seg */
Movtab{AMOVW, Yes, Ynone, Yml, 1, [4]uint8{0x8c, 0, 0, 0}},
Movtab{AMOVW, Ycs, Ynone, Yml, 1, [4]uint8{0x8c, 1, 0, 0}},
Movtab{AMOVW, Yss, Ynone, Yml, 1, [4]uint8{0x8c, 2, 0, 0}},
Movtab{AMOVW, Yds, Ynone, Yml, 1, [4]uint8{0x8c, 3, 0, 0}},
Movtab{AMOVW, Yfs, Ynone, Yml, 1, [4]uint8{0x8c, 4, 0, 0}},
Movtab{AMOVW, Ygs, Ynone, Yml, 1, [4]uint8{0x8c, 5, 0, 0}},
Movtab{AMOVW, Yml, Ynone, Yes, 2, [4]uint8{0x8e, 0, 0, 0}},
Movtab{AMOVW, Yml, Ynone, Ycs, 2, [4]uint8{0x8e, 1, 0, 0}},
Movtab{AMOVW, Yml, Ynone, Yss, 2, [4]uint8{0x8e, 2, 0, 0}},
Movtab{AMOVW, Yml, Ynone, Yds, 2, [4]uint8{0x8e, 3, 0, 0}},
Movtab{AMOVW, Yml, Ynone, Yfs, 2, [4]uint8{0x8e, 4, 0, 0}},
Movtab{AMOVW, Yml, Ynone, Ygs, 2, [4]uint8{0x8e, 5, 0, 0}},
/* mov cr */
Movtab{AMOVL, Ycr0, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 0, 0}},
Movtab{AMOVL, Ycr2, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 2, 0}},
Movtab{AMOVL, Ycr3, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 3, 0}},
Movtab{AMOVL, Ycr4, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 4, 0}},
Movtab{AMOVL, Ycr8, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 8, 0}},
Movtab{AMOVQ, Ycr0, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 0, 0}},
Movtab{AMOVQ, Ycr2, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 2, 0}},
Movtab{AMOVQ, Ycr3, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 3, 0}},
Movtab{AMOVQ, Ycr4, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 4, 0}},
Movtab{AMOVQ, Ycr8, Ynone, Yml, 3, [4]uint8{0x0f, 0x20, 8, 0}},
Movtab{AMOVL, Yml, Ynone, Ycr0, 4, [4]uint8{0x0f, 0x22, 0, 0}},
Movtab{AMOVL, Yml, Ynone, Ycr2, 4, [4]uint8{0x0f, 0x22, 2, 0}},
Movtab{AMOVL, Yml, Ynone, Ycr3, 4, [4]uint8{0x0f, 0x22, 3, 0}},
Movtab{AMOVL, Yml, Ynone, Ycr4, 4, [4]uint8{0x0f, 0x22, 4, 0}},
Movtab{AMOVL, Yml, Ynone, Ycr8, 4, [4]uint8{0x0f, 0x22, 8, 0}},
Movtab{AMOVQ, Yml, Ynone, Ycr0, 4, [4]uint8{0x0f, 0x22, 0, 0}},
Movtab{AMOVQ, Yml, Ynone, Ycr2, 4, [4]uint8{0x0f, 0x22, 2, 0}},
Movtab{AMOVQ, Yml, Ynone, Ycr3, 4, [4]uint8{0x0f, 0x22, 3, 0}},
Movtab{AMOVQ, Yml, Ynone, Ycr4, 4, [4]uint8{0x0f, 0x22, 4, 0}},
Movtab{AMOVQ, Yml, Ynone, Ycr8, 4, [4]uint8{0x0f, 0x22, 8, 0}},
/* mov dr */
Movtab{AMOVL, Ydr0, Ynone, Yml, 3, [4]uint8{0x0f, 0x21, 0, 0}},
Movtab{AMOVL, Ydr6, Ynone, Yml, 3, [4]uint8{0x0f, 0x21, 6, 0}},
Movtab{AMOVL, Ydr7, Ynone, Yml, 3, [4]uint8{0x0f, 0x21, 7, 0}},
Movtab{AMOVQ, Ydr0, Ynone, Yml, 3, [4]uint8{0x0f, 0x21, 0, 0}},
Movtab{AMOVQ, Ydr6, Ynone, Yml, 3, [4]uint8{0x0f, 0x21, 6, 0}},
Movtab{AMOVQ, Ydr7, Ynone, Yml, 3, [4]uint8{0x0f, 0x21, 7, 0}},
Movtab{AMOVL, Yml, Ynone, Ydr0, 4, [4]uint8{0x0f, 0x23, 0, 0}},
Movtab{AMOVL, Yml, Ynone, Ydr6, 4, [4]uint8{0x0f, 0x23, 6, 0}},
Movtab{AMOVL, Yml, Ynone, Ydr7, 4, [4]uint8{0x0f, 0x23, 7, 0}},
Movtab{AMOVQ, Yml, Ynone, Ydr0, 4, [4]uint8{0x0f, 0x23, 0, 0}},
Movtab{AMOVQ, Yml, Ynone, Ydr6, 4, [4]uint8{0x0f, 0x23, 6, 0}},
Movtab{AMOVQ, Yml, Ynone, Ydr7, 4, [4]uint8{0x0f, 0x23, 7, 0}},
/* mov tr */
Movtab{AMOVL, Ytr6, Ynone, Yml, 3, [4]uint8{0x0f, 0x24, 6, 0}},
Movtab{AMOVL, Ytr7, Ynone, Yml, 3, [4]uint8{0x0f, 0x24, 7, 0}},
Movtab{AMOVL, Yml, Ynone, Ytr6, 4, [4]uint8{0x0f, 0x26, 6, E}},
Movtab{AMOVL, Yml, Ynone, Ytr7, 4, [4]uint8{0x0f, 0x26, 7, E}},
/* lgdt, sgdt, lidt, sidt */
Movtab{AMOVL, Ym, Ynone, Ygdtr, 4, [4]uint8{0x0f, 0x01, 2, 0}},
Movtab{AMOVL, Ygdtr, Ynone, Ym, 3, [4]uint8{0x0f, 0x01, 0, 0}},
Movtab{AMOVL, Ym, Ynone, Yidtr, 4, [4]uint8{0x0f, 0x01, 3, 0}},
Movtab{AMOVL, Yidtr, Ynone, Ym, 3, [4]uint8{0x0f, 0x01, 1, 0}},
Movtab{AMOVQ, Ym, Ynone, Ygdtr, 4, [4]uint8{0x0f, 0x01, 2, 0}},
Movtab{AMOVQ, Ygdtr, Ynone, Ym, 3, [4]uint8{0x0f, 0x01, 0, 0}},
Movtab{AMOVQ, Ym, Ynone, Yidtr, 4, [4]uint8{0x0f, 0x01, 3, 0}},
Movtab{AMOVQ, Yidtr, Ynone, Ym, 3, [4]uint8{0x0f, 0x01, 1, 0}},
/* lldt, sldt */
Movtab{AMOVW, Yml, Ynone, Yldtr, 4, [4]uint8{0x0f, 0x00, 2, 0}},
Movtab{AMOVW, Yldtr, Ynone, Yml, 3, [4]uint8{0x0f, 0x00, 0, 0}},
/* lmsw, smsw */
Movtab{AMOVW, Yml, Ynone, Ymsw, 4, [4]uint8{0x0f, 0x01, 6, 0}},
Movtab{AMOVW, Ymsw, Ynone, Yml, 3, [4]uint8{0x0f, 0x01, 4, 0}},
/* ltr, str */
Movtab{AMOVW, Yml, Ynone, Ytask, 4, [4]uint8{0x0f, 0x00, 3, 0}},
Movtab{AMOVW, Ytask, Ynone, Yml, 3, [4]uint8{0x0f, 0x00, 1, 0}},
/* load full pointer - unsupported
Movtab{AMOVL, Yml, Ycol, 5, [4]uint8{0, 0, 0, 0}},
Movtab{AMOVW, Yml, Ycol, 5, [4]uint8{Pe, 0, 0, 0}},
*/
/* double shift */
Movtab{ASHLL, Yi8, Yrl, Yml, 6, [4]uint8{0xa4, 0xa5, 0, 0}},
Movtab{ASHLL, Ycl, Yrl, Yml, 6, [4]uint8{0xa4, 0xa5, 0, 0}},
Movtab{ASHLL, Ycx, Yrl, Yml, 6, [4]uint8{0xa4, 0xa5, 0, 0}},
Movtab{ASHRL, Yi8, Yrl, Yml, 6, [4]uint8{0xac, 0xad, 0, 0}},
Movtab{ASHRL, Ycl, Yrl, Yml, 6, [4]uint8{0xac, 0xad, 0, 0}},
Movtab{ASHRL, Ycx, Yrl, Yml, 6, [4]uint8{0xac, 0xad, 0, 0}},
Movtab{ASHLQ, Yi8, Yrl, Yml, 6, [4]uint8{Pw, 0xa4, 0xa5, 0}},
Movtab{ASHLQ, Ycl, Yrl, Yml, 6, [4]uint8{Pw, 0xa4, 0xa5, 0}},
Movtab{ASHLQ, Ycx, Yrl, Yml, 6, [4]uint8{Pw, 0xa4, 0xa5, 0}},
Movtab{ASHRQ, Yi8, Yrl, Yml, 6, [4]uint8{Pw, 0xac, 0xad, 0}},
Movtab{ASHRQ, Ycl, Yrl, Yml, 6, [4]uint8{Pw, 0xac, 0xad, 0}},
Movtab{ASHRQ, Ycx, Yrl, Yml, 6, [4]uint8{Pw, 0xac, 0xad, 0}},
Movtab{ASHLW, Yi8, Yrl, Yml, 6, [4]uint8{Pe, 0xa4, 0xa5, 0}},
Movtab{ASHLW, Ycl, Yrl, Yml, 6, [4]uint8{Pe, 0xa4, 0xa5, 0}},
Movtab{ASHLW, Ycx, Yrl, Yml, 6, [4]uint8{Pe, 0xa4, 0xa5, 0}},
Movtab{ASHRW, Yi8, Yrl, Yml, 6, [4]uint8{Pe, 0xac, 0xad, 0}},
Movtab{ASHRW, Ycl, Yrl, Yml, 6, [4]uint8{Pe, 0xac, 0xad, 0}},
Movtab{ASHRW, Ycx, Yrl, Yml, 6, [4]uint8{Pe, 0xac, 0xad, 0}},
/* load TLS base */
Movtab{AMOVL, Ytls, Ynone, Yrl, 7, [4]uint8{0, 0, 0, 0}},
Movtab{AMOVQ, Ytls, Ynone, Yrl, 7, [4]uint8{0, 0, 0, 0}},
Movtab{0, 0, 0, 0, 0, [4]uint8{}},
}
func isax(a *obj.Addr) bool {
switch a.Reg {
case REG_AX, REG_AL, REG_AH:
return true
}
if a.Index == REG_AX {
return true
}
return false
}
func subreg(p *obj.Prog, from int, to int) {
if false { /* debug['Q'] */
fmt.Printf("\n%v\ts/%v/%v/\n", p, Rconv(from), Rconv(to))
}
if int(p.From.Reg) == from {
p.From.Reg = int16(to)
p.Ft = 0
}
if int(p.To.Reg) == from {
p.To.Reg = int16(to)
p.Tt = 0
}
if int(p.From.Index) == from {
p.From.Index = int16(to)
p.Ft = 0
}
if int(p.To.Index) == from {
p.To.Index = int16(to)
p.Tt = 0
}
if false { /* debug['Q'] */
fmt.Printf("%v\n", p)
}
}
func mediaop(ctxt *obj.Link, o *Optab, op int, osize int, z int) int {
switch op {
case Pm, Pe, Pf2, Pf3:
if osize != 1 {
if op != Pm {
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
}
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
z++
op = int(o.op[z])
break
}
fallthrough
default:
if -cap(ctxt.Andptr) == -cap(ctxt.And) || ctxt.And[-cap(ctxt.Andptr)+cap(ctxt.And[:])-1] != Pm {
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
}
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
return z
}
var bpduff1 = []byte{
0x48, 0x89, 0x6c, 0x24, 0xf0, // MOVQ BP, -16(SP)
0x48, 0x8d, 0x6c, 0x24, 0xf0, // LEAQ -16(SP), BP
}
var bpduff2 = []byte{
0x48, 0x8b, 0x6d, 0x00, // MOVQ 0(BP), BP
}
func doasm(ctxt *obj.Link, p *obj.Prog) {
ctxt.Curp = p // TODO
o := opindex[p.As&obj.AMask]
if o == nil {
ctxt.Diag("asmins: missing op %v", p)
return
}
pre := prefixof(ctxt, p, &p.From)
if pre != 0 {
ctxt.Andptr[0] = byte(pre)
ctxt.Andptr = ctxt.Andptr[1:]
}
pre = prefixof(ctxt, p, &p.To)
if pre != 0 {
ctxt.Andptr[0] = byte(pre)
ctxt.Andptr = ctxt.Andptr[1:]
}
// TODO(rsc): This special case is for SHRQ $3, AX:DX,
// which encodes as SHRQ $32(DX*0), AX.
// Similarly SHRQ CX, AX:DX is really SHRQ CX(DX*0), AX.
// Change encoding generated by assemblers and compilers and remove.
if (p.From.Type == obj.TYPE_CONST || p.From.Type == obj.TYPE_REG) && p.From.Index != REG_NONE && p.From.Scale == 0 {
p.From3.Type = obj.TYPE_REG
p.From3.Reg = p.From.Index
p.From.Index = 0
}
// TODO(rsc): This special case is for PINSRQ etc, CMPSD etc.
// Change encoding generated by assemblers and compilers (if any) and remove.
switch p.As {
case AIMUL3Q, APEXTRW, APINSRW, APINSRD, APINSRQ, APSHUFHW, APSHUFL, APSHUFW, ASHUFPD, ASHUFPS, AAESKEYGENASSIST, APSHUFD, APCLMULQDQ:
if p.From3.Type == obj.TYPE_NONE {
p.From3 = p.From
p.From = obj.Addr{}
p.From.Type = obj.TYPE_CONST
p.From.Offset = p.To.Offset
p.To.Offset = 0
}
case ACMPSD, ACMPSS, ACMPPS, ACMPPD:
if p.From3.Type == obj.TYPE_NONE {
p.From3 = p.To
p.To = obj.Addr{}
p.To.Type = obj.TYPE_CONST
p.To.Offset = p.From3.Offset
p.From3.Offset = 0
}
}
if p.Ft == 0 {
p.Ft = uint8(oclass(ctxt, p, &p.From))
}
if p.F3t == 0 {
p.F3t = uint8(oclass(ctxt, p, &p.From3))
}
if p.Tt == 0 {
p.Tt = uint8(oclass(ctxt, p, &p.To))
}
ft := int(p.Ft) * Ymax
f3t := int(p.F3t) * Ymax
tt := int(p.Tt) * Ymax
xo := obj.Bool2int(o.op[0] == 0x0f)
z := 0
var a *obj.Addr
var l int
var op int
var q *obj.Prog
var r *obj.Reloc
var rel obj.Reloc
var v int64
for i := range o.ytab {
yt := &o.ytab[i]
if ycover[ft+int(yt.from)] != 0 && ycover[f3t+int(yt.from3)] != 0 && ycover[tt+int(yt.to)] != 0 {
switch o.prefix {
case Px1: /* first option valid only in 32-bit mode */
if ctxt.Mode == 64 && z == 0 {
z += int(yt.zoffset) + xo
continue
}
case Pq: /* 16 bit escape and opcode escape */
ctxt.Andptr[0] = Pe
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
case Pq3: /* 16 bit escape, Rex.w, and opcode escape */
ctxt.Andptr[0] = Pe
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = Pw
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
case Pf2, /* xmm opcode escape */
Pf3:
ctxt.Andptr[0] = byte(o.prefix)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
case Pm: /* opcode escape */
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
case Pe: /* 16 bit escape */
ctxt.Andptr[0] = Pe
ctxt.Andptr = ctxt.Andptr[1:]
case Pw: /* 64-bit escape */
if p.Mode != 64 {
ctxt.Diag("asmins: illegal 64: %v", p)
}
ctxt.Rexflag |= Pw
case Pw8: /* 64-bit escape if z >= 8 */
if z >= 8 {
if p.Mode != 64 {
ctxt.Diag("asmins: illegal 64: %v", p)
}
ctxt.Rexflag |= Pw
}
case Pb: /* botch */
if p.Mode != 64 && (isbadbyte(&p.From) || isbadbyte(&p.To)) {
goto bad
}
// NOTE(rsc): This is probably safe to do always,
// but when enabled it chooses different encodings
// than the old cmd/internal/obj/i386 code did,
// which breaks our "same bits out" checks.
// In particular, CMPB AX, $0 encodes as 80 f8 00
// in the original obj/i386, and it would encode
// (using a valid, shorter form) as 3c 00 if we enabled
// the call to bytereg here.
if p.Mode == 64 {
bytereg(&p.From, &p.Ft)
bytereg(&p.To, &p.Tt)
}
case P32: /* 32 bit but illegal if 64-bit mode */
if p.Mode == 64 {
ctxt.Diag("asmins: illegal in 64-bit mode: %v", p)
}
case Py: /* 64-bit only, no prefix */
if p.Mode != 64 {
ctxt.Diag("asmins: illegal in %d-bit mode: %v", p.Mode, p)
}
case Py1: /* 64-bit only if z < 1, no prefix */
if z < 1 && p.Mode != 64 {
ctxt.Diag("asmins: illegal in %d-bit mode: %v", p.Mode, p)
}
case Py3: /* 64-bit only if z < 3, no prefix */
if z < 3 && p.Mode != 64 {
ctxt.Diag("asmins: illegal in %d-bit mode: %v", p.Mode, p)
}
}
if z >= len(o.op) {
log.Fatalf("asmins bad table %v", p)
}
op = int(o.op[z])
if op == 0x0f {
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
z++
op = int(o.op[z])
}
switch yt.zcase {
default:
ctxt.Diag("asmins: unknown z %d %v", yt.zcase, p)
return
case Zpseudo:
break
case Zlit:
for ; ; z++ {
op = int(o.op[z])
if op == 0 {
break
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
}
case Zlitm_r:
for ; ; z++ {
op = int(o.op[z])
if op == 0 {
break
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
}
asmand(ctxt, p, &p.From, &p.To)
case Zmb_r:
bytereg(&p.From, &p.Ft)
fallthrough
/* fall through */
case Zm_r:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.From, &p.To)
case Zm2_r:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(o.op[z+1])
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.From, &p.To)
case Zm_r_xm:
mediaop(ctxt, o, op, int(yt.zoffset), z)
asmand(ctxt, p, &p.From, &p.To)
case Zm_r_xm_nr:
ctxt.Rexflag = 0
mediaop(ctxt, o, op, int(yt.zoffset), z)
asmand(ctxt, p, &p.From, &p.To)
case Zm_r_i_xm:
mediaop(ctxt, o, op, int(yt.zoffset), z)
asmand(ctxt, p, &p.From, &p.From3)
ctxt.Andptr[0] = byte(p.To.Offset)
ctxt.Andptr = ctxt.Andptr[1:]
case Zm_r_3d:
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.From, &p.To)
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
case Zibm_r:
for {
tmp1 := z
z++
op = int(o.op[tmp1])
if op == 0 {
break
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
}
asmand(ctxt, p, &p.From3, &p.To)
ctxt.Andptr[0] = byte(p.From.Offset)
ctxt.Andptr = ctxt.Andptr[1:]
case Zaut_r:
ctxt.Andptr[0] = 0x8d
ctxt.Andptr = ctxt.Andptr[1:] /* leal */
if p.From.Type != obj.TYPE_ADDR {
ctxt.Diag("asmins: Zaut sb type ADDR")
}
p.From.Type = obj.TYPE_MEM
asmand(ctxt, p, &p.From, &p.To)
p.From.Type = obj.TYPE_ADDR
case Zm_o:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.From, int(o.op[z+1]))
case Zr_m:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.To, &p.From)
case Zr_m_xm:
mediaop(ctxt, o, op, int(yt.zoffset), z)
asmand(ctxt, p, &p.To, &p.From)
case Zr_m_xm_nr:
ctxt.Rexflag = 0
mediaop(ctxt, o, op, int(yt.zoffset), z)
asmand(ctxt, p, &p.To, &p.From)
case Zo_m:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.To, int(o.op[z+1]))
case Zcallindreg:
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc)
r.Type = obj.R_CALLIND
r.Siz = 0
fallthrough
case Zo_m64:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmandsz(ctxt, p, &p.To, int(o.op[z+1]), 0, 1)
case Zm_ibo:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.From, int(o.op[z+1]))
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.To, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Zibo_m:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.To, int(o.op[z+1]))
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Zibo_m_xm:
z = mediaop(ctxt, o, op, int(yt.zoffset), z)
asmando(ctxt, p, &p.To, int(o.op[z+1]))
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Z_ib, Zib_:
if yt.zcase == Zib_ {
a = &p.From
} else {
a = &p.To
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(vaddr(ctxt, p, a, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Zib_rp:
ctxt.Rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Zil_rp:
ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
ctxt.Andptr = ctxt.Andptr[1:]
if o.prefix == Pe {
v = vaddr(ctxt, p, &p.From, nil)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 8)
ctxt.Andptr = ctxt.Andptr[1:]
} else {
relput4(ctxt, p, &p.From)
}
case Zo_iw:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
if p.From.Type != obj.TYPE_NONE {
v = vaddr(ctxt, p, &p.From, nil)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 8)
ctxt.Andptr = ctxt.Andptr[1:]
}
case Ziq_rp:
v = vaddr(ctxt, p, &p.From, &rel)
l = int(v >> 32)
if l == 0 && rel.Siz != 8 {
//p->mark |= 0100;
//print("zero: %llux %P\n", v, p);
ctxt.Rexflag &^= (0x40 | Rxw)
ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
ctxt.Andptr[0] = byte(0xb8 + reg[p.To.Reg])
ctxt.Andptr = ctxt.Andptr[1:]
if rel.Type != 0 {
r = obj.Addrel(ctxt.Cursym)
*r = rel
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
}
put4(ctxt, int32(v))
} else if l == -1 && uint64(v)&(uint64(1)<<31) != 0 { /* sign extend */
//p->mark |= 0100;
//print("sign: %llux %P\n", v, p);
ctxt.Andptr[0] = 0xc7
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.To, 0)
put4(ctxt, int32(v)) /* need all 8 */
} else {
//print("all: %llux %P\n", v, p);
ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
ctxt.Andptr = ctxt.Andptr[1:]
if rel.Type != 0 {
r = obj.Addrel(ctxt.Cursym)
*r = rel
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
}
put8(ctxt, v)
}
case Zib_rr:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.To, &p.To)
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Z_il, Zil_:
if yt.zcase == Zil_ {
a = &p.From
} else {
a = &p.To
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
if o.prefix == Pe {
v = vaddr(ctxt, p, a, nil)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 8)
ctxt.Andptr = ctxt.Andptr[1:]
} else {
relput4(ctxt, p, a)
}
case Zm_ilo, Zilo_m:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
if yt.zcase == Zilo_m {
a = &p.From
asmando(ctxt, p, &p.To, int(o.op[z+1]))
} else {
a = &p.To
asmando(ctxt, p, &p.From, int(o.op[z+1]))
}
if o.prefix == Pe {
v = vaddr(ctxt, p, a, nil)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 8)
ctxt.Andptr = ctxt.Andptr[1:]
} else {
relput4(ctxt, p, a)
}
case Zil_rr:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.To, &p.To)
if o.prefix == Pe {
v = vaddr(ctxt, p, &p.From, nil)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 8)
ctxt.Andptr = ctxt.Andptr[1:]
} else {
relput4(ctxt, p, &p.From)
}
case Z_rp:
ctxt.Rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
ctxt.Andptr = ctxt.Andptr[1:]
case Zrp_:
ctxt.Rexflag |= regrex[p.From.Reg] & (Rxb | 0x40)
ctxt.Andptr[0] = byte(op + reg[p.From.Reg])
ctxt.Andptr = ctxt.Andptr[1:]
case Zclr:
ctxt.Rexflag &^= Pw
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.To, &p.To)
case Zcallcon, Zjmpcon:
if yt.zcase == Zcallcon {
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
} else {
ctxt.Andptr[0] = byte(o.op[z+1])
ctxt.Andptr = ctxt.Andptr[1:]
}
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Type = obj.R_PCREL
r.Siz = 4
r.Add = p.To.Offset
put4(ctxt, 0)
case Zcallind:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(o.op[z+1])
ctxt.Andptr = ctxt.Andptr[1:]
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Type = obj.R_ADDR
r.Siz = 4
r.Add = p.To.Offset
r.Sym = p.To.Sym
put4(ctxt, 0)
case Zcall, Zcallduff:
if p.To.Sym == nil {
ctxt.Diag("call without target")
log.Fatalf("bad code")
}
if yt.zcase == Zcallduff && ctxt.Flag_dynlink {
ctxt.Diag("directly calling duff when dynamically linking Go")
}
if obj.Framepointer_enabled != 0 && yt.zcase == Zcallduff && p.Mode == 64 {
// Maintain BP around call, since duffcopy/duffzero can't do it
// (the call jumps into the middle of the function).
// This makes it possible to see call sites for duffcopy/duffzero in
// BP-based profiling tools like Linux perf (which is the
// whole point of obj.Framepointer_enabled).
// MOVQ BP, -16(SP)
// LEAQ -16(SP), BP
copy(ctxt.Andptr, bpduff1)
ctxt.Andptr = ctxt.Andptr[len(bpduff1):]
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Sym = p.To.Sym
r.Add = p.To.Offset
r.Type = obj.R_CALL
r.Siz = 4
put4(ctxt, 0)
if obj.Framepointer_enabled != 0 && yt.zcase == Zcallduff && p.Mode == 64 {
// Pop BP pushed above.
// MOVQ 0(BP), BP
copy(ctxt.Andptr, bpduff2)
ctxt.Andptr = ctxt.Andptr[len(bpduff2):]
}
// TODO: jump across functions needs reloc
case Zbr, Zjmp, Zloop:
if p.To.Sym != nil {
if yt.zcase != Zjmp {
ctxt.Diag("branch to ATEXT")
log.Fatalf("bad code")
}
ctxt.Andptr[0] = byte(o.op[z+1])
ctxt.Andptr = ctxt.Andptr[1:]
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Sym = p.To.Sym
r.Type = obj.R_PCREL
r.Siz = 4
put4(ctxt, 0)
break
}
// Assumes q is in this function.
// TODO: Check in input, preserve in brchain.
// Fill in backward jump now.
q = p.Pcond
if q == nil {
ctxt.Diag("jmp/branch/loop without target")
log.Fatalf("bad code")
}
if p.Back&1 != 0 {
v = q.Pc - (p.Pc + 2)
if v >= -128 {
if p.As == AJCXZL {
ctxt.Andptr[0] = 0x67
ctxt.Andptr = ctxt.Andptr[1:]
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
} else if yt.zcase == Zloop {
ctxt.Diag("loop too far: %v", p)
} else {
v -= 5 - 2
if yt.zcase == Zbr {
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
v--
}
ctxt.Andptr[0] = byte(o.op[z+1])
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 8)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 16)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 24)
ctxt.Andptr = ctxt.Andptr[1:]
}
break
}
// Annotate target; will fill in later.
p.Forwd = q.Comefrom
q.Comefrom = p
if p.Back&2 != 0 { // short
if p.As == AJCXZL {
ctxt.Andptr[0] = 0x67
ctxt.Andptr = ctxt.Andptr[1:]
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0
ctxt.Andptr = ctxt.Andptr[1:]
} else if yt.zcase == Zloop {
ctxt.Diag("loop too far: %v", p)
} else {
if yt.zcase == Zbr {
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
}
ctxt.Andptr[0] = byte(o.op[z+1])
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0
ctxt.Andptr = ctxt.Andptr[1:]
}
break
/*
v = q->pc - p->pc - 2;
if((v >= -128 && v <= 127) || p->pc == -1 || q->pc == -1) {
*ctxt->andptr++ = op;
*ctxt->andptr++ = v;
} else {
v -= 5-2;
if(yt.zcase == 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;
}
*/
case Zbyte:
v = vaddr(ctxt, p, &p.From, &rel)
if rel.Siz != 0 {
rel.Siz = uint8(op)
r = obj.Addrel(ctxt.Cursym)
*r = rel
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
}
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
if op > 1 {
ctxt.Andptr[0] = byte(v >> 8)
ctxt.Andptr = ctxt.Andptr[1:]
if op > 2 {
ctxt.Andptr[0] = byte(v >> 16)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 24)
ctxt.Andptr = ctxt.Andptr[1:]
if op > 4 {
ctxt.Andptr[0] = byte(v >> 32)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 40)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 48)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(v >> 56)
ctxt.Andptr = ctxt.Andptr[1:]
}
}
}
}
return
}
z += int(yt.zoffset) + xo
}
for mo := ymovtab; mo[0].as != 0; mo = mo[1:] {
var pp obj.Prog
var t []byte
if p.As == mo[0].as {
if ycover[ft+int(mo[0].ft)] != 0 && ycover[f3t+int(mo[0].f3t)] != 0 && ycover[tt+int(mo[0].tt)] != 0 {
t = mo[0].op[:]
switch mo[0].code {
default:
ctxt.Diag("asmins: unknown mov %d %v", mo[0].code, p)
case 0: /* lit */
for z = 0; t[z] != E; z++ {
ctxt.Andptr[0] = t[z]
ctxt.Andptr = ctxt.Andptr[1:]
}
case 1: /* r,m */
ctxt.Andptr[0] = t[0]
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.To, int(t[1]))
case 2: /* m,r */
ctxt.Andptr[0] = t[0]
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.From, int(t[1]))
case 3: /* r,m - 2op */
ctxt.Andptr[0] = t[0]
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = t[1]
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.To, int(t[2]))
ctxt.Rexflag |= regrex[p.From.Reg] & (Rxr | 0x40)
case 4: /* m,r - 2op */
ctxt.Andptr[0] = t[0]
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = t[1]
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.From, int(t[2]))
ctxt.Rexflag |= regrex[p.To.Reg] & (Rxr | 0x40)
case 5: /* load full pointer, trash heap */
if t[0] != 0 {
ctxt.Andptr[0] = t[0]
ctxt.Andptr = ctxt.Andptr[1:]
}
switch p.To.Index {
default:
goto bad
case REG_DS:
ctxt.Andptr[0] = 0xc5
ctxt.Andptr = ctxt.Andptr[1:]
case REG_SS:
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xb2
ctxt.Andptr = ctxt.Andptr[1:]
case REG_ES:
ctxt.Andptr[0] = 0xc4
ctxt.Andptr = ctxt.Andptr[1:]
case REG_FS:
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xb4
ctxt.Andptr = ctxt.Andptr[1:]
case REG_GS:
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xb5
ctxt.Andptr = ctxt.Andptr[1:]
}
asmand(ctxt, p, &p.From, &p.To)
case 6: /* double shift */
if t[0] == Pw {
if p.Mode != 64 {
ctxt.Diag("asmins: illegal 64: %v", p)
}
ctxt.Rexflag |= Pw
t = t[1:]
} else if t[0] == Pe {
ctxt.Andptr[0] = Pe
ctxt.Andptr = ctxt.Andptr[1:]
t = t[1:]
}
switch p.From.Type {
default:
goto bad
case obj.TYPE_CONST:
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = t[0]
ctxt.Andptr = ctxt.Andptr[1:]
asmandsz(ctxt, p, &p.To, reg[p.From3.Reg], regrex[p.From3.Reg], 0)
ctxt.Andptr[0] = byte(p.From.Offset)
ctxt.Andptr = ctxt.Andptr[1:]
case obj.TYPE_REG:
switch p.From.Reg {
default:
goto bad
case REG_CL, REG_CX:
ctxt.Andptr[0] = 0x0f
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = t[1]
ctxt.Andptr = ctxt.Andptr[1:]
asmandsz(ctxt, p, &p.To, reg[p.From3.Reg], regrex[p.From3.Reg], 0)
}
}
// 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.
case 7: /* mov tls, r */
if p.Mode == 64 && p.As != AMOVQ || p.Mode == 32 && p.As != AMOVL {
ctxt.Diag("invalid load of TLS: %v", p)
}
if p.Mode == 32 {
// 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:
log.Fatalf("unknown TLS base location for %s", obj.Headstr(ctxt.Headtype))
case obj.Hlinux,
obj.Hnacl:
// ELF TLS base is 0(GS).
pp.From = p.From
pp.From.Type = obj.TYPE_MEM
pp.From.Reg = REG_GS
pp.From.Offset = 0
pp.From.Index = REG_NONE
pp.From.Scale = 0
ctxt.Andptr[0] = 0x65
ctxt.Andptr = ctxt.Andptr[1:] // GS
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, &p.To)
case obj.Hplan9:
if ctxt.Plan9privates == nil {
ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
}
pp.From = obj.Addr{}
pp.From.Type = obj.TYPE_MEM
pp.From.Name = obj.NAME_EXTERN
pp.From.Sym = ctxt.Plan9privates
pp.From.Offset = 0
pp.From.Index = REG_NONE
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, &p.To)
case obj.Hwindows:
// Windows TLS base is always 0x14(FS).
pp.From = p.From
pp.From.Type = obj.TYPE_MEM
pp.From.Reg = REG_FS
pp.From.Offset = 0x14
pp.From.Index = REG_NONE
pp.From.Scale = 0
ctxt.Andptr[0] = 0x64
ctxt.Andptr = ctxt.Andptr[1:] // FS
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, &p.To)
}
break
}
switch ctxt.Headtype {
default:
log.Fatalf("unknown TLS base location for %s", obj.Headstr(ctxt.Headtype))
case obj.Hlinux:
if ctxt.Flag_shared == 0 {
log.Fatalf("unknown TLS base location for linux without -shared")
}
// Note that this is not generating the same insn as the other cases.
// MOV TLS, R_to
// becomes
// movq g@gottpoff(%rip), R_to
// which is encoded as
// movq 0(%rip), R_to
// and a R_TLS_IE reloc. This all assumes the only tls variable we access
// is g, which we can't check here, but will when we assemble the second
// instruction.
ctxt.Rexflag = Pw | (regrex[p.To.Reg] & Rxr)
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(0x05 | (reg[p.To.Reg] << 3))
ctxt.Andptr = ctxt.Andptr[1:]
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Type = obj.R_TLS_IE
r.Siz = 4
r.Add = -4
put4(ctxt, 0)
case obj.Hplan9:
if ctxt.Plan9privates == nil {
ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
}
pp.From = obj.Addr{}
pp.From.Type = obj.TYPE_MEM
pp.From.Name = obj.NAME_EXTERN
pp.From.Sym = ctxt.Plan9privates
pp.From.Offset = 0
pp.From.Index = REG_NONE
ctxt.Rexflag |= Pw
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, &p.To)
case obj.Hsolaris: // TODO(rsc): Delete Hsolaris from list. Should not use this code. See progedit in obj6.c.
// TLS base is 0(FS).
pp.From = p.From
pp.From.Type = obj.TYPE_MEM
pp.From.Name = obj.NAME_NONE
pp.From.Reg = REG_NONE
pp.From.Offset = 0
pp.From.Index = REG_NONE
pp.From.Scale = 0
ctxt.Rexflag |= Pw
ctxt.Andptr[0] = 0x64
ctxt.Andptr = ctxt.Andptr[1:] // FS
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, &p.To)
case obj.Hwindows:
// Windows TLS base is always 0x28(GS).
pp.From = p.From
pp.From.Type = obj.TYPE_MEM
pp.From.Name = obj.NAME_NONE
pp.From.Reg = REG_GS
pp.From.Offset = 0x28
pp.From.Index = REG_NONE
pp.From.Scale = 0
ctxt.Rexflag |= Pw
ctxt.Andptr[0] = 0x65
ctxt.Andptr = ctxt.Andptr[1:] // GS
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, &p.To)
}
}
return
}
}
}
goto bad
bad:
if p.Mode != 64 {
/*
* 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
unbytereg(&pp.From, &pp.Ft)
unbytereg(&pp.To, &pp.Tt)
z := int(p.From.Reg)
if p.From.Type == obj.TYPE_REG && z >= REG_BP && z <= REG_DI {
// TODO(rsc): Use this code for x86-64 too. It has bug fixes not present in the amd64 code base.
// For now, different to keep bit-for-bit compatibility.
if p.Mode == 32 {
breg := byteswapreg(ctxt, &p.To)
if breg != REG_AX {
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lhs,bx */
asmando(ctxt, p, &p.From, reg[breg])
subreg(&pp, z, breg)
doasm(ctxt, &pp)
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lhs,bx */
asmando(ctxt, p, &p.From, reg[breg])
} else {
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lsh,ax */
subreg(&pp, z, REG_AX)
doasm(ctxt, &pp)
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lsh,ax */
}
return
}
if isax(&p.To) || p.To.Type == obj.TYPE_NONE {
// We certainly don't want to exchange
// with AX if the op is MUL or DIV.
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lhs,bx */
asmando(ctxt, p, &p.From, reg[REG_BX])
subreg(&pp, z, REG_BX)
doasm(ctxt, &pp)
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lhs,bx */
asmando(ctxt, p, &p.From, reg[REG_BX])
} else {
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lsh,ax */
subreg(&pp, z, REG_AX)
doasm(ctxt, &pp)
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg lsh,ax */
}
return
}
z = int(p.To.Reg)
if p.To.Type == obj.TYPE_REG && z >= REG_BP && z <= REG_DI {
// TODO(rsc): Use this code for x86-64 too. It has bug fixes not present in the amd64 code base.
// For now, different to keep bit-for-bit compatibility.
if p.Mode == 32 {
breg := byteswapreg(ctxt, &p.From)
if breg != REG_AX {
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rhs,bx */
asmando(ctxt, p, &p.To, reg[breg])
subreg(&pp, z, breg)
doasm(ctxt, &pp)
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rhs,bx */
asmando(ctxt, p, &p.To, reg[breg])
} else {
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rsh,ax */
subreg(&pp, z, REG_AX)
doasm(ctxt, &pp)
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rsh,ax */
}
return
}
if isax(&p.From) {
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rhs,bx */
asmando(ctxt, p, &p.To, reg[REG_BX])
subreg(&pp, z, REG_BX)
doasm(ctxt, &pp)
ctxt.Andptr[0] = 0x87
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rhs,bx */
asmando(ctxt, p, &p.To, reg[REG_BX])
} else {
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rsh,ax */
subreg(&pp, z, REG_AX)
doasm(ctxt, &pp)
ctxt.Andptr[0] = byte(0x90 + reg[z])
ctxt.Andptr = ctxt.Andptr[1:] /* xchg rsh,ax */
}
return
}
}
ctxt.Diag("doasm: notfound ft=%d tt=%d %v %d %d", p.Ft, p.Tt, p, oclass(ctxt, p, &p.From), oclass(ctxt, p, &p.To))
return
}
// byteswapreg returns a byte-addressable register (AX, BX, CX, DX)
// which is not referenced in a.
// If a is empty, it returns BX to account for MULB-like instructions
// that might use DX and AX.
func byteswapreg(ctxt *obj.Link, a *obj.Addr) int {
cand := 1
canc := cand
canb := canc
cana := canb
if a.Type == obj.TYPE_NONE {
cand = 0
cana = cand
}
if a.Type == obj.TYPE_REG || ((a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Name == obj.NAME_NONE) {
switch a.Reg {
case REG_NONE:
cand = 0
cana = cand
case REG_AX, REG_AL, REG_AH:
cana = 0
case REG_BX, REG_BL, REG_BH:
canb = 0
case REG_CX, REG_CL, REG_CH:
canc = 0
case REG_DX, REG_DL, REG_DH:
cand = 0
}
}
if a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR {
switch a.Index {
case REG_AX:
cana = 0
case REG_BX:
canb = 0
case REG_CX:
canc = 0
case REG_DX:
cand = 0
}
}
if cana != 0 {
return REG_AX
}
if canb != 0 {
return REG_BX
}
if canc != 0 {
return REG_CX
}
if cand != 0 {
return REG_DX
}
ctxt.Diag("impossible byte register")
log.Fatalf("bad code")
return 0
}
func isbadbyte(a *obj.Addr) bool {
return a.Type == obj.TYPE_REG && (REG_BP <= a.Reg && a.Reg <= REG_DI || REG_BPB <= a.Reg && a.Reg <= REG_DIB)
}
var naclret = []uint8{
0x5e, // POPL SI
// 0x8b, 0x7d, 0x00, // MOVL (BP), DI - catch return to invalid address, for debugging
0x83,
0xe6,
0xe0, // ANDL $~31, SI
0x4c,
0x01,
0xfe, // ADDQ R15, SI
0xff,
0xe6, // JMP SI
}
var naclret8 = []uint8{
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
}
var naclspfix = []uint8{0x4c, 0x01, 0xfc} // ADDQ R15, SP
var naclbpfix = []uint8{0x4c, 0x01, 0xfd} // ADDQ R15, BP
var naclmovs = []uint8{
0x89,
0xf6, // MOVL SI, SI
0x49,
0x8d,
0x34,
0x37, // LEAQ (R15)(SI*1), SI
0x89,
0xff, // MOVL DI, DI
0x49,
0x8d,
0x3c,
0x3f, // LEAQ (R15)(DI*1), DI
}
var naclstos = []uint8{
0x89,
0xff, // MOVL DI, DI
0x49,
0x8d,
0x3c,
0x3f, // LEAQ (R15)(DI*1), DI
}
func nacltrunc(ctxt *obj.Link, reg int) {
if reg >= REG_R8 {
ctxt.Andptr[0] = 0x45
ctxt.Andptr = ctxt.Andptr[1:]
}
reg = (reg - REG_AX) & 7
ctxt.Andptr[0] = 0x89
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(3<<6 | reg<<3 | reg)
ctxt.Andptr = ctxt.Andptr[1:]
}
func asmins(ctxt *obj.Link, p *obj.Prog) {
ctxt.Andptr = ctxt.And[:]
ctxt.Asmode = int(p.Mode)
if p.As == obj.AUSEFIELD {
r := obj.Addrel(ctxt.Cursym)
r.Off = 0
r.Siz = 0
r.Sym = p.From.Sym
r.Type = obj.R_USEFIELD
return
}
if ctxt.Headtype == obj.Hnacl && p.Mode == 32 {
switch p.As {
case obj.ARET:
copy(ctxt.Andptr, naclret8)
ctxt.Andptr = ctxt.Andptr[len(naclret8):]
return
case obj.ACALL,
obj.AJMP:
if p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_DI {
ctxt.Andptr[0] = 0x83
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(0xe0 | (p.To.Reg - REG_AX))
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xe0
ctxt.Andptr = ctxt.Andptr[1:]
}
case AINT:
ctxt.Andptr[0] = 0xf4
ctxt.Andptr = ctxt.Andptr[1:]
return
}
}
if ctxt.Headtype == obj.Hnacl && p.Mode == 64 {
if p.As == AREP {
ctxt.Rep++
return
}
if p.As == AREPN {
ctxt.Repn++
return
}
if p.As == ALOCK {
ctxt.Lock++
return
}
if p.As != ALEAQ && p.As != ALEAL {
if p.From.Index != obj.TYPE_NONE && p.From.Scale > 0 {
nacltrunc(ctxt, int(p.From.Index))
}
if p.To.Index != obj.TYPE_NONE && p.To.Scale > 0 {
nacltrunc(ctxt, int(p.To.Index))
}
}
switch p.As {
case obj.ARET:
copy(ctxt.Andptr, naclret)
ctxt.Andptr = ctxt.Andptr[len(naclret):]
return
case obj.ACALL,
obj.AJMP:
if p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_DI {
// ANDL $~31, reg
ctxt.Andptr[0] = 0x83
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(0xe0 | (p.To.Reg - REG_AX))
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xe0
ctxt.Andptr = ctxt.Andptr[1:]
// ADDQ R15, reg
ctxt.Andptr[0] = 0x4c
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0x01
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(0xf8 | (p.To.Reg - REG_AX))
ctxt.Andptr = ctxt.Andptr[1:]
}
if p.To.Type == obj.TYPE_REG && REG_R8 <= p.To.Reg && p.To.Reg <= REG_R15 {
// ANDL $~31, reg
ctxt.Andptr[0] = 0x41
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0x83
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(0xe0 | (p.To.Reg - REG_R8))
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xe0
ctxt.Andptr = ctxt.Andptr[1:]
// ADDQ R15, reg
ctxt.Andptr[0] = 0x4d
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0x01
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(0xf8 | (p.To.Reg - REG_R8))
ctxt.Andptr = ctxt.Andptr[1:]
}
case AINT:
ctxt.Andptr[0] = 0xf4
ctxt.Andptr = ctxt.Andptr[1:]
return
case ASCASB,
ASCASW,
ASCASL,
ASCASQ,
ASTOSB,
ASTOSW,
ASTOSL,
ASTOSQ:
copy(ctxt.Andptr, naclstos)
ctxt.Andptr = ctxt.Andptr[len(naclstos):]
case AMOVSB, AMOVSW, AMOVSL, AMOVSQ:
copy(ctxt.Andptr, naclmovs)
ctxt.Andptr = ctxt.Andptr[len(naclmovs):]
}
if ctxt.Rep != 0 {
ctxt.Andptr[0] = 0xf3
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Rep = 0
}
if ctxt.Repn != 0 {
ctxt.Andptr[0] = 0xf2
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Repn = 0
}
if ctxt.Lock != 0 {
ctxt.Andptr[0] = 0xf0
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Lock = 0
}
}
ctxt.Rexflag = 0
and0 := ctxt.Andptr
ctxt.Asmode = int(p.Mode)
doasm(ctxt, p)
if ctxt.Rexflag != 0 {
/*
* as befits the whole approach of the architecture,
* the rex prefix must appear before the first opcode byte
* (and thus after any 66/67/f2/f3/26/2e/3e prefix bytes, but
* before the 0f opcode escape!), or it might be ignored.
* note that the handbook often misleadingly shows 66/f2/f3 in `opcode'.
*/
if p.Mode != 64 {
ctxt.Diag("asmins: illegal in mode %d: %v (%d %d)", p.Mode, p, p.Ft, p.Tt)
}
n := -cap(ctxt.Andptr) + cap(and0)
var c int
var np int
for np = 0; np < n; np++ {
c = int(and0[np])
if c != 0xf2 && c != 0xf3 && (c < 0x64 || c > 0x67) && c != 0x2e && c != 0x3e && c != 0x26 {
break
}
}
copy(and0[np+1:], and0[np:n])
and0[np] = byte(0x40 | ctxt.Rexflag)
ctxt.Andptr = ctxt.Andptr[1:]
}
n := -cap(ctxt.Andptr) + cap(ctxt.And[:])
var r *obj.Reloc
for i := len(ctxt.Cursym.R) - 1; i >= 0; i-- {
r = &ctxt.Cursym.R[i:][0]
if int64(r.Off) < p.Pc {
break
}
if ctxt.Rexflag != 0 {
r.Off++
}
if r.Type == obj.R_PCREL {
// PC-relative addressing is relative to the end of the instruction,
// but the relocations applied by the linker are relative to the end
// of the relocation. Because immediate instruction
// arguments can follow the PC-relative memory reference in the
// instruction encoding, the two may not coincide. In this case,
// adjust addend so that linker can keep relocating relative to the
// end of the relocation.
r.Add -= p.Pc + int64(n) - (int64(r.Off) + int64(r.Siz))
}
}
if p.Mode == 64 && ctxt.Headtype == obj.Hnacl && p.As != ACMPL && p.As != ACMPQ && p.To.Type == obj.TYPE_REG {
switch p.To.Reg {
case REG_SP:
copy(ctxt.Andptr, naclspfix)
ctxt.Andptr = ctxt.Andptr[len(naclspfix):]
case REG_BP:
copy(ctxt.Andptr, naclbpfix)
ctxt.Andptr = ctxt.Andptr[len(naclbpfix):]
}
}
}