MDEV-21907: Make GCC 9 happybb-10.5-MDEV-21907

21 files changed, 131 insertions, 152 deletions

diff --git a/include/my_bit.h b/include/my_bit.h
index 485a8d2d9ec..24c62d09ce7 100644
--- a/include/my_bit.h
+++ b/include/my_bit.h
@@ -50,7 +50,7 @@ static inline CONSTEXPR uint my_bit_log2_hex_digit(uint8 value)
 }
 static inline CONSTEXPR uint my_bit_log2_uint8(uint8 value)
 {
-  return value & 0xF0 ? my_bit_log2_hex_digit(value >> 4) + 4:
+  return value & 0xF0 ? my_bit_log2_hex_digit((uint8) (value >> 4)) + 4:
                         my_bit_log2_hex_digit(value);
 }
 static inline CONSTEXPR uint my_bit_log2_uint16(uint16 value)
diff --git a/libmysqld/libmysql.c b/libmysqld/libmysql.c
index c57e89947a6..16e9651ab3a 100644
--- a/libmysqld/libmysql.c
+++ b/libmysqld/libmysql.c
@@ -4219,7 +4219,7 @@ static int stmt_fetch_row(MYSQL_STMT *stmt, uchar *row)
       (*my_bind->fetch_result)(my_bind, field, &row);
       truncation_count+= *my_bind->error;
     }
