cpu.h 19.1 KB
Newer Older
A
Andreas Färber 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * QEMU CPU model
 *
 * Copyright (c) 2012 SUSE LINUX Products GmbH
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <http://www.gnu.org/licenses/gpl-2.0.html>
 */
#ifndef QEMU_CPU_H
#define QEMU_CPU_H

23
#include <signal.h>
24
#include <setjmp.h>
25
#include "hw/qdev-core.h"
26
#include "exec/hwaddr.h"
A
Andreas Färber 已提交
27
#include "qemu/queue.h"
28
#include "qemu/thread.h"
29
#include "qemu/tls.h"
30
#include "qemu/typedefs.h"
A
Andreas Färber 已提交
31

32 33
typedef int (*WriteCoreDumpFunction)(const void *buf, size_t size,
                                     void *opaque);
34

A
Andreas Färber 已提交
35 36 37 38 39 40 41 42 43 44 45 46
/**
 * vaddr:
 * Type wide enough to contain any #target_ulong virtual address.
 */
typedef uint64_t vaddr;
#define VADDR_PRId PRId64
#define VADDR_PRIu PRIu64
#define VADDR_PRIo PRIo64
#define VADDR_PRIx PRIx64
#define VADDR_PRIX PRIX64
#define VADDR_MAX UINT64_MAX

A
Andreas Färber 已提交
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
/**
 * SECTION:cpu
 * @section_id: QEMU-cpu
 * @title: CPU Class
 * @short_description: Base class for all CPUs
 */

#define TYPE_CPU "cpu"

#define CPU(obj) OBJECT_CHECK(CPUState, (obj), TYPE_CPU)
#define CPU_CLASS(class) OBJECT_CLASS_CHECK(CPUClass, (class), TYPE_CPU)
#define CPU_GET_CLASS(obj) OBJECT_GET_CLASS(CPUClass, (obj), TYPE_CPU)

typedef struct CPUState CPUState;

62 63 64 65
typedef void (*CPUUnassignedAccess)(CPUState *cpu, hwaddr addr,
                                    bool is_write, bool is_exec, int opaque,
                                    unsigned size);

66 67
struct TranslationBlock;

A
Andreas Färber 已提交
68 69
/**
 * CPUClass:
70 71
 * @class_by_name: Callback to map -cpu command line model name to an
 * instantiatable CPU type.
72
 * @parse_features: Callback to parse command line arguments.
73
 * @reset: Callback to reset the #CPUState to its initial state.
74
 * @reset_dump_flags: #CPUDumpFlags to use for reset logging.
75
 * @has_work: Callback for checking if there is work to do.
76
 * @do_interrupt: Callback for interrupt handling.
77
 * @do_unassigned_access: Callback for unassigned access handling.
78
 * @memory_rw_debug: Callback for GDB memory access.
79 80
 * @dump_state: Callback for dumping state.
 * @dump_statistics: Callback for dumping statistics.
81
 * @get_arch_id: Callback for getting architecture-dependent CPU ID.
82
 * @get_paging_enabled: Callback for inquiring whether paging is enabled.
83
 * @get_memory_mapping: Callback for obtaining the memory mappings.
84
 * @set_pc: Callback for setting the Program Counter register.
85 86
 * @synchronize_from_tb: Callback for synchronizing state from a TCG
 * #TranslationBlock.
87
 * @handle_mmu_fault: Callback for handling an MMU fault.
88
 * @get_phys_page_debug: Callback for obtaining a physical address.
89 90
 * @gdb_read_register: Callback for letting GDB read a register.
 * @gdb_write_register: Callback for letting GDB write a register.
91
 * @vmsd: State description for migration.
92
 * @gdb_num_core_regs: Number of core registers accessible to GDB.
93
 * @gdb_core_xml_file: File name for core registers GDB XML description.
A
Andreas Färber 已提交
94 95 96 97 98
 *
 * Represents a CPU family or model.
 */
