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

#ifndef TRACE_BACKENDS_TPM_GENERATED_TRACERS_H
#define TRACE_BACKENDS_TPM_GENERATED_TRACERS_H

#include "trace/control.h"

extern TraceEvent _TRACE_TPM_PASSTHROUGH_HANDLE_REQUEST_EVENT;
extern TraceEvent _TRACE_TPM_PASSTHROUGH_RESET_EVENT;
extern TraceEvent _TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN_EVENT;
extern TraceEvent _TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN_EVENT;
extern TraceEvent _TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN2_EVENT;
extern TraceEvent _TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN2_EVENT;
extern TraceEvent _TRACE_TPM_UTIL_GET_BUFFER_SIZE_EVENT;
extern TraceEvent _TRACE_TPM_UTIL_SHOW_BUFFER_HEADER_EVENT;
extern TraceEvent _TRACE_TPM_UTIL_SHOW_BUFFER_CONTENT_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_SET_LOCALITY_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_HANDLE_REQUEST_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_PROBE_CAPS_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_SET_BUFFER_SIZE_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_STARTUP_TPM_RESUME_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_GET_TPM_ESTABLISHED_FLAG_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_CANCEL_CMD_NOT_SUPT_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_LOCK_STORAGE_CMD_NOT_SUPT_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_VM_STATE_CHANGE_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM12_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM2_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_UNSPEC_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_STARTUP_ERROR_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_GET_STATE_BLOB_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_SET_STATE_BLOB_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_SET_STATE_BLOBS_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_SET_STATE_BLOBS_ERROR_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_SET_STATE_BLOBS_DONE_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_PRE_SAVE_EVENT;
extern TraceEvent _TRACE_TPM_EMULATOR_INST_INIT_EVENT;
extern uint16_t _TRACE_TPM_PASSTHROUGH_HANDLE_REQUEST_DSTATE;
extern uint16_t _TRACE_TPM_PASSTHROUGH_RESET_DSTATE;
extern uint16_t _TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN_DSTATE;
extern uint16_t _TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN_DSTATE;
extern uint16_t _TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN2_DSTATE;
extern uint16_t _TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN2_DSTATE;
extern uint16_t _TRACE_TPM_UTIL_GET_BUFFER_SIZE_DSTATE;
extern uint16_t _TRACE_TPM_UTIL_SHOW_BUFFER_HEADER_DSTATE;
extern uint16_t _TRACE_TPM_UTIL_SHOW_BUFFER_CONTENT_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_SET_LOCALITY_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_HANDLE_REQUEST_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_PROBE_CAPS_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_SET_BUFFER_SIZE_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_STARTUP_TPM_RESUME_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_GET_TPM_ESTABLISHED_FLAG_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_CANCEL_CMD_NOT_SUPT_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_LOCK_STORAGE_CMD_NOT_SUPT_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_VM_STATE_CHANGE_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM12_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM2_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_UNSPEC_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_STARTUP_ERROR_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_GET_STATE_BLOB_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_SET_STATE_BLOB_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_SET_STATE_BLOBS_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_SET_STATE_BLOBS_ERROR_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_SET_STATE_BLOBS_DONE_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_PRE_SAVE_DSTATE;
extern uint16_t _TRACE_TPM_EMULATOR_INST_INIT_DSTATE;
#define TRACE_TPM_PASSTHROUGH_HANDLE_REQUEST_ENABLED 1
#define TRACE_TPM_PASSTHROUGH_RESET_ENABLED 1
#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN_ENABLED 1
#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN_ENABLED 1
#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN2_ENABLED 1
#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN2_ENABLED 1
#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_ENABLED 1
#define TRACE_TPM_UTIL_SHOW_BUFFER_HEADER_ENABLED 1
#define TRACE_TPM_UTIL_SHOW_BUFFER_CONTENT_ENABLED 1
#define TRACE_TPM_EMULATOR_SET_LOCALITY_ENABLED 1
#define TRACE_TPM_EMULATOR_HANDLE_REQUEST_ENABLED 1
#define TRACE_TPM_EMULATOR_PROBE_CAPS_ENABLED 1
#define TRACE_TPM_EMULATOR_SET_BUFFER_SIZE_ENABLED 1
#define TRACE_TPM_EMULATOR_STARTUP_TPM_RESUME_ENABLED 1
#define TRACE_TPM_EMULATOR_GET_TPM_ESTABLISHED_FLAG_ENABLED 1
#define TRACE_TPM_EMULATOR_CANCEL_CMD_NOT_SUPT_ENABLED 1
#define TRACE_TPM_EMULATOR_LOCK_STORAGE_CMD_NOT_SUPT_ENABLED 1
#define TRACE_TPM_EMULATOR_VM_STATE_CHANGE_ENABLED 1
#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM12_ENABLED 1
#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM2_ENABLED 1
#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_UNSPEC_ENABLED 1
#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_STARTUP_ERROR_ENABLED 1
#define TRACE_TPM_EMULATOR_GET_STATE_BLOB_ENABLED 1
#define TRACE_TPM_EMULATOR_SET_STATE_BLOB_ENABLED 1
#define TRACE_TPM_EMULATOR_SET_STATE_BLOBS_ENABLED 1
#define TRACE_TPM_EMULATOR_SET_STATE_BLOBS_ERROR_ENABLED 1
#define TRACE_TPM_EMULATOR_SET_STATE_BLOBS_DONE_ENABLED 1
#define TRACE_TPM_EMULATOR_PRE_SAVE_ENABLED 1
#define TRACE_TPM_EMULATOR_INST_INIT_ENABLED 1
#include "qemu/log-for-trace.h"
#include "qemu/error-report.h"


