checkpoint the c -> rust asm flow for the BIO

An abomination: a zig-based C toolchain, installed via python,
compiles to clang assembly, translated by python script, into
Rust assembly. Then compiled and linked into your app.

Really tempting fate with this one...will I come back to this
commit in a couple years and be filled with regret?

Already, I have some misgivings - the zig toolchain is
definitely not stable, and has been through some API changes,
and doesn't run on all platforms. But - I forge ahead.
This commit is contained in:
bunnie 2026-02-20 02:19:46 +08:00
parent b932d7d755
commit db78b28b37
11 changed files with 1593 additions and 1 deletions

6
.gitignore vendored
View file

@ -96,4 +96,8 @@ signing/credentials
signing/fido-signer/target
# vscode extension support
tools-bao/.venv/
tools-bao/.venv/
# Zig artifacts
.zig-cache/
zig-out/

View file

@ -0,0 +1,173 @@
// build.zig
const std = @import("std");
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const linker_script = b.option(
[]const u8,
"linker",
"Path to linker script (optional)",
);
// Module name for the "dis" step: e.g. -Dmodule=math_test
// Defaults to "test" to match the legacy layout.
const module_name = b.option(
[]const u8,
"module",
"Subdirectory module to compile (e.g. math_test). " ++
"Expects <module>/main.c to exist.",
) orelse "test";
// -- RV32IMC target with x16-x31 reserved -------------------------
//
// The reserve_x* features tell LLVM's register allocator to never
// use these registers. This is the reliable way to reserve registers
// -- the -ffixed-xN C flags depend on the clang driver translating
// them into +reserve_xN target features, which zig cc may not do
// correctly when invoked as a system command.
const target = b.resolveTargetQuery(.{
.cpu_arch = .riscv32,
.os_tag = .freestanding,
.abi = .none,
.cpu_model = .{ .explicit = &std.Target.riscv.cpu.generic_rv32 },
.cpu_features_add = blk: {
var features = std.Target.Cpu.Feature.Set.empty;
features.addFeature(@intFromEnum(std.Target.riscv.Feature.m));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.c));
// Reserve x16-x31 for coprocessor use (FIFOs, special regs).
// This prevents the compiler from using these registers for
// general-purpose allocation, which would conflict with the
// inline asm in bio.h that reads/writes them directly.
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x16));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x17));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x18));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x19));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x20));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x21));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x22));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x23));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x24));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x25));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x26));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x27));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x28));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x29));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x30));
features.addFeature(@intFromEnum(std.Target.riscv.Feature.reserve_x31));
break :blk features;
},
});
// -- Build the firmware ELF (uses the selected module) ------------
const exe = b.addExecutable(.{
.name = "firmware",
.root_module = b.createModule(.{
.target = target,
.optimize = optimize,
}),
});
// main.c lives inside the module subdirectory
const main_c_path = b.pathJoin(&.{ module_name, "main.c" });
exe.root_module.addCSourceFile(.{
.file = b.path(main_c_path),
.flags = c_flags,
});
// Headers: module dir first (bio.h, fp.h, etc.), then top-level include/
exe.root_module.addIncludePath(b.path(module_name));
exe.root_module.addIncludePath(b.path("include"));
// -- Linker script ------------------------------------------------
if (linker_script) |ld| {
exe.setLinkerScript(b.path(ld));
}
b.installArtifact(exe);
// -- "zig build dis -Dmodule=<n>" - emit assembly -----------------
// Output: zig-out/<module_name>.s
//
// This invokes "zig cc -S" as a separate system command, so it does
// NOT inherit the target features from the resolveTargetQuery above.
// We must pass the reserve features explicitly via -mcpu.
const dis_step = b.step("dis", "Generate assembly from C source");
const dis_cmd = b.addSystemCommand(&.{
b.graph.zig_exe,
"cc",
"-S", // stop after compilation, emit assembly
"-fverbose-asm",
"-o",
});
dis_cmd.has_side_effects = true;
// The output filename is the module name with a .s extension.
const out_s_name = b.fmt("{s}.s", .{module_name});
const dis_output = dis_cmd.addOutputFileArg(out_s_name);
dis_cmd.addFileArg(b.path(main_c_path));
dis_cmd.addArgs(&.{
"-target",
"riscv32-freestanding",
// Pack the reserve features directly into the -mcpu string.
// This bypasses any issues with -ffixed-xN not being translated
// into LLVM target features by the zig cc driver.
"-mcpu=generic_rv32+m+c" ++
"+reserve_x16+reserve_x17+reserve_x18+reserve_x19" ++
"+reserve_x20+reserve_x21+reserve_x22+reserve_x23" ++
"+reserve_x24+reserve_x25+reserve_x26+reserve_x27" ++
"+reserve_x28+reserve_x29+reserve_x30+reserve_x31",
});
// Include paths for the compiler invocation
dis_cmd.addArg(b.fmt("-I{s}", .{module_name}));
dis_cmd.addArg("-Iinclude");
dis_cmd.addArgs(c_flags);
// Install the .s file into zig-out/ at the top level.
const install_dis = b.addInstallFile(dis_output, out_s_name);
dis_step.dependOn(&install_dis.step);
}
// ---------------------------------------------------------------------
// C compiler flags shared by both the ELF build and the dis step.
//
// Note: register reservation is NOT done here via -ffixed-xN because
// zig cc does not reliably translate those into LLVM +reserve_xN
// features. Instead, reservation is handled via:
// - cpu_features_add in the target query (ELF build)
// - the -mcpu string (dis step)
// The -ffixed-xN flags are kept as a belt-and-suspenders measure in
// case a future zig version starts honoring them, but they are not
// the primary mechanism.
// ---------------------------------------------------------------------
const c_flags = &[_][]const u8{
"-std=c11",
"-Wall",
"-Wextra",
"-ffreestanding",
"-fno-common",
"-ffunction-sections",
"-fdata-sections",
"-Os",
// Belt-and-suspenders: these may or may not be honored by zig cc,
// but the real reservation is done via target features (see above).
"-ffixed-x16",
"-ffixed-x17",
"-ffixed-x18",
"-ffixed-x19",
"-ffixed-x20",
"-ffixed-x21",
"-ffixed-x22",
"-ffixed-x23",
"-ffixed-x24",
"-ffixed-x25",
"-ffixed-x26",
"-ffixed-x27",
"-ffixed-x28",
"-ffixed-x29",
"-ffixed-x30",
"-ffixed-x31",
};

View file

