root/eaccelerator/trunk/optimize.c

/*
   +----------------------------------------------------------------------+
   | eAccelerator project                                                 |
   +----------------------------------------------------------------------+
   | Copyright (c) 2004 - 2007 eAccelerator                               |
   | http://eaccelerator.net                                              |
   +----------------------------------------------------------------------+
   | This program is free software; you can redistribute it and/or        |
   | modify it under the terms of the GNU General Public License          |
   | as published by the Free Software Foundation; either version 2       |
   | of the License, or (at your option) any later version.               |
   |                                                                      |
   | This program is distributed in the hope that it will be useful,      |
   | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
   | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        |
   | GNU General Public License for more details.                         |
   |                                                                      |
   | You should have received a copy of the GNU General Public License    |
   | along with this program; if not, write to the Free Software          |
   | Foundation, Inc., 59 Temple Place - Suite 330, Boston,               |
   | MA  02111-1307, USA.                                                 |
   |                                                                      |
   | A copy is availble at http://www.gnu.org/copyleft/gpl.txt            |
   +----------------------------------------------------------------------+
   $Id$
*/

#include "eaccelerator.h"

#ifdef HAVE_EACCELERATOR
#ifdef WITH_EACCELERATOR_OPTIMIZER

#include "zend.h"
#include "zend_API.h"
#include "zend_constants.h"
#include "opcodes.h"

typedef unsigned int* set;

struct _BBlink;

typedef struct _BB {
  zend_op*        start;
  int             len;
  int             used;
  /*
   * HOESH: To protect merging. Primary
   * it abblies to try & catch blocks.
   * ZEND_ENGINE_2 specific, but can take place
   */
  int             protect_merge;
  struct _BB*     jmp_1;
  struct _BB*     jmp_2;
  struct _BB*     jmp_ext;
  struct _BB*     follow;
  struct _BBlink* pred;  // Gonna be a chain of BBs
  struct _BB*     next;
} BB;

typedef struct _BBlink {
  struct _BB*     bb;
  struct _BBlink* next;
} BBlink;

#if 0
static void dump_bb(BB* bb, zend_op_array *op_array) {
  BB* p = bb;
  BBlink *q;
  zend_printf("<pre>%s:%s\n", op_array->filename, op_array->function_name);
  while (p != NULL) {
    zend_printf("  bb%u start=%u len=%d used=%d\n",
                 (unsigned int)(p-bb),
                 (unsigned int)(p->start-op_array->opcodes),
                 p->len,
                 p->used);
    if (p->jmp_1) {
      zend_printf("    jmp_1 bb%u start=%u  len=%d used=%d\n",
                  (unsigned int)(p->jmp_1-bb),
                  (unsigned int)(p->jmp_1->start-op_array->opcodes),
                  p->jmp_1->len,
                  p->jmp_1->used);
    }
    if (p->jmp_2) {
      zend_printf("    jmp_2 bb%u start=%u  len=%d used=%d\n",
                  (unsigned int)(p->jmp_2-bb),
                  (unsigned int)(p->jmp_2->start-op_array->opcodes),
                  p->jmp_2->len,
                  p->jmp_2->used);
    }
    if (p->jmp_ext) {
      zend_printf("    jmp_ext bb%u start=%u  len=%d used=%d\n",
                  (unsigned int)(p->jmp_ext-bb),
                  (unsigned int)(p->jmp_ext->start-op_array->opcodes),
                  p->jmp_ext->len,
                  p->jmp_ext->used);
    }
    if (p->follow) {
      zend_printf("    follow bb%u start=%u  len=%d used=%d\n",
                  (unsigned int)(p->follow-bb),
                  (unsigned int)(p->follow->start-op_array->opcodes),
                  p->follow->len,
                  p->follow->used);
    }
    q = p->pred;
    while (q != NULL) {
      zend_printf("    pred bb%u start=%u  len=%d used=%d (",
                  (unsigned int)(q->bb-bb),
                  (unsigned int)(q->bb->start-op_array->opcodes),
                  q->bb->len,
                  q->bb->used);
      if (q->bb->jmp_1 == p) {
        zend_printf("jmp_1 ");
      }
      if (q->bb->jmp_2 == p) {
        zend_printf("jmp_2 ");
      }
      if (q->bb->jmp_ext == p) {
        zend_printf("jmp_ext ");
      }
      if (q->bb->follow == p) {
        zend_printf("follow ");
      }
      zend_printf(")\n");
      q = q->next;
    }
    p = p->next;
  }
  zend_printf("</pre><hr>\n");
  fflush(stdout);
}

