diff --git a/src/gallium/drivers/iris/iris_measure.c b/src/gallium/drivers/iris/iris_measure.c
index d4de10c8a2d..75602651046 100644
--- a/src/gallium/drivers/iris/iris_measure.c
+++ b/src/gallium/drivers/iris/iris_measure.c
@@ -137,6 +137,12 @@ iris_destroy_batch_measure(struct iris_measure_batch *batch)
    free(batch);
 }
 
+static uint32_t
+fetch_hash(const struct iris_uncompiled_shader *uncompiled)
+{
+   return (uncompiled) ? uncompiled->source_hash : 0;
+}
+
 static void
 measure_start_snapshot(struct iris_context *ice,
                        struct iris_batch *batch,
@@ -202,13 +208,13 @@ measure_start_snapshot(struct iris_context *ice,
    snapshot->renderpass = renderpass;
 
    if (type == INTEL_SNAPSHOT_COMPUTE) {
-      snapshot->cs = (uintptr_t) ice->shaders.prog[MESA_SHADER_COMPUTE];
-   } else {
-      snapshot->vs  = (uintptr_t) ice->shaders.prog[MESA_SHADER_VERTEX];
-      snapshot->tcs = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_CTRL];
-      snapshot->tes = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_EVAL];
-      snapshot->gs  = (uintptr_t) ice->shaders.prog[MESA_SHADER_GEOMETRY];
-      snapshot->fs  = (uintptr_t) ice->shaders.prog[MESA_SHADER_FRAGMENT];
+      snapshot->cs  = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_COMPUTE]);
+   } else if (type == INTEL_SNAPSHOT_DRAW) {
+      snapshot->vs  = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_VERTEX]);
+      snapshot->tcs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_CTRL]);
+      snapshot->tes = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_EVAL]);
+      snapshot->gs  = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_GEOMETRY]);
+      snapshot->fs  = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_FRAGMENT]);
    }
 }
 
@@ -244,13 +250,13 @@ state_changed(const struct iris_context *ice,
    uintptr_t vs=0, tcs=0, tes=0, gs=0, fs=0, cs=0;
 
    if (type == INTEL_SNAPSHOT_COMPUTE) {
-      cs = (uintptr_t) ice->shaders.prog[MESA_SHADER_COMPUTE];
+      cs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_COMPUTE]);
    } else if (type == INTEL_SNAPSHOT_DRAW) {
-      vs  = (uintptr_t) ice->shaders.prog[MESA_SHADER_VERTEX];
-      tcs = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_CTRL];
-      tes = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_EVAL];
-      gs  = (uintptr_t) ice->shaders.prog[MESA_SHADER_GEOMETRY];
-      fs  = (uintptr_t) ice->shaders.prog[MESA_SHADER_FRAGMENT];
+      vs  = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_VERTEX]);
+      tcs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_CTRL]);
+      tes = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_EVAL]);
+      gs  = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_GEOMETRY]);
+      fs  = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_FRAGMENT]);
    }
    /* else blorp, all programs NULL */
 