typedef struct CPUClass {
    /*< private >*/
99
    DeviceClass parent_class;
A
Andreas Färber 已提交
100 101
    /*< public >*/

102
    ObjectClass *(*class_by_name)(const char *cpu_model);
103
    void (*parse_features)(CPUState *cpu, char *str, Error **errp);
104

A
Andreas Färber 已提交
105
    void (*reset)(CPUState *cpu);
106
    int reset_dump_flags;
107
    bool (*has_work)(CPUState *cpu);
108
    void (*do_interrupt)(CPUState *cpu);
109
    CPUUnassignedAccess do_unassigned_access;
110 111
    int (*memory_rw_debug)(CPUState *cpu, vaddr addr,
                           uint8_t *buf, int len, bool is_write);
112 113 114 115
    void (*dump_state)(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
                       int flags);
    void (*dump_statistics)(CPUState *cpu, FILE *f,
                            fprintf_function cpu_fprintf, int flags);
116
    int64_t (*get_arch_id)(CPUState *cpu);
117
    bool (*get_paging_enabled)(const CPUState *cpu);
118 119
    void (*get_memory_mapping)(CPUState *cpu, MemoryMappingList *list,
                               Error **errp);
120
    void (*set_pc)(CPUState *cpu, vaddr value);
121
    void (*synchronize_from_tb)(CPUState *cpu, struct TranslationBlock *tb);
122 123
    int (*handle_mmu_fault)(CPUState *cpu, vaddr address, int rw,
                            int mmu_index);
124
    hwaddr (*get_phys_page_debug)(CPUState *cpu, vaddr addr);
125 126
    int (*gdb_read_register)(CPUState *cpu, uint8_t *buf, int reg);
    int (*gdb_write_register)(CPUState *cpu, uint8_t *buf, int reg);
127

128 129 130 131 132 133 134 135
    int (*write_elf64_note)(WriteCoreDumpFunction f, CPUState *cpu,
                            int cpuid, void *opaque);
    int (*write_elf64_qemunote)(WriteCoreDumpFunction f, CPUState *cpu,
                                void *opaque);
    int (*write_elf32_note)(WriteCoreDumpFunction f, CPUState *cpu,
                            int cpuid, void *opaque);
    int (*write_elf32_qemunote)(WriteCoreDumpFunction f, CPUState *cpu,
                                void *opaque);
136 137 138

    const struct VMStateDescription *vmsd;
    int gdb_num_core_regs;
139
    const char *gdb_core_xml_file;
A
Andreas Färber 已提交
140 141
} CPUClass;

142 143 144 145 146 147 148 149 150 151 152 153
#ifdef HOST_WORDS_BIGENDIAN
typedef struct icount_decr_u16 {
    uint16_t high;
    uint16_t low;
} icount_decr_u16;
#else
typedef struct icount_decr_u16 {
    uint16_t low;
    uint16_t high;
} icount_decr_u16;
#endif

154 155 156 157 158 159
typedef struct CPUBreakpoint {
    vaddr pc;
    int flags; /* BP_* */
    QTAILQ_ENTRY(CPUBreakpoint) entry;
} CPUBreakpoint;

160 161 162 163 164 165 166
typedef struct CPUWatchpoint {
    vaddr vaddr;
    vaddr len_mask;
    int flags; /* BP_* */
    QTAILQ_ENTRY(CPUWatchpoint) entry;
} CPUWatchpoint;

167
struct KVMState;
A
Andreas Färber 已提交
168
struct kvm_run;
169

170 171 172
#define TB_JMP_CACHE_BITS 12
#define TB_JMP_CACHE_SIZE (1 << TB_JMP_CACHE_BITS)

