This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH 2/2] jit: add switch statements
- From: David Malcolm <dmalcolm at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org, jit at gcc dot gnu dot org
- Cc: David Malcolm <dmalcolm at redhat dot com>
- Date: Thu, 25 Jun 2015 15:13:41 -0400
- Subject: [PATCH 2/2] jit: add switch statements
- Authentication-results: sourceware.org; auth=none
- References: <558A846C dot 70003 at starynkevitch dot net> <1435259621-45194-1-git-send-email-dmalcolm at redhat dot com>
Some interpreters/VMs support a switch statement (for example the JVM
has opcodes "lookupswitch" and "tableswitch"). GCC has a set of
optimizations for efficiently handling switch statements, so it makes
sense to directly expose switch statements in the libgccjit API.
This patch implements a switch statement, but it isn't quite ready for
committing to trunk yet:
* It relies on gcc/typed-splay-tree.h in the previous patch
* It extends the libgccjit API. It's not clear to me yet how to
manage extensions of the libgccjit API: should I use symbol maps
and versioning, or bump the SONAME? I'm thinking of providing
precanned feature macros within libgccjit.h e.g:
#define LIBGCCJIT_HAVE_SWITCH_STATEMENT
for the benefit of client code that doesn't use configure
scripts.
* It touches the jit docs and thus needs a refresh of the generated
texinfo.
The initial implementation I tried was:
extern void
gcc_jit_block_end_with_switch (gcc_jit_block *block,
gcc_jit_location *loc,
gcc_jit_rvalue *expr,
gcc_jit_block *default_block,
int num_cases,
gcc_jit_rvalue **case_min_values,
gcc_jit_rvalue **case_max_values,
gcc_jit_block **case_blocks);
but I've now implemented it with an explicit "gcc_jit_case" type:
extern gcc_jit_case *
gcc_jit_context_new_case (gcc_jit_context *ctxt,
gcc_jit_rvalue *min_value,
gcc_jit_rvalue *max_value,
gcc_jit_block *dest_block);
extern void
gcc_jit_block_end_with_switch (gcc_jit_block *block,
gcc_jit_location *loc,
gcc_jit_rvalue *expr,
gcc_jit_block *default_block,
int num_cases,
gcc_jit_case **cases);
The motivation for this was:
* error-checking became easier (esp. for overlapping ranges etc)
* making debug strings for the switch statement became easier
* probably nicer from a language-binding POV
The requirement to allow more than 2 successor blocks for a gcc_jit_block
required updating the internal get_successor_blocks API for blocks and
block-terminating statements from:
int
get_successor_blocks (block **next1, block **next2) const;
to:
vec <recording::block *>
get_successor_blocks () const;
where ownership of the vector transfers to the caller, which
must call its release () method.
The patch extends the C and C++ APIs, adding documentation and
testcases.
I've also extended the Python bindings to cover the new entrypoints;
this can be seen in the "switch" branch of pygccjit here:
https://github.com/davidmalcolm/pygccjit/tree/switch
gcc/jit/ChangeLog:
* docs/cp/topics/functions.rst (Blocks): Add switch statements to
list of ways to terminate a block.
(gccjit::block::end_with_switch): Add function description.
(gccjit::case_): Add class.
(gccjit::context::new_case): Add function description.
* docs/cp/topics/objects.rst: Add "case_" to class hierarchy.
* docs/topics/functions.rst (Blocks): Add switch statements to
list of ways to terminate a block.
(gcc_jit_block_end_with_switch): Add function description.
(gcc_jit_case): Add type.
(gcc_jit_context_new_case): Add function description.
(gcc_jit_case_as_object): Add function description.
* docs/topics/objects.rst: Add gcc_jit_case to class hierarchy.
* jit-common.h (gcc::jit::recording::case_): Add forward decl.
(gcc::jit::playback::case_): Add forward decl.
* jit-playback.c (add_case): New function.
(gcc::jit::playback::block::add_switch): New function.
* jit-playback.h (gcc::jit::playback::case_): New struct.
(gcc::jit::playback::block::add_switch): New method.
* jit-recording.c: Within namespace gcc::jit...
(recording::context::new_case): New method.
(recording::function::validate): Update for change to
get_successor_blocks.
(recording::block::end_with_switch): New method.
(recording::block::get_successor_blocks): Update to support an
arbitrary number of successor blocks.
(recording::block::dump_edges_to_dot): Likewise.
(memento_of_new_rvalue_from_const <int>::get_wide_int): New.
(memento_of_new_rvalue_from_const <long>::get_wide_int): New.
(memento_of_new_rvalue_from_const <double>::get_wide_int): New.
(memento_of_new_rvalue_from_const <void *>::get_wide_int): New.
(recording::statement::get_successor_blocks): Update to support an
arbitrary number of successor blocks.
(recording::conditional::get_successor_blocks): Likewise.
(recording::jump::get_successor_blocks): Likewise.
(recording::return_::get_successor_blocks): Likewise.
(recording::case_::write_reproducer): New.
(recording::case_::make_debug_string): New.
(recording::switch_::switch_): New.
(recording::switch_::replay_into): New.
(recording::switch_::get_successor_blocks): New.
(recording::switch_::make_debug_string): New.
(recording::switch_::write_reproducer): New.
* jit-recording.h: Within namespace gcc::jit::recording...
(context::new_case): New.
(rvalue::is_constant): New.
(rvalue::get_wide_int): New.
(block::end_with_switch): New.
(block::get_successor_blocks): Update to support an arbitrary
number of successor blocks.
(memento_of_new_rvalue_from_const::is_constant): New.
(memento_of_new_rvalue_from_const::get_wide_int): New.
(statement::get_successor_blocks): Update to support an arbitrary
number of successor blocks.
(conditional::get_successor_blocks): Likewise.
(jump::get_successor_blocks): Likewise.
(return_::get_successor_blocks): Likewise.
(case_): New subclass of memento.
(switch_): New subclass of statement.
* libgccjit++.h (gccjit::case_): New subclass of gccjit::object.
(gccjit::context::new_case): New method.
(gccjit::block::end_with_switch): New method.
(gccjit::case_::case): New ctors.
(gccjit::case_::get_inner_case): New method.
* libgccjit.c: Include "typed-splay-tree.h"
(struct gcc_jit_case): New.
(gcc_jit_context_new_case): New function.
(gcc_jit_case_as_object): New function.
(valid_dest_for_switch): New function.
(valid_case_for_switch): New function.
(class api_call_validator): New class.
(class case_range_validator): New class.
(case_range_validator::case_range_validator): New.
(case_range_validator::validate): New.
(case_range_validator::case_compare): New.
(case_range_validator::get_wide_int): new.
(gcc_jit_block_end_with_switch): New.
* libgccjit.h: Add gcc_jit_case to class hierarchy comment.
(gcc_jit_case): New typedef.
(gcc_jit_context_new_case): New function.
(gcc_jit_case_as_object): New function.
(gcc_jit_block_end_with_switch): New function.
* libgccjit.map: Add gcc_jit_block_end_with_switch,
gcc_jit_case_as_object and gcc_jit_context_new_case.
gcc/testsuite/ChangeLog:
* jit.dg/all-non-failing-tests.h: Add test-switch.c.
* jit.dg/test-error-gcc_jit_block_end_with_switch-NULL-case.c: New
testcase.
* jit.dg/test-error-gcc_jit_block_end_with_switch-mismatching-case-type.c:
New testcase.
* jit.dg/test-error-gcc_jit_block_end_with_switch-overlapping-ranges.c:
New testcase.
* jit.dg/test-error-gcc_jit_context_new_case-non-const-label.c:
New testcase.
* jit.dg/test-error-gcc_jit_context_new_case-non-integer-type.c:
New testcase.
* jit.dg/test-error-gcc_jit_context_new_case-reversed-endpoints.c:
New testcase.
* jit.dg/test-switch.c: New testcase.
* jit.dg/test-switch.cc: New testcase.
---
gcc/jit/docs/cp/topics/functions.rst | 69 +++-
gcc/jit/docs/cp/topics/objects.rst | 1 +
gcc/jit/docs/topics/functions.rst | 81 ++++-
gcc/jit/docs/topics/objects.rst | 1 +
gcc/jit/jit-common.h | 2 +
gcc/jit/jit-playback.c | 72 ++++
gcc/jit/jit-playback.h | 19 +
gcc/jit/jit-recording.c | 322 ++++++++++++++---
gcc/jit/jit-recording.h | 87 ++++-
gcc/jit/libgccjit++.h | 63 ++++
gcc/jit/libgccjit.c | 381 +++++++++++++++++++++
gcc/jit/libgccjit.h | 61 ++++
gcc/jit/libgccjit.map | 3 +
gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 +
...error-gcc_jit_block_end_with_switch-NULL-case.c | 66 ++++
...t_block_end_with_switch-mismatching-case-type.c | 83 +++++
..._jit_block_end_with_switch-overlapping-ranges.c | 95 +++++
...rror-gcc_jit_context_new_case-non-const-label.c | 80 +++++
...ror-gcc_jit_context_new_case-non-integer-type.c | 81 +++++
...r-gcc_jit_context_new_case-reversed-endpoints.c | 80 +++++
gcc/testsuite/jit.dg/test-switch.c | 147 ++++++++
gcc/testsuite/jit.dg/test-switch.cc | 118 +++++++
22 files changed, 1861 insertions(+), 61 deletions(-)
create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-NULL-case.c
create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-mismatching-case-type.c
create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-overlapping-ranges.c
create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-const-label.c
create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-integer-type.c
create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-reversed-endpoints.c
create mode 100644 gcc/testsuite/jit.dg/test-switch.c
create mode 100644 gcc/testsuite/jit.dg/test-switch.cc
diff --git a/gcc/jit/docs/cp/topics/functions.rst b/gcc/jit/docs/cp/topics/functions.rst
index de3570a..801cdbe 100644
--- a/gcc/jit/docs/cp/topics/functions.rst
+++ b/gcc/jit/docs/cp/topics/functions.rst
@@ -98,7 +98,8 @@ Blocks
be the entrypoint.
Each basic block that you create within a function must be
- terminated, either with a conditional, a jump, or a return.
+ terminated, either with a conditional, a jump, a return, or
+ a switch.
It's legal to have multiple basic blocks that return within
one function.
@@ -241,3 +242,69 @@ Statements
.. code-block:: c
return;
+
+.. function:: void\
+ gccjit::block::end_with_switch (gccjit::rvalue expr,\
+ gccjit::block default_block,\
+ std::vector <gccjit::case_> cases,\
+ gccjit::location loc)
+
+ Terminate a block by adding evalation of an rvalue, then performing
+ a multiway branch.
+
+ This is roughly equivalent to this C code:
+
+ .. code-block:: c
+
+ switch (expr)
+ {
+ default:
+ goto default_block;
+
+ case C0.min_value ... C0.max_value:
+ goto C0.dest_block;
+
+ case C1.min_value ... C1.max_value:
+ goto C1.dest_block;
+
+ ...etc...
+
+ case C[N - 1].min_value ... C[N - 1].max_value:
+ goto C[N - 1].dest_block;
+ }
+
+ ``expr`` must be of the same integer type as all of the ``min_value``
+ and ``max_value`` within the cases.
+
+ The ranges of the cases must not overlap (or have duplicate
+ values).
+
+ .. class:: gccjit::case_
+
+ A `gccjit::case_` represents a case within a switch statement, and
+ is created within a particular :class:`gccjit::context` using
+ :func:`gccjit::context::new_case`. It is a subclass of
+ :class:`gccjit::object`.
+
+ Each case expresses a multivalued range of integer values. You
+ can express single-valued cases by passing in the same value for
+ both `min_value` and `max_value`.
+
+ .. function:: gccjit::case_ *\
+ gccjit::context::new_case (gccjit::rvalue min_value,\
+ gccjit::rvalue max_value,\
+ gccjit::block dest_block)
+
+ Create a new gccjit::case for use in a switch statement.
+ `min_value` and `max_value` must be constants of an integer type,
+ which must match that of the expression of the switch statement.
+
+ `dest_block` must be within the same function as the switch
+ statement.
+
+ Here's an example of creating a switch statement:
+
+ .. literalinclude:: ../../../../testsuite/jit.dg/test-switch.cc
+ :start-after: /* Quote from here in docs/cp/topics/functions.rst. */
+ :end-before: /* Quote up to here in docs/cp/topics/functions.rst. */
+ :language: c++
diff --git a/gcc/jit/docs/cp/topics/objects.rst b/gcc/jit/docs/cp/topics/objects.rst
index 714b645..8d99bd4 100644
--- a/gcc/jit/docs/cp/topics/objects.rst
+++ b/gcc/jit/docs/cp/topics/objects.rst
@@ -46,6 +46,7 @@ The C++ class hierarchy within the ``gccjit`` namespace looks like this::
+- rvalue
+- lvalue
+- param
+ +- case_
The :class:`gccjit::object` base class has the following operations:
diff --git a/gcc/jit/docs/topics/functions.rst b/gcc/jit/docs/topics/functions.rst
index 35e58d3..a4f72bb 100644
--- a/gcc/jit/docs/topics/functions.rst
+++ b/gcc/jit/docs/topics/functions.rst
@@ -161,7 +161,8 @@ Blocks
be the entrypoint.
Each basic block that you create within a function must be
- terminated, either with a conditional, a jump, or a return.
+ terminated, either with a conditional, a jump, a return, or a
+ switch.
It's legal to have multiple basic blocks that return within
one function.
@@ -342,3 +343,81 @@ Statements
.. code-block:: c
return;
+
+.. function:: void\
+ gcc_jit_block_end_with_switch (gcc_jit_block *block,\
+ gcc_jit_location *loc,\
+ gcc_jit_rvalue *expr,\
+ gcc_jit_block *default_block,\
+ int num_cases,\
+ gcc_jit_case **cases)
+
+ Terminate a block by adding evalation of an rvalue, then performing
+ a multiway branch.
+
+ This is roughly equivalent to this C code:
+
+ .. code-block:: c
+
+ switch (expr)
+ {
+ default:
+ goto default_block;
+
+ case C0.min_value ... C0.max_value:
+ goto C0.dest_block;
+
+ case C1.min_value ... C1.max_value:
+ goto C1.dest_block;
+
+ ...etc...
+
+ case C[N - 1].min_value ... C[N - 1].max_value:
+ goto C[N - 1].dest_block;
+ }
+
+ ``block``, ``expr``, ``default_block`` and ``cases`` must all be
+ non-NULL.
+
+ ``expr`` must be of the same integer type as all of the ``min_value``
+ and ``max_value`` within the cases.
+
+ ``num_cases`` must be >= 0.
+
+ The ranges of the cases must not overlap (or have duplicate
+ values).
+
+ .. type:: gcc_jit_case
+
+ A `gcc_jit_case` represents a case within a switch statement, and
+ is created within a particular :c:type:`gcc_jit_context` using
+ :c:func:`gcc_jit_context_new_case`.
+
+ Each case expresses a multivalued range of integer values. You
+ can express single-valued cases by passing in the same value for
+ both `min_value` and `max_value`.
+
+ .. function:: gcc_jit_case *\
+ gcc_jit_context_new_case (gcc_jit_context *ctxt,\
+ gcc_jit_rvalue *min_value,\
+ gcc_jit_rvalue *max_value,\
+ gcc_jit_block *dest_block)
+
+ Create a new gcc_jit_case instance for use in a switch statement.
+ `min_value` and `max_value` must be constants of an integer type,
+ which must match that of the expression of the switch statement.
+
+ `dest_block` must be within the same function as the switch
+ statement.
+
+ .. function:: gcc_jit_object *\
+ gcc_jit_case_as_object (gcc_jit_case *case_)
+
+ Upcast from a case to an object.
+
+ Here's an example of creating a switch statement:
+
+ .. literalinclude:: ../../../testsuite/jit.dg/test-switch.c
+ :start-after: /* Quote from here in docs/topics/functions.rst. */
+ :end-before: /* Quote up to here in docs/topics/functions.rst. */
+ :language: c
diff --git a/gcc/jit/docs/topics/objects.rst b/gcc/jit/docs/topics/objects.rst
index 3ae6309..85c783c 100644
--- a/gcc/jit/docs/topics/objects.rst
+++ b/gcc/jit/docs/topics/objects.rst
@@ -47,6 +47,7 @@ looks like this::
+- gcc_jit_rvalue
+- gcc_jit_lvalue
+- gcc_jit_param
+ +- gcc_jit_case
There are casting methods for upcasting from subclasses to parent classes.
For example, :c:func:`gcc_jit_type_as_object`:
diff --git a/gcc/jit/jit-common.h b/gcc/jit/jit-common.h
index 5a8a56d..4052052 100644
--- a/gcc/jit/jit-common.h
+++ b/gcc/jit/jit-common.h
@@ -130,6 +130,7 @@ namespace recording {
class global;
class param;
class statement;
+ class case_;
/* End of recording types. */
}
@@ -151,6 +152,7 @@ namespace playback {
class source_file;
class source_line;
class location;
+ class case_;
/* End of playback types. */
}
diff --git a/gcc/jit/jit-playback.c b/gcc/jit/jit-playback.c
index ee492ef..aff52c8 100644
--- a/gcc/jit/jit-playback.c
+++ b/gcc/jit/jit-playback.c
@@ -1578,6 +1578,78 @@ add_return (location *loc,
add_stmt (return_stmt);
}
+/* Helper function for playback::block::add_switch.
+ Construct a case label for the given range, followed by a goto stmt
+ to the given block, appending them to stmt list *ptr_t_switch_body. */
+
+static void
+add_case (tree *ptr_t_switch_body,
+ tree t_low_value,
+ tree t_high_value,
+ playback::block *dest_block)
+{
+ tree t_case_label =
+ build_case_label (t_low_value, t_high_value,
+ create_artificial_label (UNKNOWN_LOCATION));
+ append_to_statement_list (t_case_label, ptr_t_switch_body);
+
+ tree t_goto_stmt =
+ build1 (GOTO_EXPR, void_type_node, dest_block->as_label_decl ());
+ append_to_statement_list (t_goto_stmt, ptr_t_switch_body);
+}
+
+/* Add a switch statement to the function's statement list.
+
+ My initial attempt at implementing this constructed a TREE_VEC
+ of the cases and set it as SWITCH_LABELS (switch_expr). However,
+ gimplify.c:gimplify_switch_expr is set up to deal with SWITCH_BODY, and
+ doesn't have any logic for gimplifying SWITCH_LABELS.
+
+ Hence we create a switch body, and populate it with case labels, each
+ followed by a goto to the desired block. */
+
+void
+playback::block::
+add_switch (location *loc,
+ rvalue *expr,
+ block *default_block,
+ const auto_vec <case_> *cases)
+{
+ /* Compare with:
+ - c/c-typeck.c: c_start_case
+ - c-family/c-common.c:c_add_case_label
+ - java/expr.c:expand_java_switch and expand_java_add_case
+ We've already rejected overlaps and duplicates in
+ libgccjit.c:case_range_validator::validate. */
+
+ tree t_expr = expr->as_tree ();
+ tree t_type = TREE_TYPE (t_expr);
+
+ tree t_switch_body = alloc_stmt_list ();
+
+ int i;
+ case_ *c;
+ FOR_EACH_VEC_ELT (*cases, i, c)
+ {
+ tree t_low_value = c->m_min_value->as_tree ();
+ tree t_high_value = c->m_max_value->as_tree ();
+ add_case (&t_switch_body,
+ t_low_value,
+ t_high_value,
+ c->m_dest_block);
+ }
+ /* Default label. */
+ add_case (&t_switch_body,
+ NULL_TREE, NULL_TREE,
+ default_block);
+
+ tree switch_stmt = build3 (SWITCH_EXPR, t_type, t_expr,
+ t_switch_body, NULL_TREE);
+ if (loc)
+ set_tree_location (switch_stmt, loc);
+ add_stmt (switch_stmt);
+}
+
/* Constructor for gcc::jit::playback::block. */
playback::block::
diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h
index deb84ef..73ab1ca 100644
--- a/gcc/jit/jit-playback.h
+++ b/gcc/jit/jit-playback.h
@@ -440,6 +440,19 @@ private:
vec<block *> m_blocks;
};
+struct case_
+{
+ case_ (rvalue *min_value, rvalue *max_value, block *dest_block)
+ : m_min_value (min_value),
+ m_max_value (max_value),
+ m_dest_block (dest_block)
+ {}
+
+ rvalue *m_min_value;
+ rvalue *m_max_value;
+ block *m_dest_block;
+};
+
class block : public wrapper
{
public:
@@ -481,6 +494,12 @@ public:
add_return (location *loc,
rvalue *rvalue);
+ void
+ add_switch (location *loc,
+ rvalue *expr,
+ block *default_block,
+ const auto_vec <case_> *cases);
+
private:
void
set_tree_location (tree t, location *loc)
diff --git a/gcc/jit/jit-recording.c b/gcc/jit/jit-recording.c
index 09bb738..6dbd009 100644
--- a/gcc/jit/jit-recording.c
+++ b/gcc/jit/jit-recording.c
@@ -1086,6 +1086,22 @@ recording::context::new_array_access (recording::location *loc,
return result;
}
+/* Create a recording::case_ instance and add it to this context's list
+ of mementos.
+
+ Implements the post-error-checking part of
+ gcc_jit_context_new_case. */
+
+recording::case_ *
+recording::context::new_case (recording::rvalue *min_value,
+ recording::rvalue *max_value,
+ recording::block *block)
+{
+ recording::case_ *result = new case_ (this, min_value, max_value, block);
+ record (result);
+ return result;
+}
+
/* Set the given string option for this context, or add an error if
it's not recognized.
@@ -3553,23 +3569,13 @@ recording::function::validate ()
/* Add successor blocks that aren't yet marked to the worklist. */
/* We checked that each block has a terminating statement above . */
- block *next1, *next2;
- int n = b->get_successor_blocks (&next1, &next2);
- switch (n)
- {
- default:
- gcc_unreachable ();
- case 2:
- if (!next2->m_is_reachable)
- worklist.safe_push (next2);
- /* fallthrough */
- case 1:
- if (!next1->m_is_reachable)
- worklist.safe_push (next1);
- break;
- case 0:
- break;
- }
+ vec <block *> successors = b->get_successor_blocks ();
+ int i;
+ block *succ;
+ FOR_EACH_VEC_ELT (successors, i, succ)
+ if (!succ->m_is_reachable)
+ worklist.safe_push (succ);
+ successors.release ();
}
/* Now complain about any blocks that haven't been marked. */
@@ -3818,6 +3824,30 @@ recording::block::end_with_return (recording::location *loc,
return result;
}
+/* Create a recording::switch_ instance and add it to
+ the block's context's list of mementos, and to the block's
+ list of statements.
+
+ Implements the heart of gcc_jit_block_end_with_switch. */
+
+recording::statement *
+recording::block::end_with_switch (recording::location *loc,
+ recording::rvalue *expr,
+ recording::block *default_block,
+ int num_cases,
+ recording::case_ **cases)
+{
+ statement *result = new switch_ (this, loc,
+ expr,
+ default_block,
+ num_cases,
+ cases);
+ m_ctxt->record (result);
+ m_statements.safe_push (result);
+ m_has_been_terminated = true;
+ return result;
+}
+
/* Override the default implementation of
recording::memento::write_to_dump for blocks by writing
an unindented block name as a label, followed by the indented
@@ -3895,24 +3925,20 @@ recording::block::get_last_statement () const
return NULL;
}
-/* Assuming that this block has been terminated, get the number of
- successor blocks, which will be 0, 1 or 2, for return, unconditional
- jump, and conditional jump respectively.
- NEXT1 and NEXT2 must be non-NULL. The first successor block (if any)
- is written to NEXT1, and the second (if any) to NEXT2.
+/* Assuming that this block has been terminated, get the successor blocks
+ as a vector. Ownership of the vector transfers to the caller, which
+ must call its release () method.
Used when validating functions, and when dumping dot representations
of them. */
-int
-recording::block::get_successor_blocks (block **next1, block **next2) const
+vec <recording::block *>
+recording::block::get_successor_blocks () const
{
gcc_assert (m_has_been_terminated);
- gcc_assert (next1);
- gcc_assert (next2);
statement *last_statement = get_last_statement ();
gcc_assert (last_statement);
- return last_statement->get_successor_blocks (next1, next2);
+ return last_statement->get_successor_blocks ();
}
/* Implementation of pure virtual hook recording::memento::replay_into
@@ -3990,12 +4016,14 @@ recording::block::dump_to_dot (pretty_printer *pp)
void
recording::block::dump_edges_to_dot (pretty_printer *pp)
{
- block *next[2];
- int num_succs = get_successor_blocks (&next[0], &next[1]);
- for (int i = 0; i < num_succs; i++)
+ vec <block *> successors = get_successor_blocks ();
+ int i;
+ block *succ;
+ FOR_EACH_VEC_ELT (successors, i, succ)
pp_printf (pp,
"\tblock_%d:s -> block_%d:n;\n",
- m_index, next[i]->m_index);
+ m_index, succ->m_index);
+ successors.release ();
}
/* The implementation of class gcc::jit::recording::global. */
@@ -4140,6 +4168,16 @@ memento_of_new_rvalue_from_const <int>::make_debug_string ()
m_value);
}
+/* The get_wide_int specialization for <int>. */
+
+template <>
+bool
+memento_of_new_rvalue_from_const <int>::get_wide_int (wide_int *out) const
+{
+ *out = wi::shwi (m_value, sizeof (m_value) * 8);
+ return true;
+}
+
/* The write_reproducer specialization for <int>. */
template <>
@@ -4172,6 +4210,16 @@ memento_of_new_rvalue_from_const <long>::make_debug_string ()
m_value);
}
+/* The get_wide_int specialization for <long>. */
+
+template <>
+bool
+memento_of_new_rvalue_from_const <long>::get_wide_int (wide_int *out) const
+{
+ *out = wi::shwi (m_value, sizeof (m_value) * 8);
+ return true;
+}
+
/* The write_reproducer specialization for <long>. */
template <>
@@ -4225,6 +4273,15 @@ memento_of_new_rvalue_from_const <double>::make_debug_string ()
m_value);
}
+/* The get_wide_int specialization for <double>. */
+
+template <>
+bool
+memento_of_new_rvalue_from_const <double>::get_wide_int (wide_int *) const
+{
+ return false;
+}
+
/* The write_reproducer specialization for <double>. */
template <>
@@ -4264,6 +4321,15 @@ memento_of_new_rvalue_from_const <void *>::make_debug_string ()
m_type->get_debug_string ());
}
+/* The get_wide_int specialization for <void *>. */
+
+template <>
+bool
+memento_of_new_rvalue_from_const <void *>::get_wide_int (wide_int *) const
+{
+ return false;
+}
+
/* Implementation of recording::memento::write_reproducer for <void *>
values. */
@@ -5262,14 +5328,15 @@ recording::local::write_reproducer (reproducer &r)
since this vfunc must only ever be called on terminator
statements. */
-int
-recording::statement::get_successor_blocks (block **/*out_next1*/,
- block **/*out_next2*/) const
+vec <recording::block *>
+recording::statement::get_successor_blocks () const
{
/* The base class implementation is for non-terminating statements,
and thus should never be called. */
gcc_unreachable ();
- return 0;
+ vec <block *> result;
+ result.create (0);
+ return result;
}
/* Extend the default implementation of
@@ -5478,13 +5545,14 @@ recording::conditional::replay_into (replayer *r)
A conditional jump has 2 successor blocks. */
-int
-recording::conditional::get_successor_blocks (block **out_next1,
- block **out_next2) const
+vec <recording::block *>
+recording::conditional::get_successor_blocks () const
{
- *out_next1 = m_on_true;
- *out_next2 = m_on_false;
- return 2;
+ vec <block *> result;
+ result.create (2);
+ result.quick_push (m_on_true);
+ result.quick_push (m_on_false);
+ return result;
}
/* Implementation of recording::memento::make_debug_string for
@@ -5542,12 +5610,13 @@ recording::jump::replay_into (replayer *r)
An unconditional jump has 1 successor block. */
-int
-recording::jump::get_successor_blocks (block **out_next1,
- block **/*out_next2*/) const
+vec <recording::block *>
+recording::jump::get_successor_blocks () const
{
- *out_next1 = m_target;
- return 1;
+ vec <block *> result;
+ result.create (1);
+ result.quick_push (m_target);
+ return result;
}
/* Implementation of recording::memento::make_debug_string for
@@ -5593,11 +5662,12 @@ recording::return_::replay_into (replayer *r)
A return statement has no successor block. */
-int
-recording::return_::get_successor_blocks (block **/*out_next1*/,
- block **/*out_next2*/) const
+vec <recording::block *>
+recording::return_::get_successor_blocks () const
{
- return 0;
+ vec <block *> result;
+ result.create (0);
+ return result;
}
/* Implementation of recording::memento::make_debug_string for
@@ -5635,6 +5705,158 @@ recording::return_::write_reproducer (reproducer &r)
r.get_identifier (get_loc ()));
}
+/* The implementation of class gcc::jit::recording::case_. */
+
+void
+recording::case_::write_reproducer (reproducer &r)
+{
+ const char *id = r.make_identifier (this, "case");
+ const char *fmt =
+ " gcc_jit_case *%s = \n"
+ " gcc_jit_context_new_case (%s, /*gcc_jit_context *ctxt */\n"
+ " %s, /* gcc_jit_rvalue *min_value */\n"
+ " %s, /* gcc_jit_rvalue *max_value */\n"
+ " %s); /* gcc_jit_block *dest_block */\n";
+ r.write (fmt,
+ id,
+ r.get_identifier (get_context ()),
+ r.get_identifier_as_rvalue (m_min_value),
+ r.get_identifier_as_rvalue (m_max_value),
+ r.get_identifier (m_dest_block));
+}
+
+recording::string *
+recording::case_::make_debug_string ()
+{
+ return string::from_printf (get_context (),
+ "case %s ... %s: goto %s;",
+ m_min_value->get_debug_string (),
+ m_max_value->get_debug_string (),
+ m_dest_block->get_debug_string ());
+}
+
+/* The implementation of class gcc::jit::recording::switch_. */
+
+/* gcc::jit::recording::switch_'s constructor. */
+
+recording::switch_::switch_ (block *b,
+ location *loc,
+ rvalue *expr,
+ block *default_block,
+ int num_cases,
+ case_ **cases)
+: statement (b, loc),
+ m_expr (expr),
+ m_default_block (default_block)
+{
+ m_cases.reserve_exact (num_cases);
+ for (int i = 0; i< num_cases; i++)
+ m_cases.quick_push (cases[i]);
+}
+
+/* Implementation of pure virtual hook recording::memento::replay_into
+ for recording::switch_. */
+
+void
+recording::switch_::replay_into (replayer *r)
+{
+ auto_vec <playback::case_> pcases;
+ int i;
+ recording::case_ *rcase;
+ pcases.reserve_exact (m_cases.length ());
+ FOR_EACH_VEC_ELT (m_cases, i, rcase)
+ {
+ playback::case_ pcase (rcase->get_min_value ()->playback_rvalue (),
+ rcase->get_max_value ()->playback_rvalue (),
+ rcase->get_dest_block ()->playback_block ());
+ pcases.safe_push (pcase);
+ }
+ playback_block (get_block ())
+ ->add_switch (playback_location (r),
+ m_expr->playback_rvalue (),
+ m_default_block->playback_block (),
+ &pcases);
+}
+
+/* Override the poisoned default implementation of
+ gcc::jit::recording::statement::get_successor_blocks
+
+ A switch statement has (NUM_CASES + 1) successor blocks. */
+
+vec <recording::block *>
+recording::switch_::get_successor_blocks () const
+{
+ vec <block *> result;
+ result.create (m_cases.length () + 1);
+ result.quick_push (m_default_block);
+ int i;
+ case_ *c;
+ FOR_EACH_VEC_ELT (m_cases, i, c)
+ result.quick_push (c->get_dest_block ());
+ return result;
+}
+
+/* Implementation of recording::memento::make_debug_string for
+ a switch statement. */
+
+recording::string *
+recording::switch_::make_debug_string ()
+{
+ auto_vec <char> cases_str;
+ int i;
+ case_ *c;
+ FOR_EACH_VEC_ELT (m_cases, i, c)
+ {
+ size_t len = strlen (c->get_debug_string ());
+ unsigned idx = cases_str.length ();
+ cases_str.safe_grow (idx + 1 + len);
+ cases_str[idx] = ' ';
+ memcpy (&(cases_str[idx + 1]),
+ c->get_debug_string (),
+ len);
+ }
+ cases_str.safe_push ('\0');
+
+ return string::from_printf (m_ctxt,
+ "switch (%s) {default: goto %s;%s}",
+ m_expr->get_debug_string (),
+ m_default_block->get_debug_string (),
+ &cases_str[0]);
+}
+
+/* Implementation of recording::memento::write_reproducer for
+ switch statements. */
+
+void
+recording::switch_::write_reproducer (reproducer &r)
+{
+ r.make_identifier (this, "switch");
+ int i;
+ case_ *c;
+ const char *cases_id =
+ r.make_tmp_identifier ("cases_for", this);
+ r.write (" gcc_jit_case *%s[%i] = {\n",
+ cases_id,
+ m_cases.length ());
+ FOR_EACH_VEC_ELT (m_cases, i, c)
+ r.write (" %s,\n", r.get_identifier (c));
+ r.write (" };\n");
+ const char *fmt =
+ " gcc_jit_block_end_with_switch (%s, /*gcc_jit_block *block */\n"
+ " %s, /* gcc_jit_location *loc */\n"
+ " %s, /* gcc_jit_rvalue *expr */\n"
+ " %s, /* gcc_jit_block *default_block */\n"
+ " %i, /* int num_cases */\n"
+ " %s); /* gcc_jit_case **cases */\n";
+ r.write (fmt,
+ r.get_identifier (get_block ()),
+ r.get_identifier (get_loc ()),
+ r.get_identifier_as_rvalue (m_expr),
+ r.get_identifier (m_default_block),
+ m_cases.length (),
+ cases_id);
+}
+
} // namespace gcc::jit
} // namespace gcc
diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
index 090eb5d..4dd2249 100644
--- a/gcc/jit/jit-recording.h
+++ b/gcc/jit/jit-recording.h
@@ -183,6 +183,11 @@ public:
rvalue *ptr,
rvalue *index);
+ case_ *
+ new_case (rvalue *min_value,
+ rvalue *max_value,
+ block *block);
+
void
set_str_option (enum gcc_jit_str_option opt,
const char *value);
@@ -961,6 +966,9 @@ public:
const char *
get_debug_string_parens (enum precedence outer_prec);
+ virtual bool is_constant () const { return false; }
+ virtual bool get_wide_int (wide_int *) const { return false; }
+
private:
virtual enum precedence get_precedence () const = 0;
@@ -1159,6 +1167,13 @@ public:
end_with_return (location *loc,
rvalue *rvalue);
+ statement *
+ end_with_switch (location *loc,
+ rvalue *expr,
+ block *default_block,
+ int num_cases,
+ case_ **cases);
+
playback::block *
playback_block () const
{
@@ -1174,7 +1189,7 @@ public:
statement *get_first_statement () const;
statement *get_last_statement () const;
- int get_successor_blocks (block **next1, block **next2) const;
+ vec <block *> get_successor_blocks () const;
private:
string * make_debug_string ();
@@ -1240,6 +1255,10 @@ public:
void visit_children (rvalue_visitor *) {}
+ bool is_constant () const { return true; }
+
+ bool get_wide_int (wide_int *out) const;
+
private:
string * make_debug_string ();
void write_reproducer (reproducer &r);
@@ -1603,8 +1622,7 @@ private:
class statement : public memento
{
public:
- virtual int get_successor_blocks (block **out_next1,
- block **out_next2) const;
+ virtual vec <block *> get_successor_blocks () const;
void write_to_dump (dump &d);
@@ -1728,8 +1746,7 @@ public:
void replay_into (replayer *r);
- int get_successor_blocks (block **out_next1,
- block **out_next2) const;
+ vec <block *> get_successor_blocks () const;
private:
string * make_debug_string ();
@@ -1752,8 +1769,7 @@ public:
void replay_into (replayer *r);
- int get_successor_blocks (block **out_next1,
- block **out_next2) const;
+ vec <block *> get_successor_blocks () const;
private:
string * make_debug_string ();
@@ -1774,8 +1790,7 @@ public:
void replay_into (replayer *r);
- int get_successor_blocks (block **out_next1,
- block **out_next2) const;
+ vec <block *> get_successor_blocks () const;
private:
string * make_debug_string ();
@@ -1785,6 +1800,60 @@ private:
rvalue *m_rvalue;
};
+class case_ : public memento
+{
+ public:
+ case_ (context *ctxt,
+ rvalue *min_value,
+ rvalue *max_value,
+ block *dest_block)
+ : memento (ctxt),
+ m_min_value (min_value),
+ m_max_value (max_value),
+ m_dest_block (dest_block)
+ {}
+
+ rvalue *get_min_value () const { return m_min_value; }
+ rvalue *get_max_value () const { return m_max_value; }
+ block *get_dest_block () const { return m_dest_block; }
+
+ void replay_into (replayer *) { /* empty */ }
+
+ void write_reproducer (reproducer &r);
+
+private:
+ string * make_debug_string ();
+
+ private:
+ rvalue *m_min_value;
+ rvalue *m_max_value;
+ block *m_dest_block;
+};
+
+class switch_ : public statement
+{
+public:
+ switch_ (block *b,
+ location *loc,
+ rvalue *expr,
+ block *default_block,
+ int num_cases,
+ case_ **cases);
+
+ void replay_into (replayer *r);
+
+ vec <block *> get_successor_blocks () const;
+
+private:
+ string * make_debug_string ();
+ void write_reproducer (reproducer &r);
+
+private:
+ rvalue *m_expr;
+ block *m_default_block;
+ auto_vec <case_ *> m_cases;
+};
+
} // namespace gcc::jit::recording
/* Create a recording::memento_of_new_rvalue_from_const instance and add
diff --git a/gcc/jit/libgccjit++.h b/gcc/jit/libgccjit++.h
index 62ef6a4..40e123b 100644
--- a/gcc/jit/libgccjit++.h
+++ b/gcc/jit/libgccjit++.h
@@ -45,6 +45,7 @@ namespace gccjit
class rvalue;
class lvalue;
class param;
+ class case_;
/* Errors within the API become C++ exceptions of this class. */
class error
@@ -293,6 +294,10 @@ namespace gccjit
rvalue index,
location loc = location ());
+ case_ new_case (rvalue min_value,
+ rvalue max_value,
+ block dest_block);
+
private:
gcc_jit_context *m_inner_ctxt;
};
@@ -417,6 +422,10 @@ namespace gccjit
location loc = location ());
void end_with_return (location loc = location ());
+ void end_with_switch (rvalue expr,
+ block default_block,
+ std::vector <case_> cases,
+ location loc = location ());
};
class rvalue : public object
@@ -467,6 +476,14 @@ namespace gccjit
gcc_jit_param *get_inner_param () const;
};
+ class case_ : public object
+ {
+ public:
+ case_ ();
+ case_ (gcc_jit_case *inner);
+
+ gcc_jit_case *get_inner_case () const;
+ };
/* Overloaded operators, for those who want the most terse API
(at the possible risk of being a little too magical).
@@ -1108,6 +1125,17 @@ context::new_array_access (rvalue ptr,
index.get_inner_rvalue ()));
}
+inline case_
+context::new_case (rvalue min_value,
+ rvalue max_value,
+ block dest_block)
+{
+ return case_ (gcc_jit_context_new_case (m_inner_ctxt,
+ min_value.get_inner_rvalue (),
+ max_value.get_inner_rvalue (),
+ dest_block.get_inner_block ()));
+}
+
// class object
inline context
object::get_context () const
@@ -1355,6 +1383,27 @@ block::end_with_return (location loc)
loc.get_inner_location ());
}
+inline void
+block::end_with_switch (rvalue expr,
+ block default_block,
+ std::vector <case_> cases,
+ location loc)
+{
+ /* Treat std::vector as an array, relying on it not being resized: */
+ case_ *as_array_of_wrappers = &cases[0];
+
+ /* Treat the array as being of the underlying pointers, relying on
+ the wrapper type being such a pointer internally. */
+ gcc_jit_case **as_array_of_ptrs =
+ reinterpret_cast<gcc_jit_case **> (as_array_of_wrappers);
+ gcc_jit_block_end_with_switch (get_inner_block (),
+ loc.get_inner_location (),
+ expr.get_inner_rvalue (),
+ default_block.get_inner_block (),
+ cases.size (),
+ as_array_of_ptrs);
+}
+
inline rvalue
block::add_call (function other,
location loc)
@@ -1545,6 +1594,20 @@ inline param::param (gcc_jit_param *inner)
: lvalue (gcc_jit_param_as_lvalue (inner))
{}
+// class case_ : public object
+inline case_::case_ () : object () {}
+inline case_::case_ (gcc_jit_case *inner)
+ : object (gcc_jit_case_as_object (inner))
+{
+}
+
+inline gcc_jit_case *
+case_::get_inner_case () const
+{
+ /* Manual downcast: */
+ return reinterpret_cast<gcc_jit_case *> (get_inner_object ());
+}
+
/* Overloaded operators. */
// Unary operators
inline rvalue operator- (rvalue a)
diff --git a/gcc/jit/libgccjit.c b/gcc/jit/libgccjit.c
index 6e57127..cad1579 100644
--- a/gcc/jit/libgccjit.c
+++ b/gcc/jit/libgccjit.c
@@ -23,6 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h"
#include "opts.h"
#include "safe-ctype.h"
+#include "typed-splay-tree.h"
#include "libgccjit.h"
#include "jit-common.h"
@@ -84,6 +85,10 @@ struct gcc_jit_param : public gcc::jit::recording::param
{
};
+struct gcc_jit_case : public gcc::jit::recording::case_
+{
+};
+
/**********************************************************************
Error-handling.
@@ -2123,6 +2128,382 @@ gcc_jit_block_end_with_void_return (gcc_jit_block *block,
block->end_with_return (loc, NULL);
}
+/* Public entrypoint. See description in libgccjit.h.
+
+ After error-checking, the real work is done by the
+ gcc::jit::recording::context::new_case method in
+ jit-recording.c. */
+
+gcc_jit_case *
+gcc_jit_context_new_case (gcc_jit_context *ctxt,
+ gcc_jit_rvalue *min_value,
+ gcc_jit_rvalue *max_value,
+ gcc_jit_block *block)
+{
+ RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context");
+ JIT_LOG_FUNC (ctxt->get_logger ());
+ RETURN_NULL_IF_FAIL (min_value, ctxt, NULL, "NULL min_value");
+ RETURN_NULL_IF_FAIL (max_value, ctxt, NULL, "NULL max_value");
+ RETURN_NULL_IF_FAIL (block, ctxt, NULL, "NULL block");
+
+ RETURN_NULL_IF_FAIL_PRINTF1 (min_value->is_constant (), ctxt, NULL,
+ "min_value is not a constant: %s",
+ min_value->get_debug_string ());
+ RETURN_NULL_IF_FAIL_PRINTF1 (max_value->is_constant (), ctxt, NULL,
+ "max_value is not a constant: %s",
+ max_value->get_debug_string ());
+ RETURN_NULL_IF_FAIL_PRINTF2 (
+ min_value->get_type ()->is_int (),
+ ctxt, NULL,
+ "min_value: %s (type: %s) is not of integer type",
+ min_value->get_debug_string (),
+ min_value->get_type ()->get_debug_string ());
+ RETURN_NULL_IF_FAIL_PRINTF2 (
+ max_value->get_type ()->is_int (),
+ ctxt, NULL,
+ "max_value: %s (type: %s) is not of integer type",
+ max_value->get_debug_string (),
+ max_value->get_type ()->get_debug_string ());
+
+ wide_int wi_min, wi_max;
+ if (!min_value->get_wide_int (&wi_min))
+ gcc_unreachable ();
+ if (!max_value->get_wide_int (&wi_max))
+ gcc_unreachable ();
+ RETURN_NULL_IF_FAIL_PRINTF2 (
+ wi::les_p (wi_min, wi_max),
+ ctxt, NULL,
+ "min_value: %s > max_value: %s",
+ min_value->get_debug_string (),
+ max_value->get_debug_string ());
+ return (gcc_jit_case *)ctxt->new_case (min_value,
+ max_value,
+ block);
+}
+
+/* Public entrypoint. See description in libgccjit.h.
+
+ After error-checking, this calls the trivial
+ gcc::jit::recording::memento::as_object method (a case is a
+ memento), in jit-recording.h. */
+
+gcc_jit_object *
+gcc_jit_case_as_object (gcc_jit_case *case_)
+{
+ RETURN_NULL_IF_FAIL (case_, NULL, NULL, "NULL case");
+
+ return static_cast <gcc_jit_object *> (case_->as_object ());
+}
+
+/* Helper function for gcc_jit_block_end_with_switch and
+ valid_case_for_switch. */
+
+static bool
+valid_dest_for_switch (gcc::jit::recording::context *ctxt,
+ gcc_jit_location *loc,
+ const char *api_funcname,
+ gcc::jit::recording::block *switch_block,
+ gcc::jit::recording::block *dest_block,
+ const char *dest_block_desc)
+{
+ if (!dest_block)
+ {
+ jit_error (ctxt, loc, "%s: NULL %s", api_funcname, dest_block_desc);
+ return false;
+ }
+ gcc::jit::recording::function *switch_fn = switch_block->get_function ();
+ gcc::jit::recording::function *dest_fn = dest_block->get_function ();
+ if (switch_fn != dest_fn)
+ {
+ jit_error (ctxt, loc,
+ "%s: %s is not in same function:"
+ " switch block %s is in function %s"
+ " whereas %s %s is in function %s",
+ api_funcname,
+ dest_block_desc,
+ switch_block->get_debug_string (),
+ switch_fn->get_debug_string (),
+ dest_block_desc,
+ dest_block->get_debug_string (),
+ dest_fn->get_debug_string ());
+ return false;
+ }
+ return true;
+}
+
+/* Helper function for gcc_jit_block_end_with_switch. */
+
+static bool
+valid_case_for_switch (gcc::jit::recording::context *ctxt,
+ gcc_jit_location *loc,
+ const char *api_funcname,
+ gcc_jit_block *switch_block,
+ gcc_jit_rvalue *expr,
+ gcc_jit_case *case_,
+ const char *case_desc,
+ int case_idx)
+{
+ if (!case_)
+ {
+ jit_error (ctxt, loc,
+ "%s:"
+ " NULL case %i",
+ api_funcname,
+ case_idx);
+ return false;
+ }
+ if (!valid_dest_for_switch (ctxt, loc,
+ api_funcname,
+ switch_block,
+ case_->get_dest_block (),
+ case_desc))
+ return false;
+ gcc::jit::recording::type *expr_type = expr->get_type ();
+ if (expr_type != case_->get_min_value ()->get_type ())
+ {
+ jit_error (ctxt, loc,
+ "%s:"
+ " mismatching types between case and expression:"
+ " cases[%i]->min_value: %s (type: %s)"
+ " expr: %s (type: %s)",
+ api_funcname,
+ case_idx,
+ case_->get_min_value ()->get_debug_string (),
+ case_->get_min_value ()->get_type ()->get_debug_string (),
+ expr->get_debug_string (),
+ expr_type->get_debug_string ());
+ return false;
+ }
+ if (expr_type != case_->get_max_value ()->get_type ())
+ {
+ jit_error (ctxt, loc,
+ "%s:"
+ " mismatching types between case and expression:"
+ " cases[%i]->max_value: %s (type: %s)"
+ " expr: %s (type: %s)",
+ api_funcname,
+ case_idx,
+ case_->get_max_value ()->get_debug_string (),
+ case_->get_max_value ()->get_type ()->get_debug_string (),
+ expr->get_debug_string (),
+ expr_type->get_debug_string ());
+ return false;
+ }
+ return true;
+}
+
+/* A class for holding the data we need to perform error-checking
+ on a libgccjit API call. */
+
+class api_call_validator
+{
+ public:
+ api_call_validator (gcc::jit::recording::context *ctxt,
+ gcc_jit_location *loc,
+ const char *funcname)
+ : m_ctxt (ctxt),
+ m_loc (loc),
+ m_funcname (funcname)
+ {}
+
+ protected:
+ gcc::jit::recording::context *m_ctxt;
+ gcc_jit_location *m_loc;
+ const char *m_funcname;
+};
+
+/* A class for verifying that the ranges of cases within
+ gcc_jit_block_end_with_switch don't overlap. */
+
+class case_range_validator : public api_call_validator
+{
+ public:
+ case_range_validator (gcc::jit::recording::context *ctxt,
+ gcc_jit_location *loc,
+ const char *funcname);
+
+ bool
+ validate (gcc_jit_case *case_, int idx);
+
+ private:
+ static int
+ case_compare (gcc::jit::recording::rvalue *k1,
+ gcc::jit::recording::rvalue *k2);
+
+ static wide_int
+ get_wide_int (gcc::jit::recording::rvalue *k);
+
+ private:
+ typed_splay_tree <gcc::jit::recording::rvalue *, gcc_jit_case *> m_cases;
+};
+
+/* case_range_validator's ctor. */
+
+case_range_validator::case_range_validator (gcc::jit::recording::context *ctxt,
+ gcc_jit_location *loc,
+ const char *funcname)
+: api_call_validator (ctxt, loc, funcname),
+ m_cases (case_compare, NULL, NULL)
+{
+}
+
+/* Ensure that the range of CASE_ does not overlap with any of the
+ ranges of cases we've already seen.
+ Return true if everything is OK.
+ Return false and emit an error if there is an overlap.
+ Compare with c-family/c-common.c:c_add_case_label. */
+
+bool
+case_range_validator::validate (gcc_jit_case *case_,
+ int case_idx)
+{
+ /* Look up the LOW_VALUE in the table of case labels we already
+ have. */
+ gcc_jit_case *other = m_cases.lookup (case_->get_min_value ());
+
+ /* If there was not an exact match, check for overlapping ranges. */
+ if (!other)
+ {
+ gcc_jit_case *pred;
+ gcc_jit_case *succ;
+
+ /* Even though there wasn't an exact match, there might be an
+ overlap between this case range and another case range.
+ Since we've (inductively) not allowed any overlapping case
+ ranges, we simply need to find the greatest low case label
+ that is smaller that CASE_MIN_VALUE, and the smallest low case
+ label that is greater than CASE_MAX_VALUE. If there is an overlap
+ it will occur in one of these two ranges. */
+ pred = m_cases.predecessor (case_->get_min_value ());
+ succ = m_cases.successor (case_->get_max_value ());
+
+ /* Check to see if the PRED overlaps. It is smaller than
+ the LOW_VALUE, so we only need to check its max value. */
+ if (pred)
+ {
+ wide_int wi_case_min = get_wide_int (case_->get_min_value ());
+ wide_int wi_pred_max = get_wide_int (pred->get_max_value ());
+ if (wi::ges_p (wi_pred_max, wi_case_min))
+ other = pred;
+ }
+
+ if (!other && succ)
+ {
+ /* Check to see if the SUCC overlaps. The low end of that
+ range is bigger than the low end of the current range. */
+ wide_int wi_case_max = get_wide_int (case_->get_max_value ());
+ wide_int wi_succ_min = get_wide_int (succ->get_min_value ());
+ if (wi::les_p (wi_succ_min, wi_case_max))
+ other = succ;
+ }
+ }
+
+ /* If there was an overlap, issue an error. */
+ if (other)
+ {
+ jit_error (m_ctxt, m_loc,
+ "%s: duplicate (or overlapping) cases values:"
+ " case %i: %s overlaps %s",
+ m_funcname,
+ case_idx,
+ case_->get_debug_string (),
+ other->get_debug_string ());
+ return false;
+ }
+
+ /* Register this case label in the splay tree. */
+ m_cases.insert (case_->get_min_value (),
+ case_);
+ return true;
+}
+
+/* Compare with c-family/c-common.c:case_compare, which acts on tree
+ nodes, rather than rvalue *.
+
+ Comparator for case label values. K1 and K2 must be constant integer
+ values (anything else should have been rejected by
+ gcc_jit_context_new_case.
+
+ Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
+ K2, and 0 if K1 and K2 are equal. */
+
+int
+case_range_validator::case_compare (gcc::jit::recording::rvalue * k1,
+ gcc::jit::recording::rvalue * k2)
+{
+ wide_int wi1 = get_wide_int (k1);
+ wide_int wi2 = get_wide_int (k2);
+ return wi::cmps(wi1, wi2);
+}
+
+/* Given a const int rvalue K, get the underlying value as a wide_int. */
+
+wide_int
+case_range_validator::get_wide_int (gcc::jit::recording::rvalue *k)
+{
+ wide_int wi;
+ bool got_wi = k->get_wide_int (&wi);
+ gcc_assert (got_wi);
+ return wi;
+}
+
+/* Public entrypoint. See description in libgccjit.h.
+
+ After error-checking, the real work is done by the
+ gcc::jit::recording::block::end_with_switch method in
+ jit-recording.c. */
+
+void
+gcc_jit_block_end_with_switch (gcc_jit_block *block,
+ gcc_jit_location *loc,
+ gcc_jit_rvalue *expr,
+ gcc_jit_block *default_block,
+ int num_cases,
+ gcc_jit_case **cases)
+{
+ RETURN_IF_NOT_VALID_BLOCK (block, loc);
+ gcc::jit::recording::context *ctxt = block->get_context ();
+ JIT_LOG_FUNC (ctxt->get_logger ());
+ /* LOC can be NULL. */
+ RETURN_IF_FAIL (expr, ctxt, loc,
+ "NULL expr");
+ gcc::jit::recording::type *expr_type = expr->get_type ();
+ RETURN_IF_FAIL_PRINTF2 (
+ expr_type->is_int (),
+ ctxt, loc,
+ "expr: %s (type: %s) is not of integer type",
+ expr->get_debug_string (),
+ expr_type->get_debug_string ());
+ if (!valid_dest_for_switch (ctxt, loc,
+ __func__,
+ block,
+ default_block,
+ "default_block"))
+ return;
+ RETURN_IF_FAIL (num_cases >= 0, ctxt, loc, "num_cases < 0");
+ case_range_validator crv (ctxt, loc, __func__);
+ for (int i = 0; i < num_cases; i++)
+ {
+ char case_desc[32];
+ snprintf (case_desc, sizeof (case_desc),
+ "cases[%i]", i);
+ if (!valid_case_for_switch (ctxt, loc,
+ __func__,
+ block,
+ expr,
+ cases[i],
+ case_desc,
+ i))
+ return;
+ if (!crv.validate (cases[i], i))
+ return;
+ }
+
+ block->end_with_switch (loc, expr, default_block,
+ num_cases,
+ (gcc::jit::recording::case_ **)cases);
+}
+
/**********************************************************************
Option-management
**********************************************************************/
diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
index 12d3f29..a6874f4 100644
--- a/gcc/jit/libgccjit.h
+++ b/gcc/jit/libgccjit.h
@@ -67,6 +67,7 @@ typedef struct gcc_jit_result gcc_jit_result;
+- gcc_jit_rvalue
+- gcc_jit_lvalue
+- gcc_jit_param
+ +- gcc_jit_case
*/
typedef struct gcc_jit_object gcc_jit_object;
@@ -131,6 +132,12 @@ typedef struct gcc_jit_lvalue gcc_jit_lvalue;
rvalue); use gcc_jit_param_as_lvalue to convert. */
typedef struct gcc_jit_param gcc_jit_param;
+/* A gcc_jit_case is for use when building multiway branches via
+ gcc_jit_block_end_with_switch and represents a range of integer
+ values (or an individual integer value) together with an associated
+ destination block. */
+typedef struct gcc_jit_case gcc_jit_case;
+
/* Acquire a JIT-compilation context. */
extern gcc_jit_context *
gcc_jit_context_acquire (void);
@@ -1076,6 +1083,60 @@ extern void
gcc_jit_block_end_with_void_return (gcc_jit_block *block,
gcc_jit_location *loc);
+/* Create a new gcc_jit_case instance for use in a switch statement.
+ min_value and max_value must be constants of integer type. */
+
+extern gcc_jit_case *
+gcc_jit_context_new_case (gcc_jit_context *ctxt,
+ gcc_jit_rvalue *min_value,
+ gcc_jit_rvalue *max_value,
+ gcc_jit_block *dest_block);
+
+/* Upcasting from case to object. */
+
+extern gcc_jit_object *
+gcc_jit_case_as_object (gcc_jit_case *case_);
+
+/* Terminate a block by adding evalation of an rvalue, then performing
+ a multiway branch.
+
+ This is roughly equivalent to this C code:
+
+ switch (expr)
+ {
+ default:
+ goto default_block;
+
+ case C0.min_value ... C0.max_value:
+ goto C0.dest_block;
+
+ case C1.min_value ... C1.max_value:
+ goto C1.dest_block;
+
+ ...etc...
+
+ case C[N - 1].min_value ... C[N - 1].max_value:
+ goto C[N - 1].dest_block;
+ }
+
+ block, expr, default_block and cases must all be non-NULL.
+
+ expr must be of the same integer type as all of the min_value
+ and max_value within the cases.
+
+ num_cases must be >= 0.
+
+ The ranges of the cases must not overlap (or have duplicate
+ values). */
+
+extern void
+gcc_jit_block_end_with_switch (gcc_jit_block *block,
+ gcc_jit_location *loc,
+ gcc_jit_rvalue *expr,
+ gcc_jit_block *default_block,
+ int num_cases,
+ gcc_jit_case **cases);
+
/**********************************************************************
Nested contexts.
**********************************************************************/
diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map
index 2fa6217..93b19e8 100644
--- a/gcc/jit/libgccjit.map
+++ b/gcc/jit/libgccjit.map
@@ -29,7 +29,9 @@
gcc_jit_block_end_with_jump;
gcc_jit_block_end_with_return;
gcc_jit_block_end_with_void_return;
+ gcc_jit_block_end_with_switch;
gcc_jit_block_get_function;
+ gcc_jit_case_as_object;
gcc_jit_context_acquire;
gcc_jit_context_add_option;
gcc_jit_context_compile;
@@ -47,6 +49,7 @@
gcc_jit_context_new_binary_op;
gcc_jit_context_new_call;
gcc_jit_context_new_call_through_ptr;
+ gcc_jit_context_new_case;
gcc_jit_context_new_cast;
gcc_jit_context_new_child_context;
gcc_jit_context_new_comparison;
diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h
index a54041f..15fa556 100644
--- a/gcc/testsuite/jit.dg/all-non-failing-tests.h
+++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h
@@ -175,6 +175,13 @@
#undef create_code
#undef verify_code
+/* test-switch.c */
+#define create_code create_code_switch
+#define verify_code verify_code_switch
+#include "test-switch.c"
+#undef create_code
+#undef verify_code
+
/* test-types.c */
#define create_code create_code_types
#define verify_code verify_code_types
@@ -277,6 +284,9 @@ const struct testcase testcases[] = {
{"sum_of_squares",
create_code_sum_of_squares,
verify_code_sum_of_squares},
+ {"switch",
+ create_code_switch,
+ verify_code_switch},
{"types",
create_code_types,
verify_code_types},
diff --git a/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-NULL-case.c b/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-NULL-case.c
new file mode 100644
index 0000000..07a9848
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-NULL-case.c
@@ -0,0 +1,66 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case x:
+ return 3;
+
+ default:
+ return 10;
+ }
+ }
+ and verify that we get a sane error about the non-const
+ case.
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = {x};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+
+ gcc_jit_case *cases[1] = {
+ NULL
+ };
+
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 1,
+ cases);
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ CHECK_VALUE (result, NULL);
+
+ CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt),
+ "gcc_jit_block_end_with_switch: NULL case 0");
+}
diff --git a/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-mismatching-case-type.c b/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-mismatching-case-type.c
new file mode 100644
index 0000000..cc907ce
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-mismatching-case-type.c
@@ -0,0 +1,83 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case (long long)0 ... (long long)5:
+ return 3;
+ default:
+ return 10;
+ }
+ }
+ and verify that the floating-point case is an error.
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *t_long_long =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_LONG_LONG);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = {x};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+ gcc_jit_block *b_case_0 =
+ gcc_jit_function_new_block (func, "case_0");
+
+ /* Note the erroneous use of "t_float" here. */
+ gcc_jit_case *cases[1] = {
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_long_long, 0),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_long_long, 5),
+ b_case_0)
+ };
+
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 1,
+ cases);
+
+ gcc_jit_block_end_with_return (
+ b_case_0, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 3));
+ gcc_jit_block_end_with_return (
+ b_default, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10));
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ CHECK_VALUE (result, NULL);
+
+ CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt),
+ "gcc_jit_block_end_with_switch:"
+ " mismatching types between case and expression:"
+ " cases[0]->min_value: (long long)0 (type: long long)"
+ " expr: x (type: int)");
+}
diff --git a/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-overlapping-ranges.c b/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-overlapping-ranges.c
new file mode 100644
index 0000000..40655c2
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-overlapping-ranges.c
@@ -0,0 +1,95 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case 0 ... 5:
+ return 3;
+
+ case 5 ... 10:
+ return 4;
+
+ default:
+ return 10;
+ }
+ }
+ and verify that we get an error about the overlapping
+ ranges.
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = {x};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+ gcc_jit_block *b_case_0_5 =
+ gcc_jit_function_new_block (func, "case_0_5");
+ gcc_jit_block *b_case_5_10 =
+ gcc_jit_function_new_block (func, "case_5_10");
+
+ gcc_jit_case *cases[2] = {
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 0),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 5),
+ b_case_0_5),
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 5),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10),
+ b_case_5_10)
+ };
+
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 2,
+ cases);
+
+ gcc_jit_block_end_with_return (
+ b_case_0_5, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 3));
+ gcc_jit_block_end_with_return (
+ b_case_5_10, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 4));
+ gcc_jit_block_end_with_return (
+ b_default, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10));
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ CHECK_VALUE (result, NULL);
+
+ CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt),
+ "gcc_jit_block_end_with_switch:"
+ " duplicate (or overlapping) cases values:"
+ " case 1: case (int)5 ... (int)10: goto case_5_10;"
+ " overlaps case (int)0 ... (int)5: goto case_0_5;");
+}
diff --git a/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-const-label.c b/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-const-label.c
new file mode 100644
index 0000000..3953818
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-const-label.c
@@ -0,0 +1,80 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case x:
+ return 3;
+
+ default:
+ return 10;
+ }
+ }
+ and verify that we get a sane error about the non-const
+ case.
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = {x};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+ gcc_jit_block *b_case_x =
+ gcc_jit_function_new_block (func, "case_x");
+
+ /* Erroneous use of non-const x for a case. */
+ gcc_jit_case *cases[1] = {
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_param_as_rvalue (x),
+ gcc_jit_param_as_rvalue (x),
+ b_case_x)
+ };
+
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 1,
+ cases);
+ gcc_jit_block_end_with_return (
+ b_case_x, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 3));
+ gcc_jit_block_end_with_return (
+ b_default, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10));
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ CHECK_VALUE (result, NULL);
+
+ CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt),
+ "gcc_jit_context_new_case:"
+ " min_value is not a constant: x");
+}
diff --git a/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-integer-type.c b/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-integer-type.c
new file mode 100644
index 0000000..5d44286
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-integer-type.c
@@ -0,0 +1,81 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case 0.f ... 5.f:
+ return 3;
+ default:
+ return 10;
+ }
+ }
+ and verify that the floating-point case is an error.
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *t_float =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_FLOAT);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = {x};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+ gcc_jit_block *b_case_0 =
+ gcc_jit_function_new_block (func, "case_0");
+
+ /* Note the erroneous use of "t_float" here. */
+ gcc_jit_case *cases[1] = {
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_float, 0),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_float, 5),
+ b_case_0)
+ };
+
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 1,
+ cases);
+
+ gcc_jit_block_end_with_return (
+ b_case_0, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 3));
+ gcc_jit_block_end_with_return (
+ b_default, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10));
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ CHECK_VALUE (result, NULL);
+
+ CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt),
+ "gcc_jit_context_new_case:"
+ " min_value: (float)0 (type: float) is not of integer type");
+}
diff --git a/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-reversed-endpoints.c b/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-reversed-endpoints.c
new file mode 100644
index 0000000..a84d9f3
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-reversed-endpoints.c
@@ -0,0 +1,80 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case 5 ... 0:
+ return 3;
+
+ default:
+ return 10;
+ }
+ }
+ and verify that we get an error about the reversed endpoints
+ in the range.
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = {x};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+ gcc_jit_block *b_case_5_0 =
+ gcc_jit_function_new_block (func, "case_5_0");
+
+ gcc_jit_case *cases[1] = {
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 5),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 0),
+ b_case_5_0)
+ };
+
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 1,
+ cases);
+
+ gcc_jit_block_end_with_return (
+ b_case_5_0, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 3));
+ gcc_jit_block_end_with_return (
+ b_default, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10));
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ CHECK_VALUE (result, NULL);
+
+ CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt),
+ "gcc_jit_context_new_case:"
+ " min_value: (int)5 > max_value: (int)0");
+}
diff --git a/gcc/testsuite/jit.dg/test-switch.c b/gcc/testsuite/jit.dg/test-switch.c
new file mode 100644
index 0000000..74088c8
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-switch.c
@@ -0,0 +1,147 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+/* Quote from here in docs/topics/functions.rst. */
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case 0 ... 5:
+ return 3;
+
+ case 25 ... 27:
+ return 4;
+
+ case -42 ... -17:
+ return 83;
+
+ case 40:
+ return 8;
+
+ default:
+ return 10;
+ }
+ }
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = {x};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+ gcc_jit_block *b_case_0_5 =
+ gcc_jit_function_new_block (func, "case_0_5");
+ gcc_jit_block *b_case_25_27 =
+ gcc_jit_function_new_block (func, "case_25_27");
+ gcc_jit_block *b_case_m42_m17 =
+ gcc_jit_function_new_block (func, "case_m42_m17");
+ gcc_jit_block *b_case_40 =
+ gcc_jit_function_new_block (func, "case_40");
+
+ gcc_jit_case *cases[4] = {
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 0),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 5),
+ b_case_0_5),
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 25),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 27),
+ b_case_25_27),
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, -42),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, -17),
+ b_case_m42_m17),
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 40),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 40),
+ b_case_40)
+ };
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 4, cases);
+
+ gcc_jit_block_end_with_return (
+ b_case_0_5, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 3));
+ gcc_jit_block_end_with_return (
+ b_case_25_27, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 4));
+ gcc_jit_block_end_with_return (
+ b_case_m42_m17, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 83));
+ gcc_jit_block_end_with_return (
+ b_case_40, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 8));
+ gcc_jit_block_end_with_return (
+ b_default, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10));
+}
+
+/* Quote up to here in docs/topics/functions.rst. */
+
+static int
+c_test_switch (int x)
+{
+ switch (x)
+ {
+ case 0 ... 5:
+ return 3;
+ case 25 ... 27:
+ return 4;
+ case -42 ... -17:
+ return 83;
+ case 40:
+ return 8;
+ default:
+ return 10;
+ }
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ typedef int (*test_switch_type) (int);
+ CHECK_NON_NULL (result);
+ test_switch_type test_switch =
+ (test_switch_type)gcc_jit_result_get_code (result, "test_switch");
+ CHECK_NON_NULL (test_switch);
+
+ int i;
+
+ for (i = -255; i < 255; i++)
+ {
+ int val = test_switch (i);
+ int exp = c_test_switch (i);
+ if (val != exp)
+ fail ("test_switch (%i) returned: %i; expected; %i", i, val, exp);
+ }
+}
diff --git a/gcc/testsuite/jit.dg/test-switch.cc b/gcc/testsuite/jit.dg/test-switch.cc
new file mode 100644
index 0000000..862f7a8
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-switch.cc
@@ -0,0 +1,118 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit++.h"
+
+#include "harness.h"
+
+/* Quote from here in docs/cp/topics/functions.rst. */
+
+void
+create_code (gcc_jit_context *c_ctxt, void *user_data)
+{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ {
+ switch (x)
+ {
+ case 0 ... 5:
+ return 3;
+
+ case 25 ... 27:
+ return 4;
+
+ case -42 ... -17:
+ return 83;
+
+ case 40:
+ return 8;
+
+ default:
+ return 10;
+ }
+ }
+ */
+ gccjit::context ctxt (c_ctxt);
+ gccjit::type t_int = ctxt.get_type (GCC_JIT_TYPE_INT);
+ gccjit::type return_type = t_int;
+ gccjit::param x = ctxt.new_param (t_int, "x");
+ std::vector <gccjit::param> params;
+ params.push_back (x);
+ gccjit::function func = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ params, 0);
+
+ gccjit::block b_initial = func.new_block ("initial");
+
+ gccjit::block b_default = func.new_block ("default");
+ gccjit::block b_case_0_5 = func.new_block ("case_0_5");
+ gccjit::block b_case_25_27 = func.new_block ("case_25_27");
+ gccjit::block b_case_m42_m17 = func.new_block ("case_m42_m17");
+ gccjit::block b_case_40 = func.new_block ("case_40");
+
+ std::vector <gccjit::case_> cases;
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, 0),
+ ctxt.new_rvalue (t_int, 5),
+ b_case_0_5));
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, 25),
+ ctxt.new_rvalue (t_int, 27),
+ b_case_25_27));
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, -42),
+ ctxt.new_rvalue (t_int, -17),
+ b_case_m42_m17));
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, 40),
+ ctxt.new_rvalue (t_int, 40),
+ b_case_40));
+ b_initial.end_with_switch (x,
+ b_default,
+ cases);
+
+ b_case_0_5.end_with_return (ctxt.new_rvalue (t_int, 3));
+ b_case_25_27.end_with_return (ctxt.new_rvalue (t_int, 4));
+ b_case_m42_m17.end_with_return (ctxt.new_rvalue (t_int, 83));
+ b_case_40.end_with_return (ctxt.new_rvalue (t_int, 8));
+ b_default.end_with_return (ctxt.new_rvalue (t_int, 10));
+}
+
+/* Quote up to here in docs/cp/topics/functions.rst. */
+
+static int
+c_test_switch (int x)
+{
+ switch (x)
+ {
+ case 0 ... 5:
+ return 3;
+ case 25 ... 27:
+ return 4;
+ case -42 ... -17:
+ return 83;
+ case 40:
+ return 8;
+ default:
+ return 10;
+ }
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+ typedef int (*test_switch_type) (int);
+ CHECK_NON_NULL (result);
+ test_switch_type test_switch =
+ (test_switch_type)gcc_jit_result_get_code (result, "test_switch");
+ CHECK_NON_NULL (test_switch);
+
+ int i;
+
+ for (i = -255; i < 255; i++)
+ {
+ int val = test_switch (i);
+ int exp = c_test_switch (i);
+ if (val != exp)
+ fail ("test_switch (%i) returned: %i; expected; %i", i, val, exp);
+ }
+}
--
1.8.5.3