diff --git a/src/intel/common/intel_measure.c b/src/intel/common/intel_measure.c
index 9d54cd35a53..f39cf7905c6 100644
--- a/src/intel/common/intel_measure.c
+++ b/src/intel/common/intel_measure.c
@@ -279,9 +279,9 @@ intel_measure_snapshot_string(enum intel_measure_snapshot_type type)
  */
 bool
 intel_measure_state_changed(const struct intel_measure_batch *batch,
-                            uintptr_t vs, uintptr_t tcs, uintptr_t tes,
-                            uintptr_t gs, uintptr_t fs, uintptr_t cs,
-                            uintptr_t ms, uintptr_t ts)
+                            uint32_t vs, uint32_t tcs, uint32_t tes,
+                            uint32_t gs, uint32_t fs, uint32_t cs,
+                            uint32_t ms, uint32_t ts)
 {
    if (batch->index == 0) {
       /* always record the first event */
@@ -320,14 +320,14 @@ intel_measure_state_changed(const struct intel_measure_batch *batch,
       return true;
    }
 
-   return (last_snap->vs  != (uintptr_t) vs ||
-           last_snap->tcs != (uintptr_t) tcs ||
-           last_snap->tes != (uintptr_t) tes ||
-           last_snap->gs  != (uintptr_t) gs ||
-           last_snap->fs  != (uintptr_t) fs ||
-           last_snap->cs  != (uintptr_t) cs ||
-           last_snap->ms  != (uintptr_t) ms ||
-           last_snap->ts  != (uintptr_t) ts);
+   return (last_snap->vs  != vs ||
+           last_snap->tcs != tcs ||
+           last_snap->tes != tes ||
+           last_snap->gs  != gs ||
+           last_snap->fs  != fs ||
+           last_snap->cs  != cs ||
+           last_snap->ms  != ms ||
+           last_snap->ts  != ts);
 }
 
 /**
@@ -626,9 +626,8 @@ print_combined_results(struct intel_measure_device *measure_device,
            start_result->frame, start_result->batch_count,
            renderpass, start_result->event_index, event_count,
            begin->event_name, begin->count,
-           (uint32_t)begin->vs, (uint32_t)begin->tcs, (uint32_t)begin->tes,
-           (uint32_t)begin->gs, (uint32_t)begin->fs, (uint32_t)begin->cs,
-           (uint32_t)begin->ms, (uint32_t)begin->ts,
+           begin->vs, begin->tcs, begin->tes, begin->gs,
+           begin->fs, begin->cs, begin->ms, begin->ts,
            (double)duration_idle_ns / 1000.0,
            (double)duration_time_ns / 1000.0);
 }
diff --git a/src/intel/common/intel_measure.h b/src/intel/common/intel_measure.h
index 57d5571fab8..dd9b7fa9417 100644
--- a/src/intel/common/intel_measure.h
+++ b/src/intel/common/intel_measure.h
@@ -113,7 +113,7 @@ struct intel_measure_snapshot {
    unsigned count, event_count;
    const char* event_name;
    uint32_t renderpass;
-   uintptr_t vs, tcs, tes, gs, fs, cs, ms, ts;
+   uint32_t vs, tcs, tes, gs, fs, cs, ms, ts;
    /* for vulkan secondary command buffers */
    struct intel_measure_batch *secondary;
 };
@@ -163,9 +163,9 @@ struct intel_measure_batch {
 void intel_measure_init(struct intel_measure_device *device);
 const char * intel_measure_snapshot_string(enum intel_measure_snapshot_type type);
 bool intel_measure_state_changed(const struct intel_measure_batch *batch,
-                                 uintptr_t vs, uintptr_t tcs, uintptr_t tes,
-                                 uintptr_t gs, uintptr_t fs, uintptr_t cs,
-                                 uintptr_t ms, uintptr_t ts);
+                                 uint32_t vs, uint32_t tcs, uint32_t tes,
+                                 uint32_t gs, uint32_t fs, uint32_t cs,
+                                 uint32_t ms, uint32_t ts);
 void intel_measure_frame_transition(unsigned frame);
 
 bool intel_measure_ready(struct intel_measure_batch *batch);
