source: Deliverables/D2.2/8051/tests/tmp_tests/Frontend/array_copy.RTLabs @ 1525

Last change on this file since 1525 was 1525, checked in by ayache, 9 years ago

D2.2: function pointers using JMP.

File size: 9.1 KB
Line 
1program:
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
Note: See TracBrowser for help on using the repository browser.