tests/tmp_tests/Frontend/bubble_sort.RTLabs

   1 program:
   2
   3
   4   globals:
   5
   6
   7   extern "print_sint": int4s -> void
   8
   9
  10   extern "newline": void
  11
  12
  13   extern "space": void
  14
  15
  16   "min"(ptr %0, int4s %1, int4s %2)
  17     locals: int4s %3, int4s %4, int4s %5, int4s %7, ptr %8, int4s %9, int4s %10, int4s %11, int4s %12, ptr %13, int4s %14, int4s %15, int4s %16, int4s %17, int4s %18, ptr %19, int4s %20, int4s %21, int1s %22, int4s %23, int4s %24
  18     result: int4s %6
  19     stacksize: struct {}
  20     entry: min37
  21     exit: min0
  22
  23     min9: mul %9, %5, %10 --> min8
  24     min8: addp %8, %0, %9 --> min7
  25     min7: load int32, %8, %4 --> min5
  26     min6: emit _cost1 --> min5
  27     min5: imm %7, imm_int 1 --> min4
  28     min4: add %3, %3, %7 --> min3
  29     min37: emit _cost6 --> min36
  30     min36: imm %24, imm_int 0 --> min35
  31     min35: eq %23, %1, %24 --> min34
  32     min34: %23? --> min33, min30
  33     min33: emit _cost4 --> min32
  34     min32: imm %22, imm_int 0 --> min31
  35     min31: int1sto4 %6, %22 --> min0
  36     min30: emit _cost5 --> min29
  37     min3: --> min22
  38     min29: id %5, %2 --> min28
  39     min28: imm %21, imm_sizeof (int32) --> min27
  40     min27: mul %20, %5, %21 --> min26
  41     min26: addp %19, %0, %20 --> min25
  42     min25: load int32, %19, %4 --> min24
  43     min24: imm %18, imm_int 1 --> min23
  44     min23: add %3, %2, %18 --> min3
  45     min22: lt %17, %3, %1 --> min21
  46     min21: notbool %16, %17 --> min20
  47     min20: %16? --> min2, min19
  48     min2: emit _cost3 --> min1
  49     min19: emit _cost2 --> min18
  50     min18: imm %15, imm_sizeof (int32) --> min17
  51     min17: mul %14, %3, %15 --> min16
  52     min16: addp %13, %0, %14 --> min15
  53     min15: load int32, %13, %12 --> min14
  54     min14: lt %11, %12, %4 --> min13
  55     min13: %11? --> min12, min6
  56     min12: emit _cost0 --> min11
  57     min11: id %5, %3 --> min10
  58     min10: imm %10, imm_sizeof (int32) --> min9
  59     min1: id %6, %5 --> min0
  60     min0: return %6
  61
  62
  63   "swap"(ptr %0, int4s %1, int4s %2)
  64     locals: int4s %3, ptr %5, int4s %6, int4s %7, ptr %8, int4s %9, ptr %10, int4s %11, int4s %12, int4s %13, int4s %14, ptr %15, int4s %16, int4s %17
  65     result: void %4
  66     stacksize: struct {}
  67     entry: swap17
  68     exit: swap0
  69
  70     swap9: imm %12, imm_sizeof (int32) --> swap8
  71     swap8: mul %11, %2, %12 --> swap7
  72     swap7: addp %10, %0, %11 --> swap6
  73     swap6: load int32, %10, %9 --> swap5
  74     swap5: store int32, %8, %9 --> swap4
  75     swap4: imm %7, imm_sizeof (int32) --> swap3
  76     swap3: mul %6, %2, %7 --> swap2
  77     swap2: addp %5, %0, %6 --> swap1
  78     swap17: emit _cost7 --> swap16
  79     swap16: imm %17, imm_sizeof (int32) --> swap15
  80     swap15: mul %16, %1, %17 --> swap14
  81     swap14: addp %15, %0, %16 --> swap13
  82     swap13: load int32, %15, %3 --> swap12
  83     swap12: imm %14, imm_sizeof (int32) --> swap11
  84     swap11: mul %13, %1, %14 --> swap10
  85     swap10: addp %8, %0, %13 --> swap9
  86     swap1: store int32, %5, %3 --> swap0
  87     swap0: return
  88
  89
  90   "bubble_sort"(ptr %0, int4s %1)
  91     locals: int4s %2, int4s %3, int4s %4, int4s %6, int1u %7, int4s %8, int4s %9, int1s %10
  92     result: void %5
  93     stacksize: struct {}
  94     entry: bubble_sort14
  95     exit: bubble_sort0
  96
  97     bubble_sort9: %8? --> bubble_sort1, bubble_sort8
  98     bubble_sort8: emit _cost8 --> bubble_sort7
  99     bubble_sort7: call "min", [%0, %1, %2], %4: ptr -> int4s -> int4s -> int4s --> bubble_sort6
 100     bubble_sort6: id %3, %4 --> bubble_sort5
 101     bubble_sort5: call "swap", [%0, %2, %3], %7: ptr -> int4s -> int4s -> void --> bubble_sort4
 102     bubble_sort4: imm %6, imm_int 1 --> bubble_sort3
 103     bubble_sort3: add %2, %2, %6 --> bubble_sort2
 104     bubble_sort2: --> bubble_sort11
 105     bubble_sort14: emit _cost10 --> bubble_sort13
 106     bubble_sort13: imm %10, imm_int 0 --> bubble_sort12
 107     bubble_sort12: int1sto4 %2, %10 --> bubble_sort2
 108     bubble_sort11: lt %9, %2, %1 --> bubble_sort10
 109     bubble_sort10: notbool %8, %9 --> bubble_sort9
 110     bubble_sort1: emit _cost9 --> bubble_sort0
 111     bubble_sort0: return
 112
 113
 114   "print_tab"(ptr %0, int4s %1)
 115     locals: int4s %2, int1u %4, int4s %5, int1u %6, int4s %7, int1u %8, ptr %9, int4s %10, int4s %11, int4s %12, int4s %13, int1s %14
 116     result: void %3
 117     stacksize: struct {}
 118     entry: print_tab18
 119     exit: print_tab0
 120
 121     print_tab9: addp %9, %0, %10 --> print_tab8
 122     print_tab8: load int32, %9, %7 --> print_tab7
 123     print_tab7: call "print_sint", [%7], %8: int4s -> void --> print_tab6
 124     print_tab6: call "space", [], %6: void --> print_tab5
 125     print_tab5: imm %5, imm_int 1 --> print_tab4
 126     print_tab4: add %2, %2, %5 --> print_tab3
 127     print_tab3: --> print_tab15
 128     print_tab2: emit _cost12 --> print_tab1
 129     print_tab18: emit _cost13 --> print_tab17
 130     print_tab17: imm %14, imm_int 0 --> print_tab16
 131     print_tab16: int1sto4 %2, %14 --> print_tab3
 132     print_tab15: lt %13, %2, %1 --> print_tab14
 133     print_tab14: notbool %12, %13 --> print_tab13
 134     print_tab13: %12? --> print_tab2, print_tab12
 135     print_tab12: emit _cost11 --> print_tab11
 136     print_tab11: imm %11, imm_sizeof (int32) --> print_tab10
 137     print_tab10: mul %10, %2, %11 --> print_tab9
 138     print_tab1: call "newline", [], %4: void --> print_tab0
 139     print_tab0: return
 140
 141
 142   "main"()
 143     locals: int1s %1, ptr %2, int4s %3, int1u %4, int1s %5, ptr %6, offset %7, ptr %8, int4s %9, int1u %10, int1s %11, ptr %12, offset %13, ptr %14, int4s %15, int1s %16, ptr %17, int1s %18, int1s %19, int1s %20, ptr %21, offset %22, ptr %23, int4s %24, int1s %25, int1s %26, ptr %27, int1s %28, int1s %29, int1s %30, ptr %31, offset %32, ptr %33, int4s %34, int1s %35, ptr %36, int1s %37, int1s %38, int1s %39, ptr %40, offset %41, ptr %42, int4s %43, int1s %44, int1s %45, ptr %46, int1s %47, int1s %48, int1s %49, ptr %50, offset %51, ptr %52, int4s %53, int1s %54, ptr %55, int1s %56, int1s %57, int1s %58, ptr %59, offset %60
 144     result: int4s %0
 145     stacksize: struct {int32[5]}
 146     entry: main67
 147     exit: main0
 148
 149     main9: call "bubble_sort", [%8, %9], %10: ptr -> int4s -> void --> main8
 150     main8: imm %6, imm_addr STACK --> main7
 151     main7: imm %7, imm_offset { struct {int32[5]}, 0 } --> main6
 152     main67: emit _cost14 --> main66
 153     main66: imm %59, imm_addr STACK --> main65
 154     main65: imm %60, imm_offset { struct {int32[5]}, 0 } --> main64
 155     main64: addp %55, %59, %60 --> main63
 156     main63: imm %57, imm_int 0 --> main62
 157     main62: imm %58, imm_sizeof (int32) --> main61
 158     main61: mul %56, %57, %58 --> main60
 159     main60: addp %52, %55, %56 --> main59
 160     main6: addp %2, %6, %7 --> main5
 161     main59: imm %54, imm_int 26 --> main58
 162     main58: int1sto4 %53, %54 --> main57
 163     main57: store int32, %52, %53 --> main56
 164     main56: imm %50, imm_addr STACK --> main55
 165     main55: imm %51, imm_offset { struct {int32[5]}, 0 } --> main54
 166     main54: addp %46, %50, %51 --> main53
 167     main53: imm %48, imm_int 1 --> main52
 168     main52: imm %49, imm_sizeof (int32) --> main51
 169     main51: mul %47, %48, %49 --> main50
 170     main50: addp %42, %46, %47 --> main49
 171     main5: imm %5, imm_int 5 --> main4
 172     main49: imm %45, imm_int 21 --> main48
 173     main48: negint %44, %45 --> main47
 174     main47: int1sto4 %43, %44 --> main46
 175     main46: store int32, %42, %43 --> main45
 176     main45: imm %40, imm_addr STACK --> main44
 177     main44: imm %41, imm_offset { struct {int32[5]}, 0 } --> main43
 178     main43: addp %36, %40, %41 --> main42
 179     main42: imm %38, imm_int 2 --> main41
 180     main41: imm %39, imm_sizeof (int32) --> main40
 181     main40: mul %37, %38, %39 --> main39
 182     main4: int1sto4 %3, %5 --> main3
 183     main39: addp %33, %36, %37 --> main38
 184     main38: imm %35, imm_int 43 --> main37
 185     main37: int1sto4 %34, %35 --> main36
 186     main36: store int32, %33, %34 --> main35
 187     main35: imm %31, imm_addr STACK --> main34
 188     main34: imm %32, imm_offset { struct {int32[5]}, 0 } --> main33
 189     main33: addp %27, %31, %32 --> main32
 190     main32: imm %29, imm_int 3 --> main31
 191     main31: imm %30, imm_sizeof (int32) --> main30
 192     main30: mul %28, %29, %30 --> main29
 193     main3: call "print_tab", [%2, %3], %4: ptr -> int4s -> void --> main2
 194     main29: addp %23, %27, %28 --> main28
 195     main28: imm %26, imm_int 62 --> main27
 196     main27: negint %25, %26 --> main26
 197     main26: int1sto4 %24, %25 --> main25
 198     main25: store int32, %23, %24 --> main24
 199     main24: imm %21, imm_addr STACK --> main23
 200     main23: imm %22, imm_offset { struct {int32[5]}, 0 } --> main22
 201     main22: addp %17, %21, %22 --> main21
 202     main21: imm %19, imm_int 4 --> main20
 203     main20: imm %20, imm_sizeof (int32) --> main19
 204     main2: imm %1, imm_int 0 --> main1
 205     main19: mul %18, %19, %20 --> main18
 206     main18: addp %14, %17, %18 --> main17
 207     main17: imm %16, imm_int 8 --> main16
 208     main16: int1sto4 %15, %16 --> main15
 209     main15: store int32, %14, %15 --> main14
 210     main14: imm %12, imm_addr STACK --> main13
 211     main13: imm %13, imm_offset { struct {int32[5]}, 0 } --> main12
 212     main12: addp %8, %12, %13 --> main11
 213     main11: imm %11, imm_int 5 --> main10
 214     main10: int1sto4 %9, %11 --> main9
 215     main1: int1sto4 %0, %1 --> main0
 216     main0: return %0
 217
 218