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

Subversion Repositories or1k

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Intel 386 target-dependent stuff.
2
   Copyright (C) 1988, 1989, 1991, 1994, 1995, 1996, 1998
3
   Free Software Foundation, Inc.
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 "defs.h"
23
#include "gdb_string.h"
24
#include "frame.h"
25
#include "inferior.h"
26
#include "gdbcore.h"
27
#include "target.h"
28
#include "floatformat.h"
29
#include "symtab.h"
30
#include "gdbcmd.h"
31
#include "command.h"
32
 
33
static long i386_get_frame_setup PARAMS ((CORE_ADDR));
34
 
35
static void i386_follow_jump PARAMS ((void));
36
 
37
static void codestream_read PARAMS ((unsigned char *, int));
38
 
39
static void codestream_seek PARAMS ((CORE_ADDR));
40
 
41
static unsigned char codestream_fill PARAMS ((int));
42
 
43
CORE_ADDR skip_trampoline_code PARAMS ((CORE_ADDR, char *));
44
 
45
static int gdb_print_insn_i386 (bfd_vma, disassemble_info *);
46
 
47
void _initialize_i386_tdep PARAMS ((void));
48
 
49
/* i386_register_byte[i] is the offset into the register file of the
50
   start of register number i.  We initialize this from
51
   i386_register_raw_size.  */
52
int i386_register_byte[MAX_NUM_REGS];
53
 
54
/* i386_register_raw_size[i] is the number of bytes of storage in
55
   GDB's register array occupied by register i.  */
56
int i386_register_raw_size[MAX_NUM_REGS] = {
57
   4,  4,  4,  4,
58
   4,  4,  4,  4,
59
   4,  4,  4,  4,
60
   4,  4,  4,  4,
61
  10, 10, 10, 10,
62
  10, 10, 10, 10,
63
   4,  4,  4,  4,
64
   4,  4,  4,  4,
65
  16, 16, 16, 16,
66
  16, 16, 16, 16,
67
   4
68
};
69
 
70
/* i386_register_virtual_size[i] is the size in bytes of the virtual
71
   type of register i.  */
72
int i386_register_virtual_size[MAX_NUM_REGS];
73
 
74
 
75
/* This is the variable the is set with "set disassembly-flavor",
76
   and its legitimate values. */
77
static char att_flavor[] = "att";
78
static char intel_flavor[] = "intel";
79
static char *valid_flavors[] =
80
{
81
  att_flavor,
82
  intel_flavor,
83
  NULL
84
};
85
static char *disassembly_flavor = att_flavor;
86
 
87
static void i386_print_register PARAMS ((char *, int, int));
88
 
89
/* This is used to keep the bfd arch_info in sync with the disassembly flavor.  */
90
static void set_disassembly_flavor_sfunc PARAMS ((char *, int, struct cmd_list_element *));
91
static void set_disassembly_flavor PARAMS ((void));
92
 
93
/* Stdio style buffering was used to minimize calls to ptrace, but this
94
   buffering did not take into account that the code section being accessed
95
   may not be an even number of buffers long (even if the buffer is only
96
   sizeof(int) long).  In cases where the code section size happened to
97
   be a non-integral number of buffers long, attempting to read the last
98
   buffer would fail.  Simply using target_read_memory and ignoring errors,
99
   rather than read_memory, is not the correct solution, since legitimate
100
   access errors would then be totally ignored.  To properly handle this
101
   situation and continue to use buffering would require that this code
102
   be able to determine the minimum code section size granularity (not the
103
   alignment of the section itself, since the actual failing case that
104
   pointed out this problem had a section alignment of 4 but was not a
105
   multiple of 4 bytes long), on a target by target basis, and then
106
   adjust it's buffer size accordingly.  This is messy, but potentially
107
   feasible.  It probably needs the bfd library's help and support.  For
108
   now, the buffer size is set to 1.  (FIXME -fnf) */
109
 
110
#define CODESTREAM_BUFSIZ 1     /* Was sizeof(int), see note above. */
111
static CORE_ADDR codestream_next_addr;
112
static CORE_ADDR codestream_addr;
113
static unsigned char codestream_buf[CODESTREAM_BUFSIZ];
114
static int codestream_off;
115
static int codestream_cnt;
116
 
