diff --git a/src/gallium/auxiliary/draw/draw_gs.c b/src/gallium/auxiliary/draw/draw_gs.c
index e84554bef31..1c969046fe8 100644
--- a/src/gallium/auxiliary/draw/draw_gs.c
+++ b/src/gallium/auxiliary/draw/draw_gs.c
@@ -772,7 +772,7 @@ draw_create_geometry_shader(struct draw_context *draw,
 
       gs = &llvm_gs->base;
 
-      make_empty_list(&llvm_gs->variants);
+      list_inithead(&llvm_gs->variants.list);
    } else
 #endif
    {
@@ -931,13 +931,10 @@ void draw_delete_geometry_shader(struct draw_context *draw,
 #ifdef DRAW_LLVM_AVAILABLE
    if (draw->llvm) {
       struct llvm_geometry_shader *shader = llvm_geometry_shader(dgs);
-      struct draw_gs_llvm_variant_list_item *li;
+      struct draw_gs_llvm_variant_list_item *li, *next;
 
-      li = first_elem(&shader->variants);
-      while(!at_end(&shader->variants, li)) {
-         struct draw_gs_llvm_variant_list_item *next = next_elem(li);
+      LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
          draw_gs_llvm_destroy_variant(li->base);
-         li = next;
       }
 
       assert(shader->variants_cached == 0);
diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c
index 10f11d66af3..5e5ce53a3ab 100644
--- a/src/gallium/auxiliary/draw/draw_llvm.c
+++ b/src/gallium/auxiliary/draw/draw_llvm.c
@@ -58,7 +58,6 @@
 #include "util/u_math.h"
 #include "util/u_pointer.h"
 #include "util/u_string.h"
-#include "util/simple_list.h"
 #include "nir_serialize.h"
 #include "util/mesa-sha1.h"
 #define DEBUG_STORE 0
@@ -803,16 +802,16 @@ draw_llvm_create(struct draw_context *draw, LLVMContextRef context)
       goto fail;
 
    llvm->nr_variants = 0;
-   make_empty_list(&llvm->vs_variants_list);
+   list_inithead(&llvm->vs_variants_list.list);
 
    llvm->nr_gs_variants = 0;
-   make_empty_list(&llvm->gs_variants_list);
+   list_inithead(&llvm->gs_variants_list.list);
 
    llvm->nr_tcs_variants = 0;
-   make_empty_list(&llvm->tcs_variants_list);
+   list_inithead(&llvm->tcs_variants_list.list);
 
    llvm->nr_tes_variants = 0;
-   make_empty_list(&llvm->tes_variants_list);
+   list_inithead(&llvm->tes_variants_list.list);
 
    return llvm;
 
@@ -2689,9 +2688,9 @@ draw_llvm_destroy_variant(struct draw_llvm_variant *variant)
 
    gallivm_destroy(variant->gallivm);
 
-   remove_from_list(&variant->list_item_local);
+   list_del(&variant->list_item_local.list);
    variant->shader->variants_cached--;
-   remove_from_list(&variant->list_item_global);
+   list_del(&variant->list_item_global.list);
    llvm->nr_variants--;
    FREE(variant);
 }
@@ -3007,9 +3006,9 @@ draw_gs_llvm_destroy_variant(struct draw_gs_llvm_variant *variant)
 
    gallivm_destroy(variant->gallivm);
 
-   remove_from_list(&variant->list_item_local);
+   list_del(&variant->list_item_local.list);
    variant->shader->variants_cached--;
-   remove_from_list(&variant->list_item_global);
+   list_del(&variant->list_item_global.list);
    llvm->nr_gs_variants--;
    FREE(variant);
 }
@@ -3673,9 +3672,9 @@ draw_tcs_llvm_destroy_variant(struct draw_tcs_llvm_variant *variant)
 
    gallivm_destroy(variant->gallivm);
 
-   remove_from_list(&variant->list_item_local);
+   list_del(&variant->list_item_local.list);
    variant->shader->variants_cached--;
-   remove_from_list(&variant->list_item_global);
+   list_del(&variant->list_item_global.list);
    llvm->nr_tcs_variants--;
    FREE(variant);
 }
@@ -4200,9 +4199,9 @@ draw_tes_llvm_destroy_variant(struct draw_tes_llvm_variant *variant)
 
    gallivm_destroy(variant->gallivm);
 
