source: Deliverables/D2.2/8051/tests/tmp_tests/Frontend/bubble_sort.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: 8.7 KB
Line 
1program:
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
Note: See TracBrowser for help on using the repository browser.