_BitInt bit-field support [PR102989]

Message ID ZMp9YaTkwBZi7l69@tucnak
State New
Headers
Series _BitInt bit-field support [PR102989] |

Checks

Context Check Description
linaro-tcwg-bot/tcwg_gcc_build--master-aarch64 warning Patch failed to apply
linaro-tcwg-bot/tcwg_gcc_check--master-aarch64 warning Patch failed to apply
linaro-tcwg-bot/tcwg_gcc_build--master-arm warning Patch failed to apply
linaro-tcwg-bot/tcwg_gcc_check--master-arm warning Patch failed to apply

Commit Message

Jakub Jelinek Aug. 2, 2023, 3:59 p.m. UTC
  Hi!

On Fri, Jul 28, 2023 at 06:37:23PM +0000, Joseph Myers wrote:
> Yes, the type used in _Generic isn't fully specified, just the type after 
> integer promotions in contexts where those occur.

Ok.  I've removed those static_asserts from the test then, no need to test
what isn't fully specified...

> > static_assert (expr_has_type (s4.c + 1uwb, _BitInt(389)));
> > static_assert (expr_has_type (s4.d * 0wb, _BitInt(2)));
> > static_assert (expr_has_type (s6.a + 0wb, _BitInt(2)));
> > That looks to me like LLVM bug, because
> > "The value from a bit-field of a bit-precise integer type is converted to
> > the corresponding bit-precise integer type."
> > specifies that s4.c has _BitInt(389) type after integer promotions
> > and s4.d and s6.a have _BitInt(2) type.  Now, 1uwb has unsigned _BitInt(1)
> > type and 0wb has _BitInt(2) and the common type for those in all cases is
> > I believe the type of the left operand.
> 
> Indeed, I'd expect those to pass, since in those cases integer promotions 
> (to the declared _BitInt type of the bit-field, without the bit-field 
> width) are applied.

Here is an updated patch on top of the initially posted 0/5 patch series
which implements the _BitInt bit-field support including its lowering.

2023-08-02  Jakub Jelinek  <jakub@redhat.com>

	PR c/102989
gcc/
	* tree.h (CONSTRUCTOR_BITFIELD_P): Return true even for BLKmode
	bit-fields if they have BITINT_TYPE type.
	* stor-layout.cc (finish_bitfield_representative): For bit-fields
	with BITINT_TYPE, prefer representatives with precisions in
	multiple of limb precision.
	* gimple-lower-bitint.cc (struct bitint_large_huge): Declare
	handle_load method.  Add m_upwards, m_cast_conditional and
	m_bitfld_load members.
	(bitint_large_huge::limb_access): Use CEIL instead of normal
	truncating division.
	(bitint_large_huge::handle_cast): For m_upwards even if not
	m_upwards_2limb compute ext only when processing the corresponding
	limb rather than upfront.  Deal with handle_operand in 2 separate
	branches doing bit-field loads.
	(bitint_large_huge::handle_load): New method.
	(bitint_large_huge::handle_stmt): Use handle_load for loads.
	(bitint_large_huge::lower_mergeable_stmt): Handle stores into
	bit-fields.  Set m_upwards.
	(bitint_large_huge::lower_addsub_overflow): Set m_upwards.
	(bitint_large_huge::lower_stmt): Clear m_upwards, m_cast_conditional
	and m_bitfld_load.
	(stmt_needs_operand_addr): New function.
	(gimple_lower_bitint): Punt on merging loads from bit-fields and/or
	stores into bit-fields with statements whose lowering doesn't or can't
	handle those.
gcc/c/
	* c-decl.cc (check_bitfield_type_and_width): Allow BITINT_TYPE
	bit-fields.
	(finish_struct): Prefer to use BITINT_TYPE for BITINT_TYPE bit-fields
	if possible.
	* c-typeck.cc (perform_integral_promotions): Promote BITINT_TYPE
	bit-fields to their declared type.
gcc/testsuite/
	* gcc.dg/bitint-17.c: New test.
	* gcc.dg/torture/bitint-42.c: New test.



	Jakub
  

Patch

--- gcc/tree.h.jj	2023-07-11 15:28:54.703679523 +0200
+++ gcc/tree.h	2023-07-31 20:09:42.329267570 +0200
@@ -1259,7 +1259,9 @@  extern void omp_clause_range_check_faile
 /* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
    constructor output purposes.  */
 #define CONSTRUCTOR_BITFIELD_P(NODE) \
-  (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) && DECL_MODE (NODE) != BLKmode)
+  (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) \
+   && (DECL_MODE (NODE) != BLKmode \
+       || TREE_CODE (TREE_TYPE (NODE)) == BITINT_TYPE))
 
 /* True if NODE is a clobber right hand side, an expression of indeterminate
    value that clobbers the LHS in a copy instruction.  We use a volatile
--- gcc/stor-layout.cc.jj	2023-07-19 19:35:10.639889885 +0200
+++ gcc/stor-layout.cc	2023-08-01 13:08:02.667892939 +0200
@@ -2148,6 +2148,22 @@  finish_bitfield_representative (tree rep
       || GET_MODE_BITSIZE (mode) > maxbitsize
       || GET_MODE_BITSIZE (mode) > MAX_FIXED_MODE_SIZE)
     {
+      if (TREE_CODE (TREE_TYPE (field)) == BITINT_TYPE)
+	{
+	  struct bitint_info info;
+	  unsigned prec = TYPE_PRECISION (TREE_TYPE (field));
+	  gcc_assert (targetm.c.bitint_type_info (prec, &info));
+	  scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
+	  unsigned lprec = GET_MODE_PRECISION (limb_mode);
+	  if (prec > lprec)
+	    {
+	      /* For middle/large/huge _BitInt prefer bitsize being a multiple
+		 of limb precision.  */
+	      unsigned HOST_WIDE_INT bsz = CEIL (bitsize, lprec) * lprec;
+	      if (bsz <= maxbitsize)
+		bitsize = bsz;
+	    }
+	}
       /* We really want a BLKmode representative only as a last resort,
          considering the member b in
 	   struct { int a : 7; int b : 17; int c; } __attribute__((packed));
--- gcc/gimple-lower-bitint.cc.jj	2023-07-27 14:36:10.482101391 +0200
+++ gcc/gimple-lower-bitint.cc	2023-08-02 17:00:36.031655864 +0200
@@ -418,6 +418,7 @@  struct bitint_large_huge
   tree handle_plus_minus (tree_code, tree, tree, tree);
   tree handle_lshift (tree, tree, tree);
   tree handle_cast (tree, tree, tree);
+  tree handle_load (gimple *, tree);
   tree handle_stmt (gimple *, tree);
   tree handle_operand_addr (tree, gimple *, int *, int *);
   tree create_loop (tree, tree *);
@@ -483,7 +484,9 @@  struct bitint_large_huge
      iteration handles 2 limbs, plus there can be up to one full limb
      and one partial limb processed after the loop, where handle_operand
      and/or handle_stmt are called with constant idx.  m_upwards_2limb
-     is set for this case, false otherwise.
+     is set for this case, false otherwise.  m_upwards is true if it
+     is either large or huge _BitInt handled by lower_mergeable_stmt,
+     i.e. indexes always increase.
 
      Another way is used by lower_comparison_stmt, which walks limbs
      from most significant to least significant, partial limb if any
@@ -511,10 +514,22 @@  struct bitint_large_huge
      just needs to bump m_data_cnt by the same amount as when it was
      called with m_first set.  The toplevel calls to
      handle_operand/handle_stmt should set m_data_cnt to 0 and truncate
-     m_data vector when setting m_first to true.  */
+     m_data vector when setting m_first to true.
+
+     m_cast_conditional and m_bitfld_load are used when handling a
+     bit-field load inside of a widening cast.  handle_cast sometimes
+     needs to do runtime comparisons and handle_operand only conditionally
+     or even in two separate conditional blocks for one idx (once with
+     constant index after comparing the runtime one for equality with the
+     constant).  In these cases, m_cast_conditional is set to true and
+     the bit-field load then communicates its m_data_cnt to handle_cast
+     using m_bitfld_load.  */
   bool m_first;
   bool m_var_msb;
   unsigned m_upwards_2limb;
+  bool m_upwards;
+  bool m_cast_conditional;
+  unsigned m_bitfld_load;
   vec<tree> m_data;
   unsigned int m_data_cnt;
 };
