Merge pull request #257 from bext-lang/posix6502

Decouple the 6502 runner from the compiler

Author: rexim

.github/workflows/ci.yml

@@ -5,7 +5,7 @@ on: [push, pull_request]
 #   May require a special support for build-only mode in btest
 
 jobs:
-  ubuntu-excluding-macos:
+  ubuntu-linux-windows:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -16,6 +16,23 @@ jobs:
         run: |
           sudo apt-get update
           sudo apt-get install -qq -y mono-devel clang make mingw-w64 wine64 gcc-aarch64-linux-gnu qemu-user
+      - name: Build Toolchain
+        run: |
+          make -B
+      - name: Run Tests
+        run: |
+          PATH=$(realpath uxn11/bin):$PATH ./build/btest -t *linux* -t *windows*
+  ubuntu-uxn:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Rust
+        run: rustup toolchain install stable --no-self-update --profile minimal
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -qq -y clang make
           git clone https://git.sr.ht/~rabbits/uxn11
           cd uxn11
           make cli
@@ -24,7 +41,45 @@ jobs:
           make -B
       - name: Run Tests
         run: |
-          PATH=$(realpath uxn11/bin):$PATH ./build/btest -xt *darwin*
+          PATH=$(realpath uxn11/bin):$PATH ./build/btest -t uxn
+  ubuntu-6502-posix:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Rust
+        run: rustup toolchain install stable --no-self-update --profile minimal
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -qq -y clang make
+          git clone https://github.com/bext-lang/posix6502
+          cd posix6502
+          cc -o nob nob.c
+          ./nob
+      - name: Build Toolchain
+        run: |
+          make -B
+      - name: Run Tests
+        run: |
+          PATH=$(realpath posix6502/build):$PATH ./build/btest -t 6502-posix
+  ubuntu-mono:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Rust
+        run: rustup toolchain install stable --no-self-update --profile minimal
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -qq -y mono-devel clang make
+      - name: Build Toolchain
+        run: |
+          make -B
+      - name: Run Tests
+        run: |
+          ./build/btest -t *ilasm-mono*
   macos-aarch64:
     runs-on: macos-latest
     steps:

Makefile

@@ -38,7 +38,6 @@ POSIX_OBJS=\
 	$(BUILD)/glob.posix.o \
 	$(BUILD)/libc.posix.o \
 	$(BUILD)/arena.posix.o \
-	$(BUILD)/fake6502.posix.o \
 	$(BUILD)/jim.posix.o \
 	$(BUILD)/jimp.posix.o
 
@@ -48,7 +47,6 @@ MINGW32_OBJS=\
 	$(BUILD)/glob.mingw32.o \
 	$(BUILD)/libc.mingw32.o \
 	$(BUILD)/arena.mingw32.o \
-	$(BUILD)/fake6502.mingw32.o \
 	$(BUILD)/jim.mingw32.o \
 	$(BUILD)/jimp.mingw32.o
 

README.md

