diff --git a/src/poly/cl/restart.h b/src/poly/cl/restart.h
index 47f626cc3a1..de7fee25f74 100644
--- a/src/poly/cl/restart.h
+++ b/src/poly/cl/restart.h
@@ -134,7 +134,8 @@ poly_work_group_first_true(bool cond, local void *scratch)
 static inline global void *
 poly_setup_unroll_for_draw(global struct poly_heap *heap,
                            constant uint *in_draw, global uint *out_draw,
-                           enum mesa_prim mode, uint index_size_B)
+                           enum mesa_prim mode, uint in_index_size_B,
+                           uint out_index_size_B)
 {
    /* Determine an upper bound on the memory required for the index buffer.
     * Restarts only decrease the unrolled index buffer size, so the maximum size
@@ -142,7 +143,7 @@ poly_setup_unroll_for_draw(global struct poly_heap *heap,
     */
    uint max_prims = u_decomposed_prims_for_vertices(mode, in_draw[0]);
    uint max_verts = max_prims * mesa_vertices_per_prim(mode);
-   uint alloc_size = max_verts * index_size_B;
+   uint alloc_size = max_verts * out_index_size_B;
 
    /* Allocate unrolled index buffer.
     *
@@ -152,26 +153,28 @@ poly_setup_unroll_for_draw(global struct poly_heap *heap,
    uint old_heap_bottom_B = poly_heap_alloc_offs(heap, alloc_size);
 
    /* Setup most of the descriptor. Count will be determined after unroll. */
-   out_draw[1] = in_draw[1];                       /* instance count */
-   out_draw[2] = old_heap_bottom_B / index_size_B; /* index offset */
-   out_draw[3] = in_draw[3];                       /* index bias */
-   out_draw[4] = in_draw[4];                       /* base instance */
+   uint vertex_offset_idx = in_index_size_B > 0 ? 3 : 2;
+   out_draw[1] = in_draw[1];                           /* instance count */
+   out_draw[2] = old_heap_bottom_B / out_index_size_B; /* index offset */
+   out_draw[3] = in_draw[vertex_offset_idx];           /* index bias */
+   out_draw[4] = in_draw[vertex_offset_idx + 1];       /* base instance */
 
    /* Return the index buffer we allocated */
    return (global uchar *)heap->base + old_heap_bottom_B;
 }
 
 static inline void
-poly_unroll_restart(global uint32_t *out_draw,
-                    global struct poly_heap *heap,
-                    constant uint *in_draw,
-                    uint64_t index_buffer,
-                    uint32_t index_buffer_range_el,
-                    uint32_t index_size_B,
-                    uint32_t restart_index,
-                    uint32_t flatshade_first,
-                    enum mesa_prim mode,
-                    local void *scratch)
+poly_unroll_geometry(global uint32_t *out_draw,
+                     global struct poly_heap *heap,
+                     constant uint *in_draw,
+                     uint64_t index_buffer,
+                     uint32_t index_buffer_range_el,
+                     uint32_t in_index_size_B,
+                     uint32_t out_index_size_B,
+                     uint32_t restart_index,
+                     uint32_t flatshade_first,
+                     enum mesa_prim mode,
+                     local void *scratch)
 {
    uint tid = cl_local_id.x;
    uint count = in_draw[0];
@@ -179,7 +182,8 @@ poly_unroll_restart(global uint32_t *out_draw,
    uintptr_t out_ptr;
    if (tid == 0) {
       out_ptr = (uintptr_t)poly_setup_unroll_for_draw(heap, in_draw, out_draw,
-                                                      mode, index_size_B);
+                                                      mode, in_index_size_B,
+                                                      out_index_size_B);
       if (get_num_sub_groups() > 1)
          *(uintptr_t *)scratch = out_ptr;
    }
@@ -192,7 +196,7 @@ poly_unroll_restart(global uint32_t *out_draw,
    }
 
    uintptr_t in_ptr = (uintptr_t)(poly_index_buffer(
-      index_buffer, index_buffer_range_el, in_draw[2], index_size_B));
+      index_buffer, index_buffer_range_el, in_draw[2], in_index_size_B));
 
    uint out_prims = 0;
    uint needle = 0;
@@ -204,7 +208,7 @@ poly_unroll_restart(global uint32_t *out_draw,
          uint idx = next_restart + tid;
          bool restart =
             idx >= count || poly_load_index(in_ptr, index_buffer_range_el, idx,
-                                            index_size_B) == restart_index;
+                                            in_index_size_B) == restart_index;
 
          uint next_offs = poly_work_group_first_true(restart, scratch);
 
@@ -225,9 +229,9 @@ poly_unroll_restart(global uint32_t *out_draw,
 
             uint x = ((out_prims_base + i) * per_prim) + vtx;
             uint y = poly_load_index(in_ptr, index_buffer_range_el, offset,
-                                     index_size_B);
+                                     in_index_size_B);
 
-            poly_store_index(out_ptr, index_size_B, x, y);
+            poly_store_index(out_ptr, out_index_size_B, x, y);
          }
       }
 
@@ -239,6 +243,23 @@ poly_unroll_restart(global uint32_t *out_draw,
       out_draw[0] = out_prims * per_prim;
 }
 
+static inline void
+poly_unroll_restart(global uint32_t *out_draw,
+                    global struct poly_heap *heap,
+                    constant uint *in_draw,
+                    uint64_t index_buffer,
+                    uint32_t index_buffer_range_el,
+                    uint32_t index_size_B,
+                    uint32_t restart_index,
+                    uint32_t flatshade_first,
+                    enum mesa_prim mode,
+                    local void *scratch)
+{
+   poly_unroll_geometry(out_draw, heap, in_draw, index_buffer,
+                        index_buffer_range_el, index_size_B, index_size_B,
+                        restart_index, flatshade_first, mode, scratch);
+}
+
 static inline uint32_t
 poly_count_restart_prims(constant uint *in_draw,
                          uint64_t index_buffer,
diff --git a/src/poly/geometry.h b/src/poly/geometry.h
index 3ebbb7cc71b..b732add2fd2 100644
--- a/src/poly/geometry.h
+++ b/src/poly/geometry.h
@@ -657,6 +657,11 @@ static uint
 poly_load_index(uintptr_t index_buffer, uint32_t index_buffer_range_el, uint id,
                 uint index_size)
 {
+   if (index_size == 0) {
+      /* No index buffer, return vertex ID */
+      return id;
+   }
+
    bool oob = id >= index_buffer_range_el;
 
    /* If the load would be out-of-bounds, load the first element which is