#define TRACE_TPM_PASSTHROUGH_HANDLE_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_PASSTHROUGH_HANDLE_REQUEST) || \
    false)

static inline void _nocheck__trace_tpm_passthrough_handle_request(void * cmd)
{
    if (trace_event_get_state(TRACE_TPM_PASSTHROUGH_HANDLE_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 4 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_passthrough_handle_request " "processing command %p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cmd);
#line 115 "trace/trace-backends_tpm.h"
        } else {
#line 4 "../backends/tpm/trace-events"
            qemu_log("tpm_passthrough_handle_request " "processing command %p" "\n", cmd);
#line 119 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_passthrough_handle_request(void * cmd)
{
    if (true) {
        _nocheck__trace_tpm_passthrough_handle_request(cmd);
    }
}

#define TRACE_TPM_PASSTHROUGH_RESET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_PASSTHROUGH_RESET) || \
    false)

static inline void _nocheck__trace_tpm_passthrough_reset(void)
{
    if (trace_event_get_state(TRACE_TPM_PASSTHROUGH_RESET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 5 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_passthrough_reset " "reset" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 146 "trace/trace-backends_tpm.h"
        } else {
#line 5 "../backends/tpm/trace-events"
            qemu_log("tpm_passthrough_reset " "reset" "\n");
#line 150 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_passthrough_reset(void)
{
    if (true) {
        _nocheck__trace_tpm_passthrough_reset();
    }
}

#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN) || \
    false)

static inline void _nocheck__trace_tpm_util_get_buffer_size_hdr_len(uint32_t len, size_t expected)
{
    if (trace_event_get_state(TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 8 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_util_get_buffer_size_hdr_len " "tpm_resp->hdr.len = %u, expected = %zu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len, expected);
#line 177 "trace/trace-backends_tpm.h"
        } else {
#line 8 "../backends/tpm/trace-events"
            qemu_log("tpm_util_get_buffer_size_hdr_len " "tpm_resp->hdr.len = %u, expected = %zu" "\n", len, expected);
#line 181 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_util_get_buffer_size_hdr_len(uint32_t len, size_t expected)
{
    if (true) {
        _nocheck__trace_tpm_util_get_buffer_size_hdr_len(len, expected);
    }
}

#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN) || \
    false)

static inline void _nocheck__trace_tpm_util_get_buffer_size_len(uint32_t len, size_t expected)
{
    if (trace_event_get_state(TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 9 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_util_get_buffer_size_len " "tpm_resp->len = %u, expected = %zu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len, expected);
#line 208 "trace/trace-backends_tpm.h"
        } else {
#line 9 "../backends/tpm/trace-events"
            qemu_log("tpm_util_get_buffer_size_len " "tpm_resp->len = %u, expected = %zu" "\n", len, expected);
#line 212 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_util_get_buffer_size_len(uint32_t len, size_t expected)
{
    if (true) {
        _nocheck__trace_tpm_util_get_buffer_size_len(len, expected);
    }
}

#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN2_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN2) || \
    false)

static inline void _nocheck__trace_tpm_util_get_buffer_size_hdr_len2(uint32_t len, size_t expected)
{
    if (trace_event_get_state(TRACE_TPM_UTIL_GET_BUFFER_SIZE_HDR_LEN2) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 10 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_util_get_buffer_size_hdr_len2 " "tpm2_resp->hdr.len = %u, expected = %zu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len, expected);
#line 239 "trace/trace-backends_tpm.h"
        } else {
#line 10 "../backends/tpm/trace-events"
            qemu_log("tpm_util_get_buffer_size_hdr_len2 " "tpm2_resp->hdr.len = %u, expected = %zu" "\n", len, expected);
#line 243 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_util_get_buffer_size_hdr_len2(uint32_t len, size_t expected)
{
    if (true) {
        _nocheck__trace_tpm_util_get_buffer_size_hdr_len2(len, expected);
    }
}

#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN2_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN2) || \
    false)

static inline void _nocheck__trace_tpm_util_get_buffer_size_len2(uint32_t len, size_t expected)
{
    if (trace_event_get_state(TRACE_TPM_UTIL_GET_BUFFER_SIZE_LEN2) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 11 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_util_get_buffer_size_len2 " "tpm2_resp->len = %u, expected = %zu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len, expected);
#line 270 "trace/trace-backends_tpm.h"
        } else {
#line 11 "../backends/tpm/trace-events"
            qemu_log("tpm_util_get_buffer_size_len2 " "tpm2_resp->len = %u, expected = %zu" "\n", len, expected);
#line 274 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_util_get_buffer_size_len2(uint32_t len, size_t expected)
{
    if (true) {
        _nocheck__trace_tpm_util_get_buffer_size_len2(len, expected);
    }
}

#define TRACE_TPM_UTIL_GET_BUFFER_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_UTIL_GET_BUFFER_SIZE) || \
    false)

static inline void _nocheck__trace_tpm_util_get_buffer_size(size_t len)
{
    if (trace_event_get_state(TRACE_TPM_UTIL_GET_BUFFER_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 12 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_util_get_buffer_size " "buffersize of device: %zu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , len);
#line 301 "trace/trace-backends_tpm.h"
        } else {
#line 12 "../backends/tpm/trace-events"
            qemu_log("tpm_util_get_buffer_size " "buffersize of device: %zu" "\n", len);
#line 305 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_util_get_buffer_size(size_t len)
{
    if (true) {
        _nocheck__trace_tpm_util_get_buffer_size(len);
    }
}

#define TRACE_TPM_UTIL_SHOW_BUFFER_HEADER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_UTIL_SHOW_BUFFER_HEADER) || \
    false)

static inline void _nocheck__trace_tpm_util_show_buffer_header(const char * direction, size_t len)
{
    if (trace_event_get_state(TRACE_TPM_UTIL_SHOW_BUFFER_HEADER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 13 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_util_show_buffer_header " "direction: %s len: %zu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , direction, len);
#line 332 "trace/trace-backends_tpm.h"
        } else {
#line 13 "../backends/tpm/trace-events"
            qemu_log("tpm_util_show_buffer_header " "direction: %s len: %zu" "\n", direction, len);
#line 336 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_util_show_buffer_header(const char * direction, size_t len)
{
    if (true) {
        _nocheck__trace_tpm_util_show_buffer_header(direction, len);
    }
}

#define TRACE_TPM_UTIL_SHOW_BUFFER_CONTENT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_UTIL_SHOW_BUFFER_CONTENT) || \
    false)

static inline void _nocheck__trace_tpm_util_show_buffer_content(const char * buf)
{
    if (trace_event_get_state(TRACE_TPM_UTIL_SHOW_BUFFER_CONTENT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 14 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_util_show_buffer_content " "%s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , buf);
#line 363 "trace/trace-backends_tpm.h"
        } else {
#line 14 "../backends/tpm/trace-events"
            qemu_log("tpm_util_show_buffer_content " "%s" "\n", buf);
#line 367 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_util_show_buffer_content(const char * buf)
{
    if (true) {
        _nocheck__trace_tpm_util_show_buffer_content(buf);
    }
}

#define TRACE_TPM_EMULATOR_SET_LOCALITY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_SET_LOCALITY) || \
    false)

static inline void _nocheck__trace_tpm_emulator_set_locality(uint8_t locty)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_SET_LOCALITY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 17 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_set_locality " "setting locality to %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , locty);
#line 394 "trace/trace-backends_tpm.h"
        } else {
#line 17 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_set_locality " "setting locality to %d" "\n", locty);
#line 398 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_set_locality(uint8_t locty)
{
    if (true) {
        _nocheck__trace_tpm_emulator_set_locality(locty);
    }
}

#define TRACE_TPM_EMULATOR_HANDLE_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_HANDLE_REQUEST) || \
    false)

static inline void _nocheck__trace_tpm_emulator_handle_request(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_HANDLE_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 18 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_handle_request " "processing TPM command" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 425 "trace/trace-backends_tpm.h"
        } else {
#line 18 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_handle_request " "processing TPM command" "\n");
#line 429 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_handle_request(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_handle_request();
    }
}

#define TRACE_TPM_EMULATOR_PROBE_CAPS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_PROBE_CAPS) || \
    false)

static inline void _nocheck__trace_tpm_emulator_probe_caps(uint32_t caps)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_PROBE_CAPS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 19 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_probe_caps " "capabilities: 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , caps);
#line 456 "trace/trace-backends_tpm.h"
        } else {
#line 19 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_probe_caps " "capabilities: 0x%x" "\n", caps);
#line 460 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_probe_caps(uint32_t caps)
{
    if (true) {
        _nocheck__trace_tpm_emulator_probe_caps(caps);
    }
}

#define TRACE_TPM_EMULATOR_SET_BUFFER_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_SET_BUFFER_SIZE) || \
    false)

static inline void _nocheck__trace_tpm_emulator_set_buffer_size(uint32_t buffersize, uint32_t minsize, uint32_t maxsize)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_SET_BUFFER_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 20 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_set_buffer_size " "buffer size: %u, min: %u, max: %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , buffersize, minsize, maxsize);
#line 487 "trace/trace-backends_tpm.h"
        } else {
#line 20 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_set_buffer_size " "buffer size: %u, min: %u, max: %u" "\n", buffersize, minsize, maxsize);
#line 491 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_set_buffer_size(uint32_t buffersize, uint32_t minsize, uint32_t maxsize)
{
    if (true) {
        _nocheck__trace_tpm_emulator_set_buffer_size(buffersize, minsize, maxsize);
    }
}

#define TRACE_TPM_EMULATOR_STARTUP_TPM_RESUME_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_STARTUP_TPM_RESUME) || \
    false)

