FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove some manual memory management from compile interface

Browse source 
This changes gdb's compile code to use std::vector in a couple of
places, rather than manual memory management.

gdb/ChangeLog
2020-09-23  Tom Tromey  <tom@tromey.com>

	* compile/compile-cplus-types.c
	(compile_cplus_convert_struct_or_union): Use std::vector.
	(compile_cplus_convert_func): Likewise.
	* compile/compile-c-types.c (convert_func): Use std::vector.
This commit is contained in:
Tom Tromey 2020-09-23 09:32:54 -06:00
parent c4694f172b
commit ebe824f5dc
3 changed files with 25 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

7
gdb/ChangeLog
View file

@ -1,3 +1,10 @@
2020-09-23 Tom Tromey <tom@tromey.com>
* compile/compile-cplus-types.c
(compile_cplus_convert_struct_or_union): Use std::vector.
(compile_cplus_convert_func): Likewise.
* compile/compile-c-types.c (convert_func): Use std::vector.
2020-09-21 Tom Tromey <tromey@adacore.com>
* sparc-tdep.c (sparc32_skip_prologue): Use

4
gdb/compile/compile-c-types.c
View file

@ -176,13 +176,13 @@ convert_func (compile_c_instance *context, struct type *type)
return_type = context->convert_type (target_type);
array.n_elements = type->num_fields ();
array.elements = XNEWVEC (gcc_type, type->num_fields ());
std::vector<gcc_type> elements (array.n_elements);
array.elements = elements.data ();
for (i = 0; i < type->num_fields (); ++i)
array.elements[i] = context->convert_type (type->field (i).type ());
result = context->plugin ().build_function_type (return_type,
&array, is_varargs);
xfree (array.elements);
return result;
}

37
gdb/compile/compile-cplus-types.c
View file

@ -848,33 +848,29 @@ compile_cplus_convert_struct_or_union (compile_cplus_instance *instance,
gcc_type result;
if (type->code () == TYPE_CODE_STRUCT)
{
struct gcc_vbase_array bases;
int num_baseclasses = TYPE_N_BASECLASSES (type);
std::vector<gcc_type> elements (num_baseclasses);
std::vector<enum gcc_cp_symbol_kind> flags (num_baseclasses);
memset (&bases, 0, sizeof (bases));
struct gcc_vbase_array bases {};
bases.elements = elements.data ();
bases.flags = flags.data ();
bases.n_elements = num_baseclasses;
if (num_baseclasses > 0)
for (int i = 0; i < num_baseclasses; ++i)
{
bases.elements = XNEWVEC (gcc_type, num_baseclasses);
bases.flags = XNEWVEC (enum gcc_cp_symbol_kind, num_baseclasses);
bases.n_elements = num_baseclasses;
for (int i = 0; i < num_baseclasses; ++i)
{
struct type *base_type = TYPE_BASECLASS (type, i);
struct type *base_type = TYPE_BASECLASS (type, i);
bases.flags[i] = GCC_CP_SYMBOL_BASECLASS
| get_field_access_flag (type, i)
| (BASETYPE_VIA_VIRTUAL (type, i)
? GCC_CP_FLAG_BASECLASS_VIRTUAL
: GCC_CP_FLAG_BASECLASS_NOFLAG);
bases.elements[i] = instance->convert_type (base_type);
}
bases.flags[i] = (GCC_CP_SYMBOL_BASECLASS
| get_field_access_flag (type, i)
| (BASETYPE_VIA_VIRTUAL (type, i)
? GCC_CP_FLAG_BASECLASS_VIRTUAL
: GCC_CP_FLAG_BASECLASS_NOFLAG));
bases.elements[i] = instance->convert_type (base_type);
}
result = instance->plugin ().start_class_type
(name.get (), resuld, &bases, filename, line);
xfree (bases.flags);
xfree (bases.elements);
}
else
{
@ -985,8 +981,8 @@ compile_cplus_convert_func (compile_cplus_instance *instance,
types. Those are impossible in C, though. */
gcc_type return_type = instance->convert_type (target_type);
struct gcc_type_array array =
{ type->num_fields (), XNEWVEC (gcc_type, type->num_fields ()) };
std::vector<gcc_type> elements (type->num_fields ());
struct gcc_type_array array = { type->num_fields (), elements.data () };
int artificials = 0;
for (int i = 0; i < type->num_fields (); ++i)
{
@ -1006,7 +1002,6 @@ compile_cplus_convert_func (compile_cplus_instance *instance,
with some minsyms like printf (compile-cplus.exp has examples). */
gcc_type result = instance->plugin ().build_function_type
(return_type, &array, is_varargs);
xfree (array.elements);
return result;
}