/src/php-src/Zend/Optimizer/compact_literals.c

Source
/*
   +----------------------------------------------------------------------+
   | Zend OPcache                                                         |
   +----------------------------------------------------------------------+
   | Copyright © The PHP Group and Contributors.                          |
   +----------------------------------------------------------------------+
   | This source file is subject to the Modified BSD License that is      |
   | bundled with this package in the file LICENSE, and is available      |
   | through the World Wide Web at <https://www.php.net/license/>.        |
   |                                                                      |
   | SPDX-License-Identifier: BSD-3-Clause                                |
   +----------------------------------------------------------------------+
   | Authors: Dmitry Stogov <dmitry@php.net>                              |
   |          Xinchen Hui <laruence@php.net>                              |
   +----------------------------------------------------------------------+
*/

/* pass 11
 * - compact literals table
 */

#include "Optimizer/zend_optimizer.h"
#include "Optimizer/zend_optimizer_internal.h"
#include "zend_API.h"
#include "zend_constants.h"
#include "zend_execute.h"
#include "zend_vm.h"
#include "zend_extensions.h"

#define DEBUG_COMPACT_LITERALS 0

#define LITERAL_CLASS_CONST 1
#define LITERAL_STATIC_METHOD 2
#define LITERAL_STATIC_PROPERTY 3

typedef struct _literal_info {
  uint8_t num_related;
} literal_info;

#define LITERAL_INFO(n, related) do { \
    info[n].num_related = (related); \
  } while (0)

static uint32_t add_static_slot(HashTable     *hash,
                                zend_op_array *op_array,
                                uint32_t       op1,
                                uint32_t       op2,
                                uint32_t       kind,
                                uint32_t       *cache_size)
{
  uint32_t ret;
  zval *class_name = &op_array->literals[op1];
  zval *prop_name = &op_array->literals[op2];
  zval *pos, tmp;

  zend_string *key = zend_create_member_string(Z_STR_P(class_name), Z_STR_P(prop_name));
  ZSTR_H(key) = zend_string_hash_func(key);
  ZSTR_H(key) += kind;

  pos = zend_hash_find(hash, key);
  if (pos) {
    ret = Z_LVAL_P(pos);
  } else {
    ret = *cache_size;
    *cache_size += (kind == LITERAL_STATIC_PROPERTY ? 3 : 2) * sizeof(void *);
    ZVAL_LONG(&tmp, ret);
    zend_hash_add(hash, key, &tmp);
  }
  zend_string_release_ex(key, 0);
  return ret;
}

static inline void bias_key(zend_string *key, uint32_t bias)
{
  /* Add a bias to the hash so we can distinguish string keys
   * that would otherwise be the same. */
  ZSTR_H(key) = zend_string_hash_val(key) + bias;
}

static zend_string *create_str_cache_key(zval *literal, uint8_t num_related)
{
  ZEND_ASSERT(Z_TYPE_P(literal) == IS_STRING);
  if (num_related == 1) {
    return zend_string_copy(Z_STR_P(literal));
  }

  /* Concatenate all the related literals for the cache key. */
  zend_string *key;
  if (num_related == 2) {
    ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING);
    key = zend_string_concat2(
      Z_STRVAL_P(literal), Z_STRLEN_P(literal),
      Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1));
  } else if (num_related == 3) {
    ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING && Z_TYPE_P(literal + 2) == IS_STRING);
    key = zend_string_concat3(
      Z_STRVAL_P(literal), Z_STRLEN_P(literal),
      Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1),
      Z_STRVAL_P(literal + 2), Z_STRLEN_P(literal + 2));
  } else {
    ZEND_ASSERT(0 && "Currently not needed");
  }

  bias_key(key, num_related - 1);
  return key;
}

