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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [h8300-tdep.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Target-machine dependent code for Hitachi H8/300, for GDB.
2
   Copyright (C) 1988, 1990, 1991 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
/*
22
   Contributed by Steve Chamberlain
23
   sac@cygnus.com
24
 */
25
 
26
#include "defs.h"
27
#include "frame.h"
28
#include "obstack.h"
29
#include "symtab.h"
30
#include "dis-asm.h"
31
#include "gdbcmd.h"
32
#include "gdbtypes.h"
33
#include "gdbcore.h"
34
#include "gdb_string.h"
35
#include "value.h"
36
 
37
extern int h8300hmode, h8300smode;
38
 
39
#undef NUM_REGS
40
#define NUM_REGS 11
41
 
42
#define UNSIGNED_SHORT(X) ((X) & 0xffff)
43
 
44
#define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
45
#define IS_PUSH_FP(x) (x == 0x6df6)
46
#define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
47
#define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
48
#define IS_SUB2_SP(x) (x==0x1b87)
49
#define IS_SUB4_SP(x) (x==0x1b97)
50
#define IS_SUBL_SP(x) (x==0x7a37)
51
#define IS_MOVK_R5(x) (x==0x7905)
52
#define IS_SUB_R5SP(x) (x==0x1957)
53
 
54
 
55
/* The register names change depending on whether the h8300h processor
56
   type is selected. */
57
 
58
static char *original_register_names[] = REGISTER_NAMES;
59
 
60
static char *h8300h_register_names[] =
61
{"er0", "er1", "er2", "er3", "er4", "er5", "er6",
62
 "sp", "ccr", "pc", "cycles", "tick", "inst"};
63
 
64
char **h8300_register_names = original_register_names;
65
 
66
 
67
/* Local function declarations.  */
68
 
69
static CORE_ADDR examine_prologue ();
70
static void set_machine_hook PARAMS ((char *filename));
71
 
72
void h8300_frame_find_saved_regs ();
73
 
74
CORE_ADDR
75
h8300_skip_prologue (start_pc)
76
     CORE_ADDR start_pc;
77
{
78
  short int w;
79
  int adjust = 0;
80
 
81
  /* Skip past all push and stm insns.  */
82
  while (1)
83
    {
84
      w = read_memory_unsigned_integer (start_pc, 2);
85
      /* First look for push insns.  */
86
      if (w == 0x0100 || w == 0x0110 || w == 0x0120 || w == 0x0130)
87
        {
88
          w = read_memory_unsigned_integer (start_pc + 2, 2);
89
          adjust = 2;
90
        }
91
 
92
      if (IS_PUSH (w))
93
        {
94
          start_pc += 2 + adjust;
95
          w = read_memory_unsigned_integer (start_pc, 2);
96
          continue;
97
        }
98
      adjust = 0;
99
      break;
100
    }
101
 
102
  /* Skip past a move to FP, either word or long sized */
103
  w = read_memory_unsigned_integer (start_pc, 2);
104
  if (w == 0x0100)
105
    {
106
      w = read_memory_unsigned_integer (start_pc + 2, 2);
107
      adjust += 2;
108
    }
109
 
110
  if (IS_MOVE_FP (w))
111
    {
112
      start_pc += 2 + adjust;
113
      w = read_memory_unsigned_integer (start_pc, 2);
114
    }
115
 
116
  /* Check for loading either a word constant into r5;
117
     long versions are handled by the SUBL_SP below.  */
118
  if (IS_MOVK_R5 (w))
119
    {
120
      start_pc += 2;
121
      w = read_memory_unsigned_integer (start_pc, 2);
122
    }
123
 
124
  /* Now check for subtracting r5 from sp, word sized only.  */
125
  if (IS_SUB_R5SP (w))
126
    {
127
      start_pc += 2 + adjust;
128
      w = read_memory_unsigned_integer (start_pc, 2);
129
    }
130
 
131
  /* Check for subs #2 and subs #4. */
132
  while (IS_SUB2_SP (w) || IS_SUB4_SP (w))
133
    {
134
      start_pc += 2 + adjust;
135
      w = read_memory_unsigned_integer (start_pc, 2);
136
    }
137
 
138
  /* Check for a 32bit subtract.  */
139
  if (IS_SUBL_SP (w))
140
    start_pc += 6 + adjust;
141
 
142
  return start_pc;
143
}
144
 
145
int
146
gdb_print_insn_h8300 (memaddr, info)
147
     bfd_vma memaddr;
148
     disassemble_info *info;
149
{
150
  if (h8300smode)
151
    return print_insn_h8300s (memaddr, info);
152
  else if (h8300hmode)
153
    return print_insn_h8300h (memaddr, info);
154
  else
155
    return print_insn_h8300 (memaddr, info);
156
}
157
 
158
/* Given a GDB frame, determine the address of the calling function's frame.
159
   This will be used to create a new GDB frame struct, and then
160
   INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
161
 
162
   For us, the frame address is its stack pointer value, so we look up
163
   the function prologue to determine the caller's sp value, and return it.  */
164
 
165
CORE_ADDR
166
h8300_frame_chain (thisframe)
167
     struct frame_info *thisframe;
168
{
169
  if (PC_IN_CALL_DUMMY (thisframe->pc, thisframe->frame, thisframe->frame))
170
    {                           /* initialize the from_pc now */
171
      thisframe->from_pc = generic_read_register_dummy (thisframe->pc,
172
                                                        thisframe->frame,
173
                                                        PC_REGNUM);
174
      return thisframe->frame;
175
    }
176
  h8300_frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
177
  return thisframe->fsr->regs[SP_REGNUM];
178
}
179
 
180
/* Put here the code to store, into a struct frame_saved_regs,
181
   the addresses of the saved registers of frame described by FRAME_INFO.
182
   This includes special registers such as pc and fp saved in special
183
   ways in the stack frame.  sp is even more special:
184
   the address we return for it IS the sp for the next frame.
185
 
186
   We cache the result of doing this in the frame_obstack, since it is
187
   fairly expensive.  */
188
 
189
void
190
h8300_frame_find_saved_regs (fi, fsr)
191
     struct frame_info *fi;
192
     struct frame_saved_regs *fsr;
193
{
194
  register struct frame_saved_regs *cache_fsr;
195
  CORE_ADDR ip;
196
  struct symtab_and_line sal;
197
  CORE_ADDR limit;
198
 
199
  if (!fi->fsr)
200
    {
201
      cache_fsr = (struct frame_saved_regs *)
202
        frame_obstack_alloc (sizeof (struct frame_saved_regs));
203
      memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
204
 
205
      fi->fsr = cache_fsr;
206
 
207
      if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
208
        {                       /* no more to do. */
209
          if (fsr)
210
            *fsr = *fi->fsr;
211
          return;
212
        }
213
      /* Find the start and end of the function prologue.  If the PC
214
         is in the function prologue, we only consider the part that
215
         has executed already.  */
216
 
217
      ip = get_pc_function_start (fi->pc);
218
      sal = find_pc_line (ip, 0);
219
      limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
220
 
221
      /* This will fill in fields in *fi as well as in cache_fsr.  */
222
      examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
223
    }
224
 
225
  if (fsr)
226
    *fsr = *fi->fsr;
227
}
228
 
229
/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
230
   is not the address of a valid instruction, the address of the next
231
   instruction beyond ADDR otherwise.  *PWORD1 receives the first word
232
   of the instruction. */
233
 
234
CORE_ADDR
235
NEXT_PROLOGUE_INSN (addr, lim, pword1)
236
     CORE_ADDR addr;
237
     CORE_ADDR lim;
238
     INSN_WORD *pword1;
239
{
240
  char buf[2];
241
  if (addr < lim + 8)
242
    {
243
      read_memory (addr, buf, 2);
244
      *pword1 = extract_signed_integer (buf, 2);
245
 
246
      return addr + 2;
247
    }
248
  return 0;
249
}
250
 
251
/* Examine the prologue of a function.  `ip' points to the first instruction.
252
   `limit' is the limit of the prologue (e.g. the addr of the first
253
   linenumber, or perhaps the program counter if we're stepping through).
254
   `frame_sp' is the stack pointer value in use in this frame.
255
   `fsr' is a pointer to a frame_saved_regs structure into which we put
256
   info about the registers saved by this frame.
257
   `fi' is a struct frame_info pointer; we fill in various fields in it
258
   to reflect the offsets of the arg pointer and the locals pointer.  */
259
 
260
static CORE_ADDR
261
examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
262
     register CORE_ADDR ip;
263
     register CORE_ADDR limit;
264
     CORE_ADDR after_prolog_fp;
265
     struct frame_saved_regs *fsr;
266
     struct frame_info *fi;
267
{
268
  register CORE_ADDR next_ip;
269
  int r;
270
  int have_fp = 0;
271
  INSN_WORD insn_word;
272
  /* Number of things pushed onto stack, starts at 2/4, 'cause the
273
     PC is already there */
274
  unsigned int reg_save_depth = h8300hmode ? 4 : 2;
275
 
276
  unsigned int auto_depth = 0;   /* Number of bytes of autos */
277
 
278
  char in_frame[11];            /* One for each reg */
279
 
280
  int adjust = 0;
281
 
282
  memset (in_frame, 1, 11);
283
  for (r = 0; r < 8; r++)
284
    {
285
      fsr->regs[r] = 0;
286
    }
287
  if (after_prolog_fp == 0)
288
    {
289
      after_prolog_fp = read_register (SP_REGNUM);
290
    }
291
 
292
  /* If the PC isn't valid, quit now.  */
293
  if (ip == 0 || ip & (h8300hmode ? ~0xffffff : ~0xffff))
294
    return 0;
295
 
296
  next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
297
 
298
  if (insn_word == 0x0100)
299
    {
300
      insn_word = read_memory_unsigned_integer (ip + 2, 2);
301
      adjust = 2;
302
    }
303
 
304
  /* Skip over any fp push instructions */
305
  fsr->regs[6] = after_prolog_fp;
306
  while (next_ip && IS_PUSH_FP (insn_word))
307
    {
308
      ip = next_ip + adjust;
309
 
310
      in_frame[insn_word & 0x7] = reg_save_depth;
311
      next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
312
      reg_save_depth += 2 + adjust;
313
    }
314
 
315
  /* Is this a move into the fp */
316
  if (next_ip && IS_MOV_SP_FP (insn_word))
317
    {
318
      ip = next_ip;
319
      next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
320
      have_fp = 1;
321
    }
322
 
323
  /* Skip over any stack adjustment, happens either with a number of
324
     sub#2,sp or a mov #x,r5 sub r5,sp */
325
 
326
  if (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
327
    {
328
      while (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
329
        {
330
          auto_depth += IS_SUB2_SP (insn_word) ? 2 : 4;
331
          ip = next_ip;
332
          next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
333
        }
334
    }
335
  else
336
    {
337
      if (next_ip && IS_MOVK_R5 (insn_word))
338
        {
339
          ip = next_ip;
340
          next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
341
          auto_depth += insn_word;
342
 
343
          next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word);
344
          auto_depth += insn_word;
345
        }
346
      if (next_ip && IS_SUBL_SP (insn_word))
347
        {
348
          ip = next_ip;
349
          auto_depth += read_memory_unsigned_integer (ip, 4);
350
          ip += 4;
351
 
352
          next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
353
        }
354
    }
355
 
356
  /* Now examine the push insns to determine where everything lives
357
     on the stack.  */
358
  while (1)
359
    {
360
      adjust = 0;
361
      if (!next_ip)
362
        break;
363
 
364
      if (insn_word == 0x0100)
365
        {
366
          ip = next_ip;
367
          next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
368
          adjust = 2;
369
        }
370
 
371
      if (IS_PUSH (insn_word))
372
        {
373
          ip = next_ip;
374
          next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
375
          fsr->regs[r] = after_prolog_fp + auto_depth;
376
          auto_depth += 2 + adjust;
377
          continue;
378
        }
379
 
380
      /* Now check for push multiple insns.  */
381
      if (insn_word == 0x0110 || insn_word == 0x0120 || insn_word == 0x0130)
382
        {
383
          int count = ((insn_word >> 4) & 0xf) + 1;
384
          int start, i;
385
 
386
          ip = next_ip;
387
          next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
388
          start = insn_word & 0x7;
389
 
390
          for (i = start; i <= start + count; i++)
391
            {
392
              fsr->regs[i] = after_prolog_fp + auto_depth;
393
              auto_depth += 4;
394
            }
395
        }
396
      break;
397
    }
398
 
399
  /* The args are always reffed based from the stack pointer */
400
  fi->args_pointer = after_prolog_fp;
401
  /* Locals are always reffed based from the fp */
402
  fi->locals_pointer = after_prolog_fp;
403
  /* The PC is at a known place */
404
  fi->from_pc = read_memory_unsigned_integer (after_prolog_fp + BINWORD, BINWORD);
405
 
406
  /* Rememeber any others too */
407
  in_frame[PC_REGNUM] = 0;
408
 
409
  if (have_fp)
410
    /* We keep the old FP in the SP spot */
411
    fsr->regs[SP_REGNUM] = read_memory_unsigned_integer (fsr->regs[6], BINWORD);
412
  else
413
    fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
414
 
415
  return (ip);
416
}
417
 
418
void
419
h8300_init_extra_frame_info (fromleaf, fi)
420
     int fromleaf;
421
     struct frame_info *fi;
422
{
423
  fi->fsr = 0;                   /* Not yet allocated */
424
  fi->args_pointer = 0;          /* Unknown */
425
  fi->locals_pointer = 0;        /* Unknown */
426
  fi->from_pc = 0;
427
  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
428
    {                           /* anything special to do? */
429
      return;
430
    }
431
}
432
 
433
/* Return the saved PC from this frame.
434
 
435
   If the frame has a memory copy of SRP_REGNUM, use that.  If not,
436
   just use the register SRP_REGNUM itself.  */
437
 
438
CORE_ADDR
439
h8300_frame_saved_pc (frame)
440
     struct frame_info *frame;
441
{
442
  if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
443
    return generic_read_register_dummy (frame->pc, frame->frame, PC_REGNUM);
444
  else
445
    return frame->from_pc;
446
}
447
 
448
CORE_ADDR
449
frame_locals_address (fi)
450
     struct frame_info *fi;
451
{
452
  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
453
    return (CORE_ADDR) 0;        /* Not sure what else to do... */
454
  if (!fi->locals_pointer)
455
    {
456
      struct frame_saved_regs ignore;
457
 
458
      get_frame_saved_regs (fi, &ignore);
459
 
460
    }
461
  return fi->locals_pointer;
462
}
463
 
464
/* Return the address of the argument block for the frame
465
   described by FI.  Returns 0 if the address is unknown.  */
466
 
467
CORE_ADDR
468
frame_args_address (fi)
469
     struct frame_info *fi;
470
{
471
  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
472
    return (CORE_ADDR) 0;        /* Not sure what else to do... */
473
  if (!fi->args_pointer)
474
    {
475
      struct frame_saved_regs ignore;
476
 
477
      get_frame_saved_regs (fi, &ignore);
478
 
479
    }
480
 
481
  return fi->args_pointer;
482
}
483
 
484
/* Function: push_arguments
485
   Setup the function arguments for calling a function in the inferior.
486
 
487
   On the Hitachi H8/300 architecture, there are three registers (R0 to R2)
488
   which are dedicated for passing function arguments.  Up to the first
489
   three arguments (depending on size) may go into these registers.
490
   The rest go on the stack.
491
 
492
   Arguments that are smaller than WORDSIZE bytes will still take up a
493
   whole register or a whole WORDSIZE word on the stack, and will be
494
   right-justified in the register or the stack word.  This includes
495
   chars and small aggregate types.  Note that WORDSIZE depends on the
496
   cpu type.
497
 
498
   Arguments that are larger than WORDSIZE bytes will be split between
499
   two or more registers as available, but will NOT be split between a
500
   register and the stack.
501
 
502
   An exceptional case exists for struct arguments (and possibly other
503
   aggregates such as arrays) -- if the size is larger than WORDSIZE
504
   bytes but not a multiple of WORDSIZE bytes.  In this case the
505
   argument is never split between the registers and the stack, but
506
   instead is copied in its entirety onto the stack, AND also copied
507
   into as many registers as there is room for.  In other words, space
508
   in registers permitting, two copies of the same argument are passed
509
   in.  As far as I can tell, only the one on the stack is used,
510
   although that may be a function of the level of compiler
511
   optimization.  I suspect this is a compiler bug.  Arguments of
512
   these odd sizes are left-justified within the word (as opposed to
513
   arguments smaller than WORDSIZE bytes, which are right-justified).
514
 
515
   If the function is to return an aggregate type such as a struct,
516
   the caller must allocate space into which the callee will copy the
517
   return value.  In this case, a pointer to the return value location
518
   is passed into the callee in register R0, which displaces one of
519
   the other arguments passed in via registers R0 to R2.  */
520
 
521
CORE_ADDR
522
h8300_push_arguments (nargs, args, sp, struct_return, struct_addr)
523
     int nargs;
524
     struct value **args;
525
     CORE_ADDR sp;
526
     unsigned char struct_return;
527
     CORE_ADDR struct_addr;
528
{
529
  int stack_align, stack_alloc, stack_offset;
530
  int wordsize;
531
  int argreg;
532
  int argnum;
533
  struct type *type;
534
  CORE_ADDR regval;
535
  char *val;
536
  char valbuf[4];
537
  int len;
538
 
539
  if (h8300hmode || h8300smode)
540
    {
541
      stack_align = 3;
542
      wordsize = 4;
543
    }
544
  else
545
    {
546
      stack_align = 1;
547
      wordsize = 2;
548
    }
549
 
550
  /* first force sp to a n-byte alignment */
551
  sp = sp & ~stack_align;
552
 
553
  /* Now make sure there's space on the stack */
554
  for (argnum = 0, stack_alloc = 0;
555
       argnum < nargs; argnum++)
556
    stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + stack_align)
557
                    & ~stack_align);
558
  sp -= stack_alloc;            /* make room on stack for args */
559
  /* we may over-allocate a little here, but that won't hurt anything */
560
 
561
  argreg = ARG0_REGNUM;
562
  if (struct_return)            /* "struct return" pointer takes up one argreg */
563
    {
564
      write_register (argreg++, struct_addr);
565
    }
566
 
567
  /* Now load as many as possible of the first arguments into
568
     registers, and push the rest onto the stack.  There are 3N bytes
569
     in three registers available.  Loop thru args from first to last.  */
570
 
571
  for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
572
    {
573
      type = VALUE_TYPE (args[argnum]);
574
      len = TYPE_LENGTH (type);
575
      memset (valbuf, 0, sizeof (valbuf));
576
      if (len < wordsize)
577
        {
578
          /* the purpose of this is to right-justify the value within the word */
579
          memcpy (valbuf + (wordsize - len),
580
                  (char *) VALUE_CONTENTS (args[argnum]), len);
581
          val = valbuf;
582
        }
583
      else
584
        val = (char *) VALUE_CONTENTS (args[argnum]);
585
 
586
      if (len > (ARGLAST_REGNUM + 1 - argreg) * REGISTER_RAW_SIZE (ARG0_REGNUM) ||
587
          (len > wordsize && (len & stack_align) != 0))
588
        {                       /* passed on the stack */
589
          write_memory (sp + stack_offset, val,
590
                        len < wordsize ? wordsize : len);
591
          stack_offset += (len + stack_align) & ~stack_align;
592
        }
593
      /* NOTE WELL!!!!!  This is not an "else if" clause!!!
594
         That's because some *&^%$ things get passed on the stack
595
         AND in the registers!   */
596
      if (len <= (ARGLAST_REGNUM + 1 - argreg) * REGISTER_RAW_SIZE (ARG0_REGNUM))
597
        while (len > 0)
598
          {                     /* there's room in registers */
599
            regval = extract_address (val, wordsize);
600
            write_register (argreg, regval);
601
            len -= wordsize;
602
            val += wordsize;
603
            argreg++;
604
          }
605
    }
606
  return sp;
607
}
608
 
