Use more compact representation for packed arrays.

Zend/Optimizer/block_pass.c

@@ -1058,9 +1058,9 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op
 				uint32_t s = 0;
 				ZEND_ASSERT(b->successors_count == (opline->opcode == ZEND_MATCH ? 1 : 2) + zend_hash_num_elements(jumptable));
 
-				ZEND_HASH_FOREACH_VAL(jumptable, zv) {
+				ZEND_ARRAY_FOREACH_VAL(jumptable, zv) {
 					Z_LVAL_P(zv) = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[s++]].start);
-				} ZEND_HASH_FOREACH_END();
+				} ZEND_ARRAY_FOREACH_END();
 				opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[s++]].start);
 				break;
 			}

Zend/Optimizer/dfa_pass.c

@@ -415,7 +415,7 @@ int zend_dfa_optimize_calls(zend_op_array *op_array, zend_ssa *ssa)
 					ZVAL_TRUE(&tmp);
 					dst = zend_new_array(zend_hash_num_elements(src));
 					if (strict) {
-						ZEND_HASH_FOREACH_VAL(src, val) {
+						ZEND_ARRAY_FOREACH_VAL(src, val) {
 							if (Z_TYPE_P(val) == IS_STRING) {
 								zend_hash_add(dst, Z_STR_P(val), &tmp);
 							} else if (Z_TYPE_P(val) == IS_LONG) {
@@ -425,16 +425,16 @@ int zend_dfa_optimize_calls(zend_op_array *op_array, zend_ssa *ssa)
 								ok = 0;
 								break;
 							}
-						} ZEND_HASH_FOREACH_END();
+						} ZEND_ARRAY_FOREACH_END();
 					} else {
-						ZEND_HASH_FOREACH_VAL(src, val) {
+						ZEND_ARRAY_FOREACH_VAL(src, val) {
 							if (Z_TYPE_P(val) != IS_STRING || ZEND_HANDLE_NUMERIC(Z_STR_P(val), idx)) {
 								zend_array_destroy(dst);
 								ok = 0;
 								break;
 							}
 							zend_hash_add(dst, Z_STR_P(val), &tmp);
-						} ZEND_HASH_FOREACH_END();
+						} ZEND_ARRAY_FOREACH_END();
 					}
 
 					if (ok) {
@@ -660,11 +660,11 @@ static void zend_ssa_replace_control_link(zend_op_array *op_array, zend_ssa *ssa
 				{
 					HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline));
 					zval *zv;
-					ZEND_HASH_FOREACH_VAL(jumptable, zv) {
+					ZEND_ARRAY_FOREACH_VAL(jumptable, zv) {
 						if (ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)) == old->start) {
 							Z_LVAL_P(zv) = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, dst->start);
 						}
-					} ZEND_HASH_FOREACH_END();
+					} ZEND_ARRAY_FOREACH_END();
 					if (ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value) == old->start) {
 						opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, dst->start);
 					}

Zend/Optimizer/sccp.c

@@ -587,7 +587,7 @@ static inline zend_result ct_eval_add_array_unpack(zval *result, zval *array) {
 	}
 
 	SEPARATE_ARRAY(result);
