replace custom opcode dumper with O+ dump

Author: krakjoe

Zend/Optimizer/zend_dump.c

@@ -410,6 +410,10 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block
 	uint32_t flags = zend_get_opcode_flags(opline->opcode);
 	uint32_t n = 0;
 
+	if (dump_flags & ZEND_DUMP_LINE_NUMBERS) {
+		fprintf(stderr, "L%04u ", opline->lineno);
+	}
+
 	if (!ssa_op || ssa_op->result_use < 0) {
 		if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
 			if (ssa_op && ssa_op->result_def >= 0) {
@@ -721,6 +725,10 @@ static void zend_dump_op_line(const zend_op_array *op_array, const zend_basic_bl
 	int len = 0;
 	const zend_ssa *ssa = NULL;
 	zend_ssa_op *ssa_op = NULL;
+	
+	if (dump_flags & ZEND_DUMP_LINE_NUMBERS) {
+		fprintf(stderr, "L%04u ", opline->lineno);
+	}
 
 	len = fprintf(stderr, "%04u", (uint32_t)(opline - op_array->opcodes));
 	fprintf(stderr, "%*c", 5-len, ' ');
@@ -732,7 +740,7 @@ static void zend_dump_op_line(const zend_op_array *op_array, const zend_basic_bl
 		}
 	}
 
-	zend_dump_op(op_array, b, opline, dump_flags, ssa, ssa_op);
+	zend_dump_op(op_array, b, opline, dump_flags &~ ZEND_DUMP_LINE_NUMBERS, ssa, ssa_op);
 	fprintf(stderr, "\n");
 }
 

Zend/Optimizer/zend_dump.h

@@ -27,6 +27,7 @@
 #define ZEND_DUMP_CFG                  (1<<2)
 #define ZEND_DUMP_SSA                  (1<<3)
 #define ZEND_DUMP_LIVE_RANGES          (1<<4)
+#define ZEND_DUMP_LINE_NUMBERS         (1<<5)
 
 BEGIN_EXTERN_C()
 

sapi/phpdbg/phpdbg.1.in

@@ -49,10 +49,6 @@ Override .phpgdbinit location (implies -I)
 .B \-I
 Ignore .phpdbginit (default init file)
 .TP
-.B \-O \fIfile\fR
-Set oplog output to
-.IR file
-.TP
 .B \-r
 Jump straight to run
 .TP

sapi/phpdbg/phpdbg.c

@@ -122,7 +122,6 @@ static inline void php_phpdbg_globals_ctor(zend_phpdbg_globals *pg) /* {{{ */
 	pg->in_execution = 0;
 	pg->bp_count = 0;
 	pg->flags = PHPDBG_DEFAULT_FLAGS;
-	pg->oplog = NULL;
 	memset(pg->io, 0, sizeof(pg->io));
 	pg->frame.num = 0;
 	pg->sapi_name_ptr = NULL;
@@ -199,11 +198,6 @@ static PHP_MSHUTDOWN_FUNCTION(phpdbg) /* {{{ */
 		PHPDBG_G(exec) = NULL;
 	}
 
-	if (PHPDBG_G(oplog)) {
-		fclose(PHPDBG_G(oplog));
-		PHPDBG_G(oplog) = NULL;
-	}
-
 	if (PHPDBG_G(oplog_list)) {
 		phpdbg_oplog_list *cur = PHPDBG_G(oplog_list);
 		do {
@@ -1134,8 +1128,6 @@ int main(int argc, char **argv) /* {{{ */
 	char *init_file;
 	size_t init_file_len;
 	bool init_file_default;
-	char *oplog_file;
-	size_t oplog_file_len;
 	uint64_t flags;
 	char *php_optarg;
 	int php_optind, opt, show_banner = 1;
@@ -1186,8 +1178,6 @@ int main(int argc, char **argv) /* {{{ */
 	init_file = NULL;
 	init_file_len = 0;
 	init_file_default = 1;
-	oplog_file = NULL;
-	oplog_file_len = 0;
 	flags = PHPDBG_DEFAULT_FLAGS;
 	is_exit = 0;
 	php_optarg = NULL;
@@ -1281,13 +1271,6 @@ int main(int argc, char **argv) /* {{{ */
 				}
 			} break;
 
