Guest User

Untitled

a guest
Jan 31st, 2012
85
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #    define FETCH_LL(a1, a2) \
  2.         u1 = *pc++;             \
  3.         a1 = framep[u1 & 65535];\
  4.         a2 = framep[u1 >> 16]
  5.  
  6. #    define LOAD_OFFSET_AND_FETCH_LL(a1, a2, i1) \
  7.         SAVE_EXPC; \
  8.         i1 = (intptr_t)*pc++; \
  9.         FETCH_LL(a1, a2)
  10.  
  11. #    define FETCH_LB(a1, a2) \
  12.         a1 = framep[*pc++]; \
  13.         a2 = *pc++
  14.  
  15. #    define LOAD_OFFSET_AND_FETCH_LB(a1, a2, i1) \
  16.         SAVE_EXPC; \
  17.         i1 = (intptr_t)*pc++; \
  18.         FETCH_LB(a1, a2)
  19.  
  20.             // Superwords not in the instruction set.  These are selected by a table
  21.             // driven peephole optimizer, see comments and code in core/WordcodeTranslator.cpp.
  22.  
  23.             INSTR(get2locals) {
  24.                 u1 = *pc++;
  25.                 *(++sp) = framep[u1 & 65535];
  26.                 *(++sp) = framep[u1 >> 16];
  27.                 NEXT;
  28.             }
  29.  
  30.             INSTR(get3locals) {
  31.                 u1 = *pc++;
  32.                 *(++sp) = framep[u1 & 1023];
  33.                 u1 >>= 10;
  34.                 *(++sp) = framep[u1 & 1023];
  35.                 *(++sp) = framep[u1 >> 10];
  36.                 NEXT;
  37.             }
  38.  
  39.             INSTR(get4locals) {
  40.                 u1 = *pc++;
  41.                 *(++sp) = framep[u1 & 255];
  42.                 u1 >>= 8;
  43.                 *(++sp) = framep[u1 & 255];
  44.                 u1 >>= 8;
  45.                 *(++sp) = framep[u1 & 255];
  46.                 *(++sp) = framep[u1 >> 8];
  47.                 NEXT;
  48.             }
  49.  
  50.             INSTR(get5locals) {
  51.                 u1 = *pc++;
  52.                 *(++sp) = framep[u1 & 63];
  53.                 u1 >>= 6;
  54.                 *(++sp) = framep[u1 & 63];
  55.                 u1 >>= 6;
  56.                 *(++sp) = framep[u1 & 63];
  57.                 u1 >>= 6;
  58.                 *(++sp) = framep[u1 & 63];
  59.                 *(++sp) = framep[u1 >> 6];
  60.                 NEXT;
  61.             }
  62.  
  63.             INSTR(storelocal) {
  64.                 framep[*pc++] = *sp;
  65.                 NEXT;
  66.             }
  67.  
  68.             INSTR(add_ll) {
  69.                 FETCH_LL(a1,a2);
  70.                 ++sp;
  71.                 goto add_two_values_into_tos_impl;
  72.             }
  73.  
  74.             INSTR(add_set_lll) {
  75.                 u1 = *pc++;
  76.                 a1=framep[u1 & 1023];
  77.                 u1 >>= 10;
  78.                 a2=framep[u1 & 1023];
  79.                 ADD_TWO_VALUES_AND_NEXT(a1, a2, framep[u1 >> 10]);
  80.             }
  81.  
  82.             INSTR(subtract_ll) {
  83.                 FETCH_LL(a1,a2);
  84.                 ++sp;
  85.                 goto sub_two_values_and_next;
  86.             }
  87.  
  88.             INSTR(multiply_ll) {
  89.                 FETCH_LL(a1,a2);
  90.                 ++sp;
  91.                 goto mul_two_values_and_next;
  92.             }
  93.  
  94.             INSTR(divide_ll) {
  95.                 FETCH_LL(a1,a2);
  96.                 ++sp;
  97.                 goto div_two_values_and_next;
  98.             }
  99.  
  100.             INSTR(modulo_ll) {
  101.                 FETCH_LL(a1,a2);
  102.                 ++sp;
  103.                 goto mod_two_values_and_next;
  104.             }
  105.  
  106.             INSTR(bitand_ll) {
  107.                 FETCH_LL(a1,a2);
  108.                 ++sp;
  109.                 goto bitand_two_values_and_next;
  110.             }
  111.  
  112.             INSTR(bitor_ll) {
  113.                 FETCH_LL(a1,a2);
  114.                 ++sp;
  115.                 goto bitor_two_values_and_next;
  116.             }
  117.  
  118.             INSTR(bitxor_ll) {
  119.                 FETCH_LL(a1,a2);
  120.                 ++sp;
  121.                 goto bitxor_two_values_and_next;
  122.             }
  123.  
  124.             // OPTIMIZEME - redundant type check in superword.
  125.             // As long as ext_pushbits is only used for integer data we know that
  126.             // a2 is an int in the cases below, so the macros need not check.
  127.  
  128.             INSTR(add_lb) {
  129.                 FETCH_LB(a1, a2);
  130.                 ++sp;
  131.                 goto add_two_values_into_tos_impl;
  132.             }
  133.  
  134.             INSTR(subtract_lb) {
  135.                 FETCH_LB(a1, a2);
  136.                 ++sp;
  137.                 goto sub_two_values_and_next;
  138.             }
  139.  
  140.             INSTR(multiply_lb) {
  141.                 FETCH_LB(a1, a2);
  142.                 ++sp;
  143.                 goto mul_two_values_and_next;
  144.             }
  145.  
  146.             INSTR(divide_lb) {
  147.                 FETCH_LB(a1, a2);
  148.                 ++sp;
  149.                 goto div_two_values_and_next;
  150.             }
  151.  
  152.             INSTR(bitand_lb) {
  153.                 FETCH_LB(a1, a2);
  154.                 ++sp;
  155.                 goto bitand_two_values_and_next;
  156.             }
  157.  
  158.             INSTR(bitor_lb) {
  159.                 FETCH_LB(a1, a2);
  160.                 ++sp;
  161.                 goto bitor_two_values_and_next;
  162.             }
  163.  
  164.             INSTR(bitxor_lb) {
  165.                 FETCH_LB(a1, a2);
  166.                 ++sp;
  167.                 goto bitxor_two_values_and_next;
  168.             }
  169.  
  170.             INSTR(iflt_ll) {
  171.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  172.                 goto compare_lt_and_branch_impl;
  173.             }
  174.  
  175.             INSTR(ifnlt_ll) {
  176.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  177.                 goto compare_nlt_and_branch_impl;
  178.             }
  179.  
  180.             INSTR(ifle_ll) {
  181.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  182.                 goto compare_le_and_branch_impl;
  183.             }
  184.  
  185.             INSTR(ifnle_ll) {
  186.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  187.                 goto compare_nle_and_branch_impl;
  188.             }
  189.  
  190.             INSTR(ifgt_ll) {
  191.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  192.                 goto compare_gt_and_branch_impl;
  193.             }
  194.  
  195.             INSTR(ifngt_ll) {
  196.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  197.                 goto compare_ngt_and_branch_impl;
  198.             }
  199.  
  200.             INSTR(ifge_ll) {
  201.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  202.                 goto compare_ge_and_branch_impl;
  203.             }
  204.  
  205.             INSTR(ifnge_ll) {
  206.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  207.                 goto compare_nge_and_branch_impl;
  208.             }
  209.  
  210.             INSTR(ifeq_ll) {
  211.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  212.                 goto compare_eq_and_branch_impl;
  213.             }
  214.  
  215.             INSTR(ifne_ll) {
  216.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  217.                 goto compare_ne_and_branch_impl;
  218.             }
  219.  
  220.             INSTR(ifstricteq_ll) {
  221.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  222.                 goto compare_stricteq_and_branch_impl;
  223.             }
  224.  
  225.             INSTR(ifstrictne_ll) {
  226.                 LOAD_OFFSET_AND_FETCH_LL(a1,a2,i1);
  227.                 goto compare_strictne_and_branch_impl;
  228.             }
  229.  
  230.             INSTR(iflt_lb) {
  231.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  232.                 goto compare_lt_and_branch_impl;
  233.             }
  234.  
  235.             INSTR(ifnlt_lb) {
  236.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  237.                 goto compare_nlt_and_branch_impl;
  238.             }
  239.  
  240.             INSTR(ifle_lb) {
  241.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  242.                 goto compare_le_and_branch_impl;
  243.             }
  244.  
  245.             INSTR(ifnle_lb) {
  246.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  247.                 goto compare_nle_and_branch_impl;
  248.             }
  249.  
  250.             INSTR(ifgt_lb) {
  251.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  252.                 goto compare_gt_and_branch_impl;
  253.             }
  254.  
  255.             INSTR(ifngt_lb) {
  256.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  257.                 goto compare_ngt_and_branch_impl;
  258.             }
  259.  
  260.             INSTR(ifge_lb) {
  261.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  262.                 goto compare_ge_and_branch_impl;
  263.             }
  264.  
  265.             INSTR(ifnge_lb) {
  266.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  267.                 goto compare_nge_and_branch_impl;
  268.             }
  269.  
  270.             INSTR(ifeq_lb) {
  271.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  272.                 goto compare_eq_and_branch_impl;
  273.             }
  274.  
  275.             INSTR(ifne_lb) {
  276.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  277.                 goto compare_ne_and_branch_impl;
  278.             }
  279.  
  280.             INSTR(ifstricteq_lb) {
  281.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  282.                 goto compare_stricteq_and_branch_impl;
  283.             }
  284.  
  285.             INSTR(ifstrictne_lb) {
  286.                 LOAD_OFFSET_AND_FETCH_LB(a1,a2,i1);
  287.                 goto compare_strictne_and_branch_impl;
  288.             }
  289.  
  290.             INSTR(swap_pop) {
  291.                 sp[-1] = sp[0];
  292.                 --sp;
  293.                 NEXT;
  294.             }
RAW Paste Data