The jit testcase test-nested-loops.c was crashing.
Root cause is that deep inside loop optimization we're now exposing
this call within fold-const.c which wasn't being hit before:
4082 /* Compute the mask to access the bitfield. */
4083 unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
and the jit's implementation of LANG_HOOKS_TYPE_FOR_SIZE was a
placeholder that asserted it wasn't called.
This patch implements a proper LANG_HOOKS_TYPE_FOR_SIZE for jit,
by taking LTO's implementation.
Fixes test-nested-loops.c, along with the related failures in
test-combination.c and test-threads.c due to reusing the test.
This fixes all known failures in jit.sum, putting it at 8609 passes.
Committed to trunk as r244600.
gcc/jit/ChangeLog:
* dummy-frontend.c (jit_langhook_type_for_size): Implement, using
lto's lto_type_for_size.
---
gcc/jit/dummy-frontend.c | 49 ++++++++++++++++++++++++++++++++++++++++++++----
1 file changed, 45 insertions(+), 4 deletions(-)
diff --git a/gcc/jit/dummy-frontend.c b/gcc/jit/dummy-frontend.c
index 8f28e7f..5955854 100644
--- a/gcc/jit/dummy-frontend.c
+++ b/gcc/jit/dummy-frontend.c
@@ -207,12 +207,53 @@ jit_langhook_type_for_mode (enum machine_mode mode, int
unsignedp)
return NULL;
}
+/* Return an integer type with PRECISION bits of precision,
+ that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
+
static tree
-jit_langhook_type_for_size (unsigned int bits ATTRIBUTE_UNUSED,
- int unsignedp ATTRIBUTE_UNUSED)
+jit_langhook_type_for_size (unsigned precision, int unsignedp)
{
- gcc_unreachable ();
- return NULL;
+ int i;
+
+ if (precision == TYPE_PRECISION (integer_type_node))
+ return unsignedp ? unsigned_type_node : integer_type_node;
+
+ if (precision == TYPE_PRECISION (signed_char_type_node))
+ return unsignedp ? unsigned_char_type_node : signed_char_type_node;
+
+ if (precision == TYPE_PRECISION (short_integer_type_node))
+ return unsignedp ? short_unsigned_type_node : short_integer_type_node;
+
+ if (precision == TYPE_PRECISION (long_integer_type_node))
+ return unsignedp ? long_unsigned_type_node : long_integer_type_node;
+
+ if (precision == TYPE_PRECISION (long_long_integer_type_node))
+ return unsignedp
+ ? long_long_unsigned_type_node
+ : long_long_integer_type_node;
+
+ for (i = 0; i < NUM_INT_N_ENTS; i ++)
+ if (int_n_enabled_p[i]
+ && precision == int_n_data[i].bitsize)
+ return (unsignedp ? int_n_trees[i].unsigned_type
+ : int_n_trees[i].signed_type);
+
+ if (precision <= TYPE_PRECISION (intQI_type_node))
+ return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
+
+ if (precision <= TYPE_PRECISION (intHI_type_node))
+ return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
+
+ if (precision <= TYPE_PRECISION (intSI_type_node))
+ return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
+
+ if (precision <= TYPE_PRECISION (intDI_type_node))
+ return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
+
+ if (precision <= TYPE_PRECISION (intTI_type_node))
+ return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
+
+ return NULL_TREE;
}
/* Record a builtin function. We just ignore builtin functions. */
--
1.8.5.3
