← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.9/intrepid-updates

« back to all changes in this revision

Viewing changes to debian/generated-incs/insns_info.inc

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-09-04 16:01:17 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20070904160117-i15zckg2nhxe9fyw
Tags: 1.9.0+20070830-2ubuntu1
* Sync from Debian; remaining changes:
  - Add -g to CFLAGS.
* Fixes build failure on ia64.
* Fixes build failure with gcc-4.2 on lpia.
* Robustify check for target_os, fixing build failure on lpia.
* Set Ubuntu maintainer address.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/generated-incs/insns_info.inc
17
17
#define TS_CDHASH 'H'
18
18
#define TS_IC 'C'
19
19
#define TS_ID 'I'
 
20
#define TS_FUNCPTR 'F'
20
21
#define TS_VALUE 'V'
21
22
#define TS_LINDEX 'L'
22
23
#define TS_NUM 'N'
39
40
  "setglobal",
40
41
  "putnil",
41
42
  "putself",
42
 
  "putundef",
43
43
  "putobject",
44
44
  "putstring",
45
45
  "concatstrings",
100
100
  "opt_succ",
101
101
  "opt_regexpmatch1",
102
102
  "opt_regexpmatch2",
103
 
  "opt_call_native_compiled",
 
103
  "opt_call_c_function",
104
104
  "bitblt",
105
105
  "answer",
106
106
 
110
110
  "", 
111
111
  "L", 
112
112
  "L", 
113
 
  "NN", 
114
 
  "N", 
115
 
  "DN", 
116
 
  "DN", 
117
 
  "I", 
118
 
  "I", 
119
 
  "I", 
120
 
  "I", 
121
 
  "I", 
122
 
  "I", 
123
 
  "G", 
124
 
  "G", 
125
 
  "", 
 
113
  "VN", 
 
114
  "V", 
 
115
  "DN", 
 
116
  "DN", 
 
117
  "I", 
 
118
  "I", 
 
119
  "I", 
 
120
  "I", 
 
121
  "I", 
 
122
  "I", 
 
123
  "G", 
 
124
  "G", 
126
125
  "", 
127
126
  "", 
128
127
  "V", 
185
184
  "", 
186
185
  "V", 
187
186
  "", 
188
 
  "", 
 
187
  "F", 
189
188
  "", 
190
189
  "", 
191
190
 
209
208
  2,
210
209
  1,
211
210
  1,
212
 
  1,
213
211
  2,
214
212
  2,
215
213
  2,
270
268
  1,
271
269
  2,
272
270
  1,
273
 
  1,
 
271
  2,
274
272
  1,
275
273
  1,
276
274
 
277
275
};
278
276
 
 
277
#ifdef USE_INSN_RET_NUM
279
278
static int insn_stack_push_num_info[] = {
280
279
  0,
281
280
  1,
304
303
  1,
305
304
  1,
306
305
  1,
307
 
  1,
308
306
  2,
309
307
  1,
310
308
  1,
360
358
  1,
361
359
 
362
360
};
 
