I met a SIGSEGV when running the code below. When remove call (->cilk_println_i32), the code terminates normally. Do you figure any reason out about this? Any problems about save/restore physical registers around the func call?

use cilk::{
    exec::{jit::x64::compiler},
    *,
};

pub fn sample() {
    let mut m = module::Module::new("cilk");

    // Internal function must be defined when you use it
    let cilk_println_i32 = m.add_function(ir::function::Function::new(
        "cilk.println.i32",
        ir::types::Type::Void,
        vec![ir::types::Type::Int32],
    ));

    let main = cilk_ir!(m; define [void] main () {
        entry:
            i = alloca i32;
            store (i32 10), (%i);
            li = load (%i);
            __ = call (->cilk_println_i32) [(%li)];    // If remove this line, this code works.
            ret (void);
    });

    let mut jit = compiler::JITCompiler::new(&m);
    jit.compile_module();
    jit.run(main, vec![]);
}

error: process didn't exit successfully: `~/Documents/GitHub/cilk/target/debug/deps/sample-9b41210e16725396 --nocapture sample` (signal: 11, SIGSEGV: invalid memory reference)

Currently, DAG nodes are managed using id_arena. However, it's troblesome to write code like arena[id].sth, which should be written like node.sth. So I'm planning to use raw pointer to take around dag nodes. (it's unsafe though) Are there better ideas?

I'm working on compiling JavaScript to cilk-ir with rapidus, and executing by jit/x64/compiler. And found a curious behavior described below. Both of the codes work with an interpreter correctly.

Do you have any idea?

This IR works well.

liveness: define i32 main(i32) {
label.0:        // pred(), succ(), def(4,1,3), in(), out()
    %1 = alloca i32
    store i32 100, i32* %1
    %3 = load i32* %1
    %4 = call i32 f(i32 %3, )
    ret i32 %4
    ret i32 0

}
liveness: define i32 f(i32) {
label.0:        // pred(), succ(), def(1), in(), out()
    %1 = add i32 %arg.0, i32 1
    ret i32 %1
    ret i32 0

}
vreg:1  reg:None        spill:false
vreg:2  reg:None        spill:false
vreg:3  reg:Some(Register(0))   spill:false
vreg:4  reg:Some(Register(0))   spill:false
vreg:5  reg:None        spill:false
vreg:6  reg:None        spill:false
vreg:1  reg:Some(Register(0))   spill:false
vreg:2  reg:None        spill:false
vreg:3  reg:None        spill:false
exec: Int32(101)
saved register: []
jit: Int32(101)

But this goes panic when compiling call instruction.

liveness: define i32 main(i32) {
label.0:        // pred(), succ(), def(4,1,3), in(), out()
    %1 = alloca i32
    store i32 100, i32* %1
    %3 = load i32* %1
    %4 = call i32 f(i32 %3, )
    ret i32 0

}
liveness: define i32 f(i32) {
label.0:        // pred(), succ(), def(1), in(), out()
    %1 = add i32 %arg.0, i32 1
    ret i32 %1
    ret i32 0

}
vreg:1  reg:None        spill:false
vreg:2  reg:None        spill:false
vreg:3  reg:Some(Register(0))   spill:false
vreg:4  reg:None        spill:false
vreg:5  reg:None        spill:false
vreg:1  reg:Some(Register(0))   spill:false
vreg:2  reg:None        spill:false
vreg:3  reg:None        spill:false
exec: Int32(0)
saved register: []
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:347:21
stack backtrace:
   0: backtrace::backtrace::libunwind::trace
             at /Users/vsts/.cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.29/src/backtrace/libunwind.rs:88
   ...
  11: core::option::Option<T>::unwrap
             at /rustc/dfd52ba6ac2262c6b61c59ec86bfd23e4e53d3de/src/libcore/macros.rs:12
  12: cilk::exec::jit::x64::compiler::JITCompiler::compile
             at cilk/src/exec/jit/x64/compiler.rs:223
  13: rapidus::main
             at rapidus/src/main.rs:83
  ...

The JavaScript source codes are here.

/// This works.
let x = 100
return f(x)
function f(x) {
  return x + 1
}
/// This fails.
let x = 100
f(x)
function f(x) {
  return x + 1
}

Disclaimer: I have nothing to do with the Cilk language.

I noticed that this compiler infrastructure has the same name as the Cilk programming language, which is released in the 1990s: https://en.wikipedia.org/wiki/Cilk.

This can be a bit confusing because there are currently two "Cilk"s in the field of compiler implementation. But the confusion should be a little because one is a language and the other is a tool for compilers.

My question is: Have you already discussed this naming issue? If you've already done so, please just close this issue. If not, I think it is a good idea to consider this issue before your Cilk becomes more famous :)

I pushed some commits (that add some doc-comment to src/ir/module.rs experimentally) under docs branch,
but cargo test --docnot worked yet because some files occurs fail to resolve error while compilation.
cilk must fix this Inconsistency first, for expecting efficiently tests

What do you think?

docs ブランチを切ってdoc-commentをいくつか書いてみました．
しかし現状cilkで cargo test [--doc] が失敗するため，docs.rs ページのビルドも失敗する という問題があります．

そこで，私に｢cargo test によって発生するバグたちを潰す作業｣ をやらせてもらえませんか?
コンパイルエラーを削除することができればdocs.rsも生えて，使ってくれる人も増えるはず．
(TODOにテスト書きたいというのもあったので，そのままユニットテストを書くのもやっていこうかな?と思っています)

I am working on a compiler which converts JavaScript source code to cilk-IR and execute. https://github.com/sisshiki1969/rapidus-cilk Be aware that cilk folder is empty, so git clone here before execution.

limitation

• Currently, only integer is supported.
• All variables must be declared using let.
• Can not refer external variables (variables declared outside of the function).
• A block scope is not yet implemented. (Function scope only)
• Can use console.log() to print.

sample code

function fibo(x) {
  if (x == 1) {
    return 1
  } else if (x == 2) {
    return 1
  } else {
    return fibo_sub(x - 1, x - 2)
  }
  // function in function
  function fibo_sub(x, y) {
    return fibo(x) + fibo(y)
  }
}

let x = fibo(10)
console.log(x)
return x

function prime(n) {
  if (n % 2 == 0) return 0
  for (let k = 3; k * k <= n; k += 2) { if (n % k == 0) return 0 }
  return 1
}

let max = 2

for (let i = 2; i <= 20; i += 1) {
  if (prime(i) == 1) {
    console.log(i)
    max = i
  }
}

return max

let x = 0
while (x <= 8) {
  x += 1
}
console.log(x)
return x