-   remove_from_list(&variant->list_item_local);
+   list_del(&variant->list_item_local.list);
    variant->shader->variants_cached--;
-   remove_from_list(&variant->list_item_global);
+   list_del(&variant->list_item_global.list);
    llvm->nr_tes_variants--;
    FREE(variant);
 }
diff --git a/src/gallium/auxiliary/draw/draw_llvm.h b/src/gallium/auxiliary/draw/draw_llvm.h
index f0f2c404a85..7506a87161e 100644
--- a/src/gallium/auxiliary/draw/draw_llvm.h
+++ b/src/gallium/auxiliary/draw/draw_llvm.h
@@ -38,7 +38,7 @@
 #include "gallivm/lp_bld_limits.h"
 
 #include "pipe/p_context.h"
-#include "util/simple_list.h"
+#include "util/list.h"
 
 
 struct draw_llvm;
@@ -649,26 +649,26 @@ draw_tes_llvm_variant_key_images(struct draw_tes_llvm_variant_key *key)
 
 struct draw_llvm_variant_list_item
 {
+   struct list_head list;
    struct draw_llvm_variant *base;
-   struct draw_llvm_variant_list_item *next, *prev;
 };
 
 struct draw_gs_llvm_variant_list_item
 {
+   struct list_head list;
    struct draw_gs_llvm_variant *base;
-   struct draw_gs_llvm_variant_list_item *next, *prev;
 };
 
 struct draw_tcs_llvm_variant_list_item
 {
+   struct list_head list;
    struct draw_tcs_llvm_variant *base;
-   struct draw_tcs_llvm_variant_list_item *next, *prev;
 };
 
 struct draw_tes_llvm_variant_list_item
 {
+   struct list_head list;
    struct draw_tes_llvm_variant *base;
-   struct draw_tes_llvm_variant_list_item *next, *prev;
 };
 
 struct draw_llvm_variant
diff --git a/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
index 8abed870340..93010646b03 100644
--- a/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
+++ b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
@@ -80,23 +80,20 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme)
    struct draw_gs_llvm_variant_list_item *li;
    struct llvm_geometry_shader *shader = llvm_geometry_shader(gs);
    char store[DRAW_GS_LLVM_MAX_VARIANT_KEY_SIZE];
-   unsigned i;
 
    key = draw_gs_llvm_make_variant_key(llvm, store);
 
    /* Search shader's list of variants for the key */
-   li = first_elem(&shader->variants);
-   while (!at_end(&shader->variants, li)) {
+   LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
       if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
          variant = li->base;
          break;
       }
-      li = next_elem(li);
    }
 
    if (variant) {
       /* found the variant, move to head of global list (for LRU) */
-      move_to_head(&llvm->gs_variants_list, &variant->list_item_global);
+      list_move_to(&variant->list_item_global.list, &llvm->gs_variants_list.list);
    }
    else {
       /* Need to create new variant */
@@ -113,12 +110,13 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme)
          /*
           * XXX: should we flush here ?
           */
-         for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
-            struct draw_gs_llvm_variant_list_item *item;
-            if (is_empty_list(&llvm->gs_variants_list)) {
+         struct draw_gs_llvm_variant_list_item *item;
+         for (unsigned i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
+            if (list_is_empty(&llvm->gs_variants_list.list)) {
                break;
             }
-            item = last_elem(&llvm->gs_variants_list);
+            item = list_last_entry(&llvm->gs_variants_list.list,
+                                   struct draw_gs_llvm_variant_list_item, list);
             assert(item);
             assert(item->base);
             draw_gs_llvm_destroy_variant(item->base);
@@ -128,9 +126,8 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme)
       variant = draw_gs_llvm_create_variant(llvm, gs->info.num_outputs, key);
 
       if (variant) {
-         insert_at_head(&shader->variants, &variant->list_item_local);
-         insert_at_head(&llvm->gs_variants_list,
-                        &variant->list_item_global);
+         list_add(&variant->list_item_local.list, &shader->variants.list);
+         list_add(&variant->list_item_global.list, &llvm->gs_variants_list.list);
          llvm->nr_gs_variants++;
          shader->variants_cached++;
       }
@@ -155,18 +152,16 @@ llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme)
    key = draw_tcs_llvm_make_variant_key(llvm, store);
 
    /* Search shader's list of variants for the key */