117
#define codestream_tell() (codestream_addr + codestream_off)
118
#define codestream_peek() (codestream_cnt == 0 ? \
119
                           codestream_fill(1): codestream_buf[codestream_off])
120
#define codestream_get() (codestream_cnt-- == 0 ? \
121
                         codestream_fill(0) : codestream_buf[codestream_off++])
122
 
123
static unsigned char
124
codestream_fill (peek_flag)
125
     int peek_flag;
126
{
127
  codestream_addr = codestream_next_addr;
128
  codestream_next_addr += CODESTREAM_BUFSIZ;
129
  codestream_off = 0;
130
  codestream_cnt = CODESTREAM_BUFSIZ;
131
  read_memory (codestream_addr, (char *) codestream_buf, CODESTREAM_BUFSIZ);
132
 
133
  if (peek_flag)
134
    return (codestream_peek ());
135
  else
136
    return (codestream_get ());
137
}
138
 
139
static void
140
codestream_seek (place)
141
     CORE_ADDR place;
142
{
143
  codestream_next_addr = place / CODESTREAM_BUFSIZ;
144
  codestream_next_addr *= CODESTREAM_BUFSIZ;
145
  codestream_cnt = 0;
146
  codestream_fill (1);
147
  while (codestream_tell () != place)
148
    codestream_get ();
149
}
150
 
151
static void
152
codestream_read (buf, count)
153
     unsigned char *buf;
154
     int count;
155
{
156
  unsigned char *p;
157
  int i;
158
  p = buf;
159
  for (i = 0; i < count; i++)
160
    *p++ = codestream_get ();
161
}
162
 
163
/* next instruction is a jump, move to target */
164
 
165
static void
166
i386_follow_jump ()
167
{
168
  unsigned char buf[4];
169
  long delta;
170
 
171
  int data16;
172
  CORE_ADDR pos;
173
 
174
  pos = codestream_tell ();
175
 
176
  data16 = 0;
177
  if (codestream_peek () == 0x66)
178
    {
179
      codestream_get ();
180
      data16 = 1;
181
    }
182
 
183
  switch (codestream_get ())
184
    {
185
    case 0xe9:
186
      /* relative jump: if data16 == 0, disp32, else disp16 */
187
      if (data16)
188
        {
189
          codestream_read (buf, 2);
190
          delta = extract_signed_integer (buf, 2);
191
 
192
          /* include size of jmp inst (including the 0x66 prefix).  */
193
          pos += delta + 4;
194
        }
195
      else
196
        {
197
          codestream_read (buf, 4);
198
          delta = extract_signed_integer (buf, 4);
199
 
200
          pos += delta + 5;
201
        }
202
      break;
203
    case 0xeb:
204
      /* relative jump, disp8 (ignore data16) */
205
      codestream_read (buf, 1);
206
      /* Sign-extend it.  */
207
      delta = extract_signed_integer (buf, 1);
208
 
209
      pos += delta + 2;
210
      break;
211
    }
212
  codestream_seek (pos);
213
}
214
 
215
/*
216
 * find & return amound a local space allocated, and advance codestream to
217
 * first register push (if any)
218
 *
219
 * if entry sequence doesn't make sense, return -1, and leave
220
 * codestream pointer random
221
 */
222
 
223
static long
224
i386_get_frame_setup (pc)
225
     CORE_ADDR pc;
