tests/conditional_assignment.scop

   1 start: 218
   2 end: 496
   3 indent: "\t"
   4 context: '[N, M] -> {  : N >= 0 and M >= 0 and N <= 2147483647 and M <= 2147483647
   5   }'
   6 arrays:
   7 - context: '[N] -> {  : N >= 0 }'
   8   extent: '[N, M] -> { A[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <=
   9     9 }'
  10   element_type: int
  11   element_size: 4
  12 - context: '[N] -> {  : N >= 0 }'
  13   extent: '[N, M] -> { C[i0] : i0 <= -1 + N and i0 >= 0 }'
  14   element_type: int
  15   element_size: 4
  16 - context: '[M, N] -> {  : N >= 0 and M >= 0 }'
  17   extent: '[N, M] -> { in1[i0, i1] : i1 <= -1 + M and i1 >= 0 and i0 <= -1 + N and
  18     i0 >= 0 }'
  19   element_type: int
  20   element_size: 4
  21 - context: '[N] -> {  : N >= 0 }'
  22   extent: '[N, M] -> { in2[i0] : i0 <= -1 + N and i0 >= 0 }'
  23   value_bounds: '{ [i0] : i0 >= -1 and i0 <= 1 }'
  24   element_type: int
  25   element_size: 4
  26 - context: '{  :  }'
  27   extent: '[N, M] -> { m[] }'
  28   element_type: int
  29   element_size: 4
  30 statements:
  31 - line: 21
  32   domain: '[N, M] -> { S_0[i] : i <= -1 + N and i >= 0 }'
  33   schedule: '[N] -> { S_0[i] -> [0, i, 0] }'
  34   body:
  35     type: expression
  36     expr:
  37       type: op
  38       operation: =
  39       arguments:
  40       - type: access
  41         index: '[N, M] -> { S_0[i] -> m[] }'
  42         reference: __pet_ref_0
  43         read: 0
  44         write: 1
  45       - type: op
  46         operation: +
  47         arguments:
  48         - type: access
  49           index: '[N, M] -> { S_0[i] -> [(i)] }'
  50           reference: __pet_ref_1
  51           read: 1
  52           write: 0
  53         - type: int
  54           value: 1
  55 - line: 23
  56   domain: '[N, M] -> { S_1[i, j] : j <= -1 + M and j >= 0 and i <= -1 + N and i >=
  57     0 }'
  58   schedule: '[N, M] -> { S_1[i, j] -> [0, i, 1, j] }'
  59   body:
  60     type: expression
  61     expr:
  62       type: op
  63       operation: =
  64       arguments:
  65       - type: access
  66         index: '[N, M] -> { S_1[i, j] -> m[] }'
  67         reference: __pet_ref_2
  68         read: 0
  69         write: 1
  70       - type: call
  71         name: g
  72         arguments:
  73         - type: call
  74           name: h
  75           arguments:
  76           - type: access
  77             index: '[N, M] -> { S_1[i, j] -> m[] }'
  78             reference: __pet_ref_3
  79             read: 1
  80             write: 0
  81         - type: access
  82           index: '[N, M] -> { S_1[i, j] -> in1[(i), (j)] }'
  83           reference: __pet_ref_4
  84           read: 1
  85           write: 0
  86 - line: 24
  87   domain: '[N, M] -> { S_2[i] : i <= -1 + N and i >= 0 }'
  88   schedule: '[N] -> { S_2[i] -> [0, i, 2] }'
  89   body:
  90     type: expression
  91     expr:
  92       type: call
  93       name: compute_row
  94       arguments:
  95       - type: call
  96         name: h
  97         arguments:
  98         - type: access
  99           index: '[N, M] -> { S_2[i] -> m[] }'
 100           reference: __pet_ref_5
 101           read: 1
 102           write: 0
 103       - type: access
 104         index: '[N, M] -> { S_2[i] -> A[(i)] }'
 105         depth: 2
 106         reference: __pet_ref_6
 107         read: 0
 108         write: 1
 109 - line: 26
 110   domain: '[N, M] -> { S_3[] }'
 111   schedule: '{ S_3[] -> [1] }'
 112   body:
 113     type: expression
 114     expr:
 115       type: op
 116       operation: =
 117       arguments:
 118       - type: access
 119         index: '[N, M] -> { S_3[] -> A[(5), (6)] }'
 120         reference: __pet_ref_7
 121         read: 0
 122         write: 1
 123       - type: int
 124         value: 0
 125 - line: 28
 126   domain: '[N, M] -> { S_4[i] : i <= -1 + N and i >= 0 }'
 127   schedule: '[N] -> { S_4[i] -> [2, i] }'
 128   body:
 129     type: expression
 130     expr:
 131       type: op
 132       operation: =
 133       arguments:
 134       - type: access
 135         index: '[N, M] -> { S_4[i] -> C[(i)] }'
 136         reference: __pet_ref_8
 137         read: 0
 138         write: 1
 139       - type: op
 140         operation: '?:'
 141         arguments:
 142         - type: access
 143           index: '[N, M] -> { [S_4[i] -> [i1]] -> [((1) : i1 >= -i and i1 <= -1 +
 144             N - i; (0) : i = -1 + N and i1 = 1; (0) : i = 0 and i1 = -1)] }'
 145           reference: __pet_ref_10
 146           read: 1
 147           write: 0
 148           arguments:
 149           - type: access
 150             index: '[N, M] -> { S_4[i] -> in2[(i)] }'
 151             reference: __pet_ref_9
 152             read: 1
 153             write: 0
 154         - type: call
 155           name: f
 156           arguments:
 157           - type: access
 158             may_read: '[N, M] -> { [S_4[i] -> [i1]] -> A[i + i1, o1] : i1 >= -i and
 159               i1 <= -1 + N - i }'
 160             index: '[N, M] -> { [S_4[i] -> [i1]] -> A[((i + i1) : i1 >= -i)] }'
 161             depth: 2
 162             reference: __pet_ref_12
 163             read: 1
 164             write: 0
 165             arguments:
 166             - type: access
 167               may_read: '[N, M] -> { S_4[i] -> in2[i] }'
 168               index: '[N, M] -> { S_4[i] -> in2[(i)] }'
 169               reference: __pet_ref_11
 170               read: 1
 171               write: 0
 172         - type: int
 173           value: 0