A
Andreas Färber 已提交
173 174
/**
 * CPUState:
175
 * @cpu_index: CPU index (informative).
176 177
 * @nr_cores: Number of cores within this CPU package.
 * @nr_threads: Number of threads within this CPU.
178
 * @numa_node: NUMA node this CPU is belonging to.
179
 * @host_tid: Host thread ID.
180
 * @running: #true if CPU is currently running (usermode).
181
 * @created: Indicates whether the CPU thread has been successfully created.
182 183
 * @interrupt_request: Indicates a pending interrupt request.
 * @halted: Nonzero if the CPU is in suspended state.
A
Andreas Färber 已提交
184
 * @stop: Indicates a pending stop request.
185
 * @stopped: Indicates the CPU has been artificially stopped.
186 187
 * @tcg_exit_req: Set to force TCG to stop executing linked TBs for this
 *           CPU and return to its top level loop.
188
 * @singlestep_enabled: Flags for single-stepping.
189
 * @icount_extra: Instructions until next timer event.
190 191 192
 * @icount_decr: Number of cycles left, with interrupt flag in high bit.
 * This allows a single read-compare-cbranch-write sequence to test
 * for both decrementer underflow and exceptions.
193
 * @can_do_io: Nonzero if memory-mapped IO is safe.
194
 * @env_ptr: Pointer to subclass-specific CPUArchState field.
195
 * @current_tb: Currently executing TB.
196
 * @gdb_regs: Additional GDB registers.
197
 * @gdb_num_regs: Number of total registers accessible to GDB.
198
 * @gdb_num_g_regs: Number of registers in GDB 'g' packets.
199
 * @next_cpu: Next CPU sharing TB cache.
200
 * @opaque: User data.
201 202
 * @mem_io_pc: Host Program Counter at which the memory was accessed.
 * @mem_io_vaddr: Target virtual address at which the memory was accessed.
A
Andreas Färber 已提交
203
 * @kvm_fd: vCPU file descriptor for KVM.
A
Andreas Färber 已提交
204 205 206 207 208
 *
 * State of one CPU core or thread.
 */
struct CPUState {
    /*< private >*/
209
    DeviceState parent_obj;
A
Andreas Färber 已提交
210 211
    /*< public >*/

212 213
    int nr_cores;
    int nr_threads;
214
    int numa_node;
215

216
    struct QemuThread *thread;
217 218 219
#ifdef _WIN32
    HANDLE hThread;
#endif
A
Andreas Färber 已提交
220
    int thread_id;
221
    uint32_t host_tid;
222
    bool running;
A
Andreas Färber 已提交
223
    struct QemuCond *halt_cond;
224
    struct qemu_work_item *queued_work_first, *queued_work_last;
225
    bool thread_kicked;
226
    bool created;
A
Andreas Färber 已提交
227
    bool stop;
228
    bool stopped;
229
    volatile sig_atomic_t exit_request;
230
    uint32_t interrupt_request;
231
    int singlestep_enabled;
232
    int64_t icount_extra;
233
    sigjmp_buf jmp_env;
234

235 236 237
    AddressSpace *as;
    MemoryListener *tcg_as_listener;

238
    void *env_ptr; /* CPUArchState */
239
    struct TranslationBlock *current_tb;
240
    struct TranslationBlock *tb_jmp_cache[TB_JMP_CACHE_SIZE];
241
    struct GDBRegisterState *gdb_regs;
242
    int gdb_num_regs;
243
    int gdb_num_g_regs;
A
Andreas Färber 已提交
244
    QTAILQ_ENTRY(CPUState) node;
245

246 247 248
    /* ice debug support */
    QTAILQ_HEAD(breakpoints_head, CPUBreakpoint) breakpoints;

249 250 251
    QTAILQ_HEAD(watchpoints_head, CPUWatchpoint) watchpoints;
    CPUWatchpoint *watchpoint_hit;

252 253
    void *opaque;

254 255 256 257 258 259
    /* In order to avoid passing too many arguments to the MMIO helpers,
     * we store some rarely used information in the CPU context.
     */
    uintptr_t mem_io_pc;
    vaddr mem_io_vaddr;

A
Andreas Färber 已提交
260
    int kvm_fd;
A
Andreas Färber 已提交
261
    bool kvm_vcpu_dirty;
262
    struct KVMState *kvm_state;
A
Andreas Färber 已提交
263
    struct kvm_run *kvm_run;
A
Andreas Färber 已提交
264

265
    /* TODO Move common fields from CPUArchState here. */
266
    int cpu_index; /* used by alpha TCG */
267
    uint32_t halted; /* used by alpha, cris, ppc TCG */
268 269 270 271
    union {
        uint32_t u32;
        icount_decr_u16 u16;
    } icount_decr;
272
    uint32_t can_do_io;
273
    int32_t exception_index; /* used by m68k TCG */
274 275 276 277 278 279

    /* Note that this is accessed at the start of every TB via a negative
       offset from AREG0.  Leave this field at the end so as to make the
       (absolute value) offset as small as possible.  This reduces code
       size, especially for hosts without large memory offsets.  */
    volatile sig_atomic_t tcg_exit_req;
A
Andreas Färber 已提交
280 281
};