609
/* Function: push_return_address
610
   Setup the return address for a dummy frame, as called by
611
   call_function_by_hand.  Only necessary when you are using an
612
   empty CALL_DUMMY, ie. the target will not actually be executing
613
   a JSR/BSR instruction.  */
614
 
615
CORE_ADDR
616
h8300_push_return_address (pc, sp)
617
     CORE_ADDR pc;
618
     CORE_ADDR sp;
619
{
620
  unsigned char buf[4];
621
  int wordsize;
622
 
623
  if (h8300hmode || h8300smode)
624
    wordsize = 4;
625
  else
626
    wordsize = 2;
627
 
628
  sp -= wordsize;
629
  store_unsigned_integer (buf, wordsize, CALL_DUMMY_ADDRESS ());
630
  write_memory (sp, buf, wordsize);
631
  return sp;
632
}
633
 
634
/* Function: pop_frame
635
   Restore the machine to the state it had before the current frame
636
   was created.  Usually used either by the "RETURN" command, or by
637
   call_function_by_hand after the dummy_frame is finished. */
638
 
639
void
640
h8300_pop_frame ()
641
{
642
  unsigned regnum;
643
  struct frame_saved_regs fsr;
644
  struct frame_info *frame = get_current_frame ();
645
 
646
  if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
647
    {
648
      generic_pop_dummy_frame ();
649
    }
650
  else
651
    {
652
      get_frame_saved_regs (frame, &fsr);
653
 
654
      for (regnum = 0; regnum < 8; regnum++)
655
        {
656
          /* Don't forget SP_REGNUM is a frame_saved_regs struct is the
657
             actual value we want, not the address of the value we want.  */
658
          if (fsr.regs[regnum] && regnum != SP_REGNUM)
659
            write_register (regnum,
660
                            read_memory_integer (fsr.regs[regnum], BINWORD));
661
          else if (fsr.regs[regnum] && regnum == SP_REGNUM)
662
            write_register (regnum, frame->frame + 2 * BINWORD);
663
        }
664
 
665
      /* Don't forget the update the PC too!  */
666
      write_pc (frame->from_pc);
667
    }
668
  flush_cached_frames ();
669
}
670
 
