OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [config/] [or1k/] [tm-or1k.h] - Blame information for rev 1149

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/* Definitions to target GDB to or1k targets.
2
   Copyright 2001 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.  */
20
 
21
#ifndef TM_OR1K_H
22
#define TM_OR1K_H
23
 
24
#ifndef TARGET_OR1K
25
#define TARGET_OR1K
26
#endif
27
 
28 122 markom
#include "defs.h"
29
 
30 106 markom
struct value;
31
 
32
struct struct_or1k_implementation
33
  {
34
    /* Implementation version.  */
35
    unsigned int VR;
36
    /* Units present.  */
37
    unsigned int UPR;
38
    /* Number of total available matchpoints in this implementation.  */
39
    unsigned int num_matchpoints;
40 113 markom
    /* Number of currently used matchpoints.  */
41
    unsigned int num_used_matchpoints;
42 115 markom
    /* Has watchpoint driven counters.  */
43
    int has_counters;
44 106 markom
    /* Number of registers.  */
45
    unsigned int num_gpr_regs;
46 115 markom
    unsigned int num_vfpr_regs;
47
    /* Is there any vf support?  */
48 106 markom
    int vf_present;
49
 };
50
 
51
struct or1k_target_ops
52
  {
53
    /* Name this target type.  */
54
    char *to_shortname;
55
 
56
    /* Init target.  */
57
    void (*to_init) PARAMS ((char *args));
58
    /* Destruct target.  */
59
    void (*to_done) PARAMS ((void));
60
 
61 113 markom
    /* Read register.
62
       Does not fail, places error no. in err instead or call error(), if fatal.  */
63 122 markom
    ULONGEST (*to_read_reg) PARAMS ((unsigned int regno));
64 113 markom
    /* Write register.
65
       Does not fail, places error no. in err instead or call error(), if fatal.  */
66 122 markom
    void (*to_write_reg) PARAMS ((unsigned int regno, ULONGEST value));
67 106 markom
 
68 146 chris
    /* Read a block...possibly more efficient than several isolated
69
       call to read_reg...worst case the same efficiency. Returns 0
70
       on success or errno if a failure occurred. */
71
    int (*to_read_block) PARAMS ((unsigned int regno, void* block, int nRegisters));
72
 
73
    /* Write a block...possibly more efficient than several isolated
74
       call to write_reg...worst case the same efficiency. Returns 0
75
       on success or errno if a failure occurred. */
76
    int (*to_write_block) PARAMS ((unsigned int regno, void* block, int nRegisters));
77
 
78 113 markom
    /* Selects scan chain.  All register accesses are related to current scan chain.
79
       Does not fail, places error no. in err instead or call error(), if fatal.
80
       See jtag_chains enum.  */
81
    void (*to_set_chain) PARAMS ((int chain));
82 106 markom
 
83
    /* Executes extended command on the target.  */
84
    void (*to_exec_command) PARAMS ((char *args, int from_tty));
85
 
86
    /* Associated target_ops.  */
87
    struct target_ops *gdb_ops;
88
    /* Should be OPS_MAGIC. */
89
    int to_magic;
90
  };
91
 
92
 
93 403 simons
#define DEFAULT_PROMPT "(gdb) "
94 106 markom
 
95 113 markom
/* Context stuff. */
96
#define CURRENT_CID (0)
97
#define MAX_CID     (15)
98
 
99
 
100
/* Instruction definitions. */
101 364 markom
#define BRK_INSTR_STRUCT {0x21, 0x00, 0x00, 0x01}
102 113 markom
#define NOP_INSTR (0x15000000)
103
 
104 106 markom
/* Special purpose regisers.  */
105 113 markom
#define SPR_GROUP_SIZE_BITS (11)
106 106 markom
#define SPR_GROUP_SIZE (1 << SPR_GROUP_SIZE_BITS)
107
#define SPR_SYSTEM_GROUP (0)
108
#define SPR_DEBUG_GROUP (6)
109 115 markom
#define SPR_GPR_START  (1024)
110
#define SPR_VFPR_START ((MAX_CID + 1) * MAX_GPR_REGS + SPR_GPR_START)
111
#define OR1K_NUM_SPR_GROUPS (12)
112 106 markom
 
113
/* Define register values.  */
114
#define SPR_REG(group, index) (((group) << SPR_GROUP_SIZE_BITS) + (index))
115
 
