[RFC v5 04/18] gdb: introduce new function create_function_type

[Jan Vrany <jan.vrany@labware.com>]

While working on new Python API to create new function types I realized
that there's no easy way to create a new function type and control where
it is going to be allocated (whether in gdbarch's obstack pr objfile's).
Functions lookup_function_type and lookup_function_type_with_arguments
always allocate at the same obstack as its return type.

This is not sufficient for the new Python API - the user may use any
type it can get hold of. For example, one may want to create a function
returning arch-owned type and taking one argument of objfile-owned type.
In that case we need to allocate the new type on that very objfile's
obstack.

This commit introduces new function - create_function_type - that takes
type_allocator as first parameter, allowing caller to control the
allocation. Existing functions (lookup_function_type and
lookup_function_type_with_arguments) are reimplemented by means of new
create_function_type.
---
 gdb/gdbtypes.c | 47 +++++++++++++++++++++++++++++------------------
 gdb/gdbtypes.h | 24 +++++++++++++++++++-----
 2 files changed, 48 insertions(+), 23 deletions(-)

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 9c57f30a1dd..591a3cc4323 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -561,27 +561,19 @@ make_function_type (struct type *type, struct type **typeptr)
   return ntype;
 }
 
-/* Given a type TYPE, return a type of functions that return that type.
-   May need to construct such a type if this is the first use.  */
-
-struct type *
-lookup_function_type (struct type *type)
-{
-  return make_function_type (type, (struct type **) 0);
-}
-
-/* Given a type TYPE and argument types, return the appropriate
-   function type.  If the final type in PARAM_TYPES is NULL, make a
-   varargs function.  */
+/* See gdbtypes.h.  */
 
 struct type *
-lookup_function_type_with_arguments (struct type *type,
-				     int nparams,
-				     struct type **param_types)
+create_function_type (type_allocator &alloc,
+		     struct type *return_type,
+		     int nparams,
+		     struct type **param_types)
 {
-  struct type *fn = make_function_type (type, (struct type **) 0);
+  struct type *fn = alloc.new_type ();
   int i;
 
+  make_function_type (return_type, &fn);
+
   if (nparams > 0)
     {
       if (param_types[nparams - 1] == NULL)
@@ -589,8 +581,7 @@ lookup_function_type_with_arguments (struct type *type,
 	  --nparams;
 	  fn->set_has_varargs (true);
 	}
-      else if (check_typedef (param_types[nparams - 1])->code ()
-	       == TYPE_CODE_VOID)
+      else if ((param_types[nparams - 1])->is_void ())
 	{
 	  --nparams;
 	  /* Caller should have ensured this.  */
@@ -608,6 +599,26 @@ lookup_function_type_with_arguments (struct type *type,
   return fn;
 }
 
+/* See gdbtypes.h.  */
+
+struct type *
+lookup_function_type (struct type *return_type)
+{
+  type_allocator alloc (return_type);
+  return create_function_type (alloc, return_type, 0, nullptr);
+}
+
+/* See gdbtypes.h.  */
+
+struct type *
+lookup_function_type_with_arguments (struct type *return_type,
+				     int nparams,
+				     struct type **param_types)
+{
+  type_allocator alloc (return_type);
+  return create_function_type (alloc, return_type, nparams, param_types);
+}
+
 /* Identify address space identifier by name -- return a
    type_instance_flags.  */
 
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 9e2efe99cff..ba216c6db54 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -2526,11 +2526,25 @@ extern struct type *lookup_pointer_type (struct type *);
 
 extern struct type *make_function_type (struct type *, struct type **);
 
-extern struct type *lookup_function_type (struct type *);
-
-extern struct type *lookup_function_type_with_arguments (struct type *,
-							 int,
-							 struct type **);
+/* Given a return type and argument types, create new function type.
+   If the final type in PARAM_TYPES is NULL, create a varargs function.
+   New type is allocated using ALLOC.  */
+extern struct type *create_function_type (type_allocator &alloc,
+					  struct type *return_type,
+					  int nparams,
+					  struct type **param_types);
+
+/* Like create_function_type, but allocate the new function type at
+   the same obstack as RETURN_TYPE and with unspecified number of
+   parameters and their types.  */
+extern struct type *lookup_function_type (struct type *return_type);
+
+/* Like create_function_type, but allocate the new function type at
+   the same obstack as RETURN_TYPE.  */
+extern struct type *lookup_function_type_with_arguments
+					(struct type *return_type,
+					 int nparams,
+					 struct type **param_types);
 
 /* Create a range type using ALLOC.
 
-- 
2.47.2