From patchwork Thu Nov 21 12:47:09 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jan Vrany X-Patchwork-Id: 101655 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 944F23857713 for ; Thu, 21 Nov 2024 12:52:24 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 944F23857713 X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from us-smtp-delivery-114.mimecast.com (us-smtp-delivery-114.mimecast.com [170.10.133.114]) by sourceware.org (Postfix) with ESMTP id CB4083857810 for ; Thu, 21 Nov 2024 12:48:32 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org CB4083857810 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=labware.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=labware.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org CB4083857810 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.114 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1732193312; cv=none; b=QBchQq3+xNoDSOimSLpgfd4iygHjfAvjKoyOZSJPXLFXmI3QYCtNyEA4e0ZTlGEr6YOuwUVyn84kkJBhLqcP7ikHrgBdMzl6scfiG24jfxJvBNTQhmItfT1l6eOMtHU2xRqHdaKu1TSdYc2AsoKA98pU3ldfTXCcXQyMuVaXom0= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1732193312; c=relaxed/simple; bh=UKGI8NcChdnXI3PH3zcpbwcBXN4qRT6doAat53f4R3E=; h=From:To:Subject:Date:Message-ID:MIME-Version; b=m3xMBaBeF4I3xLBWaOXyp+NLFgeBU67pZgnl42CU+F+57cns4Qi7LJB3RYEliQh0SZsVxGLyX5F265Dmc/5u0olInISCaAsjEYntCZWCc0wiIF/IJM2idB8EoWyt0QSljL6fDCKYwmFgpuAS4+4Dn71OJClB0MIHQfcYmgA3RCA= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org CB4083857810 Received: from NAM10-BN7-obe.outbound.protection.outlook.com (mail-bn7nam10lp2049.outbound.protection.outlook.com [104.47.70.49]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-286-bNHJrVszNza4t59YaqBgkQ-1; Thu, 21 Nov 2024 07:48:31 -0500 X-MC-Unique: bNHJrVszNza4t59YaqBgkQ-1 X-Mimecast-MFC-AGG-ID: bNHJrVszNza4t59YaqBgkQ Received: from SA0PR17MB4314.namprd17.prod.outlook.com (2603:10b6:806:e7::16) by SJ2PR17MB6443.namprd17.prod.outlook.com (2603:10b6:a03:4fc::10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.8158.27; Thu, 21 Nov 2024 12:48:29 +0000 Received: from SA0PR17MB4314.namprd17.prod.outlook.com ([fe80::38a7:a6f2:3b95:bc26]) by SA0PR17MB4314.namprd17.prod.outlook.com ([fe80::38a7:a6f2:3b95:bc26%5]) with mapi id 15.20.8158.023; Thu, 21 Nov 2024 12:48:29 +0000 From: Jan Vrany To: gdb-patches@sourceware.org CC: Jan Vrany , Eli Zaretskii Subject: [RFC v2 16/21] gdb/python: allow instantiation of gdb.Symbol from Python Date: Thu, 21 Nov 2024 12:47:09 +0000 Message-ID: <20241121124714.419946-17-jan.vrany@labware.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20241121124714.419946-1-jan.vrany@labware.com> References: <20241121124714.419946-1-jan.vrany@labware.com> X-ClientProxiedBy: LO2P265CA0369.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:a3::21) To SA0PR17MB4314.namprd17.prod.outlook.com (2603:10b6:806:e7::16) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: SA0PR17MB4314:EE_|SJ2PR17MB6443:EE_ X-MS-Office365-Filtering-Correlation-Id: 356c0da9-5553-43f3-f0d6-08dd0a2acc8f X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|376014|1800799024|366016 X-Microsoft-Antispam-Message-Info: t83HefjSlM0je+ycHb/0aBDIrBIwEg+joXxqRqetWGvmJ8Z+0dTc6qum5eVP1N8DQNvtWBeaPz5j4AmawTZYRTGoxGjk9aRfK1dFtRqe0858bNR+vIGYcly+y7UC2BIlTdu4VTw14haAH+g1F9rKwAIK1nrNTb9ukEc/Uq6zsOsrtYvTqrjYrmwHCs4lLx5GHwmfcWKiovWUr8Y4IYxpRBabTx49cBOWTyc9ZRoVGrukQoCb9G5zpIT8rD6LcDT8+eCtoPSPM2QBZ7Ri5Sqxtmx8GtgLMOj7EIFkN2OWMQvZNhNI0+v4xADVD/FjCu012TJcfDjlvqJFfE1kue7sx5b6aQzblOt8npNzQ6Fa5UVIOICvzttSG7YYHB50HLF/Ex/9gsBdITc1fcaPFdp63zC1dJqGGQf84J3GvIS2v8EugYbkAtjCV+OD2p3/R3EhuBV52VTaCfkzztGg5z5U5LTNyro6ohFvRc8hQiWvuY2Ggl8htb3HYwFgCqDDN1VudX1r2fEWiLq9Q6m9/TZMo4PGdnteXDTwN+XqimeCxIDkWH2TJtX9G9xL5bxsgoPzpMRnE3L4j+16Hz86UmVObqIbvFSlnqPHJIFMC11fcGCrhBJY4z5L+/D6kK42aaHmCRaVBqyqBZ2o/orwKWrDix0NWy6JofUwRrVFcjga6B71Zt8AHinPOS8mARCFGOOgiUzjc2v6tvV91tYibYDM9ZCOQBjKxyj5hY0WA6lMiiqPrrpbxOTy4G4U+jVtlsrNDom2GAY7Lq8FYA/JYf69C7cgvWl1OjlUWW5pg/jLm7K+QaET44/8JHzWhMB1pv8+7aJkmzR0N+nUBXdL2PQb8LYTO9KyGxPTcpPKEPTA1u9gWtm+vokTdyfTNqiMZfYVx1VPBhLVHjgztEZ699+XxVEHy/6e4sRrQhk/R7tgqz2LP8qjAhp0lpno+9uokaUPvcBS/COPwjf+Idu36X2aucAufipBWDfg+WRdgP0r/6xrTSbZLZfy8rWFyZr5hn2EvcwuPxz4baHutDS5jt2Y7XVEL/sxL6KlXD4FEvuYh/wyM0mcmtcVt+IKtP84MjDB/9BKH608fPxPvu4Y9GEEP3cU6+nDU4fMD4eYCXHCZIQKisUSavtv1GB/eO6YpAYBD8RMOn2pPHWrCHGBkt3GVv3VA3PTcDMycB2ev5749jxmpI80sQjrKHTVtKdej+hMpzb1tjLd82rnMQQjRhWAZiKLSWIKlbNAx/tgEp0Rgq5JRW47iNLcCjZzlitpYUNIXYR1jb4gbfRwApfBhySlKC/+93+L7BglzM/jo0WnjwASW41mNwqaytVN4vHCfNf0 X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:SA0PR17MB4314.namprd17.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(376014)(1800799024)(366016); DIR:OUT; SFP:1102 X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: nEUQ+DbCGbyvPz8h7XOtTI4S4ZwegHRGEewVOk0wfNgoSpe1799dOMRo6qjZT3l7loSRKm55HBxH9iP8/1kyvzTxS3+sDwQldHykZFylsBXAHojqAPz9TFytm/9Y2xcTmQ/SoyQBHzs+Bf2VZkdWZbT4/XhOXkX/45LBGGWg5/Jw2MgO0ViW0A9BJf98NGDJYy9D52s0NAsU+KGFo7nMi6afj0Aqhyu1FTRK+CzGO2iUW1fxXNQI5nCR9MgtyJtb9ca9X1A5I3hiAizKBIG3fBrbv8Q+1P+iErmce9JzSnQDWYjIP+6mnk4gJ0WWvQjuFytrRPS/h6z7N+Y6LNFknKbuarvtzdm3X58BIiPU2QEL8KzTCfMFT+pfg+FGUCfcvwhDQFzOEwFeOffru1wxffJ0eggRIwWKv3wqULrOBucq1GT2LK9enaaJS4LFZX0ghiSOKqjGVevM+XlrW3ws6gMYximat2zYOrYg8U/EhY+iZXmpcjjtP4Wuk7XUL1/9FtWrNvrsah/gQvAmEslnxFkJfdx07R5nGELTkCLaxA6tICmJnJ+ImR57UrDl8kmC8HPsuOVjMKh1Zetril9SbrsrIXVeV+OpoqouU5v96awv7HbNgBQHcYKgx4tiBISxfEosGgx+MEHH+AoSLzl5KWTjU1okRPS+EXQwurmVWVnhv0wjZV7tB6Ld8m0lIJuTy5MjXbdoqEu4qKjuhTzKwqWBfl6+jkN4GfRcFo9KPPMdq3v6dXexOjfcYWulqIuw205aKvTDphOgG/RwM374OxF83zzV0PKyHtfyfR9Hz8O7R856dmtFnTTaxFe/KAR95ElQNEuQ9hyizz7jXJRUA4+WGV6c+kB8beO3WzMPg/HwuqnilgwGsj2+WvlDvcgRq4W33b95OzrTYEi7rKx/Af0cYewqFjQeWc1TLOPrjwtVWflDiLS8nr6UzUMTakHw8b5rg2JVOuCiHs03jhqTTkMxmzhezyR10wpkQ4Mtpy9h/Axi12uiF7WG0gaX66NE9IjRamgml2a44c4auu1WcbMHQ7nEoyNGwan35HNwPBkgNBzEDaede2sHmCXoCURGfEQQSTNTimvVCEirNDYNdVYFz7D2JNXUqCClqY4YeZDneVKJqvibGOyIpyiC1q/docnwCUACs3NBZIINvRs//vDKWkjgz+BJlyTM2oBJ7o05/XKqLaeFDS1tfE1k8eU6ECztXAv1JdB/17ryG9VOB5dZv84pA89Sz1+rRUEXEoVtlMbKSGpr0v1Tpu01CRiOw1QzKCuFXh/zc+OXWcP2BV7dxvDL2VxJWrIv/AQny88skbUqurNdGPwoSvRv3Ap33CRWIdE9whWErrEbpC+z4KuN1MNT8rd8H+RQ7TdlaUKvFXjVEE8NMO4OVR5Ak27OKuOBXL2ihwkuOzrs1Au7Qy4mMerohE9LWSaru48vJHmWkMORwGS0RJrpZo/SXdg/4dkPn8a9RQssdUlNK+1/mx1L3Uh7e4HWU+j5w8uUztyV4JT0LgW5xep3JMAecAqZwKqxeSQUIawpda8pAqrDQJqNb+gu8uK0mOHpPqSFEmnjhiKla2i4BkaFVi9FPIzO X-OriginatorOrg: labware.com X-MS-Exchange-CrossTenant-Network-Message-Id: 356c0da9-5553-43f3-f0d6-08dd0a2acc8f X-MS-Exchange-CrossTenant-AuthSource: SA0PR17MB4314.namprd17.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 21 Nov 2024 12:48:29.5207 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: b5db0322-1aa0-4c0a-859c-ad0f96966f4c X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: TGEM3dEVWWwoclxaV3r8etkqM4ZS0/bMir4zLzBq/u+kyonqVtrWH72hzoGSQnE111IKi6aHAt8/VFJF5v+y/w== X-MS-Exchange-Transport-CrossTenantHeadersStamped: SJ2PR17MB6443 X-Mimecast-Spam-Score: 0 X-Mimecast-MFC-PROC-ID: tEbGDX7QgbrAUwDaAEcpu5A3lwbRpo5AiYtkHIY4qR4_1732193310 X-Mimecast-Originator: labware.com X-Spam-Status: No, score=-12.1 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~patchwork=sourceware.org@sourceware.org This commit adds code to allow user extension to instantiate gdb.Symbol. As of now only "function" symbols can be created (that is: symbols of FUNCTION_DOMAIN and with address class LOC_BLOCK). This is enough to be able to implement "JIT reader" equivalent in Python. Future commits may extend this API to allow creation of other kinds of symbols (static variables, arguments, locals and so on). Like previous similar commits, this is a step towards a Python support for dynamically generated code (JIT) in GDB. Reviewed-By: Eli Zaretskii Reviewed-By: Eli Zaretskii --- gdb/doc/python.texi | 26 +++++ gdb/objfiles.c | 20 ++++ gdb/objfiles.h | 4 + gdb/python/py-symbol.c | 139 ++++++++++++++++++++++++- gdb/testsuite/gdb.python/py-symbol.exp | 13 +++ 5 files changed, 201 insertions(+), 1 deletion(-) diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi index 8b3c95cbf1d..55ca91920cb 100644 --- a/gdb/doc/python.texi +++ b/gdb/doc/python.texi @@ -6278,6 +6278,32 @@ arguments. A @code{gdb.Symbol} object has the following methods: +@defun Symbol.__init__ (name, symtab, type, domain, addr_class, value) +Creates new symbol named @var{name} and adds it to symbol table +@var{symtab}. + +The @var{type} argument specifies type of the symbol as @var{gdb.Type} +object (@pxref{Types In Python}). + +The @var{domain} argument specifies domain of the symbol. Each domain is +a constant defined in the @code{gdb} module and described later in this +chapter. + +The @var{addr_class} argument, together with @var{value} argument, specifies +how to find the value of this symbol. Each address class is a constant +defined in the @code{gdb} module and described later in this chapter. As of +now, only @code{gdb.SYMBOL_LOC_BLOCK} address class is supported, but future +versions of @value{GDBN} may support more address classes. + +The meaning of @var{value} argument depends on the value of @var{addr_class}: +@vtable @code +@item gdb.SYMBOL_LOC_BLOCK +The @var{value} argument must be a block (a @code{gdb.Block} object). Block +must belong to the same compunit as the +@var{symtab} parameter (@pxref{Compunits In Python}). +@end vtable +@end defun + @defun Symbol.is_valid () Returns @code{True} if the @code{gdb.Symbol} object is valid, @code{False} if not. A @code{gdb.Symbol} object can become invalid if diff --git a/gdb/objfiles.c b/gdb/objfiles.c index 0bb578fa6a8..cdb6dba2f7c 100644 --- a/gdb/objfiles.c +++ b/gdb/objfiles.c @@ -1312,3 +1312,23 @@ objfile_int_type (struct objfile *of, int size_in_bytes, bool unsigned_p) gdb_assert_not_reached ("unable to find suitable integer type"); } + +/* See objfiles.h. */ + +int +objfile::find_section_index (CORE_ADDR start, CORE_ADDR end) +{ + obj_section *sect; + int sect_index; + for (sect = this->sections_start, sect_index = 0; + sect < this->sections_end; + sect++, sect_index++) + { + if (sect->the_bfd_section == nullptr) + continue; + + if (sect->addr () <= start && end <= sect->endaddr ()) + return sect_index; + } + return -1; +} \ No newline at end of file diff --git a/gdb/objfiles.h b/gdb/objfiles.h index bd65e2bd030..94533797563 100644 --- a/gdb/objfiles.h +++ b/gdb/objfiles.h @@ -644,6 +644,10 @@ struct objfile : intrusive_list_node this->section_offsets[idx] = offset; } + /* Return the section index for section mapped at memory range + [START, END]. If there's no such section, return -1. */ + int find_section_index (CORE_ADDR start, CORE_ADDR end); + class section_iterator { public: diff --git a/gdb/python/py-symbol.c b/gdb/python/py-symbol.c index 44bed85481b..78db88333c5 100644 --- a/gdb/python/py-symbol.c +++ b/gdb/python/py-symbol.c @@ -400,6 +400,135 @@ sympy_repr (PyObject *self) symbol->print_name ()); } +/* Object initializer; creates new symbol. + + Use: __init__(NAME, SYMTAB, TYPE, DOMAIN, ADDR_CLASS, VALUE). */ + +static int +sympy_init (PyObject *zelf, PyObject *args, PyObject *kw) +{ + struct symbol_object *self = (struct symbol_object*) zelf; + + if (self->symbol) + { + PyErr_Format (PyExc_RuntimeError, + _("Symbol object already initialized.")); + return -1; + } + + static const char *keywords[] = { "name", "symtab", "type", + "domain", "addr_class", "value", + nullptr }; + const char *name; + PyObject *symtab_obj = nullptr; + PyObject *type_obj = nullptr; + domain_enum domain; + unsigned int addr_class; + PyObject *value_obj = nullptr; + + if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "sOOIIO", keywords, + &name, &symtab_obj, &type_obj, + &domain, &addr_class, &value_obj)) + return -1; + + + struct symtab *symtab = symtab_object_to_symtab (symtab_obj); + if (symtab == nullptr) + { + PyErr_Format (PyExc_TypeError, + _("The symtab argument is not valid gdb.Symtab object")); + return -1; + } + + struct type *type = type_object_to_type (type_obj); + if (type == nullptr) + { + PyErr_Format (PyExc_TypeError, + _("The type argument is not valid gdb.Type object")); + return -1; + } + if (type->objfile_owner () != nullptr && + type->objfile_owner () != symtab->compunit ()->objfile ()) + { + PyErr_Format (PyExc_ValueError, + _("The type argument's owning objfile differs from " + "symtab's objfile.")); + return -1; + } + + union _value { + const struct block *block; + } value; + + switch (addr_class) + { + default: + PyErr_Format (PyExc_ValueError, + _("The value of addr_class argument is not supported")); + return -1; + + case LOC_BLOCK: + if ((value.block = block_object_to_block (value_obj)) == nullptr) + { + PyErr_Format (PyExc_TypeError, + _("The addr_class argument is SYMBOL_LOC_BLOCK but " + "the value argument is not a valid gdb.Block.")); + return -1; + } + if (type->code () != TYPE_CODE_FUNC) + { + PyErr_Format (PyExc_ValueError, + _("The addr_class argument is SYMBOL_LOC_BLOCK but " + "the type argument is not a function type.")); + return -1; + } + break; + } + + struct objfile *objfile = symtab->compunit ()->objfile (); + auto_obstack *obstack = &(objfile->objfile_obstack); + struct symbol *sym = new (obstack) symbol(); + + sym->m_name = obstack_strdup (obstack, name); + sym->set_symtab (symtab); + sym->set_type (type); + sym->set_domain (domain); + sym->set_aclass_index (addr_class); + + switch (addr_class) + { + case LOC_BLOCK: + { + sym->set_value_block (value.block); + + if (domain == FUNCTION_DOMAIN) + const_cast (value.block)->set_function (sym); + + /* Set symbol's section index. This needed in somewhat unusual + usecase where dynamic code is generated into a special section + (defined in custom linker script or otherwise). Otherwise, + find_pc_sect_compunit_symtab () would not find the compunit + symtab and commands like "disassemble function_name" would + resort to disassemble complete section. + + Note that in usual case where new objfile is created for + dynamic code, the objfile has no sections at all and + objfile::find_section_index () returns -1. + */ + CORE_ADDR start = value.block->start (); + CORE_ADDR end = value.block->end (); + sym->set_section_index (objfile->find_section_index (start, end)); + } + break; + default: + gdb_assert_not_reached("unreachable"); + break; + } + + set_symbol (self, sym); + return 0; +} + /* Implementation of gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this) A tuple with 2 elements is always returned. The first is the symbol @@ -774,5 +903,13 @@ PyTypeObject symbol_object_type = { 0, /*tp_iternext */ symbol_object_methods, /*tp_methods */ 0, /*tp_members */ - symbol_object_getset /*tp_getset */ + symbol_object_getset, /*tp_getset */ + 0, /*tp_base */ + 0, /*tp_dict */ + 0, /*tp_descr_get */ + 0, /*tp_descr_set */ + 0, /*tp_dictoffset */ + sympy_init, /*tp_init */ + 0, /*tp_alloc */ + PyType_GenericNew, /*tp_new */ }; diff --git a/gdb/testsuite/gdb.python/py-symbol.exp b/gdb/testsuite/gdb.python/py-symbol.exp index 1bfa17b4e91..d9c0e255146 100644 --- a/gdb/testsuite/gdb.python/py-symbol.exp +++ b/gdb/testsuite/gdb.python/py-symbol.exp @@ -222,6 +222,19 @@ gdb_test "python print (t\[0\] != 123 )"\ "True" \ "test symbol non-equality with non-symbol" +# Test creation of new symbols +gdb_py_test_silent_cmd "python s = gdb.Symbol(\"ns1\", t\[0\].symtab, t\[0\].type.function(), gdb.SYMBOL_FUNCTION_DOMAIN, gdb.SYMBOL_LOC_BLOCK, t\[0\].symtab.static_block() )" \ + "create symbol" 0 +gdb_test "python print (s)" \ + "ns1" \ + "test new symbol's __str__" +gdb_test "python print (s.symtab == t\[0\].symtab)" \ + "True" \ + "test new symbol's symtab" +gdb_test "python print (s.type == t\[0\].type.function())" \ + "True" \ + "test new symbol's type" + # C++ tests # Recompile binary. lappend opts c++