/* This file is autogenerated by tracetool, do not edit. */

#ifndef TRACE_TARGET_PPC_GENERATED_TRACERS_H
#define TRACE_TARGET_PPC_GENERATED_TRACERS_H

#include "trace/control.h"

extern TraceEvent _TRACE_KVM_FAILED_SPR_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_SPR_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_FPSCR_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_FP_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_VSCR_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_VR_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_FPSCR_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_FP_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_VSCR_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_VR_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_VPA_ADDR_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_SLB_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_DTL_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_VPA_ADDR_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_SLB_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_DTL_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_NULL_VPA_ADDR_SET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_PUT_VPA_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_GET_VPA_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_DCR_WRITE_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_DCR_READ_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_HALT_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_PAPR_HCALL_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_EPR_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_WATCHDOG_EXPIRY_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_DEBUG_EXCEPTION_EVENT;
extern TraceEvent _TRACE_KVM_HANDLE_NMI_EXCEPTION_EVENT;
extern TraceEvent _TRACE_PPC_EXCP_RFI_EVENT;
extern TraceEvent _TRACE_PPC_EXCP_DSI_EVENT;
extern TraceEvent _TRACE_PPC_EXCP_ISI_EVENT;
extern TraceEvent _TRACE_PPC_EXCP_FP_IGNORE_EVENT;
extern TraceEvent _TRACE_PPC_EXCP_INVAL_EVENT;
extern TraceEvent _TRACE_PPC_EXCP_PRINT_EVENT;
extern uint16_t _TRACE_KVM_FAILED_SPR_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_SPR_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_FPSCR_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_FP_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_VSCR_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_VR_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_FPSCR_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_FP_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_VSCR_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_VR_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_VPA_ADDR_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_SLB_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_DTL_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_VPA_ADDR_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_SLB_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_DTL_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_NULL_VPA_ADDR_SET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_PUT_VPA_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_GET_VPA_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_DCR_WRITE_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_DCR_READ_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_HALT_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_PAPR_HCALL_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_EPR_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_WATCHDOG_EXPIRY_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_DEBUG_EXCEPTION_DSTATE;
extern uint16_t _TRACE_KVM_HANDLE_NMI_EXCEPTION_DSTATE;
extern uint16_t _TRACE_PPC_EXCP_RFI_DSTATE;
extern uint16_t _TRACE_PPC_EXCP_DSI_DSTATE;
extern uint16_t _TRACE_PPC_EXCP_ISI_DSTATE;
extern uint16_t _TRACE_PPC_EXCP_FP_IGNORE_DSTATE;
extern uint16_t _TRACE_PPC_EXCP_INVAL_DSTATE;
extern uint16_t _TRACE_PPC_EXCP_PRINT_DSTATE;
#define TRACE_KVM_FAILED_SPR_SET_ENABLED 1
#define TRACE_KVM_FAILED_SPR_GET_ENABLED 1
#define TRACE_KVM_FAILED_FPSCR_SET_ENABLED 1
#define TRACE_KVM_FAILED_FP_SET_ENABLED 1
#define TRACE_KVM_FAILED_VSCR_SET_ENABLED 1
#define TRACE_KVM_FAILED_VR_SET_ENABLED 1
#define TRACE_KVM_FAILED_FPSCR_GET_ENABLED 1
#define TRACE_KVM_FAILED_FP_GET_ENABLED 1
#define TRACE_KVM_FAILED_VSCR_GET_ENABLED 1
#define TRACE_KVM_FAILED_VR_GET_ENABLED 1
#define TRACE_KVM_FAILED_VPA_ADDR_GET_ENABLED 1
#define TRACE_KVM_FAILED_SLB_GET_ENABLED 1
#define TRACE_KVM_FAILED_DTL_GET_ENABLED 1
#define TRACE_KVM_FAILED_VPA_ADDR_SET_ENABLED 1
#define TRACE_KVM_FAILED_SLB_SET_ENABLED 1
#define TRACE_KVM_FAILED_DTL_SET_ENABLED 1
#define TRACE_KVM_FAILED_NULL_VPA_ADDR_SET_ENABLED 1
#define TRACE_KVM_FAILED_PUT_VPA_ENABLED 1
#define TRACE_KVM_FAILED_GET_VPA_ENABLED 1
#define TRACE_KVM_HANDLE_DCR_WRITE_ENABLED 1
#define TRACE_KVM_HANDLE_DCR_READ_ENABLED 1
#define TRACE_KVM_HANDLE_HALT_ENABLED 1
#define TRACE_KVM_HANDLE_PAPR_HCALL_ENABLED 1
#define TRACE_KVM_HANDLE_EPR_ENABLED 1
#define TRACE_KVM_HANDLE_WATCHDOG_EXPIRY_ENABLED 1
#define TRACE_KVM_HANDLE_DEBUG_EXCEPTION_ENABLED 1
#define TRACE_KVM_HANDLE_NMI_EXCEPTION_ENABLED 1
#define TRACE_PPC_EXCP_RFI_ENABLED 1
#define TRACE_PPC_EXCP_DSI_ENABLED 1
#define TRACE_PPC_EXCP_ISI_ENABLED 1
#define TRACE_PPC_EXCP_FP_IGNORE_ENABLED 1
#define TRACE_PPC_EXCP_INVAL_ENABLED 1
#define TRACE_PPC_EXCP_PRINT_ENABLED 1
#include "qemu/log-for-trace.h"
#include "qemu/error-report.h"