static inline void _nocheck__trace_tpm_emulator_startup_tpm_resume(bool is_resume, size_t buffersize)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_STARTUP_TPM_RESUME) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 21 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_startup_tpm_resume " "is_resume: %d, buffer size: %zu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , is_resume, buffersize);
#line 518 "trace/trace-backends_tpm.h"
        } else {
#line 21 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_startup_tpm_resume " "is_resume: %d, buffer size: %zu" "\n", is_resume, buffersize);
#line 522 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_startup_tpm_resume(bool is_resume, size_t buffersize)
{
    if (true) {
        _nocheck__trace_tpm_emulator_startup_tpm_resume(is_resume, buffersize);
    }
}

#define TRACE_TPM_EMULATOR_GET_TPM_ESTABLISHED_FLAG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_GET_TPM_ESTABLISHED_FLAG) || \
    false)

static inline void _nocheck__trace_tpm_emulator_get_tpm_established_flag(uint8_t flag)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_GET_TPM_ESTABLISHED_FLAG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 22 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_get_tpm_established_flag " "got established flag: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , flag);
#line 549 "trace/trace-backends_tpm.h"
        } else {
#line 22 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_get_tpm_established_flag " "got established flag: %d" "\n", flag);
#line 553 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_get_tpm_established_flag(uint8_t flag)
{
    if (true) {
        _nocheck__trace_tpm_emulator_get_tpm_established_flag(flag);
    }
}

#define TRACE_TPM_EMULATOR_CANCEL_CMD_NOT_SUPT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_CANCEL_CMD_NOT_SUPT) || \
    false)

