Changeset 78f0422c in mainline

Timestamp:

2023-10-22T17:27:09Z (13 months ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

133461c

Parents:

71b4444 (diff), dfb16c4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge C/C++ changes needed to build with newer GCC

Files:

• abi/include/_bits/decls.h (modified) (1 diff)
• abi/include/_bits/uchar.h (modified) (1 diff)
• kernel/generic/src/interrupt/interrupt.c (modified) (5 diffs)
• uspace/app/tester/fault/fault1.c (modified) (1 diff)
• uspace/app/tester/print/print5.c (modified) (1 diff)
• uspace/lib/c/generic/rtld/symbol.c (modified) (1 diff)
• uspace/lib/c/generic/thread/fibril_synch.c (modified) (1 diff)
• uspace/lib/c/include/adt/list.h (modified) (1 diff)
• uspace/lib/c/include/fibril_synch.h (modified) (1 diff)
• uspace/lib/c/test/string.c (modified) (1 diff)
• uspace/lib/cpp/include/__bits/algorithm.hpp (modified) (1 diff)
• uspace/lib/cpp/include/__bits/thread/threading.hpp (modified) (1 diff)
• uspace/srv/hid/display/test/window.c (modified) (2 diffs)

abi/include/_bits/decls.h

@@ -61 +61 @@
 #endif  /* __cplusplus */
 
+/*
+ * __CONSTEXPR for headers shared by C and C++. Headers that are purely for
+ * C++ sources should use constexpr directly.
+ */
+#ifdef __cplusplus
+#define __CONSTEXPR constexpr
+#else
+#define __CONSTEXPR
+#endif
+
 #endif
 

abi/include/_bits/uchar.h

@@ -38 +38 @@
 #include <stdint.h>
 
+/*
+ * char8_t became part of C++ with C++20.
+ * It is part of C23 hence we define it for C compilations only.
+ */
+#ifndef __cplusplus
 typedef uint8_t char8_t;
+#endif
+
 typedef uint32_t char32_t;
 

kernel/generic/src/interrupt/interrupt.c

@@ -58 +58 @@
 #include <trace.h>
 
+/*
+ * If IVT_ITEMS is zero (e.g. for special/abs32le) we hide completely any
+ * access to the exception table array and panic if the function is called
+ * at all. It also silences (correct) compiler warnings about possible
+ * out-of-bound array access.
+ */
+
 exc_table_t exc_table[IVT_ITEMS];
 IRQ_SPINLOCK_INITIALIZE(exctbl_lock);
@@ -77 +84 @@
 #if (IVT_ITEMS > 0)
         assert(n < IVT_ITEMS);
-#endif
 
         irq_spinlock_lock(&exctbl_lock, true);
@@ -91 +97 @@
 
         return old;
+#else
+        panic("No space for any exception handler, cannot register.");
+#endif
 }
 
@@ -103 +112 @@
 #if (IVT_ITEMS > 0)
         assert(n < IVT_ITEMS);
-#endif
 
         /* Account user cycles */
@@ -152 +160 @@
                 irq_spinlock_unlock(&THREAD->lock, false);
         }
+#else
+        panic("No space for any exception handler, yet we want to handle some exception.");
+#endif
 }
 

uspace/app/tester/fault/fault1.c

@@ -30 +30 @@
 #include "../tester.h"
 
