Bug #26826272: REMOVE GCC 8 WARNINGS [noclose]

Remove a few nontrivial GCC 8 warnings around memcpy of non-POD objects.

After this, only InnoDB warnings are left (except for one false positive
that has been reported as a GCC bug).

Change-Id: I45e6e8924f13e3139df7c6762b4fa6f6b72056bd

Author: Steinar H. Gunderson

sql/auth/sql_authentication.cc

@@ -1024,7 +1024,7 @@ static bool find_mpvio_user(THD *thd, MPVIO_EXT *mpvio)
 
 static bool
 read_client_connect_attrs(char **ptr, size_t *max_bytes_available,
-                          MPVIO_EXT *mpvio)
+                          MPVIO_EXT *mpvio MY_ATTRIBUTE((unused)))
 {
   size_t length, length_length;
   char *ptr_save;

sql/dd_sp.cc

@@ -170,8 +170,6 @@ static void prepare_type_string_from_dd_param(THD *thd,
   // Get type in string format.
   TABLE table;
   TABLE_SHARE share;
-  memset(&table, 0, sizeof(table));
-  memset(&share, 0, sizeof(share));
   table.in_use= thd;
   table.s= &share;
 

sql/handler.cc

@@ -1368,7 +1368,7 @@ void ha_pre_dd_shutdown(void)
 
 */
 void trans_register_ha(THD *thd, bool all, handlerton *ht_arg,
-                       const ulonglong *trxid)
+                       const ulonglong *trxid MY_ATTRIBUTE((unused)))
 {
   Ha_trx_info *ha_info;
   Transaction_ctx *trn_ctx= thd->get_transaction();
@@ -2630,8 +2630,6 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
   TABLE_SHARE dummy_share;
   DBUG_ENTER("ha_delete_table");
 
-  memset(&dummy_table, 0, sizeof(dummy_table));
-  memset(&dummy_share, 0, sizeof(dummy_share));
   dummy_table.s= &dummy_share;
 
   /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */

sql/item_func.cc

@@ -8889,7 +8889,6 @@ bool check_table_and_trigger_access(Item **args,
     DBUG_RETURN(false);
 
   TABLE_LIST table_list;
-  memset(&table_list, 0, sizeof (table_list));
   table_list.db= schema_name_ptr->ptr();
   table_list.db_length= schema_name_ptr->length();
   table_list.table_name= table_name_ptr->ptr();

sql/item_strfunc.cc

@@ -4653,7 +4653,6 @@ String *Item_func_get_dd_column_privileges::val_str(String *str)
 
       THD *thd= current_thd;
       GRANT_INFO grant_info;
-      memset(&grant_info, 0, sizeof (grant_info));
       fill_effective_table_privileges(thd,
                                       &grant_info,
                                       schema_name_ptr->c_ptr_safe(),

sql/mysqld.cc

@@ -8058,7 +8058,7 @@ static int mysql_init_variables()
   mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;
   prepared_stmt_count= 0;
   mysqld_unix_port= opt_mysql_tmpdir= my_bind_addr_str= NullS;
-  memset(&mysql_tmpdir_list, 0, sizeof(mysql_tmpdir_list));
+  new (&mysql_tmpdir_list) MY_TMPDIR;
   memset(&global_status_var, 0, sizeof(global_status_var));
   opt_large_pages= 0;
   opt_super_large_pages= 0;

sql/partition_info.cc

@@ -73,15 +73,14 @@ partition_info *partition_info::get_clone(THD *thd, bool reset /* = false */)
   DBUG_ENTER("partition_info::get_clone");
   List_iterator<partition_element> part_it(partitions);
   partition_element *part;
-  partition_info *clone= new (*THR_MALLOC) partition_info();
+  partition_info *clone= new (*THR_MALLOC) partition_info(*this);
   if (!clone)
   {
     mem_alloc_error(sizeof(partition_info));
     DBUG_RETURN(NULL);
   }
-  memcpy(clone, this, sizeof(partition_info));
-  memset(&(clone->read_partitions), 0, sizeof(clone->read_partitions));
-  memset(&(clone->lock_partitions), 0, sizeof(clone->lock_partitions));
+  new (&(clone->read_partitions)) MY_BITMAP;
+  new (&(clone->lock_partitions)) MY_BITMAP;
   clone->bitmaps_are_initialized= FALSE;
   clone->partitions.empty();
   clone->temp_partitions.empty();
@@ -90,13 +89,12 @@ partition_info *partition_info::get_clone(THD *thd, bool reset /* = false */)
   {
     List_iterator<partition_element> subpart_it(part->subpartitions);
     partition_element *subpart;
-    partition_element *part_clone= new (*THR_MALLOC) partition_element();
+    partition_element *part_clone= new (*THR_MALLOC) partition_element(*part);
     if (!part_clone)
     {
       mem_alloc_error(sizeof(partition_element));
       DBUG_RETURN(NULL);
     }
-    memcpy(part_clone, part, sizeof(partition_element));
 
     /* Explicitly copy the tablespace name, use the thd->mem_root. */
     if (part->tablespace_name != nullptr)
@@ -125,13 +123,12 @@ partition_info *partition_info::get_clone(THD *thd, bool reset /* = false */)
     part_clone->subpartitions.empty();
     while ((subpart= (subpart_it++)))
     {
-      partition_element *subpart_clone= new (*THR_MALLOC) partition_element();
+      partition_element *subpart_clone= new (*THR_MALLOC) partition_element(*subpart);
       if (!subpart_clone)
       {
         mem_alloc_error(sizeof(partition_element));
         DBUG_RETURN(NULL);
       }
-      memcpy(subpart_clone, subpart, sizeof(partition_element));
 
       /* Explicitly copy the tablespace name, use the thd->mem_root. */
       if (subpart->tablespace_name != nullptr)
@@ -1885,7 +1882,6 @@ void partition_info::print_no_partition_found(THD *thd, TABLE *table_arg)
   char *buf_ptr= (char*)&buf;
   TABLE_LIST table_list;
 
-  memset(&table_list, 0, sizeof(table_list));
   table_list.db= table_arg->s->db.str;
   table_list.table_name= table_arg->s->table_name.str;
 

sql/records.cc

@@ -209,7 +209,7 @@ bool init_read_record(READ_RECORD *info,THD *thd,
   if (!table)
     table= qep_tab->table();
 
-  memset(info, 0, sizeof(*info));
+  new (info) READ_RECORD;
   info->thd=thd;
   info->table=table;
   info->forms= &info->table;		/* Only one table */

sql/sql_alter.cc

@@ -290,7 +290,6 @@ bool Sql_cmd_alter_table::execute(THD *thd)
     // Rename of table
     DBUG_ASSERT(alter_info.flags & Alter_info::ALTER_RENAME);
     TABLE_LIST tmp_table;
-    memset(&tmp_table, 0, sizeof(tmp_table));
     tmp_table.table_name= alter_info.new_table_name.str;
     tmp_table.db= alter_info.new_db_name.str;
     tmp_table.grant.privilege= priv;

sql/sql_delete.cc

@@ -788,7 +788,6 @@ bool Sql_cmd_delete::prepare_inner(THD *thd)
     List<Item>   fields;
     List<Item>   all_fields;
 
-    memset(&tables, 0, sizeof(tables));
     tables.table = table_list->table;
     tables.alias = table_list->alias;
 

sql/sql_insert.cc

@@ -2557,7 +2557,6 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
 
   DBUG_ENTER("create_table_from_items");
 
-  memset(&tmp_table, 0, sizeof(tmp_table));
   tmp_table.s= &share;
   init_tmp_table_share(thd, &share, "", 0, "", "", nullptr);
 
@@ -2960,7 +2959,6 @@ int Query_result_create::binlog_show_create_table()
   int result;
   TABLE_LIST tmp_table_list;
 
-  memset(&tmp_table_list, 0, sizeof(tmp_table_list));
   tmp_table_list.table= table;
   query.length(0);      // Have to zero it since constructor doesn't
 

sql/sql_plugin.cc

@@ -945,15 +945,14 @@ static st_plugin_int *plugin_insert_or_reuse(st_plugin_int *plugin)
     tmp= *it;
     if (tmp->state == PLUGIN_IS_FREED)
     {
-      memcpy(tmp, plugin, sizeof(st_plugin_int));
+      *tmp = std::move(*plugin);
       DBUG_RETURN(tmp);
     }
   }
   if (plugin_array->push_back(plugin))
     DBUG_RETURN(NULL);
   tmp= plugin_array->back()=
-    static_cast<st_plugin_int*>(memdup_root(&plugin_mem_root, plugin,
-                                            sizeof(st_plugin_int)));
+    new (&plugin_mem_root) st_plugin_int(std::move(*plugin));
   DBUG_RETURN(tmp);
 }
 
@@ -979,8 +978,6 @@ static bool plugin_add(MEM_ROOT *tmp_root,
     mysql_mutex_lock(&LOCK_plugin);
     DBUG_RETURN(TRUE);
   }
-  /* Clear the whole struct to catch future extensions. */
-  memset(&tmp, 0, sizeof(tmp));
   if (! (tmp.plugin_dl= plugin_dl_add(dl, report)))
     DBUG_RETURN(TRUE);
   /* Find plugin by name */
@@ -1545,7 +1542,6 @@ bool plugin_register_builtin_and_init_core_se(int *argc, char **argv)
     for (struct st_mysql_plugin *plugin= *builtins; plugin->info; plugin++)
     {
       struct st_plugin_int tmp;
-      memset(&tmp, 0, sizeof(tmp));
       tmp.plugin= plugin;
       tmp.name.str= (char *)plugin->name;
       tmp.name.length= strlen(plugin->name);
@@ -1702,8 +1698,7 @@ static bool register_builtin(st_mysql_plugin *plugin,
     DBUG_RETURN(true);
 
   *ptr= plugin_array->back()=
-    static_cast<st_plugin_int*>(memdup_root(&plugin_mem_root, tmp,
-                                            sizeof(st_plugin_int)));
+    new (&plugin_mem_root) st_plugin_int(std::move(*tmp));
 
   plugin_hash[plugin->type]->emplace(to_string((*ptr)->name), *ptr);
 
@@ -3468,8 +3463,12 @@ static int test_plugin_options(MEM_ROOT *tmp_root, st_plugin_int *tmp,
   bool disable_plugin;
   enum_plugin_load_option plugin_load_option= tmp->load_option;
 
-  MEM_ROOT *mem_root= alloc_root_inited(&tmp->mem_root) ?
-                      &tmp->mem_root : &plugin_mem_root;
+  /*
+    We should use tmp->mem_root here instead of the global plugin_mem_root,
+    but tmp->root is not always properly freed, so it will cause leaks in
+    Valgrind (e.g. the main.validate_password_plugin test).
+  */
+  MEM_ROOT *mem_root= &plugin_mem_root;
   SYS_VAR **opt;
   my_option *opts= NULL;
   LEX_STRING plugin_name;

sql/sql_plugin_ref.h

@@ -36,15 +36,15 @@ enum enum_plugin_load_option {
 
 struct st_plugin_int
 {
-  LEX_STRING name;
-  st_mysql_plugin *plugin;
-  st_plugin_dl *plugin_dl;
-  uint state;
-  uint ref_count;               /* number of threads using the plugin */
-  void *data;                   /* plugin type specific, e.g. handlerton */
+  LEX_STRING name{nullptr, 0};
+  st_mysql_plugin *plugin{nullptr};
+  st_plugin_dl *plugin_dl{nullptr};
+  uint state{0};
+  uint ref_count{0};               /* number of threads using the plugin */
+  void *data{nullptr};                   /* plugin type specific, e.g. handlerton */
   MEM_ROOT mem_root;            /* memory for dynamic plugin structures */
-  sys_var *system_vars;         /* server variables for this plugin */
-  enum_plugin_load_option load_option; /* OFF, ON, FORCE, F+PERMANENT */
+  sys_var *system_vars{nullptr};         /* server variables for this plugin */
+  enum_plugin_load_option load_option{PLUGIN_OFF}; /* OFF, ON, FORCE, F+PERMANENT */
 };
 
 /*

sql/sql_servers.cc

@@ -384,8 +384,6 @@ static bool close_cached_connection_tables(THD *thd,
   DBUG_ENTER("close_cached_connection_tables");
   DBUG_ASSERT(thd);
 
-  memset(&tmp, 0, sizeof(TABLE_LIST));
-
   mysql_mutex_lock(&LOCK_open);
 
   for (const auto &key_and_value : *table_def_cache)

sql/sql_show.cc

@@ -456,10 +456,6 @@ find_files(THD *thd, List<LEX_STRING> *files, const char *db,
       wild_length= strlen(wild);
   }
 
-
-
-  memset(&table_list, 0, sizeof(table_list));
-
   if (!(dirp = my_dir(path,MYF(dir ? MY_WANT_STAT : 0))))
   {
     if (my_errno() == ENOENT)
@@ -3626,7 +3622,6 @@ make_table_name_list(THD *thd, List<LEX_STRING> *table_names, LEX *lex,
       if (!(thd->col_access & TABLE_ACLS))
       {
         TABLE_LIST table_list;
-        memset(&table_list, 0, sizeof(table_list));
         table_list.db= db_name->str;
         table_list.db_length= db_name->length;
         table_list.table_name= const_cast<char*>(name->c_str());

sql/sql_tmp_table.cc

@@ -2923,12 +2923,24 @@ bool create_ondisk_from_heap(THD *thd, TABLE *wtable,
       table= wtable;
     }
 
-    /*
-      TABLE has no copy ctor; can't use the move ctor as we use both objects
-      when we migrate rows.
-    */
     table->mem_root.Clear();
-    memcpy(&new_table, table, sizeof(new_table));
+
+    // Set up a partial copy of the table.
+    new_table.record[0]= table->record[0];
+    new_table.record[1]= table->record[1];
+    new_table.field= table->field;
+    new_table.key_info= table->key_info;
+    new_table.in_use= table->in_use;
+    new_table.db_stat= table->db_stat;
+    new_table.key_info= table->key_info;
+    new_table.hash_field= table->hash_field;
+    new_table.group= table->group;
+    new_table.distinct= table->distinct;
+    new_table.alias= table->alias;
+    new_table.pos_in_table_list= table->pos_in_table_list;
+    new_table.reginfo= table->reginfo;
+    new_table.read_set= table->read_set;
+    new_table.write_set= table->write_set;
 
     new_table.s= &share; // New table points to new share
 
@@ -3071,19 +3083,19 @@ bool create_ondisk_from_heap(THD *thd, TABLE *wtable,
 
     }
 
-    destroy(table->file);
-    table->file=0;
     /*
-      '*table' is overwritten with 'new_table'. new_table was set up as
-      '*table', so, between the start and end of this function, pointers like
-      'table, table->record, table->record[i]' are preserved. This is important,
-      for example because some Item_field->field->ptr points into
-      table->record[0]: such pointer remains valid after the conversion and
-      will allow to access rows of the new TABLE.
+      Replace the guts of the old table with the new one, although keeping
+      most members.
     */
-    *table= std::move(new_table);
-
-    // 'table' is now new and points to new share
+    destroy(table->file);
+    table->s= new_table.s;
+    table->file= new_table.file;
+    table->db_stat= new_table.db_stat;
+    table->in_use= new_table.in_use;
+    table->no_rows= new_table.no_rows;
+    table->record[0]= new_table.record[0];
+    table->record[1]= new_table.record[1];
+    table->mem_root= std::move(new_table.mem_root);
 
     /*
       Depending on if this TABLE clone is early/late in optimization, or in

sql/sql_view.cc

@@ -267,7 +267,7 @@ static bool fill_defined_view_parts(THD *thd, TABLE_LIST *view)
   const char *cache_key;
   size_t cache_key_length= get_table_def_key(view, &cache_key);
   TABLE_LIST decoy;
-  memcpy (&decoy, view, sizeof (TABLE_LIST));
+  decoy= *view;
 
   mysql_mutex_lock(&LOCK_open);
 

sql/trigger.cc

@@ -456,7 +456,6 @@ Trigger::Trigger(const LEX_CSTRING &trigger_name,
   m_parse_error_message[0]= 0;
 
   construct_definer_value(mem_root, &m_definer, definer_user, definer_host);
-  memset(&m_subject_table_grant, 0, sizeof (m_subject_table_grant));
 }
 
 

sql/tztime.cc

@@ -1564,10 +1564,9 @@ class Tz_names_entry
 static void
 tz_init_table_list(TABLE_LIST *tz_tabs)
 {
-  memset(tz_tabs, 0, sizeof(TABLE_LIST) * MY_TZ_TABLES_COUNT);
-
   for (int i= 0; i < MY_TZ_TABLES_COUNT; i++)
   {
+    new (&tz_tabs[i]) TABLE_LIST;
     tz_tabs[i].alias= tz_tabs[i].table_name= tz_tables_names[i].str;
     tz_tabs[i].table_name_length= tz_tables_names[i].length;
     tz_tabs[i].db= tz_tables_db_name.str;
@@ -1694,7 +1693,6 @@ my_tz_init(THD *org_thd, const char *default_tzname, bool bootstrap)
     leap seconds shared by all time zones.
   */
   thd->set_db(db);
-  memset(&tz_tables[0], 0, sizeof(TABLE_LIST));
   tz_tables[0].alias= tz_tables[0].table_name=
     (char*)"time_zone_leap_second";
   tz_tables[0].table_name_length= 21;