Optimizer: Use return true / return false for functions returning bool

Changes done with Coccinelle:

    @r1@
    identifier fn;
    typedef bool;
    symbol false;
    symbol true;
    @@

    bool fn ( ... )
    {
    <...
    return
    (
    - 0
    + false
    |
    - 1
    + true
    )
    ;
    ...>
    }

Coccinelle patch sourced from
torvalds/linux@46b5c9b.

Author: TimWolla

Zend/Optimizer/block_pass.c

@@ -42,19 +42,19 @@ bool zend_optimizer_get_persistent_constant(zend_string *name, zval *result, int
 			if (copy) {
 				Z_TRY_ADDREF_P(result);
 			}
-			return 1;
+			return true;
 		} else {
-			return 0;
+			return false;
 		}
 	}
 
 	/* Special constants null/true/false can always be substituted. */
 	c = zend_get_special_const(ZSTR_VAL(name), ZSTR_LEN(name));
 	if (c) {
 		ZVAL_COPY_VALUE(result, &c->value);
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
 /* Data dependencies macros */

Zend/Optimizer/dce.c

@@ -62,13 +62,13 @@ typedef struct {
 static inline bool is_bad_mod(const zend_ssa *ssa, int use, int def) {
 	if (def < 0) {
 		/* This modification is not tracked by SSA, assume the worst */
-		return 1;
+		return true;
 	}
 	if (ssa->var_info[use].type & MAY_BE_REF) {
 		/* Modification of reference may have side-effect */
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
 static inline bool may_have_side_effects(
@@ -125,18 +125,18 @@ static inline bool may_have_side_effects(
 		case ZEND_FUNC_GET_ARGS:
 		case ZEND_ARRAY_KEY_EXISTS:
 			/* No side effects */
-			return 0;
+			return false;
 		case ZEND_FREE:
 			return opline->extended_value == ZEND_FREE_VOID_CAST;
 		case ZEND_ADD_ARRAY_ELEMENT:
 			/* TODO: We can't free two vars. Keep instruction alive. <?php [0, "$a" => "$b"]; */
 			if ((opline->op1_type & (IS_VAR|IS_TMP_VAR)) && (opline->op2_type & (IS_VAR|IS_TMP_VAR))) {
-				return 1;
+				return true;
 			}
-			return 0;
+			return false;
 		case ZEND_ROPE_END:
 			/* TODO: Rope dce optimization, see #76446 */
-			return 1;
+			return true;
 		case ZEND_JMP:
 		case ZEND_JMPZ:
 		case ZEND_JMPNZ:
@@ -149,7 +149,7 @@ static inline bool may_have_side_effects(
 		case ZEND_BIND_INIT_STATIC_OR_JMP:
 		case ZEND_JMP_FRAMELESS:
 			/* For our purposes a jumps and branches are side effects. */
-			return 1;
+			return true;
 		case ZEND_BEGIN_SILENCE:
 		case ZEND_END_SILENCE:
 		case ZEND_ECHO:
@@ -164,7 +164,7 @@ static inline bool may_have_side_effects(
 		case ZEND_YIELD_FROM:
 		case ZEND_VERIFY_NEVER_TYPE:
 			/* Intrinsic side effects */
-			return 1;
+			return true;
 		case ZEND_DO_FCALL:
 		case ZEND_DO_FCALL_BY_NAME:
 		case ZEND_DO_ICALL:
@@ -174,31 +174,31 @@ static inline bool may_have_side_effects(
 		case ZEND_FRAMELESS_ICALL_2:
 		case ZEND_FRAMELESS_ICALL_3:
 			/* For now assume all calls have side effects */
-			return 1;
+			return true;
 		case ZEND_RECV:
 		case ZEND_RECV_INIT:
 			/* Even though RECV_INIT can be side-effect free, these cannot be simply dropped
 			 * due to the prologue skipping code. */
-			return 1;
+			return true;
 		case ZEND_ASSIGN_REF:
-			return 1;
+			return true;
 		case ZEND_ASSIGN:
 		{
 			if (is_bad_mod(ssa, ssa_op->op1_use, ssa_op->op1_def)) {
-				return 1;
+				return true;
 			}
 			if (!reorder_dtor_effects) {
 				if (opline->op2_type != IS_CONST
 					&& (OP2_INFO() & MAY_HAVE_DTOR)
 					&& ssa->vars[ssa_op->op2_use].escape_state != ESCAPE_STATE_NO_ESCAPE) {
 					/* DCE might shorten lifetime */
-					return 1;
+					return true;
 				}
 			}
-			return 0;
+			return false;
 		}
 		case ZEND_UNSET_VAR:
-			return 1;
+			return true;
 		case ZEND_UNSET_CV:
 		{
 			uint32_t t1 = OP1_INFO();
@@ -207,9 +207,9 @@ static inline bool may_have_side_effects(
 				 * an unset may be considered dead even if there is a later assignment to the
 				 * variable. Removing the unset in this case would not be correct if the variable
 				 * is a reference, because unset breaks references. */
-				return 1;
+				return true;
 			}
-			return 0;
+			return false;
 		}
 		case ZEND_PRE_INC:
 		case ZEND_POST_INC:
@@ -223,41 +223,41 @@ static inline bool may_have_side_effects(
 		case ZEND_ASSIGN_OBJ:
 			if (is_bad_mod(ssa, ssa_op->op1_use, ssa_op->op1_def)
 				|| ssa->vars[ssa_op->op1_def].escape_state != ESCAPE_STATE_NO_ESCAPE) {
-				return 1;
+				return true;
 			}
 			if (!reorder_dtor_effects) {
 				opline++;
 				ssa_op++;
 				if (opline->op1_type != IS_CONST
 					&& (OP1_INFO() & MAY_HAVE_DTOR)) {
 					/* DCE might shorten lifetime */
-					return 1;
+					return true;
 				}
 			}
-			return 0;
+			return false;
 		case ZEND_PRE_INC_OBJ:
 		case ZEND_PRE_DEC_OBJ:
 		case ZEND_POST_INC_OBJ:
 		case ZEND_POST_DEC_OBJ:
 			if (is_bad_mod(ssa, ssa_op->op1_use, ssa_op->op1_def)
 				|| ssa->vars[ssa_op->op1_def].escape_state != ESCAPE_STATE_NO_ESCAPE) {
-				return 1;
+				return true;
 			}
-			return 0;
+			return false;
 		case ZEND_BIND_STATIC:
 			if (op_array->static_variables) {
 				/* Implicit and Explicit bind static is effectively prologue of closure so
 				   report it has side effects like RECV, RECV_INIT; This allows us to
 				   reflect on the closure and discover used variable at runtime */
 				if ((opline->extended_value & (ZEND_BIND_IMPLICIT|ZEND_BIND_EXPLICIT))) {
-					return 1;
+					return true;
 				}
 				/* Modifies static variables which are observable through reflection */
 				if ((opline->extended_value & ZEND_BIND_REF) && opline->op2_type != IS_UNUSED) {
-					return 1;
+					return true;
 				}
 			}
-			return 0;
+			return false;
 		case ZEND_CHECK_VAR:
 			return (OP1_INFO() & MAY_BE_UNDEF) != 0;
 		case ZEND_FE_RESET_R:
@@ -267,7 +267,7 @@ static inline bool may_have_side_effects(
 			return (OP1_INFO() & MAY_BE_ANY) != MAY_BE_ARRAY;
 		default:
 			/* For everything we didn't handle, assume a side-effect */
-			return 1;
+			return true;
 	}
 }
 
@@ -340,7 +340,7 @@ static inline bool is_var_dead(context *ctx, int var_num) {
 // Sometimes we can mark the var as EXT_UNUSED
 static bool try_remove_var_def(context *ctx, int free_var, int use_chain, zend_op *opline) {
 	if (use_chain >= 0) {
-		return 0;
+		return false;
 	}
 	zend_ssa_var *var = &ctx->ssa->vars[free_var];
 	int def = var->definition;
@@ -381,13 +381,13 @@ static bool try_remove_var_def(context *ctx, int free_var, int use_chain, zend_o
 					def_opline->result.var = 0;
 					def_op->result_def = -1;
 					var->definition = -1;
-					return 1;
+					return true;
 				default:
 					break;
 			}
 		}
 	}
-	return 0;
+	return false;
 }
 
 static zend_always_inline bool may_be_refcounted(uint32_t type) {
@@ -400,13 +400,13 @@ static inline bool is_free_of_live_var(context *ctx, zend_op *opline, zend_ssa_o
 			/* It is always safe to remove FREEs of non-refcounted values, even if they are live. */
 			if ((ctx->ssa->var_info[ssa_op->op1_use].type & (MAY_BE_REF|MAY_BE_ANY|MAY_BE_UNDEF)) != 0
 			 && !may_be_refcounted(ctx->ssa->var_info[ssa_op->op1_use].type)) {
-				return 0;
+				return false;
 			}
 			ZEND_FALLTHROUGH;
 		case ZEND_FE_FREE:
 			return !is_var_dead(ctx, ssa_op->op1_use);
 		default:
-			return 0;
+			return false;
 	}
 }
 
@@ -417,12 +417,12 @@ static bool dce_instr(context *ctx, zend_op *opline, zend_ssa_op *ssa_op) {
 	uint8_t free_var_type;
 
 	if (opline->opcode == ZEND_NOP) {
-		return 0;
+		return false;
 	}
 
 	/* We mark FREEs as dead, but they're only really dead if the destroyed var is dead */
 	if (is_free_of_live_var(ctx, opline, ssa_op)) {
-		return 0;
+		return false;
 	}
 
 	if ((opline->op1_type & (IS_VAR|IS_TMP_VAR))&& !is_var_dead(ctx, ssa_op->op1_use)) {
@@ -440,7 +440,7 @@ static bool dce_instr(context *ctx, zend_op *opline, zend_ssa_op *ssa_op) {
 				if (free_var >= 0) {
 					// TODO: We can't free two vars. Keep instruction alive.
 					zend_bitset_excl(ctx->instr_dead, opline - ctx->op_array->opcodes);
-					return 0;
+					return false;
 				}
 				free_var = ssa_op->op2_use;
 				free_var_type = opline->op2_type;
@@ -459,9 +459,9 @@ static bool dce_instr(context *ctx, zend_op *opline, zend_ssa_op *ssa_op) {
 		ssa_op->op1_use = free_var;
 		ssa_op->op1_use_chain = ssa->vars[free_var].use_chain;
 		ssa->vars[free_var].use_chain = ssa_op - ssa->ops;
-		return 0;
+		return false;
 	}
-	return 1;
+	return true;
 }
 
 static inline int get_common_phi_source(zend_ssa *ssa, zend_ssa_phi *phi) {
@@ -507,17 +507,17 @@ static void try_remove_trivial_phi(context *ctx, zend_ssa_phi *phi) {
 static inline bool may_break_varargs(const zend_op_array *op_array, const zend_ssa *ssa, const zend_ssa_op *ssa_op) {
 	if (ssa_op->op1_def >= 0
 			&& ssa->vars[ssa_op->op1_def].var < op_array->num_args) {
-		return 1;
+		return true;
 	}
 	if (ssa_op->op2_def >= 0
 			&& ssa->vars[ssa_op->op2_def].var < op_array->num_args) {
-		return 1;
+		return true;
 	}
 	if (ssa_op->result_def >= 0
 			&& ssa->vars[ssa_op->result_def].var < op_array->num_args) {
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
 static inline bool may_throw_dce_exception(const zend_op *opline) {

Zend/Optimizer/dfa_pass.c

@@ -256,11 +256,11 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 
 static bool safe_instanceof(const zend_class_entry *ce1, const zend_class_entry *ce2) {
 	if (ce1 == ce2) {
-		return 1;
+		return true;
 	}
 	if (!(ce1->ce_flags & ZEND_ACC_LINKED)) {
 		/* This case could be generalized, similarly to unlinked_instanceof */
-		return 0;
+		return false;
 	}
 	return instanceof_function(ce1, ce2);
 }
@@ -297,7 +297,7 @@ static inline bool can_elide_return_type_check(
 	zend_ssa_var_info *use_info = &ssa->var_info[ssa_op->op1_use];
 	uint32_t use_type = use_info->type & (MAY_BE_ANY|MAY_BE_UNDEF);
 	if (use_type & MAY_BE_REF) {
-		return 0;
+		return false;
 	}
 
 	if (use_type & MAY_BE_UNDEF) {
@@ -322,20 +322,20 @@ static bool opline_supports_assign_contraction(
 		zend_op_array *op_array, zend_ssa *ssa, zend_op *opline, int src_var, uint32_t cv_var) {
 	if (opline->opcode == ZEND_NEW) {
 		/* see Zend/tests/generators/aborted_yield_during_new.phpt */
-		return 0;
+		return false;
 	}
 
 	/* Frameless calls override the return value, but the return value may overlap with the arguments. */
 	switch (opline->opcode) {
 		case ZEND_FRAMELESS_ICALL_3:
-			if ((opline + 1)->op1_type == IS_CV && (opline + 1)->op1.var == cv_var) return 0;
+			if ((opline + 1)->op1_type == IS_CV && (opline + 1)->op1.var == cv_var) return false;
 			ZEND_FALLTHROUGH;
 		case ZEND_FRAMELESS_ICALL_2:
-			if (opline->op2_type == IS_CV && opline->op2.var == cv_var) return 0;
+			if (opline->op2_type == IS_CV && opline->op2.var == cv_var) return false;
 			ZEND_FALLTHROUGH;
 		case ZEND_FRAMELESS_ICALL_1:
-			if (opline->op1_type == IS_CV && opline->op1.var == cv_var) return 0;
-			return 1;
+			if (opline->op1_type == IS_CV && opline->op1.var == cv_var) return false;
+			return true;
 	}
 
 	if (opline->opcode == ZEND_DO_ICALL || opline->opcode == ZEND_DO_UCALL
@@ -374,10 +374,10 @@ static bool opline_supports_assign_contraction(
 	 && opline->op1_type == IS_CV
 	 && opline->op1.var == cv_var
 	 && zend_may_throw(opline, &ssa->ops[ssa->vars[src_var].definition], op_array, ssa)) {
-		return 0;
+		return false;
 	}
 
-	return 1;
+	return true;
 }
 
 static bool variable_defined_or_used_in_range(zend_ssa *ssa, int var, int start, int end)
@@ -391,11 +391,11 @@ static bool variable_defined_or_used_in_range(zend_ssa *ssa, int var, int start,
 			(ssa_op->op2_use >= 0 && ssa->vars[ssa_op->op2_use].var == var) ||
 			(ssa_op->result_use >= 0 && ssa->vars[ssa_op->result_use].var == var)
 		) {
-			return 1;
+			return true;
 		}
 		start++;
 	}
-	return 0;
+	return false;
 }
 
 int zend_dfa_optimize_calls(zend_op_array *op_array, zend_ssa *ssa)
@@ -989,7 +989,7 @@ static bool zend_dfa_try_to_replace_result(zend_op_array *op_array, zend_ssa *ss
 					if ((opline->op1_type == IS_CV && opline->op1.var == cv)
 					 || (opline->op2_type == IS_CV && opline->op2.var == cv)
 					 || (opline->result_type == IS_CV && opline->result.var == cv)) {
-						return 0;
+						return false;
 					}
 					opline--;
 					i--;
@@ -1026,12 +1026,12 @@ static bool zend_dfa_try_to_replace_result(zend_op_array *op_array, zend_ssa *ss
 					op_array->opcodes[use].result.var = cv;
 				}
 
-				return 1;
+				return true;
 			}
 		}
 	}
 
-	return 0;
+	return false;
 }
 
 void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa, zend_call_info **call_map)