226
{
227
  unsigned char op;
228
 
229
  codestream_seek (pc);
230
 
231
  i386_follow_jump ();
232
 
233
  op = codestream_get ();
234
 
235
  if (op == 0x58)               /* popl %eax */
236
    {
237
      /*
238
       * this function must start with
239
       *
240
       *    popl %eax             0x58
241
       *    xchgl %eax, (%esp)  0x87 0x04 0x24
242
       * or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
243
       *
244
       * (the system 5 compiler puts out the second xchg
245
       * inst, and the assembler doesn't try to optimize it,
246
       * so the 'sib' form gets generated)
247
       *
248
       * this sequence is used to get the address of the return
249
       * buffer for a function that returns a structure
250
       */
251
      int pos;
252
      unsigned char buf[4];
253
      static unsigned char proto1[3] =
254
      {0x87, 0x04, 0x24};
255
      static unsigned char proto2[4] =
256
      {0x87, 0x44, 0x24, 0x00};
257
      pos = codestream_tell ();
258
      codestream_read (buf, 4);
259
      if (memcmp (buf, proto1, 3) == 0)
260
        pos += 3;
261
      else if (memcmp (buf, proto2, 4) == 0)
262
        pos += 4;
263
 
264
      codestream_seek (pos);
265
      op = codestream_get ();   /* update next opcode */
266
    }
267
 
268
  if (op == 0x68 || op == 0x6a)
269
    {
270
      /*
271
       * this function may start with
272
       *
273
       *   pushl constant
274
       *   call _probe
275
       *   addl $4, %esp
276
       *      followed by
277
       *     pushl %ebp
278
       *     etc.
279
       */
280
      int pos;
281
      unsigned char buf[8];
282
 
283
      /* Skip past the pushl instruction; it has either a one-byte
284
         or a four-byte operand, depending on the opcode.  */
285
      pos = codestream_tell ();
286
      if (op == 0x68)
287
        pos += 4;
288
      else
289
        pos += 1;
290
      codestream_seek (pos);
291
 
292
      /* Read the following 8 bytes, which should be "call _probe" (6 bytes)
293
         followed by "addl $4,%esp" (2 bytes).  */
294
      codestream_read (buf, sizeof (buf));
295
      if (buf[0] == 0xe8 && buf[6] == 0xc4 && buf[7] == 0x4)
296
        pos += sizeof (buf);
297
      codestream_seek (pos);
298
      op = codestream_get ();   /* update next opcode */
299
    }
300
 
301
  if (op == 0x55)               /* pushl %ebp */
302
    {
303
      /* check for movl %esp, %ebp - can be written two ways */
304
      switch (codestream_get ())
305
        {
306
        case 0x8b:
307
          if (codestream_get () != 0xec)
308
            return (-1);
309
          break;
310
        case 0x89:
311
          if (codestream_get () != 0xe5)
312
            return (-1);
313
          break;
314
        default:
315
          return (-1);
316
        }
317
      /* check for stack adjustment
318
 
319
       *  subl $XXX, %esp
320
       *
321
       * note: you can't subtract a 16 bit immediate
322
       * from a 32 bit reg, so we don't have to worry
323
       * about a data16 prefix
324
       */
325
      op = codestream_peek ();
326
      if (op == 0x83)
327
        {
328
          /* subl with 8 bit immed */
329
          codestream_get ();
330
          if (codestream_get () != 0xec)
331
            /* Some instruction starting with 0x83 other than subl.  */
332
            {
333
              codestream_seek (codestream_tell () - 2);
334
              return 0;
335
            }
336
          /* subl with signed byte immediate
337
           * (though it wouldn't make sense to be negative)
338
           */
339
          return (codestream_get ());
340
        }
341
      else if (op == 0x81)
342
        {
343
          char buf[4];
344
          /* Maybe it is subl with 32 bit immedediate.  */
345
          codestream_get ();
346
          if (codestream_get () != 0xec)
347
            /* Some instruction starting with 0x81 other than subl.  */
348
            {
349
              codestream_seek (codestream_tell () - 2);
350
              return 0;
351
            }
352
          /* It is subl with 32 bit immediate.  */
353
          codestream_read ((unsigned char *) buf, 4);
354
          return extract_signed_integer (buf, 4);
355
        }
356
      else
357
        {
358
          return (0);
359
        }
360
    }
361
  else if (op == 0xc8)
362
    {
363
      char buf[2];
364
      /* enter instruction: arg is 16 bit unsigned immed */
365
      codestream_read ((unsigned char *) buf, 2);
366
      codestream_get ();        /* flush final byte of enter instruction */
367
      return extract_unsigned_integer (buf, 2);
368
    }
369
  return (-1);
370
}
371
 
372
/* Return number of args passed to a frame.
373
   Can return -1, meaning no way to tell.  */
374
 
375
int
376
i386_frame_num_args (fi)
377
     struct frame_info *fi;