static inline void _nocheck__trace_tpm_emulator_cancel_cmd_not_supt(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_CANCEL_CMD_NOT_SUPT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 23 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_cancel_cmd_not_supt " "Backend does not support CANCEL_TPM_CMD" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 580 "trace/trace-backends_tpm.h"
        } else {
#line 23 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_cancel_cmd_not_supt " "Backend does not support CANCEL_TPM_CMD" "\n");
#line 584 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_cancel_cmd_not_supt(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_cancel_cmd_not_supt();
    }
}

#define TRACE_TPM_EMULATOR_LOCK_STORAGE_CMD_NOT_SUPT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_LOCK_STORAGE_CMD_NOT_SUPT) || \
    false)

static inline void _nocheck__trace_tpm_emulator_lock_storage_cmd_not_supt(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_LOCK_STORAGE_CMD_NOT_SUPT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 24 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_lock_storage_cmd_not_supt " "Backend does not support LOCK_STORAGE" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 611 "trace/trace-backends_tpm.h"
        } else {
#line 24 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_lock_storage_cmd_not_supt " "Backend does not support LOCK_STORAGE" "\n");
#line 615 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_lock_storage_cmd_not_supt(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_lock_storage_cmd_not_supt();
    }
}

#define TRACE_TPM_EMULATOR_VM_STATE_CHANGE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_VM_STATE_CHANGE) || \
    false)