@ -0,0 +1,662 @@
#!/usr/bin/env python3
"""
clang2rustasm.py - Convert clang RISC-V assembly output to Rust bio_code! macro invocations.
Usage:
python3 clang2rustasm.py <module> [options]
<module> is a subdirectory name such as "math_test".
The script looks for zig-out/<module>.s (produced by "zig build dis -Dmodule=<module>")
and writes the converted Rust source to <module>/<module>.rs.
Options:
--zig-out DIR Override the zig-out search directory (default: zig-out)
--fn-name NAME Function name for bio_code! (default: derived from module)
--start-label L Start label name (default: derived from module)
--end-label L End label name (default: derived from module)
--label-base N Starting numeric label number (default: 20)
-o FILE Override output file path
"""
import argparse
import re
import sys
import os
# ============================================================================
# Register translation: x16-x31 ABI names -> raw xN form
# x0-x15 ABI names are left as-is
# ============================================================================
HIGH_REG_MAP = {
"a6": "x16",
"a7": "x17",
"s2": "x18",
"s3": "x19",
"s4": "x20",
"s5": "x21",
"s6": "x22",
"s7": "x23",
"s8": "x24",
"s9": "x25",
"s10": "x26",
"s11": "x27",
"t3": "x28",
"t4": "x29",
"t5": "x30",
"t6": "x31",
}
# Directives to strip entirely
STRIP_DIRECTIVES = {
".attribute",
".file",
".ident",
".addrsig",
}
# Section directives to strip (matched by substring)
STRIP_SECTION_NAMES = {
'".note.GNU-stack"',
}
# Data directives we know how to handle, mapped to their byte width
DATA_DIRECTIVE_WIDTH = {
".byte": 1,
".half": 2,
".short": 2,
".word": 4,
".long": 4,
}
# ============================================================================
# Argument parsing and path resolution
# ============================================================================
def parse_args():
parser = argparse.ArgumentParser(
description="Convert clang RISC-V assembly to Rust bio_code! macro"
)
parser.add_argument(
"module",
help=(
"Module name (subdirectory). "
"Reads zig-out/<module>.s and writes <module>/<module>.rs."
),
)
parser.add_argument(
"-o", "--output",
help="Override output .rs file path",
)
parser.add_argument(
"--zig-out",
default="zig-out",
metavar="DIR",
help="Directory where zig places compiled .s files (default: zig-out)",
)
parser.add_argument("--fn-name", help="Function name for bio_code! (default: derived from module)")
parser.add_argument("--start-label", help="Start label name (default: derived from module)")
parser.add_argument("--end-label", help="End label name (default: derived from module)")
parser.add_argument(
"--label-base",
type=int,
default=20,
help="Starting numeric label number (default: 20)",
)
return parser.parse_args()
def resolve_paths(args):
"""
Resolve the input .s path and output .rs path from the module name.
Input: <zig-out>/<module>.s
Output: <module>/<module>.rs (or -o override)
"""
module = args.module
module = module.rstrip("/\\")
if module.endswith(".s"):
module = module[:-2]
safe = re.sub(r"[^a-zA-Z0-9]", "_", module).strip("_").lower()
fn_name = args.fn_name or f"{safe}_bio_code"
start_label = args.start_label or f"BM_{safe.upper()}_BIO_START"
end_label = args.end_label or f"BM_{safe.upper()}_BIO_END"
input_path = os.path.join(args.zig_out, f"{module}.s")
if args.output:
output_path = args.output
else:
output_path = os.path.join(module, f"{module}.rs")
return input_path, output_path, fn_name, start_label, end_label
# ============================================================================
# Directive helpers
# ============================================================================
def should_strip_directive(stripped):
for directive in STRIP_DIRECTIVES:
if stripped.startswith(directive):
return True
return False
def is_strip_section(stripped):
if stripped.startswith(".section"):
for name in STRIP_SECTION_NAMES:
if name in stripped:
return True
return False
def replace_registers(text):
"""Replace ABI register names for x16-x31 with raw xN form."""
for abi_name in sorted(HIGH_REG_MAP.keys(), key=len, reverse=True):
raw_name = HIGH_REG_MAP[abi_name]
pattern = r"(?<![a-zA-Z0-9_])" + re.escape(abi_name) + r"(?![a-zA-Z0-9_])"
text = re.sub(pattern, raw_name, text)
return text
# ============================================================================
# Pass 1a: Extract code lines from .text sections
# ============================================================================
def extract_all_code(lines):
"""
Extract all code from the assembly file, spanning multiple functions.
Returns a list of raw line strings inside .text sections.
Strips: .globl, .type, .size, .p2align, .Lfunc_end markers.
Keeps: instructions, local/function labels, #APP/#NO_APP, comments.
"""
code_lines = []
in_code_section = False
in_function = False
skip_in_body = {".globl", ".type ", ".size ", ".p2align"}
for line in lines:
stripped = line.strip()
if not stripped:
continue
if should_strip_directive(stripped):
continue
if is_strip_section(stripped):
continue
if stripped.startswith(".section"):
in_code_section = ".text" in stripped
continue
if not in_code_section:
continue
skip = any(stripped.startswith(d) for d in skip_in_body)
if skip:
continue
if stripped.startswith(".Lfunc_end"):
in_function = False
continue
func_label_match = re.match(r"^([a-zA-Z_]\w*)\s*:", stripped)
if func_label_match:
in_function = True
code_lines.append(stripped)
continue
if in_function:
code_lines.append(stripped)
return code_lines
# ============================================================================
# Pass 1b: Extract rodata objects from .rodata sections
#
# Returns a list of DataObject instances in source order.
# Each object represents one labeled symbol in a .rodata section.
# ============================================================================
class DataObject:
def __init__(self, name, align, entries, section):
self.name = name
self.align = align # alignment in bytes
self.entries = entries # list of (width_bytes, int_value)
self.section = section # original section string
def __repr__(self):
return f"DataObject({self.name!r}, align={self.align}, {len(self.entries)} entries)"
def extract_rodata(lines):
"""
Walk the file and collect all data objects from .rodata* sections.
Returns list of DataObject in source order.
"""
objects = []
in_rodata = False
current_section = None
current_obj = None
pending_align = 1
skip_obj_directives = {".globl", ".type ", ".size "}
for line in lines:
stripped = line.strip()
if not stripped:
continue
if should_strip_directive(stripped):
continue
if is_strip_section(stripped):
continue
# Section transitions
if stripped.startswith(".section"):
if current_obj is not None:
objects.append(current_obj)
current_obj = None
if ".rodata" in stripped:
in_rodata = True
m = re.match(r'\.section\s+([^\s,]+)', stripped)
current_section = m.group(1) if m else ".rodata"
pending_align = 1
else:
in_rodata = False
current_section = None
continue
if not in_rodata:
continue
# Alignment hint before the label
if stripped.startswith(".p2align"):
m = re.match(r'\.p2align\s+(\d+)', stripped)
if m:
pending_align = 1 << int(m.group(1))
continue
# Skip structural directives
if any(stripped.startswith(d) for d in skip_obj_directives):
continue
# Object label: starts a new DataObject
obj_label = re.match(r'^([a-zA-Z_]\w*)\s*:', stripped)
if obj_label:
if current_obj is not None:
objects.append(current_obj)
current_obj = DataObject(
name = obj_label.group(1),
align = pending_align,
entries = [],
section = current_section or ".rodata",
)
pending_align = 1
continue
# Data directives inside an object
if current_obj is not None:
for directive, width in DATA_DIRECTIVE_WIDTH.items():
if stripped.startswith(directive):
rest = stripped[len(directive):].strip()
rest = re.sub(r'\s*#.*$', '', rest).strip()
for val_str in rest.split(','):
val_str = val_str.strip()
if val_str:
try:
val = int(val_str, 0)
except ValueError:
val = 0
current_obj.entries.append((width, val))
break
if current_obj is not None:
objects.append(current_obj)
return objects
# ============================================================================
# Pack data entries into .word (32-bit) lines
#
# All entries are packed little-endian byte by byte, then grouped into
# 32-bit words. Padding zeros are added if the byte total is not
# a multiple of 4.
# ============================================================================
def pack_to_words(entries):
"""
Convert a list of (width_bytes, int_value) entries into a list of
32-bit unsigned integers, little-endian packed.
"""
byte_buf = []
for width, val in entries:
mask = (1 << (width * 8)) - 1
v = val & mask
for _ in range(width):
byte_buf.append(v & 0xFF)
v >>= 8
# Pad to multiple of 4
while len(byte_buf) % 4 != 0:
byte_buf.append(0)
words = []
for i in range(0, len(byte_buf), 4):
w = (byte_buf[i]
| (byte_buf[i+1] << 8)
| (byte_buf[i+2] << 16)
| (byte_buf[i+3] << 24))
words.append(w)
return words
# ============================================================================
# Label collection and unified mapping
# ============================================================================
def collect_all_labels(code_lines):
"""
Collect all labels defined in the code lines.
Returns dict: label_name -> line_index
"""
labels = {}
for i, line in enumerate(code_lines):
m = re.match(r"^(\.L\w+)\s*:", line)
if m:
labels[m.group(1)] = i
continue
m = re.match(r"^([a-zA-Z_]\w*)\s*:", line)
if m:
labels[m.group(1)] = i
continue
return labels
def build_label_map(code_labels, data_objects, label_base):
"""
Assign a unique numeric label to every code label and every data object
name. Code labels are ordered by source position; data labels follow
in source order. Data labels always get a higher number than code labels
because they appear after the code block in the macro output.
Returns label_map: name -> int
"""
label_map = {}
n = label_base
for name in sorted(code_labels.keys(), key=lambda k: code_labels[k]):
label_map[name] = n
n += 1
for obj in data_objects:
label_map[obj.name] = n
n += 1
return label_map
# ============================================================================
# Pass 2: Convert individual code lines
# ============================================================================
def convert_line(line, label_map, label_positions, current_line_idx):
"""
Convert a single code line to its Rust inline-asm string equivalent.
Returns (instruction_string_or_None, comment_or_None).
label_positions must contain an entry for every name in label_map.
Data labels should be mapped to len(code_lines) so they always appear
as forward references from any code position.
"""
stripped = line.strip()
if stripped == "#APP":
return None, "// --- inline asm begin ---"
if stripped == "#NO_APP":
return None, "// --- inline asm end ---"
# Label definition
label_def_match = re.match(r"^(\.L\w+|[a-zA-Z_]\w*)\s*:\s*(.*)", stripped)
if label_def_match:
label_name = label_def_match.group(1)
rest = label_def_match.group(2).strip()
if label_name in label_map:
num = label_map[label_name]
result = f"{num}:"
trailing_comment = None
if rest:
comment_m = re.match(r"^#\s*(.*)", rest)
if comment_m:
trailing_comment = f"// {label_name}: {comment_m.group(1).strip()}"
else:
result += f" {rest}"
if not trailing_comment:
trailing_comment = f"// {label_name}"
return result, trailing_comment
return stripped, None
# Pure comment / block marker lines
if stripped.startswith("#") or stripped.startswith("//"):
bb_match = re.match(r"^#\s*%bb\.\d+", stripped)
if bb_match:
rest = re.sub(r"^#\s*%bb\.\d+:?\s*", "", stripped).strip()
rest = re.sub(r"^#\s*", "", rest).strip()
if rest:
return None, f"// {rest}"
return None, None
comment_text = re.sub(r"^[#/]+\s*", "", stripped).strip()
if comment_text:
return None, f"// {comment_text}"
return None, None
# Instruction line: split off trailing comment
comment = None
instr = stripped
comment_match = re.search(r"\s+#\s*(.*)", instr)
if comment_match:
comment = f"// {comment_match.group(1).strip()}"
instr = instr[: comment_match.start()].strip()
# Replace %hi(label) and %lo(label) with numeric forward-ref equivalents.
# Data labels are always forward refs; code labels use position comparison.
def replace_reloc(m):
kind = m.group(1)
lname = m.group(2)
if lname in label_map:
num = label_map[lname]
lpos = label_positions.get(lname, current_line_idx + 1)
ref = f"{num}f" if lpos > current_line_idx else f"{num}b"
return f"%{kind}({ref})"
return m.group(0)
instr = re.sub(r'%(\w+)\(([a-zA-Z_]\w*)\)', replace_reloc, instr)
# Replace plain label references (branches, jumps, address loads).
# Longest names first to avoid partial matches.
for label_name in sorted(label_map.keys(), key=len, reverse=True):
num = label_map[label_name]
if label_name not in instr:
continue
lpos = label_positions.get(label_name, current_line_idx + 1)
ref = f"{num}f" if lpos > current_line_idx else f"{num}b"
pattern = r"(?<![a-zA-Z0-9_.])" + re.escape(label_name) + r"(?![a-zA-Z0-9_])"
instr = re.sub(pattern, ref, instr)
instr = replace_registers(instr)
return instr, comment
# ============================================================================
# Format the final macro output
# ============================================================================
def p2align_power(align_bytes):
"""Convert an alignment in bytes to a .p2align exponent."""
if align_bytes <= 1:
return 0
return (align_bytes).bit_length() - 1
def format_output(fn_name, start_label, end_label, converted_lines, data_objects, label_map):
"""
Emit the complete bio_code! macro invocation.
Layout inside the macro:
1. Code instructions (with numeric labels inline)
2. For each rodata object:
.section <name>
.p2align <N>
<num>: <- numeric label for the object
.word 0x... <- packed 32-bit words
"""
parts = []
parts.append("use bao1x_api::bio_code;\n")
parts.append("#[rustfmt::skip]")
parts.append(f"bio_code!({fn_name}, {start_label}, {end_label},")
# ---- Code ----
filtered = [(instr, comment) for instr, comment in converted_lines
if instr is not None or comment is not None]
for i, (instr, comment) in enumerate(filtered):
is_last_instr = (instr is not None) and all(
fi is None for fi, _ in filtered[i + 1:]
)
if instr is None and comment is not None:
parts.append(f" {comment}")
continue
# A comma is needed after the last code instruction if data follows
needs_comma = not is_last_instr or bool(data_objects)
quoted = f' "{instr}"'
if needs_comma:
quoted += ","
if comment:
quoted += f" {comment}"
parts.append(quoted)
# ---- Data sections ----
for oi, obj in enumerate(data_objects):
num = label_map[obj.name]
words = pack_to_words(obj.entries)
pow2 = p2align_power(obj.align)
parts.append(f" // --- rodata: {obj.name} ({len(obj.entries)} entries, {len(words)} words) ---")
# parts.append(f' ".section {obj.section}",') # don't emit this, we want the data in-lined
parts.append(f' ".p2align {pow2}",')
parts.append(f' "{num}:", // {obj.name}')
is_last_obj = (oi == len(data_objects) - 1)
for wi, w in enumerate(words):
is_last_word = (wi == len(words) - 1)
is_very_last = is_last_obj and is_last_word
comma = "" if is_very_last else ","
# Annotate with the original values that went into this word
byte_offset = wi * 4
n_entries_in_word = 4 // (obj.entries[0][0] if obj.entries else 4)
entry_start = wi * n_entries_in_word
entry_end = min(entry_start + n_entries_in_word, len(obj.entries))
vals = ", ".join(str(obj.entries[j][1]) for j in range(entry_start, entry_end))
parts.append(f' ".word 0x{w:08x}"{comma} // [{byte_offset}] {vals}')
parts.append(");")
return "\n".join(parts)
# ============================================================================
# Main
# ============================================================================
def main():
args = parse_args()
input_path, output_path, fn_name, start_label, end_label = resolve_paths(args)
if not os.path.exists(input_path):
print(
f"Error: assembly file not found: {input_path}\n"
f" Run: python3 -m ziglang build dis -Dmodule={args.module}",
file=sys.stderr,
)
sys.exit(1)
out_dir = os.path.dirname(output_path)
if out_dir and not os.path.isdir(out_dir):
print(
f"Error: output directory does not exist: {out_dir}\n"
f" Create the module subdirectory first.",
file=sys.stderr,
)
sys.exit(1)
with open(input_path, "r") as f:
lines = f.readlines()
# Pass 1a: extract code
code_lines = extract_all_code(lines)
if not code_lines:
print(f"Error: no code found in {input_path}", file=sys.stderr)
sys.exit(1)
# Pass 1b: extract rodata
data_objects = extract_rodata(lines)
# Build unified label map
code_label_positions = collect_all_labels(code_lines)
label_map = build_label_map(code_label_positions, data_objects, args.label_base)
# Sentinel positions for data labels: they are always forward from code
all_label_positions = dict(code_label_positions)
for obj in data_objects:
all_label_positions[obj.name] = len(code_lines)
# Diagnostics
data_names = {o.name for o in data_objects}
print("Label mapping:", file=sys.stderr)
for name, num in sorted(label_map.items(), key=lambda x: x[1]):
pos = all_label_positions[name]
kind = " (data)" if name in data_names else ""
print(f" {name:20s} -> {num}: (line {pos}){kind}", file=sys.stderr)
if data_objects:
print(f"\nData objects ({len(data_objects)}):", file=sys.stderr)
for obj in data_objects:
words = pack_to_words(obj.entries)
print(f" {obj.name}: {len(obj.entries)} entries -> {len(words)} words "
f"(section={obj.section}, align={obj.align})", file=sys.stderr)
# Pass 2: convert code lines
converted = []
for i, line in enumerate(code_lines):
instr, comment = convert_line(line, label_map, all_label_positions, i)
if instr is not None or comment is not None:
converted.append((instr, comment))
while converted and converted[-1] == (None, None):
converted.pop()
result = format_output(fn_name, start_label, end_label, converted, data_objects, label_map)
with open(output_path, "w") as f:
f.write(result + "\n")
print(f"\nWrote {output_path}", file=sys.stderr)
print(f" input: {input_path}", file=sys.stderr)
print(f" fn: {fn_name}()", file=sys.stderr)
print(f" labels: {start_label} / {end_label}", file=sys.stderr)
num_instrs = sum(1 for instr, _ in converted if instr is not None)
print(f" instructions: {num_instrs}", file=sys.stderr)
func_labels = [n for n in label_map if not n.startswith('.') and n not in data_names]
print(f" functions found: {len(func_labels)} ({', '.join(func_labels)})", file=sys.stderr)
if __name__ == "__main__":
main()

