1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/compiler/x64/gen.v

269 lines
4.6 KiB
V
Raw Normal View History

2019-11-19 09:53:52 +03:00
// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module x64
pub struct Gen {
2019-12-20 00:29:37 +03:00
out_name string
2019-11-19 09:53:52 +03:00
mut:
2019-12-20 00:29:37 +03:00
buf []byte
2019-11-19 09:53:52 +03:00
sect_header_name_pos int
2019-12-20 00:29:37 +03:00
offset i64
str_pos []i64
strings []string // TODO use a map and don't duplicate strings
file_size_pos i64
main_fn_addr i64
code_start_pos i64 // location of the start of the assembly instructions
fn_addr map[string]i64
// string_addr map[string]i64
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
enum Register {
eax
edi
rax
rdi
rsi
edx
rdx
r12
}
enum Size {
_8
_16
_32
_64
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
pub fn new_gen(out_name string) &Gen {
return &Gen{
2019-12-20 00:29:37 +03:00
sect_header_name_pos: 0
2019-11-19 09:53:52 +03:00
buf: []
out_name: out_name
2019-11-29 12:33:04 +03:00
}
}
2019-11-19 09:53:52 +03:00
pub fn (g &Gen) pos() i64 {
return g.buf.len
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) write8(n int) {
// write 1 byte
g.buf << byte(n)
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) write16(n int) {
// write 2 bytes
g.buf << byte(n)
2019-12-20 00:29:37 +03:00
g.buf << byte(n>>8)
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) write32(n int) {
// write 4 bytes
g.buf << byte(n)
2019-12-20 00:29:37 +03:00
g.buf << byte(n>>8)
g.buf << byte(n>>16)
g.buf << byte(n>>24)
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) write64(n i64) {
// write 8 bytes
g.buf << byte(n)
2019-12-20 00:29:37 +03:00
g.buf << byte(n>>8)
g.buf << byte(n>>16)
g.buf << byte(n>>24)
g.buf << byte(n>>32)
g.buf << byte(n>>40)
g.buf << byte(n>>48)
g.buf << byte(n>>56)
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) write64_at(n i64, at i64) {
// write 8 bytes
g.buf[at] = byte(n)
2019-12-20 00:29:37 +03:00
g.buf[at + 1] = byte(n>>8)
g.buf[at + 2] = byte(n>>16)
g.buf[at + 3] = byte(n>>24)
g.buf[at + 4] = byte(n>>32)
g.buf[at + 5] = byte(n>>40)
g.buf[at + 6] = byte(n>>48)
g.buf[at + 7] = byte(n>>56)
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) write_string(s string) {
for c in s {
g.write8(int(c))
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
}
fn (g mut Gen) inc(reg Register) {
g.write16(0xff49)
match reg {
2019-12-20 00:29:37 +03:00
.r12 {
g.write8(0xc4)
}
else {
panic('unhandled inc $reg')
}}
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) cmp(reg Register, size Size, val i64) {
g.write8(0x49)
// Second byte depends on the size of the value
match size {
2019-12-20 00:29:37 +03:00
._8 {
g.write8(0x83)
}
._32 {
g.write8(0x81)
}
else {
panic('unhandled cmp')
}}
2019-11-19 09:53:52 +03:00
// Third byte depends on the register being compared to
match reg {
2019-12-20 00:29:37 +03:00
.r12 {
g.write8(0xfc)
}
else {
panic('unhandled cmp')
}}
2019-11-19 09:53:52 +03:00
g.write8(int(val))
}
2019-12-20 00:29:37 +03:00
fn abs(a i64) i64 {
return if a < 0 { -a } else { a }
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) jle(addr i64) {
// Calculate the relative offset to jump to
// (`addr` is absolute address)
2019-12-20 00:29:37 +03:00
offset := 0xff - int(abs(addr - g.buf.len)) - 1
2019-11-19 09:53:52 +03:00
g.write8(0x7e)
g.write8(offset)
}
fn (g mut Gen) jl(addr i64) {
2019-12-20 00:29:37 +03:00
offset := 0xff - int(abs(addr - g.buf.len)) - 1
g.write8(0x7c)
g.write8(offset)
}
fn (g &Gen) abs_to_rel_addr(addr i64) int {
2019-12-20 00:29:37 +03:00
return int(abs(addr - g.buf.len)) - 1
2019-11-29 12:33:04 +03:00
}
2019-12-20 00:29:37 +03:00
fn (g mut Gen) jmp(addr i64) {
offset := 0xff - g.abs_to_rel_addr(addr)
g.write8(0xe9)
g.write8(offset)
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) mov64(reg Register, val i64) {
match reg {
.rsi {
g.write8(0x48)
g.write8(0xbe)
}
2019-12-20 00:29:37 +03:00
else {
println('unhandled mov $reg')
}}
2019-11-19 09:53:52 +03:00
g.write64(val)
}
fn (g mut Gen) call(addr int) {
2019-12-20 00:29:37 +03:00
// rel := g.abs_to_rel_addr(addr)
// rel := 0xffffffff - int(abs(addr - g.buf.len))-1
println('call addr=$addr rel_addr=$addr pos=$g.buf.len')
2019-11-19 09:53:52 +03:00
g.write8(0xe8)
g.write32(addr)
2019-11-19 09:53:52 +03:00
}
fn (g mut Gen) syscall() {
// g.write(0x050f)
g.write8(0x0f)
g.write8(0x05)
}
pub fn (g mut Gen) ret() {
2019-11-19 09:53:52 +03:00
g.write8(0xc3)
}
// returns label's relative address
pub fn (g mut Gen) gen_loop_start(from int) int {
g.mov(.r12, from)
label := g.buf.len
g.inc(.r12)
return label
}
pub fn (g mut Gen) gen_loop_end(to int, label int) {
g.cmp(.r12, ._8, to)
2019-11-29 12:33:04 +03:00
g.jl(label)
2019-11-19 09:53:52 +03:00
}
pub fn (g mut Gen) save_main_fn_addr() {
g.main_fn_addr = g.buf.len
}
2019-11-19 09:53:52 +03:00
pub fn (g mut Gen) gen_print(s string) {
g.strings << s + '\n'
2019-12-20 00:29:37 +03:00
// g.string_addr[s] = str_pos
2019-11-19 09:53:52 +03:00
g.mov(.eax, 1)
g.mov(.edi, 1)
str_pos := g.buf.len + 2
g.str_pos << str_pos
2019-12-20 00:29:37 +03:00
g.mov64(.rsi, 0) // segment_start + 0x9f) // str pos // PLACEHOLDER
g.mov(.edx, s.len + 1) // len
2019-11-19 09:53:52 +03:00
g.syscall()
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
pub fn (g mut Gen) gen_exit() {
// Return 0
g.mov(.edi, 0) // ret value
g.mov(.eax, 60)
g.syscall()
}
2019-11-19 09:53:52 +03:00
fn (g mut Gen) mov(reg Register, val int) {
match reg {
2019-12-20 00:29:37 +03:00
.eax {
g.write8(0xb8)
}
.edi {
g.write8(0xbf)
}
.edx {
g.write8(0xba)
}
2019-11-19 09:53:52 +03:00
.rsi {
g.write8(0x48)
g.write8(0xbe)
}
.r12 {
g.write8(0x41)
2019-12-20 00:29:37 +03:00
g.write8(0xbc) // r11 is 0xbb etc
2019-11-29 12:33:04 +03:00
}
2019-11-19 09:53:52 +03:00
else {
panic('unhandled mov $reg')
2019-12-20 00:29:37 +03:00
}}
2019-11-19 09:53:52 +03:00
g.write32(val)
}
pub fn (g mut Gen) register_function_address(name string) {
addr := g.pos()
2019-12-31 21:42:16 +03:00
//println('reg fn addr $name $addr')
g.fn_addr[name] = addr
}
pub fn (g mut Gen) call_fn(name string) {
if !name.contains('__') {
return
2019-11-29 12:33:04 +03:00
}
addr := g.fn_addr[name]
g.call(int(addr))
println('call $name $addr')
}