gdb/extension.h

   1 /* Interface between gdb and its extension languages.
   2
   3    Copyright (C) 2014-2023 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef EXTENSION_H
  21 #define EXTENSION_H
  22
  23 #include "mi/mi-cmds.h"
  24 #include "gdbsupport/array-view.h"
  25 #include "gdbsupport/gdb_optional.h"
  26
  27 struct breakpoint;
  28 struct command_line;
  29 class frame_info_ptr;
  30 struct language_defn;
  31 struct objfile;
  32 struct extension_language_defn;
  33 struct type;
  34 struct ui_file;
  35 struct ui_out;
  36 struct value;
  37 struct value_print_options;
  38
  39 /* A function to load and process a script file.
  40    The file has been opened and is ready to be read from the beginning.
  41    Any exceptions are not caught, and are passed to the caller.  */
  42 typedef void script_sourcer_func (const struct extension_language_defn *,
  43                                   FILE *stream, const char *filename);
  44
  45 /* A function to load and process a script for an objfile.
  46    The file has been opened and is ready to be read from the beginning.
  47    Any exceptions are not caught, and are passed to the caller.  */
  48 typedef void objfile_script_sourcer_func
  49   (const struct extension_language_defn *,
  50    struct objfile *, FILE *stream, const char *filename);
  51
  52 /* A function to execute a script for an objfile.
  53    Any exceptions are not caught, and are passed to the caller.  */
  54 typedef void objfile_script_executor_func
  55   (const struct extension_language_defn *,
  56    struct objfile *, const char *name, const char *script);
  57
  58 /* Enum of each extension(/scripting) language.  */
  59
  60 enum extension_language
  61   {
  62     EXT_LANG_NONE,
  63     EXT_LANG_GDB,
  64     EXT_LANG_PYTHON,
  65     EXT_LANG_GUILE
  66   };
  67
  68 /* Extension language frame-filter status return values.  */
  69
  70 enum ext_lang_bt_status
  71   {
  72     /* Return when an error has occurred in processing frame filters,
  73        or when printing the stack.  */
  74     EXT_LANG_BT_ERROR = -1,
  75
  76     /* Return from internal routines to indicate that the function
  77        succeeded.  */
  78     EXT_LANG_BT_OK = 1,
  79
  80     /* Return when the frame filter process is complete, but there
  81        were no filter registered and enabled to process.  */
  82     EXT_LANG_BT_NO_FILTERS = 2
  83   };
  84
  85 /* Flags to pass to apply_extlang_frame_filter.  */
  86
  87 enum frame_filter_flag
  88   {
  89     /* Set this flag if frame level is to be printed.  */
  90     PRINT_LEVEL = 1 << 0,
  91
  92     /* Set this flag if frame information is to be printed.  */
  93     PRINT_FRAME_INFO = 1 << 1,
  94
  95     /* Set this flag if frame arguments are to be printed.  */
  96     PRINT_ARGS = 1 << 2,
  97
  98     /* Set this flag if frame locals are to be printed.  */
  99     PRINT_LOCALS = 1 << 3,
 100
 101     /* Set this flag if a "More frames" message is to be printed.  */
 102     PRINT_MORE_FRAMES = 1 << 4,
 103
 104     /* Set this flag if elided frames should not be printed.  */
 105     PRINT_HIDE = 1 << 5,
 106   };
 107
 108 DEF_ENUM_FLAGS_TYPE (enum frame_filter_flag, frame_filter_flags);
 109
 110 /* A choice of the different frame argument printing strategies that
 111    can occur in different cases of frame filter instantiation.  */
 112
 113 enum ext_lang_frame_args
 114   {
 115     /* Print no values for arguments when invoked from the MI. */
 116     NO_VALUES = PRINT_NO_VALUES,
 117
 118     MI_PRINT_ALL_VALUES = PRINT_ALL_VALUES,
 119
 120     /* Print only simple values (what MI defines as "simple") for
 121        arguments when invoked from the MI. */
 122     MI_PRINT_SIMPLE_VALUES = PRINT_SIMPLE_VALUES,
 123
 124     /* Print only scalar values for arguments when invoked from the CLI. */
 125     CLI_SCALAR_VALUES,
 126
 127     /* Print all values for arguments when invoked from the CLI. */
 128     CLI_ALL_VALUES,
 129
 130     /* Only indicate the presence of arguments when invoked from the CLI.  */
 131     CLI_PRESENCE
 132   };
 133
 134 /* The possible results of
 135    extension_language_ops.breakpoint_cond_says_stop.  */
 136
 137 enum ext_lang_bp_stop
 138   {
 139     /* No "stop" condition is set.  */
 140     EXT_LANG_BP_STOP_UNSET,
 141
 142     /* A "stop" condition is set, and it says "don't stop".  */
 143     EXT_LANG_BP_STOP_NO,
 144
 145     /* A "stop" condition is set, and it says "stop".  */
 146     EXT_LANG_BP_STOP_YES
 147   };
 148
 149 /* Table of type printers associated with the global typedef table.  */
 150
 151 struct ext_lang_type_printers
 152 {
 153   ext_lang_type_printers ();
 154   ~ext_lang_type_printers ();
 155
 156   DISABLE_COPY_AND_ASSIGN (ext_lang_type_printers);
 157
 158   /* Type-printers from Python.  */
 159   void *py_type_printers = nullptr;
 160 };
 161
 162 /* The return code for some API calls.  */
 163
 164 enum ext_lang_rc
 165 {
 166   /* The operation completed successfully.  */
 167   EXT_LANG_RC_OK,
 168
 169   /* The operation was not performed (e.g., no pretty-printer).  */
 170   EXT_LANG_RC_NOP,
 171
 172   /* There was an error (e.g., Python error while printing a value).
 173      When an error occurs no further extension languages are tried.
 174      This is to preserve existing behaviour, and because it's convenient
 175      for Python developers.
 176      Note: This is different than encountering a memory error trying to read
 177      a value for pretty-printing.  Here we're referring to, e.g., programming
 178      errors that trigger an exception in the extension language.  */
 179   EXT_LANG_RC_ERROR
 180 };
 181
 182 /* A type which holds its extension language specific xmethod worker data.  */
 183
 184 struct xmethod_worker
 185 {
 186   xmethod_worker (const extension_language_defn *extlang)
 187   : m_extlang (extlang)
 188   {}
 189
 190   virtual ~xmethod_worker () = default;
 191
 192   /* Invoke the xmethod encapsulated in this worker and return the result.
 193      The method is invoked on OBJ with arguments in the ARGS array.  */
 194
 195   virtual value *invoke (value *obj, gdb::array_view<value *> args) = 0;
 196
 197   /* Return the arg types of the xmethod encapsulated in this worker.
 198      The type of the 'this' object is returned as the first element of
 199      the vector.  */
 200
 201   std::vector<type *> get_arg_types ();
 202
 203   /* Return the type of the result of the xmethod encapsulated in this worker.
 204      OBJECT and ARGS are the same as for invoke.  */
 205
 206   type *get_result_type (value *object, gdb::array_view<value *> args);
 207
 208 private:
 209
 210   /* Return the types of the arguments the method takes.  The types
 211      are returned in TYPE_ARGS, one per argument.  */
 212
 213   virtual enum ext_lang_rc do_get_arg_types
 214     (std::vector<type *> *type_args) = 0;
 215
 216   /* Fetch the type of the result of the method implemented by this
 217      worker.  OBJECT and ARGS are the same as for the invoked method.
 218      The result type is stored in *RESULT_TYPE.  */
 219
 220   virtual enum ext_lang_rc do_get_result_type
 221     (struct value *obj, gdb::array_view<value *> args,
 222      struct type **result_type_ptr) = 0;
 223
 224   /* The language the xmethod worker is implemented in.  */
 225
 226   const extension_language_defn *m_extlang;
 227 };
 228
 229 typedef std::unique_ptr<xmethod_worker> xmethod_worker_up;
 230
 231 /* The interface for gdb's own extension(/scripting) language.  */
 232 extern const struct extension_language_defn extension_language_gdb;
 233
 234 extern const struct extension_language_defn *get_ext_lang_defn
 235   (enum extension_language lang);
 236
 237 extern const struct extension_language_defn *get_ext_lang_of_file
 238   (const char *file);
 239
 240 extern int ext_lang_present_p (const struct extension_language_defn *);
 241
 242 extern int ext_lang_initialized_p (const struct extension_language_defn *);
 243
 244 extern void throw_ext_lang_unsupported
 245   (const struct extension_language_defn *);
 246
 247 /* Accessors for "public" attributes of the extension language definition.  */
 248
 249 extern enum extension_language ext_lang_kind
 250   (const struct extension_language_defn *);
 251
 252 extern const char *ext_lang_name (const struct extension_language_defn *);
 253
 254 extern const char *ext_lang_capitalized_name
 255   (const struct extension_language_defn *);
 256
 257 extern const char *ext_lang_suffix (const struct extension_language_defn *);
 258
 259 extern const char *ext_lang_auto_load_suffix
 260   (const struct extension_language_defn *);
 261
 262 extern script_sourcer_func *ext_lang_script_sourcer
 263   (const struct extension_language_defn *);
 264
 265 extern objfile_script_sourcer_func *ext_lang_objfile_script_sourcer
 266   (const struct extension_language_defn *);
 267
 268 extern objfile_script_executor_func *ext_lang_objfile_script_executor
 269   (const struct extension_language_defn *);
 270
 271 /* Return true if auto-loading of EXTLANG scripts is enabled.
 272    False is returned if support for this language isn't compiled in.  */
 273
 274 extern bool ext_lang_auto_load_enabled (const struct extension_language_defn *);
 275
 276 /* Wrappers for each extension language API function that iterate over all
 277    extension languages.  */
 278
 279 extern void ext_lang_initialization (void);
 280
 281 extern void eval_ext_lang_from_control_command (struct command_line *cmd);
 282
 283 extern void auto_load_ext_lang_scripts_for_objfile (struct objfile *);
 284
 285 extern gdb::unique_xmalloc_ptr<char> apply_ext_lang_type_printers
 286      (struct ext_lang_type_printers *, struct type *);
 287
 288 extern int apply_ext_lang_val_pretty_printer
 289   (struct value *value, struct ui_file *stream, int recurse,
 290    const struct value_print_options *options,
 291    const struct language_defn *language);
 292
 293 extern enum ext_lang_bt_status apply_ext_lang_frame_filter
 294   (frame_info_ptr frame, frame_filter_flags flags,
 295    enum ext_lang_frame_args args_type,
 296    struct ui_out *out, int frame_low, int frame_high);
 297
 298 extern void preserve_ext_lang_values (struct objfile *, htab_t copied_types);
 299
 300 extern const struct extension_language_defn *get_breakpoint_cond_ext_lang
 301   (struct breakpoint *b, enum extension_language skip_lang);
 302
 303 extern bool breakpoint_ext_lang_cond_says_stop (struct breakpoint *);
 304
 305 /* If a method with name METHOD_NAME is to be invoked on an object of type
 306    TYPE, then all extension languages are searched for implementations of
 307    methods with name METHOD_NAME.  All matches found are appended to the WORKERS
 308    vector.  */
 309
 310 extern void get_matching_xmethod_workers
 311   (struct type *type, const char *method_name,
 312    std::vector<xmethod_worker_up> *workers);
 313
 314 /* Try to colorize some source code.  FILENAME is the name of the file
 315    holding the code.  CONTENTS is the source code itself.  This will
 316    either a colorized (using ANSI terminal escapes) version of the
 317    source code, or an empty value if colorizing could not be done.  */
 318
 319 extern gdb::optional<std::string> ext_lang_colorize
 320   (const std::string &filename, const std::string &contents);
 321
 322 /* Try to colorize a single line of disassembler output, CONTENT for
 323    GDBARCH.  This will return either a colorized (using ANSI terminal
 324    escapes) version of CONTENT, or an empty value if colorizing could not
 325    be done.  */
 326
 327 extern gdb::optional<std::string> ext_lang_colorize_disasm
 328   (const std::string &content, gdbarch *gdbarch);
 329
 330 /* Calls extension_language_ops::print_insn for each extension language,
 331    returning the result from the first extension language that returns a
 332    non-empty result (any further extension languages are not then called).
 333
 334    All arguments are forwarded to extension_language_ops::print_insn, see
 335    that function for a full description.  */
 336
 337 extern gdb::optional<int> ext_lang_print_insn
 338   (struct gdbarch *gdbarch, CORE_ADDR address, struct disassemble_info *info);
 339
 340 /* When GDB calls into an extension language because an objfile was
 341    discovered for which GDB couldn't find any debug information, this
 342    structure holds the result that the extension language returns.
 343
 344    There are three possible actions that might be returned by an extension;
 345    first an extension can return a filename, this is the path to the file
 346    containing the required debug  information.  The second possibility is
 347    to return a flag indicating that GDB should check again for the missing
 348    debug information, this would imply that the extension has installed
 349    the debug information into a location where GDB can be expected to find
 350    it.  And the third option is for the extension to just return a null
 351    result, indication there is nothing the extension can do to provide the
 352    missing debug information.  */
 353 struct ext_lang_missing_debuginfo_result
 354 {
 355   /* Default result.  The extension was unable to provide the missing debug
 356      info.  */
 357   ext_lang_missing_debuginfo_result ()
 358   { /* Nothing.  */ }
 359
 360   /* When TRY_AGAIN is true GDB should try searching again, the extension
 361      may have installed the missing debug info into a suitable location.
 362      When TRY_AGAIN is false this is equivalent to the default, no
 363      argument, constructor.  */
 364   ext_lang_missing_debuginfo_result (bool try_again)
 365     : m_try_again (try_again)
 366   { /* Nothing.  */ }
 367
 368   /* Look in FILENAME for the missing debug info.  */
 369   ext_lang_missing_debuginfo_result (std::string &&filename)
 370     : m_filename (std::move (filename))
 371   { /* Nothing.  */ }
 372
 373   /* The filename where GDB can find the missing debuginfo.  This is empty
 374      if the extension didn't suggest a file that can be used.  */
 375   const std::string &
 376   filename () const
 377   {
 378     return m_filename;
 379   }
 380
 381   /* Returns true if GDB should look again for the debug information.  */
 382   const bool
 383   try_again () const
 384   {
 385     return m_try_again;
 386   }
 387
 388 private:
 389   /* The filename where the missing debuginfo can now be found.  */
 390   std::string m_filename;
 391
 392   /* When true GDB will search again for the debuginfo using its standard
 393      techniques.  When false GDB will not search again.  */
 394   bool m_try_again = false;
 395 };
 396
 397 /* Called when GDB failed to find any debug information for OBJFILE.  */
 398
 399 extern ext_lang_missing_debuginfo_result ext_lang_handle_missing_debuginfo
 400   (struct objfile *objfile);
 401
 402 #if GDB_SELF_TEST
 403 namespace selftests {
 404 extern void (*hook_set_active_ext_lang) ();
 405 }
 406 #endif
 407
 408 /* Temporarily disable cooperative SIGINT handling.  Needed when we
 409    don't want a SIGINT to interrupt the currently active extension
 410    language.  */
 411 class scoped_disable_cooperative_sigint_handling
 412 {
 413 public:
 414   scoped_disable_cooperative_sigint_handling ();
 415   ~scoped_disable_cooperative_sigint_handling ();
 416
 417   DISABLE_COPY_AND_ASSIGN (scoped_disable_cooperative_sigint_handling);
 418
 419 private:
 420   struct active_ext_lang_state *m_prev_active_ext_lang_state;
 421   bool m_prev_cooperative_sigint_handling_disabled;
 422 };
 423
 424 #endif /* EXTENSION_H */