378
{
379
#if 1
380
  return -1;
381
#else
382
  /* This loses because not only might the compiler not be popping the
383
     args right after the function call, it might be popping args from both
384
     this call and a previous one, and we would say there are more args
385
     than there really are.  */
386
 
387
  int retpc;
388
  unsigned char op;
389
  struct frame_info *pfi;
390
 
391
  /* on the 386, the instruction following the call could be:
392
     popl %ecx        -  one arg
393
     addl $imm, %esp  -  imm/4 args; imm may be 8 or 32 bits
394
     anything else    -  zero args  */
395
 
396
  int frameless;
397
 
398
  frameless = FRAMELESS_FUNCTION_INVOCATION (fi);
399
  if (frameless)
400
    /* In the absence of a frame pointer, GDB doesn't get correct values
401
       for nameless arguments.  Return -1, so it doesn't print any
402
       nameless arguments.  */
403
    return -1;
404
 
405
  pfi = get_prev_frame (fi);
406
  if (pfi == 0)
407
    {
408
      /* Note:  this can happen if we are looking at the frame for
409
         main, because FRAME_CHAIN_VALID won't let us go into
410
         start.  If we have debugging symbols, that's not really
411
         a big deal; it just means it will only show as many arguments
412
         to main as are declared.  */
413
      return -1;
414
    }
415
  else
416
    {
417
      retpc = pfi->pc;
418
      op = read_memory_integer (retpc, 1);
419
      if (op == 0x59)
420
        /* pop %ecx */
421
        return 1;
422
      else if (op == 0x83)
423
        {
424
          op = read_memory_integer (retpc + 1, 1);
425
          if (op == 0xc4)
426
            /* addl $<signed imm 8 bits>, %esp */
427
            return (read_memory_integer (retpc + 2, 1) & 0xff) / 4;
428
          else
429
            return 0;
430
        }
431
      else if (op == 0x81)
432
        {                       /* add with 32 bit immediate */
433
          op = read_memory_integer (retpc + 1, 1);
434
          if (op == 0xc4)
435
            /* addl $<imm 32>, %esp */
436
            return read_memory_integer (retpc + 2, 4) / 4;
437
          else
438
            return 0;
439
        }
440
      else
441
        {
442
          return 0;
443
        }
444
    }
445
#endif
446
}
447
 
448
/*
449
 * parse the first few instructions of the function to see
450
 * what registers were stored.
451
 *
452
 * We handle these cases:
453
 *
454
 * The startup sequence can be at the start of the function,
455
 * or the function can start with a branch to startup code at the end.
456
 *
457
 * %ebp can be set up with either the 'enter' instruction, or
458
 * 'pushl %ebp, movl %esp, %ebp' (enter is too slow to be useful,
459
 * but was once used in the sys5 compiler)
460
 *
461
 * Local space is allocated just below the saved %ebp by either the
462
 * 'enter' instruction, or by 'subl $<size>, %esp'.  'enter' has
463
 * a 16 bit unsigned argument for space to allocate, and the
464
 * 'addl' instruction could have either a signed byte, or
465
 * 32 bit immediate.
466
 *
467
 * Next, the registers used by this function are pushed.  In
468
 * the sys5 compiler they will always be in the order: %edi, %esi, %ebx
469
 * (and sometimes a harmless bug causes it to also save but not restore %eax);
470
 * however, the code below is willing to see the pushes in any order,
471
 * and will handle up to 8 of them.
472
 *
473
 * If the setup sequence is at the end of the function, then the
474
 * next instruction will be a branch back to the start.
475
 */
476
 
477
void
478
i386_frame_init_saved_regs (fip)
479
     struct frame_info *fip;