A
Andreas Färber 已提交
282 283 284 285 286 287 288
QTAILQ_HEAD(CPUTailQ, CPUState);
extern struct CPUTailQ cpus;
#define CPU_NEXT(cpu) QTAILQ_NEXT(cpu, node)
#define CPU_FOREACH(cpu) QTAILQ_FOREACH(cpu, &cpus, node)
#define CPU_FOREACH_SAFE(cpu, next_cpu) \
    QTAILQ_FOREACH_SAFE(cpu, &cpus, node, next_cpu)
#define first_cpu QTAILQ_FIRST(&cpus)
289

290 291 292
DECLARE_TLS(CPUState *, current_cpu);
#define current_cpu tls_var(current_cpu)

293 294 295 296 297 298 299 300
/**
 * cpu_paging_enabled:
 * @cpu: The CPU whose state is to be inspected.
 *
 * Returns: %true if paging is enabled, %false otherwise.
 */
bool cpu_paging_enabled(const CPUState *cpu);

301 302 303 304 305 306 307 308 309
/**
 * cpu_get_memory_mapping:
 * @cpu: The CPU whose memory mappings are to be obtained.
 * @list: Where to write the memory mappings to.
 * @errp: Pointer for reporting an #Error.
 */
void cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list,
                            Error **errp);

310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
/**
 * cpu_write_elf64_note:
 * @f: pointer to a function that writes memory to a file
 * @cpu: The CPU whose memory is to be dumped
 * @cpuid: ID number of the CPU
 * @opaque: pointer to the CPUState struct
 */
int cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu,
                         int cpuid, void *opaque);

/**
 * cpu_write_elf64_qemunote:
 * @f: pointer to a function that writes memory to a file
 * @cpu: The CPU whose memory is to be dumped
 * @cpuid: ID number of the CPU
 * @opaque: pointer to the CPUState struct
 */
int cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
                             void *opaque);

/**
 * cpu_write_elf32_note:
 * @f: pointer to a function that writes memory to a file
 * @cpu: The CPU whose memory is to be dumped
 * @cpuid: ID number of the CPU
 * @opaque: pointer to the CPUState struct
 */
int cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu,
                         int cpuid, void *opaque);

/**
 * cpu_write_elf32_qemunote:
 * @f: pointer to a function that writes memory to a file
 * @cpu: The CPU whose memory is to be dumped
 * @cpuid: ID number of the CPU
 * @opaque: pointer to the CPUState struct
 */
int cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
                             void *opaque);
A
Andreas Färber 已提交
349

350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
/**
 * CPUDumpFlags:
 * @CPU_DUMP_CODE:
 * @CPU_DUMP_FPU: dump FPU register state, not just integer
 * @CPU_DUMP_CCOP: dump info about TCG QEMU's condition code optimization state
 */
enum CPUDumpFlags {
    CPU_DUMP_CODE = 0x00010000,
    CPU_DUMP_FPU  = 0x00020000,
    CPU_DUMP_CCOP = 0x00040000,
};

/**
 * cpu_dump_state:
 * @cpu: The CPU whose state is to be dumped.
 * @f: File to dump to.
 * @cpu_fprintf: Function to dump with.
 * @flags: Flags what to dump.
 *
 * Dumps CPU state.
 */
void cpu_dump_state(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
                    int flags);

/**
 * cpu_dump_statistics:
 * @cpu: The CPU whose state is to be dumped.
 * @f: File to dump to.
 * @cpu_fprintf: Function to dump with.
 * @flags: Flags what to dump.
 *
 * Dumps CPU statistics.
 */
void cpu_dump_statistics(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
                         int flags);

386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
#ifndef CONFIG_USER_ONLY
/**
 * cpu_get_phys_page_debug:
 * @cpu: The CPU to obtain the physical page address for.
 * @addr: The virtual address.
 *
 * Obtains the physical page corresponding to a virtual one.
 * Use it only for debugging because no protection checks are done.
 *
 * Returns: Corresponding physical page address or -1 if no page found.
 */
static inline hwaddr cpu_get_phys_page_debug(CPUState *cpu, vaddr addr)
{
    CPUClass *cc = CPU_GET_CLASS(cpu);

    return cc->get_phys_page_debug(cpu, addr);
}
#endif

