wishpal_ironfan
/
service
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
service/vendor/github.com/cloudwego/iasm/x86_64/assembler.go

1820 lines
49 KiB
Go
Raw Blame History

//
// Copyright 2024 CloudWeGo Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package x86_64
import (
`bytes`
`errors`
`fmt`
`math`
`strconv`
`strings`
`unicode`
`github.com/cloudwego/iasm/expr`
)
type (
_TokenKind int
_Punctuation int
)
const (
_T_end _TokenKind = iota + 1
_T_int
_T_name
_T_punc
_T_space
)
const (
_P_plus _Punctuation = iota + 1
_P_minus
_P_star
_P_slash
_P_percent
_P_amp
_P_bar
_P_caret
_P_shl
_P_shr
_P_tilde
_P_lbrk
_P_rbrk
_P_dot
_P_comma
_P_colon
_P_dollar
_P_hash
)
var _PUNC_NAME = map[_Punctuation]string {
_P_plus : "+",
_P_minus : "-",
_P_star : "*",
_P_slash : "/",
_P_percent : "%",
_P_amp : "&",
_P_bar : "|",
_P_caret : "^",
_P_shl : "<<",
_P_shr : ">>",
_P_tilde : "~",
_P_lbrk : "(",
_P_rbrk : ")",
_P_dot : ".",
_P_comma : ",",
_P_colon : ":",
_P_dollar : "$",
_P_hash : "#",
}
func (self _Punctuation) String() string {
if v, ok := _PUNC_NAME[self]; ok {
return v
} else {
return fmt.Sprintf("_Punctuation(%d)", self)
}
}
type _Token struct {
pos int
end int
u64 uint64
str string
tag _TokenKind
}
func (self *_Token) punc() _Punctuation {
return _Punctuation(self.u64)
}
func (self *_Token) String() string {
switch self.tag {
case _T_end : return "<END>"
case _T_int : return fmt.Sprintf("<INT %d>", self.u64)
case _T_punc : return fmt.Sprintf("<PUNC %s>", _Punctuation(self.u64))
case _T_name : return fmt.Sprintf("<NAME %s>", strconv.QuoteToASCII(self.str))
case _T_space : return "<SPACE>"
default : return fmt.Sprintf("<UNK:%d %d %s>", self.tag, self.u64, strconv.QuoteToASCII(self.str))
}
}
func tokenEnd(p int, end int) _Token {
return _Token {
pos: p,
end: end,
tag: _T_end,
}
}
func tokenInt(p int, val uint64) _Token {
return _Token {
pos: p,
u64: val,
tag: _T_int,
}
}
func tokenName(p int, name string) _Token {
return _Token {
pos: p,
str: name,
tag: _T_name,
}
}
func tokenPunc(p int, punc _Punctuation) _Token {
return _Token {
pos: p,
tag: _T_punc,
u64: uint64(punc),
}
}
func tokenSpace(p int, end int) _Token {
return _Token {
pos: p,
end: end,
tag: _T_space,
}
}
// SyntaxError represents an error in the assembly syntax.
type SyntaxError struct {
Pos int
Row int
Src []rune
Reason string
}
// Error implements the error interface.
func (self *SyntaxError) Error() string {
if self.Pos < 0 {
return fmt.Sprintf("%s at line %d", self.Reason, self.Row)
} else {
return fmt.Sprintf("%s at %d:%d", self.Reason, self.Row, self.Pos + 1)
}
}
type _Tokenizer struct {
pos int
row int
src []rune
}
func (self *_Tokenizer) ch() rune {
return self.src[self.pos]
}
func (self *_Tokenizer) eof() bool {
return self.pos >= len(self.src)
}
func (self *_Tokenizer) rch() (ret rune) {
ret, self.pos = self.src[self.pos], self.pos + 1
return
}
func (self *_Tokenizer) err(pos int, msg string) *SyntaxError {
return &SyntaxError {
Pos : pos,
Row : self.row,
Src : self.src,
Reason : msg,
}
}
type _TrimState int
const (
_TS_normal _TrimState = iota
_TS_slcomm
_TS_hscomm
_TS_string
_TS_escape
_TS_accept
_TS_nolast
)
func (self *_Tokenizer) init(src string) {
var i int
var ch rune
var st _TrimState
/* set the source */
self.pos = 0
self.src = []rune(src)
/* remove commends, including "//" and "##" */
loop: for i, ch = range self.src {
switch {
case st == _TS_normal && ch == '/' : st = _TS_slcomm
case st == _TS_normal && ch == '"' : st = _TS_string
case st == _TS_normal && ch == ';' : st = _TS_accept; break loop
case st == _TS_normal && ch == '#' : st = _TS_hscomm
case st == _TS_slcomm && ch == '/' : st = _TS_nolast; break loop
case st == _TS_slcomm : st = _TS_normal
case st == _TS_hscomm && ch == '#' : st = _TS_nolast; break loop
case st == _TS_hscomm : st = _TS_normal
case st == _TS_string && ch == '"' : st = _TS_normal
case st == _TS_string && ch == '\\' : st = _TS_escape
case st == _TS_escape : st = _TS_string
}
}
/* check for errors */
switch st {
case _TS_accept: self.src = self.src[:i]
case _TS_nolast: self.src = self.src[:i - 1]
case _TS_string: panic(self.err(i, "string is not terminated"))
case _TS_escape: panic(self.err(i, "escape sequence is not terminated"))
}
}
func (self *_Tokenizer) skip(check func(v rune) bool) {
for !self.eof() && check(self.ch()) {
self.pos++
}
}
func (self *_Tokenizer) find(pos int, check func(v rune) bool) string {
self.skip(check)
return string(self.src[pos:self.pos])
}
func (self *_Tokenizer) chrv(p int) _Token {
var err error
var val uint64
/* starting and ending position */
p0 := p + 1
p1 := p0 + 1
/* find the end of the literal */
for p1 < len(self.src) && self.src[p1] != '\'' {
if p1++; self.src[p1 - 1] == '\\' {
p1++
}
}
/* empty literal */
if p1 == p0 {
panic(self.err(p1, "empty character constant"))
}
/* check for EOF */
if p1 == len(self.src) {
panic(self.err(p1, "unexpected EOF when scanning literals"))
}
/* parse the literal */
if val, err = literal64(string(self.src[p0:p1])); err != nil {
panic(self.err(p0, "cannot parse literal: " + err.Error()))
}
/* skip the closing '\'' */
self.pos = p1 + 1
return tokenInt(p, val)
}
func (self *_Tokenizer) numv(p int) _Token {
if val, err := strconv.ParseUint(self.find(p, isnumber), 0, 64); err != nil {
panic(self.err(p, "invalid immediate value: " + err.Error()))
} else {
return tokenInt(p, val)
}
}
func (self *_Tokenizer) defv(p int, cc rune) _Token {
if isdigit(cc) {
return self.numv(p)
} else if isident0(cc) {
return tokenName(p, self.find(p, isident))
} else {
panic(self.err(p, "invalid char: " + strconv.QuoteRune(cc)))
}
}
func (self *_Tokenizer) rep2(p int, pp _Punctuation, cc rune) _Token {
if self.eof() {
panic(self.err(self.pos, "unexpected EOF when scanning operators"))
} else if c := self.rch(); c != cc {
panic(self.err(p + 1, strconv.QuoteRune(cc) + " expected, got " + strconv.QuoteRune(c)))
} else {
return tokenPunc(p, pp)
}
}
func (self *_Tokenizer) read() _Token {
var p int
var c rune
var t _Token
/* check for EOF */
if self.eof() {
return tokenEnd(self.pos, self.pos)
}
/* skip spaces as needed */
if p = self.pos; unicode.IsSpace(self.src[p]) {
self.skip(unicode.IsSpace)
return tokenSpace(p, self.pos)
}
/* check for line comments */
if p = self.pos; p < len(self.src) - 1 && self.src[p] == '/' && self.src[p + 1] == '/' {
self.pos = len(self.src)
return tokenEnd(p, self.pos)
}
/* read the next character */
p = self.pos
c = self.rch()
/* parse the next character */
switch c {
case '+' : t = tokenPunc(p, _P_plus)
case '-' : t = tokenPunc(p, _P_minus)
case '*' : t = tokenPunc(p, _P_star)
case '/' : t = tokenPunc(p, _P_slash)
case '%' : t = tokenPunc(p, _P_percent)
case '&' : t = tokenPunc(p, _P_amp)
case '|' : t = tokenPunc(p, _P_bar)
case '^' : t = tokenPunc(p, _P_caret)
case '<' : t = self.rep2(p, _P_shl, '<')
case '>' : t = self.rep2(p, _P_shr, '>')
case '~' : t = tokenPunc(p, _P_tilde)
case '(' : t = tokenPunc(p, _P_lbrk)
case ')' : t = tokenPunc(p, _P_rbrk)
case '.' : t = tokenPunc(p, _P_dot)
case ',' : t = tokenPunc(p, _P_comma)
case ':' : t = tokenPunc(p, _P_colon)
case '$' : t = tokenPunc(p, _P_dollar)
case '#' : t = tokenPunc(p, _P_hash)
case '\'' : t = self.chrv(p)
default : t = self.defv(p, c)
}
/* mark the end of token */
t.end = self.pos
return t
}
func (self *_Tokenizer) next() (tk _Token) {
for {
if tk = self.read(); tk.tag != _T_space {
return
}
}
}
// LabelKind indicates the type of label reference.
type LabelKind int
// OperandKind indicates the type of the operand.
type OperandKind int
// InstructionPrefix indicates the prefix bytes prepended to the instruction.
type InstructionPrefix byte
const (
// OpImm means the operand is an immediate value.
OpImm OperandKind = 1 << iota
// OpReg means the operand is a register.
OpReg
// OpMem means the operand is a memory address.
OpMem
// OpLabel means the operand is a label, specifically for
// branch instructions.
OpLabel
)
const (
// Declaration means the label is a declaration.
Declaration LabelKind = iota + 1
// BranchTarget means the label should be treated as a branch target.
BranchTarget
// RelativeAddress means the label should be treated as a reference to
// the code section (e.g. RIP-relative addressing).
RelativeAddress
)
const (
// PrefixLock 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.
PrefixLock InstructionPrefix = iota
// PrefixSegmentCS overrides the memory operation of this instruction to CS (Code Segment).
PrefixSegmentCS
// PrefixSegmentDS overrides the memory operation of this instruction to DS (Data Segment),
// this is the default section for most instructions if not specified.
PrefixSegmentDS
// PrefixSegmentES overrides the memory operation of this instruction to ES (Extra Segment).
PrefixSegmentES
// PrefixSegmentFS overrides the memory operation of this instruction to FS.
PrefixSegmentFS
// PrefixSegmentGS overrides the memory operation of this instruction to GS.
PrefixSegmentGS
// PrefixSegmentSS overrides the memory operation of this instruction to SS (Stack Segment).
PrefixSegmentSS
)
// ParsedLabel represents a label in the source, either a jump target or
// an RIP-relative addressing.
type ParsedLabel struct {
Name string
Kind LabelKind
}
// ParsedOperand represents an operand of an instruction in the source.
type ParsedOperand struct {
Op OperandKind
Imm int64
Reg Register
Label ParsedLabel
Memory MemoryAddress
}
// ParsedInstruction represents an instruction in the source.
type ParsedInstruction struct {
Mnemonic string
Operands []ParsedOperand
Prefixes []InstructionPrefix
}
func (self *ParsedInstruction) imm(v int64) {
self.Operands = append(self.Operands, ParsedOperand {
Op : OpImm,
Imm : v,
})
}
func (self *ParsedInstruction) reg(v Register) {
self.Operands = append(self.Operands, ParsedOperand {
Op : OpReg,
Reg : v,
})
}
func (self *ParsedInstruction) mem(v MemoryAddress) {
self.Operands = append(self.Operands, ParsedOperand {
Op : OpMem,
Memory : v,
})
}
func (self *ParsedInstruction) target(v string) {
self.Operands = append(self.Operands, ParsedOperand {
Op : OpLabel,
Label : ParsedLabel {
Name: v,
Kind: BranchTarget,
},
})
}
func (self *ParsedInstruction) reference(v string) {
self.Operands = append(self.Operands, ParsedOperand {
Op : OpLabel,
Label : ParsedLabel {
Name: v,
Kind: RelativeAddress,
},
})
}
// LineKind indicates the type of ParsedLine.
type LineKind int
const (
// LineLabel means the ParsedLine is a label.
LineLabel LineKind = iota + 1
// LineInstr means the ParsedLine is an instruction.
LineInstr
// LineCommand means the ParsedLine is a ParsedCommand.
LineCommand
)
// ParsedLine represents a parsed source line.
type ParsedLine struct {
Row int
Src []rune
Kind LineKind
Label ParsedLabel
Command ParsedCommand
Instruction ParsedInstruction
}
// ParsedCommand represents a parsed assembly directive command.
type ParsedCommand struct {
Cmd string
Args []ParsedCommandArg
}
// ParsedCommandArg represents an argument of a ParsedCommand.
type ParsedCommandArg struct {
Value string
IsString bool
}
// Parser parses the source, and generates a sequence of ParsedInstruction's.
type Parser struct {
lex _Tokenizer
exp expr.Parser
}
const (
rip Register64 = 0xff
)
var _RegBranch = map[string]bool {
"jmp" : true,
"jmpq" : true,
"call" : true,
"callq" : true,
}
var _SegPrefix = map[string]InstructionPrefix {
"cs": PrefixSegmentCS,
"ds": PrefixSegmentDS,
"es": PrefixSegmentES,
"fs": PrefixSegmentFS,
"gs": PrefixSegmentGS,
"ss": PrefixSegmentSS,
}
func (self *Parser) i32(tk _Token, v int64) int32 {
if v >= math.MinInt32 && v <= math.MaxUint32 {
return int32(v)
} else {
panic(self.err(tk.pos, fmt.Sprintf("32-bit integer out ouf range: %d", v)))
}
}
func (self *Parser) err(pos int, msg string) *SyntaxError {
return &SyntaxError {
Pos : pos,
Row : self.lex.row,
Src : self.lex.src,
Reason : msg,
}
}
func (self *Parser) negv() int64 {
tk := self.lex.read()
tt := tk.tag
/* must be an integer */
if tt != _T_int {
panic(self.err(tk.pos, "integer expected after '-'"))
} else {
return -int64(tk.u64)
}
}
func (self *Parser) eval(p int) (r int64) {
var e error
var v *expr.Expr
/* searching start */
n := 1
q := p + 1
/* find the end of expression */
for n > 0 && q < len(self.lex.src) {
switch self.lex.src[q] {
case '(' : q++; n++
case ')' : q++; n--
default : q++
}
}
/* check for EOF */
if n != 0 {
panic(self.err(q, "unexpected EOF when parsing expressions"))
}
/* evaluate the expression */
if v, e = self.exp.SetSource(string(self.lex.src[p:q - 1])).Parse(nil); e != nil {
panic(self.err(p, "cannot evaluate expression: " + e.Error()))
}
/* evaluate the expression */
if r, e = v.Evaluate(); e != nil {
panic(self.err(p, "cannot evaluate expression: " + e.Error()))
}
/* skip the last ')' */
v.Free()
self.lex.pos = q
return
}
func (self *Parser) relx(tk _Token) {
if tk.tag != _T_punc || tk.punc() != _P_lbrk {
panic(self.err(tk.pos, "'(' expected for RIP-relative addressing"))
} else if tk = self.lex.next(); self.regx(tk) != rip {
panic(self.err(tk.pos, "RIP-relative addressing expects %rip as the base register"))
} else if tk = self.lex.next(); tk.tag != _T_punc || tk.punc() != _P_rbrk {
panic(self.err(tk.pos, "RIP-relative addressing does not support indexing or scaling"))
}
}
func (self *Parser) immx(tk _Token) int64 {
if tk.tag != _T_punc || tk.punc() != _P_dollar {
panic(self.err(tk.pos, "'$' expected for registers"))
} else if tk = self.lex.read(); tk.tag == _T_int {
return int64(tk.u64)
} else if tk.tag == _T_punc && tk.punc() == _P_lbrk {
return self.eval(self.lex.pos)
} else if tk.tag == _T_punc && tk.punc() == _P_minus {
return self.negv()
} else {
panic(self.err(tk.pos, "immediate value expected"))
}
}
func (self *Parser) regx(tk _Token) Register {
if tk.tag != _T_punc || tk.punc() != _P_percent {
panic(self.err(tk.pos, "'%' expected for registers"))
} else if tk = self.lex.read(); tk.tag != _T_name {
panic(self.err(tk.pos, "register name expected"))
} else if tk.str == "rip" {
return rip
} else if reg, ok := Registers[tk.str]; ok {
return reg
} else {
panic(self.err(tk.pos, "invalid register name: " + strconv.Quote(tk.str)))
}
}
func (self *Parser) regv(tk _Token) Register {
if reg := self.regx(tk); reg == rip {
panic(self.err(tk.pos, "%rip is not accessable as a dedicated register"))
} else {
return reg
}
}
func (self *Parser) disp(vv int32) MemoryAddress {
switch tk := self.lex.next(); tk.tag {
case _T_end : return MemoryAddress { Displacement: vv }
case _T_punc : return self.relm(tk, vv)
default : panic(self.err(tk.pos, "',' or '(' expected"))
}
}
func (self *Parser) relm(tv _Token, disp int32) MemoryAddress {
var tk _Token
var tt _TokenKind
/* check for absolute addressing */
if tv.punc() == _P_comma {
self.lex.pos--
return MemoryAddress { Displacement: disp }
}
/* must be '(' now */
if tv.punc() != _P_lbrk {
panic(self.err(tv.pos, "',' or '(' expected"))
}
/* read the next token */
tk = self.lex.next()
tt = tk.tag
/* must be a punctuation */
if tt != _T_punc {
panic(self.err(tk.pos, "'%' or ',' expected"))
}
/* check for base */
switch tk.punc() {
case _P_percent : return self.base(tk, disp)
case _P_comma : return self.index(nil, disp)
default : panic(self.err(tk.pos, "'%' or ',' expected"))
}
}
func (self *Parser) base(tk _Token, disp int32) MemoryAddress {
rr := self.regx(tk)
nk := self.lex.next()
/* check for register indirection or base-index addressing */
if !isReg64(rr) {
panic(self.err(tk.pos, "not a valid base register"))
} else if nk.tag != _T_punc {
panic(self.err(nk.pos, "',' or ')' expected"))
} else if nk.punc() == _P_comma {
return self.index(rr, disp)
} else if nk.punc() == _P_rbrk {
return MemoryAddress { Base: rr, Displacement: disp }
} else {
panic(self.err(nk.pos, "',' or ')' expected"))
}
}
func (self *Parser) index(base Register, disp int32) MemoryAddress {
tk := self.lex.next()
rr := self.regx(tk)
nk := self.lex.next()
/* check for scaled indexing */
if base == rip {
panic(self.err(tk.pos, "RIP-relative addressing does not support indexing or scaling"))
} else if !isIndexable(rr) {
panic(self.err(tk.pos, "not a valid index register"))
} else if nk.tag != _T_punc {
panic(self.err(nk.pos, "',' or ')' expected"))
} else if nk.punc() == _P_comma {
return self.scale(base, rr, disp)
} else if nk.punc() == _P_rbrk {
return MemoryAddress { Base: base, Index: rr, Scale: 1, Displacement: disp }
} else {
panic(self.err(nk.pos, "',' or ')' expected"))
}
}
func (self *Parser) scale(base Register, index Register, disp int32) MemoryAddress {
tk := self.lex.next()
tt := tk.tag
tv := tk.u64
/* must be an integer */
if tt != _T_int {
panic(self.err(tk.pos, "integer expected"))
}
/* scale can only be 1, 2, 4 or 8 */
if tv == 0 || (_Scales & (1 << tv)) == 0 {
panic(self.err(tk.pos, "scale can only be 1, 2, 4 or 8"))
}
/* read next token */
tk = self.lex.next()
tt = tk.tag
/* check for the closing ')' */
if tt != _T_punc || tk.punc() != _P_rbrk {
panic(self.err(tk.pos, "')' expected"))
}
/* construct the memory address */
return MemoryAddress {
Base : base,
Index : index,
Scale : uint8(tv),
Displacement : disp,
}
}
func (self *Parser) cmds() *ParsedLine {
cmd := ""
pos := self.lex.pos
buf := []ParsedCommandArg(nil)
/* find the end of command */
for p := pos; pos < len(self.lex.src); pos++ {
if unicode.IsSpace(self.lex.src[pos]) {
cmd = string(self.lex.src[p:pos])
break
}
}
/* parse the arguments */
loop: for {
switch self.next(&pos) {
case 0 : break loop
case '#' : break loop
case '"' : pos = self.strings(&buf, pos)
default : pos = self.expressions(&buf, pos)
}
}
/* construct the line */
return &ParsedLine {
Row : self.lex.row,
Src : self.lex.src,
Kind : LineCommand,
Command : ParsedCommand {
Cmd : cmd,
Args : buf,
},
}
}
func (self *Parser) feed(line string) *ParsedLine {
ff := true
rr := false
lk := false
/* reset the lexer */
self.lex.row++
self.lex.init(line)
/* parse the first token */
tk := self.lex.next()
tt := tk.tag
/* it is a directive if it starts with a dot */
if tk.tag == _T_punc && tk.punc() == _P_dot {
return self.cmds()
}
/* otherwise it could be labels or instructions */
if tt != _T_name {
panic(self.err(tk.pos, "identifier expected"))
}
/* peek the next token */
lex := self.lex
tkx := lex.next()
/* check for labels */
if tkx.tag == _T_punc && tkx.punc() == _P_colon {
tkx = lex.next()
ttx := tkx.tag
/* the line must end here */
if ttx != _T_end {
panic(self.err(tkx.pos, "garbage after label definition"))
}
/* construct the label */
return &ParsedLine {
Row : self.lex.row,
Src : self.lex.src,
Kind : LineLabel,
Label : ParsedLabel {
Kind: Declaration,
Name: tk.str,
},
}
}
/* special case for the "lock" prefix */
if tk.tag == _T_name && strings.ToLower(tk.str) == "lock" {
lk = true
tk = self.lex.next()
/* must be an instruction */
if tk.tag != _T_name {
panic(self.err(tk.pos, "identifier expected"))
}
}
/* set the line kind and mnemonic */
ret := &ParsedLine {
Row : self.lex.row,
Src : self.lex.src,
Kind : LineInstr,
Instruction : ParsedInstruction { Mnemonic: strings.ToLower(tk.str) },
}
/* check for LOCK prefix */
if lk {
ret.Instruction.Prefixes = append(ret.Instruction.Prefixes, PrefixLock)
}
/* parse all the operands */
for {
tk = self.lex.next()
tt = tk.tag
/* check for end of line */
if tt == _T_end {
break
}
/* expect a comma if not the first operand */
if !ff {
if tt == _T_punc && tk.punc() == _P_comma {
tk = self.lex.next()
} else {
panic(self.err(tk.pos, "',' expected"))
}
}
/* not the first operand anymore */
ff = false
tt = tk.tag
/* encountered an integer, must be a SIB memory address */
if tt == _T_int {
ret.Instruction.mem(self.disp(self.i32(tk, int64(tk.u64))))
continue
}
/* encountered an identifier, maybe an expression or a jump target, or a segment override prefix */
if tt == _T_name {
ts := tk.str
tp := self.lex.pos
/* if the next token is EOF or a comma, it's a jumpt target */
if tk = self.lex.next(); tk.tag == _T_end || (tk.tag == _T_punc && tk.punc() == _P_comma) {
self.lex.pos = tp
ret.Instruction.target(ts)
continue
}
/* if it is a colon, it's a segment override prefix, otherwise it must be an RIP-relative addressing operand */
if tk.tag != _T_punc || tk.punc() != _P_colon {
self.relx(tk)
ret.Instruction.reference(ts)
continue
}
/* lookup segment prefixes */
if p, ok := _SegPrefix[strings.ToLower(ts)]; !ok {
panic(self.err(tk.pos, "invalid segment name"))
} else {
ret.Instruction.Prefixes = append(ret.Instruction.Prefixes, p)
}
/* read the next token */
tk = self.lex.next()
tt = tk.tag
/* encountered an integer, must be a SIB memory address */
if tt == _T_int {
ret.Instruction.mem(self.disp(self.i32(tk, int64(tk.u64))))
continue
}
}
/* certain instructions may have a "*" before operands */
if tt == _T_punc && tk.punc() == _P_star {
tk = self.lex.next()
tt = tk.tag
rr = true
}
/* ... otherwise it must be a punctuation */
if tt != _T_punc {
panic(self.err(tk.pos, "'$', '%', '-' or '(' expected"))
}
/* check the operator */
switch tk.punc() {
case _P_lbrk : break
case _P_minus : ret.Instruction.mem(self.disp(self.i32(tk, self.negv()))) ; continue
case _P_dollar : ret.Instruction.imm(self.immx(tk)) ; continue
case _P_percent : ret.Instruction.reg(self.regv(tk)) ; continue
default : panic(self.err(tk.pos, "'$', '%', '-' or '(' expected"))
}
/* special case of '(', might be either `(expr)(SIB)` or just `(SIB)`
* read one more token to confirm */
tk = self.lex.next()
tt = tk.tag
/* the next token is '%', it's a memory address,
* or ',' if it's a memory address without base,
* otherwise it must be in `(expr)(SIB)` form */
if tk.tag == _T_punc && tk.punc() == _P_percent {
ret.Instruction.mem(self.base(tk, 0))
} else if tk.tag == _T_punc && tk.punc() == _P_comma {
ret.Instruction.mem(self.index(nil, 0))
} else {
ret.Instruction.mem(self.disp(self.i32(tk, self.eval(tk.pos))))
}
}
/* check "jmp" and "call" instructions */
if !_RegBranch[ret.Instruction.Mnemonic] {
return ret
} else if len(ret.Instruction.Operands) != 1 {
panic(self.err(tk.pos, fmt.Sprintf(`"%s" requires exact 1 argument`, ret.Instruction.Mnemonic)))
} else if !rr && ret.Instruction.Operands[0].Op != OpReg && ret.Instruction.Operands[0].Op != OpLabel {
panic(self.err(tk.pos, fmt.Sprintf(`invalid operand for "%s" instruction`, ret.Instruction.Mnemonic)))
} else {
return ret
}
}
func (self *Parser) next(p *int) rune {
for {
if *p >= len(self.lex.src) {
return 0
} else if cc := self.lex.src[*p]; !unicode.IsSpace(cc) {
return cc
} else {
*p++
}
}
}
func (self *Parser) delim(p int) int {
if cc := self.next(&p); cc == 0 {
return p
} else if cc == ',' {
return p + 1
} else {
panic(self.err(p, "',' expected"))
}
}
func (self *Parser) strings(argv *[]ParsedCommandArg, p int) int {
var i int
var e error
var v string
/* find the end of string */
for i = p + 1; i < len(self.lex.src) && self.lex.src[i] != '"'; i++ {
if self.lex.src[i] == '\\' {
i++
}
}
/* check for EOF */
if i == len(self.lex.src) {
panic(self.err(i, "unexpected EOF when scanning strings"))
}
/* unquote the string */
if v, e = strconv.Unquote(string(self.lex.src[p:i + 1])); e != nil {
panic(self.err(p, "invalid string: " + e.Error()))
}
/* add the argument to buffer */
*argv = append(*argv, ParsedCommandArg { Value: v, IsString: true })
return self.delim(i + 1)
}
func (self *Parser) directives(line string) {
self.lex.row++
self.lex.init(line)
/* parse the first token */
tk := self.lex.next()
tt := tk.tag
/* check for EOF */
if tt == _T_end {
return
}
/* must be a directive */
if tt != _T_punc || tk.punc() != _P_hash {
panic(self.err(tk.pos, "'#' expected"))
}
/* parse the line number */
tk = self.lex.next()
tt = tk.tag
/* must be a line number, if it is, set the row number, and ignore the rest of the line */
if tt != _T_int {
panic(self.err(tk.pos, "line number expected"))
} else {
self.lex.row = int(tk.u64) - 1
}
}
func (self *Parser) expressions(argv *[]ParsedCommandArg, p int) int {
var i int
var n int
var s int
/* scan until the first standalone ',' or EOF */
loop: for i = p; i < len(self.lex.src); i++ {
switch self.lex.src[i] {
case ',' : if s == 0 { if n == 0 { break loop } }
case ']', '}', '>' : if s == 0 { if n == 0 { break loop } else { n-- } }
case '[', '{', '<' : if s == 0 { n++ }
case '\\' : if s != 0 { i++ }
case '\'' : if s != 2 { s ^= 1 }
case '"' : if s != 1 { s ^= 2 }
}
}
/* check for EOF in strings */
if s != 0 {
panic(self.err(i, "unexpected EOF when scanning strings"))
}
/* check for bracket matching */
if n != 0 {
panic(self.err(i, "unbalanced '{' or '[' or '<'"))
}
/* add the argument to buffer */
*argv = append(*argv, ParsedCommandArg { Value: string(self.lex.src[p:i]) })
return self.delim(i)
}
// Feed feeds the parser with one more line, and the parser
// parses it into a ParsedLine.
//
// NOTE: Feed does not handle empty lines or multiple lines,
// it panics when this happens. Use Parse to parse multiple
// lines of assembly source.
//
func (self *Parser) Feed(src string) (ret *ParsedLine, err error) {
var ok bool
var ss string
var vv interface{}
/* check for multiple lines */
if strings.ContainsRune(src, '\n') {
return nil, errors.New("passing multiple lines to Feed()")
}
/* check for blank lines */
if ss = strings.TrimSpace(src); ss == "" || ss[0] == '#' || strings.HasPrefix(ss, "//") {
return nil, errors.New("blank line or line with only comments or line-marks")
}
/* setup error handler */
defer func() {
if vv = recover(); vv != nil {
if err, ok = vv.(*SyntaxError); !ok {
panic(vv)
}
}
}()
/* call the actual parser */
ret = self.feed(src)
return
}
// Parse parses the entire assembly source (possibly multiple lines) into
// a sequence of *ParsedLine.
func (self *Parser) Parse(src string) (ret []*ParsedLine, err error) {
var ok bool
var ss string
var vv interface{}
/* setup error handler */
defer func() {
if vv = recover(); vv != nil {
if err, ok = vv.(*SyntaxError); !ok {
panic(vv)
}
}
}()
/* feed every line */
for _, line := range strings.Split(src, "\n") {
if ss = strings.TrimSpace(line); ss == "" || strings.HasPrefix(ss, "//") {
self.lex.row++
} else if ss[0] == '#' {
self.directives(line)
} else {
ret = append(ret, self.feed(line))
}
}
/* all done */
err = nil
return
}
// Directive handles the directive.
func (self *Parser) Directive(line string) (err error) {
var ok bool
var ss string
var vv interface{}
/* check for directives */
if ss = strings.TrimSpace(line); ss == "" || ss[0] != '#' {
return errors.New("not a directive")
}
/* setup error handler */
defer func() {
if vv = recover(); vv != nil {
if err, ok = vv.(*SyntaxError); !ok {
panic(vv)
}
}
}()
/* call the directive parser */
self.directives(line)
return
}
type _TermRepo struct {
terms map[string]expr.Term
}
func (self *_TermRepo) Get(name string) (expr.Term, error) {
if ret, ok := self.terms[name]; ok {
return ret, nil
} else {
return nil, errors.New("undefined name: " + name)
}
}
func (self *_TermRepo) label(name string) (*Label, error) {
var ok bool
var lb *Label
var tr expr.Term
/* check for existing terms */
if tr, ok = self.terms[name]; ok {
if lb, ok = tr.(*Label); ok {
return lb, nil
} else {
return nil, errors.New("name is not a label: " + name)
}
}
/* create a new one as needed */
lb = new(Label)
lb.Name = name
/* create the map if needed */
if self.terms == nil {
self.terms = make(map[string]expr.Term, 1)
}
/* register the label */
self.terms[name] = lb
return lb, nil
}
func (self *_TermRepo) define(name string, term expr.Term) {
var ok bool
var tr expr.Term
/* create the map if needed */
if self.terms == nil {
self.terms = make(map[string]expr.Term, 1)
}
/* check for existing terms */
if tr, ok = self.terms[name]; !ok {
self.terms[name] = term
} else if _, ok = tr.(*Label); !ok {
self.terms[name] = term
} else {
panic("conflicting term types: " + name)
}
}
// _Command describes an assembler command.
//
// The _Command.args describes both the arity and argument type with characters,
// the length is the number of arguments, the character itself represents the
// argument type.
//
// Possible values are:
//
// s This argument should be a string
// e This argument should be an expression
// ? The next argument is optional, and must be the last argument.
//
type _Command struct {
args string
handler func(*Assembler, *Program, []ParsedCommandArg) error
}
// Options controls the behavior of Assembler.
type Options struct {
// InstructionAliasing specifies whether to enable instruction aliasing.
// Set to true enables instruction aliasing, and the Assembler will try harder to find instructions.
InstructionAliasing bool
// IgnoreUnknownDirectives specifies whether to report errors when encountered unknown directives.
// Set to true ignores all unknwon directives silently, useful for parsing generated assembly.
IgnoreUnknownDirectives bool
}
// Assembler assembles the entire assembly program and generates the corresponding
// machine code representations.
type Assembler struct {
cc int
ps Parser
pc uintptr
buf []byte
main string
opts Options
repo _TermRepo
expr expr.Parser
line *ParsedLine
}
var asmCommands = map[string]_Command {
"org" : { "e" , (*Assembler).assembleCommandOrg },
"set" : { "ee" , (*Assembler).assembleCommandSet },
"byte" : { "e" , (*Assembler).assembleCommandByte },
"word" : { "e" , (*Assembler).assembleCommandWord },
"long" : { "e" , (*Assembler).assembleCommandLong },
"quad" : { "e" , (*Assembler).assembleCommandQuad },
"fill" : { "e?e" , (*Assembler).assembleCommandFill },
"space" : { "e?e" , (*Assembler).assembleCommandFill },
"align" : { "e?e" , (*Assembler).assembleCommandAlign },
"entry" : { "e" , (*Assembler).assembleCommandEntry },
"ascii" : { "s" , (*Assembler).assembleCommandAscii },
"asciz" : { "s" , (*Assembler).assembleCommandAsciz },
"p2align" : { "e?e" , (*Assembler).assembleCommandP2Align },
}
func (self *Assembler) err(msg string) *SyntaxError {
return &SyntaxError {
Pos : -1,
Row : self.line.Row,
Src : self.line.Src,
Reason : msg,
}
}
func (self *Assembler) eval(expr string) (int64, error) {
if exp, err := self.expr.SetSource(expr).Parse(nil); err != nil {
return 0, err
} else {
return exp.Evaluate()
}
}
func (self *Assembler) checkArgs(i int, n int, v *ParsedCommand, isString bool) error {
if i >= len(v.Args) {
return self.err(fmt.Sprintf("command %s takes exact %d arguments", strconv.Quote(v.Cmd), n))
} else if isString && !v.Args[i].IsString {
return self.err(fmt.Sprintf("argument %d of command %s must be a string", i + 1, strconv.Quote(v.Cmd)))
} else if !isString && v.Args[i].IsString {
return self.err(fmt.Sprintf("argument %d of command %s must be an expression", i + 1, strconv.Quote(v.Cmd)))
} else {
return nil
}
}
func (self *Assembler) assembleLabel(p *Program, lb *ParsedLabel) error {
if v, err := self.repo.label(lb.Name); err != nil {
return err
} else {
p.Link(v)
return nil
}
}
func (self *Assembler) assembleInstr(p *Program, line *ParsedInstruction) (err error) {
var ok bool
var pfx []byte
var ops []interface{}
var enc _InstructionEncoder
/* convert to lower-case */
opts := self.opts
name := strings.ToLower(line.Mnemonic)
/* fix register-addressing branches if needed */
if opts.InstructionAliasing && len(line.Operands) == 1 {
switch {
case name == "retq" : name = "ret"
case name == "movabsq" : name = "movq"
case name == "jmp" && line.Operands[0].Op != OpLabel : name = "jmpq"
case name == "jmpq" && line.Operands[0].Op == OpLabel : name = "jmp"
case name == "call" && line.Operands[0].Op != OpLabel : name = "callq"
case name == "callq" && line.Operands[0].Op == OpLabel : name = "call"
}
}
/* lookup from the alias table if needed */
if opts.InstructionAliasing {
enc, ok = _InstructionAliases[name]
}
/* lookup from the instruction table */
if !ok {
enc, ok = Instructions[name]
}
/* remove size suffix if possible */
if !ok && opts.InstructionAliasing {
switch i := len(name) - 1; name[i] {
case 'b', 'w', 'l', 'q': {
enc, ok = Instructions[name[:i]]
}
}
}
/* check for instruction name */
if !ok {
return self.err("no such instruction: " + strconv.Quote(name))
}
/* allocate memory for prefix if any */
if len(line.Prefixes) != 0 {
pfx = make([]byte, len(line.Prefixes))
}
/* convert the prefixes */
for i, v := range line.Prefixes {
switch v {
case PrefixLock : pfx[i] = _P_lock
case PrefixSegmentCS : pfx[i] = _P_cs
case PrefixSegmentDS : pfx[i] = _P_ds
case PrefixSegmentES : pfx[i] = _P_es
case PrefixSegmentFS : pfx[i] = _P_fs
case PrefixSegmentGS : pfx[i] = _P_gs
case PrefixSegmentSS : pfx[i] = _P_ss
default : panic("unreachable: invalid segment prefix")
}
}
/* convert the operands */
for _, op := range line.Operands {
switch op.Op {
case OpImm : ops = append(ops, op.Imm)
case OpReg : ops = append(ops, op.Reg)
case OpMem : self.assembleInstrMem(&ops, op.Memory)
case OpLabel : self.assembleInstrLabel(&ops, op.Label)
default : panic("parser yields an invalid operand kind")
}
}
/* catch any exceptions in the encoder */
defer func() {
if v := recover(); v != nil {
err = self.err(fmt.Sprint(v))
}
}()
/* encode the instruction */
enc(p, ops...).prefix = pfx
return nil
}
func (self *Assembler) assembleInstrMem(ops *[]interface{}, addr MemoryAddress) {
mem := new(MemoryOperand)
*ops = append(*ops, mem)
/* check for RIP-relative addressing */
if addr.Base != rip {
mem.Addr.Type = Memory
mem.Addr.Memory = addr
} else {
mem.Addr.Type = Offset
mem.Addr.Offset = RelativeOffset(addr.Displacement)
}
}
func (self *Assembler) assembleInstrLabel(ops *[]interface{}, label ParsedLabel) {
vk := label.Kind
tr, err := self.repo.label(label.Name)
/* check for errors */
if err != nil {
panic(err)
}
/* check for branch target */
if vk == BranchTarget {
*ops = append(*ops, tr)
return
}
/* add to ops */
*ops = append(*ops, &MemoryOperand {
Addr: Addressable {
Type : Reference,
Reference : tr,
},
})
}
func (self *Assembler) assembleCommand(p *Program, line *ParsedCommand) error {
var iv int
var cc rune
var ok bool
var va bool
var fn _Command
/* find the command */
if fn, ok = asmCommands[line.Cmd]; !ok {
if self.opts.IgnoreUnknownDirectives {
return nil
} else {
return self.err("no such command: " + strconv.Quote(line.Cmd))
}
}
/* expected & real argument count */
argx := len(fn.args)
argc := len(line.Args)
/* check the arguments */
loop: for iv, cc = range fn.args {
switch cc {
case '?' : va = true; break loop
case 's' : if err := self.checkArgs(iv, argx, line, true) ; err != nil { return err }
case 'e' : if err := self.checkArgs(iv, argx, line, false) ; err != nil { return err }
default : panic("invalid argument descriptor: " + strconv.Quote(fn.args))
}
}
/* simple case: non-variadic command */
if !va {
if argc == argx {
return fn.handler(self, p, line.Args)
} else {
return self.err(fmt.Sprintf("command %s takes exact %d arguments", strconv.Quote(line.Cmd), argx))
}
}
/* check for the descriptor */
if iv != argx - 2 {
panic("invalid argument descriptor: " + strconv.Quote(fn.args))
}
/* variadic command and the final optional argument is set */
if argc == argx - 1 {
switch fn.args[argx - 1] {
case 's' : if err := self.checkArgs(iv, -1, line, true) ; err != nil { return err }
case 'e' : if err := self.checkArgs(iv, -1, line, false) ; err != nil { return err }
default : panic("invalid argument descriptor: " + strconv.Quote(fn.args))
}
}
/* check argument count */
if argc == argx - 1 || argc == argx - 2 {
return fn.handler(self, p, line.Args)
} else {
return self.err(fmt.Sprintf("command %s takes %d or %d arguments", strconv.Quote(line.Cmd), argx - 2, argx - 1))
}
}
func (self *Assembler) assembleCommandInt(p *Program, argv []ParsedCommandArg, addfn func(*Program, *expr.Expr) *Instruction) error {
var err error
var val *expr.Expr
/* parse the expression */
if val, err = self.expr.SetSource(argv[0].Value).Parse(&self.repo); err != nil {
return err
}
/* add to the program */
addfn(p, val)
return nil
}
func (self *Assembler) assembleCommandOrg(_ *Program, argv []ParsedCommandArg) error {
var err error
var val int64
/* evaluate the expression */
if val, err = self.eval(argv[0].Value); err != nil {
return err
}
/* check for origin */
if val < 0 {
return self.err(fmt.Sprintf("negative origin: %d", val))
}
/* ".org" must be the first command if any */
if self.cc != 1 {
return self.err(".org must be the first command if present")
}
/* set the initial program counter */
self.pc = uintptr(val)
return nil
}
func (self *Assembler) assembleCommandSet(_ *Program, argv []ParsedCommandArg) error {
var err error
var val *expr.Expr
/* parse the expression */
if val, err = self.expr.SetSource(argv[1].Value).Parse(&self.repo); err != nil {
return err
}
/* define the new identifier */
self.repo.define(argv[0].Value, val)
return nil
}
func (self *Assembler) assembleCommandByte(p *Program, argv []ParsedCommandArg) error {
return self.assembleCommandInt(p, argv, (*Program).Byte)
}
func (self *Assembler) assembleCommandWord(p *Program, argv []ParsedCommandArg) error {
return self.assembleCommandInt(p, argv, (*Program).Word)
}
func (self *Assembler) assembleCommandLong(p *Program, argv []ParsedCommandArg) error {
return self.assembleCommandInt(p, argv, (*Program).Long)
}
func (self *Assembler) assembleCommandQuad(p *Program, argv []ParsedCommandArg) error {
return self.assembleCommandInt(p, argv, (*Program).Quad)
}
func (self *Assembler) assembleCommandFill(p *Program, argv []ParsedCommandArg) error {
var fv byte
var nb int64
var ex error
/* evaluate the size */
if nb, ex = self.eval(argv[0].Value); ex != nil {
return ex
}
/* check for filling size */
if nb < 0 {
return self.err(fmt.Sprintf("negative filling size: %d", nb))
}
/* check for optional filling value */
if len(argv) == 2 {
if val, err := self.eval(argv[1].Value); err != nil {
return err
} else if val < math.MinInt8 || val > math.MaxUint8 {
return self.err(fmt.Sprintf("value %d cannot be represented with a byte", val))
} else {
fv = byte(val)
}
}
/* fill with specified byte */
p.Data(bytes.Repeat([]byte { fv }, int(nb)))
return nil
}
func (self *Assembler) assembleCommandAlign(p *Program, argv []ParsedCommandArg) error {
var nb int64
var ex error
var fv *expr.Expr
/* evaluate the size */
if nb, ex = self.eval(argv[0].Value); ex != nil {
return ex
}
/* check for alignment value */
if nb <= 0 {
return self.err(fmt.Sprintf("zero or negative alignment: %d", nb))
}
/* alignment must be a power of 2 */
if (nb & (nb - 1)) != 0 {
return self.err(fmt.Sprintf("alignment must be a power of 2: %d", nb))
}
/* check for optional filling value */
if len(argv) == 2 {
if v, err := self.expr.SetSource(argv[1].Value).Parse(&self.repo); err == nil {
fv = v
} else {
return err
}
}
/* fill with specified byte, default to 0 if not specified */
p.Align(uint64(nb), fv)
return nil
}
func (self *Assembler) assembleCommandEntry(_ *Program, argv []ParsedCommandArg) error {
name := argv[0].Value
rbuf := []rune(name)
/* check all the characters */
for i, cc := range rbuf {
if !isident0(cc) && (i == 0 || !isident(cc)) {
return self.err("entry point must be a label name")
}
}
/* set the main entry point */
self.main = name
return nil
}
func (self *Assembler) assembleCommandAscii(p *Program, argv []ParsedCommandArg) error {
p.Data([]byte(argv[0].Value))
return nil
}
func (self *Assembler) assembleCommandAsciz(p *Program, argv []ParsedCommandArg) error {
p.Data(append([]byte(argv[0].Value), 0))
return nil
}
func (self *Assembler) assembleCommandP2Align(p *Program, argv []ParsedCommandArg) error {
var nb int64
var ex error
var fv *expr.Expr
/* evaluate the size */
if nb, ex = self.eval(argv[0].Value); ex != nil {
return ex
}
/* check for alignment value */
if nb <= 0 {
return self.err(fmt.Sprintf("zero or negative alignment: %d", nb))
}
/* check for optional filling value */
if len(argv) == 2 {
if v, err := self.expr.SetSource(argv[1].Value).Parse(&self.repo); err == nil {
fv = v
} else {
return err
}
}
/* fill with specified byte, default to 0 if not specified */
p.Align(1 << nb, fv)
return nil
}
// Base returns the origin.
func (self *Assembler) Base() uintptr {
return self.pc
}
// Code returns the assembled machine code.
func (self *Assembler) Code() []byte {
return self.buf
}
// Entry returns the address of the specified entry point, or the origin if not specified.
func (self *Assembler) Entry() uintptr {
if self.main == "" {
return self.pc
} else if tr, err := self.repo.Get(self.main); err != nil {
panic(err)
} else if val, err := tr.Evaluate(); err != nil {
panic(err)
} else {
return uintptr(val)
}
}
// Options returns the internal options reference, changing it WILL affect this Assembler instance.
func (self *Assembler) Options() *Options {
return &self.opts
}
// WithBase resets the origin to pc.
func (self *Assembler) WithBase(pc uintptr) *Assembler {
self.pc = pc
return self
}
// Assemble assembles the assembly source and save the machine code to internal buffer.
func (self *Assembler) Assemble(src string) error {
var err error
var buf []*ParsedLine
/* parse the source */
if buf, err = self.ps.Parse(src); err != nil {
return err
}
/* create a new program */
p := DefaultArch.CreateProgram()
defer p.Free()
/* process every line */
for _, self.line = range buf {
switch self.cc++; self.line.Kind {
case LineLabel : if err = self.assembleLabel (p, &self.line.Label) ; err != nil { return err }
case LineInstr : if err = self.assembleInstr (p, &self.line.Instruction) ; err != nil { return err }
case LineCommand : if err = self.assembleCommand (p, &self.line.Command) ; err != nil { return err }
default : panic("parser yields an invalid line kind")
}
}
/* assemble the program */
self.buf = p.Assemble(self.pc)
return nil
}
Reference in New Issue View Git Blame Copy Permalink