-	ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(array), key, value) {
+	ZEND_ARRAY_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(array), key, value) {
 		if (key) {
 			value = zend_hash_update(Z_ARR_P(result), key, value);
 		} else {
@@ -597,7 +597,7 @@ static inline zend_result ct_eval_add_array_unpack(zval *result, zval *array) {
 			return FAILURE;
 		}
 		Z_TRY_ADDREF_P(value);
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 	return SUCCESS;
 }
 
@@ -2009,7 +2009,7 @@ static void join_hash_tables(HashTable *ret, HashTable *ht1, HashTable *ht2)
 	zend_string *key;
 	zval *val1, *val2;
 
-	ZEND_HASH_FOREACH_KEY_VAL(ht1, index, key, val1) {
+	ZEND_ARRAY_FOREACH_KEY_VAL(ht1, index, key, val1) {
 		if (key) {
 			val2 = zend_hash_find(ht2, key);
 		} else {
@@ -2023,7 +2023,7 @@ static void join_hash_tables(HashTable *ret, HashTable *ht1, HashTable *ht2)
 			}
 			Z_TRY_ADDREF_P(val1);
 		}
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 }
 
 static zend_result join_partial_arrays(zval *a, zval *b)

Zend/Optimizer/zend_cfg.c

@@ -401,9 +401,9 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array,
 			{
 				HashTable *jumptable = Z_ARRVAL_P(CRT_CONSTANT(opline->op2));
 				zval *zv;
-				ZEND_HASH_FOREACH_VAL(jumptable, zv) {
+				ZEND_ARRAY_FOREACH_VAL(jumptable, zv) {
 					BB_START(ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)));
-				} ZEND_HASH_FOREACH_END();
+				} ZEND_ARRAY_FOREACH_END();
 				BB_START(ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
 				BB_START(i + 1);
 				break;
@@ -574,9 +574,9 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array,
 				block->successors_count = (opline->opcode == ZEND_MATCH ? 1 : 2) + zend_hash_num_elements(jumptable);
 				block->successors = zend_arena_calloc(arena, block->successors_count, sizeof(int));
 
-				ZEND_HASH_FOREACH_VAL(jumptable, zv) {
+				ZEND_ARRAY_FOREACH_VAL(jumptable, zv) {
 					block->successors[s++] = block_map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))];
-				} ZEND_HASH_FOREACH_END();
+				} ZEND_ARRAY_FOREACH_END();
 
 				block->successors[s++] = block_map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)];
 				if (opline->opcode != ZEND_MATCH) {

Zend/Optimizer/zend_dump.c

@@ -31,7 +31,7 @@ void zend_dump_ht(HashTable *ht)
 	zval *val;
 	bool first = 1;
 
-	ZEND_HASH_FOREACH_KEY_VAL(ht, index, key, val) {
+	ZEND_ARRAY_FOREACH_KEY_VAL(ht, index, key, val) {
 		if (first) {
 			first = 0;
 		} else {
@@ -44,7 +44,7 @@ void zend_dump_ht(HashTable *ht)
 		}
 		fprintf(stderr, " =>");
 		zend_dump_const(val);
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 }
 
 void zend_dump_const(const zval *zv)
@@ -643,7 +643,7 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block
 			zend_string *key;
 			zend_ulong num_key;
 			zval *zv;
-			ZEND_HASH_FOREACH_KEY_VAL(jumptable, num_key, key, zv) {
+			ZEND_ARRAY_FOREACH_KEY_VAL(jumptable, num_key, key, zv) {
 				if (key) {
 					fprintf(stderr, " \"%s\":", ZSTR_VAL(key));
 				} else {
@@ -654,7 +654,7 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block
 				} else {
 					fprintf(stderr, " %04u,", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)));
 				}
-			} ZEND_HASH_FOREACH_END();
+			} ZEND_ARRAY_FOREACH_END();
 			fprintf(stderr, " default:");
 		} else {
 			zend_dump_const(op);

Zend/Optimizer/zend_inference.c

@@ -2031,14 +2031,14 @@ ZEND_API uint32_t ZEND_FASTCALL zend_array_type_info(const zval *zv)
 		tmp |= MAY_BE_RCN;
 	}
 
-	ZEND_HASH_FOREACH_STR_KEY_VAL(ht, str, val) {
+	ZEND_ARRAY_FOREACH_STR_KEY_VAL(ht, str, val) {
 		if (str) {
 			tmp |= MAY_BE_ARRAY_KEY_STRING;
 		} else {
 			tmp |= MAY_BE_ARRAY_KEY_LONG;
 		}
 		tmp |= 1 << (Z_TYPE_P(val) + MAY_BE_ARRAY_SHIFT);
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 	if (HT_IS_PACKED(ht)) {
 		tmp &= ~(MAY_BE_ARRAY_NUMERIC_HASH|MAY_BE_ARRAY_STRING_HASH);
 	}

Zend/Optimizer/zend_optimizer.c

@@ -676,9 +676,9 @@ void zend_optimizer_migrate_jump(zend_op_array *op_array, zend_op *new_opline, z
 		{
 			HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline));
 			zval *zv;
-			ZEND_HASH_FOREACH_VAL(jumptable, zv) {
+			ZEND_ARRAY_FOREACH_VAL(jumptable, zv) {
 				Z_LVAL_P(zv) = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)));
-			} ZEND_HASH_FOREACH_END();
+			} ZEND_ARRAY_FOREACH_END();
 			new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
 			break;
 		}