116 115 markom
#define VR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 0)
117
#define UPR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 1)
118
#define CPUCFGR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 2)
119
#define DCFGR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 7)
120
#define PC_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 16)
121
#define SR_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 17)
122 372 markom
#define PPC_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 18)
123 113 markom
#define CCR_SPRNUM(cid) SPR_REG(SPR_SYSTEM_GROUP, 4 + (cid))
124 362 markom
#define EPCR_SPRNUM(cid) SPR_REG(SPR_SYSTEM_GROUP, 32 + (cid))
125
#define EPCR0_SPRNUM SPR_REG(SPR_SYSTEM_GROUP, 32)
126
 
127
#define DVR0_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 0xee)
128
#define DCR0_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 0xee)
129
#define DMR1_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 16)
130
#define DMR2_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 17)
131
#define DCWR0_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 0xee)
132
#define DCWR1_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 0xee)
133
#define DSR_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 20)
134
#define DRR_SPRNUM SPR_REG(SPR_DEBUG_GROUP, 21)
135
 
136 106 markom
#define ZERO_REGNUM (0)
137
#define SP_REGNUM (1)
138
#define FP_REGNUM (2)
139
#define A0_REGNUM (3)
140
#define A5_REGNUM (8)
141
#define LR_REGNUM (9)
142
#define RV_REGNUM (11)
143 113 markom
#define VFA0_REGNUM (MAX_GPR_REGS + 0)
144
#define VFA5_REGNUM (MAX_GPR_REGS + 5)
145
#define VFRV_REGNUM (MAX_GPR_REGS + 6)
146
#define PC_REGNUM (MAX_GPR_REGS + MAX_VF_REGS + 0)
147
#define PS_REGNUM (MAX_GPR_REGS + MAX_VF_REGS + 1)
148 362 markom
#define EPCR_REGNUM (MAX_GPR_REGS + MAX_VF_REGS + 2)
149 113 markom
#define CCR_REGNUM (MAX_GPR_REGS + MAX_VF_REGS + 2)
150 106 markom
 
151 207 chris
/******** END OF ADDITIONS BY CZ ************/
152
 
153 106 markom
extern int or1k_regnum_to_sprnum PARAMS ((int regno));
154
#define REGNUM_TO_SPRNUM(regno) (or1k_regnum_to_sprnum(regno))
155
 
156
/* Defines for SPR bits.  */
157
#define DMR1_ST    (0x00400000)
158
 
159 136 chris
/* Changed by CZ 21/06/01 */
160 363 markom
#define DRR_TE     (0x00002000)
161 372 markom
#define DRR_SSE    (0x00001000)
162 136 chris
#define DRR_SCE    (0x00000800)
163
#define DRR_RE     (0x00000400)
164
#define DRR_IME    (0x00000200)
165
#define DRR_DME    (0x00000100)
166
#define DRR_HPINTE (0x00000080)
167 106 markom
#define DRR_IIE    (0x00000040)
168 136 chris
#define DRR_AE     (0x00000020)
169
#define DRR_LPINTE (0x00000010)
170
#define DRR_IPFE   (0x00000008)
171
#define DRR_DPFE   (0x00000004)
172
#define DRR_BUSEE  (0x00000002)
173
#define DRR_RSTE   (0x00000001)
174 106 markom
 
175
/* Number of matchpoints */
176
#define NUM_MATCHPOINTS (or1k_implementation.num_matchpoints)
177 118 markom
#define MAX_MATCHPOINTS (8)
178 106 markom
 
179
/* Number of machine GPR registers */
180
#define NUM_GPR_REGS (or1k_implementation.num_gpr_regs)
181
#define MAX_GPR_REGS (32)
182
 
183
/* Number of machine VF registers */
184 116 markom
#define NUM_VF_REGS (or1k_implementation.num_vfpr_regs)
185 106 markom
#define MAX_VF_REGS (32)
186
 
187
/* gdb mapping of registers */
188
#ifndef NUM_REGS
189 363 markom
#define NUM_REGS (MAX_GPR_REGS+MAX_VF_REGS+3)
190 106 markom
#endif
191
 
192
/* Can act like a little or big endian.  */
193
#if !defined (TARGET_BYTE_ORDER_DEFAULT)
194
#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
195
#define TARGET_BYTE_ORDER_SELECTABLE_P (1)
196
#endif
197
 
198
/* Size (in bytes) of registers.  */
199
#define OR1K_SPR_REGSIZE (4)
200
#define OR1K_VF_REGSIZE (8)
201
#define OR1K_GPR_REGSIZE ((OR1K_64BIT_IMPLEMENTATION)?(8):(4))
202 113 markom
#define OR1K_VF_DOUBLE (0)
203 106 markom
 
