gotosocial/vendor/github.com/chenzhuoyu/iasm/x86_64/program.go

package x86_64

import (
    `fmt`
    `math`
    `math/bits`

    `github.com/chenzhuoyu/iasm/expr`
)

type (
    _PseudoType         int
    _InstructionEncoder func(*Program, ...interface{}) *Instruction
)

const (
    _PseudoNop _PseudoType = iota + 1
    _PseudoByte
    _PseudoWord
    _PseudoLong
    _PseudoQuad
    _PseudoData
    _PseudoAlign
)

func (self _PseudoType) String() string {
    switch self {
        case _PseudoNop   : return ".nop"
        case _PseudoByte  : return ".byte"
        case _PseudoWord  : return ".word"
        case _PseudoLong  : return ".long"
        case _PseudoQuad  : return ".quad"
        case _PseudoData  : return ".data"
        case _PseudoAlign : return ".align"
        default           : panic("unreachable")
    }
}

type _Pseudo struct {
    kind _PseudoType
    data []byte
    uint uint64
    expr *expr.Expr
}

func (self *_Pseudo) free() {
    if self.expr != nil {
        self.expr.Free()
    }
}

func (self *_Pseudo) encode(m *[]byte, pc uintptr) int {
    switch self.kind {
        case _PseudoNop   : return 0
        case _PseudoByte  : self.encodeByte(m)      ; return 1
        case _PseudoWord  : self.encodeWord(m)      ; return 2
        case _PseudoLong  : self.encodeLong(m)      ; return 4
        case _PseudoQuad  : self.encodeQuad(m)      ; return 8
        case _PseudoData  : self.encodeData(m)      ; return len(self.data)
        case _PseudoAlign : self.encodeAlign(m, pc) ; return self.alignSize(pc)
        default           : panic("invalid pseudo instruction")
    }
}

func (self *_Pseudo) evalExpr(low int64, high int64) int64 {
    if v, err := self.expr.Evaluate(); err != nil {
        panic(err)
    } else if v < low || v > high {
        panic(fmt.Sprintf("expression out of range [%d, %d]: %d", low, high, v))
    } else {
        return v
    }
}

func (self *_Pseudo) alignSize(pc uintptr) int {
    if !ispow2(self.uint) {
        panic(fmt.Sprintf("aligment should be a power of 2, not %d", self.uint))
    } else {
        return align(int(pc), bits.TrailingZeros64(self.uint)) - int(pc)
    }
}

func (self *_Pseudo) encodeData(m *[]byte) {
    if m != nil {
        *m = append(*m, self.data...)
    }
}

func (self *_Pseudo) encodeByte(m *[]byte) {
    if m != nil {
        append8(m, byte(self.evalExpr(math.MinInt8, math.MaxUint8)))
    }
}

func (self *_Pseudo) encodeWord(m *[]byte) {
    if m != nil {
        append16(m, uint16(self.evalExpr(math.MinInt16, math.MaxUint16)))
    }
}

func (self *_Pseudo) encodeLong(m *[]byte) {
    if m != nil {
        append32(m, uint32(self.evalExpr(math.MinInt32, math.MaxUint32)))
    }
}

func (self *_Pseudo) encodeQuad(m *[]byte) {
    if m != nil {
        if v, err := self.expr.Evaluate(); err != nil {
            panic(err)
        } else {
            append64(m, uint64(v))
        }
    }
}

func (self *_Pseudo) encodeAlign(m *[]byte, pc uintptr) {
    if m != nil {
        if self.expr == nil {
            expandmm(m, self.alignSize(pc), 0)
        } else {
            expandmm(m, self.alignSize(pc), byte(self.evalExpr(math.MinInt8, math.MaxUint8)))
        }
    }
}

// Operands represents a sequence of operand required by an instruction.
type Operands [_N_args]interface{}

// InstructionDomain represents the domain of an instruction.
type InstructionDomain uint8

const (
    DomainGeneric InstructionDomain = iota
    DomainMMXSSE
    DomainAVX
    DomainFMA
    DomainCrypto
    DomainMask
    DomainAMDSpecific
    DomainMisc
    DomainPseudo
)

type (
	_BranchType uint8
)

const (
    _B_none _BranchType = iota
    _B_conditional
    _B_unconditional
)

// Instruction represents an unencoded instruction.
type Instruction struct {
    next   *Instruction
    pc     uintptr
    nb     int
    len    int
    argc   int
    name   string
    argv   Operands
    forms  [_N_forms]_Encoding
    pseudo _Pseudo
    branch _BranchType
    domain InstructionDomain
    prefix []byte
}

func (self *Instruction) add(flags int, encoder func(m *_Encoding, v []interface{})) {
    self.forms[self.len].flags = flags
    self.forms[self.len].encoder = encoder
    self.len++
}

func (self *Instruction) free() {
    self.clear()
    self.pseudo.free()
    freeInstruction(self)
}