@@ -722,9 +722,9 @@ void zend_optimizer_shift_jump(zend_op_array *op_array, zend_op *opline, uint32_
 		{
 			HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline));
 			zval *zv;
-			ZEND_HASH_FOREACH_VAL(jumptable, zv) {
+			ZEND_ARRAY_FOREACH_VAL(jumptable, zv) {
 				Z_LVAL_P(zv) = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)) - shiftlist[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))]);
-			} ZEND_HASH_FOREACH_END();
+			} ZEND_ARRAY_FOREACH_END();
 			opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value) - shiftlist[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]);
 			break;
 		}

Zend/zend.c

@@ -315,7 +315,7 @@ static void print_hash(smart_str *buf, HashTable *ht, int indent, bool is_object
 	}
 	smart_str_appends(buf, "(\n");
 	indent += PRINT_ZVAL_INDENT;
-	ZEND_HASH_FOREACH_KEY_VAL_IND(ht, num_key, string_key, tmp) {
+	ZEND_ARRAY_FOREACH_KEY_VAL_IND(ht, num_key, string_key, tmp) {
 		for (i = 0; i < indent; i++) {
 			smart_str_appendc(buf, ' ');
 		}
@@ -345,7 +345,7 @@ static void print_hash(smart_str *buf, HashTable *ht, int indent, bool is_object
 		smart_str_appends(buf, "] => ");
 		zend_print_zval_r_to_buf(buf, tmp, indent+PRINT_ZVAL_INDENT);
 		smart_str_appends(buf, "\n");
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 	indent -= PRINT_ZVAL_INDENT;
 	for (i = 0; i < indent; i++) {
 		smart_str_appendc(buf, ' ');
@@ -361,7 +361,7 @@ static void print_flat_hash(smart_str *buf, HashTable *ht) /* {{{ */
 	zend_ulong num_key;
 	int i = 0;
 
-	ZEND_HASH_FOREACH_KEY_VAL_IND(ht, num_key, string_key, tmp) {
+	ZEND_ARRAY_FOREACH_KEY_VAL_IND(ht, num_key, string_key, tmp) {
 		if (i++ > 0) {
 			smart_str_appendc(buf, ',');
 		}
@@ -373,7 +373,7 @@ static void print_flat_hash(smart_str *buf, HashTable *ht) /* {{{ */
 		}
 		smart_str_appends(buf, "] => ");
 		zend_print_flat_zval_r_to_buf(buf, tmp);
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 }
 /* }}} */
 

Zend/zend_API.c

@@ -3919,7 +3919,7 @@ ZEND_API zend_result zend_fcall_info_args_ex(zend_fcall_info *fci, zend_function
 	fci->param_count = zend_hash_num_elements(Z_ARRVAL_P(args));
 	fci->params = params = (zval *) erealloc(fci->params, fci->param_count * sizeof(zval));
 
-	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(args), arg) {
+	ZEND_ARRAY_FOREACH_VAL(Z_ARRVAL_P(args), arg) {
 		if (func && !Z_ISREF_P(arg) && ARG_SHOULD_BE_SENT_BY_REF(func, n)) {
 			ZVAL_NEW_REF(params, arg);
 			Z_TRY_ADDREF_P(arg);
@@ -3928,7 +3928,7 @@ ZEND_API zend_result zend_fcall_info_args_ex(zend_fcall_info *fci, zend_function
 		}
 		params++;
 		n++;
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 
 	return SUCCESS;
 }

Zend/zend_alloc.c

@@ -2798,10 +2798,10 @@ static void *tracked_realloc(void *ptr, size_t new_size) {
 static void tracked_free_all() {
 	HashTable *tracked_allocs = AG(mm_heap)->tracked_allocs;
 	zend_ulong h;
-	ZEND_HASH_FOREACH_NUM_KEY(tracked_allocs, h) {
+	ZEND_ARRAY_FOREACH_NUM_KEY(tracked_allocs, h) {
 		void *ptr = (void *) (uintptr_t) (h << ZEND_MM_ALIGNMENT_LOG2);
 		free(ptr);
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_ARRAY_FOREACH_END();
 }
 #endif
 

Zend/zend_ast.c

@@ -460,7 +460,7 @@ static zend_result zend_ast_add_unpacked_element(zval *result, zval *expr) {
 		zval *val;
 		zend_string *key;
 
-		ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
+		ZEND_ARRAY_FOREACH_STR_KEY_VAL(ht, key, val) {
 			if (key) {
 				zend_hash_update(Z_ARRVAL_P(result), key, val);
 			} else {
@@ -471,7 +471,7 @@ static zend_result zend_ast_add_unpacked_element(zval *result, zval *expr) {
 				}
 			}
 			Z_TRY_ADDREF_P(val);
-		} ZEND_HASH_FOREACH_END();
+		} ZEND_ARRAY_FOREACH_END();
 		return SUCCESS;
 	}
 
@@ -1418,7 +1418,7 @@ static ZEND_COLD void zend_ast_export_zval(smart_str *str, zval *zv, int priorit
 			zval *val;
 			bool first = true;
 			smart_str_appendc(str, '[');
-			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(zv), idx, key, val) {
+			ZEND_ARRAY_FOREACH_KEY_VAL(Z_ARRVAL_P(zv), idx, key, val) {
 				if (first) {
 					first = false;
 				} else {
@@ -1433,7 +1433,7 @@ static ZEND_COLD void zend_ast_export_zval(smart_str *str, zval *zv, int priorit
 					smart_str_appends(str, " => ");
 				}
 				zend_ast_export_zval(str, val, 0, indent);
-			} ZEND_HASH_FOREACH_END();
+			} ZEND_ARRAY_FOREACH_END();
 			smart_str_appendc(str, ']');
 			break;
 		}

Zend/zend_attributes.c

@@ -78,11 +78,11 @@ static zend_attribute *get_attribute(HashTable *attributes, zend_string *lcname,
 	if (attributes) {
 		zend_attribute *attr;
 
-		ZEND_HASH_FOREACH_PTR(attributes, attr) {
+		ZEND_PACKED_FOREACH_PTR(attributes, attr) {
 			if (attr->offset == offset && zend_string_equals(attr->lcname, lcname)) {
 				return attr;
 			}
-		} ZEND_HASH_FOREACH_END();
+		} ZEND_PACKED_FOREACH_END();
 	}
 
 	return NULL;
@@ -93,13 +93,13 @@ static zend_attribute *get_attribute_str(HashTable *attributes, const char *str,
 	if (attributes) {
 		zend_attribute *attr;
 
-		ZEND_HASH_FOREACH_PTR(attributes, attr) {
+		ZEND_PACKED_FOREACH_PTR(attributes, attr) {
 			if (attr->offset == offset && ZSTR_LEN(attr->lcname) == len) {
 				if (0 == memcmp(ZSTR_VAL(attr->lcname), str, len)) {
 					return attr;
 				}
 			}
-		} ZEND_HASH_FOREACH_END();
+		} ZEND_PACKED_FOREACH_END();
 	}
 
 	return NULL;
@@ -173,13 +173,13 @@ ZEND_API bool zend_is_attribute_repeated(HashTable *attributes, zend_attribute *
 {
 	zend_attribute *other;
 
-	ZEND_HASH_FOREACH_PTR(attributes, other) {
+	ZEND_PACKED_FOREACH_PTR(attributes, other) {
 		if (other != attr && other->offset == attr->offset) {
 			if (zend_string_equals(other->lcname, attr->lcname)) {
 				return 1;
 			}
 		}
-	} ZEND_HASH_FOREACH_END();
+	} ZEND_PACKED_FOREACH_END();
 
 	return 0;
 }