static inline void _nocheck__trace_tpm_emulator_vm_state_change(int running, int state)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_VM_STATE_CHANGE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 25 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_vm_state_change " "state change to running %d state %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , running, state);
#line 642 "trace/trace-backends_tpm.h"
        } else {
#line 25 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_vm_state_change " "state change to running %d state %d" "\n", running, state);
#line 646 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_vm_state_change(int running, int state)
{
    if (true) {
        _nocheck__trace_tpm_emulator_vm_state_change(running, state);
    }
}

#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM12_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM12) || \
    false)

static inline void _nocheck__trace_tpm_emulator_handle_device_opts_tpm12(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM12) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 26 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_handle_device_opts_tpm12 " "TPM Version 1.2" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 673 "trace/trace-backends_tpm.h"
        } else {
#line 26 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_handle_device_opts_tpm12 " "TPM Version 1.2" "\n");
#line 677 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_handle_device_opts_tpm12(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_handle_device_opts_tpm12();
    }
}

#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM2_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM2) || \
    false)

static inline void _nocheck__trace_tpm_emulator_handle_device_opts_tpm2(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_TPM2) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 27 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_handle_device_opts_tpm2 " "TPM Version 2" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 704 "trace/trace-backends_tpm.h"
        } else {
#line 27 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_handle_device_opts_tpm2 " "TPM Version 2" "\n");
#line 708 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_handle_device_opts_tpm2(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_handle_device_opts_tpm2();
    }
}

#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_UNSPEC_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_UNSPEC) || \
    false)

static inline void _nocheck__trace_tpm_emulator_handle_device_opts_unspec(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_UNSPEC) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 28 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_handle_device_opts_unspec " "TPM Version Unspecified" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 735 "trace/trace-backends_tpm.h"
        } else {
#line 28 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_handle_device_opts_unspec " "TPM Version Unspecified" "\n");
#line 739 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_handle_device_opts_unspec(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_handle_device_opts_unspec();
    }
}

#define TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_STARTUP_ERROR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_STARTUP_ERROR) || \
    false)

static inline void _nocheck__trace_tpm_emulator_handle_device_opts_startup_error(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_HANDLE_DEVICE_OPTS_STARTUP_ERROR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 29 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_handle_device_opts_startup_error " "Startup error" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 766 "trace/trace-backends_tpm.h"
        } else {
#line 29 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_handle_device_opts_startup_error " "Startup error" "\n");
#line 770 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_handle_device_opts_startup_error(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_handle_device_opts_startup_error();
    }
}

#define TRACE_TPM_EMULATOR_GET_STATE_BLOB_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_GET_STATE_BLOB) || \
    false)

