/[gxemul]/trunk/src/include/cpu.h
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/src/include/cpu.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 29 by dpavlin, Mon Oct 8 16:20:26 2007 UTC revision 30 by dpavlin, Mon Oct 8 16:20:40 2007 UTC
# Line 28  Line 28 
28   *  SUCH DAMAGE.   *  SUCH DAMAGE.
29   *   *
30   *   *
31   *  $Id: cpu.h,v 1.84 2006/07/20 21:53:00 debug Exp $   *  $Id: cpu.h,v 1.90 2006/08/12 11:43:13 debug Exp $
32   *   *
33   *  CPU-related definitions.   *  CPU-related definitions.
34   */   */
# Line 59  Line 59 
59   *  (several pages can be in the same chain, but only one matches the   *  (several pages can be in the same chain, but only one matches the
60   *  specific physaddr.)   *  specific physaddr.)
61   *   *
  *  flags contains special flags. Currently only COMBINATIONS, which indicates  
  *  that the page has instruction combinations.  
  *  
62   *  translations is a tiny bitmap indicating which parts of the page have   *  translations is a tiny bitmap indicating which parts of the page have
63   *  actual translations. Bit 0 corresponds to the lowest 1/32th of the page,   *  actual translations. Bit 0 corresponds to the lowest 1/32th of the page,
64   *  bit 1 to the second-lowest 1/32th, and so on.   *  bit 1 to the second-lowest 1/32th, and so on.
# Line 77  Line 74 
74                  struct arch ## _instr_call ics[ARCH ## _IC_ENTRIES_PER_PAGE+2];\                  struct arch ## _instr_call ics[ARCH ## _IC_ENTRIES_PER_PAGE+2];\
75                  uint32_t        next_ofs;       /*  (0 for end of chain)  */ \                  uint32_t        next_ofs;       /*  (0 for end of chain)  */ \
76                  uint32_t        translations;                           \                  uint32_t        translations;                           \
                 int             flags;                                  \  
77                  addrtype        physaddr;                               \                  addrtype        physaddr;                               \
78          };                                                              \          };                                                              \
79                                                                          \                                                                          \
# Line 87  Line 83 
83                  addrtype        vaddr_page;                             \                  addrtype        vaddr_page;                             \
84                  addrtype        paddr_page;                             \                  addrtype        paddr_page;                             \
85                  unsigned char   *host_page;                             \                  unsigned char   *host_page;                             \
                 int64_t         timestamp;                              \  