204 113 markom
#define OR1K_IS_GPR(N) ((N) >= 0 && (N) < MAX_GPR_REGS)
205
#define OR1K_IS_VF(N) ((N) >= MAX_GPR_REGS && (N) < MAX_GPR_REGS + MAX_VF_REGS)
206 106 markom
 
207
/* Register representation is the same as in memory.  */
208
#define REGISTER_CONVERTIBLE(N) (0)
209
 
210
/* Given the register index, return the name of the corresponding
211
   register. */
212
extern char *or1k_register_name PARAMS ((int regno));
213
#define REGISTER_NAME(regno) or1k_register_name (regno)
214
 
215
/* Is this implementation 64 or 32 bit.
216
   WARNING: gdb or1k port is not yet prepared for 64b implementations!  */
217
#define OR1K_64BIT_IMPLEMENTATION 0
218
 
219
/* Number of bytes of storage in the actual machine representation for
220
   register N.  NOTE: This indirectly defines the register size
221
   transfered by the GDB protocol.  If we have 64bit processor
222
   implementation, GPR register raw size is 8B, otherwise 4B.  */
223 1142 sfurman
#define REGISTER_RAW_SIZE(N) or1k_register_raw_size(N)
224
extern int or1k_register_raw_size PARAMS ((int regnum));
225 106 markom
 
226
/* Number of bytes of storage in the program's representation
227
   for register N. Same as RAW_SIZE.  */
228
#define REGISTER_VIRTUAL_SIZE(N) TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (N))
229
 
230
/* Return the GDB type object for the "standard" data type of data in
231
   register N.  */
232
#define REGISTER_VIRTUAL_TYPE(N) ((OR1K_IS_GPR(N))?(\
233 113 markom
(OR1K_64BIT_IMPLEMENTATION)?builtin_type_int64:builtin_type_int\
234
):(OR1K_IS_VF(N) ? builtin_type_float : builtin_type_uint32))
235 106 markom
 
236
/* Largest value REGISTER_RAW_SIZE can have.  */
237
#define MAX_REGISTER_RAW_SIZE ((OR1K_64BIT_IMPLEMENTATION)?(8):(4))
238
 
239
/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
240
#define MAX_REGISTER_VIRTUAL_SIZE ((OR1K_64BIT_IMPLEMENTATION)?(8):(4))
241
 
242
#define REGISTER_SIZE (MAX_REGISTER_VIRTUAL_SIZE)
243
 
244
/* ABI uses R3 through R8 for args.  */
245
#define OR1K_LAST_ARG_REGNUM (A5_REGNUM)
246
#define OR1K_NUM_ARG_REGS (6)
247 118 markom
 
248 106 markom
/* ABI uses VFR0 through VFR5 for float args.  */
249
#define OR1K_LAST_FP_ARG_REGNUM (VFA5_REGNUM)
250
#define OR1K_NUM_FP_ARG_REGS (6)
251
 
252
/* Should not store into R0.  */
253
#define CANNOT_STORE_REGISTER(N) ((N) == 0)
254
 
255
/* Index within `registers' of the first byte of the space for
256
   register N.  */
257 1142 sfurman
#define REGISTER_BYTE(N) or1k_register_byte(N)
258
extern int or1k_register_byte PARAMS ((int regnum));
259 106 markom
 
260
/* Total amount of space needed to store our copies of the machine's
261
   register state, the array `registers'.  */
262 1142 sfurman
#define REGISTER_BYTES ((NUM_GPR_REGS * OR1K_GPR_REGSIZE) + \
263
                        (NUM_VF_REGS * OR1K_VF_REGSIZE) + \
264
                        (3 * OR1K_SPR_REGSIZE ))
265 106 markom
 
266 113 markom
extern void or1k_do_registers_info PARAMS ((int, int));
267
#define DO_REGISTERS_INFO(regnum, fp) or1k_do_registers_info(regnum, fp)
268
 
269
 
270
 
271 106 markom
/* BREAKPOINT_FROM_PC uses the program counter value to determine whether a
272
   16- or 32-bit breakpoint should be used.  It returns a pointer
273
   to a string of bytes that encode a breakpoint instruction, stores
274
   the length of the string to *lenptr, and adjusts the pc (if necessary) to
275
   point to the actual memory location where the breakpoint should be
276
   inserted.  */
277
extern unsigned char *or1k_breakpoint_from_pc PARAMS ((CORE_ADDR *bp_addr, int *bp_size));
278
#define BREAKPOINT_FROM_PC(pcptr, lenptr) or1k_breakpoint_from_pc (pcptr, lenptr)
279
 
280
/* Amount PC must be decremented by after a breakpoint.
281
   This is often the number of bytes in BREAKPOINT
282
   but not always.  */
