Re: [RFC PATCH 01/78] include/qemu/compiler.h: replace QEMU_FALLTHROUGH with fallthrough

["Daniel P. Berrangé" <berrange@redhat.com>]

On Fri, Oct 13, 2023 at 10:47:05AM +0300, Emmanouil Pitsidianakis wrote:
> Signed-off-by: Emmanouil Pitsidianakis <manos.pitsidianakis@linaro.org>
> ---
>  audio/pwaudio.c              |  8 ++++----
>  hw/arm/smmuv3.c              |  2 +-
>  include/qemu/compiler.h      | 30 +++++++++++++++++++++++-------
>  include/qemu/osdep.h         |  4 ++--
>  target/loongarch/cpu.c       |  4 ++--
>  target/loongarch/translate.c |  2 +-
>  tcg/optimize.c               |  8 ++++----
>  7 files changed, 37 insertions(+), 21 deletions(-)

This patch (and all the others in the series) have a ridiculously
large context either side of the change. It makes this horrible
to review as it requires wading through pages of pre-existing code
trying to spot the change.

Please send patches with the default git context lines setting.

> 
> diff --git a/audio/pwaudio.c b/audio/pwaudio.c
> index 3ce5f6507b..bf26fadb06 100644
> --- a/audio/pwaudio.c
> +++ b/audio/pwaudio.c
> @@ -1,29 +1,29 @@
>  /*
>   * QEMU PipeWire audio driver
>   *
>   * Copyright (c) 2023 Red Hat Inc.
>   *
>   * Author: Dorinda Bassey       <dbassey@redhat.com>
>   *
>   * SPDX-License-Identifier: GPL-2.0-or-later
>   */
>  
> +#include <spa/param/audio/format-utils.h>
> +#include <spa/utils/ringbuffer.h>
> +#include <spa/utils/result.h>
> +#include <spa/param/props.h>
>  #include "qemu/osdep.h"
>  #include "qemu/module.h"
>  #include "audio.h"
>  #include <errno.h>
>  #include "qemu/error-report.h"
>  #include "qapi/error.h"
> -#include <spa/param/audio/format-utils.h>
> -#include <spa/utils/ringbuffer.h>
> -#include <spa/utils/result.h>
> -#include <spa/param/props.h>
>  
>  #include <pipewire/pipewire.h>
>  #include "trace.h"
>  
>  #define AUDIO_CAP "pipewire"
>  #define RINGBUFFER_SIZE    (1u << 22)
>  #define RINGBUFFER_MASK    (RINGBUFFER_SIZE - 1)
>  
>  #include "audio_int.h"
> diff --git a/hw/arm/smmuv3.c b/hw/arm/smmuv3.c
> index 6f2b2bd45f..545d82ff04 100644
> --- a/hw/arm/smmuv3.c
> +++ b/hw/arm/smmuv3.c
> @@ -1166,210 +1166,210 @@ smmuv3_invalidate_ste(gpointer key, gpointer value, gpointer user_data)
>  static int smmuv3_cmdq_consume(SMMUv3State *s)
>  {
>      SMMUState *bs = ARM_SMMU(s);
>      SMMUCmdError cmd_error = SMMU_CERROR_NONE;
>      SMMUQueue *q = &s->cmdq;
>      SMMUCommandType type = 0;
>  
>      if (!smmuv3_cmdq_enabled(s)) {
>          return 0;
>      }
>      /*
>       * some commands depend on register values, typically CR0. In case those
>       * register values change while handling the command, spec says it
>       * is UNPREDICTABLE whether the command is interpreted under the new
>       * or old value.
>       */
>  
>      while (!smmuv3_q_empty(q)) {
>          uint32_t pending = s->gerror ^ s->gerrorn;
>          Cmd cmd;
>  
>          trace_smmuv3_cmdq_consume(Q_PROD(q), Q_CONS(q),
>                                    Q_PROD_WRAP(q), Q_CONS_WRAP(q));
>  
>          if (FIELD_EX32(pending, GERROR, CMDQ_ERR)) {
>              break;
>          }
>  
>          if (queue_read(q, &cmd) != MEMTX_OK) {
>              cmd_error = SMMU_CERROR_ABT;
>              break;
>          }
>  
>          type = CMD_TYPE(&cmd);
>  
>          trace_smmuv3_cmdq_opcode(smmu_cmd_string(type));
>  
>          qemu_mutex_lock(&s->mutex);
>          switch (type) {
>          case SMMU_CMD_SYNC:
>              if (CMD_SYNC_CS(&cmd) & CMD_SYNC_SIG_IRQ) {
>                  smmuv3_trigger_irq(s, SMMU_IRQ_CMD_SYNC, 0);
>              }
>              break;
>          case SMMU_CMD_PREFETCH_CONFIG:
>          case SMMU_CMD_PREFETCH_ADDR:
>              break;
>          case SMMU_CMD_CFGI_STE:
>          {
>              uint32_t sid = CMD_SID(&cmd);
>              IOMMUMemoryRegion *mr = smmu_iommu_mr(bs, sid);
>              SMMUDevice *sdev;
>  
>              if (CMD_SSEC(&cmd)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
>  
>              if (!mr) {
>                  break;
>              }
>  
>              trace_smmuv3_cmdq_cfgi_ste(sid);
>              sdev = container_of(mr, SMMUDevice, iommu);
>              smmuv3_flush_config(sdev);
>  
>              break;
>          }
>          case SMMU_CMD_CFGI_STE_RANGE: /* same as SMMU_CMD_CFGI_ALL */
>          {
>              uint32_t sid = CMD_SID(&cmd), mask;
>              uint8_t range = CMD_STE_RANGE(&cmd);
>              SMMUSIDRange sid_range;
>  
>              if (CMD_SSEC(&cmd)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
>  
>              mask = (1ULL << (range + 1)) - 1;
>              sid_range.start = sid & ~mask;
>              sid_range.end = sid_range.start + mask;
>  
>              trace_smmuv3_cmdq_cfgi_ste_range(sid_range.start, sid_range.end);
>              g_hash_table_foreach_remove(bs->configs, smmuv3_invalidate_ste,
>                                          &sid_range);
>              break;
>          }
>          case SMMU_CMD_CFGI_CD:
>          case SMMU_CMD_CFGI_CD_ALL:
>          {
>              uint32_t sid = CMD_SID(&cmd);
>              IOMMUMemoryRegion *mr = smmu_iommu_mr(bs, sid);
>              SMMUDevice *sdev;
>  
>              if (CMD_SSEC(&cmd)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
>  
>              if (!mr) {
>                  break;
>              }
>  
>              trace_smmuv3_cmdq_cfgi_cd(sid);
>              sdev = container_of(mr, SMMUDevice, iommu);
>              smmuv3_flush_config(sdev);
>              break;
>          }
>          case SMMU_CMD_TLBI_NH_ASID:
>          {
>              uint16_t asid = CMD_ASID(&cmd);
>  
>              if (!STAGE1_SUPPORTED(s)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
>  
>              trace_smmuv3_cmdq_tlbi_nh_asid(asid);
>              smmu_inv_notifiers_all(&s->smmu_state);
>              smmu_iotlb_inv_asid(bs, asid);
>              break;
>          }
>          case SMMU_CMD_TLBI_NH_ALL:
>              if (!STAGE1_SUPPORTED(s)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
> -            QEMU_FALLTHROUGH;
> +            fallthrough;
>          case SMMU_CMD_TLBI_NSNH_ALL:
>              trace_smmuv3_cmdq_tlbi_nh();
>              smmu_inv_notifiers_all(&s->smmu_state);
>              smmu_iotlb_inv_all(bs);
>              break;
>          case SMMU_CMD_TLBI_NH_VAA:
>          case SMMU_CMD_TLBI_NH_VA:
>              if (!STAGE1_SUPPORTED(s)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
>              smmuv3_range_inval(bs, &cmd);
>              break;
>          case SMMU_CMD_TLBI_S12_VMALL:
>          {
>              uint16_t vmid = CMD_VMID(&cmd);
>  
>              if (!STAGE2_SUPPORTED(s)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
>  
>              trace_smmuv3_cmdq_tlbi_s12_vmid(vmid);
>              smmu_inv_notifiers_all(&s->smmu_state);
>              smmu_iotlb_inv_vmid(bs, vmid);
>              break;
>          }
>          case SMMU_CMD_TLBI_S2_IPA:
>              if (!STAGE2_SUPPORTED(s)) {
>                  cmd_error = SMMU_CERROR_ILL;
>                  break;
>              }
>              /*
>               * As currently only either s1 or s2 are supported
>               * we can reuse same function for s2.
>               */
>              smmuv3_range_inval(bs, &cmd);
>              break;
>          case SMMU_CMD_TLBI_EL3_ALL:
>          case SMMU_CMD_TLBI_EL3_VA:
>          case SMMU_CMD_TLBI_EL2_ALL:
>          case SMMU_CMD_TLBI_EL2_ASID:
>          case SMMU_CMD_TLBI_EL2_VA:
>          case SMMU_CMD_TLBI_EL2_VAA:
>          case SMMU_CMD_ATC_INV:
>          case SMMU_CMD_PRI_RESP:
>          case SMMU_CMD_RESUME:
>          case SMMU_CMD_STALL_TERM:
>              trace_smmuv3_unhandled_cmd(type);
>              break;
>          default:
>              cmd_error = SMMU_CERROR_ILL;
>              break;
>          }
>          qemu_mutex_unlock(&s->mutex);
>          if (cmd_error) {
>              if (cmd_error == SMMU_CERROR_ILL) {
>                  qemu_log_mask(LOG_GUEST_ERROR,
>                                "Illegal command type: %d\n", CMD_TYPE(&cmd));
>              }
>              break;
>          }
>          /*
>           * We only increment the cons index after the completion of
>           * the command. We do that because the SYNC returns immediately
>           * and does not check the completion of previous commands
>           */
>          queue_cons_incr(q);
>      }
>  
>      if (cmd_error) {
>          trace_smmuv3_cmdq_consume_error(smmu_cmd_string(type), cmd_error);
>          smmu_write_cmdq_err(s, cmd_error);
>          smmuv3_trigger_irq(s, SMMU_IRQ_GERROR, R_GERROR_CMDQ_ERR_MASK);
>      }
>  
>      trace_smmuv3_cmdq_consume_out(Q_PROD(q), Q_CONS(q),
>                                    Q_PROD_WRAP(q), Q_CONS_WRAP(q));
>  
>      return 0;
>  }
> diff --git a/include/qemu/compiler.h b/include/qemu/compiler.h
> index 1109482a00..959982805d 100644
> --- a/include/qemu/compiler.h
> +++ b/include/qemu/compiler.h
> @@ -1,215 +1,231 @@
>  /* compiler.h: macros to abstract away compiler specifics
>   *
>   * This work is licensed under the terms of the GNU GPL, version 2 or later.
>   * See the COPYING file in the top-level directory.
>   */
>  
>  #ifndef COMPILER_H
>  #define COMPILER_H
>  
>  #define HOST_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
>  
>  /* HOST_LONG_BITS is the size of a native pointer in bits. */
>  #define HOST_LONG_BITS (__SIZEOF_POINTER__ * 8)
>  
>  #if defined __clang_analyzer__ || defined __COVERITY__
>  #define QEMU_STATIC_ANALYSIS 1
>  #endif
>  
>  #ifdef __cplusplus
>  #define QEMU_EXTERN_C extern "C"
>  #else
>  #define QEMU_EXTERN_C extern
>  #endif
>  
>  #if defined(_WIN32) && (defined(__x86_64__) || defined(__i386__))
>  # define QEMU_PACKED __attribute__((gcc_struct, packed))
>  #else
>  # define QEMU_PACKED __attribute__((packed))
>  #endif
>  
>  #define QEMU_ALIGNED(X) __attribute__((aligned(X)))
>  
>  #ifndef glue
>  #define xglue(x, y) x ## y
>  #define glue(x, y) xglue(x, y)
>  #define stringify(s) tostring(s)
>  #define tostring(s) #s
>  #endif
>  
>  /* Expands into an identifier stemN, where N is another number each time */
>  #define MAKE_IDENTFIER(stem) glue(stem, __COUNTER__)
>  
>  #ifndef likely
>  #define likely(x)   __builtin_expect(!!(x), 1)
>  #define unlikely(x)   __builtin_expect(!!(x), 0)
>  #endif
>  
>  #ifndef container_of
>  #define container_of(ptr, type, member) ({                      \
>          const typeof(((type *) 0)->member) *__mptr = (ptr);     \
>          (type *) ((char *) __mptr - offsetof(type, member));})
>  #endif
>  
>  #define sizeof_field(type, field) sizeof(((type *)0)->field)
>  
>  /*
>   * Calculate the number of bytes up to and including the given 'field' of
>   * 'container'.
>   */
>  #define endof(container, field) \
>      (offsetof(container, field) + sizeof_field(container, field))
>  
>  /* Convert from a base type to a parent type, with compile time checking.  */
>  #define DO_UPCAST(type, field, dev) ( __extension__ ( { \
>      char __attribute__((unused)) offset_must_be_zero[ \
>          -offsetof(type, field)]; \
>      container_of(dev, type, field);}))
>  
>  #define typeof_field(type, field) typeof(((type *)0)->field)
>  #define type_check(t1,t2) ((t1*)0 - (t2*)0)
>  
>  #define QEMU_BUILD_BUG_ON_STRUCT(x) \
>      struct { \
>          int:(x) ? -1 : 1; \
>      }
>  
>  #define QEMU_BUILD_BUG_MSG(x, msg) _Static_assert(!(x), msg)
>  
>  #define QEMU_BUILD_BUG_ON(x) QEMU_BUILD_BUG_MSG(x, "not expecting: " #x)
>  
>  #define QEMU_BUILD_BUG_ON_ZERO(x) (sizeof(QEMU_BUILD_BUG_ON_STRUCT(x)) - \
>                                     sizeof(QEMU_BUILD_BUG_ON_STRUCT(x)))
>  
>  #if !defined(__clang__) && defined(_WIN32)
>  /*
>   * Map __printf__ to __gnu_printf__ because we want standard format strings even
>   * when MinGW or GLib include files use __printf__.
>   */
>  # define __printf__ __gnu_printf__
>  #endif
>  
>  #ifndef __has_warning
>  #define __has_warning(x) 0 /* compatibility with non-clang compilers */
>  #endif
>  
>  #ifndef __has_feature
>  #define __has_feature(x) 0 /* compatibility with non-clang compilers */
>  #endif
>  
>  #ifndef __has_builtin
>  #define __has_builtin(x) 0 /* compatibility with non-clang compilers */
>  #endif
>  
>  #if __has_builtin(__builtin_assume_aligned) || !defined(__clang__)
>  #define HAS_ASSUME_ALIGNED
>  #endif
>  
>  #ifndef __has_attribute
>  #define __has_attribute(x) 0 /* compatibility with older GCC */
>  #endif
>  
>  #if defined(__SANITIZE_ADDRESS__) || __has_feature(address_sanitizer)
>  # define QEMU_SANITIZE_ADDRESS 1
>  #endif
>  
>  #if defined(__SANITIZE_THREAD__) || __has_feature(thread_sanitizer)
>  # define QEMU_SANITIZE_THREAD 1
>  #endif
>  
>  /*
>   * GCC doesn't provide __has_attribute() until GCC 5, but we know all the GCC
>   * versions we support have the "flatten" attribute. Clang may not have the
>   * "flatten" attribute but always has __has_attribute() to check for it.
>   */
>  #if __has_attribute(flatten) || !defined(__clang__)
>  # define QEMU_FLATTEN __attribute__((flatten))
>  #else
>  # define QEMU_FLATTEN
>  #endif
>  
>  /*
>   * If __attribute__((error)) is present, use it to produce an error at
>   * compile time.  Otherwise, one must wait for the linker to diagnose
>   * the missing symbol.
>   */
>  #if __has_attribute(error)
>  # define QEMU_ERROR(X) __attribute__((error(X)))
>  #else
>  # define QEMU_ERROR(X)
>  #endif
>  
>  /*
>   * The nonstring variable attribute specifies that an object or member
>   * declaration with type array of char or pointer to char is intended
>   * to store character arrays that do not necessarily contain a terminating
>   * NUL character. This is useful in detecting uses of such arrays or pointers
>   * with functions that expect NUL-terminated strings, and to avoid warnings
>   * when such an array or pointer is used as an argument to a bounded string
>   * manipulation function such as strncpy.
>   */
>  #if __has_attribute(nonstring)
>  # define QEMU_NONSTRING __attribute__((nonstring))
>  #else
>  # define QEMU_NONSTRING
>  #endif
>  
>  /*
>   * Forced inlining may be desired to encourage constant propagation
>   * of function parameters.  However, it can also make debugging harder,
>   * so disable it for a non-optimizing build.
>   */
>  #if defined(__OPTIMIZE__)
>  #define QEMU_ALWAYS_INLINE  __attribute__((always_inline))
>  #else
>  #define QEMU_ALWAYS_INLINE
>  #endif
>  
> -/**
> - * In most cases, normal "fallthrough" comments are good enough for
> - * switch-case statements, but sometimes the compiler has problems
> - * with those. In that case you can use QEMU_FALLTHROUGH instead.
> +/*
> + * Add the pseudo keyword 'fallthrough' so case statement blocks
> + * must end with any of these keywords:
> + *   break;
> + *   fallthrough;
> + *   continue;
> + *   goto <label>;
> + *   return [expression];
> + *
> + *  gcc: https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html#Statement-Attributes
>   */
> -#if __has_attribute(fallthrough)
> -# define QEMU_FALLTHROUGH __attribute__((fallthrough))
> +
> +/*
> + * glib_macros.h contains its own definition of fallthrough, so if we define
> + * the pseudokeyword here it will expand when the glib header checks for the
> + * attribute. glib headers must be #included after this header.
> + */
> +#ifdef fallthrough
> +#undef fallthrough
> +#endif
> +
> +#if __has_attribute(__fallthrough__)
> +# define fallthrough                    __attribute__((__fallthrough__))
>  #else
> -# define QEMU_FALLTHROUGH do {} while (0) /* fallthrough */
> +# define fallthrough                    do {} while (0)  /* fallthrough */
>  #endif
>  
>  #ifdef CONFIG_CFI
>  /*
>   * If CFI is enabled, use an attribute to disable cfi-icall on the following
>   * function
>   */
>  #define QEMU_DISABLE_CFI __attribute__((no_sanitize("cfi-icall")))
>  #else
>  /* If CFI is not enabled, use an empty define to not change the behavior */
>  #define QEMU_DISABLE_CFI
>  #endif
>  
>  /*
>   * Apple clang version 14 has a bug in its __builtin_subcll(); define
>   * BUILTIN_SUBCLL_BROKEN for the offending versions so we can avoid it.
>   * When a version of Apple clang which has this bug fixed is released
>   * we can add an upper bound to this check.
>   * See https://gitlab.com/qemu-project/qemu/-/issues/1631
>   * and https://gitlab.com/qemu-project/qemu/-/issues/1659 for details.
>   * The bug never made it into any upstream LLVM releases, only Apple ones.
>   */
>  #if defined(__apple_build_version__) && __clang_major__ >= 14
>  #define BUILTIN_SUBCLL_BROKEN
>  #endif
>  
>  #if __has_attribute(annotate)
>  #define QEMU_ANNOTATE(x) __attribute__((annotate(x)))
>  #else
>  #define QEMU_ANNOTATE(x)
>  #endif
>  
>  #if __has_attribute(used)
>  # define QEMU_USED __attribute__((used))
>  #else
>  # define QEMU_USED
>  #endif
>  
>  #endif /* COMPILER_H */
> diff --git a/include/qemu/osdep.h b/include/qemu/osdep.h
> index 475a1c62ff..8f790f0deb 100644
> --- a/include/qemu/osdep.h
> +++ b/include/qemu/osdep.h
> @@ -1,171 +1,171 @@
>  /*
>   * OS includes and handling of OS dependencies
>   *
>   * This header exists to pull in some common system headers that
>   * most code in QEMU will want, and to fix up some possible issues with
>   * it (missing defines, Windows weirdness, and so on).
>   *
>   * To avoid getting into possible circular include dependencies, this
>   * file should not include any other QEMU headers, with the exceptions
>   * of config-host.h, config-target.h, qemu/compiler.h,
>   * sysemu/os-posix.h, sysemu/os-win32.h, glib-compat.h and
>   * qemu/typedefs.h, all of which are doing a similar job to this file
>   * and are under similar constraints.
>   *
>   * This header also contains prototypes for functions defined in
>   * os-*.c and util/oslib-*.c; those would probably be better split
>   * out into separate header files.
>   *
>   * In an ideal world this header would contain only:
>   *  (1) things which everybody needs
>   *  (2) things without which code would work on most platforms but
>   *      fail to compile or misbehave on a minority of host OSes
>   *
>   * This work is licensed under the terms of the GNU GPL, version 2 or later.
>   * See the COPYING file in the top-level directory.
>   */
>  #ifndef QEMU_OSDEP_H
>  #define QEMU_OSDEP_H
>  
>  #if !defined _FORTIFY_SOURCE && defined __OPTIMIZE__ && __OPTIMIZE__ && defined __linux__
>  # define _FORTIFY_SOURCE 2
>  #endif
>  
>  #include "config-host.h"
>  #ifdef NEED_CPU_H
>  #include CONFIG_TARGET
>  #else
>  #include "exec/poison.h"
>  #endif
>  
>  /*
>   * HOST_WORDS_BIGENDIAN was replaced with HOST_BIG_ENDIAN. Prevent it from
>   * creeping back in.
>   */
>  #pragma GCC poison HOST_WORDS_BIGENDIAN
>  
>  /*
>   * TARGET_WORDS_BIGENDIAN was replaced with TARGET_BIG_ENDIAN. Prevent it from
>   * creeping back in.
>   */
>  #pragma GCC poison TARGET_WORDS_BIGENDIAN
>  
> -#include "qemu/compiler.h"
> -
>  /* Older versions of C++ don't get definitions of various macros from
>   * stdlib.h unless we define these macros before first inclusion of
>   * that system header.
>   */
>  #ifndef __STDC_CONSTANT_MACROS
>  #define __STDC_CONSTANT_MACROS
>  #endif
>  #ifndef __STDC_LIMIT_MACROS
>  #define __STDC_LIMIT_MACROS
>  #endif
>  #ifndef __STDC_FORMAT_MACROS
>  #define __STDC_FORMAT_MACROS
>  #endif
>  
>  /* The following block of code temporarily renames the daemon() function so the
>   * compiler does not see the warning associated with it in stdlib.h on OSX
>   */
>  #ifdef __APPLE__
>  #define daemon qemu_fake_daemon_function
>  #include <stdlib.h>
>  #undef daemon
>  QEMU_EXTERN_C int daemon(int, int);
>  #endif
>  
>  #ifdef _WIN32
>  /* as defined in sdkddkver.h */
>  #ifndef _WIN32_WINNT
>  #define _WIN32_WINNT 0x0602 /* Windows 8 API (should be >= the one from glib) */
>  #endif
>  /* reduces the number of implicitly included headers */
>  #ifndef WIN32_LEAN_AND_MEAN
>  #define WIN32_LEAN_AND_MEAN
>  #endif
>  #endif
>  
>  /* enable C99/POSIX format strings (needs mingw32-runtime 3.15 or later) */
>  #ifdef __MINGW32__
>  #define __USE_MINGW_ANSI_STDIO 1
>  #endif
>  
>  /*
>   * We need the FreeBSD "legacy" definitions. Rust needs the FreeBSD 11 system
>   * calls since it doesn't use libc at all, so we have to emulate that despite
>   * FreeBSD 11 being EOL'd.
>   */
>  #ifdef __FreeBSD__
>  #define _WANT_FREEBSD11_STAT
>  #define _WANT_FREEBSD11_STATFS
>  #define _WANT_FREEBSD11_DIRENT
>  #define _WANT_KERNEL_ERRNO
>  #define _WANT_SEMUN
>  #endif
>  
>  #include <stdarg.h>
>  #include <stddef.h>
>  #include <stdbool.h>
>  #include <stdint.h>
>  #include <sys/types.h>
>  #include <stdlib.h>
>  #include <stdio.h>
>  
>  #include <string.h>
>  #include <strings.h>
>  #include <inttypes.h>
>  #include <limits.h>
>  /* Put unistd.h before time.h as that triggers localtime_r/gmtime_r
>   * function availability on recentish Mingw-w64 platforms. */
>  #include <unistd.h>
>  #include <time.h>
>  #include <ctype.h>
>  #include <errno.h>
>  #include <fcntl.h>
>  #include <getopt.h>
>  #include <sys/stat.h>
>  #include <sys/time.h>
>  #include <assert.h>
>  /* setjmp must be declared before sysemu/os-win32.h
>   * because it is redefined there. */
>  #include <setjmp.h>
>  #include <signal.h>
>  
>  #ifdef CONFIG_IOVEC
>  #include <sys/uio.h>
>  #endif
>  
>  #if defined(__linux__) && defined(__sparc__)
>  /* The SPARC definition of QEMU_VMALLOC_ALIGN needs SHMLBA */
>  #include <sys/shm.h>
>  #endif
>  
>  #ifndef _WIN32
>  #include <sys/wait.h>
>  #else
>  #define WIFEXITED(x)   1
>  #define WEXITSTATUS(x) (x)
>  #endif
>  
>  #ifdef __APPLE__
>  #include <AvailabilityMacros.h>
>  #endif
>  
>  /*
>   * This is somewhat like a system header; it must be outside any extern "C"
>   * block because it includes system headers itself, including glib.h,
>   * which will not compile if inside an extern "C" block.
>   */
>  #include "glib-compat.h"
>  
> +#include "qemu/compiler.h"
> +
>  #ifdef _WIN32
>  #include "sysemu/os-win32.h"
>  #endif
>  
>  #ifdef CONFIG_POSIX
>  #include "sysemu/os-posix.h"
>  #endif
>  
>  #ifdef __cplusplus
> diff --git a/target/loongarch/cpu.c b/target/loongarch/cpu.c
> index 2bea7ca5d5..e01d626b15 100644
> --- a/target/loongarch/cpu.c
> +++ b/target/loongarch/cpu.c
> @@ -142,145 +142,145 @@ static inline bool cpu_loongarch_hw_interrupts_pending(CPULoongArchState *env)
>  static void loongarch_cpu_do_interrupt(CPUState *cs)
>  {
>      LoongArchCPU *cpu = LOONGARCH_CPU(cs);
>      CPULoongArchState *env = &cpu->env;
>      bool update_badinstr = 1;
>      int cause = -1;
>      const char *name;
>      bool tlbfill = FIELD_EX64(env->CSR_TLBRERA, CSR_TLBRERA, ISTLBR);
>      uint32_t vec_size = FIELD_EX64(env->CSR_ECFG, CSR_ECFG, VS);
>  
>      if (cs->exception_index != EXCCODE_INT) {
>          if (cs->exception_index < 0 ||
>              cs->exception_index >= ARRAY_SIZE(excp_names)) {
>              name = "unknown";
>          } else {
>              name = excp_names[cs->exception_index];
>          }
>  
>          qemu_log_mask(CPU_LOG_INT,
>                       "%s enter: pc " TARGET_FMT_lx " ERA " TARGET_FMT_lx
>                       " TLBRERA " TARGET_FMT_lx " %s exception\n", __func__,
>                       env->pc, env->CSR_ERA, env->CSR_TLBRERA, name);
>      }
>  
>      switch (cs->exception_index) {
>      case EXCCODE_DBP:
>          env->CSR_DBG = FIELD_DP64(env->CSR_DBG, CSR_DBG, DCL, 1);
>          env->CSR_DBG = FIELD_DP64(env->CSR_DBG, CSR_DBG, ECODE, 0xC);
>          goto set_DERA;
>      set_DERA:
>          env->CSR_DERA = env->pc;
>          env->CSR_DBG = FIELD_DP64(env->CSR_DBG, CSR_DBG, DST, 1);
>          set_pc(env, env->CSR_EENTRY + 0x480);
>          break;
>      case EXCCODE_INT:
>          if (FIELD_EX64(env->CSR_DBG, CSR_DBG, DST)) {
>              env->CSR_DBG = FIELD_DP64(env->CSR_DBG, CSR_DBG, DEI, 1);
>              goto set_DERA;
>          }
> -        QEMU_FALLTHROUGH;
> +        fallthrough;
>      case EXCCODE_PIF:
>      case EXCCODE_ADEF:
>          cause = cs->exception_index;
>          update_badinstr = 0;
>          break;
>      case EXCCODE_SYS:
>      case EXCCODE_BRK:
>      case EXCCODE_INE:
>      case EXCCODE_IPE:
>      case EXCCODE_FPD:
>      case EXCCODE_FPE:
>      case EXCCODE_SXD:
>      case EXCCODE_ASXD:
>          env->CSR_BADV = env->pc;
> -        QEMU_FALLTHROUGH;
> +        fallthrough;
>      case EXCCODE_BCE:
>      case EXCCODE_ADEM:
>      case EXCCODE_PIL:
>      case EXCCODE_PIS:
>      case EXCCODE_PME:
>      case EXCCODE_PNR:
>      case EXCCODE_PNX:
>      case EXCCODE_PPI:
>          cause = cs->exception_index;
>          break;
>      default:
>          qemu_log("Error: exception(%d) has not been supported\n",
>                   cs->exception_index);
>          abort();
>      }
>  
>      if (update_badinstr) {
>          env->CSR_BADI = cpu_ldl_code(env, env->pc);
>      }
>  
>      /* Save PLV and IE */
>      if (tlbfill) {
>          env->CSR_TLBRPRMD = FIELD_DP64(env->CSR_TLBRPRMD, CSR_TLBRPRMD, PPLV,
>                                         FIELD_EX64(env->CSR_CRMD,
>                                         CSR_CRMD, PLV));
>          env->CSR_TLBRPRMD = FIELD_DP64(env->CSR_TLBRPRMD, CSR_TLBRPRMD, PIE,
>                                         FIELD_EX64(env->CSR_CRMD, CSR_CRMD, IE));
>          /* set the DA mode */
>          env->CSR_CRMD = FIELD_DP64(env->CSR_CRMD, CSR_CRMD, DA, 1);
>          env->CSR_CRMD = FIELD_DP64(env->CSR_CRMD, CSR_CRMD, PG, 0);
>          env->CSR_TLBRERA = FIELD_DP64(env->CSR_TLBRERA, CSR_TLBRERA,
>                                        PC, (env->pc >> 2));
>      } else {
>          env->CSR_ESTAT = FIELD_DP64(env->CSR_ESTAT, CSR_ESTAT, ECODE,
>                                      EXCODE_MCODE(cause));
>          env->CSR_ESTAT = FIELD_DP64(env->CSR_ESTAT, CSR_ESTAT, ESUBCODE,
>                                      EXCODE_SUBCODE(cause));
>          env->CSR_PRMD = FIELD_DP64(env->CSR_PRMD, CSR_PRMD, PPLV,
>                                     FIELD_EX64(env->CSR_CRMD, CSR_CRMD, PLV));
>          env->CSR_PRMD = FIELD_DP64(env->CSR_PRMD, CSR_PRMD, PIE,
>                                     FIELD_EX64(env->CSR_CRMD, CSR_CRMD, IE));
>          env->CSR_ERA = env->pc;
>      }
>  
>      env->CSR_CRMD = FIELD_DP64(env->CSR_CRMD, CSR_CRMD, PLV, 0);
>      env->CSR_CRMD = FIELD_DP64(env->CSR_CRMD, CSR_CRMD, IE, 0);
>  
>      if (vec_size) {
>          vec_size = (1 << vec_size) * 4;
>      }
>  
>      if  (cs->exception_index == EXCCODE_INT) {
>          /* Interrupt */
>          uint32_t vector = 0;
>          uint32_t pending = FIELD_EX64(env->CSR_ESTAT, CSR_ESTAT, IS);
>          pending &= FIELD_EX64(env->CSR_ECFG, CSR_ECFG, LIE);
>  
>          /* Find the highest-priority interrupt. */
>          vector = 31 - clz32(pending);
>          set_pc(env, env->CSR_EENTRY + \
>                 (EXCCODE_EXTERNAL_INT + vector) * vec_size);
>          qemu_log_mask(CPU_LOG_INT,
>                        "%s: PC " TARGET_FMT_lx " ERA " TARGET_FMT_lx
>                        " cause %d\n" "    A " TARGET_FMT_lx " D "
>                        TARGET_FMT_lx " vector = %d ExC " TARGET_FMT_lx "ExS"
>                        TARGET_FMT_lx "\n",
>                        __func__, env->pc, env->CSR_ERA,
>                        cause, env->CSR_BADV, env->CSR_DERA, vector,
>                        env->CSR_ECFG, env->CSR_ESTAT);
>      } else {
>          if (tlbfill) {
>              set_pc(env, env->CSR_TLBRENTRY);
>          } else {
>              set_pc(env, env->CSR_EENTRY + EXCODE_MCODE(cause) * vec_size);
>          }
>          qemu_log_mask(CPU_LOG_INT,
>                        "%s: PC " TARGET_FMT_lx " ERA " TARGET_FMT_lx
>                        " cause %d%s\n, ESTAT " TARGET_FMT_lx
>                        " EXCFG " TARGET_FMT_lx " BADVA " TARGET_FMT_lx
>                        "BADI " TARGET_FMT_lx " SYS_NUM " TARGET_FMT_lu
>                        " cpu %d asid " TARGET_FMT_lx "\n", __func__, env->pc,
>                        tlbfill ? env->CSR_TLBRERA : env->CSR_ERA,
>                        cause, tlbfill ? "(refill)" : "", env->CSR_ESTAT,
>                        env->CSR_ECFG,
>                        tlbfill ? env->CSR_TLBRBADV : env->CSR_BADV,
>                        env->CSR_BADI, env->gpr[11], cs->cpu_index,
>                        env->CSR_ASID);
>      }
>      cs->exception_index = -1;
>  }
> diff --git a/target/loongarch/translate.c b/target/loongarch/translate.c
> index 21f4db6fbd..36fceb1beb 100644
> --- a/target/loongarch/translate.c
> +++ b/target/loongarch/translate.c
> @@ -304,24 +304,24 @@ static void loongarch_tr_translate_insn(DisasContextBase *dcbase, CPUState *cs)
>  static void loongarch_tr_tb_stop(DisasContextBase *dcbase, CPUState *cs)
>  {
>      DisasContext *ctx = container_of(dcbase, DisasContext, base);
>  
>      switch (ctx->base.is_jmp) {
>      case DISAS_STOP:
>          tcg_gen_movi_tl(cpu_pc, ctx->base.pc_next);
>          tcg_gen_lookup_and_goto_ptr();
>          break;
>      case DISAS_TOO_MANY:
>          gen_goto_tb(ctx, 0, ctx->base.pc_next);
>          break;
>      case DISAS_NORETURN:
>          break;
>      case DISAS_EXIT_UPDATE:
>          tcg_gen_movi_tl(cpu_pc, ctx->base.pc_next);
> -        QEMU_FALLTHROUGH;
> +        fallthrough;
>      case DISAS_EXIT:
>          tcg_gen_exit_tb(NULL, 0);
>          break;
>      default:
>          g_assert_not_reached();
>      }
>  }
> diff --git a/tcg/optimize.c b/tcg/optimize.c
> index 3013eb04e6..3da135a353 100644
> --- a/tcg/optimize.c
> +++ b/tcg/optimize.c
> @@ -1062,81 +1062,81 @@ static bool fold_brcond(OptContext *ctx, TCGOp *op)
>  static bool fold_brcond2(OptContext *ctx, TCGOp *op)
>  {
>      TCGCond cond = op->args[4];
>      TCGArg label = op->args[5];
>      int i, inv = 0;
>  
>      if (swap_commutative2(&op->args[0], &op->args[2])) {
>          op->args[4] = cond = tcg_swap_cond(cond);
>      }
>  
>      i = do_constant_folding_cond2(&op->args[0], &op->args[2], cond);
>      if (i >= 0) {
>          goto do_brcond_const;
>      }
>  
>      switch (cond) {
>      case TCG_COND_LT:
>      case TCG_COND_GE:
>          /*
>           * Simplify LT/GE comparisons vs zero to a single compare
>           * vs the high word of the input.
>           */
>          if (arg_is_const(op->args[2]) && arg_info(op->args[2])->val == 0 &&
>              arg_is_const(op->args[3]) && arg_info(op->args[3])->val == 0) {
>              goto do_brcond_high;
>          }
>          break;
>  
>      case TCG_COND_NE:
>          inv = 1;
> -        QEMU_FALLTHROUGH;
> +        fallthrough;
>      case TCG_COND_EQ:
>          /*
>           * Simplify EQ/NE comparisons where one of the pairs
>           * can be simplified.
>           */
>          i = do_constant_folding_cond(TCG_TYPE_I32, op->args[0],
>                                       op->args[2], cond);
>          switch (i ^ inv) {
>          case 0:
>              goto do_brcond_const;
>          case 1:
>              goto do_brcond_high;
>          }
>  
>          i = do_constant_folding_cond(TCG_TYPE_I32, op->args[1],
>                                       op->args[3], cond);
>          switch (i ^ inv) {
>          case 0:
>              goto do_brcond_const;
>          case 1:
>              op->opc = INDEX_op_brcond_i32;
>              op->args[1] = op->args[2];
>              op->args[2] = cond;
>              op->args[3] = label;
>              break;
>          }
>          break;
>  
>      default:
>          break;
>  
>      do_brcond_high:
>          op->opc = INDEX_op_brcond_i32;
>          op->args[0] = op->args[1];
>          op->args[1] = op->args[3];
>          op->args[2] = cond;
>          op->args[3] = label;
>          break;
>  
>      do_brcond_const:
>          if (i == 0) {
>              tcg_op_remove(ctx->tcg, op);
>              return true;
>          }
>          op->opc = INDEX_op_br;
>          op->args[0] = label;
>          break;
>      }
>      return false;
>  }
> @@ -1424,46 +1424,46 @@ static bool fold_extract2(OptContext *ctx, TCGOp *op)
>  static bool fold_exts(OptContext *ctx, TCGOp *op)
>  {
>      uint64_t s_mask_old, s_mask, z_mask, sign;
>      bool type_change = false;
>  
>      if (fold_const1(ctx, op)) {
>          return true;
>      }
>  
>      z_mask = arg_info(op->args[1])->z_mask;
>      s_mask = arg_info(op->args[1])->s_mask;
>      s_mask_old = s_mask;
>  
>      switch (op->opc) {
>      CASE_OP_32_64(ext8s):
>          sign = INT8_MIN;
>          z_mask = (uint8_t)z_mask;
>          break;
>      CASE_OP_32_64(ext16s):
>          sign = INT16_MIN;
>          z_mask = (uint16_t)z_mask;
>          break;
>      case INDEX_op_ext_i32_i64:
>          type_change = true;
> -        QEMU_FALLTHROUGH;
> +        fallthrough;
>      case INDEX_op_ext32s_i64:
>          sign = INT32_MIN;
>          z_mask = (uint32_t)z_mask;
>          break;
>      default:
>          g_assert_not_reached();
>      }
>  
>      if (z_mask & sign) {
>          z_mask |= sign;
>      }
>      s_mask |= sign << 1;
>  
>      ctx->z_mask = z_mask;
>      ctx->s_mask = s_mask;
>      if (!type_change) {
>          ctx->a_mask = s_mask & ~s_mask_old;
>      }
>  
>      return fold_masks(ctx, op);
>  }
> @@ -1471,40 +1471,40 @@ static bool fold_exts(OptContext *ctx, TCGOp *op)
>  static bool fold_extu(OptContext *ctx, TCGOp *op)
>  {
>      uint64_t z_mask_old, z_mask;
>      bool type_change = false;
>  
>      if (fold_const1(ctx, op)) {
>          return true;
>      }
>  
>      z_mask_old = z_mask = arg_info(op->args[1])->z_mask;
>  
>      switch (op->opc) {
>      CASE_OP_32_64(ext8u):
>          z_mask = (uint8_t)z_mask;
>          break;
>      CASE_OP_32_64(ext16u):
>          z_mask = (uint16_t)z_mask;
>          break;
>      case INDEX_op_extrl_i64_i32:
>      case INDEX_op_extu_i32_i64:
>          type_change = true;
> -        QEMU_FALLTHROUGH;
> +        fallthrough;
>      case INDEX_op_ext32u_i64:
>          z_mask = (uint32_t)z_mask;
>          break;
>      case INDEX_op_extrh_i64_i32:
>          type_change = true;
>          z_mask >>= 32;
>          break;
>      default:
>          g_assert_not_reached();
>      }
>  
>      ctx->z_mask = z_mask;
>      ctx->s_mask = smask_from_zmask(z_mask);
>      if (!type_change) {
>          ctx->a_mask = z_mask_old ^ z_mask;
>      }
>      return fold_masks(ctx, op);
>  }
> @@ -1835,75 +1835,75 @@ static bool fold_negsetcond(OptContext *ctx, TCGOp *op)
>  static bool fold_setcond2(OptContext *ctx, TCGOp *op)
>  {
>      TCGCond cond = op->args[5];
>      int i, inv = 0;
>  
>      if (swap_commutative2(&op->args[1], &op->args[3])) {
>          op->args[5] = cond = tcg_swap_cond(cond);
>      }
>  
>      i = do_constant_folding_cond2(&op->args[1], &op->args[3], cond);
>      if (i >= 0) {
>          goto do_setcond_const;
>      }
>  
>      switch (cond) {
>      case TCG_COND_LT:
>      case TCG_COND_GE:
>          /*
>           * Simplify LT/GE comparisons vs zero to a single compare
>           * vs the high word of the input.
>           */
>          if (arg_is_const(op->args[3]) && arg_info(op->args[3])->val == 0 &&
>              arg_is_const(op->args[4]) && arg_info(op->args[4])->val == 0) {
>              goto do_setcond_high;
>          }
>          break;
>  
>      case TCG_COND_NE:
>          inv = 1;
> -        QEMU_FALLTHROUGH;
> +        fallthrough;
>      case TCG_COND_EQ:
>          /*
>           * Simplify EQ/NE comparisons where one of the pairs
>           * can be simplified.
>           */
>          i = do_constant_folding_cond(TCG_TYPE_I32, op->args[1],
>                                       op->args[3], cond);
>          switch (i ^ inv) {
>          case 0:
>              goto do_setcond_const;
>          case 1:
>              goto do_setcond_high;
>          }
>  
>          i = do_constant_folding_cond(TCG_TYPE_I32, op->args[2],
>                                       op->args[4], cond);
>          switch (i ^ inv) {
>          case 0:
>              goto do_setcond_const;
>          case 1:
>              op->args[2] = op->args[3];
>              op->args[3] = cond;
>              op->opc = INDEX_op_setcond_i32;
>              break;
>          }
>          break;
>  
>      default:
>          break;
>  
>      do_setcond_high:
>          op->args[1] = op->args[2];
>          op->args[2] = op->args[4];
>          op->args[3] = cond;
>          op->opc = INDEX_op_setcond_i32;
>          break;
>      }
>  
>      ctx->z_mask = 1;
>      ctx->s_mask = smask_from_zmask(1);
>      return false;
>  
>   do_setcond_const:
>      return tcg_opt_gen_movi(ctx, op, op->args[0], i);
>  }
> -- 
> 2.39.2
> 
> 

With regards,
Daniel
-- 
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|