1 /* Support for GCC plugin mechanism.
2 Copyright (C) 2009 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file contains the support for GCC plugin mechanism based on the
21 APIs described in doc/plugin.texi. */
26 /* If plugin support is not enabled, do not try to execute any code
27 that may reference libdl. The generic code is still compiled in to
28 avoid including too many conditional compilation paths in the rest
34 #include "coretypes.h"
37 #include "tree-pass.h"
44 #include "plugin-version.h"
47 /* Event names as strings. Keep in sync with enum plugin_event. */
48 const char *plugin_event_name
[] =
50 "PLUGIN_PASS_MANAGER_SETUP",
53 "PLUGIN_CXX_CP_PRE_GENERICIZE",
59 "PLUGIN_REGISTER_GGC_ROOTS",
64 /* Hash table for the plugin_name_args objects created during command-line
66 static htab_t plugin_name_args_tab
= NULL
;
68 /* List node for keeping track of plugin-registered callback. */
71 const char *plugin_name
; /* Name of plugin that registers the callback. */
72 plugin_callback_func func
; /* Callback to be called. */
73 void *user_data
; /* plugin-specified data. */
74 struct callback_info
*next
;
77 /* An array of lists of 'callback_info' objects indexed by the event id. */
78 static struct callback_info
*plugin_callbacks
[PLUGIN_EVENT_LAST
] = { NULL
};
80 /* List node for an inserted pass instance. We need to keep track of all
81 the newly-added pass instances (with 'added_pass_nodes' defined below)
82 so that we can register their dump files after pass-positioning is finished.
83 Registering dumping files needs to be post-processed or the
84 static_pass_number of the opt_pass object would be modified and mess up
85 the dump file names of future pass instances to be added. */
88 struct opt_pass
*pass
;
89 struct pass_list_node
*next
;
92 static struct pass_list_node
*added_pass_nodes
= NULL
;
93 static struct pass_list_node
*prev_added_pass_node
;
96 /* Each plugin should define an initialization function with exactly
98 static const char *str_plugin_init_func_name
= "plugin_init";
100 /* Each plugin should define this symbol to assert that it is
101 distributed under a GPL-compatible license. */
102 static const char *str_license
= "plugin_is_GPL_compatible";
105 /* Helper function for the hash table that compares the base_name of the
106 existing entry (S1) with the given string (S2). */
109 htab_str_eq (const void *s1
, const void *s2
)
111 const struct plugin_name_args
*plugin
= (const struct plugin_name_args
*) s1
;
112 return !strcmp (plugin
->base_name
, (const char *) s2
);
116 /* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so,
120 get_plugin_base_name (const char *full_name
)
122 /* First get the base name part of the full-path name, i.e. NAME.so. */
123 char *base_name
= xstrdup (lbasename (full_name
));
125 /* Then get rid of '.so' part of the name. */
126 strip_off_ending (base_name
, strlen (base_name
));
132 /* Create a plugin_name_args object for the give plugin and insert it to
133 the hash table. This function is called when -fplugin=/path/to/NAME.so
134 option is processed. */
137 add_new_plugin (const char* plugin_name
)
139 struct plugin_name_args
*plugin
;
141 char *base_name
= get_plugin_base_name (plugin_name
);
143 /* If this is the first -fplugin= option we encounter, create
144 'plugin_name_args_tab' hash table. */
145 if (!plugin_name_args_tab
)
146 plugin_name_args_tab
= htab_create (10, htab_hash_string
, htab_str_eq
,
149 slot
= htab_find_slot (plugin_name_args_tab
, base_name
, INSERT
);
151 /* If the same plugin (name) has been specified earlier, either emit an
152 error or a warning message depending on if they have identical full
156 plugin
= (struct plugin_name_args
*) *slot
;
157 if (strcmp (plugin
->full_name
, plugin_name
))
158 error ("Plugin %s was specified with different paths:\n%s\n%s",
159 plugin
->base_name
, plugin
->full_name
, plugin_name
);
163 plugin
= XCNEW (struct plugin_name_args
);
164 plugin
->base_name
= base_name
;
165 plugin
->full_name
= plugin_name
;
171 /* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a
172 'plugin_argument' object for the parsed key-value pair. ARG is
173 the <name>-<key>[=<value>] part of the option. */
176 parse_plugin_arg_opt (const char *arg
)
178 size_t len
= 0, name_len
= 0, key_len
= 0, value_len
= 0;
179 const char *ptr
, *name_start
= arg
, *key_start
= NULL
, *value_start
= NULL
;
180 char *name
, *key
, *value
;
182 bool name_parsed
= false, key_parsed
= false;
184 /* Iterate over the ARG string and identify the starting character position
185 of 'name', 'key', and 'value' and their lengths. */
186 for (ptr
= arg
; *ptr
; ++ptr
)
188 /* Only the first '-' encountered is considered a separator between
189 'name' and 'key'. All the subsequent '-'s are considered part of
190 'key'. For example, given -fplugin-arg-foo-bar-primary-key=value,
191 the plugin name is 'foo' and the key is 'bar-primary-key'. */
192 if (*ptr
== '-' && !name_parsed
)
200 else if (*ptr
== '=')
204 error ("Malformed option -fplugin-arg-%s (multiple '=' signs)",
210 value_start
= ptr
+ 1;
220 error ("Malformed option -fplugin-arg-%s (missing -<key>[=<value>])",
225 /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN.
226 Otherwise, it is the VALUE_LEN. */
232 name
= XNEWVEC (char, name_len
+ 1);
233 strncpy (name
, name_start
, name_len
);
234 name
[name_len
] = '\0';
236 /* Check if the named plugin has already been specified earlier in the
238 if (plugin_name_args_tab
239 && ((slot
= htab_find_slot (plugin_name_args_tab
, name
, NO_INSERT
))
242 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
244 key
= XNEWVEC (char, key_len
+ 1);
245 strncpy (key
, key_start
, key_len
);
249 value
= XNEWVEC (char, value_len
+ 1);
250 strncpy (value
, value_start
, value_len
);
251 value
[value_len
] = '\0';
256 /* Create a plugin_argument object for the parsed key-value pair.
257 If there are already arguments for this plugin, we will need to
258 adjust the argument array size by creating a new array and deleting
259 the old one. If the performance ever becomes an issue, we can
260 change the code by pre-allocating a larger array first. */
261 if (plugin
->argc
> 0)
263 struct plugin_argument
*args
= XNEWVEC (struct plugin_argument
,
265 memcpy (args
, plugin
->argv
,
266 sizeof (struct plugin_argument
) * plugin
->argc
);
267 XDELETEVEC (plugin
->argv
);
273 gcc_assert (plugin
->argv
== NULL
);
274 plugin
->argv
= XNEWVEC (struct plugin_argument
, 1);
278 plugin
->argv
[plugin
->argc
- 1].key
= key
;
279 plugin
->argv
[plugin
->argc
- 1].value
= value
;
282 error ("Plugin %s should be specified before -fplugin-arg-%s "
283 "in the command line", name
, arg
);
285 /* We don't need the plugin's name anymore. Just release it. */
290 /* Insert the plugin pass at the proper position. Return true if the pass
291 is successfully added.
293 PLUGIN_PASS_INFO - new pass to be inserted
294 PASS_LIST - root of the pass list to insert the new pass to */
297 position_pass (struct plugin_pass
*plugin_pass_info
,
298 struct opt_pass
**pass_list
)
300 struct opt_pass
*pass
= *pass_list
, *prev_pass
= NULL
;
301 bool success
= false;
303 for ( ; pass
; prev_pass
= pass
, pass
= pass
->next
)
305 /* Check if the current pass is of the same type as the new pass and
306 matches the name and the instance number of the reference pass. */
307 if (pass
->type
== plugin_pass_info
->pass
->type
309 && !strcmp (pass
->name
, plugin_pass_info
->reference_pass_name
)
310 && ((plugin_pass_info
->ref_pass_instance_number
== 0)
311 || (plugin_pass_info
->ref_pass_instance_number
==
312 pass
->static_pass_number
)
313 || (plugin_pass_info
->ref_pass_instance_number
== 1
314 && pass
->todo_flags_start
& TODO_mark_first_instance
)))
316 struct opt_pass
*new_pass
= plugin_pass_info
->pass
;
317 struct pass_list_node
*new_pass_node
;
319 /* The following code (if-statement) is adopted from next_pass_1. */
320 if (new_pass
->static_pass_number
)
322 new_pass
= XNEW (struct opt_pass
);
323 memcpy (new_pass
, plugin_pass_info
->pass
, sizeof (*new_pass
));
324 new_pass
->next
= NULL
;
326 new_pass
->todo_flags_start
&= ~TODO_mark_first_instance
;
328 plugin_pass_info
->pass
->static_pass_number
-= 1;
329 new_pass
->static_pass_number
=
330 -plugin_pass_info
->pass
->static_pass_number
;
334 new_pass
->todo_flags_start
|= TODO_mark_first_instance
;
335 new_pass
->static_pass_number
= -1;
338 /* Insert the new pass instance based on the positioning op. */
339 switch (plugin_pass_info
->pos_op
)
341 case PASS_POS_INSERT_AFTER
:
342 new_pass
->next
= pass
->next
;
343 pass
->next
= new_pass
;
345 /* Skip newly inserted pass to avoid repeated
346 insertions in the case where the new pass and the
347 existing one have the same name. */
350 case PASS_POS_INSERT_BEFORE
:
351 new_pass
->next
= pass
;
353 prev_pass
->next
= new_pass
;
355 *pass_list
= new_pass
;
357 case PASS_POS_REPLACE
:
358 new_pass
->next
= pass
->next
;
360 prev_pass
->next
= new_pass
;
362 *pass_list
= new_pass
;
363 new_pass
->sub
= pass
->sub
;
364 new_pass
->tv_id
= pass
->tv_id
;
368 error ("Invalid pass positioning operation");
372 /* Save the newly added pass (instance) in the added_pass_nodes
373 list so that we can register its dump file later. Note that
374 we cannot register the dump file now because doing so will modify
375 the static_pass_number of the opt_pass object and therefore
376 mess up the dump file name of future instances. */
377 new_pass_node
= XCNEW (struct pass_list_node
);
378 new_pass_node
->pass
= new_pass
;
379 if (!added_pass_nodes
)
380 added_pass_nodes
= new_pass_node
;
382 prev_added_pass_node
->next
= new_pass_node
;
383 prev_added_pass_node
= new_pass_node
;
388 if (pass
->sub
&& position_pass (plugin_pass_info
, &pass
->sub
))
396 /* Hook into the pass lists (trees) a new pass registered by a plugin.
398 PLUGIN_NAME - display name for the plugin
399 PASS_INFO - plugin pass information that specifies the opt_pass object,
400 reference pass, instance number, and how to position
404 register_pass (const char *plugin_name
, struct plugin_pass
*pass_info
)
406 if (!pass_info
->pass
)
408 error ("No pass specified when registering a new pass in plugin %s",
413 if (!pass_info
->reference_pass_name
)
415 error ("No reference pass specified for positioning the pass "
416 " from plugin %s", plugin_name
);
420 /* Try to insert the new pass to the pass lists. We need to check all
421 three lists as the reference pass could be in one (or all) of them. */
422 if (!position_pass (pass_info
, &all_lowering_passes
)
423 && !position_pass (pass_info
, &all_ipa_passes
)
424 && !position_pass (pass_info
, &all_passes
))
425 error ("Failed to position pass %s registered by plugin %s. "
426 "Cannot find the (specified instance of) reference pass %s",
427 pass_info
->pass
->name
, plugin_name
, pass_info
->reference_pass_name
);
430 /* OK, we have successfully inserted the new pass. We need to register
431 the dump files for the newly added pass and its duplicates (if any).
432 Because the registration of plugin passes happens after the
433 command-line options are parsed, the options that specify single
434 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
435 plugin passes. Therefore we currently can only enable dumping of
436 new plugin passes when the 'dump-all' flags (e.g. -fdump-tree-all)
437 are specified. While doing so, we also delete the pass_list_node
438 objects created during pass positioning. */
439 while (added_pass_nodes
)
441 struct pass_list_node
*next_node
= added_pass_nodes
->next
;
442 enum tree_dump_index tdi
;
443 register_one_dump_file (added_pass_nodes
->pass
);
444 if (added_pass_nodes
->pass
->type
== SIMPLE_IPA_PASS
445 || added_pass_nodes
->pass
->type
== IPA_PASS
)
447 else if (added_pass_nodes
->pass
->type
== GIMPLE_PASS
)
451 /* Check if dump-all flag is specified. */
452 if (get_dump_file_info (tdi
)->state
)
453 get_dump_file_info (added_pass_nodes
->pass
->static_pass_number
)
454 ->state
= get_dump_file_info (tdi
)->state
;
455 XDELETE (added_pass_nodes
);
456 added_pass_nodes
= next_node
;
462 /* Register additional plugin information. NAME is the name passed to
463 plugin_init. INFO is the information that should be registered. */
466 register_plugin_info (const char* name
, struct plugin_info
*info
)
468 void **slot
= htab_find_slot (plugin_name_args_tab
, name
, NO_INSERT
);
469 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
470 plugin
->version
= info
->version
;
471 plugin
->help
= info
->help
;
474 /* Called from the plugin's initialization code. Register a single callback.
475 This function can be called multiple times.
477 PLUGIN_NAME - display name for this plugin
478 EVENT - which event the callback is for
479 CALLBACK - the callback to be called at the event
480 USER_DATA - plugin-provided data */
483 register_callback (const char *plugin_name
,
484 enum plugin_event event
,
485 plugin_callback_func callback
,
490 case PLUGIN_PASS_MANAGER_SETUP
:
491 gcc_assert (!callback
);
492 register_pass (plugin_name
, (struct plugin_pass
*) user_data
);
495 gcc_assert (!callback
);
496 register_plugin_info (plugin_name
, (struct plugin_info
*) user_data
);
498 case PLUGIN_REGISTER_GGC_ROOTS
:
499 gcc_assert (!callback
);
500 ggc_register_root_tab ((const struct ggc_root_tab
*) user_data
);
502 case PLUGIN_FINISH_TYPE
:
503 case PLUGIN_START_UNIT
:
504 case PLUGIN_FINISH_UNIT
:
505 case PLUGIN_CXX_CP_PRE_GENERICIZE
:
506 case PLUGIN_GGC_START
:
507 case PLUGIN_GGC_MARKING
:
509 case PLUGIN_ATTRIBUTES
:
512 struct callback_info
*new_callback
;
515 error ("Plugin %s registered a null callback function "
516 "for event %s", plugin_name
, plugin_event_name
[event
]);
519 new_callback
= XNEW (struct callback_info
);
520 new_callback
->plugin_name
= plugin_name
;
521 new_callback
->func
= callback
;
522 new_callback
->user_data
= user_data
;
523 new_callback
->next
= plugin_callbacks
[event
];
524 plugin_callbacks
[event
] = new_callback
;
527 case PLUGIN_EVENT_LAST
:
529 error ("Unkown callback event registered by plugin %s",
535 /* Called from inside GCC. Invoke all plug-in callbacks registered with
538 EVENT - the event identifier
539 GCC_DATA - event-specific data provided by the compiler */
542 invoke_plugin_callbacks (enum plugin_event event
, void *gcc_data
)
544 timevar_push (TV_PLUGIN_RUN
);
548 case PLUGIN_FINISH_TYPE
:
549 case PLUGIN_START_UNIT
:
550 case PLUGIN_FINISH_UNIT
:
551 case PLUGIN_CXX_CP_PRE_GENERICIZE
:
552 case PLUGIN_ATTRIBUTES
:
554 case PLUGIN_GGC_START
:
555 case PLUGIN_GGC_MARKING
:
558 /* Iterate over every callback registered with this event and
560 struct callback_info
*callback
= plugin_callbacks
[event
];
561 for ( ; callback
; callback
= callback
->next
)
562 (*callback
->func
) (gcc_data
, callback
->user_data
);
566 case PLUGIN_PASS_MANAGER_SETUP
:
567 case PLUGIN_EVENT_LAST
:
568 case PLUGIN_REGISTER_GGC_ROOTS
:
573 timevar_pop (TV_PLUGIN_RUN
);
577 /* We need a union to cast dlsym return value to a function pointer
578 as ISO C forbids assignment between function pointer and 'void *'.
579 Use explicit union instead of __extension__(<union_cast>) for
581 #define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; }
582 #define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q)
583 #define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq)
585 /* Try to initialize PLUGIN. Return true if successful. */
588 try_init_one_plugin (struct plugin_name_args
*plugin
)
591 plugin_init_func plugin_init
;
593 PTR_UNION_TYPE (plugin_init_func
) plugin_init_union
;
595 /* We use RTLD_NOW to accelerate binding and detect any mismatch
596 between the API expected by the plugin and the GCC API; we use
597 RTLD_GLOBAL which is useful to plugins which themselves call
599 dl_handle
= dlopen (plugin
->full_name
, RTLD_NOW
| RTLD_GLOBAL
);
602 error ("Cannot load plugin %s\n%s", plugin
->full_name
, dlerror ());
606 /* Clear any existing error. */
609 /* Check the plugin license. */
610 if (dlsym (dl_handle
, str_license
) == NULL
)
611 fatal_error ("plugin %s is not licensed under a GPL-compatible license\n"
612 "%s", plugin
->full_name
, dlerror ());
614 PTR_UNION_AS_VOID_PTR (plugin_init_union
) =
615 dlsym (dl_handle
, str_plugin_init_func_name
);
616 plugin_init
= PTR_UNION_AS_CAST_PTR (plugin_init_union
);
618 if ((err
= dlerror ()) != NULL
)
620 error ("Cannot find %s in plugin %s\n%s", str_plugin_init_func_name
,
621 plugin
->full_name
, err
);
625 /* Call the plugin-provided initialization routine with the arguments. */
626 if ((*plugin_init
) (plugin
, &gcc_version
))
628 error ("Fail to initialize plugin %s", plugin
->full_name
);
636 /* Routine to dlopen and initialize one plugin. This function is passed to
637 (and called by) the hash table traverse routine. Return 1 for the
638 htab_traverse to continue scan, 0 to stop.
640 SLOT - slot of the hash table element
641 INFO - auxiliary pointer handed to hash table traverse routine
642 (unused in this function) */
645 init_one_plugin (void **slot
, void * ARG_UNUSED (info
))
647 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
648 bool ok
= try_init_one_plugin (plugin
);
651 htab_remove_elt (plugin_name_args_tab
, plugin
->base_name
);
657 #endif /* ENABLE_PLUGIN */
659 /* Main plugin initialization function. Called from compile_file() in
663 initialize_plugins (void)
665 /* If no plugin was specified in the command-line, simply return. */
666 if (!plugin_name_args_tab
)
669 timevar_push (TV_PLUGIN_INIT
);
672 /* Traverse and initialize each plugin specified in the command-line. */
673 htab_traverse_noresize (plugin_name_args_tab
, init_one_plugin
, NULL
);
676 timevar_pop (TV_PLUGIN_INIT
);
679 /* Release memory used by one plugin. */
682 finalize_one_plugin (void **slot
, void * ARG_UNUSED (info
))
684 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
689 /* Free memory allocated by the plugin system. */
692 finalize_plugins (void)
694 if (!plugin_name_args_tab
)
697 /* We can now delete the plugin_name_args object as it will no longer
698 be used. Note that base_name and argv fields (both of which were also
699 dynamically allocated) are not freed as they could still be used by
702 htab_traverse_noresize (plugin_name_args_tab
, finalize_one_plugin
, NULL
);
704 /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it. */
705 htab_delete (plugin_name_args_tab
);
706 plugin_name_args_tab
= NULL
;
709 /* Used to pass options to htab_traverse callbacks. */
717 /* Print the version of one plugin. */
720 print_version_one_plugin (void **slot
, void *data
)
722 struct print_options
*opt
= (struct print_options
*) data
;
723 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
724 const char *version
= plugin
->version
? plugin
->version
: "Unknown version.";
726 fprintf (opt
->file
, " %s%s: %s\n", opt
->indent
, plugin
->base_name
, version
);
730 /* Print the version of each plugin. */
733 print_plugins_versions (FILE *file
, const char *indent
)
735 struct print_options opt
;
738 if (!plugin_name_args_tab
|| htab_elements (plugin_name_args_tab
) == 0)
741 fprintf (file
, "%sVersions of loaded plugins:\n", indent
);
742 htab_traverse_noresize (plugin_name_args_tab
, print_version_one_plugin
, &opt
);
745 /* Print help for one plugin. SLOT is the hash table slot. DATA is the
746 argument to htab_traverse_noresize. */
749 print_help_one_plugin (void **slot
, void *data
)
751 struct print_options
*opt
= (struct print_options
*) data
;
752 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
753 const char *help
= plugin
->help
? plugin
->help
: "No help available .";
755 char *dup
= xstrdup (help
);
757 fprintf (opt
->file
, " %s%s:\n", opt
->indent
, plugin
->base_name
);
759 for (p
= nl
= dup
; nl
; p
= nl
)
761 nl
= strchr (nl
, '\n');
767 fprintf (opt
->file
, " %s %s\n", opt
->indent
, p
);
774 /* Print help for each plugin. The output goes to FILE and every line starts
778 print_plugins_help (FILE *file
, const char *indent
)
780 struct print_options opt
;
783 if (!plugin_name_args_tab
|| htab_elements (plugin_name_args_tab
) == 0)
786 fprintf (file
, "%sHelp for the loaded plugins:\n", indent
);
787 htab_traverse_noresize (plugin_name_args_tab
, print_help_one_plugin
, &opt
);
791 /* Return true if plugins have been loaded. */
794 plugins_active_p (void)
798 for (event
= PLUGIN_PASS_MANAGER_SETUP
; event
< PLUGIN_EVENT_LAST
; event
++)
799 if (plugin_callbacks
[event
])
806 /* Dump to FILE the names and associated events for all the active
810 dump_active_plugins (FILE *file
)
814 if (!plugins_active_p ())
817 fprintf (stderr
, "Event\t\t\tPlugins\n");
818 for (event
= PLUGIN_PASS_MANAGER_SETUP
; event
< PLUGIN_EVENT_LAST
; event
++)
819 if (plugin_callbacks
[event
])
821 struct callback_info
*ci
;
823 fprintf (file
, "%s\t", plugin_event_name
[event
]);
825 for (ci
= plugin_callbacks
[event
]; ci
; ci
= ci
->next
)
826 fprintf (file
, "%s ", ci
->plugin_name
);
828 fprintf (file
, "\n");
833 /* Dump active plugins to stderr. */
836 debug_active_plugins (void)
838 dump_active_plugins (stderr
);
841 /* The default version check. Compares every field in VERSION. */
844 plugin_default_version_check (struct plugin_gcc_version
*gcc_version
,
845 struct plugin_gcc_version
*plugin_version
)
847 if (!gcc_version
|| !plugin_version
)
850 if (strcmp (gcc_version
->basever
, plugin_version
->basever
))
852 if (strcmp (gcc_version
->datestamp
, plugin_version
->datestamp
))
854 if (strcmp (gcc_version
->devphase
, plugin_version
->devphase
))
856 if (strcmp (gcc_version
->revision
, plugin_version
->revision
))
858 if (strcmp (gcc_version
->configuration_arguments
,
859 plugin_version
->configuration_arguments
))