glsl: don't use ralloc for blob creation

There is no need to use ralloc here.

Reviewed-by: Marek Olšák <marek.olsak@amd.com>

diff --git a/src/compiler/glsl/blob.c b/src/compiler/glsl/blob.c
index 14dc690..769ebf1 100644 (file)
--- a/src/compiler/glsl/blob.c
+++ b/src/compiler/glsl/blob.c
@@ -24,7 +24,6 @@
 #include <string.h>
 
 #include "main/macros.h"
-#include "util/ralloc.h"
 #include "blob.h"
 
 #define BLOB_INITIAL_SIZE 4096
@@ -49,7 +48,7 @@ grow_to_fit(struct blob *blob, size_t additional)
 
    to_allocate = MAX2(to_allocate, blob->allocated + additional);
 
-   new_data = reralloc_size(blob, blob->data, to_allocate);
+   new_data = realloc(blob->data, to_allocate);
    if (new_data == NULL)
       return false;
 
@@ -88,11 +87,9 @@ align_blob_reader(struct blob_reader *blob, size_t alignment)
 }
 
 struct blob *
-blob_create(void *mem_ctx)
+blob_create()
 {
-   struct blob *blob;
-
-   blob = ralloc(mem_ctx, struct blob);
+   struct blob *blob = (struct blob *) malloc(sizeof(struct blob));
    if (blob == NULL)
       return NULL;
 

diff --git a/src/compiler/glsl/blob.h b/src/compiler/glsl/blob.h
index 21fa43d..6d21ffd 100644 (file)
--- a/src/compiler/glsl/blob.h
+++ b/src/compiler/glsl/blob.h
@@ -73,12 +73,12 @@ struct blob_reader {
 };
 
 /**
- * Create a new, empty blob, belonging to \mem_ctx.
+ * Create a new, empty blob.
  *
  * \return The new blob, (or NULL in case of allocation failure).
  */
 struct blob *
-blob_create(void *mem_ctx);
+blob_create(void);
 
 /**
  * Add some unstructured, fixed-size data to a blob.

diff --git a/src/compiler/glsl/shader_cache.cpp b/src/compiler/glsl/shader_cache.cpp
index 6e56d86..7d8d63b 100644 (file)
--- a/src/compiler/glsl/shader_cache.cpp
+++ b/src/compiler/glsl/shader_cache.cpp
@@ -1224,7 +1224,7 @@ shader_cache_write_program_metadata(struct gl_context *ctx,
    if (*prog->data->sha1 == 0)
       return;
 
-   struct blob *metadata = blob_create(NULL);
+   struct blob *metadata = blob_create();
 
    write_uniforms(metadata, prog);
 
@@ -1272,7 +1272,7 @@ shader_cache_write_program_metadata(struct gl_context *ctx,
 
    disk_cache_put(cache, prog->data->sha1, metadata->data, metadata->size);
 
-   ralloc_free(metadata);
+   free(metadata);
 
    if (ctx->_Shader->Flags & GLSL_CACHE_INFO) {
       fprintf(stderr, "putting program metadata in cache: %s\n",

diff --git a/src/compiler/glsl/tests/blob_test.c b/src/compiler/glsl/tests/blob_test.c
index 09114b1..01b5ef0 100644 (file)
--- a/src/compiler/glsl/tests/blob_test.c
+++ b/src/compiler/glsl/tests/blob_test.c
@@ -118,14 +118,13 @@ expect_equal_bytes(uint8_t *expected, uint8_t *actual,
 static void
 test_write_and_read_functions (void)
 {
-   void *ctx = ralloc_context(NULL);
    struct blob *blob;
    struct blob_reader reader;
    uint8_t *reserved;
    size_t str_offset, uint_offset;
    uint8_t reserve_buf[sizeof(reserve_test_str)];
 
-   blob = blob_create(ctx);
+   blob = blob_create();
 
    /*** Test blob by writing one of every possible kind of value. */
 
@@ -185,20 +184,19 @@ test_write_and_read_functions (void)
                 "read_consumes_all_bytes");
    expect_equal(false, reader.overrun, "read_does_not_overrun");
 
-   ralloc_free(ctx);
+   free(blob);
 }
 
 /* Test that data values are written and read with proper alignment. */
 static void
 test_alignment(void)
 {
-   void *ctx = ralloc_context(NULL);
    struct blob *blob;
    struct blob_reader reader;
    uint8_t bytes[] = "ABCDEFGHIJKLMNOP";
    size_t delta, last, num_bytes;
 
-   blob = blob_create(ctx);
+   blob = blob_create();
 
    /* First, write an intptr value to the blob and capture that size. This is
     * the expected offset between any pair of intptr values (if written with
@@ -244,19 +242,18 @@ test_alignment(void)
                    "aligned read of intptr_t");
    }
 
-   ralloc_free(ctx);
+   free(blob);
 }
 
 /* Test that we detect overrun. */
 static void
 test_overrun(void)
 {
-   void *ctx =ralloc_context(NULL);
    struct blob *blob;
    struct blob_reader reader;
    uint32_t value = 0xdeadbeef;
 
-   blob = blob_create(ctx);
+   blob = blob_create();
 
    blob_write_uint32(blob, value);
 
@@ -267,7 +264,7 @@ test_overrun(void)
    expect_equal(0, blob_read_uint32(&reader), "read at overrun");
    expect_equal(true, reader.overrun, "overrun flag set");
 
-   ralloc_free(ctx);
+   free(blob);
 }
 
 /* Test that we can read and write some large objects, (exercising the code in
@@ -284,7 +281,7 @@ test_big_objects(void)
    size_t i;
    char *buf;
 
-   blob = blob_create(ctx);
+   blob = blob_create();
 
    /* Initialize our buffer. */
    buf = ralloc_size(ctx, size);
@@ -311,6 +308,7 @@ test_big_objects(void)
    expect_equal(false, reader.overrun,
                 "overrun flag not set reading large objects");
 
+   free(blob);
    ralloc_free(ctx);
 }
 

diff --git a/src/mesa/state_tracker/st_shader_cache.c b/src/mesa/state_tracker/st_shader_cache.c
index f22380c..4383194 100644 (file)
--- a/src/mesa/state_tracker/st_shader_cache.c
+++ b/src/mesa/state_tracker/st_shader_cache.c
@@ -68,7 +68,7 @@ st_store_tgsi_in_disk_cache(struct st_context *st, struct gl_program *prog,
       return;
 
    unsigned char *sha1;
-   struct blob *blob = blob_create(NULL);
+   struct blob *blob = blob_create();
 
    switch (prog->info.stage) {
    case MESA_SHADER_VERTEX: {
@@ -134,7 +134,7 @@ st_store_tgsi_in_disk_cache(struct st_context *st, struct gl_program *prog,
               _mesa_shader_stage_to_string(prog->info.stage), sha1_buf);
    }
 
-   ralloc_free(blob);
+   free(blob);
 }
 
 static void