func (self *Instruction) clear() {
    for i := 0; i < self.argc; i++ {
        if v, ok := self.argv[i].(Disposable); ok {
            v.Free()
        }
    }
}

func (self *Instruction) check(e *_Encoding) bool {
    if (e.flags & _F_rel1) != 0 {
        return isRel8(self.argv[0])
    } else if (e.flags & _F_rel4) != 0 {
        return isRel32(self.argv[0]) || isLabel(self.argv[0])
    } else {
        return true
    }
}

func (self *Instruction) encode(m *[]byte) int {
    n := math.MaxInt64
    p := (*_Encoding)(nil)

    /* encode prefixes if any */
    if self.nb = len(self.prefix); m != nil {
        *m = append(*m, self.prefix...)
    }

    /* check for pseudo-instructions */
    if self.pseudo.kind != 0 {
        self.nb += self.pseudo.encode(m, self.pc)
        return self.nb
    }

    /* find the shortest encoding */
    for i := 0; i < self.len; i++ {
        if e := &self.forms[i]; self.check(e) {
            if v := e.encode(self.argv[:self.argc]); v < n {
                n = v
                p = e
            }
        }
    }

    /* add to buffer if needed */
    if m != nil {
        *m = append(*m, p.bytes[:n]...)
    }

    /* update the instruction length */
    self.nb += n
    return self.nb
}

/** Instruction Prefixes **/

const (
    _P_cs   = 0x2e
    _P_ds   = 0x3e
    _P_es   = 0x26
    _P_fs   = 0x64
    _P_gs   = 0x65
    _P_ss   = 0x36
    _P_lock = 0xf0
)

// CS overrides the memory operation of this instruction to CS.
func (self *Instruction) CS() *Instruction {
    self.prefix = append(self.prefix, _P_cs)
    return self
}

// DS overrides the memory operation of this instruction to DS,
// this is the default section for most instructions if not specified.
func (self *Instruction) DS() *Instruction {
    self.prefix = append(self.prefix, _P_ds)
    return self
}

// ES overrides the memory operation of this instruction to ES.
func (self *Instruction) ES() *Instruction {
    self.prefix = append(self.prefix, _P_es)
    return self
}

// FS overrides the memory operation of this instruction to FS.
func (self *Instruction) FS() *Instruction {
    self.prefix = append(self.prefix, _P_fs)
    return self
}

// GS overrides the memory operation of this instruction to GS.
func (self *Instruction) GS() *Instruction {
    self.prefix = append(self.prefix, _P_gs)
    return self
}

// SS overrides the memory operation of this instruction to SS.
func (self *Instruction) SS() *Instruction {
    self.prefix = append(self.prefix, _P_ss)
    return self
}

// LOCK causes the processor's LOCK# signal to be asserted during execution of
// the accompanying instruction (turns the instruction into an atomic instruction).
// In a multiprocessor environment, the LOCK# signal insures that the processor
// has exclusive use of any shared memory while the signal is asserted.
func (self *Instruction) LOCK() *Instruction {
    self.prefix = append(self.prefix, _P_lock)
    return self
}

/** Basic Instruction Properties **/

// Name returns the instruction name.
func (self *Instruction) Name() string {
    return self.name
}

// Domain returns the domain of this instruction.
func (self *Instruction) Domain() InstructionDomain {
    return self.domain
}

// Operands returns the operands of this instruction.
func (self *Instruction) Operands() []interface{} {
    return self.argv[:self.argc]
}

// Program represents a sequence of instructions.
type Program struct {
    arch *Arch
    head *Instruction
    tail *Instruction
}

const (
    _N_near       = 2 // near-branch (-128 ~ +127) takes 2 bytes to encode
    _N_far_cond   = 6 // conditional far-branch takes 6 bytes to encode
    _N_far_uncond = 5 // unconditional far-branch takes 5 bytes to encode
)

func (self *Program) clear() {
    for p, q := self.head, self.head; p != nil; p = q {
        q = p.next
        p.free()
    }
}

func (self *Program) alloc(name string, argc int, argv Operands) *Instruction {
    p := self.tail
    q := newInstruction(name, argc, argv)

    /* attach to tail if any */
    if p != nil {
        p.next = q
    } else {
        self.head = q
    }

    /* set the new tail */
    self.tail = q
    return q
}

func (self *Program) pseudo(kind _PseudoType) (p *Instruction) {
    p = self.alloc(kind.String(), 0, Operands{})
    p.domain = DomainPseudo
    p.pseudo.kind = kind
    return
}

func (self *Program) require(isa ISA) {
    if !self.arch.HasISA(isa) {
        panic("ISA '" + isa.String() + "' was not enabled")
    }
}

func (self *Program) branchSize(p *Instruction) int {
    switch p.branch {
        case _B_none          : panic("p is not a branch")
        case _B_conditional   : return _N_far_cond
        case _B_unconditional : return _N_far_uncond
        default               : panic("invalid instruction")
    }
}