86          };          };
87    
88  #define DYNTRANS_MISC64_DECLARATIONS(arch,ARCH,tlbindextype)            \  #define DYNTRANS_MISC64_DECLARATIONS(arch,ARCH,tlbindextype)            \
# Line 216  struct machine; Line 211  struct machine;
211  struct memory;  struct memory;
212    
213    
214    /*
215     *  cpu_family
216     *  ----------
217     *
218     *  This structure consists of various pointers to functions, performing
219     *  architecture-specific functions.
220     *
221     *  Except for the next and arch fields at the top, all fields in the
222     *  cpu_family struct are filled in by ecah CPU family's init function.
223     */
224  struct cpu_family {  struct cpu_family {
225          struct cpu_family       *next;          struct cpu_family       *next;
226          int                     arch;          int                     arch;
227    
228          /*  These are filled in by each CPU family's init function:  */          /*  Familty name, e.g. "MIPS", "Alpha" etc.  */
229          char                    *name;          char                    *name;
230    
231            /*  Fill in architecture specific parts of a struct cpu.  */
232          int                     (*cpu_new)(struct cpu *cpu, struct memory *mem,          int                     (*cpu_new)(struct cpu *cpu, struct memory *mem,
233                                      struct machine *machine,                                      struct machine *machine,
234                                      int cpu_id, char *cpu_type_name);                                      int cpu_id, char *cpu_type_name);
235    
236            /*  Initialize various translation tables.  */
237            void                    (*init_tables)(struct cpu *cpu);
238    
239            /*  List available CPU types for this architecture.  */
240          void                    (*list_available_types)(void);          void                    (*list_available_types)(void);
241    
242            /*  Read or write a CPU register, given a name.  */
243          void                    (*register_match)(struct machine *m,          void                    (*register_match)(struct machine *m,
244                                      char *name, int writeflag,                                      char *name, int writeflag,
245                                      uint64_t *valuep, int *match_register);                                      uint64_t *valuep, int *match_register);
246    
247            /*  Disassemble an instruction.  */
248          int                     (*disassemble_instr)(struct cpu *cpu,          int                     (*disassemble_instr)(struct cpu *cpu,
249                                      unsigned char *instr, int running,                                      unsigned char *instr, int running,
250                                      uint64_t dumpaddr);                                      uint64_t dumpaddr);
251    
252            /*  Dump CPU registers in readable format.  */
253          void                    (*register_dump)(struct cpu *cpu,          void                    (*register_dump)(struct cpu *cpu,
254                                      int gprs, int coprocs);                                      int gprs, int coprocs);
255    
256            /*  Dump generic CPU info in readable format.  */
257          void                    (*dumpinfo)(struct cpu *cpu);          void                    (*dumpinfo)(struct cpu *cpu);
258    
259            /*  Dump TLB data for CPU id x.  */
260          void                    (*tlbdump)(struct machine *m, int x,          void                    (*tlbdump)(struct machine *m, int x,
261                                      int rawflag);                                      int rawflag);
262    
263            /*  Assert an interrupt.  */
264          int                     (*interrupt)(struct cpu *cpu, uint64_t irq_nr);          int                     (*interrupt)(struct cpu *cpu, uint64_t irq_nr);
265    
266            /*  De-assert an interrupt.  */
267          int                     (*interrupt_ack)(struct cpu *cpu,          int                     (*interrupt_ack)(struct cpu *cpu,
268                                      uint64_t irq_nr);                                      uint64_t irq_nr);
269    
270            /*  Print architecture-specific function call arguments.
271                (This is called for each function call, if running with -t.)  */
272          void                    (*functioncall_trace)(struct cpu *,          void                    (*functioncall_trace)(struct cpu *,
273                                      uint64_t f, int n_args);                                      uint64_t f, int n_args);
274    
275            /*  GDB command handler.  */
276          char                    *(*gdb_stub)(struct cpu *, char *cmd);          char                    *(*gdb_stub)(struct cpu *, char *cmd);
         void                    (*init_tables)(struct cpu *cpu);  
277  };  };
278    
279    
# Line 254  struct cpu_family { Line 284  struct cpu_family {
284   *  into the cache, for possible translation cache structs for physical pages.   *  into the cache, for possible translation cache structs for physical pages.
285   */   */
286    
 /*  Physpage flags:  */  
 #define COMBINATIONS                    1  
   
287  /*  Meaning of delay_slot:  */  /*  Meaning of delay_slot:  */
288  #define NOT_DELAYED                     0  #define NOT_DELAYED                     0
289  #define DELAYED                         1  #define DELAYED                         1
290  #define TO_BE_DELAYED                   2  #define TO_BE_DELAYED                   2
291  #define EXCEPTION_IN_DELAY_SLOT         0x100  #define EXCEPTION_IN_DELAY_SLOT         8
292    
293  #define N_SAFE_DYNTRANS_LIMIT_SHIFT     14  #define N_SAFE_DYNTRANS_LIMIT_SHIFT     14
294  #define N_SAFE_DYNTRANS_LIMIT   ((1 << (N_SAFE_DYNTRANS_LIMIT_SHIFT - 1)) - 1)  #define N_SAFE_DYNTRANS_LIMIT   ((1 << (N_SAFE_DYNTRANS_LIMIT_SHIFT - 1)) - 1)
295    
296  #define DYNTRANS_CACHE_SIZE             (32*1048576)  #define DYNTRANS_CACHE_SIZE             (24*1048576)
297  #define DYNTRANS_CACHE_MARGIN           350000  #define DYNTRANS_CACHE_MARGIN           300000
298    
299  #define N_BASE_TABLE_ENTRIES            32768  #define N_BASE_TABLE_ENTRIES            32768
300  #define PAGENR_TO_TABLE_INDEX(a)        ((a) & (N_BASE_TABLE_ENTRIES-1))  #define PAGENR_TO_TABLE_INDEX(a)        ((a) & (N_BASE_TABLE_ENTRIES-1))
# Line 281  struct cpu { Line 308  struct cpu {
308          /*  Pointer back to the machine this CPU is in:  */          /*  Pointer back to the machine this CPU is in:  */
309          struct machine  *machine;          struct machine  *machine;
310    
311            /*  CPU-specific name, e.g. "R2000", "21164PC", etc.  */
312            char            *name;
313    
314            /*  EMUL_LITTLE_ENDIAN or EMUL_BIG_ENDIAN.  */
315          int             byte_order;          int             byte_order;
316          int             running;  
317          int             dead;          /*  0-based CPU id, in an emulated SMP system.  */
         int             bootstrap_cpu_flag;  