#define TRACE_KVM_FAILED_SPR_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_SPR_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_spr_set(int spr, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_SPR_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 4 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_spr_set " "Warning: Unable to set SPR %d to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , spr, msg);
#line 127 "trace/trace-target_ppc.h"
        } else {
#line 4 "../target/ppc/trace-events"
            qemu_log("kvm_failed_spr_set " "Warning: Unable to set SPR %d to KVM: %s" "\n", spr, msg);
#line 131 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_spr_set(int spr, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_spr_set(spr, msg);
    }
}

#define TRACE_KVM_FAILED_SPR_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_SPR_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_spr_get(int spr, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_SPR_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 5 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_spr_get " "Warning: Unable to retrieve SPR %d from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , spr, msg);
#line 158 "trace/trace-target_ppc.h"
        } else {
#line 5 "../target/ppc/trace-events"
            qemu_log("kvm_failed_spr_get " "Warning: Unable to retrieve SPR %d from KVM: %s" "\n", spr, msg);
#line 162 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_spr_get(int spr, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_spr_get(spr, msg);
    }
}

#define TRACE_KVM_FAILED_FPSCR_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_FPSCR_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_fpscr_set(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_FPSCR_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 6 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_fpscr_set " "Unable to set FPSCR to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 189 "trace/trace-target_ppc.h"
        } else {
#line 6 "../target/ppc/trace-events"
            qemu_log("kvm_failed_fpscr_set " "Unable to set FPSCR to KVM: %s" "\n", msg);
#line 193 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_fpscr_set(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_fpscr_set(msg);
    }
}

#define TRACE_KVM_FAILED_FP_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_FP_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_fp_set(const char * fpname, int fpnum, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_FP_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 7 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_fp_set " "Unable to set %s%d to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , fpname, fpnum, msg);
#line 220 "trace/trace-target_ppc.h"
        } else {
#line 7 "../target/ppc/trace-events"
            qemu_log("kvm_failed_fp_set " "Unable to set %s%d to KVM: %s" "\n", fpname, fpnum, msg);
#line 224 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_fp_set(const char * fpname, int fpnum, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_fp_set(fpname, fpnum, msg);
    }
}

#define TRACE_KVM_FAILED_VSCR_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_VSCR_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_vscr_set(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_VSCR_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 8 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_vscr_set " "Unable to set VSCR to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 251 "trace/trace-target_ppc.h"
        } else {
#line 8 "../target/ppc/trace-events"
            qemu_log("kvm_failed_vscr_set " "Unable to set VSCR to KVM: %s" "\n", msg);
#line 255 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_vscr_set(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_vscr_set(msg);
    }
}

#define TRACE_KVM_FAILED_VR_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_VR_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_vr_set(int vr, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_VR_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 9 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_vr_set " "Unable to set VR%d to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , vr, msg);
#line 282 "trace/trace-target_ppc.h"
        } else {
#line 9 "../target/ppc/trace-events"
            qemu_log("kvm_failed_vr_set " "Unable to set VR%d to KVM: %s" "\n", vr, msg);
#line 286 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_vr_set(int vr, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_vr_set(vr, msg);
    }
}