361
#endif
363
362
 
 
363
#ifdef USE_INSN_STACK_INCREASE
364
364
static int
365
365
insn_stack_increase(int depth, int insn, VALUE *opes)
366
366
{
367
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(putundef):{
420
 
        return depth + 1;
421
 
      }
422
 
      case BIN(putobject):{
423
 
        return depth + 1;
424
 
      }
425
 
      case BIN(putstring):{
426
 
        return depth + 1;
427
 
      }
428
 
      case BIN(concatstrings):{
429
 
        int inc = 0;
430
 
        unsigned long num = FIX2INT(opes[0]);
431
 
         inc += 1 - num;;
432
 
        return depth + inc;
433
 
      }
434
 
      case BIN(tostring):{
435
 
        return depth + 0;
436
 
      }
437
 
      case BIN(toregexp):{
438
 
        return depth + 0;
439
 
      }
440
 
      case BIN(newarray):{
441
 
        int inc = 0;
442
 
        unsigned long num = FIX2INT(opes[0]);
443
 
         inc += 1 - num;;
444
 
        return depth + inc;
445
 
      }
446
 
      case BIN(duparray):{
447
 
        return depth + 1;
448
 
      }
449
 
      case BIN(expandarray):{
450
 
        int inc = 0;
 
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(putstring):{
 
423
          return depth + 1;
 
424
        }
 
425
        case BIN(concatstrings):{
 
426
          int inc = 0;
 
427
        unsigned long num = FIX2INT(opes[0]);
 
428
        inc += 1 - num;;
 
429
        return depth + inc;
 
430
        }
 
431
        case BIN(tostring):{
 
432
          return depth + 0;
 
433
        }
 
434
        case BIN(toregexp):{
 
435
          return depth + 0;
 
436
        }
 
437
        case BIN(newarray):{
 
438
          int inc = 0;
 
439
        unsigned long num = FIX2INT(opes[0]);
 
440
        inc += 1 - num;;
 
441
        return depth + inc;
 
442
        }
 
443
        case BIN(duparray):{
 
444
          return depth + 1;
 
445
        }
 
446
        case BIN(expandarray):{
 
447
          int inc = 0;
451
448
        unsigned long num = FIX2INT(opes[0]);
452
449
        unsigned long flag = FIX2INT(opes[1]);
453
 
         inc += (num > 0) ? num - 1 + (flag ? 1 : 0) : num + 1 - (flag ? 1 : 0);;
 
450
        inc += flag == 0x02 ? num : ((num > 0) ? num - 1 + (flag ? 1 : 0) : num + 1 - (flag ? 1 : 0));;
454
451
        return depth + inc;
455
 
      }
456
 
      case BIN(concatarray):{
457
 
        return depth + -1;
458
 
      }
459
 
      case BIN(splatarray):{
460
 
        return depth + 0;
461
 
      }
462
 
      case BIN(checkincludearray):{
463
 
        return depth + 0;
464
 
      }
465
 
      case BIN(newhash):{
466
 
        int inc = 0;
 
452
        }
 
453
        case BIN(concatarray):{
 
454
          return depth + -1;
 
455
        }
 
456
        case BIN(splatarray):{
 
457
          return depth + 0;
 
458
        }
 
459
        case BIN(checkincludearray):{
 
460
          return depth + 0;
 
461
        }
 
462
        case BIN(newhash):{
 
463
          int inc = 0;
467
464
        unsigned long num = FIX2INT(opes[0]);
468
 
         inc += 1 - num;;
469
 
        return depth + inc;
470
 
      }
471
 
      case BIN(newrange):{
472
 
        return depth + -1;
473
 
      }
474
 
      case BIN(putnot):{
475
 
        return depth + 0;
476
 
      }
477
 
      case BIN(pop):{
478
 
        return depth + -1;
479
 
      }
480
 
      case BIN(dup):{
481
 
        return depth + 1;
482
 
      }
483
 
      case BIN(dupn):{
484
 
        int inc = 0;
485
 
        unsigned long n = FIX2INT(opes[0]);
486
 
         inc += n;;
487
 
        return depth + inc;
488
 
      }
489
 
      case BIN(swap):{
490
 
        return depth + 0;
491
 
      }
492
 
      case BIN(reput):{
493
 
        int inc = 0;
494
 
         inc += 0;;
495
 
        return depth + inc;
496
 
      }
497
 
      case BIN(topn):{
498
 
        int inc = 0;
499
 
        unsigned long n = FIX2INT(opes[0]);
500
 
         inc += 1;;
501
 
        return depth + inc;
502
 
      }
503
 
      case BIN(setn):{
504
 
        int inc = 0;
505
 
        unsigned long n = FIX2INT(opes[0]);
506
 
         inc += 0;
507
 
        return depth + inc;
508
 
      }
509
 
      case BIN(emptstack):{
510
 
        int inc = 0;
511
 
         inc = 0; depth = 0;;
512
 
        return depth + inc;
513
 
      }
514
 
      case BIN(definemethod):{
515
 
        return depth + -1;
516
 
      }
517
 
      case BIN(alias):{
518
 
        return depth + 0;
519
 
      }
520
 
      case BIN(undef):{
521
 
        return depth + 0;
522
 
      }
523
 
      case BIN(defined):{
524
 
        return depth + 0;
525
 
      }
526
 
      case BIN(postexe):{
527
 
        return depth + 0;
528
 
      }
529
 
      case BIN(trace):{
530
 
        return depth + 0;
531
 
      }
532
 
      case BIN(defineclass):{
533
 
        return depth + -1;
534
 
      }
535
 
      case BIN(send):{
536
 
        int inc = 0;
 
465
        inc += 1 - num;;
 
466
        return depth + inc;
 
467
        }
 
468
        case BIN(newrange):{
 
469
          return depth + -1;
 
470
        }
 
471
        case BIN(putnot):{
 
472
          return depth + 0;
 
473
        }
 
474
        case BIN(pop):{
 
475
          return depth + -1;
 
476
        }
 
477
        case BIN(dup):{
 
478
          return depth + 1;
 
479
        }
 
480
        case BIN(dupn):{
 
481
          int inc = 0;
 
482
        unsigned long n = FIX2INT(opes[0]);
 
483
        inc += n;;
 
484
        return depth + inc;
 
485
        }
 
486
        case BIN(swap):{
 
487
          return depth + 0;
 
488
        }
 
489
        case BIN(reput):{
 
490
          int inc = 0;
 
491
        inc += 0;;
 
492
        return depth + inc;
 
493
        }
 
494
        case BIN(topn):{
 
495
          int inc = 0;
 
496
        unsigned long n = FIX2INT(opes[0]);
 
497
        inc += 1;;
 
498
        return depth + inc;
 
499
        }
 
500
        case BIN(setn):{
 
501
          int inc = 0;
 
502
        unsigned long n = FIX2INT(opes[0]);
 
503
        inc += 0;
 
504
        return depth + inc;
 
505
        }
 
506
        case BIN(emptstack):{
 
507
          int inc = 0;
 
508
        inc = 0; depth = 0;;
 
509
        return depth + inc;
 
510
        }
 
511
        case BIN(definemethod):{
 
512
          return depth + -1;
 
513
        }
 
514
        case BIN(alias):{
 
515
          return depth + 0;
 
516
        }
 
517
        case BIN(undef):{
 
518
          return depth + 0;
 
519
        }
 
520
        case BIN(defined):{
 
521
          return depth + 0;
 
522
        }
 
523
        case BIN(postexe):{
 
524
          return depth + 0;
 
525
        }
 
526
        case BIN(trace):{
 
527
          return depth + 0;
 
528
        }
 
529
        case BIN(defineclass):{
 
530
          return depth + -1;
 
531
        }
 
532
        case BIN(send):{
 
533
          int inc = 0;
537
534
        unsigned long op_argc = FIX2INT(opes[1]);
538
535
        unsigned long op_flag = FIX2INT(opes[3]);
539
 
         inc += - (op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));;
 
536
        inc += - (op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));;
540
537
        return depth + inc;
541
 
      }