void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx *ctx)
{
  zend_op *opline, *end;
  int n, *map;
  uint32_t cache_size;
  zval zv, *pos;
  literal_info *info;
  int l_null = -1;
  int l_false = -1;
  int l_true = -1;
  int l_empty_arr = -1;
  HashTable hash;
  zend_string *key = NULL;
  void *checkpoint = zend_arena_checkpoint(ctx->arena);
  int *const_slot, *class_slot, *func_slot, *bind_var_slot, *property_slot, *method_slot, *jmp_slot;

  if (op_array->last_literal) {
    uint32_t j;
    info = (literal_info*)zend_arena_calloc(&ctx->arena, op_array->last_literal, sizeof(literal_info));

      /* Mark literals of specific types */
    opline = op_array->opcodes;
    end = opline + op_array->last;
    while (opline < end) {
      switch (opline->opcode) {
        case ZEND_JMP_FRAMELESS:
          LITERAL_INFO(opline->op1.constant, 1);
          break;
        case ZEND_INIT_FCALL_BY_NAME:
          LITERAL_INFO(opline->op2.constant, 2);
          break;
        case ZEND_INIT_NS_FCALL_BY_NAME:
          LITERAL_INFO(opline->op2.constant, 3);
          break;
        case ZEND_INIT_METHOD_CALL:
          if (opline->op1_type == IS_CONST) {
            LITERAL_INFO(opline->op1.constant, 1);
          }
          if (opline->op2_type == IS_CONST) {
            LITERAL_INFO(opline->op2.constant, 2);
          }
          break;
        case ZEND_INIT_STATIC_METHOD_CALL:
          if (opline->op1_type == IS_CONST) {
            LITERAL_INFO(opline->op1.constant, 2);
          }
          if (opline->op2_type == IS_CONST) {
            LITERAL_INFO(opline->op2.constant, 2);
          }
          break;
        case ZEND_INIT_PARENT_PROPERTY_HOOK_CALL:
          LITERAL_INFO(opline->op1.constant, 1);
          break;
        case ZEND_CATCH:
          LITERAL_INFO(opline->op1.constant, 2);
          break;
        case ZEND_FETCH_CONSTANT:
          if (opline->op1.num & IS_CONSTANT_UNQUALIFIED_IN_NAMESPACE) {
            LITERAL_INFO(opline->op2.constant, 3);
          } else {
            LITERAL_INFO(opline->op2.constant, 2);
          }
          break;
        case ZEND_FETCH_CLASS_CONSTANT:
          if (opline->op1_type == IS_CONST) {
            LITERAL_INFO(opline->op1.constant, 2);
          }
          if (opline->op2_type == IS_CONST) {
            LITERAL_INFO(opline->op2.constant, 1);
          }
          break;
        case ZEND_ASSIGN_STATIC_PROP:
        case ZEND_ASSIGN_STATIC_PROP_REF:
        case ZEND_FETCH_STATIC_PROP_R:
        case ZEND_FETCH_STATIC_PROP_W:
        case ZEND_FETCH_STATIC_PROP_RW:
        case ZEND_FETCH_STATIC_PROP_IS:
        case ZEND_FETCH_STATIC_PROP_UNSET:
        case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
        case ZEND_UNSET_STATIC_PROP:
        case ZEND_ISSET_ISEMPTY_STATIC_PROP:
        case ZEND_PRE_INC_STATIC_PROP:
        case ZEND_PRE_DEC_STATIC_PROP:
        case ZEND_POST_INC_STATIC_PROP:
        case ZEND_POST_DEC_STATIC_PROP:
        case ZEND_ASSIGN_STATIC_PROP_OP:
          if (opline->op2_type == IS_CONST) {
            LITERAL_INFO(opline->op2.constant, 2);
          }
          if (opline->op1_type == IS_CONST) {
            LITERAL_INFO(opline->op1.constant, 1);
          }
          break;
        case ZEND_FETCH_CLASS:
        case ZEND_INSTANCEOF:
          if (opline->op2_type == IS_CONST) {
            LITERAL_INFO(opline->op2.constant, 2);
          }
          break;
        case ZEND_NEW:
          if (opline->op1_type == IS_CONST) {
            LITERAL_INFO(opline->op1.constant, 2);
          }
          break;
        case ZEND_DECLARE_CLASS:
        case ZEND_DECLARE_CLASS_DELAYED:
          LITERAL_INFO(opline->op1.constant, 2);
          if (opline->op2_type == IS_CONST) {
            LITERAL_INFO(opline->op2.constant, 1);
          }
          break;
        case ZEND_ISSET_ISEMPTY_DIM_OBJ:
        case ZEND_ASSIGN_DIM:
        case ZEND_UNSET_DIM:
        case ZEND_FETCH_DIM_R:
        case ZEND_FETCH_DIM_W:
        case ZEND_FETCH_DIM_RW:
        case ZEND_FETCH_DIM_IS:
        case ZEND_FETCH_DIM_FUNC_ARG:
        case ZEND_FETCH_DIM_UNSET:
        case ZEND_FETCH_LIST_R:
        case ZEND_FETCH_LIST_W:
        case ZEND_ASSIGN_DIM_OP:
          if (opline->op1_type == IS_CONST) {
            LITERAL_INFO(opline->op1.constant, 1);
          }
          if (opline->op2_type == IS_CONST) {
            if (Z_EXTRA(op_array->literals[opline->op2.constant]) == ZEND_EXTRA_VALUE) {
              LITERAL_INFO(opline->op2.constant, 2);
            } else {
              LITERAL_INFO(opline->op2.constant, 1);
            }
          }
          break;
        default:
          if (opline->op1_type == IS_CONST) {
            LITERAL_INFO(opline->op1.constant, 1);
          }
          if (opline->op2_type == IS_CONST) {
            LITERAL_INFO(opline->op2.constant, 1);
          }
          break;
      }
      opline++;
    }

#if DEBUG_COMPACT_LITERALS
    {
      fprintf(stderr, "File %s func %s\n", op_array->filename->val,
          op_array->function_name ? op_array->function_name->val : "main");
      fprintf(stderr, "Literals table size %d\n", op_array->last_literal);

      for (uint32_t i = 0; i < op_array->last_literal; i++) {
        zend_string *str = zval_get_string(op_array->literals + i);
        fprintf(stderr, "Literal %" PRIu32 ", val (%zu):%s\n", i, ZSTR_LEN(str), ZSTR_VAL(str));
        zend_string_release(str);
      }
      fflush(stderr);
    }
#endif

    /* Merge equal constants */
    j = 0;
    zend_hash_init(&hash, op_array->last_literal, NULL, NULL, 0);
    map = (int*)zend_arena_alloc(&ctx->arena, op_array->last_literal * sizeof(int));
    memset(map, 0, op_array->last_literal * sizeof(int));
    for (uint32_t i = 0; i < op_array->last_literal; i++) {
      if (!info[i].num_related) {
        /* unset literal */
        zval_ptr_dtor_nogc(&op_array->literals[i]);
        continue;
      }
      switch (Z_TYPE(op_array->literals[i])) {
        case IS_NULL:
          ZEND_ASSERT(info[i].num_related == 1);
          if (l_null < 0) {
            l_null = j;
            if (i != j) {
              op_array->literals[j] = op_array->literals[i];
              info[j] = info[i];
            }
            j++;
          }
          map[i] = l_null;
          break;
        case IS_FALSE:
          ZEND_ASSERT(info[i].num_related == 1);
          if (l_false < 0) {
            l_false = j;
            if (i != j) {
              op_array->literals[j] = op_array->literals[i];
              info[j] = info[i];
            }
            j++;
          }
          map[i] = l_false;
          break;
        case IS_TRUE:
          ZEND_ASSERT(info[i].num_related == 1);
          if (l_true < 0) {
            l_true = j;
            if (i != j) {
              op_array->literals[j] = op_array->literals[i];
              info[j] = info[i];
            }
            j++;
          }
          map[i] = l_true;
          break;
        case IS_LONG:
          if (info[i].num_related == 1) {
            if ((pos = zend_hash_index_find(&hash, Z_LVAL(op_array->literals[i]))) != NULL) {
              map[i] = Z_LVAL_P(pos);
            } else {
              map[i] = j;
              ZVAL_LONG(&zv, j);
              zend_hash_index_add_new(&hash, Z_LVAL(op_array->literals[i]), &zv);
              if (i != j) {
                op_array->literals[j] = op_array->literals[i];
                info[j] = info[i];
              }
              j++;
            }
          } else {
            ZEND_ASSERT(info[i].num_related == 2);
            key = zend_string_init(Z_STRVAL(op_array->literals[i+1]), Z_STRLEN(op_array->literals[i+1]), 0);
            bias_key(key, 100 + info[i].num_related - 1);
            if ((pos = zend_hash_find(&hash, key)) != NULL) {
              ZEND_ASSERT(info[Z_LVAL_P(pos)].num_related == 2);
              map[i] = Z_LVAL_P(pos);
              zval_ptr_dtor_nogc(&op_array->literals[i+1]);
            } else {
              map[i] = j;
              ZVAL_LONG(&zv, j);
              zend_hash_add_new(&hash, key, &zv);
              if (i != j) {
                op_array->literals[j] = op_array->literals[i];
                info[j] = info[i];
                op_array->literals[j+1] = op_array->literals[i+1];
                info[j+1] = info[i+1];
              }
              j += 2;
            }
            zend_string_release_ex(key, 0);
            i++;
          }
          break;
        case IS_DOUBLE:
          ZEND_ASSERT(info[i].num_related == 1);
          key = zend_string_init((char*)&Z_DVAL(op_array->literals[i]), sizeof(double), 0);
          bias_key(key, 200);
          if ((pos = zend_hash_find(&hash, key))) {
            map[i] = Z_LVAL_P(pos);
          } else {
            map[i] = j;
            ZVAL_LONG(&zv, j);
            zend_hash_add_new(&hash, key, &zv);
            if (i != j) {
              op_array->literals[j] = op_array->literals[i];
              info[j] = info[i];
            }
            j++;
          }
          zend_string_release_ex(key, 0);
          break;
        case IS_STRING: {
          key = create_str_cache_key(&op_array->literals[i], info[i].num_related);
          if ((pos = zend_hash_find(&hash, key)) != NULL) {
            ZEND_ASSERT(Z_TYPE(op_array->literals[Z_LVAL_P(pos)]) == IS_STRING &&
              info[i].num_related == info[Z_LVAL_P(pos)].num_related);
            zend_string_release_ex(key, 0);
            map[i] = Z_LVAL_P(pos);
            zval_ptr_dtor_nogc(&op_array->literals[i]);
            n = info[i].num_related;
            while (n > 1) {
              i++;
              zval_ptr_dtor_nogc(&op_array->literals[i]);
              n--;
            }
          } else {
            map[i] = j;
            ZVAL_LONG(&zv, j);
            zend_hash_add_new(&hash, key, &zv);
            zend_string_release_ex(key, 0);
            if (i != j) {
              op_array->literals[j] = op_array->literals[i];
              info[j] = info[i];
            }
            j++;
            n = info[i].num_related;
            while (n > 1) {
              i++;
              if (i != j) op_array->literals[j] = op_array->literals[i];
              j++;
              n--;
            }
          }
          break;
        }
        case IS_ARRAY:
          ZEND_ASSERT(info[i].num_related == 1);
          if (zend_hash_num_elements(Z_ARRVAL(op_array->literals[i])) == 0) {
            if (l_empty_arr < 0) {
              l_empty_arr = j;
              if (i != j) {
                op_array->literals[j] = op_array->literals[i];
                info[j] = info[i];
              }
              j++;
            } else {
              zval_ptr_dtor_nogc(&op_array->literals[i]);
            }
            map[i] = l_empty_arr;
            break;
          }
          ZEND_FALLTHROUGH;
        default:
          /* don't merge other types */
          ZEND_ASSERT(info[i].num_related == 1);
          map[i] = j;
          if (i != j) {
            op_array->literals[j] = op_array->literals[i];
            info[j] = info[i];
          }
          j++;
          break;
      }
    }

    /* Only clean "hash", as it will be reused in the loop below. */
    zend_hash_clean(&hash);
    op_array->last_literal = j;

    const_slot = zend_arena_alloc(&ctx->arena, j * 7 * sizeof(int));
    memset(const_slot, -1, j * 7 * sizeof(int));
    class_slot = const_slot + j;
    func_slot = class_slot + j;
    bind_var_slot = func_slot + j;
    property_slot = bind_var_slot + j;
    method_slot = property_slot + j;
    jmp_slot = method_slot + j;

    /* Update opcodes to use new literals table */
    cache_size = zend_op_array_extension_handles * sizeof(void*);
    opline = op_array->opcodes;
    end = opline + op_array->last;
    while (opline < end) {
      if (opline->op1_type == IS_CONST) {
        opline->op1.constant = map[opline->op1.constant];
      }
      if (opline->op2_type == IS_CONST) {
        opline->op2.constant = map[opline->op2.constant];
      }
      switch (opline->opcode) {
        case ZEND_ASSIGN_STATIC_PROP_OP:
          if (opline->op1_type == IS_CONST) {
            // op1 static property
            if (opline->op2_type == IS_CONST) {
              (opline+1)->extended_value = add_static_slot(&hash, op_array,
                opline->op2.constant,
                opline->op1.constant,
                LITERAL_STATIC_PROPERTY,
                &cache_size);
            } else {
              (opline+1)->extended_value = cache_size;
              cache_size += 3 * sizeof(void *);
            }
          } else if (opline->op2_type == IS_CONST) {
            // op2 class
            if (class_slot[opline->op2.constant] >= 0) {
              (opline+1)->extended_value = class_slot[opline->op2.constant];
            } else {
              (opline+1)->extended_value = cache_size;
              class_slot[opline->op2.constant] = cache_size;
              cache_size += sizeof(void *);
            }
          }
          break;
        case ZEND_ASSIGN_OBJ_OP:
          if (opline->op2_type == IS_CONST) {
            // op2 property
            if (opline->op1_type == IS_UNUSED &&
                property_slot[opline->op2.constant] >= 0) {
              (opline+1)->extended_value = property_slot[opline->op2.constant];
            } else {
              (opline+1)->extended_value = cache_size;
              cache_size += 3 * sizeof(void *);
              if (opline->op1_type == IS_UNUSED) {
                property_slot[opline->op2.constant] = (opline+1)->extended_value;
              }
            }
          }
          break;
        case ZEND_ASSIGN_OBJ:
        case ZEND_ASSIGN_OBJ_REF:
        case ZEND_FETCH_OBJ_R:
        case ZEND_FETCH_OBJ_W:
        case ZEND_FETCH_OBJ_RW:
        case ZEND_FETCH_OBJ_IS:
        case ZEND_FETCH_OBJ_UNSET:
        case ZEND_FETCH_OBJ_FUNC_ARG:
        case ZEND_UNSET_OBJ:
        case ZEND_PRE_INC_OBJ:
        case ZEND_PRE_DEC_OBJ:
        case ZEND_POST_INC_OBJ:
        case ZEND_POST_DEC_OBJ:
          if (opline->op2_type == IS_CONST) {
            // op2 property
            if (opline->op1_type == IS_UNUSED &&
                property_slot[opline->op2.constant] >= 0) {
              opline->extended_value = property_slot[opline->op2.constant] | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
            } else {
              opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
              cache_size += 3 * sizeof(void *);
              if (opline->op1_type == IS_UNUSED) {
                property_slot[opline->op2.constant] = opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS;
              }
            }
          }
          break;
        case ZEND_ISSET_ISEMPTY_PROP_OBJ:
          if (opline->op2_type == IS_CONST) {
            // op2 property
            if (opline->op1_type == IS_UNUSED &&
                property_slot[opline->op2.constant] >= 0) {
              opline->extended_value = property_slot[opline->op2.constant] | (opline->extended_value & ZEND_ISEMPTY);
            } else {
              opline->extended_value = cache_size | (opline->extended_value & ZEND_ISEMPTY);
              cache_size += 3 * sizeof(void *);
              if (opline->op1_type == IS_UNUSED) {
                property_slot[opline->op2.constant] = opline->extended_value & ~ZEND_ISEMPTY;
              }
            }
          }
          break;
        case ZEND_INIT_FCALL:
        case ZEND_INIT_FCALL_BY_NAME:
        case ZEND_INIT_NS_FCALL_BY_NAME:
          // op2 func
          if (func_slot[opline->op2.constant] >= 0) {
            opline->result.num = func_slot[opline->op2.constant];
          } else {
            opline->result.num = cache_size;
            cache_size += sizeof(void *);
            func_slot[opline->op2.constant] = opline->result.num;
          }
          break;
        case ZEND_INIT_METHOD_CALL:
          if (opline->op2_type == IS_CONST) {
            // op2 method
            if (opline->op1_type == IS_UNUSED &&
                method_slot[opline->op2.constant] >= 0) {
              opline->result.num = method_slot[opline->op2.constant];
            } else {
              opline->result.num = cache_size;
              cache_size += 2 * sizeof(void *);
              if (opline->op1_type == IS_UNUSED) {
                method_slot[opline->op2.constant] = opline->result.num;
              }
            }
          }
          break;
        case ZEND_INIT_STATIC_METHOD_CALL:
          if (opline->op2_type == IS_CONST) {
            // op2 static method
            if (opline->op1_type == IS_CONST) {
              opline->result.num = add_static_slot(&hash, op_array,
                opline->op1.constant,
                opline->op2.constant,
                LITERAL_STATIC_METHOD,
                &cache_size);
            } else {
              opline->result.num = cache_size;
              cache_size += 2 * sizeof(void *);
            }
          } else if (opline->op1_type == IS_CONST) {
            // op1 class
            if (class_slot[opline->op1.constant] >= 0) {
              opline->result.num = class_slot[opline->op1.constant];
            } else {
              opline->result.num = cache_size;
              cache_size += sizeof(void *);
              class_slot[opline->op1.constant] = opline->result.num;
            }
          }
          break;
        case ZEND_DEFINED:
          // op1 const
          if (const_slot[opline->op1.constant] >= 0) {
            opline->extended_value = const_slot[opline->op1.constant];
          } else {
            opline->extended_value = cache_size;
            cache_size += sizeof(void *);
            const_slot[opline->op1.constant] = opline->extended_value;
          }
          break;
        case ZEND_FETCH_CONSTANT:
          // op2 const
          if (const_slot[opline->op2.constant] >= 0) {
            opline->extended_value = const_slot[opline->op2.constant];
          } else {
            opline->extended_value = cache_size;
            cache_size += sizeof(void *);
            const_slot[opline->op2.constant] = opline->extended_value;
          }
          break;
        case ZEND_FETCH_CLASS_CONSTANT:
          if (opline->op1_type == IS_CONST
            && opline->op2_type == IS_CONST
            && Z_TYPE(op_array->literals[opline->op2.constant]) == IS_STRING) {
            // op1/op2 class_const
            opline->extended_value = add_static_slot(&hash, op_array,
              opline->op1.constant,
              opline->op2.constant,
              LITERAL_CLASS_CONST,
              &cache_size);
          } else {
            opline->extended_value = cache_size;
            cache_size += 2 * sizeof(void *);
          }
          break;
        case ZEND_ASSIGN_STATIC_PROP:
        case ZEND_ASSIGN_STATIC_PROP_REF:
        case ZEND_FETCH_STATIC_PROP_R:
        case ZEND_FETCH_STATIC_PROP_W:
        case ZEND_FETCH_STATIC_PROP_RW:
        case ZEND_FETCH_STATIC_PROP_IS:
        case ZEND_FETCH_STATIC_PROP_UNSET:
        case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
        case ZEND_UNSET_STATIC_PROP:
        case ZEND_ISSET_ISEMPTY_STATIC_PROP:
        case ZEND_PRE_INC_STATIC_PROP:
        case ZEND_PRE_DEC_STATIC_PROP:
        case ZEND_POST_INC_STATIC_PROP:
        case ZEND_POST_DEC_STATIC_PROP:
          if (opline->op1_type == IS_CONST) {
            // op1 static property
            if (opline->op2_type == IS_CONST) {
              opline->extended_value = add_static_slot(&hash, op_array,
                opline->op2.constant,
                opline->op1.constant,
                LITERAL_STATIC_PROPERTY,
                &cache_size) | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
            } else {
              opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
              cache_size += 3 * sizeof(void *);
            }
          } else if (opline->op2_type == IS_CONST) {
            // op2 class
            if (class_slot[opline->op2.constant] >= 0) {
              opline->extended_value = class_slot[opline->op2.constant] | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
            } else {
              opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
              class_slot[opline->op2.constant] = cache_size;
              cache_size += sizeof(void *);
            }
          }
          break;
        case ZEND_FETCH_CLASS:
        case ZEND_INSTANCEOF:
          if (opline->op2_type == IS_CONST) {
            // op2 class
            if (class_slot[opline->op2.constant] >= 0) {
              opline->extended_value = class_slot[opline->op2.constant];
            } else {
              opline->extended_value = cache_size;
              cache_size += sizeof(void *);
              class_slot[opline->op2.constant] = opline->extended_value;
            }
          }
          break;
        case ZEND_NEW:
          if (opline->op1_type == IS_CONST) {
            // op1 class
            if (class_slot[opline->op1.constant] >= 0) {
              opline->op2.num = class_slot[opline->op1.constant];
            } else {
              opline->op2.num = cache_size;
              cache_size += sizeof(void *);
              class_slot[opline->op1.constant] = opline->op2.num;
            }
          }
          break;
        case ZEND_CATCH:
          if (opline->op1_type == IS_CONST) {
            // op1 class
            if (class_slot[opline->op1.constant] >= 0) {
              opline->extended_value = class_slot[opline->op1.constant] | (opline->extended_value & ZEND_LAST_CATCH);
            } else {
              opline->extended_value = cache_size | (opline->extended_value & ZEND_LAST_CATCH);
              cache_size += sizeof(void *);
              class_slot[opline->op1.constant] = opline->extended_value & ~ZEND_LAST_CATCH;
            }
          }
          break;
        case ZEND_BIND_GLOBAL:
          // op2 bind var
          if (bind_var_slot[opline->op2.constant] >= 0) {
            opline->extended_value = bind_var_slot[opline->op2.constant];
          } else {
            opline->extended_value = cache_size;
            cache_size += sizeof(void *);
            bind_var_slot[opline->op2.constant] = opline->extended_value;
          }
          break;
        case ZEND_DECLARE_ANON_CLASS:
        case ZEND_DECLARE_CLASS_DELAYED:
          opline->extended_value = cache_size;
          cache_size += sizeof(void *);
          break;
        case ZEND_JMP_FRAMELESS:
          // op1 func
          if (jmp_slot[opline->op1.constant] >= 0) {
            opline->extended_value = jmp_slot[opline->op1.constant];
          } else {
            opline->extended_value = cache_size;
            cache_size += sizeof(void *);
            jmp_slot[opline->op1.constant] = opline->extended_value;
          }
          break;
        case ZEND_SEND_VAL:
        case ZEND_SEND_VAL_EX:
        case ZEND_SEND_VAR:
        case ZEND_SEND_VAR_EX:
        case ZEND_SEND_VAR_NO_REF:
        case ZEND_SEND_VAR_NO_REF_EX:
        case ZEND_SEND_REF:
        case ZEND_SEND_FUNC_ARG:
        case ZEND_CHECK_FUNC_ARG:
          if (opline->op2_type == IS_CONST) {
            opline->result.num = cache_size;
            cache_size += 2 * sizeof(void *);
          }
          break;
        case ZEND_CALLABLE_CONVERT:
          if (opline->extended_value != (uint32_t)-1) {
            opline->extended_value = cache_size;
            cache_size += sizeof(void *);
          }
          break;
      }
      opline++;
    }
    op_array->cache_size = cache_size;
    zend_hash_destroy(&hash);
    zend_arena_release(&ctx->arena, checkpoint);

    if (1) {
      opline = op_array->opcodes;
      while (1) {
        if (opline->opcode == ZEND_RECV_INIT) {
          zval *val = &op_array->literals[opline->op2.constant];

          if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
            /* Ensure zval is aligned to 8 bytes */
            op_array->cache_size = ZEND_MM_ALIGNED_SIZE_EX(op_array->cache_size, 8);
            Z_CACHE_SLOT_P(val) = op_array->cache_size;
            op_array->cache_size += sizeof(zval);
          }
        } else if (opline->opcode != ZEND_RECV) {
          break;
        }
        opline++;
      }
    }

#if DEBUG_COMPACT_LITERALS
    {
      fprintf(stderr, "Optimized literals table size %d\n", op_array->last_literal);

      for (uint32_t i = 0; i < op_array->last_literal; i++) {
        zend_string *str = zval_get_string(op_array->literals + i);
        fprintf(stderr, "Literal %" PRIu32 ", val (%zu):%s\n", i, ZSTR_LEN(str), ZSTR_VAL(str));
        zend_string_release(str);
      }
      fflush(stderr);
    }
#endif
  }
}

Coverage Report

Created: 2026-06-02 06:36