source: Deliverables/D2.2/8051/tests/clight/ifthenelse.log.expected @ 486

Last change on this file since 486 was 486, checked in by ayache, 8 years ago

Deliverable D2.2

File size: 12.8 KB
Line 
1Warning (during instrumentation):
2  Clight instrumentation is not implemented yet.
3Checking execution traces...OK.
4ing has cost 0.
5Warning: branching to if_jian12 has cost 1; continuing has cost 3.
6Warning: branching to if_jian13 has cost 2; continuing has cost 3.
7Call(func,stop)
8Regular(seq,stop)
9Regular(cost,seq)
10Regular(call,seq)
11Call(func,call)
12Regular(seq,call)
13Regular(cost,seq)
14Regular(assign t1,seq)
15Regular(skip,seq)
16Regular(seq,call)
17Regular(cost,seq)
18Regular(assign t2,seq)
19Regular(skip,seq)
20Regular(seq,call)
21Regular(cost,seq)
22Regular(assign t3,seq)
23Regular(skip,seq)
24Regular(seq,call)
25Regular(cost,seq)
26Regular(ifthenelse,seq)
27Regular(seq,seq)
28Regular(cost,seq)
29Regular(assign t4,seq)
30Regular(skip,seq)
31Regular(seq,seq)
32Regular(cost,seq)
33Regular(assign t5,seq)
34Regular(skip,seq)
35Regular(cost,seq)
36Regular(assign u,seq)
37Regular(skip,seq)
38Regular(cost,call)
39Regular(return,call)
40Return(Int(22),call)
41Regular(skip,seq)
42Regular(seq,stop)
43Regular(cost,seq)
44Regular(call,seq)
45Call(func,call)
46Regular(seq,call)
47Regular(cost,seq)
48Regular(ifthenelse,seq)
49Regular(seq,seq)
50Regular(cost,seq)
51Regular(assign e,seq)
52Regular(skip,seq)
53Regular(seq,seq)
54Regular(cost,seq)
55Regular(assign e,seq)
56Regular(skip,seq)
57Regular(cost,seq)
58Regular(assign g,seq)
59Regular(skip,seq)
60Regular(cost,call)
61Regular(return,call)
62Return(Int(6),call)
63Regular(skip,seq)
64Regular(seq,stop)
65Regular(cost,seq)
66Regular(call,seq)
67Call(func,call)
68Regular(seq,call)
69Regular(cost,seq)
70Regular(ifthenelse,seq)
71Regular(cost,seq)
72Regular(ifthenelse,seq)
73Regular(cost,seq)
74Regular(assign result,seq)
75Regular(skip,seq)
76Regular(cost,call)
77Regular(return,call)
78Return(Int(2),call)
79Regular(skip,seq)
80Regular(seq,stop)
81Regular(cost,seq)
82Regular(call,seq)
83Call(func,call)
84Regular(seq,call)
85Regular(cost,seq)
86Regular(ifthenelse,seq)
87Regular(cost,seq)
88Regular(ifthenelse,seq)
89Regular(cost,seq)
90Regular(assign result,seq)
91Regular(skip,seq)
92Regular(cost,call)
93Regular(return,call)
94Return(Int(2),call)
95Regular(skip,seq)
96Regular(seq,stop)
97Regular(cost,seq)
98Regular(call,seq)
99Call(func,call)
100Regular(seq,call)
101Regular(cost,seq)
102Regular(ifthenelse,seq)
103Regular(cost,seq)
104Regular(assign min,seq)
105Regular(skip,seq)
106Regular(cost,call)
107Regular(return,call)
108Return(Int(1),call)
109Regular(skip,seq)
110Regular(seq,stop)
111Regular(cost,seq)
112Regular(call,seq)
113Call(func,call)
114Regular(seq,call)
115Regular(cost,seq)
116Regular(assign a,seq)
117Regular(skip,seq)
118Regular(seq,call)
119Regular(cost,seq)
120Regular(ifthenelse,seq)
121Regular(cost,seq)
122Regular(assign b,seq)
123Regular(skip,seq)
124Regular(cost,call)
125Regular(return,call)
126Return(Int(3),call)
127Regular(skip,seq)
128Regular(seq,stop)
129Regular(cost,seq)
130Regular(call,seq)
131Call(func,call)
132Regular(seq,call)
133Regular(cost,seq)
134Regular(assign c,seq)
135Regular(skip,seq)
136Regular(seq,call)
137Regular(cost,seq)
138Regular(ifthenelse,seq)
139Regular(cost,seq)
140Regular(assign c,seq)
141Regular(skip,seq)
142Regular(cost,call)
143Regular(return,call)
144Return(Int(1),call)
145Regular(skip,seq)
146Regular(seq,stop)
147Regular(cost,seq)
148Regular(call,seq)
149Call(func,call)
150Regular(seq,call)
151Regular(cost,seq)
152Regular(assign c,seq)
153Regular(skip,seq)
154Regular(seq,call)
155Regular(cost,seq)
156Regular(assign d,seq)
157Regular(skip,seq)
158Regular(seq,call)
159Regular(cost,seq)
160Regular(assign v,seq)
161Regular(skip,seq)
162Regular(seq,call)
163Regular(cost,seq)
164Regular(assign w,seq)
165Regular(skip,seq)
166Regular(seq,call)
167Regular(cost,seq)
168Regular(assign z,seq)
169Regular(skip,seq)
170Regular(seq,call)
171Regular(cost,seq)
172Regular(ifthenelse,seq)
173Regular(cost,seq)
174Regular(assign c,seq)
175Regular(skip,seq)
176Regular(seq,call)
177Regular(cost,seq)
178Regular(ifthenelse,seq)
179Regular(seq,seq)
180Regular(cost,seq)
181Regular(assign z,seq)
182Regular(skip,seq)
183Regular(cost,seq)
184Regular(assign w,seq)
185Regular(skip,seq)
186Regular(seq,call)
187Regular(cost,seq)
188Regular(assign d,seq)
189Regular(skip,seq)
190Regular(seq,call)
191Regular(cost,seq)
192Regular(assign v,seq)
193Regular(skip,seq)
194Regular(cost,call)
195Regular(return,call)
196Return(Int(3),call)
197Regular(skip,seq)
198Regular(seq,stop)
199Regular(cost,seq)
200Regular(call,seq)
201Call(func,call)
202Regular(seq,call)
203Regular(cost,seq)
204Regular(ifthenelse,seq)
205Regular(cost,seq)
206Regular(ifthenelse,seq)
207Regular(cost,seq)
208Regular(assign result,seq)
209Regular(skip,seq)
210Regular(cost,call)
211Regular(return,call)
212Return(Int(-1),call)
213Regular(skip,seq)
214Regular(cost,stop)
215Regular(return,stop)
216Result: Int(-1)
217Memory dump:
218n = 54
219block 1 : Free.
220
221block 2 : Free.
222
223block 3 : Free.
224
225block 4 : Free.
226
227block 5 : Free.
228
229block 6 : Free.
230
231block 7 : Free.
232
233block 8 : Free.
234
235block 9 : Free.
236
237block 10 : Free.
238
239block 11 : Free.
240
241block 12 : Free.
242
243block 13 : Free.
244
245block 14 : Free.
246
247block 15 : Free.
248
249block 16 : Free.
250
251block 17 : Free.
252
253block 18 : Free.
254
255block 19 : Free.
256
257block 20 : Free.
258
259block 21 : Free.
260
261block 22 : Free.
262
263block 23 : Free.
264
265block 24 : Free.
266
267block 25 : Free.
268
269block 26 : Free.
270
271block 27 : Free.
272
273block 28 : Free.
274
275block 29 : Free.
276
277block 30 : Free.
278
279block 31 : Free.
280
281block 32 : Free.
282
283block 33 : Free.
284
285block 34 : Free.
286
287block 35 : Free.
288
289block 36 : Free.
290
291block 37 : Free.
292
293block 38 : Free.
294
295block 39 : Free.
296
297block 40 : Free.
298
299block 41 : Free.
300
301block 42 : Free.
302
303block 43 : Free.
304
305block 44 : Free.
306
307block 45 : Free.
308
309block 46 : Free.
310
311block 47 : Free.
312
313block 48 : Free.
314
315block 49 : Free.
316
317block 50 : Free.
318
319block 51 : Free.
320
321block 52 : Free.
322
323block 53 : Free.
324
325State_call { function() - stop }
326State_regular { seq - stop }
327State_regular { cost - seq::cont }
328State_regular { call - seq::cont }
329State_call { function(Int(1),Int(2),Int(3),Int(4),Int(5),Int(6),Int(7),Int(8),Int(9)) - returnto }
330State_regular { seq - returnto }
331State_regular { cost - seq::cont }
332State_regular { assign - seq::cont }
333State_regular { skip - seq::cont }
334State_regular { seq - returnto }
335State_regular { cost - seq::cont }
336State_regular { assign - seq::cont }
337State_regular { skip - seq::cont }
338State_regular { seq - returnto }
339State_regular { cost - seq::cont }
340State_regular { assign - seq::cont }
341State_regular { skip - seq::cont }
342State_regular { seq - returnto }
343State_regular { cost - cost::cont }
344State_regular { ifthenelse - cost::cont }
345State_regular { seq - cost::cont }
346State_regular { cost - seq::cont }
347State_regular { assign - seq::cont }
348State_regular { skip - seq::cont }
349State_regular { seq - cost::cont }
350State_regular { cost - cost::cont }
351State_regular { assign - cost::cont }
352State_regular { skip - cost::cont }
353State_regular { cost - cost::cont }
354State_regular { assign - cost::cont }
355State_regular { skip - cost::cont }
356State_regular { cost - returnto }
357State_regular { return - returnto }
358State_return { Int(22) - returnto }
359State_regular { skip - seq::cont }
360State_regular { seq - stop }
361State_regular { cost - seq::cont }
362State_regular { call - seq::cont }
363State_call { function(Int(1),Int(2)) - returnto }
364State_regular { seq - returnto }
365State_regular { cost - cost::cont }
366State_regular { ifthenelse - cost::cont }
367State_regular { seq - cost::cont }
368State_regular { cost - seq::cont }
369State_regular { assign - seq::cont }
370State_regular { skip - seq::cont }
371State_regular { seq - cost::cont }
372State_regular { cost - cost::cont }
373State_regular { assign - cost::cont }
374State_regular { skip - cost::cont }
375State_regular { cost - cost::cont }
376State_regular { assign - cost::cont }
377State_regular { skip - cost::cont }
378State_regular { cost - returnto }
379State_regular { return - returnto }
380State_return { Int(6) - returnto }
381State_regular { skip - seq::cont }
382State_regular { seq - stop }
383State_regular { cost - seq::cont }
384State_regular { call - seq::cont }
385State_call { function(Int(1),Int(2),Int(3)) - returnto }
386State_regular { seq - returnto }
387State_regular { cost - cost::cont }
388State_regular { ifthenelse - cost::cont }
389State_regular { cost - cost::cont }
390State_regular { ifthenelse - cost::cont }
391State_regular { cost - cost::cont }
392State_regular { assign - cost::cont }
393State_regular { skip - cost::cont }
394State_regular { cost - returnto }
395State_regular { return - returnto }
396State_return { Int(2) - returnto }
397State_regular { skip - seq::cont }
398State_regular { seq - stop }
399State_regular { cost - seq::cont }
400State_regular { call - seq::cont }
401State_call { function(Int(1),Int(2),Int(3)) - returnto }
402State_regular { seq - returnto }
403State_regular { cost - cost::cont }
404State_regular { ifthenelse - cost::cont }
405State_regular { cost - cost::cont }
406State_regular { ifthenelse - cost::cont }
407State_regular { cost - cost::cont }
408State_regular { assign - cost::cont }
409State_regular { skip - cost::cont }
410State_regular { cost - returnto }
411State_regular { return - returnto }
412State_return { Int(2) - returnto }
413State_regular { skip - seq::cont }
414State_regular { seq - stop }
415State_regular { cost - seq::cont }
416State_regular { call - seq::cont }
417State_call { function(Int(1),Int(2)) - returnto }
418State_regular { seq - returnto }
419State_regular { cost - cost::cont }
420State_regular { ifthenelse - cost::cont }
421State_regular { cost - cost::cont }
422State_regular { assign - cost::cont }
423State_regular { skip - cost::cont }
424State_regular { cost - returnto }
425State_regular { return - returnto }
426State_return { Int(1) - returnto }
427State_regular { skip - seq::cont }
428State_regular { seq - stop }
429State_regular { cost - seq::cont }
430State_regular { call - seq::cont }
431State_call { function(Int(1),Int(2)) - returnto }
432State_regular { seq - returnto }
433State_regular { cost - seq::cont }
434State_regular { assign - seq::cont }
435State_regular { skip - seq::cont }
436State_regular { seq - returnto }
437State_regular { cost - cost::cont }
438State_regular { ifthenelse - cost::cont }
439State_regular { cost - cost::cont }
440State_regular { assign - cost::cont }
441State_regular { skip - cost::cont }
442State_regular { cost - returnto }
443State_regular { return - returnto }
444State_return { Int(3) - returnto }
445State_regular { skip - seq::cont }
446State_regular { seq - stop }
447State_regular { cost - seq::cont }
448State_regular { call - seq::cont }
449State_call { function(Int(1),Int(2)) - returnto }
450State_regular { seq - returnto }
451State_regular { cost - seq::cont }
452State_regular { assign - seq::cont }
453State_regular { skip - seq::cont }
454State_regular { seq - returnto }
455State_regular { cost - cost::cont }
456State_regular { ifthenelse - cost::cont }
457State_regular { cost - cost::cont }
458State_regular { assign - cost::cont }
459State_regular { skip - cost::cont }
460State_regular { cost - returnto }
461State_regular { return - returnto }
462State_return { Int(1) - returnto }
463State_regular { skip - seq::cont }
464State_regular { seq - stop }
465State_regular { cost - seq::cont }
466State_regular { call - seq::cont }
467State_call { function(Int(1),Int(2),Int(3),Int(4)) - returnto }
468State_regular { seq - returnto }
469State_regular { cost - seq::cont }
470State_regular { assign - seq::cont }
471State_regular { skip - seq::cont }
472State_regular { seq - returnto }
473State_regular { cost - seq::cont }
474State_regular { assign - seq::cont }
475State_regular { skip - seq::cont }
476State_regular { seq - returnto }
477State_regular { cost - seq::cont }
478State_regular { assign - seq::cont }
479State_regular { skip - seq::cont }
480State_regular { seq - returnto }
481State_regular { cost - seq::cont }
482State_regular { assign - seq::cont }
483State_regular { skip - seq::cont }
484State_regular { seq - returnto }
485State_regular { cost - seq::cont }
486State_regular { assign - seq::cont }
487State_regular { skip - seq::cont }
488State_regular { seq - returnto }
489State_regular { cost - seq::cont }
490State_regular { ifthenelse - seq::cont }
491State_regular { cost - seq::cont }
492State_regular { assign - seq::cont }
493State_regular { skip - seq::cont }
494State_regular { seq - returnto }
495State_regular { cost - seq::cont }
496State_regular { ifthenelse - seq::cont }
497State_regular { seq - seq::cont }
498State_regular { cost - cost::cont }
499State_regular { assign - cost::cont }
500State_regular { skip - cost::cont }
501State_regular { cost - seq::cont }
502State_regular { assign - seq::cont }
503State_regular { skip - seq::cont }
504State_regular { seq - returnto }
505State_regular { cost - seq::cont }
506State_regular { assign - seq::cont }
507State_regular { skip - seq::cont }
508State_regular { seq - returnto }
509State_regular { cost - cost::cont }
510State_regular { assign - cost::cont }
511State_regular { skip - cost::cont }
512State_regular { cost - returnto }
513State_regular { return - returnto }
514State_return { Int(3) - returnto }
515State_regular { skip - seq::cont }
516State_regular { seq - stop }
517State_regular { cost - cost::cont }
518State_regular { call - cost::cont }
519State_call { function(Int(1),Int(2),Int(3)) - returnto }
520State_regular { seq - returnto }
521State_regular { cost - cost::cont }
522State_regular { ifthenelse - cost::cont }
523State_regular { cost - cost::cont }
524State_regular { ifthenelse - cost::cont }
525State_regular { cost - cost::cont }
526State_regular { assign - cost::cont }
527State_regular { skip - cost::cont }
528State_regular { cost - returnto }
529State_regular { return - returnto }
530State_return { Int(-1) - returnto }
531State_regular { skip - cost::cont }
532State_regular { cost - stop }
533State_regular { return - stop }
534Result: Int(-1)
535Memory dump:
536n = 11
537block 1 : Free.
538
539block 2 : Free.
540
541block 3 : Free.
542
543block 4 : Free.
544
545block 5 : Free.
546
547block 6 : Free.
548
549block 7 : Free.
550
551block 8 : Free.
552
553block 9 : Free.
554
555block 10 : Free.
556
Note: See TracBrowser for help on using the repository browser.