static void dump_array(int nb,void *pos,char type)
{  int j;

   switch(type) {
   case 'i': {
     int *ptr=pos;
     for (j=0;j<nb;j++) {
       zend_printf("%d:%6d ",j,*ptr);
       ptr++;
     }
   }
   break; 
   case 'x': {
     int *ptr=pos;
     for (j=0;j<nb;j++) {
       zend_printf("%d:%x ",j,*ptr);
       ptr++;
     }
   }
   break; 
   case 'c': {
     unsigned char *ptr=pos;
     for (j=0;j<nb;j++) {
/*       if (*ptr>=32 && *ptr<128) zend_printf("%d:%c",j,*ptr);
       else if (*ptr>=128) zend_printf("%d:%2x",j,*ptr);
       else if (*ptr<16) zend_printf("%d:&%1x",j,*ptr);
       else zend_printf("%d:$%1x",j,(*ptr)-16); */
       zend_printf("%d:%1x ",j,*ptr);
       ptr++;
     }
   }
   break;   
   default:
     for (j=0;j<nb;j++)
       zend_printf("# ");
   }
   zend_printf("<br>\n");
}
#endif

#define SET_TO_NOP(op) \
  (op)->opcode = ZEND_NOP; \
  (op)->op1.op_type = IS_UNUSED; \
  (op)->op2.op_type = IS_UNUSED; \
  (op)->result.op_type = IS_UNUSED;

