logo

drewdevault.com

[mirror] blog and personal website of Drew DeVault git clone https://hacktivis.me/git/mirror/drewdevault.com.git

Limited-generics-in-C.md (3402B)

    

  1. ---
  2. date: 2017-06-05
  3. layout: post
  4. title: Limited "generics" in C without macros or UB
  5. tags: [C]
  6. ---
  8. I should start this post off by clarifying that what I have to show you today is
  9. not, in fact, generics. However, it's useful in some situations to solve the
  10. same problems that generics might. This is a pattern I've started using to
  11. reduce the number of `void*` pointers floating around in my code: multiple
  12. definitions of a struct.
  14. **Errata**: we rolled this approach back in wlroots because it causes problems
  15. with LTO. I no longer recommend it.
  17. Let's take a look at a specific example. In
  18. [wlroots](https://github.com/SirCmpwn/wlroots), `wlr_output` is a generic type
  19. that can be implemented by any number of backends, like DRM (direct rendering
  20. manager), wayland windows, X11 windows, RDP outputs, etc. The `wlr/types.h`
  21. header includes this structure:
  23. ```c
  24. struct wlr_output_impl;
  25. struct wlr_output_state;
  27. struct wlr_output {
  28.     const struct wlr_output_impl *impl;
  29.     struct wlr_output_state *state;
  30.     // [...]
  31. };
  33. void wlr_output_enable(struct wlr_output *output, bool enable);
  34. bool wlr_output_set_mode(struct wlr_output *output,
  35.     struct wlr_output_mode *mode);
  36. void wlr_output_destroy(struct wlr_output *output);
  37. ```
  39. `wlr_output_impl` is defined elsewhere:
  41. ```c
  42. struct wlr_output_impl {
  43.     void (*enable)(struct wlr_output_state *state, bool enable);
  44.     bool (*set_mode)(struct wlr_output_state *state,
  45.         struct wlr_output_mode *mode);
  46.     void (*destroy)(struct wlr_output_state *state);
  47. };
  49. struct wlr_output *wlr_output_create(struct wlr_output_impl *impl,
  50.         struct wlr_output_state *state);
  51. void wlr_output_free(struct wlr_output *output);
  52. ```
  54. Nowhere, however, is `wlr_output_state` defined. It's left an incomplete type
  55. throughout all of the common `wlr_output` code. The "generic" part is that each
  56. output implementation, in its own private headers, defines the
  57. `wlr_output_state` struct for itself, like the DRM backend:
  59. ```c
  60. struct wlr_output_state {
  61.     uint32_t connector;
  62.     char name[16];
  63.     uint32_t crtc;
  64.     drmModeCrtc *old_crtc;
  65.     struct wlr_drm_renderer *renderer;
  66.     struct gbm_surface *gbm;
  67.     EGLSurface *egl;
  68.     bool pageflip_pending;
  69.     enum wlr_drm_output_state state;
  70.     // [...]
  71. };
  72. ```
  74. This allows implementations of the `enable`, `set_mode`, and `destroy` functions
  75. to avoid casting a `void*` to the appropriate type:
  77. ```c
  78. static struct wlr_output_impl output_impl = {
  79.     .enable = wlr_drm_output_enable,
  80.     // [...]
  81. };
  83. static void wlr_drm_output_enable(struct wlr_output_state *output,
  84.         bool enable) {
  85.     struct wlr_backend_state *state =
  86.         wl_container_of(output->renderer, state, renderer);
  87.     if (output->state != DRM_OUTPUT_CONNECTED) {
  88.         return;
  89.     }
  90.     if (enable) {
  91.         drmModeConnectorSetProperty(state->fd,
  92.             output->connector,
  93.             output->props.dpms,
  94.             DRM_MODE_DPMS_ON);
  95.         // [...]
  96.     } else {
  97.         drmModeConnectorSetProperty(state->fd,
  98.             output->connector,
  99.             output->props.dpms,
  100.             DRM_MODE_DPMS_STANDBY);
  101.     }
  102. }
  104. // [...]
  105. struct wlr_output output = wlr_output_create(&output_impl, output);
  106. ```
  108. The limitations of this approach are apparent: you cannot work with multiple
  109. definitions of `wlr_output_state` in the same file. However, you get improved
  110. type safety, have to write less code, and improve readability.