671
/* Function: extract_return_value
672
   Figure out where in REGBUF the called function has left its return value.
673
   Copy that into VALBUF.  Be sure to account for CPU type.   */
674
 
675
void
676
h8300_extract_return_value (type, regbuf, valbuf)
677
     struct type *type;
678
     char *regbuf;
679
     char *valbuf;
680
{
681
  int wordsize, len;
682
 
683
  if (h8300smode || h8300hmode)
684
    wordsize = 4;
685
  else
686
    wordsize = 2;
687
 
688
  len = TYPE_LENGTH (type);
689
 
690
  switch (len)
691
    {
692
    case 1:                     /* (char) */
693
    case 2:                     /* (short), (int) */
694
      memcpy (valbuf, regbuf + REGISTER_BYTE (0) + (wordsize - len), len);
695
      break;
696
    case 4:                     /* (long), (float) */
697
      if (h8300smode || h8300hmode)
698
        {
699
          memcpy (valbuf, regbuf + REGISTER_BYTE (0), 4);
700
        }
701
      else
702
        {
703
          memcpy (valbuf, regbuf + REGISTER_BYTE (0), 2);
704
          memcpy (valbuf + 2, regbuf + REGISTER_BYTE (1), 2);
705
        }
706
      break;
707
    case 8:                     /* (double) (doesn't seem to happen, which is good,
708
                                   because this almost certainly isn't right.  */
709
      error ("I don't know how a double is returned.");
710
      break;
711
    }
712
}
713
 