480
{
481
  long locals = -1;
482
  unsigned char op;
483
  CORE_ADDR dummy_bottom;
484
  CORE_ADDR adr;
485
  CORE_ADDR pc;
486
  int i;
487
 
488
  if (fip->saved_regs)
489
    return;
490
 
491
  frame_saved_regs_zalloc (fip);
492
 
493
  /* if frame is the end of a dummy, compute where the
494
   * beginning would be
495
   */
496
  dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH;
497
 
498
  /* check if the PC is in the stack, in a dummy frame */
499
  if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
500
    {
501
      /* all regs were saved by push_call_dummy () */
502
      adr = fip->frame;
503
      for (i = 0; i < NUM_REGS; i++)
504
        {
505
          adr -= REGISTER_RAW_SIZE (i);
506
          fip->saved_regs[i] = adr;
507
        }
508
      return;
509
    }
510
 
511
  pc = get_pc_function_start (fip->pc);
512
  if (pc != 0)
513
    locals = i386_get_frame_setup (pc);
514
 
515
  if (locals >= 0)
516
    {
517
      adr = fip->frame - 4 - locals;
518
      for (i = 0; i < 8; i++)
519
        {
520
          op = codestream_get ();
521
          if (op < 0x50 || op > 0x57)
522
            break;
523
#ifdef I386_REGNO_TO_SYMMETRY
524
          /* Dynix uses different internal numbering.  Ick.  */
525
          fip->saved_regs[I386_REGNO_TO_SYMMETRY (op - 0x50)] = adr;
526
#else
527
          fip->saved_regs[op - 0x50] = adr;
528
#endif
529
          adr -= 4;
530
        }
531
    }
532
 
533
  fip->saved_regs[PC_REGNUM] = fip->frame + 4;
534
  fip->saved_regs[FP_REGNUM] = fip->frame;
535
}
536
 
537
/* return pc of first real instruction */
538
 
539
int
540
i386_skip_prologue (pc)
541
     int pc;
542
{
543
  unsigned char op;
544
  int i;
545
  static unsigned char pic_pat[6] =
546
  {0xe8, 0, 0, 0, 0,                /* call   0x0 */
547
   0x5b,                        /* popl   %ebx */
548
  };
549
  CORE_ADDR pos;
550
 
551
  if (i386_get_frame_setup (pc) < 0)
552
    return (pc);
553
 
554
  /* found valid frame setup - codestream now points to
555
   * start of push instructions for saving registers
556
   */
557
 
558
  /* skip over register saves */
559
  for (i = 0; i < 8; i++)
560
    {
561
      op = codestream_peek ();
562
      /* break if not pushl inst */
563
      if (op < 0x50 || op > 0x57)
564
        break;
565
      codestream_get ();
566
    }
567
 
568
  /* The native cc on SVR4 in -K PIC mode inserts the following code to get
569
     the address of the global offset table (GOT) into register %ebx.
570
     call       0x0
571
     popl       %ebx
572
     movl       %ebx,x(%ebp)    (optional)
573
     addl       y,%ebx
574
     This code is with the rest of the prologue (at the end of the
575
     function), so we have to skip it to get to the first real
576
     instruction at the start of the function.  */
577
 
578
  pos = codestream_tell ();
579
  for (i = 0; i < 6; i++)
580
    {
581
      op = codestream_get ();
582
      if (pic_pat[i] != op)
583
        break;
584
    }
585
  if (i == 6)
586
    {
587
      unsigned char buf[4];
588
      long delta = 6;
589
 
590
      op = codestream_get ();
591
      if (op == 0x89)           /* movl %ebx, x(%ebp) */
592
        {
593
          op = codestream_get ();
594
          if (op == 0x5d)       /* one byte offset from %ebp */
595
            {
596
              delta += 3;
597
              codestream_read (buf, 1);
598
            }
599
          else if (op == 0x9d)  /* four byte offset from %ebp */
600
            {
601
              delta += 6;
602
              codestream_read (buf, 4);
603
            }
604
          else                  /* unexpected instruction */
605
            delta = -1;
606
          op = codestream_get ();
607
        }
608
      /* addl y,%ebx */
609
      if (delta > 0 && op == 0x81 && codestream_get () == 0xc3)
610
        {
611
          pos += delta + 6;
612
        }
613
    }
614
  codestream_seek (pos);
615
 
616
  i386_follow_jump ();
617
 
618
  return (codestream_tell ());
619
}
620
 
