intel: make intel_base_create() take a intel_handle

With this change, we now create intel_dev using

  dev = intel_base_create(&gpu->handle, ...);

instead of

  dev = intel_base_create(NULL, ...);

The calls to intel_dev_log() in base_dbg_copy_create_info() are removed.  One
of them is replaced an assert() and the other should have been called in
intel_mem_alloc().

diff --git a/icd/intel/buf.c b/icd/intel/buf.c
index 69374b4..339fdad 100644 (file)
--- a/icd/intel/buf.c
+++ b/icd/intel/buf.c
@@ -92,8 +92,8 @@ XGL_RESULT intel_buf_create(struct intel_dev *dev,
 {
     struct intel_buf *buf;
 
-    buf = (struct intel_buf *) intel_base_create(dev, sizeof(*buf),
-            dev->base.dbg, XGL_DBG_OBJECT_BUFFER, info, 0);
+    buf = (struct intel_buf *) intel_base_create(&dev->base.handle,
+            sizeof(*buf), dev->base.dbg, XGL_DBG_OBJECT_BUFFER, info, 0);
     if (!buf)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/cmd.c b/icd/intel/cmd.c
index 44734a4..56e5b04 100644 (file)
--- a/icd/intel/cmd.c
+++ b/icd/intel/cmd.c
@@ -277,8 +277,8 @@ XGL_RESULT intel_cmd_create(struct intel_dev *dev,
         break;
     }
 
-    cmd = (struct intel_cmd *) intel_base_create(dev, sizeof(*cmd),
-            dev->base.dbg, XGL_DBG_OBJECT_CMD_BUFFER, info, 0);
+    cmd = (struct intel_cmd *) intel_base_create(&dev->base.handle,
+            sizeof(*cmd), dev->base.dbg, XGL_DBG_OBJECT_CMD_BUFFER, info, 0);
     if (!cmd)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/desc.c b/icd/intel/desc.c
index 598964e..9869c4f 100644 (file)
--- a/icd/intel/desc.c
+++ b/icd/intel/desc.c
@@ -311,9 +311,9 @@ XGL_RESULT intel_desc_region_create(struct intel_dev *dev,
     struct intel_desc_region *region;
     XGL_RESULT ret;
 
-    region = (struct intel_desc_region *)
-        intel_base_create(dev, sizeof(*region), dev->base.dbg,
-                XGL_DBG_OBJECT_DESCRIPTOR_REGION, info, 0);
+    region = (struct intel_desc_region *) intel_base_create(&dev->base.handle,
+            sizeof(*region), dev->base.dbg, XGL_DBG_OBJECT_DESCRIPTOR_REGION,
+            info, 0);
     if (!region)
         return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -382,9 +382,9 @@ XGL_RESULT intel_desc_set_create(struct intel_dev *dev,
     struct intel_desc_set *set;
     XGL_RESULT ret;
 
-    set = (struct intel_desc_set *)
-        intel_base_create(dev, sizeof(*set), dev->base.dbg,
-                XGL_DBG_OBJECT_DESCRIPTOR_SET, NULL, 0);
+    set = (struct intel_desc_set *) intel_base_create(&dev->base.handle,
+            sizeof(*set), dev->base.dbg, XGL_DBG_OBJECT_DESCRIPTOR_SET,
+            NULL, 0);
     if (!set)
         return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -828,9 +828,9 @@ XGL_RESULT intel_desc_layout_create(struct intel_dev *dev,
     struct intel_desc_layout *layout;
     XGL_RESULT ret;
 
-    layout = (struct intel_desc_layout *)
-        intel_base_create(dev, sizeof(*layout), dev->base.dbg,
-                XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT, info, 0);
+    layout = (struct intel_desc_layout *) intel_base_create(&dev->base.handle,
+            sizeof(*layout), dev->base.dbg,
+            XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT, info, 0);
     if (!layout)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/dev.c b/icd/intel/dev.c
index 89e06f6..d9c87a8 100644 (file)
--- a/icd/intel/dev.c
+++ b/icd/intel/dev.c
@@ -110,8 +110,8 @@ XGL_RESULT intel_dev_create(struct intel_gpu *gpu,
     if (gpu->winsys)
         return XGL_ERROR_DEVICE_ALREADY_CREATED;
 
-    dev = (struct intel_dev *) intel_base_create(NULL, sizeof(*dev),
-            info->flags & XGL_DEVICE_CREATE_VALIDATION_BIT,
+    dev = (struct intel_dev *) intel_base_create(&gpu->handle,
+            sizeof(*dev), info->flags & XGL_DEVICE_CREATE_VALIDATION_BIT,
             XGL_DBG_OBJECT_DEVICE, info, sizeof(struct intel_dev_dbg));
     if (!dev)
         return XGL_ERROR_OUT_OF_MEMORY;

diff --git a/icd/intel/event.c b/icd/intel/event.c
index 1c126c7..fb65732 100644 (file)
--- a/icd/intel/event.c
+++ b/icd/intel/event.c
@@ -123,8 +123,8 @@ XGL_RESULT intel_event_create(struct intel_dev *dev,
 {
     struct intel_event *event;
 
-    event = (struct intel_event *) intel_base_create(dev, sizeof(*event),
-            dev->base.dbg, XGL_DBG_OBJECT_EVENT, info, 0);
+    event = (struct intel_event *) intel_base_create(&dev->base.handle,
+            sizeof(*event), dev->base.dbg, XGL_DBG_OBJECT_EVENT, info, 0);
     if (!event)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/fb.c b/icd/intel/fb.c
index f6c0bad..845ecae 100644 (file)
--- a/icd/intel/fb.c
+++ b/icd/intel/fb.c
@@ -46,8 +46,8 @@ XGL_RESULT intel_fb_create(struct intel_dev *dev,
     if (info->colorAttachmentCount > INTEL_MAX_RENDER_TARGETS)
         return XGL_ERROR_INVALID_VALUE;
 
-    fb = (struct intel_fb *) intel_base_create(dev, sizeof(*fb),
-            dev->base.dbg, XGL_DBG_OBJECT_FRAMEBUFFER, info, 0);
+    fb = (struct intel_fb *) intel_base_create(&dev->base.handle,
+            sizeof(*fb), dev->base.dbg, XGL_DBG_OBJECT_FRAMEBUFFER, info, 0);
     if (!fb)
         return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -145,8 +145,8 @@ XGL_RESULT intel_render_pass_create(struct intel_dev *dev,
     struct intel_render_pass *rp;
     uint32_t i;
 
-    rp = (struct intel_render_pass *) intel_base_create(dev, sizeof(*rp),
-            dev->base.dbg, XGL_DBG_OBJECT_RENDER_PASS, info, 0);
+    rp = (struct intel_render_pass *) intel_base_create(&dev->base.handle,
+            sizeof(*rp), dev->base.dbg, XGL_DBG_OBJECT_RENDER_PASS, info, 0);
     if (!rp)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/fence.c b/icd/intel/fence.c
index debcd7e..e588147 100644 (file)
--- a/icd/intel/fence.c
+++ b/icd/intel/fence.c
@@ -44,8 +44,8 @@ XGL_RESULT intel_fence_create(struct intel_dev *dev,
 {
     struct intel_fence *fence;
 
-    fence = (struct intel_fence *) intel_base_create(dev, sizeof(*fence),
-            dev->base.dbg, XGL_DBG_OBJECT_FENCE, info, 0);
+    fence = (struct intel_fence *) intel_base_create(&dev->base.handle,
+            sizeof(*fence), dev->base.dbg, XGL_DBG_OBJECT_FENCE, info, 0);
     if (!fence)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/img.c b/icd/intel/img.c
index 4b6a1bd..48378f3 100644 (file)
--- a/icd/intel/img.c
+++ b/icd/intel/img.c
@@ -109,8 +109,8 @@ XGL_RESULT intel_img_create(struct intel_dev *dev,
     struct intel_img *img;
     struct intel_layout *layout;
 
-    img = (struct intel_img *) intel_base_create(dev, sizeof(*img),
-            dev->base.dbg, XGL_DBG_OBJECT_IMAGE, info, 0);
+    img = (struct intel_img *) intel_base_create(&dev->base.handle,
+            sizeof(*img), dev->base.dbg, XGL_DBG_OBJECT_IMAGE, info, 0);
     if (!img)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/mem.c b/icd/intel/mem.c
index efad6a0..94f21a0 100644 (file)
--- a/icd/intel/mem.c
+++ b/icd/intel/mem.c
@@ -36,8 +36,8 @@ XGL_RESULT intel_mem_alloc(struct intel_dev *dev,
 
     /* ignore any IMAGE_INFO and BUFFER_INFO usage: they don't alter allocations */
 
-    mem = (struct intel_mem *) intel_base_create(dev, sizeof(*mem),
-            dev->base.dbg, XGL_DBG_OBJECT_GPU_MEMORY, info, 0);
+    mem = (struct intel_mem *) intel_base_create(&dev->base.handle,
+            sizeof(*mem), dev->base.dbg, XGL_DBG_OBJECT_GPU_MEMORY, info, 0);
     if (!mem)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/obj.c b/icd/intel/obj.c
index c43776f..a5ffb04 100644 (file)
--- a/icd/intel/obj.c
+++ b/icd/intel/obj.c
@@ -188,10 +188,7 @@ static bool base_dbg_copy_create_info(struct intel_base_dbg *dbg,
         shallow_copy = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
         break;
     default:
-        // log debug message regarding invalid struct_type?
-        intel_dev_log(dbg->dev, XGL_DBG_MSG_ERROR,
-                      XGL_VALIDATION_LEVEL_0, XGL_NULL_HANDLE, 0, 0,
-                      "Invalid Create Info type: 0x%x", info.header->struct_type);
+        assert(!"unknown dbg object type");
         return false;
         break;
     }
@@ -221,10 +218,6 @@ static bool base_dbg_copy_create_info(struct intel_base_dbg *dbg,
                     size += sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
                     break;
                 default:
-                    intel_dev_log(dbg->dev, XGL_DBG_MSG_ERROR,
-                          XGL_VALIDATION_LEVEL_0, XGL_NULL_HANDLE, 0, 0,
-                          "Invalid Memory Alloc Create Info type: 0x%x",
-                          ptr_next->sType);
                     return false;
             }
             ptr_next = (XGL_MEMORY_ALLOC_INFO *) ptr_next->pNext;
@@ -308,7 +301,7 @@ static bool base_dbg_copy_create_info(struct intel_base_dbg *dbg,
  * Create an intel_base_dbg.  When dbg_size is non-zero, a buffer of that
  * size is allocated and zeroed.
  */
-struct intel_base_dbg *intel_base_dbg_create(struct intel_dev *dev,
+struct intel_base_dbg *intel_base_dbg_create(const struct intel_handle *handle,
                                              XGL_DBG_OBJECT_TYPE type,
                                              const void *create_info,
                                              size_t dbg_size)
@@ -328,7 +321,6 @@ struct intel_base_dbg *intel_base_dbg_create(struct intel_dev *dev,
 
     dbg->alloc_id = icd_allocator_get_id();
     dbg->type = type;
-    dbg->dev = dev;
 
     if (!base_dbg_copy_create_info(dbg, create_info)) {
         icd_free(dbg);
@@ -353,7 +345,7 @@ void intel_base_dbg_destroy(struct intel_base_dbg *dbg)
  * Create an intel_base.  obj_size and dbg_size specify the real sizes of the
  * object and the debug metadata.  Memories are zeroed.
  */
-struct intel_base *intel_base_create(struct intel_dev *dev,
+struct intel_base *intel_base_create(const struct intel_handle *handle,
                                      size_t obj_size, bool debug,
                                      XGL_DBG_OBJECT_TYPE type,
                                      const void *create_info,
@@ -373,16 +365,9 @@ struct intel_base *intel_base_create(struct intel_dev *dev,
     memset(base, 0, obj_size);
     intel_handle_init(&base->handle, type);
 
-    if (dev == NULL) {
-        /*
-         * dev is NULL when we are creating the base device object
-         * Set dev now so that debug setup happens correctly
-         */
-        dev = (struct intel_dev *) base;
-    }
-
     if (debug) {
-        base->dbg = intel_base_dbg_create(dev, type, create_info, dbg_size);
+        base->dbg = intel_base_dbg_create(handle,
+                type, create_info, dbg_size);
         if (!base->dbg) {
             icd_free(base);
             return NULL;

diff --git a/icd/intel/obj.h b/icd/intel/obj.h
index 83f4139..48cf6ef 100644 (file)
--- a/icd/intel/obj.h
+++ b/icd/intel/obj.h
@@ -42,12 +42,6 @@ struct intel_base_dbg {
 
     void *tag;
     size_t tag_size;
-
-    /*
-     * Need pointer to base object to be able to log debug
-     * messages with intel_dev_log
-     */
-    struct intel_dev *dev;
 };
 
 struct intel_base {
@@ -90,13 +84,13 @@ static inline void intel_obj_bind_mem(struct intel_obj *obj,
 XGL_RESULT intel_base_get_info(struct intel_base *base, int type,
                                size_t *size, void *data);
 
-struct intel_base_dbg *intel_base_dbg_create(struct intel_dev *dev,
+struct intel_base_dbg *intel_base_dbg_create(const struct intel_handle *handle,
                                              XGL_DBG_OBJECT_TYPE type,
                                              const void *create_info,
                                              size_t dbg_size);
 void intel_base_dbg_destroy(struct intel_base_dbg *dbg);
 
-struct intel_base *intel_base_create(struct intel_dev *dev,
+struct intel_base *intel_base_create(const struct intel_handle *handle,
                                      size_t obj_size, bool debug,
                                      XGL_DBG_OBJECT_TYPE type,
                                      const void *create_info,

diff --git a/icd/intel/pipeline.c b/icd/intel/pipeline.c
index 2fb38f0..216f16d 100644 (file)
--- a/icd/intel/pipeline.c
+++ b/icd/intel/pipeline.c
@@ -1386,9 +1386,9 @@ static XGL_RESULT graphics_pipeline_create(struct intel_dev *dev,
     if (ret != XGL_SUCCESS)
         return ret;
 
-    pipeline = (struct intel_pipeline *)
-        intel_base_create(dev, sizeof(*pipeline), dev->base.dbg,
-                XGL_DBG_OBJECT_GRAPHICS_PIPELINE, info_, 0);
+    pipeline = (struct intel_pipeline *) intel_base_create(&dev->base.handle,
+            sizeof(*pipeline), dev->base.dbg,
+            XGL_DBG_OBJECT_GRAPHICS_PIPELINE, info_, 0);
     if (!pipeline)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/query.c b/icd/intel/query.c
index 70c3ad5..2c4700d 100644 (file)
--- a/icd/intel/query.c
+++ b/icd/intel/query.c
@@ -69,8 +69,9 @@ XGL_RESULT intel_query_create(struct intel_dev *dev,
 {
     struct intel_query *query;
 
-    query = (struct intel_query *) intel_base_create(dev, sizeof(*query),
-            dev->base.dbg, XGL_DBG_OBJECT_QUERY_POOL, info, 0);
+    query = (struct intel_query *) intel_base_create(&dev->base.handle,
+            sizeof(*query), dev->base.dbg, XGL_DBG_OBJECT_QUERY_POOL,
+            info, 0);
     if (!query)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/queue.c b/icd/intel/queue.c
index b185419..7c4f49b 100644 (file)
--- a/icd/intel/queue.c
+++ b/icd/intel/queue.c
@@ -269,8 +269,8 @@ XGL_RESULT intel_queue_create(struct intel_dev *dev,
         break;
     }
 
-    queue = (struct intel_queue *) intel_base_create(dev, sizeof(*queue),
-            dev->base.dbg, XGL_DBG_OBJECT_QUEUE, NULL, 0);
+    queue = (struct intel_queue *) intel_base_create(&dev->base.handle,
+            sizeof(*queue), dev->base.dbg, XGL_DBG_OBJECT_QUEUE, NULL, 0);
     if (!queue)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/sampler.c b/icd/intel/sampler.c
index 0776a07..34d08e3 100644 (file)
--- a/icd/intel/sampler.c
+++ b/icd/intel/sampler.c
@@ -367,7 +367,7 @@ XGL_RESULT intel_sampler_create(struct intel_dev *dev,
 {
     struct intel_sampler *sampler;
 
-    sampler = (struct intel_sampler *) intel_base_create(dev,
+    sampler = (struct intel_sampler *) intel_base_create(&dev->base.handle,
             sizeof(*sampler), dev->base.dbg, XGL_DBG_OBJECT_SAMPLER, info, 0);
     if (!sampler)
         return XGL_ERROR_OUT_OF_MEMORY;

diff --git a/icd/intel/shader.c b/icd/intel/shader.c
index 2480cf1..b2c1155 100644 (file)
--- a/icd/intel/shader.c
+++ b/icd/intel/shader.c
@@ -47,8 +47,8 @@ static XGL_RESULT shader_create(struct intel_dev *dev,
         (const struct icd_bil_header *) info->pCode;
     struct intel_shader *sh;
 
-    sh = (struct intel_shader *) intel_base_create(dev, sizeof(*sh),
-            dev->base.dbg, XGL_DBG_OBJECT_SHADER, info, 0);
+    sh = (struct intel_shader *) intel_base_create(&dev->base.handle,
+            sizeof(*sh), dev->base.dbg, XGL_DBG_OBJECT_SHADER, info, 0);
     if (!sh)
         return XGL_ERROR_OUT_OF_MEMORY;
 

diff --git a/icd/intel/state.c b/icd/intel/state.c
index d39f8f6..3186f64 100644 (file)
--- a/icd/intel/state.c
+++ b/icd/intel/state.c
@@ -228,7 +228,7 @@ XGL_RESULT intel_viewport_state_create(struct intel_dev *dev,
     struct intel_dynamic_vp *state;
     XGL_RESULT ret;
 
-    state = (struct intel_dynamic_vp *) intel_base_create(dev,
+    state = (struct intel_dynamic_vp *) intel_base_create(&dev->base.handle,
             sizeof(*state), dev->base.dbg, XGL_DBG_OBJECT_VIEWPORT_STATE,
             info, 0);
     if (!state)
@@ -266,7 +266,7 @@ XGL_RESULT intel_raster_state_create(struct intel_dev *dev,
 {
     struct intel_dynamic_rs *state;
 
-    state = (struct intel_dynamic_rs *) intel_base_create(dev,
+    state = (struct intel_dynamic_rs *) intel_base_create(&dev->base.handle,
             sizeof(*state), dev->base.dbg, XGL_DBG_OBJECT_RASTER_STATE,
             info, 0);
     if (!state)
@@ -298,7 +298,7 @@ XGL_RESULT intel_blend_state_create(struct intel_dev *dev,
 {
     struct intel_dynamic_cb *state;
 
-    state = (struct intel_dynamic_cb *) intel_base_create(dev,
+    state = (struct intel_dynamic_cb *) intel_base_create(&dev->base.handle,
             sizeof(*state), dev->base.dbg, XGL_DBG_OBJECT_COLOR_BLEND_STATE,
             info, 0);
     if (!state)
@@ -330,7 +330,7 @@ XGL_RESULT intel_ds_state_create(struct intel_dev *dev,
 {
     struct intel_dynamic_ds *state;
 
-    state = (struct intel_dynamic_ds *) intel_base_create(dev,
+    state = (struct intel_dynamic_ds *) intel_base_create(&dev->base.handle,
             sizeof(*state), dev->base.dbg, XGL_DBG_OBJECT_DEPTH_STENCIL_STATE,
             info, 0);
     if (!state)

diff --git a/icd/intel/view.c b/icd/intel/view.c
index 9fda59b..9593e95 100644 (file)
--- a/icd/intel/view.c
+++ b/icd/intel/view.c
@@ -1087,8 +1087,9 @@ XGL_RESULT intel_buf_view_create(struct intel_dev *dev,
     struct intel_buf_view *view;
     int i;
 
-    view = (struct intel_buf_view *) intel_base_create(dev, sizeof(*view),
-            dev->base.dbg, XGL_DBG_OBJECT_BUFFER_VIEW, info, 0);
+    view = (struct intel_buf_view *) intel_base_create(&dev->base.handle,
+            sizeof(*view), dev->base.dbg, XGL_DBG_OBJECT_BUFFER_VIEW,
+            info, 0);
     if (!view)
         return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -1173,8 +1174,8 @@ XGL_RESULT intel_img_view_create(struct intel_dev *dev,
     if (array_size > img->array_size - info->subresourceRange.baseArraySlice)
         array_size = img->array_size - info->subresourceRange.baseArraySlice;
 
-    view = (struct intel_img_view *) intel_base_create(dev, sizeof(*view),
-            dev->base.dbg, XGL_DBG_OBJECT_IMAGE_VIEW, info, 0);
+    view = (struct intel_img_view *) intel_base_create(&dev->base.handle,
+            sizeof(*view), dev->base.dbg, XGL_DBG_OBJECT_IMAGE_VIEW, info, 0);
     if (!view)
         return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -1251,8 +1252,9 @@ XGL_RESULT intel_rt_view_create(struct intel_dev *dev,
     struct intel_img *img = intel_img(info->image);
     struct intel_rt_view *view;
 
-    view = (struct intel_rt_view *) intel_base_create(dev, sizeof(*view),
-            dev->base.dbg, XGL_DBG_OBJECT_COLOR_TARGET_VIEW, info, 0);
+    view = (struct intel_rt_view *) intel_base_create(&dev->base.handle,
+            sizeof(*view), dev->base.dbg, XGL_DBG_OBJECT_COLOR_TARGET_VIEW,
+            info, 0);
     if (!view)
         return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -1302,8 +1304,9 @@ XGL_RESULT intel_ds_view_create(struct intel_dev *dev,
     struct intel_img *img = intel_img(info->image);
     struct intel_ds_view *view;
 
-    view = (struct intel_ds_view *) intel_base_create(dev, sizeof(*view),
-            dev->base.dbg, XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW, info, 0);
+    view = (struct intel_ds_view *) intel_base_create(&dev->base.handle,
+            sizeof(*view), dev->base.dbg, XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW,
+            info, 0);
     if (!view)
         return XGL_ERROR_OUT_OF_MEMORY;