On Fri, Oct 13, 2023 at 10:47:05AM +0300, Emmanouil Pitsidianakis wrote: > Signed-off-by: Emmanouil Pitsidianakis <manos.pitsidiana...@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 <dbas...@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 :|