gdb: Use C++17's std::make_unique instead of gdb::make_unique

gdb::make_unique is a wrapper around std::make_unique when compiled with
C++17.  Now that C++17 is required, use std::make_unique directly in the
codebase, and remove gdb::make_unique.

Change-Id: I80b615e46e4b7c097f09d78e579a9bdce00254ab
Approved-By: Tom Tromey <tom@tromey.com>
Approved-By: Pedro Alves <pedro@palves.net

gdb/addrmap.c

@@ -428,7 +428,7 @@ test_addrmap ()
 
   /* Create mutable addrmap.  */
   auto_obstack temp_obstack;
-  auto map = gdb::make_unique<struct addrmap_mutable> ();
+  auto map = std::make_unique<struct addrmap_mutable> ();
   SELF_CHECK (map != nullptr);
 
   /* Check initial state.  */

gdb/break-catch-load.c

@@ -230,7 +230,7 @@ add_solib_catchpoint (const char *arg, bool is_load, bool is_temp, bool enabled)
   if (*arg == '\0')
     arg = nullptr;
 
-  auto c = gdb::make_unique<solib_catchpoint> (gdbarch, is_temp, nullptr,
+  auto c = std::make_unique<solib_catchpoint> (gdbarch, is_temp, nullptr,
 					       is_load, arg);
 
   c->enable_state = enabled ? bp_enabled : bp_disabled;

gdb/compile/compile-c-support.c

@@ -118,7 +118,7 @@ get_compile_context (const char *fe_libcc, const char *fe_context,
     error (_("The loaded version of GCC does not support the required version "
 	     "of the API."));
 
-  return gdb::make_unique<INSTTYPE> (context);
+  return std::make_unique<INSTTYPE> (context);
 }
 
 /* A C-language implementation of get_compile_context.  */

gdb/cp-name-parser.y

@@ -2038,7 +2038,7 @@ cp_demangled_name_to_comp (const char *demangled_name,
 
   state.demangle_info = allocate_info ();
 
-  auto result = gdb::make_unique<demangle_parse_info> ();
+  auto result = std::make_unique<demangle_parse_info> ();
   result->info = state.demangle_info;
 
   if (yyparse (&state))

gdb/cp-support.c

@@ -675,7 +675,7 @@ mangled_name_to_comp (const char *mangled_name, int options,
 					      options, memory);
       if (ret)
 	{
-	  auto info = gdb::make_unique<demangle_parse_info> ();
+	  auto info = std::make_unique<demangle_parse_info> ();
 	  info->tree = ret;
 	  *demangled_p = NULL;
 	  return info;

gdb/dwarf2/frame.c

@@ -2126,7 +2126,7 @@ dwarf2_build_frame_info (struct objfile *objfile)
   struct gdbarch *gdbarch = objfile->arch ();
 
   /* Build a minimal decoding of the DWARF2 compilation unit.  */
-  auto unit = gdb::make_unique<comp_unit> (objfile);
+  auto unit = std::make_unique<comp_unit> (objfile);
 
   if (objfile->separate_debug_objfile_backlink == NULL)
     {

gdb/dwarf2/read-debug-names.c

@@ -464,7 +464,7 @@ create_cus_from_debug_names (dwarf2_per_bfd *per_bfd,
 bool
 dwarf2_read_debug_names (dwarf2_per_objfile *per_objfile)
 {
-  auto map = gdb::make_unique<mapped_debug_names> ();
+  auto map = std::make_unique<mapped_debug_names> ();
   mapped_debug_names dwz_map;
   struct objfile *objfile = per_objfile->objfile;
   dwarf2_per_bfd *per_bfd = per_objfile->per_bfd;

gdb/dwarf2/read-gdb-index.c

@@ -828,7 +828,7 @@ dwarf2_read_gdb_index
   if (main_index_contents.empty ())
     return 0;
 
-  auto map = gdb::make_unique<mapped_gdb_index> ();
+  auto map = std::make_unique<mapped_gdb_index> ();
   if (!read_gdb_index_from_buffer (objfile_name (objfile),
 				   use_deprecated_index_sections,
 				   main_index_contents, map.get (), &cu_list,

gdb/dwarf2/read.c

@@ -4372,7 +4372,7 @@ allocate_type_unit_groups_table ()
 static std::unique_ptr<type_unit_group>
 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
 {
-  auto tu_group = gdb::make_unique<type_unit_group> ();
+  auto tu_group = std::make_unique<type_unit_group> ();
 
   tu_group->hash.dwo_unit = cu->dwo_unit;
   tu_group->hash.line_sect_off = line_offset_struct;

gdb/gdb_bfd.c

@@ -303,7 +303,7 @@ gdb_bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size,
 				 const char *target)
 {
   std::unique_ptr<target_buffer> buffer
-    = gdb::make_unique<target_buffer> (addr, size);
+    = std::make_unique<target_buffer> (addr, size);
 
   return gdb_bfd_openr_iovec (buffer->filename (), target,
 			      [&] (bfd *nbfd)

gdb/gdbtypes.c

@@ -5833,7 +5833,7 @@ static const struct registry<objfile>::key<fixed_point_type_storage>
 void
 allocate_fixed_point_type_info (struct type *type)
 {
-  auto up = gdb::make_unique<fixed_point_type_info> ();
+  auto up = std::make_unique<fixed_point_type_info> ();
   fixed_point_type_info *info;
 
   if (type->is_objfile_owned ())

gdb/mi/mi-main.c

@@ -1932,7 +1932,7 @@ mi_execute_command (const char *cmd, int from_tty)
     = gdb::checked_static_cast<mi_interp *> (command_interp ());
   try
     {
-      command = gdb::make_unique<mi_parse> (cmd, &token);
+      command = std::make_unique<mi_parse> (cmd, &token);
     }
   catch (const gdb_exception &exception)
     {

gdb/mi/mi-out.c

@@ -340,13 +340,13 @@ std::unique_ptr<mi_ui_out>
 mi_out_new (const char *mi_version)
 {
   if (streq (mi_version, INTERP_MI4) ||  streq (mi_version, INTERP_MI))
-    return gdb::make_unique<mi_ui_out> (4);
+    return std::make_unique<mi_ui_out> (4);
 
   if (streq (mi_version, INTERP_MI3))
-    return gdb::make_unique<mi_ui_out> (3);
+    return std::make_unique<mi_ui_out> (3);
 
   if (streq (mi_version, INTERP_MI2))
-    return gdb::make_unique<mi_ui_out> (2);
+    return std::make_unique<mi_ui_out> (2);
 
   return nullptr;
 }

gdb/nat/linux-btrace.c

@@ -468,7 +468,7 @@ linux_enable_bts (ptid_t ptid, const struct btrace_config_bts *conf)
     error (_("BTS support has been disabled for the target cpu."));
 
   std::unique_ptr<linux_btrace_target_info> tinfo
-    { gdb::make_unique<linux_btrace_target_info> (ptid) };
+    { std::make_unique<linux_btrace_target_info> (ptid) };
 
   tinfo->conf.format = BTRACE_FORMAT_BTS;
 
@@ -617,7 +617,7 @@ linux_enable_pt (ptid_t ptid, const struct btrace_config_pt *conf)
     pid = ptid.pid ();
 
   std::unique_ptr<linux_btrace_target_info> tinfo
-    { gdb::make_unique<linux_btrace_target_info> (ptid) };
+    { std::make_unique<linux_btrace_target_info> (ptid) };
 
   tinfo->conf.format = BTRACE_FORMAT_PT;
 

gdb/python/py-mi.c

@@ -290,7 +290,7 @@ gdbpy_execute_mi_command (PyObject *self, PyObject *args, PyObject *kw)
   try
     {
       scoped_restore save_uiout = make_scoped_restore (&current_uiout, &uiout);
-      auto parser = gdb::make_unique<mi_parse> (std::move (mi_command),
+      auto parser = std::make_unique<mi_parse> (std::move (mi_command),
 						std::move (arg_strings));
       mi_execute_command (parser.get ());
     }

gdb/python/py-varobj.c

@@ -170,5 +170,5 @@ py_varobj_get_iterator (struct varobj *var, PyObject *printer,
       error (_("Could not get children iterator"));
     }
 
-  return gdb::make_unique<py_varobj_iter> (var, std::move (iter), opts);
+  return std::make_unique<py_varobj_iter> (var, std::move (iter), opts);
 }

gdb/solib-aix.c

@@ -484,7 +484,7 @@ solib_aix_current_sos ()
 
       new_solib->so_original_name = so_name;
       new_solib->so_name = so_name;
-      new_solib->lm_info = gdb::make_unique<lm_info_aix> (info);
+      new_solib->lm_info = std::make_unique<lm_info_aix> (info);
 
       /* Add it to the list.  */
       sos.push_back (*new_solib);

gdb/solib-darwin.c

@@ -274,7 +274,7 @@ darwin_current_sos ()
       /* Create and fill the new struct shobj element.  */
       shobj *newobj = new shobj;
 
-      auto li = gdb::make_unique<lm_info_darwin> ();
+      auto li = std::make_unique<lm_info_darwin> ();
 
       newobj->so_name = file_path.get ();
       newobj->so_original_name = newobj->so_name;

gdb/solib-dsbt.c

@@ -594,7 +594,7 @@ dsbt_current_sos (void)
 	    }
 
 	  shobj *sop = new shobj;
-	  auto li = gdb::make_unique<lm_info_dsbt> ();
+	  auto li = std::make_unique<lm_info_dsbt> ();
 	  li->map = loadmap;
 	  /* Fetch the name.  */
 	  addr = extract_unsigned_integer (lm_buf.l_name,

gdb/solib-frv.c

@@ -377,7 +377,7 @@ frv_current_sos ()
 	    }
 
 	  shobj *sop = new shobj;
-	  auto li = gdb::make_unique<lm_info_frv> ();
+	  auto li = std::make_unique<lm_info_frv> ();
 	  li->map = loadmap;
 	  li->got_value = got_addr;
 	  li->lm_addr = lm_addr;

gdb/solib-rocm.c

@@ -212,7 +212,7 @@ so_list_from_rocm_sos (const std::vector<rocm_so> &sos)
   for (const rocm_so &so : sos)
     {
       struct shobj *newobj = new struct shobj;
-      newobj->lm_info = gdb::make_unique<lm_info_svr4> (*so.lm_info);
+      newobj->lm_info = std::make_unique<lm_info_svr4> (*so.lm_info);
 
       newobj->so_name = so.name;
       newobj->so_original_name = so.unique_name;
@@ -725,7 +725,7 @@ rocm_update_solib_list ()
 
       gdb::unique_xmalloc_ptr<char> uri_bytes_holder (uri_bytes);
 
-      lm_info_svr4_up li = gdb::make_unique<lm_info_svr4> ();
+      lm_info_svr4_up li = std::make_unique<lm_info_svr4> ();
       li->l_addr = l_addr;
 
       /* Generate a unique name so that code objects with the same URI but

gdb/solib-svr4.c

@@ -213,7 +213,7 @@ lm_info_read (CORE_ADDR lm_addr)
       type *ptr_type
 	= builtin_type (current_inferior ()->arch ())->builtin_data_ptr;
 
-      lm_info = gdb::make_unique<lm_info_svr4> ();
+      lm_info = std::make_unique<lm_info_svr4> ();
       lm_info->lm_addr = lm_addr;
 
       lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset],
@@ -1001,7 +1001,7 @@ so_list_from_svr4_sos (const std::vector<svr4_so> &sos)
 
       newobj->so_name = so.name;
       newobj->so_original_name = so.name;
-      newobj->lm_info = gdb::make_unique<lm_info_svr4> (*so.lm_info);
+      newobj->lm_info = std::make_unique<lm_info_svr4> (*so.lm_info);
 
       dst.push_back (*newobj);
     }
@@ -1032,7 +1032,7 @@ library_list_start_library (struct gdb_xml_parser *parser,
   ULONGEST *l_ldp
     = (ULONGEST *) xml_find_attribute (attributes, "l_ld")->value.get ();
 
-  lm_info_svr4_up li = gdb::make_unique<lm_info_svr4> ();
+  lm_info_svr4_up li = std::make_unique<lm_info_svr4> ();
   li->lm_addr = *lmp;
   li->l_addr_inferior = *l_addrp;
   li->l_ld = *l_ldp;
@@ -1190,7 +1190,7 @@ svr4_default_sos (svr4_info *info)
     return {};
 
   shobj *newobj = new shobj;
-  auto li = gdb::make_unique<lm_info_svr4> ();
+  auto li = std::make_unique<lm_info_svr4> ();
 
   /* Nothing will ever check the other fields if we set l_addr_p.  */
   li->l_addr = li->l_addr_inferior = info->debug_loader_offset;

gdb/ui-out.c

@@ -236,7 +236,7 @@ void ui_out_table::append_header (int width, ui_align alignment,
     internal_error (_("table header must be specified after table_begin and "
 		      "before table_body."));
 
-  auto header = gdb::make_unique<ui_out_hdr> (m_headers.size () + 1,
+  auto header = std::make_unique<ui_out_hdr> (m_headers.size () + 1,
 					      width, alignment,
 					      col_name, col_hdr);
 
@@ -328,7 +328,7 @@ ui_out::current_level () const
 void
 ui_out::push_level (ui_out_type type)
 {
-  auto level = gdb::make_unique<ui_out_level> (type);
+  auto level = std::make_unique<ui_out_level> (type);
 
   m_levels.push_back (std::move (level));
 }

gdb/unittests/parallel-for-selftests.c

@@ -160,7 +160,7 @@ TEST (int n_threads)
 	      {
 		if (start == end)
 		  any_empty_tasks = true;
-		return gdb::make_unique<int> (end - start);
+		return std::make_unique<int> (end - start);
 	      });
   SELF_CHECK (!any_empty_tasks);
   SELF_CHECK (std::all_of (intresults.begin (),
@@ -178,7 +178,7 @@ TEST (int n_threads)
 	      {
 		if (start == end)
 		  any_empty_tasks = true;
-		return gdb::make_unique<int> (end - start);
+		return std::make_unique<int> (end - start);
 	      },
 	    task_size_one);
   SELF_CHECK (!any_empty_tasks);

gdb/varobj.c

@@ -259,7 +259,7 @@ varobj_create (const char *objname,
 	       const char *expression, CORE_ADDR frame, enum varobj_type type)
 {
   /* Fill out a varobj structure for the (root) variable being constructed.  */
-  auto var = gdb::make_unique<varobj> (new varobj_root);
+  auto var = std::make_unique<varobj> (new varobj_root);
 
   if (expression != NULL)
     {

gdbsupport/gdb_unique_ptr.h

@@ -56,19 +56,6 @@ struct noop_deleter
   void operator() (T *ptr) const { }
 };
 
-/* Create simple std::unique_ptr<T> objects.  */
-
-template<typename T, typename... Arg>
-std::unique_ptr<T>
-make_unique (Arg &&...args)
-{
-#if __cplusplus >= 201402L
-  return std::make_unique<T> (std::forward<Arg> (args)...);
-#else
-  return std::unique_ptr<T> (new T (std::forward<Arg> (args)...));
-#endif /* __cplusplus < 201402L */
-}
-
 } /* namespace gdb */
 
 /* Dup STR and return a unique_xmalloc_ptr for the result.  */