View file

@ -0,0 +1,55 @@
#include <stdint.h>
// pop_fifoN: read from reserved register xN.
// volatile prevents the compiler from caching or dropping the read.
static inline __attribute__((always_inline)) uint32_t pop_fifo0() {
uint32_t rx;
__asm__ volatile ("mv %0, x16" : "=r"(rx));
return rx;
}
static inline __attribute__((always_inline)) uint32_t pop_fifo1() {
uint32_t rx;
__asm__ volatile ("mv %0, x17" : "=r"(rx));
return rx;
}
static inline __attribute__((always_inline)) uint32_t pop_fifo2() {
uint32_t rx;
__asm__ volatile ("mv %0, x18" : "=r"(rx));
return rx;
}
static inline __attribute__((always_inline)) uint32_t pop_fifo3() {
uint32_t rx;
__asm__ volatile ("mv %0, x19" : "=r"(rx));
return rx;
}
// push_fifoN: write to reserved register xN.
// "memory" clobber is the key fix: it tells the compiler this asm has an
// observable side effect beyond the registers listed, so it cannot
// dead-code-eliminate the computation feeding the push even at -Os.
static inline __attribute__((always_inline)) void push_fifo0(uint32_t tx) {
__asm__ volatile ("mv x16, %0" : : "r"(tx) : "memory");
}
static inline __attribute__((always_inline)) void push_fifo1(uint32_t tx) {
__asm__ volatile ("mv x17, %0" : : "r"(tx) : "memory");
}
static inline __attribute__((always_inline)) void push_fifo2(uint32_t tx) {
__asm__ volatile ("mv x18, %0" : : "r"(tx) : "memory");
}
static inline __attribute__((always_inline)) void push_fifo3(uint32_t tx) {
__asm__ volatile ("mv x19, %0" : : "r"(tx) : "memory");
}
__attribute__((naked, section(".text._start")))
void _start(void) {
__asm__ volatile (
"li sp, 0x1000\n" // Load stack pointer to 0xE00
"j main\n" // Jump to main
);
}