283
 
284
#define DECR_PC_AFTER_BREAK 0
285
 
286 372 markom
/* Don't step over l.trap */
287
#define CANNOT_STEP_BREAKPOINT
288
 
289 113 markom
extern int or1k_insert_breakpoint (CORE_ADDR addr, char *contents_cache);
290
#define target_insert_hw_breakpoint(addr, cache) or1k_insert_breakpoint (addr, cache)
291
 
292
extern int or1k_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
293
#define target_remove_hw_breakpoint(addr, cache) or1k_remove_breakpoint (addr, cache)
294
 
295
/* Watchpoint support.  */
296
#define TARGET_HAS_HARDWARE_WATCHPOINTS
297
 
298
/* Use these macros for watchpoint insertion/deletion.  */
299
/* type can be 0: write watch, 1: read watch, 2: access watch (read/write) */
300
extern int or1k_insert_watchpoint PARAMS ((CORE_ADDR addr, int len, int type));
301
#define target_insert_watchpoint(addr, len, type) \
302
        or1k_insert_watchpoint (addr, len, type)
303
 
304
extern int or1k_insert_watchpoint PARAMS ((CORE_ADDR addr, int len, int type));
305
#define target_remove_watchpoint(addr, len, type) \
306
        or1k_remove_watchpoint (addr, len, type)
307
 
308
/* We need to remove watchpoints when stepping, else we hit them again! */
309
#define HAVE_NONSTEPPABLE_WATCHPOINT
310
 
311
extern int or1k_stopped_by_watchpoint PARAMS ((void));
312
#define STOPPED_BY_WATCHPOINT(w) or1k_stopped_by_watchpoint ()
313
 
314 1142 sfurman
typedef enum bptype bptype;
315 113 markom
extern int or1k_can_use_hardware_watchpoint PARAMS ((enum bptype, int));
316
#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(bp_type, cnt, ot) \
317
  or1k_can_use_hardware_watchpoint(bp_type, cnt)
318
 
319
 
320
/* Catchpoint support.  */
321
/* HACK: how do we hook to signal namings otherwise? */
322
#include "target.h"
323
extern char *target_signal_to_string PARAMS ((enum target_signal));
324 118 markom
 
325 113 markom
/* Return the name (SIGHUP, etc.) for a signal.  */
326
extern char *or1k_signal_to_name PARAMS ((enum target_signal));
327 118 markom
 
328 113 markom
/* Given a name (SIGHUP, etc.), return its signal.  */
329
extern enum target_signal or1k_signal_from_name PARAMS ((char *));
330
 
331 207 chris
#define NUM_OR1K_SIGNALS (14)
332 113 markom
 
333 106 markom
/* Extract from an array REGBUF containing the (raw) register state
334
   a function return value of type TYPE, and copy that, in virtual format,
335
   into VALBUF.  */
336
extern void or1k_extract_return_value PARAMS ((struct type *, char[], char *));
337
#define EXTRACT_RETURN_VALUE(TYPE, REGBUF, VALBUF) \
338
  or1k_extract_return_value (TYPE, REGBUF, VALBUF)
339
 
340
/* Write into appropriate registers a function return value
341
   of type TYPE, given in virtual format.  */
342
#define STORE_RETURN_VALUE(TYPE,VALBUF) \
343
  {\
344
    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)\
345
      write_register_bytes (REGISTER_BYTE (VFRV_REGNUM), VALBUF, TYPE_LENGTH (TYPE));\
346
    else\
347
      write_register_bytes (REGISTER_BYTE (RV_REGNUM), VALBUF, TYPE_LENGTH (TYPE));\
348
  }
349
 
350
/* Extract from an array REGBUF containing the (raw) register state
351
   the address in which a function should return its structure value,
352
   as a CORE_ADDR (or an expression that can be used as one).  */
353
/* The address is passed in a0 upon entry to the function, but when
354
   the function exits, the compiler has copied the value to v0.  This
355
   convention is specified by the System V ABI, so I think we can rely
356
   on it.  */
357
#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
358
  (extract_address (REGBUF + REGISTER_BYTE (RV_REGNUM), \
359
                    REGISTER_RAW_SIZE (RV_REGNUM)))
360
 
361 593 markom
#ifdef GDBTK
362
#define EXTRACT_STRUCT_VALUE_ADDRESS_P() 1
363
#else
364 106 markom
#define EXTRACT_STRUCT_VALUE_ADDRESS_P 1
365 593 markom
#endif
366 106 markom
 
367
/* Advance PC across any function entry prologue instructions
368
   to reach some "real" code.  */
