rbug: Update rbug protocol with new context calls

diff --git a/src/gallium/auxiliary/rbug/rbug_context.c b/src/gallium/auxiliary/rbug/rbug_context.c
index b4fad5300d9b574cbe4f349ec6db62f76f900d44..787f650f7102709b830d7a81677cbee3addadb76 100644 (file)
--- a/src/gallium/auxiliary/rbug/rbug_context.c
+++ b/src/gallium/auxiliary/rbug/rbug_context.c
@@ -110,8 +110,9 @@ int rbug_send_context_info(struct rbug_connection *__con,
        return __ret;
 }
 
-int rbug_send_context_block_draw(struct rbug_connection *__con,
+int rbug_send_context_draw_block(struct rbug_connection *__con,
                                  rbug_context_t context,
+                                 rbug_block_t block,
                                  uint32_t *__serial)
 {
        uint32_t __len = 0;
@@ -121,6 +122,7 @@ int rbug_send_context_block_draw(struct rbug_connection *__con,
 
        LEN(8); /* header */
        LEN(8); /* context */
+       LEN(4); /* block */
 
        /* align */
        PAD(__len, 8);
@@ -129,9 +131,10 @@ int rbug_send_context_block_draw(struct rbug_connection *__con,
        if (!__data)
                return -ENOMEM;
 
-       WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_BLOCK_DRAW));
+       WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK));
        WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
        WRITE(8, rbug_context_t, context); /* context */
+       WRITE(4, rbug_block_t, block); /* block */
 
        /* final pad */
        PAD(__pos, 8);
@@ -139,7 +142,7 @@ int rbug_send_context_block_draw(struct rbug_connection *__con,
        if (__pos != __len) {
                __ret = -EINVAL;
        } else {
-               rbug_connection_send_start(__con, RBUG_OP_CONTEXT_BLOCK_DRAW, __len);
+               rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCK, __len);
                rbug_connection_write(__con, __data, __len);
                __ret = rbug_connection_send_finish(__con, __serial);
        }
@@ -148,8 +151,50 @@ int rbug_send_context_block_draw(struct rbug_connection *__con,
        return __ret;
 }
 
-int rbug_send_context_unblock_draw(struct rbug_connection *__con,
+int rbug_send_context_draw_step(struct rbug_connection *__con,
+                                rbug_context_t context,
+                                rbug_block_t step,
+                                uint32_t *__serial)
+{
+       uint32_t __len = 0;
+       uint32_t __pos = 0;
+       uint8_t *__data = NULL;
+       int __ret = 0;
+
+       LEN(8); /* header */
+       LEN(8); /* context */
+       LEN(4); /* step */
+
+       /* align */
+       PAD(__len, 8);
+
+       __data = (uint8_t*)MALLOC(__len);
+       if (!__data)
+               return -ENOMEM;
+
+       WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_STEP));
+       WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+       WRITE(8, rbug_context_t, context); /* context */
+       WRITE(4, rbug_block_t, step); /* step */
+
+       /* final pad */
+       PAD(__pos, 8);
+
+       if (__pos != __len) {
+               __ret = -EINVAL;
+       } else {
+               rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_STEP, __len);
+               rbug_connection_write(__con, __data, __len);
+               __ret = rbug_connection_send_finish(__con, __serial);
+       }
+
+       FREE(__data);
+       return __ret;
+}
+
+int rbug_send_context_draw_unblock(struct rbug_connection *__con,
                                    rbug_context_t context,
+                                   rbug_block_t unblock,
                                    uint32_t *__serial)
 {
        uint32_t __len = 0;
@@ -159,6 +204,7 @@ int rbug_send_context_unblock_draw(struct rbug_connection *__con,
 
        LEN(8); /* header */
        LEN(8); /* context */
+       LEN(4); /* unblock */
 
        /* align */
        PAD(__len, 8);
@@ -167,9 +213,10 @@ int rbug_send_context_unblock_draw(struct rbug_connection *__con,
        if (!__data)
                return -ENOMEM;
 
-       WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_UNBLOCK_DRAW));
+       WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK));
        WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
        WRITE(8, rbug_context_t, context); /* context */
+       WRITE(4, rbug_block_t, unblock); /* unblock */
 
        /* final pad */
        PAD(__pos, 8);