static void compute_live_var(BB* bb, zend_op_array* op_array, char* global)
{
  BB* p = bb;
#ifdef ZEND_ENGINE_2_3
  ALLOCA_FLAG(use_heap)
#endif

  memset(global, 0, op_array->T * sizeof(char));
  if (p != NULL && p->next != NULL) {
    int bb_count = 0;
#ifdef ZEND_ENGINE_2_3
    char *def = do_alloca(op_array->T * sizeof(char), use_heap);
#else
    char *def = do_alloca(op_array->T * sizeof(char));
#endif
#if 0
    zend_printf("<hr>%s::%s<br>", op_array->filename, op_array->function_name);
#endif
    while (p != NULL) {
      zend_op* op = p->start;
      zend_op* end = op + p->len;
      memset(def, 0, op_array->T * sizeof(char));
      while (op < end) {
        if ((op->op1.op_type == IS_VAR || op->op1.op_type == IS_TMP_VAR) &&
            !def[VAR_NUM(op->op1.u.var)] && !global[VAR_NUM(op->op1.u.var)]) {
          global[VAR_NUM(op->op1.u.var)] = 1;
        }
        if ((op->op2.op_type == IS_VAR || op->op2.op_type == IS_TMP_VAR) &&
            !def[VAR_NUM(op->op2.u.var)] && !global[VAR_NUM(op->op2.u.var)]) {
          if (op->opcode != ZEND_OP_DATA) {
            global[VAR_NUM(op->op2.u.var)] = 1;
          }
        }
        if (op->opcode == ZEND_DECLARE_INHERITED_CLASS &&
            !def[VAR_NUM(op->extended_value)] &&
            !global[VAR_NUM(op->extended_value)]) {
          global[VAR_NUM(op->extended_value)] = 1;
        }
        if ((op->result.op_type == IS_VAR &&
             (op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT ||
              (op->result.u.EA.type & EXT_TYPE_UNUSED) == 0)) ||
            (op->result.op_type == IS_TMP_VAR)) {
          if (!def[VAR_NUM(op->result.u.var)] && !global[VAR_NUM(op->result.u.var)]) {
            switch (op->opcode) {
              case ZEND_RECV:
              case ZEND_RECV_INIT:
              case ZEND_ADD_ARRAY_ELEMENT:
                global[VAR_NUM(op->result.u.var)] = 1;
             }
          }
          def[VAR_NUM(op->result.u.var)] = 1;
        }
        op++;
      }
      p = p->next;
      bb_count++;
    }
#ifdef ZEND_ENGINE_2_3
    free_alloca(def, use_heap);
#else
    free_alloca(def);
#endif
  }
  {
#ifdef ZEND_ENGINE_2_3
    char *used = do_alloca(op_array->T * sizeof(char), use_heap);
#else
    char *used = do_alloca(op_array->T * sizeof(char));
#endif
    p = bb;
    while (p != NULL) {
      zend_op* op = p->start;
      zend_op* end = op + p->len;
      memset(used, 0, op_array->T * sizeof(char));
      while (op < end) {
        end--;
        if (((end->result.op_type == IS_VAR &&
             (end->opcode == ZEND_RECV || end->opcode == ZEND_RECV_INIT ||
              (end->result.u.EA.type & EXT_TYPE_UNUSED) == 0)) ||
             (end->result.op_type == IS_TMP_VAR)) &&
            !global[VAR_NUM(end->result.u.var)] && !used[VAR_NUM(end->result.u.var)]) {
           switch(end->opcode) {
             case ZEND_JMPZ_EX:
               end->opcode = ZEND_JMPZ;
               end->result.op_type = IS_UNUSED;
               break;
             case ZEND_JMPNZ_EX:
               end->opcode = ZEND_JMPNZ;
               end->result.op_type = IS_UNUSED;
               break;
             case ZEND_ASSIGN_ADD:
             case ZEND_ASSIGN_SUB:
             case ZEND_ASSIGN_MUL:
             case ZEND_ASSIGN_DIV:
             case ZEND_ASSIGN_MOD:
             case ZEND_ASSIGN_SL:
             case ZEND_ASSIGN_SR:
             case ZEND_ASSIGN_CONCAT:
             case ZEND_ASSIGN_BW_OR:
             case ZEND_ASSIGN_BW_AND:
             case ZEND_ASSIGN_BW_XOR:
             case ZEND_PRE_INC:
             case ZEND_PRE_DEC:
             case ZEND_POST_INC:
             case ZEND_POST_DEC:
             case ZEND_ASSIGN:
             case ZEND_ASSIGN_REF:
             case ZEND_DO_FCALL:
             case ZEND_DO_FCALL_BY_NAME:
               if (end->result.op_type == IS_VAR) {
                 end->result.u.EA.type |= EXT_TYPE_UNUSED;
               }
               break;
             case ZEND_UNSET_VAR:
             case ZEND_UNSET_DIM:
             case ZEND_UNSET_OBJ:
               end->result.op_type = IS_UNUSED;
               break;
             case ZEND_RECV:
             case ZEND_RECV_INIT:
             /*case ZEND_ADD_ARRAY_ELEMENT:*/
             case ZEND_INCLUDE_OR_EVAL:
             case ZEND_NEW:
             case ZEND_FE_FETCH:
             case ZEND_PRINT:
             case ZEND_INIT_METHOD_CALL:
             case ZEND_INIT_STATIC_METHOD_CALL:
             case ZEND_ASSIGN_DIM:
             case ZEND_ASSIGN_OBJ:
             case ZEND_DECLARE_CLASS:
             case ZEND_DECLARE_INHERITED_CLASS:
              break;
            default:
              if (end->op1.op_type == IS_CONST) {
                zval_dtor(&end->op1.u.constant);
              }
              if (end->op2.op_type == IS_CONST) {
                zval_dtor(&end->op2.u.constant);
              }
              SET_TO_NOP(end);
          }
        } else if (end->result.op_type == IS_VAR &&
                   (end->result.u.EA.type & EXT_TYPE_UNUSED) != 0 &&
                   end->opcode != ZEND_RECV && end->opcode != ZEND_RECV_INIT &&
                   used[VAR_NUM(end->result.u.var)]) {
          end->result.u.EA.type &= ~EXT_TYPE_UNUSED;
        }
        if ((end->result.op_type == IS_VAR &&
            (end->opcode == ZEND_RECV || end->opcode == ZEND_RECV_INIT ||
             (end->result.u.EA.type & EXT_TYPE_UNUSED) == 0)) ||
            (end->result.op_type == IS_TMP_VAR)) {
          switch (end->opcode) {
            case ZEND_RECV:
            case ZEND_RECV_INIT:
            case ZEND_ADD_ARRAY_ELEMENT:
              used[VAR_NUM(end->result.u.var)] = 1;
              break;
            default:
              used[VAR_NUM(end->result.u.var)] = 0;
           }
        }
        if (end->op1.op_type == IS_VAR || end->op1.op_type == IS_TMP_VAR) {
          used[VAR_NUM(end->op1.u.var)] = 1;
        }
        if (end->op2.op_type == IS_VAR || end->op2.op_type == IS_TMP_VAR) {
          used[VAR_NUM(end->op2.u.var)] = 1;
        }
        if (end->opcode == ZEND_DECLARE_INHERITED_CLASS) {
          used[VAR_NUM(end->extended_value)] = 1;
        }
      }
      p = p->next;
    }
#ifdef ZEND_ENGINE_2_3
    free_alloca(used, use_heap);
#else
    free_alloca(used);
#endif
  }
/*
  while (1) {
    int change = 0;
    p = bb;
    while (p != NULL) {
      int n = SET_SIZE(op_array->T);
      while (n-- > 0) {
        unsigned int old_in = p->in[n];
        p->out[n] = 0;
        if (p->jmp_1   != NULL) p->out[n] |= p->jmp_1->in[n];
        if (p->jmp_2   != NULL) p->out[n] |= p->jmp_2->in[n];
        if (p->jmp_ext != NULL) p->out[n] |= p->jmp_ext->in[n];
        if (p->follow  != NULL) p->out[n] |= p->follow->in[n];
        p->in[n] = p->use[n] | (p->out[n] & ~p->def[n]);
        if (old_in != p->in[n]) change = 1;
      }
      p = p->next;
    }
    if (!change) break;
  }
*/
}

