xref: /PHP-8.1/sapi/phpdbg/phpdbg_print.c (revision 60fbd6df)
1 /*
2    +----------------------------------------------------------------------+
3    | Copyright (c) The PHP Group                                          |
4    +----------------------------------------------------------------------+
5    | This source file is subject to version 3.01 of the PHP license,      |
6    | that is bundled with this package in the file LICENSE, and is        |
7    | available through the world-wide-web at the following url:           |
8    | https://www.php.net/license/3_01.txt                                 |
9    | If you did not receive a copy of the PHP license and are unable to   |
10    | obtain it through the world-wide-web, please send a note to          |
11    | license@php.net so we can mail you a copy immediately.               |
12    +----------------------------------------------------------------------+
13    | Authors: Felipe Pena <felipe@php.net>                                |
14    | Authors: Joe Watkins <joe.watkins@live.co.uk>                        |
15    | Authors: Bob Weinand <bwoebi@php.net>                                |
16    +----------------------------------------------------------------------+
17 */
18 
19 #include "phpdbg.h"
20 #include "phpdbg_print.h"
21 #include "phpdbg_utils.h"
22 #include "phpdbg_prompt.h"
23 
24 #include "Optimizer/zend_dump.h"
25 
26 ZEND_EXTERN_MODULE_GLOBALS(phpdbg)
27 
28 #define PHPDBG_PRINT_COMMAND_D(f, h, a, m, l, s, flags) \
29 	PHPDBG_COMMAND_D_EXP(f, h, a, m, l, s, &phpdbg_prompt_commands[8], flags)
30 
31 const phpdbg_command_t phpdbg_print_commands[] = {
32 	PHPDBG_PRINT_COMMAND_D(exec,       "print out the instructions in the main execution context", 'e', print_exec,   NULL, 0, PHPDBG_ASYNC_SAFE),
33 	PHPDBG_PRINT_COMMAND_D(opline,     "print out the instruction in the current opline",          'o', print_opline, NULL, 0, PHPDBG_ASYNC_SAFE),
34 	PHPDBG_PRINT_COMMAND_D(class,      "print out the instructions in the specified class",        'c', print_class,  NULL, "s", PHPDBG_ASYNC_SAFE),
35 	PHPDBG_PRINT_COMMAND_D(method,     "print out the instructions in the specified method",       'm', print_method, NULL, "m", PHPDBG_ASYNC_SAFE),
36 	PHPDBG_PRINT_COMMAND_D(func,       "print out the instructions in the specified function",     'f', print_func,   NULL, "s", PHPDBG_ASYNC_SAFE),
37 	PHPDBG_PRINT_COMMAND_D(stack,      "print out the instructions in the current stack",          's', print_stack,  NULL, 0, PHPDBG_ASYNC_SAFE),
38 	PHPDBG_END_COMMAND
39 };
40 
PHPDBG_PRINT(opline)41 PHPDBG_PRINT(opline) /* {{{ */
42 {
43 	if (PHPDBG_G(in_execution) && EG(current_execute_data)) {
44 		phpdbg_print_opline(phpdbg_user_execute_data(EG(current_execute_data)), 1);
45 	} else {
46 		phpdbg_error("Not Executing!");
47 	}
48 
49 	return SUCCESS;
50 } /* }}} */
51 
phpdbg_print_function_helper(zend_function * method)52 static inline void phpdbg_print_function_helper(zend_function *method) /* {{{ */
53 {
54 	switch (method->type) {
55 		case ZEND_USER_FUNCTION: {
56 			zend_op_array* op_array = &(method->op_array);
57 
58 			if (op_array) {
59 				zend_dump_op_array(op_array, ZEND_DUMP_LINE_NUMBERS, NULL, NULL);
60 
61 				for (uint32_t i = 0; i < op_array->num_dynamic_func_defs; i++) {
62 					zend_op_array *def = op_array->dynamic_func_defs[i];
63 					phpdbg_out("\ndynamic def: %i, function name: %.*s\n",
64 						i, (int) ZSTR_LEN(def->function_name), ZSTR_VAL(def->function_name));
65 					zend_dump_op_array(def, ZEND_DUMP_LINE_NUMBERS, NULL, NULL);
66 				}
67 			}
68 		} break;
69 
70 		default: {
71 			if (method->common.scope) {
72 				phpdbg_writeln("\tInternal %s::%s()", ZSTR_VAL(method->common.scope->name), ZSTR_VAL(method->common.function_name));
73 			} else {
74 				phpdbg_writeln("\tInternal %s()", ZSTR_VAL(method->common.function_name));
75 			}
76 		}
77 	}
78 } /* }}} */
79 
PHPDBG_PRINT(exec)80 PHPDBG_PRINT(exec) /* {{{ */
81 {
82 	if (PHPDBG_G(exec)) {
83 		if (!PHPDBG_G(ops) && !(PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER)) {
84 			phpdbg_compile();
85 		}
86 
87 		if (PHPDBG_G(ops)) {
88 			phpdbg_notice("Context %s (%d ops)", PHPDBG_G(exec), PHPDBG_G(ops)->last);
89 
90 			phpdbg_print_function_helper((zend_function*) PHPDBG_G(ops));
91 		}
92 	} else {
93 		phpdbg_error("No execution context set");
94 	}
95 
96 	return SUCCESS;
97 } /* }}} */
98 
PHPDBG_PRINT(stack)99 PHPDBG_PRINT(stack) /* {{{ */
100 {
101 	if (PHPDBG_G(in_execution) && EG(current_execute_data)) {
102 		zend_op_array *ops = &phpdbg_user_execute_data(EG(current_execute_data))->func->op_array;
103 		if (ops->function_name) {
104 			if (ops->scope) {
105 				phpdbg_notice("Stack in %s::%s() (%d ops)", ZSTR_VAL(ops->scope->name), ZSTR_VAL(ops->function_name), ops->last);
106 			} else {
107 				phpdbg_notice("Stack in %s() (%d ops)", ZSTR_VAL(ops->function_name), ops->last);
108 			}
109 		} else {
110 			if (ops->filename) {
111 				phpdbg_notice("Stack in %s (%d ops)", ZSTR_VAL(ops->filename), ops->last);
112 			} else {
113 				phpdbg_notice("Stack @ %p (%d ops)", ops, ops->last);
114 			}
115 		}
116 		phpdbg_print_function_helper((zend_function*) ops);
117 	} else {
118 		phpdbg_error("Not Executing!");
119 	}
120 
121 	return SUCCESS;
122 } /* }}} */
123 
PHPDBG_PRINT(class)124 PHPDBG_PRINT(class) /* {{{ */
125 {
126 	zend_class_entry *ce;
127 
128 	if (phpdbg_safe_class_lookup(param->str, param->len, &ce) == SUCCESS) {
129 		phpdbg_notice("%s %s: %s (%d methods)",
130 			(ce->type == ZEND_USER_CLASS) ?
131 				"User" : "Internal",
132 			(ce->ce_flags & ZEND_ACC_INTERFACE) ?
133 				"Interface" :
134 				(ce->ce_flags & ZEND_ACC_ABSTRACT) ?
135 					"Abstract Class" :
136 					"Class",
137 			ZSTR_VAL(ce->name),
138 			zend_hash_num_elements(&ce->function_table));
139 
140 		if (zend_hash_num_elements(&ce->function_table)) {
141 			zend_function *method;
142 
143 			ZEND_HASH_FOREACH_PTR(&ce->function_table, method) {
144 				phpdbg_print_function_helper(method);
145 			} ZEND_HASH_FOREACH_END();
146 		}
147 	} else {
148 		phpdbg_error("The class %s could not be found", param->str);
149 	}
150 
151 	return SUCCESS;
152 } /* }}} */
153 
PHPDBG_PRINT(method)154 PHPDBG_PRINT(method) /* {{{ */
155 {
156 	zend_class_entry *ce;
157 
158 	if (phpdbg_safe_class_lookup(param->method.class, strlen(param->method.class), &ce) == SUCCESS) {
159 		zend_function *fbc;
160 		zend_string *lcname = zend_string_alloc(strlen(param->method.name), 0);
161 		zend_str_tolower_copy(ZSTR_VAL(lcname), param->method.name, ZSTR_LEN(lcname));
162 
163 		if ((fbc = zend_hash_find_ptr(&ce->function_table, lcname))) {
164 			phpdbg_notice("%s Method %s (%d ops)",
165 				(fbc->type == ZEND_USER_FUNCTION) ? "User" : "Internal",
166 				ZSTR_VAL(fbc->common.function_name),
167 				(fbc->type == ZEND_USER_FUNCTION) ? fbc->op_array.last : 0);
168 
169 			phpdbg_print_function_helper(fbc);
170 		} else {
171 			phpdbg_error("The method %s::%s could not be found", param->method.class, param->method.name);
172 		}
173 
174 		zend_string_release(lcname);
175 	} else {
176 		phpdbg_error("The class %s could not be found", param->method.class);
177 	}
178 
179 	return SUCCESS;
180 } /* }}} */
181 
PHPDBG_PRINT(func)182 PHPDBG_PRINT(func) /* {{{ */
183 {
184 	HashTable *func_table = EG(function_table);
185 	zend_function* fbc;
186 	const char *func_name = param->str;
187 	size_t func_name_len = param->len;
188 	zend_string *lcname;
189 	/* search active scope if begins with period */
190 	if (func_name[0] == '.') {
191 		zend_class_entry *scope = zend_get_executed_scope();
192 
193 		if (scope) {
194 			func_name++;
195 			func_name_len--;
196 
197 			func_table = &scope->function_table;
198 		} else {
199 			phpdbg_error("No active class");
200 			return SUCCESS;
201 		}
202 	} else if (!EG(function_table)) {
203 		phpdbg_error("No function table loaded");
204 		return SUCCESS;
205 	} else {
206 		func_table = EG(function_table);
207 	}
208 
209 	lcname = zend_string_alloc(func_name_len, 0);
210 	zend_str_tolower_copy(ZSTR_VAL(lcname), func_name, ZSTR_LEN(lcname));
211 
212 	phpdbg_try_access {
213 		if ((fbc = zend_hash_find_ptr(func_table, lcname))) {
214 			phpdbg_notice("%s %s %s (%d ops)",
215 				(fbc->type == ZEND_USER_FUNCTION) ? "User" : "Internal",
216 				(fbc->common.scope) ? "Method" : "Function",
217 				ZSTR_VAL(fbc->common.function_name),
218 				(fbc->type == ZEND_USER_FUNCTION) ? fbc->op_array.last : 0);
219 
220 			phpdbg_print_function_helper(fbc);
221 		} else {
222 			phpdbg_error("The function %s could not be found", func_name);
223 		}
224 	} phpdbg_catch_access {
225 		phpdbg_error("Couldn't fetch function %.*s, invalid data source", (int) func_name_len, func_name);
226 	} phpdbg_end_try_access();
227 
228 	efree(lcname);
229 
230 	return SUCCESS;
231 } /* }}} */
232 
phpdbg_print_opcodes_main(void)233 void phpdbg_print_opcodes_main(void) {
234 	phpdbg_print_function_helper((zend_function *) PHPDBG_G(ops));
235 }
236 
phpdbg_print_opcodes_function(const char * function,size_t len)237 void phpdbg_print_opcodes_function(const char *function, size_t len) {
238 	zend_function *func = zend_hash_str_find_ptr(EG(function_table), function, len);
239 
240 	if (!func) {
241 		phpdbg_error("The function %s could not be found", function);
242 		return;
243 	}
244 
245 	phpdbg_print_function_helper(func);
246 }
247 
phpdbg_print_opcodes_method_ce(zend_class_entry * ce,const char * function)248 static void phpdbg_print_opcodes_method_ce(zend_class_entry *ce, const char *function) {
249 	zend_function *func;
250 
251 	if (ce->type != ZEND_USER_CLASS) {
252 		phpdbg_out("function name: %s::%s (internal)\n", ce->name->val, function);
253 		return;
254 	}
255 
256 	if (!(func = zend_hash_str_find_ptr(&ce->function_table, function, strlen(function)))) {
257 		phpdbg_error("The method %s::%s could not be found", ZSTR_VAL(ce->name), function);
258 		return;
259 	}
260 
261 	phpdbg_print_function_helper(func);
262 }
263 
phpdbg_print_opcodes_method(const char * class,const char * function)264 void phpdbg_print_opcodes_method(const char *class, const char *function) {
265 	zend_class_entry *ce;
266 
267 	if (phpdbg_safe_class_lookup(class, strlen(class), &ce) != SUCCESS) {
268 		phpdbg_error("The class %s could not be found", class);
269 		return;
270 	}
271 
272 	phpdbg_print_opcodes_method_ce(ce, function);
273 }
274 
phpdbg_print_opcodes_ce(zend_class_entry * ce)275 static void phpdbg_print_opcodes_ce(zend_class_entry *ce) {
276 	zend_function *method;
277 	bool first = 1;
278 
279 	phpdbg_out("%s %s: %s\n",
280 		(ce->type == ZEND_USER_CLASS) ?
281 			"user" : "internal",
282 		(ce->ce_flags & ZEND_ACC_INTERFACE) ?
283 			"interface" :
284 			(ce->ce_flags & ZEND_ACC_ABSTRACT) ?
285 				"abstract Class" :
286 				"class",
287 		ZSTR_VAL(ce->name));
288 
289 	if (ce->type != ZEND_USER_CLASS) {
290 		return;
291 	}
292 
293 	phpdbg_out("%d methods: ", zend_hash_num_elements(&ce->function_table));
294 	ZEND_HASH_FOREACH_PTR(&ce->function_table, method) {
295 		if (first) {
296 			first = 0;
297 		} else {
298 			phpdbg_out(", ");
299 		}
300 		phpdbg_out("%s", ZSTR_VAL(method->common.function_name));
301 	} ZEND_HASH_FOREACH_END();
302 	if (first) {
303 		phpdbg_out("-");
304 	}
305 	phpdbg_out("\n");
306 
307 	ZEND_HASH_FOREACH_PTR(&ce->function_table, method) {
308 		phpdbg_print_function_helper(method);
309 	} ZEND_HASH_FOREACH_END();
310 }
311 
phpdbg_print_opcodes_class(const char * class)312 void phpdbg_print_opcodes_class(const char *class) {
313 	zend_class_entry *ce;
314 
315 	if (phpdbg_safe_class_lookup(class, strlen(class), &ce) != SUCCESS) {
316 		phpdbg_error("The class %s could not be found", class);
317 		return;
318 	}
319 
320 	phpdbg_print_opcodes_ce(ce);
321 }
322 
phpdbg_print_opcodes(const char * function)323 void phpdbg_print_opcodes(const char *function)
324 {
325 	if (function == NULL) {
326 		phpdbg_print_opcodes_main();
327 	} else if (function[0] == '*' && function[1] == 0) {
328 		/* all */
329 		zend_string *name;
330 		zend_function *func;
331 		zend_class_entry *ce;
332 
333 		phpdbg_print_opcodes_main();
334 
335 		ZEND_HASH_FOREACH_STR_KEY_PTR(EG(function_table), name, func) {
336 			if (func->type == ZEND_USER_FUNCTION) {
337 				phpdbg_print_opcodes_function(ZSTR_VAL(name), ZSTR_LEN(name));
338 			}
339 		} ZEND_HASH_FOREACH_END();
340 
341 		ZEND_HASH_FOREACH_PTR(EG(class_table), ce) {
342 			if (ce->type == ZEND_USER_CLASS) {
343 				phpdbg_out("\n");
344 				phpdbg_print_opcodes_ce(ce);
345 			}
346 		} ZEND_HASH_FOREACH_END();
347 	} else {
348 		char *function_lowercase = zend_str_tolower_dup(function, strlen(function));
349 
350 		if (strstr(function_lowercase, "::") == NULL) {
351 			phpdbg_print_opcodes_function(function_lowercase, strlen(function_lowercase));
352 		} else {
353 			char *method_name, *class_name = strtok(function_lowercase, "::");
354 			if ((method_name = strtok(NULL, "::")) == NULL) {
355 				phpdbg_print_opcodes_class(class_name);
356 			} else {
357 				phpdbg_print_opcodes_method(class_name, method_name);
358 			}
359 		}
360 
361 		efree(function_lowercase);
362 	}
363 }
364 
phpdbg_print_opline(zend_execute_data * execute_data,bool ignore_flags)365 void phpdbg_print_opline(zend_execute_data *execute_data, bool ignore_flags) /* {{{ */
366 {
367 	if (ignore_flags || (!(PHPDBG_G(flags) & PHPDBG_IS_QUIET) && (PHPDBG_G(flags) & PHPDBG_IS_STEPPING))) {
368 		zend_dump_op_line(&EX(func)->op_array, NULL, EX(opline), ZEND_DUMP_LINE_NUMBERS, NULL);
369 	}
370 
371 	if (PHPDBG_G(oplog_list)) {
372 		phpdbg_oplog_entry *cur = zend_arena_alloc(&PHPDBG_G(oplog_arena), sizeof(phpdbg_oplog_entry));
373 		zend_op_array *op_array = &EX(func)->op_array;
374 		cur->op = (zend_op *) EX(opline);
375 		cur->opcodes = op_array->opcodes;
376 		cur->filename = op_array->filename;
377 		cur->scope = op_array->scope;
378 		cur->function_name = op_array->function_name;
379 		cur->next = NULL;
380 		PHPDBG_G(oplog_cur)->next = cur;
381 		PHPDBG_G(oplog_cur) = cur;
382 	}
383 } /* }}} */
384