318          int             cpu_id;          int             cpu_id;
         int             is_32bit;       /*  0 for 64-bit, 1 for 32-bit  */  
         char            *name;  
319    
320            /*  0 for emulated 64-bit CPUs, 1 for 32-bit.  */
321            int             is_32bit;
322    
323            /*  1 while running, 0 when paused/stopped.  */
324            int             running;
325    
326            /*  A pointer to the main memory connected to this CPU.  */
327          struct memory   *mem;          struct memory   *mem;
328    
329          int             (*run_instr)(struct cpu *cpu);          int             (*run_instr)(struct cpu *cpu);
# Line 309  struct cpu { Line 344  struct cpu {
344          int             (*instruction_has_delayslot)(struct cpu *cpu,          int             (*instruction_has_delayslot)(struct cpu *cpu,
345                              unsigned char *ib);                              unsigned char *ib);
346    
347            /*  The program counter. (For 32-bit modes, not all bits are used.)  */
348          uint64_t        pc;          uint64_t        pc;
349    
350            /*  See comment further up.  */
351            int             delay_slot;
352    
353            /*  The current depth of function call tracing.  */
354          int             trace_tree_depth;          int             trace_tree_depth;
355    
356          /*          /*
357             *  If is_halted is true when an interrupt trap occurs, the pointer
358             *  to the next instruction to execute will be the instruction
359             *  following the halt instruction, not the halt instrucion itself.
360             */
361            int             is_halted;
362    
363            /*
364           *  Dynamic translation:           *  Dynamic translation:
365             *
366             *  The number of translated instructions is assumed to be 1 per
367             *  instruction call. For each case where this differs from the
368             *  truth, n_translated_instrs should be modified. E.g. if 1000
369             *  instruction calls are done, and n_translated_instrs is 50, then
370             *  1050 emulated instructions were actually executed.
371             *
372             *  Note that it can also be adjusted negatively, that is, the way
373             *  to "get out" of a dyntrans loop is to set the current instruction
374             *  call pointer to the "nothing" instruction. This instruction
375             *  _decreases_ n_translated_instrs. That way, once the dyntrans loop
376             *  exits, only real instructions will be counted, and not the
377             *  "nothing" instructions.
378           */           */
         int             running_translated;  
379          int             n_translated_instrs;          int             n_translated_instrs;
380          unsigned char   *translation_cache;          unsigned char   *translation_cache;
381          size_t          translation_cache_cur_ofs;          size_t          translation_cache_cur_ofs;
382    
         uint64_t        delay_jmpaddr;  /*  only used if delay_slot > 0  */  
         int             delay_slot;  
   
383          /*          /*
384           *  CPU-family dependent:           *  CPU-family dependent:
385             *
386             *  These contain everything ranging from registers, memory management,
387             *  status words, etc.
388           */           */
389          union {          union {
390                  struct alpha_cpu      alpha;                  struct alpha_cpu      alpha;
Legend:
Removed from v.29  
changed lines
  Added in v.30
  ViewVC Help
Powered by ViewVC 1.1.26