369 1142 sfurman
extern CORE_ADDR or1k_skip_prologue PARAMS ((CORE_ADDR addr, struct frame_info *fi));
370
#define SKIP_PROLOGUE(pc) (or1k_skip_prologue (pc, NULL))
371 106 markom
 
372
/* FRAMES */
373 207 chris
 
374 106 markom
#define FRAME_ARGS_ADDRESS(fi)  (fi)->frame
375
 
376
#define FRAME_LOCALS_ADDRESS(fi) (fi)->frame
377
 
378
/* FRAME_CHAIN takes a frame's nominal address
379
   and produces the frame's chain-pointer. */
380
#define FRAME_CHAIN(thisframe) (CORE_ADDR) or1k_frame_chain (thisframe)
381
extern CORE_ADDR or1k_frame_chain PARAMS ((struct frame_info *));
382
 
383 1142 sfurman
extern void or1k_init_extra_frame_info (int fromleaf, struct frame_info *);
384
#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) or1k_init_extra_frame_info (fromleaf, fi)
385
 
386 106 markom
/* Discard from the stack the innermost frame, restoring all registers.  */
387
extern void or1k_pop_frame PARAMS ((void));
388
#define POP_FRAME or1k_pop_frame()
389
 
390
 
391
/* Return number of args passed to a frame.
392
   Can return -1, meaning no way to tell.  */
393
#define FRAME_NUM_ARGS(fi)      (-1)
394
 
395
/* Return number of bytes at start of arglist that are not really args.  */
396
#define FRAME_ARGS_SKIP 0
397
 
398
/* Put here the code to store, into a struct frame_saved_regs,
399
   the addresses of the saved registers of frame described by FRAME_INFO.
400
   This includes special registers such as pc and fp saved in special
401
   ways in the stack frame.  sp is even more special:
402
   the address we return for it IS the sp for the next frame.  */
403
extern void or1k_init_saved_regs PARAMS ((struct frame_info *));
404
#define FRAME_INIT_SAVED_REGS(frame_info) or1k_init_saved_regs (frame_info);
405
 
406
/* Saved Pc.  */
407
extern CORE_ADDR or1k_frame_saved_pc PARAMS ((struct frame_info *));
408
#define FRAME_SAVED_PC(FRAME) (or1k_frame_saved_pc(FRAME))
409
 
410
/* Set the return address register to point to the entry
411
   point of the program, where a breakpoint lies in wait.  */
412
extern CORE_ADDR or1k_push_return_address PARAMS ((CORE_ADDR pc, CORE_ADDR sp));
413
#define PUSH_RETURN_ADDRESS(PC, SP) (or1k_push_return_address ((PC), (SP)))
414
 
415
/* Immediately after a function call, return the saved pc.
416
   Can't always go through the frames for this because on some machines
417
   the new frame is not set up until the new function executes
418
   some instructions.  */
419
#define SAVED_PC_AFTER_CALL(frame)      read_register(LR_REGNUM)
420
 
421
/* Offset from address of function to start of its code.
422
   Zero on most machines.  */
423
#define FUNCTION_START_OFFSET (0)
424
 
425
/* Floating point is IEEE compliant */
426 593 markom
#define IEEE_FLOAT 1
427 106 markom
 
428
/* Is floating/vector unit present.  */
429
#define OR1K_VF_PRESENT (or1k_implementation.vf_present)
430
 
431 207 chris
/* #define INIT_FRAME_PC        */      /* Not necessary */
432 106 markom
 
433
/* Stack grows downward.  */
434
#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
435
 
436
/* Size of stack entry - in bytes.  */
437
#define OR1K_STACK_ALIGN (8)
438 118 markom
 
439 106 markom
/* Maximum struct size, that is still stored onto stack.  */
440
#define OR1K_STRUCT_CONV_SIZE (8)
441
#define STACK_ALIGN(addr) OR1K_STACK_ALIGN
442
 
443
#define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH (type) > OR1K_STRUCT_CONV_SIZE)
444
 
445
/* Stack must be aligned on 32-bit boundaries when synthesizing
446
   function calls. PUSH_ARGUMENTS will handle it. */