@@ -598,7 +613,7 @@  bitint_large_huge::limb_access (tree typ
 					 TREE_TYPE (TREE_TYPE (var))))
 	{
 	  unsigned HOST_WIDE_INT nelts
-	    = tree_to_uhwi (TYPE_SIZE (type)) / limb_prec;
+	    = CEIL (tree_to_uhwi (TYPE_SIZE (type)), limb_prec);
 	  tree atype = build_array_type_nelts (m_limb_type, nelts);
 	  var = build1 (VIEW_CONVERT_EXPR, atype, var);
 	}
@@ -1142,6 +1157,11 @@  bitint_large_huge::handle_cast (tree lhs
 	  if (TYPE_UNSIGNED (rhs_type))
 	    /* No need to keep state between iterations.  */
 	    ;
+	  else if (m_upwards && !m_upwards_2limb)
+	    /* We need to keep state between iterations, but
+	       not within any loop, everything is straight line
+	       code with only increasing indexes.  */
+	    ;
 	  else if (!m_upwards_2limb)
 	    {
 	      unsigned save_data_cnt = m_data_cnt;
@@ -1225,16 +1245,26 @@  bitint_large_huge::handle_cast (tree lhs
 	      e2 = find_edge (e2->dest, e3->dest);
 	    }
 	  m_gsi = gsi_after_labels (e2->src);
+	  bool save_cast_conditional = m_cast_conditional;
+	  m_cast_conditional = true;
+	  m_bitfld_load = 0;
 	  tree t1 = handle_operand (rhs1, idx), t2 = NULL_TREE;
 	  if (m_first)
 	    m_data[save_data_cnt + 2]
 	      = build_int_cst (NULL_TREE, m_data_cnt);
 	  tree ext = NULL_TREE;
+	  tree bitfld = NULL_TREE;
 	  if (!single_comparison)
 	    {
 	      m_gsi = gsi_after_labels (e4->src);
 	      m_first = false;
 	      m_data_cnt = save_data_cnt + 3;
+	      if (m_bitfld_load)
+		{
+		  bitfld = m_data[m_bitfld_load];
+		  m_data[m_bitfld_load] = m_data[m_bitfld_load + 2];
+		  m_bitfld_load = 0;
+		}
 	      t2 = handle_operand (rhs1, size_int (low));
 	      if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (t2)))
 		t2 = add_cast (m_limb_type, t2);
@@ -1274,6 +1304,25 @@  bitint_large_huge::handle_cast (tree lhs
 	      g = gimple_build_assign (m_data[save_data_cnt + 1], t4);
 	      insert_before (g);
 	    }
+	  if (m_bitfld_load)
+	    {
+	      tree t4;
+	      if (!m_first)
+		t4 = m_data[m_bitfld_load + 1];
+	      else
+		t4 = make_ssa_name (m_limb_type);
+	      phi = create_phi_node (t4, e2->dest);
+	      add_phi_arg (phi, e4 ? bitfld : m_data[m_bitfld_load],
+			   e2, UNKNOWN_LOCATION);
+	      add_phi_arg (phi, m_data[m_bitfld_load + 2],
+			   e3, UNKNOWN_LOCATION);
+	      if (e4)
+		add_phi_arg (phi, m_data[m_bitfld_load], e4, UNKNOWN_LOCATION);
+	      m_data[m_bitfld_load] = t4;
+	      m_data[m_bitfld_load + 2] = t4;
+	      m_bitfld_load = 0;
+	    }
+	  m_cast_conditional = save_cast_conditional;
 	  m_first = save_first;
 	  return t;
 	}
@@ -1295,7 +1344,7 @@  bitint_large_huge::handle_cast (tree lhs
 	      if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (t)))
 		t = add_cast (m_limb_type, t);
 	      tree ext = NULL_TREE;