#define TRACE_KVM_FAILED_FPSCR_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_FPSCR_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_fpscr_get(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_FPSCR_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 10 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_fpscr_get " "Unable to get FPSCR from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 313 "trace/trace-target_ppc.h"
        } else {
#line 10 "../target/ppc/trace-events"
            qemu_log("kvm_failed_fpscr_get " "Unable to get FPSCR from KVM: %s" "\n", msg);
#line 317 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_fpscr_get(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_fpscr_get(msg);
    }
}

#define TRACE_KVM_FAILED_FP_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_FP_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_fp_get(const char * fpname, int fpnum, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_FP_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 11 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_fp_get " "Unable to get %s%d from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , fpname, fpnum, msg);
#line 344 "trace/trace-target_ppc.h"
        } else {
#line 11 "../target/ppc/trace-events"
            qemu_log("kvm_failed_fp_get " "Unable to get %s%d from KVM: %s" "\n", fpname, fpnum, msg);
#line 348 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_fp_get(const char * fpname, int fpnum, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_fp_get(fpname, fpnum, msg);
    }
}

#define TRACE_KVM_FAILED_VSCR_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_VSCR_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_vscr_get(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_VSCR_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 12 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_vscr_get " "Unable to get VSCR from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 375 "trace/trace-target_ppc.h"
        } else {
#line 12 "../target/ppc/trace-events"
            qemu_log("kvm_failed_vscr_get " "Unable to get VSCR from KVM: %s" "\n", msg);
#line 379 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_vscr_get(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_vscr_get(msg);
    }
}

#define TRACE_KVM_FAILED_VR_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_VR_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_vr_get(int vr, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_VR_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 13 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_vr_get " "Unable to get VR%d from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , vr, msg);
#line 406 "trace/trace-target_ppc.h"
        } else {
#line 13 "../target/ppc/trace-events"
            qemu_log("kvm_failed_vr_get " "Unable to get VR%d from KVM: %s" "\n", vr, msg);
#line 410 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_vr_get(int vr, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_vr_get(vr, msg);
    }
}

#define TRACE_KVM_FAILED_VPA_ADDR_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_VPA_ADDR_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_vpa_addr_get(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_VPA_ADDR_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 14 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_vpa_addr_get " "Unable to get VPA address from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 437 "trace/trace-target_ppc.h"
        } else {
#line 14 "../target/ppc/trace-events"
            qemu_log("kvm_failed_vpa_addr_get " "Unable to get VPA address from KVM: %s" "\n", msg);
#line 441 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_vpa_addr_get(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_vpa_addr_get(msg);
    }
}

#define TRACE_KVM_FAILED_SLB_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_SLB_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_slb_get(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_SLB_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 15 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_slb_get " "Unable to get SLB shadow state from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 468 "trace/trace-target_ppc.h"
        } else {
#line 15 "../target/ppc/trace-events"
            qemu_log("kvm_failed_slb_get " "Unable to get SLB shadow state from KVM: %s" "\n", msg);
#line 472 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_slb_get(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_slb_get(msg);
    }
}

#define TRACE_KVM_FAILED_DTL_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_DTL_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_dtl_get(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_DTL_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 16 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_dtl_get " "Unable to get dispatch trace log state from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 499 "trace/trace-target_ppc.h"
        } else {
#line 16 "../target/ppc/trace-events"
            qemu_log("kvm_failed_dtl_get " "Unable to get dispatch trace log state from KVM: %s" "\n", msg);
#line 503 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_dtl_get(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_dtl_get(msg);
    }
}

#define TRACE_KVM_FAILED_VPA_ADDR_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_VPA_ADDR_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_vpa_addr_set(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_VPA_ADDR_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 17 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_vpa_addr_set " "Unable to set VPA address to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 530 "trace/trace-target_ppc.h"
        } else {
#line 17 "../target/ppc/trace-events"
            qemu_log("kvm_failed_vpa_addr_set " "Unable to set VPA address to KVM: %s" "\n", msg);
#line 534 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_vpa_addr_set(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_vpa_addr_set(msg);
    }
}

