static-destruct: several cleanups

No functional changes, preparation for later commits.

diff --git a/src/basic/static-destruct.h b/src/basic/static-destruct.h
index 97baac7abb0c07568e317f1425ccd9856c88afa8..4bc82889be324c5c23ebeb20cd09fccfffa5cefb 100644 (file)
--- a/src/basic/static-destruct.h
+++ b/src/basic/static-destruct.h
@@ -10,6 +10,21 @@
  * feel a bit like the gcc cleanup attribute, but for static variables. Note that this does not work for static
  * variables declared in .so's, as the list is private to the same linking unit. But maybe that's a good thing. */
 
+#define _common_static_destruct_attrs_                                  \
+        /* Older compilers don't know "retain" attribute. */            \
+        _Pragma("GCC diagnostic ignored \"-Wattributes\"")              \
+        /* The actual destructor structure we place in a special section to find it. */ \
+        _section_("SYSTEMD_STATIC_DESTRUCT")                            \
+        /* Use pointer alignment, since that is apparently what gcc does for static variables. */ \
+        _alignptr_                                                      \
+        /* Make sure this is not dropped from the image despite not being explicitly referenced. */ \
+        _used_                                                          \
+        /* Prevent garbage collection by the linker. */                 \
+        _retain_                                                        \
+        /* Make sure that AddressSanitizer doesn't pad this variable: we want everything in this section
+         * packed next to each other so that we can enumerate it. */    \
+        _variable_no_sanitize_address_
+
 typedef struct StaticDestructor {
         void *data;
         free_func_t destroy;
@@ -24,19 +39,7 @@ typedef struct StaticDestructor {
                 typeof(variable) *q = p;                                \
                 func(q);                                                \
         }                                                               \
-        /* Older compilers don't know "retain" attribute. */            \
-        _Pragma("GCC diagnostic ignored \"-Wattributes\"")              \
-        /* The actual destructor structure we place in a special section to find it. */ \
-        _section_("SYSTEMD_STATIC_DESTRUCT")                            \
-        /* Use pointer alignment, since that is apparently what gcc does for static variables. */ \
-        _alignptr_                                                      \
-        /* Make sure this is not dropped from the image despite not being explicitly referenced. */ \
-        _used_                                                          \
-        /* Prevent garbage collection by the linker. */                 \
-        _retain_                                                        \
-        /* Make sure that AddressSanitizer doesn't pad this variable: we want everything in this section
-         * packed next to each other so that we can enumerate it. */     \
-        _variable_no_sanitize_address_                                  \
+        _common_static_destruct_attrs_                                  \
         static const StaticDestructor UNIQ_T(static_destructor_entry, uq) = { \
                 .data = &(variable),                                    \
                 .destroy = UNIQ_T(static_destructor_wrapper, uq),       \
@@ -44,20 +47,17 @@ typedef struct StaticDestructor {
 
 /* Beginning and end of our section listing the destructors. We define these as weak as we want this to work
  * even if no destructors are defined and the section is missing. */
-extern const struct StaticDestructor _weak_ __start_SYSTEMD_STATIC_DESTRUCT[];
-extern const struct StaticDestructor _weak_ __stop_SYSTEMD_STATIC_DESTRUCT[];
+extern const StaticDestructor _weak_ __start_SYSTEMD_STATIC_DESTRUCT[];
+extern const StaticDestructor _weak_ __stop_SYSTEMD_STATIC_DESTRUCT[];
 
 /* The function to destroy everything. (Note that this must be static inline, as it's key that it remains in
  * the same linking unit as the variables we want to destroy.) */
 static inline void static_destruct(void) {
-        const StaticDestructor *d;
-
         if (!__start_SYSTEMD_STATIC_DESTRUCT)
                 return;
 
-        d = ALIGN_PTR(__start_SYSTEMD_STATIC_DESTRUCT);
-        while (d < __stop_SYSTEMD_STATIC_DESTRUCT) {
+        for (const StaticDestructor *d = ALIGN_PTR(__start_SYSTEMD_STATIC_DESTRUCT);
+             d < __stop_SYSTEMD_STATIC_DESTRUCT;
+             d = ALIGN_PTR(d + 1))
                 d->destroy(d->data);
-                d = ALIGN_PTR(d + 1);
-        }
 }