AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gallium: list use inline function to avoid macro shot coming

Browse Source 
Macro can lead to hard to debug list bugs. For instance consider
the following :
LIST_ADD(item, list->prev)
3 instruction of the macro became :
(list->prev)->next->prev = item
which is equivalent to :
list->prev = item
Thus list prev field changes and next instruction in the macro
(list->prev)->next = item
became :
item->next = item
And you endup with list corruption, other case lead to similar
list corruption. Inline function are not affected by this short
coming

Signed-off-by: Jerome Glisse <jglisse@redhat.com>
This commit is contained in:
Jerome Glisse
2011-03-28 17:45:31 -04:00
parent dcad6fb670
commit ebe304fa54
1 changed files with 62 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/auxiliary/util/u_double_list.h
+62 -38
View File
@@ -39,6 +39,7 @@
#include <stddef.h> #include <stddef.h>
#include "pipe/p_compiler.h"
struct list_head struct list_head
@@ -47,50 +48,56 @@ struct list_head
struct list_head *next; struct list_head *next;
}; };
static INLINE void list_inithead(struct list_head *item)
{
item->prev = item;
item->next = item;
}
#define LIST_INITHEAD(__item) \ static INLINE void list_add(struct list_head *item, struct list_head *list)
do { \ {
(__item)->prev = (__item); \ item->prev = list;
(__item)->next = (__item); \ item->next = list->next;
} while (0) list->next->prev = item;
list->next = item;
}
#define LIST_ADD(__item, __list) \ static INLINE void list_addtail(struct list_head *item, struct list_head *list)
do { \ {
(__item)->prev = (__list); \ item->next = list;
(__item)->next = (__list)->next; \ item->prev = list->prev;
(__list)->next->prev = (__item); \ list->prev->next = item;
(__list)->next = (__item); \ list->prev = item;
} while (0) }
#define LIST_ADDTAIL(__item, __list) \ static INLINE void list_replace(struct list_head *from, struct list_head *to)
do { \ {
(__item)->next = (__list); \ to->prev = from->prev;
(__item)->prev = (__list)->prev; \ to->next = from->next;
(__list)->prev->next = (__item); \ from->next->prev = to;
(__list)->prev = (__item); \ from->prev->next = to;
} while(0) }
#define LIST_REPLACE(__from, __to) \ static INLINE void list_del(struct list_head *item)
do { \ {
(__to)->prev = (__from)->prev; \ item->prev->next = item->next;
(__to)->next = (__from)->next; \ item->next->prev = item->prev;
(__from)->next->prev = (__to); \ }
(__from)->prev->next = (__to); \
} while (0)
#define LIST_DEL(__item) \ static INLINE void list_delinit(struct list_head *item)
do { \ {
(__item)->prev->next = (__item)->next; \ item->prev->next = item->next;
(__item)->next->prev = (__item)->prev; \ item->next->prev = item->prev;
} while(0) item->next = item;
item->prev = item;
}
#define LIST_DELINIT(__item) \ #define LIST_INITHEAD(__item) list_inithead(__item)
do { \ #define LIST_ADD(__item, __list) list_add(__item, __list)
(__item)->prev->next = (__item)->next; \ #define LIST_ADDTAIL(__item, __list) list_addtail(__item, __list)
(__item)->next->prev = (__item)->prev; \ #define LIST_REPLACE(__from, __to) list_replace(__from, __to)
(__item)->next = (__item); \ #define LIST_DEL(__item) list_del(__item)
(__item)->prev = (__item); \ #define LIST_DELINIT(__item) list_delinit(__item)
} while(0)
#define LIST_ENTRY(__type, __item, __field) \ #define LIST_ENTRY(__type, __item, __field) \
((__type *)(((char *)(__item)) - offsetof(__type, __field))) ((__type *)(((char *)(__item)) - offsetof(__type, __field)))
@@ -114,4 +121,21 @@ struct list_head
storage = container_of(pos->member.next, pos, member); \ storage = container_of(pos->member.next, pos, member); \
&pos->member != (head); \ &pos->member != (head); \
pos = storage, storage = container_of(storage->member.next, storage, member)) pos = storage, storage = container_of(storage->member.next, storage, member))
#define LIST_FOR_EACH_ENTRY_SAFE_REV(pos, storage, head, member) \
for (pos = container_of((head)->prev, pos, member), \
storage = container_of(pos->member.prev, pos, member); \
&pos->member != (head); \
pos = storage, storage = container_of(storage->member.prev, storage, member))
#define LIST_FOR_EACH_ENTRY_FROM(pos, start, head, member) \
for (pos = container_of((start), pos, member); \
&pos->member != (head); \
pos = container_of(pos->member.next, pos, member))
#define LIST_FOR_EACH_ENTRY_FROM_REV(pos, start, head, member) \
for (pos = container_of((start), pos, member); \
&pos->member != (head); \
pos = container_of(pos->member.prev, pos, member))
#endif /*_U_DOUBLE_LIST_H_*/ #endif /*_U_DOUBLE_LIST_H_*/