← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to cpu-all.h

Tags: upstream-0.9.0+20070816
Import upstream version 0.9.0+20070816

Show diffs side-by-side

added added

removed removed

Lines of Context:
cpu-all.h
20
20
#ifndef CPU_ALL_H
21
21
#define CPU_ALL_H
22
22
 
23
 
#if defined(__arm__) || defined(__sparc__)
 
23
#if defined(__arm__) || defined(__sparc__) || defined(__mips__)
24
24
#define WORDS_ALIGNED
25
25
#endif
26
26
 
644
644
#define lduw_code(p) lduw_raw(p)
645
645
#define ldsw_code(p) ldsw_raw(p)
646
646
#define ldl_code(p) ldl_raw(p)
 
647
#define ldq_code(p) ldq_raw(p)
647
648
 
648
649
#define ldub_kernel(p) ldub_raw(p)
649
650
#define ldsb_kernel(p) ldsb_raw(p)
650
651
#define lduw_kernel(p) lduw_raw(p)
651
652
#define ldsw_kernel(p) ldsw_raw(p)
652
653
#define ldl_kernel(p) ldl_raw(p)
 
654
#define ldq_kernel(p) ldq_raw(p)
653
655
#define ldfl_kernel(p) ldfl_raw(p)
654
656
#define ldfq_kernel(p) ldfq_raw(p)
655
657
#define stb_kernel(p, v) stb_raw(p, v)
690
692
void page_set_flags(target_ulong start, target_ulong end, int flags);
691
693
void page_unprotect_range(target_ulong data, target_ulong data_size);
692
694
 
693
 
#define SINGLE_CPU_DEFINES
694
 
#ifdef SINGLE_CPU_DEFINES
695
 
 
696
 
#if defined(TARGET_I386)
697
 
 
698
 
#define CPUState CPUX86State
699
 
#define cpu_init cpu_x86_init
700
 
#define cpu_exec cpu_x86_exec
701
 
#define cpu_gen_code cpu_x86_gen_code
702
 
#define cpu_signal_handler cpu_x86_signal_handler
703
 
 
704
 
#elif defined(TARGET_ARM)
705
 
 
706
 
#define CPUState CPUARMState
707
 
#define cpu_init cpu_arm_init
708
 
#define cpu_exec cpu_arm_exec
709
 
#define cpu_gen_code cpu_arm_gen_code
710
 
#define cpu_signal_handler cpu_arm_signal_handler
711
 
 
712
 
#elif defined(TARGET_SPARC)
713
 
 
714
 
#define CPUState CPUSPARCState
715
 
#define cpu_init cpu_sparc_init
716
 
#define cpu_exec cpu_sparc_exec
717
 
#define cpu_gen_code cpu_sparc_gen_code
718
 
#define cpu_signal_handler cpu_sparc_signal_handler
719
 
 
720
 
#elif defined(TARGET_PPC)
721
 
 
722
 
#define CPUState CPUPPCState
723
 
#define cpu_init cpu_ppc_init
724
 
#define cpu_exec cpu_ppc_exec
725
 
#define cpu_gen_code cpu_ppc_gen_code
726
 
#define cpu_signal_handler cpu_ppc_signal_handler
727
 
 
728
 
#elif defined(TARGET_M68K)
729
 
#define CPUState CPUM68KState
730
 
#define cpu_init cpu_m68k_init
731
 
#define cpu_exec cpu_m68k_exec
732
 
#define cpu_gen_code cpu_m68k_gen_code
733
 
#define cpu_signal_handler cpu_m68k_signal_handler
734
 
 
735
 
#elif defined(TARGET_MIPS)
736
 
#define CPUState CPUMIPSState
737
 
#define cpu_init cpu_mips_init
738
 
#define cpu_exec cpu_mips_exec
739
 
#define cpu_gen_code cpu_mips_gen_code
740
 
#define cpu_signal_handler cpu_mips_signal_handler
741
 
 
742
 
#elif defined(TARGET_SH4)
743
 
#define CPUState CPUSH4State
744
 
#define cpu_init cpu_sh4_init
745
 
#define cpu_exec cpu_sh4_exec
746
 
#define cpu_gen_code cpu_sh4_gen_code
747
 
#define cpu_signal_handler cpu_sh4_signal_handler
748
 
 
749
 
#else
750
 
 
751
 
#error unsupported target CPU
752
 
 
753
 
#endif
754
 
 
755
 
#endif /* SINGLE_CPU_DEFINES */
 
695
CPUState *cpu_copy(CPUState *env);
756
696
 
757
697
void cpu_dump_state(CPUState *env, FILE *f, 
758
698
                    int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
759
699
                    int flags);
 
700
void cpu_dump_statistics (CPUState *env, FILE *f,
 
701
                          int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
 
702
                          int flags);
760
703
 