-			case 'O': { /* set oplog output */
-				oplog_file_len = strlen(php_optarg);
-				if (oplog_file_len) {
-					oplog_file = strdup(php_optarg);
-				}
-			} break;
-
 			case 'v': /* set quietness off */
 				flags &= ~PHPDBG_IS_QUIET;
 			break;
@@ -1442,9 +1425,6 @@ int main(int argc, char **argv) /* {{{ */
 			if (exec) {
 				free(exec);
 			}
-			if (oplog_file) {
-				free(oplog_file);
-			}
 			if (init_file) {
 				free(init_file);
 			}
@@ -1534,15 +1514,6 @@ int main(int argc, char **argv) /* {{{ */
 		php_stream_stdio_ops.write = phpdbg_stdiop_write;
 #endif
 
-		if (oplog_file) { /* open oplog */
-			PHPDBG_G(oplog) = fopen(oplog_file, "w+");
-			if (!PHPDBG_G(oplog)) {
-				phpdbg_error("Failed to open oplog %s", oplog_file);
-			}
-			free(oplog_file);
-			oplog_file = NULL;
-		}
-
 		{
 			zval *zv = zend_hash_str_find(php_stream_get_url_stream_wrappers_hash(), ZEND_STRL("php"));
 			php_stream_wrapper *tmp_wrapper = Z_PTR_P(zv);
@@ -1757,7 +1728,6 @@ int main(int argc, char **argv) /* {{{ */
 				settings->exec = zend_strndup(PHPDBG_G(exec), PHPDBG_G(exec_len));
 				settings->exec_len = PHPDBG_G(exec_len);
 			}
-			settings->oplog = PHPDBG_G(oplog);
 			settings->prompt[0] = PHPDBG_G(prompt)[0];
 			settings->prompt[1] = PHPDBG_G(prompt)[1];
 			memcpy(ZEND_VOIDP(settings->colors), PHPDBG_G(colors), sizeof(settings->colors));

sapi/phpdbg/phpdbg.h

@@ -44,6 +44,7 @@
 #include "zend_ini_scanner.h"
 #include "zend_stream.h"
 #include "zend_signal.h"
+#include "Optimizer/zend_dump.h"
 #if !defined(_WIN32) && !defined(ZEND_SIGNALS)
 #	include <signal.h>
 #elif defined(PHP_WIN32)
@@ -107,8 +108,6 @@
 #define memcpy(...) memcpy_tmp(__VA_ARGS__)
 #endif
 
-#if !defined(PHPDBG_WEBDATA_TRANSFER_H) && !defined(PHPDBG_WEBHELPER_H)
-
 #ifdef ZTS
 # define PHPDBG_G(v) ZEND_TSRMG(phpdbg_globals_id, zend_phpdbg_globals *, v)
 #else
@@ -266,7 +265,6 @@ ZEND_BEGIN_MODULE_GLOBALS(phpdbg)
 	zend_op_array *(*compile_string)(zend_string *source_string, const char *filename);
 	HashTable file_sources;
 
-	FILE *oplog;                                 /* opline log */
 	zend_arena *oplog_arena;                     /* arena for storing oplog */
 	phpdbg_oplog_list *oplog_list;               /* list of oplog starts */
 	phpdbg_oplog_entry *oplog_cur;               /* current oplog entry */
@@ -304,6 +302,4 @@ ZEND_BEGIN_MODULE_GLOBALS(phpdbg)
 	zend_ulong lines;                                  /* max number of lines to display */
 ZEND_END_MODULE_GLOBALS(phpdbg) /* }}} */
 
-#endif
-
 #endif /* PHPDBG_H */

sapi/phpdbg/phpdbg_help.c

