Write an ASM code

[zlfn]

Considering the future project direction, it seems necessary to create an in-line assembly.
However, there is a slight difference between the inline assembly for SDCC and the inline assembly for GCC that LLVM-CBE generates, and the inline assembly in Rust cannot be compiled directly for now.

fn test_asm() {
    unsafe {
        asm!("ret");
    }
}

#[no_mangle]
pub extern fn main() {
    test_asm();
    ...
}

This Rust code, compiled to C in below form.

void main(void) {
  __asm__ volatile ("ret"
        :
        :);
}

The problem is

1. SDCC does not have a keyword volatile.
2. SDCC do not support multiline in-line asm with :.

So, it seems necessary to parse this phrase and then post-process it.

[zlfn]

It also seems difficult to pass or receive variables in an in-line assembly. The fundamental problem is that Rust's in-line assembly depends on the platform, and we are building the code somewhere other than Rust's platform.

How can we solve this problem...?

Rust

#[inline(never)]
extern "C" fn test_asm() -> u8 {
    return unsafe {
        let e: u8;
        asm!("ld {}, #0x0000", out(reg) e);
        e
    }
}

LLVM

; out::test_asm
; Function Attrs: noinline nounwind
define internal fastcc noundef i8 @_ZN3out8test_asm17h09c831454c351d2dE() unnamed_addr addrspace(1) #0 {
start:
  %0 = tail call addrspace(0) i8 asm sideeffect alignstack "ld ${0}, #0x0000", "=&a,~{sreg},~{memory}"() #5, !srcloc !1
  ret i8 %0
}

C

static uint8_t _ZN3out8test_asm17h09c831454c351d2dE(void) {
  __asm__ ("ld %ld ${00}, #0x0000, #0x0000");
  return _1; //Error!
}

Maybe it have to write an inline function in C and link it to Rust.

[zlfn]

It seems reasonable to abandon the inline assembly, link the assembly file directly to the lcc, and use it like any other GBDK function.

The next task is to create a simple assembly function that "writes a value to a particular address" and call it in Rust.

If this is possible, all the other tasks dealing with hardware in Rust will be possible.

[zlfn]

Some reading materials for organizing
https://www.msx.org/forum/msx-talk/development/sdcc-4112-a-game-changer-for-c-programming
https://gbdev.io/pandocs/CPU_Instruction_Set.html

[zlfn]

In sdcccall(1) calling convention,
The arguments are passed in the order of a -> e -> stack and a return value passed to register a(8-bit) or de (16-bit).

[zlfn]

0c968b4

The assembly codes in the ./asm are now linked to the rom file while running cargo build-rom, and the assembly function can be executed from the Rust code.

I will add the feature that can call assembly from inline Rust code with proc_macro, etc.

[zlfn]

The problem with this method is that each function call results in overhead. (call and ret, etc)
It would be best to use the method of replacing it with SDCC's inline assembly, but it would be a bit of a hassle because we have to go through Rust parsing -> ASM extraction -> C file modification.