/** Pseudo-Instructions **/

// Byte is a pseudo-instruction to add raw byte to the assembled code.
func (self *Program) Byte(v *expr.Expr) (p *Instruction) {
    p = self.pseudo(_PseudoByte)
    p.pseudo.expr = v
    return
}

// Word is a pseudo-instruction to add raw uint16 as little-endian to the assembled code.
func (self *Program) Word(v *expr.Expr) (p *Instruction) {
    p = self.pseudo(_PseudoWord)
    p.pseudo.expr = v
    return
}

// Long is a pseudo-instruction to add raw uint32 as little-endian to the assembled code.
func (self *Program) Long(v *expr.Expr) (p *Instruction) {
    p = self.pseudo(_PseudoLong)
    p.pseudo.expr = v
    return
}

// Quad is a pseudo-instruction to add raw uint64 as little-endian to the assembled code.
func (self *Program) Quad(v *expr.Expr) (p *Instruction) {
    p = self.pseudo(_PseudoQuad)
    p.pseudo.expr = v
    return
}

// Data is a pseudo-instruction to add raw bytes to the assembled code.
func (self *Program) Data(v []byte) (p *Instruction) {
    p = self.pseudo(_PseudoData)
    p.pseudo.data = v
    return
}

// Align is a pseudo-instruction to ensure the PC is aligned to a certain value.
func (self *Program) Align(align uint64, padding *expr.Expr) (p *Instruction) {
    p = self.pseudo(_PseudoAlign)
    p.pseudo.uint = align
    p.pseudo.expr = padding
    return
}

/** Program Assembler **/

// Free returns the Program object into pool.
// Any operation performed after Free is undefined behavior.
//
// NOTE: This also frees all the instructions, labels, memory
//       operands and expressions associated with this program.
//
func (self *Program) Free() {
    self.clear()
    freeProgram(self)
}

// Link pins a label at the current position.
func (self *Program) Link(p *Label) {
    if p.Dest != nil {
        panic("lable was alreay linked")
    } else {
        p.Dest = self.pseudo(_PseudoNop)
    }
}

// Assemble assembles and links the entire program into machine code.
func (self *Program) Assemble(pc uintptr) (ret []byte) {
    orig := pc
    next := true
    offs := uintptr(0)

    /* Pass 0: PC-precompute, assume all labeled branches are far-branches. */
    for p := self.head; p != nil; p = p.next {
        if p.pc = pc; !isLabel(p.argv[0]) || p.branch == _B_none {
            pc += uintptr(p.encode(nil))
        } else {
            pc += uintptr(self.branchSize(p))
        }
    }

    /* allocate space for the machine code */
    nb := int(pc - orig)
    ret = make([]byte, 0, nb)

    /* Pass 1: adjust all the jumps */
    for next {
        next = false
        offs = uintptr(0)

        /* scan all the branches */
        for p := self.head; p != nil; p = p.next {
            var ok bool
            var lb *Label

            /* re-calculate the alignment here */
            if nb = p.nb; p.pseudo.kind == _PseudoAlign {
                p.pc -= offs
                offs += uintptr(nb - p.encode(nil))
                continue
            }

            /* adjust the program counter */
            p.pc -= offs
            lb, ok = p.argv[0].(*Label)

            /* only care about labeled far-branches */
            if !ok || p.nb == _N_near || p.branch == _B_none {
                continue
            }

            /* calculate the jump offset */
            size := self.branchSize(p)
            diff := lb.offset(p.pc, size)

            /* too far to be a near jump */
            if diff > 127 || diff < -128 {
                p.nb = size
                continue
            }

            /* a far jump becomes a near jump, calculate
             * the PC adjustment value and assemble again */
            next = true
            p.nb = _N_near
            offs += uintptr(size - _N_near)
        }
    }

    /* Pass 3: link all the cross-references */
    for p := self.head; p != nil; p = p.next {
        for i := 0; i < p.argc; i++ {
            var ok bool
            var lb *Label
            var op *MemoryOperand

            /* resolve labels */
            if lb, ok = p.argv[i].(*Label); ok {
                p.argv[i] = lb.offset(p.pc, p.nb)
                continue
            }

            /* check for memory operands */
            if op, ok = p.argv[i].(*MemoryOperand); !ok {
                continue
            }

            /* check for label references */
            if op.Addr.Type != Reference {
                continue
            }

            /* replace the label with the real offset */
            op.Addr.Type = Offset
            op.Addr.Offset = op.Addr.Reference.offset(p.pc, p.nb)
        }
    }

    /* Pass 4: actually encode all the instructions */
    for p := self.head; p != nil; p = p.next {
        p.encode(&ret)
    }

    /* all done */
    return ret
}

// AssembleAndFree is like Assemble, but it frees the Program after assembling.
func (self *Program) AssembleAndFree(pc uintptr) (ret []byte) {
    ret = self.Assemble(pc)
    self.Free()
    return
}