714
/* Function: store_return_value
715
   Place the appropriate value in the appropriate registers.
716
   Primarily used by the RETURN command.  */
717
 
718
void
719
h8300_store_return_value (type, valbuf)
720
     struct type *type;
721
     char *valbuf;
722
{
723
  int wordsize, len, regval;
724
 
725
  if (h8300hmode || h8300smode)
726
    wordsize = 4;
727
  else
728
    wordsize = 2;
729
 
730
  len = TYPE_LENGTH (type);
731
  switch (len)
732
    {
733
    case 1:                     /* char */
734
    case 2:                     /* short, int */
735
      regval = extract_address (valbuf, len);
736
      write_register (0, regval);
737
      break;
738
    case 4:                     /* long, float */
739
      regval = extract_address (valbuf, len);
740
      if (h8300smode || h8300hmode)
741
        {
742
          write_register (0, regval);
743
        }
744
      else
745
        {
746
          write_register (0, regval >> 16);
747
          write_register (1, regval & 0xffff);
748
        }
749
      break;
750
    case 8:                     /* presumeably double, but doesn't seem to happen */
751
      error ("I don't know how to return a double.");
752
      break;
753
    }
754
}
755
 
756
struct cmd_list_element *setmemorylist;
757
 
758
static void
759
set_register_names ()
760
{
761
  if (h8300hmode != 0)
762
    h8300_register_names = h8300h_register_names;
763
  else
764
    h8300_register_names = original_register_names;
765
}
766
 
