How to use MIR_new_mem_op?

[giann]

Hi there.

Coming from LLVM and its GEP instruction, i have a hard time understanding how to use MIR_new_mem_op.

How would one access a struct field? Should I use the disp argument to point to the field I want (meaning I have to compute myself where the field would be relative to the struct address?)

Also index and base are MIR_reg_t: does it mean I have to put those values in registers even when I know their value when generating?

If I have a pointer as a MIR_op_t, how can use it as base since MIR_new_mem_op expects a MIR_reg_t?

Thanks for feedback

PS: is there an IRC chan or Discord server for this project?

[vnmakarov]

Hi there.

Coming from LLVM and its GEP instruction, i have a hard time understanding how to use MIR_new_mem_op.

How would one access a struct field? Should I use the disp argument to point to the field I want (meaning I have to compute myself where the field would be relative to the struct address?)

There are no struct and arrays types in MIR. It is not so high level as LLVM IR. Basically mem in MIR is for accessing a MIR-type value in memory. MIR type is signed/unsigned integer of different sizes and fp types. The address of the value is calculated as disp+base_reg+index_reg*scale (base and index parts are optional).

So you need to calculate field address by yourself (to access some external C struct value in MIR I use base reg as struct address and disp got by C offsetof macro).

Also index and base are MIR_reg_t: does it mean I have to put those values in registers even when I know their value when generating?

Zero value of base or index means they are not used in address calculation. So basically in this case you can just put the address into disp and use zero value for base and index reg .

If I have a pointer as a MIR_op_t, how can use it as base since MIR_new_mem_op expects a MIR_reg_t?

If the pointer value in MIR_op_t (let say prtr_op) is a register, you can address value (let assume 32-bit signed integer) in memory by the pointer as

 MIR_new_mem_op (ctx, MIR_I32, 0 /* disp */, ptr_op.u.reg, 0 /* no index reg */, 0 /* scale, the value does not mater if index is not used */);

Thanks for feedback

PS: is there an IRC chan or Discord server for this project?

No, sorry. It is mostly one person project and it is not my major project. So I can not spend much time on it.

[giann]

I think I got most of it but MIR_gen crashes with this code. Here's the snippet i'm trying to make work, it should take a ptr to Test as argument and return its first field a (it's zig code, but it's pretty readable coming from C):

const std = @import("std");
const Test = struct {
    a: u64,
    b: *u64,
    c: bool,
};
const Native = fn (t: *Test) u64;
const NativeFn = *const Native;

test "figuring out mir" {
    const debug_file = std.c.fopen("/Users/giann/tmp/out.txt", "w").?;
    defer _ = std.c.fclose(debug_file);

    const ctx = MIR_init();
    const module = MIR_new_module(ctx, "test");
    // fn (t: Test) u64
    const func = MIR_new_func_arr(
        ctx,
        "test",
        1,
        &[_]MIR_type_t{MIR_T_U64},
        1,
        &[_]MIR_var_t{
            .{
                .type = MIR_T_P,
                .name = "arg",
                // What is this for?
                .size = undefined,
            },
        },
    );

    const arg = MIR_reg(ctx, "arg", func.u.func);
    const index = MIR_new_func_reg(ctx, func.u.func, MIR_T_I64, "idx");

    // put 0 in index
    MIR_append_insn(
        ctx,
        func,
        MIR_new_insn_arr(
            ctx,
            MIR_MOV,
            2,
            &[_]MIR_op_t{
                MIR_new_reg_op(ctx, index),
                MIR_new_int_op(ctx, 0),
            },
        ),
    );

    // Get field a
    const a_field = MIR_new_mem_op(
        ctx,
        MIR_T_U64,
        // @offsetOf: Returns the byte offset of a field relative to its containing struct.
        @offsetOf(Test, "a"),
        arg,
        index,
        1,
    );

    // Return it
    MIR_append_insn(
        ctx,
        func,
        @call(
            .auto,
            MIR_new_ret_insn,
            .{ ctx, 1, a_field },
        ),
    );

    MIR_finish_func(ctx);
    MIR_finish_module(ctx);

    MIR_load_module(ctx, module);
    // MIR_link(ctx, MIR_set_gen_interface, null);

    MIR_gen_init(ctx, 1);
    MIR_gen_set_debug_file(ctx, 0, debug_file);

    const compiled = MIR_gen(ctx, 0, func);

    var b: u64 = 43;
    var t = Test{
        .a = 42,
        .b = &b,
        .c = true,
    };

    // Calling compiled function
    // compiled(&t)
    const a_ptr = @call(
        .auto,
        @ptrCast(
            NativeFn,
            @alignCast(
                @alignOf(Native),
                compiled.?,
            ),
        ),
        .{&t},
    );

    std.debug.print("Got {}\n", .{ a_ptr });

    MIR_gen_finish(ctx);
    MIR_finish(ctx);
}

[giann]

@vnmakarov the generated MIR seems ok though:

Code generation of function test:
+++++++++++++MIR before generator:
test:	func	p, p:arg
	local	i64:idx
# 1 arg, 1 local
	mov	idx, 0
	ret	p:(arg, idx)
	endfunc
+++++++++++++MIR after building CFG:
BB   0
  in edges:
  out edges:   1   2

BB   1
  in edges:   0   2
  out edges:

BB   2
  in edges:   0
  out edges:   1
	mov	idx, 0 # indexes: _,_
	ret	p:(arg, idx) # indexes: _

Minimizing SSA phis: from 0 to 0 phis (non-phi insns 2)