A
Andreas Färber 已提交
405 406 407 408 409 410
/**
 * cpu_reset:
 * @cpu: The CPU whose state is to be reset.
 */
void cpu_reset(CPUState *cpu);

411 412 413 414 415 416 417 418 419 420 421
/**
 * cpu_class_by_name:
 * @typename: The CPU base type.
 * @cpu_model: The model string without any parameters.
 *
 * Looks up a CPU #ObjectClass matching name @cpu_model.
 *
 * Returns: A #CPUClass or %NULL if not matching class is found.
 */
ObjectClass *cpu_class_by_name(const char *typename, const char *cpu_model);

422 423 424 425 426 427 428 429 430 431 432
/**
 * cpu_generic_init:
 * @typename: The CPU base type.
 * @cpu_model: The model string including optional parameters.
 *
 * Instantiates a CPU, processes optional parameters and realizes the CPU.
 *
 * Returns: A #CPUState or %NULL if an error occurred.
 */
CPUState *cpu_generic_init(const char *typename, const char *cpu_model);

433
/**
434
 * cpu_has_work:
435 436 437 438 439 440
 * @cpu: The vCPU to check.
 *
 * Checks whether the CPU has work to do.
 *
 * Returns: %true if the CPU has work, %false otherwise.
 */
441 442 443 444 445 446 447
static inline bool cpu_has_work(CPUState *cpu)
{
    CPUClass *cc = CPU_GET_CLASS(cpu);

    g_assert(cc->has_work);
    return cc->has_work(cpu);
}
448

449 450 451 452 453 454 455 456 457 458
/**
 * qemu_cpu_is_self:
 * @cpu: The vCPU to check against.
 *
 * Checks whether the caller is executing on the vCPU thread.
 *
 * Returns: %true if called from @cpu's thread, %false otherwise.
 */
bool qemu_cpu_is_self(CPUState *cpu);

459 460 461 462 463 464 465 466
/**
 * qemu_cpu_kick:
 * @cpu: The vCPU to kick.
 *
 * Kicks @cpu's thread.
 */
void qemu_cpu_kick(CPUState *cpu);

467 468 469 470 471 472 473 474 475 476 477
/**
 * cpu_is_stopped:
 * @cpu: The CPU to check.
 *
 * Checks whether the CPU is stopped.
 *
 * Returns: %true if run state is not running or if artificially stopped;
 * %false otherwise.
 */
bool cpu_is_stopped(CPUState *cpu);

478 479 480 481 482 483 484 485 486 487
/**
 * run_on_cpu:
 * @cpu: The vCPU to run on.
 * @func: The function to be executed.
 * @data: Data to pass to the function.
 *
 * Schedules the function @func for execution on the vCPU @cpu.
 */
void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data);

C
Chegu Vinod 已提交
488 489 490 491 492 493 494 495 496 497
/**
 * async_run_on_cpu:
 * @cpu: The vCPU to run on.
 * @func: The function to be executed.
 * @data: Data to pass to the function.
 *
 * Schedules the function @func for execution on the vCPU @cpu asynchronously.
 */
void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data);

498 499 500 501 502 503 504 505 506 507
/**
 * qemu_get_cpu:
 * @index: The CPUState@cpu_index value of the CPU to obtain.
 *
 * Gets a CPU matching @index.
 *
 * Returns: The CPU or %NULL if there is no matching CPU.
 */
CPUState *qemu_get_cpu(int index);

508 509 510 511 512 513 514 515 516 517
/**
 * cpu_exists:
 * @id: Guest-exposed CPU ID to lookup.
 *
 * Search for CPU with specified ID.
 *
 * Returns: %true - CPU is found, %false - CPU isn't found.
 */
bool cpu_exists(int64_t id);

518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
#ifndef CONFIG_USER_ONLY

typedef void (*CPUInterruptHandler)(CPUState *, int);

extern CPUInterruptHandler cpu_interrupt_handler;

/**
 * cpu_interrupt:
 * @cpu: The CPU to set an interrupt on.
 * @mask: The interupts to set.
 *
 * Invokes the interrupt handler.
 */
static inline void cpu_interrupt(CPUState *cpu, int mask)
{
    cpu_interrupt_handler(cpu, mask);
}