/* Adds FROM as predcessor of TO */
#define BB_ADD_PRED(TO,FROM) { \
                               BBlink *q = (TO)->pred; \
                               while (q != NULL) { \
                                 if (q->bb == (FROM)) break; \
                                 q = q->next; \
                               } \
                               if (q == NULL) { \
                                 q = emalloc(sizeof(*q)); \
                                 q->bb = (FROM); \
                                 q->next = (TO)->pred; \
                                 (TO)->pred = q; \
                               } \
                             }

/* Removes FROM from predcessors of TO */
#define BB_DEL_PRED(TO,FROM) { \
                               BBlink *q = (TO)->pred; \
                               if (q != NULL) { \
                                 if (q->bb == (FROM)) { \
                                   (TO)->pred = q->next; \
                                   efree(q); \
                                 } else { \
                                   while (q->next != NULL) { \
                                     if (q->next->bb == (FROM)) { \
                                       BBlink *r = q->next; \
                                       q->next = q->next->next; \
                                       efree(r); \
                                       break; \
                                     } \
                                     q = q->next; \
                                   } \
                                 } \
                               } \
                             }

#define RM_BB(p) do {if (p->pred == NULL && p != bb) rm_bb(p);} while (0)

static void mark_used_bb(BB* bb)
{
  if (bb->used) return;
  bb->used = 1;
  if (bb->jmp_1 != NULL) {
    mark_used_bb(bb->jmp_1);
    BB_ADD_PRED(bb->jmp_1, bb);
  }
  if (bb->jmp_2 != NULL) {
    mark_used_bb(bb->jmp_2);
    BB_ADD_PRED(bb->jmp_2, bb);
  }
  if (bb->jmp_ext != NULL) {
    mark_used_bb(bb->jmp_ext);
    BB_ADD_PRED(bb->jmp_ext, bb);
  }
  if (bb->follow != NULL) {
    mark_used_bb(bb->follow);
    BB_ADD_PRED(bb->follow, bb);
  }
}

static void mark_used_bb2(BB* bb)
{
  if (bb->used) return;
  bb->used = 1;
  if (bb->jmp_1 != NULL) {
    mark_used_bb2(bb->jmp_1);
  }
  if (bb->jmp_2 != NULL) {
    mark_used_bb2(bb->jmp_2);
  }
  if (bb->jmp_ext != NULL) {
    mark_used_bb2(bb->jmp_ext);
  }
  if (bb->follow != NULL) {
    mark_used_bb2(bb->follow);
  }
}

static void rm_bb(BB* bb)
{
  if (bb->used == 0) {
    return;
  }
  bb->used = 0;
  if (bb->jmp_1 != NULL) {
    BB_DEL_PRED(bb->jmp_1, bb);
  }
  if (bb->jmp_2 != NULL) {
    BB_DEL_PRED(bb->jmp_2, bb);
  }
  if (bb->jmp_ext != NULL) {
    BB_DEL_PRED(bb->jmp_ext, bb);
  }
  if (bb->follow != NULL) {
    BB_DEL_PRED(bb->follow, bb);
  }
}

static void del_bb(BB* bb)
{
  zend_op* op = bb->start;
  zend_op* end = op + bb->len;

  rm_bb(bb);
  while (op < end) {
    --end;
    if (end->op1.op_type == IS_CONST) {
      zval_dtor(&end->op1.u.constant);
    }
    if (end->op2.op_type == IS_CONST) {
      zval_dtor(&end->op2.u.constant);
    }
    SET_TO_NOP(end);
  }
  bb->len  = 0;
  bb->used = 0;
}

