Avoid bailout in pattern matching

Author: iluuu1994

Zend/zend_execute_API.c

@@ -198,7 +198,6 @@ void init_executor(void) /* {{{ */
 
 	EG(filename_override) = NULL;
 	EG(lineno_override) = -1;
-	EG(pattern_matching_bailout) = false;
 
 	zend_max_execution_timer_init();
 	zend_fiber_init();

Zend/zend_globals.h

@@ -304,9 +304,6 @@ struct _zend_executor_globals {
 	struct sigaction oldact;
 #endif
 
-	/* Whether the last bailout was triggered while pattern matching */
-	bool pattern_matching_bailout;
-
 	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
 };
 

Zend/zend_pattern_matching.c

@@ -20,38 +20,38 @@
 #include "zend_exceptions.h"
 #include "zend_type_info.h"
 
-bool zend_pattern_match_ex(zval *zv, zend_ast *pattern);
+typedef enum {
+	PM_ERROR = -1,
+	PM_MISMATCH = 0,
+	PM_MATCH = 1,
+} pm_result;
 
-static bool match_type(zval *zv, zend_ast *type_ast)
+pm_result zend_pattern_match_ex(zval *zv, zend_ast *pattern);
+
+static pm_result match_type(zval *zv, zend_ast *type_ast)
 {
 	zend_ast *class_name_ast = type_ast->child[0];
 	if (class_name_ast) {
 		if (Z_TYPE_P(zv) != IS_OBJECT) {
-			return false;
+			return PM_MISMATCH;
 		}
 
 		zend_object *obj = Z_OBJ_P(zv);
 		zend_string *class_name = zend_ast_get_str(class_name_ast);
 		if (!zend_string_equals_ci(obj->ce->name, class_name)) {
 			zend_class_entry *expected_class = zend_lookup_class_ex(class_name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
 			if (!expected_class || !instanceof_function(Z_OBJ_P(zv)->ce, expected_class)) {
-				return false;
+				return PM_MISMATCH;
 			}
 		}
 	} else {
 		zend_type type = ZEND_TYPE_INIT_MASK(type_ast->attr);
 		if (!ZEND_TYPE_CONTAINS_CODE(type, Z_TYPE_P(zv))) {
-			return false;
+			return PM_MISMATCH;
 		}
 	}
 
-	return true;
-}
-
-static bool pattern_matching_bailout(void)
-{
-	EG(pattern_matching_bailout) = true;
-	zend_bailout();
+	return PM_MATCH;
 }
 
 static bool match_zval(zval *lhs, zval *rhs)
@@ -68,26 +68,26 @@ static zend_class_entry *get_class_from_fetch_type(uint32_t fetch_type)
 			scope = zend_get_executed_scope();
 			if (UNEXPECTED(!scope)) {
 				zend_throw_error(NULL, "%s", "Cannot access \"self\" when no class scope is active");
-				pattern_matching_bailout();
+				return NULL;
 			}
 			return scope;
 		case ZEND_FETCH_CLASS_PARENT:
 			scope = zend_get_executed_scope();
 			if (UNEXPECTED(!scope)) {
 				zend_throw_error(NULL, "%s", "Cannot access \"parent\" when no class scope is active");
-				pattern_matching_bailout();
+				return NULL;
 			}
 			scope = scope->parent;
 			if (UNEXPECTED(!scope)) {
 				zend_throw_error(NULL, "%s", "Cannot access \"parent\" when current class scope has no parent");
-				pattern_matching_bailout();
+				return NULL;
 			}
 			return scope;
 		case ZEND_FETCH_CLASS_STATIC:
 			scope = zend_get_called_scope(EG(current_execute_data));
 			if (UNEXPECTED(!scope)) {
 				zend_throw_error(NULL, "%s", "Cannot access \"static\" when no class scope is active");
-				pattern_matching_bailout();
+				return NULL;
 			}
 			return scope;
 		EMPTY_SWITCH_DEFAULT_CASE();
@@ -96,28 +96,31 @@ static zend_class_entry *get_class_from_fetch_type(uint32_t fetch_type)
 	return NULL;
 }
 
