[6/7] gdb: extension languages finish_initialization to initialize

Message ID e3707c31029370562c3bbb9a31461393ad517781.1619125261.git.andrew.burgess@embecosm.com
State New
Headers show
Series
  • New options to control how Python is initialized
Related show

Commit Message

Andrew Burgess April 22, 2021, 9:02 p.m.
Now that both Python and Guile are fully initialized from their
respective finish_initialization methods, the "finish" in the method
name doesn't really make sense; initialization starts _and_ finishes
with that method.

As such, this commit renames finish_initialization to just initialize.

There should be no user visible changes after this commit.

gdb/ChangeLog:

	* extension-priv.h (struct extension_language_ops): Rename
	'finish_initialization' to 'initialize'.
	* extension.c (finish_ext_lang_initialization): Renamed to...
	(ext_lang_initialization): ...this, update comment, and updated
	the calls to reflect the change in struct extension_language_ops.
	* extension.h (finish_ext_lang_initialization): Renamed to...
	(ext_lang_initialization): ...this.
	* guile/guile.c (gdbscm_finish_initialization): Renamed to...
	(gdbscm_initialize): ...this, update comment at definition.
	(guile_extension_ops): Update.
	* main.c (captured_main_1): Update call to
	finish_ext_lang_initialization.
	* python/python.c (gdbpy_finish_initialization): Rename to...
	(gdbpy_initialize): ...this, update comment at definition, and
	update call to do_finish_initialization.
	(python_extension_ops): Update.
	(do_finish_initialization): Rename to...
	(do_initialize): ...this, and update comment.
---
 gdb/ChangeLog        | 21 +++++++++++++++++++++
 gdb/extension-priv.h |  9 +++++----
 gdb/extension.c      | 10 +++++-----
 gdb/extension.h      |  2 +-
 gdb/guile/guile.c    | 12 +++++-------
 gdb/main.c           |  4 ++--
 gdb/python/python.c  | 25 +++++++++++--------------
 7 files changed, 50 insertions(+), 33 deletions(-)

-- 
2.25.4

Comments

Tom Tromey April 23, 2021, 2:31 p.m. | #1
>>>>> "Andrew" == Andrew Burgess <andrew.burgess@embecosm.com> writes:


Andrew> Now that both Python and Guile are fully initialized from their
Andrew> respective finish_initialization methods, the "finish" in the method
Andrew> name doesn't really make sense; initialization starts _and_ finishes
Andrew> with that method.

Andrew> As such, this commit renames finish_initialization to just initialize.

Thanks for doing this.  Looks good to me.

Tom

Patch

diff --git a/gdb/extension-priv.h b/gdb/extension-priv.h
index 1b6701ba6cc..77f23e0f911 100644
--- a/gdb/extension-priv.h
+++ b/gdb/extension-priv.h
@@ -109,10 +109,11 @@  struct extension_language_script_ops
 
 struct extension_language_ops
 {
-  /* Called at the end of gdb initialization to give the extension language
-     an opportunity to finish up.  This is useful for things like adding
-     new commands where one has to wait until gdb itself is initialized.  */
-  void (*finish_initialization) (const struct extension_language_defn *);
+  /* Called after GDB has processed the early initialization settings
+     files.  This is when the extension language should be initialized.  By
+     the time this is called all of the earlier initialization functions
+     have already been called.  */
+  void (*initialize) (const struct extension_language_defn *);
 
   /* Return non-zero if the extension language successfully initialized.
      This method is required.  */
diff --git a/gdb/extension.c b/gdb/extension.c
index 8f3722d3049..920827c453f 100644
--- a/gdb/extension.c
+++ b/gdb/extension.c
@@ -323,19 +323,19 @@  using scoped_default_sigint = scoped_default_signal<SIGINT>;
    These only iterate over external extension languages, not including
    GDB's own extension/scripting language, unless otherwise indicated.  */
 
-/* Wrapper to call the extension_language_ops.finish_initialization "method"
-   for each compiled-in extension language.  */
+/* Wrapper to call the extension_language_ops.initialize "method" for each
+   compiled-in extension language.  */
 
 void
-finish_ext_lang_initialization (void)
+ext_lang_initialization (void)
 {
   for (const struct extension_language_defn *extlang : extension_languages)
     {
       if (extlang->ops != nullptr
-	  && extlang->ops->finish_initialization != NULL)
+	  && extlang->ops->initialize != NULL)
 	{
 	  scoped_default_sigint set_sigint_to_default_handler;
-	  extlang->ops->finish_initialization (extlang);
+	  extlang->ops->initialize (extlang);
 	}
     }
 }
diff --git a/gdb/extension.h b/gdb/extension.h
index a505c68d25e..56f57560de3 100644
--- a/gdb/extension.h
+++ b/gdb/extension.h
@@ -276,7 +276,7 @@  extern bool ext_lang_auto_load_enabled (const struct extension_language_defn *);
 /* Wrappers for each extension language API function that iterate over all
    extension languages.  */
 
-extern void finish_ext_lang_initialization (void);
+extern void ext_lang_initialization (void);
 
 extern void eval_ext_lang_from_control_command (struct command_line *cmd);
 