static void replace_bb(BB* src, BB* dst)
{
  BBlink* p = src->pred;
  while (p != NULL) {
    BBlink* q = p->next;
    if (p->bb->jmp_1   == src) {
      p->bb->jmp_1 = dst;
      BB_ADD_PRED(dst,p->bb);
    }
    if (p->bb->jmp_2   == src) {
      p->bb->jmp_2 = dst;
      BB_ADD_PRED(dst,p->bb);
    }
    if (p->bb->jmp_ext == src) {
      p->bb->jmp_ext = dst;
      BB_ADD_PRED(dst,p->bb);
    }
    if (p->bb->follow  == src) {
      p->bb->follow = dst;
      BB_ADD_PRED(dst,p->bb);
    }
    efree(p);
    p = q;
  }
  src->pred = NULL;
}

static void optimize_jmp(BB* bb, zend_op_array* op_array)
{
  BB* p;

  while(1) {
    int ok = 1;

    /* Remove Unused Basic Blocks */
    p = bb;
    while (p->next != NULL) {
      if (p->next->used && p->next->pred) {
        p = p->next;
      } else {
        del_bb(p->next);
        p->next = p->next->next;
        ok = 0;
      }
    }

    /* Clear leading NOP(s) */
    p = bb;
    while (p != NULL) {
      if (p->used) {
        while (p->len > 0 && p->start->opcode ==ZEND_NOP) {
          p->start++;
          p->len--;
        }
        if (p->len == 0 && p != bb) {
          if (p->follow) {
            replace_bb(p, p->follow);
          }
          rm_bb(p);
          p->used = 0;
          ok = 0;
        }
      }
      p = p->next;
    }

    /* JMP optimization */
    p = bb;
    while (p != NULL) {
      while (p->next != NULL && (!p->next->used || p->next->pred == NULL)) {
        del_bb(p->next);
        p->next = p->next->next;
        ok = 0;
      }
      if (p->used && p->len > 0) {
        zend_op* op = &p->start[p->len-1];

        switch (op->opcode) {
          case ZEND_JMP:
jmp:
            /* L1: JMP L1+1  => NOP
            */
            if (p->jmp_1 == p->next) {
              p->follow = p->jmp_1;
              p->jmp_1   = NULL;
              SET_TO_NOP(op);
              --(p->len);
              ok = 0;
              break;
            }
            /*     JMP L1  =>  JMP L2
                   ...         ...
               L1: JMP L2      JMP L2
            */
            while (p->jmp_1->len == 1 &&
                p->jmp_1->start->opcode == ZEND_JMP &&
                p->jmp_1 != p) {
              BB* x_p = p->jmp_1;
              BB_DEL_PRED(p->jmp_1, p);
              RM_BB(x_p);
              p->jmp_1 = x_p->jmp_1;
              BB_ADD_PRED(p->jmp_1, p);
              ok = 0;
            }
            break;
          case ZEND_JMPZNZ:
jmp_znz:
            /* JMPZNZ  ?,L1,L1  =>  JMP L1
            */
            if (p->jmp_ext == p->jmp_2) {
              op->opcode = ZEND_JMP;
              op->extended_value = 0;
              op->op1.op_type = IS_UNUSED;
              op->op2.op_type = IS_UNUSED;
              p->jmp_1 = p->jmp_2;
              p->jmp_2 = NULL;
              p->jmp_ext = NULL;
              ok = 0;
              goto jmp;
            } else if (op->op1.op_type == IS_CONST) {
              /* JMPZNZ  0,L1,L2  =>  JMP L1
              */
              if (!zend_is_true(&op->op1.u.constant)) {
                op->opcode = ZEND_JMP;
                op->extended_value = 0;
                op->op1.op_type = IS_UNUSED;
                op->op2.op_type = IS_UNUSED;
                if (p->jmp_ext != p->jmp_2) {
                  BB_DEL_PRED(p->jmp_ext, p);
                  RM_BB(p->jmp_ext);
                }
                p->jmp_1   = p->jmp_2;
                p->jmp_2   = NULL;
                p->jmp_ext = NULL;
                p->follow  = NULL;
                ok = 0;
                goto jmp;
              /* JMPZNZ  1,L1,L2  =>  JMP L2
              */
              } else {
                op->opcode = ZEND_JMP;
                op->extended_value = 0;
                op->op1.op_type = IS_UNUSED;
                op->op2.op_type = IS_UNUSED;
                if (p->jmp_ext != p->jmp_2) {
                  BB_DEL_PRED(p->jmp_2, p);
                  RM_BB(p->jmp_2);
                }
                p->jmp_1   = p->jmp_ext;
                p->jmp_2   = NULL;
                p->jmp_ext = NULL;
                p->follow  = NULL;
                ok = 0;
                goto jmp;
              }
            /* L1: JMPZNZ ?,L2,L1+1  => JMPZ ?,L2
            */
            } else if (p->jmp_ext == p->next) {
              op->opcode = ZEND_JMPZ;
              op->extended_value = 0;
              p->follow = p->jmp_ext;
              p->jmp_ext = NULL;
              ok = 0;
              goto jmp_z;
            /* L1: JMPZNZ ?,L1+1,L2  => JMPNZ ?,L2
            */
            } else if (p->jmp_2 == p->next) {
              op->opcode = ZEND_JMPNZ;
              op->extended_value = 0;
              p->follow = p->jmp_2;
              p->jmp_2  = p->jmp_ext;
              p->jmp_ext = NULL;
              ok = 0;
              goto jmp_nz;
            } else if (p->jmp_2->len == 1 &&
                       op->op1.op_type == IS_TMP_VAR) {
            /*     JMPZNZ $x,L1,L2  =>  JMPZNZ $x,L3,L2
                   ...                  ...
               L1: JMPZ   $x,L3         JMPZ   $x,L3
            */
            /*     JMPZNZ $x,L1,L2  =>  JMPZNZ $x,L3,L2
                   ...                  ...
               L1: JMPZNZ $x,L3,L4      JMPZNZ $x,L3,L4
            */
            if        ((p->jmp_2->start->opcode == ZEND_JMPZ ||
                        p->jmp_2->start->opcode == ZEND_JMPZNZ) &&
                       p->jmp_2->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_2->start->op1.u.var) {
              if (p->jmp_2 != p->jmp_ext) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(p->jmp_2);
              }
              p->jmp_2 = p->jmp_2->jmp_2;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_znz;
            /*     JMPZNZ $x,L1,L2  =>  JMPZNZ $x,L1+1,L2
                   ...                  ...
               L1: JMPNZ  $x,L3         JMPNZ  $x,L3
            */
            } else if (p->jmp_2->start->opcode == ZEND_JMPNZ &&
                       p->jmp_2->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_2->start->op1.u.var) {
              if (p->jmp_2 != p->jmp_ext) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(p->jmp_2);
              }
              p->jmp_2 = p->jmp_2->follow;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_znz;
            /*     JMPZNZ $x,L1,L2  =>  JMPZNZ $x,L1,L3
                   ...                  ...
               L2: JMPNZ  $x,L3         JMPNZ  $x,L3
            */
            } else if (p->jmp_ext->start->opcode == ZEND_JMPNZ &&
                       p->jmp_ext->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_ext->start->op1.u.var) {
              if (p->jmp_2 != p->jmp_ext) {
                BB_DEL_PRED(p->jmp_ext, p);
                RM_BB(p->jmp_ext);
              }
              p->jmp_ext = p->jmp_ext->jmp_2;
              BB_ADD_PRED(p->jmp_ext, p);
              ok = 0;
              goto jmp_znz;
            /*     JMPZNZ $x,L1,L2  =>  JMPZNZ $x,L1,L4
                   ...                  ...
               L2: JMPZNZ $x,L3,L4      JMPZNZ $x,L3,L4
            */
            } else if (p->jmp_ext->start->opcode == ZEND_JMPZNZ &&
                       p->jmp_ext->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_ext->start->op1.u.var) {
              if (p->jmp_2 != p->jmp_ext) {
                BB_DEL_PRED(p->jmp_ext, p);
                RM_BB(p->jmp_ext);
              }
              p->jmp_ext = p->jmp_ext->jmp_ext;
              BB_ADD_PRED(p->jmp_ext, p);
              ok = 0;
              goto jmp_znz;
            /*     JMPZNZ $x,L1,L2  =>  JMPZNZ $x,L1,L2+1
                   ...                  ...
               L2: JMPZ   $x,L3         JMPZ   $x,L3
            */
            } else if (p->jmp_ext->start->opcode == ZEND_JMPZ &&
                       p->jmp_ext->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_ext->start->op1.u.var) {
              if (p->jmp_2 != p->jmp_ext) {
                BB_DEL_PRED(p->jmp_ext, p);
                RM_BB(p->jmp_ext);
              }
              p->jmp_ext = p->jmp_ext->follow;
              BB_ADD_PRED(p->jmp_ext, p);
              ok = 0;
              goto jmp_znz;
            }
            }
            while (p->jmp_2->len == 1 && p->jmp_2->start->opcode == ZEND_JMP) {
              BB* x_p = p->jmp_2;
              if (p->jmp_2 != p->jmp_ext) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(x_p);
              }
              p->jmp_2 = x_p->jmp_1;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
            }
            while (p->jmp_ext->len == 1 && p->jmp_ext->start->opcode == ZEND_JMP) {
              BB* x_p = p->jmp_ext;
              if (p->jmp_2 != p->jmp_ext) {
                BB_DEL_PRED(p->jmp_ext, p);
                RM_BB(x_p);
              }
              p->jmp_ext = x_p->jmp_1;
              BB_ADD_PRED(p->jmp_ext, p);
              ok = 0;
            }
            break;
          case ZEND_JMPZ:
jmp_z:
            /* L1: JMPZ  ?,L1+1  =>  NOP
            */
            if (p->follow == p->jmp_2) {
              p->jmp_2   = NULL;
              SET_TO_NOP(op);
              --(p->len);
              ok = 0;
              break;
            } else if (op->op1.op_type == IS_CONST) {
              /* JMPZ  0,L1  =>  JMP L1
              */
              if (!zend_is_true(&op->op1.u.constant)) {
                op->opcode = ZEND_JMP;
                op->op1.op_type = IS_UNUSED;
                op->op2.op_type = IS_UNUSED;
                if (p->follow != p->jmp_2) {
                  BB_DEL_PRED(p->follow, p);
                  RM_BB(p->follow);
                }
                p->jmp_1  = p->jmp_2;
                p->jmp_2  = NULL;
                p->follow = NULL;
                ok = 0;
                goto jmp;
              /* JMPZ  1,L1  =>  NOP
              */
              } else {
                if (p->follow != p->jmp_2) {
                  BB_DEL_PRED(p->jmp_2, p);
                  RM_BB(p->jmp_2);
                }
                p->jmp_2   = NULL;
                SET_TO_NOP(op);
                --(p->len);
                ok = 0;
                break;
              }
            /* JMPZ ?,L1  =>  JMPZNZ  ?,L1,L2
               JMP  L2        JMP     L2
            */
            } else if (p->follow->len == 1 && p->follow->start->opcode == ZEND_JMP) {
              BB* x_p = p->follow;
              op->opcode = ZEND_JMPZNZ;
              if (p->jmp_2 != p->follow) {
                BB_DEL_PRED(p->follow, p);
                RM_BB(x_p);
              }
              p->follow = NULL;
              p->jmp_ext = x_p->jmp_1;
              BB_ADD_PRED(p->jmp_ext, p);
              ok = 0;
              goto jmp_znz;
            } else if (p->jmp_2->len == 1 &&
                       op->op1.op_type == IS_TMP_VAR) {
            /*     JMPZ $x,L1  =>  JMPZ $x,L2
                   ...             ...
               L1: JMPZ $x,L2      JMPZ $x,L2
               ----------------------------------------
                   JMPZ   $x,L1     =>  JMPZ  $x,L2
                   ...                   ...
               L1: JMPZNZ $x,L2,L3      JMPZNZ $x,L2,L3
            */
            if       ((p->jmp_2->start->opcode == ZEND_JMPZ ||
                       p->jmp_2->start->opcode == ZEND_JMPZNZ) &&
                      p->jmp_2->start->op1.op_type == IS_TMP_VAR &&
                      op->op1.u.var == p->jmp_2->start->op1.u.var) {
              if (p->jmp_2 != p->follow) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(p->jmp_2);
              }
              p->jmp_2 = p->jmp_2->jmp_2;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_z;
            /*     JMPZ  $x,L1  =>  JMPZ  $x,L1+1
                   ...              ...
               L1: JMPNZ $x,L2      JMPNZ $x,L2
            */
            } else if (p->jmp_2->start->opcode == ZEND_JMPNZ &&
                       p->jmp_2->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_2->start->op1.u.var) {
              if (p->jmp_2 != p->follow) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(p->jmp_2);
              }
              p->jmp_2 = p->jmp_2->follow;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_z;
            }
            }
            goto jmp_2;
          case ZEND_JMPNZ:
