gdb/symmetry-tdep.c

   1 /* Sequent Symmetry target interface, for GDB when running under Unix.
   2    Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 GDB 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 1, or (at your option)
   9 any later version.
  10
  11 GDB 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 GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* many 387-specific items of use taken from i386-dep.c */
  21
  22 #include <stdio.h>
  23 #include "defs.h"
  24 #include "param.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "symtab.h"
  28
  29 #include <signal.h>
  30 #include <sys/param.h>
  31 #include <sys/user.h>
  32 #include <sys/dir.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/stat.h>
  35 #include "gdbcore.h"
  36 #include <fcntl.h>
  37
  38 static long i386_get_frame_setup ();
  39 static i386_follow_jump ();
  40
  41 #include <sgtty.h>
  42 #define TERMINAL struct sgttyb
  43
  44 exec_file_command (filename, from_tty)
  45      char *filename;
  46      int from_tty;
  47 {
  48   int val;
  49
  50   /* Eliminate all traces of old exec file.
  51      Mark text segment as empty.  */
  52
  53   if (execfile)
  54     free (execfile);
  55   execfile = 0;
  56   data_start = 0;
  57   data_end -= exec_data_start;
  58   text_start = 0;
  59   text_end = 0;
  60   exec_data_start = 0;
  61   exec_data_end = 0;
  62   if (execchan >= 0)
  63     close (execchan);
  64   execchan = -1;
  65
  66   /* Now open and digest the file the user requested, if any.  */
  67
  68   if (filename)
  69     {
  70       filename = tilde_expand (filename);
  71       make_cleanup (free, filename);
  72
  73       execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
  74                         &execfile);
  75       if (execchan < 0)
  76         perror_with_name (filename);
  77
  78 #ifdef COFF_FORMAT
  79       {
  80         int aout_hdrsize;
  81         int num_sections;
  82
  83         if (read_file_hdr (execchan, &file_hdr) < 0)
  84           error ("\"%s\": not in executable format.", execfile);
  85
  86         aout_hdrsize = file_hdr.f_opthdr;
  87         num_sections = file_hdr.f_nscns;
  88
  89         if (read_aout_hdr (execchan, &exec_aouthdr, aout_hdrsize) < 0)
  90           error ("\"%s\": can't read optional aouthdr", execfile);
  91
  92         if (read_section_hdr (execchan, _TEXT, &text_hdr, num_sections,
  93                               aout_hdrsize) < 0)
  94           error ("\"%s\": can't read text section header", execfile);
  95
  96         if (read_section_hdr (execchan, _DATA, &data_hdr, num_sections,
  97                               aout_hdrsize) < 0)
  98           error ("\"%s\": can't read data section header", execfile);
  99
 100         text_start = exec_aouthdr.text_start;
 101         text_end = text_start + exec_aouthdr.tsize;
 102         text_offset = text_hdr.s_scnptr;
 103         exec_data_start = exec_aouthdr.data_start;
 104         exec_data_end = exec_data_start + exec_aouthdr.dsize;
 105         exec_data_offset = data_hdr.s_scnptr;
 106         data_start = exec_data_start;
 107         data_end += exec_data_start;
 108         exec_mtime = file_hdr.f_timdat;
 109       }
 110 #else /* not COFF_FORMAT */
 111       {
 112         struct stat st_exec;
 113
 114         val = myread (execchan, &exec_aouthdr, sizeof (AOUTHDR));
 115
 116         if (val < 0)
 117           perror_with_name (filename);
 118
 119         text_start = N_ADDRADJ(exec_aouthdr);
 120         exec_data_start = round(exec_aouthdr.a_text, NBPG*CLSIZE);
 121         text_offset = N_TXTOFF (exec_aouthdr);
 122         exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;
 123         text_end = exec_aouthdr.a_text;
 124         exec_data_end = exec_data_start + exec_aouthdr.a_data;
 125         data_start = exec_data_start;
 126         data_end = data_start + exec_aouthdr.a_data;
 127         exec_data_offset = N_TXTOFF(exec_aouthdr);
 128         fstat (execchan, &st_exec);
 129         exec_mtime = st_exec.st_mtime;
 130       }
 131 #endif /* not COFF_FORMAT */
 132
 133       validate_files ();
 134     }
 135   else if (from_tty)
 136     printf ("No exec file now.\n");
 137
 138   /* Tell display code (if any) about the changed file name.  */
 139   if (exec_file_display_hook)
 140     (*exec_file_display_hook) (filename);
 141 }
 142
 143 /* rounds 'one' up to divide evenly by 'two' */
 144
 145 int
 146 round(one,two)
 147 register int one, two;
 148
 149 {
 150     register int temp;
 151     temp = (one/two)*two;
 152     if (one != temp) {
 153         temp += two;
 154     }
 155     return temp;
 156 }
 157
 158
 159 static CORE_ADDR codestream_next_addr;
 160 static CORE_ADDR codestream_addr;
 161 static unsigned char codestream_buf[sizeof (int)];
 162 static int codestream_off;
 163 static int codestream_cnt;
 164
 165 #define codestream_tell() (codestream_addr + codestream_off)
 166 #define codestream_peek() (codestream_cnt == 0 ? \
 167                            codestream_fill(1): codestream_buf[codestream_off])
 168 #define codestream_get() (codestream_cnt-- == 0 ? \
 169                          codestream_fill(0) : codestream_buf[codestream_off++])
 170
 171
 172 static unsigned char
 173 codestream_fill (peek_flag)
 174 {
 175   codestream_addr = codestream_next_addr;
 176   codestream_next_addr += sizeof (int);
 177   codestream_off = 0;
 178   codestream_cnt = sizeof (int);
 179   read_memory (codestream_addr,
 180                (unsigned char *)codestream_buf,
 181                sizeof (int));
 182
 183   if (peek_flag)
 184     return (codestream_peek());
 185   else
 186     return (codestream_get());
 187 }
 188
 189 static void
 190 codestream_seek (place)
 191 {
 192   codestream_next_addr = place & -sizeof (int);
 193   codestream_cnt = 0;
 194   codestream_fill (1);
 195   while (codestream_tell() != place)
 196     codestream_get ();
 197 }
 198
 199 static void
 200 codestream_read (buf, count)
 201      unsigned char *buf;
 202 {
 203   unsigned char *p;
 204   int i;
 205   p = buf;
 206   for (i = 0; i < count; i++)
 207     *p++ = codestream_get ();
 208 }
 209
 210 /*
 211  * Following macro translates i386 opcode register numbers to Symmetry
 212  * register numbers.  This is used by FRAME_FIND_SAVED_REGS.
 213  *
 214  *           %eax  %ecx  %edx  %ebx  %esp  %ebp  %esi  %edi
 215  * i386        0     1     2     3     4     5     6     7
 216  * Symmetry    0     2     1     5    14    15     6     7
 217  *
 218  */
 219 #define I386_REGNO_TO_SYMMETRY(n) \
 220 ((n)==0?0 :(n)==1?2 :(n)==2?1 :(n)==3?5 :(n)==4?14 :(n)==5?15 :(n))
 221
 222 /* from i386-dep.c */
 223 i386_frame_find_saved_regs (fip, fsrp)
 224      struct frame_info *fip;
 225      struct frame_saved_regs *fsrp;
 226 {
 227   unsigned long locals;
 228   unsigned char *p;
 229   unsigned char op;
 230   CORE_ADDR dummy_bottom;
 231   CORE_ADDR adr;
 232   int i;
 233
 234   bzero (fsrp, sizeof *fsrp);
 235
 236   /* if frame is the end of a dummy, compute where the
 237    * beginning would be
 238    */
 239   dummy_bottom = fip->frame - 4 - NUM_REGS*4 - CALL_DUMMY_LENGTH;
 240
 241   /* check if the PC is in the stack, in a dummy frame */
 242   if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
 243     {
 244       /* all regs were saved by push_call_dummy () */
 245       adr = fip->frame - 4;
 246       for (i = 0; i < NUM_REGS; i++)
 247         {
 248           fsrp->regs[i] = adr;
 249           adr -= 4;
 250         }
 251       return;
 252     }
 253
 254   locals = i386_get_frame_setup (get_pc_function_start (fip->pc));
 255
 256   if (locals >= 0)
 257     {
 258       adr = fip->frame - 4 - locals;
 259       for (i = 0; i < 8; i++)
 260         {
 261           op = codestream_get ();
 262           if (op < 0x50 || op > 0x57)
 263             break;
 264           fsrp->regs[I386_REGNO_TO_SYMMETRY(op - 0x50)] = adr;
 265           adr -= 4;
 266         }
 267     }
 268
 269   fsrp->regs[PC_REGNUM] = fip->frame + 4;
 270   fsrp->regs[FP_REGNUM] = fip->frame;
 271 }
 272
 273 static long
 274 i386_get_frame_setup (pc)
 275 {
 276   unsigned char op;
 277
 278   codestream_seek (pc);
 279
 280   i386_follow_jump ();
 281
 282   op = codestream_get ();
 283
 284   if (op == 0x58) /* popl %eax */
 285     {
 286       /*
 287        * this function must start with
 288        *
 289        *    popl %eax             0x58
 290        *    xchgl %eax, (%esp)  0x87 0x04 0x24
 291        * or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
 292        *
 293        * (the system 5 compiler puts out the second xchg
 294        * inst, and the assembler doesn't try to optimize it,
 295        * so the 'sib' form gets generated)
 296        *
 297        * this sequence is used to get the address of the return
 298        * buffer for a function that returns a structure
 299        */
 300       int pos;
 301       unsigned char buf[4];
 302       static unsigned char proto1[3] = { 0x87,0x04,0x24 };
 303       static unsigned char proto2[4] = { 0x87,0x44,0x24,0x00 };
 304       pos = codestream_tell ();
 305       codestream_read (buf, 4);
 306       if (bcmp (buf, proto1, 3) == 0)
 307         pos += 3;
 308       else if (bcmp (buf, proto2, 4) == 0)
 309         pos += 4;
 310
 311       codestream_seek (pos);
 312       op = codestream_get (); /* update next opcode */
 313     }
 314
 315   if (op == 0x55)                       /* pushl %esp */
 316     {
 317       if (codestream_get () != 0x8b)    /* movl %esp, %ebp (2bytes) */
 318         return (-1);
 319       if (codestream_get () != 0xec)
 320         return (-1);
 321       /*
 322        * check for stack adjustment
 323        *
 324        *  subl $XXX, %esp
 325        *
 326        * note: you can't subtract a 16 bit immediate
 327        * from a 32 bit reg, so we don't have to worry
 328        * about a data16 prefix
 329        */
 330       op = codestream_peek ();
 331       if (op == 0x83)  /* subl with 8 bit immed */
 332         {
 333           codestream_get ();
 334           if (codestream_get () != 0xec)
 335             return (-1);
 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)  /* subl with 32 bit immed */
 342         {
 343           int locals;
 344           if (codestream_get () != 0xec)
 345             return (-1);
 346           /* subl with 32 bit immediate */
 347           codestream_read ((unsigned char *)&locals, 4);
 348           return (locals);
 349         }
 350       else
 351         {
 352           return (0);
 353         }
 354     }
 355   else if (op == 0xc8)
 356     {
 357       /* enter instruction: arg is 16 unsigned immed */
 358       unsigned short slocals;
 359       codestream_read ((unsigned char *)&slocals, 2);
 360       codestream_get (); /* flush final byte of enter instruction */
 361       return (slocals);
 362     }
 363   return (-1);
 364 }
 365
 366 /* next instruction is a jump, move to target */
 367 static
 368 i386_follow_jump ()
 369 {
 370   int long_delta;
 371   short short_delta;
 372   char byte_delta;
 373   int data16;
 374   int pos;
 375
 376   pos = codestream_tell ();
 377
 378   data16 = 0;
 379   if (codestream_peek () == 0x66)
 380     {
 381       codestream_get ();
 382       data16 = 1;
 383     }
 384
 385   switch (codestream_get ())
 386     {
 387     case 0xe9:
 388       /* relative jump: if data16 == 0, disp32, else disp16 */
 389       if (data16)
 390         {
 391           codestream_read ((unsigned char *)&short_delta, 2);
 392           pos += short_delta + 3; /* include size of jmp inst */
 393         }
 394       else
 395         {
 396           codestream_read ((unsigned char *)&long_delta, 4);
 397           pos += long_delta + 5;
 398         }
 399       break;
 400     case 0xeb:
 401       /* relative jump, disp8 (ignore data16) */
 402       codestream_read ((unsigned char *)&byte_delta, 1);
 403       pos += byte_delta + 2;
 404       break;
 405     }
 406   codestream_seek (pos + data16);
 407 }
 408
 409 /* return pc of first real instruction */
 410 /* from i386-dep.c */
 411
 412 i386_skip_prologue (pc)
 413 {
 414   unsigned char op;
 415   int i;
 416
 417   if (i386_get_frame_setup (pc) < 0)
 418     return (pc);
 419
 420   /* found valid frame setup - codestream now points to
 421    * start of push instructions for saving registers
 422    */
 423
 424   /* skip over register saves */
 425   for (i = 0; i < 8; i++)
 426     {
 427       op = codestream_peek ();
 428       /* break if not pushl inst */
 429       if (op < 0x50 || op > 0x57)
 430         break;
 431       codestream_get ();
 432     }
 433
 434   i386_follow_jump ();
 435
 436   return (codestream_tell ());
 437 }
 438
 439 symmetry_extract_return_value(type, regbuf, valbuf)
 440      struct type *type;
 441      char *regbuf;
 442      char *valbuf;
 443 {
 444   union {
 445     double      d;
 446     int l[2];
 447   } xd;
 448   int i;
 449   float f;
 450
 451   if (TYPE_CODE_FLT == TYPE_CODE(type)) {
 452     for (i = 0; i < misc_function_count; i++) {
 453       if (!strcmp(misc_function_vector[i].name, "1167_flt"))
 454         break;
 455     }
 456     if (i < misc_function_count) {
 457       /* found "1167_flt" means 1167, %fp2-%fp3 */
 458       /* float & double; 19= %fp2, 20= %fp3 */
 459       /* no single precision on 1167 */
 460       xd.l[1] = *((int *)&regbuf[REGISTER_BYTE(19)]);
 461       xd.l[0] = *((int *)&regbuf[REGISTER_BYTE(20)]);
 462       switch (TYPE_LENGTH(type)) {
 463       case 4:
 464         f = (float) xd.d;
 465         bcopy(&f, valbuf, TYPE_LENGTH(type));
 466         break;
 467       case 8:
 468         bcopy(&xd.d, valbuf, TYPE_LENGTH(type));
 469         break;
 470       default:
 471         error("Unknown floating point size");
 472         break;
 473       }
 474     } else {
 475       /* 387 %st(0), gcc uses this */
 476       i387_to_double(((int *)&regbuf[REGISTER_BYTE(3)]),
 477                      &xd.d);
 478       switch (TYPE_LENGTH(type)) {
 479       case 4:                   /* float */
 480         f = (float) xd.d;
 481         bcopy(&f, valbuf, 4);
 482         break;
 483       case 8:                   /* double */
 484         bcopy(&xd.d, valbuf, 8);
 485         break;
 486       default:
 487         error("Unknown floating point size");
 488         break;
 489       }
 490     }
 491   } else {
 492     bcopy (regbuf, valbuf, TYPE_LENGTH (type));
 493   }
 494 }