-	      if (!TYPE_UNSIGNED (rhs_type) && m_upwards_2limb)
+	      if (!TYPE_UNSIGNED (rhs_type) && m_upwards)
 		{
 		  ext = add_cast (signed_type_for (m_limb_type), t);
 		  tree lpm1 = build_int_cst (unsigned_type_node,
@@ -1473,54 +1522,277 @@  bitint_large_huge::handle_cast (tree lhs
   return NULL_TREE;
 }
 
-/* Return a limb IDX from a mergeable statement STMT.  */
+/* Helper function for handle_stmt method, handle a load from memory.  */
 
 tree
-bitint_large_huge::handle_stmt (gimple *stmt, tree idx)
+bitint_large_huge::handle_load (gimple *stmt, tree idx)
 {
-  tree lhs, rhs1, rhs2 = NULL_TREE;
+  tree rhs1 = gimple_assign_rhs1 (stmt);
+  tree rhs_type = TREE_TYPE (rhs1);
+  bool eh = stmt_ends_bb_p (stmt);
+  edge eh_edge = NULL;
   gimple *g;
-  switch (gimple_code (stmt))
+
+  if (eh)
     {
-    case GIMPLE_ASSIGN:
-      if (gimple_assign_load_p (stmt))
+      edge_iterator ei;
+      basic_block bb = gimple_bb (stmt);
+
+      FOR_EACH_EDGE (eh_edge, ei, bb->succs)
+	if (eh_edge->flags & EDGE_EH)
+	    break;
+    }
+
+  if (TREE_CODE (rhs1) == COMPONENT_REF
+      && DECL_BIT_FIELD_TYPE (TREE_OPERAND (rhs1, 1)))
+    {
+      tree fld = TREE_OPERAND (rhs1, 1);
+      /* For little-endian, we can allow as inputs bit-fields
+	 which start at a limb boundary.  */
+      gcc_assert (tree_fits_uhwi_p (DECL_FIELD_BIT_OFFSET (fld)));
+      if (DECL_OFFSET_ALIGN (fld) >= TYPE_ALIGN (TREE_TYPE (rhs1))
+	  && (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld)) % limb_prec) == 0)
+	goto normal_load;
+      /* Even if DECL_FIELD_BIT_OFFSET (fld) is a multiple of UNITS_PER_BIT,
+	 handle it normally for now.  */
+      if ((tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld)) % BITS_PER_UNIT) == 0)
+	goto normal_load;
+      tree repr = DECL_BIT_FIELD_REPRESENTATIVE (fld);
+      poly_int64 bitoffset;
+      poly_uint64 field_offset, repr_offset;
+      bool var_field_off = false;
+      if (poly_int_tree_p (DECL_FIELD_OFFSET (fld), &field_offset)
+	  && poly_int_tree_p (DECL_FIELD_OFFSET (repr), &repr_offset))
+	bitoffset = (field_offset - repr_offset) * BITS_PER_UNIT;
+      else
 	{
-	  rhs1 = gimple_assign_rhs1 (stmt);
-	  tree rhs_type = TREE_TYPE (rhs1);
-	  bool eh = stmt_ends_bb_p (stmt);
-	  /* Use write_p = true for loads with EH edges to make
-	     sure limb_access doesn't add a cast as separate
-	     statement after it.  */
-	  rhs1 = limb_access (rhs_type, rhs1, idx, eh);
-	  lhs = make_ssa_name (TREE_TYPE (rhs1));
-	  g = gimple_build_assign (lhs, rhs1);
+	  bitoffset = 0;
+	  var_field_off = true;
+	}
+      bitoffset += (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld))
+		    - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)));
+      tree nrhs1 = build3 (COMPONENT_REF, TREE_TYPE (repr),
+			   TREE_OPERAND (rhs1, 0), repr,
+			   var_field_off ? TREE_OPERAND (rhs1, 2) : NULL_TREE);
+      HOST_WIDE_INT bo = bitoffset.to_constant ();
+      unsigned bo_idx = (unsigned HOST_WIDE_INT) bo / limb_prec;
+      unsigned bo_bit = (unsigned HOST_WIDE_INT) bo % limb_prec;
+      if (m_first)
+	{
+	  if (m_upwards)
+	    {
+	      gimple_stmt_iterator save_gsi = m_gsi;
+	      m_gsi = m_init_gsi;
+	      if (gsi_end_p (m_gsi))
+		m_gsi = gsi_after_labels (gsi_bb (m_gsi));
+	      else
+		gsi_next (&m_gsi);
+	      tree t = limb_access (rhs_type, nrhs1, size_int (bo_idx), true);
+	      tree iv = make_ssa_name (m_limb_type);
+	      g = gimple_build_assign (iv, t);
+	      insert_before (g);
+	      if (eh)
+		{
+		  maybe_duplicate_eh_stmt (g, stmt);
+		  if (eh_edge)
+		    {
+		      edge e = split_block (gsi_bb (m_gsi), g);
+		      make_edge (e->src, eh_edge->dest, EDGE_EH)->probability
+			= profile_probability::very_unlikely ();
+		      m_init_gsi.bb = e->dest;
+		    }
+		}
+	      m_gsi = save_gsi;
+	      tree out;
+	      prepare_data_in_out (iv, idx, &out);
+	      out = m_data[m_data_cnt];
+	      m_data.safe_push (out);
+	    }
+	  else
+	    {
+	      m_data.safe_push (NULL_TREE);
+	      m_data.safe_push (NULL_TREE);
+	      m_data.safe_push (NULL_TREE);
+	    }
+	}
+
+      tree nidx0 = NULL_TREE, nidx1;
+      tree iv = m_data[m_data_cnt];
+      if (m_cast_conditional && iv)
+	{
+	  gcc_assert (!m_bitfld_load);
+	  m_bitfld_load = m_data_cnt;
+	}
+      if (tree_fits_uhwi_p (idx))
+	{
+	  unsigned prec = TYPE_PRECISION (rhs_type);
+	  unsigned HOST_WIDE_INT i = tree_to_uhwi (idx);
+	  gcc_assert (i * limb_prec < prec);
+	  nidx1 = size_int (i + bo_idx + 1);
+	  if ((i + 1) * limb_prec > prec)
+	    {
+	      prec %= limb_prec;
+	      if (prec + bo_bit <= (unsigned) limb_prec)
+		nidx1 = NULL_TREE;
+	    }
+	  if (!iv)
+	    nidx0 = size_int (i + bo_idx);
+	}
+      else
+	{
+	  if (!iv)
+	    {
+	      if (bo_idx == 0)
+		nidx0 = idx;
+	      else
+		{
+		  nidx0 = make_ssa_name (sizetype);
+		  g = gimple_build_assign (nidx0, PLUS_EXPR, idx,
+					   size_int (bo_idx));
+		  insert_before (g);
+		}
+	    }
+	  nidx1 = make_ssa_name (sizetype);
+	  g = gimple_build_assign (nidx1, PLUS_EXPR, idx,
+				   size_int (bo_idx + 1));
+	  insert_before (g);
+	}
+
+      tree iv2 = NULL_TREE;
+      if (nidx0)
+	{
+	  tree t = limb_access (rhs_type, nrhs1, nidx0, true);
+	  iv = make_ssa_name (m_limb_type);
+	  g = gimple_build_assign (iv, t);
+	  insert_before (g);
+	  gcc_assert (!eh);
+	}
+      if (nidx1)
+	{
+	  bool conditional = m_var_msb && !tree_fits_uhwi_p (idx);
+	  unsigned prec = TYPE_PRECISION (rhs_type);
+	  if (conditional)
+	    {
+	      if ((prec % limb_prec) == 0
+		  || ((prec % limb_prec) + bo_bit > (unsigned) limb_prec))
+		conditional = false;
+	    }
+	  edge e1 = NULL, e2 = NULL, e3 = NULL;
+	  if (conditional)
+	    {
+	      g = gimple_build_cond (EQ_EXPR, idx,
+				     size_int (prec / limb_prec),
+				     NULL_TREE, NULL_TREE);
+	      insert_before (g);
+	      e1 = split_block (gsi_bb (m_gsi), g);
+	      e2 = split_block (e1->dest, (gimple *) NULL);
+	      e3 = make_edge (e1->src, e2->dest, EDGE_TRUE_VALUE);
+	      e3->probability = profile_probability::unlikely ();
+	      e1->flags = EDGE_FALSE_VALUE;
+	      e1->probability = e3->probability.invert ();
+	      set_immediate_dominator (CDI_DOMINATORS, e2->dest, e1->src);
+	      m_gsi = gsi_after_labels (e1->dest);
+	    }
+	  tree t = limb_access (rhs_type, nrhs1, nidx1, true);
+	  if (m_upwards_2limb
+	      && !m_first
+	      && !m_bitfld_load
+	      && !tree_fits_uhwi_p (idx))
+	    iv2 = m_data[m_data_cnt + 1];
+	  else
+	    iv2 = make_ssa_name (m_limb_type);
+	  g = gimple_build_assign (iv2, t);
 	  insert_before (g);
 	  if (eh)
 	    {
 	      maybe_duplicate_eh_stmt (g, stmt);
-	      edge e1;
-	      edge_iterator ei;
-	      basic_block bb = gimple_bb (stmt);
-
-	      FOR_EACH_EDGE (e1, ei, bb->succs)
-		if (e1->flags & EDGE_EH)
-		  break;
-	      if (e1)
+	      if (eh_edge)
 		{
-		  edge e2 = split_block (gsi_bb (m_gsi), g);
-		  m_gsi = gsi_after_labels (e2->dest);
-		  make_edge (e2->src, e1->dest, EDGE_EH)->probability
+		  edge e = split_block (gsi_bb (m_gsi), g);
+		  m_gsi = gsi_after_labels (e->dest);
+		  make_edge (e->src, eh_edge->dest, EDGE_EH)->probability
 		    = profile_probability::very_unlikely ();
 		}
-	      if (tree_fits_uhwi_p (idx))
-		{
-		  tree atype = limb_access_type (rhs_type, idx);
-		  if (!useless_type_conversion_p (atype, TREE_TYPE (rhs1)))
-		    lhs = add_cast (atype, lhs);
-		}
 	    }
-	  return lhs;
+	  if (conditional)
+	    {
+	      tree iv3 = make_ssa_name (m_limb_type);
+	      if (eh)
+		e2 = find_edge (gsi_bb (m_gsi), e3->dest);
+	      gphi *phi = create_phi_node (iv3, e2->dest);
+	      add_phi_arg (phi, iv2, e2, UNKNOWN_LOCATION);
+	      add_phi_arg (phi, build_zero_cst (m_limb_type),
+			   e3, UNKNOWN_LOCATION);
+	      m_gsi = gsi_after_labels (e2->dest);
+	    }
 	}