761
 
void cpu_abort(CPUState *env, const char *fmt, ...);
 
704
void cpu_abort(CPUState *env, const char *fmt, ...)
 
705
    __attribute__ ((__format__ (__printf__, 2, 3)))
 
706
    __attribute__ ((__noreturn__));
762
707
extern CPUState *first_cpu;
763
708
extern CPUState *cpu_single_env;
764
709
extern int code_copy_enabled;
770
715
#define CPU_INTERRUPT_FIQ    0x10 /* Fast interrupt pending.  */
771
716
#define CPU_INTERRUPT_HALT   0x20 /* CPU halt wanted */
772
717
#define CPU_INTERRUPT_SMI    0x40 /* (x86 only) SMI interrupt pending */
 
718
#define CPU_INTERRUPT_DEBUG  0x80 /* Debug event occured.  */
773
719
 
774
720
void cpu_interrupt(CPUState *s, int mask);
775
721
void cpu_reset_interrupt(CPUState *env, int mask);
776
722
 
 
723
int cpu_watchpoint_insert(CPUState *env, target_ulong addr);
 
724
int cpu_watchpoint_remove(CPUState *env, target_ulong addr);
777
725
int cpu_breakpoint_insert(CPUState *env, target_ulong pc);
778
726
int cpu_breakpoint_remove(CPUState *env, target_ulong pc);
779
727
void cpu_single_step(CPUState *env, int enabled);
782
730
/* Return the physical page corresponding to a virtual one. Use it
783
731
   only for debugging because no protection checks are done. Return -1
784
732
   if no page found. */
785
 
target_ulong cpu_get_phys_page_debug(CPUState *env, target_ulong addr);
 
733
target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr);
786
734
 
787
735
#define CPU_LOG_TB_OUT_ASM (1 << 0) 
788
736
#define CPU_LOG_TB_IN_ASM  (1 << 1)
840
788
   exception, the write memory callback gets the ram offset instead of
841
789
   the physical address */
842
790
#define IO_MEM_ROMD        (1)
 
791
#define IO_MEM_SUBPAGE     (2)
843
792
 
844
793
typedef void CPUWriteMemoryFunc(void *opaque, target_phys_addr_t addr, uint32_t value);
845
794
typedef uint32_t CPUReadMemoryFunc(void *opaque, target_phys_addr_t addr);
848
797
                                  unsigned long size,
849
798
                                  unsigned long phys_offset);
850
799
uint32_t cpu_get_physical_page_desc(target_phys_addr_t addr);
 
800
ram_addr_t qemu_ram_alloc(unsigned int size);
 
801
void qemu_ram_free(ram_addr_t addr);
851
802
int cpu_register_io_memory(int io_index,
852
803
                           CPUReadMemoryFunc **mem_read,
853
804
                           CPUWriteMemoryFunc **mem_write,
872
823
uint32_t ldl_phys(target_phys_addr_t addr);
873
824
uint64_t ldq_phys(target_phys_addr_t addr);
874
825
void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val);
 
826
void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val);
875
827
void stb_phys(target_phys_addr_t addr, uint32_t val);
876
828
void stw_phys(target_phys_addr_t addr, uint32_t val);
877
829
void stl_phys(target_phys_addr_t addr, uint32_t val);
980
932
    return val;
981
933
}
982
934
 
983
 
#elif defined(__sparc_v9__)
 
935
#elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
984
936
 
985
937
static inline int64_t cpu_get_real_ticks (void)
986
938
{
1001
953
        return rval.i64;
1002
954
#endif
1003
955
}
 
956
 
 
957
#elif defined(__mips__)
 
958
 
 
959
static inline int64_t cpu_get_real_ticks(void)
 
960
{
 
961
#if __mips_isa_rev >= 2
 
962
    uint32_t count;
 
963
    static uint32_t cyc_per_count = 0;
 
964
 
 
965
    if (!cyc_per_count)
 
966
        __asm__ __volatile__("rdhwr %0, $3" : "=r" (cyc_per_count));
 
967
 
 
968
    __asm__ __volatile__("rdhwr %1, $2" : "=r" (count));
 
969
    return (int64_t)(count * cyc_per_count);
 
970
#else
 
971
    /* FIXME */
 
972
    static int64_t ticks = 0;
 
973
    return ticks++;
 
974
#endif
 
975
}
 
976
 
1004
977
#else
1005
978
/* The host CPU doesn't have an easily accessible cycle counter.
1006
 
   Just return a monotonically increasing vlue.  This will be totally wrong,
1007
 
   but hopefully better than nothing.  */
 
979
   Just return a monotonically increasing value.  This will be
 
980
   totally wrong, but hopefully better than nothing.  */
1008
981
static inline int64_t cpu_get_real_ticks (void)
1009
982
{
1010
983
    static int64_t ticks = 0;