-   li = first_elem(&shader->variants);
-   while (!at_end(&shader->variants, li)) {
+   LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
       if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
          variant = li->base;
          break;
       }
-      li = next_elem(li);
    }
 
    if (variant) {
       /* found the variant, move to head of global list (for LRU) */
-      move_to_head(&llvm->tcs_variants_list, &variant->list_item_global);
+      list_move_to(&variant->list_item_global.list, &llvm->tcs_variants_list.list);
    }
    else {
       /* Need to create new variant */
@@ -185,10 +180,11 @@ llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme)
           */
          for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
             struct draw_tcs_llvm_variant_list_item *item;
-            if (is_empty_list(&llvm->tcs_variants_list)) {
+            if (list_is_empty(&llvm->tcs_variants_list.list)) {
                break;
             }
-            item = last_elem(&llvm->tcs_variants_list);
+            item = list_last_entry(&llvm->tcs_variants_list.list,
+                                   struct draw_tcs_llvm_variant_list_item, list);
             assert(item);
             assert(item->base);
             draw_tcs_llvm_destroy_variant(item->base);
@@ -198,9 +194,8 @@ llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme)
       variant = draw_tcs_llvm_create_variant(llvm, 0, key);
 
       if (variant) {
-         insert_at_head(&shader->variants, &variant->list_item_local);
-         insert_at_head(&llvm->tcs_variants_list,
-                        &variant->list_item_global);
+         list_add(&variant->list_item_local.list, &shader->variants.list);
+         list_add(&variant->list_item_global.list, &llvm->tcs_variants_list.list);
          llvm->nr_tcs_variants++;
          shader->variants_cached++;
       }
@@ -225,18 +220,16 @@ llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme)
    key = draw_tes_llvm_make_variant_key(llvm, store);
 
    /* Search shader's list of variants for the key */
-   li = first_elem(&shader->variants);
-   while (!at_end(&shader->variants, li)) {
+   LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
       if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
          variant = li->base;
          break;
       }
-      li = next_elem(li);
    }
 
    if (variant) {
       /* found the variant, move to head of global list (for LRU) */
-      move_to_head(&llvm->tes_variants_list, &variant->list_item_global);
+      list_move_to(&variant->list_item_global.list, &llvm->tes_variants_list.list);
    }
    else {
       /* Need to create new variant */
@@ -255,10 +248,11 @@ llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme)
           */
          for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
             struct draw_tes_llvm_variant_list_item *item;
-            if (is_empty_list(&llvm->tes_variants_list)) {
+            if (list_is_empty(&llvm->tes_variants_list.list)) {
                break;
             }
-            item = last_elem(&llvm->tes_variants_list);
+            item = list_last_entry(&llvm->tes_variants_list.list,
+                                   struct draw_tes_llvm_variant_list_item, list);
             assert(item);
             assert(item->base);
             draw_tes_llvm_destroy_variant(item->base);
@@ -268,9 +262,8 @@ llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme)
       variant = draw_tes_llvm_create_variant(llvm, draw_total_tes_outputs(draw), key);
 
       if (variant) {
-         insert_at_head(&shader->variants, &variant->list_item_local);
-         insert_at_head(&llvm->tes_variants_list,
-                        &variant->list_item_global);
+         list_add(&variant->list_item_local.list, &shader->variants.list);
+         list_add(&variant->list_item_global.list, &llvm->tes_variants_list.list);
          llvm->nr_tes_variants++;
          shader->variants_cached++;
       }
@@ -356,18 +349,16 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
       key = draw_llvm_make_variant_key(llvm, store);
 
       /* Search shader's list of variants for the key */
-      li = first_elem(&shader->variants);
-      while (!at_end(&shader->variants, li)) {
+      LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
          if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
             variant = li->base;
             break;
          }