+      g = gimple_build_assign (make_ssa_name (m_limb_type), RSHIFT_EXPR,
+			       iv, build_int_cst (unsigned_type_node, bo_bit));
+      insert_before (g);
+      iv = gimple_assign_lhs (g);
+      if (iv2)
+	{
+	  g = gimple_build_assign (make_ssa_name (m_limb_type), LSHIFT_EXPR,
+				   iv2, build_int_cst (unsigned_type_node,
+						       limb_prec - bo_bit));
+	  insert_before (g);
+	  g = gimple_build_assign (make_ssa_name (m_limb_type), BIT_IOR_EXPR,
+				   gimple_assign_lhs (g), iv);
+	  insert_before (g);
+	  iv = gimple_assign_lhs (g);
+	  if (m_data[m_data_cnt])
+	    m_data[m_data_cnt] = iv2;
+	}
+      if (tree_fits_uhwi_p (idx))
+	{
+	  tree atype = limb_access_type (rhs_type, idx);
+	  if (!useless_type_conversion_p (atype, TREE_TYPE (iv)))
+	    iv = add_cast (atype, iv);
+	}
+      m_data_cnt += 3;
+      return iv;
+    }
+
+normal_load:
+  /* Use write_p = true for loads with EH edges to make
+     sure limb_access doesn't add a cast as separate
+     statement after it.  */
+  rhs1 = limb_access (rhs_type, rhs1, idx, eh);
+  tree ret = make_ssa_name (TREE_TYPE (rhs1));
+  g = gimple_build_assign (ret, rhs1);
+  insert_before (g);
+  if (eh)
+    {
+      maybe_duplicate_eh_stmt (g, stmt);
+      if (eh_edge)
+	{
+	  edge e = split_block (gsi_bb (m_gsi), g);
+	  m_gsi = gsi_after_labels (e->dest);
+	  make_edge (e->src, eh_edge->dest, EDGE_EH)->probability
+	    = profile_probability::very_unlikely ();
+	}
+      if (tree_fits_uhwi_p (idx))
+	{
+	  tree atype = limb_access_type (rhs_type, idx);
+	  if (!useless_type_conversion_p (atype, TREE_TYPE (rhs1)))
+	    ret = add_cast (atype, ret);
+	}
+    }
+  return ret;
+}
+
+/* Return a limb IDX from a mergeable statement STMT.  */
+
+tree
+bitint_large_huge::handle_stmt (gimple *stmt, tree idx)
+{
+  tree lhs, rhs1, rhs2 = NULL_TREE;
+  gimple *g;
+  switch (gimple_code (stmt))
+    {
+    case GIMPLE_ASSIGN:
+      if (gimple_assign_load_p (stmt))
+	return handle_load (stmt, idx);
       switch (gimple_assign_rhs_code (stmt))
 	{
 	case BIT_AND_EXPR:
@@ -1899,6 +2171,10 @@  bitint_large_huge::lower_mergeable_stmt
   tree ext = NULL_TREE, store_operand = NULL_TREE;
   bool eh = false;
   basic_block eh_pad = NULL;
+  tree nlhs = NULL_TREE;
+  unsigned HOST_WIDE_INT bo_idx = 0;
+  unsigned HOST_WIDE_INT bo_bit = 0;
+  tree bf_cur = NULL_TREE, bf_next = NULL_TREE;
   if (gimple_store_p (stmt))
     {
       store_operand = gimple_assign_rhs1 (stmt);
@@ -1916,6 +2192,38 @@  bitint_large_huge::lower_mergeable_stmt
 		break;
 	      }
 	}
+      if (TREE_CODE (lhs) == COMPONENT_REF
+	  && DECL_BIT_FIELD_TYPE (TREE_OPERAND (lhs, 1)))
+	{
+	  tree fld = TREE_OPERAND (lhs, 1);
+	  gcc_assert (tree_fits_uhwi_p (DECL_FIELD_BIT_OFFSET (fld)));
+	  tree repr = DECL_BIT_FIELD_REPRESENTATIVE (fld);
+	  poly_int64 bitoffset;
+	  poly_uint64 field_offset, repr_offset;
+	  if ((tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld)) % BITS_PER_UNIT) == 0)
+	    nlhs = lhs;
+	  else
+	    {
+	      bool var_field_off = false;
+	      if (poly_int_tree_p (DECL_FIELD_OFFSET (fld), &field_offset)
+		  && poly_int_tree_p (DECL_FIELD_OFFSET (repr), &repr_offset))
+		bitoffset = (field_offset - repr_offset) * BITS_PER_UNIT;
+	      else
+		{
+		  bitoffset = 0;
+		  var_field_off = true;
+		}
+	      bitoffset += (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld))
+			    - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)));
+	      nlhs = build3 (COMPONENT_REF, TREE_TYPE (repr),
+			     TREE_OPERAND (lhs, 0), repr,
+			     var_field_off
+			     ? TREE_OPERAND (lhs, 2) : NULL_TREE);
+	      HOST_WIDE_INT bo = bitoffset.to_constant ();
+	      bo_idx = (unsigned HOST_WIDE_INT) bo / limb_prec;
+	      bo_bit = (unsigned HOST_WIDE_INT) bo % limb_prec;
+	    }
+	}
     }
   if ((store_operand
        && TREE_CODE (store_operand) == SSA_NAME
@@ -1976,6 +2284,12 @@  bitint_large_huge::lower_mergeable_stmt
     m_after_stmt = stmt;
   if (kind != bitint_prec_large)
     m_upwards_2limb = end;
+  m_upwards = true;
+
+  bool separate_ext
+    = (prec != (unsigned) TYPE_PRECISION (type)
+       && (CEIL ((unsigned) TYPE_PRECISION (type), limb_prec)
+	   > CEIL (prec, limb_prec)));
 
   for (unsigned i = 0; i < cnt; i++)
     {
@@ -2005,24 +2319,156 @@  bitint_large_huge::lower_mergeable_stmt
 	    rhs1 = handle_operand (store_operand, idx);
 	  else
 	    rhs1 = handle_stmt (stmt, idx);
-	  tree l = limb_access (lhs_type, lhs, idx, true);
-	  if (!useless_type_conversion_p (TREE_TYPE (l), TREE_TYPE (rhs1)))
-	    rhs1 = add_cast (TREE_TYPE (l), rhs1);
+	  if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (rhs1)))
+	    rhs1 = add_cast (m_limb_type, rhs1);
 	  if (sext && i == cnt - 1)
 	    ext = rhs1;
-	  g = gimple_build_assign (l, rhs1);
-	  insert_before (g);
-	  if (eh)
+	  tree nidx = idx;
+	  if (bo_idx)
 	    {
-	      maybe_duplicate_eh_stmt (g, stmt);
-	      if (eh_pad)
+	      if (tree_fits_uhwi_p (idx))
+		nidx = size_int (tree_to_uhwi (idx) + bo_idx);
+	      else
 		{
-		  edge e = split_block (gsi_bb (m_gsi), g);
-		  m_gsi = gsi_after_labels (e->dest);
-		  make_edge (e->src, eh_pad, EDGE_EH)->probability
-		    = profile_probability::very_unlikely ();
+		  nidx = make_ssa_name (sizetype);
+		  g = gimple_build_assign (nidx, PLUS_EXPR, idx,
+					   size_int (bo_idx));
+		  insert_before (g);
 		}
 	    }
+	  bool done = false;
+	  basic_block new_bb = NULL;
+	  /* Handle stores into bit-fields.  */
+	  if (bo_bit)
+	    {
+	      if (i == 0)
+		{
+		  edge e2 = NULL;
+		  if (kind != bitint_prec_large)
+		    {
+		      prepare_data_in_out (build_zero_cst (m_limb_type),
+					   idx, &bf_next);
+		      bf_next = m_data.pop ();
+		      bf_cur = m_data.pop ();
+		      g = gimple_build_cond (EQ_EXPR, idx, size_zero_node,
+					     NULL_TREE, NULL_TREE);
+		      insert_before (g);
+		      edge e1 = split_block (gsi_bb (m_gsi), g);
+		      e2 = split_block (e1->dest, (gimple *) NULL);
+		      basic_block bb = create_empty_bb (e1->dest);
+		      add_bb_to_loop (bb, e1->dest->loop_father);
+		      edge e3 = make_edge (e1->src, bb, EDGE_TRUE_VALUE);
+		      e1->flags = EDGE_FALSE_VALUE;
+		      e1->probability = profile_probability::likely ();
+		      e3->probability = e1->probability.invert ();
+		      set_immediate_dominator (CDI_DOMINATORS, bb, e1->src);
+		      set_immediate_dominator (CDI_DOMINATORS, e2->dest,
+					       e1->src);
+		      make_edge (bb, e2->dest, EDGE_FALLTHRU);
+		      m_gsi = gsi_after_labels (bb);
+		      new_bb = e2->dest;
+		    }
+		  tree ftype
+		    = build_nonstandard_integer_type (limb_prec - bo_bit, 1);
+		  tree bfr = build3 (BIT_FIELD_REF, ftype, unshare_expr (nlhs),
+				     bitsize_int (limb_prec - bo_bit),
+				     bitsize_int (bo_idx * limb_prec + bo_bit));
+		  tree t = add_cast (ftype, rhs1);
+		  g = gimple_build_assign (bfr, t);
+		  insert_before (g);
+		  if (eh)
+		    {
+		      maybe_duplicate_eh_stmt (g, stmt);
+		      if (eh_pad)
+			{
+			  edge e = split_block (gsi_bb (m_gsi), g);
+			  m_gsi = gsi_after_labels (e->dest);
+			  make_edge (e->src, eh_pad, EDGE_EH)->probability
+			    = profile_probability::very_unlikely ();
+			}
+		    }
+		  if (kind == bitint_prec_large)
+		    {
+		      bf_cur = rhs1;
+		      done = true;
+		    }
+		  else if (e2)
+		    m_gsi = gsi_after_labels (e2->src);
+		}
+	      if (!done)
+		{
+		  tree t1 = make_ssa_name (m_limb_type);
+		  tree t2 = make_ssa_name (m_limb_type);
+		  tree t3 = make_ssa_name (m_limb_type);
+		  g = gimple_build_assign (t1, RSHIFT_EXPR, bf_cur,
+					   build_int_cst (unsigned_type_node,
+							  limb_prec - bo_bit));
+		  insert_before (g);
+		  g = gimple_build_assign (t2, LSHIFT_EXPR, rhs1,
+					   build_int_cst (unsigned_type_node,
+							  bo_bit));
+		  insert_before (g);
+		  bf_cur = rhs1;
+		  g = gimple_build_assign (t3, BIT_IOR_EXPR, t1, t2);
+		  insert_before (g);
+		  rhs1 = t3;
+		  if (bf_next && i == 1)
+		    {
+		      g = gimple_build_assign (bf_next, bf_cur);
+		      insert_before (g);
+		    }
+		}
+	    }
+	  if (!done)
+	    {
+	      /* Handle bit-field access to partial last limb if needed.  */
+	      if (nlhs
+		  && i == cnt - 1
+		  && !separate_ext
+		  && tree_fits_uhwi_p (idx))
+		{
+		  unsigned int tprec = TYPE_PRECISION (type);
+		  unsigned int rprec = tprec % limb_prec;
+		  if (rprec + bo_bit < (unsigned) limb_prec)
+		    {
+		      tree ftype
+			= build_nonstandard_integer_type (rprec + bo_bit, 1);
+		      tree bfr = build3 (BIT_FIELD_REF, ftype,
+					 unshare_expr (nlhs),
+					 bitsize_int (rprec + bo_bit),
+					 bitsize_int ((bo_idx
+						       + tprec / limb_prec)
+						      * limb_prec));
+		      tree t = add_cast (ftype, rhs1);
+		      g = gimple_build_assign (bfr, t);
+		      done = true;
+		      bf_cur = NULL_TREE;
+		    }
+		  else if (rprec + bo_bit == (unsigned) limb_prec)
+		    bf_cur = NULL_TREE;
+		}
+	      /* Otherwise, stores to any other lhs.  */
+	      if (!done)
+		{
+		  tree l = limb_access (lhs_type, nlhs ? nlhs : lhs,
+					nidx, true);
+		  g = gimple_build_assign (l, rhs1);
+		}
+	      insert_before (g);
+	      if (eh)
+		{
+		  maybe_duplicate_eh_stmt (g, stmt);
+		  if (eh_pad)
+		    {
+		      edge e = split_block (gsi_bb (m_gsi), g);
+		      m_gsi = gsi_after_labels (e->dest);
+		      make_edge (e->src, eh_pad, EDGE_EH)->probability
+			= profile_probability::very_unlikely ();
+		    }
+		}
+	      if (new_bb)
+		m_gsi = gsi_after_labels (new_bb);
+	    }
 	}
       m_first = false;
       if (kind == bitint_prec_huge && i <= 1)
