227 lines
6.9 KiB
Python
227 lines
6.9 KiB
Python
# Copyright 2014-2022 Free Software Foundation, Inc.
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
# This file is part of the GDB testsuite. It test the xmethods support
|
|
# in the Python extension language.
|
|
|
|
import gdb
|
|
import re
|
|
|
|
from gdb.xmethod import XMethod
|
|
from gdb.xmethod import XMethodMatcher, XMethodWorker
|
|
from gdb.xmethod import SimpleXMethodMatcher
|
|
|
|
|
|
def A_plus_A(obj, opr):
|
|
print("From Python <A_plus_A>:")
|
|
return obj["a"] + opr["a"]
|
|
|
|
|
|
def plus_plus_A(obj):
|
|
print("From Python <plus_plus_A>:")
|
|
return obj["a"] + 1
|
|
|
|
|
|
def A_geta(obj):
|
|
print("From Python <A_geta>:")
|
|
return obj["a"]
|
|
|
|
|
|
def A_getarrayind(obj, index):
|
|
print("From Python <A_getarrayind>:")
|
|
return obj["array"][index]
|
|
|
|
|
|
def A_indexoper(obj, index):
|
|
return obj["array"][index].reference_value()
|
|
|
|
|
|
def B_indexoper(obj, index):
|
|
return obj["array"][index].const_value().reference_value()
|
|
|
|
|
|
type_A = gdb.parse_and_eval("(dop::A *) 0").type.target()
|
|
type_B = gdb.parse_and_eval("(dop::B *) 0").type.target()
|
|
type_int = gdb.parse_and_eval("(int *) 0").type.target()
|
|
|
|
|
|
# The E class matcher and worker test two things:
|
|
# 1. xmethod returning None.
|
|
# 2. Matcher returning a list of workers.
|
|
|
|
|
|
class E_method_char_worker(XMethodWorker):
|
|
def __init__(self):
|
|
pass
|
|
|
|
def get_arg_types(self):
|
|
return gdb.lookup_type("char")
|
|
|
|
def get_result_type(self, obj, arg):
|
|
return gdb.lookup_type("void")
|
|
|
|
def __call__(self, obj, arg):
|
|
print("From Python <E_method_char>")
|
|
return None
|
|
|
|
|
|
class E_method_int_worker(XMethodWorker):
|
|
def __init__(self):
|
|
pass
|
|
|
|
def get_arg_types(self):
|
|
return gdb.lookup_type("int")
|
|
|
|
# Note: get_result_type method elided on purpose
|
|
|
|
def __call__(self, obj, arg):
|
|
print("From Python <E_method_int>")
|
|
return None
|
|
|
|
|
|
class E_method_matcher(XMethodMatcher):
|
|
def __init__(self):
|
|
XMethodMatcher.__init__(self, "E_methods")
|
|
self.methods = [XMethod("method_int"), XMethod("method_char")]
|
|
|
|
def match(self, class_type, method_name):
|
|
class_tag = class_type.unqualified().tag
|
|
if not re.match("^dop::E$", class_tag):
|
|
return None
|
|
if not re.match("^method$", method_name):
|
|
return None
|
|
workers = []
|
|
if self.methods[0].enabled:
|
|
workers.append(E_method_int_worker())
|
|
if self.methods[1].enabled:
|
|
workers.append(E_method_char_worker())
|
|
return workers
|
|
|
|
|
|
# The G class method matcher and worker illustrate how to write
|
|
# xmethod matchers and workers for template classes and template
|
|
# methods.
|
|
|
|
|
|
class G_size_diff_worker(XMethodWorker):
|
|
def __init__(self, class_template_type, method_template_type):
|
|
self._class_template_type = class_template_type
|
|
self._method_template_type = method_template_type
|
|
|
|
def get_arg_types(self):
|
|
pass
|
|
|
|
def __call__(self, obj):
|
|
print("From Python G<>::size_diff()")
|
|
return self._method_template_type.sizeof - self._class_template_type.sizeof
|
|
|
|
|
|
class G_size_mul_worker(XMethodWorker):
|
|
def __init__(self, class_template_type, method_template_val):
|
|
self._class_template_type = class_template_type
|
|
self._method_template_val = method_template_val
|
|
|
|
def get_arg_types(self):
|
|
pass
|
|
|
|
def __call__(self, obj):
|
|
print("From Python G<>::size_mul()")
|
|
return self._class_template_type.sizeof * self._method_template_val
|
|
|
|
|
|
class G_mul_worker(XMethodWorker):
|
|
def __init__(self, class_template_type, method_template_type):
|
|
self._class_template_type = class_template_type
|
|
self._method_template_type = method_template_type
|
|
|
|
def get_arg_types(self):
|
|
return self._method_template_type
|
|
|
|
def __call__(self, obj, arg):
|
|
print("From Python G<>::mul()")
|
|
return obj["t"] * arg
|
|
|
|
|
|
class G_methods_matcher(XMethodMatcher):
|
|
def __init__(self):
|
|
XMethodMatcher.__init__(self, "G_methods")
|
|
self.methods = [XMethod("size_diff"), XMethod("size_mul"), XMethod("mul")]
|
|
|
|
def _is_enabled(self, name):
|
|
for method in self.methods:
|
|
if method.name == name and method.enabled:
|
|
return True
|
|
|
|
def match(self, class_type, method_name):
|
|
class_tag = class_type.unqualified().tag
|
|
if not re.match("^dop::G<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$", class_tag):
|
|
return None
|
|
t_name = class_tag[7:-1]
|
|
try:
|
|
t_type = gdb.lookup_type(t_name)
|
|
except gdb.error:
|
|
return None
|
|
if re.match("^size_diff<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$", method_name):
|
|
if not self._is_enabled("size_diff"):
|
|
return None
|
|
t1_name = method_name[10:-1]
|
|
try:
|
|
t1_type = gdb.lookup_type(t1_name)
|
|
return G_size_diff_worker(t_type, t1_type)
|
|
except gdb.error:
|
|
return None
|
|
if re.match("^size_mul<[ ]*[0-9]+[ ]*>$", method_name):
|
|
if not self._is_enabled("size_mul"):
|
|
return None
|
|
m_val = int(method_name[9:-1])
|
|
return G_size_mul_worker(t_type, m_val)
|
|
if re.match("^mul<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$", method_name):
|
|
if not self._is_enabled("mul"):
|
|
return None
|
|
t1_name = method_name[4:-1]
|
|
try:
|
|
t1_type = gdb.lookup_type(t1_name)
|
|
return G_mul_worker(t_type, t1_type)
|
|
except gdb.error:
|
|
return None
|
|
|
|
|
|
global_dm_list = [
|
|
SimpleXMethodMatcher(
|
|
r"A_plus_A",
|
|
r"^dop::A$",
|
|
r"operator\+",
|
|
A_plus_A,
|
|
# This is a replacement, hence match the arg type
|
|
# exactly!
|
|
type_A.const().reference(),
|
|
),
|
|
SimpleXMethodMatcher(r"plus_plus_A", r"^dop::A$", r"operator\+\+", plus_plus_A),
|
|
SimpleXMethodMatcher(r"A_geta", r"^dop::A$", r"^geta$", A_geta),
|
|
SimpleXMethodMatcher(
|
|
r"A_getarrayind", r"^dop::A$", r"^getarrayind$", A_getarrayind, type_int
|
|
),
|
|
SimpleXMethodMatcher(
|
|
r"A_indexoper", r"^dop::A$", r"operator\[\]", A_indexoper, type_int
|
|
),
|
|
SimpleXMethodMatcher(
|
|
r"B_indexoper", r"^dop::B$", r"operator\[\]", B_indexoper, type_int
|
|
),
|
|
]
|
|
|
|
for matcher in global_dm_list:
|
|
gdb.xmethod.register_xmethod_matcher(gdb, matcher)
|
|
gdb.xmethod.register_xmethod_matcher(gdb.current_progspace(), G_methods_matcher())
|
|
gdb.xmethod.register_xmethod_matcher(gdb.current_progspace(), E_method_matcher())
|