621
void
622
i386_push_dummy_frame ()
623
{
624
  CORE_ADDR sp = read_register (SP_REGNUM);
625
  int regnum;
626
  char regbuf[MAX_REGISTER_RAW_SIZE];
627
 
628
  sp = push_word (sp, read_register (PC_REGNUM));
629
  sp = push_word (sp, read_register (FP_REGNUM));
630
  write_register (FP_REGNUM, sp);
631
  for (regnum = 0; regnum < NUM_REGS; regnum++)
632
    {
633
      read_register_gen (regnum, regbuf);
634
      sp = push_bytes (sp, regbuf, REGISTER_RAW_SIZE (regnum));
635
    }
636
  write_register (SP_REGNUM, sp);
637
}
638
 
639
void
640
i386_pop_frame ()
641
{
642
  struct frame_info *frame = get_current_frame ();
643
  CORE_ADDR fp;
644
  int regnum;
645
  char regbuf[MAX_REGISTER_RAW_SIZE];
646
 
647
  fp = FRAME_FP (frame);
648
  i386_frame_init_saved_regs (frame);
649
 
650
  for (regnum = 0; regnum < NUM_REGS; regnum++)
651
    {
652
      CORE_ADDR adr;
653
      adr = frame->saved_regs[regnum];
654
      if (adr)
655
        {
656
          read_memory (adr, regbuf, REGISTER_RAW_SIZE (regnum));
657
          write_register_bytes (REGISTER_BYTE (regnum), regbuf,
658
                                REGISTER_RAW_SIZE (regnum));
659
        }
660
    }
661
  write_register (FP_REGNUM, read_memory_integer (fp, 4));
662
  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
663
  write_register (SP_REGNUM, fp + 8);
664
  flush_cached_frames ();
665
}
666
 
667
#ifdef GET_LONGJMP_TARGET
668
 
669
/* Figure out where the longjmp will land.  Slurp the args out of the stack.
670
   We expect the first arg to be a pointer to the jmp_buf structure from which
671
   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
672
   This routine returns true on success. */
673
 
674
int
675
get_longjmp_target (pc)
676
     CORE_ADDR *pc;
677
{
678
  char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
679
  CORE_ADDR sp, jb_addr;
680
 
681
  sp = read_register (SP_REGNUM);
682
 
683
  if (target_read_memory (sp + SP_ARG0,         /* Offset of first arg on stack */
684
                          buf,
685
                          TARGET_PTR_BIT / TARGET_CHAR_BIT))
686
    return 0;
687
 
688
  jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
689
 
690
  if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
691
                          TARGET_PTR_BIT / TARGET_CHAR_BIT))
692
    return 0;
693
 
694
  *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
695
 
696
  return 1;
697
}
698
 
699
#endif /* GET_LONGJMP_TARGET */
700
 
701
/* These registers are used for returning integers (and on some
702
   targets also for returning `struct' and `union' values when their
703
   size and alignment match an integer type.  */
704
#define LOW_RETURN_REGNUM 0     /* %eax */
705
#define HIGH_RETURN_REGNUM 2    /* %edx */
706
 
707
/* Extract from an array REGBUF containing the (raw) register state, a
708
   function return value of TYPE, and copy that, in virtual format,
709
   into VALBUF.  */
710
 
711
void
712
i386_extract_return_value (struct type *type, char *regbuf, char *valbuf)
713
{
714
  int len = TYPE_LENGTH (type);
715
 
716
  if (TYPE_CODE_FLT == TYPE_CODE (type))
717
    {
718
      if (NUM_FREGS == 0)
719
        {
720
          warning ("Cannot find floating-point return value.");
721
          memset (valbuf, 0, len);
722
        }
723
 
724
      /* Floating-point return values can be found in %st(0).  */
725
      if (len == TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT
726
          && TARGET_LONG_DOUBLE_FORMAT == &floatformat_i387_ext)
727
        {
728
          /* Copy straight over, but take care of the padding.  */
729
          memcpy (valbuf, &regbuf[REGISTER_BYTE (FP0_REGNUM)],
730
                  FPU_REG_RAW_SIZE);
731
          memset (valbuf + FPU_REG_RAW_SIZE, 0, len - FPU_REG_RAW_SIZE);
732
        }
733
      else
734
        {
735
          /* Convert the extended floating-point number found in
736
             %st(0) to the desired type.  This is probably not exactly
737
             how it would happen on the target itself, but it is the
738
             best we can do.  */
739
          DOUBLEST val;
740
          floatformat_to_doublest (&floatformat_i387_ext,
741
                                   &regbuf[REGISTER_BYTE (FP0_REGNUM)], &val);
742
          store_floating (valbuf, TYPE_LENGTH (type), val);
743
        }
744
    }
745
  else
746
    {
747
      int low_size = REGISTER_RAW_SIZE (LOW_RETURN_REGNUM);
748
      int high_size = REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM);
749
 
750
      if (len <= low_size)
751
        memcpy (valbuf, &regbuf[REGISTER_BYTE (LOW_RETURN_REGNUM)], len);
752
      else if (len <= (low_size + high_size))
753
        {
754
          memcpy (valbuf,
755
                  &regbuf[REGISTER_BYTE (LOW_RETURN_REGNUM)], low_size);
756
          memcpy (valbuf + low_size,
757
                  &regbuf[REGISTER_BYTE (HIGH_RETURN_REGNUM)], len - low_size);
758
        }
759
      else
760
        internal_error ("Cannot extract return value of %d bytes long.", len);
761
    }