-         li = next_elem(li);
       }
 
       if (variant) {
          /* found the variant, move to head of global list (for LRU) */
-         move_to_head(&llvm->vs_variants_list, &variant->list_item_global);
+         list_move_to(&variant->list_item_global.list, &llvm->vs_variants_list.list);
       }
       else {
          /* Need to create new variant */
@@ -386,10 +377,11 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
              */
             for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
                struct draw_llvm_variant_list_item *item;
-               if (is_empty_list(&llvm->vs_variants_list)) {
+               if (list_is_empty(&llvm->vs_variants_list.list)) {
                   break;
                }
-               item = last_elem(&llvm->vs_variants_list);
+               item = list_last_entry(&llvm->vs_variants_list.list,
+                                    struct draw_llvm_variant_list_item, list);
                assert(item);
                assert(item->base);
                draw_llvm_destroy_variant(item->base);
@@ -399,9 +391,8 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
          variant = draw_llvm_create_variant(llvm, nr, key);
 
          if (variant) {
-            insert_at_head(&shader->variants, &variant->list_item_local);
-            insert_at_head(&llvm->vs_variants_list,
-                           &variant->list_item_global);
+            list_add(&variant->list_item_local.list, &shader->variants.list);
+            list_add(&variant->list_item_global.list, &llvm->vs_variants_list.list);
             llvm->nr_variants++;
             shader->variants_cached++;
          }
diff --git a/src/gallium/auxiliary/draw/draw_tess.c b/src/gallium/auxiliary/draw/draw_tess.c
index c1742eb0300..9658e6f76ef 100644
--- a/src/gallium/auxiliary/draw/draw_tess.c
+++ b/src/gallium/auxiliary/draw/draw_tess.c
@@ -431,7 +431,7 @@ draw_create_tess_ctrl_shader(struct draw_context *draw,
 
       tcs = &llvm_tcs->base;
 
-      make_empty_list(&llvm_tcs->variants);
+      list_inithead(&llvm_tcs->variants.list);
    } else
 #endif
    {
@@ -489,13 +489,10 @@ void draw_delete_tess_ctrl_shader(struct draw_context *draw,
    if (draw->llvm) {
       struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(dtcs);
 
-      struct draw_tcs_llvm_variant_list_item *li;
+      struct draw_tcs_llvm_variant_list_item *li, *next;
 
-      li = first_elem(&shader->variants);
-      while(!at_end(&shader->variants, li)) {
-         struct draw_tcs_llvm_variant_list_item *next = next_elem(li);
+      LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
          draw_tcs_llvm_destroy_variant(li->base);
-         li = next;
       }
 
       assert(shader->variants_cached == 0);
@@ -535,7 +532,7 @@ draw_create_tess_eval_shader(struct draw_context *draw,
          return NULL;
 
       tes = &llvm_tes->base;
-      make_empty_list(&llvm_tes->variants);
+      list_inithead(&llvm_tes->variants.list);
    } else
 #endif
    {
@@ -619,13 +616,10 @@ void draw_delete_tess_eval_shader(struct draw_context *draw,
 #ifdef DRAW_LLVM_AVAILABLE
    if (draw->llvm) {
       struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(dtes);
-      struct draw_tes_llvm_variant_list_item *li;
+      struct draw_tes_llvm_variant_list_item *li, *next;
 
-      li = first_elem(&shader->variants);
-      while(!at_end(&shader->variants, li)) {
-         struct draw_tes_llvm_variant_list_item *next = next_elem(li);
+      LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
          draw_tes_llvm_destroy_variant(li->base);
-         li = next;
       }
 
       assert(shader->variants_cached == 0);
diff --git a/src/gallium/auxiliary/draw/draw_vs_llvm.c b/src/gallium/auxiliary/draw/draw_vs_llvm.c
index feb60768252..d71dd177411 100644
--- a/src/gallium/auxiliary/draw/draw_vs_llvm.c
+++ b/src/gallium/auxiliary/draw/draw_vs_llvm.c
@@ -68,13 +68,10 @@ static void
 vs_llvm_delete( struct draw_vertex_shader *dvs )
 {
    struct llvm_vertex_shader *shader = llvm_vertex_shader(dvs);
-   struct draw_llvm_variant_list_item *li;
+   struct draw_llvm_variant_list_item *li, *next;
 
-   li = first_elem(&shader->variants);
-   while(!at_end(&shader->variants, li)) {
-      struct draw_llvm_variant_list_item *next = next_elem(li);
+   LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
       draw_llvm_destroy_variant(li->base);
-      li = next;
    }
 
    assert(shader->variants_cached == 0);
@@ -126,7 +123,7 @@ draw_create_vs_llvm(struct draw_context *draw,
    vs->base.delete = vs_llvm_delete;
    vs->base.create_variant = draw_vs_create_variant_generic;
 
-   make_empty_list(&vs->variants);
+   list_inithead(&vs->variants.list);
 
    return &vs->base;
 }