View file

@ -0,0 +1,235 @@
/*
* fp.h - Fixed-point math library
*
* Format: configurable Q format via FP_FRAC_BITS
* Default: Q20.12 (20 integer bits, 12 fractional bits)
*
* Representation: signed 32-bit integer
* Range (Q20.12): -524288.0 to +524287.9998
* Resolution: 1/4096 ~= 0.000244
*/
#ifndef FP_H
#define FP_H
#include <stdint.h>
#include <stddef.h>
/* --- Configuration --- */
#ifndef FP_FRAC_BITS
#define FP_FRAC_BITS 12
#endif
#define FP_ONE (1 << FP_FRAC_BITS)
#define FP_MASK (FP_ONE - 1)
typedef int32_t fp_t;
/* --- Constants ---
*
* All computed at compile time from integer literals so the preprocessor
* never emits a divide or a float-to-int conversion at runtime.
*
* At Q12 (FP_ONE = 4096):
* PI = round(3.14159265 * 4096) = 12868
* TWO_PI = 25736
* HALF_PI = 6434 (== PI/2, exact: 3.14159265/2*4096 = 6433.98 -> 6434)
*/
#define FP_PI ((fp_t)(3.14159265f * FP_ONE + 0.5f))
#define FP_TWO_PI ((fp_t)(6.28318530f * FP_ONE + 0.5f))
#define FP_HALF_PI ((fp_t)(1.57079632f * FP_ONE + 0.5f))
/* --- Conversion --- */
#define FP_FROM_INT(x) ((fp_t)((x) << FP_FRAC_BITS))
#define FP_TO_INT(x) ((int32_t)((x) >> FP_FRAC_BITS))
#define FP_FROM_FLOAT(x) ((fp_t)((x) * FP_ONE + 0.5f))
#define FP_TO_FLOAT(x) ((float)(x) / FP_ONE)
/* --- Arithmetic --- */
static inline fp_t fp_add(fp_t a, fp_t b)
{
return a + b;
}
static inline fp_t fp_sub(fp_t a, fp_t b)
{
return a - b;
}
/*
* fp_mul - fixed-point multiply using RISC-V mulh/mul pair.
*
* Reconstructs the full 64-bit product from the high (mulh) and low (mul)
* 32-bit words, then shifts right by FP_FRAC_BITS to re-align the binary
* point. The early-clobber on 'hi' (&) prevents the compiler from aliasing
* it with an input register.
*/
static inline fp_t fp_mul(fp_t a, fp_t b)
{
int32_t hi, lo;
__asm__ (
"mulh %0, %2, %3\n"
"mul %1, %2, %3\n"
: "=&r"(hi), "=r"(lo)
: "r"(a), "r"(b)
);
return (fp_t)(((uint32_t)hi << (32 - FP_FRAC_BITS)) |
((uint32_t)lo >> FP_FRAC_BITS));
}
/*
* u32_divrem - unsigned 32-bit shift-and-subtract divider.
*
* 32 iterations of: shift one bit of the dividend into the partial
* remainder, subtract the divisor if it fits, record the quotient bit.
* No hardware divide instruction required.
*/
static inline uint32_t u32_divrem(uint32_t dividend, uint32_t divisor,
uint32_t *remainder)
{
uint32_t quotient = 0;
uint32_t rem = 0;
int i;
for (i = 31; i >= 0; i--) {
rem = (rem << 1) | ((dividend >> i) & 1);
if (rem >= divisor) {
rem -= divisor;
quotient |= (1u << i);
}
}
if (remainder) *remainder = rem;
return quotient;
}
/*
* fp_div - signed fixed-point division, no hardware divide.
*
* Works in two passes through u32_divrem:
* pass 1: integer quotient and remainder of |a| / |b|
* pass 2: fractional bits from (remainder << FP_FRAC_BITS) / |b|
* Sign is restored at the end.
*
* Note: r << FP_FRAC_BITS is safe because r < ub after pass 1, and
* ub is a Q12 value so fits comfortably within 32 bits after the shift.
*/
static inline fp_t fp_div(fp_t a, fp_t b)
{
int32_t sign = ((a ^ b) < 0) ? -1 : 1;
uint32_t ua = (uint32_t)(a < 0 ? -a : a);
uint32_t ub = (uint32_t)(b < 0 ? -b : b);
uint32_t q, r;
fp_t res;
q = u32_divrem(ua, ub, &r);
res = (fp_t)((q << FP_FRAC_BITS) | u32_divrem(r << FP_FRAC_BITS, ub, NULL));
return sign < 0 ? -res : res;
}
/* --- Trigonometry --- */
#define COS_TABLE_ENTRIES 64
/*
* Lookup table for cos(i/64 * pi/2) in Q12, i = 0..64.
*
* Generated by:
* import math
* N, Q = 64, 4096
* [round(math.cos(i/N * math.pi/2) * Q) for i in range(N+1)]
*
* Covers one quadrant [0, pi/2]; the other three are handled by symmetry.
* Values fit in int16_t (max 4096 <= 32767).
*/
static const int16_t cos_table[COS_TABLE_ENTRIES + 1] = {
4096, 4096, 4095, 4094, 4092, 4090, 4087, 4083,
4078, 4073, 4067, 4060, 4052, 4044, 4035, 4025,
4014, 4003, 3991, 3978, 3964, 3950, 3935, 3919,
3902, 3885, 3867, 3848, 3828, 3807, 3786, 3764,
3741, 3718, 3694, 3669, 3643, 3617, 3590, 3563,
3535, 3506, 3477, 3447, 3417, 3386, 3354, 3322,
3289, 3256, 3222, 3188, 3153, 3118, 3082, 3046,
3009, 2972, 2935, 2897, 2859, 2820, 2781, 2742,
2702
};
/*
* fp_cos - cosine via table lookup + linear interpolation.
*
* Symmetry used to cover the full circle from the [0, pi/2] table:
* [0, pi/2]: cos(x) -> table forward
* [pi/2, pi]: cos(pi - x) -> table forward, negated
* [pi, 3pi/2]: cos(x - pi) -> same as above by symmetry
* [3pi/2, 2pi]: cos(2pi - x) -> table forward
*
* Range reduction uses only addition/subtraction (no divide).
* The single fp_div call inside scales x to a table index.
*
* FP_HALF_PI, FP_PI, FP_TWO_PI are all compile-time constants so no
* runtime divide is emitted for them.
*/
static inline fp_t fp_cos(fp_t x)
{
int32_t negate = 0;
int32_t idx;
fp_t offset, frac, lo, hi;
/* --- Range-reduce to [0, 2*pi) using only add/subtract --- */
/* Handle large negative values first */
if (x < 0) {
/* How many full 2*pi below zero? Round up, then add. */
int32_t periods = FP_TO_INT(-x) / FP_TO_INT(FP_TWO_PI) + 1;
x += (fp_t)(periods * FP_TWO_PI);
}
/* Handle large positive values */
while (x >= FP_TWO_PI) {
x -= FP_TWO_PI;
}
/* --- Quadrant reduction to [0, pi/2] --- */
/* [pi, 2*pi] -> [0, pi]: cos(2pi - x) = cos(x), no sign change */
if (x > FP_PI) {
x = FP_TWO_PI - x;
}
/* [pi/2, pi] -> [0, pi/2]: cos(pi - x) = -cos(x), flip sign */
if (x > FP_HALF_PI) {
x = FP_PI - x;
negate = 1;
}
/* --- Scale x in [0, pi/2] to a table index in [0, 64] --- */
/*
* offset = x / (pi/2) * 64
* = x * 64 / HALF_PI
*
* x <= HALF_PI = 6434, so x * 64 <= 411776, well within int32_t.
* We do the multiply first (shift left 6) then divide, keeping
* everything in fixed-point so the result is still Q12.
*/
offset = fp_div(x << 6, FP_HALF_PI); /* result in Q12, range [0, 64<<12] */
idx = FP_TO_INT(offset); /* integer table index, 0..64 */
frac = offset & FP_MASK; /* fractional part for lerp, Q12 */
/* Clamp: x == pi/2 exactly maps to index 64, which is the last entry */
if (idx >= COS_TABLE_ENTRIES) {
idx = COS_TABLE_ENTRIES - 1;
frac = FP_ONE;
}
/* --- Linear interpolation between adjacent table entries --- */
lo = (fp_t)cos_table[idx];
hi = (fp_t)cos_table[idx + 1];
offset = lo + fp_mul(hi - lo, frac); /* result is Q12 */
return negate ? -offset : offset;
}
#endif /* FP_H */

