diff options
Diffstat (limited to 'gdb/compile/compile-cplus-templates.h')
| -rw-r--r-- | gdb/compile/compile-cplus-templates.h | 319 |
1 files changed, 319 insertions, 0 deletions
diff --git a/gdb/compile/compile-cplus-templates.h b/gdb/compile/compile-cplus-templates.h new file mode 100644 index 0000000..56290b4 --- /dev/null +++ b/gdb/compile/compile-cplus-templates.h @@ -0,0 +1,319 @@ +/* Template support for compile. + + Copyright (C) 2016, 2017 Free Software Foundation, Inc. + + This file is part of GDB. + + 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/>. */ + +#ifndef COMPILE_CPLUS_TEMPLATES_H +#define COMPILE_CPLUS_TEMPLATES_H +#include "gdbtypes.h" +#include "cp-support.h" + +#include <string> +#include <vector> +#include <unordered_map> +#include <memory> + +struct symbol; +struct gcc_cp_template_args; +struct template_symbol; + +namespace compile +{ + class function_template_defn; + class class_template_defn; + class compile_cplus_instance; + + /* Types used for tracking template definitions. */ + typedef std::unique_ptr<function_template_defn> function_template_defn_up; + typedef std::unique_ptr<class_template_defn> class_template_defn_up; + typedef std::pair<std::string, function_template_defn_up> + function_template_map_item_t; + typedef std::unordered_map<std::string, function_template_defn_up> + function_template_defn_map_t; + typedef std::pair<std::string, class_template_defn_up> + class_template_map_item_t; + typedef std::unordered_map<std::string, class_template_defn_up> + class_template_defn_map_t; + + /* A base class holding data common to all template definitions. */ + + class template_defn + { + public: + + /* Return the declaration name of this definition. */ + + const char * + decl_name () const + { + return m_decl_name.c_str (); + } + + /* Return the compiler plug-in's decl for this definition. */ + + gcc_decl + decl () const + { + return m_decl; + } + + /* Set the compiler plug-in's decl for this definition. */ + + void + set_decl (gcc_decl decl) + { + m_decl = decl; + } + + /* Return the generic string for this template definition. */ + + const std::string + generic (void) const + { + return m_generic; + } + + /* Return the compiler plug-in's abstract type for the IDX'th + template parameter. */ + + gcc_type + parameter_abstract_type (unsigned int idx) const + { + return m_abstract_types[idx]; + } + + /* Set the IDX'th template parameter's abstract type. */ + + void + set_parameter_abstract_type (unsigned int idx, gcc_type type) + { + m_abstract_types[idx] = type; + } + + /* Has this template already been defined in the compiler plug-in? */ + + bool + defined (void) const + { + return m_defined; + } + + /* Mark this definition as defined in the compiler plug-in. */ + + void + set_defined (bool val) + { + m_defined = val; + } + + /* Return the ARG_NUM'th template parameter's default value + or NULL if none was set (or known). */ + + struct symbol * + default_argument (unsigned int arg_num) const + { + return m_default_arguments[arg_num]; + } + + /* Record the value of the ARG_NUM'th template parameter. */ + + void + set_default_argument (unsigned int arg_num, struct symbol *value) + { + m_default_arguments[arg_num] = value; + } + + protected: + + /* Protected constructor so that no one instantiates this + type directly. + + DECL_NAME is the declaration name of this template, i.e., it's + name with no template parameters. GENERIC is the computed generic + template definition. N_PARAMETERS specifies how many template + parameters this template has. */ + + template_defn (std::string decl_name, std::string generic, + unsigned int n_parameters) + : m_decl_name (decl_name), m_generic (generic), + m_abstract_types (n_parameters), m_decl (0), + m_default_arguments (n_parameters), m_defined (false) + { + } + + private: + + /* The declaration name of the template, excluding any + parameters. */ + std::string m_decl_name; + + /* A string representation of the generic template definition. */ + std::string m_generic; + + /* The abstract template parameter types. */ + std::vector<gcc_type> m_abstract_types; + + /* The decl associated with this template definition. */ + gcc_decl m_decl; + + /* A list of default values for the parameters of this template. */ + std::vector<struct symbol *> m_default_arguments; + + /* Has this template already been defined? This is a necessary evil + since we have to traverse over all hash table entries. */ + bool m_defined; + }; + + /* A function template definition. */ + + class function_template_defn + : public template_defn + { + public: + + /* Construct a new function template definition with the generic + string representation GENERIC and demangle INFO, based on the + concrete instance given by template symbol TSYMBOL. + + If this definition is a method template, PARENT_TYPE is the type + of the closing class and FIDX and MIDX are the fieldlist and + method indices, respectively, which describe this method. + + If this definition is not a method template, PARENT_TYPE is NULL + and FIDX/MIDX are both -1. */ + + function_template_defn (std::string generic, + std::unique_ptr<demangle_parse_info> info, + const struct template_symbol *tsymbol, + struct type *parent_type, int fidx, int midx); + + /* Return the demangle information for this template. */ + + const demangle_parse_info *demangle_info (void) const + { + return m_demangle_info.get (); + } + + /* Return the concrete instance used to define this template. */ + + const struct template_symbol *template_symbol (void) const + { + return m_tsymbol; + } + + /* For method templates, return the type of the enclosing parent type, + or NULL for non-method templates. */ + + struct type *parent_type (void) const + { + return m_parent_type; + } + + /* For method templates, return the field list index in PARENT_TYPE + which describes this method. Return -1 otherwise. */ + + int fidx (void) const + { + return m_fidx; + } + + /* For method templates, return the index of this method into the + field list (given by fidx()). Return -1 otherwise. */ + + int midx (void) const + { + return m_midx; + } + + private: + + /* The template symbol used to create this template definition. + NOTE: Any given template_defn could be associated with any number + of template instances in the program. + + This field is not const since we will be lazily computing template + parameter indices for the function's argument and return types. */ + + const struct template_symbol *m_tsymbol; + + /* The parent type or NULL if this does not represent a method. */ + + struct type *m_parent_type; + + /* The fieldlist and method indices for the method or -1 if this template + definition does not represent a method. */ + + int m_fidx; + int m_midx; + + /* Demangle tree for the template defining this generic. */ + std::unique_ptr<demangle_parse_info> m_demangle_info; + }; + + /* A class template definition. */ + + class class_template_defn + : public template_defn + { + public: + + /* A unary function to delete map items. */ + + static void destroy (class_template_map_item_t p); + + /* Construct a new class template definition with the generic + string representation GENERIC based on the concrete instance + TYPE. */ + + class_template_defn (std::string decl_name, std::string generic, + struct type *type) + : template_defn (decl_name, generic, TYPE_N_TEMPLATE_ARGUMENTS (type)), + m_type (type) + { + } + + /* Return concrete instance that this template definition was + based on. */ + + struct type *type (void) const + { + return m_type; + } + + private: + + /* The type used to create this template definition. + NOTE: Any given template_defn could be associated with any number + of template instances in the program. */ + struct type *m_type; + }; + + /* Loop over SYMBOLS, defining any generic template definitions for + any template symbols in the list. */ + + void define_templates (compile_cplus_instance *instance, + VEC (block_symbol_d) *symbols); + + + /* Scan TYPE for any new function templates. + Does not actually emit definitions for any new templates until + emit_function_template_decls is called. */ + + void scan_type_for_function_templates (compile_cplus_instance *instance, + struct type *type); +}; +#endif /* COMPILE_CPLUS_TEMPLATES_H */ |