Ruby  1.9.3p547(2014-05-14revision45962)
insns_info.inc
Go to the documentation of this file.
1 
12 #define TS_OFFSET 'O'
13 #define TS_NUM 'N'
14 #define TS_LINDEX 'L'
15 #define TS_DINDEX 'D'
16 #define TS_VALUE 'V'
17 #define TS_ID 'I'
18 #define TS_GENTRY 'G'
19 #define TS_IC 'C'
20 #define TS_CDHASH 'H'
21 #define TS_ISEQ 'S'
22 #define TS_VARIABLE '.'
23 #define TS_FUNCPTR 'F'
24 
25 static const char *const insn_name_info[] = {
26  "nop",
27  "getlocal",
28  "setlocal",
29  "getspecial",
30  "setspecial",
31  "getdynamic",
32  "setdynamic",
33  "getinstancevariable",
34  "setinstancevariable",
35  "getclassvariable",
36  "setclassvariable",
37  "getconstant",
38  "setconstant",
39  "getglobal",
40  "setglobal",
41  "putnil",
42  "putself",
43  "putobject",
44  "putspecialobject",
45  "putiseq",
46  "putstring",
47  "concatstrings",
48  "tostring",
49  "toregexp",
50  "newarray",
51  "duparray",
52  "expandarray",
53  "concatarray",
54  "splatarray",
55  "checkincludearray",
56  "newhash",
57  "newrange",
58  "pop",
59  "dup",
60  "dupn",
61  "swap",
62  "reput",
63  "topn",
64  "setn",
65  "adjuststack",
66  "defined",
67  "trace",
68  "defineclass",
69  "send",
70  "invokesuper",
71  "invokeblock",
72  "leave",
73  "finish",
74  "throw",
75  "jump",
76  "branchif",
77  "branchunless",
78  "getinlinecache",
79  "onceinlinecache",
80  "setinlinecache",
81  "opt_case_dispatch",
82  "opt_checkenv",
83  "opt_plus",
84  "opt_minus",
85  "opt_mult",
86  "opt_div",
87  "opt_mod",
88  "opt_eq",
89  "opt_neq",
90  "opt_lt",
91  "opt_le",
92  "opt_gt",
93  "opt_ge",
94  "opt_ltlt",
95  "opt_aref",
96  "opt_aset",
97  "opt_length",
98  "opt_size",
99  "opt_succ",
100  "opt_not",
101  "opt_regexpmatch1",
102  "opt_regexpmatch2",
103  "opt_call_c_function",
104  "bitblt",
105  "answer",
106 
107 };
108 
109 static const char *const insn_operand_info[] = {
110  "",
111  "L",
112  "L",
113  "NN",
114  "N",
115  "DN",
116  "DN",
117  "IC",
118  "IC",
119  "I",
120  "I",
121  "I",
122  "I",
123  "G",
124  "G",
125  "",
126  "",
127  "V",
128  "N",
129  "S",
130  "V",
131  "N",
132  "",
133  "NN",
134  "N",
135  "V",
136  "NN",
137  "",
138  "V",
139  "V",
140  "N",
141  "N",
142  "",
143  "",
144  "N",
145  "",
146  "",
147  "N",
148  "N",
149  "N",
150  "NVV",
151  "N",
152  "ISN",
153  "INSNC",
154  "NSN",
155  "NN",
156  "",
157  "",
158  "N",
159  "O",
160  "O",
161  "O",
162  "OC",
163  "OC",
164  "C",
165  "HO",
166  "",
167  "C",
168  "C",
169  "C",
170  "C",
171  "C",
172  "C",
173  "CC",
174  "C",
175  "C",
176  "C",
177  "C",
178  "C",
179  "C",
180  "C",
181  "C",
182  "C",
183  "C",
184  "C",
185  "V",
186  "",
187  "F",
188  "",
189  "",
190 
191 };
192 
193 static const int insn_len_info[] = {
194  1,
195  2,
196  2,
197  3,
198  2,
199  3,
200  3,
201  3,
202  3,
203  2,
204  2,
205  2,
206  2,
207  2,
208  2,
209  1,
210  1,
211  2,
212  2,
213  2,
214  2,
215  2,
216  1,
217  3,
218  2,
219  2,
220  3,
221  1,
222  2,
223  2,
224  2,
225  2,
226  1,
227  1,
228  2,
229  1,
230  1,
231  2,
232  2,
233  2,
234  4,
235  2,
236  4,
237  6,
238  4,
239  3,
240  1,
241  1,
242  2,
243  2,
244  2,
245  2,
246  3,
247  3,
248  2,
249  3,
250  1,
251  2,
252  2,
253  2,
254  2,
255  2,
256  2,
257  3,
258  2,
259  2,
260  2,
261  2,
262  2,
263  2,
264  2,
265  2,
266  2,
267  2,
268  2,
269  2,
270  1,
271  2,
272  1,
273  1,
274 
275 };
276 
277 #ifdef USE_INSN_RET_NUM
278 static const int insn_stack_push_num_info[] = {
279  0,
280  1,
281  0,
282  1,
283  0,
284  1,
285  0,
286  1,
287  0,
288  1,
289  0,
290  1,
291  0,
292  1,
293  0,
294  1,
295  1,
296  1,
297  1,
298  1,
299  1,
300  1,
301  1,
302  1,
303  1,
304  1,
305  1,
306  1,
307  1,
308  2,
309  1,
310  1,
311  0,
312  2,
313  1,
314  2,
315  1,
316  1,
317  1,
318  1,
319  1,
320  0,
321  1,
322  1,
323  1,
324  1,
325  1,
326  1,
327  1,
328  0,
329  0,
330  0,
331  1,
332  1,
333  1,
334  0,
335  0,
336  1,
337  1,
338  1,
339  1,
340  1,
341  1,
342  1,
343  1,
344  1,
345  1,
346  1,
347  1,
348  1,
349  1,
350  1,
351  1,
352  1,
353  1,
354  1,
355  1,
356  0,
357  1,
358  1,
359 
360 };
361 #endif
362 
363 #ifdef USE_INSN_STACK_INCREASE
364 static int
365 insn_stack_increase(int depth, int insn, VALUE *opes)
366 {
367  switch(insn){
368  case BIN(nop):{
369  return depth + 0;
370  }
371  case BIN(getlocal):{
372  return depth + 1;
373  }
374  case BIN(setlocal):{
375  return depth + -1;
376  }
377  case BIN(getspecial):{
378  return depth + 1;
379  }
380  case BIN(setspecial):{
381  return depth + -1;
382  }
383  case BIN(getdynamic):{
384  return depth + 1;
385  }
386  case BIN(setdynamic):{
387  return depth + -1;
388  }
389  case BIN(getinstancevariable):{
390  return depth + 1;
391  }
392  case BIN(setinstancevariable):{
393  return depth + -1;
394  }
395  case BIN(getclassvariable):{
396  return depth + 1;
397  }
398  case BIN(setclassvariable):{
399  return depth + -1;
400  }
401  case BIN(getconstant):{
402  return depth + 0;
403  }
404  case BIN(setconstant):{
405  return depth + -2;
406  }
407  case BIN(getglobal):{
408  return depth + 1;
409  }
410  case BIN(setglobal):{
411  return depth + -1;
412  }
413  case BIN(putnil):{
414  return depth + 1;
415  }
416  case BIN(putself):{
417  return depth + 1;
418  }
419  case BIN(putobject):{
420  return depth + 1;
421  }
422  case BIN(putspecialobject):{
423  return depth + 1;
424  }
425  case BIN(putiseq):{
426  return depth + 1;
427  }
428  case BIN(putstring):{
429  return depth + 1;
430  }
431  case BIN(concatstrings):{
432  int inc = 0;
433  int num = FIX2INT(opes[0]);
434  inc += 1 - num;;
435  return depth + inc;
436  }
437  case BIN(tostring):{
438  return depth + 0;
439  }
440  case BIN(toregexp):{
441  int inc = 0;
442  int cnt = FIX2INT(opes[1]);
443  inc += 1 - cnt;;
444  return depth + inc;
445  }
446  case BIN(newarray):{
447  int inc = 0;
448  int num = FIX2INT(opes[0]);
449  inc += 1 - num;;
450  return depth + inc;
451  }
452  case BIN(duparray):{
453  return depth + 1;
454  }
455  case BIN(expandarray):{
456  int inc = 0;
457  int num = FIX2INT(opes[0]);
458  int flag = FIX2INT(opes[1]);
459  inc += num - 1 + (flag & 1 ? 1 : 0);;
460  return depth + inc;
461  }
462  case BIN(concatarray):{
463  return depth + -1;
464  }
465  case BIN(splatarray):{
466  return depth + 0;
467  }
468  case BIN(checkincludearray):{
469  return depth + 0;
470  }
471  case BIN(newhash):{
472  int inc = 0;
473  int num = FIX2INT(opes[0]);
474  inc += 1 - num;;
475  return depth + inc;
476  }
477  case BIN(newrange):{
478  return depth + -1;
479  }
480  case BIN(pop):{
481  return depth + -1;
482  }
483  case BIN(dup):{
484  return depth + 1;
485  }
486  case BIN(dupn):{
487  int inc = 0;
488  int n = FIX2INT(opes[0]);
489  inc += n;;
490  return depth + inc;
491  }
492  case BIN(swap):{
493  return depth + 0;
494  }
495  case BIN(reput):{
496  int inc = 0;
497  inc += 0;;
498  return depth + inc;
499  }
500  case BIN(topn):{
501  int inc = 0;
502  inc += 1;;
503  return depth + inc;
504  }
505  case BIN(setn):{
506  int inc = 0;
507  inc += 0;
508  return depth + inc;
509  }
510  case BIN(adjuststack):{
511  int inc = 0;
512  int n = FIX2INT(opes[0]);
513  inc -= n;
514  return depth + inc;
515  }
516  case BIN(defined):{
517  return depth + 0;
518  }
519  case BIN(trace):{
520  return depth + 0;
521  }
522  case BIN(defineclass):{
523  return depth + -1;
524  }
525  case BIN(send):{
526  int inc = 0;
527  int op_argc = FIX2INT(opes[1]);
528  int op_flag = FIX2INT(opes[3]);
529  inc += - (int)(op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));;
530  return depth + inc;
531  }
532  case BIN(invokesuper):{
533  int inc = 0;
534  int op_argc = FIX2INT(opes[0]);
535  int op_flag = FIX2INT(opes[2]);
536  inc += - (int)(op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));;
537  return depth + inc;
538  }
539  case BIN(invokeblock):{
540  int inc = 0;
541  int num = FIX2INT(opes[0]);
542  inc += 1 - num;;
543  return depth + inc;
544  }
545  case BIN(leave):{
546  return depth + 0;
547  }
548  case BIN(finish):{
549  return depth + 0;
550  }
551  case BIN(throw):{
552  return depth + 0;
553  }
554  case BIN(jump):{
555  return depth + 0;
556  }
557  case BIN(branchif):{
558  return depth + -1;
559  }
560  case BIN(branchunless):{
561  return depth + -1;
562  }
563  case BIN(getinlinecache):{
564  return depth + 1;
565  }
566  case BIN(onceinlinecache):{
567  return depth + 1;
568  }
569  case BIN(setinlinecache):{
570  return depth + 0;
571  }
572  case BIN(opt_case_dispatch):{
573  int inc = 0;
574  inc += -1;;
575  return depth + inc;
576  }
577  case BIN(opt_checkenv):{
578  return depth + 0;
579  }
580  case BIN(opt_plus):{
581  return depth + -1;
582  }
583  case BIN(opt_minus):{
584  return depth + -1;
585  }
586  case BIN(opt_mult):{
587  return depth + -1;
588  }
589  case BIN(opt_div):{
590  return depth + -1;
591  }
592  case BIN(opt_mod):{
593  return depth + -1;
594  }
595  case BIN(opt_eq):{
596  return depth + -1;
597  }
598  case BIN(opt_neq):{
599  return depth + -1;
600  }
601  case BIN(opt_lt):{
602  return depth + -1;
603  }
604  case BIN(opt_le):{
605  return depth + -1;
606  }
607  case BIN(opt_gt):{
608  return depth + -1;
609  }
610  case BIN(opt_ge):{
611  return depth + -1;
612  }
613  case BIN(opt_ltlt):{
614  return depth + -1;
615  }
616  case BIN(opt_aref):{
617  return depth + -1;
618  }
619  case BIN(opt_aset):{
620  return depth + -2;
621  }
622  case BIN(opt_length):{
623  return depth + 0;
624  }
625  case BIN(opt_size):{
626  return depth + 0;
627  }
628  case BIN(opt_succ):{
629  return depth + 0;
630  }
631  case BIN(opt_not):{
632  return depth + 0;
633  }
634  case BIN(opt_regexpmatch1):{
635  return depth + 0;
636  }
637  case BIN(opt_regexpmatch2):{
638  return depth + -1;
639  }
640  case BIN(opt_call_c_function):{
641  return depth + 0;
642  }
643  case BIN(bitblt):{
644  return depth + 1;
645  }
646  case BIN(answer):{
647  return depth + 1;
648  }
649 
650  default:
651  rb_bug("insn_sp_increase: unreachable");
652  }
653  return 0;
654 }
655 #endif
656 
657 /* some utilities */
658 
659 static int
660 insn_len(VALUE insn)
661 {
662  return insn_len_info[(int)insn];
663 }
664 
665 static const char *
666 insn_name(VALUE insn)
667 {
668  return insn_name_info[(int)insn];
669 }
670 
671 static const char *
672 insn_op_types(VALUE insn)
673 {
674  return insn_operand_info[(int)insn];
675 }
676 
677 static int
678 insn_op_type(VALUE insn, long pos)
679 {
680  int len = insn_len(insn) - 1;
681  if(pos < len){
682  return insn_operand_info[(int)insn][pos];
683  }
684  else{
685  return 0;
686  }
687 }
688 
689 #ifdef USE_INSN_RET_NUM
690 static int
691 insn_ret_num(VALUE insn)
692 {
693  return insn_stack_push_num_info[(int)insn];
694 }
695 #endif
#define VM_CALL_ARGS_BLOCKARG_BIT
Definition: vm_core.h:558
void rb_bug(const char *fmt,...)
Definition: error.c:265
answer
Definition: dir.c:1269
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:420
unsigned long VALUE
Definition: ruby.h:88
#define FIX2INT(x)
Definition: ruby.h:538
register unsigned int len
Definition: name2ctype.h:22210