tree-wide: Clean up interaction with bool values

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 */
@@ -949,14 +949,14 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array
 					src = VAR_SOURCE(opline->op1);
 					if (src && src->opcode == ZEND_QM_ASSIGN) {
 						zend_op *op = src + 1;
-						bool optimize = 1;
+						bool optimize = true;
 
 						while (op < opline) {
 							if ((op->op1_type == opline->op1_type
 							  && op->op1.var == opline->op1.var)
 							 || (op->op2_type == opline->op1_type
 							  && op->op2.var == opline->op1.var)) {
-								optimize = 0;
+								optimize = false;
 								break;
 							}
 							op++;
@@ -1566,14 +1566,14 @@ static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset use
 	}
 
 	if (ctx->debug_level & ZEND_DUMP_BLOCK_PASS_VARS) {
-		bool printed = 0;
+		bool printed = false;
 		uint32_t i;
 
 		for (i = op_array->last_var; i< op_array->T; i++) {
 			if (zend_bitset_in(used_ext, i)) {
 				if (!printed) {
 					fprintf(stderr, "NON-LOCAL-VARS: %d", i);
-					printed = 1;
+					printed = true;
 				} else {
 					fprintf(stderr, ", %d", i);
 				}

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) {