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);
+    }
+}
