commit 21bf530

Use static assertion to ensure types are castable, instead of container_of

1@@ -60,7 +60,7 @@ void wld_draw_text_utf8_n(struct wld_drawable * drawable,
2                           int32_t x, int32_t y,
3                           const char * text, int32_t length)
4 {
5-    struct font * font = container_of(font_base, typeof(*font), base);
6+    struct font * font = (void *) font_base;
7 
8     drawable->interface->draw_text_utf8(drawable, font, color, x, y,
9                                         text, length);

 1@@ -49,6 +49,9 @@ struct drm_drawable
 2     uint32_t name;
 3 };
 4 
 5+_Static_assert(offsetof(struct drm_drawable, base) == 0,
 6+               "Non-zero offset of base field");
 7+
 8 #if ENABLE_INTEL
 9 extern const struct wld_drm_interface intel_drm;
10 #endif

 1@@ -152,7 +152,7 @@ struct wld_font * wld_font_open_pattern(struct wld_font_context * context,
 2 
 3 void wld_font_close(struct wld_font * font_base)
 4 {
 5-    struct font * font = container_of(font_base, typeof(*font), base);
 6+    struct font * font = (void *) font_base;
 7 
 8     FT_Done_Face(font->face);
 9     free(font);
10@@ -194,7 +194,7 @@ bool font_ensure_glyph(struct font * font, FT_UInt glyph_index)
11 
12 bool wld_font_ensure_char(struct wld_font * font_base, uint32_t character)
13 {
14-    struct font * font = container_of(font_base, typeof(*font), base);
15+    struct font * font = (void *) font_base;
16     FT_UInt glyph_index;
17 
18     glyph_index = FT_Get_Char_Index(font->face, character);
19@@ -206,7 +206,7 @@ void wld_font_text_extents_utf8_n(struct wld_font * font_base,
20                                   const char * text, int32_t length,
21                                   struct wld_extents * extents)
22 {
23-    struct font * font = container_of(font_base, typeof(*font), base);
24+    struct font * font = (void *) font_base;
25     int ret;
26     uint32_t c;
27     FT_UInt glyph_index;

 1@@ -45,6 +45,9 @@ struct intel_drawable
 2     drm_intel_bo * bo;
 3 };
 4 
 5+_Static_assert(offsetof(struct intel_drawable, drm) == 0,
 6+               "Non-zero offset of base field");
 7+
 8 static void intel_fill_rectangle(struct wld_drawable * drawable, uint32_t color,
 9                           pixman_rectangle16_t * rectangle);
10 static void intel_draw_text_utf8(struct wld_drawable * drawable,
11@@ -124,9 +127,8 @@ struct wld_drawable * wld_intel_create_drawable
12 void intel_fill_rectangle(struct wld_drawable * drawable, uint32_t color,
13                           pixman_rectangle16_t * rectangle)
14 {
15-    struct intel_drawable * intel;
16+    struct intel_drawable * intel = (void *) drawable;
17 
18-    intel = container_of(drawable, typeof(*intel), drm.base);
19     xy_color_blt(&intel->context->batch, intel->bo, intel->drm.pitch,
20                  rectangle->x, rectangle->y,
21                  rectangle->x + rectangle->width,
22@@ -138,7 +140,7 @@ void intel_draw_text_utf8(struct wld_drawable * drawable,
23                           int32_t x, int32_t y,
24                           const char * text, int32_t length)
25 {
26-    struct intel_drawable * intel;
27+    struct intel_drawable * intel = (void *) drawable;
28     int ret;
29     struct glyph * glyph;
30     uint32_t row;
31@@ -148,8 +150,6 @@ void intel_draw_text_utf8(struct wld_drawable * drawable,
32     uint8_t * byte;
33     uint8_t byte_index;
34 
35-    intel = container_of(drawable, typeof(*intel), drm.base);
36-
37     /* For some reason the text doesn't render if we don't flush the command
38      * buffer first. */
39     intel_batch_flush(&intel->context->batch);
40@@ -195,17 +195,14 @@ void intel_draw_text_utf8(struct wld_drawable * drawable,
41 
42 void intel_flush(struct wld_drawable * drawable)
43 {
44-    struct intel_drawable * intel;
45+    struct intel_drawable * intel = (void *) drawable;
46 
47-    intel = container_of(drawable, typeof(*intel), drm.base);
48     intel_batch_flush(&intel->context->batch);
49 }
50 
51 void intel_destroy(struct wld_drawable * drawable)
52 {
53-    struct intel_drawable * intel;
54-
55-    intel = container_of(drawable, typeof(*intel), drm.base);
56+    struct intel_drawable * intel = (void *) drawable;
57     drm_intel_bo_unreference(intel->bo);
58     free(intel);
59 }

 1@@ -43,6 +43,9 @@ struct pixman_drawable
 2     struct wld_pixman_context * context;
 3 };
 4 
 5+_Static_assert(offsetof(struct pixman_drawable, base) == 0,
 6+               "Non-zero offset of base field");
 7+
 8 static void pixman_fill_rectangles(struct wld_drawable * drawable,
 9                                    uint32_t color,
10                                    pixman_rectangle16_t * rectangles,
11@@ -130,10 +133,9 @@ static void pixman_fill_rectangles(struct wld_drawable * drawable,
12                                    pixman_rectangle16_t * rectangles,
13                                    uint32_t num_rectangles)
14 {
15-    struct pixman_drawable * pixman;
16+    struct pixman_drawable * pixman = (void *) drawable;
17     pixman_color_t pixman_color = PIXMAN_COLOR(color);
18 
19-    pixman = container_of(drawable, typeof(*pixman), base);
20     pixman_image_fill_rectangles(PIXMAN_OP_SRC, pixman->image, &pixman_color,
21                                  num_rectangles, rectangles);
22 }
23@@ -152,7 +154,7 @@ static void pixman_draw_text_utf8(struct wld_drawable * drawable,
24                                   int32_t x, int32_t y,
25                                   const char * text, int32_t length)
26 {
27-    struct pixman_drawable * pixman;
28+    struct pixman_drawable * pixman = (void *) drawable;
29     int ret;
30     uint32_t c;
31     struct glyph * glyph;
32@@ -162,7 +164,6 @@ static void pixman_draw_text_utf8(struct wld_drawable * drawable,
33     pixman_color_t pixman_color = PIXMAN_COLOR(color);
34     pixman_image_t * solid;
35 
36-    pixman = container_of(drawable, typeof(*pixman), base);
37     solid = pixman_image_create_solid_fill(&pixman_color);
38 
39     while ((ret = FcUtf8ToUcs4((FcChar8 *) text, &c, length)) > 0 && c != '\0')
40@@ -239,9 +240,8 @@ static void pixman_draw_text_utf8(struct wld_drawable * drawable,
41 
42 void pixman_destroy(struct wld_drawable * drawable)
43 {
44-    struct pixman_drawable * pixman;
45+    struct pixman_drawable * pixman = (void *) drawable;
46 
47-    pixman = container_of(drawable, typeof(*pixman), base);
48     pixman_image_unref(pixman->image);
49     free(pixman);
50 }

 1@@ -50,6 +50,9 @@ struct wayland_drawable
 2     uint8_t front_buffer;
 3 };
 4 
 5+_Static_assert(offsetof(struct wayland_drawable, base) == 0,
 6+               "Non-zero offset of base field");
 7+
 8 static void callback_done(void * data, struct wl_callback * callback,
 9                           uint32_t msecs);
10 
11@@ -239,9 +242,8 @@ void callback_done(void * data, struct wl_callback * callback, uint32_t msecs)
12 void wayland_fill_rectangle(struct wld_drawable * drawable, uint32_t color,
13                             pixman_rectangle16_t * rectangle)
14 {
15-    struct wayland_drawable * wayland;
16+    struct wayland_drawable * wayland = (void *) drawable;
17 
18-    wayland = container_of(drawable, typeof(*wayland), base);
19     wld_fill_rectangle(BACKBUF(wayland).drawable, color, rectangle);
20 }
21 
22@@ -249,9 +251,8 @@ void wayland_fill_rectangles(struct wld_drawable * drawable, uint32_t color,
23                              pixman_rectangle16_t * rectangles,
24                              uint32_t num_rectangles)
25 {
26-    struct wayland_drawable * wayland;
27+    struct wayland_drawable * wayland = (void *) drawable;
28 
29-    wayland = container_of(drawable, typeof(*wayland), base);
30     wld_fill_rectangles(BACKBUF(wayland).drawable, color,
31                         rectangles, num_rectangles);
32 }
33@@ -261,18 +262,15 @@ void wayland_draw_text_utf8(struct wld_drawable * drawable,
34                             int32_t x, int32_t y,
35                             const char * text, int32_t length)
36 {
37-    struct wayland_drawable * wayland;
38+    struct wayland_drawable * wayland = (void *) drawable;
39 
40-    wayland = container_of(drawable, typeof(*wayland), base);
41     wld_draw_text_utf8_n(BACKBUF(wayland).drawable, &font->base, color,
42                          x, y, text, length);
43 }
44 
45 void wayland_flush(struct wld_drawable * drawable)
46 {
47-    struct wayland_drawable * wayland;
48-
49-    wayland = container_of(drawable, typeof(*wayland), base);
50+    struct wayland_drawable * wayland = (void *) drawable;
51 
52     wld_flush(BACKBUF(wayland).drawable);
53     wl_surface_attach(wayland->surface, BACKBUF(wayland).buffer, 0, 0);
54@@ -282,9 +280,8 @@ void wayland_flush(struct wld_drawable * drawable)
55 
56 void wayland_destroy(struct wld_drawable * drawable)
57 {
58-    struct wayland_drawable * wayland;
59+    struct wayland_drawable * wayland = (void *) drawable;
60 
61-    wayland = container_of(drawable, typeof(*wayland), base);
62     wl_buffer_destroy(wayland->buffers[0].buffer);
63     wl_buffer_destroy(wayland->buffers[1].buffer);
64     wld_destroy_drawable(wayland->buffers[0].drawable);

 1@@ -36,11 +36,6 @@
 2 #   define offsetof __builtin_offsetof
 3 #endif
 4 
 5-#define container_of(ptr, type, member) ({                                  \
 6-    const typeof(((type *) 0)->member) *__mptr = (ptr);                     \
 7-    ((type *) ((uintptr_t) __mptr - offsetof(type, member)));               \
 8-})
 9-
10 #define ARRAY_LENGTH(array) (sizeof (array) / sizeof (array)[0])
11 #if ENABLE_DEBUG
12 #   define DEBUG(format, args...) \
13@@ -78,6 +73,9 @@ struct font
14     struct glyph ** glyphs;
15 };
16 
17+_Static_assert(offsetof(struct font, base) == 0,
18+               "Non-zero offset of base field");
19+
20 struct wld_draw_interface
21 {
22     void (* fill_rectangle)(struct wld_drawable * drawable, uint32_t color,