]> matita.cs.unibo.it Git - pkg-cerco/acc.git/blob - tests/tmp_tests/Frontend/array_copy.RTLabs
Package description and copyright added.
[pkg-cerco/acc.git] / 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