FilesExpand file tree

 master

/

phpdbg_opcode.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

192 lines (170 loc) · 6.51 KB

 master

/

phpdbg_opcode.c

Copy path

Top

File metadata and controls

• Code
• Blame

192 lines (170 loc) · 6.51 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

/*

+----------------------------------------------------------------------+

| PHP Version 7 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2017 The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Authors: Felipe Pena <felipe@php.net> |

| Authors: Joe Watkins <joe.watkins@live.co.uk> |

| Authors: Bob Weinand <bwoebi@php.net> |

+----------------------------------------------------------------------+

*/

#include "phpdbg.h"

#include "zend_vm_opcodes.h"

#include "zend_compile.h"

#include "phpdbg_opcode.h"

#include "phpdbg_utils.h"

#include "ext/standard/php_string.h"

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_LIVE_RANGE == (flags & ZEND_VM_OP_MASK)) {

if (opline->extended_value & ZEND_FREE_ON_RETURN) {

spprintf(&result, 0, "live-range(%" 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:

spprintf(&decode[3], 0, "%" PRIu32, opline->result.num);

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, zend_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("opline", "line=\"%u\" opline=\"%p\" op=\"%s\" file=\"%s\"", "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_ex(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 (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;

cur->opcodes = op_array->opcodes;

cur->filename = op_array->filename;

cur->scope = op_array->scope;

cur->function_name = op_array->function_name;

cur->next = NULL;

PHPDBG_G(oplog_cur)->next = cur;

PHPDBG_G(oplog_cur) = cur;

}

} /* }}} */

void phpdbg_print_opline(zend_execute_data *execute_data, zend_bool ignore_flags) /* {{{ */

{

phpdbg_print_opline_ex(execute_data, ignore_flags);

} /* }}} */