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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [go32-nat.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Native debugging support for Intel x86 running DJGPP.
2
   Copyright 1997, 1999 Free Software Foundation, Inc.
3
   Written by Robert Hoehne.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include <fcntl.h>
23
 
24
#include "defs.h"
25
#include "inferior.h"
26
#include "gdb_wait.h"
27
#include "gdbcore.h"
28
#include "command.h"
29
#include "floatformat.h"
30
#include "buildsym.h"
31
 
32
#include <stdio.h>              /* required for __DJGPP_MINOR__ */
33
#include <stdlib.h>
34
#include <string.h>
35
#include <errno.h>
36
#include <unistd.h>
37
#include <io.h>
38
#include <dpmi.h>
39
#include <debug/v2load.h>
40
#include <debug/dbgcom.h>
41
#if __DJGPP_MINOR__ > 2
42
#include <debug/redir.h>
43
#endif
44
 
45
#if __DJGPP_MINOR__ < 3
46
/* This code will be provided from DJGPP 2.03 on. Until then I code it
47
   here */
48
typedef struct
49
  {
50
    unsigned short sig0;
51
    unsigned short sig1;
52
    unsigned short sig2;
53
    unsigned short sig3;
54
    unsigned short exponent:15;
55
    unsigned short sign:1;
56
  }
57
NPXREG;
58
 
59
typedef struct
60
  {
61
    unsigned int control;
62
    unsigned int status;
63
    unsigned int tag;
64
    unsigned int eip;
65
    unsigned int cs;
66
    unsigned int dataptr;
67
    unsigned int datasel;
68
    NPXREG reg[8];
69
  }
70
NPX;
71
 
72
static NPX npx;
73
 
74
static void save_npx (void);    /* Save the FPU of the debugged program */
75
static void load_npx (void);    /* Restore the FPU of the debugged program */
76
 
77
/* ------------------------------------------------------------------------- */
78
/* Store the contents of the NPX in the global variable `npx'.  */
79
/* *INDENT-OFF* */
80
 
81
static void
82
save_npx (void)
83
{
84
  asm ("inb    $0xa0, %%al
85
       testb $0x20, %%al
86
       jz 1f
87
       xorb %% al, %%al
88
       outb %% al, $0xf0
89
       movb $0x20, %%al
90
       outb %% al, $0xa0
91
       outb %% al, $0x20
92
1:
93
       fnsave % 0
94
       fwait "
95
:     "=m" (npx)
96
:                               /* No input */
97
:     "%eax");
98
}
99
 
100
/* *INDENT-ON* */
101
 
102
 
103
 
104
 
105
 
106
/* ------------------------------------------------------------------------- */
107
/* Reload the contents of the NPX from the global variable `npx'.  */
108
 
109
static void
110
load_npx (void)
111
{
112
asm ("frstor %0":"=m" (npx));
113
}
114
/* ------------------------------------------------------------------------- */
115
/* Stubs for the missing redirection functions.  */
116
typedef struct {
117
  char *command;
118
  int redirected;
119
} cmdline_t;
120
 
121
void redir_cmdline_delete (cmdline_t *ptr) {ptr->redirected = 0;}
122
int  redir_cmdline_parse (const char *args, cmdline_t *ptr)
123
{
124
  return -1;
125
}
126
int redir_to_child (cmdline_t *ptr)
127
{
128
  return 1;
129
}
130
int redir_to_debugger (cmdline_t *ptr)
131
{
132
  return 1;
133
}
134
int redir_debug_init (cmdline_t *ptr) { return 0; }
135
#endif /* __DJGPP_MINOR < 3 */
136
 
137
extern void _initialize_go32_nat (void);
138
 
139
typedef enum { wp_insert, wp_remove, wp_count } wp_op;
140
 
141
/* This holds the current reference counts for each debug register.  */
142
static int dr_ref_count[4];
143
 
144
extern char **environ;
145
 
146
#define SOME_PID 42
147
 
148
static int prog_has_started = 0;
149
static void go32_open (char *name, int from_tty);
150
static void go32_close (int quitting);
151
static void go32_attach (char *args, int from_tty);
152
static void go32_detach (char *args, int from_tty);
153
static void go32_resume (int pid, int step, enum target_signal siggnal);
154
static int go32_wait (int pid, struct target_waitstatus *status);
155
static void go32_fetch_registers (int regno);
156
static void store_register (int regno);
157
static void go32_store_registers (int regno);
158
static void go32_prepare_to_store (void);
159
static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
160
                             int write, struct target_ops *target);
161
static void go32_files_info (struct target_ops *target);
162
static void go32_stop (void);
163
static void go32_kill_inferior (void);
164
static void go32_create_inferior (char *exec_file, char *args, char **env);
165
static void cleanup_dregs (void);
166
static void go32_mourn_inferior (void);
167
static int go32_can_run (void);
168
static int go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
169
                                           int len, int rw);
170
static int go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
171
                                           int len, int rw);
172
static int go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr,
173
                                              CORE_ADDR addr, int len, int rw);
174
 
175
static struct target_ops go32_ops;
176
static void go32_terminal_init (void);
177
static void go32_terminal_inferior (void);
178
static void go32_terminal_ours (void);
179
 
180
#define r_ofs(x) (offsetof(TSS,x))
181
 