jmp_nz:
            /* L1: JMPNZ  ?,L1+1  =>  NOP
            */
            if (p->follow == p->jmp_2) {
              p->jmp_2   = NULL;
              SET_TO_NOP(op);
              --(p->len);
              ok = 0;
              break;
            } else if (op->op1.op_type == IS_CONST) {
              /* JMPNZ  1,L1  =>  JMP L1
              */
              if (zend_is_true(&op->op1.u.constant)) {
                op->opcode = ZEND_JMP;
                op->op1.op_type = IS_UNUSED;
                op->op2.op_type = IS_UNUSED;
                if (p->follow != p->jmp_2) {
                  BB_DEL_PRED(p->follow, p);
                  RM_BB(p->follow);
                }
                p->jmp_1  = p->jmp_2;
                p->jmp_2  = NULL;
                p->follow = NULL;
                ok = 0;
                goto jmp;
              /* JMPNZ  0,L1  =>  NOP
              */
              } else {
                if (p->follow != p->jmp_2) {
                  BB_DEL_PRED(p->jmp_2, p);
                  RM_BB(p->jmp_2);
                }
                p->jmp_2   = NULL;
                SET_TO_NOP(op);
                --(p->len);
                ok = 0;
                break;
              }
            /* JMPNZ ?,L1  =>  JMPZNZ  ?,L2,L1
               JMP   L2        JMP     L2
            */
            } else if (p->follow->len == 1 && p->follow->start->opcode == ZEND_JMP) {
              BB* x_p = p->follow;
              op->opcode = ZEND_JMPZNZ;
              if (p->jmp_2 != p->follow) {
                BB_DEL_PRED(p->follow, p);
                RM_BB(p->follow);
              }
              p->follow = NULL;
              p->jmp_ext = p->jmp_2;
              p->jmp_2 = x_p->jmp_1;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_znz;
            /*     JMPNZ $x,L1  =>  JMPNZ $x,L2
                   ...              ...
               L1: JMPNZ $x,L2      JMPNZ $x,L2
            */
            } else if (p->jmp_2->len == 1 &&
                       op->op1.op_type == IS_TMP_VAR) {
            if        (p->jmp_2->start->opcode == ZEND_JMPNZ &&
                       p->jmp_2->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_2->start->op1.u.var) {
              if (p->jmp_2 != p->follow) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(p->jmp_2);
              }
              p->jmp_2 = p->jmp_2->jmp_2;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_nz;
            /*     JMPNZ  $x,L1  =>  JMPNZ  $x,L1+1
                   ...               ...
               L1: JMPZ   $x,L2      JMPZ $x,L2
            */
            } else if (p->jmp_2->start->opcode == ZEND_JMPZ &&
                       p->jmp_2->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_2->start->op1.u.var) {
              if (p->jmp_2 != p->follow) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(p->jmp_2);
              }
              p->jmp_2 = p->jmp_2->follow;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_nz;
            /*     JMPNZ  $x,L1     =>  JMPNZ  $x,L3
                   ...                   ...
               L1: JMPZNZ $x,L2,L3      JMPZNZ $x,L2,L3
            */
            } else if (p->jmp_2->start->opcode == ZEND_JMPZNZ &&
                       p->jmp_2->start->op1.op_type == IS_TMP_VAR &&
                       op->op1.u.var == p->jmp_2->start->op1.u.var) {
              if (p->jmp_2 != p->follow) {
                BB_DEL_PRED(p->jmp_2, p);
                RM_BB(p->jmp_2);
              }
              p->jmp_2 = p->jmp_2->jmp_ext;
              BB_ADD_PRED(p->jmp_2, p);
              ok = 0;
              goto jmp_nz;
            }
            }
            goto jmp_2;
          case ZEND_JMPZ_EX:
jmp_z_ex:
            /* L1: JMPZ_EX  $x,L1+1,$x  =>  NOP
            */
            if (p->follow == p->jmp_2 &&
                op->op1.op_type == IS_TMP_VAR &&
                op->result.op_type == IS_TMP_VAR &&
                op->op1.u.var == op->result.u.var) {
              p->jmp_2   = NULL;
              SET_TO_NOP(op);
              --(p->len);
              ok = 0;
              break;
            /* L1: JMPZ_EX  $x,L1+1,$y  =>  BOOL $x,$y
            */
            } else if (p->follow == p->jmp_2) {
              p->jmp_2   = NULL;
              op->opcode = ZEND_BOOL;
              op->op2.op_type = IS_UNUSED;
              ok = 0;
              break;
            } else if (p->jmp_2->len == 1 &&