iris/lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

convert programs into tests

Browse Source
This commit is contained in:
iris
2026-06-12 22:24:35 -04:00
parent 715a50b1fa
commit 571ff70fa1
13 changed files with 129 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/arch/x86_64/mod.rs
+1 -1
View File
@@ -1,6 +1,7 @@
mod compile;
mod encode;
mod reg;
#[cfg(test)]
mod test;
mod types;
mod util;
@@ -14,7 +15,6 @@ use crate::{
pub use compile::*;
pub use encode::*;
pub use reg::*;
pub use test::bin::run as bin_test;
pub use types::*;
use util::*;
src/arch/x86_64/test/bin.rs
-132
View File
@@ -1,132 +0,0 @@
use crate::{
arch::x86_64::*,
backend::{Instr as BInstr, Program},
};
use std::{fs::OpenOptions, io::Write, os::unix::fs::OpenOptionsExt, process::Command};
pub fn run() {
if let Err(err) = linux() {
println!("{err:?}");
}
}
fn linux() -> Result<(), CompilerMsg> {
let mut program = Program::<X86_64>::default();
let text = b"Hello world!\n";
let text_sym = program.ro_data("hello_en", text);
let text2 = "世界、こんにちは！\n";
let text_sym2 = program.ro_data("hello_jp", text2);
let hello2 = program.func(
"hello2",
[BInstr::Asm(encode(|c| {
c.mov(ax, 1)?;
c.mov(di, 1)?;
c.lea(rsi, text_sym2);
c.mov(dx, text2.len() as u64)?;
c.syscall();
c.ret();
Ok(())
})?)],
);
let entry = program.func(
"main",
[BInstr::Asm(encode(|c| {
c.mov(rdi, 39)?;
c.push(rdi)?;
c.mov(ax, 1)?;
c.mov(di, 1)?;
c.lea(rsi, text_sym);
c.mov(dx, text.len() as u64)?;
c.syscall();
c.call(hello2);
c.mov(ax, 0x3c)?;
c.pop(rdi)?;
c.syscall();
Ok(())
})?)],
);
program.entry = Some(entry);
let linked = program.compile().expect("failed to compile");
let binary = linked.to_elf();
let path = "./test/x86_64_test";
write(path, &binary);
println!("running...");
let gdb = false;
let mut proc = if gdb {
let mut cmd = Command::new("gdb");
#[rustfmt::skip]
cmd.args([
"-q",
"-ex", "starti",
"-ex", "layout asm",
"-ex", "focus next",
"x86_64_test",
]);
cmd
} else {
Command::new(path)
}
.spawn()
.expect("failed to run");
let status = proc.wait().expect("failed to wait");
if let Some(code) = status.code() {
std::process::exit(code);
}
Ok(())
}
fn windows() -> Result<(), CompilerMsg> {
let mut program = Program::<X86_64>::default();
let [get_std_handle, write_file, exit_process] =
program.external("KERNEL32.dll", ["GetStdHandle", "WriteFile", "ExitProcess"]);
let text = b"Hello world!\n";
let text_sym = program.ro_data("hello_en", text);
let written = program.ro_data("written", [0; 4]);
let entry = program.func(
"main",
[BInstr::Asm(encode(|c| {
c.sub();
// stdout
c.mov(ecx, -11)?;
c.call_mem(get_std_handle);
// write
c.mov(rcx, rax)?;
c.lea(rdx, text_sym);
c.mov(r8d, text.len() as u64)?;
c.lea(r9, written);
c.mov(mem(rsp, 0x20, Width::B32), 0)?;
c.call_mem(write_file);
// exit
c.mov(ecx, 39)?;
c.call_mem(exit_process);
Ok(())
})?)],
);
program.entry = Some(entry);
let linked = program.compile().expect("failed to compile");
let binary = linked.to_pe();
let path = "./test/x86_64_test.exe";
write(path, &binary);
let mut cmd = Command::new("wine");
cmd.arg("x86_64_test");
let mut proc = cmd.spawn().expect("failed to run");
let status = proc.wait().expect("failed to wait");
if let Some(code) = status.code() {
std::process::exit(code);
}
Ok(())
}
fn write(path: &str, binary: &[u8]) {
let mut file = OpenOptions::new()
.create(true)
.write(true)
.truncate(true)
.mode(0o750)
.open(path)
.expect("Failed to create file");
file.write_all(binary).expect("Failed to write to file");
file.sync_all().expect("Failed to sync file");
}
src/arch/x86_64/test/full/linux.rs
+54
View File
@@ -0,0 +1,54 @@
use super::*;
#[test]
fn hello() -> Result<(), CompilerMsg> {
let mut program = Program::<X86_64>::default();
let text = b"Hello world!\n";
let text_sym = program.ro_data("hello_en", text);
let text2 = "世界、こんにちは！\n";
let text_sym2 = program.ro_data("hello_jp", text2);
let hello2 = program.func(
"hello2",
[Instr::Asm(encode(|c| {
c.mov(ax, 1)?;
c.mov(di, 1)?;
c.lea(rsi, text_sym2);
c.mov(dx, text2.len() as u64)?;
c.syscall();
c.ret();
Ok(())
})?)],
);
let entry = program.func(
"main",
[Instr::Asm(encode(|c| {
c.mov(rdi, 39)?;
c.push(rdi)?;
c.mov(ax, 1)?;
c.mov(di, 1)?;
c.lea(rsi, text_sym);
c.mov(dx, text.len() as u64)?;
c.syscall();
c.call(hello2);
c.mov(ax, 0x3c)?;
c.pop(rdi)?;
c.syscall();
Ok(())
})?)],
);
program.entry = Some(entry);
let linked = program.compile().expect("failed to compile");
let binary = linked.to_elf();
let path = "test/bin/x86_64_test";
write(path, &binary);
println!("running...");
let mut cmd = Command::new(path);
let output = cmd.output().expect("failed to run");
let Some(code) = output.status.code() else {
panic!("no exit code");
};
let result: String = output.stdout.try_into().expect("non ascii output");
assert_eq!(result, "Hello world!\n世界、こんにちは！\n");
assert_eq!(code, 39);
Ok(())
}
src/arch/x86_64/test/full/mod.rs
+11
View File
@@ -0,0 +1,11 @@
mod linux;
mod util;
mod windows;
use crate::{
arch::x86_64::*,
backend::{Instr, Program},
io::CompilerMsg,
};
use std::process::Command;
use util::*;
src/arch/x86_64/test/full/util.rs
+13
View File
@@ -0,0 +1,13 @@
use std::{fs::OpenOptions, io::Write, os::unix::fs::OpenOptionsExt};
pub fn write(path: &str, binary: &[u8]) {
let mut file = OpenOptions::new()
.create(true)
.write(true)
.truncate(true)
.mode(0o750)
.open(path)
.expect("Failed to create file");
file.write_all(binary).expect("Failed to write to file");
file.sync_all().expect("Failed to sync file");
}
src/arch/x86_64/test/full/windows.rs
+48
View File
@@ -0,0 +1,48 @@
use super::*;
#[test]
fn hello() -> Result<(), CompilerMsg> {
let mut program = Program::<X86_64>::default();
let [get_std_handle, write_file, exit_process] =
program.external("KERNEL32.dll", ["GetStdHandle", "WriteFile", "ExitProcess"]);
let text = b"Hello world!\n";
let text_sym = program.ro_data("hello_en", text);
let written = program.ro_data("written", [0; 4]);
let entry = program.func(
"main",
[Instr::Asm(encode(|c| {
c.sub();
// stdout
c.mov(ecx, -11)?;
c.call_mem(get_std_handle);
// write
c.mov(rcx, rax)?;
c.lea(rdx, text_sym);
c.mov(r8d, text.len() as u64)?;
c.lea(r9, written);
c.mov(mem(rsp, 0x20, Width::B32), 0)?;
c.call_mem(write_file);
// exit
c.mov(ecx, 39)?;
c.call_mem(exit_process);
Ok(())
})?)],
);
program.entry = Some(entry);
let linked = program.compile().expect("failed to compile");
let binary = linked.to_pe();
let path = "test/bin/x86_64_test.exe";
write(path, &binary);
let mut cmd = Command::new("wine");
cmd.arg(path);
let output = cmd.output().expect("failed to run");
let Some(code) = output.status.code() else {
panic!("no exit code");
};
let result: String = output.stdout.try_into().expect("non ascii output");
assert_eq!(result, "Hello world!\n");
assert_eq!(code, 39);
Ok(())
}
src/arch/x86_64/test/mod.rs
+1 -6
View File
@@ -1,7 +1,2 @@
pub mod bin;
#[cfg(test)]
mod full;
mod nasm;
#[cfg(test)]
mod reg;
#[cfg(test)]
use super::*;
src/arch/x86_64/test/reg.rs
-83
View File
@@ -1,83 +0,0 @@
use super::*;
macro_rules! eq {
($expected:expr, $instr:ident $args:tt $(,)?) => {
let expected = $expected.as_ref();
let mut code = Code::default();
let res = code.$instr $args;
let asm = stringify!($instr $args);
if let Err(e) = res {
panic!("{asm}: failed to compile: {}", e.msg);
}
let res = &code.bytes[..];
assert_eq!(expected, res, "{asm}: expected {expected:x?}, got {res:x?}");
};
}
// used objdump on some nasm compiled assembly
#[test]
fn mov_reg_reg() {
eq!([0x48, 0x89, 0xd8], mov(rax, rbx));
eq!([0x89, 0xd8], mov(eax, ebx));
eq!([0x66, 0x89, 0xd8], mov(ax, bx));
eq!([0x88, 0xd8], mov(al, bl));
eq!([0x88, 0xfc], mov(ah, bh));
eq!([0x88, 0xf8], mov(al, bh));
eq!([0x88, 0xdc], mov(ah, bl));
eq!([0x40, 0x88, 0xe7], mov(dil, spl));
eq!([0x4d, 0x89, 0xc8], mov(r8, r9));
eq!([0x45, 0x89, 0xc8], mov(r8d, r9d));
eq!([0x66, 0x45, 0x89, 0xc8], mov(r8w, r9w));
eq!([0x45, 0x88, 0xc8], mov(r8b, r9b));
eq!([0x49, 0x89, 0xc0], mov(r8, rax));
eq!([0x4c, 0x89, 0xc0], mov(rax, r8));
eq!([0x4d, 0x89, 0xd1], mov(r9, r10));
eq!([0x4d, 0x89, 0xe0], mov(r8, r12));
eq!([0x89, 0xe0], mov(eax, esp));
eq!([0x89, 0xc4], mov(esp, eax));
}
#[test]
fn mov_reg_imm() {
eq!(
[0x49, 0xbf, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12],
mov(r15, 0x123456789abcdef0u64),
);
eq!(
[0x49, 0xb8, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12],
mov(r8, 0x123456789abcdef0u64),
);
eq!(
[0x49, 0xb9, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12],
mov(r9, 0x123456789abcdef0u64),
);
eq!([0x41, 0xb9, 0x78, 0x56, 0x34, 0x12], mov(r9d, 0x12345678));
eq!([0x66, 0x41, 0xb9, 0x34, 0x12], mov(r9w, 0x1234));
eq!([0x41, 0xb1, 0x12], mov(r9b, 0x12));
eq!([0x41, 0xb0, 0x12], mov(r8b, 0x12));
eq!([0x41, 0xb7, 0x12], mov(r15b, 0x12));
eq!(
[0x48, 0xb8, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12],
mov(rax, 0x123456789abcdef0u64),
);
eq!(
[0x48, 0xbb, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12],
mov(rbx, 0x123456789abcdef0u64),
);
eq!(
[0x48, 0xbf, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12],
mov(rdi, 0x123456789abcdef0u64),
);
eq!([0xbb, 0x78, 0x56, 0x34, 0x12], mov(ebx, 0x12345678));
eq!([0x66, 0xbb, 0x34, 0x12], mov(bx, 0x1234));
eq!([0xb3, 0x12], mov(bl, 0x12));
eq!([0xb7, 0x12], mov(bh, 0x12));
eq!([0xb4, 0x12], mov(ah, 0x12));
eq!([0x40, 0xb7, 0x12], mov(dil, 0x12));
}
src/backend/container/pe/mod.rs
-1
View File
@@ -48,7 +48,6 @@ pub fn create(program: &LinkedProgram<u64>) -> Vec<u8> {
let code_start = data.pos();
data.extend(&program.code);
println!("entry: 0x{:x}", (code_start as u64 + program.entry.unwrap()) as u32);
if !program.imports.is_empty() {
let import_rva = import::encode(&mut data, &program.imports, code_start);
src/main.rs
+1 -2
View File
@@ -1,4 +1,4 @@
#![feature(gen_blocks)]
#![cfg_attr(test, feature(gen_blocks))]
use crate::{io::CompilerOutput, parser_ir::parse_program};
@@ -10,7 +10,6 @@ mod parser;
mod parser_ir;
fn main() {
return crate::arch::x86_64::bin_test();
let mut args = std::env::args();
let Some(path) = args.nth(1) else {
println!("file expected");
test/x86_64_test → test/bin/x86_64_test
View File
test/bin/x86_64_test.exe
Executable
BIN
View File
Binary file not shown.
test/x86_64_test.exe
BIN
View File
Binary file not shown.