[binutils-gdb] gdb/ada-lang.c: one malloc -> unique_ptr<[]>

[Pedro Alves <palves at sourceware dot org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=200069c74f42ffcc726b9995a46971a86286a256

commit 200069c74f42ffcc726b9995a46971a86286a256
Author: Pedro Alves <palves@redhat.com>
Date:   Wed Nov 16 11:38:49 2016 +0000

    gdb/ada-lang.c: one malloc -> unique_ptr<[]>
    
    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  <palves@redhat.com>
    
    	* ada-lang.c (ada_value_primitive_packed_val): Use unique_ptr and
    	new gdb_byte[] instead of malloc and cleanups.

Diff:
---
 gdb/ChangeLog  |  5 +++++
 gdb/ada-lang.c | 14 +++++---------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index cc83ac6..c4dccb8 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2016-11-16  Pedro Alves  <palves@redhat.com>
+
+	* 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  <palves@redhat.com>
 
 	* tracepoint.c (collection_list::add_memrange): Add gdbarch
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 73f7964..0647a9b 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<gdb_byte[]> 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;
 }