@@ -177,7 +224,48 @@ int rbug_send_context_unblock_draw(struct rbug_connection *__con,
        if (__pos != __len) {
                __ret = -EINVAL;
        } else {
-               rbug_connection_send_start(__con, RBUG_OP_CONTEXT_UNBLOCK_DRAW, __len);
+               rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_UNBLOCK, __len);
+               rbug_connection_write(__con, __data, __len);
+               __ret = rbug_connection_send_finish(__con, __serial);
+       }
+
+       FREE(__data);
+       return __ret;
+}
+
+int rbug_send_context_flush(struct rbug_connection *__con,
+                            rbug_context_t context,
+                            int32_t flags,
+                            uint32_t *__serial)
+{
+       uint32_t __len = 0;
+       uint32_t __pos = 0;
+       uint8_t *__data = NULL;
+       int __ret = 0;
+
+       LEN(8); /* header */
+       LEN(8); /* context */
+       LEN(4); /* flags */
+
+       /* align */
+       PAD(__len, 8);
+
+       __data = (uint8_t*)MALLOC(__len);
+       if (!__data)
+               return -ENOMEM;
+
+       WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_FLUSH));
+       WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+       WRITE(8, rbug_context_t, context); /* context */
+       WRITE(4, int32_t, flags); /* flags */
+
+       /* final pad */
+       PAD(__pos, 8);
+
+       if (__pos != __len) {
+               __ret = -EINVAL;
+       } else {
+               rbug_connection_send_start(__con, RBUG_OP_CONTEXT_FLUSH, __len);
                rbug_connection_write(__con, __data, __len);
                __ret = rbug_connection_send_finish(__con, __serial);
        }
@@ -230,10 +318,13 @@ int rbug_send_context_list_reply(struct rbug_connection *__con,
 
 int rbug_send_context_info_reply(struct rbug_connection *__con,
                                  uint32_t serial,
+                                 rbug_shader_t vertex,
+                                 rbug_shader_t fragment,
                                  rbug_texture_t *cbufs,
                                  uint32_t cbufs_len,
-                                 rbug_texture_t zdbuf,
-                                 uint8_t blocked,
+                                 rbug_texture_t zsbuf,
+                                 rbug_block_t blocker,
+                                 rbug_block_t blocked,
                                  uint32_t *__serial)
 {
        uint32_t __len = 0;
@@ -243,9 +334,12 @@ int rbug_send_context_info_reply(struct rbug_connection *__con,
 
        LEN(8); /* header */
        LEN(4); /* serial */
+       LEN(8); /* vertex */
+       LEN(8); /* fragment */
        LEN_ARRAY(8, cbufs); /* cbufs */
-       LEN(8); /* zdbuf */
-       LEN(1); /* blocked */
+       LEN(8); /* zsbuf */
+       LEN(4); /* blocker */
+       LEN(4); /* blocked */
 
        /* align */
        PAD(__len, 8);
@@ -257,9 +351,12 @@ int rbug_send_context_info_reply(struct rbug_connection *__con,
        WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY));
        WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
        WRITE(4, uint32_t, serial); /* serial */
+       WRITE(8, rbug_shader_t, vertex); /* vertex */
+       WRITE(8, rbug_shader_t, fragment); /* fragment */
        WRITE_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
-       WRITE(8, rbug_texture_t, zdbuf); /* zdbuf */
-       WRITE(1, uint8_t, blocked); /* blocked */
+       WRITE(8, rbug_texture_t, zsbuf); /* zsbuf */
+       WRITE(4, rbug_block_t, blocker); /* blocker */
+       WRITE(4, rbug_block_t, blocked); /* blocked */
 
        /* final pad */
        PAD(__pos, 8);
@@ -276,6 +373,47 @@ int rbug_send_context_info_reply(struct rbug_connection *__con,
        return __ret;
 }
 
+int rbug_send_context_draw_blocked(struct rbug_connection *__con,
+                                   rbug_context_t context,
+                                   rbug_block_t block,
+                                   uint32_t *__serial)
+{
+       uint32_t __len = 0;
+       uint32_t __pos = 0;
+       uint8_t *__data = NULL;
+       int __ret = 0;
+
+       LEN(8); /* header */
+       LEN(8); /* context */
+       LEN(4); /* block */
+
+       /* align */
+       PAD(__len, 8);
+
+       __data = (uint8_t*)MALLOC(__len);
+       if (!__data)
+               return -ENOMEM;
+
+       WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED));
+       WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
+       WRITE(8, rbug_context_t, context); /* context */
+       WRITE(4, rbug_block_t, block); /* block */
+
+       /* final pad */
+       PAD(__pos, 8);
+
+       if (__pos != __len) {
+               __ret = -EINVAL;
+       } else {
+               rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCKED, __len);
+               rbug_connection_write(__con, __data, __len);
+               __ret = rbug_connection_send_finish(__con, __serial);
+       }
+
+       FREE(__data);
+       return __ret;
+}
+
 struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header)
 {
        uint32_t len = 0;
@@ -329,16 +467,72 @@ struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_h
        return ret;
 }
 