542
 
      case BIN(invokesuper):{
543
 
        int inc = 0;
 
538
        }
 
539
        case BIN(invokesuper):{
 
540
          int inc = 0;
544
541
        unsigned long op_argc = FIX2INT(opes[0]);
545
 
        unsigned long flag = FIX2INT(opes[2]);
546
 
         inc += - op_argc;;
 
542
        unsigned long op_flag = FIX2INT(opes[2]);
 
543
        inc += - op_argc;;
547
544
        return depth + inc;
548
 
      }
549
 
      case BIN(invokeblock):{
550
 
        int inc = 0;
 
545
        }
 
546
        case BIN(invokeblock):{
 
547
          int inc = 0;
551
548
        unsigned long num = FIX2INT(opes[0]);
552
549
        unsigned long flag = FIX2INT(opes[1]);
553
 
         inc += 1 - num;;
554
 
        return depth + inc;
555
 
      }
556
 
      case BIN(leave):{
557
 
        return depth + 0;
558
 
      }
559
 
      case BIN(finish):{
560
 
        return depth + 0;
561
 
      }
562
 
      case BIN(throw):{
563
 
        return depth + 0;
564
 
      }
565
 
      case BIN(jump):{
566
 
        return depth + 0;
567
 
      }
568
 
      case BIN(branchif):{
569
 
        return depth + -1;
570
 
      }
571
 
      case BIN(branchunless):{
572
 
        return depth + -1;
573
 
      }
574
 
      case BIN(getinlinecache):{
575
 
        return depth + 1;
576
 
      }
577
 
      case BIN(onceinlinecache):{
578
 
        return depth + 1;
579
 
      }
580
 
      case BIN(setinlinecache):{
581
 
        return depth + 0;
582
 
      }
583
 
      case BIN(opt_case_dispatch):{
584
 
        int inc = 0;
585
 
         inc += -1;;
586
 
        return depth + inc;
587
 
      }
588
 
      case BIN(opt_checkenv):{
589
 
        return depth + 0;
590
 
      }
591
 
      case BIN(opt_plus):{
592
 
        return depth + -1;
593
 
      }
594
 
      case BIN(opt_minus):{
595
 
        return depth + -1;
596
 
      }
597
 
      case BIN(opt_mult):{
598
 
        return depth + -1;
599
 
      }
600
 
      case BIN(opt_div):{
601
 
        return depth + -1;
602
 
      }
603
 
      case BIN(opt_mod):{
604
 
        return depth + -1;
605
 
      }
606
 
      case BIN(opt_eq):{
607
 
        return depth + -1;
608
 
      }
609
 
      case BIN(opt_lt):{
610
 
        return depth + -1;
611
 
      }
612
 
      case BIN(opt_le):{
613
 
        return depth + -1;
614
 
      }
615
 
      case BIN(opt_gt):{
616
 
        return depth + -1;
617
 
      }