447
extern CORE_ADDR or1k_push_arguments PARAMS ((int, struct value **, CORE_ADDR, int, CORE_ADDR));
448
#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
449
(or1k_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
450
 
451 403 simons
/* Return nonzero if instruction has delay slot */
452
extern int is_delayed PARAMS ((unsigned long));
453
 
454 106 markom
/* Return non-zero if PC points to an instruction which will cause a step
455
   to execute both the instruction at PC and an instruction at PC+4.  */
456
extern int or1k_step_skips_delay PARAMS ((CORE_ADDR));
457
#define STEP_SKIPS_DELAY_P (1)
458
#define STEP_SKIPS_DELAY(pc) (or1k_step_skips_delay (pc))
459
 
460
/* DUMMY CALLS */
461
#define USE_GENERIC_DUMMY_FRAMES 1
462
#define CALL_DUMMY                   {0}
463
#define CALL_DUMMY_START_OFFSET      (0)
464
#define CALL_DUMMY_BREAKPOINT_OFFSET (0)
465
#define SIZEOF_CALL_DUMMY_WORDS      (0)
466
#define CALL_DUMMY_LOCATION          AT_ENTRY_POINT
467
#define FIX_CALL_DUMMY(DUMMY, START, FUNADDR, NARGS, ARGS, TYPE, GCCP) 
468
 
469
/* Return a location where we can set a breakpoint that will be hit
470
   when an inferior function call returns.  This is normally the
471
   program's entry point.  */
472
#define CALL_DUMMY_ADDRESS()         entry_point_address ()
473
#define SAVE_DUMMY_FRAME_TOS(SP)     generic_save_dummy_frame_tos (SP)
474
#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
475
#define PUSH_DUMMY_FRAME             generic_push_dummy_frame ()
476
 
477
/* Definitions and declarations used by or1k dependent files.  */
478
#define OR1K_INSTLEN 4          /* Length of an instruction */
479
typedef unsigned long t_inst;   /* Integer big enough to hold an instruction */
480
 
481
 
482
 
483
/* Defined in remote-or1k.c */
484
 
485
/* Target state names.  */
486
extern const char *status_name[];
487 118 markom
 
488 106 markom
/* Target state.  */
489
enum target_status
490
  {
491
    TARGET_UNDEFINED,
492
    TARGET_CONNECTING,
493
    TARGET_DISCONNECTING,
494
    TARGET_RUNNING,
495
    TARGET_STOPPED
496
  };
497
 
498
/* Compare conditions for DCRx registers.  */
499
enum enum_compare_condition
500
  {
501 118 markom
    CC_MASKED, CC_EQUAL, CC_LESS, CC_LESSE, CC_GREAT, CC_GREATE, CC_NEQUAL
502 106 markom
  };
503
 
504
/* Compare operand to compare DVRx to.  */
505
enum enum_compare_to
506
  {
507 119 markom
    CT_DISABLED, CT_FETCH, CT_LEA, CT_SEA, CT_LDATA, CT_SDATA, CT_AEA, CT_ADATA
508 106 markom
  };
509
 
510 118 markom
/* Matchpoint chaining types.  */
511
enum enum_chaining
512
  {
513
    CHAINING_NONE, CHAINING_AND, CHAINING_OR
514
  };
515 106 markom
 
516 118 markom
/* Names for cts.  */
517
#define NUM_CT_NAMES 8
518
extern const char *compare_to_names[NUM_CT_NAMES];
519
 
520 106 markom
/* DRCx struct */
521
struct dcr_struct
522
  {
523 113 markom
    enum enum_compare_to ct:3;
524
    unsigned int sc:1;
525 106 markom
    enum enum_compare_condition cc:3;
526 113 markom
    unsigned int dp:1;
527 106 markom
  };
528
 
529 118 markom
/* All data needed for a matchpoint.  */
530
struct matchpoint
531
  {
532
    struct dcr_struct dcr;
533
    unsigned int dvr;
534
    unsigned int chain_type;
535
    unsigned int cause_breakpoint;
536
  };
537
 
538
/* Trace related structures and data.  */
539
#define TRACE_FILENAME_SIZE (128)
540
extern char trace_filename[TRACE_FILENAME_SIZE];
541
#define TRACE_FILENAME (&trace_filename[0])
542
#define TRACE_DATA_SIZE (sizeof(struct htrace_data_struct))
543
 
544
struct htrace_data_struct
545
  {
546
    unsigned int unused:24;
547
    unsigned int data:32;
548
    unsigned int type:4;
549
    unsigned int reserved:3;
550
    unsigned int valid:1;
551
  };
552
 
553
enum enum_operation
554
  {
555
    TRIGOP_ANY, TRIGOP_OR, TRIGOP_AND
556
  };
557
 
558
struct htrace_event_struct
559
  {
560
    enum enum_operation operation:2;
561
    unsigned int reserved1:6;
562
    unsigned int is_valid:1;
563
    unsigned int is_trig:2;
564
    unsigned int ls_valid:1;
565
    unsigned int ls_trig:4;
566
    unsigned int reserved2:2;
567
    unsigned int bp_valid:1;
568
    unsigned int bp_trig:1;
569
    unsigned int wp_valid:1;
570
    unsigned int wp_trig:11;
571
  };
572
 
573
struct htrace_record_struct
574
  {
575
    unsigned int reserved:25;
576
    unsigned int rec:7;
577
  };
578
 
579
struct htrace_moder_struct
580
  {
581
    unsigned int reserved:29;
582
    unsigned int rec_sel_dep:1;
583
    unsigned int trace_enable:1;
584
    unsigned int contin:1;
585
  };
586
 
587
/* Number of records as defined in TAP.  */
588
#define NUM_RECORDS (8)
589
 
590
struct htrace_struct
591
  {
592
    /* Local copy of HW regs for trace.  */
593
    struct htrace_event_struct trig, qual, stop;
594
    struct htrace_record_struct recwp[MAX_MATCHPOINTS], recbp;
595
    struct htrace_moder_struct moder;
596
    /* Which matchpoints does record use?  Bitmask.  */
597
    unsigned int wp_record_uses[MAX_MATCHPOINTS];
598
  };
599
 
600
extern struct htrace_struct or1k_htrace;
601
extern int trace_size;
602
 
603
#define MAX_RECORD_NAMES 7
604
extern const char *or1k_record_names[MAX_RECORD_NAMES];
605
#define MAX_IS_NAMES 4
606
extern const char *or1k_is_names[MAX_IS_NAMES];
607
#define MAX_LS_NAMES 16
608
extern const char *or1k_ls_names[MAX_LS_NAMES];
609
 
610
/* Stuff for HW watches.  */
611
#define MAX_HW_WATCHES MAX_MATCHPOINTS
612
 
613
struct hwatch_struct
614
  {
615
    int matchpoint_start;
616
  };
617
 
618
extern int num_hw_watches;
619
extern struct hwatch_struct or1k_hwatch[MAX_HW_WATCHES];
620
 
621 106 markom
/* Possible errors are listed here.  */
622 126 chris
enum enum_errors  /* modified <chris@asics.ws> CZ 24/05/01 */
623
{
624
  /* Codes > 0 are for system errors */
625 106 markom
 
626 126 chris
  ERR_NONE = 0,
627
  ERR_CRC = -1,
628 146 chris
  ERR_MEM = -2,
629
  JTAG_PROXY_INVALID_COMMAND = -3,
630
  JTAG_PROXY_SERVER_TERMINATED = -4,
631
  JTAG_PROXY_NO_CONNECTION = -5,
632
  JTAG_PROXY_PROTOCOL_ERROR = -6,
633
  JTAG_PROXY_COMMAND_NOT_IMPLEMENTED = -7,
634
  JTAG_PROXY_INVALID_CHAIN = -8,
635
  JTAG_PROXY_INVALID_ADDRESS = -9,
636
  JTAG_PROXY_ACCESS_EXCEPTION = -10, /* Write to ROM */
637
  JTAG_PROXY_INVALID_LENGTH = -11,
638
  JTAG_PROXY_OUT_OF_MEMORY = -12,
639 126 chris
};
640
 
641 118 markom
/* All JTAG chains.  */
642 113 markom
enum jtag_chains
643
  {
644
    SC_GLOBAL,      /* 0 Global BS Chain */
645
    SC_RISC_DEBUG,  /* 1 RISC Debug Interface chain */
646
    SC_RISC_TEST,   /* 2 RISC Test Chain */
647
    SC_TRACE,       /* 3 Trace Chain */
648 362 markom
    SC_REGISTER,    /* 4 Register Chain */
649
    SC_WISHBONE,    /* 5 Wisbone Chain */
650
    SC_BLOCK        /* Block Chains */
651 113 markom
  };
652
 
653 118 markom
/* See JTAG documentation about these.  */
654
#define JI_SIZE (4)
655
enum jtag_instr
656
  {
657
    JI_EXTEST,
658
    JI_SAMPLE_PRELOAD,
659
    JI_IDCODE,
660
    JI_CHAIN_SELECT,
661
    JI_INTEST,
662
    JI_CLAMP,
663
    JI_CLAMPZ,
664
    JI_HIGHZ,
665 362 markom
    JI_DEBUG,
666 118 markom
    JI_BYPASS = 0xF
667
  };
668
 
669 113 markom
/* JTAG registers.  */
670 118 markom
#define JTAG_MODER  (0x0)
671
#define JTAG_TSEL   (0x1)
672
#define JTAG_QSEL   (0x2)
673
#define JTAG_SSEL   (0x3)
674 362 markom
#define JTAG_RISCOP (0x4)
675 118 markom
#define JTAG_RECWP0 (0x10)
676
#define JTAG_RECBP0 (0x1b)
677 113 markom
 
678 118 markom
 
679
/* Current register values.  */
680
extern unsigned int dmr1;
681
extern unsigned int dmr2;
682
extern unsigned int dsr;
683
extern unsigned int drr;
684
 
685
extern int matchpoint_user_count[MAX_MATCHPOINTS];
686
 
687
/* Current watchpoints.  */
688
extern unsigned int dvr[MAX_MATCHPOINTS];
689
extern struct dcr_struct dcr[MAX_MATCHPOINTS];
690
extern int debug_regs_changed;
691
 
692
/* Returns error name.  */
693 106 markom
extern const char *or1k_err_name PARAMS ((int e));
694
 
695 118 markom
/* Last error number.  */
696
extern int err;
697
 
698 106 markom
extern struct struct_or1k_implementation or1k_implementation;
699
extern unsigned int or1k_fetch_instruction PARAMS ((CORE_ADDR addr));
700
extern void or1k_fetch_registers PARAMS ((int regno));
701
 
702
/* Sets register/memory regno to data.  */
703 113 markom
extern void or1k_write_spr_reg PARAMS ((unsigned int regno, unsigned int data));
704 106 markom
 
705
/* Sets register/memory regno to data.  */
706 113 markom
extern unsigned int or1k_read_spr_reg PARAMS ((unsigned int regno));
707 106 markom
 
708 118 markom
/* Flushes or1k's pipeline.  */
709 113 markom
extern void or1k_flush_pipeline PARAMS ((void));
710
 
711 118 markom
/* Sifts unused matchpoints to higher indexses.  */
712
extern void sift_matchpoints ();
713
 
714 126 chris
 
715
/* Added by Chris Ziomkowski <chris@asics.ws> 24/05/01 */
716
typedef enum {
717
  JTAG_COMMAND_READ = 1,
718
  JTAG_COMMAND_WRITE = 2,
719 146 chris
  JTAG_COMMAND_BLOCK_READ = 3,
720
  JTAG_COMMAND_BLOCK_WRITE = 4,
721
  JTAG_COMMAND_CHAIN = 5,
722 126 chris
} JTAG_proxy_protocol_commands;
723
 
724
/* Each transmit structure must begin with an integer
725
   which specifies the type of command. Information
726
   after this is variable. Make sure to have all information
727
   aligned properly. If we stick with 32 bit integers, it
728
   should be portable onto every platform. These structures
729
   will be transmitted across the network in network byte
730
   order.
731
*/
732
 
733
typedef struct {
734
  uint32_t command;
735
  uint32_t length;
736
  uint32_t address;
737
  uint32_t data_H;
738
  uint32_t data_L;
739
} JTAGProxyWriteMessage;
740
 
741
typedef struct {
742
  uint32_t command;
743
  uint32_t length;
744
  uint32_t address;
745
} JTAGProxyReadMessage;
746
 
747
typedef struct {
748
  uint32_t command;
749
  uint32_t length;
750 146 chris
  uint32_t address;
751
  int32_t  nRegisters;
752
  uint32_t data[1];
753
} JTAGProxyBlockWriteMessage;
754
 
755
typedef struct {
756
  uint32_t command;
757
  uint32_t length;
758
  uint32_t address;
759
  int32_t  nRegisters;
760
} JTAGProxyBlockReadMessage;
761
 
762
typedef struct {
763
  uint32_t command;
764
  uint32_t length;
765 126 chris
  uint32_t chain;
766
} JTAGProxyChainMessage;
767
 
768
/* The responses are messages specific, however convention
769
   states the first word should be an error code. Again,
770
   sticking with 32 bit integers should provide maximum
771
   portability. */
772
 
773
typedef struct {
774
  int32_t status;
775
} JTAGProxyWriteResponse;
776
 
777
typedef struct {
778
  int32_t status;
779
  uint32_t data_H;
780
  uint32_t data_L;
781
} JTAGProxyReadResponse;
782
 
783
typedef struct {
784
  int32_t status;
785 146 chris
} JTAGProxyBlockWriteResponse;
786
 
787
typedef struct {
788
  int32_t status;
789
  int32_t nRegisters;
790
  uint32_t data[1];
791
  /* uint32_t data[nRegisters-1] still unread */
792
} JTAGProxyBlockReadResponse;
793
 
794
typedef struct {
795
  int32_t status;
796 126 chris
} JTAGProxyChainResponse;
797
 
798 146 chris
 
799 106 markom
#endif /* TM_OR1K_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.