-struct rbug_proto_context_block_draw * rbug_demarshal_context_block_draw(struct rbug_proto_header *header)
+struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header)
+{
+       uint32_t len = 0;
+       uint32_t pos = 0;
+       uint8_t *data =  NULL;
+       struct rbug_proto_context_draw_block *ret;
+
+       if (!header)
+               return NULL;
+       if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCK)
+               return NULL;
+
+       pos = 0;
+       len = header->length * 4;
+       data = (uint8_t*)&header[1];
+       ret = MALLOC(sizeof(*ret));
+       if (!ret)
+               return NULL;
+
+       ret->header.__message = header;
+       ret->header.opcode = header->opcode;
+
+       READ(8, rbug_context_t, context); /* context */
+       READ(4, rbug_block_t, block); /* block */
+
+       return ret;
+}
+
+struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header)
+{
+       uint32_t len = 0;
+       uint32_t pos = 0;
+       uint8_t *data =  NULL;
+       struct rbug_proto_context_draw_step *ret;
+
+       if (!header)
+               return NULL;
+       if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_STEP)
+               return NULL;
+
+       pos = 0;
+       len = header->length * 4;
+       data = (uint8_t*)&header[1];
+       ret = MALLOC(sizeof(*ret));
+       if (!ret)
+               return NULL;
+
+       ret->header.__message = header;
+       ret->header.opcode = header->opcode;
+
+       READ(8, rbug_context_t, context); /* context */
+       READ(4, rbug_block_t, step); /* step */
+
+       return ret;
+}
+
+struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header)
 {
        uint32_t len = 0;
        uint32_t pos = 0;
        uint8_t *data =  NULL;
-       struct rbug_proto_context_block_draw *ret;
+       struct rbug_proto_context_draw_unblock *ret;
 
        if (!header)
                return NULL;
-       if (header->opcode != (int16_t)RBUG_OP_CONTEXT_BLOCK_DRAW)
+       if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK)
                return NULL;
 
        pos = 0;
@@ -352,20 +546,21 @@ struct rbug_proto_context_block_draw * rbug_demarshal_context_block_draw(struct
        ret->header.opcode = header->opcode;
 
        READ(8, rbug_context_t, context); /* context */
+       READ(4, rbug_block_t, unblock); /* unblock */
 
        return ret;
 }
 