static inline void _nocheck__trace_tpm_emulator_get_state_blob(uint8_t type, uint32_t size, uint32_t flags)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_GET_STATE_BLOB) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 30 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_get_state_blob " "got state blob type %d, %u bytes, flags 0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , type, size, flags);
#line 797 "trace/trace-backends_tpm.h"
        } else {
#line 30 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_get_state_blob " "got state blob type %d, %u bytes, flags 0x%08x" "\n", type, size, flags);
#line 801 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_get_state_blob(uint8_t type, uint32_t size, uint32_t flags)
{
    if (true) {
        _nocheck__trace_tpm_emulator_get_state_blob(type, size, flags);
    }
}

#define TRACE_TPM_EMULATOR_SET_STATE_BLOB_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_SET_STATE_BLOB) || \
    false)

static inline void _nocheck__trace_tpm_emulator_set_state_blob(uint8_t type, uint32_t size, uint32_t flags)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_SET_STATE_BLOB) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 31 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_set_state_blob " "set state blob type %d, %u bytes, flags 0x%08x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , type, size, flags);
#line 828 "trace/trace-backends_tpm.h"
        } else {
#line 31 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_set_state_blob " "set state blob type %d, %u bytes, flags 0x%08x" "\n", type, size, flags);
#line 832 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_set_state_blob(uint8_t type, uint32_t size, uint32_t flags)
{
    if (true) {
        _nocheck__trace_tpm_emulator_set_state_blob(type, size, flags);
    }
}

#define TRACE_TPM_EMULATOR_SET_STATE_BLOBS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_SET_STATE_BLOBS) || \
    false)

static inline void _nocheck__trace_tpm_emulator_set_state_blobs(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_SET_STATE_BLOBS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 32 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_set_state_blobs " "setting state blobs" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 859 "trace/trace-backends_tpm.h"
        } else {
#line 32 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_set_state_blobs " "setting state blobs" "\n");
#line 863 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_set_state_blobs(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_set_state_blobs();
    }
}

#define TRACE_TPM_EMULATOR_SET_STATE_BLOBS_ERROR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_SET_STATE_BLOBS_ERROR) || \
    false)

static inline void _nocheck__trace_tpm_emulator_set_state_blobs_error(const char * msg)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_SET_STATE_BLOBS_ERROR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 33 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_set_state_blobs_error " "error while setting state blobs: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 890 "trace/trace-backends_tpm.h"
        } else {
#line 33 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_set_state_blobs_error " "error while setting state blobs: %s" "\n", msg);
#line 894 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_set_state_blobs_error(const char * msg)
{
    if (true) {
        _nocheck__trace_tpm_emulator_set_state_blobs_error(msg);
    }
}

#define TRACE_TPM_EMULATOR_SET_STATE_BLOBS_DONE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_SET_STATE_BLOBS_DONE) || \
    false)

static inline void _nocheck__trace_tpm_emulator_set_state_blobs_done(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_SET_STATE_BLOBS_DONE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 34 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_set_state_blobs_done " "Done setting state blobs" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 921 "trace/trace-backends_tpm.h"
        } else {
#line 34 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_set_state_blobs_done " "Done setting state blobs" "\n");
#line 925 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_set_state_blobs_done(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_set_state_blobs_done();
    }
}

#define TRACE_TPM_EMULATOR_PRE_SAVE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_PRE_SAVE) || \
    false)

static inline void _nocheck__trace_tpm_emulator_pre_save(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_PRE_SAVE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 35 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_pre_save " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 952 "trace/trace-backends_tpm.h"
        } else {
#line 35 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_pre_save " "" "\n");
#line 956 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_pre_save(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_pre_save();
    }
}

#define TRACE_TPM_EMULATOR_INST_INIT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TPM_EMULATOR_INST_INIT) || \
    false)

static inline void _nocheck__trace_tpm_emulator_inst_init(void)
{
    if (trace_event_get_state(TRACE_TPM_EMULATOR_INST_INIT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 36 "../backends/tpm/trace-events"
            qemu_log("%d@%zu.%06zu:tpm_emulator_inst_init " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 983 "trace/trace-backends_tpm.h"
        } else {
#line 36 "../backends/tpm/trace-events"
            qemu_log("tpm_emulator_inst_init " "" "\n");
#line 987 "trace/trace-backends_tpm.h"
        }
    }
}

static inline void trace_tpm_emulator_inst_init(void)
{
    if (true) {
        _nocheck__trace_tpm_emulator_inst_init();
    }
}
#endif /* TRACE_BACKENDS_TPM_GENERATED_TRACERS_H */