182
static struct
183
{
184
  size_t tss_ofs;
185
  size_t size;
186
}
187
regno_mapping[] =
188
{
189
  {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
190
  {r_ofs (tss_ecx), 4},
191
  {r_ofs (tss_edx), 4},
192
  {r_ofs (tss_ebx), 4},
193
  {r_ofs (tss_esp), 4},
194
  {r_ofs (tss_ebp), 4},
195
  {r_ofs (tss_esi), 4},
196
  {r_ofs (tss_edi), 4},
197
  {r_ofs (tss_eip), 4},
198
  {r_ofs (tss_eflags), 4},
199
  {r_ofs (tss_cs), 2},
200
  {r_ofs (tss_ss), 2},
201
  {r_ofs (tss_ds), 2},
202
  {r_ofs (tss_es), 2},
203
  {r_ofs (tss_fs), 2},
204
  {r_ofs (tss_gs), 2},
205
  {0, 10},               /* 8 FP registers, from npx.reg[] */
206
  {1, 10},
207
  {2, 10},
208
  {3, 10},
209
  {4, 10},
210
  {5, 10},
211
  {6, 10},
212
  {7, 10},
213
        /* The order of the next 7 registers must be consistent
214
           with their numbering in config/i386/tm-i386.h, which see.  */
215
  {0, 2},                /* control word, from npx */
216
  {4, 2},               /* status word, from npx */
217
  {8, 2},               /* tag word, from npx */
218
  {16, 2},              /* last FP exception CS from npx */
219
  {12, 4},              /* last FP exception EIP from npx */
220
  {24, 2},              /* last FP exception operand selector from npx */
221
  {20, 4},              /* last FP exception operand offset from npx */
222
  {18, 2}               /* last FP opcode from npx */
223
};
224
 
225
static struct
226
  {
227
    int go32_sig;
228
    enum target_signal gdb_sig;
229
  }
230
sig_map[] =
231
{
232
  {0, TARGET_SIGNAL_FPE},
233
  {1, TARGET_SIGNAL_TRAP},
234
  /* Exception 2 is triggered by the NMI.  DJGPP handles it as SIGILL,
235
     but I think SIGBUS is better, since the NMI is usually activated
236
     as a result of a memory parity check failure.  */
237
  {2, TARGET_SIGNAL_BUS},
238
  {3, TARGET_SIGNAL_TRAP},
239
  {4, TARGET_SIGNAL_FPE},
240
  {5, TARGET_SIGNAL_SEGV},
241
  {6, TARGET_SIGNAL_ILL},
242
  {7, TARGET_SIGNAL_EMT},       /* no-coprocessor exception */
243
  {8, TARGET_SIGNAL_SEGV},
244
  {9, TARGET_SIGNAL_SEGV},
245
  {10, TARGET_SIGNAL_BUS},
246
  {11, TARGET_SIGNAL_SEGV},
247
  {12, TARGET_SIGNAL_SEGV},
248
  {13, TARGET_SIGNAL_SEGV},
249
  {14, TARGET_SIGNAL_SEGV},
250
  {16, TARGET_SIGNAL_FPE},
251
  {17, TARGET_SIGNAL_BUS},
252
  {31, TARGET_SIGNAL_ILL},
253
  {0x1b, TARGET_SIGNAL_INT},
254
  {0x75, TARGET_SIGNAL_FPE},
255
  {0x78, TARGET_SIGNAL_ALRM},
256
  {0x79, TARGET_SIGNAL_INT},
257
  {0x7a, TARGET_SIGNAL_QUIT},
258
  {-1, TARGET_SIGNAL_LAST}
259
};
260
 
261
static struct {
262
  enum target_signal gdb_sig;
263
  int djgpp_excepno;
264
} excepn_map[] = {
265
  {TARGET_SIGNAL_0, -1},
266
  {TARGET_SIGNAL_ILL, 6},       /* Invalid Opcode */
267
  {TARGET_SIGNAL_EMT, 7},       /* triggers SIGNOFP */
268
  {TARGET_SIGNAL_SEGV, 13},     /* GPF */
269
  {TARGET_SIGNAL_BUS, 17},      /* Alignment Check */
270
  /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
271
     details.  */
272
  {TARGET_SIGNAL_TERM, 0x1b},   /* triggers Ctrl-Break type of SIGINT */
273
  {TARGET_SIGNAL_FPE, 0x75},
274
  {TARGET_SIGNAL_INT, 0x79},
275
  {TARGET_SIGNAL_QUIT, 0x7a},
276
  {TARGET_SIGNAL_ALRM, 0x78},   /* triggers SIGTIMR */
277
  {TARGET_SIGNAL_PROF, 0x78},
278
  {TARGET_SIGNAL_LAST, -1}
279
};
280
 
281
static void
282
go32_open (char *name ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
283
{
284
  printf_unfiltered ("Done.  Use the \"run\" command to run the program.\n");
285
}
286
 
287
static void
288
go32_close (int quitting ATTRIBUTE_UNUSED)
289
{
290
}
291
 
292
static void
293
go32_attach (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
294
{
295
  error ("\
296
You cannot attach to a running program on this platform.\n\
297
Use the `run' command to run DJGPP programs.");
298
}
299
 
300
static void
301
go32_detach (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
302
{
303
}
304
 
305
static int resume_is_step;
306
static int resume_signal = -1;
307
 
308
static void
309
go32_resume (int pid ATTRIBUTE_UNUSED, int step, enum target_signal siggnal)
310
{
311
  int i;
312
 
313
  resume_is_step = step;
314
 
315
  if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
316
  {
317
    for (i = 0, resume_signal = -1;
318
         excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
319
      if (excepn_map[i].gdb_sig == siggnal)
320
      {
321
        resume_signal = excepn_map[i].djgpp_excepno;
322
        break;
323
      }
324
    if (resume_signal == -1)
325
      printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
326
                         target_signal_to_name (siggnal));
327
  }
328
}
329
 
330
static char child_cwd[FILENAME_MAX];
331
 
332
static int
333
go32_wait (int pid ATTRIBUTE_UNUSED, struct target_waitstatus *status)
334
{
335
  int i;
336
  unsigned char saved_opcode;
337
  unsigned long INT3_addr = 0;
338
  int stepping_over_INT = 0;
339
 
340
  a_tss.tss_eflags &= 0xfeff;   /* reset the single-step flag (TF) */
341
  if (resume_is_step)
342
    {
343
      /* If the next instruction is INT xx or INTO, we need to handle
344
         them specially.  Intel manuals say that these instructions
345
         reset the single-step flag (a.k.a. TF).  However, it seems
346
         that, at least in the DPMI environment, and at least when
347
         stepping over the DPMI interrupt 31h, the problem is having
348
         TF set at all when INT 31h is executed: the debuggee either
349
         crashes (and takes the system with it) or is killed by a
350
         SIGTRAP.
351
 
352
         So we need to emulate single-step mode: we put an INT3 opcode
353
         right after the INT xx instruction, let the debuggee run
354
         until it hits INT3 and stops, then restore the original
355
         instruction which we overwrote with the INT3 opcode, and back
356
         up the debuggee's EIP to that instruction.  */
357
      read_child (a_tss.tss_eip, &saved_opcode, 1);
358
      if (saved_opcode == 0xCD || saved_opcode == 0xCE)
359
        {
360
          unsigned char INT3_opcode = 0xCC;
361
 
362
          INT3_addr
363
            = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
364
          stepping_over_INT = 1;
365
          read_child (INT3_addr, &saved_opcode, 1);
366
          write_child (INT3_addr, &INT3_opcode, 1);
367
        }
368
      else
369
        a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
370
    }
371
 
372
  /* The special value FFFFh in tss_trap indicates to run_child that
373
     tss_irqn holds a signal to be delivered to the debuggee.  */
374
  if (resume_signal <= -1)
375
    {
376
      a_tss.tss_trap = 0;
377
      a_tss.tss_irqn = 0xff;
378
    }
379
  else
380
    {
381
      a_tss.tss_trap = 0xffff;  /* run_child looks for this */
382
      a_tss.tss_irqn = resume_signal;
383
    }
384
 
385
  /* The child might change working directory behind our back.  The
386
     GDB users won't like the side effects of that when they work with
387
     relative file names, and GDB might be confused by its current
388
     directory not being in sync with the truth.  So we always make a
389
     point of changing back to where GDB thinks is its cwd, when we
390
     return control to the debugger, but restore child's cwd before we
391
     run it.  */
392
  chdir (child_cwd);
393
 
394
#if __DJGPP_MINOR__ < 3
395
  load_npx ();
396
#endif
397
  run_child ();
398
#if __DJGPP_MINOR__ < 3
399
  save_npx ();
400
#endif
401
 
402
  /* Did we step over an INT xx instruction?  */
403
  if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
404
    {
405
      /* Restore the original opcode.  */
406
      a_tss.tss_eip--;  /* EIP points *after* the INT3 instruction */
407
      write_child (a_tss.tss_eip, &saved_opcode, 1);
408
      /* Simulate a TRAP exception.  */
409
      a_tss.tss_irqn = 1;
410
      a_tss.tss_eflags |= 0x0100;
411
    }
412
 
413
  getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
414
  chdir (current_directory);
415
 
416
  if (a_tss.tss_irqn == 0x21)
417
    {
418
      status->kind = TARGET_WAITKIND_EXITED;
419
      status->value.integer = a_tss.tss_eax & 0xff;
420
    }
421
  else
422
    {
423
      status->value.sig = TARGET_SIGNAL_UNKNOWN;
424
      status->kind = TARGET_WAITKIND_STOPPED;
425
      for (i = 0; sig_map[i].go32_sig != -1; i++)
426
        {
427
          if (a_tss.tss_irqn == sig_map[i].go32_sig)
428
            {
429
#if __DJGPP_MINOR__ < 3
430
              if ((status->value.sig = sig_map[i].gdb_sig) !=
431
                  TARGET_SIGNAL_TRAP)
432
                status->kind = TARGET_WAITKIND_SIGNALLED;
433
#else
434
              status->value.sig = sig_map[i].gdb_sig;
435
#endif
436
              break;
437
            }
438
        }
439
    }
440
  return SOME_PID;
441
}
442
 
443
static void
444
go32_fetch_registers (int regno)
445
{
446
  /*JHW */
447
  int end_reg = regno + 1;      /* just one reg initially */
448
 
449
  if (regno < 0)         /* do the all registers */
450
    {
451
      regno = 0;         /* start at first register */
452
      /* # regs in table */
453
      end_reg = sizeof (regno_mapping) / sizeof (regno_mapping[0]);
454
    }
455
 
456
  for (; regno < end_reg; regno++)
457
    {
458
      if (regno < 16)
459
        supply_register (regno,
460
                         (char *) &a_tss + regno_mapping[regno].tss_ofs);
461
      else if (regno < 24)
462
        supply_register (regno,
463
                         (char *) &npx.reg[regno_mapping[regno].tss_ofs]);
464
      else if (regno < 32)
465
        {
466
          unsigned regval;
467
 
468
          switch (regno_mapping[regno].size)
469
            {
470
              case 2:
471
                regval = *(unsigned short *)
472
                  ((char *) &npx + regno_mapping[regno].tss_ofs);
473
                regval &= 0xffff;
474
                if (regno == FOP_REGNUM && regval)
475
                  /* Feature: restore the 5 bits of the opcode
476
                     stripped by FSAVE/FNSAVE.  */
477
                  regval |= 0xd800;
478
                break;
479
              case 4:
480
                regval = *(unsigned *)
481
                  ((char *) &npx + regno_mapping[regno].tss_ofs);
482
                break;
483
              default:
484
                internal_error ("\
485
Invalid native size for register no. %d in go32_fetch_register.", regno);
486
            }
487
          supply_register (regno, (char *) &regval);
488
        }
489
      else
490
        internal_error ("Invalid register no. %d in go32_fetch_register.",
491
                        regno);
492
    }
493
}
494
 
495
static void
496
store_register (int regno)
497
{
498
  void *rp;
499
  void *v = (void *) &registers[REGISTER_BYTE (regno)];
500
 
501
  if (regno < 16)
502
    rp = (char *) &a_tss + regno_mapping[regno].tss_ofs;
503
  else if (regno < 24)
504
    rp = (char *) &npx.reg[regno_mapping[regno].tss_ofs];
505
  else if (regno < 32)
506
    rp = (char *) &npx + regno_mapping[regno].tss_ofs;
507
  else
508
    internal_error ("Invalid register no. %d in store_register.", regno);
509
  memcpy (rp, v, regno_mapping[regno].size);
510
  if (regno == FOP_REGNUM)
511
    *(short *)rp &= 0x07ff; /* strip high 5 bits, in case they added them */
512
}
513
 
514
static void
515
go32_store_registers (int regno)
516
{
517
  unsigned r;
518
 
519
  if (regno >= 0)
520
    store_register (regno);
521
  else
522
    {
523
      for (r = 0; r < sizeof (regno_mapping) / sizeof (regno_mapping[0]); r++)
524
        store_register (r);
525
    }
526
}
527
 
528
static void
529
go32_prepare_to_store (void)
530
{
531
}
532
 
533
static int
534
go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
535
                  struct target_ops *target ATTRIBUTE_UNUSED)
536
{
537
  if (write)
538
    {
539
      if (write_child (memaddr, myaddr, len))
540
        {
541
          return 0;
542
        }
543
      else
544
        {
545
          return len;
546
        }
547
    }
548
  else
549
    {
550
      if (read_child (memaddr, myaddr, len))
551
        {
552
          return 0;
553
        }
554
      else
555
        {
556
          return len;
557
        }
558
    }
559
}
560
 
561
static cmdline_t child_cmd;     /* parsed child's command line kept here */
562
 
563
static void
564
go32_files_info (struct target_ops *target ATTRIBUTE_UNUSED)
565
{
566
  printf_unfiltered ("You are running a DJGPP V2 program.\n");
567
}
568
 
569
static void
570
go32_stop (void)
571
{
572
  normal_stop ();
573
  cleanup_client ();
574
  inferior_pid = 0;
575
  prog_has_started = 0;
576
}
577
 
578
static void
579
go32_kill_inferior (void)
580
{
581
  redir_cmdline_delete (&child_cmd);
582
  resume_signal = -1;
583
  resume_is_step = 0;
584
  unpush_target (&go32_ops);
585
}
586
 
587
static void
588
go32_create_inferior (char *exec_file, char *args, char **env)
589
{
590
  jmp_buf start_state;
591
  char *cmdline;
592
  char **env_save = environ;
593
 
594
  /* If no exec file handed to us, get it from the exec-file command -- with
595
     a good, common error message if none is specified.  */
596
  if (exec_file == 0)
597
    exec_file = get_exec_file (1);
598
 
599
  if (prog_has_started)
600
    {
601
      go32_stop ();
602
      go32_kill_inferior ();
603
    }
604
  resume_signal = -1;
605
  resume_is_step = 0;
606
  /* Init command line storage.  */
607
  if (redir_debug_init (&child_cmd) == -1)
608
    internal_error ("Cannot allocate redirection storage: not enough memory.\n");
609
 
610
  /* Parse the command line and create redirections.  */
611
  if (strpbrk (args, "<>"))
612
    {
613
      if (redir_cmdline_parse (args, &child_cmd) == 0)
614
        args = child_cmd.command;
615
      else
616
        error ("Syntax error in command line.");
617
    }
618
  else
619
    child_cmd.command = xstrdup (args);
620
 
621
  cmdline = (char *) alloca (strlen (args) + 4);
622
  cmdline[0] = strlen (args);
623
  strcpy (cmdline + 1, args);
624
  cmdline[strlen (args) + 1] = 13;
625
 
626
  environ = env;
627
 
628
  if (v2loadimage (exec_file, cmdline, start_state))
629
    {
630
      environ = env_save;
631
      printf_unfiltered ("Load failed for image %s\n", exec_file);
632
      exit (1);
633
    }
634
  environ = env_save;
635
 
636
  edi_init (start_state);
637
#if __DJGPP_MINOR__ < 3
638
  save_npx ();
639
#endif
640
 
641
  inferior_pid = SOME_PID;
642
  push_target (&go32_ops);
643
  clear_proceed_status ();
644
  insert_breakpoints ();
645
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
646
  prog_has_started = 1;
647
}
648
 
649
static void
650
go32_mourn_inferior (void)
651
{
652
  /* We need to make sure all the breakpoint enable bits in the DR7
653
     register are reset when the inferior exits.  Otherwise, if they
654
     rerun the inferior, the uncleared bits may cause random SIGTRAPs,
655
     failure to set more watchpoints, and other calamities.  It would
656
     be nice if GDB itself would take care to remove all breakpoints
657
     at all times, but it doesn't, probably under an assumption that
658
     the OS cleans up when the debuggee exits.  */
659
  cleanup_dregs ();
660
  go32_kill_inferior ();
661
  generic_mourn_inferior ();
662
}
663
 
664
static int
665
go32_can_run (void)
666
{
667
  return 1;
668
}
669
 
670
/* Hardware watchpoint support.  */
671
 
672
#define DR_STATUS 6
673
#define DR_CONTROL 7
674
#define DR_ENABLE_SIZE 2
675
#define DR_LOCAL_ENABLE_SHIFT 0
676
#define DR_GLOBAL_ENABLE_SHIFT 1
677
#define DR_LOCAL_SLOWDOWN 0x100
678
#define DR_GLOBAL_SLOWDOWN 0x200
679
#define DR_CONTROL_SHIFT 16
680
#define DR_CONTROL_SIZE 4
681
#define DR_RW_READWRITE 0x3
682
#define DR_RW_WRITE 0x1
683
#define DR_CONTROL_MASK 0xf
684
#define DR_ENABLE_MASK 0x3
685
#define DR_LEN_1 0x0
686
#define DR_LEN_2 0x4
687
#define DR_LEN_4 0xc
688
 
689
#define D_REGS edi.dr
690
#define CONTROL D_REGS[DR_CONTROL]
691
#define STATUS D_REGS[DR_STATUS]
692
 
693
#define IS_REG_FREE(index) \
694
  (!(CONTROL & (3 << (DR_ENABLE_SIZE * (index)))))
695
 
696
#define LOCAL_ENABLE_REG(index) \
697
  (CONTROL |= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
698
 
699
#define GLOBAL_ENABLE_REG(index) \
700
  (CONTROL |= (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
701
 
702
#define DISABLE_REG(index) \
703
  (CONTROL &= ~(3 << (DR_ENABLE_SIZE * (index))))
704
 
705
#define SET_LOCAL_EXACT() \
706
  (CONTROL |= DR_LOCAL_SLOWDOWN)
707
 
708
#define SET_GLOBAL_EXACT() \
709
  (CONTROL |= DR_GLOBAL_SLOWDOWN)
710
 
711
#define RESET_LOCAL_EXACT() \
712
   (CONTROL &= ~(DR_LOCAL_SLOWDOWN))
713
 
714
#define RESET_GLOBAL_EXACT() \
715
   (CONTROL &= ~(DR_GLOBAL_SLOWDOWN))
716
 
717
#define SET_BREAK(index,address) \
718
  do {\
719
    CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index)));\
720
    D_REGS[index] = address;\
721
    dr_ref_count[index]++;\
722
  } while(0)
723
 
724
#define SET_WATCH(index,address,rw,len) \
725
  do {\
726
    SET_BREAK(index,address);\
727
    CONTROL |= ((len)|(rw)) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index));\
728
  } while (0)
729
 
730
#define IS_WATCH(index) \
731
  (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE*(index))))
732
 
733
#define WATCH_HIT(index) ((STATUS & (1 << (index))) && IS_WATCH(index))
734
 
735
#define DR_DEF(index) \
736
  ((CONTROL >> (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index))) & 0x0f)
737
 
738
 
739
#if 0 /* use debugging macro */
740
#define SHOW_DR(text,len) \
741
do { \
742
  if (!getenv ("GDB_SHOW_DR")) break; \
743
  fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \
744
  fprintf(stderr,"%08x %d %08x %d ", \
745
          edi.dr[0],dr_ref_count[0],edi.dr[1],dr_ref_count[1]); \
746
  fprintf(stderr,"%08x %d %08x %d ", \
747
          edi.dr[2],dr_ref_count[2],edi.dr[3],dr_ref_count[3]); \
748
  fprintf(stderr,(len)?"(%s:%d)\n":"(%s)\n",#text,len); \
749
} while (0)
750
#else
751
#define SHOW_DR(text,len) do {} while (0)
752
#endif
753
 
754
static void
755
cleanup_dregs (void)
756
{
757
  int i;
758
 
759
  CONTROL = 0;
760
  STATUS = 0;
761
  for (i = 0; i < 4; i++)
762
    {
763
      D_REGS[i] = 0;
764
      dr_ref_count[i] = 0;
765
    }
766
}
767
 
768
/* Insert a watchpoint.  */
769
 
770
int
771
go32_insert_watchpoint (int pid ATTRIBUTE_UNUSED, CORE_ADDR addr,
772
                        int len, int rw)
773
{
774
  int ret = go32_insert_aligned_watchpoint (addr, addr, len, rw);
775
 
776
  SHOW_DR (insert_watch, len);
777
  return ret;
778
}
779
 
780
static int
781
go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
782
                                int len, int rw)
783
{
784
  int i;
785
  int read_write_bits, len_bits;
786
 
787
  /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
788
     However, x86 doesn't support read-only data breakpoints.  */
789
  read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
790
 
791
  switch (len)
792
  {
793
  case 4:
794
    len_bits = DR_LEN_4;
795
    break;
796
  case 2:
797
    len_bits = DR_LEN_2;
798
    break;
799
  case 1:
800
    len_bits = DR_LEN_1;
801
    break;
802
  default:
803
    /* The debug registers only have 2 bits for the length, so
804
       so this value will always fail the loop below.  */
805
    len_bits = 0x10;
806
  }
807
 
808
  /* Look for an occupied debug register with the same address and the
809
     same RW and LEN definitions.  If we find one, we can use it for
810
     this watchpoint as well (and save a register).  */
811
  for (i = 0; i < 4; i++)
812
  {
813
    if (!IS_REG_FREE (i) && D_REGS[i] == addr
814
        && DR_DEF (i) == (unsigned)(len_bits | read_write_bits))
815
    {
816
      dr_ref_count[i]++;
817
      return 0;
818
    }
819
  }
820
 
821
  /* Look for a free debug register.  */
822
  for (i = 0; i <= 3; i++)
823
  {
824
    if (IS_REG_FREE (i))
825
      break;
826
  }
827
 
828
  /* No more debug registers!  */
829
  if (i > 3)
830
    return -1;
831
 
832
  if (len == 2)
833
  {
834
    if (addr % 2)
835
      return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
836
                                                len, rw);
837
  }
838
  else if (len == 4)
839
  {
840
    if (addr % 4)
841
      return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
842
                                                len, rw);
843
  }
844
  else if (len != 1)
845
    return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr, len, rw);
846
 
847
  SET_WATCH (i, addr, read_write_bits, len_bits);
848
  LOCAL_ENABLE_REG (i);
849
  SET_LOCAL_EXACT ();
850
  SET_GLOBAL_EXACT ();
851
  return 0;
852
}
853
 
854
static int
855
go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr, CORE_ADDR addr,
856
                                   int len, int rw)
857
{
858
  int align;
859
  int size;
860
  int rv = 0, status = 0;
861
 
862
  static int size_try_array[4][4] =
863
  {
864
    { 1, 1, 1, 1 },             /* trying size one */
865
    { 2, 1, 2, 1 },             /* trying size two */
866
    { 2, 1, 2, 1 },             /* trying size three */
867
    { 4, 1, 2, 1 }              /* trying size four */
868
  };
869
 
870
  while (len > 0)
871
    {
872
      align = addr % 4;
873
      /* Four is the maximum length a 386 debug register can watch.  */
874
      size = size_try_array[len > 4 ? 3 : len - 1][align];
875
      if (what == wp_insert)
876
        status = go32_insert_aligned_watchpoint (waddr, addr, size, rw);
877
      else if (what == wp_remove)
878
        status = go32_remove_aligned_watchpoint (waddr, addr, size, rw);
879
      else if (what == wp_count)
880
        rv++;
881
      else
882
        status = EINVAL;
883
      /* We keep the loop going even after a failure, because some of
884
         the other aligned watchpoints might still succeed, e.g. if
885
         they watch addresses that are already watched, and thus just
886
         increment the reference counts of occupied debug registers.
887
         If we break out of the loop too early, we could cause those
888
         addresses watched by other watchpoints to be disabled when
889
         GDB reacts to our failure to insert this watchpoint and tries
890
         to remove it.  */
891
      if (status)
892
        rv = status;
893
      addr += size;
894
      len -= size;
895
    }
896
  return rv;
897
}
898
 
899
/* Remove a watchpoint.  */
900
 
901
int
902
go32_remove_watchpoint (int pid ATTRIBUTE_UNUSED, CORE_ADDR addr,
903
                        int len, int rw)
904
{
905
  int ret = go32_remove_aligned_watchpoint (addr, addr, len, rw);
906
 
907
  SHOW_DR (remove_watch, len);
908
  return ret;
909
}
910
 
911
static int
912
go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
913
                                int len, int rw)
914
{
915
  int i;
916
  int read_write_bits, len_bits;
917
 
918
  /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
919
     However, x86 doesn't support read-only data breakpoints.  */
920
  read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
921
 
922
  switch (len)
923
    {
924
      case 4:
925
        len_bits = DR_LEN_4;
926
        break;
927
      case 2:
928
        len_bits = DR_LEN_2;
929
        break;
930
      case 1:
931
        len_bits = DR_LEN_1;
932
        break;
933
      default:
934
        /* The debug registers only have 2 bits for the length, so
935
           so this value will always fail the loop below.  */
936
        len_bits = 0x10;
937
    }
938
 
939
  if (len == 2)
940
    {
941
      if (addr % 2)
942
        return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
943
                                                  len, rw);
944
    }
945
  else if (len == 4)
946
    {
947
      if (addr % 4)
948
        return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
949
                                                  len, rw);
950
    }
951
  else if (len != 1)
952
    return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw);
953
 
954
  for (i = 0; i <= 3; i++)
955
    {
956
      if (!IS_REG_FREE (i) && D_REGS[i] == addr
957
          && DR_DEF (i) == (unsigned)(len_bits | read_write_bits))
958
        {
959
          dr_ref_count[i]--;
960
          if (dr_ref_count[i] == 0)
961
            DISABLE_REG (i);
962
        }
963
    }
964
  RESET_LOCAL_EXACT ();
965
  RESET_GLOBAL_EXACT ();
966
 
967
  return 0;
968
}
969
 
970
/* Can we use debug registers to watch a region whose address is ADDR
971
   and whose length is LEN bytes?  */
972
 
973
int
974
go32_region_ok_for_watchpoint (CORE_ADDR addr, int len)
975
{
976
  /* Compute how many aligned watchpoints we would need to cover this
977
     region.  */
978
  int nregs = go32_handle_nonaligned_watchpoint (wp_count, addr, addr, len, 0);
979
 
980
  return nregs <= 4 ? 1 : 0;
981
}
982
 
983
/* Check if stopped by a data watchpoint.  If so, return the address
984
   whose access triggered the watchpoint.  */
985
 
986
CORE_ADDR
987
go32_stopped_by_watchpoint (int pid ATTRIBUTE_UNUSED, int data_watchpoint)
988
{
989
  int i, ret = 0;
990
  int status;
991
 
992
  status = edi.dr[DR_STATUS];
993
  SHOW_DR (stopped_by, 0);
994
  for (i = 0; i <= 3; i++)
995
    {
996
      if (WATCH_HIT (i) && data_watchpoint)
997
        {
998
          SHOW_DR (WP_HIT, 0);
999
          ret = D_REGS[i];
1000
        }
1001
    }
1002
 
1003
  return ret;
1004
}
1005
 
1006
/* Remove a breakpoint.  */
1007
 
1008
int
1009
go32_remove_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1010
{
1011
  int i;
1012
  for (i = 0; i <= 3; i++)
1013
    {
1014
      if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1015
        {
1016
          dr_ref_count[i]--;
1017
          if (dr_ref_count[i] == 0)
1018
            DISABLE_REG (i);
1019
        }
1020
    }
1021
  SHOW_DR (remove_hw, 0);
1022
  return 0;
1023
}
1024
 
1025
int
1026
go32_insert_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1027
{
1028
  int i;
1029
 
1030
  /* Look for an occupied debug register with the same address and the
1031
     same RW and LEN definitions.  If we find one, we can use it for
1032
     this breakpoint as well (and save a register).  */
1033
  for (i = 0; i < 4; i++)
1034
    {
1035
      if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1036
        {
1037
          dr_ref_count[i]++;
1038
          SHOW_DR (insert_hw, 0);
1039
          return 0;
1040
        }
1041
    }
1042
 
1043
  /* Look for a free debug register.  */
1044
  for (i = 0; i <= 3; i++)
1045
    {
1046
      if (IS_REG_FREE (i))
1047
        break;
1048
    }
1049
 
1050
  /* No more debug registers?  */
1051
  if (i < 4)
1052
    {
1053
      SET_BREAK (i, addr);
1054
      LOCAL_ENABLE_REG (i);
1055
    }
1056
  SHOW_DR (insert_hw, 0);
1057
 
1058
  return i < 4 ? 0 : EBUSY;
1059
}
1060
 
1061
/* Put the device open on handle FD into either raw or cooked
1062
   mode, return 1 if it was in raw mode, zero otherwise.  */
1063
 
1064
static int
1065
device_mode (int fd, int raw_p)
1066
{
1067
  int oldmode, newmode;
1068
  __dpmi_regs regs;
1069
 
1070
  regs.x.ax = 0x4400;
1071
  regs.x.bx = fd;
1072
  __dpmi_int (0x21, &regs);
1073
  if (regs.x.flags & 1)
1074
    return -1;
1075
  newmode = oldmode = regs.x.dx;
1076
 
1077
  if (raw_p)
1078
    newmode |= 0x20;
1079
  else
1080
    newmode &= ~0x20;
1081
 
1082
  if (oldmode & 0x80)   /* Only for character dev */
1083
  {
1084
    regs.x.ax = 0x4401;
1085
    regs.x.bx = fd;
1086
    regs.x.dx = newmode & 0xff;   /* Force upper byte zero, else it fails */
1087
    __dpmi_int (0x21, &regs);
1088
    if (regs.x.flags & 1)
1089
      return -1;
1090
  }
1091
  return (oldmode & 0x20) == 0x20;
1092
}
1093
 
1094
 
1095
static int inf_mode_valid = 0;
1096
static int inf_terminal_mode;
1097
 
1098
/* This semaphore is needed because, amazingly enough, GDB calls
1099
   target.to_terminal_ours more than once after the inferior stops.
1100
   But we need the information from the first call only, since the
1101
   second call will always see GDB's own cooked terminal.  */
1102
static int terminal_is_ours = 1;
1103
 
1104
static void
1105
go32_terminal_init (void)
1106
{
1107
  inf_mode_valid = 0;    /* reinitialize, in case they are restarting child */
1108
  terminal_is_ours = 1;
1109
}
1110
 
1111
static void
1112
go32_terminal_info (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
1113
{
1114
  printf_unfiltered ("Inferior's terminal is in %s mode.\n",
1115
                     !inf_mode_valid
1116
                     ? "default" : inf_terminal_mode ? "raw" : "cooked");
1117
 
1118
#if __DJGPP_MINOR__ > 2
1119
  if (child_cmd.redirection)
1120
  {
1121
    int i;
1122
 
1123
    for (i = 0; i < DBG_HANDLES; i++)
1124
    {
1125
      if (child_cmd.redirection[i]->file_name)
1126
        printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
1127
                           i, child_cmd.redirection[i]->file_name);
1128
      else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
1129
        printf_unfiltered
1130
          ("\tFile handle %d appears to be closed by inferior.\n", i);
1131
      /* Mask off the raw/cooked bit when comparing device info words.  */
1132
      else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
1133
               != (_get_dev_info (i) & 0xdf))
1134
        printf_unfiltered
1135
          ("\tFile handle %d appears to be redirected by inferior.\n", i);
1136
    }
1137
  }
1138
#endif
1139
}
1140
 
1141
static void
1142
go32_terminal_inferior (void)
1143
{
1144
  /* Redirect standard handles as child wants them.  */
1145
  errno = 0;
1146
  if (redir_to_child (&child_cmd) == -1)
1147
  {
1148
    redir_to_debugger (&child_cmd);
1149
    error ("Cannot redirect standard handles for program: %s.",
1150
           strerror (errno));
1151
  }
1152
  /* set the console device of the inferior to whatever mode
1153
     (raw or cooked) we found it last time */
1154
  if (terminal_is_ours)
1155
  {
1156
    if (inf_mode_valid)
1157
      device_mode (0, inf_terminal_mode);
1158
    terminal_is_ours = 0;
1159
  }
1160
}
1161
 
1162
static void
1163
go32_terminal_ours (void)
1164
{
1165
  /* Switch to cooked mode on the gdb terminal and save the inferior
1166
     terminal mode to be restored when it is resumed */
1167
  if (!terminal_is_ours)
1168
  {
1169
    inf_terminal_mode = device_mode (0, 0);
1170
    if (inf_terminal_mode != -1)
1171
      inf_mode_valid = 1;
1172
    else
1173
      /* If device_mode returned -1, we don't know what happens with
1174
         handle 0 anymore, so make the info invalid.  */
1175
      inf_mode_valid = 0;
1176
    terminal_is_ours = 1;
1177
 
1178
    /* Restore debugger's standard handles.  */
1179
    errno = 0;
1180
    if (redir_to_debugger (&child_cmd) == -1)
1181
    {
1182
      redir_to_child (&child_cmd);
1183
      error ("Cannot redirect standard handles for debugger: %s.",
1184
             strerror (errno));
1185
    }
1186
  }
1187
}
1188
 
1189
static void
1190
init_go32_ops (void)
1191
{
1192
  go32_ops.to_shortname = "djgpp";
1193
  go32_ops.to_longname = "djgpp target process";
1194
  go32_ops.to_doc =
1195
    "Program loaded by djgpp, when gdb is used as an external debugger";
1196
  go32_ops.to_open = go32_open;
1197
  go32_ops.to_close = go32_close;
1198
  go32_ops.to_attach = go32_attach;
1199
  go32_ops.to_detach = go32_detach;
1200
  go32_ops.to_resume = go32_resume;
1201
  go32_ops.to_wait = go32_wait;
1202
  go32_ops.to_fetch_registers = go32_fetch_registers;
1203
  go32_ops.to_store_registers = go32_store_registers;
1204
  go32_ops.to_prepare_to_store = go32_prepare_to_store;
1205
  go32_ops.to_xfer_memory = go32_xfer_memory;
1206
  go32_ops.to_files_info = go32_files_info;
1207
  go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
1208
  go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
1209
  go32_ops.to_terminal_init = go32_terminal_init;
1210
  go32_ops.to_terminal_inferior = go32_terminal_inferior;
1211
  go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
1212
  go32_ops.to_terminal_ours = go32_terminal_ours;
1213
  go32_ops.to_terminal_info = go32_terminal_info;
1214
  go32_ops.to_kill = go32_kill_inferior;
1215
  go32_ops.to_create_inferior = go32_create_inferior;
1216
  go32_ops.to_mourn_inferior = go32_mourn_inferior;
1217
  go32_ops.to_can_run = go32_can_run;
1218
  go32_ops.to_stop = go32_stop;
1219
  go32_ops.to_stratum = process_stratum;
1220
  go32_ops.to_has_all_memory = 1;
1221
  go32_ops.to_has_memory = 1;
1222
  go32_ops.to_has_stack = 1;
1223
  go32_ops.to_has_registers = 1;
1224
  go32_ops.to_has_execution = 1;
1225
  go32_ops.to_magic = OPS_MAGIC;
1226
 
1227
  /* Initialize child's cwd with the current one.  */
1228
  getcwd (child_cwd, sizeof (child_cwd));
1229
 
1230
  /* Initialize child's command line storage.  */
1231
  if (redir_debug_init (&child_cmd) == -1)
1232
    internal_error ("Cannot allocate redirection storage: not enough memory.\n");
1233
 
1234
  /* We are always processing GCC-compiled programs.  */
1235
  processing_gcc_compilation = 2;
1236
}
1237
 
1238
void
1239
_initialize_go32_nat (void)
1240
{
1241
  init_go32_ops ();
1242
  add_target (&go32_ops);
1243
}
1244
 
1245
pid_t
1246
tcgetpgrp (int fd)
1247
{
1248
  if (isatty (fd))
1249
    return SOME_PID;
1250
  errno = ENOTTY;
1251
  return -1;
1252
}
1253
 
1254
int
1255
tcsetpgrp (int fd, pid_t pgid)
1256
{
1257
  if (isatty (fd) && pgid == SOME_PID)
1258
    return 0;
1259
  errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1260
  return -1;
1261
}

powered by: WebSVN 2.1.0

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