-struct rbug_proto_context_unblock_draw * rbug_demarshal_context_unblock_draw(struct rbug_proto_header *header)
+struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header)
 {
        uint32_t len = 0;
        uint32_t pos = 0;
        uint8_t *data =  NULL;
-       struct rbug_proto_context_unblock_draw *ret;
+       struct rbug_proto_context_flush *ret;
 
        if (!header)
                return NULL;
-       if (header->opcode != (int16_t)RBUG_OP_CONTEXT_UNBLOCK_DRAW)
+       if (header->opcode != (int16_t)RBUG_OP_CONTEXT_FLUSH)
                return NULL;
 
        pos = 0;
@@ -379,6 +574,7 @@ struct rbug_proto_context_unblock_draw * rbug_demarshal_context_unblock_draw(str
        ret->header.opcode = header->opcode;
 
        READ(8, rbug_context_t, context); /* context */
+       READ(4, int32_t, flags); /* flags */
 
        return ret;
 }
@@ -434,9 +630,40 @@ struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct
        ret->header.opcode = header->opcode;
 
        READ(4, uint32_t, serial); /* serial */
+       READ(8, rbug_shader_t, vertex); /* vertex */
+       READ(8, rbug_shader_t, fragment); /* fragment */
        READ_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
-       READ(8, rbug_texture_t, zdbuf); /* zdbuf */
-       READ(1, uint8_t, blocked); /* blocked */
+       READ(8, rbug_texture_t, zsbuf); /* zsbuf */
+       READ(4, rbug_block_t, blocker); /* blocker */
+       READ(4, rbug_block_t, blocked); /* blocked */
+
+       return ret;
+}
+
+struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header)
+{
+       uint32_t len = 0;
+       uint32_t pos = 0;
+       uint8_t *data =  NULL;
+       struct rbug_proto_context_draw_blocked *ret;
+
+       if (!header)
+               return NULL;
+       if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCKED)
+               return NULL;
+
+       pos = 0;
+       len = header->length * 4;
+       data = (uint8_t*)&header[1];
+       ret = MALLOC(sizeof(*ret));
+       if (!ret)
+               return NULL;
+
+       ret->header.__message = header;
+       ret->header.opcode = header->opcode;
+
+       READ(8, rbug_context_t, context); /* context */
+       READ(4, rbug_block_t, block); /* block */
 
        return ret;
 }

diff --git a/src/gallium/auxiliary/rbug/rbug_context.h b/src/gallium/auxiliary/rbug/rbug_context.h
index bcd2a826a77708f2f8ac8aa8d94c984348510388..9f1726d64d466be61119ea40a422ec59ecc86d90 100644 (file)
--- a/src/gallium/auxiliary/rbug/rbug_context.h
+++ b/src/gallium/auxiliary/rbug/rbug_context.h
@@ -39,9 +39,13 @@
 #define _RBUG_PROTO_CONTEXT_H_
 
 #include "rbug/rbug_proto.h"
-#include "rbug/rbug_texture.h"
+#include "rbug/rbug_core.h"
 
-typedef uint64_t rbug_context_t;
+typedef enum
+{
+       RBUG_BLOCK_BEFORE = 1,
+       RBUG_BLOCK_AFTER = 2,
+} rbug_block_t;
 
 struct rbug_proto_context_list
 {
@@ -54,16 +58,32 @@ struct rbug_proto_context_info
        rbug_context_t context;
 };
 
-struct rbug_proto_context_block_draw
+struct rbug_proto_context_draw_block
+{
+       struct rbug_header header;
+       rbug_context_t context;
+       rbug_block_t block;
+};
+
+struct rbug_proto_context_draw_step
 {
        struct rbug_header header;
        rbug_context_t context;
+       rbug_block_t step;
 };
 
-struct rbug_proto_context_unblock_draw
+struct rbug_proto_context_draw_unblock
 {
        struct rbug_header header;
        rbug_context_t context;
+       rbug_block_t unblock;
+};
+
+struct rbug_proto_context_flush
+{
+       struct rbug_header header;
+       rbug_context_t context;
+       int32_t flags;
 };
 
 struct rbug_proto_context_list_reply