[giann]

Using the text version of it gives me the same crash so it's not a bad usage of the API. I'm pretty stuck on why this doesn't work:

MIR_scan_string(
        ctx,
        \\
        \\ test_m: module
        \\         export test
        \\ test:   func u64, p:arg
        \\         local i64:idx
        \\         mov idx, 0
        \\         ret u64:(arg, idx)
        \\         endfunc
        \\         endmodule
        \\
        ,
    );

[vnmakarov]

I've tried the following on x86_64-linux:

test_m: module
        export test
test:   func u64, p:arg
        local i64:idx
        mov idx, 0
        ret u64:(arg, idx)
        endfunc
p1:     proto u64, p:arg
main: func i64
      local i64:res
      local i64:a
      alloca a, 8
      mov i64:(a), 42
      call p1, test, res, a
      ret res
      endfunc
endmodule

by c2m t.mir -eg;echo $? and it returns 42 as expected. But if I change local i64:a to local p:a it gives undeclared func reg a. Something wrong with dealing with type p (pointer). May be the problem is in using type MIR_T_P. To be honest I always used i64 instead of p as MIR is only designed for 64-bit targets and I did not plan to move it to 32-bits targets.

I'll will look at this problem.

[giann]

Here you call test from MIR code. In my use case i'm calling test from Zig/C directly.
Changing from p to i64 doesn't fix my issue.

const Test = struct {
    a: u64,
    b: *u64,
    c: bool,
};
const Native = fn (t: *Test) u64;
const NativeFn = *const Native;

const ctx = MIR_init();
MIR_scan_string(
    ctx,
    \\
    \\ test_m: module
    \\         export test
    \\ test:   func u64, i64:arg
    \\         local i64:idx
    \\         mov idx, 0
    \\         ret i64:(arg, idx)
    \\         endfunc
    \\         endmodule
    \\
    ,
);

const modules = MIR_get_module_list(ctx);
const module = modules.head;
const func = module.items.tail;

MIR_load_module(ctx, module);
MIR_gen_init(ctx, 1);

const compiled = MIR_gen(ctx, 0, func);

// Calling it
var b: u64 = 43;
var t = Test{
    .a = 42,
    .b = &b,
    .c = true,
};

// equivalent to `compiled(&t)` but we have to do some casting so that zig lets us call it
const a = @call(
    .auto,
    @ptrCast(
        NativeFn,
        @alignCast(
            @alignOf(Native),
            compiled.?,
        ),
    ),
    .{&t},
);

std.debug.print("Got {x}, actual is {x}\n", .{ a, t.a });

MIR_gen_finish(ctx);
MIR_finish(ctx);

Also, unrelated, but why do you declare a proto for test and call that in main? instead of directly calling test?

[vnmakarov]

Here you call test from MIR code. In my use case i'm calling test from Zig/C directly. Changing from p to i64 doesn't fix my issue.

I think I found the reason. The code is simplified before the generator work and it is not done for the ret insn (probably because there is an optimization to use only one ret insn in the func). Therefore the generator crashes when building SSA for not simplified ret insn.

I'll try to fix the issue on this week.

Also, unrelated, but why do you declare a proto for test and call that in main? instead of directly calling test?

The first arg in call insn is always a proto. It is necessary because a called func address can be calculated and stored in reg or memory.

To generate correct code for the call, we need to know type of the func (result type and # of args and arg types).

For calling func from C (and probably zig) we do not pass the proto as call code generated by C (or zig) on func type provided for the call.

[vnmakarov]

It seems you missed call MIR_link that is where MIR simplification is done besides linking loaded modules. You should call MIR_link even for one module. The code on C should look like:

#include "mir-gen.h"
typedef unsigned long u64;
struct Test {
  u64 a, *b;
  int c;
};
int main (void) {
  MIR_context_t ctx = MIR_init ();
  MIR_scan_string (ctx,
                   "test_m: module\n\                                                                                                                                                                                                                         
         export test\n\                                                                                                                                                                                                                                       
 test:   func u64, i64:arg\n\                                                                                                                                                                                                                                 
         local i64:idx\n\                                                                                                                                                                                                                                     
         mov idx, 0\n\                                                                                                                                                                                                                                        
         ret i64:(arg, idx)\n\                                                                                                                                                                                                                                
         endfunc\n\                                                                                                                                                                                                                                           
         endmodule\n");

  DLIST (MIR_module_t) *modules = MIR_get_module_list (ctx);
  MIR_module_t module = DLIST_HEAD (MIR_module_t, *modules);
  MIR_item_t func = DLIST_TAIL (MIR_item_t, module->items);

  MIR_load_module (ctx, module);
  MIR_gen_init (ctx, 1);
=>MIR_link (ctx, MIR_set_lazy_gen_interface, NULL);
  MIR_gen_set_debug_file (ctx, 0, stderr);
  MIR_gen_set_debug_level (ctx, 0, 5);
  const void *compiled = MIR_gen (ctx, 0, func);

  // Calling it                                                                                                                                                                                                                                               
  u64 b = 43;
  struct Test t = {.a = 42, .b = &b, .c = 1};

  const u64 a = ((u64 (*) (struct Test *)) compiled) (&t);

  printf ("Got %lu, actual is %lu\n", a, t.a);

  MIR_gen_finish (ctx);
  MIR_finish (ctx);
  return 0;
}

Besides debug info the execution of this program returns :

Got 42, actual is 42 

[giann]

That was it thanks!