@@ -2050,9 +2496,7 @@  bitint_large_huge::lower_mergeable_stmt
 	}
     }
 
-  if (prec != (unsigned) TYPE_PRECISION (type)
-      && (CEIL ((unsigned) TYPE_PRECISION (type), limb_prec)
-	  > CEIL (prec, limb_prec)))
+  if (separate_ext)
     {
       if (sext)
 	{
@@ -2070,7 +2514,7 @@  bitint_large_huge::lower_mergeable_stmt
       unsigned start = CEIL (prec, limb_prec);
       prec = TYPE_PRECISION (type);
       idx = idx_first = idx_next = NULL_TREE;
-      if (prec <= (start + 2) * limb_prec)
+      if (prec <= (start + 2 + (bo_bit != 0)) * limb_prec)
 	kind = bitint_prec_large;
       if (kind == bitint_prec_large)
 	cnt = CEIL (prec, limb_prec) - start;
@@ -2078,22 +2522,94 @@  bitint_large_huge::lower_mergeable_stmt
 	{
 	  rem = prec % limb_prec;
 	  end = (prec - rem) / limb_prec;
-	  cnt = 1 + (rem != 0);
-	  idx = create_loop (size_int (start), &idx_next);
+	  cnt = (bo_bit != 0) + 1 + (rem != 0);
 	}
       for (unsigned i = 0; i < cnt; i++)
 	{
-	  if (kind == bitint_prec_large)
+	  if (kind == bitint_prec_large || (i == 0 && bo_bit != 0))
 	    idx = size_int (start + i);
-	  else if (i == 1)
+	  else if (i == cnt - 1)
 	    idx = size_int (end);
+	  else if (i == (bo_bit != 0))
+	    idx = create_loop (size_int (start + i), &idx_next);
 	  rhs1 = ext;
-	  tree l = limb_access (lhs_type, lhs, idx, true);
-	  if (!useless_type_conversion_p (TREE_TYPE (l), TREE_TYPE (rhs1)))
-	    rhs1 = add_cast (TREE_TYPE (l), rhs1);
-	  g = gimple_build_assign (l, rhs1);
+	  if (bf_cur != NULL_TREE && bf_cur != ext)
+	    {
+	      tree t1 = make_ssa_name (m_limb_type);
+	      g = gimple_build_assign (t1, RSHIFT_EXPR, bf_cur,
+				       build_int_cst (unsigned_type_node,
+						      limb_prec - bo_bit));
+	      insert_before (g);
+	      if (integer_zerop (ext))
+		rhs1 = t1;
+	      else
+		{
+		  tree t2 = make_ssa_name (m_limb_type);
+		  rhs1 = make_ssa_name (m_limb_type);
+		  g = gimple_build_assign (t2, LSHIFT_EXPR, ext,
+					   build_int_cst (unsigned_type_node,
+							  bo_bit));
+		  insert_before (g);
+		  g = gimple_build_assign (rhs1, BIT_IOR_EXPR, t1, t2);
+		  insert_before (g);
+		}
+	      bf_cur = ext;
+	    }
+	  tree nidx = idx;
+	  if (bo_idx)
+	    {
+	      if (tree_fits_uhwi_p (idx))
+		nidx = size_int (tree_to_uhwi (idx) + bo_idx);
+	      else
+		{
+		  nidx = make_ssa_name (sizetype);
+		  g = gimple_build_assign (nidx, PLUS_EXPR, idx,
+					   size_int (bo_idx));
+		  insert_before (g);
+		}
+	    }
+	  bool done = false;
+	  /* Handle bit-field access to partial last limb if needed.  */
+	  if (nlhs && i == cnt - 1)
+	    {
+	      unsigned int tprec = TYPE_PRECISION (type);
+	      unsigned int rprec = tprec % limb_prec;
+	      if (rprec + bo_bit < (unsigned) limb_prec)
+		{
+		  tree ftype
+		    = build_nonstandard_integer_type (rprec + bo_bit, 1);
+		  tree bfr = build3 (BIT_FIELD_REF, ftype,
+				     unshare_expr (nlhs),
+				     bitsize_int (rprec + bo_bit),
+				     bitsize_int ((bo_idx + tprec / limb_prec)
+						  * limb_prec));
+		  tree t = add_cast (ftype, rhs1);
+		  g = gimple_build_assign (bfr, t);
+		  done = true;
+		  bf_cur = NULL_TREE;
+		}
+	      else if (rprec + bo_bit == (unsigned) limb_prec)
+		bf_cur = NULL_TREE;
+	    }
+	  /* Otherwise, stores to any other lhs.  */
+	  if (!done)
+	    {
+	      tree l = limb_access (lhs_type, nlhs ? nlhs : lhs, nidx, true);
+	      g = gimple_build_assign (l, rhs1);
+	    }
 	  insert_before (g);
-	  if (kind == bitint_prec_huge && i == 0)
+	  if (eh)
+	    {
+	      maybe_duplicate_eh_stmt (g, stmt);
+	      if (eh_pad)
+		{
+		  edge e = split_block (gsi_bb (m_gsi), g);
+		  m_gsi = gsi_after_labels (e->dest);
+		  make_edge (e->src, eh_pad, EDGE_EH)->probability
+		    = profile_probability::very_unlikely ();
+		}
+	    }
+	  if (kind == bitint_prec_huge && i == (bo_bit != 0))
 	    {
 	      g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
 				       size_one_node);
@@ -2105,6 +2621,39 @@  bitint_large_huge::lower_mergeable_stmt
 	    }
 	}
     }
