From 200069c74f42ffcc726b9995a46971a86286a256 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Wed, 16 Nov 2016 11:38:49 +0000 Subject: [PATCH] gdb/ada-lang.c: one malloc -> unique_ptr<[]> MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Switching gdb to use gnulib's C++ namespace mode reveals we're calling malloc instead of xmalloc here: ..../src/gdb/ada-lang.c: In function ‘value* ada_value_primitive_packed_val(value*, const gdb_byte*, long int, int, int, type*)’: ..../src/gdb/ada-lang.c:2592:50: error: call to ‘malloc’ declared with attribute warning: The symbol ::malloc refers to the system function. Use gnulib::malloc instead. [-Werror] staging = (gdb_byte *) malloc (staging_len); ^ We're unconditionaly using the result afterwards -- so it's not a case of gracefully handling huge allocations. Since we want to get rid of all cleanups, fix this by switching to new[] and unique_ptr<[]> instead, while at it. Regtested on Fedora 23. gdb/ChangeLog: 2016-11-16 Pedro Alves * ada-lang.c (ada_value_primitive_packed_val): Use unique_ptr and new gdb_byte[] instead of malloc and cleanups. --- gdb/ChangeLog | 5 +++++ gdb/ada-lang.c | 14 +++++--------- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index cc83ac6a59e..c4dccb8b488 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,8 @@ +2016-11-16 Pedro Alves + + * ada-lang.c (ada_value_primitive_packed_val): Use unique_ptr and + new gdb_byte[] instead of malloc and cleanups. + 2016-11-17 Pedro Alves * tracepoint.c (collection_list::add_memrange): Add gdbarch diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 73f7964ddf9..0647a9b9fe0 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -2568,9 +2568,8 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr, gdb_byte *unpacked; const int is_scalar = is_scalar_type (type); const int is_big_endian = gdbarch_bits_big_endian (get_type_arch (type)); - gdb_byte *staging = NULL; + std::unique_ptr staging; int staging_len = 0; - struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); type = ada_check_typedef (type); @@ -2589,14 +2588,13 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr, we do, is unpack the data into a byte-aligned buffer, and then use that buffer as our object's value for resolving the type. */ staging_len = (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; - staging = (gdb_byte *) malloc (staging_len); - make_cleanup (xfree, staging); + staging.reset (new gdb_byte[staging_len]); ada_unpack_from_contents (src, bit_offset, bit_size, - staging, staging_len, + staging.get (), staging_len, is_big_endian, has_negatives (type), is_scalar); - type = resolve_dynamic_type (type, staging, 0); + type = resolve_dynamic_type (type, staging.get (), 0); if (TYPE_LENGTH (type) < (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT) { /* This happens when the length of the object is dynamic, @@ -2656,7 +2654,6 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr, if (bit_size == 0) { memset (unpacked, 0, TYPE_LENGTH (type)); - do_cleanups (old_chain); return v; } @@ -2665,14 +2662,13 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr, /* Small short-cut: If we've unpacked the data into a buffer of the same size as TYPE's length, then we can reuse that, instead of doing the unpacking again. */ - memcpy (unpacked, staging, staging_len); + memcpy (unpacked, staging.get (), staging_len); } else ada_unpack_from_contents (src, bit_offset, bit_size, unpacked, TYPE_LENGTH (type), is_big_endian, has_negatives (type), is_scalar); - do_cleanups (old_chain); return v; } -- 2.30.2