#define TRACE_KVM_FAILED_SLB_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_SLB_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_slb_set(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_SLB_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 18 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_slb_set " "Unable to set SLB shadow state to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 561 "trace/trace-target_ppc.h"
        } else {
#line 18 "../target/ppc/trace-events"
            qemu_log("kvm_failed_slb_set " "Unable to set SLB shadow state to KVM: %s" "\n", msg);
#line 565 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_slb_set(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_slb_set(msg);
    }
}

#define TRACE_KVM_FAILED_DTL_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_DTL_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_dtl_set(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_DTL_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 19 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_dtl_set " "Unable to set dispatch trace log state to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 592 "trace/trace-target_ppc.h"
        } else {
#line 19 "../target/ppc/trace-events"
            qemu_log("kvm_failed_dtl_set " "Unable to set dispatch trace log state to KVM: %s" "\n", msg);
#line 596 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_dtl_set(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_dtl_set(msg);
    }
}

#define TRACE_KVM_FAILED_NULL_VPA_ADDR_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_NULL_VPA_ADDR_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_null_vpa_addr_set(const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_NULL_VPA_ADDR_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 20 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_null_vpa_addr_set " "Unable to set VPA address to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 623 "trace/trace-target_ppc.h"
        } else {
#line 20 "../target/ppc/trace-events"
            qemu_log("kvm_failed_null_vpa_addr_set " "Unable to set VPA address to KVM: %s" "\n", msg);
#line 627 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_null_vpa_addr_set(const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_null_vpa_addr_set(msg);
    }
}

#define TRACE_KVM_FAILED_PUT_VPA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_PUT_VPA) || \
    false)

static inline void _nocheck__trace_kvm_failed_put_vpa(void)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_PUT_VPA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 21 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_put_vpa " "Warning: Unable to set VPA information to KVM" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 654 "trace/trace-target_ppc.h"
        } else {
#line 21 "../target/ppc/trace-events"
            qemu_log("kvm_failed_put_vpa " "Warning: Unable to set VPA information to KVM" "\n");
#line 658 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_put_vpa(void)
{
    if (true) {
        _nocheck__trace_kvm_failed_put_vpa();
    }
}

#define TRACE_KVM_FAILED_GET_VPA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_GET_VPA) || \
    false)

static inline void _nocheck__trace_kvm_failed_get_vpa(void)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_GET_VPA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 22 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_get_vpa " "Warning: Unable to get VPA information from KVM" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 685 "trace/trace-target_ppc.h"
        } else {
#line 22 "../target/ppc/trace-events"
            qemu_log("kvm_failed_get_vpa " "Warning: Unable to get VPA information from KVM" "\n");
#line 689 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_failed_get_vpa(void)
{
    if (true) {
        _nocheck__trace_kvm_failed_get_vpa();
    }
}

#define TRACE_KVM_HANDLE_DCR_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_DCR_WRITE) || \
    false)

static inline void _nocheck__trace_kvm_handle_dcr_write(void)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_DCR_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 23 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_dcr_write " "handle dcr write" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 716 "trace/trace-target_ppc.h"
        } else {
#line 23 "../target/ppc/trace-events"
            qemu_log("kvm_handle_dcr_write " "handle dcr write" "\n");
#line 720 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_dcr_write(void)
{
    if (true) {
        _nocheck__trace_kvm_handle_dcr_write();
    }
}

#define TRACE_KVM_HANDLE_DCR_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_DCR_READ) || \
    false)

static inline void _nocheck__trace_kvm_handle_dcr_read(void)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_DCR_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 24 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_dcr_read " "handle dcr read" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 747 "trace/trace-target_ppc.h"
        } else {
#line 24 "../target/ppc/trace-events"
            qemu_log("kvm_handle_dcr_read " "handle dcr read" "\n");
#line 751 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_dcr_read(void)
{
    if (true) {
        _nocheck__trace_kvm_handle_dcr_read();
    }
}

#define TRACE_KVM_HANDLE_HALT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_HALT) || \
    false)

