php_gdb.py

"""GDB support for PHP types

This is auto-loaded by GDB if Python Auto-loading is enabled (the default), and
the PHP binary is in the auto load safe path:

 # ~/.config/gdb/gdbinit (not ~/.gdbinit)
 add-auto-load-safe-path /path/to/php-src

See https://sourceware.org/gdb/current/onlinedocs/gdb.html/Python-Auto_002dloading.html
See https://sourceware.org/gdb/current/onlinedocs/gdb.html/Auto_002dloading-safe-path.html#Auto_002dloading-safe-path

If needed, pretty printers can be by-passed by using the /r flag:
 (gdb) p /r any_variable

Use |set print pretty| to enable multi-line printing and indentation:
 (gdb) set print pretty on

Use |set print max-depth| to control the maximum print depth for nested
structures:
 (gdb) set print pretty on

To interactively type Python for development of the printers, use
 (gdb) python foo = gdb.parse_and_eval('bar')
to put the C value 'bar' in the current scope into a Python variable 'foo'.
Then you can interact with that variable:
 (gdb) python print foo['impl_']
"""

importgdb
importre

pp_set=gdb.printing.RegexpCollectionPrettyPrinter("php")

classZendStringPrettyPrinter(gdb.printing.PrettyPrinter):
"Print a zend_string"

def__init__(self, val):
self.val=val

defto_string(self):
returnself.format_string()

defchildren(self):
forfieldinself.val.type.fields():
iffield.name=='val':
yield ('val', self.format_string())
else:
yield (field.name, self.val[field.name])

defformat_string(self):
len=int(self.val['len'])
truncated=False
iflen>50:
len=50
truncated=True

ptr_type=gdb.lookup_type('char').pointer()
ary_type=gdb.lookup_type('char').array(len)
str=self.val['val'].cast(ptr_type).dereference().cast(ary_type)
str=str.format_string()
iftruncated:
str+=' (%d bytes total)'%int(self.val['len'])

returnstr


pp_set.add_printer('zend_string', '^_zend_string$', ZendStringPrettyPrinter)

classZendTypePrettyPrinter(gdb.printing.PrettyPrinter):
"Print a zend_type"

def__init__(self, val):
self.val=val
load_type_bits()

defto_string(self):
returnself.format_type(self.val)

defchildren(self):
forfieldinself.val.type.fields():
yield (field.name, self.val[field.name])

defformat_type(self, t):
type_mask=int(t['type_mask'])
type_mask_size=t['type_mask'].type.sizeof*8
separator='|'
parts= []
meta= []
forbitinrange(0, type_mask_size):
iftype_mask& (1<<bit):
type_name=type_bit_to_name.get(bit)
matchtype_name:
caseNone:
parts.append('(1<<%d)'%bit)
case'list':
list=t['ptr'].cast(gdb.lookup_type('zend_type_list').pointer())
num_types=int(list['num_types'])
types=list['types'].dereference().cast(gdb.lookup_type('zend_type').array(num_types))
foriinrange(0, num_types):
str=self.format_type(types[i])
ifany((cinset('|&()')) forcinstr):
str='(%s)'%str
parts.append(str)
case'union'|'arena':
meta.append(type_name)
case'intersection':
meta.append(type_name)
separator='&'
case'name':
str=t['ptr'].cast(gdb.lookup_type('zend_string').pointer())
parts.append(ZendStringPrettyPrinter(str).to_string())
case _:
parts.append(type_name)

str=separator.join(parts)

iflen(meta) >0:
str='[%s] %s'% (','.join(meta), str)

returnstr


pp_set.add_printer('zend_type', '^zend_type$', ZendTypePrettyPrinter)

classZendAstKindPrettyPrinter(gdb.printing.PrettyPrinter):
"Print a zend_ast_kind"

def__init__(self, val):
self.val=val

defto_string(self):
returnself.val.cast(gdb.lookup_type('enum _zend_ast_kind'))


pp_set.add_printer('zend_ast_kind', '^zend_ast_kind$', ZendAstKindPrettyPrinter)

classZendAstPrettyPrinter(gdb.printing.PrettyPrinter):
"Print a zend_ast"

def__init__(self, val):
self.val=val

defto_string(self):
return'((%s*)0x%x)'% (str(self.cast().type), self.val.address)

defchildren(self):
val=self.cast()
forfieldinval.type.fields():
iffield.name=='child':
children=val[field.name]
num_children=self.num_children()

ptr_type=gdb.lookup_type('zend_ast').pointer().pointer()
children=children.cast(ptr_type)

foriinrange(0, num_children):
c=children[i]
ifint(c) !=0:
c=c.dereference()
yield ('child[%d]'%i, c)
eliffield.name=='name':
yield (field.name, ZendStringPrettyPrinter(val[field.name].dereference()).to_string())
eliffield.name=='val':
yield (field.name, ZvalPrettyPrinter(val[field.name]).to_string())
else:
yield (field.name, val[field.name])

defis_special(self):
special_shift=6# ZEND_AST_SPECIAL_SHIFT
kind=self.val['kind']
return (kind>>special_shift) &1

defis_decl(self):
returnself.is_special() andint(self.val['kind']) >=enum_value('ZEND_AST_FUNC_DECL')