762
}
763
 
764
/* Convert data from raw format for register REGNUM in buffer FROM to
765
   virtual format with type TYPE in buffer TO.  In principle both
766
   formats are identical except that the virtual format has two extra
767
   bytes appended that aren't used.  We set these to zero.  */
768
 
769
void
770
i386_register_convert_to_virtual (int regnum, struct type *type,
771
                                  char *from, char *to)
772
{
773
  /* Copy straight over, but take care of the padding.  */
774
  memcpy (to, from, FPU_REG_RAW_SIZE);
775
  memset (to + FPU_REG_RAW_SIZE, 0, TYPE_LENGTH (type) - FPU_REG_RAW_SIZE);
776
}
777
 
778
/* Convert data from virtual format with type TYPE in buffer FROM to
779
   raw format for register REGNUM in buffer TO.  Simply omit the two
780
   unused bytes.  */
781
 
782
void
783
i386_register_convert_to_raw (struct type *type, int regnum,
784
                              char *from, char *to)
785
{
786
  memcpy (to, from, FPU_REG_RAW_SIZE);
787
}
788
 
789
 
790
#ifdef I386V4_SIGTRAMP_SAVED_PC
791
/* Get saved user PC for sigtramp from the pushed ucontext on the stack
792
   for all three variants of SVR4 sigtramps.  */
793
 
794
CORE_ADDR
795
i386v4_sigtramp_saved_pc (frame)
796
     struct frame_info *frame;
797
{
798
  CORE_ADDR saved_pc_offset = 4;
799
  char *name = NULL;
800
 
801
  find_pc_partial_function (frame->pc, &name, NULL, NULL);
802
  if (name)
803
    {
804
      if (STREQ (name, "_sigreturn"))
805
        saved_pc_offset = 132 + 14 * 4;
806
      else if (STREQ (name, "_sigacthandler"))
807
        saved_pc_offset = 80 + 14 * 4;
808
      else if (STREQ (name, "sigvechandler"))
809
        saved_pc_offset = 120 + 14 * 4;
810
    }
811
 
812
  if (frame->next)
813
    return read_memory_integer (frame->next->frame + saved_pc_offset, 4);
814
  return read_memory_integer (read_register (SP_REGNUM) + saved_pc_offset, 4);
815
}
816
#endif /* I386V4_SIGTRAMP_SAVED_PC */
817
 
818
 
819
#ifdef STATIC_TRANSFORM_NAME
820
/* SunPRO encodes the static variables.  This is not related to C++ mangling,
821
   it is done for C too.  */
822
 
823
char *
824
sunpro_static_transform_name (name)
825
     char *name;
826
{
827
  char *p;
828
  if (IS_STATIC_TRANSFORM_NAME (name))
829
    {
830
      /* For file-local statics there will be a period, a bunch
831
         of junk (the contents of which match a string given in the
832
         N_OPT), a period and the name.  For function-local statics
833
         there will be a bunch of junk (which seems to change the
834
         second character from 'A' to 'B'), a period, the name of the
835
         function, and the name.  So just skip everything before the
836
         last period.  */
837
      p = strrchr (name, '.');
838
      if (p != NULL)
839
        name = p + 1;
840
    }
841
  return name;
842
}
843
#endif /* STATIC_TRANSFORM_NAME */
844
 
