How to actually run main

[moste00]

So, apologies in advance if this question is too "Noob" or obvious, I tried a few things before I resorted to asking.

How to actually run Sail code ?

For context, I want to to modify main like this:

How to actually execute this new main and see the actual output from the print call appear in the terminal?

As a wider context: I made (as part of GSoC and the wonderful people at https://github.com/rizinorg/rizin/ and https://github.com/capstone-engine/capstone/) a generator tool that generates comprehensible C code for the encdec mapping, the assembly mapping, and multiple key elements in the sail riscv model. We're really excited about this in rizin and capstone because it means (modulo bugs in the generator, the sail-riscv model, and the generated code) we can now rely on sail-riscv and get automatic up-to-date RISC-V decoding, disassembly, and operand details. In a sense, every contribution to sail-riscv would become a contribution (through the generator) to capstone and rizin's RISC-V disassembly capability.

As part of testing the generated code, mainly encdec and assembly, I had the idea to write a sail entrypoint that traverses the entire 32-bit space of the instructions (and the entire 16-bit compressed space of instructions), call encdec for each binary pattern, obtain the string representation of the resulting AST structure, and store into a file the giant map between uint32_t to string. (Massive portions of this file would probably be invalid, illegal, insanely reptitive, differing only in a single bit in a number argument, etc..., but I'm not worrying about that now). It's an extremly simple but extremly effective testing strategy to then use this massive file and assert that in my generated code, assemble(decode(binary_input)) ==s== str_output for every possible 32-bit bit pattern.

So, tldr; I want to run sail code, and I can't.

What I tried:

(1) I tried running make interpret, this loads all the files but it drops me into a weird prompt that I can't figure out how to drive. It appears to be modal (like vim?)? but simply writing an expression like 1+1 and pressing enter doesn't print 2, unlike the vast majority of programming languages I have ever dealt with. Now granted, this is a sail issue not a sail-riscv issue, but I figured a lot of you guys had to deal with that and figured it out.

(2) There is the C option, but, first, the cgen target in the Makefile is probably buggy, it passes the argument cgen to sail which, as of sail 0.18, sail says it doesn't actually understand. After modifying the Makefile to pass -c instead, it indeed runs to completion and generates the output in the c_emulator directly. I was hoping for something different as this emulator is massively minified/obfuscated and the almost no name from the original sail source survive unscathed. I can probably still compile and call the generated C code, but I was hoping for a better way.

As a bonus question, if I want the bare minimum of additional work besides being able to call encdec and assembly, is the above code in the image correct? That is, should I call anything else besides init_model(); and sail_end_cycle(); to do some additional setup? Would there be any other blockers that you know of to calling encdec and assembly in the main function?

Thank you.

[jrtc27]

Did you read https://github.com/riscv/sail-riscv/blob/master/README.md#getting-started? It covers all this. But the TL;DR is that make will build an emulator and then you run that emulator, just like QEMU or Spike. What made you think it was more complicated than that and pursue all these strange strategies?

[moste00]

Huh, I just thought that there is an "easy" way to run Sail that just involved running it directly instead of the generated C emulator.

I tried make just now and it exits with a linker error because ztick_clock and ztick_platform are used but never defined. This happened for both make and ARCH=RV32 make.

Also, is the cgen target of Makefile buggy? The command in it is wrong.

[jrtc27]

Yes, the cgen target broke, but it was rather pointless, so got deleted. #651.

ztick_clock comes from

sail-riscv/model/riscv_platform.sail

Line 276 in c0ebea2

function tick_clock() = {

(Sail-generated C identifiers start with z). I'm guessing either you've got local changes that are broken or you need to clean your tree after running your hacked up cgen target.

[Timmmm]

So what happens is this:

1. function main() -> unit = ... gets compiled to a function called zmain in C, something like this:

unit zmain(unit zgsz317645)
{

2. Sail will also include this hard-coded function in the C:

int model_main(int argc, char *argv[])
{
  model_init();
  if (process_arguments(argc, argv)) exit(EXIT_FAILURE);
  zmain(UNIT);
  model_fini();
  model_pre_exit();
  return EXIT_SUCCESS;
}

3. By default, Sail will also generate a main():

int main(int argc, char *argv[])
{
  return model_main(argc, argv);
}

That can be disabled via the --c-no-main flag. In the RISC-V model I don't believe we use main() at all, except maybe for make interp? I've never used that though tbh.

If you are writing code outside of the RISC-V model you can do something like this script that I use as a "Sail playground":

#!/bin/bash
set -e

SAIL_LIB=$(sail -dir)
sail main.sail -c -o model
cc model.c -o model -O -I "$SAIL_LIB/lib" $SAIL_LIB/lib/*.c -lgmp -lz
./model

If you want to run your own main() in the RISC-V model I would just copy & paste the emulator into a new directory (and copy/paste the target), and then change it to call model_main() instead of its zstep() loop.

Another option instead of calling model_main() is to call the Sail functions you want directly in a loop in C, something like:

int main() {
  model_init();
  for (...) {
    zencdec_forwards(...);
  }
  model_fini();
  model_preexit();
}

In the long term you would want to add a target that compiles the sail code but without main.sail and with --c-preserve encdec_forwards etc. That should dead-code eliminate all the C code you don't want and lead to much nicer output.