View file

@ -0,0 +1,32 @@
#include <stdint.h>
#include "fp.h"
#include "bio.h"
void main(void) {
int32_t in;
fp_t arg;
fp_t result;
// fp_t state = FP_FROM_INT(1);
// fp_t a;
// computes fifo1 <- cosine(fifo0), where the value presented is in degrees
while (1) {
in = pop_fifo0();
arg = FP_FROM_INT(in);
// arg = arg * pi / 180
arg = fp_mul(arg, FP_PI);
arg = fp_div(arg, FP_FROM_INT(180));
arg = fp_cos(arg);
result = fp_mul(arg, FP_FROM_INT(10));
/*
arg = FP_FROM_INT(in);
a = fp_mul(arg, FP_FROM_INT(2));
a = fp_add(state, a);
result = fp_div(a, state);
state = arg;
*/
push_fifo1(FP_TO_INT(result));
}
}

View file

@ -0,0 +1,291 @@
use bao1x_api::bio_code;
#[rustfmt::skip]
bio_code!(math_test_bio_code, BM_MATH_TEST_BIO_START, BM_MATH_TEST_BIO_END,
"20:", // _start: @_start
// --- inline asm begin ---
"lui sp, 1",
"j 21f",
// --- inline asm end ---
"21:", // main: @main
"addi sp, sp, -48",
"sw ra, 44(sp)", // 4-byte Folded Spill
"sw s0, 40(sp)", // 4-byte Folded Spill
"sw s1, 36(sp)", // 4-byte Folded Spill
"lui a1, 6",
"lui a3, 3",
"li ra, 1",
"lui s0, 1048396",
"li t0, -1",
"lui a4, 699051",
"lui a5, 0xa2f06",
"lui a2, 0x9",
"slli a2, a2, 4",
"add a5, a2, a5",
"lui a0, 2",
"lui s1, 1048574",
"addi a2, a1, 1160",
"sw a2, 12(sp)", // 4-byte Folded Spill
"addi a2, a3, 580",
"sw a2, 32(sp)", // 4-byte Folded Spill
"addi a2, a4, -1365",
"sw a2, 4(sp)", // 4-byte Folded Spill
"addi a1, a1, 1159",
"sw a1, 16(sp)", // 4-byte Folded Spill
"addi a1, a5, 1317",
"sw a1, 8(sp)", // 4-byte Folded Spill
"addi a0, a0, -1757",
"sw a0, 28(sp)", // 4-byte Folded Spill
"addi t1, s1, 1758",
"22:", // .LBB1_1: =>This Loop Header: Depth=1
// Child Loop BB1_2 Depth 2
// Child Loop BB1_4 Depth 2
// Child Loop BB1_16 Depth 2
// Child Loop BB1_18 Depth 2
"li a3, 0",
"li s1, 0",
// --- inline asm begin ---
"mv a1, x16",
// --- inline asm end ---
"slli a1, a1, 12",
"lw a0, 32(sp)", // 4-byte Folded Reload
// --- inline asm begin ---
"mulh a4, a1, a0",
"mul a1, a1, a0",
// --- inline asm end ---
"srli a1, a1, 12",
"slli a4, a4, 19",
"slli a4, a4, 1",
"or t2, a4, a1",
"srai a4, a4, 31",
"xor a1, t2, a4",
"sub a4, a1, a4",
"li a5, 31",
"23:", // .LBB1_2: Parent Loop BB1_1 Depth=1
// => This Inner Loop Header: Depth=2
"slli a3, a3, 1",
"srl a1, a4, a5",
"sll a0, ra, a5",
"addi a5, a5, -1",
"andi a1, a1, 1",
"or a1, a1, a3",
"srli a3, a3, 14",
"sltiu a3, a3, 45",
"addi a3, a3, -1",
"and a0, a0, a3",
"and a3, a3, s0",
"or s1, s1, a0",
"add a3, a3, a1",
"bne a5, t0, 23b",
// in Loop: Header=BB1_1 Depth=1
"li a1, 0",
"li a4, 0",
"slli a5, a3, 12",
"li a3, 31",
"24:", // .LBB1_4: Parent Loop BB1_1 Depth=1
// => This Inner Loop Header: Depth=2
"slli a1, a1, 1",
"srl a0, a5, a3",
"sll a2, ra, a3",
"addi a3, a3, -1",
"andi a0, a0, 1",
"or a0, a0, a1",
"srli a1, a1, 14",
"sltiu a1, a1, 45",
"addi a1, a1, -1",
"and a2, a2, a1",
"and a1, a1, s0",
"or a4, a4, a2",
"add a1, a1, a0",
"bne a3, t0, 24b",
// in Loop: Header=BB1_1 Depth=1
"slli s1, s1, 12",
"or a4, a4, s1",
"bgez t2, 25f",
// in Loop: Header=BB1_1 Depth=1
"neg a4, a4",
"25:", // .LBB1_7: in Loop: Header=BB1_1 Depth=1
"lw a2, 12(sp)", // 4-byte Folded Reload
"bgez a4, 26f",
// in Loop: Header=BB1_1 Depth=1
"neg a0, a4",
"lw a1, 4(sp)", // 4-byte Folded Reload
"mulhu a0, a0, a1",
"srli a0, a0, 14",
"mul a0, a0, a2",
"add a4, a4, a2",
"add a4, a4, a0",
"26:", // .LBB1_9: in Loop: Header=BB1_1 Depth=1
"mv a1, a4",
"lw a0, 16(sp)", // 4-byte Folded Reload
"blt a0, a4, 27f",
// in Loop: Header=BB1_1 Depth=1
"lw a1, 16(sp)", // 4-byte Folded Reload
"27:", // .LBB1_11: in Loop: Header=BB1_1 Depth=1
"lw a0, 8(sp)", // 4-byte Folded Reload
"mulhu a0, a1, a0",
"sub a1, a1, a1",
"srli a0, a0, 14",
"mul a0, a0, a2",
"add a1, a1, a4",
"sub a1, a1, a0",
"lw a0, 32(sp)", // 4-byte Folded Reload
"bge a0, a1, 28f",
// in Loop: Header=BB1_1 Depth=1
"sub a1, a2, a1",
"28:", // .LBB1_13: in Loop: Header=BB1_1 Depth=1
"mv a3, a1",
"lw a0, 28(sp)", // 4-byte Folded Reload
"blt a1, a0, 29f",
// in Loop: Header=BB1_1 Depth=1
"lw a0, 32(sp)", // 4-byte Folded Reload
"sub a3, a0, a1",
"29:", // .LBB1_15: in Loop: Header=BB1_1 Depth=1
"sw a1, 24(sp)", // 4-byte Folded Spill
"li ra, 0",
"li s1, 0",
"slli a3, a3, 6",
"srai a0, a3, 31",
"sw a3, 20(sp)", // 4-byte Folded Spill
"xor a4, a3, a0",
"sub a4, a4, a0",
"li a3, 31",
"li s0, 1",
"lui a1, 2",
"30:", // .LBB1_16: Parent Loop BB1_1 Depth=1
// => This Inner Loop Header: Depth=2
"slli ra, ra, 1",
"srl a0, a4, a3",
"addi t2, a1, -1758",
"sll a2, s0, a3",
"addi a3, a3, -1",
"andi a0, a0, 1",
"or a0, a0, ra",
"sltu a5, ra, t2",
"addi a5, a5, -1",
"and a2, a2, a5",
"and a5, a5, t1",
"or s1, s1, a2",
"add ra, a5, a0",
"bne a3, t0, 30b",
// in Loop: Header=BB1_1 Depth=1
"li a5, 0",
"li a4, 0",
"slli ra, ra, 12",
"li a3, 31",
"31:", // .LBB1_18: Parent Loop BB1_1 Depth=1
// => This Inner Loop Header: Depth=2
"slli a5, a5, 1",
"srl a0, ra, a3",
"sll a2, s0, a3",
"addi a3, a3, -1",
"andi a0, a0, 1",
"or a0, a0, a5",
"sltu a5, a5, t2",
"addi a5, a5, -1",
"and a2, a2, a5",
"and a5, a5, t1",
"or a4, a4, a2",
"add a5, a5, a0",
"bne a3, t0, 31b",
// in Loop: Header=BB1_1 Depth=1
"slli a3, s1, 12",
"or a3, a3, a4",
"lw a1, 24(sp)", // 4-byte Folded Reload
"addi sp, sp, -4",
"lw a0, 24(sp)", // 4-byte Folded Reload
"addi sp, sp, 4",
"bgez a0, 32f",
// in Loop: Header=BB1_1 Depth=1
"neg a3, a3",
"32:", // .LBB1_21: in Loop: Header=BB1_1 Depth=1
"lui s0, 1048396",
"li ra, 1",
"srai a4, a3, 12",
"li a5, 63",
"bge a5, a4, 33f",
// in Loop: Header=BB1_1 Depth=1
"lui a3, 1",
"bge a4, a5, 34f",
"j 35f",
"33:", // .LBB1_23: in Loop: Header=BB1_1 Depth=1
"slli a3, a3, 19",
"slli a3, a3, 1",
"srli a3, a3, 19",
"srli a3, a3, 1",
"blt a4, a5, 35f",
"34:", // .LBB1_24: in Loop: Header=BB1_1 Depth=1
"li a4, 63",
"35:", // .LBB1_25: in Loop: Header=BB1_1 Depth=1
"slli a4, a4, 1",
"lui a0, %hi(37f)",
"addi a0, a0, %lo(37f)",
"add a4, a4, a0",
"lh a0, 0(a4)",
"lh a2, 2(a4)",
"sub a2, a2, a0",
// --- inline asm begin ---
"mulh a4, a2, a3",
"mul a2, a2, a3",
// --- inline asm end ---
"srli a2, a2, 12",
"slli a4, a4, 19",
"slli a4, a4, 1",
"or a2, a2, a4",
"add a3, a2, a0",
"lw a0, 28(sp)", // 4-byte Folded Reload
"blt a1, a0, 36f",
// in Loop: Header=BB1_1 Depth=1
"neg a3, a3",
"36:", // .LBB1_27: in Loop: Header=BB1_1 Depth=1
"lui a1, 10",
// --- inline asm begin ---
"mulh a0, a3, a1",
"mul a1, a3, a1",
// --- inline asm end ---
"srli a1, a1, 12",
"slli a0, a0, 19",
"slli a0, a0, 1",
"or a0, a0, a1",
"srai a0, a0, 12",
// --- inline asm begin ---
"mv x17, a0",
// --- inline asm end ---
"j 22b",
// --- rodata: cos_table (65 entries, 33 words) ---
".p2align 1",
"37:", // cos_table
".word 0x10001000", // [0] 4096, 4096
".word 0x0ffe0fff", // [4] 4095, 4094
".word 0x0ffa0ffc", // [8] 4092, 4090
".word 0x0ff30ff7", // [12] 4087, 4083
".word 0x0fe90fee", // [16] 4078, 4073
".word 0x0fdc0fe3", // [20] 4067, 4060
".word 0x0fcc0fd4", // [24] 4052, 4044
".word 0x0fb90fc3", // [28] 4035, 4025
".word 0x0fa30fae", // [32] 4014, 4003
".word 0x0f8a0f97", // [36] 3991, 3978
".word 0x0f6e0f7c", // [40] 3964, 3950
".word 0x0f4f0f5f", // [44] 3935, 3919
".word 0x0f2d0f3e", // [48] 3902, 3885
".word 0x0f080f1b", // [52] 3867, 3848
".word 0x0edf0ef4", // [56] 3828, 3807
".word 0x0eb40eca", // [60] 3786, 3764
".word 0x0e860e9d", // [64] 3741, 3718
".word 0x0e550e6e", // [68] 3694, 3669
".word 0x0e210e3b", // [72] 3643, 3617
".word 0x0deb0e06", // [76] 3590, 3563
".word 0x0db20dcf", // [80] 3535, 3506
".word 0x0d770d95", // [84] 3477, 3447
".word 0x0d3a0d59", // [88] 3417, 3386
".word 0x0cfa0d1a", // [92] 3354, 3322
".word 0x0cb80cd9", // [96] 3289, 3256
".word 0x0c740c96", // [100] 3222, 3188
".word 0x0c2e0c51", // [104] 3153, 3118
".word 0x0be60c0a", // [108] 3082, 3046
".word 0x0b9c0bc1", // [112] 3009, 2972
".word 0x0b510b77", // [116] 2935, 2897
".word 0x0b040b2b", // [120] 2859, 2820
".word 0x0ab60add", // [124] 2781, 2742
".word 0x00000a8e" // [128] 2702
);