-static bool match_object(zval *zv, zend_ast *pattern)
+static pm_result match_object(zval *zv, zend_ast *pattern)
 {
 	if (Z_TYPE_P(zv) != IS_OBJECT) {
-		return false;
+		return PM_MISMATCH;
 	}
 
 	zend_object *obj = Z_OBJ_P(zv);
 	zend_ast *class_name_ast = pattern->child[0];
-	
+
 	if (class_name_ast) {
 		zend_string *class_name = zend_ast_get_str(class_name_ast);
 		if (!zend_string_equals_ci(obj->ce->name, class_name)) {
 			zend_class_entry *expected_class = zend_lookup_class_ex(class_name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
 			if (!expected_class || !instanceof_function(Z_OBJ_P(zv)->ce, expected_class)) {
-				return false;
+				return PM_MISMATCH;
 			}
 		}
 	} else {
 		uint32_t fetch_type = pattern->attr;
 		zend_class_entry *scope = get_class_from_fetch_type(fetch_type);
+		if (EG(exception)) {
+			return PM_ERROR;
+		}
 		if (!instanceof_function(Z_OBJ_P(zv)->ce, scope)) {
-			return false;
+			return PM_MISMATCH;
 		}
 	}
 
@@ -129,40 +132,40 @@ static bool match_object(zval *zv, zend_ast *pattern)
 		zend_string *property_name = zend_ast_get_str(property_or_method_call);
 		zval property_result_rv;
 		zval *property_result = obj->handlers->read_property(obj, property_name, BP_VAR_R, NULL, &property_result_rv);
-		bool element_matched = zend_pattern_match_ex(property_result, element_pattern);
+		pm_result element_matched = zend_pattern_match_ex(property_result, element_pattern);
 		if (property_result == &property_result_rv) {
 			zval_ptr_dtor(property_result);
 		}
-		if (!element_matched) {
-			return false;
+		if (element_matched != PM_MATCH) {
+			return element_matched;
 		}
 	}
 
-	return true;
+	return PM_MATCH;
 }
 
-static bool match_range(zval *zv, zend_ast *pattern)
+static pm_result match_range(zval *zv, zend_ast *pattern)
 {
 	zval *start = zend_ast_get_zval(pattern->child[0]);
 	zval *end = zend_ast_get_zval(pattern->child[1]);
 
 	if (Z_TYPE_P(zv) != Z_TYPE_P(start) && zend_compare(zv, start) == -1) {
-		return false;
+		return PM_MISMATCH;
 	}
 
 	int end_check = zend_compare(zv, end);
 	if (Z_TYPE_P(zv) != Z_TYPE_P(end) || end_check == 1 || (!(pattern->attr & ZEND_AST_RANGE_INCLUSIVE_END) && end_check == 0)) {
-		return false;
+		return PM_MISMATCH;
 	}
 
-	return true;
+	return PM_MATCH;
 }
 
-static bool match_binding(zval *zv, zend_ast *pattern)
+static pm_result match_binding(zval *zv, zend_ast *pattern)
 {
 	zend_ast *sub_pattern = pattern->child[1];
 	if (sub_pattern && !zend_pattern_match_ex(zv, sub_pattern)) {
-		return false;
+		return PM_MISMATCH;
 	}
 
 	// FIXME: Delay to the end of pattern matching
@@ -172,22 +175,22 @@ static bool match_binding(zval *zv, zend_ast *pattern)
 	zend_assign_to_variable(cv, zv, IS_CV, EX_USES_STRICT_TYPES());
 	/* Destructor might throw */
 	if (EG(exception)) {
-		pattern_matching_bailout();
+		return PM_ERROR;
 	}
-	return true;
+	return PM_MATCH;
 }
 
-static bool match_array(zval *zv, zend_ast *pattern)
+static pm_result match_array(zval *zv, zend_ast *pattern)
 {
 	if (Z_TYPE_P(zv) != IS_ARRAY) {
-		return false;
+		return PM_MISMATCH;
 	}
 
 	HashTable *ht = Z_ARRVAL_P(zv);
 	zend_ast_list *element_list = zend_ast_get_list(pattern->child[0]);
 
 	if (!(pattern->attr & ZEND_ARRAY_PATTERN_NON_EXHAUSTIVE) && element_list->children != zend_hash_num_elements(ht)) {
-		return false;
+		return PM_MISMATCH;
 	}
 
 	// FIXME: Deal with indexes properly
@@ -211,14 +214,14 @@ static bool match_array(zval *zv, zend_ast *pattern)
 			index++;
 		}
 		if (Z_TYPE_P(element_zv) == IS_UNDEF || !zend_pattern_match_ex(element_zv, pattern_ast)) {
-			return false;
+			return PM_MISMATCH;
 		}
 	}
 
-	return true;
+	return PM_MATCH;
 }
 
-bool zend_pattern_match_ex(zval *zv, zend_ast *pattern)
+pm_result zend_pattern_match_ex(zval *zv, zend_ast *pattern)
 {
 	ZVAL_DEREF(zv);
 	// FIXME: Do we need DEINDIRECT too?
@@ -231,10 +234,13 @@ bool zend_pattern_match_ex(zval *zv, zend_ast *pattern)
 		case ZEND_AST_OBJECT_PATTERN:
 			return match_object(zv, pattern);
 		case ZEND_AST_WILDCARD_PATTERN:
-			return true;
-		case ZEND_AST_OR_PATTERN:
-			return zend_pattern_match_ex(zv, pattern->child[0])
-				|| zend_pattern_match_ex(zv, pattern->child[1]);
+			return PM_MATCH;
+		case ZEND_AST_OR_PATTERN:;
+			pm_result lhs = zend_pattern_match_ex(zv, pattern->child[0]);
+			if (lhs != PM_MISMATCH) {
+				return lhs;
+			}
+			return zend_pattern_match_ex(zv, pattern->child[1]);
 		case ZEND_AST_RANGE_PATTERN:
 			return match_range(zv, pattern);
 		case ZEND_AST_BINDING_PATTERN:
@@ -247,18 +253,5 @@ bool zend_pattern_match_ex(zval *zv, zend_ast *pattern)
 
 bool zend_pattern_match(zval *zv, zend_ast *pattern)
 {
-	bool result;
-
-	zend_first_try {
-		result = zend_pattern_match_ex(zv, pattern);
-	} zend_catch {
-		if (!EG(pattern_matching_bailout)) {
-			zend_bailout();
-		}
-		ZEND_ASSERT(EG(exception));
-		EG(pattern_matching_bailout) = false;
-		return false;
-	} zend_end_try();
-
-	return result;
+	return zend_pattern_match_ex(zv, pattern) == PM_MATCH;
 }