#else /* USER_ONLY */

void cpu_interrupt(CPUState *cpu, int mask);

#endif /* USER_ONLY */

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
#ifndef CONFIG_USER_ONLY

static inline void cpu_unassigned_access(CPUState *cpu, hwaddr addr,
                                         bool is_write, bool is_exec,
                                         int opaque, unsigned size)
{
    CPUClass *cc = CPU_GET_CLASS(cpu);

    if (cc->do_unassigned_access) {
        cc->do_unassigned_access(cpu, addr, is_write, is_exec, opaque, size);
    }
}

#endif

557 558 559 560 561 562 563 564 565
/**
 * cpu_reset_interrupt:
 * @cpu: The CPU to clear the interrupt on.
 * @mask: The interrupt mask to clear.
 *
 * Resets interrupts on the vCPU @cpu.
 */
void cpu_reset_interrupt(CPUState *cpu, int mask);

566 567 568 569 570 571 572 573
/**
 * cpu_exit:
 * @cpu: The CPU to exit.
 *
 * Requests the CPU @cpu to exit execution.
 */
void cpu_exit(CPUState *cpu);

574 575 576 577 578 579 580
/**
 * cpu_resume:
 * @cpu: The CPU to resume.
 *
 * Resumes CPU, i.e. puts CPU into runnable state.
 */
void cpu_resume(CPUState *cpu);
A
Andreas Färber 已提交
581

582 583 584 585 586 587 588 589
/**
 * qemu_init_vcpu:
 * @cpu: The vCPU to initialize.
 *
 * Initializes a vCPU.
 */
void qemu_init_vcpu(CPUState *cpu);

590 591 592 593 594 595 596 597 598 599 600 601 602
#define SSTEP_ENABLE  0x1  /* Enable simulated HW single stepping */
#define SSTEP_NOIRQ   0x2  /* Do not use IRQ while single stepping */
#define SSTEP_NOTIMER 0x4  /* Do not Timers while single stepping */

/**
 * cpu_single_step:
 * @cpu: CPU to the flags for.
 * @enabled: Flags to enable.
 *
 * Enables or disables single-stepping for @cpu.
 */
void cpu_single_step(CPUState *cpu, int enabled);

603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
/* Breakpoint/watchpoint flags */
#define BP_MEM_READ           0x01
#define BP_MEM_WRITE          0x02
#define BP_MEM_ACCESS         (BP_MEM_READ | BP_MEM_WRITE)
#define BP_STOP_BEFORE_ACCESS 0x04
#define BP_WATCHPOINT_HIT     0x08
#define BP_GDB                0x10
#define BP_CPU                0x20

int cpu_breakpoint_insert(CPUState *cpu, vaddr pc, int flags,
                          CPUBreakpoint **breakpoint);
int cpu_breakpoint_remove(CPUState *cpu, vaddr pc, int flags);
void cpu_breakpoint_remove_by_ref(CPUState *cpu, CPUBreakpoint *breakpoint);
void cpu_breakpoint_remove_all(CPUState *cpu, int mask);

618 619 620 621 622 623 624
int cpu_watchpoint_insert(CPUState *cpu, vaddr addr, vaddr len,
                          int flags, CPUWatchpoint **watchpoint);
int cpu_watchpoint_remove(CPUState *cpu, vaddr addr,
                          vaddr len, int flags);
void cpu_watchpoint_remove_by_ref(CPUState *cpu, CPUWatchpoint *watchpoint);
void cpu_watchpoint_remove_all(CPUState *cpu, int mask);

625 626 627
void QEMU_NORETURN cpu_abort(CPUState *cpu, const char *fmt, ...)
    GCC_FMT_ATTR(2, 3);

628 629 630 631 632 633 634 635 636 637 638 639 640 641
#ifdef CONFIG_SOFTMMU
extern const struct VMStateDescription vmstate_cpu_common;
#else
#define vmstate_cpu_common vmstate_dummy
#endif

#define VMSTATE_CPU() {                                                     \
    .name = "parent_obj",                                                   \
    .size = sizeof(CPUState),                                               \
    .vmsd = &vmstate_cpu_common,                                            \
    .flags = VMS_STRUCT,                                                    \
    .offset = 0,                                                            \
}

A
Andreas Färber 已提交
642
#endif