static inline void _nocheck__trace_kvm_handle_halt(void)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_HALT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 25 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_halt " "handle halt" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 778 "trace/trace-target_ppc.h"
        } else {
#line 25 "../target/ppc/trace-events"
            qemu_log("kvm_handle_halt " "handle halt" "\n");
#line 782 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_halt(void)
{
    if (true) {
        _nocheck__trace_kvm_handle_halt();
    }
}

#define TRACE_KVM_HANDLE_PAPR_HCALL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_PAPR_HCALL) || \
    false)

static inline void _nocheck__trace_kvm_handle_papr_hcall(uint64_t hcall)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_PAPR_HCALL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 26 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_papr_hcall " "0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , hcall);
#line 809 "trace/trace-target_ppc.h"
        } else {
#line 26 "../target/ppc/trace-events"
            qemu_log("kvm_handle_papr_hcall " "0x%" PRIx64 "\n", hcall);
#line 813 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_papr_hcall(uint64_t hcall)
{
    if (true) {
        _nocheck__trace_kvm_handle_papr_hcall(hcall);
    }
}

#define TRACE_KVM_HANDLE_EPR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_EPR) || \
    false)

static inline void _nocheck__trace_kvm_handle_epr(void)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_EPR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 27 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_epr " "handle epr" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 840 "trace/trace-target_ppc.h"
        } else {
#line 27 "../target/ppc/trace-events"
            qemu_log("kvm_handle_epr " "handle epr" "\n");
#line 844 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_epr(void)
{
    if (true) {
        _nocheck__trace_kvm_handle_epr();
    }
}

#define TRACE_KVM_HANDLE_WATCHDOG_EXPIRY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_WATCHDOG_EXPIRY) || \
    false)

static inline void _nocheck__trace_kvm_handle_watchdog_expiry(void)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_WATCHDOG_EXPIRY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 28 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_watchdog_expiry " "handle watchdog expiry" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 871 "trace/trace-target_ppc.h"
        } else {
#line 28 "../target/ppc/trace-events"
            qemu_log("kvm_handle_watchdog_expiry " "handle watchdog expiry" "\n");
#line 875 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_watchdog_expiry(void)
{
    if (true) {
        _nocheck__trace_kvm_handle_watchdog_expiry();
    }
}

#define TRACE_KVM_HANDLE_DEBUG_EXCEPTION_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_DEBUG_EXCEPTION) || \
    false)

static inline void _nocheck__trace_kvm_handle_debug_exception(void)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_DEBUG_EXCEPTION) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 29 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_debug_exception " "handle debug exception" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 902 "trace/trace-target_ppc.h"
        } else {
#line 29 "../target/ppc/trace-events"
            qemu_log("kvm_handle_debug_exception " "handle debug exception" "\n");
#line 906 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_debug_exception(void)
{
    if (true) {
        _nocheck__trace_kvm_handle_debug_exception();
    }
}

#define TRACE_KVM_HANDLE_NMI_EXCEPTION_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_HANDLE_NMI_EXCEPTION) || \
    false)

