tests/tmp_tests/Frontend/array_copy.RTLabs

   1 program:
   2
   3
   4   globals:
   5     "tab1" { int32[5] }
   6
   7
   8   extern "print_sint": int4s -> void
   9
  10
  11   extern "newline": void
  12
  13
  14   extern "space": void
  15
  16
  17   "copy"(ptr %0, ptr %1, int4s %2)
  18     locals: int4s %3, int4s %5, ptr %6, int4s %7, ptr %8, int4s %9, int4s %10, int4s %11, int4s %12, int4s %13, int4s %14, int1s %15
  19     result: void %4
  20     stacksize: struct {}
  21     entry: copy19
  22     exit: copy0
  23
  24     copy9: imm %10, imm_sizeof (int32) --> copy8
  25     copy8: mul %9, %3, %10 --> copy7
  26     copy7: addp %8, %1, %9 --> copy6
  27     copy6: load int32, %8, %7 --> copy5
  28     copy5: store int32, %6, %7 --> copy4
  29     copy4: imm %5, imm_int 1 --> copy3
  30     copy3: add %3, %3, %5 --> copy2
  31     copy2: --> copy16
  32     copy19: emit _cost2 --> copy18
  33     copy18: imm %15, imm_int 0 --> copy17
  34     copy17: int1sto4 %3, %15 --> copy2
  35     copy16: lt %14, %3, %2 --> copy15
  36     copy15: notbool %13, %14 --> copy14
  37     copy14: %13? --> copy1, copy13
  38     copy13: emit _cost0 --> copy12
  39     copy12: imm %12, imm_sizeof (int32) --> copy11
  40     copy11: mul %11, %3, %12 --> copy10
  41     copy10: addp %6, %0, %11 --> copy9
  42     copy1: emit _cost1 --> copy0
  43     copy0: return
  44
  45
  46   "print_tab"(ptr %0, int4s %1)
  47     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
  48     result: void %3
  49     stacksize: struct {}
  50     entry: print_tab18
  51     exit: print_tab0
  52
  53     print_tab9: addp %9, %0, %10 --> print_tab8
  54     print_tab8: load int32, %9, %7 --> print_tab7
  55     print_tab7: call "print_sint", [%7], %8: int4s -> void --> print_tab6
  56     print_tab6: call "space", [], %6: void --> print_tab5
  57     print_tab5: imm %5, imm_int 1 --> print_tab4
  58     print_tab4: add %2, %2, %5 --> print_tab3
  59     print_tab3: --> print_tab15
  60     print_tab2: emit _cost4 --> print_tab1
  61     print_tab18: emit _cost5 --> print_tab17
  62     print_tab17: imm %14, imm_int 0 --> print_tab16
  63     print_tab16: int1sto4 %2, %14 --> print_tab3
  64     print_tab15: lt %13, %2, %1 --> print_tab14
  65     print_tab14: notbool %12, %13 --> print_tab13
  66     print_tab13: %12? --> print_tab2, print_tab12
  67     print_tab12: emit _cost3 --> print_tab11
  68     print_tab11: imm %11, imm_sizeof (int32) --> print_tab10
  69     print_tab10: mul %10, %2, %11 --> print_tab9
  70     print_tab1: call "newline", [], %4: void --> print_tab0
  71     print_tab0: return
  72
  73
  74   "main"()
  75     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, int1u %16, int1s %17, ptr %18, ptr %19, int4s %20, int1u %21, int1s %22, ptr %23, offset %24, ptr %25, ptr %26, int4s %27, int1u %28, int1s %29, ptr %30, offset %31, ptr %32, int4s %33, int1s %34, ptr %35, int1s %36, int1s %37, int1s %38, ptr %39, offset %40, ptr %41, int4s %42, int1s %43, ptr %44, int1s %45, int1s %46, int1s %47, ptr %48, offset %49, ptr %50, int4s %51, int1s %52, ptr %53, int1s %54, int1s %55, int1s %56, ptr %57, offset %58, ptr %59, int4s %60, int1s %61, ptr %62, int1s %63, int1s %64, int1s %65, ptr %66, offset %67, ptr %68, int4s %69, int1s %70, ptr %71, int1s %72, int1s %73, int1s %74, ptr %75, offset %76, ptr %77, int4u %78, ptr %79, offset %80, offset %81, offset %82, ptr %83, int4u %84, ptr %85, offset %86, offset %87, offset %88, ptr %89, int4u %90, ptr %91, offset %92, offset %93, offset %94, ptr %95, int4u %96, ptr %97, offset %98, offset %99, offset %100, ptr %101, int4u %102, ptr %103, offset %104, offset %105, offset %106
  76     result: int4s %0
  77     stacksize: struct {int32[5], int32[5]}
  78     entry: main118
  79     exit: main0
  80
  81     main99: imm %90, imm_int 25 --> main98
  82     main98: store int32, %89, %90 --> main97
  83     main97: imm %85, imm_addr "tab1" --> main96
  84     main96: imm %87, imm_int 0 --> main95
  85     main95: imm %88, imm_offset { int32[5], 3 } --> main94
  86     main94: add %86, %87, %88 --> main93
  87     main93: addp %83, %85, %86 --> main92
  88     main92: imm %84, imm_int 56 --> main91
  89     main91: store int32, %83, %84 --> main90
  90     main90: imm %79, imm_addr "tab1" --> main89
  91     main9: call "print_tab", [%8, %9], %10: ptr -> int4s -> void --> main8
  92     main89: imm %81, imm_int 0 --> main88
  93     main88: imm %82, imm_offset { int32[5], 4 } --> main87
  94     main87: add %80, %81, %82 --> main86
  95     main86: addp %77, %79, %80 --> main85
  96     main85: imm %78, imm_int -32 --> main84
  97     main84: store int32, %77, %78 --> main83
  98     main83: emit _cost6 --> main82
  99     main82: imm %75, imm_addr STACK --> main81
 100     main81: imm %76, imm_offset { struct {int32[5], int32[5]}, 1 } --> main80
 101     main80: addp %71, %75, %76 --> main79
 102     main8: imm %6, imm_addr STACK --> main7
 103     main79: imm %73, imm_int 0 --> main78
 104     main78: imm %74, imm_sizeof (int32) --> main77
 105     main77: mul %72, %73, %74 --> main76
 106     main76: addp %68, %71, %72 --> main75
 107     main75: imm %70, imm_int 0 --> main74
 108     main74: int1sto4 %69, %70 --> main73
 109     main73: store int32, %68, %69 --> main72
 110     main72: imm %66, imm_addr STACK --> main71
 111     main71: imm %67, imm_offset { struct {int32[5], int32[5]}, 1 } --> main70
 112     main70: addp %62, %66, %67 --> main69
 113     main7: imm %7, imm_offset { struct {int32[5], int32[5]}, 1 } --> main6
 114     main69: imm %64, imm_int 1 --> main68
 115     main68: imm %65, imm_sizeof (int32) --> main67
 116     main67: mul %63, %64, %65 --> main66
 117     main66: addp %59, %62, %63 --> main65
 118     main65: imm %61, imm_int 1 --> main64
 119     main64: int1sto4 %60, %61 --> main63
 120     main63: store int32, %59, %60 --> main62
 121     main62: imm %57, imm_addr STACK --> main61
 122     main61: imm %58, imm_offset { struct {int32[5], int32[5]}, 1 } --> main60
 123     main60: addp %53, %57, %58 --> main59
 124     main6: addp %2, %6, %7 --> main5
 125     main59: imm %55, imm_int 2 --> main58
 126     main58: imm %56, imm_sizeof (int32) --> main57
 127     main57: mul %54, %55, %56 --> main56
 128     main56: addp %50, %53, %54 --> main55
 129     main55: imm %52, imm_int 2 --> main54
 130     main54: int1sto4 %51, %52 --> main53
 131     main53: store int32, %50, %51 --> main52
 132     main52: imm %48, imm_addr STACK --> main51
 133     main51: imm %49, imm_offset { struct {int32[5], int32[5]}, 1 } --> main50
 134     main50: addp %44, %48, %49 --> main49
 135     main5: imm %5, imm_int 5 --> main4
 136     main49: imm %46, imm_int 3 --> main48
 137     main48: imm %47, imm_sizeof (int32) --> main47
 138     main47: mul %45, %46, %47 --> main46
 139     main46: addp %41, %44, %45 --> main45
 140     main45: imm %43, imm_int 3 --> main44
 141     main44: int1sto4 %42, %43 --> main43
 142     main43: store int32, %41, %42 --> main42
 143     main42: imm %39, imm_addr STACK --> main41
 144     main41: imm %40, imm_offset { struct {int32[5], int32[5]}, 1 } --> main40
 145     main40: addp %35, %39, %40 --> main39
 146     main4: int1sto4 %3, %5 --> main3
 147     main39: imm %37, imm_int 4 --> main38
 148     main38: imm %38, imm_sizeof (int32) --> main37
 149     main37: mul %36, %37, %38 --> main36
 150     main36: addp %32, %35, %36 --> main35
 151     main35: imm %34, imm_int 4 --> main34
 152     main34: int1sto4 %33, %34 --> main33
 153     main33: store int32, %32, %33 --> main32
 154     main32: imm %30, imm_addr STACK --> main31
 155     main31: imm %31, imm_offset { struct {int32[5]}, 0 } --> main30
 156     main30: addp %25, %30, %31 --> main29
 157     main3: call "print_tab", [%2, %3], %4: ptr -> int4s -> void --> main2
 158     main29: imm %26, imm_addr "tab1" --> main28
 159     main28: imm %29, imm_int 5 --> main27
 160     main27: int1sto4 %27, %29 --> main26
 161     main26: call "copy", [%25, %26, %27], %28: ptr -> ptr -> int4s -> void --> main25
 162     main25: imm %18, imm_addr "tab1" --> main24
 163     main24: imm %23, imm_addr STACK --> main23
 164     main23: imm %24, imm_offset { struct {int32[5], int32[5]}, 1 } --> main22
 165     main22: addp %19, %23, %24 --> main21
 166     main21: imm %22, imm_int 5 --> main20
 167     main20: int1sto4 %20, %22 --> main19
 168     main2: imm %1, imm_int 0 --> main1
 169     main19: call "copy", [%18, %19, %20], %21: ptr -> ptr -> int4s -> void --> main18
 170     main18: imm %14, imm_addr "tab1" --> main17
 171     main17: imm %17, imm_int 5 --> main16
 172     main16: int1sto4 %15, %17 --> main15
 173     main15: call "print_tab", [%14, %15], %16: ptr -> int4s -> void --> main14
 174     main14: imm %12, imm_addr STACK --> main13
 175     main13: imm %13, imm_offset { struct {int32[5]}, 0 } --> main12
 176     main12: addp %8, %12, %13 --> main11
 177     main118: imm %103, imm_addr "tab1" --> main117
 178     main117: imm %105, imm_int 0 --> main116
 179     main116: imm %106, imm_offset { int32[5], 0 } --> main115
 180     main115: add %104, %105, %106 --> main114
 181     main114: addp %101, %103, %104 --> main113
 182     main113: imm %102, imm_int 10 --> main112
 183     main112: store int32, %101, %102 --> main111
 184     main111: imm %97, imm_addr "tab1" --> main110
 185     main110: imm %99, imm_int 0 --> main109
 186     main11: imm %11, imm_int 5 --> main10
 187     main109: imm %100, imm_offset { int32[5], 1 } --> main108
 188     main108: add %98, %99, %100 --> main107
 189     main107: addp %95, %97, %98 --> main106
 190     main106: imm %96, imm_int -3 --> main105
 191     main105: store int32, %95, %96 --> main104
 192     main104: imm %91, imm_addr "tab1" --> main103
 193     main103: imm %93, imm_int 0 --> main102
 194     main102: imm %94, imm_offset { int32[5], 2 } --> main101
 195     main101: add %92, %93, %94 --> main100
 196     main100: addp %89, %91, %92 --> main99
 197     main10: int1sto4 %9, %11 --> main9
 198     main1: int1sto4 %0, %1 --> main0
 199     main0: return %0
 200
 201