767
static void
768
h8300_command (args, from_tty)
769
{
770
  extern int h8300hmode;
771
  h8300hmode = 0;
772
  h8300smode = 0;
773
  set_register_names ();
774
}
775
 
776
static void
777
h8300h_command (args, from_tty)
778
{
779
  extern int h8300hmode;
780
  h8300hmode = 1;
781
  h8300smode = 0;
782
  set_register_names ();
783
}
784
 
785
static void
786
h8300s_command (args, from_tty)
787
{
788
  extern int h8300smode;
789
  extern int h8300hmode;
790
  h8300smode = 1;
791
  h8300hmode = 1;
792
  set_register_names ();
793
}
794
 
795
 
796
static void
797
set_machine (args, from_tty)
798
     char *args;
799
     int from_tty;
800
{
801
  printf_unfiltered ("\"set machine\" must be followed by h8300, h8300h");
802
  printf_unfiltered ("or h8300s");
803
  help_list (setmemorylist, "set memory ", -1, gdb_stdout);
804
}
805
 
806
/* set_machine_hook is called as the exec file is being opened, but
807
   before the symbol file is opened.  This allows us to set the
808
   h8300hmode flag based on the machine type specified in the exec
809
   file.  This in turn will cause subsequently defined pointer types
810
   to be 16 or 32 bits as appropriate for the machine.  */