defis_list(self):
list_shift=7# ZEND_AST_IS_LIST_SHIFT
kind=self.val['kind']
return (kind>>list_shift) &1

defcast(self):
kind=int(self.val['kind'])

ifkind==enum_value('ZEND_AST_ZVAL') orkind==enum_value('ZEND_AST_CONSTANT'):
returnself.val.cast(gdb.lookup_type('zend_ast_zval'))
ifkind==enum_value('ZEND_AST_ZNODE'):
returnself.val.cast(gdb.lookup_type('zend_ast_znode'))
ifself.is_decl():
returnself.val.cast(gdb.lookup_type('zend_ast_decl'))
ifself.is_list():
returnself.val.cast(gdb.lookup_type('zend_ast_list'))

returnself.val

defnum_children(self):
ifself.is_decl():
decl_type=gdb.lookup_type('zend_ast_decl')
child_type=decl_type['child'].type
returnarray_size(child_type)
ifself.is_special():
return0
elifself.is_list():
returnint(self.cast()['children'])
else:
num_children_shift=8# ZEND_AST_NUM_CHILDREN_SHIFT
kind=self.val['kind']
returnkind>>num_children_shift


pp_set.add_printer('zend_ast', '^_zend_ast$', ZendAstPrettyPrinter)

classZvalPrettyPrinter(gdb.printing.PrettyPrinter):
"Print a zval"

def__init__(self, val):
self.val=val
load_type_bits()

defto_string(self):
returnself.value_to_string()

defvalue_to_string(self):
t=int(self.val['u1']['v']['type'])
ift==type_name_to_bit['undef']:
return'undef'
elift==type_name_to_bit['null']:
return'null'
elift==type_name_to_bit['false']:
return'false'
elift==type_name_to_bit['true']:
return'true'
elift==type_name_to_bit['long']:
returnstr(self.val['value']['lval'])
elift==type_name_to_bit['double']:
returnstr(self.val['value']['dval'])
elift==type_name_to_bit['string']:
returnZendStringPrettyPrinter(self.val['value']['str'].dereference()).to_string()
elift==type_name_to_bit['array']:
return'array'
elift==type_name_to_bit['object']:
return'object(%s)'%ZendStringPrettyPrinter(self.val['value']['obj']['ce']['name'].dereference()).to_string()
elift==type_name_to_bit['resource']:
return'resource'
elift==type_name_to_bit['reference']:
return'reference'
elift==type_name_to_bit['constant_ast']:
return'constant_ast'
else:
return'zval of type %d'%int(self.val['u1']['v']['type'])

defchildren(self):
forfieldinself.val.type.fields():
iffield.name=='value':
value=self.val['value']
t=int(self.val['u1']['v']['type'])
ift==type_name_to_bit['undef']:
value=value['lval']
elift==type_name_to_bit['null']:
value=value['lval']
elift==type_name_to_bit['false']:
value=value['lval']
elift==type_name_to_bit['true']:
value=value['lval']
elift==type_name_to_bit['long']:
value=value['lval']
elift==type_name_to_bit['double']:
value=value['dval']
elift==type_name_to_bit['string']:
value=value['str'].dereference()
elift==type_name_to_bit['array']:
value=value['ht'].dereference()
elift==type_name_to_bit['object']:
value=value['obj'].dereference()
elift==type_name_to_bit['resource']:
value=value['res'].dereference()
elift==type_name_to_bit['reference']:
value=value['ref'].dereference()
elift==type_name_to_bit['constant_ast']:
value=value['ast'].dereference()
else:
value=value['ptr']
yield (field.name, value)
eliffield.name=='u2':
yield ('u2', self.val[field.name]['extra'])
else:
yield (field.name, self.val[field.name])


pp_set.add_printer('zval', '^_zval_struct$', ZvalPrettyPrinter)

type_bit_to_name=None
type_name_to_bit=None

defload_type_bits():
globaltype_bit_to_name
globaltype_name_to_bit

iftype_bit_to_name!=None:
return

 (symbol,_) =gdb.lookup_symbol("zend_gc_refcount")
ifsymbol==None:
raiseException("Could not find zend_types.h: symbol zend_gc_refcount not found")
filename=symbol.symtab.fullname()

bits= {}

withopen(filename, 'r') asfile:
content=file.read()

pattern=re.compile(r'#define _ZEND_TYPE_([^\s]+)_BIT\s+\(1u << (\d+)\)')
matches=pattern.findall(content)
forname, bitinmatches:
bits[int(bit)] =name.lower()

pattern=re.compile(r'#define IS_([^\s]+)\s+(\d+)')
matches=pattern.findall(content)
forname, bitinmatches:
ifnotint(bit) inbits:
bits[int(bit)] =name.lower()

types= {}
forbitinbits:
types[bits[bit]] =bit

type_bit_to_name=bits
type_name_to_bit=types

deflookup_symbol(name):
 (symbol, _) =gdb.lookup_symbol(name)
ifsymbol==None:
raiseException("Could not lookup symbol %s"%name)
returnsymbol

defenum_value(name):
symbol=lookup_symbol(name)
returnint(symbol.value())

defarray_size(ary_type):
# array types have a single field whose type represents its range
returnary_type.fields()[0].type.range()[1]+1

gdb.printing.register_pretty_printer(gdb, pp_set, replace=True)