static inline void _nocheck__trace_kvm_handle_nmi_exception(void)
{
    if (trace_event_get_state(TRACE_KVM_HANDLE_NMI_EXCEPTION) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 30 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_handle_nmi_exception " "handle NMI exception" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 933 "trace/trace-target_ppc.h"
        } else {
#line 30 "../target/ppc/trace-events"
            qemu_log("kvm_handle_nmi_exception " "handle NMI exception" "\n");
#line 937 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_kvm_handle_nmi_exception(void)
{
    if (true) {
        _nocheck__trace_kvm_handle_nmi_exception();
    }
}

#define TRACE_PPC_EXCP_RFI_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PPC_EXCP_RFI) || \
    false)

static inline void _nocheck__trace_ppc_excp_rfi(uint64_t nip, uint64_t msr)
{
    if (trace_event_get_state(TRACE_PPC_EXCP_RFI) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 33 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:ppc_excp_rfi " "Return from exception at 0x%" PRIx64 " with flags 0x%016" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , nip, msr);
#line 964 "trace/trace-target_ppc.h"
        } else {
#line 33 "../target/ppc/trace-events"
            qemu_log("ppc_excp_rfi " "Return from exception at 0x%" PRIx64 " with flags 0x%016" PRIx64 "\n", nip, msr);
#line 968 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_ppc_excp_rfi(uint64_t nip, uint64_t msr)
{
    if (true) {
        _nocheck__trace_ppc_excp_rfi(nip, msr);
    }
}

#define TRACE_PPC_EXCP_DSI_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PPC_EXCP_DSI) || \
    false)

static inline void _nocheck__trace_ppc_excp_dsi(uint64_t dsisr, uint64_t dar)
{
    if (trace_event_get_state(TRACE_PPC_EXCP_DSI) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 34 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:ppc_excp_dsi " "DSI exception: DSISR=0x%" PRIx64 " DAR=0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , dsisr, dar);
#line 995 "trace/trace-target_ppc.h"
        } else {
#line 34 "../target/ppc/trace-events"
            qemu_log("ppc_excp_dsi " "DSI exception: DSISR=0x%" PRIx64 " DAR=0x%" PRIx64 "\n", dsisr, dar);
#line 999 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_ppc_excp_dsi(uint64_t dsisr, uint64_t dar)
{
    if (true) {
        _nocheck__trace_ppc_excp_dsi(dsisr, dar);
    }
}

#define TRACE_PPC_EXCP_ISI_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PPC_EXCP_ISI) || \
    false)

static inline void _nocheck__trace_ppc_excp_isi(uint64_t msr, uint64_t nip)
{
    if (trace_event_get_state(TRACE_PPC_EXCP_ISI) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 35 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:ppc_excp_isi " "ISI exception: msr=0x%016" PRIx64 " nip=0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msr, nip);
#line 1026 "trace/trace-target_ppc.h"
        } else {
#line 35 "../target/ppc/trace-events"
            qemu_log("ppc_excp_isi " "ISI exception: msr=0x%016" PRIx64 " nip=0x%" PRIx64 "\n", msr, nip);
#line 1030 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_ppc_excp_isi(uint64_t msr, uint64_t nip)
{
    if (true) {
        _nocheck__trace_ppc_excp_isi(msr, nip);
    }
}

#define TRACE_PPC_EXCP_FP_IGNORE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PPC_EXCP_FP_IGNORE) || \
    false)

static inline void _nocheck__trace_ppc_excp_fp_ignore(void)
{
    if (trace_event_get_state(TRACE_PPC_EXCP_FP_IGNORE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 36 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:ppc_excp_fp_ignore " "Ignore floating point exception" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1057 "trace/trace-target_ppc.h"
        } else {
#line 36 "../target/ppc/trace-events"
            qemu_log("ppc_excp_fp_ignore " "Ignore floating point exception" "\n");
#line 1061 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_ppc_excp_fp_ignore(void)
{
    if (true) {
        _nocheck__trace_ppc_excp_fp_ignore();
    }
}

#define TRACE_PPC_EXCP_INVAL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PPC_EXCP_INVAL) || \
    false)

static inline void _nocheck__trace_ppc_excp_inval(uint64_t nip)
{
    if (trace_event_get_state(TRACE_PPC_EXCP_INVAL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 37 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:ppc_excp_inval " "Invalid instruction at 0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , nip);
#line 1088 "trace/trace-target_ppc.h"
        } else {
#line 37 "../target/ppc/trace-events"
            qemu_log("ppc_excp_inval " "Invalid instruction at 0x%" PRIx64 "\n", nip);
#line 1092 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_ppc_excp_inval(uint64_t nip)
{
    if (true) {
        _nocheck__trace_ppc_excp_inval(nip);
    }
}

#define TRACE_PPC_EXCP_PRINT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PPC_EXCP_PRINT) || \
    false)

static inline void _nocheck__trace_ppc_excp_print(const char * excp)
{
    if (trace_event_get_state(TRACE_PPC_EXCP_PRINT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 38 "../target/ppc/trace-events"
            qemu_log("%d@%zu.%06zu:ppc_excp_print " "%s exception" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , excp);
#line 1119 "trace/trace-target_ppc.h"
        } else {
#line 38 "../target/ppc/trace-events"
            qemu_log("ppc_excp_print " "%s exception" "\n", excp);
#line 1123 "trace/trace-target_ppc.h"
        }
    }
}

static inline void trace_ppc_excp_print(const char * excp)
{
    if (true) {
        _nocheck__trace_ppc_excp_print(excp);
    }
}
#endif /* TRACE_TARGET_PPC_GENERATED_TRACERS_H */