618
 
      case BIN(opt_ge):{
619
 
        return depth + -1;
620
 
      }
621
 
      case BIN(opt_ltlt):{
622
 
        return depth + -1;
623
 
      }
624
 
      case BIN(opt_aref):{
625
 
        return depth + -1;
626
 
      }
627
 
      case BIN(opt_aset):{
628
 
        return depth + -2;
629
 
      }
630
 
      case BIN(opt_length):{
631
 
        return depth + 0;
632
 
      }
633
 
      case BIN(opt_succ):{
634
 
        return depth + 0;
635
 
      }
636
 
      case BIN(opt_regexpmatch1):{
637
 
        return depth + 0;
638
 
      }
639
 
      case BIN(opt_regexpmatch2):{
640
 
        return depth + -1;
641
 
      }
642
 
      case BIN(opt_call_native_compiled):{
643
 
        return depth + 0;
644
 
      }
645
 
      case BIN(bitblt):{
646
 
        return depth + 1;
647
 
      }
648
 
      case BIN(answer):{
649
 
        return depth + 1;
650
 
      }
 
550
        inc += 1 - num;;
 
551
        return depth + inc;
 
552
        }
 
553
        case BIN(leave):{
 
554
          return depth + 0;
 
555
        }
 
556
        case BIN(finish):{
 
557
          return depth + 0;
 
558
        }
 
559
        case BIN(throw):{
 
560
          return depth + 0;
 
561
        }
 
562
        case BIN(jump):{
 
563
          return depth + 0;
 
564
        }
 
565
        case BIN(branchif):{
 
566
          return depth + -1;
 
567
        }
 
568
        case BIN(branchunless):{
 
569
          return depth + -1;
 
570
        }
 
571
        case BIN(getinlinecache):{
 
572
          return depth + 1;
 
573
        }
 
574
        case BIN(onceinlinecache):{
 
575
          return depth + 1;
 
576
        }
 
577
        case BIN(setinlinecache):{
 
578
          return depth + 0;
 
579
        }
 
580
        case BIN(opt_case_dispatch):{
 
581
          int inc = 0;
 
582
        inc += -1;;
 
583
        return depth + inc;
 
584
        }
 
585
        case BIN(opt_checkenv):{
 
586
          return depth + 0;
 
587
        }
 
588
        case BIN(opt_plus):{
 
589
          return depth + -1;
 
590
        }
 
591
        case BIN(opt_minus):{
 
592
          return depth + -1;
 
593
        }
 
594
        case BIN(opt_mult):{
 
595
          return depth + -1;
 
596
        }
 
597
        case BIN(opt_div):{
 
598
          return depth + -1;
 
599
        }
 
600
        case BIN(opt_mod):{
 
601
          return depth + -1;
 
602
        }
 
603
        case BIN(opt_eq):{
 
604
          return depth + -1;
 
605
        }
 
606
        case BIN(opt_lt):{
 
607
          return depth + -1;
 
608
        }
 
609
        case BIN(opt_le):{
 
610
          return depth + -1;
 
611
        }
 
612
        case BIN(opt_gt):{
 
613
          return depth + -1;
 
614
        }
 
615
        case BIN(opt_ge):{
 
616
          return depth + -1;
 
617
        }
 
618
        case BIN(opt_ltlt):{
 
619
          return depth + -1;
 
620
        }
 
621
        case BIN(opt_aref):{
 
622
          return depth + -1;
 
623
        }
 
624
        case BIN(opt_aset):{
 
625
          return depth + -2;
 
626
        }
 
627
        case BIN(opt_length):{
 
628
          return depth + 0;
 
629
        }
 
630
        case BIN(opt_succ):{
 
631
          return depth + 0;
 
632
        }
 
633
        case BIN(opt_regexpmatch1):{
 
634
          return depth + 0;
 
635
        }
 
636
        case BIN(opt_regexpmatch2):{
 
637
          return depth + -1;
 
638
        }
 
639
        case BIN(opt_call_c_function):{
 
640
          return depth + 0;
 
641
        }
 
642
        case BIN(bitblt):{
 
643
          return depth + 1;
 
644
        }
 
645
        case BIN(answer):{
 
646
          return depth + 1;
 
647
        }
651
648
 
652
649
  default:
653
650
    rb_bug("insn_sp_increase: unreachable");
654
651
  }
655
652
  return 0;
656
653
}
 
654
#endif
657
655
 
658
656
/* some utilities */
659
657
 
687
685
  }
688
686
}
689
687
 
 
688
#ifdef USE_INSN_RET_NUM
690
689
static int
691
690
insn_ret_num(int insn)
692
691
{
693
692
  return insn_stack_push_num_info[insn];
694
693
}
 
694
#endif