diff --git a/gdb/guile/guile.c b/gdb/guile/guile.c
index 9c2a40b61be..bdf15cd498b 100644
--- a/gdb/guile/guile.c
+++ b/gdb/guile/guile.c
@@ -75,8 +75,7 @@  const char *gdbscm_print_excp = gdbscm_print_excp_message;
 
 #ifdef HAVE_GUILE
 
-static void gdbscm_finish_initialization
-  (const struct extension_language_defn *);
+static void gdbscm_initialize (const struct extension_language_defn *);
 static int gdbscm_initialized (const struct extension_language_defn *);
 static void gdbscm_eval_from_control_command
   (const struct extension_language_defn *, struct command_line *);
@@ -113,7 +112,7 @@  static const struct extension_language_script_ops guile_extension_script_ops =
 
 static const struct extension_language_ops guile_extension_ops =
 {
-  gdbscm_finish_initialization,
+  gdbscm_initialize,
   gdbscm_initialized,
 
   gdbscm_eval_from_control_command,
@@ -638,12 +637,11 @@  call_initialize_gdb_module (void *data)
   return NULL;
 }
 
-/* A callback to finish Guile initialization after gdb has finished all its
-   initialization.
-   This is the extension_language_ops.finish_initialization "method".  */
+/* A callback to initialize Guile after gdb has finished all its
+   initialization.  This is the extension_language_ops.initialize "method".  */
 
 static void
-gdbscm_finish_initialization (const struct extension_language_defn *extlang)
+gdbscm_initialize (const struct extension_language_defn *extlang)
 {
 #if HAVE_GUILE
   /* The Python support puts the C side in module "_gdb", leaving the
diff --git a/gdb/main.c b/gdb/main.c
index 2a1c3a4866f..d92aa02d831 100644
--- a/gdb/main.c
+++ b/gdb/main.c
@@ -1053,8 +1053,8 @@  captured_main_1 (struct captured_main_args *context)
   execute_cmdargs (&cmdarg_vec, CMDARG_EARLYINIT_FILE,
 		   CMDARG_EARLYINIT_COMMAND, &ret);
 
-  /* Finish initializing the extension languges.  */
-  finish_ext_lang_initialization ();
+  /* Initialize the extension languages.  */
+  ext_lang_initialization ();
 
   /* Recheck if we're starting up quietly after processing the startup
      scripts and commands.  */
diff --git a/gdb/python/python.c b/gdb/python/python.c
index 520508043ba..1d0d86d5c49 100644
--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -129,8 +129,7 @@  PyObject *gdbpy_gdb_memory_error;
 static script_sourcer_func gdbpy_source_script;
 static objfile_script_sourcer_func gdbpy_source_objfile_script;
 static objfile_script_executor_func gdbpy_execute_objfile_script;
-static void gdbpy_finish_initialization
-  (const struct extension_language_defn *);
+static void gdbpy_initialize (const struct extension_language_defn *);
 static int gdbpy_initialized (const struct extension_language_defn *);
 static void gdbpy_eval_from_control_command
   (const struct extension_language_defn *, struct command_line *cmd);
@@ -162,7 +161,7 @@  const struct extension_language_script_ops python_extension_script_ops =
 
 const struct extension_language_ops python_extension_ops =
 {
-  gdbpy_finish_initialization,
+  gdbpy_initialize,
   gdbpy_initialized,
 
   gdbpy_eval_from_control_command,
@@ -1885,12 +1884,12 @@  message == an error message without a stack will be printed."),
 
 #ifdef HAVE_PYTHON
 
-/* Helper function for gdbpy_finish_initialization.  This does the
-   work and then returns false if an error has occurred and must be
-   displayed, or true on success.  */
+/* Helper function for gdbpy_initialize.  This does the work and then
+   returns false if an error has occurred and must be displayed, or true on
+   success.  */
 
 static bool
-do_finish_initialization (const struct extension_language_defn *extlang)
+do_initialize (const struct extension_language_defn *extlang)
 {
   PyObject *m;
   PyObject *sys_path;
@@ -1948,21 +1947,19 @@  do_finish_initialization (const struct extension_language_defn *extlang)
   return gdb_pymodule_addobject (m, "gdb", gdb_python_module) >= 0;
 }
 
-/* Perform the remaining python initializations.
-   These must be done after GDB is at least mostly initialized.
-   E.g., The "info pretty-printer" command needs the "info" prefix
-   command installed.
-   This is the extension_language_ops.finish_initialization "method".  */
+/* Perform Python initialization.  This will be called after GDB has
+   performed all of its own initialization.  This is the
+   extension_language_ops.initialize "method".  */
 
 static void
-gdbpy_finish_initialization (const struct extension_language_defn *extlang)
+gdbpy_initialize (const struct extension_language_defn *extlang)
 {
   if (!do_start_initialization () && PyErr_Occurred ())
     gdbpy_print_stack ();
 
   gdbpy_enter enter_py (get_current_arch (), current_language);
 
-  if (!do_finish_initialization (extlang))
+  if (!do_initialize (extlang))
     {
       gdbpy_print_stack ();
       warning (_("internal error: Unhandled Python exception"));