811
 
812
static void
813
set_machine_hook (filename)
814
     char *filename;
815
{
816
  if (bfd_get_mach (exec_bfd) == bfd_mach_h8300s)
817
    {
818
      h8300smode = 1;
819
      h8300hmode = 1;
820
    }
821
  else if (bfd_get_mach (exec_bfd) == bfd_mach_h8300h)
822
    {
823
      h8300smode = 0;
824
      h8300hmode = 1;
825
    }
826
  else
827
    {
828
      h8300smode = 0;
829
      h8300hmode = 0;
830
    }
831
  set_register_names ();
832
}
833
 
834
void
835
_initialize_h8300m ()
836
{
837
  add_prefix_cmd ("machine", no_class, set_machine,
838
                  "set the machine type",
839
                  &setmemorylist, "set machine ", 0,
840
                  &setlist);
841
 
842
  add_cmd ("h8300", class_support, h8300_command,
843
           "Set machine to be H8/300.", &setmemorylist);
844
 
845
  add_cmd ("h8300h", class_support, h8300h_command,
846
           "Set machine to be H8/300H.", &setmemorylist);
847
 
848
  add_cmd ("h8300s", class_support, h8300s_command,
849
           "Set machine to be H8/300S.", &setmemorylist);
850
 
851
  /* Add a hook to set the machine type when we're loading a file. */
852
 
853
  specify_exec_file_hook (set_machine_hook);
854
}
855
 