@@ -13,13 +13,6 @@
 
 Compiler for the [B Programming Language](https://en.wikipedia.org/wiki/B_(programming_language)) implemented in [Crust](https://github.com/tsoding/crust).
 
-## Dependencies
-
-- [Rust](https://www.rust-lang.org/) - the compiler is written in it;
-- [GCC](https://gcc.gnu.org/) or [Clang](https://clang.llvm.org/) (whatever serves as the `cc` on your POSIX platform) - the `x86_64` and `aarch64` targets generate assembly and pass it to `cc` to assemble and link.
-
-<!-- TODO: document specific dependencies for the rest of the targets. Like mingw32-w64 and wine on Linux for gas-x86_64-Windows, etc. -->
-
 ## Quick Start
 
 ```console
@@ -30,6 +23,49 @@ $ ./build/b -run ./examples/hello_world.b
 Also check out more examples at [./examples/](./examples/).
 Find the project documentation at [./docs/](./docs/).
 
+## Dependencies
+
+Generally, to write programs for the three major contemporary platforms (Linux, Windows, Darwin) you need only these things:
+
+- [Rust](https://www.rust-lang.org/) - the compiler is written in it;
+- [GCC](https://gcc.gnu.org/) or [Clang](https://clang.llvm.org/) or [mingw-w64](https://www.mingw-w64.org/) (whatever serves as the `cc` on your POSIX platform) - the `x86_64` and `aarch64` targets generate assembly and pass it to `cc` to assemble and link.
+
+If you feel like playing with our "spicy" targets, you will need to setup few additional things.
+
+### uxn
+
+[Uxn](https://100r.co/site/uxn.html) is a pretty cool small virtual machine designed to be simple and portable.
+
+This compiler toolchain expects the `uxnemu` and `uxncli` executables to be available in the `$PATH` environment variable. We recommend to build them from the source code available at [https://git.sr.ht/~rabbits/uxn](https://git.sr.ht/~rabbits/uxn). Follow their build instructions and then copy the contents of the `bin/` folder somewhere were the `$PATH` points at.
+
+### 6502-posix
+
+[MOS Technology 6502](https://en.wikipedia.org/wiki/MOS_Technology_6502) is a legendary processor that was used in such systems as the Atari 2600, Atari 8-bit computers, Apple II, Nintendo Entertainment System, Commodore 64, Atari Lynx, BBC Micro and others.
+
+Since "targeting 6502" doesn't really mean anything, given the diverse array of hardware, we created a special target called [posix6502](https://github.com/bext-lang/posix6502). It's a simple 6502 emulator that exposes some POSIX functionality to programs running on the 6502 processor, allowing them to operate in a POSIX environment. We use it as a testing and playground target for 6502 codegen. In the future, we may add more 6502-related targets.
+
+It consist of a single `posix6502` executable which is expected to be available to the compiler toolchain via the `$PATH` environment variable. We recommend to build it from the source code:
+
+```console
+$ git clone https://github.com/bext-lang/posix6502 && cd posix6502
+$ cc -o nob nob.c
+$ ./nob
+```
+
+Copy the `build/posix6502` executable somewhere were the `$PATH` points at.
+
+### ilasm-mono
+
+This target tries to produce [.NET](https://dotnet.microsoft.com/en-us/)/[Mono](https://www.mono-project.com/) compatible binaries. It's currently a work-in-progress and does not have anything useful implemented in it.
+
+The compiler toolchain expects `ilasm` and `mono` executables available in the `$PATH` environment variables. Lots of Linux distros make them available via the mono packages in their official repos:
+
+```consols
+$ sudo xbps-install mono      # Void Linux
+$ sudo apt install mono-devel # Ubuntu
+...
+```
+
 ## Contribution
 
 Accepting Pull Requests is currently paused. We are in the middle of [Decentralizing](https://github.com/tsoding/b/issues/62) this repo. The plan is
@@ -38,7 +74,7 @@ Accepting Pull Requests is currently paused. We are in the middle of [Decentrali
 2. Keep `*x86_64*` and `*aarch64*` codegens in the main repo.
 3. Move codegens [6502](./src/codegen/mos6502.rs) (owner [@Miezekatze64](https://github.com/miezekatze64)), [uxn](./src/codegen/uxn.rs) (owner [@deniska](https://github.com/deniska)), [gas-sh4dsp-prizm](https://github.com/tsoding/b/pull/175) (owner [@seija-amanojaku](https://github.com/seija-amanojaku)) to separate repos within the organization and give the owners full admin access to them.
 
-You can still submit PRs in the meantime. Just don't expect them to be reviewed any time soon since decouping codegens requires extensive refactoring. They will be addressed eventually.
+You can still submit PRs in the meantime. Just don't expect them to be reviewed any time soon since decoupling codegens requires extensive refactoring. The PRs will be addressed eventually.
 
 ## References
 

libb/6502.b libb/6502-posix.blibb/6502.b renamed to libb/6502-posix.b

@@ -1161,6 +1161,13 @@ pub unsafe fn get_garbage_base(path: *const c_char, target: Target) -> Option<*m
     Some(temp_sprintf(c!("%s/%s.%s"), garbage_dir, filename, target.name()))
 }
 
+pub unsafe fn print_available_targets() {
+    fprintf(stderr(), c!("Compilation targets:\n"));
+    for i in 0..TARGET_ORDER.len() {
+        fprintf(stderr(), c!("    %s\n"), (*TARGET_ORDER)[i].name());
+    }
+}
+
 pub unsafe fn main(mut argc: i32, mut argv: *mut*mut c_char) -> Option<()> {
     let default_target;
     if cfg!(target_arch = "aarch64") && (cfg!(target_os = "linux") || cfg!(target_os = "android")) {
@@ -1228,15 +1235,13 @@ pub unsafe fn main(mut argc: i32, mut argv: *mut*mut c_char) -> Option<()> {
     }
 
     if strcmp(*target_name, c!("list")) == 0 {
-        fprintf(stderr(), c!("Compilation targets:\n"));
-        for i in 0..TARGET_ORDER.len() {
-            fprintf(stderr(), c!("    %s\n"), (*TARGET_ORDER)[i].name());
-        }
+        print_available_targets();
         return Some(());
     }
 
     let Some(target) = Target::by_name(*target_name) else {
         usage();
+        print_available_targets();
         log(Log_Level::ERROR, c!("Unknown target `%s`"), *target_name);
         return None;
     };
@@ -1416,7 +1421,7 @@ pub unsafe fn main(mut argc: i32, mut argv: *mut*mut c_char) -> Option<()> {
                 codegen::uxn::run_program(&mut cmd, c!("uxnemu"), program_path, da_slice(run_args), None)?;
             }
         }
-        Target::Mos6502 => {
+        Target::Mos6502_Posix => {
             let config = codegen::mos6502::parse_config_from_link_flags(da_slice(*linker))?;
 
             codegen::mos6502::generate_program(
@@ -1427,7 +1432,7 @@ pub unsafe fn main(mut argc: i32, mut argv: *mut*mut c_char) -> Option<()> {
             )?;
 
             if *run {
-                codegen::mos6502::run_program(&mut output, config, program_path, None)?;
+                codegen::mos6502::run_program(&mut cmd, config, program_path, da_slice(run_args), None)?;
             }
         }
         Target::ILasm_Mono => {

src/b.rs

@@ -137,7 +137,7 @@ pub unsafe fn execute_test(
         Target::Gas_x86_64_Linux    => c!("gas-x86_64-linux"),
         Target::Gas_x86_64_Windows  => c!("exe"),
         Target::Uxn                 => c!("rom"),
-        Target::Mos6502             => c!("6502"),
+        Target::Mos6502_Posix       => c!("6502"),
         // TODO: ILasm_Mono may collide with Gas_x86_64_Windows if we introduce parallel runner
         Target::ILasm_Mono          => c!("exe"),
     });
@@ -163,9 +163,9 @@ pub unsafe fn execute_test(
         Target::Gas_x86_64_Windows  => codegen::gas_x86_64::run_program(cmd, program_path, &[], Some(stdout_path), Os::Windows),
         Target::Gas_x86_64_Darwin   => codegen::gas_x86_64::run_program(cmd, program_path, &[], Some(stdout_path), Os::Darwin),
         Target::Uxn                 => codegen::uxn::run_program(cmd, c!("uxncli"), program_path, &[], Some(stdout_path)),
-        Target::Mos6502             => codegen::mos6502::run_program(sb, Config {
+        Target::Mos6502_Posix       => codegen::mos6502::run_program(cmd, Config {
             load_offset: DEFAULT_LOAD_OFFSET
-        }, program_path, Some(stdout_path)),
+        }, program_path, &[], Some(stdout_path)),
         Target::ILasm_Mono          => codegen::ilasm_mono::run_program(cmd, program_path, &[], Some(stdout_path)),
     };
 
@@ -463,10 +463,6 @@ pub unsafe fn load_tt_from_json_file_if_exists(
                         target = Some(parsed_target);
                     } else {
                         jimp_diagf(jimp, c!("WARNING: invalid target name `%s`\n"), (*jimp).string);
-                        jimp_diagf(jimp, c!("NOTE: Expected target values are:\n"));
-                        for i in 0..TARGET_ORDER.len() {
-                            jimp_diagf(jimp, c!("NOTE:  %s\n"), (*TARGET_ORDER)[i]);
-                        }
                     }
                     continue 'row;
                 }
@@ -481,10 +477,6 @@ pub unsafe fn load_tt_from_json_file_if_exists(
                         state = parsed_state;
                     } else {
                         jimp_diagf(jimp, c!("WARNING: invalid state name `%s`\n"), (*jimp).string);
-                        jimp_diagf(jimp, c!("NOTE: Expected state values are:\n"));
-                        for i in 0..TEST_STATE_ORDER.len() {
-                            jimp_diagf(jimp, c!("NOTE:  %s\n"), (*TEST_STATE_ORDER)[i]);
-                        }
                     }
                     continue 'row;
                 }
@@ -501,14 +493,14 @@ pub unsafe fn load_tt_from_json_file_if_exists(
 
             let Some(target) = target else {
                 (*jimp).token_start = saved_point;
-                jimp_diagf(jimp, c!("ERROR: `target` is not defined for this test row. Ignoring the entire row...\n"));
+                jimp_diagf(jimp, c!("WARNING: no valid `target` field is defined for this test row. Ignoring the entire row...\n"));
                 // TODO: memory leak, we are dropping the whole row here
                 continue 'table;
             };
 
             if case_name.is_null() {
                 (*jimp).token_start = saved_point;
-                jimp_diagf(jimp, c!("ERROR: `case_name` is not defined for this test row. Ignoring the entire row...\n"));
+                jimp_diagf(jimp, c!("WARNING: no valid `case_name` field is defined for this test row. Ignoring the entire row...\n"));
                 // TODO: memory leak, we are dropping the whole row here
                 continue 'table;
             }

src/btest.rs

@@ -1493,95 +1493,23 @@ pub struct Config {
     pub load_offset: u16,
 }
 
-pub mod fake6502 {
-    use core::mem::zeroed;
-    use crate::nob::*;
-
-    pub static mut MEMORY: [u8; 1<<16] = unsafe { zeroed() };
-
-    pub unsafe fn load_rom_at(rom: String_Builder, offset: u16) {
-        for i in 0..rom.count {
-            MEMORY[i + offset as usize] = *rom.items.add(i) as u8;
-        }
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn read6502(address: u16) -> u8 {
-        MEMORY[address as usize]
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn write6502(address: u16, value: u8) {
-        MEMORY[address as usize] = value;
+pub unsafe fn run_program(cmd: *mut Cmd, config: Config, program_path: *const c_char, run_args: *const [*const c_char], stdout_path: Option<*const c_char>) -> Option<()> {
+    cmd_append!{
+        cmd,
+        c!("posix6502"), c!("-load-offset"), temp_sprintf(c!("%u"), config.load_offset as c_uint),
+        program_path
     }
-
-    extern "C" {
-        #[link_name = "reset6502"]
-        pub fn reset();
-        #[link_name = "step6502"]
-        pub fn step();
-        pub fn rts();
-        pub static mut pc: u16;
-        pub static mut sp: u16;
-        pub static mut a: u8;
-        pub static mut x: u8;
-        pub static mut y: u8;
+    if run_args.len() > 0 {
+        cmd_append!(cmd, c!("--"));
+        da_append_many(cmd, run_args);
     }
-
-}
-
-pub unsafe fn run_impl(output: *mut String_Builder, config: Config, stdout: *mut FILE) -> Option<()> {
-    fake6502::load_rom_at(*output, config.load_offset);
-    fake6502::reset();
-    fake6502::pc = config.load_offset;
-
-    // set reset to $0000 to exit on reset
-    fake6502::MEMORY[0xFFFC] = 0;
-    fake6502::MEMORY[0xFFFD] = 0;
-
-    while fake6502::pc != 0 { // The convetion is stop executing when pc == $0000
-        let prev_sp = fake6502::sp & 0xFF;
-        let opcode  = fake6502::MEMORY[fake6502::pc as usize];
-        fake6502::step();
-
-        let curr_sp = fake6502::sp & 0xFF;
-        if opcode == 0x48 && curr_sp > prev_sp { // PHA instruction
-            log(Log_Level::ERROR, c!("Stack overflow detected"));
-            log(Log_Level::ERROR, c!("SP changed from $%02X to $%02X after PHA instruction"), prev_sp as c_uint, curr_sp as c_uint);
-            return None;
-        }
-
-        if fake6502::pc == 0xFFEF { // Emulating wozmon ECHO routine
-            fprintf(stdout, c!("%c"), fake6502::a as c_uint);
-            fake6502::rts();
-        }
-    }
-    // print exit code (in Y:A)
-    let code = ((fake6502::y as c_uint) << 8) | fake6502::a as c_uint;
-    log(Log_Level::INFO, c!("Exited with code %hd"), code);
-
-    if code != 0 {
-        return None;
-    }
-    Some(())
-}
-
-pub unsafe fn run_program(output: *mut String_Builder, config: Config, program_path: *const c_char, stdout_path: Option<*const c_char>) -> Option<()> {
-    (*output).count = 0;
-    read_entire_file(program_path, output)?;
-
-    let stdout = if let Some(stdout_path) = stdout_path {
-        let stdout = fopen(stdout_path, c!("wb"));
-        if stdout.is_null() {
-            return None
-        }
-        stdout
+    if let Some(stdout_path) = stdout_path {
+        let mut fdout = fd_open_for_write(stdout_path);
+        let mut redirect: Cmd_Redirect = zeroed();
+        redirect.fdout = &mut fdout;
+        if !cmd_run_sync_redirect_and_reset(cmd, redirect) { return None; }
     } else {
-        stdout()
-    };
-    let result = run_impl(output, config, stdout);
-    if stdout_path.is_some() {
-        fclose(stdout);
+        if !cmd_run_sync_and_reset(cmd) { return None; }
     }
-    result
+    Some(())
 }