-    if (!((bit<<=1) & 255))
+    if (!(bit= (uchar) (bit << 1)))
     {
       bit= 1;					/* To next uchar */
       null_ptr++;
@@ -4419,7 +4419,7 @@ static void stmt_update_metadata(MYSQL_STMT *stmt, MYSQL_ROWS *data)
     if (!(*null_ptr & bit))
       (*my_bind->skip_result)(my_bind, field, &row);
     DBUG_ASSERT(row <= row_end);
-    if (!((bit<<=1) & 255))
+    if (!(bit= (uchar) (bit << 1)))
     {
       bit= 1;					/* To next uchar */
       null_ptr++;
diff --git a/storage/innobase/btr/btr0bulk.cc b/storage/innobase/btr/btr0bulk.cc
index 9c62ba6d7ce..9873f30aa45 100644
--- a/storage/innobase/btr/btr0bulk.cc
+++ b/storage/innobase/btr/btr0bulk.cc
@@ -372,7 +372,7 @@ inline void PageBulk::finishPage()
   {
     uint16_t offset= mach_read_from_2(PAGE_NEW_INFIMUM - REC_NEXT + m_page);
     ut_ad(offset >= PAGE_NEW_SUPREMUM - PAGE_NEW_INFIMUM);
-    offset += PAGE_NEW_INFIMUM;
+    offset= static_cast<uint16_t>(offset + PAGE_NEW_INFIMUM);
     /* Set owner & dir. */
     do
     {
diff --git a/storage/innobase/dict/dict0dict.cc b/storage/innobase/dict/dict0dict.cc
index f784f2bdcc9..86ce341f25a 100644
--- a/storage/innobase/dict/dict0dict.cc
+++ b/storage/innobase/dict/dict0dict.cc
@@ -2474,7 +2474,8 @@ dict_index_build_internal_clust(
 		new_index->n_uniq = new_index->n_def;
 	} else {
 		/* Also the row id is needed to identify the entry */
-		new_index->n_uniq = 1 + unsigned(new_index->n_def);
+		new_index->n_uniq = unsigned(new_index->n_def + 1)
+			& dict_index_t::MAX_N_FIELDS;
 	}
 
 	new_index->trx_id_offset = 0;
diff --git a/storage/innobase/fsp/fsp0fsp.cc b/storage/innobase/fsp/fsp0fsp.cc
index f9fdc4f3af3..a4c1530d55e 100644
--- a/storage/innobase/fsp/fsp0fsp.cc
+++ b/storage/innobase/fsp/fsp0fsp.cc
@@ -271,14 +271,15 @@ fseg_mark_page_used(fseg_inode_t *seg_inode, buf_block_t *iblock,
   ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
   ut_ad(!memcmp(seg_inode + FSEG_ID, descr + XDES_ID, 4));
 
-  const uint16_t xoffset= XDES_FLST_NODE + uint16_t(descr - xdes->frame);
+  const uint16_t xoffset= uint16_t(descr - xdes->frame + XDES_FLST_NODE);
   const uint16_t ioffset= uint16_t(seg_inode - iblock->frame);
 
   if (!xdes_get_n_used(descr))
   {
     /* We move the extent from the free list to the NOT_FULL list */
-    flst_remove(iblock, FSEG_FREE + ioffset, xdes, xoffset, mtr);
-    flst_add_last(iblock, FSEG_NOT_FULL + ioffset, xdes, xoffset, mtr);
+    flst_remove(iblock, uint16_t(FSEG_FREE + ioffset), xdes, xoffset, mtr);
+    flst_add_last(iblock, uint16_t(FSEG_NOT_FULL + ioffset),
+                  xdes, xoffset, mtr);
   }
 
   ut_ad(xdes_is_free(descr, page % FSP_EXTENT_SIZE));
@@ -292,8 +293,8 @@ fseg_mark_page_used(fseg_inode_t *seg_inode, buf_block_t *iblock,
   if (xdes_is_full(descr))
   {
     /* We move the extent from the NOT_FULL list to the FULL list */
-    flst_remove(iblock, FSEG_NOT_FULL + ioffset, xdes, xoffset, mtr);
-    flst_add_last(iblock, FSEG_FULL + ioffset, xdes, xoffset, mtr);
+    flst_remove(iblock, uint16_t(FSEG_NOT_FULL + ioffset), xdes, xoffset, mtr);
+    flst_add_last(iblock, uint16_t(FSEG_FULL + ioffset), xdes, xoffset, mtr);
     mtr->write<4>(*iblock, seg_inode + FSEG_NOT_FULL_N_USED,
                   not_full_n_used - FSP_EXTENT_SIZE);
   }
@@ -920,8 +921,8 @@ fsp_fill_free_list(
 			fil_block_check_type(*xdes, FIL_PAGE_TYPE_XDES, mtr);
 		}
 		xdes_init(*xdes, descr, mtr);
-		const uint16_t xoffset= XDES_FLST_NODE
-			+ uint16_t(descr - xdes->frame);
+		const uint16_t xoffset= static_cast<uint16_t>(
+			descr - xdes->frame + XDES_FLST_NODE);
 
 		if (UNIV_UNLIKELY(init_xdes)) {
 
@@ -1004,9 +1005,9 @@ fsp_alloc_free_extent(
 						mtr);
 	}
 
-	flst_remove(header, FSP_HEADER_OFFSET + FSP_FREE,
-		    desc_block, uint16_t(descr - desc_block->frame)
-		    + XDES_FLST_NODE, mtr);
+	flst_remove(header, FSP_HEADER_OFFSET + FSP_FREE, desc_block,
+		    static_cast<uint16_t>(
+			    descr - desc_block->frame + XDES_FLST_NODE), mtr);
 	space->free_len--;
 	*xdes = desc_block;
 
@@ -1034,8 +1035,8 @@ fsp_alloc_from_free_frag(buf_block_t *header, buf_block_t *xdes, xdes_t *descr,
 
 	if (xdes_is_full(descr)) {
 		/* The fragment is full: move it to another list */
-		const uint16_t xoffset= XDES_FLST_NODE
-			+ uint16_t(descr - xdes->frame);
+		const uint16_t xoffset= static_cast<uint16_t>(
+			descr - xdes->frame + XDES_FLST_NODE);
 		flst_remove(header, FSP_HEADER_OFFSET + FSP_FREE_FRAG,
 			    xdes, xoffset, mtr);
 		xdes_set_state(*xdes, descr, XDES_FULL_FRAG, mtr);
@@ -1141,8 +1142,9 @@ fsp_alloc_free_page(
 
 			xdes_set_state(*xdes, descr, XDES_FREE_FRAG, mtr);
 			flst_add_last(block, FSP_HEADER_OFFSET + FSP_FREE_FRAG,
-				      xdes, XDES_FLST_NODE
-				      + uint16_t(descr - xdes->frame), mtr);
+				      xdes, static_cast<uint16_t>(
+					      descr - xdes->frame
+					      + XDES_FLST_NODE), mtr);
 		} else {
 			descr = xdes_lst_get_descriptor(space, first, &xdes,
 							mtr);
@@ -1262,7 +1264,8 @@ static void fsp_free_page(fil_space_t* space, page_no_t offset, mtr_t* mtr)
 	frag_n_used = mach_read_from_4(FSP_HEADER_OFFSET + FSP_FRAG_N_USED
 				       + header->frame);
 
-	const uint16_t xoffset= XDES_FLST_NODE + uint16_t(descr - xdes->frame);
+	const uint16_t xoffset= static_cast<uint16_t>(descr - xdes->frame
+						      + XDES_FLST_NODE);
 
 	if (state == XDES_FULL_FRAG) {
 		/* The fragment was full: move it to another list */
@@ -1306,7 +1309,8 @@ static void fsp_free_extent(fil_space_t* space, page_no_t offset, mtr_t* mtr)
   xdes_init(*xdes, descr, mtr);
 
   flst_add_last(block, FSP_HEADER_OFFSET + FSP_FREE,
-                xdes, XDES_FLST_NODE + uint16_t(descr - xdes->frame), mtr);
+                xdes, static_cast<uint16_t>(descr - xdes->frame
+					    + XDES_FLST_NODE), mtr);
   space->free_len++;
 }
 
@@ -1913,10 +1917,11 @@ fseg_fill_free_list(
 		      == FSEG_MAGIC_N_VALUE);
 		mtr->write<8>(*xdes, descr + XDES_ID, seg_id);
 
-		flst_add_last(iblock, FSEG_FREE
-			      + uint16_t(inode - iblock->frame),
-			      xdes, XDES_FLST_NODE
-			      + uint16_t(descr - xdes->frame), mtr);
+		flst_add_last(iblock,
+			      static_cast<uint16_t>(inode - iblock->frame
+						    + FSEG_FREE), xdes,
+			      static_cast<uint16_t>(descr - xdes->frame
+						    + XDES_FLST_NODE), mtr);
 		hint += FSP_EXTENT_SIZE;
 	}
 }
@@ -1967,10 +1972,11 @@ fseg_alloc_free_extent(
 
 		xdes_set_state(**xdes, descr, XDES_FSEG, mtr);
 		mtr->write<8,mtr_t::OPT>(**xdes, descr + XDES_ID, seg_id);
-		flst_add_last(iblock, FSEG_FREE
-			      + uint16_t(inode - iblock->frame),
-			      *xdes, XDES_FLST_NODE
-			      + uint16_t(descr - (*xdes)->frame), mtr);
+		flst_add_last(iblock,
+			      static_cast<uint16_t>(inode - iblock->frame
+						    + FSEG_FREE), *xdes,
+			      static_cast<uint16_t>(descr - (*xdes)->frame
+						    + XDES_FLST_NODE), mtr);
 
 		/* Try to fill the segment free list */
 		fseg_fill_free_list(inode, iblock, space,
@@ -2076,10 +2082,11 @@ take_hinted_page:
 
 		xdes_set_state(*xdes, ret_descr, XDES_FSEG, mtr);
 		mtr->write<8,mtr_t::OPT>(*xdes, ret_descr + XDES_ID, seg_id);
-		flst_add_last(iblock, FSEG_FREE
-			      + uint16_t(seg_inode - iblock->frame),
-			      xdes, XDES_FLST_NODE
-			      + uint16_t(ret_descr - xdes->frame), mtr);
+		flst_add_last(iblock,
+			      static_cast<uint16_t>(seg_inode - iblock->frame
+						    + FSEG_FREE), xdes,
+			      static_cast<uint16_t>(ret_descr - xdes->frame
+						    + XDES_FLST_NODE), mtr);
 
 		/* Try to fill the segment free list */
 		fseg_fill_free_list(seg_inode, iblock, space,
@@ -2566,14 +2573,16 @@ fseg_free_page_low(
 
 	byte* p_not_full = seg_inode + FSEG_NOT_FULL_N_USED;
 	uint32_t not_full_n_used = mach_read_from_4(p_not_full);
-	const uint16_t xoffset= XDES_FLST_NODE + uint16_t(descr - xdes->frame);
+	const uint16_t xoffset= uint16_t(descr - xdes->frame + XDES_FLST_NODE);
 	const uint16_t ioffset= uint16_t(seg_inode - iblock->frame);
 
 	if (xdes_is_full(descr)) {
 		/* The fragment is full: move it to another list */
-		flst_remove(iblock, FSEG_FULL + ioffset, xdes, xoffset, mtr);
-		flst_add_last(iblock, FSEG_NOT_FULL + ioffset, xdes, xoffset,
-			      mtr);
+		flst_remove(iblock, static_cast<uint16_t>(FSEG_FULL + ioffset),
+			    xdes, xoffset, mtr);
+		flst_add_last(iblock, static_cast<uint16_t>(FSEG_NOT_FULL
+							    + ioffset),
+			      xdes, xoffset, mtr);
 		not_full_n_used += FSP_EXTENT_SIZE - 1;
 	} else {
 		ut_a(not_full_n_used > 0);
@@ -2588,8 +2597,9 @@ fseg_free_page_low(
 
 	if (!xdes_get_n_used(descr)) {
 		/* The extent has become free: free it to space */
-		flst_remove(iblock, FSEG_NOT_FULL + ioffset, xdes, xoffset,
-			    mtr);
+		flst_remove(iblock, static_cast<uint16_t>(FSEG_NOT_FULL
+							  + ioffset),
+			    xdes, xoffset, mtr);
 		fsp_free_extent(space, offset, mtr);
 	}
 }
@@ -2717,17 +2727,19 @@ fseg_free_extent(
 	}
 #endif /* BTR_CUR_HASH_ADAPT */
 
-	const uint16_t xoffset= XDES_FLST_NODE + uint16_t(descr - xdes->frame);
+	const uint16_t xoffset= uint16_t(descr - xdes->frame + XDES_FLST_NODE);
 	const uint16_t ioffset= uint16_t(seg_inode - iblock->frame);
 
 	if (xdes_is_full(descr)) {
-		flst_remove(iblock, FSEG_FULL + ioffset, xdes, xoffset, mtr);
+		flst_remove(iblock, static_cast<uint16_t>(FSEG_FULL + ioffset),
+			    xdes, xoffset, mtr);
 	} else if (!xdes_get_n_used(descr)) {
-		flst_remove(iblock, FSEG_FREE + ioffset, xdes, xoffset, mtr);
+		flst_remove(iblock, static_cast<uint16_t>(FSEG_FREE + ioffset),
+			    xdes, xoffset, mtr);
 	} else {
-		flst_remove(iblock, FSEG_NOT_FULL + ioffset, xdes, xoffset,
-			    mtr);
-
+		flst_remove(iblock, static_cast<uint16_t>(FSEG_NOT_FULL
+							  + ioffset),
+			    xdes, xoffset, mtr);
 		ulint not_full_n_used = mach_read_from_4(
 			FSEG_NOT_FULL_N_USED + seg_inode);
 		ulint descr_n_used = xdes_get_n_used(descr);
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index 899dd22c8ec..766fece542e 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -10279,7 +10279,8 @@ ha_innobase::wsrep_append_keys(
 							keyval1,
 						    /* for len1+1 see keyval1
 						     initialization comment */
-							len1+1, key_type);
+							uint16_t(len1+1),
+							key_type);
 						    if (rcode)
 							DBUG_RETURN(rcode);
 						}
@@ -10291,7 +10292,8 @@ ha_innobase::wsrep_append_keys(
 						thd, trx, table_share,
 						/* for len0+1 see keyval0
 						   initialization comment */
-						keyval0, len0+1, key_type);
+						keyval0, uint16_t(len0+1),
+						key_type);
 					if (rcode)
 						DBUG_RETURN(rcode);
 
diff --git a/storage/innobase/include/dict0mem.h b/storage/innobase/include/dict0mem.h
index 7e64a0f7ac3..b5f71775a2c 100644
--- a/storage/innobase/include/dict0mem.h
+++ b/storage/innobase/include/dict0mem.h
@@ -1176,11 +1176,17 @@ struct dict_index_t {
 		return n_uniq;
 	}
 	/** @return the position of DB_ROLL_PTR */
-	uint16_t db_roll_ptr() const { return db_trx_id() + 1; }
+	uint16_t db_roll_ptr() const
+	{
+		return static_cast<uint16_t>(db_trx_id() + 1);
+	}
 
 	/** @return the offset of the metadata BLOB field,
 	or the first user field after the PRIMARY KEY,DB_TRX_ID,DB_ROLL_PTR */
-	uint16_t first_user_field() const { return db_trx_id() + 2; }
+	uint16_t first_user_field() const
+	{
+		return static_cast<uint16_t>(db_trx_id() + 2);
+	}
 
 	/** @return whether the index is corrupted */
 	inline bool is_corrupted() const;
diff --git a/storage/innobase/include/mtr0log.h b/storage/innobase/include/mtr0log.h
index 29765faa017..bb533d40a6c 100644
--- a/storage/innobase/include/mtr0log.h
+++ b/storage/innobase/include/mtr0log.h
@@ -42,7 +42,7 @@ constexpr uint32_t MLOG_DECODE_ERROR= ~0U;
 inline uint8_t mlog_decode_varint_length(byte first)
 {
   uint8_t len= 1;
-  for (; first & 0x80; len++, first<<= 1);
+  for (; first & 0x80; len++, first= static_cast<uint8_t>(first << 1));
   return len;
 }
 
diff --git a/storage/innobase/include/page0page.ic b/storage/innobase/include/page0page.ic
index e548b6d6816..92b8922ffe0 100644
--- a/storage/innobase/include/page0page.ic
+++ b/storage/innobase/include/page0page.ic
@@ -716,7 +716,7 @@ page_get_instant(const page_t* page)
 		break;
 	}
 #endif /* UNIV_DEBUG */
-	return(i >> 3);
+	return i / 8;
 }
 #endif /* !UNIV_INNOCHECKSUM */
 
diff --git a/storage/innobase/include/trx0purge.h b/storage/innobase/include/trx0purge.h
index 3af3b30ad04..0c3d4ee5c00 100644
--- a/storage/innobase/include/trx0purge.h
+++ b/storage/innobase/include/trx0purge.h
@@ -36,16 +36,6 @@ Created 3/26/1996 Heikki Tuuri
 which needs no purge */
 extern trx_undo_rec_t	trx_purge_dummy_rec;
 
-/********************************************************************//**
-Calculates the file address of an undo log header when we have the file
-address of its history list node.
-@return file address of the log */
-UNIV_INLINE
-fil_addr_t
-trx_purge_get_log_from_hist(
-/*========================*/
-	fil_addr_t	node_addr);	/*!< in: file address of the history
-					list node of the log */
 /** Prepend the history list with an undo log.
 Remove the undo log segment from the rseg slot if it is too big for reuse.
 @param[in]	trx		transaction
@@ -261,6 +251,4 @@ public:
 /** The global data structure coordinating a purge */
 extern purge_sys_t	purge_sys;
 
-#include "trx0purge.ic"
-
 #endif /* trx0purge_h */
diff --git a/storage/innobase/include/trx0purge.ic b/storage/innobase/include/trx0purge.ic
deleted file mode 100644
index e460676d58e..00000000000
--- a/storage/innobase/include/trx0purge.ic
+++ /dev/null
@@ -1,42 +0,0 @@
-/*****************************************************************************
-
-Copyright (c) 1996, 2013, Oracle and/or its affiliates. All Rights Reserved.
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; version 2 of the License.
-
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
-
-*****************************************************************************/
-
-/**************************************************//**
-@file include/trx0purge.ic
-Purge old versions
-
-Created 3/26/1996 Heikki Tuuri
-*******************************************************/
-
-#include "trx0undo.h"
-
-/********************************************************************//**
-Calculates the file address of an undo log header when we have the file
-address of its history list node.
-@return file address of the log */
-UNIV_INLINE
-fil_addr_t
-trx_purge_get_log_from_hist(
-/*========================*/
-	fil_addr_t	node_addr)	/*!< in: file address of the history
-					list node of the log */
-{
-	node_addr.boffset -= TRX_UNDO_HISTORY_NODE;
-
-	return(node_addr);
-}
diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc
index 5facd8284b2..c21c539c50c 100644
--- a/storage/innobase/log/log0recv.cc
+++ b/storage/innobase/log/log0recv.cc
@@ -150,7 +150,7 @@ public:
   {
     ut_ad(start_lsn < lsn);
     reinterpret_cast<byte*>(memcpy(end(), recs, size))[size]= 0;
-    len+= static_cast<uint16_t>(size);
+    len= static_cast<uint16_t>(len + size);
   }
 
   /** Apply an UNDO_APPEND record.
@@ -458,7 +458,7 @@ page_corrupted:
         if (UNIV_UNLIKELY(offset + last_offset < 8 ||
                           offset + last_offset >= size))
           goto record_corrupted;
-        last_offset+= static_cast<uint16_t>(offset);
+        last_offset= static_cast<uint16_t>(last_offset + offset);
         l+= olen;
         rlen-= olen;
         size_t llen= rlen;
@@ -477,7 +477,7 @@ page_corrupted:
             applied= APPLIED_TO_FSP_HEADER;
         next_after_applying_write:
           ut_ad(llen + last_offset <= size);
-          last_offset+= static_cast<uint16_t>(llen);
+          last_offset= static_cast<uint16_t>(last_offset + llen);
           goto next_after_applying;
         }
         llen= mlog_decode_varint_length(*l);
diff --git a/storage/innobase/os/os0file.cc b/storage/innobase/os/os0file.cc
index 02040da9e52..4bfde1e3fc8 100644
--- a/storage/innobase/os/os0file.cc
+++ b/storage/innobase/os/os0file.cc
@@ -4032,8 +4032,8 @@ static bool is_linux_native_aio_supported()
 
 bool os_aio_init(ulint n_reader_threads, ulint n_writer_threads, ulint)
 {
-	int max_write_events = (int)n_writer_threads * OS_AIO_N_PENDING_IOS_PER_THREAD;
-	int max_read_events = (int)n_reader_threads * OS_AIO_N_PENDING_IOS_PER_THREAD;
+  int max_write_events= int(n_writer_threads * OS_AIO_N_PENDING_IOS_PER_THREAD);
+  int max_read_events= int(n_reader_threads * OS_AIO_N_PENDING_IOS_PER_THREAD);
 	int max_ibuf_events = 1 * OS_AIO_N_PENDING_IOS_PER_THREAD;
 	int max_events = max_read_events + max_write_events + max_ibuf_events;
 	int ret;
diff --git a/storage/innobase/page/page0cur.cc b/storage/innobase/page/page0cur.cc
index 9df2d2c0d29..c1c389fed67 100644
--- a/storage/innobase/page/page0cur.cc
+++ b/storage/innobase/page/page0cur.cc
@@ -1866,7 +1866,7 @@ too_small:
     static_assert(UNIV_ZIP_SIZE_SHIFT_MAX == 14, "compatibility");
     if (next_rec)
     {
-      next_rec+= static_cast<int16_t>(free_rec);
+      next_rec= static_cast<int16_t>(next_rec + free_rec);
       ut_ad(int{PAGE_NEW_SUPREMUM_END + REC_N_NEW_EXTRA_BYTES} <= next_rec);
       ut_ad(static_cast<uint16_t>(next_rec) < srv_page_size);
     }
@@ -2041,7 +2041,8 @@ static void page_mem_free(const buf_block_t &block, rec_t *rec,
   ut_ad(!block.page.zip.data);
   const rec_t *free= page_header_get_ptr(block.frame, PAGE_FREE);
 
-  const uint16_t n_heap= page_header_get_field(block.frame, PAGE_N_HEAP) - 1;
+  const uint16_t n_heap= uint16_t(page_header_get_field(block.frame,
+                                                        PAGE_N_HEAP) - 1);
   ut_ad(page_get_n_recs(block.frame) < (n_heap & 0x7fff));
   const bool deleting_top= n_heap == ((n_heap & 0x8000)
                                       ? (rec_get_heap_no_new(rec) | 0x8000)
@@ -2643,7 +2644,7 @@ corrupted:
       goto corrupted;
     if ((n= mach_read_from_2(free_rec - REC_NEXT)) != 0)
     {
-      n+= static_cast<uint16_t>(free_rec - block.frame);
+      n= static_cast<uint16_t>(n + free_rec - block.frame);
       if (UNIV_UNLIKELY(n < PAGE_NEW_SUPREMUM_END + REC_N_NEW_EXTRA_BYTES ||
                         heap_top < block.frame + n))
         goto corrupted;
diff --git a/storage/innobase/rem/rem0rec.cc b/storage/innobase/rem/rem0rec.cc
index 53bb2f4f1d8..78ed14311b1 100644
--- a/storage/innobase/rem/rem0rec.cc
+++ b/storage/innobase/rem/rem0rec.cc
@@ -351,7 +351,8 @@ start:
 	do {
 		if (mblob) {
 			if (i == index->first_user_field()) {
-				offs += FIELD_REF_SIZE;
+				offs = static_cast<offset_t>(offs
+							     + FIELD_REF_SIZE);
 				len = combine(offs, STORED_OFFPAGE);
 				any |= REC_OFFS_EXTERNAL;
 				field--;
@@ -424,8 +425,8 @@ start:
 			more, or when the field is stored externally. */
 			if ((len & 0x80) && DATA_BIG_COL(col)) {
 				/* 1exxxxxxx xxxxxxxx */
-				len <<= 8;
-				len = static_cast<offset_t>(len | *lens--);
+				len = static_cast<offset_t>(len << 8
+							    | *lens--);
 				offs = static_cast<offset_t>(offs
 							     + get_value(len));
 				if (UNIV_UNLIKELY(len & 0x4000)) {
@@ -439,9 +440,10 @@ start:
 				continue;
 			}
 
-			len = offs += len;
+			len = offs = static_cast<offset_t>(offs + len);
 		} else {
-			len = offs += field->fixed_len;
+			len = offs = static_cast<offset_t>(offs
+							   + field->fixed_len);
 		}
 	} while (field++, rec_offs_base(offsets)[++i] = len,
 		 i < rec_offs_n_fields(offsets));
@@ -665,7 +667,8 @@ rec_init_offsets(
 		do {
 			offset_t len;
 			if (UNIV_UNLIKELY(i == n_node_ptr_field)) {
-				len = offs += REC_NODE_PTR_SIZE;
+				len = offs = static_cast<offset_t>(
+					offs + REC_NODE_PTR_SIZE);
 				goto resolved;
 			}
 
@@ -708,10 +711,8 @@ rec_init_offsets(
 				if (DATA_BIG_COL(col)) {
 					if (len & 0x80) {
 						/* 1exxxxxxx xxxxxxxx */
-
-						len <<= 8;
 						len = static_cast<offset_t>(
-							len | *lens--);
+							len << 8 | *lens--);
 
 						/* B-tree node pointers
 						must not contain externally
@@ -726,9 +727,10 @@ rec_init_offsets(
 					}
 				}
 
-				len = offs += len;
+				len = offs = static_cast<offset_t>(offs + len);
 			} else {
-				len = offs += field->fixed_len;
+				len = offs = static_cast<offset_t>(
+					offs + field->fixed_len);
 			}
 resolved:
 			rec_offs_base(offsets)[i + 1] = len;
@@ -745,7 +747,7 @@ resolved:
 		offset_t any;
 
 		if (rec_get_1byte_offs_flag(rec)) {
-			offs += static_cast<offset_t>(n_fields);
+			offs = static_cast<offset_t>(offs + n_fields);
 			any = offs;
 			/* Determine offsets to fields */
 			do {
@@ -978,7 +980,8 @@ rec_get_offsets_reverse(
 	do {
 		offset_t len;
 		if (UNIV_UNLIKELY(i == n_node_ptr_field)) {
-			len = offs += REC_NODE_PTR_SIZE;
+			len = offs = static_cast<offset_t>(
+				offs + REC_NODE_PTR_SIZE);
 			goto resolved;
 		}
 
@@ -1018,9 +1021,8 @@ rec_get_offsets_reverse(
 			if (DATA_BIG_COL(col)) {
 				if (len & 0x80) {
 					/* 1exxxxxxx xxxxxxxx */
-					len <<= 8;
 					len = static_cast<offset_t>(
-						len | *lens++);
+						len << 8 | *lens++);
 
 					offs = static_cast<offset_t>(
 						offs + get_value(len));
@@ -1036,9 +1038,10 @@ rec_get_offsets_reverse(
 				}
 			}
 
-			len = offs += len;
+			len = offs = static_cast<offset_t>(offs + len);
 		} else {
-			len = offs += static_cast<offset_t>(field->fixed_len);
+			len = offs = static_cast<offset_t>(offs
+							   + field->fixed_len);
 		}
 resolved:
 		rec_offs_base(offsets)[i + 1] = len;
diff --git a/storage/innobase/row/row0ftsort.cc b/storage/innobase/row/row0ftsort.cc
index 614ca1d151f..a8e4a06b8ea 100644
--- a/storage/innobase/row/row0ftsort.cc
+++ b/storage/innobase/row/row0ftsort.cc
@@ -103,7 +103,8 @@ row_merge_create_fts_sort_index(
 		? DATA_VARCHAR : DATA_VARMYSQL;
 	field->col->mbminlen = idx_field->col->mbminlen;
 	field->col->mbmaxlen = idx_field->col->mbmaxlen;
-	field->col->len = HA_FT_MAXCHARLEN * unsigned(field->col->mbmaxlen);
+	field->col->len = static_cast<uint16_t>(
+		HA_FT_MAXCHARLEN * field->col->mbmaxlen);
 
 	field->fixed_len = 0;
 
diff --git a/storage/innobase/row/row0purge.cc b/storage/innobase/row/row0purge.cc
index 12aceaa0842..20685398a81 100644
--- a/storage/innobase/row/row0purge.cc
+++ b/storage/innobase/row/row0purge.cc
@@ -704,7 +704,7 @@ static void row_purge_reset_trx_id(purge_node_t* node, mtr_t* mtr)
 				byte*	ptr = rec_get_nth_field(
 					rec, offsets, trx_id_pos, &len);
 				ut_ad(len == DATA_TRX_ID_LEN);
-				uint16_t offs = page_offset(ptr);
+				size_t offs = page_offset(ptr);
 				mtr->memset(block, offs, DATA_TRX_ID_LEN, 0);
 				offs += DATA_TRX_ID_LEN;
 				mtr->write<1,mtr_t::OPT>(*block, block->frame
diff --git a/storage/innobase/row/row0umod.cc b/storage/innobase/row/row0umod.cc
index b17f4b99980..6822c4a363d 100644
--- a/storage/innobase/row/row0umod.cc
+++ b/storage/innobase/row/row0umod.cc
@@ -478,8 +478,7 @@ row_undo_mod_clust(
 					0, 1ULL << ROLL_PTR_INSERT_FLAG_POS,
 					&mtr);
 			} else {
-				uint16_t offs = page_offset(rec
-							    + trx_id_offset);
+				size_t offs = page_offset(rec + trx_id_offset);
 				mtr.memset(block, offs, DATA_TRX_ID_LEN, 0);
 				offs += DATA_TRX_ID_LEN;
 				mtr.write<1,mtr_t::OPT>(*block, block->frame
diff --git a/storage/innobase/trx/trx0i_s.cc b/storage/innobase/trx/trx0i_s.cc
index 78681ab68f8..2161044cc80 100644
--- a/storage/innobase/trx/trx0i_s.cc
+++ b/storage/innobase/trx/trx0i_s.cc
@@ -718,16 +718,16 @@ static bool fill_locks_row(
 		&& (lock->type_mode & LOCK_GAP);
 	switch (lock->type_mode & LOCK_MODE_MASK) {
 	case LOCK_S:
-		row->lock_mode = 1 + is_gap_lock;
+		row->lock_mode = uint8_t(1 + is_gap_lock);
 		break;
 	case LOCK_X:
-		row->lock_mode = 3 + is_gap_lock;
+		row->lock_mode = uint8_t(3 + is_gap_lock);
 		break;
 	case LOCK_IS:
-		row->lock_mode = 5 + is_gap_lock;
+		row->lock_mode = uint8_t(5 + is_gap_lock);
 		break;
 	case LOCK_IX:
-		row->lock_mode = 7 + is_gap_lock;
+		row->lock_mode = uint8_t(7 + is_gap_lock);
 		break;
 	case LOCK_AUTO_INC:
 		row->lock_mode = 9;
diff --git a/storage/innobase/trx/trx0purge.cc b/storage/innobase/trx/trx0purge.cc
index df370d91c0b..762ee1fd461 100644
--- a/storage/innobase/trx/trx0purge.cc
+++ b/storage/innobase/trx/trx0purge.cc
@@ -294,9 +294,9 @@ trx_purge_add_undo_to_history(const trx_t* trx, trx_undo_t*& undo, mtr_t* mtr)
 	}
 
 	/* Add the log as the first in the history list */
-	flst_add_first(rseg_header, TRX_RSEG + TRX_RSEG_HISTORY,
-		       undo_page, undo->hdr_offset + TRX_UNDO_HISTORY_NODE,
-		       mtr);
+	flst_add_first(rseg_header, TRX_RSEG + TRX_RSEG_HISTORY, undo_page,
+		       static_cast<uint16_t>(undo->hdr_offset
+					     + TRX_UNDO_HISTORY_NODE), mtr);
 
 	mtr->write<8>(*undo_page, undo_header + TRX_UNDO_TRX_NO, trx->no);
 	/* This is needed for upgrading old undo log pages from
@@ -336,7 +336,7 @@ static void trx_purge_remove_log_hdr(buf_block_t *rseg, buf_block_t* log,
                                      uint16_t offset, mtr_t *mtr)
 {
   flst_remove(rseg, TRX_RSEG + TRX_RSEG_HISTORY,
-              log, offset + TRX_UNDO_HISTORY_NODE, mtr);
+              log, static_cast<uint16_t>(offset + TRX_UNDO_HISTORY_NODE), mtr);
   trx_sys.rseg_history_len--;
 }
 
@@ -438,8 +438,11 @@ trx_purge_truncate_rseg_history(
 
 	buf_block_t* rseg_hdr = trx_rsegf_get(rseg.space, rseg.page_no, &mtr);
 
-	hdr_addr = trx_purge_get_log_from_hist(
-		flst_get_last(TRX_RSEG + TRX_RSEG_HISTORY + rseg_hdr->frame));
+	hdr_addr = flst_get_last(TRX_RSEG + TRX_RSEG_HISTORY
+				 + rseg_hdr->frame);
+	hdr_addr.boffset = static_cast<uint16_t>(hdr_addr.boffset
+						 - TRX_UNDO_HISTORY_NODE);
+
 loop:
 	if (hdr_addr.page == FIL_NULL) {
 func_exit:
@@ -464,9 +467,10 @@ func_exit:
 		goto func_exit;
 	}
 
-	prev_hdr_addr = trx_purge_get_log_from_hist(
-		flst_get_prev_addr(block->frame + hdr_addr.boffset
-				   + TRX_UNDO_HISTORY_NODE));
+	prev_hdr_addr = flst_get_prev_addr(block->frame + hdr_addr.boffset
+					   + TRX_UNDO_HISTORY_NODE);
+	prev_hdr_addr.boffset = static_cast<uint16_t>(prev_hdr_addr.boffset
+						      - TRX_UNDO_HISTORY_NODE);
 
 	if (mach_read_from_2(TRX_UNDO_SEG_HDR + TRX_UNDO_STATE + block->frame)
 	    == TRX_UNDO_TO_PURGE
@@ -841,8 +845,10 @@ static void trx_purge_rseg_get_next_history_log(
 
 	(*n_pages_handled)++;
 
-	prev_log_addr = trx_purge_get_log_from_hist(
-		flst_get_prev_addr(log_hdr + TRX_UNDO_HISTORY_NODE));
+	prev_log_addr = flst_get_prev_addr(log_hdr + TRX_UNDO_HISTORY_NODE);
+	prev_log_addr.boffset = static_cast<uint16_t>(prev_log_addr.boffset
+						      - TRX_UNDO_HISTORY_NODE);
+
 
 	const bool empty = prev_log_addr.page == FIL_NULL;
 
diff --git a/storage/innobase/trx/trx0rseg.cc b/storage/innobase/trx/trx0rseg.cc
index b61a2331f46..ccc8ccb6ac1 100644
--- a/storage/innobase/trx/trx0rseg.cc
+++ b/storage/innobase/trx/trx0rseg.cc
@@ -510,9 +510,11 @@ trx_rseg_mem_restore(trx_rseg_t* rseg, trx_id_t& max_trx_id, mtr_t* mtr)
 				    + rseg_hdr->frame)) {
 		trx_sys.rseg_history_len += len;
 
-		fil_addr_t	node_addr = trx_purge_get_log_from_hist(
-			flst_get_last(TRX_RSEG + TRX_RSEG_HISTORY
-				      + rseg_hdr->frame));
+		fil_addr_t node_addr = flst_get_last(TRX_RSEG
+						     + TRX_RSEG_HISTORY
+						     + rseg_hdr->frame);
+		node_addr.boffset = static_cast<uint16_t>(
+			node_addr.boffset - TRX_UNDO_HISTORY_NODE);
 
 		rseg->last_page_no = node_addr.page;
 		rseg->last_offset = node_addr.boffset;