Changes in / [78f0422c:71b4444] in mainline


Ignore:
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • abi/include/_bits/decls.h

    r78f0422c r71b4444  
    6161#endif  /* __cplusplus */
    6262
    63 /*
    64  * __CONSTEXPR for headers shared by C and C++. Headers that are purely for
    65  * C++ sources should use constexpr directly.
    66  */
    67 #ifdef __cplusplus
    68 #define __CONSTEXPR constexpr
    69 #else
    70 #define __CONSTEXPR
    71 #endif
    72 
    7363#endif
    7464

  • abi/include/_bits/uchar.h

    r78f0422c r71b4444  
    3838#include <stdint.h>
    3939
    40 /*
    41  * char8_t became part of C++ with C++20.
    42  * It is part of C23 hence we define it for C compilations only.
    43  */
    44 #ifndef __cplusplus
    4540typedef uint8_t char8_t;
    46 #endif
    47 
    4841typedef uint32_t char32_t;
    4942

  • kernel/generic/src/interrupt/interrupt.c

    r78f0422c r71b4444  
    5858#include <trace.h>
    5959
    60 /*
    61  * If IVT_ITEMS is zero (e.g. for special/abs32le) we hide completely any
    62  * access to the exception table array and panic if the function is called
    63  * at all. It also silences (correct) compiler warnings about possible
    64  * out-of-bound array access.
    65  */
    66 
    6760exc_table_t exc_table[IVT_ITEMS];
    6861IRQ_SPINLOCK_INITIALIZE(exctbl_lock);
    … …  
    8477#if (IVT_ITEMS > 0)
    8578        assert(n < IVT_ITEMS);
     79#endif
    8680
    8781        irq_spinlock_lock(&exctbl_lock, true);
    … …  
    9791
    9892        return old;
    99 #else
    100         panic("No space for any exception handler, cannot register.");
    101 #endif
    10293}
    10394
    … …  
    112103#if (IVT_ITEMS > 0)
    113104        assert(n < IVT_ITEMS);
     105#endif
    114106
    115107        /* Account user cycles */
    … …  
    160152                irq_spinlock_unlock(&THREAD->lock, false);
    161153        }
    162 #else
    163         panic("No space for any exception handler, yet we want to handle some exception.");
    164 #endif
    165154}
    166155

  • uspace/app/tester/fault/fault1.c

    r78f0422c r71b4444  
    3030#include "../tester.h"
    3131
    32 #pragma GCC diagnostic ignored "-Warray-bounds"
    33 
    3432const char *test_fault1(void)
    3533{

  • uspace/app/tester/print/print5.c

    r78f0422c r71b4444  
    3838 */
    3939#pragma GCC diagnostic ignored "-Wformat"
    40 #pragma GCC diagnostic ignored "-Wformat-overflow"
    4140
    4241#include <stdio.h>

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

    r78f0422c r71b4444  
    135135        modules_untag(start->rtld);
    136136
    137         /*
    138          * Insert root (the program) into the queue and tag it.
    139          *
    140          * We disable the dangling-pointer warning because the compiler incorrectly
    141          * assumes that we leak local address (queue) to a parent scope (to start
    142          * argument). However, we always empty the list so the pointer cannot
    143          * actually escape. Probably the compiler can never statically analyze that
    144          * correctly.
    145          */
     137        /* Insert root (the program) into the queue and tag it */
    146138        list_initialize(&queue);
    147139        start->bfs_tag = true;
    148 #pragma GCC diagnostic push
    149 #if defined(__GNUC__) && (__GNUC__ >= 12)
    150 #pragma GCC diagnostic ignored "-Wdangling-pointer"
    151 #endif
    152140        list_append(&start->queue_link, &queue);
    153 #pragma GCC diagnostic pop
    154141
    155142        /* If the symbol is found, it will be stored in 'sym' */

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

    r78f0422c r71b4444  
    160160{
    161161        check_fibril_for_deadlock(oi, fibril_self());
     162}
     163
     164void fibril_mutex_initialize(fibril_mutex_t *fm)
     165{
     166        fm->oi.owned_by = NULL;
     167        fm->counter = 1;
     168        list_initialize(&fm->waiters);
    162169}
    163170

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

    r78f0422c r71b4444  
    183183 *
    184184 */
    185 _NO_TRACE static inline __CONSTEXPR void list_initialize(list_t *list)
     185_NO_TRACE static inline void list_initialize(list_t *list)
    186186{
    187187        list->head.prev = &list->head;

  • uspace/lib/c/include/fibril_synch.h

    r78f0422c r71b4444  
    153153extern void __fibril_synch_fini(void);
    154154
    155 /** Initialize fibril mutex.
    156  *
    157  * Kept as in-line to allow constexpr marker for C++ library where this
    158  * is used by C++ mutex type (list initialization are two assignments
    159  * so it is actually reasonable to have this inlined).
    160  */
    161 static inline __CONSTEXPR void fibril_mutex_initialize(fibril_mutex_t *fm)
    162 {
    163         fm->oi.owned_by = NULL;
    164         fm->counter = 1;
    165         list_initialize(&fm->waiters);
    166 }
    167 
     155extern void fibril_mutex_initialize(fibril_mutex_t *);
    168156extern void fibril_mutex_lock(fibril_mutex_t *);
    169157extern bool fibril_mutex_trylock(fibril_mutex_t *);

  • uspace/lib/c/test/string.c

    r78f0422c r71b4444  
    799799PCUT_TEST(strndup_nonempty_short)
    800800{
    801 #pragma GCC diagnostic push
    802         // Intentionally checking it works with _longer_ size than actual
    803 #if defined(__GNUC__) && (__GNUC__ >= 11)
    804 #pragma GCC diagnostic ignored "-Wstringop-overread"
    805 #endif
    806801        char *d = strndup("abc", 5);
    807 #pragma GCC diagnostic pop
    808802        PCUT_ASSERT_NOT_NULL(d);
    809803        PCUT_ASSERT_TRUE(d[0] == 'a');

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

    r78f0422c r71b4444  
    11101110                                 InputIterator2 last2)
    11111111    {
    1112         while ((first1 != last1) && (first2 != last2))
    1113         {
    1114             if (*first1 < *first2)
    1115                 return true;
    1116             if (*first2 < *first1)
    1117                 return false;
    1118 
    1119             ++first1;
    1120             ++first2;
    1121         }
    1122 
    11231112        /**
    1124          * Up until now they are same, so we have to check
    1125          * if we reached the end on one.
     1113         * *first1 and *first2 can have different types
     1114         * so we use a transparent comparator.
    11261115         */
    1127         return (first1 == last1) && (first2 != last2);
     1116        return lexicographical_compare(
     1117            first1, last1, first2, last2,
     1118            less<void>{}
     1119        );
    11281120    }
    11291121

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

    r78f0422c r71b4444  
    8787        struct mutex
    8888        {
    89             static constexpr void init(mutex_type& mtx)
     89            static void init(mutex_type& mtx)
    9090            {
    9191                ::helenos::fibril_mutex_initialize(&mtx);

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

    r78f0422c r71b4444  
    11091109        PCUT_ASSERT_EQUALS(wnd->display->cursor[dcurs_arrow], wnd->cursor);
    11101110
    1111         // Check that invalid cursors cannot be set: ignore enum conversions
    1112         // as we are out-of-bounds
    1113 #pragma GCC diagnostic push
    1114 #if defined(__GNUC__) && (__GNUC__ >= 10)
    1115 #pragma GCC diagnostic ignored "-Wenum-conversion"
    1116 #endif
    11171111        rc = ds_window_set_cursor(wnd, dcurs_limit);
    11181112        PCUT_ASSERT_ERRNO_VAL(EINVAL, rc);
    … …  
    11221116        PCUT_ASSERT_ERRNO_VAL(EINVAL, rc);
    11231117        PCUT_ASSERT_EQUALS(wnd->display->cursor[dcurs_arrow], wnd->cursor);
    1124 #pragma GCC diagnostic pop
    11251118
    11261119        rc = ds_window_set_cursor(wnd, dcurs_size_lr);
Note: See TracChangeset for help on using the changeset viewer.