diff --git a/src/intel/vulkan/anv_measure.c b/src/intel/vulkan/anv_measure.c
index 10210dc9960..cdae334291e 100644
--- a/src/intel/vulkan/anv_measure.c
+++ b/src/intel/vulkan/anv_measure.c
@@ -152,17 +152,17 @@ anv_measure_start_snapshot(struct anv_cmd_buffer *cmd_buffer,
                             : measure->base.renderpass;
 
    if (type == INTEL_SNAPSHOT_COMPUTE && cmd_buffer->state.compute.pipeline) {
-      snapshot->cs = (uintptr_t) cmd_buffer->state.compute.pipeline->cs;
-   } else if (cmd_buffer->state.gfx.pipeline) {
+      snapshot->cs = cmd_buffer->state.compute.pipeline->source_hash;
+   } else if (type == INTEL_SNAPSHOT_DRAW && cmd_buffer->state.gfx.pipeline) {
       const struct anv_graphics_pipeline *pipeline =
          cmd_buffer->state.gfx.pipeline;
-      snapshot->vs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_VERTEX];
-      snapshot->tcs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_TESS_CTRL];
-      snapshot->tes = (uintptr_t) pipeline->base.shaders[MESA_SHADER_TESS_EVAL];
-      snapshot->gs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_GEOMETRY];
-      snapshot->fs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_FRAGMENT];
-      snapshot->ms = (uintptr_t) pipeline->base.shaders[MESA_SHADER_MESH];
-      snapshot->ts = (uintptr_t) pipeline->base.shaders[MESA_SHADER_TASK];
+      snapshot->vs = pipeline->base.source_hashes[MESA_SHADER_VERTEX];
+      snapshot->tcs = pipeline->base.source_hashes[MESA_SHADER_TESS_CTRL];
+      snapshot->tes = pipeline->base.source_hashes[MESA_SHADER_TESS_EVAL];
+      snapshot->gs = pipeline->base.source_hashes[MESA_SHADER_GEOMETRY];
+      snapshot->fs = pipeline->base.source_hashes[MESA_SHADER_FRAGMENT];
+      snapshot->ms = pipeline->base.source_hashes[MESA_SHADER_MESH];
+      snapshot->ts = pipeline->base.source_hashes[MESA_SHADER_TASK];
    }
 }
 
@@ -197,7 +197,7 @@ static bool
 state_changed(struct anv_cmd_buffer *cmd_buffer,
               enum intel_measure_snapshot_type type)
 {
-   uintptr_t vs=0, tcs=0, tes=0, gs=0, fs=0, cs=0, ms=0, ts=0;
+   uint32_t vs=0, tcs=0, tes=0, gs=0, fs=0, cs=0, ms=0, ts=0;
 
    if (cmd_buffer->usage_flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)
       /* can't record timestamps in this mode */
@@ -207,17 +207,17 @@ state_changed(struct anv_cmd_buffer *cmd_buffer,
       const struct anv_compute_pipeline *cs_pipe =
          cmd_buffer->state.compute.pipeline;
       assert(cs_pipe);
-      cs = (uintptr_t)cs_pipe->cs;
+      cs = cs_pipe->source_hash;
    } else if (type == INTEL_SNAPSHOT_DRAW) {
       const struct anv_graphics_pipeline *gfx = cmd_buffer->state.gfx.pipeline;
       assert(gfx);
-      vs = (uintptr_t) gfx->base.shaders[MESA_SHADER_VERTEX];
-      tcs = (uintptr_t) gfx->base.shaders[MESA_SHADER_TESS_CTRL];
-      tes = (uintptr_t) gfx->base.shaders[MESA_SHADER_TESS_EVAL];
-      gs = (uintptr_t) gfx->base.shaders[MESA_SHADER_GEOMETRY];
-      fs = (uintptr_t) gfx->base.shaders[MESA_SHADER_FRAGMENT];
-      ms = (uintptr_t) gfx->base.shaders[MESA_SHADER_MESH];
-      ts = (uintptr_t) gfx->base.shaders[MESA_SHADER_TASK];
+      vs = gfx->base.source_hashes[MESA_SHADER_VERTEX];
+      tcs = gfx->base.source_hashes[MESA_SHADER_TESS_CTRL];
+      tes = gfx->base.source_hashes[MESA_SHADER_TESS_EVAL];
+      gs = gfx->base.source_hashes[MESA_SHADER_GEOMETRY];
+      fs = gfx->base.source_hashes[MESA_SHADER_FRAGMENT];
+      ms = gfx->base.source_hashes[MESA_SHADER_MESH];
+      ts = gfx->base.source_hashes[MESA_SHADER_TASK];
    }
    /* else blorp, all programs NULL */