@@ -78,10 +98,20 @@ struct rbug_proto_context_info_reply
 {
        struct rbug_header header;
        uint32_t serial;
+       rbug_shader_t vertex;
+       rbug_shader_t fragment;
        rbug_texture_t *cbufs;
        uint32_t cbufs_len;
-       rbug_texture_t zdbuf;
-       uint8_t blocked;
+       rbug_texture_t zsbuf;
+       rbug_block_t blocker;
+       rbug_block_t blocked;
+};
+
+struct rbug_proto_context_draw_blocked
+{
+       struct rbug_header header;
+       rbug_context_t context;
+       rbug_block_t block;
 };
 
 int rbug_send_context_list(struct rbug_connection *__con,
@@ -91,14 +121,26 @@ int rbug_send_context_info(struct rbug_connection *__con,
                            rbug_context_t context,
                            uint32_t *__serial);
 
-int rbug_send_context_block_draw(struct rbug_connection *__con,
+int rbug_send_context_draw_block(struct rbug_connection *__con,
                                  rbug_context_t context,
+                                 rbug_block_t block,
                                  uint32_t *__serial);
 
-int rbug_send_context_unblock_draw(struct rbug_connection *__con,
+int rbug_send_context_draw_step(struct rbug_connection *__con,
+                                rbug_context_t context,
+                                rbug_block_t step,
+                                uint32_t *__serial);
+
+int rbug_send_context_draw_unblock(struct rbug_connection *__con,
                                    rbug_context_t context,
+                                   rbug_block_t unblock,
                                    uint32_t *__serial);
 
+int rbug_send_context_flush(struct rbug_connection *__con,
+                            rbug_context_t context,
+                            int32_t flags,
+                            uint32_t *__serial);
+
 int rbug_send_context_list_reply(struct rbug_connection *__con,
                                  uint32_t serial,
                                  rbug_context_t *contexts,
@@ -107,22 +149,36 @@ int rbug_send_context_list_reply(struct rbug_connection *__con,
 
 int rbug_send_context_info_reply(struct rbug_connection *__con,
                                  uint32_t serial,
+                                 rbug_shader_t vertex,
+                                 rbug_shader_t fragment,
                                  rbug_texture_t *cbufs,
                                  uint32_t cbufs_len,
-                                 rbug_texture_t zdbuf,
-                                 uint8_t blocked,
+                                 rbug_texture_t zsbuf,
+                                 rbug_block_t blocker,
+                                 rbug_block_t blocked,
                                  uint32_t *__serial);
 
+int rbug_send_context_draw_blocked(struct rbug_connection *__con,
+                                   rbug_context_t context,
+                                   rbug_block_t block,
+                                   uint32_t *__serial);
+
 struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header);
 
 struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header);
 
-struct rbug_proto_context_block_draw * rbug_demarshal_context_block_draw(struct rbug_proto_header *header);
+struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header);
 
-struct rbug_proto_context_unblock_draw * rbug_demarshal_context_unblock_draw(struct rbug_proto_header *header);
+struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header);
+
+struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header);
+
+struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header);
 
 struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header);
 
 struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header);
 
+struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header);
+
 #endif

diff --git a/src/gallium/auxiliary/rbug/rbug_core.h b/src/gallium/auxiliary/rbug/rbug_core.h
index d63a8c80764797d289840ceb3a58e2249ef0f990..99a36a0163ed66bd34d46f5ffd349b242b86c006 100644 (file)
--- a/src/gallium/auxiliary/rbug/rbug_core.h
+++ b/src/gallium/auxiliary/rbug/rbug_core.h
@@ -40,6 +40,10 @@
 
 #include "rbug/rbug_proto.h"
 