View file

@ -0,0 +1,88 @@
mod math_test;
use bao1x_api::bio::*;
use bao1x_api::bio_resources::*;
use bao1x_hal::bio::{Bio, CoreCsr};
use math_test::*;
use utralib::utra::bio_bdma;
pub struct MathTest {
bio_ss: Bio,
// handles have to be kept around or else the underlying CSR is dropped
_tx_handle: CoreHandle,
_rx_handle: CoreHandle,
// the CoreCsr is a convenience object that manages the CSR view of the handle
tx: CoreCsr,
rx: CoreCsr,
// tracks the resources used by the object
resource_grant: ResourceGrant,
}
impl Resources for MathTest {
fn resource_spec() -> ResourceSpec {
ResourceSpec {
claimer: "math-test".to_string(),
cores: vec![CoreRequirement::Any],
fifos: vec![Fifo::Fifo0, Fifo::Fifo1],
static_pins: vec![],
dynamic_pin_count: 0,
}
}
}
impl Drop for MathTest {
fn drop(&mut self) {
for &core in self.resource_grant.cores.iter() {
self.bio_ss.de_init_core(core).unwrap();
}
self.bio_ss.release_resources(self.resource_grant.grant_id).unwrap();
}
}
impl MathTest {
pub fn new() -> Result<Self, BioError> {
let mut bio_ss = Bio::new();
// claim core resource and initialize it
let resource_grant = bio_ss.claim_resources(&Self::resource_spec())?;
let config = CoreConfig { clock_mode: bao1x_api::bio::ClockMode::FixedDivider(0, 0) };
bio_ss.init_core(resource_grant.cores[0], &math_test_bio_code(), 0, config)?;
bio_ss.set_core_run_state(&resource_grant, true);
// safety: fifo1 and fifo2 are stored in this object so they aren't Drop'd before the object is
// destroyed
let tx_handle = unsafe { bio_ss.get_core_handle(Fifo::Fifo0) }?.expect("Didn't get FIFO0 handle");
let rx_handle = unsafe { bio_ss.get_core_handle(Fifo::Fifo1) }?.expect("Didn't get FIFO1 handle");
Ok(Self {
bio_ss,
tx: CoreCsr::from_handle(&tx_handle),
rx: CoreCsr::from_handle(&rx_handle),
// safety: tx and rx are wrapped in CSR objects whose lifetime matches that of the handles
_tx_handle: tx_handle,
_rx_handle: rx_handle,
resource_grant,
})
}
pub fn test_cos(&mut self) {
for i in (0..360).step_by(4) {
// self.bio_ss.debug(self.resource_grant.cores[0]);
self.tx.csr.wo(bio_bdma::SFR_TXF0, i);
// let mut dbg_count: usize = 0;
while self.rx.csr.rf(bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL1) == 0 {
/*
if dbg_count < 20 {
self.bio_ss.debug(self.resource_grant.cores[0]);
}
dbg_count = dbg_count.saturating_add(1);
*/
}
let result = self.rx.csr.r(bio_bdma::SFR_RXF1) as i32 + 11; // result should be -10 to 10
let mut line = String::new();
for _ in 0..result {
line.push(' ');
}
line.push('*');
log::info!("{:3},{:2}:{}", i, result, line);
}
}
}

View file

@ -0,0 +1 @@
pub mod math_test;

View file

@ -0,0 +1,51 @@
#include <stdint.h>
static inline __attribute__((always_inline)) volatile uint32_t pop_fifo0() {
uint32_t rx;
__asm__ volatile (
"mv %0, x16"
: "=r"(rx) // output
);
return rx;
}
static inline __attribute__((always_inline)) volatile uint32_t pop_fifo1() {
uint32_t rx;
__asm__ volatile (
"mv %0, x17"
: "=r"(rx) // output
);
return rx;
}
static inline __attribute__((always_inline)) void push_fifo0(uint32_t tx) {
__asm__ volatile (
"mv x16, %0"
: // nil output
: "r"(tx)
);
}
__attribute__((naked, section(".text._start")))
void _start(void) {
__asm__ volatile (
"li sp, 0xe00\n" // Load stack pointer to 0xE00
"j main\n" // Jump to main
);
}
void main(void) {
uint32_t a;
uint32_t b;
uint32_t i;
uint32_t c = 0;
while (1) {
a = pop_fifo0();
for(i = 0; i < a; i++) {
b = pop_fifo1();
c = b * a + c;
}
push_fifo0(c);
}
}

View file