+  if (bf_cur != NULL_TREE)
+    {
+      unsigned int tprec = TYPE_PRECISION (type);
+      unsigned int rprec = tprec % limb_prec;
+      tree ftype = build_nonstandard_integer_type (rprec + bo_bit, 1);
+      tree bfr = build3 (BIT_FIELD_REF, ftype, unshare_expr (nlhs),
+			 bitsize_int (rprec + bo_bit),
+			 bitsize_int ((bo_idx + tprec / limb_prec)
+				      * limb_prec));
+      rhs1 = bf_cur;
+      if (bf_cur != ext)
+	{
+	  rhs1 = make_ssa_name (TREE_TYPE (rhs1));
+	  g = gimple_build_assign (rhs1, RSHIFT_EXPR, bf_cur,
+				   build_int_cst (unsigned_type_node,
+						  limb_prec - bo_bit));
+	  insert_before (g);
+	}
+      rhs1 = add_cast (ftype, rhs1);
+      g = gimple_build_assign (bfr, rhs1);
+      insert_before (g);
+      if (eh)
+	{
+	  maybe_duplicate_eh_stmt (g, stmt);
+	  if (eh_pad)
+	    {
+	      edge e = split_block (gsi_bb (m_gsi), g);
+	      m_gsi = gsi_after_labels (e->dest);
+	      make_edge (e->src, eh_pad, EDGE_EH)->probability
+		= profile_probability::very_unlikely ();
+	    }
+	}
+    }
 
   if (gimple_store_p (stmt))
     {
@@ -3294,6 +3843,7 @@  bitint_large_huge::lower_addsub_overflow
 
   if (kind == bitint_prec_huge)
     m_upwards_2limb = fin;
+  m_upwards = true;
 
   tree type0 = TREE_TYPE (arg0);
   tree type1 = TREE_TYPE (arg1);
@@ -4047,7 +4597,10 @@  bitint_large_huge::lower_stmt (gimple *s
   gsi_prev (&m_init_gsi);
   m_preheader_bb = NULL;
   m_upwards_2limb = 0;
+  m_upwards = false;
   m_var_msb = false;
+  m_cast_conditional = false;
+  m_bitfld_load = 0;
   m_loc = gimple_location (stmt);
   if (is_gimple_call (stmt))
     {
@@ -4276,6 +4829,30 @@  vuse_eq (ao_ref *, tree vuse1, void *dat
   return NULL;
 }
 
+/* Return true if STMT uses a library function and needs to take
+   address of its inputs.  We need to avoid bit-fields in those
+   cases.  */
+
+bool
+stmt_needs_operand_addr (gimple *stmt)
+{
+  if (is_gimple_assign (stmt))
+    switch (gimple_assign_rhs_code (stmt))
+      {
+      case MULT_EXPR:
+      case TRUNC_DIV_EXPR:
+      case TRUNC_MOD_EXPR:
+      case FLOAT_EXPR:
+	return true;
+      default:
+	break;
+      }
+  else if (gimple_call_internal_p (stmt, IFN_MUL_OVERFLOW)
+	   || gimple_call_internal_p (stmt, IFN_UBSAN_CHECK_MUL))
+    return true;
+  return false;
+}
+
 /* Dominator walker used to discover which large/huge _BitInt
    loads could be sunk into all their uses.  */
 
@@ -4341,14 +4918,16 @@  bitint_dom_walker::before_dom_children (
 	    worklist.safe_push (s);
 	}
 
+      bool needs_operand_addr = stmt_needs_operand_addr (stmt);
       while (worklist.length () > 0)
 	{
 	  tree s = worklist.pop ();
 
 	  if (!bitmap_bit_p (m_names, SSA_NAME_VERSION (s)))
 	    {
-	      FOR_EACH_SSA_USE_OPERAND (use_p, SSA_NAME_DEF_STMT (s),
-					oi, SSA_OP_USE)
+	      gimple *g = SSA_NAME_DEF_STMT (s);
+	      needs_operand_addr |= stmt_needs_operand_addr (g);
+	      FOR_EACH_SSA_USE_OPERAND (use_p, g, oi, SSA_OP_USE)
 		{
 		  tree s2 = USE_FROM_PTR (use_p);
 		  if (TREE_CODE (TREE_TYPE (s2)) == BITINT_TYPE
@@ -4371,8 +4950,28 @@  bitint_dom_walker::before_dom_children (
 	  else if (!bitmap_bit_p (m_loads, SSA_NAME_VERSION (s)))
 	    continue;
 
+	  tree rhs1 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (s));
+	  if (needs_operand_addr
+	      && TREE_CODE (rhs1) == COMPONENT_REF
+	      && DECL_BIT_FIELD_TYPE (TREE_OPERAND (rhs1, 1)))
+	    {
+	      tree fld = TREE_OPERAND (rhs1, 1);
+	      /* For little-endian, we can allow as inputs bit-fields
+		 which start at a limb boundary.  */
+	      if (DECL_OFFSET_ALIGN (fld) >= TYPE_ALIGN (TREE_TYPE (rhs1))
+		  && tree_fits_uhwi_p (DECL_FIELD_BIT_OFFSET (fld))
+		  && (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld))
+		      % limb_prec) == 0)
+		;
+	      else
+		{
+		  bitmap_clear_bit (m_loads, SSA_NAME_VERSION (s));
+		  continue;
+		}
+	    }
+
 	  ao_ref ref;
-	  ao_ref_init (&ref, gimple_assign_rhs1 (SSA_NAME_DEF_STMT (s)));
+	  ao_ref_init (&ref, rhs1);
 	  tree lvop = gimple_vuse (SSA_NAME_DEF_STMT (s));
 	  unsigned limit = 64;
 	  tree vuse = cvop;
@@ -4878,7 +5477,20 @@  gimple_lower_bitint (void)
 			&& is_gimple_assign (use_stmt)
 			&& !gimple_has_volatile_ops (use_stmt)
 			&& !stmt_ends_bb_p (use_stmt))
-		      continue;
+		      {
+			tree lhs = gimple_assign_lhs (use_stmt);
+			/* As multiply/division passes address of the lhs
+			   to library function and that assumes it can extend
+			   it to whole number of limbs, avoid merging those
+			   with bit-field stores.  Don't allow it for
+			   shifts etc. either, so that the bit-field store
+			   handling doesn't have to be done everywhere.  */
+			if (TREE_CODE (lhs) == COMPONENT_REF
+			    && DECL_BIT_FIELD_TYPE (TREE_OPERAND (lhs, 1)))
+			  break;
+			continue;
+		      }
+		    break;
 		  default:
 		    break;
 		  }
--- gcc/c/c-decl.cc.jj	2023-07-11 15:28:54.706679483 +0200
+++ gcc/c/c-decl.cc	2023-07-28 17:15:46.480173360 +0200
@@ -6382,7 +6382,8 @@  check_bitfield_type_and_width (location_
   /* Detect invalid bit-field type.  */
   if (TREE_CODE (*type) != INTEGER_TYPE
       && TREE_CODE (*type) != BOOLEAN_TYPE
-      && TREE_CODE (*type) != ENUMERAL_TYPE)
+      && TREE_CODE (*type) != ENUMERAL_TYPE
+      && TREE_CODE (*type) != BITINT_TYPE)
     {
       error_at (loc, "bit-field %qs has invalid type", name);
       *type = unsigned_type_node;
@@ -9322,8 +9323,14 @@  finish_struct (location_t loc, tree t, t
 	  tree type = TREE_TYPE (field);
 	  if (width != TYPE_PRECISION (type))
 	    {
-	      TREE_TYPE (field)
-		= c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
+	      if (TREE_CODE (type) == BITINT_TYPE
+		  && (width > 1 || TYPE_UNSIGNED (type)))
+		TREE_TYPE (field)
+		  = build_bitint_type (width, TYPE_UNSIGNED (type));
+	      else
+		TREE_TYPE (field)
+		  = c_build_bitfield_integer_type (width,
+						   TYPE_UNSIGNED (type));
 	      SET_DECL_MODE (field, TYPE_MODE (TREE_TYPE (field)));
 	    }
 	  DECL_INITIAL (field) = NULL_TREE;
--- gcc/c/c-typeck.cc.jj	2023-07-11 15:28:54.708679456 +0200
+++ gcc/c/c-typeck.cc	2023-07-28 17:12:19.720007447 +0200
@@ -2279,12 +2279,17 @@  perform_integral_promotions (tree exp)
   /* ??? This should no longer be needed now bit-fields have their
      proper types.  */
   if (TREE_CODE (exp) == COMPONENT_REF
-      && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
+      && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)))
+    {
+      if (TREE_CODE (DECL_BIT_FIELD_TYPE (TREE_OPERAND (exp, 1)))
+	  == BITINT_TYPE)
+	return convert (DECL_BIT_FIELD_TYPE (TREE_OPERAND (exp, 1)), exp);
       /* If it's thinner than an int, promote it like a
 	 c_promoting_integer_type_p, otherwise leave it alone.  */
-      && compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
-			   TYPE_PRECISION (integer_type_node)) < 0)
-    return convert (integer_type_node, exp);
+      if (compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
+			    TYPE_PRECISION (integer_type_node)) < 0)
+	return convert (integer_type_node, exp);
+    }
 
   if (c_promoting_integer_type_p (type))
     {
--- gcc/testsuite/gcc.dg/bitint-17.c.jj	2023-07-28 15:09:19.199372151 +0200
+++ gcc/testsuite/gcc.dg/bitint-17.c	2023-07-29 13:12:03.375902895 +0200
@@ -0,0 +1,47 @@ 
+/* PR c/102989 */
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-O2 -std=c2x -pedantic-errors" } */
+
+#define expr_has_type(e, t) _Generic (e, default : 0, t : 1)
+
+struct S1 { char x; char : 0; char y; };
+struct S2 { char x; int : 0; char y; };
+#if __BITINT_MAXWIDTH__ >= 575
+struct S3 { char x; _BitInt(575) : 0; char y; };
+#endif
+#if __BITINT_MAXWIDTH__ >= 389
+struct S4 { char x; _BitInt(195) a : 63; _BitInt(282) b : 280; _BitInt(389) c : 23; _BitInt(2) d : 1; char y; };
+#endif
+#if __BITINT_MAXWIDTH__ >= 192
+struct S5 { char x; _BitInt(192) a : 191; unsigned _BitInt(192) b : 190; _BitInt(192) c : 189; char y; };
+#endif
+struct S6 { _BitInt(2) a : 1; };
+#if __BITINT_MAXWIDTH__ >= 389
+struct S4 s4;
+static_assert (expr_has_type (s4.a + 1uwb, _BitInt(195)));
+static_assert (expr_has_type (s4.b + 1uwb, _BitInt(282)));
+static_assert (expr_has_type (s4.c + 1uwb, _BitInt(389)));
+static_assert (expr_has_type (s4.d * 0wb, _BitInt(2)));
+#endif
+#if __BITINT_MAXWIDTH__ >= 192
+struct S5 s5;
+static_assert (expr_has_type (s5.a + 1uwb, _BitInt(192)));
+static_assert (expr_has_type (s5.b + 1wb, unsigned _BitInt(192)));
+static_assert (expr_has_type (s5.c + 1uwb, _BitInt(192)));
+#endif
+struct S6 s6;
+static_assert (expr_has_type (s6.a + 0wb, _BitInt(2)));
+#if defined(__x86_64__) && __LP64__ && __BITINT_MAXWIDTH__ >= 575
+static_assert (sizeof (struct S1) == 2);
+static_assert (sizeof (struct S2) == 5);
+static_assert (sizeof (struct S3) == 9);
+static_assert (sizeof (struct S4) == 48);
+static_assert (sizeof (struct S5) == 88);
+static_assert (sizeof (struct S6) == 1);
+static_assert (alignof (struct S1) == 1);
+static_assert (alignof (struct S2) == 1);
+static_assert (alignof (struct S3) == 1);
+static_assert (alignof (struct S4) == 8);
+static_assert (alignof (struct S5) == 8);
+static_assert (alignof (struct S6) == 1);
+#endif
--- gcc/testsuite/gcc.dg/torture/bitint-42.c.jj	2023-08-02 16:26:43.417869163 +0200
+++ gcc/testsuite/gcc.dg/torture/bitint-42.c	2023-08-02 17:28:22.492492723 +0200
@@ -0,0 +1,184 @@ 
+/* PR c/102989 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c2x -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 156
+struct S156 { unsigned _BitInt(156) a : 135; _BitInt(156) b : 2; };
+struct T156 { _BitInt(156) a : 2; unsigned _BitInt(156) b : 135; _BitInt(156) c : 2; };
+
+__attribute__((noipa)) _BitInt(156)
+test156 (struct S156 *p, struct T156 *q, struct T156 *r, int n)
+{
+  r[0].b = p[0].a + q[0].b;
+  r[1].b = p[1].a * q[1].b;
+  r[2].a = p[2].a == q[2].b;
+  r[3].a = p[3].a < q[3].b;
+  r[4].b = p[4].a << n;
+  return p[5].a + q[5].b;
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 495
+struct S495 { unsigned _BitInt(495) a : 471; _BitInt(495) b : 2; };
+struct T495 { _BitInt(495) a : 2; unsigned _BitInt(495) b : 471; _BitInt(495) c : 2; };
+
+__attribute__((noipa)) _BitInt(495)
+test495 (struct S495 *p, struct T495 *q, struct T495 *r, int n)
+{
+  r[0].b = p[0].a + q[0].b;
+  r[1].b = p[1].a * q[1].b;
+  r[2].a = p[2].a == q[2].b;
+  r[3].a = p[3].a < q[3].b;
+  r[4].b = p[4].a << n;
+  return p[5].a + q[5].b;
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 575
+struct T575 { _BitInt(575) a : 2; _BitInt(575) b : 382; _BitInt(575) c : 2; };
+
+__attribute__((noipa)) _BitInt(575)
+test575 (struct T575 *q, _BitInt(575) x)
+{
+  return q->b + x;
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 156
+  static struct S156 p156[] = {
+    { 6086908847973295618751425718189955476089uwb, 0wb },
+    { 22782605434509677806291360175224474025979uwb, 1wb },
+    { 37470702016132547913133822619863997855935uwb, -1wb },
+    { 35506973813062189967442086745146532460068uwb, -2wb },
+    { 30541197841349399254932135707861871578815uwb, -2wb },
+    { 42800615576623455179183425579556615564998uwb, 1wb },
+    { 83771790414073692613953222993102430597uwb, 0wb },
+    { 36412564746565547536452588666710660799602uwb, 1wb },
+    { 33301340481967309644890101787523367044846uwb, -1wb },
+    { 12245185680611854260212331160624126801841uwb, -2wb },
+    { 35828279900949208432533857460683046288424uwb, -1wb },
+    { 4123278359205456806488911776768785478962uwb, 1wb }
+  };
+  static struct T156 q156[] = {
+    { -2wb, 20935792668463008606182638244678610336415uwb, 0wb },
+    { -1wb, 209336580249060835473242979959042853484uwb, -1wb },
+    { 0wb, 26553091584512375040647771207085289684805uwb, -2wb },
+    { 1wb, 8584102019879028804166913978503267690027uwb, 1wb },
+    { -2wb, 3364986457594728242491236670969190237662uwb, 0wb },
+    { 1wb, 28487958103578401823549712846248514887291uwb, -1wb },
+    { 1wb, 30323438060061607929914857363700386658179uwb, -2wb },
+    { -2wb, 38436123658875864126535628489050345446219uwb, 1wb },
+    { -1wb, 33301340481967309644890101787523367044846uwb, -1wb },
+    { 0wb, 18081372790322879821963779970917788200718uwb, 0wb },
+    { 1wb, 35310198378318023568520640435634029391465uwb, -2wb },
+    { -2wb, 16532060682830030166332649597929082719904uwb, -1wb }
+  };
+  struct T156 r156[12];
+  static unsigned _BitInt(135) e156[] = {
+    27022701516436304224934063962868565812504uwb,
+    29613894605882195495382184794066465590244uwb,
+    0uwb,
+    0uwb,
+    25008039169844990156837660987808592822272uwb,
+    27732430714321733679421188674538799385921uwb,
+    30407209850475681622528810586693489088776uwb,
+    9125928536800138281422179636318960655206uwb,
+    1uwb,
+    1uwb,
+    27059094310193532424702800326126974533632uwb,
+    20655339042035486972821561374697868198866uwb
+  };
+  for (int i = 0; i < 12; ++i)
+    {
+      r156[i].a = (i & 1) ? 1wb : -2wb;
+      r156[i].b = (i & 1) ? 14518714321960041107770649917088777022122uwb : 29037428643920082215541299834177554044245uwb;
+      r156[i].c = (i & 1) ? -2wb : 1wb;
+    }
+  r156[5].b = test156 (&p156[0], &q156[0], &r156[0], 17);
+  r156[11].b = test156 (&p156[6], &q156[6], &r156[6], 117);
+  for (int i = 0; i < 12; ++i)
+    if ((((i % 6) - 2U <= 1U) ? r156[i].a : r156[i].b) != e156[i])
+      __builtin_abort ();
+    else if ((((i % 6) - 2U > 1U) && r156[i].a != ((i & 1) ? 1wb : -2wb))
+	     || (((i % 6) - 2U <= 1U) && r156[i].b != ((i & 1) ? 14518714321960041107770649917088777022122uwb : 29037428643920082215541299834177554044245uwb))
+	     || r156[i].c != ((i & 1) ? -2wb : 1wb))
+      __builtin_abort ();
+#endif
+#if __BITINT_MAXWIDTH__ >= 495
+  static struct S495 p495[] = {
+    { 5900641461698162830220261443910312286116186030711054026202132317287171989449954433727605565187406942318472276126021616097079737645240098454013uwb, 0wb },
+    { 5619335266199392590390116416034736345432323405939461237257863293465693217703812518219356211176818397041537700744525965483063880249177661765822uwb, -1wb },
+    { 744675643612988167093151199551285556694415176163561012938968935653355128760309622135847398882788196739068398576440472762370028310765535983503uwb, 1wb },
+    { 4710120587609940729927891635083547264060530096467790505615232580303577049694742313824211264116793595223025831432779325089965241897060863692416uwb, -2wb },
+    { 4700240735957362687308898816111021174982406591648489926246999776223031821022674194534613241738369983608058217658021289655774135981827101958355uwb, -1wb },
+    { 1876262100946684033144524627883805711239772124030259629263615724983251183045150901527994496938087455223125779829665212386349414296844947524925uwb, 0wb },
+    { 2635441776228543412090459941414006837629084474712903013295503578947861806271451688519107975488661564459243720565422264844084425272156107387136uwb, 1wb },
+    { 2630153258749552262848995430888671592867309014306367216498408256861265344131972108995527284590063838830515851856437258905217521364301962720643uwb, -2wb },
+    { 2745338434240621337939928605056928843351970485626602387969150293308450866745407501724727739848971206349186529783705440219203189970551219879381uwb, 1wb },
+    { 2688974451781009079406742432598239379065348006788221659938456041627730645258351669705421830999330571339577238631004906071154604486839621759962uwb, -1wb },
+    { 4974200409958136921019163732486769139044513968318459321751943678326303994594283963911023171617076265195547773578798591476134329493900866070930uwb, -2wb },
+    { 5308892348567193242289576342108929297198516978578910066291782408432432101971103786646801744963140659914127252602243854634890888430591500677669uwb, 0wb }
+  };
+  static struct T495 q495[] = {
+    { 0wb, 4301604554146816407338627211447119428992719156607107928889754501636100741327050147838502142108071735464603549268761292458205988617578325763173uwb, -2wb },
+    { -1wb, 2715194601730000102297343743781623149283369741076005412784114057373119142888076403665408178274328506558203084450300859444566357959934633829946uwb, -1wb },
+    { -2wb, 744675643612988167093151199551285556694415176163561012938968935653355128760309622135847398882788196739068398576440472762370028310765535983503uwb, 0wb },
+    { 1wb, 2905575297593112682176271367301360286079539486548283169761776505152778266677295498111968142984117916873706310434203454796302860902084876845657uwb, 1wb },
+    { -2wb, 1837917528781539509450058185492923533367227689379651913582946492506072644598679412452807791857307066254676899775684162126897712525287848351976uwb, -2wb },
+    { -1wb, 2319680246150988952074978951387405463389161562155916967834748191217991286707290863021474691040798411643120909475843121856853198824610064919029uwb, -1wb },
+    { 0wb, 995091385198857217634636856758679675740255626224651591597840191331701102225958567078470825514618566121501749811346910563358603344922083332530uwb, 0wb },
+    { 1wb, 1935767072657166967374130326547364176008146414333487504728787607207566058414790635912675474199093488415105292641061350133643468776770358124726uwb, 1wb },
+    { -1wb, 2323578462079768493720340989036535936419394491913499982954052044299468738290318204298367303716254084159730145465632640799602734853085685711959uwb, -1wb },
+    { 0wb, 3134743387837581735890167538039234659353143305621277824366534871456819272038615182289564667918939704822338586693965843434870517084569520632192uwb, 1wb },
+    { -2wb, 6069214031750054027161180881734548627596253190931156326304738913835931214674310539698411833298960086513572699541120829870803305974299213978797uwb, -2wb },
+    { 1wb, 3475118701665891960802877416318617212624733636229950713368672781946851382777667645205965216548373630879140490108440746796343158443948723601215uwb, 0wb }
+  };
+  struct T495 r495[12];
+  static unsigned _BitInt(471) e495[] = {
+    4105080878509056910641706565917653774193674439925640176070095882154968553394649854768634849749595921611538850548285598212613898764208491978338uwb,
+    4272455060900825442658035799123612713461581925816375155025420465351224978751666594799676382302564435552275519560187020810679530912731598360332uwb,
+    1uwb,
+    0uwb,
+    193936707178394586072944129724741337251602515686017126954836162236154016065720970574348980545042390967692432385246117380757295497134607826944uwb,
+    4195942347097672985219503579271211174628933686186176597098363916201242469752441764549469187978885866866246689305508334243202613121455012443954uwb,
+    3630533161427400629725096798172686513369340100937554604893343770279562908497410255597578801003280130580745470376769175407443028617078190719666uwb,
+    3017199903252810774645258484587879229328468140025245420287647204420639096996138928094942159316263828975261069022192893745856107126530044652322uwb,
+    0uwb,
+    1uwb,
+    4881485695834897810379845656011652834144895329454510745024612553531749469753415260371487385803388022234443037087409795804654957238790836453376uwb,
+    2686845912897162876175271668987768568908019867416339000638664253610979307366416705055294103965631534621730767864187291088562219375930292040036uwb
+  };
+  for (int i = 0; i < 12; ++i)
+    {
+      r495[i].a = (i & 1) ? 1wb : -2wb;
+      r495[i].b = (i & 1) ? 4064776758223948217944788059626518627276820498261681186014527291178869451588236484531648571697255170781024649897664873561781218332406621492565uwb : 2032388379111974108972394029813259313638410249130840593007263645589434725794118242265824285848627585390512324948832436780890609166203310746282uwb;
+      r495[i].c = (i & 1) ? -2wb : 1wb;
+    }
+  r495[5].b = test495 (&p495[0], &q495[0], &r495[0], 17);
+  r495[11].b = test495 (&p495[6], &q495[6], &r495[6], 117);
+  for (int i = 0; i < 12; ++i)
+    if ((((i % 6) - 2U <= 1U) ? r495[i].a : r495[i].b) != e495[i])
+      __builtin_abort ();
+    else if ((((i % 6) - 2U > 1U) && r495[i].a != ((i & 1) ? 1wb : -2wb))
+	     || (((i % 6) - 2U <= 1U) && r495[i].b != ((i & 1) ? 4064776758223948217944788059626518627276820498261681186014527291178869451588236484531648571697255170781024649897664873561781218332406621492565uwb : 2032388379111974108972394029813259313638410249130840593007263645589434725794118242265824285848627585390512324948832436780890609166203310746282uwb))
+	     || r495[i].c != ((i & 1) ? -2wb : 1wb))
+      __builtin_abort ();
+#endif
+#if __BITINT_MAXWIDTH__ >= 575
+  struct T575 q575[] = {
+    { 0wb, 96684809381001318096256993724350755663760586347837309196134430400012751231961429238828670682891585656560169817843wb, -2wb },
+    { -1wb, -2736587102891263842950610428227571747319762162345429601728737031966764668220310874246707348170368842425752759862563wb, 1wb }
+  };
+  if (test575 (&q575[0], -20620110861486347200204305994458440394552720887062830768778333216240622422772611435913937143052282943196256683484434522946545384240670168537704102522242938522404309878852322wb)
+      != -20620110861486347200204305994458440394552720887062830768778236531431241421454515178920212792296619182609908846175238388516145371489438207108465273851560046936747749709034479wb)
+    __builtin_abort ();
+  if (test575 (&q575[1], 42621052848920155042866550876502212956983884683310087431575669593007353224147609487103322505341199223508939436382180596125666953651582557283994756434373621037386194691552808wb)
+      != 42621052848920155042866550876502212956983884683310087431572933005904461960304658876675094933593879461346594006780451859093700188983362246409748049086203252194960441931690245wb)
+    __builtin_abort ();
+#endif
+}