856
 
857
 
858
void
859
print_register_hook (regno)
860
{
861
  if (regno == 8)
862
    {
863
      /* CCR register */
864
      int C, Z, N, V;
865
      unsigned char b[4];
866
      unsigned char l;
867
      read_relative_register_raw_bytes (regno, b);
868
      l = b[REGISTER_VIRTUAL_SIZE (8) - 1];
869
      printf_unfiltered ("\t");
870
      printf_unfiltered ("I-%d - ", (l & 0x80) != 0);
871
      printf_unfiltered ("H-%d - ", (l & 0x20) != 0);
872
      N = (l & 0x8) != 0;
873
      Z = (l & 0x4) != 0;
874
      V = (l & 0x2) != 0;
875
      C = (l & 0x1) != 0;
876
      printf_unfiltered ("N-%d ", N);
877
      printf_unfiltered ("Z-%d ", Z);
878
      printf_unfiltered ("V-%d ", V);
879
      printf_unfiltered ("C-%d ", C);
880
      if ((C | Z) == 0)
881
        printf_unfiltered ("u> ");
882
      if ((C | Z) == 1)
883
        printf_unfiltered ("u<= ");
884
      if ((C == 0))
885
        printf_unfiltered ("u>= ");
886
      if (C == 1)
887
        printf_unfiltered ("u< ");
888
      if (Z == 0)
889
        printf_unfiltered ("!= ");
890
      if (Z == 1)
891
        printf_unfiltered ("== ");
892
      if ((N ^ V) == 0)
893
        printf_unfiltered (">= ");
894
      if ((N ^ V) == 1)
895
        printf_unfiltered ("< ");
896
      if ((Z | (N ^ V)) == 0)
897
        printf_unfiltered ("> ");
898
      if ((Z | (N ^ V)) == 1)
899
        printf_unfiltered ("<= ");
900
    }
901
}
902
 
903
void
904
_initialize_h8300_tdep ()
905
{
906
  tm_print_insn = gdb_print_insn_h8300;
907
}

powered by: WebSVN 2.1.0

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