@@ -391,7 +391,6 @@ phpdbg_help_text_t phpdbg_help_text[] = {
 "  **-b**                          Disable colour" CR
 "  **-i**      **-i**my.init           Set .phpdbginit file" CR
 "  **-I**                          Ignore default .phpdbginit" CR
-"  **-O**      **-O**my.oplog          Sets oplog output file" CR
 "  **-r**                          Run execution context" CR
 "  **-rr**                         Run execution context and quit after execution (not respecting breakpoints)" CR
 "  **-e**                          Generate extended information for debugger/profiler" CR
@@ -872,7 +871,6 @@ phpdbg_help_text_t phpdbg_help_text[] = {
 "   **prompt**     **p**     set the prompt" CR
 "   **color**      **c**     set color  <element> <color>" CR
 "   **colors**     **C**     set colors [<on|off>]" CR
-"   **oplog**      **O**     set oplog [output]" CR
 "   **break**      **b**     set break **id** <on|off>" CR
 "   **breaks**     **B**     set breaks [<on|off>]" CR
 "   **quiet**      **q**     set quiet [<on|off>]" CR

sapi/phpdbg/phpdbg_opcode.c

@@ -25,157 +25,18 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg)
 
-static inline const char *phpdbg_decode_opcode(zend_uchar opcode) /* {{{ */
-{
-	const char *ret = zend_get_opcode_name(opcode);
-	if (ret) {
-		return ret + 5; /* Skip ZEND_ prefix */
-	}
-	return "UNKNOWN";
-} /* }}} */
-
-static inline char *phpdbg_decode_op(
-		zend_op_array *ops, const zend_op *opline, const znode_op *op, uint32_t type) /* {{{ */
-{
-	char *decode = NULL;
-
-	switch (type) {
-		case IS_CV: {
-			zend_string *var = ops->vars[EX_VAR_TO_NUM(op->var)];
-			spprintf(&decode, 0, "$%.*s%c",
-				ZSTR_LEN(var) <= 19 ? (int) ZSTR_LEN(var) : 18,
-				ZSTR_VAL(var), ZSTR_LEN(var) <= 19 ? 0 : '+');
-		} break;
-
-		case IS_VAR:
-			spprintf(&decode, 0, "@%u", EX_VAR_TO_NUM(op->var) - ops->last_var);
-		break;
-		case IS_TMP_VAR:
-			spprintf(&decode, 0, "~%u", EX_VAR_TO_NUM(op->var) - ops->last_var);
-		break;
-		case IS_CONST: {
-			zval *literal = RT_CONSTANT(opline, *op);
-			decode = phpdbg_short_zval_print(literal, 20);
-		} break;
-	}
-	return decode;
-} /* }}} */
-
-char *phpdbg_decode_input_op(
-		zend_op_array *ops, const zend_op *opline, znode_op op, zend_uchar op_type,
-		uint32_t flags) {
-	char *result = NULL;
-	if (op_type != IS_UNUSED) {
-		result = phpdbg_decode_op(ops, opline, &op, op_type);
-	} else if (ZEND_VM_OP_JMP_ADDR == (flags & ZEND_VM_OP_MASK)) {
-		spprintf(&result, 0, "J%td", OP_JMP_ADDR(opline, op) - ops->opcodes);
-	} else if (ZEND_VM_OP_NUM == (flags & ZEND_VM_OP_MASK)) {
-		spprintf(&result, 0, "%" PRIu32, op.num);
-	} else if (ZEND_VM_OP_TRY_CATCH == (flags & ZEND_VM_OP_MASK)) {
-		if (op.num != (uint32_t)-1) {
-			spprintf(&result, 0, "try-catch(%" PRIu32 ")", op.num);
-		}
-	} else if (ZEND_VM_OP_THIS == (flags & ZEND_VM_OP_MASK)) {
-		result = estrdup("THIS");
-	} else if (ZEND_VM_OP_NEXT == (flags & ZEND_VM_OP_MASK)) {
-		result = estrdup("NEXT");
-	} else if (ZEND_VM_OP_CLASS_FETCH == (flags & ZEND_VM_OP_MASK)) {
-		//zend_dump_class_fetch_type(op.num);
-	} else if (ZEND_VM_OP_CONSTRUCTOR == (flags & ZEND_VM_OP_MASK)) {
-		result = estrdup("CONSTRUCTOR");
-	}
-	return result;
-}
-
-char *phpdbg_decode_opline(zend_op_array *ops, zend_op *opline) /*{{{ */
-{
-	const char *opcode_name = phpdbg_decode_opcode(opline->opcode);
-	uint32_t flags = zend_get_opcode_flags(opline->opcode);
-	char *result, *decode[4] = {NULL, NULL, NULL, NULL};
-
-	/* OpcodeName */
-	if (opline->extended_value) {
-		spprintf(&decode[0], 0, "%s<%" PRIi32 ">", opcode_name, opline->extended_value);
-	}
-
-	/* OP1 */
-	decode[1] = phpdbg_decode_input_op(
-		ops, opline, opline->op1, opline->op1_type, ZEND_VM_OP1_FLAGS(flags));
-
-	/* OP2 */
-	decode[2] = phpdbg_decode_input_op(
-		ops, opline, opline->op2, opline->op2_type, ZEND_VM_OP2_FLAGS(flags));
-
-	/* RESULT */
-	switch (opline->opcode) {
-	case ZEND_CATCH:
-		if (opline->extended_value & ZEND_LAST_CATCH) {
-			if (decode[2]) {
-				efree(decode[2]);
-				decode[2] = NULL;
-			}
-		}
-		decode[3] = phpdbg_decode_op(ops, opline, &opline->result, opline->result_type);
-		break;
-	default:
-		decode[3] = phpdbg_decode_op(ops, opline, &opline->result, opline->result_type);
-		break;
-	}
-
-	spprintf(&result, 0,
-		"%-23s %-20s %-20s %-20s",
-		decode[0] ? decode[0] : opcode_name,
-		decode[1] ? decode[1] : "",
-		decode[2] ? decode[2] : "",
-		decode[3] ? decode[3] : "");
-
-	if (decode[0])
-		efree(decode[0]);
-	if (decode[1])
-		efree(decode[1]);
-	if (decode[2])
-		efree(decode[2]);
-	if (decode[3])
-		efree(decode[3]);
-
-	return result;
-} /* }}} */
-
 void phpdbg_print_opline_ex(zend_execute_data *execute_data, bool ignore_flags) /* {{{ */
 {
-	/* force out a line while stepping so the user knows what is happening */
-	if (ignore_flags ||
-		(!(PHPDBG_G(flags) & PHPDBG_IS_QUIET) ||
-		(PHPDBG_G(flags) & PHPDBG_IS_STEPPING) ||
-		(PHPDBG_G(oplog)))) {
-
-		zend_op *opline = (zend_op *) execute_data->opline;
-		char *decode = phpdbg_decode_opline(&execute_data->func->op_array, opline);
-
-		if (ignore_flags || (!(PHPDBG_G(flags) & PHPDBG_IS_QUIET) || (PHPDBG_G(flags) & PHPDBG_IS_STEPPING))) {
-			/* output line info */
-			phpdbg_notice("L%-5u %16p %s %s",
-			   opline->lineno,
-			   opline,
-			   decode,
-			   execute_data->func->op_array.filename ? ZSTR_VAL(execute_data->func->op_array.filename) : "unknown");
-		}
-
-		if (!ignore_flags && PHPDBG_G(oplog)) {
-			phpdbg_log_internal(fileno(PHPDBG_G(oplog)), "L%-5u %16p %s %s\n",
-				opline->lineno,
-				opline,
-				decode,
-				execute_data->func->op_array.filename ? ZSTR_VAL(execute_data->func->op_array.filename) : "unknown");
-		}
-
-		efree(decode);
+	if (ignore_flags || (!(PHPDBG_G(flags) & PHPDBG_IS_QUIET) && (PHPDBG_G(flags) & PHPDBG_IS_STEPPING))) {
+		fprintf(stderr, "[");
+		zend_dump_op(&EX(func)->op_array, NULL, EX(opline), ZEND_DUMP_LINE_NUMBERS, NULL, NULL);
+		fprintf(stderr, "]\n");
 	}
 
 	if (PHPDBG_G(oplog_list)) {
 		phpdbg_oplog_entry *cur = zend_arena_alloc(&PHPDBG_G(oplog_arena), sizeof(phpdbg_oplog_entry));
-		zend_op_array *op_array = &execute_data->func->op_array;
-		cur->op = (zend_op *) execute_data->opline;
+		zend_op_array *op_array = &EX(func)->op_array;
+		cur->op = (zend_op *) EX(opline);
 		cur->opcodes = op_array->opcodes;
 		cur->filename = op_array->filename;
 		cur->scope = op_array->scope;

sapi/phpdbg/phpdbg_opcode.h

@@ -21,7 +21,6 @@
 
 #include "zend_types.h"
 
-char *phpdbg_decode_opline(zend_op_array *ops, zend_op *op);
 void phpdbg_print_opline(zend_execute_data *execute_data, bool ignore_flags);
 void phpdbg_print_opline_ex(zend_execute_data *execute_data, bool ignore_flags);