+typedef uint64_t rbug_shader_t;
+typedef uint64_t rbug_context_t;
+typedef uint64_t rbug_texture_t;
+
 struct rbug_proto_noop
 {
        struct rbug_header header;

diff --git a/src/gallium/auxiliary/rbug/rbug_demarshal.c b/src/gallium/auxiliary/rbug/rbug_demarshal.c
index e3c0954f9ecb5e8bbfdf31d88c4faf6c7d49662d..80894f4a64cae75163423283f4c9443107e13fcf 100644 (file)
--- a/src/gallium/auxiliary/rbug/rbug_demarshal.c
+++ b/src/gallium/auxiliary/rbug/rbug_demarshal.c
@@ -59,14 +59,20 @@ struct rbug_header * rbug_demarshal(struct rbug_proto_header *header)
                return (struct rbug_header *)rbug_demarshal_context_list(header);
        case RBUG_OP_CONTEXT_INFO:
                return (struct rbug_header *)rbug_demarshal_context_info(header);
-       case RBUG_OP_CONTEXT_BLOCK_DRAW:
-               return (struct rbug_header *)rbug_demarshal_context_block_draw(header);
-       case RBUG_OP_CONTEXT_UNBLOCK_DRAW:
-               return (struct rbug_header *)rbug_demarshal_context_unblock_draw(header);
+       case RBUG_OP_CONTEXT_DRAW_BLOCK:
+               return (struct rbug_header *)rbug_demarshal_context_draw_block(header);
+       case RBUG_OP_CONTEXT_DRAW_STEP:
+               return (struct rbug_header *)rbug_demarshal_context_draw_step(header);
+       case RBUG_OP_CONTEXT_DRAW_UNBLOCK:
+               return (struct rbug_header *)rbug_demarshal_context_draw_unblock(header);
+       case RBUG_OP_CONTEXT_FLUSH:
+               return (struct rbug_header *)rbug_demarshal_context_flush(header);
        case RBUG_OP_CONTEXT_LIST_REPLY:
                return (struct rbug_header *)rbug_demarshal_context_list_reply(header);
        case RBUG_OP_CONTEXT_INFO_REPLY:
                return (struct rbug_header *)rbug_demarshal_context_info_reply(header);
+       case RBUG_OP_CONTEXT_DRAW_BLOCKED:
+               return (struct rbug_header *)rbug_demarshal_context_draw_blocked(header);
        case RBUG_OP_SHADER_LIST:
                return (struct rbug_header *)rbug_demarshal_shader_list(header);
        case RBUG_OP_SHADER_INFO:

diff --git a/src/gallium/auxiliary/rbug/rbug_proto.h b/src/gallium/auxiliary/rbug/rbug_proto.h
index 8fa183677130fa5be3e948e04f716d9302836865..db9fa685006371b7a2fad49e46a3cec9c2177fa0 100644 (file)
--- a/src/gallium/auxiliary/rbug/rbug_proto.h
+++ b/src/gallium/auxiliary/rbug/rbug_proto.h
@@ -52,10 +52,13 @@ enum rbug_opcode
        RBUG_OP_TEXTURE_READ_REPLY = -259,
        RBUG_OP_CONTEXT_LIST = 512,
        RBUG_OP_CONTEXT_INFO = 513,
-       RBUG_OP_CONTEXT_BLOCK_DRAW = 514,
-       RBUG_OP_CONTEXT_UNBLOCK_DRAW = 515,
+       RBUG_OP_CONTEXT_DRAW_BLOCK = 514,
+       RBUG_OP_CONTEXT_DRAW_STEP = 515,
+       RBUG_OP_CONTEXT_DRAW_UNBLOCK = 516,
+       RBUG_OP_CONTEXT_FLUSH = 518,
        RBUG_OP_CONTEXT_LIST_REPLY = -512,
        RBUG_OP_CONTEXT_INFO_REPLY = -513,
+       RBUG_OP_CONTEXT_DRAW_BLOCKED = 517,
        RBUG_OP_SHADER_LIST = 768,
        RBUG_OP_SHADER_INFO = 769,
        RBUG_OP_SHADER_DISABLE = 770,

diff --git a/src/gallium/auxiliary/rbug/rbug_shader.h b/src/gallium/auxiliary/rbug/rbug_shader.h
index fe1b9ac0f721c13fa0367a54b283f24ecaceabe1..b5d886781d866d95e6e4e0dec61e1a5cac405405 100644 (file)
--- a/src/gallium/auxiliary/rbug/rbug_shader.h
+++ b/src/gallium/auxiliary/rbug/rbug_shader.h
@@ -39,9 +39,7 @@
 #define _RBUG_PROTO_SHADER_H_
 
 #include "rbug/rbug_proto.h"
-#include "rbug/rbug_context.h"
-
-typedef uint64_t rbug_shader_t;
+#include "rbug/rbug_core.h"
 
 struct rbug_proto_shader_list
 {

diff --git a/src/gallium/auxiliary/rbug/rbug_texture.h b/src/gallium/auxiliary/rbug/rbug_texture.h
index 2bcc3566f367f850dd05d7d3e7f8e47b07512939..fbb247e1d4f288676dc5e8fd43831d23ca1b1085 100644 (file)
--- a/src/gallium/auxiliary/rbug/rbug_texture.h
+++ b/src/gallium/auxiliary/rbug/rbug_texture.h
@@ -39,8 +39,7 @@
 #define _RBUG_PROTO_TEXTURE_H_
 
 #include "rbug/rbug_proto.h"
-
-typedef uint64_t rbug_texture_t;
+#include "rbug/rbug_core.h"
 
 struct rbug_proto_texture_list
 {