+#pragma GCC diagnostic ignored "-Warray-bounds"
+
 const char *test_fault1(void)
 {

uspace/app/tester/print/print5.c

@@ -38 +38 @@
  */
 #pragma GCC diagnostic ignored "-Wformat"
+#pragma GCC diagnostic ignored "-Wformat-overflow"
 
 #include <stdio.h>

uspace/lib/c/generic/rtld/symbol.c

@@ -135 +135 @@
         modules_untag(start->rtld);
 
-        /* Insert root (the program) into the queue and tag it */
+        /*
+         * Insert root (the program) into the queue and tag it.
+         *
+         * We disable the dangling-pointer warning because the compiler incorrectly
+         * assumes that we leak local address (queue) to a parent scope (to start
+         * argument). However, we always empty the list so the pointer cannot
+         * actually escape. Probably the compiler can never statically analyze that
+         * correctly.
+         */
         list_initialize(&queue);
         start->bfs_tag = true;
+#pragma GCC diagnostic push
+#if defined(__GNUC__) && (__GNUC__ >= 12)
+#pragma GCC diagnostic ignored "-Wdangling-pointer"
+#endif
         list_append(&start->queue_link, &queue);
+#pragma GCC diagnostic pop
 
         /* If the symbol is found, it will be stored in 'sym' */

uspace/lib/c/generic/thread/fibril_synch.c

@@ -160 +160 @@
 {
         check_fibril_for_deadlock(oi, fibril_self());
-}
-
-void fibril_mutex_initialize(fibril_mutex_t *fm)
-{
-        fm->oi.owned_by = NULL;
-        fm->counter = 1;
-        list_initialize(&fm->waiters);
 }
 

uspace/lib/c/include/adt/list.h

@@ -183 +183 @@
  *
  */
-_NO_TRACE static inline void list_initialize(list_t *list)
+_NO_TRACE static inline __CONSTEXPR void list_initialize(list_t *list)
 {
         list->head.prev = &list->head;

uspace/lib/c/include/fibril_synch.h

@@ -153 +153 @@
 extern void __fibril_synch_fini(void);
 
-extern void fibril_mutex_initialize(fibril_mutex_t *);
+/** Initialize fibril mutex.
+ *
+ * Kept as in-line to allow constexpr marker for C++ library where this
+ * is used by C++ mutex type (list initialization are two assignments
+ * so it is actually reasonable to have this inlined).
+ */
+static inline __CONSTEXPR void fibril_mutex_initialize(fibril_mutex_t *fm)
+{
+        fm->oi.owned_by = NULL;
+        fm->counter = 1;
+        list_initialize(&fm->waiters);
+}
+
 extern void fibril_mutex_lock(fibril_mutex_t *);
 extern bool fibril_mutex_trylock(fibril_mutex_t *);

uspace/lib/c/test/string.c

@@ -799 +799 @@
 PCUT_TEST(strndup_nonempty_short)
 {
+#pragma GCC diagnostic push
+        // Intentionally checking it works with _longer_ size than actual
+#if defined(__GNUC__) && (__GNUC__ >= 11)
+#pragma GCC diagnostic ignored "-Wstringop-overread"
+#endif
         char *d = strndup("abc", 5);
+#pragma GCC diagnostic pop
         PCUT_ASSERT_NOT_NULL(d);
         PCUT_ASSERT_TRUE(d[0] == 'a');

uspace/lib/cpp/include/__bits/algorithm.hpp

@@ -1110 +1110 @@
                                  InputIterator2 last2)
     {
+        while ((first1 != last1) && (first2 != last2))
+        {
+            if (*first1 < *first2)
+                return true;
+            if (*first2 < *first1)
+                return false;
+
+            ++first1;
+            ++first2;
+        }
+
         /**
-         * *first1 and *first2 can have different types
-         * so we use a transparent comparator.
+         * Up until now they are same, so we have to check
+         * if we reached the end on one.
          */
-        return lexicographical_compare(
-            first1, last1, first2, last2,
-            less<void>{}
-        );
+        return (first1 == last1) && (first2 != last2);
     }
 

uspace/lib/cpp/include/__bits/thread/threading.hpp

@@ -87 +87 @@
         struct mutex
         {
-            static void init(mutex_type& mtx)
+            static constexpr void init(mutex_type& mtx)
             {
                 ::helenos::fibril_mutex_initialize(&mtx);

uspace/srv/hid/display/test/window.c

@@ -1109 +1109 @@
         PCUT_ASSERT_EQUALS(wnd->display->cursor[dcurs_arrow], wnd->cursor);
 
+        // Check that invalid cursors cannot be set: ignore enum conversions
+        // as we are out-of-bounds
+#pragma GCC diagnostic push
+#if defined(__GNUC__) && (__GNUC__ >= 10)
+#pragma GCC diagnostic ignored "-Wenum-conversion"
+#endif
         rc = ds_window_set_cursor(wnd, dcurs_limit);
         PCUT_ASSERT_ERRNO_VAL(EINVAL, rc);
@@ -1116 +1122 @@
         PCUT_ASSERT_ERRNO_VAL(EINVAL, rc);
         PCUT_ASSERT_EQUALS(wnd->display->cursor[dcurs_arrow], wnd->cursor);
+#pragma GCC diagnostic pop
 
         rc = ds_window_set_cursor(wnd, dcurs_size_lr);