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