845
 
846
 
847
/* Stuff for WIN32 PE style DLL's but is pretty generic really. */
848
 
849
CORE_ADDR
850
skip_trampoline_code (pc, name)
851
     CORE_ADDR pc;
852
     char *name;
853
{
854
  if (pc && read_memory_unsigned_integer (pc, 2) == 0x25ff)     /* jmp *(dest) */
855
    {
856
      unsigned long indirect = read_memory_unsigned_integer (pc + 2, 4);
857
      struct minimal_symbol *indsym =
858
      indirect ? lookup_minimal_symbol_by_pc (indirect) : 0;
859
      char *symname = indsym ? SYMBOL_NAME (indsym) : 0;
860
 
861
      if (symname)
862
        {
863
          if (strncmp (symname, "__imp_", 6) == 0
864
              || strncmp (symname, "_imp_", 5) == 0)
865
            return name ? 1 : read_memory_unsigned_integer (indirect, 4);
866
        }
867
    }
868
  return 0;                      /* not a trampoline */
869
}
870
 
871
static int
872
gdb_print_insn_i386 (memaddr, info)
873
     bfd_vma memaddr;
874
     disassemble_info *info;
875
{
876
  if (disassembly_flavor == att_flavor)
877
    return print_insn_i386_att (memaddr, info);
878
  else if (disassembly_flavor == intel_flavor)
879
    return print_insn_i386_intel (memaddr, info);
880
  /* Never reached - disassembly_flavour is always either att_flavor
881
     or intel_flavor */
882
  abort ();
883
}
884
 
885
/* If the disassembly mode is intel, we have to also switch the
886
   bfd mach_type.  This function is run in the set disassembly_flavor
887
   command, and does that.  */
888
 
889
static void
890
set_disassembly_flavor_sfunc (args, from_tty, c)
891
     char *args;
892
     int from_tty;
893
     struct cmd_list_element *c;
894
{
895
  set_disassembly_flavor ();
896
}
897
 
898
static void
899
set_disassembly_flavor ()
900
{
901
  if (disassembly_flavor == att_flavor)
902
    set_architecture_from_arch_mach (bfd_arch_i386, bfd_mach_i386_i386);
903
  else if (disassembly_flavor == intel_flavor)
904
    set_architecture_from_arch_mach (bfd_arch_i386, bfd_mach_i386_i386_intel_syntax);
905
}
906
 
907
 
908
void
909
_initialize_i386_tdep ()
910
{
911
  /* Initialize the table saying where each register starts in the
912
     register file.  */
913
  {
914
    int i, offset;
915
 
916
    offset = 0;
917
    for (i = 0; i < MAX_NUM_REGS; i++)
918
      {
919
        i386_register_byte[i] = offset;
920
        offset += i386_register_raw_size[i];
921
      }
922
  }
923
 
924
  /* Initialize the table of virtual register sizes.  */
925
  {
926
    int i;
927
 
928
    for (i = 0; i < MAX_NUM_REGS; i++)
929
      i386_register_virtual_size[i] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i));
930
  }
931
 
932
  tm_print_insn = gdb_print_insn_i386;
933
  tm_print_insn_info.mach = bfd_lookup_arch (bfd_arch_i386, 0)->mach;
934
 
935
  /* Add the variable that controls the disassembly flavor */
936
  {
937
    struct cmd_list_element *new_cmd;
938
 
939
    new_cmd = add_set_enum_cmd ("disassembly-flavor", no_class,
940
                                valid_flavors,
941
                                (char *) &disassembly_flavor,
942
                                "Set the disassembly flavor, the valid values are \"att\" and \"intel\", \
943
and the default value is \"att\".",
944
                                &setlist);
945
    new_cmd->function.sfunc = set_disassembly_flavor_sfunc;
946
    add_show_from_set (new_cmd, &showlist);
947
  }
948
 
949
  /* Finally, initialize the disassembly flavor to the default given
950
     in the disassembly_flavor variable */
951
 
952
  set_disassembly_flavor ();
953
}

powered by: WebSVN 2.1.0

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