Condition protecting 2D array read moved after read in compiled C code

[nqpz]

Using the newest Futhark compiler from git, the following program results in correct compiled C code for the one-dimensional step, but incorrect (I think) C code for the two-dimensional step:

module dim1 = {
  type~ state = []f32

  def init (m: i64): state =
    replicate (m * m) 1f32

  def step' [n] (cells: *[n]f32): *[n]f32 =
    let step_cell (cell: f32) (i: i64) =
      let x = if i > 0
              then cells[i - 1]
              else 0
      in cell * x
    in map2 step_cell cells (0..<n)

  def step (cells: state): state =
    step' (copy cells)
}

module dim2 = {
  type~ state = [][]f32

  def init (m: i64): state =
    unflatten m m (replicate (m * m) 1f32)

  def step' [m] (cells: *[m][m]f32): *[m][m]f32 =
    let step_cell (cell: f32) ((y, x): (i64, i64)) =
      let x = if y > 0
              then cells[y - 1, x]
              else 0
      in cell * x
    in map2 (map2 step_cell) cells (tabulate_2d m m (\y x -> (y, x)))

  def step (cells: state): state =
    step' (copy cells)
}

type~ state_1d = dim1.state
entry init_1d: i64 -> state_1d = dim1.init
entry step_1d: state_1d -> state_1d = dim1.step

type~ state_2d = dim2.state
entry init_2d: i64 -> state_2d = dim2.init
entry step_2d: state_2d -> state_2d = dim2.step

Using the compiled futhark_entry_step_2d causes a segfault. See https://gist.github.com/nqpz/94e0e7499be770e86c90231ff0060014 for an example of how to trigger it.

Maybe the issue extends to other backends as well. I have only tried this program with the C backend. The original program (https://github.com/nqpz/graffito/blob/main/stencils/gameoflifeprob/stencil.fut) that provoked a segfault does work with the OpenCL backend on my laptop, but maybe my Intel driver is just more accepting towards reading bad memory.

The compiled futrts_entry_step_1d function looks like this:

    for (int64_t i_7603 = 0; i_7603 < dz2080U_6827; i_7603++) {
        float x_7424 = ((float *) x_mem_7617.mem)[i_7603];
        bool cond_7426 = slt64((int64_t) 0, i_7603);
        float x_7427;
        
        if (cond_7426 == 1) {
            int64_t i_7580 = sub64(i_7603, (int64_t) 1);
            float x_t_res_7581 = ((float *) x_mem_7617.mem)[i_7580];
            
            x_7427 = x_t_res_7581;
        } else {
            x_7427 = 0.0F;
        }
        // ...
    }

However, the inner loop of the compiled futrts_entry_step_2d function looks like this:

        for (int64_t i_7603 = 0; i_7603 < dz2082U_7251; i_7603++) {
            float x_7586 = ((float *) x_mem_7617.mem)[i_7607 * dz2082U_7251 + i_7603];
            float x_elem_7600 = ((float *) x_mem_7617.mem)[i_7591 * dz2082U_7251 + i_7603];
            float x_7590;
            
            if (cond_7589 == 1) {
                x_7590 = x_elem_7600;
            } else {
                x_7590 = 0.0F;
            }
            // ...
        }

I think that the assignment of x_elem_7600 should only happen if the condition holds true, like in the one-dimensional step.

This problem probably also extends to higher dimensions, would be my guess.

[athas]

I can reproduce with this test block:

-- ==
-- entry: step_2d
-- script input { init_2d 10i64 }