+++ /dev/null
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; gdb code changes
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-/*
- * Core Problem: when gdb says something like (../src/file.c 1234), the
- * real file might be in any of the active dirs in use by gdb and thus
- * emacs can not always find the file at "../src". Emacs cannot just
- * scan for GDB dir commands because these might be given in the .gdbinit
- * file or other scripts. The only solution is to have gdb be a bit more
- * specific when it prints file names.
- *
- * Remaining defects:
- *
- * 1. Do I really have to open the file to find out if it exists?
- * There should be a faster way.
- *
- * 2. Should there be a bdb command to toggle between short and absolute
- * forms of the file name?
- */
-
-
-/* Add this to ~emacs/gdb/source.c after the openp function */
-
-char *
-get_absolute_filename(table)
-/* Added by Lynn Slater, Silvar-Lisco 10/6/87
- returns the address of the best possible name to use for the file
- in the passed symtab. Returns the filename if the path cannot be
- resolved.
- Please remember to free the absolute name after use.*/
-struct symtab *table;
-{
- register int desc;
- char *absolute_name;
-
- desc = openp (source_path, 0, table->filename, O_RDONLY, 0, &absolute_name);
- if (desc < 0)
- return( savestring(table->filename, strlen(table->filename)));
-
- close (desc);
- return(absolute_name);
-}
-
-/* Replace this fcn in ~emacs/gdb/stack.c */
-void
-print_frame_info (fi, level, source, args)
- struct frame_info *fi;
- register int level;
- int source;
- int args;
-{
- register FRAME frame = fi->frame;
- struct symtab_and_line sal;
- struct symbol *func;
- register char *funname = 0;
- int numargs;
-
- sal = find_pc_line (fi->pc, fi->next_frame);
- func = get_frame_function (frame);
- if (func)
- funname = SYMBOL_NAME (func);
- else
- {
- register int misc_index = find_pc_misc_function (fi->pc);
- if (misc_index >= 0)
- funname = misc_function_vector[misc_index].name;
- }
-
- if (source >= 0 || !sal.symtab)
- {
- /* This avoids a bug in cc on the sun. */
- struct frame_info tem;
- tem = *fi;
-
- if (level >= 0)
- printf ("#%-2d ", level);
- if (fi->pc != sal.pc || !sal.symtab)
- printf ("0x%x in ", fi->pc);
- printf ("%s (", funname ? funname : "??");
- if (args)
- {
- FRAME_NUM_ARGS (numargs, tem);
- print_frame_args (func, FRAME_ARGS_ADDRESS (tem), numargs, stdout);
- }
- printf (")");
- if (sal.symtab)
- {
- char * absolute_filename;
- absolute_filename = (char *) get_absolute_filename(sal.symtab);
- printf (" (%s line %d)", absolute_filename, sal.line);
- free(absolute_filename);
- }
- printf ("\n");
- }
-
- if (source != 0 && sal.symtab)
- {
- if (source < 0 && fi->pc != sal.pc)
- printf ("0x%x\t", fi->pc);
- print_source_lines (sal.symtab, sal.line, sal.line + 1);
- current_source_line = max (sal.line - 5, 1);
- }
- if (source != 0)
- set_default_breakpoint (1, fi->pc, sal.symtab, sal.line);
-
- fflush (stdout);
-}
-
+++ /dev/null
-===================================================================
-RCS file: RCS/printcmd.c,v
-retrieving revision 1.1
-diff -c3 -r1.1 printcmd.c
-*** /tmp/,RCSt1011248 Tue Jan 12 14:06:06 1988
---- printcmd.c Mon Sep 21 21:33:39 1987
-***************
-*** 174,179
- VALUE_TYPE (val) = builtin_type_float;
- if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (double))
- VALUE_TYPE (val) = builtin_type_double;
- printf ("%g", value_as_double (val));
- break;
-
-
---- 174,185 -----
- VALUE_TYPE (val) = builtin_type_float;
- if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (double))
- VALUE_TYPE (val) = builtin_type_double;
-+ #ifdef PRINTF_BUG
-+ if (is_nan(value_as_double (val)))
-+ printf ("Nan");
-+ else
-+ printf ("%g", value_as_double (val));
-+ #else
- printf ("%g", value_as_double (val));
- #endif
- break;
-***************
-*** 175,180
- if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (double))
- VALUE_TYPE (val) = builtin_type_double;
- printf ("%g", value_as_double (val));
- break;
-
- case 0:
-
---- 181,187 -----
- printf ("%g", value_as_double (val));
- #else
- printf ("%g", value_as_double (val));
-+ #endif
- break;
-
- case 0:
-===================================================================
-RCS file: RCS/valprint.c,v
-retrieving revision 1.1
-diff -c3 -r1.1 valprint.c
-*** /tmp/,RCSt1011248 Tue Jan 12 14:06:09 1988
---- valprint.c Mon Sep 21 21:35:45 1987
-***************
-*** 21,26
- #include <stdio.h>
- #include "defs.h"
- #include "initialize.h"
- #include "symtab.h"
- #include "value.h"
-
-
---- 21,27 -----
- #include <stdio.h>
- #include "defs.h"
- #include "initialize.h"
-+ #include "param.h"
- #include "symtab.h"
- #include "value.h"
-
-***************
-*** 249,255
- break;
-
- case TYPE_CODE_FLT:
-! fprintf (stream, "%g", unpack_double (type, valaddr));
- break;
-
- case TYPE_CODE_VOID:
-
---- 250,265 -----
- break;
-
- case TYPE_CODE_FLT:
-! { double d = unpack_double (type, valaddr);
-! #ifdef PRINTF_BUG
-! if (is_nan(d))
-! fprintf (stream, "Nan");
-! else
-! fprintf (stream, "%g", d);
-! #else
-! fprintf (stream, "%g", d);
-! #endif
-! }
- break;
-
- case TYPE_CODE_VOID:
-***************
-*** 559,563
- float_type_table[sizeof (float)] = "float";
- float_type_table[sizeof (double)] = "double";
- }
-
- END_FILE
-
---- 569,599 -----
- float_type_table[sizeof (float)] = "float";
- float_type_table[sizeof (double)] = "double";
- }
-+
-+
-+ #ifdef PRINTF_BUG
-+
-+ struct ieee { /* IEEE floating format */
-+ unsigned int s:1;
-+ unsigned int e:11;
-+ unsigned int f1:20;
-+ unsigned int f2;
-+ };
-+
-+ #define ZERO_F(x) ((x.f1 == 0) && (x.f2 == 0)) /* zero fraction ? */
-+ #define ZERO_E(x) (x.e == 0) /* zero exponential ? */
-+ #define MAX_E(x) (x.e == 0x7ff) /* max exponential ? */
-+ #define MINUS_S(x) (x.s == 1) /* minus ? */
-+
-+ int
-+ is_nan(arg) /* Not a Number ? */
-+ struct ieee arg;
-+ {
-+ if (MAX_E(arg) && !ZERO_F(arg))
-+ return (1);
-+ else
-+ return (0);
-+ }
-+ #endif
-
- END_FILE
-
+++ /dev/null
-From uwvax!sequent!ogcvax!reed!keith@RUTGERS.EDU Thu Jul 23 21:46:44 1987
-Received: by PREP.AI.MIT.EDU; Thu, 23 Jul 87 21:44:35 EDT
-Received: by RUTGERS.EDU (5.54/1.14) with UUCP
- id AA04584; Thu, 23 Jul 87 21:42:33 EDT
-Received: from sequent.UUCP by spool.WISC.EDU; Thu, 23 Jul 87 20:36:20 CDT
-Received: from reed.UUCP by ogcvax.OGC.EDU (5.51/OGC_4.6+)
- id AA05332; Thu, 23 Jul 87 13:31:52 PDT
-Received: by reed.UUCP (5.51/5.17)
- id AA23265; Thu, 23 Jul 87 11:19:20 PDT
-From: uwvax!sequent!ogcvax!reed!keith@RUTGERS.EDU (Keith Packard)
-Message-Id: <8707231819.AA23265@reed.UUCP>
-To: phr@prep.ai.mit.edu (Paul Rubin)
-Subject: Re: gdb
-In-Reply-To: Your message of Thu, 23 Jul 87 02:06:52 EDT.
- <8707230603.AA11722@EDDIE.MIT.EDU>
-Date: Thu, 23 Jul 87 11:19:13 PDT
-Status: R
-
-
-Thanks much for the address -- the 2.1 sources that I have do not contain
-any bug reporting address. The only real bug that I found was in
-write_register_bytes in findvar.c:
-
-was:
-
- bcopy (myaddr, ®isters[regbyte], len);
- if (have_inferior_p ())
- store_inferior_registers (0);
-
-should be:
-
- bcopy (myaddr, ®isters[regbyte], len);
- if (have_inferior_p ())
- store_inferior_registers (-1);
-
-Other than that, most of the porting effort to the 32k was in removing
-references to alloca - the 32k is adamant about not using alloca -- in fact
-someone at tektronix wrote a replacement which accepted another argument
-pointing to the function entry instruction so that the stack could be maimed
-mercilessly... I just replaced them all with malloc and used free at
-judicious times. It's not perfect but it worked fine.
-
-I would upload gdb 2.3 if I could, however I am not on the arpa net. I'll
-probably end up sending GNU a tape.
-
-It's a great debugger, thanks!
-
- keith packard
- tektronix!reed!keith
-
-Here are the param files and instruction printer for the 32032:
-
-#!/bin/sh
-# shar: Shell Archiver
-# Run the following text with /bin/sh to create:
-# m-merlin.h
-# n32k-opcode.h
-# n32k-pinsn.c
-sed 's/^X//' << 'SHAR_EOF' > m-merlin.h
-X/* Definitions to make GDB run on a merlin under utek 2.1
-X Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-X
-XGDB is distributed in the hope that it will be useful, but WITHOUT ANY
-XWARRANTY. No author or distributor accepts responsibility to anyone
-Xfor the consequences of using it or for whether it serves any
-Xparticular purpose or works at all, unless he says so in writing.
-XRefer to the GDB General Public License for full details.
-X
-XEveryone is granted permission to copy, modify and redistribute GDB,
-Xbut only under the conditions described in the GDB General Public
-XLicense. A copy of this license is supposed to have been given to you
-Xalong with GDB so you can know your rights and responsibilities. It
-Xshould be in a file named COPYING. Among other things, the copyright
-Xnotice and this notice must be preserved on all copies.
-X
-XIn other words, go ahead and share GDB, but don't try to stop
-Xanyone else from sharing it farther. Help stamp out software hoarding!
-X*/
-X
-X#ifndef ns16000
-X#define ns16000
-X#endif
-X
-X# include <machine/reg.h>
-X
-X/* Define this if the C compiler puts an underscore at the front
-X of external names before giving them to the linker. */
-X
-X#define NAMES_HAVE_UNDERSCORE
-X
-X/* Offset from address of function to start of its code.
-X Zero on most machines. */
-X
-X#define FUNCTION_START_OFFSET 0
-X
-X/* Advance PC across any function entry prologue instructions
-X to reach some "real" code. */
-X
-X#define SKIP_PROLOGUE(pc) \
-X{ register int op = read_memory_integer (pc, 1); \
-X if (op == 0x82) { op = read_memory_integer (pc+2,1); \
-X if ((op & 0x80) == 0) pc += 3; \
-X else if ((op & 0xc0) == 0x80) pc += 4; \
-X else pc += 6; \
-X } \
-X}
-X
-X/* Immediately after a function call, return the saved pc.
-X Can't always go through the frames for this because on some machines
-X the new frame is not set up until the new function executes
-X some instructions. */
-X
-X#define SAVED_PC_AFTER_CALL(frame) \
-X read_memory_integer (read_register (SP_REGNUM), 4)
-X
-X/* This is the amount to subtract from u.u_ar0
-X to get the offset in the core file of the register values. */
-X
-X#define KERNEL_U_ADDR (0xfef000)
-X
-X/* Address of end of stack space. */
-X
-X#define STACK_END_ADDR (0x800000)
-X
-X/* Stack grows downward. */
-X
-X#define INNER_THAN <
-X
-X/* Sequence of bytes for breakpoint instruction. */
-X
-X#define BREAKPOINT {0xf2}
-X
-X/* Amount PC must be decremented by after a breakpoint.
-X This is often the number of bytes in BREAKPOINT
-X but not always. */
-X
-X#define DECR_PC_AFTER_BREAK 0
-X
-X/* Nonzero if instruction at PC is a return instruction. */
-X
-X#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12)
-X
-X/* Return 1 if P points to an invalid floating point value. */
-X
-X#define INVALID_FLOAT(p) (0)
-X
-X/* Say how long (ordinary) registers are. */
-X
-X#define REGISTER_TYPE long
-X
-X/* Number of machine registers */
-X
-X#define NUM_REGS 25
-X
-X#define NUM_GENERAL_REGS 8
-X
-X/* Initializer for an array of names of registers.
-X There should be NUM_REGS strings in this initializer. */
-X
-X#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
-X "pc", "sp", "fp", "ps", \
-X "fsr", \
-X "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
-X "l0", "l1", "l2", "l3", "l4", \
-X }
-X
-X/* Register numbers of various important registers.
-X Note that some of these values are "real" register numbers,
-X and correspond to the general registers of the machine,
-X and some are "phony" register numbers which are too large
-X to be actual register numbers as far as the user is concerned
-X but do serve to get the desired values when passed to read_register. */
-X
-X#define AP_REGNUM FP_REGNUM
-X#define FP_REGNUM 10 /* Contains address of executing stack frame */
-X#define SP_REGNUM 9 /* Contains address of top of stack */
-X#define PC_REGNUM 8 /* Contains program counter */
-X#define PS_REGNUM 11 /* Contains processor status */
-X#define FPS_REGNUM 12 /* Floating point status register */
-X#define FP0_REGNUM 13 /* Floating point register 0 */
-X#define LP0_REGNUM 21 /* Double register 0 (same as FP0) */
-X
-X#define REGISTER_U_ADDR(addr, blockend, regno) \
-X{ \
-X switch (regno) { \
-X case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: \
-X addr = blockend + (R0 - regno) * sizeof (int); break; \
-X case PC_REGNUM: \
-X addr = blockend + PC * sizeof (int); break; \
-X case SP_REGNUM: \
-X addr = blockend + SP * sizeof (int); break; \
-X case FP_REGNUM: \
-X addr = blockend + FP * sizeof (int); break; \
-X case PS_REGNUM: \
-X addr = blockend + 12 * sizeof (int); break; \
-X case FPS_REGNUM: \
-X addr = 108; break; \
-X case FP0_REGNUM + 0: case FP0_REGNUM + 1: \
-X case FP0_REGNUM + 2: case FP0_REGNUM + 3: \
-X case FP0_REGNUM + 4: case FP0_REGNUM + 5: \
-X case FP0_REGNUM + 6: case FP0_REGNUM + 7: \
-X addr = 76 + (regno - FP0_REGNUM) * sizeof (float); break; \
-X case LP0_REGNUM + 0: case LP0_REGNUM + 1: \
-X case LP0_REGNUM + 2: case LP0_REGNUM + 3: \
-X addr = 76 + (regno - LP0_REGNUM) * sizeof (double); break; \
-X default: \
-X printf ("bad argument to REGISTER_U_ADDR %d\n", regno); \
-X abort (); \
-X } \
-X}
-X
-X/* Total amount of space needed to store our copies of the machine's
-X register state, the array `registers'. */
-X#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double))
-X
-X/* Index within `registers' of the first byte of the space for
-X register N. */
-X
-X#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \
-X LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4)
-X
-X/* Number of bytes of storage in the actual machine representation
-X for register N. On the 32000, all regs are 4 bytes
-X except for the doubled floating registers. */
-X
-X#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
-X
-X/* Number of bytes of storage in the program's representation
-X for register N. On the 32000, all regs are 4 bytes
-X except for the doubled floating registers. */
-X
-X#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
-X
-X/* Largest value REGISTER_RAW_SIZE can have. */
-X
-X#define MAX_REGISTER_RAW_SIZE 8
-X
-X/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-X
-X#define MAX_REGISTER_VIRTUAL_SIZE 8
-X
-X/* Nonzero if register N requires conversion
-X from raw format to virtual format. */
-X
-X#define REGISTER_CONVERTIBLE(N) 0
-X
-X/* Convert data from raw format for register REGNUM
-X to virtual format for register REGNUM. */
-X
-X#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
-X bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
-X
-X/* Convert data from virtual format for register REGNUM
-X to raw format for register REGNUM. */
-X
-X#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
-X bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
-X
-X/* Return the GDB type object for the "standard" data type
-X of data in register N. */
-X
-X#define REGISTER_VIRTUAL_TYPE(N) \
-X ((N) >= FP0_REGNUM ? \
-X (N) >= LP0_REGNUM ? \
-X builtin_type_double \
-X : builtin_type_float \
-X : builtin_type_int)
-X\f
-X/* Describe the pointer in each stack frame to the previous stack frame
-X (its caller). */
-X
-X/* FRAME_CHAIN takes a frame's nominal address
-X and produces the frame's chain-pointer.
-X
-X FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
-X and produces the nominal address of the caller frame.
-X
-X However, if FRAME_CHAIN_VALID returns zero,
-X it means the given frame is the outermost one and has no caller.
-X In that case, FRAME_CHAIN_COMBINE is not used. */
-X
-X/* In the case of the Merlin, the frame's nominal address is the FP value,
-X and at that address is saved previous FP value as a 4-byte word. */
-X
-X#define FRAME_CHAIN(thisframe) (read_memory_integer (thisframe, 4))
-X
-X#define FRAME_CHAIN_VALID(chain, thisframe) \
-X (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
-X
-X#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-X
-X/* Define other aspects of the stack frame. */
-X
-X#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
-X
-X/* compute base of arguments */
-X#define FRAME_ARGS_ADDRESS(fi) ((fi).frame)
-X
-X#define FRAME_LOCALS_ADDRESS(fi) ((fi).frame)
-X
-X/* Return number of args passed to a frame.
-X Can return -1, meaning no way to tell. */
-X
-X#define FRAME_NUM_ARGS(numargs, fi) \
-X{ CORE_ADDR pc; \
-X int insn; \
-X int addr_mode; \
-X int width; \
-X \
-X pc = FRAME_SAVED_PC (fi.frame); \
-X insn = read_memory_integer (pc,2); \
-X addr_mode = (insn >> 11) & 0x1f; \
-X insn = insn & 0x7ff; \
-X if ((insn & 0x7fc) == 0x57c && \
-X addr_mode == 0x14) { /* immediate */ \
-X if (insn == 0x57c) /* adjspb */ \
-X width = 1; \
-X else if (insn == 0x57d) /* adjspw */ \
-X width = 2; \
-X else if (insn == 0x57f) /* adjspd */ \
-X width = 4; \
-X numargs = read_memory_integer (pc+2,width); \
-X if (width > 1) \
-X flip_bytes (&numargs, width); \
-X numargs = - sign_extend (numargs, width*8) / 4; \
-X } else { \
-X numargs = -1; \
-X } \
-X}
-X
-X/* Return number of bytes at start of arglist that are not really args. */
-X
-X#define FRAME_ARGS_SKIP 8
-X
-X/* Put here the code to store, into a struct frame_saved_regs,
-X the addresses of the saved registers of frame described by FRAME_INFO.
-X This includes special registers such as pc and fp saved in special
-X ways in the stack frame. sp is even more special:
-X the address we return for it IS the sp for the next frame. */
-X
-X#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
-X{ \
-X int regmask,regnum; \
-X int localcount; \
-X CORE_ADDR enter_addr; \
-X CORE_ADDR next_addr; \
-X \
-X enter_addr = get_pc_function_start ((frame_info).pc); \
-X regmask = read_memory_integer (enter_addr+1, 1); \
-X localcount = n32k_localcount (enter_addr); \
-X next_addr = (frame_info).frame + localcount; \
-X for (regnum = 0; regnum < 8; regnum++, regmask >>= 1) \
-X (frame_saved_regs).regs[regnum] = (regmask & 1) ? \
-X (next_addr -= 4) : 0; \
-X (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 4; \
-X (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4; \
-X (frame_saved_regs).regs[FP_REGNUM] = (read_memory_integer \
-X ((frame_info).frame, 4)); \
-X}
-X\f
-X/* Things needed for making the inferior call functions. */
-X
-X/* Push an empty stack frame, to record the current PC, etc. */
-X
-X#define PUSH_DUMMY_FRAME \
-X{ register CORE_ADDR sp = read_register (SP_REGNUM);\
-X register int regnum; \
-X sp = push_word (sp, read_register (PC_REGNUM)); \
-X sp = push_word (sp, read_register (FP_REGNUM)); \
-X write_register (FP_REGNUM, sp); \
-X for (regnum = 0; regnum < 8; regnum++) \
-X sp = push_word (sp, read_register (regnum)); \
-X write_register (SP_REGNUM, sp); \
-X}
-X
-X/* Discard from the stack the innermost frame, restoring all registers. */
-X
-X#define POP_FRAME \
-X{ register CORE_ADDR fp = read_register (FP_REGNUM); \
-X register int regnum; \
-X struct frame_saved_regs fsr; \
-X struct frame_info fi; \
-X fi = get_frame_info (fp); \
-X get_frame_saved_regs (&fi, &fsr); \
-X for (regnum = 0; regnum < 8; regnum++) \
-X if (fsr.regs[regnum]) \
-X write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
-X write_register (FP_REGNUM, read_memory_integer (fp, 4)); \
-X write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \
-X write_register (SP_REGNUM, fp + 8); \
-X}
-X
-X/* This sequence of words is the instructions
-X enter 0xff,0 82 ff 00
-X jsr @0x00010203 7f ae c0 01 02 03
-X adjspd 0x69696969 7f a5 01 02 03 04
-X bpt f2
-X Note this is 16 bytes. */
-X
-X#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 }
-X
-X#define CALL_DUMMY_START_OFFSET 3
-X#define CALL_DUMMY_LENGTH 16
-X#define CALL_DUMMY_ADDR 5
-X#define CALL_DUMMY_NARGS 11
-X
-X/* Insert the specified number of args and function address
-X into a call sequence of the above form stored at DUMMYNAME. */
-X
-X#define FIX_CALL_DUMMY(dummyname, fun, nargs) \
-X{ \
-X int flipped; \
-X flipped = fun | 0xc0000000; \
-X flip_bytes (&flipped, 4); \
-X *((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped; \
-X flipped = - nargs * 4; \
-X flip_bytes (&flipped, 4); \
-X *((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped; \
-X}
-X\f
-X#ifdef notdef
-X/* Interface definitions for kernel debugger KDB. */
-X
-X/* Map machine fault codes into signal numbers.
-X First subtract 0, divide by 4, then index in a table.
-X Faults for which the entry in this table is 0
-X are not handled by KDB; the program's own trap handler
-X gets to handle then. */
-X
-X#define FAULT_CODE_ORIGIN 0
-X#define FAULT_CODE_UNITS 4
-X#define FAULT_TABLE \
-X{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \
-X 0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \
-X 0, 0, 0, 0, 0, 0, 0, 0}
-X
-X/* Start running with a stack stretching from BEG to END.
-X BEG and END should be symbols meaningful to the assembler.
-X This is used only for kdb. */
-X
-X#define INIT_STACK(beg, end) \
-X{ asm (".globl end"); \
-X asm ("movl $ end, sp"); \
-X asm ("clrl fp"); }
-X
-X/* Push the frame pointer register on the stack. */
-X#define PUSH_FRAME_PTR \
-X asm ("pushl fp");
-X
-X/* Copy the top-of-stack to the frame pointer register. */
-X#define POP_FRAME_PTR \
-X asm ("movl (sp), fp");
-X
-X/* After KDB is entered by a fault, push all registers
-X that GDB thinks about (all NUM_REGS of them),
-X so that they appear in order of ascending GDB register number.
-X The fault code will be on the stack beyond the last register. */
-X
-X#define PUSH_REGISTERS \
-X{ asm ("pushl 8(sp)"); \
-X asm ("pushl 8(sp)"); \
-X asm ("pushal 0x14(sp)"); \
-X asm ("pushr $037777"); }
-X
-X/* Assuming the registers (including processor status) have been
-X pushed on the stack in order of ascending GDB register number,
-X restore them and return to the address in the saved PC register. */
-X
-X#define POP_REGISTERS \
-X{ asm ("popr $037777"); \
-X asm ("subl2 $8,(sp)"); \
-X asm ("movl (sp),sp"); \
-X asm ("rei"); }
-X#endif
-SHAR_EOF
-sed 's/^X//' << 'SHAR_EOF' > n32k-opcode.h
-X/* n32k-opcode.h */
-X
-X#ifndef n32k_opcodeT
-X#define n32k_opcodeT int
-X#endif /* no n32k_opcodeT */
-X
-Xstruct not_wot /* n32k opcode table: wot to do with this */
-X /* particular opcode */
-X{
-X int obits; /* number of opcode bits */
-X int ibits; /* number of instruction bits */
-X n32k_opcodeT code; /* op-code (may be > 8 bits!) */
-X char *args; /* how to compile said opcode */
-X};
-X
-Xstruct not /* n32k opcode text */
-X{
-X char * name; /* opcode name: lowercase string [key] */
-X struct not_wot detail; /* rest of opcode table [datum] */
-X};
-X
-X/* F : 32 bit float
-X * L : 64 bit float
-X * B : byte
-X * W : word
-X * D : double-word
-X * Q : quad-word
-X * d : displacement
-X * q : quick
-X * i : immediate (8 bits)
-X * r : register number (3 bits)
-X * p : displacement - pc relative addressing
-X*/
-Xstatic struct not
-Xnotstrs[] =
-X{
-X{ "absf", 14,24, 0x35be, "1F2F" },
-X{ "absl", 14,24, 0x34be, "1L2L" },
-X{ "absb", 14,24, 0x304e, "1B2B" },
-X{ "absw", 14,24, 0x314e, "1W2W" },
-X{ "absd", 14,24, 0x334e, "1D2D" },
-X{ "acbb", 7,16, 0x4c, "2B1q3p" },
-X{ "addf", 14,24, 0x01be, "1F2F" },
-X{ "addl", 14,24, 0x00be, "1L2L" },
-X{ "addb", 6,16, 0x00, "1B2B" },
-X{ "addw", 6,16, 0x01, "1W2W" },
-X{ "addd", 6,16, 0x03, "1D2D" },
-X{ "addcb", 6,16, 0x10, "1B2B" },
-X{ "addcw", 6,16, 0x11, "1W2W" },
-X{ "addcd", 6,16, 0x13, "1D2D" },
-X{ "addpb", 14,24, 0x3c4e, "1B2B" },
-X{ "addpw", 14,24, 0x3d4e, "1W2W" },
-X{ "addpd", 14,24, 0x3f4e, "1D2D" },
-X{ "addqb", 7,16, 0x0c, "2B1q" },
-X{ "addqw", 7,16, 0x0d, "2W1q" },
-X{ "addqd", 7,16, 0x0f, "2D1q" },
-X{ "addr", 6,16, 0x27, "1D2D" },
-X{ "adjspb", 11,16, 0x057c, "1B" },
-X{ "adjspw", 11,16, 0x057d, "1W" },
-X{ "adjspd", 11,16, 0x057f, "1D" },
-X{ "andb", 6,16, 0x28, "1B2B" },
-X{ "andw", 6,16, 0x29, "1W2W" },
-X{ "andd", 6,16, 0x2b, "1D2D" },
-X{ "ashb", 14,24, 0x044e, "1B2B" },
-X{ "ashw", 14,24, 0x054e, "1B2W" },
-X{ "ashd", 14,24, 0x074e, "1B2D" },
-X{ "beq", 8,8, 0x0a, "1p" },
-X{ "bne", 8,8, 0x1a, "1p" },
-X{ "bcs", 8,8, 0x2a, "1p" },
-X{ "bcc", 8,8, 0x3a, "1p" },
-X{ "bhi", 8,8, 0x4a, "1p" },
-X{ "bls", 8,8, 0x5a, "1p" },
-X{ "bgt", 8,8, 0x6a, "1p" },
-X{ "ble", 8,8, 0x7a, "1p" },
-X{ "bfs", 8,8, 0x8a, "1p" },
-X{ "bfc", 8,8, 0x9a, "1p" },
-X{ "blo", 8,8, 0xaa, "1p" },
-X{ "bhs", 8,8, 0xba, "1p" },
-X{ "blt", 8,8, 0xca, "1p" },
-X{ "bge", 8,8, 0xda, "1p" },
-X{ "bicb", 6,16, 0x08, "1B2B" },
-X{ "bicw", 6,16, 0x09, "1W2W" },
-X{ "bicd", 6,16, 0x0b, "1D2D" },
-X{ "bicpsrb", 11,16, 0x17c, "1B" },
-X{ "bicpsrw", 11,16, 0x17d, "1W" },
-X{ "bispsrb", 11,16, 0x37c, "1B" },
-X{ "bispsrw", 11,16, 0x37d, "1W" },
-X{ "bpt", 8,8, 0xf2, "" },
-X{ "br", 8,8, 0xea, "1p" },
-X{ "bsr", 8,8, 0x02, "1p" },
-X{ "caseb", 11,16, 0x77c, "1B" },
-X{ "casew", 11,16, 0x77d, "1W" },
-X{ "cased", 11,16, 0x77f, "1D" },
-X{ "cbitb", 14,24, 0x084e, "1B2D" },
-X{ "cbitw", 14,24, 0x094e, "1W2D" },
-X{ "cbitd", 14,24, 0x0b4e, "1D2D" },
-X{ "cbitib", 14,24, 0x0c4e, "1B2D" },
-X{ "cbitiw", 14,24, 0x0d4e, "1W2D" },
-X{ "cbitid", 14,24, 0x0f4e, "1D2D" },
-X{ "checkb", 11,24, 0x0ee, "2A3B1r" },
-X{ "checkw", 11,24, 0x1ee, "2A3B1r" },
-X{ "checkd", 11,24, 0x3ee, "2A3D1r" },
-X{ "cmpf", 14,24, 0x09be, "1F2F" },
-X{ "cmpl", 14,24, 0x08be, "1L2L" },
-X{ "cmpb", 6,16, 0x04, "1B2B" },
-X{ "cmpw", 6,16, 0x05, "1W2W" },
-X{ "cmpd", 6,16, 0x07, "1D2D" },
-X{ "cmpmb", 14,24, 0x04ce, "1D2D3d" },
-X{ "cmpmw", 14,24, 0x05ce, "1D2D3d" },
-X{ "cmpmd", 14,24, 0x07ce, "1D2D3d" },
-X{ "cmpqb", 7,16, 0x1c, "2B1q" },
-X{ "cmpqw", 7,16, 0x1d, "2W1q" },
-X{ "cmpqd", 7,16, 0x1f, "2D1q" },
-X{ "cmpsb", 16,16, 0x040e, "i" },
-X{ "cmpsw", 16,16, 0x050e, "i" },
-X{ "cmpsd", 16,16, 0x070e, "i" },
-X{ "cmpst", 16,16, 0x840e, "i" },
-X{ "comb", 14,24, 0x344e, "1B2B" },
-X{ "comw", 14,24, 0x354e, "1W2W" },
-X{ "comd", 14,24, 0x374e, "1D2D" },
-X{ "cvtp", 11,24, 0x036e, "2D3D1r" },
-X{ "cxp", 8,8, 0x22, "1p" },
-X{ "cxpd", 11,16, 0x07f, "1D" },
-X{ "deib", 14,24, 0x2cce, "1B2W" },
-X{ "deiw", 14,24, 0x2cce, "1W2D" },
-X{ "deid", 14,24, 0x2cce, "1D2Q" },
-X{ "dia", 8,8, 0xc2, "" },
-X{ "divf", 14,24, 0x21be, "1F2F" },
-X{ "divl", 14,24, 0x20be, "1L2L" },
-X{ "divb", 14,24, 0x3cce, "1B2B" },
-X{ "divw", 14,24, 0x3dce, "1W2W" },
-X{ "divd", 14,24, 0x3fce, "1D2D" },
-X{ "enter", 8,8, 0x82, "1i2d" },
-X{ "exit", 8,8, 0x92, "1i" },
-X{ "extb", 11,24, 0x02e, "2D3B1r4d" },
-X{ "extw", 11,24, 0x12e, "2D3W1r4d" },
-X{ "extd", 11,24, 0x32e, "2D3D1r4d" },
-X{ "extsb", 14,24, 0x0cce, "1D2B3i" },
-X{ "extsw", 14,24, 0x0dce, "1D2W3i" },
-X{ "extsd", 14,24, 0x0fce, "1D2D3i" },
-X{ "ffsb", 14,24, 0x046e, "1B2B" },
-X{ "ffsw", 14,24, 0x056e, "1W2B" },
-X{ "ffsd", 14,24, 0x076e, "1D2B" },
-X{ "flag", 8,8, 0xd2, "" },
-X{ "floorfb", 14,24, 0x3c3e, "1F2B" },
-X{ "floorfw", 14,24, 0x3d3e, "1F2W" },
-X{ "floorfd", 14,24, 0x3f3e, "1F2D" },
-X{ "floorlb", 14,24, 0x383e, "1L2B" },
-X{ "floorlw", 14,24, 0x393e, "1L2W" },
-X{ "floorld", 14,24, 0x3b3e, "1L2D" },
-X{ "ibitb", 14,24, 0x384e, "1B2D" },
-X{ "ibitw", 14,24, 0x394e, "1W2D" },
-X{ "ibitd", 14,24, 0x3b4e, "1D2D" },
-X{ "indexb", 11,24, 0x42e, "2B3B1r" },
-X{ "indexw", 11,24, 0x52e, "2W3W1r" },
-X{ "indexd", 11,24, 0x72e, "2D3D1r" },
-X{ "insb", 11,24, 0x0ae, "2B3B1r4d" },
-X{ "insw", 11,24, 0x1ae, "2W3W1r4d" },
-X{ "insd", 11,24, 0x3ae, "2D3D1r4d" },
-X{ "inssb", 14,24, 0x08ce, "1B2D3i" },
-X{ "inssw", 14,24, 0x09ce, "1W2D3i" },
-X{ "inssd", 14,24, 0x0bce, "1D2D3i" },
-X{ "jsr", 11,16, 0x67f, "1A" },
-X{ "jump", 11,16, 0x27f, "1A" },
-X{ "lfsr", 19,24, 0x00f3e,"1D" },
-X{ "lmr", 15,24, 0x0b1e, "2D1q" },
-X{ "lprb", 7,16, 0x6c, "2B1q" },
-X{ "lprw", 7,16, 0x6d, "2W1q" },
-X{ "lprd", 7,16, 0x6f, "2D1q" },
-X{ "lshb", 14,24, 0x144e, "1B2B" },
-X{ "lshw", 14,24, 0x154e, "1B2W" },
-X{ "lshd", 14,24, 0x174e, "1B2D" },
-X{ "meib", 14,24, 0x24ce, "1B2W" },
-X{ "meiw", 14,24, 0x25ce, "1W2D" },
-X{ "meid", 14,24, 0x27ce, "1D2Q" },
-X{ "modb", 14,24, 0x38ce, "1B2B" },
-X{ "modw", 14,24, 0x39ce, "1W2W" },
-X{ "modd", 14,24, 0x3bce, "1D2D" },
-X{ "movf", 14,24, 0x05be, "1F2F" },
-X{ "movl", 14,24, 0x04be, "1L2L" },
-X{ "movb", 6,16, 0x14, "1B2B" },
-X{ "movw", 6,16, 0x15, "1W2W" },
-X{ "movd", 6,16, 0x17, "1D2D" },
-X{ "movbf", 14,24, 0x043e, "1B2F" },
-X{ "movwf", 14,24, 0x053e, "1W2F" },
-X{ "movdf", 14,24, 0x073e, "1D2F" },
-X{ "movbl", 14,24, 0x003e, "1B2L" },
-X{ "movwl", 14,24, 0x013e, "1W2L" },
-X{ "movdl", 14,24, 0x033e, "1D2L" },
-X{ "movfl", 14,24, 0x1b3e, "1F2L" },
-X{ "movlf", 14,24, 0x163e, "1L2F" },
-X{ "movmb", 14,24, 0x00ce, "1D2D3d" },
-X{ "movmw", 14,24, 0x00de, "1D2D3d" },
-X{ "movmd", 14,24, 0x00fe, "1D2D3d" },
-X{ "movqb", 7,16, 0x5c, "2B1q" },
-X{ "movqw", 7,16, 0x5d, "2B1q" },
-X{ "movqd", 7,16, 0x5f, "2B1q" },
-X{ "movsb", 16,16, 0x000e, "i" },
-X{ "movsw", 16,16, 0x010e, "i" },
-X{ "movsd", 16,16, 0x030e, "i" },
-X{ "movst", 16,16, 0x800e, "i" },
-X{ "movsub", 14,24, 0x0cae, "1A1A" },
-X{ "movsuw", 14,24, 0x0dae, "1A1A" },
-X{ "movsud", 14,24, 0x0fae, "1A1A" },
-X{ "movusb", 14,24, 0x1cae, "1A1A" },
-X{ "movusw", 14,24, 0x1dae, "1A1A" },
-X{ "movusd", 14,24, 0x1fae, "1A1A" },
-X{ "movxbd", 14,24, 0x1cce, "1B2D" },
-X{ "movxwd", 14,24, 0x1dce, "1W2D" },
-X{ "movxbw", 14,24, 0x10ce, "1B2W" },
-X{ "movzbd", 14,24, 0x18ce, "1B2D" },
-X{ "movzwd", 14,24, 0x19ce, "1W2D" },
-X{ "movzbw", 14,24, 0x14ce, "1B2W" },
-X{ "mulf", 14,24, 0x31be, "1F2F" },
-X{ "mull", 14,24, 0x30be, "1L2L" },
-X{ "mulb", 14,24, 0x20ce, "1B2B" },
-X{ "mulw", 14,24, 0x21ce, "1W2W" },
-X{ "muld", 14,24, 0x23ce, "1D2D" },
-X{ "negf", 14,24, 0x15be, "1F2F" },
-X{ "negl", 14,24, 0x14be, "1L2L" },
-X{ "negb", 14,24, 0x204e, "1B2B" },
-X{ "negw", 14,24, 0x214e, "1W2W" },
-X{ "negd", 14,24, 0x234e, "1D2D" },
-X{ "nop", 8,8, 0xa2, "" },
-X{ "notb", 14,24, 0x244e, "1B2B" },
-X{ "notw", 14,24, 0x254e, "1W2W" },
-X{ "notd", 14,24, 0x274e, "1D2D" },
-X{ "orb", 6,16, 0x18, "1B1B" },
-X{ "orw", 6,16, 0x19, "1W1W" },
-X{ "ord", 6,16, 0x1b, "1D1D" },
-X{ "quob", 14,24, 0x30ce, "1B2B" },
-X{ "quow", 14,24, 0x31ce, "1W2W" },
-X{ "quod", 14,24, 0x33ce, "1D2D" },
-X{ "rdval", 19,24, 0x0031e,"1A" },
-X{ "remb", 14,24, 0x34ce, "1B2B" },
-X{ "remw", 14,24, 0x35ce, "1W2W" },
-X{ "remd", 14,24, 0x37ce, "1D2D" },
-X{ "restore", 8,8, 0x72, "1i" },
-X{ "ret", 8,8, 0x12, "1d" },
-X{ "reti", 8,8, 0x52, "" },
-X{ "rett", 8,8, 0x42, "" },
-X{ "rotb", 14,24, 0x004e, "1B2B" },
-X{ "rotw", 14,24, 0x014e, "1B2W" },
-X{ "rotd", 14,24, 0x034e, "1B2D" },
-X{ "roundfb", 14,24, 0x243e, "1F2B" },
-X{ "roundfw", 14,24, 0x253e, "1F2W" },
-X{ "roundfd", 14,24, 0x273e, "1F2D" },
-X{ "roundlb", 14,24, 0x203e, "1L2B" },
-X{ "roundlw", 14,24, 0x213e, "1L2W" },
-X{ "roundld", 14,24, 0x233e, "1L2D" },
-X{ "rxp", 8,8, 0x32, "1d" },
-X{ "sCONDb", 7,16, 0x3c, "2B1q" },
-X{ "sCONDw", 7,16, 0x3d, "2D1q" },
-X{ "sCONDd", 7,16, 0x3f, "2D1q" },
-X{ "save", 8,8, 0x62, "1i" },
-X{ "sbitb", 14,24, 0x184e, "1B2A" },
-X{ "sbitw", 14,24, 0x194e, "1W2A" },
-X{ "sbitd", 14,24, 0x1b4e, "1D2A" },
-X{ "sbitib", 14,24, 0x1c4e, "1B2A" },
-X{ "sbitiw", 14,24, 0x1d4e, "1W2A" },
-X{ "sbitid", 14,24, 0x1f4e, "1D2A" },
-X{ "setcfg", 15,24, 0x0b0e, "5D1q" },
-X{ "sfsr", 14,24, 0x673e, "5D1D" },
-X{ "skpsb", 16,16, 0x0c0e, "i" },
-X{ "skpsw", 16,16, 0x0d0e, "i" },
-X{ "skpsd", 16,16, 0x0f0e, "i" },
-X{ "skpst", 16,16, 0x8c0e, "i" },
-X{ "smr", 15,24, 0x0f1e, "2D1q" },
-X{ "sprb", 7,16, 0x2c, "2B1q" },
-X{ "sprw", 7,16, 0x2d, "2W1q" },
-X{ "sprd", 7,16, 0x2f, "2D1q" },
-X{ "subf", 14,24, 0x11be, "1F2F" },
-X{ "subl", 14,24, 0x10be, "1L2L" },
-X{ "subb", 6,16, 0x20, "1B2B" },
-X{ "subw", 6,16, 0x21, "1W2W" },
-X{ "subd", 6,16, 0x23, "1D2D" },
-X{ "subcb", 6,16, 0x30, "1B2B" },
-X{ "subcw", 6,16, 0x31, "1W2W" },
-X{ "subcd", 6,16, 0x33, "1D2D" },
-X{ "subpb", 14,24, 0x2c4e, "1B2B" },
-X{ "subpw", 14,24, 0x2d4e, "1W2W" },
-X{ "subpd", 14,24, 0x2f4e, "1D2D" },
-X{ "svc", 8,8, 0xe2, "2i1i" }, /* not really, but unix uses it */
-X{ "tbitb", 6,16, 0x34, "1B2A" },
-X{ "tbitw", 6,16, 0x35, "1W2A" },
-X{ "tbitd", 6,16, 0x37, "1D2A" },
-X{ "truncfb", 14,24, 0x2c3e, "1F2B" },
-X{ "truncfw", 14,24, 0x2d3e, "1F2W" },
-X{ "truncfd", 14,24, 0x2f3e, "1F2D" },
-X{ "trunclb", 14,24, 0x283e, "1L2B" },
-X{ "trunclw", 14,24, 0x293e, "1L2W" },
-X{ "truncld", 14,24, 0x2b3e, "1L2D" },
-X{ "wait", 8,8, 0xb2, "" },
-X{ "wrval", 19,24, 0x0071e,"1A" },
-X{ "xorb", 6,16, 0x38, "1B2B" },
-X{ "xorw", 6,16, 0x39, "1W2W" },
-X{ "xord", 6,16, 0x3b, "1D2D" },
-X}; /* notstrs */
-X
-X/* end: n32k.opcode.h */
-X
-X# define MAX_ARGS 4
-X# define ARG_LEN 50
-SHAR_EOF
-sed 's/^X//' << 'SHAR_EOF' > n32k-pinsn.c
-X/* Print 32000 instructions for GDB, the GNU debugger.
-X Copyright (C) 1986 Free Software Foundation, Inc.
-X
-XGDB is distributed in the hope that it will be useful, but WITHOUT ANY
-XWARRANTY. No author or distributor accepts responsibility to anyone
-Xfor the consequences of using it or for whether it serves any
-Xparticular purpose or works at all, unless he says so in writing.
-XRefer to the GDB General Public License for full details.
-X
-XEveryone is granted permission to copy, modify and redistribute GDB,
-Xbut only under the conditions described in the GDB General Public
-XLicense. A copy of this license is supposed to have been given to you
-Xalong with GDB so you can know your rights and responsibilities. It
-Xshould be in a file named COPYING. Among other things, the copyright
-Xnotice and this notice must be preserved on all copies.
-X
-XIn other words, go ahead and share GDB, but don't try to stop
-Xanyone else from sharing it farther. Help stamp out software hoarding!
-X*/
-X
-X#include <stdio.h>
-X
-X#include "defs.h"
-X#include "param.h"
-X#include "symtab.h"
-X#include "n32k-opcode.h"
-X
-X/* 32000 instructions are never longer than this. */
-X#define MAXLEN 62
-X
-X/* Number of elements in the opcode table. */
-X#define NOPCODES (sizeof notstrs / sizeof notstrs[0])
-X
-Xextern char *reg_names[];
-X
-X#define NEXT_IS_ADDR '|'
-X
-X/*
-X * extract "count" bits starting "offset" bits
-X * into buffer
-X */
-X
-Xint
-Xbit_extract (buffer, offset, count)
-Xchar *buffer;
-Xint offset;
-Xint count;
-X{
-X int result;
-X int mask;
-X int bit;
-X
-X buffer += offset >> 3;
-X offset &= 7;
-X bit = 1;
-X result = 0;
-X while (count--) {
-X if ((*buffer & (1 << offset)))
-X result |= bit;
-X if (++offset == 8) {
-X offset = 0;
-X buffer++;
-X }
-X bit <<= 1;
-X }
-X return result;
-X}
-X
-Xdouble
-Xdbit_extract (buffer, offset, count)
-X{
-X union {
-X struct {
-X int low, high;
-X } ival;
-X double dval;
-X } foo;
-X
-X foo.ival.low = bit_extract (buffer, offset, 32);
-X foo.ival.high = bit_extract (buffer, offset+32, 32);
-X return foo.dval;
-X}
-X
-Xsign_extend (value, bits)
-X{
-X value = value & ((1 << bits) - 1);
-X return (value & (1 << (bits-1))) ?
-X (value | (~((1 << bits) - 1)))
-X : value;
-X}
-X
-Xflip_bytes (ptr, count)
-Xchar *ptr;
-Xint count;
-X{
-X char tmp;
-X
-X while (count > 0) {
-X tmp = *ptr;
-X ptr[0] = ptr[count-1];
-X ptr[count-1] = tmp;
-X ptr++;
-X count -= 2;
-X }
-X}
-X
-X\f
-X/* Print the 32000 instruction at address MEMADDR in debugged memory,
-X on STREAM. Returns length of the instruction, in bytes. */
-X
-Xint
-Xprint_insn (memaddr, stream)
-XCORE_ADDR memaddr;
-XFILE *stream;
-X{
-X unsigned char buffer[MAXLEN];
-X register int i;
-X register unsigned char *p;
-X register char *d;
-X unsigned short first_word;
-X int gen, disp;
-X int ioffset; /* bits into instruction */
-X int aoffset; /* bits into arguments */
-X char arg_bufs[MAX_ARGS+1][ARG_LEN];
-X int argnum;
-X int maxarg;
-X
-X read_memory (memaddr, buffer, MAXLEN);
-X
-X first_word = *(unsigned short *) buffer;
-X for (i = 0; i < NOPCODES; i++) {
-X if ((first_word & ((1 << notstrs[i].detail.obits) - 1)) ==
-X notstrs[i].detail.code)
-X break;
-X }
-X
-X /* Handle undefined instructions. */
-X if (i == NOPCODES) {
-X fprintf (stream, "0%o", buffer[0]);
-X return 1;
-X }
-X
-X fprintf (stream, "%s", notstrs[i].name);
-X
-X ioffset = notstrs[i].detail.ibits;
-X aoffset = notstrs[i].detail.ibits;
-X d = notstrs[i].detail.args;
-X
-X if (*d) {
-X fputc ('\t', stream);
-X
-X maxarg = 0;
-X while (*d)
-X {
-X argnum = *d - '1';
-X d++;
-X if (argnum > maxarg && argnum < MAX_ARGS)
-X maxarg = argnum;
-X ioffset = print_insn_arg (*d, ioffset, &aoffset, buffer,
-X memaddr, arg_bufs[argnum]);
-X d++;
-X }
-X for (argnum = 0; argnum <= maxarg; argnum++) {
-X CORE_ADDR addr;
-X char *ch, *index ();
-X for (ch = arg_bufs[argnum]; *ch;) {
-X if (*ch == NEXT_IS_ADDR) {
-X ++ch;
-X addr = atoi (ch);
-X print_address (addr, stream);
-X while (*ch && *ch != NEXT_IS_ADDR)
-X ++ch;
-X if (*ch)
-X ++ch;
-X } else
-X putc (*ch++, stream);
-X }
-X if (argnum < maxarg)
-X fprintf (stream, ", ");
-X }
-X }
-X return aoffset / 8;
-X}
-X
-Xprint_insn_arg (d, ioffset, aoffsetp, buffer, addr, result)
-Xchar d;
-Xint ioffset, *aoffsetp;
-Xchar *buffer;
-XCORE_ADDR addr;
-Xchar *result;
-X{
-X int addr_mode;
-X float Fvalue;
-X double Lvalue;
-X int Ivalue;
-X int disp1, disp2;
-X int index;
-X
-X switch (d) {
-X case 'F':
-X case 'L':
-X case 'B':
-X case 'W':
-X case 'D':
-X case 'A':
-X addr_mode = bit_extract (buffer, ioffset-5, 5);
-X ioffset -= 5;
-X switch (addr_mode) {
-X case 0x0: case 0x1: case 0x2: case 0x3:
-X case 0x4: case 0x5: case 0x6: case 0x7:
-X sprintf (result, "r%d", addr_mode);
-X break;
-X case 0x8: case 0x9: case 0xa: case 0xb:
-X case 0xc: case 0xd: case 0xe: case 0xf:
-X disp1 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "%d(r%d)", disp1, addr_mode & 7);
-X break;
-X case 0x10:
-X case 0x11:
-X case 0x12:
-X disp1 = get_displacement (buffer, aoffsetp);
-X disp2 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "%d(%d(%s))", disp2, disp1,
-X addr_mode==0x10?"fp":addr_mode==0x11?"sp":"sb");
-X break;
-X case 0x13:
-X sprintf (result, "reserved");
-X break;
-X case 0x14:
-X switch (d) {
-X case 'B':
-X Ivalue = bit_extract (buffer, *aoffsetp, 8);
-X Ivalue = sign_extend (Ivalue, 8);
-X *aoffsetp += 8;
-X sprintf (result, "$%d", Ivalue);
-X break;
-X case 'W':
-X Ivalue = bit_extract (buffer, *aoffsetp, 16);
-X flip_bytes (&Ivalue, 2);
-X *aoffsetp += 16;
-X Ivalue = sign_extend (Ivalue, 16);
-X sprintf (result, "$%d", Ivalue);
-X break;
-X case 'D':
-X Ivalue = bit_extract (buffer, *aoffsetp, 32);
-X flip_bytes (&Ivalue, 4);
-X *aoffsetp += 32;
-X sprintf (result, "$%d", Ivalue);
-X break;
-X case 'A':
-X Ivalue = bit_extract (buffer, *aoffsetp, 32);
-X flip_bytes (&Ivalue, 4);
-X *aoffsetp += 32;
-X sprintf (result, "$|%d|", Ivalue);
-X break;
-X case 'F':
-X Fvalue = (float) bit_extract
-X (buffer, *aoffsetp, 32);
-X flip_bytes (&Fvalue, 4);
-X *aoffsetp += 32;
-X sprintf (result, "$%g", Fvalue);
-X break;
-X case 'L':
-X Lvalue = dbit_extract
-X (buffer, *aoffsetp, 64);
-X flip_bytes (&Lvalue, 8);
-X *aoffsetp += 64;
-X sprintf (result, "$%g", Lvalue);
-X break;
-X }
-X break;
-X case 0x15:
-X disp1 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "@|%d|", disp1);
-X break;
-X case 0x16:
-X disp1 = get_displacement (buffer, aoffsetp);
-X disp2 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "EXT(%d) + %d", disp1, disp2);
-X break;
-X case 0x17:
-X sprintf (result, "tos");
-X break;
-X case 0x18:
-X disp1 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "%d(fp)", disp1);
-X break;
-X case 0x19:
-X disp1 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "%d(sp)", disp1);
-X break;
-X case 0x1a:
-X disp1 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "%d(sb)", disp1);
-X break;
-X case 0x1b:
-X disp1 = get_displacement (buffer, aoffsetp);
-X sprintf (result, "|%d|", addr + disp1);
-X break;
-X case 0x1c:
-X case 0x1d:
-X case 0x1e:
-X case 0x1f:
-X index = bit_extract (buffer, *aoffsetp, 8);
-X *aoffsetp += 8;
-X print_insn_arg (d, *aoffsetp, aoffsetp, buffer, addr,
-X result);
-X {
-X static char *ind[] = {"b", "w", "d", "q"};
-X char *off;
-X
-X off = result + strlen (result);
-X sprintf (off, "[r%d:%s]", index & 7,
-X ind[addr_mode & 3]);
-X }
-X break;
-X }
-X break;
-X case 'q':
-X Ivalue = bit_extract (buffer, ioffset-4, 4);
-X Ivalue = sign_extend (Ivalue, 4);
-X sprintf (result, "%d", Ivalue);
-X ioffset -= 4;
-X break;
-X case 'r':
-X Ivalue = bit_extract (buffer, ioffset-3, 3);
-X sprintf (result, "r%d", Ivalue&7);
-X ioffset -= 3;
-X break;
-X case 'd':
-X sprintf (result, "%d", get_displacement (buffer, aoffsetp));
-X break;
-X case 'p':
-X sprintf (result, "%c%d%c", NEXT_IS_ADDR, addr +
-X get_displacement (buffer, aoffsetp),
-X NEXT_IS_ADDR);
-X break;
-X case 'i':
-X Ivalue = bit_extract (buffer, *aoffsetp, 8);
-X *aoffsetp += 8;
-X sprintf (result, "0x%x", Ivalue);
-X break;
-X }
-X return ioffset;
-X}
-X
-Xget_displacement (buffer, aoffsetp)
-Xchar *buffer;
-Xint *aoffsetp;
-X{
-X int Ivalue;
-X
-X Ivalue = bit_extract (buffer, *aoffsetp, 8);
-X switch (Ivalue & 0xc0) {
-X case 0x00:
-X case 0x40:
-X Ivalue = sign_extend (Ivalue, 7);
-X *aoffsetp += 8;
-X break;
-X case 0x80:
-X Ivalue = bit_extract (buffer, *aoffsetp, 16);
-X flip_bytes (&Ivalue, 2);
-X Ivalue = sign_extend (Ivalue, 14);
-X *aoffsetp += 16;
-X break;
-X case 0xc0:
-X Ivalue = bit_extract (buffer, *aoffsetp, 32);
-X flip_bytes (&Ivalue, 4);
-X Ivalue = sign_extend (Ivalue, 30);
-X *aoffsetp += 32;
-X break;
-X }
-X return Ivalue;
-X}
-X/*
-X * return the number of locals in the current frame given a pc
-X * pointing to the enter instruction
-X */
-Xn32k_localcount (enter_pc)
-XCORE_ADDR enter_pc;
-X{
-X int localtype, localcount;
-X
-X localtype = read_memory_integer (enter_pc+2, 1);
-X if ((localtype & 0x80) == 0)
-X localcount = localtype;
-X else if ((localtype & 0xc0) == 0x80)
-X localcount =
-X ((read_memory_integer (enter_pc+2, 1) & ~0xc0) << 8) |
-X ((read_memory_integer (enter_pc+3, 1)));
-X else
-X localcount =
-X ((read_memory_integer (enter_pc+2, 1) & ~0xc0) << 24) |
-X ((read_memory_integer (enter_pc+3, 1)) << 16) |
-X ((read_memory_integer (enter_pc+4, 1)) << 8 ) |
-X ((read_memory_integer (enter_pc+5, 1)));
-X return localcount;
-X}
-SHAR_EOF
-exit
-
+++ /dev/null
-BABYL OPTIONS:
-Version: 5
-Labels:
-Note: This is the header of an rmail file.
-Note: If you are seeing it in rmail,
-Note: it means the file has no messages in it.
-\1f\f
-1,answered,,
-Received: by PREP.AI.MIT.EDU; Tue, 26 May 87 14:03:00 EDT
-Received: by po2.andrew.cmu.edu (5.54/3.15) id <AA00274> for rms@PREP.AI.MIT.EDU; Tue, 26 May 87 13:12:52 EDT
-Received: via switchmail; Tue, 26 May 87 13:12:49 edt
-Received: FROM mooncrest VIA qmail
- ID </cmu/common/mailqs/q004/QF.mooncrest.20b9cce3.d0134>;
- Tue, 26 May 87 13:12:08 edt
-Received: FROM mooncrest VIA qmail
- ID </cmu/itc/kazar/.Outgoing/QF.mooncrest.20b9ccb0.1b570>;
- Tue, 26 May 87 13:11:14 edt
-Message-Id: <0UiQmky00UkA06w0Ci@andrew.cmu.edu>
-X-Trace: MS Version 3.24 on ibm032 host mooncrest, by kazar (71).
-Date: Tue, 26 May 87 13:11:12 edt
-From: kazar#@andrew.cmu.edu (Mike Kazar)
-To: rms@PREP.AI.MIT.EDU (Richard M. Stallman)
-Subject: Re: Fwd: RT diffs for gdb version 2.1
-Cc: zs01#@andrew.cmu.edu (Zalman Stern)
-In-Reply-To: <4UiN0ly00Vs8Njw0PC@andrew.cmu.edu>
-
-*** EOOH ***
-X-Trace: MS Version 3.24 on ibm032 host mooncrest, by kazar (71).
-Date: Tue, 26 May 87 13:11:12 edt
-From: kazar#@andrew.cmu.edu (Mike Kazar)
-To: rms@PREP.AI.MIT.EDU (Richard M. Stallman)
-Subject: Re: Fwd: RT diffs for gdb version 2.1
-Cc: zs01#@andrew.cmu.edu (Zalman Stern)
-In-Reply-To: <4UiN0ly00Vs8Njw0PC@andrew.cmu.edu>
-
-I'm afraid that neither of your proposed simplifications to the gdb RT port
-actually work.
-
-First, the trace table problem. The fundamental problem is that gdb expects
-to be able to pass in a frame pointer and get that frame's parent. This is
-the purpose of FRAME_CHAIN, a macro whose one parameter is the frame whose
-parent is desired.
-
-This is simply insufficient information with which to compute the preceding
-frame's address. In order to truly appreciate how bad things are, let me
-describe the procedure involved in going from a set of saved registers
-(including the pc), say after a core dump occurs, to the address of the
-preceding frame. I assure you that you'll be shocked by its complexity....
-
-I start off knowing only one thing: the PC of the guy who pushed the last
-stack frame. At the time of a core dump, this is in the saved PC, and for
-other stack frames, it is in register R15 (the return address is put in R15
-by the procedure call sequence). My first goal is to compute the frame
-register number! Not the contents of the frame register, but the register
-number itself, because the RT calling convention lets you change frame
-pointers from procedure to procedure! So, I scan for the trace table, based
-on the PC, and obtain a structure that gives the frame register number (for
-both of our C compilers, this is R13, but it doesn't have to be), the number
-of arguments to the procedure, the space used by the locals and the number of
-registers saved by the procedure prolog. This enables me to take the frame
-pointer, compute the offset of the saved registers off of this frame pointer
-and essentially restore the registers to the state they were at the time this
-procedure was called. R15 now contains *its* callers PC, and I can redo this
-procedure again to back up another frame.
-
-In essence, in order to compute the preceding frame's address, I need more
-than just the current frame's address. I need the full machine state at the
-time of the call, including all of the registers since I don't know which one
-will even turn out to be the frame pointer for the preceding procedure.
-
-This is why I put in the frame caching code. Note that even were I to assume
-that the frame pointer is always in R13 (and this is almost certainly a
-mistake; IBM will surely eventually come up with a compiler where the frame
-pointer is NOT r13), I still either need r15 or the PC (depending upon which
-frame we're dealing with) in order to compute the preceding frame address.
-
-As for the _foo v.s. _.foo issue, there are two problems. First, we can not
-simply ignore _foo symbols, since an _foo symbol is only "junk" if there is
-(possibly later) an _.foo symbol. We might be able to have the processing
-for the "_.foo" change the value in the symbol table placed under the name
-_foo. I do not know if this will work, since I do not know what processing
-is done when a symbol is first encountered, and how much can be done a second
-time. The second problem is that sometimes we need to see what is in the
-variable named _foo, and we can't if it actually refers to _.foo. I
-personally might be willing to live with this loss of functionality, but
-other people probably would not.
-
-As for initialize.h, we simply have no guarantees that IBM won't again change
-the junk they stick in front of procedures in the text segment. Already,
-depending upon which compiler (and we use both), pcc puts a funny string (and
-maybe an integer, too) in front of every procedure, while the metaware hc
-compiler puts a funny string in front of the first procedure in a file, but
-nothing in front of the others. IBM has made it clear to us that they feel
-free to change this at any time, so I feel quite strongly that it would be a
-mistake to assume that they've finished playing around with junk at the start
-of the text. BTW, for all I know, some of these magic text strings disappear
-when you compile with -O. They certainly *should*.
-
- Mike
-
-
-
-\1f
\ No newline at end of file
+++ /dev/null
-X-Trace: MS Version 3.24 on ibm032 host dublin.itc.cmu.edu, by zs01 (623).
-Date: Mon, 25 May 87 10:30:10 edt
-From: zs01#@andrew.cmu.edu (Zalman Stern)
-To: rms@PREP.AI.MIT.EDU (Richard M. Stallman)
-Subject: Re: RT diffs for gdb version 2.1
-Cc: kazar#@andrew.cmu.edu (Mike Kazar), zs01#@andrew.cmu.edu (Zalman Stern)
-In-Reply-To: <8705250107.AA13256@prep.ai.mit.edu>
-
-Richard,
-
-First I will cover the easy questions.
-
-Either of our fixes to environ.c (i.e. with respect to version 1.9 which was
-broken) will work. As I understand it, the intent of init_environ is to fill
-in the environment and leave a little extra space for later additions. I do
-not understand why you would want to only leave the extra space when the
-original size was within 10 elements of the final size.
-
-add_com returning something is probably left over from a fix I put in which
-is superceeded by the "user" class to distinguish command lists from function
-pointers. I should have removed it.
-
-We use csh instead of sh because I got tired of putting up with sh's crapping
-out on large environments.
-
-The change to inferior_args involves putting an explicit initializer of NULL
-on it, and testing it for NULL before freeing it. I guess most
-implementations of free ignore NULL pointers. The one we have on our Sun-2's
-does not.
-
-I can't remember why the alloca's were moved out of the variable
-initializations. It may have been to avoid a compiler problem. In any event,
-ignoring this modification shouldn't hurt.
-
-Now for the hard ones...
-
-The RT is a very different architecture from either a Sun or a VAX. It does
-not use a self-describing stack frame and it does not use the same
-conventions for symbols within object modules. There are also certain
-subtleties to the way it lays out its address space that cause problems. Many
-people at the ITC, including myself, are very impressed with the quality of
-the port Mike did in spite of these obstacles. You may feel that these
-problems are not worth effort. I have attempted to describe the differences
-involved with the RT in case you choose to address them. If not, we are still
-quite happy with the debugger we have and thank you for providing us with the
-code...
-
-Both the 68k family and the VAX have a frame pointer and a stack pointer.
-Using these to values and the information on the stack, one can do a complete
-stack trace. The RT on the other hand has only a stack pointer and a very
-loose concept of a frame pointer. The stack pointer will point just below a
-section of the stack dedicated to the maximum number of outgoing parameters
-minus 4 (the first 4 are in registers). The frame pointer will point
-somewhere in the stack where the compiler has deemed it optimal for
-addressing locals and parameters. There are variable length fields in the
-stack frame, such as the register save areas. In all, the thing looks like
-so:
-
-
-Higher Address
------------------
-
-a) Incoming args 5 through N <---- Previous sp was here
- (part of previous function's stack frame)
-b) Four words to save register passed arguments.
-c) Four words of linkage area (reserved).
-d) 1 word static link.
-e) 1 - 16 words of register save area.
- (Variable length, return address is at the top of this since it was in
-r15)
-f) 0 -8 words of floating point reg. save area. (Variable length)
-g) Local variables (variable length)
-h) Outgoing arguments, words 5 - N <---- Current sp points to bottom of this.
-
-Lower Address
-----------------
-
-These and the stack contents are not enough to get back to the previous stack
-frame because you do not know how far back it is to the register save area.
-The code works because each function has been compiled to know how to pop its
-stack frame (i.e. it has embedded constants). In order to facilitate
-debugging, there is a trace table at the end of each function containing all
-the necessary information. (Namely the offset from the frame pointer to the
-top of the stack frame b in the above diagram) The trace table is located by
-starting at the beginning of the function and looking for the illegal
-instruction sequence 0xdf07df. Since the RT does not have 32bit constants in
-the instruction stream, this actually works. In general, the iar and the
-stack pointer are needed to do frame manipulations. The cache is necessary
-because finding the trace table is very expensive. In short, the machinery
-present in gdb was not up to handling this system, so we added what we
-thought would work. It is interesting to note that similar calling
-conventions are used on other RISC machines, notably the MIPS R2000. If you
-wish to take advantage of these high performance machines, you will have to
-do something like what we have done.
-
-The POP_DUMMY_FRAME problem is related to this. The RT stores return address
-in r15. We can not use this location to store the current iar since we must
-store r15 for later restoration. This rules out using the same function for
-popping both kinds of frames. There is also some hassle involved in getting
-the stack and frame pointers correct, but I think this might be fixed by
-generating an appropriate trace back table for the dummy function.
-
-The other problem we faced is the non-standard use of symbols within object
-modules. The RT defines two symbols for a function foo. There is "_.foo"
-which corresponds to the actual code in the text segment (just like "_foo" on
-a Sun or VAX), and "_foo" which points to the data area for the function in
-the data segment. The first word of the data area contains a pointer to the
-code. A function pointer (i.e. int (*foo)()) points to the data area (_foo),
-not the code (_.foo). This is what the TYPE_CODE_PTR modification in valops.c
-is for. Since both of these symbols are used for certain things, we cannot
-simply remove the dots. This is a bogus IBM feature and we do not like it any
-better than you do. We have to live with it if we want a working debugger.
-
-The "fix" to find_pc_misc function handles a special case on the RT where
-certain functions are in the high end of the address space. The RT uses the
-top 4 bits of an address as a segment number. The text segment is seg. 0, the
-data segment is seg. 1, and the kernel is mapped into seg. 14. Certain kernel
-functions (i.e. floating point functions) are directly callable by user code
-and so occur in the misc_function_vector. I realize this is bogus.
-
-The initialization code will not run because both the RT compilers (pcc and
-hc) output ascii data in the text section preceding the first function. Pcc
-outputs the name of each function before the function. Hc outputs the name of
-the source file at the beginning of the object module. Coding around this may
-be possible, but what is the point? I see no reason for this hackery. I have
-had problems getting it to work not only on the RT, but on the Sun-3. It is
-guaranteed to be a portability headache on many other machines as well. If
-you intend for gdb to only work when compiled with gcc, I suppose you may be
-able to use this method.
-
-I strongly agree with your statements that cleaner solutions are better in
-every way. Unfortunately, we did not write gdb, nor is the system we are
-working with particularly supportive of symbolic debugging. We were faced
-with the task of both figuring out gdb, and hacking our way around a
-contorted system (featuring among other things, a plethora of compiler bugs).
-The fact that our version of gdb is the only working symbolic debugger on the
-IBM RT (despite much effort by IBM) is proof that we have done something
-right. I am willing to discuss what would make this port better. However, it
-is not our intent to maintain or rewrite gdb. We merely wish to use it, and
-if not a terrible hassle, let other people use it too. Mike and I would
-prefer a copyright assignment. I would appreciate it if you would send me
-info on what we need to do.
-
--Z-
-
-
-
+++ /dev/null
-From: zs01#@andrew.cmu.edu (Zalman Stern)
-Date: Sun, 24 May 87 03:20:57 edt
-To: rms@prep.ai.mit.edu
-Subject: RT diffs for gdb version 2.1
-
-Here are the new files, followed by the diffs to old files. The first file below
-is ITCMODS which is my attempt to document some of our changes. Unfortunately,
-it has not been maintained particularly well and notably does not include info
-about our changes to support the HIGH-C compiler. One big change we put in was
-to use a number of initialize routines instead of the "linked list of object
-modules" that is used on other machines. The RT object file format appears to
-have a variable size header before the code, making it very difficult
-(impossible?) to get the initialization stuff to work. If you have any
-questions, don't hesitate to send me mail.
-
--Z-
-
-Only in .: ITCMODS
-
-blockframe.c:
- set_current_frame now takes an extra argument.
- RT specific code for interpreting and caching of trace table entries.
- Added initialize routine.
-
-breakpoint.c:
- Added new_breakpoint_commands flag to prevent incorrect interpretation of command lists containing a continue statement.
- Modified do_breakpoint_commands to know about new_breakpoint_commands.
- Modified clear_breakpoint_commands to set new_breakpoint_commands.
- Added initialize routine.
-
-core.c:
- RT specific code to find the uarea.
- RT specific code to indicate the start of the data segment.
- set_current_frame now takes an extra argument.
- Added initialize routine.
-
-dbxread.c:
- Added support for the Camphor dynamic loading system. (All under #ifdef CAMPHOR).
- Fix for multiple declarations of register variables (i.e. they are declared twice). The fix munges the incorrect declaration (i.e. the one which is not register).
- set_rel_command to set relocation offset for camphor loaded files. (Under #ifdef CAMPHOR).
- add_file_command to append a file's symbols to the current symbol table instead of replacing it. (Under #ifdef CAMPHOR).
- RT specific code to deal with function names being _.foo instead of _foo.
- Added initialize routine.
-
- Feb 8, 1987 Zalman Stern.
- Added test in symbol_file_command to see if file was compiled with debugging. If not print an error message instead of dumping core.
- Added same test in add_file_command and made it run through BZPATH, CLASSPATH, and PATH in that order (Under #ifdef CAMPHOR).
-
-environ.c:
- Fixed error in calculating new size of a reallocated environment.
-
-eval.c:
- Added initialize routine.
-
-expread.y:
- Moved alloca call out of variable initializations.
-
-findvar.c:
- Added initialize routine.
-
-firstfile.c:
- Added main initialization driver routine.
-
-frame.h:
- Added RT specific declarations to hold frame information, and to deal with trace table caching.
-
-ibm032-pinsn.c:
- New file, contains RT disassembler.
-
-ibm032-opcode.h:
- New file, contains RT opcode definitions.
-
-infcmd.c
- Changed code to use csh instead of sh to avoid the anoyance of the environment bug.
- Added initialize routine.
-
-inflow.c:
- Added initialize routine.
-
-infrun.c:
- set_current_frame now takes an extra argument.
- Added some code to deal with stopping in the middle of a camphor link. (Under #ifdef CAMPHOR).
- Added RT specific code to get the return values from the right registers. Replaces code that was there for RT.
- RT specific code to do a "POP_DUMMY_FRAME." Dummy frames are to store more complete state than a normal frame. Makes calling a function in inferior more reliable. Perhaps this should be expanded to other machine types.
- Added initialize routine.
-
- Feb 9, 1987 Zalman Stern.
- Added call to select_frame after popping a stack dummy frame in normal_stop. This fixes the bug where you could not print variables without doing a "frame 0" after printing an expression with a function call in it.
-
-iniitialize.h:
- Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
-
-m-ibm032.h:
- New file, contains RT specific macros and variables.
-
-param.h:
- Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
-
-pinsn.c:
- Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
-
-printcmd.c:
- Moved alloca calls out of variable initialization.
- Added initialize routine.
-
-source.c:
- Added initialize routine.
-
-stack.c:
- Added initialize routine.
-
-symmisc.c:
- Added initialize routine.
-
-symtab.c:
- RT specific code to deal with function names being _.foo instead of _foo.
- Added initialize routine.
-
-utils.c:
- Added comment.
-
-valarith.c:
- Added initialize routine.
-
-valops.c:
- Added initialize routine.
-
-valprint.c:
- Added initialize routine.
-
-values.c:
- Added initialize routine.
-
-Only in .: ibm032-opcode.h
-
-/* The opcode table consists of a 256 element array containing an
- * instruction mnemonic and an instruction type field. This can be
- * indexed directly by the first eight bits of an RT instruction.
- * The instruction type consists of a type field and some flags.
- * In addition to this, there is an ifdef'd out "instruction" table
- * at the end of the file. This is an alphabetical listing of the instructions
- * containing mnemonic, opcode, and type. This is useful for modification
- * purposes. There is also some code in the ifdef to convert the
- * instruction table into an opcode table.
- */
-
-/* Various useful bit masks. */
-#define ibm032_typeMask 0x0f /* Mask to get actual type info out of instruction type. */
-#define LOW4 0x0f
-#define HIGH4 0xf0
-#define LOW16 0x0000ffff
-#define HIGH16 0xffff0000
-#define LOW20 0x000fffff
-#define LOW24 0x00ffffff
-
-/* Instruction types consist of a type id in the low 4 bits and flags above that. */
-
-/* Flags. */
-#define ibm032_conditional 0x10
-#define ibm032_negative 0x20
-
-/* Format types. */
-#define ibm032_JI 0x0 /* Jump immediate. */
-#define ibm032_X 0x1 /* ??? */
-
-/* These next ones are in a special bit position. Do not change their defines. */
-#define ibm032_DS0 0x2 /* Data short with no shift for immediate value. */
-#define ibm032_DS1 0x3 /* Data short with 1 bit shift for immediate value. */
-#define ibm032_DS2 0x4 /* Data short with 2 bit shift for immediate value */
-#define ibm032_DSShiftOffset ibm032_DS0 /* Offset to get shift value from ibm032_DS? types. */
-
-#define ibm032_RR 0x5 /* R format where second argument is a register */
-#define ibm032_RI 0x6 /* R format where second argument is 4 bit immediate. */
-#define ibm032_BI 0x7 /* Branch immediate. */
-#define ibm032_BA 0x8 /* Branch absolute. */
-#define ibm032_D 0x9 /* Data. */
-
-/* What an instruction looks like. */
-struct ibm032_opcode {
- char *mnemonic; /* the name. NULL indicates illegal instruction. */
- int type; /* See above. */
-};
-
-#define MAXOPCODES 256 /* Pretty well hardwired. */
-
-#ifndef BUILDTABLE
-/* The actual data. */
-struct ibm032_opcode ibm032_opcodes[] = {
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"j%s", ibm032_JI | ibm032_conditional},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"stcs", ibm032_DS0},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sths", ibm032_DS1},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"sts", ibm032_DS2},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lcs", ibm032_DS0},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"lhas", ibm032_DS1},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"cas", ibm032_X},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {"ls", ibm032_DS2},
- {0, 0},
- {0, 0},
- {0, 0},
- {0, 0},
- {0, 0},
- {0, 0},
- {0, 0},
- {0, 0},
- {"b%s", ibm032_BI | ibm032_conditional | ibm032_negative},
- {"b%sx", ibm032_BI | ibm032_conditional | ibm032_negative},
- {"bala", ibm032_BA},
- {"balax", ibm032_BA},
- {"bali", ibm032_BI},
- {"balix", ibm032_BI},
- {"b%s", ibm032_BI | ibm032_conditional},
- {"b%sx", ibm032_BI | ibm032_conditional},
- {"ais", ibm032_RI},
- {"inc", ibm032_RI},
- {"sis", ibm032_RI},
- {"dec", ibm032_RI},
- {"cis", ibm032_RI},
- {"clrsb", ibm032_RI},
- {"mfs", ibm032_RR},
- {"setsb", ibm032_RI},
- {"clrbu", ibm032_RI},
- {"clrbl", ibm032_RI},
- {"setbu", ibm032_RI},
- {"setbl", ibm032_RI},
- {"mftbiu", ibm032_RI},
- {"mftbil", ibm032_RI},
- {"mttbiu", ibm032_RI},
- {"mttbil", ibm032_RI},
- {"sari", ibm032_RI},
- {"sari16", ibm032_RI},
- {0, 0},
- {0, 0},
- {"lis", ibm032_RI},
- {0, 0},
- {0, 0},
- {0, 0},
- {"sri", ibm032_RI},
- {"sri16", ibm032_RI},
- {"sli", ibm032_RI},
- {"sli16", ibm032_RI},
- {"srpi", ibm032_RI},
- {"srpi16", ibm032_RI},
- {"slpi", ibm032_RI},
- {"slpi16", ibm032_RI},
- {"sar", ibm032_RR},
- {"exts", ibm032_RR},
- {"sf", ibm032_RR},
- {"cl", ibm032_RR},
- {"c", ibm032_RR},
- {"mts", ibm032_RR},
- {"d", ibm032_RR},
- {0, 0},
- {"sr", ibm032_RR},
- {"srp", ibm032_RR},
- {"sl", ibm032_RR},
- {"slp", ibm032_RR},
- {"mftb", ibm032_RR},
- {"tgte", ibm032_RR},
- {"tlt", ibm032_RR},
- {"mttb", ibm032_RR},
- {"svc", ibm032_D},
- {"ai", ibm032_D},
- {"cal16", ibm032_D},
- {"oiu", ibm032_D},
- {"oil", ibm032_D},
- {"nilz", ibm032_D},
- {"nilo", ibm032_D},
- {"xil", ibm032_D},
- {"cal", ibm032_D},
- {"lm", ibm032_D},
- {"lha", ibm032_D},
- {"ior", ibm032_D},
- {"ti", ibm032_D},
- {"l", ibm032_D},
- {"lc", ibm032_D},
- {"tsh", ibm032_D},
- {"lps", ibm032_D},
- {"aei", ibm032_D},
- {"sfi", ibm032_D},
- {"cli", ibm032_D},
- {"ci", ibm032_D},
- {"niuz", ibm032_D},
- {"niuo", ibm032_D},
- {"xiu", ibm032_D},
- {"cau", ibm032_D},
- {"stm", ibm032_D},
- {"lh", ibm032_D},
- {"iow", ibm032_D},
- {"sth", ibm032_D},
- {"st", ibm032_D},
- {"stc", ibm032_D},
- {0, 0},
- {"abs", ibm032_RR},
- {"a", ibm032_RR},
- {"s", ibm032_RR},
- {"o", ibm032_RR},
- {"twoc", ibm032_RR},
- {"n", ibm032_RR},
- {"m", ibm032_RR},
- {"x", ibm032_RR},
- {"b%sr", ibm032_RR | ibm032_conditional | ibm032_negative},
- {"b%srx", ibm032_RR | ibm032_conditional | ibm032_negative},
- {0, 0},
- {"lhs", ibm032_RR},
- {"balr", ibm032_RR},
- {"balrx", ibm032_RR},
- {"b%sr", ibm032_RR | ibm032_conditional},
- {"b%srx", ibm032_RR | ibm032_conditional},
- {"wait", ibm032_RR},
- {"ae", ibm032_RR},
- {"se", ibm032_RR},
- {"ca16", ibm032_RR},
- {"onec", ibm032_RR},
- {"clz", ibm032_RR},
- {0, 0},
- {0, 0},
- {0, 0},
- {"mc03", ibm032_RR},
- {"mc13", ibm032_RR},
- {"mc23", ibm032_RR},
- {"mc33", ibm032_RR},
- {"mc30", ibm032_RR},
- {"mc31", ibm032_RR},
- {"mc32", ibm032_RR},
-};
-
-#else
-struct ibm032_opcode ibm032_opcodes[MAXOPCODES];
-
-struct ibm032_instruction {
- char *mnemonic; /* Mnemonic for this instruction */
- char opcode; /* Numerical value of opcode. */
- int type; /* This instructions format. */
-};
-
-struct ibm032_instruction ibm032_instructions[] =
-{
- {"a", 0xe1, ibm032_RR},
- {"abs", 0xe0, ibm032_RR},
- {"ae", 0xf1, ibm032_RR},
- {"aei", 0xd1, ibm032_D},
- {"ai", 0xc1, ibm032_D},
- {"ais", 0x90, ibm032_RI},
- {"bala", 0x8a, ibm032_BA},
- {"balax", 0x8b, ibm032_BA},
- {"bali", 0x8c, ibm032_BI},
- {"balix", 0x8d, ibm032_BI},
- {"balr", 0xec, ibm032_RR},
- {"balrx", 0xed, ibm032_RR},
- {"b%s", 0x8e, ibm032_BI | ibm032_conditional},
- {"b%sr", 0xee, ibm032_RR | ibm032_conditional},
- {"b%srx", 0xef, ibm032_RR | ibm032_conditional},
- {"b%sx", 0x8f, ibm032_BI | ibm032_conditional},
- {"b%s", 0x88, ibm032_BI | ibm032_conditional | ibm032_negative},
- {"b%sr", 0xe8, ibm032_RR | ibm032_conditional | ibm032_negative},
- {"b%srx", 0xe9, ibm032_RR | ibm032_conditional | ibm032_negative},
- {"b%sx", 0x89, ibm032_BI | ibm032_conditional | ibm032_negative},
- {"c", 0xb4, ibm032_RR},
- {"cal", 0xc8, ibm032_D},
- {"cal16", 0xc2, ibm032_D},
- {"cas", 0x60, ibm032_X},
- {"cau", 0xd8, ibm032_D},
- {"ca16", 0xf3, ibm032_RR},
- {"ci", 0xd4, ibm032_D},
- {"cis", 0x94, ibm032_RI},
- {"cl", 0xb3, ibm032_RR},
- {"cli", 0xd3, ibm032_D},
- {"clrbl", 0x99, ibm032_RI},
- {"clrbu", 0x98, ibm032_RI},
- {"clrsb", 0x95, ibm032_RI},
- {"clz", 0xf5, ibm032_RR},
- {"d", 0xb6, ibm032_RR},
- {"dec", 0x93, ibm032_RI},
- {"exts", 0xb1, ibm032_RR},
- {"inc", 0x91, ibm032_RI},
- {"ior", 0xcb, ibm032_D},
- {"iow", 0xdb, ibm032_D},
-
- {"j%s", 0x08, ibm032_JI | ibm032_conditional},
- {"j%s", 0x00, ibm032_JI | ibm032_conditional | ibm032_negative},
-
- {"l", 0xcd, ibm032_D},
- {"lc", 0xce, ibm032_D},
- {"lcs", 0x40, ibm032_DS0},
- {"lh", 0xda, ibm032_D},
- {"lha", 0xca, ibm032_D},
- {"lhas", 0x50, ibm032_DS1},
- {"lhs", 0xeb, ibm032_RR},
- {"lis", 0xa4, ibm032_RI},
- {"lm", 0xc9, ibm032_D},
- {"lps", 0xd0, ibm032_D},
- {"ls", 0x70, ibm032_DS2},
- {"m", 0xe6, ibm032_RR},
- {"mc03", 0xf9, ibm032_RR},
- {"mc13", 0xfa, ibm032_RR},
- {"mc23", 0xfb, ibm032_RR},
- {"mc33", 0xfc, ibm032_RR},
- {"mc30", 0xfd, ibm032_RR},
- {"mc31", 0xfe, ibm032_RR},
- {"mc32", 0xff, ibm032_RR},
- {"mfs", 0x96, ibm032_RR},
- {"mftb", 0xbc, ibm032_RR},
- {"mftbil", 0x9d, ibm032_RI},
- {"mftbiu", 0x9c, ibm032_RI},
- {"mts", 0xb5, ibm032_RR},
- {"mttb", 0xbf, ibm032_RR},
- {"mttbil", 0x9f, ibm032_RI},
- {"mttbiu", 0x9e, ibm032_RI},
- {"n", 0xe5, ibm032_RR},
-
- {"nilo", 0xc6, ibm032_D},
- {"nilz", 0xc5, ibm032_D},
- {"niuo", 0xd6, ibm032_D},
- {"niuz", 0xd5, ibm032_D},
- {"o", 0xe3, ibm032_RR},
- {"oil", 0xc4, ibm032_D},
- {"oiu", 0xc3, ibm032_D},
- {"onec", 0xf4, ibm032_RR},
- {"s", 0xe2, ibm032_RR},
- {"sar", 0xb0, ibm032_RR},
- {"sari", 0xa0, ibm032_RI},
- {"sari16", 0xa1, ibm032_RI},
- {"se", 0xf2, ibm032_RR},
- {"setbl", 0x9b, ibm032_RI},
- {"setbu", 0x9a, ibm032_RI},
- {"setsb", 0x97, ibm032_RI},
- {"sf", 0xb2, ibm032_RR},
-
- {"sfi", 0xd2, ibm032_D},
-
- {"sis", 0x92, ibm032_RI},
- {"sl", 0xba, ibm032_RR},
- {"sli", 0xaa, ibm032_RI},
- {"sli16", 0xab, ibm032_RI},
- {"slp", 0xbb, ibm032_RR},
- {"slpi", 0xae, ibm032_RI},
- {"slpi16", 0xaf, ibm032_RI},
- {"sr", 0xb8, ibm032_RR},
- {"sri", 0xa8, ibm032_RI},
- {"sri16", 0xa9, ibm032_RI},
- {"srp", 0xb9, ibm032_RR},
- {"srpi", 0xac, ibm032_RI},
- {"srpi16", 0xad, ibm032_RI},
-
- {"st", 0xdd, ibm032_D},
-
- {"stc", 0xde, ibm032_D},
- {"stcs", 0x10, ibm032_DS0},
- {"sth", 0xdc, ibm032_D},
- {"sths", 0x20, ibm032_DS1},
- {"stm", 0xd9, ibm032_D},
- {"sts", 0x30, ibm032_DS2},
- {"svc", 0xc0, ibm032_D},
- {"tgte", 0xbd, ibm032_RR},
- {"ti", 0xcc, ibm032_D},
- {"tlt", 0xbe, ibm032_RR},
- {"tsh", 0xcf, ibm032_D},
- {"twoc", 0xe4, ibm032_RR},
- {"wait", 0xf0, ibm032_RR},
- {"x", 0xe7, ibm032_RR},
- {"xil", 0xc7, ibm032_D},
- {"xiu", 0xd7, ibm032_D}
-};
-
-/* Code to generate the packed opcode table from the instructions table. */
-
-#include <stdio.h>
-
-char *typeNames[] = {
- "ibm032_JI",
- "ibm032_X",
- "ibm032_DS0",
- "ibm032_DS1",
- "ibm032_DS2",
- "ibm032_RR",
- "ibm032_RI",
- "ibm032_BI",
- "ibm032_BA",
- "ibm032_D"
-};
-
-main()
-{
-
- int i, j, opcode, type;
-
- for (j = (sizeof(ibm032_instructions) / sizeof(struct ibm032_instruction)); j >= 0; j--) {
- opcode = ibm032_instructions[j].opcode;
- switch (ibm032_instructions[j].type & ibm032_typeMask) {
- case ibm032_JI:
- i = 7;
- break;
- case ibm032_X:
- case ibm032_DS0:
- case ibm032_DS1:
- case ibm032_DS2:
- i = 15;
- break;
- case ibm032_RR:
- case ibm032_RI:
- default:
- i = 0;
- break;
- }
- for (;i >= 0; i--) {
- ibm032_opcodes[opcode + i].mnemonic = ibm032_instructions[j].mnemonic;
- ibm032_opcodes[opcode + i].type = ibm032_instructions[j].type;
- }
- }
-
- printf("struct ibm032_opcode ibm032_opcodes[] = {\n");
- for ( j = 0; j < 256; j++) {
- type = ibm032_opcodes[j].type;
- if (ibm032_opcodes[j].mnemonic != NULL)
- printf(" {\"%s\",\t\t%s%s%s},\n", ibm032_opcodes[j].mnemonic,
- typeNames[type & ibm032_typeMask],
- (type & ibm032_conditional) ? " | ibm032_conditional" : "",
- (type & ibm032_negative) ? " | ibm032_negative" : "");
- else
- printf(" {0,\t\t\t0},\n");
- }
- printf("};\n");
-}
-#endif /* BUILDTABLE */
-
-Only in .: ibm032-pinsn.c
-
-/* Print ibm032 instructions for GDB, the GNU debugger.
- Copyright (C) 1986 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include <stdio.h>
-
-#include "defs.h"
-#include "param.h"
-#include "symtab.h"
-#include "ibm032-opcode.h"
-
-/* ibm032 instructions are never longer than this many bytes. */
-#define MAXLEN 4
-
-extern char *reg_names[];
-
-static char *mapCondition();
-
-\f
-/* Print the ibm032 instruction at address MEMADDR in debugged memory,
- on STREAM. Returns length of the instruction, in bytes. */
-
-int
-print_insn (memaddr, stream)
- CORE_ADDR memaddr;
- FILE *stream;
-{
- unsigned char buffer[MAXLEN];
- int opcodeIndex, instructionBits, type;
- char *mnemonic;
-
- read_memory (memaddr, buffer, MAXLEN);
- instructionBits = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; /* Get it into an int for easy use. */
-
- if ((mnemonic = ibm032_opcodes[opcodeIndex = buffer[0]].mnemonic) == NULL)
- {
- fprintf (stream, "0%o", (instructionBits & HIGH16) >> 16);
- return 2;
- }
- type = ibm032_opcodes[opcodeIndex].type;
- if (!(type & ibm032_conditional)) {
- fprintf (stream, "%s", mnemonic);
-
- switch (type) {
-
- int displacement; /* Used for sign extensions. */
- char *sign;
-
- case ibm032_X:
- fprintf(stream, "\t%s, %s(%s)", reg_names[buffer[0] & LOW4], (buffer[1] & HIGH4) ? (reg_names[(buffer[1] & HIGH4) >> 4]) : "", reg_names[buffer[1] & LOW4]);
- return 2;
- case ibm032_DS0:
- case ibm032_DS1:
- case ibm032_DS2:
- fprintf(stream, "\t%s, %x", reg_names[(buffer[1] & HIGH4) >> 4], (buffer[0] & LOW4) << (ibm032_opcodes[opcodeIndex].type - ibm032_DSShiftOffset)); /* Hacked to shift imediate field. */
- if (buffer[1] & LOW4)
- fprintf(stream, "(%s)", reg_names[buffer[1] & LOW4]);
- return 2;
- case ibm032_RR:
- fprintf(stream, "\t%s, %s", reg_names[(buffer[1] & HIGH4) >> 4], reg_names[buffer[1] & 0x0f]);
- return 2;
- case ibm032_RI:
- fprintf(stream, "\t%s, %x", reg_names[(buffer[1] & HIGH4) >> 4], buffer[1] & LOW4);
- return 2;
- case ibm032_BI:
- fprintf(stream, "\t%s, ", reg_names[(buffer[1] & HIGH4) >> 4]);
- displacement = (instructionBits & LOW20);
- if ((displacement & (1 << 19)) != 0) /* Cover sign extension. */
- displacement |= 0xfff00000;
- print_address(memaddr + (displacement * 2), stream); /* Need sign extension. */
- return 4;
- case ibm032_BA:
- print_address((instructionBits & LOW24) & ~1, stream);
- return 4;
- case ibm032_D:
- displacement = (instructionBits & LOW16);
- if ((displacement & (1 << 15)) != 0) { /* Cover sign extension. */
- displacement = - (displacement | 0xffff0000);
- sign = "-";
- }
- else
- sign = "";
- fprintf(stream, "\t%s, %s, %s%x", reg_names[(buffer[1] & HIGH4) >> 4], reg_names[buffer[1] & LOW4], sign, displacement);
- return 4;
- }
- }
- else { /* Conditional branches are hacked. */
- switch (type & 0x0f) {
-
- int displacement;
-
- case ibm032_JI:
- fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, buffer[0] & LOW4));
- putc('\t', stream);
- print_address((buffer[1] << 1) + memaddr, stream);
- return 2;
- case ibm032_BI:
- fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[1] & HIGH4) >> 4));
- putc('\t', stream);
- displacement = (instructionBits & LOW20);
- if ((displacement & (1 << 19)) != 0) /* Cover sign extension. */
- displacement |= 0xfff00000;
- print_address((displacement * 2) + memaddr, stream);
- return 4;
- case ibm032_RR:
- fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[1] & HIGH4) >> 4));
- fprintf(stream, "\t%s", reg_names[buffer[1] & LOW4]);
- return 2;
- }
- }
-}
-
-/* Converts a 4 bit "conditional specifier" into a semi-meaningful name. */
-static char *mapCondition(negative, conditionBits)
- int conditionBits;
-{
-
- char *condition;
-
- if (negative)
- switch (conditionBits) {
- case 0x8:
- condition = "";
- break;
- case 0x9:
- condition = "ge";
- break;
- case 0xa:
- condition = "ne";
- break;
- case 0xb:
- condition = "le";
- break;
- case 0xc:
- condition = "nc";
- break;
- case 0xd: /* Reserved. */
- condition = "notbogus";
- break;
- case 0xe:
- condition = "no";
- break;
- case 0xf:
- condition = "ntb";
- break;
- default:
- condition = "notbogus";
- break;
- }
- else
- switch (conditionBits) {
- case 0x8:
- condition = "nop";
- break;
- case 0x9:
- condition = "lt";
- break;
- case 0xa:
- condition = "eq";
- break;
- case 0xb:
- condition = "gt";
- break;
- case 0xc:
- condition = "c";
- break;
- case 0xd: /* Reserved. */
- condition = "bogus";
- break;
- case 0xe:
- condition = "o";
- break;
- case 0xf:
- condition = "tb";
- break;
- default:
- condition = "bogus";
- break;
- }
- return condition;
-}
-
-Only in .: m-ibm032.h
-
-/* Parameters for execution on an IBM RT, for GDB, the GNU debugger.
- Copyright (C) 1986 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-/* Define this if the C compiler puts an underscore at the front
- of external names before giving them to the linker. */
-
-#define NAMES_HAVE_UNDERSCORE
-
-/* Offset from address of function to start of its code.
- Zero on most machines. */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
-
-#define SKIP_PROLOGUE(pc) \
-{ register int op = read_memory_integer (pc, 1) & 0x00ff; \
- if (op == 0xd9) { \
- pc += 4; \
- op = read_memory_integer (pc, 2); \
- if ((op & 0xff00) == 0xc100) { /* pcc prolog add r1, number */ \
- pc += 4; \
- op = read_memory_integer (pc, 1) & 0x00ff; \
- if (op == 0x6e) { /* cas r14, 0 */ \
- pc += 2; \
- op = read_memory_integer (pc, 2) & 0xffff; \
- if (op == 0xc8d1) pc += 4; /* cal r13, junk(r1) */ \
- } \
- } \
- else if ((op & 0xffff) == 0x6e00) { /* hc prolog cas r14, 0 */ \
- pc += 4; \
- op = read_memory_integer(pc, 1) & 0xff; \
- if (op == 0x6d) { /* cas r13 junk, probably */ \
- pc += 2; \
- op = read_memory_integer(pc, 2) & 0xffff; \
- if (op == 0xc811) pc += 4; /* cal r1, foo(r1) */ \
- } \
- } \
- } \
- while (1) { \
- /* now watch for st, sth, stc, and short versions thereof, cas instructions and exts */ \
- /* which are all used to store the parameters from r2-r5 onto the stack or into reg vars */ \
- op = read_memory_integer (pc, 2); \
- if ((op & 0xff00) == 0x3000 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
- else if ((op & 0xff00) == 0x2300 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
- else if ((op & 0xff00) == 0x1b00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
- else if ((op & 0xff00) == 0x6c00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
- else if ((op & 0xff00) == 0xb100) pc += 2; /* extend sign */ \
- else if ((op & 0xff00) == 0xdd00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 4; \
- else break; \
- } \
-}
-
-/* Immediately after a function call, return the saved pc.
- Can't go through the frames for this because on some machines
- the new frame is not set up until the new function executes
- some instructions. */
-
-#define SAVED_PC_AFTER_CALL(frame) \
-read_register (15)
-
-/* This is the amount to subtract from u.u_ar0
- to get the offset in the core file of the register values. */
-
-#define KERNEL_U_ADDR (0x20000000 - NBPG * (UPAGES))
-
-/* Address of end of stack space. */
-
-/* extra page is for the "red zone" */
-#define STACK_END_ADDR (0x20000000 - NBPG * (UPAGES+1))
-
-/* Stack grows downward. */
-
-#define INNER_THAN <
-
-/* Sequence of bytes for breakpoint instruction. */
-
-#define BREAKPOINT {0xbd, 0x00}
-
-/* Amount PC must be decremented by after a breakpoint.
- This is often the number of bytes in BREAKPOINT
- but not always. */
-
-#define DECR_PC_AFTER_BREAK 0
-
-/* Nonzero if instruction at PC is a return instruction. */
-
-#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) & 0x00ff == 0xc9)
-
-/* Return 1 if P points to an invalid floating point value. */
-
-#define INVALID_FLOAT(p) 0 /* Just a first guess; not checked */
-
-/* Say how long (ordinary) registers are. */
-
-#define REGISTER_TYPE long
-
-/* Number of machine registers */
-
-#define NUM_REGS 18
-
-/* Initializer for an array of names of registers.
- There should be NUM_REGS strings in this initializer. */
-
-#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "iar", "mq"}
-
-/* Register numbers of various important registers.
- Note that some of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and some are "phony" register numbers which are too large
- to be actual register numbers as far as the user is concerned
- but do serve to get the desired values when passed to read_register. */
-
-#define FP_REGNUM 13 /* Contains address of executing stack frame */
-#define SP_REGNUM 1 /* Contains address of top of stack */
-#define PS_REGNUM 17 /* Contains processor status */
-#define PC_REGNUM 16 /* Contains program counter */
-
-#define REGISTER_U_ADDR(addr, blockend, regno) \
-{ addr = blockend + regno * 4; }
-
-/* Total amount of space needed to store our copies of the machine's
- register state, the array `registers'. */
-#define REGISTER_BYTES (NUM_REGS*4)
-
-/* Index within `registers' of the first byte of the space for
- register N. */
-
-#define REGISTER_BYTE(N) ((N) * 4)
-
-/* Number of bytes of storage in the actual machine representation
- for register N. On the vax, all regs are 4 bytes. */
-
-#define REGISTER_RAW_SIZE(N) 4
-
-/* Number of bytes of storage in the program's representation
- for register N. On the vax, all regs are 4 bytes. */
-
-#define REGISTER_VIRTUAL_SIZE(N) 4
-
-/* Largest value REGISTER_RAW_SIZE can have. */
-
-#define MAX_REGISTER_RAW_SIZE 4
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 4
-
-/* Nonzero if register N requires conversion
- from raw format to virtual format. */
-
-#define REGISTER_CONVERTIBLE(N) 0
-
-/* Convert data from raw format for register REGNUM
- to virtual format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), 4);
-
-/* Convert data from virtual format for register REGNUM
- to raw format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), 4);
-
-/* Return the GDB type object for the "standard" data type
- of data in register N. */
-
-#define REGISTER_VIRTUAL_TYPE(N) builtin_type_int
-\f
-/* Describe the pointer in each stack frame to the previous stack frame
- (its caller). */
-
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer.
-
- FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
- and produces the nominal address of the caller frame.
-
- However, if FRAME_CHAIN_VALID returns zero,
- it means the given frame is the outermost one and has no caller.
- In that case, FRAME_CHAIN_COMBINE is not used. */
-
-/* In the case of the Sun, the frame's nominal address
- is the address of a 4-byte word containing the calling frame's address. */
-
-#define FRAME_CHAIN(thisframe) (rt_prev_frame(thisframe))
-
-#define FRAME_CHAIN_VALID(chain, thisframe) \
- (chain >= 0x10000000 && chain < 0x20000000)
-
-#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-
-/* Define other aspects of the stack frame. */
-
-#define FRAME_SAVED_PC(frame) (rt_frame_reg(frame, 15))
-
-#define FRAME_ARGS_ADDRESS(fi) (rt_frame_args(fi.frame))
-
-#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
-
-/* Return number of args passed to a frame.
- Can return -1, meaning no way to tell. */
-
-#define FRAME_NUM_ARGS(val, fi) \
-{register struct rt_frame *tf; \
- tf = get_cached_frame(fi.frame); \
- val = -1; \
- if (tf) val = tf->nParms;\
-}
-
-/* Return number of bytes at start of arglist that are not really args. */
-
-#define FRAME_ARGS_SKIP 0
-
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
-
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
-{ register int regnum; \
- register struct rt_frame *tf; \
- register CORE_ADDR next_addr; \
- bzero (&(frame_saved_regs), sizeof (frame_saved_regs)); \
- tf = get_cached_frame((frame_info).frame); \
- if (tf) { \
- for(regnum = tf->firstReg; regnum < 16; regnum++) { \
- (frame_saved_regs).regs[regnum] = tf->firstRLoc+ 4*(regnum - tf->firstReg); \
- } \
- } \
-}
-
-\f
-/* Things needed for making the inferior call functions. */
-
-/* Push an empty stack frame, to record the current PC, etc. */
-
-#define PUSH_DUMMY_FRAME \
-{ register CORE_ADDR sp = read_register (SP_REGNUM);\
- register int regnum; \
- sp = push_word (sp, read_register (PC_REGNUM)); \
- for (regnum = 15; regnum >= 0; regnum--) \
- sp = push_word (sp, read_register (regnum)); \
- write_register (FP_REGNUM, sp+64); \
- write_register (SP_REGNUM, sp); }
-
-/* discard special frame pushed by PUSH_DUMMY_FRAME */
-#define POP_DUMMY_FRAME \
- {register CORE_ADDR sp; \
- register int regnum; \
- sp = read_register(FP_REGNUM)-64; \
- for(regnum = 0; regnum < 16;regnum++) { \
- write_register(regnum, read_memory_integer(sp, 4)); \
- sp += 4; \
- } \
- /* now get the pc */ \
- write_register(PC_REGNUM, read_memory_integer(sp, 4)); \
- sp += 4; \
- }
-
-/* Discard from the stack the innermost frame, restoring all registers. */
-/* THIS ROUTINE DOES NOT SET R1 (SP_REGNUM) CORRECTLY */
-/* REALLY MUST CONSULT TRACE TBL TO FIND OUT FRAME SIZE */
-#define POP_FRAME \
-{ register CORE_ADDR fp = read_register (FP_REGNUM); \
- register int regnum; \
- register struct rt_frame *tf; \
- tf = (struct rt_frame *) get_cached_frame(fp); \
- if (tf) { \
- for(regnum = tf->firstReg; regnum < 16; regnum++) { \
- write_register(regnum, \
- read_memory_integer (tf->firstRLoc + 4*(regnum-tf->firstReg), 4) \
- ); \
- } \
- write_register(PC_REGNUM, read_register(15)); \
- write_register(SP_REGNUM, tf->firstRLoc + 4*(16-tf->firstReg) + 36); \
- } \
-}
-
-/* This sequence of words is the instructions
- ls r2,0(r1) 2 bytes pick up args
- ls r3,4(r1) 2 bytes pick up args
- ls r4,8(r1) 2 bytes pick up args
- ls r5,c(r1) 2 bytes pick up args
- cal r1,16(r1) 4 bytes fix up ap (==sp)
- cal16 r15,<low> 4 bytes do call
- oiu r15,<high>(r15) 4
- lr r0,r15 2
- ls r15,0(r15) 2
- balr r15 2
- bpt 2 get back to gdb
- <4 byte trace table> 4
-
-This is 16 bytes.
-*/
-
-#define CALL_DUMMY {0x70217131, 0x72417351, 0xc8110010, 0xc2f06969, \
- 0xc3ff6969, 0x60f070ff, 0xecffbd00, 0xdf7fdf00}
-
-#define CALL_DUMMY_LENGTH 32
-
-#define CALL_DUMMY_START_OFFSET 0
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
-
-#define FIX_CALL_DUMMY(dummyname, fun, nargs) \
-{ *((short *)(((char *)dummyname)+14)) = fun&0xffff; \
-*((short *)(((char *)dummyname)+18)) = (fun>>16)&0xffff; \
-}
-\f
-/* Interface definitions for kernel debugger KDB. */
-
-/* Map machine fault codes into signal numbers.
- First subtract 0, divide by 4, then index in a table.
- Faults for which the entry in this table is 0
- are not handled by KDB; the program's own trap handler
- gets to handle then. */
-
-#define FAULT_CODE_ORIGIN 0
-#define FAULT_CODE_UNITS 4
-#define FAULT_TABLE \
-{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
- 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
- 0, 0, 0, 0, 0, 0, 0, 0, \
- SIGILL }
-
-/* Start running with a stack stretching from BEG to END.
- BEG and END should be symbols meaningful to the assembler.
- This is used only for kdb, which we do not support. */
-
-#define INIT_STACK(beg, end) \
-{ }
-
-/* Push the frame pointer register on the stack. */
-#define PUSH_FRAME_PTR \
-{ }
-
-/* Copy the top-of-stack to the frame pointer register. */
-#define POP_FRAME_PTR \
-{ }
-
-/* After KDB is entered by a fault, push all registers
- that GDB thinks about (all NUM_REGS of them),
- so that they appear in order of ascending GDB register number.
- The fault code will be on the stack beyond the last register. */
-
-#define PUSH_REGISTERS \
-{ }
-
-/* Assuming the registers (including processor status) have been
- pushed on the stack in order of ascending GDB register number,
- restore them and return to the address in the saved PC register. */
-
-#define POP_REGISTERS \
-{ }
-
-Only in .: m-ibm032init.h
-
-/* This is how the size of an individual .o file's text segment
- is rounded on a sun. */
-
-#define FILEADDR_ROUND(addr) ((addr + 3) & -4)
-
-diff -c ../../gnu/gdb/blockframe.c ./blockframe.c
-*** ../../gnu/gdb/blockframe.c Sat Apr 4 22:06:18 1987
---- ./blockframe.c Mon Apr 27 01:06:06 1987
-***************
-*** 53,62 ****
- }
-
- void
-! set_current_frame (frame)
- FRAME frame;
- {
- current_frame = frame;
- }
-
- /* Return the frame that called FRAME.
---- 53,67 ----
- }
-
- void
-! set_current_frame (frame, validp)
- FRAME frame;
-+ int validp;
- {
- current_frame = frame;
-+ #ifdef ibm032
-+ if (validp)
-+ recache_frames();
-+ #endif
- }
-
- /* Return the frame that called FRAME.
-***************
-*** 291,301 ****
- CORE_ADDR pc;
- {
- register int i;
-
- /* Note that the last thing in the vector is always _etext. */
- for (i = 0; i < misc_function_count; i++)
- {
-! if (pc < misc_function_vector[i].address)
- return i - 1;
- }
- return -1;
---- 296,309 ----
- CORE_ADDR pc;
- {
- register int i;
-+ register long j;
-
- /* Note that the last thing in the vector is always _etext. */
- for (i = 0; i < misc_function_count; i++)
- {
-! if ((j = misc_function_vector[i].address) < 0)
-! continue;
-! if (pc < j)
- return i - 1;
- }
- return -1;
-***************
-*** 325,333 ****
---- 333,610 ----
- }
- }
-
-+ #ifdef ibm032
-+ /* RT frame format:
-+ arg 3 these are not really here, but are in regs
-+ arg 2
-+ arg 1
-+ arg 0
-+ resvd 20 bytes
-+ rn to r15 saved regs
-+ floating regs (at first assume 0 bytes, fix later)
-+ locals
-+
-+ N.B. r13 points 64 bytes below the end of the locals.
-+ */
-+
-+ /*
-+ * Routine for ibm032 stack trace. Called after a new frame has been set. Do an entire stack
-+ * trace, and squirrel away the information. We need to do this since the ibm032 (rt) does
-+ * not have enough info in a known place off of the frame ptr (r13) to do anything useful.
-+ * Instead, one also requires the pc, and can then perform various operations to find
-+ * out how that procedure built its frame, and thus, to decode it. However, since this is
-+ * fairly slow, we only do it after a set_current_frame operation has been performed.
-+ */
-+
-+ #define rtTTSize 50
-+ static struct rtTTCache {
-+ CORE_ADDR lbound; /* lowest address so far known as using this trace table */
-+ CORE_ADDR ttaddr; /* address of the last '0xdf' in the trace table */
-+ char ttype; /* type of the trace table -- 0 == unused */
-+ } ttcache[rtTTSize];
-+ short ttptr = 0;
-+
-+ #define rtSize 50
-+ static struct rt_frame rtFrames[rtSize];
-+ static int rtCount;
-+ static CORE_ADDR rt_next_frame, rt_next_pc;
-+
-+ static struct rtTTCache *ttfind (addr)
-+ CORE_ADDR addr; {
-+ register int i;
-+ register struct rtTTCache *tp;
-+ for(i=0,tp=ttcache;i<rtTTSize;i++,tp++) {
-+ if (addr >= tp->lbound && addr <= tp->ttaddr) return tp;
-+ }
-+ return 0;
-+ }
-+
-+ static ttadd(lowaddr, ttaddr, type)
-+ register CORE_ADDR lowaddr, ttaddr;
-+ char type; {
-+ register struct rtTTCache *tp;
-+ if (tp = ttfind(ttaddr)) {
-+ /* possibly increase the bound on this cache element */
-+ if (lowaddr < tp->lbound) tp->lbound = lowaddr;
-+ }
-+ else {
-+ /* add a new element */
-+ tp = &ttcache[ttptr++];
-+ tp->lbound = lowaddr;
-+ tp->ttaddr = ttaddr;
-+ tp->ttype = type;
-+ if (ttptr >= rtTTSize) ttptr = 0; /* keep it in bounds */
-+ }
-+ }
-+
-+ /* this routine scans for a trace table, and returns 4 bytes: 0 0 <n params> <first saved reg> */
-+ rt_num_regs (pc, tf)
-+ register struct rt_frame *tf;
-+ CORE_ADDR pc; {
-+ register state = 0;
-+ register long newpc = pc;
-+ register int tc;
-+ short nparms, firstreg;
-+ short ttype;
-+ short optx;
-+ long offset;
-+ char offtype;
-+ struct rtTTCache *tp;
-+ CORE_ADDR frame;
-+
-+ frame = tf->frame;
-+ /* first see if it is in our ttcache */
-+ if (tp = ttfind(pc)) {
-+ state = 3;
-+ ttype = tp->ttype;
-+ newpc = tp->ttaddr;
-+ }
-+ else {
-+ /* state machine to look for 'df' 'xx' 'df' */
-+ while (1) {
-+ tc = read_memory_integer(newpc, 2);
-+ if (state == 0 && (tc&0xff00) == 0xdf00) {
-+ state = 1;
-+ ttype = tc & 0xff;
-+ }
-+ else if (state == 1 && (tc & 0xff00) == 0xdf00) {
-+ state = 3;
-+ break;
-+ }
-+ else state = 0;
-+ if (newpc - pc > 20000) break;
-+ newpc += 2;
-+ }
-+ if (state == 3) ttadd(pc, newpc, ttype); /* add to cache */
-+ }
-+ if (state != 3) {
-+ printf("No trace table for pc %x, making one up.\n", pc);
-+ tf->nParms = 0;
-+ tf->firstReg = 12;
-+ tf->firstRLoc = frame+64;
-+ rt_next_pc = read_memory_integer(frame+64+12, 4);
-+ rt_next_frame = read_memory_integer(frame+64+4, 4);
-+ return 0;
-+ }
-+ /* otherwise newpc is pointing at the last 'df' in the trace table */
-+ else if (ttype == 3) {
-+ /* funny trace table found by OBSERVATION (not doc) to be in program prolog */
-+ return -1; /* special value checked by recache_frames */
-+ }
-+ else if (ttype == 2) {
-+ /* assembly: no registers were saved */
-+ tf->nParms = 0;
-+ tf->firstReg = 16;
-+ tf->firstRLoc = 0;
-+ rt_next_pc = read_register(15); /* where we go back to */
-+ rt_next_frame = frame;
-+ tf->frame -= 100; /* hack to eliminate duplicate tags */
-+ return 0;
-+ }
-+ else if (ttype == 0x7f) {
-+ /* special machine state frame saved by STACK_DUMMY */
-+ tf->nParms = 0;
-+ tf->firstReg = 16;
-+ tf->firstRLoc = 0;
-+ rt_next_pc = read_memory_integer(frame + 64 - 64, 4);
-+ rt_next_frame = read_memory_integer(frame -64 + 13*4, 4);
-+ return 0;
-+ }
-+ else {
-+ /* C program, I hope */
-+ nparms = (read_memory_integer(newpc+2, 1) >> 4) & 0x0f;
-+ firstreg = ((tc=read_memory_integer(newpc+1, 1)) >> 4) & 0x0f;
-+ optx = ((tc&4)? 1 : 0); /* flags says if floating registers described */
-+ offtype = read_memory_integer(newpc+optx+3, 1) & 0xff;
-+ if ((offtype & 0xc0) == 0) {
-+ /* 6 bits of local offset */
-+ offset = offtype & 0x3f;
-+ }
-+ else if ((offtype & 0xc0) == 0x40) {
-+ /* 14 bits of local offset */
-+ offset = (offtype & 0x3f) << 8;
-+ offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
-+ }
-+ else if ((offtype & 0xc0) == 0x80) {
-+ /* 22 bits of local offset */
-+ offset = (offtype & 0x3f) << 8;
-+ offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
-+ offset <<= 8;
-+ offset += (read_memory_integer(newpc+optx+5, 1) & 0xff);
-+ }
-+ else if ((offtype & 0xc0) == 0xc0) {
-+ /* 30 bits of local offset */
-+ offset = (offtype & 0x3f) << 8;
-+ offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
-+ offset <<= 8;
-+ offset += (read_memory_integer(newpc+optx+5, 1) & 0xff);
-+ offset <<= 8;
-+ offset += (read_memory_integer(newpc+optx+6, 1) & 0xff);
-+ }
-+ offset <<= 2;
-+ tf->nParms = nparms;
-+ tf->firstReg = firstreg;
-+ tf->firstRLoc = frame /* initial frame location */
-+ + offset /* to top of frame */
-+ - 36 /* pascal static link, incomings args and linkage */
-+ - (4*(16-firstreg)); /* space used by general regs */
-+ rt_next_pc = read_memory_integer(tf->firstRLoc + 4*(15-firstreg), 4);
-+ rt_next_frame = read_memory_integer(tf->firstRLoc + 4*(13-firstreg), 4);
-+ return 0;
-+ }
-+ }
-+
-+ recache_frames() {
-+ register long i, j;
-+ long pc;
-+ CORE_ADDR curfp;
-+ struct rt_frame *tf;
-+
-+ pc = read_pc();
-+ curfp = current_frame;
-+ rtCount = 0;
-+ /* these next special cases can only occur with frame #0; others can't make calls
-+ in these intermediate states.
-+ */
-+ /* if pc points at br or brx, we're doing a return, so set the pc to the target */
-+ i=read_memory_integer(pc, 2);
-+ if ((i & 0xfe00) == 0xe800) {
-+ /* we're looking at a br or brx instruction */
-+ pc = read_register(i&0x0f);
-+ }
-+ /* also, if pc points at d9xx or c111 we're in the middle of a frame push, and should
-+ use r15 for the pc.
-+ */
-+ if ((i & 0xff00) == 0xd900 || (i & 0xffff) == 0xc111) {
-+ pc = read_register(15);
-+ }
-+ while (1) {
-+ if (curfp <= 0x10000000 || curfp >= 0x20000000) break;
-+ if (pc > 0x20000000) break;
-+ /* otherwise try to add a new frame structure */
-+ if (rtCount >= rtTTSize) break;
-+ tf = &rtFrames[rtCount++];
-+ tf->frame = curfp;
-+ tf->pc = pc;
-+ i = rt_num_regs(pc, tf);
-+ if (i<0) { /* exceptional values */
-+ rtCount--; /* last frame was bogus */
-+ break;
-+ }
-+ /* now setup for next iteration */
-+ pc = rt_next_pc;
-+ curfp = rt_next_frame;
-+ }
-+ }
-+
-+ struct rt_frame *get_cached_frame(aframe)
-+ CORE_ADDR aframe; {
-+ register int i;
-+ for(i=0;i<rtCount;i++) {
-+ if (rtFrames[i].frame == aframe) return &rtFrames[i];
-+ }
-+ return 0;
-+ }
-+
-+ long rt_prev_frame(frame)
-+ register CORE_ADDR frame; {
-+ register int i;
-+ for(i=0;i<rtCount-1;i++) {
-+ if (rtFrames[i].frame == frame) return rtFrames[i+1].frame;
-+ }
-+ return 0;
-+ }
-+
-+ long rt_frame_reg(frame, reg)
-+ CORE_ADDR frame;
-+ register long reg; {
-+ register struct rt_frame *tf;
-+ tf = get_cached_frame(frame);
-+ if (tf == 0) return 0;
-+ if (tf->firstReg > reg) return 0; /* didn't save this one! */
-+ return read_memory_integer(tf->firstRLoc + 4 * (reg - tf->firstReg), 4);
-+ }
-+
-+ long rt_frame_args(frame)
-+ CORE_ADDR frame; {
-+ register struct rt_frame *tf;
-+ tf = get_cached_frame(frame);
-+ if (!tf) return 0;
-+ return tf->firstRLoc + 20 + 4*(16 - tf->firstReg);
-+ }
-+ #endif
-+
-+ blockinitialize() {initialize();}
-+
- static
- initialize ()
- {
-+ #ifdef ibm032
-+ #ifdef CAMPHOR
-+ add_com ("recache-frames", class_stack, recache_frames,
-+ "Tell debugger to recompute PC/RT stack frame cache\n");
-+ #endif
-+ #endif
- }
-
- END_FILE
-diff -c ../../gnu/gdb/breakpoint.c ./breakpoint.c
-*** ../../gnu/gdb/breakpoint.c Sat Apr 4 22:22:44 1987
---- ./breakpoint.c Sun Apr 26 23:02:20 1987
-***************
-*** 94,99 ****
---- 94,100 ----
- of last breakpoint hit. */
-
- struct command_line *breakpoint_commands;
-+ char new_breakpoint_commands = 0; /* Zalman Stern, ITC 1/12/1987 */
-
- START_FILE
-
-***************
-*** 203,210 ****
- {
- execute_command (breakpoint_commands->line, 0);
- /* If command was "cont", breakpoint_commands is 0 now. */
-! if (breakpoint_commands)
- breakpoint_commands = breakpoint_commands->next;
- }
- clear_momentary_breakpoints ();
- }
---- 204,213 ----
- {
- execute_command (breakpoint_commands->line, 0);
- /* If command was "cont", breakpoint_commands is 0 now. */
-! if (breakpoint_commands && !new_breakpoint_commands) /* Zalman Stern, ITC 1/12/1987 */
- breakpoint_commands = breakpoint_commands->next;
-+ else /* Zalman Stern, ITC 1/12/1987 */
-+ new_breakpoint_commands = 0; /* Zalman Stern, ITC 1/12/1987 */
- }
- clear_momentary_breakpoints ();
- }
-***************
-*** 215,220 ****
---- 218,225 ----
- void
- clear_breakpoint_commands ()
- {
-+ if (breakpoint_commands != 0) /* Zalman Stern, ITC 1/12/1987 */
-+ new_breakpoint_commands = 1; /* Zalman Stern, ITC 1/12/1987 */
- breakpoint_commands = 0;
- breakpoint_auto_delete (0);
- }
-***************
-*** 921,926 ****
---- 926,933 ----
- struct cmd_list_element *enablelist;
-
- extern struct cmd_list_element *cmdlist;
-+
-+ breakinitialize() {initialize();}
-
- static
- initialize ()
-diff -c ../../gnu/gdb/command.c ./command.c
-*** ../../gnu/gdb/command.c Sat Apr 4 22:24:07 1987
---- ./command.c Sat Apr 25 17:18:15 1987
-***************
-*** 94,100 ****
- You are forbidden to forbid anyone else to use, share and improve
- what you give them. Help stamp out software-hoarding! */
-
--
- #include "command.h"
- #include <stdio.h>
-
---- 94,99 ----
-***************
-*** 388,394 ****
- {
- if (nfound > 1 && allow_unknown >= 0)
- {
-! *p = 0;
- ambbuf[0] = 0;
- for (c = list; c; c = c->next)
- if (!strncmp (*line, c->name, p - *line))
---- 387,393 ----
- {
- if (nfound > 1 && allow_unknown >= 0)
- {
-! *p = 0;
- ambbuf[0] = 0;
- for (c = list; c; c = c->next)
- if (!strncmp (*line, c->name, p - *line))
-diff -c ../../gnu/gdb/core.c ./core.c
-*** ../../gnu/gdb/core.c Sat Apr 4 22:27:23 1987
---- ./core.c Mon Apr 27 13:20:47 1987
-***************
-*** 163,172 ****
- int reg_offset;
-
- /* 4.2bsd-style core dump */
- val = myread (corechan, &u, sizeof u);
- if (val < 0)
-! perror_with_name (filename);
- data_start = exec_data_start;
- data_end = data_start + NBPG * u.u_dsize;
- stack_start = stack_end - NBPG * u.u_ssize;
- data_offset = NBPG * UPAGES;
---- 163,180 ----
- int reg_offset;
-
- /* 4.2bsd-style core dump */
-+ #ifdef ibm032
-+ /* on ibm032, uarea is at the far end of the u pages */
-+ lseek(corechan, UPAGES*NBPG - sizeof(u), 0);
-+ #endif
- val = myread (corechan, &u, sizeof u);
- if (val < 0)
-! perror_with_name (execfile);
-! #ifdef ibm032
-! data_start = 0x10000000;
-! #else
- data_start = exec_data_start;
-+ #endif
- data_end = data_start + NBPG * u.u_dsize;
- stack_start = stack_end - NBPG * u.u_ssize;
- data_offset = NBPG * UPAGES;
-***************
-*** 208,214 ****
- corefile = concat (dirname, "/", filename);
- }
-
-! set_current_frame (read_register (FP_REGNUM));
- select_frame (get_current_frame (), 0);
- validate_files ();
- }
---- 216,222 ----
- corefile = concat (dirname, "/", filename);
- }
-
-! set_current_frame (read_register (FP_REGNUM), 1);
- select_frame (get_current_frame (), 0);
- validate_files ();
- }
-***************
-*** 523,528 ****
---- 531,539 ----
-
- #endif /* not NEW_SUN_CORE */
- \f
-+
-+ coreinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/dbxread.c ./dbxread.c
-*** ../../gnu/gdb/dbxread.c Sat Apr 4 22:29:54 1987
---- ./dbxread.c Fri May 15 15:52:24 1987
-***************
-*** 28,33 ****
---- 28,36 ----
- #include "initialize.h"
- #include "symtab.h"
- #include "param.h"
-+ #ifdef CAMPHOR
-+ #include "value.h"
-+ #endif
-
- static void add_symbol_to_list ();
- static void read_dbx_symtab ();
-***************
-*** 89,94 ****
---- 92,109 ----
- int prev_line_number;
- };
-
-+ /* When dealing with dynamically loaded objects, the symbol table in the sym file
-+ does not match where we actually load the files. Thus, gdb has to relocate those
-+ symbols during dbxread. This is only used by the camphor support code, and
-+ probably should be under an ifdef camphor. */
-+
-+ struct dlreloc
-+ {
-+ long text;
-+ long data;
-+ long bss;
-+ } dlreloc;
-+
- static struct subfile *subfiles;
-
- static struct subfile *current_subfile;
-***************
-*** 1015,1020 ****
---- 1030,1037 ----
- register int i, nbl;
- register struct blockvector *bv;
- register struct block *b;
-+ int j;
-+ struct symbol *ts1, *ts2;
-
- for (s = symtab_list; s; s = s->next)
- {
-***************
-*** 1025,1034 ****
---- 1042,1238 ----
- b = BLOCKVECTOR_BLOCK (bv, i);
- qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
- sizeof (struct symbol *), compare_symbols);
-+ /* Register parms have two decls, but the register one is the only one of interest */
-+ /* So, trash the name of the bad one, since binary srch could get either. Yucko. */
-+ /* doing name this way enables symbol freeing code to keep working */
-+ for(j=1;j<BLOCK_NSYMS(b);j++)
-+ {
-+ ts1 = BLOCK_SYM(b,j-1);
-+ ts2 = BLOCK_SYM(b, j);
-+ if (SYMBOL_NAMESPACE(ts1) == VAR_NAMESPACE
-+ && SYMBOL_NAMESPACE(ts2) == VAR_NAMESPACE
-+ && strcmp(SYMBOL_NAME(ts1), SYMBOL_NAME(ts2)) == 0)
-+ {if (SYMBOL_CLASS(ts1) == LOC_REGISTER)
-+ {SYMBOL_CLASS(ts2) = LOC_REGISTER;
-+ SYMBOL_TYPE(ts2) = SYMBOL_TYPE(ts1);
-+ SYMBOL_VALUE(ts2) = SYMBOL_VALUE(ts1);
-+ }
-+ else if (SYMBOL_CLASS(ts2) == LOC_REGISTER )
-+ {SYMBOL_CLASS(ts1) = LOC_REGISTER;
-+ SYMBOL_TYPE(ts1) = SYMBOL_TYPE(ts2);
-+ SYMBOL_VALUE(ts1) = SYMBOL_VALUE(ts2);
-+ }
-+ #ifdef notdef
-+ else printf("Check out def of symbol %s\n", SYMBOL_NAME(ts1));
-+ #endif
-+ }
-+ }
- }
- }
- }
- \f
-+
-+ #ifdef CAMPHOR
-+ set_rel_command(exp)
-+ char *exp;
-+ {
-+ struct expression *expr = (struct expression *) parse_c_expression (exp);
-+ register value val;
-+ register long temp;
-+ register struct cleanup *old_chain
-+ = make_cleanup (free_current_contents, &expr);
-+ val = evaluate_expression (expr);
-+ temp = value_as_long (val);
-+ dlreloc.text = dlreloc.data = dlreloc.bss = temp;
-+ printf("Relocation for all segs set to %x.\n", temp);
-+ do_cleanups (old_chain);
-+ }
-+
-+ void
-+ add_file_command (name)
-+ char *name;
-+ {
-+ register int desc;
-+ struct exec hdr;
-+ struct nlist *nlist;
-+ char *stringtab;
-+ long buffer;
-+ register int val;
-+ extern void close ();
-+ struct cleanup *old_chain;
-+ int in_this_dir = 1;
-+ struct symtab *symtab_temp;
-+
-+ dont_repeat ();
-+
-+ if (name == 0)
-+ error_no_arg ("file to add symbols from");
-+
-+ if (symtab_list && !query ("Add more symbols from \"%s\"? ", name))
-+ error ("Not confirmed.");
-+
-+ if (symfile)
-+ free (symfile);
-+ symfile = 0;
-+
-+ desc = open (name, 0);
-+ if (desc < 0)
-+ {
-+ if ((desc = openp (getenv ("BZPATH"), name, 0, 0)) < 0)
-+ if ((desc = openp (getenv ("CLASSPATH"), name, 0, 0)) < 0)
-+ desc = openp (getenv ("PATH"), name, 0, 0);
-+
-+ in_this_dir = 0;
-+ }
-+ if (desc < 0)
-+ perror_with_name (name);
-+
-+ old_chain = make_cleanup (close, desc);
-+
-+ val = myread (desc, &hdr, sizeof hdr);
-+ if (val < 0)
-+ perror_with_name (name);
-+
-+ if (N_BADMAG (hdr))
-+ error ("File \"%s\" not in executable format.", name);
-+
-+ if (hdr.a_syms == 0)
-+ {
-+ free_all_symtabs (); /* check this */
-+ return;
-+ }
-+
-+ /* Now read the string table, all at once. */
-+ val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
-+ if (val < 0)
-+ perror_with_name (name);
-+ val = myread (desc, &buffer, sizeof buffer);
-+ if (val < 0)
-+ perror_with_name (name);
-+ stringtab = (char *) alloca (buffer);
-+ bcopy (&buffer, stringtab, sizeof buffer);
-+ val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
-+ if (val < 0)
-+ perror_with_name (name);
-+
-+ #ifdef READ_GDB_SYMSEGS
-+ /* That puts us at the symsegs. Read them. */
-+ symseg_chain = read_symsegs (desc, name);
-+ hash_symsegs ();
-+ #else
-+ /* Where people are using the 4.2 ld program, must not check for
-+ symsegs, because that ld puts randonm garbage at the end of
-+ the output file and that would trigger an error message. */
-+ symseg_chain = 0;
-+ #endif
-+
-+ /* Position to read the symbol table. Do not read it all at once. */
-+ val = lseek (desc, N_SYMOFF (hdr), 0);
-+ if (val < 0)
-+ perror_with_name (name);
-+
-+ printf ("Reading symbol data from %s...", name);
-+ fflush (stdout);
-+
-+ init_misc_functions ();
-+ make_cleanup (discard_misc_bunches, 0);
-+ init_header_files ();
-+ make_cleanup (free_header_files, 0);
-+
-+ /* Remember symtab_list to check if the added file had any dbx info in it. */
-+ symtab_temp = symtab_list;
-+
-+ /* Now that the symbol table data of the executable file are all in core,
-+ process them and define symbols accordingly. Closes desc. */
-+
-+ read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
-+
-+ if (symtab_list == symtab_temp) {
-+ printf("\n%s not compiled with -g, debugging posibilities are limited.\n", name);
-+ fflush(stdout);
-+ }
-+ else {
-+
-+ /* Sort symbols alphabetically within each block. */
-+
-+ sort_syms ();
-+
-+ /* Go over the misc functions and install them in vector. */
-+
-+ condense_misc_bunches ();
-+
-+ /* Make a default for file to list. */
-+
-+ select_source_symtab (symtab_list);
-+ }
-+
-+ do_cleanups (old_chain);
-+
-+ /* Free the symtabs made by read_symsegs, but not their contents,
-+ which have been copied into symtabs on symtab_list. */
-+ while (symseg_chain)
-+ {
-+ register struct symtab *s = symseg_chain->next;
-+ free (symseg_chain);
-+ symseg_chain = s;
-+ }
-+
-+ if (in_this_dir && name[0] != '/')
-+ {
-+ char dirname[MAXPATHLEN];
-+
-+ getwd (dirname);
-+ symfile = concat (dirname, "/",
-+ savestring (name, strlen (name)));
-+ }
-+ else
-+ symfile = savestring (name, strlen (name));
-+
-+ printf ("done.\n");
-+ fflush (stdout);
-+ }
-+ #endif
-+
- /* This is the symbol-file command. Read the file, analyze its symbols,
- and add a struct symtab to symtab_list. */
-
-***************
-*** 1047,1052 ****
---- 1251,1263 ----
-
- dont_repeat ();
-
-+ #ifdef CAMPHOR
-+ /* this command does not deal with automatically relocated stuff */
-+ dlreloc.text = 0;
-+ dlreloc.data = 0;
-+ dlreloc.bss = 0;
-+ #endif
-+
- if (name == 0)
- error_no_arg ("file to read symbols from");
-
-***************
-*** 1130,1151 ****
-
- read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
-
- /* Sort symbols alphabetically within each block. */
-
-! sort_syms ();
-
- /* Go over the misc functions and install them in vector. */
-
-! condense_misc_bunches ();
-
- /* Don't allow char * to have a typename (else would get caddr_t.) */
-
-! TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
-
- /* Make a default for file to list. */
-
-! select_source_symtab (symtab_list);
-
- symfile = savestring (name, strlen (name));
-
- do_cleanups (old_chain);
---- 1341,1372 ----
-
- read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
-
-+ /* Check to make sure file was compiled with -g. */
-+
-+ if (symtab_list == NULL) {
-+ printf("\n%s not compiled with -g, debugging posibilities are limited.\n", name);
-+ fflush(stdout);
-+ }
-+ else {
-+
- /* Sort symbols alphabetically within each block. */
-
-! sort_syms ();
-
- /* Go over the misc functions and install them in vector. */
-
-! condense_misc_bunches ();
-
- /* Don't allow char * to have a typename (else would get caddr_t.) */
-
-! TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
-
- /* Make a default for file to list. */
-
-! select_source_symtab (symtab_list);
-
-+ }
-+
- symfile = savestring (name, strlen (name));
-
- do_cleanups (old_chain);
-***************
-*** 1204,1209 ****
---- 1425,1440 ----
- {
- fread (&buf, sizeof buf, 1, stream);
- namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : 0;
-+ #ifdef CAMPHOR
-+ if ((buf.n_type & N_TYPE) == N_UNDF) {
-+ /* don't screw around with undefined symbols */
-+ }
-+ else {
-+ if ((buf.n_type & N_TYPE) == N_TEXT) buf.n_value += dlreloc.text;
-+ else if ((buf.n_type & N_TYPE) == N_DATA) buf.n_value += dlreloc.data;
-+ else if ((buf.n_type & N_TYPE) == N_BSS) buf.n_value += dlreloc.bss;
-+ }
-+ #endif
- if (buf.n_type & N_STAB)
- process_one_symbol (buf.n_type, buf.n_desc,
- buf.n_value, namestring);
-***************
-*** 1356,1361 ****
---- 1587,1596 ----
- }
- }
- \f
-+ #ifdef ibm032
-+ static char hcState; /* two different, incompatible compilers for the RT */
-+ #endif
-+
- static void
- process_one_symbol (type, desc, value, name)
- int type, desc;
-***************
-*** 1363,1369 ****
- char *name;
- {
- register struct context_stack *new;
-!
- /* Something is wrong if we see real data before
- seeing a source file name. */
-
---- 1598,1633 ----
- char *name;
- {
- register struct context_stack *new;
-! char tname[256];
-! /* Now, there are two compilers for the RT, and they are seriously incompatible.
-! pcc is just like normal c compilers: stabs for a block occur before the LBRAC
-! stab for that same block. Thus this code squirrels them away in the context
-! and when the RBRAC is hit, restores local_symbols as of the time the LBRAC
-! was encountered, and adds these symbosl to the block that just ended.
-!
-! However, with the HC compiler, those symbols occur *after* the LBRAC symbol
-! declaring the block's start. Totally incompatible, of course. One expects no
-! less from IBM. For hc compiled programs, we use the symbols in local_symbols
-! *before* the RBRAC command pops the context stack.
-!
-! Amazingly enough, when we complained to IBM/Palo Alto about this incompatibility,
-! they claimed that Mark Linton (original author of dbx) liked the new way better, and
-! that he didn't even know that pcc used a different order. Sorta explains some things
-! about dbx, n'est-ce pas? Furthermore, of course, IBM doesn't want to change
-! either pcc or hc.
-!
-! Anyway, hc and pcc compiled .o files often co-exist in programs. How do we
-! tell which is which? Stupid heuristic which doesn't work with programs
-! with no top-level locals or parameters: after seeing a function's start, if we see
-! an LBRAC before seeing a variable, then we are using hc, otherwise it is pcc.
-! Stupid heuristics are better than none, so we use it.
-!
-! The variable hcState is used to keep track of this crap.
-! 0 ==> saw function symbol
-! 1 ==> saw lbrac in state 0, this is hc.
-! 2 ==> saw symbol in state 0, this is pcc.
-! */
-!
- /* Something is wrong if we see real data before
- seeing a source file name. */
-
-***************
-*** 1384,1389 ****
---- 1648,1656 ----
- also the end of the lexical context for the previous function. */
- new = context_stack;
- within_function = 1;
-+ #ifdef ibm032
-+ hcState = 0;
-+ #endif
- if (new)
- {
- /* Make a block for the local symbols within. */
-***************
-*** 1400,1406 ****
---- 1667,1679 ----
- new->locals = 0;
- new->old_blocks = pending_blocks;
- new->start_addr = value;
-+ #ifdef ibm032
-+ strcpy(tname, ".");
-+ strcat(tname, name);
-+ new->name = define_symbol(value, tname);
-+ #else
- new->name = define_symbol (value, name);
-+ #endif
- local_symbols = 0;
- break;
-
-***************
-*** 1407,1412 ****
---- 1680,1688 ----
- case N_LBRAC:
- /* This "symbol" just indicates the start of an inner lexical
- context within a function. */
-+ #ifdef ibm032
-+ if (hcState == 0) hcState = 1;
-+ #endif
- new = (struct context_stack *) xmalloc (sizeof (struct context_stack));
- new->depth = desc;
- new->next = context_stack;
-***************
-*** 1422,1430 ****
- /* This "symbol" just indicates the end of an inner lexical
- context that was started with N_RBRAC. */
- new = context_stack;
- if (new == 0 || desc != new->depth)
- error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
-- local_symbols = new->locals;
- context_stack = new->next;
- /* If this is not the outermost LBRAC...RBRAC pair in the
- function, its local symbols preceded it, and are the ones
---- 1698,1711 ----
- /* This "symbol" just indicates the end of an inner lexical
- context that was started with N_RBRAC. */
- new = context_stack;
-+ #ifdef ibm032
-+ if (hcState == 2) /* pcc */
-+ local_symbols = new->locals;
-+ #else
-+ local_symbols = new->locals;
-+ #endif
- if (new == 0 || desc != new->depth)
- error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
- context_stack = new->next;
- /* If this is not the outermost LBRAC...RBRAC pair in the
- function, its local symbols preceded it, and are the ones
-***************
-*** 1443,1448 ****
---- 1724,1733 ----
- new->start_addr + last_source_start_addr,
- value + last_source_start_addr);
- }
-+ #ifdef ibm032
-+ if (hcState == 1 && context_stack->next) /* hc */
-+ local_symbols = new->locals; /* now we get them */
-+ #endif
- free (new);
- break;
-
-***************
-*** 1493,1498 ****
---- 1778,1786 ----
- break;
-
- default:
-+ #ifdef ibm032
-+ if (hcState == 0) hcState = 2;
-+ #endif
- if (name)
- define_symbol (value, name);
- }
-***************
-*** 1553,1558 ****
---- 1841,1849 ----
- Dbx data never actually contains 'l'. */
- case 'l':
- SYMBOL_CLASS (sym) = LOC_LOCAL;
-+ #ifdef ibm032
-+ if (hcState == 1) value += 1000000; /* temporary hack until rel 3 pcc matches hc */
-+ #endif
- SYMBOL_VALUE (sym) = value;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- add_symbol_to_list (sym, &local_symbols);
-***************
-*** 1572,1577 ****
---- 1863,1875 ----
- add_symbol_to_list (sym, &local_symbols);
- break;
-
-+ case 'R':
-+ SYMBOL_CLASS (sym) = LOC_REGISTER;
-+ SYMBOL_VALUE (sym) = value;
-+ SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-+ add_symbol_to_list (sym, &local_symbols);
-+ break;
-+
- case 'S':
- /* Static symbol at top level of file */
- SYMBOL_CLASS (sym) = LOC_STATIC;
-***************
-*** 1616,1622 ****
- break;
-
- default:
-! error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
- }
- return sym;
- }
---- 1914,1928 ----
- break;
-
- default:
-! printf ("Unknown symbol-type code '%c' in dbx symbol table, assuming local.\n", deftype);
-! SYMBOL_CLASS (sym) = LOC_LOCAL;
-! #ifdef ibm032
-! if (hcState == 1) value += 1000000; /* temporary hack until rel 3 pcc matches hc */
-! #endif
-! SYMBOL_VALUE (sym) = value;
-! SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-! add_symbol_to_list (sym, &local_symbols);
-! break;
- }
- return sym;
- }
-***************
-*** 1741,1746 ****
---- 2047,2056 ----
- (*pp) += 5;
- else if (!strncmp (*pp, "r(0,1);0;", 9))
- (*pp) += 9;
-+ #if 1
-+ else if ((**pp == 'r') && (!strncmp(*pp + 2, ";0;", 3)))
-+ (*pp) += 5;
-+ #endif
- else break;
-
- TYPE_CODE (type) = TYPE_CODE_ARRAY;
-***************
-*** 1980,1986 ****
- rather than -128 which is what I would like.
- So use n1 != 0 to prevent char from being taken as unsigned. */
-
-! else if (n2 == 0 && n1 == 1)
- {
- /* an unsigned type */
- if (n3 == (1 << (8 * sizeof (int))))
---- 2290,2296 ----
- rather than -128 which is what I would like.
- So use n1 != 0 to prevent char from being taken as unsigned. */
-
-! if (n2 == 0)
- {
- /* an unsigned type */
- if (n3 == (1 << (8 * sizeof (int))))
-***************
-*** 1989,1994 ****
---- 2299,2306 ----
- return builtin_type_unsigned_short;
- if (n3 == (1 << (8 * sizeof (char))))
- return builtin_type_unsigned_char;
-+ if (n3 == (1 << (8 * sizeof (char) - 1)))
-+ return builtin_type_char;
- }
- else
- {
-***************
-*** 2002,2007 ****
---- 2314,2321 ----
- if (n3 == (1 << (8 * sizeof (char) - 1)))
- return builtin_type_char;
- }
-+ if (n2 == 0 && n3 == 1)
-+ return builtin_type_void;
- error ("Invalid symbol data: range type spec %s at symtab pos %d.",
- errp - 1, symnum);
- }
-***************
-*** 2033,2040 ****
---- 2347,2364 ----
-
- /* Read the digits, as far as they go. */
-
-+ #if 0 /* Yet another "Compiler sucks" fix. */
- while ((c = *p++) >= '0' && c <= '9')
-+ #else
-+ while (((c = *p++) >= '0' && c <= '9') || ((end != '\n') && (c == '\n')))
-+ #endif
- {
-+ #if 1
-+ if (c == '\n') {
-+ printf("Ignoring bogus newline in stabs entry. Your compiler should be fixed.\n");
-+ continue;
-+ }
-+ #endif
- n *= 10;
- n += c - '0';
- }
-***************
-*** 2050,2060 ****
---- 2374,2392 ----
- return n * sign;
- }
-
-+ dbxinitialize() {initialize();}
-+
- static
- initialize ()
- {
- symfile = 0;
-
-+ #ifdef CAMPHOR
-+ add_com ("add-file", class_files, add_file_command,
-+ "Add a new symbol table (in dbx format) from file FILE.");
-+ add_com("set-rel", class_files, set_rel_command,
-+ "Set relocation for add-file command to NUMBER.");
-+ #endif
- add_com ("symbol-file", class_files, symbol_file_command,
- "Load symbol table (in dbx format) from executable file FILE.");
- }
-diff -c ../../gnu/gdb/environ.c ./environ.c
-*** ../../gnu/gdb/environ.c Sat Apr 4 22:31:16 1987
---- ./environ.c Sun Apr 26 23:48:05 1987
-***************
-*** 129,135 ****
-
- if (e->allocated < i)
- {
-! e->allocated = max (i, e->allocated + 10);
- e->vector = (char **) xrealloc (e->vector,
- (e->allocated + 1) * sizeof (char *));
- }
---- 129,136 ----
-
- if (e->allocated < i)
- {
-! e->allocated = i + 10;
- e->vector = (char **) xrealloc (e->vector,
- (e->allocated + 1) * sizeof (char *));
- }
-diff -c ../../gnu/gdb/eval.c ./eval.c
-*** ../../gnu/gdb/eval.c Sat Apr 4 22:32:36 1987
---- ./eval.c Mon Apr 27 00:01:27 1987
-***************
-*** 546,551 ****
---- 546,553 ----
- }
- }
- \f
-+ evalinitialize() {initialize();}
-+
- static
- initialize ()
- { }
-diff -c ../../gnu/gdb/expread.y ./expread.y
-*** ../../gnu/gdb/expread.y Sat Apr 4 22:35:27 1987
---- ./expread.y Sun Apr 26 23:56:51 1987
-***************
-*** 650,655 ****
---- 650,656 ----
- ;
- else
- {
-+ /*N.B. error does a longjmp, so we do not have to worry about storage */
- err_copy = (char *) alloca (olen + 1);
- bcopy (lexptr, err_copy, olen);
- err_copy[olen] = 0;
-***************
-*** 945,953 ****
- {
- register int len = sizeof (struct expression) +
- expr->nelts * sizeof (union exp_element);
-! register struct expression *temp
-! = (struct expression *) alloca (len);
- register int inpos = expr->nelts, outpos = 0;
-
- /* Copy the original expression into temp. */
- bcopy (expr, temp, len);
---- 946,955 ----
- {
- register int len = sizeof (struct expression) +
- expr->nelts * sizeof (union exp_element);
-! register struct expression *temp;
- register int inpos = expr->nelts, outpos = 0;
-+
-+ temp = (struct expression *) alloca(len);
-
- /* Copy the original expression into temp. */
- bcopy (expr, temp, len);
-diff -c ../../gnu/gdb/findvar.c ./findvar.c
-*** ../../gnu/gdb/findvar.c Sat Apr 4 22:36:38 1987
---- ./findvar.c Mon Apr 27 00:01:44 1987
-***************
-*** 359,364 ****
---- 359,366 ----
- return value_cast (lookup_pointer_type (SYMBOL_TYPE (var)),
- value_from_long (builtin_type_long, addr));
- }
-+ \f
-+ findinitialize() {initialize();}
-
- static
- initialize ()
-diff -c ../../gnu/gdb/firstfile.c ./firstfile.c
-*** ../../gnu/gdb/firstfile.c Sat Apr 4 22:37:06 1987
---- ./firstfile.c Mon Apr 27 00:02:06 1987
-***************
-*** 125,130 ****
---- 125,152 ----
- static initialize_dummy_1 ();
- static initialize_dummy_2 ();
-
-+ initialize_all_files() {
-+ blockinitialize();
-+ breakinitialize();
-+ coreinitialize();
-+ dbxinitialize();
-+ evalinitialize();
-+ findinitialize();
-+ infcmdinitialize();
-+ inflowinitialize();
-+ infruninitialize();
-+ symmiscinitialize();
-+ symtabinitialize();
-+ valarithinitialize();
-+ valopsinitialize();
-+ valprintinitialize();
-+ valuesinitialize();
-+ printcmdinitialize();
-+ sourceinitialize();
-+ stackinitialize();
-+ }
-+
-+ #if 0
- initialize_all_files ()
- {
- initialize_next_file ((char *) initialize_dummy_2
-***************
-*** 148,153 ****
---- 170,176 ----
- initialize_dummy_2 ()
- {
- }
-+ #endif
-
- /* This makes the function initialize_next_file. */
-
-diff -c ../../gnu/gdb/frame.h ./frame.h
-*** ../../gnu/gdb/frame.h Sat Apr 4 22:37:22 1987
---- ./frame.h Mon Apr 27 00:02:14 1987
-***************
-*** 20,25 ****
---- 20,35 ----
-
- /* Note that frame.h requires param.h! */
-
-+ #ifdef ibm032
-+ struct rt_frame {
-+ CORE_ADDR frame; /* frame address */
-+ CORE_ADDR pc; /* pc we called from */
-+ CORE_ADDR firstRLoc; /* loc'n of first saved general reg */
-+ short nParms; /* number of parameters to this frame */
-+ short firstReg; /* the reg stored at 64(fp) */
-+ };
-+ #endif
-+
- #define FRAME CORE_ADDR
-
- struct frame_info
-***************
-*** 62,64 ****
---- 72,77 ----
- extern struct block *get_selected_block ();
- extern struct symbol *get_frame_function ();
- extern struct symbol *get_pc_function ();
-+ #ifdef ibm032
-+ extern struct rt_frame *get_cached_frame();
-+ #endif
-diff -c ../../gnu/gdb/infcmd.c ./infcmd.c
-*** ../../gnu/gdb/infcmd.c Sat Apr 4 22:47:22 1987
---- ./infcmd.c Mon Apr 27 00:07:53 1987
-***************
-*** 39,45 ****
- /* String containing arguments to give to the program,
- with a space added at the front. Just a space means no args. */
-
-! static char *inferior_args;
-
- /* Pid of our debugged inferior, or 0 if no inferior now. */
-
---- 39,45 ----
- /* String containing arguments to give to the program,
- with a space added at the front. Just a space means no args. */
-
-! static char *inferior_args = NULL;
-
- /* Pid of our debugged inferior, or 0 if no inferior now. */
-
-***************
-*** 112,119 ****
- set_args_command (args)
- char *args;
- {
-! free (inferior_args);
-! if (!args) args = "";
- inferior_args = concat (" ", args, "");
- }
-
---- 112,121 ----
- set_args_command (args)
- char *args;
- {
-! if (inferior_args != NULL)
-! free (inferior_args);
-! if (!args)
-! args = "";
- inferior_args = concat (" ", args, "");
- }
-
-***************
-*** 171,177 ****
- signal (SIGINT, SIG_DFL); */
-
- ptrace (0);
-! execle ("/bin/sh", "sh", "-c", allargs, 0,
- environ_vector (inferior_environ));
-
- fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
---- 173,180 ----
- signal (SIGINT, SIG_DFL); */
-
- ptrace (0);
-!
-! execle ("/bin/csh", "csh", "-f", "-c", allargs, 0,
- environ_vector (inferior_environ));
-
- fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
-***************
-*** 473,478 ****
---- 476,482 ----
-
- retbuf[0] = stop_r0;
- retbuf[1] = stop_r1;
-+
- val = value_being_returned (value_type, retbuf);
- printf ("Value returned is $%d = ", record_latest_value (val));
- value_print (val, stdout);
-***************
-*** 705,710 ****
---- 709,716 ----
- printf ("Contents are relative to selected stack frame.\n");
- }
- \f
-+ infcmdinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/inflow.c ./inflow.c
-*** ../../gnu/gdb/inflow.c Sat Apr 4 22:56:34 1987
---- ./inflow.c Mon Apr 27 00:12:10 1987
-***************
-*** 188,194 ****
- inferior_pid = 0;
- mark_breakpoints_out ();
- if (have_core_file_p ())
-! set_current_frame (read_register (FP_REGNUM));
- }
-
- /* Resume execution of the inferior process.
---- 188,194 ----
- inferior_pid = 0;
- mark_breakpoints_out ();
- if (have_core_file_p ())
-! set_current_frame (read_register (FP_REGNUM), 1);
- }
-
- /* Resume execution of the inferior process.
-***************
-*** 266,271 ****
---- 266,274 ----
- char buf[MAX_REGISTER_RAW_SIZE];
- register int i;
-
-+ #ifdef ibm032
-+ offset += UPAGES*NBPG - sizeof(u); /* ibm032: ustruct at end of uarea */
-+ #endif
- offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
- for (regno = 0; regno < NUM_REGS; regno++)
- {
-***************
-*** 291,296 ****
---- 294,303 ----
- register unsigned int regaddr;
- char buf[80];
-
-+ #ifdef ibm032
-+ offset += UPAGES*NBPG - sizeof(u); /* ibm032: ustruct at end of uarea */
-+ #endif
-+
- offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
-
- if (regno >= 0)
-***************
-*** 340,347 ****
- register int count
- = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
- /* Allocate buffer of that many longwords. */
-! register int *buffer = (int *) alloca (count * sizeof (int));
-
- /* Read all the longwords */
- for (i = 0; i < count; i++, addr += sizeof (int))
- buffer[i] = ptrace (1, inferior_pid, addr, 0);
---- 347,355 ----
- register int count
- = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
- /* Allocate buffer of that many longwords. */
-! register int *buffer;
-
-+ buffer = (int *) alloca(count * sizeof(int));
- /* Read all the longwords */
- for (i = 0; i < count; i++, addr += sizeof (int))
- buffer[i] = ptrace (1, inferior_pid, addr, 0);
-***************
-*** 367,377 ****
- register int count
- = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
- /* Allocate buffer of that many longwords. */
-! register int *buffer = (int *) alloca (count * sizeof (int));
- extern int errno;
-
- /* Fill start and end extra bytes of buffer with existing memory data. */
-
- buffer[0] = ptrace (1, inferior_pid, addr, 0);
- if (count > 1)
- buffer[count - 1]
---- 375,386 ----
- register int count
- = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
- /* Allocate buffer of that many longwords. */
-! register int *buffer;
- extern int errno;
-
- /* Fill start and end extra bytes of buffer with existing memory data. */
-
-+ buffer = (int *) alloca (count * sizeof (int));
- buffer[0] = ptrace (1, inferior_pid, addr, 0);
- if (count > 1)
- buffer[count - 1]
-***************
-*** 388,397 ****
- {
- errno = 0;
- ptrace (4, inferior_pid, addr, buffer[i]);
-! if (errno)
- return 1;
- }
--
- return 0;
- }
- \f
---- 397,406 ----
- {
- errno = 0;
- ptrace (4, inferior_pid, addr, buffer[i]);
-! if (errno) {
- return 1;
-+ }
- }
- return 0;
- }
- \f
-***************
-*** 421,426 ****
---- 430,437 ----
- }
- }
- \f
-+ inflowinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/infrun.c ./infrun.c
-*** ../../gnu/gdb/infrun.c Sat Apr 4 22:57:15 1987
---- ./infrun.c Mon Apr 27 00:17:40 1987
-***************
-*** 257,263 ****
- pc_changed = 0;
- fetch_inferior_registers ();
- stop_pc = read_pc ();
-! set_current_frame (read_register (FP_REGNUM));
- stop_frame = get_current_frame ();
- stop_sp = read_register (SP_REGNUM);
- another_trap = 0;
---- 257,271 ----
- pc_changed = 0;
- fetch_inferior_registers ();
- stop_pc = read_pc ();
-! #ifdef CAMPHOR
-! /* if we're not going to stop, don't bother with a stack trace */
-! if (WIFSTOPPED(w) && !signal_stop[WSTOPSIG(w)])
-! set_current_frame(read_register(FP_REGNUM), 0);
-! else
-! set_current_frame(read_register(FP_REGNUM), 1);
-! #else
-! set_current_frame (read_register (FP_REGNUM), 1);
-! #endif
- stop_frame = get_current_frame ();
- stop_sp = read_register (SP_REGNUM);
- another_trap = 0;
-***************
-*** 688,700 ****
-
- /* Save the function value return registers
- We might be about to restore their previous contents. */
-! stop_r0 = read_register (0);
-! stop_r1 = read_register (1);
-
- if (stop_stack_dummy)
- {
- /* Pop the empty frame that contains the stack dummy. */
- POP_FRAME;
- select_frame (read_register (FP_REGNUM), 0);
- }
- }
---- 696,717 ----
-
- /* Save the function value return registers
- We might be about to restore their previous contents. */
-! #ifdef ibm032
-! stop_r0 = read_register (2);
-! stop_r1 = read_register (3);
-! #else
-! stop_r0 = read_register (0);
-! stop_r1 = read_register (1);
-! #endif
-
- if (stop_stack_dummy)
- {
- /* Pop the empty frame that contains the stack dummy. */
-+ #ifdef ibm032
-+ POP_DUMMY_FRAME;
-+ #else
- POP_FRAME;
-+ #endif
- select_frame (read_register (FP_REGNUM), 0);
- }
- }
-***************
-*** 841,846 ****
---- 858,865 ----
- printf ("\nUse the \"handle\" command to change these tables.\n");
- }
- \f
-+ infruninitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/initialize.h ./initialize.h
-*** ../../gnu/gdb/initialize.h Sat Apr 4 22:58:27 1987
---- ./initialize.h Sun May 24 00:19:21 1987
-***************
-*** 103,109 ****
---- 103,120 ----
- of the end of one object file's text to the start of the next
- object file's text. */
-
-+ /* Changed to use ifdefs on the machine type. David Nichols, 11/28/86 */
-+ #ifdef ibm032
-+ #include "m-ibm032init.h"
-+ #endif
-+
-+ #ifdef vax
- #include "m-vaxinit.h"
-+ #endif
-+
-+ #ifdef sun
-+ #include "m-suninit.h"
-+ #endif
-
- /* This is used to make a file's initialization function.
- It calls another function named `initialize', which must
-diff -c ../../gnu/gdb/main.c ./main.c
-*** ../../gnu/gdb/main.c Sat Apr 4 23:11:59 1987
---- ./main.c Mon Apr 27 00:27:21 1987
-***************
-*** 236,241 ****
---- 236,243 ----
- if (*p)
- {
- c = lookup_cmd (&p, cmdlist, "", 0);
-+ if (c->function == 0)
-+ error ("That is not a command, just a help topic.");
- if (c->class == (int) class_user)
- {
- if (*p)
-***************
-*** 457,463 ****
- \f
- /* Add an element to the list of commands. */
-
-! void
- add_com (name, class, fun, doc)
- char *name;
- int class;
---- 459,465 ----
- \f
- /* Add an element to the list of commands. */
-
-! struct cmd_list_element *
- add_com (name, class, fun, doc)
- char *name;
- int class;
-***************
-*** 464,470 ****
- void (*fun) ();
- char *doc;
- {
-! add_cmd (name, class, fun, doc, &cmdlist);
- }
-
- /* Add an alias or abbreviation command to the list of commands. */
---- 466,473 ----
- void (*fun) ();
- char *doc;
- {
-!
-! return add_cmd (name, class, fun, doc, &cmdlist);
- }
-
- /* Add an alias or abbreviation command to the list of commands. */
-***************
-*** 547,552 ****
---- 550,556 ----
-
- if (c && c->class == (int) class_user)
- free_command_lines (&c->function);
-+
-
- add_com (comname, class_user, cmds,
- (c && c->class == (int) class_user)
-diff -c ../../gnu/gdb/param.h ./param.h
-*** ../../gnu/gdb/param.h Sat Apr 4 23:15:44 1987
---- ./param.h Mon Apr 27 00:28:17 1987
-***************
-*** 1 ****
---- 1,19 ----
-+ /* Changed to use ifdefs so we don't have to edit it all the time.
-+ David Nichols
-+ 28 November 1986 */
-+
-+ #ifdef vax
- #include "m-vax.h"
-+ #endif
-+
-+ #ifdef ibm032
-+ #include "m-ibm032.h"
-+ #endif
-+
-+ #ifdef sun
-+ #ifdef mc68020
-+ #include "m-sun3.h"
-+ #else
-+ #include "m-sun2.h"
-+ #endif
-+ #endif
-diff -c ../../gnu/gdb/pinsn.c ./pinsn.c
-*** ../../gnu/gdb/pinsn.c Sat Apr 4 23:15:58 1987
---- ./pinsn.c Mon Apr 27 00:28:36 1987
-***************
-*** 1 ****
---- 1,15 ----
-+ /* Changed to use ifdefs so we don't have to edit this.
-+ David Nichols
-+ 28 Nov 1986 */
-+
-+ #ifdef ibm032
-+ #include "ibm032-pinsn.c"
-+ #endif
-+
-+ #ifdef vax
- #include "vax-pinsn.c"
-+ #endif
-+
-+ #ifdef sun
-+ #include "m68k-pinsn.c"
-+ #endif
-diff -c ../../gnu/gdb/printcmd.c ./printcmd.c
-*** ../../gnu/gdb/printcmd.c Sat Apr 4 23:17:03 1987
---- ./printcmd.c Mon Apr 27 00:30:52 1987
-***************
-*** 797,804 ****
- CORE_ADDR frame;
- FILE *stream;
- {
-! char *space = (char *) alloca (TYPE_LENGTH (SYMBOL_TYPE (var)));
- value val = read_var_value (var, frame);
- value_print (val, stream);
- }
-
---- 797,805 ----
- CORE_ADDR frame;
- FILE *stream;
- {
-! char *space;
- value val = read_var_value (var, frame);
-+ space = (char *) alloca (TYPE_LENGTH (SYMBOL_TYPE (var)));
- value_print (val, stream);
- }
-
-***************
-*** 883,888 ****
---- 884,891 ----
- }
- }
- \f
-+ printcmdinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/source.c ./source.c
-*** ../../gnu/gdb/source.c Sat Apr 4 23:17:55 1987
---- ./source.c Mon Apr 27 00:31:25 1987
-***************
-*** 276,282 ****
- if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
- printf ("Source file is more recent than executable.\n");
-
-! data = (char *) alloca (st.st_size);
- myread (desc, data, st.st_size, s->filename);
- end = data + st.st_size;
- p = data;
---- 276,283 ----
- if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
- printf ("Source file is more recent than executable.\n");
-
-! data = (char *) alloca(st.st_size);
-!
- myread (desc, data, st.st_size, s->filename);
- end = data + st.st_size;
- p = data;
-***************
-*** 530,535 ****
---- 531,538 ----
- printf ("Line number %d is out of range for \"%s\".\n",
- sal.line, sal.symtab->filename);
- }
-+
-+ sourceinitialize() {initialize();}
-
- static
- initialize ()
-diff -c ../../gnu/gdb/stack.c ./stack.c
-*** ../../gnu/gdb/stack.c Sun Apr 5 00:28:05 1987
---- ./stack.c Mon Apr 27 00:31:50 1987
-***************
-*** 511,516 ****
---- 511,517 ----
-
- print_stack_frame (selected_frame, selected_frame_level, 1);
- }
-+
- \f
- static void
- return_command (retval_exp)
-***************
-*** 538,543 ****
---- 539,546 ----
- frame_command ("0", 1);
- }
- \f
-+ stackinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/symmisc.c ./symmisc.c
-*** ../../gnu/gdb/symmisc.c Sun Apr 5 00:33:16 1987
---- ./symmisc.c Mon Apr 27 00:37:46 1987
-***************
-*** 504,509 ****
---- 504,511 ----
- return i;
- }
- \f
-+ symmiscinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/symtab.c ./symtab.c
-*** ../../gnu/gdb/symtab.c Sun Apr 5 00:35:45 1987
---- ./symtab.c Mon Apr 27 00:38:19 1987
-***************
-*** 71,78 ****
- strcpy (copy, name);
- strcat (copy, ".c");
- for (s = symtab_list; s; s = s->next)
-! if (!strcmp (copy, s->filename))
- return s;
-
- return 0;
- }
---- 71,79 ----
- strcpy (copy, name);
- strcat (copy, ".c");
- for (s = symtab_list; s; s = s->next)
-! if (!strcmp (copy, s->filename)) {
- return s;
-+ }
-
- return 0;
- }
-***************
-*** 703,709 ****
- register struct symbol *sym;
- register CORE_ADDR pc;
- register int i;
-! char *copy;
-
- /* Defaults have defaults. */
-
---- 704,710 ----
- register struct symbol *sym;
- register CORE_ADDR pc;
- register int i;
-! char *copy, *dotcopy;
-
- /* Defaults have defaults. */
-
-***************
-*** 818,825 ****
---- 819,847 ----
- /* Look up that token as a function.
- If file specified, use that file's per-file block to start with. */
-
-+ #ifdef ibm032
-+ /* RT has stupid dots in front of function names (_.foo), and worse, has bogus _foo
-+ symbol to confuse us, too.
-+ */
-+ if (*copy != '.') {
-+ dotcopy = (char *) alloca (strlen(copy)+2); /* one for the null and one for the dot */
-+ dotcopy[0] = '.';
-+ strcpy(dotcopy+1, copy);
-+ sym = lookup_symbol (dotcopy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
-+ VAR_NAMESPACE);
-+ }
-+ else {
-+ sym = 0;
-+ dotcopy = 0;
-+ }
-+ if (!sym || SYMBOL_CLASS(sym) != LOC_BLOCK) {
-+ sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
-+ VAR_NAMESPACE);
-+ }
-+ #else
- sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
- VAR_NAMESPACE);
-+ #endif
-
- if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
- {
-***************
-*** 835,840 ****
---- 857,875 ----
- if (sym)
- error ("%s is not a function.", copy);
-
-+ #ifdef ibm032
-+ /* try the dot version first */
-+ if (dotcopy) for (i = 0; i < misc_function_count; i++)
-+ if (!strcmp (misc_function_vector[i].name, dotcopy))
-+ {
-+ value.symtab = 0;
-+ value.line = 0;
-+ value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
-+ if (funfirstline)
-+ SKIP_PROLOGUE (value.pc);
-+ return value;
-+ }
-+ #endif
- for (i = 0; i < misc_function_count; i++)
- if (!strcmp (misc_function_vector[i].name, copy))
- {
-***************
-*** 1027,1032 ****
---- 1062,1069 ----
-
- return type;
- }
-+
-+ symtabinitialize() {initialize();}
-
- static
- initialize ()
-diff -c ../../gnu/gdb/utils.c ./utils.c
-*** ../../gnu/gdb/utils.c Sun Apr 5 00:40:01 1987
---- ./utils.c Mon Apr 27 00:40:01 1987
-***************
-*** 151,156 ****
---- 151,157 ----
- else
- err = "unknown error";
-
-+ /* ibm032: no core leak or other problems 'cause we alway call error -> longjmps away */
- combined = (char *) alloca (strlen (err) + strlen (string) + 3);
- strcpy (combined, string);
- strcat (combined, ": ");
-diff -c ../../gnu/gdb/valarith.c ./valarith.c
-*** ../../gnu/gdb/valarith.c Sun Apr 5 00:40:44 1987
---- ./valarith.c Fri May 22 20:18:46 1987
-***************
-*** 239,245 ****
- COERCE_ARRAY (arg1);
-
- len = TYPE_LENGTH (VALUE_TYPE (arg1));
-! p = VALUE_CONTENTS (arg1);
-
- while (--len >= 0)
- {
---- 239,245 ----
- COERCE_ARRAY (arg1);
-
- len = TYPE_LENGTH (VALUE_TYPE (arg1));
-! p = (char *) VALUE_CONTENTS (arg1);
-
- while (--len >= 0)
- {
-***************
-*** 281,288 ****
- && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
- == TYPE_LENGTH (VALUE_TYPE (arg2))))
- {
-! p1 = VALUE_CONTENTS (arg1);
-! p2 = VALUE_CONTENTS (arg2);
- while (--len >= 0)
- {
- if (*p1++ != *p2++)
---- 281,288 ----
- && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
- == TYPE_LENGTH (VALUE_TYPE (arg2))))
- {
-! p1 = (char *) VALUE_CONTENTS (arg1);
-! p2 = (char *) VALUE_CONTENTS (arg2);
- while (--len >= 0)
- {
- if (*p1++ != *p2++)
-***************
-*** 348,353 ****
---- 348,355 ----
- return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
- }
- \f
-+ valarithinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/valops.c ./valops.c
-*** ../../gnu/gdb/valops.c Sun Apr 5 00:41:32 1987
---- ./valops.c Fri May 22 20:13:02 1987
-***************
-*** 174,180 ****
- /* Return a value just like TOVAL except with the contents of FROMVAL. */
-
- val = allocate_value (type);
-! bcopy (toval, val, VALUE_CONTENTS (val) - (char *) val);
- bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
-
- return val;
---- 174,180 ----
- /* Return a value just like TOVAL except with the contents of FROMVAL. */
-
- val = allocate_value (type);
-! bcopy (toval, val, (char *) VALUE_CONTENTS (val) - (char *) val);
- bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
-
- return val;
-***************
-*** 413,419 ****
---- 413,427 ----
- }
- else if (code == TYPE_CODE_PTR)
- {
-+ #ifdef ibm032
-+ /* apparently '_a' pseudoprocedure has lval_memory as its lval type */
-+ if (VALUE_LVAL(function) == lval_memory)
-+ funaddr = VALUE_ADDRESS(function);
-+ else
-+ funaddr = value_as_long (function);
-+ #else
- funaddr = value_as_long (function);
-+ #endif
- if (TYPE_CODE (TYPE_TARGET_TYPE (ftype))
- == TYPE_CODE_FUNC)
- value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
-***************
-*** 429,439 ****
- else
- /* Handle integer used as address of a function. */
- funaddr = value_as_long (function);
--
- value_type = builtin_type_int;
- }
-! else
- error ("Invalid data type for function to be called.");
-
- /* Create a call sequence customized for this function
- and the number of arguments for it. */
---- 437,447 ----
- else
- /* Handle integer used as address of a function. */
- funaddr = value_as_long (function);
- value_type = builtin_type_int;
- }
-! else {
- error ("Invalid data type for function to be called.");
-+ }
-
- /* Create a call sequence customized for this function
- and the number of arguments for it. */
-***************
-*** 590,595 ****
---- 598,605 ----
- return value_field (arg1, i);
- }
- \f
-+ valopsinitialize() {initialize();}
-+
- static
- initialize ()
- { }
-diff -c ../../gnu/gdb/valprint.c ./valprint.c
-*** ../../gnu/gdb/valprint.c Sun Apr 5 00:42:28 1987
---- ./valprint.c Mon Apr 27 00:40:56 1987
-***************
-*** 529,534 ****
---- 529,536 ----
- print_max = atoi (arg);
- }
-
-+ valprintinitialize() {initialize();}
-+
- static
- initialize ()
- {
-diff -c ../../gnu/gdb/value.h ./value.h
-*** ../../gnu/gdb/value.h Sun Apr 5 00:43:44 1987
---- ./value.h Fri May 22 20:03:32 1987
-***************
-*** 37,43 ****
- short repeated;
- short repetitions;
- short regno;
-! char contents[1];
- };
-
- typedef struct value *value;
---- 37,43 ----
- short repeated;
- short repetitions;
- short regno;
-! long contents[1]; /* Forces alignment... */
- };
-
- typedef struct value *value;
-diff -c ../../gnu/gdb/values.c ./values.c
-*** ../../gnu/gdb/values.c Sun Apr 5 00:45:14 1987
---- ./values.c Fri May 22 20:12:40 1987
-***************
-*** 338,344 ****
- int offset, bitpos, bitsize;
- value newval;
- {
-! register char *addr = VALUE_CONTENTS (var->value) + offset;
- if (bitsize)
- modify_field (addr, value_as_long (newval),
- bitpos, bitsize);
---- 338,344 ----
- int offset, bitpos, bitsize;
- value newval;
- {
-! register char *addr = (char *) VALUE_CONTENTS (var->value) + offset;
- if (bitsize)
- modify_field (addr, value_as_long (newval),
- bitpos, bitsize);
-***************
-*** 733,738 ****
---- 733,740 ----
- write_register (1, retbuf[1]);
- }
- \f
-+ valuesinitialize() {initialize();}
-+
- static
- initialize ()
- {
-
+++ /dev/null
-BABYL OPTIONS:
-Version: 5
-Labels:
-Note: This is the header of an rmail file.
-Note: If you are seeing it in rmail,
-Note: it means the file has no messages in it.
-\1f\f
-1,,
-Received: by PREP.AI.MIT.EDU; Mon, 25 May 87 04:03:20 EDT
-Message-Id: <8705250803.AA14993@prep.ai.mit.edu>
-Received: by po2.andrew.cmu.edu (5.54/3.15) id <AA00199> for rms@prep.ai.mit.edu; Mon, 25 May 87 04:02:41 EDT
-Received: via switchmail; Mon, 25 May 87 04:02:29 edt
-Received: FROM z.itc.cmu.edu VIA qmail
- ID </cmu/common/mailqs/q004/QF.z.itc.cmu.edu.20b7fa53.6bb39>;
- Mon, 25 May 87 04:01:27 edt
-Received: FROM z.itc.cmu.edu VIA qmail
- ID </cmu/itc/zs01/.Outgoing/QF.z.itc.cmu.edu.20b7fa49.a49502>;
- Mon, 25 May 87 04:01:15 edt
-From: zs01#@andrew.cmu.edu (Zalman Stern)
-Date: Mon, 25 May 87 04:01:13 edt
-To: rms@prep.ai.mit.edu
-Subject: Small diff to yesterdays gdb diffs.
-
-*** EOOH ***
-From: zs01#@andrew.cmu.edu (Zalman Stern)
-Date: Mon, 25 May 87 04:01:13 edt
-To: rms@prep.ai.mit.edu
-Subject: Small diff to yesterdays gdb diffs.
-
-Richard,
-
-Here is another minor diff to the diassembler to get certain conditional
-branches instructions correct...
-
-Also, I noticed that gcc.tar.Z is out of date with respect to gcc.tar .
-When I go to get these files, should I go ahead and replace the compressed
-version with a newer one or should I leave it alone? Likewise, should I try and
-make a split version on prep?
-
--Z-
-
-*** ibm032-pinsn.c.old Mon May 25 03:31:04 1987
---- ibm032-pinsn.c Mon May 25 03:47:12 1987
-***************
-*** 101,112 ****
- }
- }
- else { /* Conditional branches are hacked. */
-! switch (type & 0x0f) {
-
- int displacement;
-
- case ibm032_JI:
-! fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, buffer[0] & LOW4));
- putc('\t', stream);
- print_address((buffer[1] << 1) + memaddr, stream);
- return 2;
---- 101,112 ----
- }
- }
- else { /* Conditional branches are hacked. */
-! switch (type & LOW4) {
-
- int displacement;
-
- case ibm032_JI:
-! fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[0] & LOW3) + 8));
- putc('\t', stream);
- print_address((buffer[1] << 1) + memaddr, stream);
- return 2;
-*** ibm032-opcode.h.old Mon May 25 03:33:19 1987
---- ibm032-opcode.h Mon May 25 03:33:24 1987
-***************
-*** 11,16 ****
---- 11,17 ----
-
- /* Various useful bit masks. */
- #define ibm032_typeMask 0x0f /* Mask to get actual type info out of instruction type. */
-+ #define LOW3 0x07
- #define LOW4 0x0f
- #define HIGH4 0xf0
- #define LOW16 0x0000ffff
-
-\1f
\ No newline at end of file
+++ /dev/null
-From beatty@unh.cs.cmu.edu Sat Jul 4 12:04:01 1987
-Received: by PREP.AI.MIT.EDU; Sat, 4 Jul 87 12:03:37 EDT
-Message-Id: <8707041603.AA08600@prep.ai.mit.edu>
-To: phr@prep.ai.mit.edu (Paul Rubin)
-Date: Sat, 4 Jul 87 12:03:01 EDT
-From: Derek Beatty <beatty@unh.cs.cmu.edu>
-Subject: Re: gdb and X (msg 1 of 3)
-Status: R
-
-This is part 1 of 3 parts. It consists of the cursor I used, and a message
-I sent to Zalman Stern at Andrew regarding what I did, and why. The
-code and context diffs will follow in other messages.
-
-#define gdb_width 16
-#define gdb_height 16
-#define gdb_x_hot 7
-#define gdb_y_hot 0
-static short gdb_bits[] = {
- 0x0000, 0x0140, 0x0220, 0x0220,
- 0x23e2, 0x13e4, 0x09c8, 0x0ff8,
- 0x0220, 0x3ffe, 0x0630, 0x03e0,
- 0x0220, 0x1ffc, 0x2632, 0x01c0};
-
-#define gdb_mask_width 16
-#define gdb_mask_height 16
-#define gdb_mask_x_hot 7
-#define gdb_mask_y_hot 0
-static short gdb_mask_bits[] = {
- 0x0360, 0x07f0, 0x07f0, 0x77f7,
- 0x7fff, 0x7fff, 0x1ffc, 0x1ffc,
- 0x7fff, 0x7fff, 0x7fff, 0x0ff8,
- 0x3ffe, 0x7fff, 0x7fff, 0x7fff};
-
->
-> The X support I added is minimal; it was inspired by Suntools' dbxtool,
-> together with the availability of the V10 implementation of the X V11
-> toolkit specification. Design was guided by simplicity and the facilities
-> of the toolkit. The debugger window provides a view into the code
-> corresponding to the current stack frame, and several buttons for the
-> breakpoint, print, step, next, continue, finish, up, and down commands.
-> The standard gdb command interface remains available in the tty window from
-> which gdb was started. The breakpoint and print buttons make use of the
-> current selection, so you can do simple things like click at text in the
-> source window, then click the "Go 'til" button to continue until that
-> point.
->
-> Such an interface is simple to program ( ~ 20 hours, about 700 lines),
-> but it has some drawbacks. First, I didn't take the time to understand
-> the longjmp's in gdb, and I'm not exactly happy with the idea of them
-> jumping out of my callback procedures that were invoked by toolkit routines.
-> There's one core dump bug (it shows up when gdb can't find a source
-> file) that I haven't tracked down, and it may be related to this. Second,
-> selection in the text window is not particularly graceful: double-clicking
-> highlights one word of text, as the toolkit defines a word. It would
-> be much more graceful were double-clicking to highlight a C identifier.
-> Finally, and most seriously, most buttons operate by building textual
-> command lines and passing them to gdb's execute_command function. This
-> means that all selected expressions are evaluated and printed in the
-> lexical scope corresponding to the current stack frame, although the
-> selected text may be in a different lexical scope. This serious bug would
-> require work to fix.
->
-> I wrote the X support out of frustration at not having dbxtool available
-> when I work on a vax. The hope of portability to V11 via the toolkit
-> also helped motivate me to write V10 code at this late date. Finally,
-> I'd never written any nontrivial code that ran on a windowing system
-> (although that turns out still to be the case). Were I to make a more
-> serious effort at this project, I would probably add a general "define-button"
-> command akin to gdb's "define" command.
->
-> Look in /usr/beatty/gnu/gdb on vlsi.cs.cmu.edu. All files I have modified
-> are marked, and also have associated backups (.B extensions). Bennet
-> Yee has a copy of the toolkit library; see /usr/bsy/Xtlib on f.gp.cs.cmu.edu.
->
-> -- Derek
->
-
- -- Derek Beatty
-
-From beatty@unh.cs.cmu.edu Sat Jul 4 12:12:47 1987
-Received: by PREP.AI.MIT.EDU; Sat, 4 Jul 87 12:09:20 EDT
-Message-Id: <8707041609.AA08643@prep.ai.mit.edu>
-To: phr@PREP.AI.MIT.EDU (Paul Rubin)
-Date: Sat, 4 Jul 87 12:07:25 EDT
-From: Derek Beatty <beatty@unh.cs.cmu.edu>
-Subject: Re: gdb and X (msg 2 of 3)
-In-Reply-To: Message from "Paul Rubin" of Jul 4, 87 at 1:22 am
-Status: R
-
-The following is "tool.c". I hereby grant permission to do anything you
-like with it.
-
- -- Derek Beatty
-
-[nosave]
-/*
- * gdb tool for X V10R4 (using V11-compatible toolkit).
- * Derek Beatty 30 June 87.
- */
-#include <X/Xlib.h>
-#include <X/Xt/Xtlib.h>
-#include <stdio.h>
-
-#include "defs.h"
-#include "symtab.h"
-
-#include "gdb.cursor"
-#include "gdb_mask.cursor"
-
-
-
-/* forward refs */
-
-static Window createFileText();
-/*
- * Windows manipulated by this package.
- */
-
-static Window
- icon,
- frame,
- srcLabelStrip,
- srcText,
- ctlPanel,
- execLabelStrip;
-
-static Cursor curse;
-
-/*
- * Source text display.
- */
-
-static struct symtab *displayedSymtab= 0;
-
-extern struct symtab *current_source_symtab;
-extern int current_source_line;
-
-toolDisplaySource()
-{
- char *fullName;
- static Arg labelArgs[1];
- int linenumbers_changed= 0;
- static int newWidget= 1;
-
- struct symtab_and_line get_selected_frame_sal();
- struct symtab_and_line sal;
-
- /* we could be called before we are initialized */
- if (!frame) return;
-
- sal= get_selected_frame_sal();
-
- /* strictly this is wrong, but better than a blank display */
- if (sal.symtab==NULL) {
- sal.symtab= current_source_symtab;
- /* current_source_line may be off by a small number like 4 */
- sal.line= current_source_line;
- }
-
- /*
- * Switch to a new file if necessary.
- */
-
- if (sal.symtab)
- linenumbers_changed= get_filename_and_charpos(sal.symtab,
- sal.line,
- &fullName);
- if (!fullName) sal.symtab= NULL;
- /* if the display may be wrong, destroy it */
- if (linenumbers_changed || displayedSymtab != sal.symtab) {
- XtVPanedWindowDeletePane( srcText);
- XtSendDestroyNotify( srcText);
- XDestroyWindow( srcText);
- srcText= 0;
- }
- /* if there's no display, create one */
- if (!srcText) {
- newWidget= 1;
- /* if there's no valid display, create a dummy display */
- if (!sal.symtab ) {
- displayedSymtab= NULL;
- srcText= createFileText(frame, "/dev/null");
- XtVPanedWindowAddPane(frame, srcText, 1, 20, 1000, 1);
- /* create /dev/null text widget */
- XtSetArg(labelArgs[0], XtNlabel, "No source displayed.");
- XtLabelSetValues(srcLabelStrip, labelArgs, XtNumber(labelArgs));
- } else {
- displayedSymtab= sal.symtab;
- srcText= createFileText(frame, fullName);
- XtVPanedWindowAddPane(frame, srcText, 1, 20, 1000, 1);
- XtSetArg(labelArgs[0], XtNlabel, fullName);
- XtLabelSetValues(srcLabelStrip, labelArgs, XtNumber(labelArgs));
- /* free filename (maybe: check gdb code!) */
- }
- }
-
- /*
- * Update display and cursor positions as necessary.
- * Cursor should be placed on line sal.line.
- */
-
- {
- static int prevTop= 0, highWaterMark= 0;
- int currentTop;
- Arg textArgs[1];
-
- /* get positions of start of display, and caret */
- XtSetArg(textArgs[0], XtNdisplayPosition, NULL);
- XtTextGetValues(srcText, textArgs, XtNumber(textArgs));
- currentTop= cvtCharToLine(displayedSymtab,
- (int) textArgs[0].value);
-
- highWaterMark += currentTop - prevTop;
-
- if ( sal.line < currentTop
- || sal.line > highWaterMark
- || newWidget) {
-
- /* warp the display */
-
- newWidget= 0;
-
- /* yes, these magic numbers are ugly, but I don't know how
- * to get the height of a text widget in a V11-portable way
- */
- currentTop= (sal.line > 15) ? sal.line - 15 : 0;
- highWaterMark= currentTop + 35;
-
- XtSetArg(textArgs[0], XtNdisplayPosition,
- cvtLineToChar(displayedSymtab, currentTop));
- XtTextSetValues(srcText, textArgs, XtNumber(textArgs));
- }
- XtSetArg(textArgs[0], XtNinsertPosition,
- cvtLineToChar(displayedSymtab, sal.line));
- XtTextSetValues(srcText, textArgs, XtNumber(textArgs));
-
- prevTop= currentTop;
- }
-}
-
-/* return the character position of a line */
-int
-cvtLineToChar( s, line)
- struct symtab *s;
- int line;
-{
- if (!s) return 0;
- if (!s->line_charpos) return 0;
- if (line < 0) line= 0;
- if (line > s->nlines) line= s->nlines;
- return *(s->line_charpos + line-1);
-}
-
-/* return the line position of a character */
-int
-cvtCharToLine( s, chr)
- register struct symtab *s;
- register int chr;
-{
- register int lineNumber= 0;
- register int *lnp;
-
- if (!s) return 0;
- lnp= s->line_charpos;
- /* files are usually short, so sequential search is Ok */
- while ( lineNumber < s->nlines && *lnp <= chr) {
- lineNumber++;
- lnp++;
- }
- if (lineNumber >= s->nlines)
- lineNumber= s->nlines;
- return lineNumber;
-}
-
-/*
- * title bar at bottom
- */
-
-static char *execFileName;
-
-toolSetExecFile(s)
- char *s;
-{
- execFileName= s;
- if (execLabelStrip) {
- static Arg labelArgs[1];
-
- XtSetArg(labelArgs[0], XtNlabel, execFileName);
- XtLabelSetValues(execLabelStrip, labelArgs, XtNumber(labelArgs));
- }
-}
-
-/*
- * Command line into which command are placed for execution.
- * There's some ugly interaction between this and readline in main.c.
- */
-extern char *line;
-extern int linesize;
-
-/*
- * Do any necessary prompting, etc.
- */
-static char *gdbPrompt;
-
-static void
-printPrompt()
-{
- if (gdbPrompt) {
- printf("%s", gdbPrompt);
- fflush(stdout);
- }
-}
-
-/*
- * Callback procedures for control panel.
- */
-
-/* used by "print" and "print*" buttons */
-static void printButnProc_1( starflag)
- int starflag;
-{
- int selnLen;
- char *seln;
-
- char *cmd= starflag ? "print * " : "print ";
- register int cmdlen= strlen(cmd);
-
- seln= XFetchBytes(&selnLen);
- if (selnLen) {
- if (selnLen+cmdlen >= linesize-1) {
- linesize= (selnLen+cmdlen > linesize*2-1) ? selnLen+cmdlen+1 : linesize*2;
- line= (char *) xrealloc(line, linesize);
- }
- strcpy(line, cmd);
- strncpy(line+cmdlen, seln, selnLen);
- *(line+cmdlen+selnLen)= '\0';
- execute_command(line, 0);
- free(seln);
- }
- printPrompt();
-}
-
-static void printButnProc()
-{
- printButnProc_1( 0);
-}
-
-static void printStarButnProc()
-{
- printButnProc_1( 1);
-}
-
-static void nextButnProc()
-{
- strcpy(line, "next");
- execute_command(line, 0);
- toolDisplaySource();
- printPrompt();
-}
-
-static void stepButnProc()
-{
- strcpy(line, "step");
- execute_command(line, 0);
- toolDisplaySource();
- printPrompt();
-}
-
-static void contButnProc()
-{
- strcpy(line, "cont");
- execute_command(line, 0);
- toolDisplaySource();
- printPrompt();
-}
-
-static void finButnProc()
-{
- strcpy(line, "finish");
- execute_command(line, 0);
- toolDisplaySource();
- printPrompt();
-}
-
-/* used by "stop at" and "go till" buttons */
-static void stopAtButnProc_1( gotillFlag)
- int gotillFlag;
-{
- XtTextPosition start, finish;
- static int lineNumber;
-
- XtTextGetSelectionPos(srcText, &start, &finish);
- if (!displayedSymtab)
- printf("No source file displayed.\n");
- else {
- break_command_for_tool( displayedSymtab,
- cvtCharToLine(displayedSymtab, start),
- gotillFlag);
- if (gotillFlag) {
- strcpy(line, "cont");
- execute_command(line, 0);
- toolDisplaySource();
- }
- }
- printPrompt();
-}
-
-static void stopAtButnProc()
-{
- stopAtButnProc_1( 0);
-}
-
-static void untilButnProc()
-{
- stopAtButnProc_1( 1);
-}
-
-/* decide if a character is trash */
-static int
-garbage(c)
- char c;
-{
- if ('a' <= c && c <= 'z') return 0;
- if ('A' <= c && c <= 'Z') return 0;
- if ('0' <= c && c <= '9') return 0;
- if (c == '_') return 0;
- return 1;
-}
-
-static void stopInButnProc()
-{
- static int selnLen;
- static char *seln;
- char *sp, *selnp;
-
- seln= XFetchBytes(&selnLen);
- if (selnLen) {
- if (selnLen+6 >= linesize-1) {
- linesize= (selnLen+6 > linesize*2-1) ? selnLen+7 : linesize*2;
- line= (char *) xrealloc(line, linesize);
- }
- strcpy(line, "break ");
- /* copy selection but not garbage */
- selnp= seln;
- sp= line+strlen(line);
- while (garbage(*selnp) && selnLen) selnp++, selnLen--;
- while (!garbage(*selnp) && selnLen) {
- *sp++= *selnp++;
- selnLen--;
- }
- *sp= '\0';
- execute_command(line, 0);
- free(seln);
- }
- printPrompt();
-}
-
-static void deIconifyButnProc()
-{
- XUnmapWindow(icon);
- XMapWindow(frame);
-}
-
-static void iconifyButnProc()
-{
- static Arg iconArgs[1];
- XtSetArg(iconArgs[0], XtNlabel, gdbPrompt);
- XtCommandSetValues(icon, iconArgs, XtNumber(iconArgs));
- XUnmapWindow(frame);
- XMapWindow(icon);
-}
-
-static void upButnProc()
-{
- strcpy(line, "up");
- execute_command(line, 0);
- toolDisplaySource();
- printPrompt();
-}
-
-static void downButnProc()
-{
- strcpy(line, "down");
- execute_command(line, 0);
- toolDisplaySource();
- printPrompt();
-}
-
-#define addbutton(w) XtSetArg(buttons[buttoncount], XtNwindow, w); \
- buttoncount++;
-static Arg buttons[20];
-static int buttoncount= 0;
-
-/*
- * Create control panel buttons.
- */
-static createButtons(parent)
- Window parent;
-{
- static Window button;
- static Arg commandArgs[2];
-
-#define crButn(label,fn) \
- XtSetArg(commandArgs[0], XtNlabel, label);\
- XtSetArg(commandArgs[1], XtNfunction, fn);\
- button= XtCommandCreate(parent, commandArgs, XtNumber(commandArgs));\
- addbutton(button);
-
- crButn("Brk At", stopAtButnProc);
- crButn("Brk In", stopInButnProc);
- crButn("Go 'til", untilButnProc);
-
- crButn("Print", printButnProc);
- crButn("Print*", printStarButnProc);
-
- crButn("Next", nextButnProc);
- crButn("Step", stepButnProc);
- crButn("Cont", contButnProc);
- crButn("Finish", finButnProc);
-
- crButn("Up", upButnProc);
- crButn("Down", downButnProc);
-
- crButn("Iconify", iconifyButnProc);
-#undef crButn
-}
-
-static Window createLabel(parent, name, label)
- Window parent;
- char *name, *label;
-{
- static Arg labelArgs[2];
-
- XtSetArg(labelArgs[0], XtNname, name);
- XtSetArg(labelArgs[1], XtNlabel, label);
- return XtLabelCreate(frame, labelArgs, XtNumber(labelArgs));
-}
-
-static Window createFileText( parent, filename)
- Window parent;
- char *filename;
-{
- static Arg fileArgs[2];
-
- XtSetArg(fileArgs[0], XtNfile, filename);
- XtSetArg(fileArgs[1], XtNtextOptions, scrollVertical);
- return XtTextDiskCreate(parent, fileArgs, XtNumber(fileArgs));
-}
-
-/***************** Externally referenced routine **************/
-int createTool()
-{
- static Arg frameArgs[]= {
- {XtNwidth, (XtArgVal) 600},
- {XtNheight, (XtArgVal) 700},
- };
-
- ResourceDataBase db;
- FILE *rdbFile;
-
- /*
- * init and database stuff... this is wrong but what the heck
- */
- if (XOpenDisplay("") == NULL)
- return 0;
- printf("Initializing tool..."); fflush(stdout);
- XtInitialize();
- /* should be checking .Xdefaults in $HOME */
- if ((rdbFile= fopen(".Xresources", "r")) != NULL) {
- XtGetDataBase(rdbFile, &db);
- XtSetCurrentDataBase(db);
- fclose(rdbFile);
- }
-
- /*
- * create the frame
- */
- frame= XtVPanedWindowCreate(RootWindow, frameArgs, XtNumber(frameArgs));
-
- /* create source label strip and add to frame */
- srcLabelStrip= createLabel(frame, "Source File", "No source file yet.");
- XtVPanedWindowAddPane(frame, srcLabelStrip, 0, 15, 15, 0);
-
- /* create text widget and add to frame */
- srcText= createFileText(frame, "/dev/null");
- XtVPanedWindowAddPane(frame, srcText, 1, 20, 1000, 1);
-
- /* create button box */
- ctlPanel= XtButtonBoxCreate(frame, NULL, 0);
- createButtons( ctlPanel);
- XtButtonBoxAddButton(ctlPanel, buttons, buttoncount);
- XtVPanedWindowAddPane(frame, ctlPanel, 2, 30, 30, 0);
-
- /* create exec label strip and add */
- execLabelStrip= createLabel(frame, "Executable",
- execFileName ? execFileName : "No executable specified.");
- XtVPanedWindowAddPane(frame, execLabelStrip, 3, 15, 15, 0);
-
-
- /* create icon */
- {
- static Arg iconArgs[2];
- XtSetArg(iconArgs[0], XtNlabel, "(gdb)");
- XtSetArg(iconArgs[1], XtNfunction, deIconifyButnProc);
- icon= XtCommandCreate(RootWindow, iconArgs, XtNumber(iconArgs));
- XMoveWindow(icon, 100, 100); /* HACK */
- XSetIconWindow(frame, icon);
- }
-
- /* throw it onto the display */
- curse= XCreateCursor(gdb_width, gdb_height, gdb_bits, gdb_mask_bits,
- gdb_x_hot, gdb_y_hot,
- BlackPixel, WhitePixel, GXcopy);
- XDefineCursor(frame, curse);
- XDefineCursor(icon, curse);
- XMapWindow(frame);
- XMapSubwindows(frame);
- XFlush();
- printf("done\n");
- return 1;
-}
-
-/**************** Externally referenced routine. ***********/
-/* toolDispatcher -- dispatch events until data is available on fp */
-toolDispatcher(fp, prompt)
- FILE *fp;
- char *prompt;
-{
- int inMask= 1 << fileno(fp);
- int xMask= 1 << dpyno();
- int rfds= 0;
- int nfds;
- XEvent ev;
- int pend;
-
- gdbPrompt= prompt;
-
- while (! (rfds & inMask)) {
- pend= XPending();
- if (!pend) {
- rfds= inMask | xMask;
- /* this isn't right for 4.3 but it works 'cuz of 4.2 compatibility */
- nfds= select( 32, &rfds, 0, 0, (struct timeval *) 0);
- }
- if (pend || rfds & xMask) {
- XNextEvent(&ev);
- XtDispatchEvent(&ev);
- }
- }
-}
-
-From beatty@unh.cs.cmu.edu Sat Jul 4 12:17:44 1987
-Received: by PREP.AI.MIT.EDU; Sat, 4 Jul 87 12:15:18 EDT
-Message-Id: <8707041615.AA08691@prep.ai.mit.edu>
-To: phr@PREP.AI.MIT.EDU (Paul Rubin)
-Date: Sat, 4 Jul 87 12:14:08 EDT
-From: Derek Beatty <beatty@unh.cs.cmu.edu>
-Subject: Re: gdb and X (msg 3 of 3)
-In-Reply-To: Message from "Paul Rubin" of Jul 4, 87 at 1:22 am
-Status: R
-
-Context diffs follow. The original files are from GDB 2.1 (emacs distribution
-18.40).
-
- -- Derek Beatty
-[nosave]
-*** /usr/misc/.gdb/src/core.c Fri Mar 27 12:20:14 1987
---- core.c Sat Jul 4 11:12:16 1987
-***************
-*** 1,3
- /* Work with core dump and executable files, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-
---- 1,5 -----
-+ /* modified by Beatty 1 Jul 87 for gdb tool. */
-+
- /* Work with core dump and executable files, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-***************
-*** 257,262
- }
- else if (from_tty)
- printf ("No exec file now.\n");
- }
- \f
- /* If we have both a core file and an exec file,
-
---- 259,267 -----
- }
- else if (from_tty)
- printf ("No exec file now.\n");
-+ #ifdef TOOL
-+ toolSetExecFile( filename ? filename : "No executable specified.\n");
-+ #endif /* def TOOL */
- }
- \f
- /* If we have both a core file and an exec file,
-*** /usr/misc/.gdb/src/breakpoint.c Fri Mar 27 12:20:11 1987
---- breakpoint.c Wed Jul 1 11:27:31 1987
-***************
-*** 1,3
- /* Everything about breakpoints, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-
---- 1,5 -----
-+ /* modified by Beatty 1 Jul 87 for gdbtool */
-+
- /* Everything about breakpoints, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-***************
-*** 513,518
- break;
- }
- }
- \f
- /* Set a breakpoint according to ARG (function, linenum or *address)
- and make it temporary if TEMPFLAG is nonzero. */
-
---- 515,571 -----
- break;
- }
- }
-+
-+ #ifdef TOOL
-+ /* set a breakpoint from a symtab and line */
-+ void break_command_for_tool( s, line, tempflag)
-+ struct symtab *s;
-+ int line;
-+ int tempflag;
-+ {
-+ register struct breakpoint *b;
-+ struct symtab_and_line sal;
-+
-+ sal.symtab= s;
-+ sal.line= line;
-+ sal.pc= find_line_pc( sal.symtab, sal.line);
-+ if (sal.pc==0) {
-+ error("No line %d in file \"%s\".\n", sal.line, sal.symtab->filename);
-+ } else {
-+ b= set_raw_breakpoint( sal);
-+ b->number= ++breakpoint_count;
-+ b->cond= 0;
-+ if (tempflag)
-+ b->enable= temporary;
-+
-+ printf ("Breakpoint %d at 0x%x", b->number, b->address);
-+ if (b->symtab)
-+ printf (": file %s, line %d.", b->symtab->filename, b->line_number);
-+ printf ("\n");
-+
-+ {
-+ int others = 0;
-+ ALL_BREAKPOINTS (b)
-+ if (b->address == sal.pc && b->number != breakpoint_count)
-+ others++;
-+ if (others > 0)
-+ {
-+ printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
-+ ALL_BREAKPOINTS (b)
-+ if (b->address == sal.pc && b->number != breakpoint_count)
-+ {
-+ others--;
-+ printf ("%d%s%s ",
-+ b->number,
-+ (b->enable == disabled) ? " (disabled)" : "",
-+ (others > 1) ? "," : ((others == 1) ? " and" : ""));
-+ }
-+ printf (" also set at pc 0x%x\n", sal.pc);
-+ }
-+ }
-+ }
-+ }
-+ #endif /* def TOOL */
- \f
- /* Set a breakpoint according to ARG (function, linenum or *address)
- and make it temporary if TEMPFLAG is nonzero. */
-*** /usr/misc/.gdb/src/main.c Fri Mar 27 12:20:45 1987
---- main.c Sat Jul 4 11:13:32 1987
-***************
-*** 1,3
- /* Top level for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-
---- 1,5 -----
-+ /* modified by Beatty 30 june 87 for gdb tool */
-+
- /* Top level for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-***************
-*** 42,47
-
- FILE *instream;
-
- void free_command_lines ();
- char *read_line ();
- static void initialize_main ();
-
---- 44,54 -----
-
- FILE *instream;
-
-+ #ifdef TOOL
-+ /* flag indicating whether we are running in a window system */
-+ int isaTool= 0;
-+ #endif /* def TOOL */
-+
- void free_command_lines ();
- char *read_line ();
- static void initialize_main ();
-***************
-*** 214,219
-
- while (1)
- {
- if (!setjmp (to_top_level))
- command_loop ();
- clearerr (stdin); /* Don't get hung if C-d is typed. */
-
---- 221,232 -----
-
- while (1)
- {
-+
-+ #ifdef TOOL
-+ if (!isaTool)
-+ isaTool= createTool();
-+ #endif /* def TOOL */
-+
- if (!setjmp (to_top_level))
- command_loop ();
- clearerr (stdin); /* Don't get hung if C-d is typed. */
-***************
-*** 270,275
- printf ("%s", prompt);
- fflush (stdout);
-
- quit_flag = 0;
- execute_command (read_line (instream == stdin), instream == stdin);
- /* Do any commands attached to breakpoint we stopped at. */
-
---- 283,294 -----
- printf ("%s", prompt);
- fflush (stdout);
-
-+ #ifdef TOOL
-+ toolDisplaySource();
-+ if (isaTool) toolDispatcher(instream,
-+ instream==stdin ? prompt : NULL);
-+ #endif /* def TOOL */
-+
- quit_flag = 0;
- execute_command (read_line (instream == stdin), instream == stdin);
- /* Do any commands attached to breakpoint we stopped at. */
-***************
-*** 320,325
-
- while (1)
- {
- c = fgetc (instream);
- if (c == -1 || c == '\n')
- break;
-
---- 339,345 -----
-
- while (1)
- {
-+
- c = fgetc (instream);
- if (c == -1 || c == '\n')
- break;
-***************
-*** 765,770
- GDB is free software and you are welcome to distribute copies of it\n\
- under certain conditions; type \"info copying\" to see the conditions.\n",
- version);
- }
-
- static void
-
---- 785,793 -----
- GDB is free software and you are welcome to distribute copies of it\n\
- under certain conditions; type \"info copying\" to see the conditions.\n",
- version);
-+ #ifdef TOOL
-+ printf( "(CMU X support is available in this version.)\n");
-+ #endif
- }
-
- static void
-*** /usr/misc/.gdb/src/source.c Fri Mar 27 12:20:50 1987
---- source.c Wed Jul 1 17:56:58 1987
-***************
-*** 1,3
- /* List lines of source files for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-
---- 1,5 -----
-+ /* modified 1 July 87 by Beatty for gdbtool */
-+
- /* List lines of source files for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-***************
-*** 295,300
- s->nlines = nlines;
- s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int));
- }
- \f
- /* Print source lines from the file of symtab S,
- starting with line number LINE and stopping before line number STOPLINE. */
-
---- 297,328 -----
- s->nlines = nlines;
- s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int));
- }
-+
-+ #ifdef TOOL
-+ /* Get full pathname and line number positions for a symtab
-+ * return nonzero if line numbers may have changed
-+ * set full pathname to NULL if no file found
-+ */
-+ int
-+ get_filename_and_charpos(s, line, fullname)
-+ struct symtab *s;
-+ int line;
-+ char **fullname;
-+ {
-+ register int desc, linenums_changed= 0;
-+
-+ desc= openp(source_path, 0, s->filename, O_RDONLY, 0, fullname);
-+ if (desc < 0) {
-+ *fullname= NULL;
-+ return 0;
-+ }
-+ if (s->line_charpos==0) linenums_changed= 1;
-+ if (linenums_changed) find_source_lines(s, desc);
-+ close(desc);
-+ return linenums_changed;
-+ }
-+ #endif /* def TOOL */
-+
- \f
- /* Print source lines from the file of symtab S,
- starting with line number LINE and stopping before line number STOPLINE. */
-*** /usr/misc/.gdb/src/stack.c Fri Mar 27 12:20:51 1987
---- stack.c Wed Jul 1 17:27:34 1987
-***************
-*** 1,3
- /* Print and select stack frames for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-
---- 1,5 -----
-+ /* modified by Beatty 1 Jul 87 for gdbtool */
-+
- /* Print and select stack frames for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-***************
-*** 42,47
- static void select_calling_frame ();
-
- void print_frame_info ();
- \f
- /* Print a stack frame briefly. FRAME should be the frame address
- and LEVEL should be its level in the stack (or -1 for level not defined).
-
---- 44,62 -----
- static void select_calling_frame ();
-
- void print_frame_info ();
-+
-+ #ifdef TOOL
-+ /* get symtab and line of selected frame, for tool display */
-+ struct symtab_and_line
-+ get_selected_frame_sal()
-+ {
-+ struct frame_info fi;
-+
-+ fi= get_frame_info( selected_frame);
-+ return find_pc_line(fi.pc, fi.next_frame);
-+ }
-+
-+ #endif /* TOOL */
- \f
- /* Print a stack frame briefly. FRAME should be the frame address
- and LEVEL should be its level in the stack (or -1 for level not defined).
-End of context diffs. The presence of this line verifies that this message
-has not been truncated.
-
+++ /dev/null
-
- GDB GENERAL PUBLIC LICENSE
- (Clarified 20 March 1987)
-
- Copyright (C) 1986 Richard M. Stallman
- Everyone is permitted to copy and distribute verbatim copies
- of this license, but changing it is not allowed.
-
- The license agreements of most software companies keep you at the
-mercy of those companies. By contrast, our general public license is
-intended to give everyone the right to share GDB. To make sure that
-you get the rights we want you to have, we need to make restrictions
-that forbid anyone to deny you these rights or to ask you to surrender
-the rights. Hence this license agreement.
-
- Specifically, we want to make sure that you have the right to give
-away copies of GDB, that you receive source code or else can get it
-if you want it, that you can change GDB or use pieces of it in new
-free programs, and that you know you can do these things.
-
- To make sure that everyone has such rights, we have to forbid you to
-deprive anyone else of these rights. For example, if you distribute
-copies of GDB, you must give the recipients all the rights that you
-have. You must make sure that they, too, receive or can get the
-source code. And you must tell them their rights.
-
- Also, for our own protection, we must make certain that everyone
-finds out that there is no warranty for GDB. If GDB is modified by
-someone else and passed on, we want its recipients to know that what
-they have is not what we distributed, so that any problems introduced
-by others will not reflect on our reputation.
-
- Therefore we (Richard Stallman and the Free Software Foundation,
-Inc.) make the following terms which say what you must do to be
-allowed to distribute or change GDB.
-
-
- COPYING POLICIES
-
- 1. You may copy and distribute verbatim copies of GDB source code as
-you receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy a valid copyright notice "Copyright
-(C) 1986 Free Software Foundation, Inc." (or with the year updated if
-that is appropriate); keep intact the notices on all files that refer
-to this License Agreement and to the absence of any warranty; and give
-any other recipients of the GDB program a copy of this License
-Agreement along with the program. You may charge a distribution fee
-for the physical act of transferring a copy.
-
- 2. You may modify your copy or copies of GDB or any portion of it,
-and copy and distribute such modifications under the terms of
-Paragraph 1 above, provided that you also do the following:
-
- a) cause the modified files to carry prominent notices stating
- that you changed the files and the date of any change; and
-
- b) cause the whole of any work that you distribute or publish,
- that in whole or in part contains or is a derivative of GDB or any
- part thereof, to be licensed at no charge to all third parties on
- terms identical to those contained in this License Agreement
- (except that you may choose to grant more extensive warranty
- protection to third parties, at your option).
-
- c) if the modified program serves as a debugger, cause it
- when started running in the simplest and usual way, to print
- an announcement including a valid copyright notice
- "Copyright (C) 1986 Free Software Foundation, Inc." (or with
- the year updated if appropriate), saying that there
- is no warranty (or else, saying that you provide
- a warranty) and that users may redistribute the program under
- these conditions, and telling the user how to view a copy of
- this License Agreement.
-
- d) You may charge a distribution fee for the physical act of
- transferring a copy, and you may at your option offer warranty
- protection in exchange for a fee.
-
- 3. You may copy and distribute GDB or any portion of it in
-compiled, executable or object code form under the terms of Paragraphs
-1 and 2 above provided that you do the following:
-
- a) cause each such copy to be accompanied by the
- corresponding machine-readable source code, which must
- be distributed under the terms of Paragraphs 1 and 2 above; or,
-
- b) cause each such copy to be accompanied by a
- written offer, with no time limit, to give any third party
- free (except for a nominal shipping charge) a machine readable
- copy of the corresponding source code, to be distributed
- under the terms of Paragraphs 1 and 2 above; or,
-
- c) in the case of a recipient of GDB in compiled, executable
- or object code form (without the corresponding source code) you
- shall cause copies you distribute to be accompanied by a copy
- of the written offer of source code which you received along
- with the copy you received.
-
- 4. You may not copy, sublicense, distribute or transfer GDB
-except as expressly provided under this License Agreement. Any attempt
-otherwise to copy, sublicense, distribute or transfer GDB is void and
-your rights to use the program under this License agreement shall be
-automatically terminated. However, parties who have received computer
-software programs from you with this License Agreement will not have
-their licenses terminated so long as such parties remain in full compliance.
-
- 5. If you wish to incorporate parts of GDB into other free
-programs whose distribution conditions are different, write to the Free
-Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
-worked out a simple rule that can be stated here, but we will often permit
-this. We will be guided by the two goals of preserving the free status of
-all derivatives of our free software and of promoting the sharing and reuse
-of software.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-
- NO WARRANTY
-
- BECAUSE GDB IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO
-WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
-WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
-RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GDB "AS IS" WITHOUT
-WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
-PERFORMANCE OF GDB IS WITH YOU. SHOULD GDB PROVE DEFECTIVE, YOU
-ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
-STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
-WHO MAY MODIFY AND REDISTRIBUTE GDB AS PERMITTED ABOVE, BE LIABLE TO
-YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER
-SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
-INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
-BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
-FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GDB, EVEN
-IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR
-ANY CLAIM BY ANY OTHER PARTY.
+++ /dev/null
-Fri Jan 15 05:09:18 1988 Richard Stallman (rms at frosted-flakes)
-
- * valprint.c [IEEE_FLOAT]: New function `is_nan' checks
- whether a double is a nan.
-
- * printcmd.c (print_formatted) [IEEE_FLOAT]:
- Detect nans and print specially.
- * valprint.c (val_print) [IEEE_FLOAT]: Same thing.
-
- * m68k-pinsn.c (convert_{to,from}_68881): Hand-assemble
- all the assembler code.
-
- * m-newsinit.h, m-news800.h: Two new files.
-
-Thu Jan 7 22:25:16 1988 Richard Stallman (rms at frosted-flakes)
-
- * valops.c (value_assign): Don't coerce the arg being stored in.
- Coercion is not right either for an array or for an enum.
-
-Tue Jan 5 00:59:29 1988 Richard Stallman (rms at frosted-flakes)
-
- * symtab.c (decode_line_1): Don't complain about no symtabs loaded
- until after trying the misc function table.
-
-Sat Jan 2 13:16:08 1988 Richard Stallman (rms at frosted-flakes)
-
- * stack.c (record_selected_frame): New fn to access
- the selected frame and its level.
- * infcmd.c (run_stack_dummy): Save and restore the selected
- frame and its level.
-
-Wed Dec 30 18:44:41 1987 Richard Stallman (rms at frosted-flakes)
-
- * valprint.c (type_print_varspec_prefix):
- Treat arrays just like functions.
- * valprint.c (type_print_varspec_{prefix,suffix}):
- When passed_a_ptr is handled, pass 0 for it in the recursive call.
-
-Fri Dec 18 10:24:14 1987 Richard Stallman (rms at frosted-flakes)
-
- * findvar.c (read_var_value): Share code between values really
- in registers and values in saved registers.
- Register short on a big-endian machine needs a VALUE_OFFSET.
-
- * findvar.c (locate_var_value): Offset the address of a
- saved register variable that's shorter than the register.
-
-Thu Dec 17 08:26:31 1987 Richard Stallman (rms at lucky-charms)
-
- * valprint.c (type_print_base): Print nameless bit fields
- to indicate gaps before bit fields.
-
- * source.c (select_source_symtab): Ignore .h files.
- Also, if a function `main' exists, make the default listing line
- the beginning of `main'.
-
- * breakpoint.c ({get,set}_breakpoint_commands):
- Commands to examine or set the pending breakpoint-commands.
-
- * infcmd.c (run_stack_dummy): Save and restore the breakpoint
- commands around the function call.
-
- * stack.c (return_command): Don't query or print if not interactive.
-
- * value.h (COERCE_ENUM): New macro: if arg is enum, convert to int.
- * value.h (COERCE_ARRAY): Do that, as well as old job.
-
- * valarith.c (value_binop, value_neg, value_lognot):
- Use COERCE_ENUM on the arguments.
- * valops.c (value_arg_coerce): Likewise.
- * valops.c (value_cast): AVOID coercing enums when arrays are.
-
- * eval.c (evaluate_subexp): In the BINOP_SUB case,
- use evaluate_subexp_with_coercion.
-
- * inflow.c (terminal_ours_1, terminal_inferior):
- Ignore inferior_thisrun_terminal since our terminal
- is the inferior's controlling terminal regardless.
-
- * m-sun3.h: Fix assembler syntax for kdb macros.
-
- * infcmd.c ({attach,detach}_command): New functions from Dave Taylor.
- * inflow.c (attach, detach): New functions from Dave Taylor.
- * infrun.c (attach_process): New function, middle-level.
- Does all the work of attaching a process, assuming there is no
- inferior yet, except for printing and querying.
-
- * infrun.c (clear_proceed_status): Clear `stop_after_attach'.
- * infrun.c (wait_for_inferior): Handle `stop_after_attach'.
-
-Sat Dec 12 04:36:39 1987 Richard Stallman (rms at corn-chex)
-
- * dbxread.c (end_symtab): The free_code for a symseg got
- from a file should be free_linetable.
-
- * dbxread.c: Allocate blockvector, blocks, symbols and symbol names
- from the symbol-obstack, and use free_linetable for all files.
- The typevector is still malloc'd, so put it in the free_ptr
- to get it freed.
-
- * symmisc.c (free_symtab): Always free the `free_ptr' if nonzero.
- `free_explicit' therefore now the same as `free_nothing'.
-
- * dbxread.c (define_symbol): Handle defn code 'c', used by
- fortran, which defines integer and real constant symbols.
-
- * symseg.h: Define LOC_CONST_BYTES for constants longer than a
- word. New `bytes' alternative for the value of a symbol.
-
- * symtab.h (SYMBOL_VALUE_BYTES): Macro to access `bytes'.
-
- * findvar.c ({read,locate}_var_value): Handle LOC_CONST_BYTES.
- * printcmd.c (address_info): Handle LOC_CONST_BYTES.
- * symmisc.c (print_symbol): Handle LOC_CONST_BYTES.
-
-Tue Dec 8 20:26:37 1987 Richard Stallman (rms at frosted-flakes)
-
- * symtab.c (find_line_pc_range): Detection of last line in file
- was erroneous.
-
-Fri Dec 4 21:52:52 1987 Richard Stallman (rms at frosted-flakes)
-
- * dbxread.c (read_range_type): Accept the typenums as argument.
- Use read_type_number to read the subrange-of type.
- A type defined as a subrange of itself is void.
-
-Thu Dec 3 12:45:10 1987 Richard Stallman (rms at frosted-flakes)
-
- * inflow.c ({fetch,store}_inferior_registers): Support UMAX_PTRACE.
-
- * m-umax.h: New file, for Encore machines.
-
- * core.c (exec_file_command, etc): Decode COFF files.
- * core.c (core_file_command): Support UMAX_CORE format.
- * core.c (validate_files, exec_file_command):
- Set exec_mtime in exec_file_command so that COFF vs non-COFF
- differences appear all in one place.
-
- * coffread.c: New file from Dave Johnson.
-
- * core.c (specify_exec_file_hook): New function to specify
- a hook to be called by exec_file_command. Last #ifdef X_WINDOWS gone.
- * xgdb.c (initialize): Specify a hook.
-
- * infrun.c, inferior.h: Replace stop_r0 and stop_r1 with an array
- `stop_registers' that will hold ALL the registers.
- * infcmd.c (run_stack_dummy): Get the value from `stop_registers'
- and copy all of that into BUFFER.
- * infcmd.c (finish_command): Specify `stop_registers'
- to `value_being_returned'.
- * values.c (value_being_returned): Use the new EXTRACT... macros.
- * values.c (set_return_value): Use new STORE_RETURN_VALUE macro.
- * valops.c (call_function): Allocate retbuf long enough for all regs.
- * m-*.h: New macros EXTRACT_RETURN_VALUE, STORE_RETURN_VALUE and
- EXTRACT_STRUCT_VALUE_ADDRESS that express machine-dependencies
- in where return values are stored.
-
- * valops.c (call_function): Flush default for CALL_DUMMY_START_OFFSET.
- Assume it is defined.
- * m-vax.h: Define CALL_DUMMY_START_OFFSET.
-
- * ns32k-pinsn.c (ns32k-localcount): Fix decoding of `enter' insn.
- * ns32k-pinsn.c (n32k_get_enter_addr): New fn used from m-umax.h.
-
- * m-*.h: Change INVALID_FLOAT to accept 2nd arg which is length
- of the float.
- * values.c (unpack_double): Pass the 2nd arg.
- * vax-pinsn.c (print_insn_arg): Pass the 2nd arg.
- * infcmd.c (registers_info): Pass the 2nd arg.
-
-Wed Nov 25 15:06:55 1987 Richard Stallman (rms at frosted-flakes)
-
- * Bug fixes by David Johnson (ddj%cs.brown.edu@relay.cs.net).
-
- * symtab.c (list_symbols): Print typedef names, and don't call
- them `static'.
-
- * symmisc.c (print_symtabs): Allow immediate quit, and close the
- output file if that happens.
-
- * stack.c (frame_command): Declare args `unsigned' so a negative
- number is a frame address, not a level number.
-
- * source.c: Check for error-return from calls to `getwd'.
-
- * printcmd.c (address_info): Fix error in case of a function name.
-
- * inflow.c (create_inferior): Return the inferior pid properly.
-
- * inferior.h: Define `inferior_io_terminal'.
- * infrun.c (tty_command): New command to specify inferior_io_terminal.
- * inflow.c (new_tty): Open specified terminal for the inferior.
- * inflow.c (terminal_{ours,inferior}): Do nothing if inferior was
- started with its own terminal.
- * main.c (main): -t switch calls `tty_command'.
-
- * expread.y (rule for `block'): `copy_name' was called in wrong
- place and with wrong args.
-
- * dbxread.c: Entire file #ifdef READ_DBX_FORMAT.
- * m-*.h: Define READ_DBX_FORMAT.
-
- * breakpoint.c (initialize): Error in doc string of `info breakpoints'.
-
-Wed Nov 11 12:57:28 1987 Richard Stallman (rms at frosted-flakes)
-
- * ns32k-opcode.h, ns32k-pinsn.c: Two new files.
- * m-merlin.h: New file, for one 32000 box.
-
-Mon Nov 9 10:31:42 1987 Brian Fox (bfox at sugar-smacks)
-
- * eval.c (evaluate_subexp): Made the case of OP_FUNCALL use
- evaluate_subexp_with_coercion, so that array references would
- get converted into pointer references.
-
-Mon Nov 9 05:50:24 1987 Richard Stallman (rms at sugar-smacks)
-
- * breakpoint.c (ignore_command): Error if no arg.
-
-Sat Nov 7 13:57:40 1987 Richard Stallman (rms at frosted-flakes)
-
- * main.c (quit_command): Get rid of execfile before the kill_inferior.
-
- * xgdb.c: New file, interface to X windows.
-
- * main.c (main): Look for flag arguments before
- calling the initialization functions. -nw switch sets
- `inhibit_windows' which xgdb.c looks at.
- * main.c (command_loop): Call the window hook function, if any.
-
- * source.c (get_filename_and_charpos): New function
- that interfaces to find_source_lines.
- * source.c (source_line_charpos, source_charpos_line):
- New functions translate source line number to char pos and vice versa.
-
- * breakpoint.c (describe_other_breakpoints): New subroutine
- to list all breakpoints at PC in a message about "other
- breakpoints".
- * breakpoint.c (break_command_1): Use describe_other_breakpoints.
- * breakpoint.c (set_breakpoint): Like break_command_1
- but takes arg predecoded into symtab and line.
-
- * core.c (exec_file_command): Call xgdb_display_exec_file.
-
- * valprint.c (type_print_base): For struct bitfields,
- print the bit size.
-
-Thu Aug 20 02:46:47 1987 Richard M. Stallman (rms at prep)
-
- * Version 2.4.
-
- * m68k-pinsn.c (print_insn_arg): Implement place = '3'.
-
- * findvar.c (write_register_bytes): Arg to
- store_inferior_registers should be -1: write all registers.
-
- * dbxread.c (symbol_file_command): If no arg,
- just discard all symbols.
-
- * core.c (myread): Flush the 4th arg (filename).
- * source.c (find_source_lines): Don't pass 4th arg.
- * symmisc.c (read_symsegs): Ditto.
-
- * dbxread.c (process_one_symbol): One call to `define_symbol'
- lacked 3rd arg.
-
- * inflow.c (write_inferior_memory): On failure, return the errno value.
- * core.c (write_memory): ditto.
- * breakpoint.c ({insert,remove}_breakpoints): ditto.
- * utils.c (print_sys_errmsg): Like perror_with_name but don't
- signal an error; also, the error code is an arg instead of from
- `errno'.
- * infrun.c : Save the value from insert_breakpoints and pass it to
- print_sys_errmsg.
-
- * main.c (input_from_terminal_p): Put in omitted `return'.
-
- * Makefile (expread.o): Use $(CC).
-
-Sun Jun 7 04:42:51 1987 Richard M. Stallman (rms at prep)
-
- * version.c: Version 2.3.
-
- * inflow.c (terminal_ours): Save fcntl flags correctly.
- * inflow.c (term_status_command):
- Print the tchars and ltchars structures, byte by byte.
-
-Mon May 25 14:37:14 1987 Richard M. Stallman (rms at prep)
-
- * version.c: Version 2.2.
-
- * breakpoint.c (do_breakpoint_commands):
- Advance breakpoint_commands before executing the command,
- in case command is `cont' and it hits another bpt with commands.
-
-Sun May 24 20:45:04 1987 Richard M. Stallman (rms at prep)
-
- * value.h: Declare `contents' long and cast its address to char *.
-
- * expread.y (prefixify_expression): Don't call alloca among the decls.
-
- * printcmd.c (print_variable_value): Flush unused local `space'.
-
- * main.c (execute_command): Barf on "user" like other class names.
-
-Fri May 22 01:34:37 1987 Richard M. Stallman (rms at prep)
-
- * m68k-pinsn.c (fetch_arg): New arg position 'j', for movec.
- (print_insn_arg): New arg syntax 'J', for movec.
- * m68k-opcode.h: movec uses 'Jj'. Everything reformatted.
- bf... and cas... insns were corrected.
-
- * inflow.c (create_inferior): Fork and exec with given args and env.
- Call close_exec_file.
- (inferior_died): Record the fact that the inferior no longer exists.
- Call reopen_exec_file.
-
- * core.c (close_exec_file): New fn: Close the execchan if it's open.
- (reopen_exec_file): New fn: Reopen execchan if not currently open.
-
- * infrun.c (wait_for_inferior): Call inferior_died if it exits.
-
- * infcmd.c (run_command): Don't fork and exec; call create_inferior.
-
- * findvar.c (read_var_value): For reg var in a convertable reg,
- fetch reg in its own virtual type and then cast to variable's type.
-
- * symtab.h: Declare xmalloc to return char *.
-
- * dbxread.c (read_dbx_symtab): Record static text syms as
- misc-functions. But if an assembler symbol supplies the address
- for a debugger symbol, don't record it as a misc-function.
-
- * utils.c (query): Do clearerr (stdin) frequently in case of C-d.
-
- * dbxread.c (process_one_symbol, define_symbol):
- Pass the stab's DESC down to define_symbol.
- DESC = 0 means GCC output: if type is "short", believe it.
-
- * dbxread.c (read_enum_type): Don't allocate the type here;
- take it as an argument. (Like read_struct_type.)
- (read_type)): Before call to read_enum_type, allocate the type
- or get the one already allocated.
-
- * printcmd.c (print_frame_args): Print a comma before
- every arg except the first.
-
-Wed May 13 00:36:00 1987 Richard M. Stallman (rms at prep)
-
- * m68k-pinsn.c (convert_{to,from}_68881):
- Hand-assemble the fmoved and fmovex insns.
-
- * dbxread.c (define_symbol): For case 'p', a parameter,
- if specified type is short or char, change it to int.
- This is for how PCC handles arguments.
- Define new case 'P' that does what 'p' used to do.
- Maybe GCC will use this.
-
-Mon May 4 21:52:44 1987 Richard M. Stallman (rms at prep)
-
- * main.c (main): If SET_STACK_LIMIT_HUGE, set the
- run-time stack limit as high as it can go.
- * m-sun3.h, m-vax.h: define SET_STACK_LIMIT_HUGE.
-
-Sun May 3 08:46:23 1987 Richard Mlynarik (mly at prep)
-
- * command.c, expread.y, findvar.c, infcmd.c, inflow.c, utils.c,
- values.c, defs.h: Various ANSI C compatibility changes
- (fouts@wilbur.arpa <8705010117.AA13112@wilbur.arpa>)
-
- * core.c, inflow.c: Fix calls to supply_register.
- * findvar.c (supply_register): Instead of register value as int,
- pass address of buffer in core containing contents in raw form.
-
-Sat Apr 18 17:09:42 1987 Richard Mlynarik (mly at prep)
-
- * main.c (command_loop):
- Do any cleanups made by a executing a command each time around.
-
- * source.c (directory_command):
- make_cleanup (free, dirname), not
- make_cleanup (free_current_contents, &dirname)
- (rlk <8704180416.AA29572@PARIS.MIT.EDU>)
-
-Mon Apr 13 20:28:26 1987 Leonard H. Tower Jr. (tower at prep)
-
- * gdb.1: fixed typo and italicization errors.
- (<kgk%cs.brown.edu@RELAY.CS.NET> id AA16470;Sun,12 Apr 87 14:30:07 EST)
-
-Sat Apr 11 15:41:01 1987 Richard Mlynarik (mly at prep)
-
- * dbxread.c (read_dbx_symtab):
- No name for symbol => "" not 0 (avoid referencing memory 0)
- (tower <8704081854.AA00135@buit3.bu.edu>)
-
-Mon Mar 30 22:24:07 1987 Leonard H. Tower Jr. (tower at prep)
-
- * gdb.1: Unix style manual page pointing at internal gdb
- documentation, and info sub-system in GNU Emacs.
-
-Fri Mar 20 12:07:15 1987 Richard M. Stallman (rms at prep)
-
- * COPYING: Clarifications about distribution fees and mixing.
- * main.c (copying_info): Same changes.
-
-Tue Mar 17 17:40:14 1987 Richard M. Stallman (rms at prep)
-
- * values.c (unpack_field_as_long): Avoid >>= operator
- since ISI compiler has a bug.
-
-Sat Mar 7 12:19:35 1987 Richard M. Stallman (rms at prep)
-
- * GDB version 2.1.
-
- * values.c (unpack-field-as-long): Tests for endianness were broken.
- * findvar.c (read_var_value):
- Now we initialize the union as an int and test it as a char.
-
-Sun Mar 1 16:16:20 1987 Richard M. Stallman (rms at prep)
-
- * main.c (define_command): Command class symbols
- must be cast to int.
-
-Mon Feb 23 02:47:44 1987 Richard M. Stallman (rms at prep)
-
- * source.c (list_command): Reword error messages.
- New message for case of first arg not just a line-number
- and no symtab specified by it.
-
-Sun Feb 22 21:15:19 1987 Richard M. Stallman (rms at prep)
-
- * dbxread.c (compare_misc_functions):
- Compare the addresses as unsigned numbers.
-
-Sun Feb 22 13:11:45 1987 Richard Mlynarik (mly at prep)
-
- * main.c (define_command, document_command):
- Stuff was being unnecessarily malloced (-and- not freed!)
-
- * main.c (execute_command):
- User-defined commands don't take args.
- Don't confuse empty user command with no command.
- Replace bogus `etext' test with a comparison against
- class_user.
-
- * main.c (define_command):
- If the command of the specified name is built-in, note that when
- asking whether to redefine it (this is suppressed for class_alias
- -- should it not be?)
-
- * main.c (define_command):
- If command was previously built-in, don't preserve its
- documentation (otherwise could get error later when trying to free
- the non-malloced text of built-in documentation strings)
-
-Tue Feb 17 16:23:57 1987 Richard Mlynarik (mly at prep)
-
- * main.c (echo_command): Don't die if not given any arg.
- * main.c (cd_command): Echo new cwd if interactive.
-
-Thu Feb 12 11:22:56 1987 Richard M. Stallman (rms at prep)
-
- * stack.c (initialize): "bt" now appears in help aliases.
-
- * Version 2.0 released.
-
-Wed Feb 11 17:45:45 1987 Richard M. Stallman (rms at prep)
-
- * m68k-opcode.h: Errors corrected in several instructions
- and reordering done for assembler's sake.
-
- * m-vax.h (POP_FRAME): End with call to set_current_frame.
-
-Tue Feb 10 15:06:07 1987 Richard M. Stallman (rms at prep)
-
- * infrun.c (wait_for_inferior): Set stop_print_frame to 1
- after checking breakpoint condition.
-
- * infcmd.c (run_stack_dummy): Save many flags.
-
-Thu Feb 5 07:12:20 1987 Richard Mlynarik (mly at prep)
-
- * source.c (directory_command):
- Step over `:'
-
-Mon Feb 2 23:40:32 1987 Richard M. Stallman (rms at prep)
-
- * infcmd.c (set_environment_command): Fix stupid error
- for case where no "=" appears in the string.
-
-Mon Jan 26 13:46:52 1987 Richard M. Stallman (rms at prep)
-
- * printcmd.c (print_frame_args): Round end-of-arg offset
- up rather than down to multiple of int.
-
-Fri Jan 23 15:11:50 1987 Richard M. Stallman (rms at prep)
-
- * source.c (directory_command): If dir is not added cause already
- present, print explanation.
-
- * infrun.c (proceed): Use read_pc (), not stop_pc,
- to get current pc to think about. stop_pc could have been
- clobbered by call_function.
-
-Fri Jan 23 15:00:55 1987 Richard Mlynarik (mly at prep)
-
- * source.c (directory_command):
- If dir is already in source_path, don't append another copy of it.
-
-Thu Jan 22 00:31:03 1987 Richard M. Stallman (rms at prep)
-
- * Version 2.0.
-
- * blockframe.c (get_pc_function_start):
- Understand misc functions.
-
- * core.c (core_file_command):
- Copy all register contents into the array `registers'
- Save a.out header of executable file in core_aouthdr.
- Print name of executable file that was running, if we know
- where to find it.
-
- * core.c (exec_file_command):
- Save a.out header in exec_aouthdr and file's mtime
- in exec_mtime.
-
- * core.c (validate_files): Check that core file's a.out hdr
- matches exec file's.
-
- * New handling of registers:
- Now all registers are fetched once when the program stops or
- when a core file is selected. Their contents are kept in
- `registers', an array of bytes. This is done by
- `fetch_inferior_registers'. `read_register', etc., just look
- there. Writing a register works through
- `store_inferior_registers' which writes one or all registers
- from `registers' back to the inferior.
-
- A register now can have a "raw" data format and a "virtual"
- data format, which may require conversion or even be different sizes.
- The conversion can be different for different registers.
- For example, the 68000 cpu registers need no conversion
- and both raw and virtual size is 4, but the 68881 floating point
- registers have raw size 12 (for extended fmt) and virtual size 8
- (for double). Macros in the m- file such as REGISTER_BYTES,
- REGISTER_BYTE, REGISTER_{RAW,VIRTUAL}_SIZE, and
- REGISTER_CONVERT_TO_{RAW,VIRTUAL} control these things.
-
- `read_register' and `write_register' are usable only on registers
- which hold an int and need no conversion (raw fmt = virtual fmt).
- For other registers, `read_register_bytes' is used, or
- `read_relative_register_raw_bytes'.
-
- * m-sun3.h: Define the 68881 fp registers.
- Know how to recognize insns that save them.
- Make dummy frames save them.
-
- * core.c (read_register, write_registers): Functions deleted.
- * findvar.c (read_register, write_registers): New functions,
- not the same as the old ones of the same name.
-
- * findvar.c (supply_register): Function used by
- fetch_inferior_registers, etc., to install the register
- values fetched from the inferior.
-
- * findvar.c (read_register_bytes, write_register_bytes):
- Read spec'd number of bytes from the byte-array `registers'.
-
- * findvar.c (read_relative_register_raw_bytes):
- Replaces old function `read_relative_register'; accepts
- address of where to store the contents; # bytes stored is size
- of the specified register in raw format.
-
- * findvar.c (value_of_register, read_var_value):
- Convert register values and values of register variables
- from raw format to virtual format.
-
- * findvar.c (locate_var_value): Like `read_var_value' but
- returns value for variable's address.
-
- * value.h: Add new field VALUE_REGNO to each value. It holds
- register number to control virtual-to-raw conversion
- for assignments to the value.
-
- * valops.c (value_assign): Convert data from virtual to raw format
- if value came from a register variable.
- Use read_register_bytes and write_register_bytes.
-
-
- * infcmd.c (continue_command): Subtract 1 from arg
- before setting breakpoint's ignore-count.
-
- * infcmd.c (jump_command): Query if spec'd line is outside
- of the current function.
-
- * infcmd.c (finish_command): Now finish the selected frame,
- and no arg required.
-
- * infcmd.c (set_environment_command): Allow space to separate
- varname and value.
-
- * infcmd.c (registers_info): Print both raw and virtual data
- format if they differ. Allow register name as arg.
- Ask for a Newline each 16 registers.
-
- * inflow.c (kill_inferior): call mark_breakpoints_out.
- * inflow.c ({fetch,store}_inferior_registers for Sun):
- Get the fp registers and store them in right places in
- `registers'.
- * inflow.c ({read,write}_inferior_register): Deleted.
-
- * infrun.c (wait_for_inferior): Single-stepping is not considered
- to have hit a breakpoint unless the pc before the step matches the
- address of the breakpoint. Necessary on machines where
- breakpoints leave the pc incremented.
-
- If shell gets SIGSEGV, pass the signal silently to it.
-
- * m68k-pinsn.c, m68k-opcode.h:
- Add the 68881 instructions. New operand codes `F', `I', `s'
- and `k' are needed for them. New place codes `78tcik'.
- NEXTBYTE now skips a word but fetches just a byte.
- Explicit sign-extension removed from NEXTBYTE and NEXTWORD.
- NEXTSINGLE, NEXTDOUBLE, NEXTEXTEND and NEXTPACKED defined.
- Various changes to implement the new operand and place codes.
- print_index changed because displacement-size codes for
- word and long displacement were interchanged.
-
- * m68k-pinsn.c (convert_{from,to}_68881): Functions added
- to support REGISTER_CONVERT_TO_{RAW,VIRTUAL} on 68000.
-
- * main.c (main): Move around calls to setjmp.
- * main.c (define_command, document_command):
- Accept a from_tty argument instead of calling input_from_terminal_p.
-
- * printcmd.c (address_info): Print info on class and address
- of a specified symbol. For register symbols, gives name of register.
-
- * printcmd.c (print_command): Remember explicitly whether
- `make_cleanup' was called.
-
- * printcmd.c (print_frame_args): Know how arg-addresses vary with
- data type on big-endian machines.
-
- * source.c (directory_command): Detect `:' in arg and reject it.
- Free the old directory-path. Simplify things like `/.' in
- dirname.
-
- * source.c (openp): Simplify `./' in specified name.
-
- * source.c (find_source_lines): Compare source mtime against
- `exec_mtime' and warn if source is newer.
-
- * source.c (line_info): No arg means use last line listed
- or line following last one this command was used on.
- If from tty, clear out argument so Return is like `i li' without
- arg.
-
- * stack.c (frame_info): Print addresses registers are saved at.
-
- * stack.c (return_command): When asking for confirmation, give
- name of function that will be made to return.
-
- * valops.c (call_function): If function type is
- pointer-to-function, dereference it to compute return type.
- If pointer-to-object, assume function returns int.
- If char, assume that the value's address is the function address
- (because it's a misc functon). If int, the value itself is the
- function address.
-
- * dbxread.c (compare_symbols): Sort register symbols
- before all others.
-
- * eval.c (evaluate_subexp_for_address): New function like
- `evaluate_subexp' but returns a value for the address where
- the subexpression's value would be located.
-
- * eval.c (evaluate_subexp_for_sizeof): New function like
- `evaluate_subexp' but returns a value for the size of the subexp.
-
- * eval.c (evaluate_subexp_with_coercion): Like `evaluate_subexp'
- but coerces arrays to pointers (without taking the time to
- read the array contents).
-
- * eval.c (evaluate_subexp): Use the three new functions above
- when appropriate instead of calling self recursively.
-
-Wed Jan 14 17:00:03 1987 Richard Mlynarik (mly at prep)
-
- * core.c (core_file_command):
- Use correct file in calls to perror_with_name
-
-Mon Jan 12 03:34:35 1987 Richard Mlynarik (mly at prep)
-
- * breakpoint.c (map_breakpoint_numbers):
- Err if no args not supplied, otherwise would get mpv.
-
- * main.c (main):
- Command-line arg "-d dir" adds dir to source-file directory
- search-list.
-
-Sun Jan 11 19:19:52 1987 Richard Mlynarik (mly at prep)
-
- * symmisc.c (free_all_symtabs):
- Don't call free on 0.
-
- * core.c (exec_file_command):
- Use correct name in call to perror_with_name.
- Record absolute pathname.
- Don't savestring an arg to concat.
-
- * dbxread.c (symbol_file_command):
- Record absolute name of pathname opened.
- Print a message if file doesn't have a symbol-table.
- Don't savestring an arg to concat.
-
- * source.c (openp):
- Add new arg filename_opened, which if non-zero will be set to a
- malloced string of the absolute name of the actual filename opened.
-
- * breakpoint.c (clear_command):
- If from_tty or cleared more than one breakpoint at location,
- print which bpts were deleted.
-
- * breakpoint.c (break_command_1, break_command, tbreak_command):
- If from_tty, mention any other breakpoints set at same location.
-
- * symtab.c (decode_line_1):
- If no symtabs, err mentioning `symbol-file' command rather than
- saying "function foo not defined"
-
-Fri Jan 9 01:25:19 1987 Richard Mlynarik (mly at prep)
-
- * main.c (set_prompt_command):
- Add support command "set-prompt"
-
- * printcmd.c (undisplay_command):
- Fix paren error to make "undisplay <number>" work.
-
-Wed Jan 7 12:06:09 1987 Richard Mlynarik (mly at prep)
-
- * main.c (print_gdb_version, gdb_version_info):
- Add command "info version" to report the version
- of gdb for use in bug reports.
-
- * infcmd.c:
- Ensure inferior_args always points to string starting with a space
- and is never 0.
-
- * printcmd.c: (clear_displays, undisplay_command):
- Fix bug in clear_displays which led to looping.
- Make undisplay_command call it instead of wrong-looking code which
- looked at (display->number == 0) instead of (display == 0) to
- determine if it were at the end of the chain.
-
-Mon Dec 15 20:57:06 1986 Richard M. Stallman (rms at prep)
-
- * utils.c (query): Don't ignore a second line if given a null line.
-
- * infrun.c (normal_stop): Print "bug in shell" message
- only for a segmentation fault.
-
- * main.c (main): Read init file from home directory if any,
- before init file from current directory.
-
-Thu Dec 4 09:05:35 1986 Richard M. Stallman (rms at prep)
-
- * source.c (select_source_symtab): Don't ref thru arg if null.
-
- * m68k.opcode.h: For trap instruction code, use type T.
- * m68k-pinsn.c (print_insn_arg): Recognize new arg-code T
- and print the trap vector properly.
-
- * m-sun[23].h (FRAME_FIND_SAVED_REGS): Recognize a movl REG,-(sp)
- as a way to save one register. Recognize clrw -(sp); movw -(sp)
- after saving regs as a way to save the PS register. Adjust the
- way to find the starting pc of a stack dummy frame for the fact
- that these frames now save the PS.
-
- * m-sun[23].h (POP_FRAME): Restore PS register if frame saved it.
-
- * m-sun[23].h (PUSH_DUMMY_FRAME): Push the old PS register.
-
- * m-sun[23].h (CALL_DUMMY, etc.): Fix erroneous binary code for
- the addl #nnn,sp instruction. Insert clrw -(sp); movw -(sp)
- to indicate that the PS has been saved.
-
- * infrun.c (wait_for_inferior): If inferior exits, call
- mark_breakpoints_out so it works to delete breakpoints afterward.
-
- * infrun.c (normal_stop): After popping a stack dummy frame,
- select the frame that we get to.
-
- * dbxread.c (process_one_symbol): Store new `depth' field
- in all context_stack elements created. For N_RBRAC, test
- that depth matches that in the context_stack; if not, error.
-
- * dbxread.c (all callers of error): Make all error messages
- start "Invalid symbol data: " and end with value of symnum.
- Also change a few aborts to errors.
-
-Mon Dec 1 20:20:37 1986 Richard M. Stallman (rms at prep)
-
- * version.c: Version 1.11.
-
- * breakpoint.c (condition_command): If no condition spec'd,
- print "breakpoint N now unconditional".
-
- * breakpoint.c (commands_command): Give different error messages
- for cases of args not containing a breakpoint number
- and args containing anything after the breakpoint number.
-
- * commands.c (lookup_command): Don't store a zero in *p
- if have an undefined subcommand that is not an error.
-
- * commands.c (lookup_command): For recursive call,
- pass subcommand list properly. Was passing the address
- of the word containing the list.
-
- * core.c ({core,exec}_file_name): If no arg, tell user
- what the effect is.
-
- * dbxread.c (define_symbol): Accept class code 'v'
- for static variable within a function.
-
- * dbxread.c (read_type): Now allow any plain number or
- pair of numbers in parens, with no code letter. This means
- define new type same as type with specified number, or define
- it as void if specified number's type is not yet mentioned.
-
- * m68k-pinsn.c (print_insn_arg): Case of general operand
- in byte insn that happened to be immediate used wrong arg-size.
-
- * printcmd.c (set_next_address): Set next_address from arg
- and also set value of `$_' from it.
-
- * printcmd.c (do_examine): Save address in last_examine_address
- and value fetched to examine in last_examine_value.
-
- * printcmd.c (x_command): Copy last_examine_{address,value}
- into values of `$_' and `$__'. Change `x' documentation string.
-
- * source.c (directory_command): Query when no args now says
- what new value it wants use for the path.
-
- * source.c (list_command): Don't die in cases like `list ,+30'.
-
- * source.c (line_info): Call `set_next_address' to make `x'
- display the text of the line. Change `info list' doc string.
-
-Sat Nov 29 07:59:29 1986 Richard M. Stallman (rms at prep)
-
- * printcmd.c (undisplay_command): If get no arg,
- rather than crashing, query and then delete undisplay everything.
-
-Fri Nov 28 15:43:52 1986 Richard M. Stallman (rms at prep)
-
- * dbxread.c (process_one_symbol): If N_LBRAC sym
- has a greater value that N_RBRAC, ignore the
- N_LBRAC value and give the block zero length.
-
-Tue Nov 25 03:10:12 1986 Richard M. Stallman (rms at prep)
-
- * dbxread.c (process_one_symbol): Ignore N_NSYMS symbols
- that appear in Ultrix.
-
-Sat Nov 22 22:49:06 1986 Richard M. Stallman (rms at prep)
-
- * version.c: version 1.10.
-
- * valprint.c (type_print*):
- SHOW < 0 now means abbreviate struct/union members
- or enum values with `...'. SHOW now decremented on
- each recursion in type_print_base. Several places
- that used to check !show now check show <= 0.
-
- * valprint.c (val_print): Pass -1 for SHOW to type_print
- when printing typename inside parens or braces.
-
- * printcmd.c (print_command): If no value specified to print,
- print the value of $.
-
- * expression.h, expread.y, eval.c, expprint.c:
- OP_MEMVAL renamed UNOP_MEMVAL
- and now allows any expression, not just an integer address.
- It now has same format as UNOP_CAST and works almost like it.
- Each place that referred to it has been rewritten
- starting with a copy of the code that handles UNOP_CAST.
- Doc for `print' command changed for this.
-
- * source.c (init_source_path):
- Free and zero out any line_charpos's saved in source symtabs.
-
- * breakpoint.c (condition_command):
- Parse the condition in the environment of the code where the
- breakpoint is set. This requires finding the breakpoint
- before parsing, so code is rearranged.
-
- * dbxread.c (dbx_alloc_type):
- New function given typenums returns the type for those typenums
- or allocates a new, empty type for those typenums and returns it.
-
- * symtab.c (smash_type_to_{pointer,function}):
- New functions modify an already-allocated type object
- to be a pointer to or function returning some given type.
-
- * dbxread.c (read_type): Uses dbx_alloc_type in many cases.
- Reading a pointer or function type now works by doing that,
- then reading the value type or type pointed to, then smashing
- it into the type already allocated. This makes some fwd refs win.
- Likewise for structs and unions.
-
- * dbxread.c (read_struct_type): Now receives the type object
- as args. Used to get typenums as args and look up the type
- itself.
-
- * dbxread.c (symbol_file_command):
- At very end, clear out any type name that `char *' has received.
-
-Thu Nov 20 16:43:53 1986 Richard M. Stallman (rms at prep)
-
- * m-sun2.h, m-sun3.h (FIND_FRAME_SAVED_REGS):
- Was incrementing address even for regs not saved.
-
-Sun Nov 16 14:59:07 1986 Richard M. Stallman (rms at prep)
-
- * values.c (value_field): Was adding in byte offset
- before calling unpack_field_as_long, which itself
- adds in the offset. Now pass addr of start of structure.
-
- * infrun.c (normal_stop): Clean up inferior_pid conditionals:
- just return early if no inferior.
-
-Thu Nov 13 15:45:50 1986 Richard M. Stallman (rms at prep)
-
- * dbxread.c (struct header_file): add new field .instance
- to distinguish the various entries for one header file.
-
- * dbxread.c (process_one_symbol): Use the `value' of
- a N_BINCL or N_EXCL as the instance code for the header file.
-
- * dbxread.c (add_{new,old}_header_file):
- Accept an instance code as arg and treat it as if it were
- part of the file name for distinguishing and finding entries.
-
- * dbxread.c (add_new_header_file, read_type):
- Turn off the header_file_prev_index feature with #if 0.
-
- * values.c (unpack_field_as_long, modify_field):
- Run-time test to distinguish big and little endian machines
- and do shifting accordingly.
-
-Tue Nov 11 00:31:18 1986 Richard M. Stallman (rms at prep)
-
- * version.c: version 1.9.
-
- * breakpoint.c (delete_command):
- Don't query if 2nd arg is zero.
-
- * breakpoint.c (clear_breakpoints):
- Pass 2nd arg of zero to delete_command.
-
-Sat Nov 8 23:29:19 1986 Richard M. Stallman (rms at prep)
-
- * breakpoint.c (delete_command):
- Ask for confirmation when used with no arg (delete all).
-
-Fri Nov 7 11:23:09 1986 Richard M. Stallman (rms at prep)
-
- * infrun.c (start_inferior, wait_for_inferior):
- Eliminate `stop_in_shell' which was not being maintained right.
- New variable `running_in_shell' is set to 1 or 0 when the
- expected SIGTRAPs happen, and is simply examined at other times.
-
- * infrun.c (wait_for_inferior):
- If get SIGSEGV with running_in_shell == 1, it is sh
- allocating memory. Pass the signal silently to the shell.
-
- * core.c (exec_file_command):
- data_{start,end} are adjusted unconditionally when an
- exec file is opened, so closing counter-adjustment is
- now unconditional as well.
-
- * printcmd.c (x_command):
- Don't erase the expression from the calling args
- if cllaed noninteractively (used to be clobbering
- definitions of user-defined commands).
-
- * source.c (list_command): likewise.
-
-Wed Nov 5 09:41:00 1986 Richard M. Stallman (rms at prep)
-
- * Makefile: New variable OBSTACK1 that people can use
- to make obstack.o a dependency of gdb.
-
- * breakpoint.c (initialize):
- Define new aliases "br", "bre" and "brea" for "break".
-
-Sun Nov 2 21:16:06 1986 Richard Mlynarik (mly at prep)
-
- * symmisc.c (read_symsegs):
- Add an extra protection against invalid symbol-file
-
- * m-vax.h:
- Set KERNEL_U_ADDR and STACK_END_ADDR non-4.2-specifically
-
-Tue Oct 21 13:34:14 1986 Richard Mlynarik (mly at prep)
-
- * breakpoints.c (initialize):
- Delet reference to non-existent command "tenable" from doc of "enable"
-
-Tue Oct 14 19:58:27 1986 Richard Mlynarik (mly at prep)
-
- * printcmd.c (display_command, undisplay_command):
- * infcmd.c (run_command):
- Call dont_repeat.
-
-\f
-Local Variables:
-mode: indented-text
-eval: (auto-fill-mode 1)
-left-margin: 8
-fill-column: 74
-version-control: never
-End:
# -I. for "#include <obstack.h>"
-CFLAGS = -g -I. -Dvfork=fork -DDEBUG
+CFLAGS = -g -I.
# NOTE!!! -O may FAIL TO WORK! See initialize.h for some weird hacks.
+CC = cc
+BISON = bison
# define this to be "obstack.o" if you don't have the obstack library installed
# you must at the same time define OBSTACK1 as "obstack.o"
# so that the dependencies work right.
-OBSTACK = obstack.o alloca.o -lPW
-OBSTACK1 = obstack.o alloca.o
+OBSTACK = obstack.o
+OBSTACK1 = obstack.o
STARTOBS = main.o firstfile.o
OBS = blockframe.o breakpoint.o findvar.o stack.o source.o \
values.o eval.o valops.o valarith.o valprint.o printcmd.o \
- symtab.o symmisc.o coffread.o dbxread.o infcmd.o infrun.o
+ symtab.o symmisc.o coffread.o dbxread.o infcmd.o infrun.o remote.o
TSOBS = core.o inflow.o
NTSSTART = kdb-start.o
-gdb : $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) $(OBSTACK1)
- $(CC) -o gdb $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) -lg $(OBSTACK)
+gdb+: $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) $(OBSTACK1)
+ $(CC) -o gdb+ $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) -lc -lg $(OBSTACK)
-xgdb : $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) $(OBSTACK1)
- $(CC) -o xgdb $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) \
+xgdb+ : $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) $(OBSTACK1)
+ $(CC) -o xgdb+ $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) \
-lXtk11 -lXrm -lX11 -lg $(OBSTACK)
kdb : $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) $(OBSTACK1)
ld -o kdb $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) -lc -lg $(OBSTACK)
-clean:
- rm -f $(STARTOBS) $(OBS) $(TSOBS) $(OBSTACK1) $(NTSSTART) $(NTSOBS)
- rm -f xgdb.o gdb xgdb kdb tags errs expread.tab.c
-
blockframe.o : blockframe.c defs.h initialize.h param.h symtab.h frame.h
breakpoint.o : breakpoint.c defs.h initialize.h param.h symtab.h frame.h
command.o : command.c command.h
environ.o : environ.c environ.h
expprint.o : expprint.c defs.h symtab.h expression.h
expread.tab.c : expread.y
- @echo 'Expect 96 shift/reduce conflicts.'
- yacc expread.y
- mv y.tab.c expread.tab.c
+ @echo 'Expect 101 shift/reduce conflicts and 1 reduce/reduce conflict.'
+ $(BISON) -v expread.y
expread.o : expread.tab.c defs.h param.h symtab.h frame.h expression.h
$(CC) -c ${CFLAGS} expread.tab.c
mv expread.tab.o expread.o
pinsn.o : pinsn.c defs.h param.h symtab.h \
vax-opcode.h vax-pinsn.c m68k-opcode.h m68k-pinsn.c
printcmd.o : printcmd.c defs.h initialize.h param.h symtab.h value.h expression.h
+remote.o : remote.c defs.h initialize.h param.h frame.h inferior.h
source.o : source.c defs.h initialize.h symtab.h
stack.o : stack.c defs.h initialize.h param.h symtab.h frame.h
standalone.o : standalone.c defs.h initialize.h param.h symtab.h frame.h inferior.h wait.h
+++ /dev/null
-head 1.4;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @# @;
-
-
-1.4
-date 88.06.08.23.14.28; author gnu; state Exp;
-branches ;
-next 1.3;
-
-1.3
-date 88.02.28.03.38.17; author gnu; state Exp;
-branches ;
-next 1.2;
-
-1.2
-date 88.01.26.05.14.43; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.26.05.14.07; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Original from RMS's wheaties devl dirs
-@
-
-
-1.4
-log
-@Add -DEBUG
-@
-text
-@# -I. for "#include <obstack.h>"
-CFLAGS = -g -I. -Dvfork=fork -DDEBUG
-# NOTE!!! -O may FAIL TO WORK! See initialize.h for some weird hacks.
-
-# define this to be "obstack.o" if you don't have the obstack library installed
-# you must at the same time define OBSTACK1 as "obstack.o"
-# so that the dependencies work right.
-OBSTACK = obstack.o alloca.o -lPW
-OBSTACK1 = obstack.o alloca.o
-
-STARTOBS = main.o firstfile.o
-
-OBS = blockframe.o breakpoint.o findvar.o stack.o source.o \
- values.o eval.o valops.o valarith.o valprint.o printcmd.o \
- symtab.o symmisc.o coffread.o dbxread.o infcmd.o infrun.o
-
-TSOBS = core.o inflow.o
-
-NTSOBS = standalone.o
-
-ENDOBS = lastfile.o command.o utils.o expread.o expprint.o pinsn.o \
- environ.o version.o
-
-TSSTART = /lib/crt0.o
-
-NTSSTART = kdb-start.o
-
-gdb : $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) $(OBSTACK1)
- $(CC) -o gdb $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) -lg $(OBSTACK)
-
-xgdb : $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) $(OBSTACK1)
- $(CC) -o xgdb $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) \
- -lXtk11 -lXrm -lX11 -lg $(OBSTACK)
-
-kdb : $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) $(OBSTACK1)
- ld -o kdb $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) -lc -lg $(OBSTACK)
-
-clean:
- rm -f $(STARTOBS) $(OBS) $(TSOBS) $(OBSTACK1) $(NTSSTART) $(NTSOBS)
- rm -f xgdb.o gdb xgdb kdb tags errs expread.tab.c
-
-blockframe.o : blockframe.c defs.h initialize.h param.h symtab.h frame.h
-breakpoint.o : breakpoint.c defs.h initialize.h param.h symtab.h frame.h
-command.o : command.c command.h
-coffread.o : coffread.c defs.h initialize.h param.h symtab.h
-core.o : core.c defs.h initialize.h param.h
-dbxread.o : dbxread.c defs.h initialize.h param.h symtab.h
-environ.o : environ.c environ.h
-expprint.o : expprint.c defs.h symtab.h expression.h
-expread.tab.c : expread.y
- @@echo 'Expect 96 shift/reduce conflicts.'
- yacc expread.y
- mv y.tab.c expread.tab.c
-expread.o : expread.tab.c defs.h param.h symtab.h frame.h expression.h
- $(CC) -c ${CFLAGS} expread.tab.c
- mv expread.tab.o expread.o
-eval.o : eval.c defs.h initialize.h symtab.h value.h expression.h
-findvar.o : findvar.c defs.h initialize.h param.h symtab.h frame.h value.h
-firstfile.o : firstfile.c initialize.h
-infcmd.o : infcmd.c defs.h initialize.h param.h symtab.h frame.h inferior.h environ.h value.h
-inflow.o : inflow.c defs.h initialize.h param.h frame.h inferior.h
-infrun.o : infrun.c defs.h initialize.h param.h symtab.h frame.h inferior.h wait.h
-kdb-start.o : kdb-start.c defs.h param.h
-lastfile.o : lastfile.c
-main.o : main.c defs.h command.h
-# pinsn.o depends on ALL the opcode printers
-# since we don't know which one is really being used.
-pinsn.o : pinsn.c defs.h param.h symtab.h \
- vax-opcode.h vax-pinsn.c m68k-opcode.h m68k-pinsn.c
-printcmd.o : printcmd.c defs.h initialize.h param.h symtab.h value.h expression.h
-source.o : source.c defs.h initialize.h symtab.h
-stack.o : stack.c defs.h initialize.h param.h symtab.h frame.h
-standalone.o : standalone.c defs.h initialize.h param.h symtab.h frame.h inferior.h wait.h
-symmisc.o : symmisc.c defs.h initialize.h symtab.h
-symtab.o : symtab.c defs.h initialize.h param.h symtab.h
-utils.o : utils.c defs.h
-valarith.o : valarith.c defs.h initialize.h param.h symtab.h value.h expression.h
-valops.o : valops.c defs.h initialize.h param.h symtab.h value.h
-valprint.o : valprint.c defs.h initialize.h symtab.h value.h
-values.o : values.c defs.h initialize.h param.h symtab.h value.h
-version.o : version.c
-xgdb.o : xgdb.c defs.h initialize.h param.h symtab.h frame.h
- $(CC) -c $(CFLAGS) xgdb.c -o $@@
-
-obstack.o : obstack.c
-@
-
-
-1.3
-log
-@Make clean
-@
-text
-@d2 1
-a2 1
-CFLAGS = -g -I. -Dvfork=fork
-@
-
-
-1.2
-log
-@We don't have vfork or alloca, and regexp routines are in libPW.a for
-no good reason.
-@
-text
-@d38 4
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d2 1
-a2 1
-CFLAGS = -g -I.
-d8 2
-a9 2
-OBSTACK = obstack.o
-OBSTACK1 = obstack.o
-@
+++ /dev/null
-head 1.4;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.4
-date 88.06.08.23.13.40; author gnu; state Exp;
-branches ;
-next 1.3;
-
-1.3
-date 88.02.28.03.37.53; author gnu; state Exp;
-branches ;
-next 1.2;
-
-1.2
-date 88.01.26.05.02.32; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.26.00.38.04; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Original from RMS's work dirs on Wheaties
-@
-
-
-1.4
-log
-@Half reasonable reading of coff files. Problem was that it assumed
-that a .text would show up sometime, and it never did. We have to close
-out each source file's symtab as we hit the next one.
-@
-text
-@/* Read coff symbol tables and convert to internal format, for GDB.
- Design and support routines derived from dbxread.c, and UMAX COFF
- specific routines written 9/1/87 by David D. Johnson, Brown University.
- Revised 11/27/87 ddj@@cs.brown.edu
- Copyright (C) 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-\f
-#include "defs.h"
-#include "param.h"
-#ifdef COFF_FORMAT
-#include "initialize.h"
-#include "symtab.h"
-
-#include <a.out.h>
-#include <stdio.h>
-#include <obstack.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/file.h>
-
-static void add_symbol_to_list ();
-static void read_coff_symtab ();
-static void patch_opaque_types ();
-static struct type *decode_function_type ();
-static struct type *decode_type ();
-static struct type *decode_base_type ();
-static struct type *read_enum_type ();
-static struct type *read_struct_type ();
-static void finish_block ();
-static struct blockvector *make_blockvector ();
-static struct symbol *process_coff_symbol ();
-static int init_stringtab ();
-static void free_stringtab ();
-static char *getfilename ();
-static char *getsymname ();
-static int init_lineno ();
-static void enter_linenos ();
-
-START_FILE
-
-/* Name of source file whose symbol data we are now processing.
- This comes from a symbol named ".file". */
-
-static char *last_source_file;
-
-/* Core address of start and end of text of current source file.
- This comes from a ".text" symbol where x_nlinno > 0. */
-
-static CORE_ADDR cur_src_start_addr;
-static CORE_ADDR cur_src_end_addr;
-
-/* End of the text segment of the executable file,
- as found in the symbol _etext. */
-
-static CORE_ADDR end_of_text_addr;
-
-/* The addresses of the symbol table stream and number of symbols
- of the object file we are reading (as copied into core). */
-
-static FILE *nlist_stream_global;
-static int nlist_nsyms_global;
-
-/* The file and text section headers of the symbol file */
-
-static FILHDR file_hdr;
-static SCNHDR text_hdr;
-
-/* The index in the symbol table of the last coff symbol that was processed. */
-
-static int symnum;
-
-/* Vector of types defined so far, indexed by their coff symnum. */
-
-static struct typevector *type_vector;
-
-/* Number of elements allocated for type_vector currently. */
-
-static int type_vector_length;
-
-/* Vector of line number information. */
-
-static struct linetable *line_vector;
-
-/* Index of next entry to go in line_vector_index. */
-
-static int line_vector_index;
-
-/* Last line number recorded in the line vector. */
-
-static int prev_line_number;
-
-/* Number of elements allocated for line_vector currently. */
-
-static int line_vector_length;
-
-/* Chain of typedefs of pointers to empty struct/union types.
- They are chained thru the SYMBOL_VALUE. */
-
-#define HASHSIZE 127
-static struct symbol *opaque_type_chain[HASHSIZE];
-
-/* Record the symbols defined for each context in a list.
- We don't create a struct block for the context until we
- know how long to make it. */
-
-struct pending
-{
- struct pending *next;
- struct symbol *symbol;
-};
-
-/* Here are the three lists that symbols are put on. */
-
-struct pending *file_symbols; /* static at top level, and types */
-
-struct pending *global_symbols; /* global functions and variables */
-
-struct pending *local_symbols; /* everything local to lexical context */
-
-/* List of unclosed lexical contexts
- (that will become blocks, eventually). */
-
-struct context_stack
-{
- struct context_stack *next;
- struct pending *locals;
- struct pending_block *old_blocks;
- struct symbol *name;
- CORE_ADDR start_addr;
- int depth;
-};
-
-struct context_stack *context_stack;
-
-/* Nonzero if within a function (so symbols should be local,
- if nothing says specifically). */
-
-int within_function;
-
-/* List of blocks already made (lexical contexts already closed).
- This is used at the end to make the blockvector. */
-
-struct pending_block
-{
- struct pending_block *next;
- struct block *block;
-};
-
-struct pending_block *pending_blocks;
-
-extern CORE_ADDR first_object_file_end; /* From blockframe.c */
-
-/* File name symbols were loaded from. */
-
-static char *symfile;
-
-int debug = 1;
-
-\f
-/* Look up a coff type-number index. Return the address of the slot
- where the type for that index is stored.
- The type-number is in INDEX.
-
- This can be used for finding the type associated with that index
- or for associating a new type with the index. */
-
-static struct type **
-coff_lookup_type (index)
- register int index;
-{
- if (index >= type_vector_length)
- {
- type_vector_length *= 2;
- type_vector = (struct typevector *)
- xrealloc (type_vector, sizeof (struct typevector)
- + type_vector_length * sizeof (struct type *));
- bzero (&type_vector->type[type_vector_length / 2],
- type_vector_length * sizeof (struct type *) / 2);
- }
- return &type_vector->type[index];
-}
-
-/* Make sure there is a type allocated for type number index
- and return the type object.
- This can create an empty (zeroed) type object. */
-
-static struct type *
-coff_alloc_type (index)
- int index;
-{
- register struct type **type_addr = coff_lookup_type (index);
- register struct type *type = *type_addr;
-
- /* If we are referring to a type not known at all yet,
- allocate an empty type for it.
- We will fill it in later if we find out how. */
- if (type == 0)
- {
- type = (struct type *) obstack_alloc (symbol_obstack,
- sizeof (struct type));
- bzero (type, sizeof (struct type));
- *type_addr = type;
- }
- return type;
-}
-\f
-/* maintain the lists of symbols and blocks */
-
-/* Add a symbol to one of the lists of symbols. */
-static void
-add_symbol_to_list (symbol, listhead)
- struct symbol *symbol;
- struct pending **listhead;
-{
- register struct pending *link
- = (struct pending *) xmalloc (sizeof (struct pending));
-
- link->next = *listhead;
- link->symbol = symbol;
- *listhead = link;
-}
-
-/* Take one of the lists of symbols and make a block from it.
- Put the block on the list of pending blocks. */
-
-static void
-finish_block (symbol, listhead, old_blocks, start, end)
- struct symbol *symbol;
- struct pending **listhead;
- struct pending_block *old_blocks;
- CORE_ADDR start, end;
-{
- register struct pending *next, *next1;
- register struct block *block;
- register struct pending_block *pblock;
- struct pending_block *opblock;
- register int i;
-
- /* Count the length of the list of symbols. */
-
- for (next = *listhead, i = 0; next; next = next->next, i++);
-
- block = (struct block *) xmalloc (sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
-
- /* Copy the symbols into the block. */
-
- BLOCK_NSYMS (block) = i;
- for (next = *listhead; next; next = next->next
\ No newline at end of file
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.04.52; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.21.05.04.03; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@From RMS's development version on wheaties, 20Jan88
-@
-
-
-1.2
-log
-@Hacks to get it to compile on a/ux. Needs work at finding the registers
-in a core file.
-@
-text
-@/* Work with core dump and executable files, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include "initialize.h"
-#include "defs.h"
-#include "param.h"
-
-#include <a.out.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/dir.h>
-#include <sys/file.h>
-#include <sys/stat.h>
-
-/* Recognize COFF format systems because a.out.h defines AOUTHDR. */
-#ifdef AOUTHDR
-#define COFF_FORMAT
-#endif
-
-#ifdef NEW_SUN_CORE
-#include <sys/core.h>
-#else /* not NEW_SUN_CORE */
-#ifdef UMAX_CORE
-#include <sys/ptrace.h>
-#else /* not UMAX_CORE */
-#ifdef mac_aux
-#include <sys/seg.h>
-#include <sys/mmu.h>
-#include <sys/signal.h>
-#include <sys/time.h>
-#include <sys/user.h>
-#else
-#include <sys/user.h>
-#endif /* mac_aux */
-#endif /* UMAX_CORE */
-#endif /* NEW_SUN_CORE */
-
-#ifndef N_TXTADDR
-#define N_TXTADDR(hdr) 0
-#endif /* no N_TXTADDR */
-
-#ifndef N_DATADDR
-#define N_DATADDR(hdr) hdr.a_text
-#endif /* no N_DATADDR */
-
-/* Make COFF and non-COFF names for things a little more compatible
- to reduce conditionals later. */
-
-#ifdef COFF_FORMAT
-#define a_magic magic
-#endif
-
-#ifndef COFF_FORMAT
-#define AOUTHDR struct exec
-#endif
-
-START_FILE
-
-/* Hook for `exec_file_command' command to call. */
-
-void (*exec_file_display_hook) ();
-
-/* File names of core file and executable file. */
-
-static char *corefile;
-static char *execfile;
-
-/* Descriptors on which core file and executable file are open.
- Note that the execchan is closed when an inferior is created
- and reopened if the inferior dies or is killed. */
-
-static int corechan;
-static int execchan;
-
-/* Last modification time of executable file.
- Also used in source.c to compare against mtime of a source file. */
-
-int exec_mtime;
-
-/* Virtual addresses of bounds of the two areas of memory in the core file. */
-
-static CORE_ADDR data_start;
-static CORE_ADDR data_end;
-static CORE_ADDR stack_start;
-static CORE_ADDR stack_end;
-
-/* Virtual addresses of bounds of two areas of memory in the exec file.
- Note that the data area in the exec file is used only when there is no core file. */
-
-static CORE_ADDR text_start;
-static CORE_ADDR text_end;
-static CORE_ADDR exec_data_start;
-static CORE_ADDR exec_data_end;
-
-/* Address in executable file of start of text area data. */
-
-static int text_offset;
-
-/* Address in executable file of start of data area data. */
-
-static int exec_data_offset;
-
-/* Address in core file of start of data area data. */
-
-static int data_offset;
-
-/* Address in core file of start of stack area data. */
-
-static int stack_offset;
-
-#ifdef COFF_FORMAT
-/* various coff data structures */
-
-static FILHDR file_hdr;
-static SCNHDR text_hdr;
-static SCNHDR data_hdr;
-
-#endif /* not COFF_FORMAT */
-
-/* a.out header saved in core file. */
-
-static AOUTHDR core_aouthdr;
-
-/* a.out header of exec file. */
-
-static AOUTHDR exec_aouthdr;
-
-static void validate_files ();
-unsigned int register_addr ();
-\f
-core_file_command (filename, from_tty)
- char *filename;
- int from_tty;
-{
- int val;
- extern char registers[];
-
- /* Discard all vestiges of any previous core file
- and mark data and stack spaces as empty. */
-
- if (corefile)
- free (corefile);
- corefile = 0;
-
- if (corechan >= 0)
- close (corechan);
- corechan = -1;
-
- data_start = 0;
- data_end = 0;
- stack_start = STACK_END_ADDR;
- stack_end = STACK_END_ADDR;
-
- /* Now, if a new core file was specified, open it and digest it. */
-
- if (filename)
- {
- if (have_inferior_p ())
- error ("To look at a core file, you must kill the inferior with \"kill\".");
- corechan = open (filename, O_RDONLY, 0);
- if (corechan < 0)
- perror_with_name (filename);
-#ifdef NEW_SUN_CORE
- {
- struct core corestr;
-
- val = myread (corechan, &corestr, sizeof corestr);
- if (val < 0)
- perror_with_name (filename);
- if (corestr.c_magic != CORE_MAGIC)
- error ("\"%s\" does not appear to be a core dump file (magic 0x%x, expected 0x%x)",
- filename, corestr.c_magic, (int) CORE_MAGIC);
- else if (sizeof (struct core) != corestr.c_len)
- error ("\"%s\" has an invalid struct core length (%d, expected %d)",
- filename, corestr.c_len, (int) sizeof (struct core));
-
- data_start = exec_data_start;
- data_end = data_start + corestr.c_dsize;
- stack_start = stack_end - corestr.c_ssize;
- data_offset = sizeof corestr;
- stack_offset = sizeof corestr + corestr.c_dsize;
-
- bcopy (&corestr.c_regs, registers, 16 * 4);
- *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = corestr.c_regs.r_ps;
- *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = corestr.c_regs.r_pc;
- bcopy (corestr.c_fpstatus.fps_regs,
- ®isters[REGISTER_BYTE (FP0_REGNUM)],
- sizeof corestr.c_fpstatus.fps_regs);
- bcopy (&corestr.c_fpstatus.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
- sizeof corestr.c_fpstatus - sizeof corestr.c_fpstatus.fps_regs);
-
- bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec));
-
- printf ("Core file is from \"%s\".\n", corestr.c_cmdname);
- }
-#else /* not NEW_SUN_CORE */
- /* 4.2-style (and perhaps also sysV-style) core dump file. */
- {
-#ifdef UMAX_CORE
- struct ptrace_user u;
-#else
- struct user u;
-#endif
- int reg_offset;
-
- val = myread (corechan, &u, sizeof u);
- if (val < 0)
- perror_with_name (filename);
- data_start = exec_data_start;
-
-#ifdef UMAX_CORE
- data_end = data_start + u.pt_dsize;
- stack_start = stack_end - u.pt_ssize;
- data_offset = sizeof u;
- stack_offset = data_offset + u.pt_dsize;
- reg_offset = 0;
-
- bcopy (&u.pt_aouthdr, &core_aouthdr, sizeof (AOUTHDR));
-
-#else /* not UMAX_CORE */
-#ifdef mac_aux
- /* This may well not work for 0407 (nonshared text) a.out's */
- data_end = data_start + u.u_dsize << PAGESHIFT;
- stack_start = stack_end - u.u_ssize << PAGESHIFT;
- data_offset = USIZE;
- stack_offset = USIZE + u.u_dsize << PAGESHIFT;
- reg_offset = (int) &u.u_ar0[0] - (int) &u;
-
- core_aouthdr.a_magic = u.u_exdata.ux_mag;
-#else
- data_end = data_start + NBPG * u.u_dsize;
- stack_start = stack_end - NBPG * u.u_ssize;
- data_offset = NBPG * UPAGES;
- stack_offset = NBPG * (UPAGES + u.u_dsize);
- reg_offset = (int) u.u_ar0 - KERNEL_U_ADDR;
-
- /* I don't know where to find this info.
- So, for now, mark it as not available. */
- core_aouthdr.a_magic = 0;
-#endif /* not mac_aux */
-#endif /* not UMAX_CORE */
-
- /* Read the register values out of the core file and store
- them where `read_register' will find them. */
-
- {
- register int regno;
-
- for (regno = 0; regno < NUM_REGS; regno++)
- {
- char buf[MAX_REGISTER_RAW_SIZE];
-
- val = lseek (corechan, register_addr (regno, reg_offset), 0);
- if (val < 0)
- perror_with_name (filename);
-
- val = myread (corechan, buf, sizeof buf);
- if (val < 0)
- perror_with_name (filename);
- supply_register (regno, buf);
- }
- }
- }
-#endif /* not NEW_SUN_CORE */
- if (filename[0] == '/')
- corefile = savestring (filename, strlen (filename));
- else
- {
- char dirname[MAXPATHLEN];
-
- getwd (dirname);
- corefile = concat (dirname, "/", filename);
- }
-
- set_current_frame (read_register (FP_REGNUM));
- select_frame (get_current_frame (), 0);
- validate_files ();
- }
- else if (from_tty)
- printf ("No core file now.\n");
-}
-\f
-exec_file_command (filename, from_tty)
- char *filename;
- int from_tty;
-{
- int val;
-
- /* Eliminate all traces of old exec file.
- Mark text segment as empty. */
-
- if (execfile)
- free (execfile);
- execfile = 0;
- data_start = 0;
- data_end -= exec_data_start;
- text_start = 0;
- text_end = 0;
- exec_data_start = 0;
- exec_data_end = 0;
- if (execchan >= 0)
- close (execchan);
- execchan = -1;
-
- /* Now open and digest the file the user requested, if any. */
-
- if (filename)
- {
- execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
- &execfile);
- if (execchan < 0)
- perror_with_name (filename);
-
-#ifdef COFF_FORMAT
- {
- int aout_hdrsize;
- int num_sections;
-
- if (read_file_hdr (execchan, &file_hdr) < 0)
- error ("\"%s\": not in executable format.", execfile);
-
- aout_hdrsize = file_hdr.f_opthdr;
- num_sections = file_hdr.f_nscns;
-
- if (read_aout_hdr (execchan, &exec_aouthdr, aout_hdrsize) < 0)
- error ("\"%s\": can't read optional aouthdr", execfile);
-
- if (read_section_hdr (execchan, _TEXT, &text_hdr, num_sections) < 0)
- error ("\"%s\": can't read text section header", execfile);
-
- if (read_section_hdr (execchan, _DATA, &data_hdr, num_sections) < 0)
- error ("\"%s\": can't read data section header", execfile);
-
- text_start = exec_aouthdr.text_start;
- text_end = text_start + exec_aouthdr.tsize;
- text_offset = text_hdr.s_scnptr;
- exec_data_start = exec_aouthdr.data_start;
- exec_data_end = exec_data_start + exec_aouthdr.dsize;
- exec_data_offset = data_hdr.s_scnptr;
- data_start = exec_data_start;
- data_end += exec_data_start;
- exec_mtime = file_hdr.f_timdat;
- }
-#else /* not COFF_FORMAT */
- {
- struct stat st_exec;
-
- val = myread (execchan, &exec_aouthdr, sizeof (AOUTHDR));
-
- if (val < 0)
- perror_with_name (filename);
-
- text_start = N_TXTADDR (exec_aouthdr);
- text_end = text_start + exec_aouthdr.a_text;
- text_offset = N_TXTOFF (exec_aouthdr);
- exec_data_start = N_DATADDR (exec_aouthdr);
- exec_data_end = exec_data_start + exec_aouthdr.a_data;
- exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;
- data_start = exec_data_start;
- data_end += exec_data_start;
-
- fstat (execchan, &st_exec);
- exec_mtime = st_exec.st_mtime;
- }
-#endif /* not COFF_FORMAT */
-
- validate_files ();
- }
- else if (from_tty)
- printf ("No exec file now.\n");
-
- /* Tell display code (if any) about the changed file name. */
- if (exec_file_display_hook)
- (*exec_file_display_hook)
- (filename ? filename : "No executable specified.\n");
-}
-
-/* Call this to specify the hook for exec_file_command to call back.
- This is called from the x-window display code. */
-
-specify_exec_file_hook (hook)
- void (*hook) ();
-{
- exec_file_display_hook = hook;
-}
-
-/* The exec file must be closed before running an inferior.
- If it is needed again after the inferior dies, it must
- be reopened. */
-
-close_exec_file ()
-{
- if (execchan >= 0)
- close (execchan);
- execchan = -1;
-}
-
-reopen_exec_file ()
-{
- if (execchan < 0 && execfile != 0)
- {
- char *filename = concat (execfile, "", "");
- exec_file_command (filename, 0);
- free (filename);
- }
-}
-\f
-/* If we have both a core file and an exec file,
- print a warning if they don't go together.
- This should really check that the core file came
- from that exec file, but I don't know how to do it. */
-
-static void
-validate_files ()
-{
- if (execfile != 0 && corefile != 0)
- {
- struct stat st_core;
-
- fstat (corechan, &st_core);
-
- if (core_aouthdr.a_magic != 0
- && bcmp (&core_aouthdr, &exec_aouthdr, sizeof core_aouthdr))
- printf ("Warning: core file does not match specified executable file.\n");
- else if (exec_mtime > st_core.st_mtime)
- printf ("Warning: exec file is newer than core file.\n");
- }
-}
-
-char *
-get_exec_file ()
-{
- if (execfile == 0)
- error ("No executable file specified.\n\
-Use the \"exec-file\" and \"symbol-file\" commands.");
- return execfile;
-}
-
-int
-have_core_file_p ()
-{
- return corefile != 0;
-}
-
-static void
-files_info ()
-{
- char *symfile;
- extern char *get_sym_file ();
-
- if (execfile)
- printf ("Executable file \"%s\".\n", execfile);
- else
- printf ("No executable file\n");
- if (corefile == 0)
- printf ("No core dump file\n");
- else
- printf ("Core dump file \"%s\".\n", corefile);
-
- if (have_inferior_p ())
- printf ("Using the running image of the program, rather than these files.\n");
-
- symfile = get_sym_file ();
- if (symfile != 0)
- printf ("Symbols loaded from \"%s\".\n", symfile);
-
- if (! have_inferior_p ())
- {
- if (execfile)
- {
- printf ("Text segment from 0x%x to 0x%x.\n",
- text_start, text_end);
- }
- if (corefile)
- {
- printf ("Data segment from 0x%x to 0x%x.\nStack segment from 0x%x to 0x%x.\n",
- data_start, data_end, stack_start, stack_end);
- }
- else
- {
- printf ("Data segment in executable from 0x%x to 0x%x.\n",
- exec_data_start, exec_data_end);
- }
- }
-}
-\f
-/* Read "memory data" from core file and/or executable file */
-
-read_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
-{
- if (have_inferior_p ())
- read_inferior_memory (memaddr, myaddr, len);
- else
- xfer_core_file (memaddr, myaddr, len, 0);
-}
-
-/* Write LEN bytes of data starting at address MYADDR
- into debugged program memory at address MEMADDR.
- Returns zero if successful, or an errno value if ptrace failed. */
-
-int
-write_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
-{
- if (have_inferior_p ())
- return write_inferior_memory (memaddr, myaddr, len);
- else
- error ("Can write memory only when program being debugged is running.");
-}
-
-xfer_core_file (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
-{
- register int i;
- register int val;
- int xferchan;
- char **xferfile;
- int fileptr;
-
- while (len > 0)
- {
- xferfile = 0;
- xferchan = 0;
-
- /* Determine which file the next bunch of addresses reside in,
- and where in the file. Set the file's read/write pointer
- to point at the proper place for the desired address
- and set xferfile and xferchan for the correct file.
- If desired address is nonexistent, leave them zero.
- i is set to the number of bytes that can be handled
- along with the next address. */
-
- if (memaddr < text_start)
- {
- i = min (len, text_start - memaddr);
- }
- else if (memaddr >= text_end && memaddr < data_start)
- {
- i = min (len, data_start - memaddr);
- }
- else if (memaddr >= (corechan >= 0 ? data_end : exec_data_end)
- && memaddr < stack_start)
- {
- i = min (len, stack_start - memaddr);
- }
- else if (memaddr >= stack_end && stack_end != 0)
- {
- i = min (len, - memaddr);
- }
- /* Note that if there is no core file
- data_start and data_end are equal. */
- else if (memaddr >= data_start && memaddr < data_end)
- {
- i = min (len, data_end - memaddr);
- fileptr = memaddr - data_start + data_offset;
- xferfile = &corefile;
- xferchan = corechan;
- }
- /* Note that if there is no core file
- stack_start and stack_end are equal. */
- else if (memaddr >= stack_start && memaddr < stack_end)
- {
- i = min (len, stack_end - memaddr);
- fileptr = memaddr - stack_start + stack_offset;
- xferfile = &corefile;
- xferchan = corechan;
- }
- else if (corechan < 0
- && memaddr >= exec_data_start && memaddr < exec_data_end)
- {
- i = min (len, exec_data_end - memaddr);
- fileptr = memaddr - exec_data_start + exec_data_offset;
- xferfile = &execfile;
- xferchan = execchan;
- }
- else if (memaddr >= text_start && memaddr < text_end)
- {
- i = min (len, text_end - memaddr);
- fileptr = memaddr - text_start + text_offset;
- xferfile = &execfile;
- xferchan = execchan;
- }
-
- /* Now we know which file to use.
- Set up its pointer and transfer the data. */
- if (xferfile)
- {
- if (*xferfile == 0)
- if (xferfile == &execfile)
- error ("No program file to examine.");
- else
- error ("No core dump file or running program to examine.");
- val = lseek (xferchan, fileptr, 0);
- if (val < 0)
- perror_with_name (*xferfile);
- val = myread (xferchan, myaddr, i);
- if (val < 0)
- perror_with_name (*xferfile);
- }
- /* If this address is for nonexistent memory,
- read zeros if reading, or do nothing if writing. */
- else
- bzero (myaddr, i);
-
- memaddr += i;
- myaddr += i;
- len -= i;
- }
-}
-\f
-/* My replacement for the read system call.
- Used like `read' but keeps going if `read' returns too soon. */
-
-myread (desc, addr, len)
- int desc;
- char *addr;
- int len;
-{
- register int val;
- int orglen = len;
-
- while (len > 0)
- {
- val = read (desc, addr, len);
- if (val < 0)
- return val;
- if (val == 0)
- return orglen - len;
- len -= val;
- addr += val;
- }
-}
-\f
-#ifndef NEW_SUN_CORE
-
-/* Return the address in the core dump or inferior of register REGNO.
- BLOCKEND is the address of the end of the user structure. */
-
-unsigned int
-register_addr (regno, blockend)
- int regno;
- int blockend;
-{
- int addr;
-
- if (regno < 0 || regno >= NUM_REGS)
- error ("Invalid register number %d.", regno);
-
-#ifdef mac_aux
-/* FIXME, we don't know where the regs are. Maybe the test command
- * that tests what parts of the upage are writeable will find 'em for us.
- */
-#define REGISTER_U_ADDR(addr, foo, bar) addr = 0;
-#endif
- REGISTER_U_ADDR (addr, blockend, regno);
-
- return addr;
-}
-
-#endif /* not NEW_SUN_CORE */
-\f
-static
-initialize ()
-{
- corechan = -1;
- execchan = -1;
- corefile = 0;
- execfile = 0;
- exec_file_display_hook = 0;
-
- text_start = 0;
- text_end = 0;
- data_start = 0;
- data_end = 0;
- exec_data_start = 0;
- exec_data_end = 0;
- stack_start = STACK_END_ADDR;
- stack_end = STACK_END_ADDR;
-
- add_com ("core-file", class_files, core_file_command,
- "Use FILE as core dump for examining memory and registers.\n\
-No arg means have no core file.");
- add_com ("exec-file", class_files, exec_file_command,
- "Use FILE as program for getting contents of pure memory.\n\
-If FILE cannot be found as specified, your execution directory path\n\
-is searched for a command of that name.\n\
-No arg means have no executable file.");
- add_info ("files", files_info, "Names of files being debugged.");
-}
-
-END_FILE
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d27 1
-d44 5
-d50 4
-a53 1
-#endif
-d240 10
-d259 1
-d675 6
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.06.19; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.26.01.19.05; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Original from RMS's wheaties devl sources
-@
-
-
-1.2
-log
-@Add local sys_siglist for a/ux because they don't provide one, sigh.
-@
-text
-@/* Memory-access and commands for inferior process, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include "defs.h"
-#include "initialize.h"
-#include "symtab.h"
-#include "param.h"
-#include "frame.h"
-#include "inferior.h"
-#include "environ.h"
-#include "value.h"
-
-#include <stdio.h>
-#include <signal.h>
-#include <sys/param.h>
-
-#ifdef mac_aux
-/* Warning! This table is positional and highly dependent on the local
- system. Check it closely against <sys/signal.h> when porting. */
-char *sys_siglist[] = {
- "Signal 0",
- "Hangup",
- "Interrupt",
- "Quit",
- "Invalid instruction",
- "Trace/breakpoint trap",
- "IOT trap",
- "EMT trap",
- "Floating point exception",
- "Killed",
- "Bus error",
- "Segmentation fault",
- "Bad system call",
- "Broken pipe",
- "Alarm clock",
- "Terminated",
- "User signal 1",
- "User signal 2",
- "Child exited",
- "Power-fail restart",
- "Stopped",
- "Stopped (tty input)",
- "Stopped (tty output)",
- "Stopped (signal)",
- "Cputime limit exceeded",
- "File size limit exceeded",
- "Virtual timer expired",
- "Profiling timer expired",
- "Window changed",
- "Continued",
- "Urgent I/O condition",
- "I/O possible",
-};
-#else
-/* More portable systems do it for you */
-extern char *sys_siglist[];
-#endif
-
-#define ERROR_NO_INFERIOR \
- if (inferior_pid == 0) error ("The program is not being run.");
-
-/* String containing arguments to give to the program,
- with a space added at the front. Just a space means no args. */
-
-static char *inferior_args;
-
-/* File name for default use for standard in/out in the inferior. */
-
-char *inferior_io_terminal;
-
-/* Pid of our debugged inferior, or 0 if no inferior now. */
-
-int inferior_pid;
-
-/* Last signal that the inferior received (why it stopped). */
-
-int stop_signal;
-
-/* Address at which inferior stopped. */
-
-CORE_ADDR stop_pc;
-
-/* Stack frame when program stopped. */
-
-FRAME stop_frame;
-
-/* Number of breakpoint it stopped at, or 0 if none. */
-
-int stop_breakpoint;
-
-/* Nonzero if stopped due to a step command. */
-
-int stop_step;
-
-/* Nonzero if stopped due to completion of a stack dummy routine. */
-
-int stop_stack_dummy;
-
-/* Range to single step within.
- If this is nonzero, respond to a single-step signal
- by continuing to step if the pc is in this range. */
-
-CORE_ADDR step_range_start; /* Inclusive */
-CORE_ADDR step_range_end; /* Exclusive */
-
-/* Stack frame address as of when stepping command was issued.
- This is how we know when we step into a subroutine call,
- and how to set the frame for the breakpoint used to step out. */
-
-CORE_ADDR step_frame;
-
-/* 1 means step over all subroutine calls.
- -1 means step over calls to undebuggable functions. */
-
-int step_over_calls;
-
-/* If stepping, nonzero means step count is > 1
- so don't print frame next time inferior stops
- if it stops due to stepping. */
-
-int step_multi;
-
-/* Environment to use for running inferior,
- in format described in environ.h. */
-
-struct environ *inferior_environ;
-
-CORE_ADDR read_pc ();
-struct command_line *get_breakpoint_commands ();
-
-START_FILE
-\f
-int
-have_inferior_p ()
-{
- return inferior_pid != 0;
-}
-
-static void
-set_args_command (args)
- char *args;
-{
- free (inferior_args);
- if (!args) args = "";
- inferior_args = concat (" ", args, "");
-}
-
-void
-tty_command (file)
- char *file;
-{
- if (file == 0)
- error_no_arg ("terminal name for running target process");
-
- inferior_io_terminal = savestring (file, strlen (file));
-}
-
-static void
-run_command (args, from_tty)
- char *args;
- int from_tty;
-{
- extern char **environ;
- register int i;
- char *exec_file;
- char *allargs;
-
- extern int sys_nerr;
- extern char *sys_errlist[];
- extern int errno;
-
- dont_repeat ();
-
- if (inferior_pid)
- {
- if (query ("The program being debugged has been started already.\n\
-Start it from the beginning? "))
- kill_inferior ();
- else
- error ("Program already started.");
- }
-
- if (args)
- set_args_command (args);
-
- exec_file = (char *) get_exec_file ();
- if (from_tty)
- {
- printf ("Starting program: %s%s\n",
- exec_file, inferior_args);
- fflush (stdout);
- }
-
- allargs = concat ("exec ", exec_file, inferior_args);
- inferior_pid = create_inferior (allargs, environ_vector (inferior_environ));
-
- clear_proceed_status ();
-
- start_inferior ();
-}
-\f
-void
-cont_command (proc_count_exp, from_tty)
- char *proc_count_exp;
- int from_tty;
-{
- ERROR_NO_INFERIOR;
-
- clear_proceed_status ();
-
- /* If have argument, set proceed count of breakpoint we stopped at. */
-
- if (stop_breakpoint && proc_count_exp)
- {
- set_ignore_count (stop_breakpoint,
- parse_and_eval_address (proc_count_exp) - 1,
- from_tty);
- if (from_tty)
- printf (" ");
- }
-
- if (from_tty)
- printf ("Continuing.\n");
-
- proceed (-1, -1, 0);
-}
-\f
-/* Step until outside of current statement. */
-static void step_1 ();
-
-static void
-step_command (count_string)
-{
- step_1 (0, 0, count_string);
-}
-
-/* Likewise, but skip over subroutine calls as if single instructions. */
-
-static void
-next_command (count_string)
-{
- step_1 (1, 0, count_string);
-}
-
-/* Likewise, but step only one instruction. */
-
-static void
-stepi_command (count_string)
-{
- step_1 (0, 1, count_string);
-}
-
-static void
-nexti_command (count_string)
-{
- step_1 (1, 1, count_string);
-}
-
-static void
-step_1 (skip_subroutines, single_inst, count_string)
- int skip_subroutines;
- int single_inst;
- char *count_string;
-{
- register int count = 1;
-
- ERROR_NO_INFERIOR;
- count = count_string ? parse_and_eval_address (count_string) : 1;
-
- for (; count > 0; count--)
- {
- clear_proceed_status ();
-
- step_frame = get_current_frame ();
-
- if (! single_inst)
- {
- find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
- if (step_range_end == 0)
- {
- terminal_ours ();
- error ("Current function has no line number information.");
- }
- }
- else
- {
- /* Say we are stepping, but stop after one insn whatever it does.
- Don't step through subroutine calls even to undebuggable functions. */
- step_range_start = step_range_end = 1;
- if (!skip_subroutines)
- step_over_calls = 0;
- }
-
- if (skip_subroutines)
- step_over_calls = 1;
-
- step_multi = (count > 1);
- proceed (-1, -1, 1);
- if (! stop_step)
- break;
- }
-}
-\f
-/* Continue program at specified address. */
-
-static void
-jump_command (arg, from_tty)
- char *arg;
- int from_tty;
-{
- register CORE_ADDR addr;
- struct symtab_and_line sal;
-
- ERROR_NO_INFERIOR;
-
- if (!arg)
- error_no_arg ("starting address");
-
- sal = decode_line_spec (arg, 1);
-
- if (sal.symtab == 0 && sal.pc == 0)
- error ("No source file has been specified.");
-
- if (sal.pc == 0)
- sal.pc = find_line_pc (sal.symtab, sal.line);
-
- {
- struct symbol *fn = get_frame_function (get_current_frame ());
- struct symbol *sfn = find_pc_function (sal.pc);
- if (fn != 0 && sfn != fn
- && ! query ("That is not in function %s. Continue there? ",
- sal.line, SYMBOL_NAME (fn)))
- error ("Not confirmed.");
- }
-
- if (sal.pc == 0)
- error ("No line %d in file \"%s\".", sal.line, sal.symtab->filename);
-
- addr = sal.pc;
-
- clear_proceed_status ();
-
- if (from_tty)
- printf ("Continuing at 0x%x.\n", addr);
-
- proceed (addr, 0, 0);
-}
-
-/* Continue program giving it specified signal. */
-
-static void
-signal_command (signum_exp, from_tty)
- char *signum_exp;
- int from_tty;
-{
- register int signum;
-
- dont_repeat (); /* Too dangerous. */
- ERROR_NO_INFERIOR;
-
- if (!signum_exp)
- error_no_arg ("signal number");
-
- signum = parse_and_eval_address (signum_exp);
-
- clear_proceed_status ();
-
- if (from_tty)
- printf ("Continuing with signal %d.\n", signum);
-
- proceed (stop_pc, signum, 0);
-}
-
-/* Execute a "stack dummy", a piece of code stored in the stack
- by the debugger to be executed in the inferior.
-
- To call: first, do PUSH_DUMMY_FRAME.
- Then push the contents of the dummy. It should end with a breakpoint insn.
- Then call here, passing address at which to start the dummy.
-
- The contents of all registers are saved before the dummy frame is popped
- and copied into the buffer BUFFER.
-
- The dummy's frame is automatically popped whenever that break is hit.
- If that is the first time the program stops, run_stack_dummy
- returns to its caller with that frame already gone.
- Otherwise, the caller never gets returned to. */
-
-/* 4 => return instead of letting the stack dummy run. */
-
-static int stack_dummy_testing = 0;
-
-void
-run_stack_dummy (addr, buffer)
- CORE_ADDR addr;
- REGISTER_TYPE *buffer;
-{
- int saved_pc_changed = pc_changed;
- int saved_stop_signal = stop_signal;
- int saved_stop_pc = stop_pc;
- int saved_stop_frame = stop_frame;
- int saved_stop_breakpoint = stop_breakpoint;
- int saved_stop_step = stop_step;
- int saved_stop_stack_dummy = stop_stack_dummy;
- FRAME saved_selected_frame;
- int saved_selected_level;
- struct command_line *saved_breakpoint_commands
- = get_breakpoint_commands ();
-
- record_selected_frame (&saved_selected_frame, &saved_selected_level);
-
- /* Now proceed, having reached the desired place. */
- clear_proceed_status ();
- if (stack_dummy_testing & 4)
- {
- POP_FRAME;
- return;
- }
- proceed (addr, 0, 0);
-
- if (!stop_stack_dummy)
- error ("Cannot continue previously requested operation.");
-
- set_breakpoint_commands (saved_breakpoint_commands);
- select_frame (saved_selected_frame, saved_selected_level);
- stop_signal = saved_stop_signal;
- stop_pc = saved_stop_pc;
- stop_frame = saved_stop_frame;
- stop_breakpoint = saved_stop_breakpoint;
- stop_step = saved_stop_step;
- stop_stack_dummy = saved_stop_stack_dummy;
- pc_changed = saved_pc_changed;
-
- /* On return, the stack dummy has been popped already. */
-
- bcopy (stop_registers, buffer, sizeof stop_registers);
-}
-\f
-/* "finish": Set a temporary breakpoint at the place
- the selected frame will return to, then continue. */
-
-static void
-finish_command (arg, from_tty)
- char *arg;
- int from_tty;
-{
- struct symtab_and_line sal;
- register FRAME frame;
- struct frame_info fi;
-
- register struct symbol *function;
-
- if (!have_inferior_p ())
- error ("The program is not being run.");
- if (arg)
- error ("The \"finish\" command does not take any arguments.");
-
- frame = get_prev_frame (selected_frame);
- if (frame == 0)
- error ("\"finish\" not meaningful in the outermost frame.");
-
- clear_proceed_status ();
-
- fi = get_frame_info (frame);
- sal = find_pc_line (fi.pc, 0);
- sal.pc = fi.pc;
- set_momentary_breakpoint (sal, frame);
-
- /* Find the function we will return from. */
-
- fi = get_frame_info (fi.next_frame);
- function = find_pc_function (fi.pc);
-
- if (from_tty)
- {
- printf ("Run till exit from ");
- print_selected_frame ();
- }
-
- proceed (-1, -1, 0);
-
- if (stop_breakpoint == -3 && function != 0)
- {
- struct type *value_type;
- register value val;
-
- if (TYPE_CODE (SYMBOL_TYPE (function)) != TYPE_CODE_VOID)
- value_type = SYMBOL_TYPE (function);
- else
- return;
-
- val = value_being_returned (value_type, stop_registers);
- printf ("Value returned is $%d = ", record_latest_value (val));
- value_print (val, stdout);
- putchar ('\n');
- }
-}
-\f
-static void
-program_info ()
-{
- if (inferior_pid == 0)
- {
- printf ("The program being debugged is not being run.\n");
- return;
- }
-
- printf ("Program being debugged is in process %d, stopped at 0x%x.\n",
- inferior_pid, stop_pc);
- if (stop_step)
- printf ("It stopped after being stepped.\n");
- else if (stop_breakpoint)
- printf ("It stopped at breakpoint %d.\n", stop_breakpoint);
- else if (stop_signal)
- printf ("It stopped with signal %d (%s).\n",
- stop_signal, sys_siglist[stop_signal]);
-
- printf ("\nType \"info stack\" or \"info reg\" for more information.\n");
-}
-\f
-static void
-environment_info (var)
- char *var;
-{
- if (var)
- {
- register char *val = get_in_environ (inferior_environ, var);
- if (val)
- printf ("%s = %s\n", var, val);
- else
- printf ("Environment variable \"%s\" not defined.\n", var);
- }
- else
- {
- register char **vector = environ_vector (inferior_environ);
- while (*vector)
- printf ("%s\n", *vector++);
- }
-}
-
-static void
-set_environment_command (arg)
- char *arg;
-{
- register char *p, *val, *var;
-
- if (arg == 0)
- error_no_arg ("environment variable and value");
-
- p = (char *) index (arg, '=');
- val = (char *) index (arg, ' ');
- if (p != 0 && val != 0)
- p = arg + min (p - arg, val - arg);
- else if (val != 0 && p == 0)
- p = val;
-
- if (p == 0)
- error ("Space or \"=\" must separate variable name and its value");
- if (p[1] == 0)
- error_no_arg ("value for the variable");
- if (p == arg)
- error_no_arg ("environment variable to set");
-
- val = p + 1;
- while (*val == ' ' || *val == '\t') val++;
- while (p != arg && (p[-1] == ' ' || p[-1] == '\t')) p--;
-
- var = savestring (arg, p - arg);
- set_in_environ (inferior_environ, var, val);
- free (var);
-}
-
-static void
-unset_environment_command (var)
- char *var;
-{
- if (var == 0)
- error_no_arg ("environment variable");
-
- unset_in_environ (inferior_environ, var);
-}
-\f
-/* Read an integer from debugged memory, given address and number of bytes. */
-
-read_memory_integer (memaddr, len)
- CORE_ADDR memaddr;
- int len;
-{
- char cbuf;
- short sbuf;
- int ibuf;
- long lbuf;
-
- if (len == sizeof (char))
- {
- read_memory (memaddr, &cbuf, len);
- return cbuf;
- }
- if (len == sizeof (short))
- {
- read_memory (memaddr, &sbuf, len);
- return sbuf;
- }
- if (len == sizeof (int))
- {
- read_memory (memaddr, &ibuf, len);
- return ibuf;
- }
- if (len == sizeof (lbuf))
- {
- read_memory (memaddr, &lbuf, len);
- return lbuf;
- }
- error ("Cannot handle integers of %d bytes.", len);
-}
-\f
-CORE_ADDR
-read_pc ()
-{
- return (CORE_ADDR) read_register (PC_REGNUM);
-}
-
-write_pc (val)
- CORE_ADDR val;
-{
- write_register (PC_REGNUM, (long) val);
-}
-
-char *reg_names[] = REGISTER_NAMES;
-
-static void
-registers_info (addr_exp)
- char *addr_exp;
-{
- register int i;
- int regnum;
-
- if (addr_exp)
- {
- if (*addr_exp >= '0' && *addr_exp <= '9')
- regnum = atoi (addr_exp);
- else
- {
- register char *p = addr_exp;
- if (p[0] == '$')
- p++;
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (!strcmp (p, reg_names[regnum]))
- break;
- if (regnum == NUM_REGS)
- error ("%s: invalid register name.", addr_exp);
- }
- }
- else
- printf ("Reg\tContents\n\n");
-
- for (i = 0; i < NUM_REGS; i++)
- {
- unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
- unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
- REGISTER_TYPE val;
-
- if (addr_exp != 0 && i != regnum)
- continue;
-
- /* On machines with lots of registers, pause every 16 lines
- so user can read the output. */
- if (addr_exp == 0 && i > 0 && i % 16 == 0)
- {
- printf ("--Type Return to print more--");
- fflush (stdout);
- read_line ();
- }
-
- /* Get the data in raw format, then convert also to virtual format. */
- read_relative_register_raw_bytes (i, raw_buffer);
- REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
-
- printf ("%s\t", reg_names[i]);
-
- /* If virtual format is floating, print it that way. */
- if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT
- && ! INVALID_FLOAT (virtual_buffer, REGISTER_VIRTUAL_SIZE (i)))
- val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout);
- /* Else if virtual format is too long for printf,
- print in hex a byte at a time. */
- else if (REGISTER_VIRTUAL_SIZE (i) > sizeof (long))
- {
- register int j;
- printf ("0x");
- for (j = 0; j < REGISTER_VIRTUAL_SIZE (i); j++)
- printf ("%02x", virtual_buffer[j]);
- }
- /* Else print as integer in hex and in decimal. */
- else
- {
- long val;
-
- bcopy (virtual_buffer, &val, sizeof (long));
- if (val == 0)
- printf ("0");
- else
- printf ("0x%08x %d", val, val);
- }
-
- /* If register has different raw and virtual formats,
- print the raw format in hex now. */
-
- if (REGISTER_CONVERTIBLE (i))
- {
- register int j;
-
- printf (" (raw 0x");
- for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
- printf ("%02x", raw_buffer[j]);
- printf (")");
- }
- printf ("\n");
- }
-
- printf ("Contents are relative to selected stack frame.\n");
-}
-\f
-#ifdef ATTACH_DETACH
-/*
- * TODO:
- * Should save/restore the tty state since it might be that the
- * program to be debugged was started on this tty and it wants
- * the tty in some state other than what we want. If it's running
- * on another terminal or without a terminal, then saving and
- * restoring the tty state is a harmless no-op.
- */
-
-/*
- * attach_command --
- * takes a program started up outside of gdb and ``attaches'' to it.
- * This stops it cold in it's tracks and allows us to start tracing
- * it. For this to work, we must be able to send the process a
- * signal and we must have the same effective uid as the program.
- */
-static void
-attach_command (args, from_tty)
- char *args;
- int from_tty;
-{
- char *exec_file;
- int pid;
-
- dont_repeat();
-
- if (!args)
- error_no_arg ("process-id to attach");
- else
- pid = atoi (args);
-
- if (inferior_pid)
- {
- if (query ("A program is being debugged already. Kill it? "))
- kill_inferior ();
- else
- error ("Inferior not killed.");
- }
-
- exec_file = (char *) get_exec_file ();
-
- if (from_tty)
- {
- printf ("Attaching program: %s pid %d\n",
- exec_file, pid);
- fflush (stdout);
- }
-
- attach_program (pid);
-}
-
-/*
- * detach_command --
- * takes a program previously attached to and detaches it.
- * The program resumes execution and will no longer stop
- * on signals, etc. We better not have left any breakpoints
- * in the program or it'll die when it hits one. For this
- * to work, it may be necessary for the process to have been
- * previously attached. It *might* work if the program was
- * started via the normal ptrace (PTRACE_TRACEME).
- */
-
-static void
-detach_command (args, from_tty)
- char *args;
- int from_tty;
-{
- char *exec_file = (char *)get_exec_file ();
- int signal = 0;
-
- if (!inferior_pid)
- error ("Not currently tracing a program\n");
- if (from_tty)
- {
- printf ("Detaching program: %s pid %d\n",
- exec_file, inferior_pid);
- fflush (stdout);
- }
- if (args)
- signal = atoi (args);
-
- detach (signal);
- inferior_pid = 0;
-}
-#endif /* ATTACH_DETACH */
-\f
-static
-initialize ()
-{
- add_com ("tty", class_run, tty_command,
- "Set terminal for future runs of program being debugged.");
-
- add_com ("set-args", class_run, set_args_command,
- "Specify arguments to give program being debugged when it is started.\n\
-Follow this command with any number of args, to be passed to the program.");
-
- add_info ("environment", environment_info,
- "The environment to give the program, or one variable's value.\n\
-With an argument VAR, prints the value of environment variable VAR to\n\
-give the program being debugged. With no arguments, prints the entire\n\
-environment to be given to the program.");
-
- add_com ("unset-environment", class_run, unset_environment_command,
- "Cancel environment variable VAR for the program.\n\
-This does not affect the program until the next \"run\" command.");
- add_com ("set-environment", class_run, set_environment_command,
- "Set environment variable value to give the program.\n\
-Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
-VALUES of environment variables are uninterpreted strings.\n\
-This does not affect the program until the next \"run\" command.");
-
-#ifdef ATTACH_DETACH
- add_com ("attach", class_run, attach_command,
- "Attach to a process that was started up outside of GDB.\n\
-To do this, you must have permission to send the process a signal.\n\
-And it must have the same effective uid as the debugger.\n\n\
-Before using \"attach\", you must use the \"exec-file\" command\n\
-to specify the program running in the process,\n\
-and the \"symbol-file\" command to load its symbol table.");
- add_com ("detach", class_run, detach_command,
- "Detach the process previously attached.\n\
-The process is no longer traced and continues its execution.");
-#endif /* ATTACH_DETACH */
-
- add_com ("signal", class_run, signal_command,
- "Continue program giving it signal number SIGNUMBER.");
-
- add_com ("stepi", class_run, stepi_command,
- "Step one instruction exactly.\n\
-Argument N means do this N times (or till program stops for another reason).");
- add_com_alias ("si", "stepi", class_alias, 0);
-
- add_com ("nexti", class_run, nexti_command,
- "Step one instruction, but proceed through subroutine calls.\n\
-Argument N means do this N times (or till program stops for another reason).");
- add_com_alias ("ni", "nexti", class_alias, 0);
-
- add_com ("finish", class_run, finish_command,
- "Execute until selected stack frame returns.\n\
-Upon return, the value returned is printed and put in the value history.");
-
- add_com ("next", class_run, next_command,
- "Step program, proceeding through subroutine calls.\n\
-Like the \"step\" command as long as subroutine calls do not happen;\n\
-when they do, the call is treated as one instruction.\n\
-Argument N means do this N times (or till program stops for another reason).");
- add_com_alias ("n", "next", class_run, 1);
-
- add_com ("step", class_run, step_command,
- "Step program until it reaches a different source line.\n\
-Argument N means do this N times (or till program stops for another reason).");
- add_com_alias ("s", "step", class_run, 1);
-
- add_com ("jump", class_run, jump_command,
- "Continue program being debugged at specified line or address.\n\
-Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
-for an address to start at.");
-
- add_com ("cont", class_run, cont_command,
- "Continue program being debugged, after signal or breakpoint.\n\
-If proceeding from breakpoint, a number N may be used as an argument:\n\
-then the same breakpoint won't break until the Nth time it is reached.");
- add_com_alias ("c", "cont", class_run, 1);
-
- add_com ("run", class_run, run_command,
- "Start debugged program. You may specify arguments to give it.\n\
-Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
-Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
-With no arguments, uses arguments last specified (with \"run\" or \"set-args\".\n\
-To cancel previous arguments and run with no arguments,\n\
-use \"set-args\" without arguments.");
- add_com_alias ("r", "run", class_run, 1);
-
- add_info ("registers", registers_info,
- "List of registers and their contents, for selected stack frame.\n\
-Register name as argument means describe only that register.");
-
- add_info ("program", program_info,
- "Execution status of the program.");
-
- inferior_args = savestring (" ", 1); /* By default, no args. */
- inferior_environ = make_environ ();
- init_environ (inferior_environ);
-}
-
-END_FILE
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d34 39
-d74 1
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.07.38; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.21.05.04.57; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@From RMS's development sources on wheaties, 20Jan88
-@
-
-
-1.2
-log
-@Major Sys V tty changes, and a few changes to try to find the registers
-in the upage (untested yet).
-@
-text
-@/* Low level interface to ptrace, for GDB when running under Unix.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include "defs.h"
-#include "initialize.h"
-#include "param.h"
-#include "frame.h"
-#include "inferior.h"
-
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/dir.h>
-#include <signal.h>
-#include <sys/ioctl.h>
-#include <sgtty.h>
-#include <fcntl.h>
-
-#ifdef mac_aux
-#include <sys/seg.h>
-#include <sys/mmu.h>
-#include <sys/signal.h>
-#include <sys/time.h>
-#include <sys/user.h>
-#else
-#include <sys/user.h>
-#endif /* mac_aux */
-
-
-#ifdef UMAX_PTRACE
-#include <a.out.h>
-#endif
-
-#ifdef NEW_SUN_PTRACE
-#include <sys/ptrace.h>
-#include <machine/reg.h>
-#endif
-
-#ifdef SYSV_TTYS
-#include <termio.h>
-#endif
-
-extern int errno;
-
-/* Nonzero if we are debugging an attached outside process
- rather than an inferior. */
-
-static int attach_flag;
-
-#define UPAGE_MASK 0x00003FFF
-
-START_FILE
-\f
-/* Record terminal status separately for debugger and inferior. */
-
-#ifdef SYSV_TTYS
-static struct termio ti_inferior;
-#else
-static struct sgttyb sg_inferior;
-static struct tchars tc_inferior;
-static struct ltchars ltc_inferior;
-static int lmode_inferior;
-#endif
-static int tflags_inferior;
-static int pgrp_inferior;
-
-#ifdef SYSV_TTYS
-static struct termio ti_ours;
-#else
-static struct sgttyb sg_ours;
-static struct tchars tc_ours;
-static struct ltchars ltc_ours;
-static int lmode_ours;
-#endif
-static int tflags_ours;
-static int pgrp_ours;
-
-/* Copy of inferior_io_terminal when inferior was last started. */
-static char *inferior_thisrun_terminal;
-
-static void terminal_ours_1 ();
-
-/* Nonzero if our terminal settings are in effect.
- Zero if the inferior's settings are in effect. */
-static int terminal_is_ours;
-
-/* Initialize the terminal settings we record for the inferior,
- before we actually run the inferior. */
-
-void
-terminal_init_inferior ()
-{
-
-#ifdef SYSV_TTYS
- ti_inferior = ti_ours;
-#else
- sg_inferior = sg_ours;
- tc_inferior = tc_ours;
- ltc_inferior = ltc_ours;
- lmode_inferior = lmode_ours;
-#endif
- tflags_inferior = tflags_ours;
- pgrp_inferior = inferior_pid;
-
- terminal_is_ours = 1;
-}
-
-/* Put the inferior's terminal settings into effect.
- This is preparation for starting or resuming the inferior. */
-
-void
-terminal_inferior ()
-{
- if (terminal_is_ours) /* && inferior_thisrun_terminal == 0) */
- {
- fcntl (0, F_SETFL, tflags_inferior);
- fcntl (0, F_SETFL, tflags_inferior);
-#ifdef SYSV_TTYS
- ioctl (0, TCSETA, &ti_inferior);
-#else
- ioctl (0, TIOCSETN, &sg_inferior);
- ioctl (0, TIOCSETC, &tc_inferior);
- ioctl (0, TIOCSLTC, <c_inferior);
- ioctl (0, TIOCLSET, &lmode_inferior);
-#endif
- ioctl (0, TIOCSPGRP, &pgrp_inferior);
- }
- terminal_is_ours = 0;
-}
-
-/* Put some of our terminal settings into effect,
- enough to get proper results from our output,
- but do not change into or out of RAW mode
- so that no input is discarded.
-
- After doing this, either terminal_ours or terminal_inferior
- should be called to get back to a normal state of affairs. */
-
-void
-terminal_ours_for_output ()
-{
- terminal_ours_1 (1);
-}
-
-/* Put our terminal settings into effect.
- First record the inferior's terminal settings
- so they can be restored properly later. */
-
-void
-terminal_ours ()
-{
- terminal_ours_1 (0);
-}
-
-static void
-terminal_ours_1 (output_only)
- int output_only;
-{
- /* Ignore this signal since it will happen when we try to set the pgrp. */
- int (*osigttou) ();
-
- if (!terminal_is_ours) /* && inferior_thisrun_terminal == 0) */
- {
- terminal_is_ours = 1;
-
- osigttou = signal (SIGTTOU, SIG_IGN);
-
- ioctl (0, TIOCGPGRP, &pgrp_inferior);
- ioctl (0, TIOCSPGRP, &pgrp_ours);
-
- signal (SIGTTOU, osigttou);
-
- tflags_inferior = fcntl (0, F_GETFL, 0);
-#ifdef SYSV_TTYS
- ioctl (0, TCGETA, &ti_inferior);
-#else
- ioctl (0, TIOCGETP, &sg_inferior);
- ioctl (0, TIOCGETC, &tc_inferior);
- ioctl (0, TIOCGLTC, <c_inferior);
- ioctl (0, TIOCLGET, &lmode_inferior);
-#endif
- }
-
- fcntl (0, F_SETFL, tflags_ours);
- fcntl (0, F_SETFL, tflags_ours);
-
-
-#ifdef SYSV_TTYS
- ti_ours.c_lflag |= ICANON | ISIG;
- if (output_only)
- ti_ours.c_lflag &= ~((ICANON|ISIG)&ti_inferior.c_lflag);
- ioctl (0, TCSETA, &ti_ours);
- ti_ours.c_lflag |= ICANON | ISIG;
-#else
- sg_ours.sg_flags &= ~RAW & ~CBREAK;
- if (output_only)
- sg_ours.sg_flags |= (RAW | CBREAK) & sg_inferior.sg_flags;
- ioctl (0, TIOCSETN, &sg_ours);
- ioctl (0, TIOCSETC, &tc_ours);
- ioctl (0, TIOCSLTC, <c_ours);
- ioctl (0, TIOCLSET, &lmode_ours);
- sg_ours.sg_flags &= ~RAW & ~CBREAK;
-#endif
-}
-
-static void
-term_status_command ()
-{
- register int i;
- printf ("Inferior's terminal status (currently saved by GDB):\n");
-#ifdef SYSV_TTYS
- printf ("fcntl flags = 0x%x, owner pid = %d.\n",
- tflags_inferior, pgrp_inferior);
- printf ("iflag = 0x%04x, oflag = 0x%04x, cflag = 0x%04x, lflag = 0x%04x\n",
- ti_inferior.c_iflag, ti_inferior.c_oflag,
- ti_inferior.c_cflag, ti_inferior.c_lflag);
- printf ("line discipline = %d\n", ti_inferior.c_line);
- printf ("control chars: ");
- for (i = 0; i < NCC; i++)
- printf ("0x%x ", ti_inferior.c_cc[i]);
- printf ("\n");
-#else
- printf ("fcntl flags = 0x%x, lmode = 0x%x,\nsgttyb.sg_flags = 0x%x, owner pid = %d.\n",
- tflags_inferior, lmode_inferior,
- sg_inferior.sg_flags, pgrp_inferior);
- printf ("tchars: ");
- for (i = 0; i < sizeof (struct tchars); i++)
- printf ("0x%x ", ((char *)&tc_inferior)[i]);
- printf ("\n");
- printf ("ltchars: ");
- for (i = 0; i < sizeof (struct ltchars); i++)
- printf ("0x%x ", ((char *)<c_inferior)[i]);
- printf ("\n");
-#endif
-}
-\f
-static void
-new_tty (ttyname)
- char *ttyname;
-{
- register int tty;
- register int fd;
-
-#if 0
- /* I think it is better not to do this. Then C-z on the GDB terminal
- will still stop the program, while C-z on the data terminal
- will be input. */
-
- /* Disconnect the child process from our controlling terminal. */
- tty = open("/dev/tty", O_RDWR);
- if (tty > 0)
- {
- ioctl(tty, TIOCNOTTY, 0);
- close(tty);
- }
-#endif
- /* Now open the specified new terminal. */
-
- tty = open(ttyname, O_RDWR);
- if (tty == -1)
- _exit(1);
-
- dup2(tty, 0);
- dup2(tty, 1);
- dup2(tty, 2);
- close(tty);
-}
-\f
-/* Start an inferior process and returns its pid.
- ALLARGS is a vector of program-name and args.
- ENV is the environment vector to pass. */
-
-int
-create_inferior (allargs, env)
- char **allargs;
- char **env;
-{
- int pid;
- extern int sys_nerr;
- extern char *sys_errlist[];
- extern int errno;
-
- /* exec is said to fail if the executable is open. */
- close_exec_file ();
-
- pid = vfork ();
- if (pid < 0)
- perror_with_name ("vfork");
-
- if (pid == 0)
- {
- /* Run inferior in a separate process group. */
- setpgrp (getpid (), getpid ());
-
- inferior_thisrun_terminal = inferior_io_terminal;
- if (inferior_io_terminal != 0)
- new_tty (inferior_io_terminal);
-
-/* Not needed on Sun, at least, and loses there
- because it clobbers the superior. */
-/*??? signal (SIGQUIT, SIG_DFL);
- signal (SIGINT, SIG_DFL); */
-
- ptrace (0);
- execle ("/bin/sh", "sh", "-c", allargs, 0, env);
-
- fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
- errno < sys_nerr ? sys_errlist[errno] : "unknown error");
- fflush (stderr);
- _exit (0177);
- }
- return pid;
-}
-
-/* Kill the inferior process. Make us have no inferior. */
-
-static void
-kill_command ()
-{
- if (inferior_pid == 0)
- error ("The program is not being run.");
- if (!query ("Kill the inferior process? "))
- error ("Not confirmed.");
- kill_inferior ();
-}
-
-kill_inferior ()
-{
- if (inferior_pid == 0)
- return;
- ptrace (8, inferior_pid, 0, 0);
- wait (0);
- inferior_died ();
-}
-
-inferior_died ()
-{
- inferior_pid = 0;
- attach_flag = 0;
- mark_breakpoints_out ();
- reopen_exec_file ();
- if (have_core_file_p ())
- set_current_frame (read_register (FP_REGNUM));
-}
-
-/* Resume execution of the inferior process.
- If STEP is nonzero, single-step it.
- If SIGNAL is nonzero, give it that signal. */
-
-void
-resume (step, signal)
- int step;
- int signal;
-{
- errno = 0;
- ptrace (step ? 9 : 7, inferior_pid, 1, signal);
- if (errno)
- perror_with_name ("ptrace");
-}
-\f
-#ifdef NEW_SUN_PTRACE
-
-/* Start debugging the process whose number is PID. */
-
-attach (pid)
- int pid;
-{
- errno = 0;
- ptrace (PTRACE_ATTACH, pid, 0, 0);
- if (errno)
- perror_with_name ("ptrace");
- attach_flag = 1;
- return pid;
-}
-
-/* Stop debugging the process whose number is PID
- and continue it with signal number SIGNAL.
- SIGNAL = 0 means just continue it. */
-
-void
-detach (signal)
- int signal;
-{
- errno = 0;
- ptrace (PTRACE_DETACH, inferior_pid, 1, signal);
- if (errno)
- perror_with_name ("ptrace");
- attach_flag = 0;
-}
-#endif
-\f
-#ifdef NEW_SUN_PTRACE
-
-void
-fetch_inferior_registers ()
-{
- struct regs inferior_registers;
- struct fp_status inferior_fp_registers;
- extern char registers[];
-
- ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers);
- ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers);
-
- bcopy (&inferior_registers, registers, 16 * 4);
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
- sizeof inferior_fp_registers.fps_regs);
- *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
- *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
- bcopy (&inferior_fp_registers.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
-}
-
-/* Store our register values back into the inferior.
- If REGNO is -1, do this for all registers.
- Otherwise, REGNO specifies which register (so we can save time). */
-
-store_inferior_registers (regno)
- int regno;
-{
- struct regs inferior_registers;
- struct fp_status inferior_fp_registers;
- extern char registers[];
-
- bcopy (registers, &inferior_registers, 16 * 4);
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
- sizeof inferior_fp_registers.fps_regs);
- inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
- inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.fps_control,
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
-
- ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
- ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers);
-}
-
-#else
-
-void
-fetch_inferior_registers ()
-{
- register int regno;
- register unsigned int regaddr;
- char buf[MAX_REGISTER_RAW_SIZE];
- register int i;
-
-#ifdef UMAX_PTRACE
- unsigned int offset = 0;
-#else
- struct user u;
- unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
- offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
-#endif
-
- for (regno = 0; regno < NUM_REGS; regno++)
- {
- regaddr = register_addr (regno, offset);
- for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
- {
- *(int *) &buf[i] = ptrace (3, inferior_pid, regaddr, 0);
- regaddr += sizeof (int);
- }
- supply_register (regno, buf);
- }
-}
-
-/* Store our register values back into the inferior.
- If REGNO is -1, do this for all registers.
- Otherwise, REGNO specifies which register (so we can save time). */
-
-store_inferior_registers (regno)
- int regno;
-{
- register unsigned int regaddr;
- char buf[80];
-
-#ifdef UMAX_PTRACE
- unsigned int offset = 0;
-#else
- struct user u;
- unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
- offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
-#endif
-
- if (regno >= 0)
- {
- regaddr = register_addr (regno, offset);
- errno = 0;
- ptrace (6, inferior_pid, regaddr, read_register (regno));
- if (errno != 0)
- {
- sprintf (buf, "writing register number %d", regno);
- perror_with_name (buf);
- }
- }
- else for (regno = 0; regno < NUM_REGS; regno++)
- {
- regaddr = register_addr (regno, offset);
- errno = 0;
- ptrace (6, inferior_pid, regaddr, read_register (regno));
- if (errno != 0)
- {
- sprintf (buf, "writing register number %d", regno);
- perror_with_name (buf);
- }
- }
-}
-
-#endif /* not NEW_SUN_PTRACE */
-\f
-/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
- in the NEW_SUN_PTRACE case.
- It ought to be straightforward. But it appears that writing did
- not write the data that I specified. I cannot understand where
- it got the data that it actually did write. */
-
-/* Copy LEN bytes from inferior's memory starting at MEMADDR
- to debugger memory starting at MYADDR. */
-
-read_inferior_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
-{
- register int i;
- /* Round starting address down to longword boundary. */
- register CORE_ADDR addr = memaddr & - sizeof (int);
- /* Round ending address up; get number of longwords that makes. */
- register int count
- = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
- /* Allocate buffer of that many longwords. */
- register int *buffer = (int *) alloca (count * sizeof (int));
-
- /* Read all the longwords */
- for (i = 0; i < count; i++, addr += sizeof (int))
- buffer[i] = ptrace (1, inferior_pid, addr, 0);
-
- /* Copy appropriate bytes out of the buffer. */
- bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
-}
-
-/* Copy LEN bytes of data from debugger memnory at MYADDR
- to inferior's memory at MEMADDR.
- On failure (cannot write the inferior)
- returns the value of errno. */
-
-int
-write_inferior_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
-{
- register int i;
- /* Round starting address down to longword boundary. */
- register CORE_ADDR addr = memaddr & - sizeof (int);
- /* Round ending address up; get number of longwords that makes. */
- register int count
- = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
- /* Allocate buffer of that many longwords. */
- register int *buffer = (int *) alloca (count * sizeof (int));
- extern int errno;
-
- /* Fill start and end extra bytes of buffer with existing memory data. */
-
- buffer[0] = ptrace (1, inferior_pid, addr, 0);
- if (count > 1)
- buffer[count - 1]
- = ptrace (1, inferior_pid,
- addr + (count - 1) * sizeof (int), 0);
-
- /* Copy data to be written over corresponding part of buffer */
-
- bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
-
- /* Write the entire buffer. */
-
- for (i = 0; i < count; i++, addr += sizeof (int))
- {
- errno = 0;
- ptrace (4, inferior_pid, addr, buffer[i]);
- if (errno)
- return errno;
- }
-
- return 0;
-}
-\f
-static void
-try_writing_regs_command ()
-{
- register int i;
- register int value;
- extern int errno;
-
- if (inferior_pid == 0)
- error ("The program is not being run.");
-
- for (i = 0; ; i += 2)
- {
- QUIT;
- errno = 0;
- value = ptrace (3, inferior_pid, i, 0);
- ptrace (6, inferior_pid, i, value);
- if (errno == 0)
- {
- printf (" Succeeded with address 0x%x; value 0x%x (%d).\n",
- i, value, value);
- }
- else if ((i & 0377) == 0)
- printf (" Failed at 0x%x.\n", i);
- }
-}
-\f
-static
-initialize ()
-{
- add_com ("term-status", class_obscure, term_status_command,
- "Print info on inferior's saved terminal status.");
-
- add_com ("try-writing-regs", class_obscure, try_writing_regs_command,
- "Try writing all locations in inferior's system block.\n\
-Report which ones can be written.");
-
- add_com ("kill", class_run, kill_command,
- "Kill execution of program being debugged.");
-
- inferior_pid = 0;
-
-#ifdef SYSV_TTYS
- ioctl (0, TCGETA, &ti_ours);
-#else
- ioctl (0, TIOCGETP, &sg_ours);
- ioctl (0, TIOCGETC, &tc_ours);
- ioctl (0, TIOCGLTC, <c_ours);
- ioctl (0, TIOCLGET, &lmode_ours);
-#endif
- fcntl (0, F_GETFL, tflags_ours);
- ioctl (0, TIOCGPGRP, &pgrp_ours);
-
- terminal_is_ours = 1;
-}
-
-END_FILE
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d28 1
-a30 1
-#include <sys/user.h>
-d36 11
-d56 4
-d67 2
-d73 3
-d80 1
-d84 3
-d91 1
-d110 4
-d118 1
-d135 3
-d142 1
-d191 3
-d198 1
-d201 11
-a214 3
-
- fcntl (0, F_SETFL, tflags_ours);
- fcntl (0, F_SETFL, tflags_ours);
-d220 1
-d228 12
-d251 1
-d470 1
-a470 1
- offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
-d500 1
-a500 1
- offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
-d647 3
-d654 1
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.16.06; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.26.05.15.44; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Originally nonexistent, I create it.
-@
-
-
-1.2
-log
-@Original new config file for Mac-II running A/UX.
-@
-text
-@/* Parameters for execution on Macintosh under A/UX, for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#ifndef mac_aux
-#define mac_aux
-#endif
-
-/* Get rid of any system-imposed stack limit if possible. */
-
-#undef SET_STACK_LIMIT_HUGE
-
-/* Define this if the C compiler puts an underscore at the front
- of external names before giving them to the linker. */
-
-#undef NAMES_HAVE_UNDERSCORE
-
-/* COFF format object files */
-
-#define COFF_FORMAT
-
-/* System eVil ttys */
-
-#define SYSV_TTYS
-
-/* Debugger information will not be in DBX format. */
-
-#undef READ_DBX_FORMAT
-
-/* Offset from address of function to start of its code.
- Zero on most machines. */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
-
-#define SKIP_PROLOGUE(pc) \
-{ register int op = read_memory_integer (pc, 2); \
- if (op == 0047126) \
- pc += 4; /* Skip link #word */ \
- else if (op == 0044016) \
- pc += 6; /* Skip link #long */ \
-}
-
-/* Immediately after a function call, return the saved pc.
- Can't go through the frames for this because on some machines
- the new frame is not set up until the new function executes
- some instructions. */
-
-#define SAVED_PC_AFTER_CALL(frame) \
-read_memory_integer (read_register (SP_REGNUM), 4)
-
-/* Address of end of stack space. */
-
-#define STACK_END_ADDR 0x20000000
-
-/* Stack grows downward. */
-
-#define INNER_THAN <
-
-/* Sequence of bytes for breakpoint instruction. */
-
-#define BREAKPOINT {0x4e, 0x4f}
-
-/* Amount PC must be decremented by after a breakpoint.
- This is often the number of bytes in BREAKPOINT
- but not always. */
-
-#define DECR_PC_AFTER_BREAK 2
-
-/* Nonzero if instruction at PC is a return instruction. */
-
-#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
-
-/* Return 1 if P points to an invalid floating point value. */
-
-#define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */
-
-/* Say how long (ordinary) registers are. */
-
-#define REGISTER_TYPE long
-
-/* Number of machine registers */
-
-#define NUM_REGS 31
-
-/* Initializer for an array of names of registers.
- There should be NUM_REGS strings in this initializer. */
-
-#define REGISTER_NAMES \
- {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
- "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
- "ps", "pc", \
- "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
- "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags" }
-
-/* Register numbers of various important registers.
- Note that some of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and some are "phony" register numbers which are too large
- to be actual register numbers as far as the user is concerned
- but do serve to get the desired values when passed to read_register. */
-
-#define FP_REGNUM 14 /* Contains address of executing stack frame */
-#define SP_REGNUM 15 /* Contains address of top of stack */
-#define PS_REGNUM 16 /* Contains processor status */
-#define PC_REGNUM 17 /* Contains program counter */
-#define FP0_REGNUM 18 /* Floating point register 0 */
-#define FPC_REGNUM 26 /* 68881 control register */
-
-/* Total amount of space needed to store our copies of the machine's
- register state, the array `registers'. */
-#define REGISTER_BYTES (16*4+8*12+8+20)
-
-/* Index within `registers' of the first byte of the space for
- register N. */
-
-#define REGISTER_BYTE(N) \
- ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168 \
- : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72 \
- : (N) * 4)
-
-/* Number of bytes of storage in the actual machine representation
- for register N. On the 68000, all regs are 4 bytes
- except the floating point regs which are 12 bytes. */
-
-#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
-
-/* Number of bytes of storage in the program's representation
- for register N. On the 68000, all regs are 4 bytes
- except the floating point regs which are 8-byte doubles. */
-
-#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
-
-/* Largest value REGISTER_RAW_SIZE can have. */
-
-#define MAX_REGISTER_RAW_SIZE 12
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Nonzero if register N requires conversion
- from raw format to virtual format. */
-
-#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
-
-/* Convert data from raw format for register REGNUM
- to virtual format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
-{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
- convert_from_68881 ((FROM), (TO)); \
- else \
- bcopy ((FROM), (TO), 4); }
-
-/* Convert data from virtual format for register REGNUM
- to raw format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
-{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
- convert_to_68881 ((FROM), (TO)); \
- else \
- bcopy ((FROM), (TO), 4); }
-
-/* Return the GDB type object for the "standard" data type
- of data in register N. */
-
-#define REGISTER_VIRTUAL_TYPE(N) \
- (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
-
-/* Extract from an array REGBUF containing the (raw) register state
- a function return value of type TYPE, and copy that, in virtual format,
- into VALBUF. */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
-
-/* Write into appropriate registers a function return value
- of type TYPE, given in virtual format. */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
- write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
-
-/* Extract from an array REGBUF containing the (raw) register state
- the address in which a function should return its structure value,
- as a CORE_ADDR (or an expression that can be used as one). */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
-
-/* Enable use of alternate code to read and write registers. */
-
-#undef NEW_SUN_PTRACE
-
-/* Enable use of alternate code for Sun's format of core dump file. */
-
-#undef NEW_SUN_CORE
-
-/* Do implement the attach and detach commands. */
-
-#undef ATTACH_DETACH
-
-/* It is safe to look for symsegs on a Sun, because Sun's ld
- does not screw up with random garbage at end of file. */
-
-#define READ_GDB_SYMSEGS
-\f
-/* Describe the pointer in each stack frame to the previous stack frame
- (its caller). */
-
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer.
-
- FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
- and produces the nominal address of the caller frame.
-
- However, if FRAME_CHAIN_VALID returns zero,
- it means the given frame is the outermost one and has no caller.
- In that case, FRAME_CHAIN_COMBINE is not used. */
-
-/* In the case of the Sun, the frame's nominal address
- is the address of a 4-byte word containing the calling frame's address. */
-
-#define FRAME_CHAIN(thisframe) (read_memory_integer (thisframe, 4))
-
-#define FRAME_CHAIN_VALID(chain, thisframe) \
- (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
-
-#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-
-/* Define other aspects of the stack frame. */
-
-#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
-
-#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
-
-#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
-
-/* Set VAL to the number of args passed to frame described by FI.
- Can set VAL to -1, meaning no way to tell. */
-
-/* We can't tell how many args there are
- now that the C compiler delays popping them. */
-#define FRAME_NUM_ARGS(val,fi) (val = -1)
-
-#if 0
-#define FRAME_NUM_ARGS(val, fi) \
-{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame); \
- register int insn = 0177777 & read_memory_integer (pc, 2); \
- val = 0; \
- if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */ \
- val = read_memory_integer (pc + 2, 2); \
- else if ((insn & 0170777) == 0050217 /* addql #N, sp */ \
- || (insn & 0170777) == 0050117) /* addqw */ \
- { val = (insn >> 9) & 7; if (val == 0) val = 8; } \
- else if (insn == 0157774) /* addal #WW, sp */ \
- val = read_memory_integer (pc + 2, 4); \
- val >>= 2; }
-#endif
-
-/* Return number of bytes at start of arglist that are not really args. */
-
-#define FRAME_ARGS_SKIP 8
-
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
-
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
-{ register int regnum; \
- register int regmask; \
- register CORE_ADDR next_addr; \
- register CORE_ADDR pc; \
- int nextinsn; \
- bzero (&frame_saved_regs, sizeof frame_saved_regs); \
- if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
- && (frame_info).pc <= (frame_info).frame) \
- { next_addr = (frame_info).frame; \
- pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
- else \
- { pc = get_pc_function_start ((frame_info).pc); \
- /* Verify we have a link a6 instruction next; \
- if not we lose. If we win, find the address above the saved \
- regs using the amount of storage from the link instruction. */\
- if (044016 == read_memory_integer (pc, 2)) \
- next_addr = (frame_info).frame + read_memory_integer (pc += 2, 4), pc+=4; \
- else if (047126 == read_memory_integer (pc, 2)) \
- next_addr = (frame_info).frame + read_memory_integer (pc += 2, 2), pc+=2; \
- else goto lose; \
- /* If have an addal #-n, sp next, adjust next_addr. */ \
- if ((0177777 & read_memory_integer (pc, 2)) == 0157774) \
- next_addr += read_memory_integer (pc += 2, 4), pc += 4; \
- } \
- /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */ \
- regmask = read_memory_integer (pc + 2, 2); \
- /* But before that can come an fmovem. Check for it. */ \
- nextinsn = 0xffff & read_memory_integer (pc, 2); \
- if (0xf227 == nextinsn \
- && (regmask & 0xff00) == 0xe000) \
- { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */ \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr -= 12); \
- regmask = read_memory_integer (pc + 2, 2); } \
- if (0044327 == read_memory_integer (pc, 2)) \
- { pc += 4; /* Regmask's low bit is for register 0, the first written */ \
- for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; } \
- else if (0044347 == read_memory_integer (pc, 2)) \
- { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \
- for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \
- else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2)) \
- { regnum = 0xf & read_memory_integer (pc, 2); pc += 2; \
- (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \
- /* fmovemx to index of sp may follow. */ \
- regmask = read_memory_integer (pc + 2, 2); \
- nextinsn = 0xffff & read_memory_integer (pc, 2); \
- if (0xf236 == nextinsn \
- && (regmask & 0xff00) == 0xf000) \
- { pc += 10; /* Regmask's low bit is for register fp0, the first written */ \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr += 12) - 12; \
- regmask = read_memory_integer (pc + 2, 2); } \
- /* clrw -(sp); movw ccr,-(sp) may follow. */ \
- if (0x426742e7 == read_memory_integer (pc, 4)) \
- (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4); \
- lose: ; \
- (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8; \
- (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame; \
- (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4; \
-}
-\f
-/* Things needed for making the inferior call functions. */
-
-/* Push an empty stack frame, to record the current PC, etc. */
-
-#define PUSH_DUMMY_FRAME \
-{ register CORE_ADDR sp = read_register (SP_REGNUM); \
- register int regnum; \
- char raw_buffer[12]; \
- sp = push_word (sp, read_register (PC_REGNUM)); \
- sp = push_word (sp, read_register (FP_REGNUM)); \
- write_register (FP_REGNUM, sp); \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \
- { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \
- sp = push_bytes (sp, raw_buffer, 12); } \
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \
- sp = push_word (sp, read_register (regnum)); \
- sp = push_word (sp, read_register (PS_REGNUM)); \
- write_register (SP_REGNUM, sp); }
-
-/* Discard from the stack the innermost frame,
- restoring all saved registers. */
-
-#define POP_FRAME \
-{ register CORE_ADDR fp = read_register (FP_REGNUM); \
- register int regnum; \
- struct frame_saved_regs fsr; \
- struct frame_info fi; \
- char raw_buffer[12]; \
- fi = get_frame_info (fp); \
- get_frame_saved_regs (&fi, &fsr); \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \
- if (fsr.regs[regnum]) \
- { read_memory (fsr.regs[regnum], raw_buffer, 12); \
- write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \
- if (fsr.regs[regnum]) \
- write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
- if (fsr.regs[PS_REGNUM]) \
- write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
- write_register (FP_REGNUM, read_memory_integer (fp, 4)); \
- write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \
- write_register (SP_REGNUM, fp + 8); \
- set_current_frame (read_register (FP_REGNUM)); }
-
-/* This sequence of words is the instructions
- fmovem 0xff,-(sp)
- moveml 0xfffc,-(sp)
- clrw -(sp)
- movew ccr,-(sp)
- /..* The arguments are pushed at this point by GDB;
- no code is needed in the dummy for this.
- The CALL_DUMMY_START_OFFSET gives the position of
- the following jsr instruction. *../
- jsr @@#32323232
- addl #69696969,sp
- bpt
- nop
-Note this is 28 bytes.
-We actually start executing at the jsr, since the pushing of the
-registers is done by PUSH_DUMMY_FRAME. If this were real code,
-the arguments for the function called by the jsr would be pushed
-between the moveml and the jsr, and we could allow it to execute through.
-But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
-and we cannot allow the moveml to push the registers again lest they be
-taken for the arguments. */
-
-#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
-
-#define CALL_DUMMY_LENGTH 28
-
-#define CALL_DUMMY_START_OFFSET 12
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
-
-#define FIX_CALL_DUMMY(dummyname, fun, nargs) \
-{ *(int *)((char *) dummyname + 20) = nargs * 4; \
- *(int *)((char *) dummyname + 14) = fun; }
-\f
-/* Interface definitions for kernel debugger KDB. */
-
-/* Map machine fault codes into signal numbers.
- First subtract 0, divide by 4, then index in a table.
- Faults for which the entry in this table is 0
- are not handled by KDB; the program's own trap handler
- gets to handle then. */
-
-#define FAULT_CODE_ORIGIN 0
-#define FAULT_CODE_UNITS 4
-#define FAULT_TABLE \
-{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
- 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
- 0, 0, 0, 0, 0, 0, 0, 0, \
- SIGILL }
-
-/* Start running with a stack stretching from BEG to END.
- BEG and END should be symbols meaningful to the assembler.
- This is used only for kdb. */
-
-#define INIT_STACK(beg, end) \
-{ asm (".globl end"); \
- asm ("movel #end, sp"); \
- asm ("movel #0,a6"); }
-
-/* Push the frame pointer register on the stack. */
-#define PUSH_FRAME_PTR \
- asm ("movel a6,sp@@-");
-
-/* Copy the top-of-stack to the frame pointer register. */
-#define POP_FRAME_PTR \
- asm ("movl sp@@,a6");
-
-/* After KDB is entered by a fault, push all registers
- that GDB thinks about (all NUM_REGS of them),
- so that they appear in order of ascending GDB register number.
- The fault code will be on the stack beyond the last register. */
-
-#define PUSH_REGISTERS \
-{ asm ("clrw -(sp)"); \
- asm ("pea sp@@(10)"); \
- asm ("movem #0xfffe,sp@@-"); }
-
-/* Assuming the registers (including processor status) have been
- pushed on the stack in order of ascending GDB register number,
- restore them and return to the address in the saved PC register. */
-
-#define POP_REGISTERS \
-{ asm ("subil #8,sp@@(28)"); \
- asm ("movem sp@@,#0xffff"); \
- asm ("rte"); }
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d1 485
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.19.09; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.26.05.18.45; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Originally nonexistent.
-@
-
-
-1.2
-log
-@Created by John Gilmore for Mac A/UX
-@
-text
-@
-/* This is how the size of an individual .o file's text segment
- is rounded on a mac under a/ux. */
-
-#define FILEADDR_ROUND(addr) (addr)
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d1 5
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.08.29; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.21.22.04.55; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@From RMS's development sources on wheaties, 20Jan88
-@
-
-
-1.2
-log
-@Avoid the so-called "portable" preassembled instructions; call a macro
-to generate them, since a/ux assembler uses a different syntax (grumble)
-@
-text
-@/* Print m68k instructions for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include <stdio.h>
-
-#include "defs.h"
-#include "param.h"
-#include "symtab.h"
-#include "m68k-opcode.h"
-
-/* 68k instructions are never longer than this many bytes. */
-#define MAXLEN 22
-
-/* Number of elements in the opcode table. */
-#define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
-
-extern char *reg_names[];
-char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
- "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
-
-static unsigned char *print_insn_arg ();
-static unsigned char *print_indexed ();
-static void print_base ();
-static int fetch_arg ();
-
-#define NEXTBYTE(p) (p += 2, ((char *)p)[-1])
-
-#define NEXTWORD(p) \
- (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
-
-#define NEXTLONG(p) \
- (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
-
-#define NEXTSINGLE(p) \
- (p += 4, *((float *)(p - 4)))
-
-#define NEXTDOUBLE(p) \
- (p += 8, *((double *)(p - 8)))
-
-#define NEXTEXTEND(p) \
- (p += 12, 0.0) /* Need a function to convert from extended to double
- precision... */
-
-#define NEXTPACKED(p) \
- (p += 12, 0.0) /* Need a function to convert from packed to double
- precision. Actually, it's easier to print a
- packed number than a double anyway, so maybe
- there should be a special case to handle this... */
-\f
-/* Print the m68k instruction at address MEMADDR in debugged memory,
- on STREAM. Returns length of the instruction, in bytes. */
-
-int
-print_insn (memaddr, stream)
- CORE_ADDR memaddr;
- FILE *stream;
-{
- unsigned char buffer[MAXLEN];
- register int i;
- register unsigned char *p;
- register char *d;
- register int bestmask;
- int best;
-
- read_memory (memaddr, buffer, MAXLEN);
-
- bestmask = 0;
- best = -1;
- for (i = 0; i < NOPCODES; i++)
- {
- register unsigned int opcode = m68k_opcodes[i].opcode;
- register unsigned int match = m68k_opcodes[i].match;
- if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
- && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
- && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
- && ((0xff & buffer[3] & match) == (0xff & opcode)))
- {
- /* Don't use for printout the variants of divul and divsl
- that have the same register number in two places.
- The more general variants will match instead. */
- for (d = m68k_opcodes[i].args; *d; d += 2)
- if (d[1] == 'D')
- break;
-
- /* Don't use for printout the variants of most floating
- point coprocessor instructions which use the same
- register number in two places, as above. */
- if (*d == 0)
- for (d = m68k_opcodes[i].args; *d; d += 2)
- if (d[1] == 't')
- break;
-
- if (*d == 0 && match > bestmask)
- {
- best = i;
- bestmask = match;
- }
- }
- }
-
- /* Handle undefined instructions. */
- if (best < 0)
- {
- fprintf (stream, "0%o", (buffer[0] << 8) + buffer[1]);
- return 2;
- }
-
- fprintf (stream, "%s", m68k_opcodes[best].name);
-
- /* Point at first word of argument data,
- and at descriptor for first argument. */
- p = buffer + 2;
-
- /* Why do this this way? -MelloN */
- for (d = m68k_opcodes[best].args; *d; d += 2)
- {
- if (d[0] == '#')
- {
- if (d[1] == 'l' && p - buffer < 6)
- p = buffer + 6;
- else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
- p = buffer + 4;
- }
- if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
- p = buffer + 4;
- if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
- p = buffer + 6;
- }
-
- d = m68k_opcodes[best].args;
-
- if (*d)
- fputc (' ', stream);
-
- while (*d)
- {
- p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
- d += 2;
- if (*d && *(d - 2) != 'I' && *d != 'k')
- fprintf (stream, ",");
- }
- return p - buffer;
-}
-
-static unsigned char *
-print_insn_arg (d, buffer, p, addr, stream)
- char *d;
- unsigned char *buffer;
- register unsigned char *p;
- CORE_ADDR addr; /* PC for this arg to be relative to */
- FILE *stream;
-{
- register int val;
- register int place = d[1];
- int regno;
- register char *regname;
- register unsigned char *p1;
- register double flval;
- int flt_p;
-
- switch (*d)
- {
- case 'C':
- fprintf (stream, "ccr");
- break;
-
- case 'S':
- fprintf (stream, "sr");
- break;
-
- case 'U':
- fprintf (stream, "usp");
- break;
-
- case 'J':
- {
- static struct { char *name; int value; } names[]
- = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
- {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
- {"msp", 0x803}, {"isp", 0x804}};
-
- val = fetch_arg (buffer, place, 12);
- for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
- if (names[regno].value == val)
- {
- fprintf (stream, names[regno].name);
- break;
- }
- if (regno < 0)
- fprintf (stream, "%d", val);
- }
- break;
-
- case 'Q':
- val = fetch_arg (buffer, place, 3);
- if (val == 0) val = 8;
- fprintf (stream, "#%d", val);
- break;
-
- case 'M':
- val = fetch_arg (buffer, place, 8);
- if (val & 0x80)
- val = val - 0x100;
- fprintf (stream, "#%d", val);
- break;
-
- case 'T':
- val = fetch_arg (buffer, place, 4);
- fprintf (stream, "#%d", val);
- break;
-
- case 'D':
- fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
- break;
-
- case 'A':
- fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3) + 010]);
- break;
-
- case 'R':
- fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
- break;
-
- case 'F':
- fprintf (stream, "fp%d", fetch_arg (buffer, place, 3));
- break;
-
- case 'O':
- val = fetch_arg (buffer, place, 6);
- if (val & 0x20)
- fprintf (stream, "%s", reg_names [val & 7]);
- else
- fprintf (stream, "%d", val);
- break;
-
- case '+':
- fprintf (stream, "(%s)+", reg_names[fetch_arg (buffer, place, 3) + 8]);
- break;
-
- case '-':
- fprintf (stream, "-(%s)", reg_names[fetch_arg (buffer, place, 3) + 8]);
- break;
-
- case 'k':
- if (place == 'k')
- fprintf (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
- else if (place == 'C')
- {
- val = fetch_arg (buffer, place, 7);
- if ( val > 63 ) /* This is a signed constant. */
- val -= 128;
- fprintf (stream, "{#%d}", val);
- }
- else
- error ("Invalid arg format in opcode table: \"%c%c\".",
- *d, place);
- break;
-
- case '#':
- p1 = buffer + 2;
- if (place == 's')
- val = fetch_arg (buffer, place, 4);
- else if (place == 'C')
- val = fetch_arg (buffer, place, 7);
- else if (place == '8')
- val = fetch_arg (buffer, place, 3);
- else if (place == '3')
- val = fetch_arg (buffer, place, 8);
- else if (place == 'b')
- val = NEXTBYTE (p1);
- else if (place == 'w')
- val = NEXTWORD (p1);
- else if (place == 'l')
- val = NEXTLONG (p1);
- else
- error ("Invalid arg format in opcode table: \"%c%c\".",
- *d, place);
- fprintf (stream, "#%d", val);
- break;
-
- case '^':
- if (place == 's')
- val = fetch_arg (buffer, place, 4);
- else if (place == 'C')
- val = fetch_arg (buffer, place, 7);
- else if (place == '8')
- val = fetch_arg (buffer, place, 3);
- else if (place == 'b')
- val = NEXTBYTE (p);
- else if (place == 'w')
- val = NEXTWORD (p);
- else if (place == 'l')
- val = NEXTLONG (p);
- else
- error ("Invalid arg format in opcode table: \"%c%c\".",
- *d, place);
- fprintf (stream, "#%d", val);
- break;
-
- case 'B':
- if (place == 'b')
- val = NEXTBYTE (p);
- else if (place == 'w')
- val = NEXTWORD (p);
- else if (place == 'l')
- val = NEXTLONG (p);
- else if (place == 'g')
- {
- val = ((char *)buffer)[1];
- if (val == 0)
- val = NEXTWORD (p);
- else if (val == -1)
- val = NEXTLONG (p);
- }
- else if (place == 'c')
- {
- if (buffer[1] & 0x40) /* If bit six is one, long offset */
- val = NEXTLONG (p);
- else
- val = NEXTWORD (p);
- }
- else
- error ("Invalid arg format in opcode table: \"%c%c\".",
- *d, place);
-
- print_address (addr + val, stream);
- break;
-
- case 'd':
- val = NEXTWORD (p);
- fprintf (stream, "%d(%s)", val, fetch_arg (buffer, place, 3));
- break;
-
- case 's':
- fprintf (stream, "%s", fpcr_names[fetch_arg (buffer, place, 3)]);
- break;
-
- case 'I':
- val = fetch_arg (buffer, 'd', 3); /* Get coprocessor ID... */
- if (val != 1) /* Unusual coprocessor ID? */
- fprintf (stream, "(cpid=%d) ", val);
- if (place == 'i')
- p += 2; /* Skip coprocessor extended operands */
- break;
-
- case '*':
- case '~':
- case '%':
- case ';':
- case '@@':
- case '!':
- case '$':
- case '?':
- case '/':
- case '&':
-
- if (place == 'd')
- {
- val = fetch_arg (buffer, 'x', 6);
- val = ((val & 7) << 3) + ((val >> 3) & 7);
- }
- else
- val = fetch_arg (buffer, 's', 6);
-
- /* Get register number assuming address register. */
- regno = (val & 7) + 8;
- regname = reg_names[regno];
- switch (val >> 3)
- {
- case 0:
- fprintf (stream, "%s", reg_names[val]);
- break;
-
- case 1:
- fprintf (stream, "%s", regname);
- break;
-
- case 2:
- fprintf (stream, "(%s)", regname);
- break;
-
- case 3:
- fprintf (stream, "(%s)+", regname);
- break;
-
- case 4:
- fprintf (stream, "-(%s)", regname);
- break;
-
- case 5:
- val = NEXTWORD (p);
- fprintf (stream, "%d(%s)", val, regname);
- break;
-
- case 6:
- p = print_indexed (regno, p, addr, stream);
- break;
-
- case 7:
- switch (val & 7)
- {
- case 0:
- val = NEXTWORD (p);
- fprintf (stream, "@@#");
- print_address (val, stream);
- break;
-
- case 1:
- val = NEXTLONG (p);
- fprintf (stream, "@@#");
- print_address (val, stream);
- break;
-
- case 2:
- val = NEXTWORD (p);
- print_address (addr + val, stream);
- break;
-
- case 3:
- p = print_indexed (-1, p, addr, stream);
- break;
-
- case 4:
- flt_p = 1; /* Assume it's a float... */
- switch( place )
- {
- case 'b':
- val = NEXTBYTE (p);
- flt_p = 0;
- break;
-
- case 'w':
- val = NEXTWORD (p);
- flt_p = 0;
- break;
-
- case 'l':
- val = NEXTLONG (p);
- flt_p = 0;
- break;
-
- case 'f':
- flval = NEXTSINGLE(p);
- break;
-
- case 'F':
- flval = NEXTDOUBLE(p);
- break;
-
- case 'x':
- flval = NEXTEXTEND(p);
- break;
-
- case 'p':
- flval = NEXTPACKED(p);
- break;
-
- default:
- error ("Invalid arg format in opcode table: \"%c%c\".",
- *d, place);
- }
- if ( flt_p ) /* Print a float? */
- fprintf (stream, "#%g", flval);
- else
- fprintf (stream, "#%d", val);
- break;
-
- default:
- fprintf (stream, "<invalid address mode 0%o>", val);
- }
- }
- break;
-
- default:
- error ("Invalid arg format in opcode table: \"%c\".", *d);
- }
-
- return (unsigned char *) p;
-}
-
-/* Fetch BITS bits from a position in the instruction specified by CODE.
- CODE is a "place to put an argument", or 'x' for a destination
- that is a general address (mode and register).
- BUFFER contains the instruction. */
-
-static int
-fetch_arg (buffer, code, bits)
- unsigned char *buffer;
- char code;
- int bits;
-{
- register int val;
- switch (code)
- {
- case 's':
- val = buffer[1];
- break;
-
- case 'd': /* Destination, for register or quick. */
- val = (buffer[0] << 8) + buffer[1];
- val >>= 9;
- break;
-
- case 'x': /* Destination, for general arg */
- val = (buffer[0] << 8) + buffer[1];
- val >>= 6;
- break;
-
- case 'k':
- val = (buffer[3] >> 4);
- break;
-
- case 'C':
- val = buffer[3];
- break;
-
- case '1':
- val = (buffer[2] << 8) + buffer[3];
- val >>= 12;
- break;
-
- case '2':
- val = (buffer[2] << 8) + buffer[3];
- val >>= 6;
- break;
-
- case '3':
- case 'j':
- val = (buffer[2] << 8) + buffer[3];
- break;
-
- case '4':
- val = (buffer[4] << 8) + buffer[5];
- val >>= 12;
- break;
-
- case '5':
- val = (buffer[4] << 8) + buffer[5];
- val >>= 6;
- break;
-
- case '6':
- val = (buffer[4] << 8) + buffer[5];
- break;
-
- case '7':
- val = (buffer[2] << 8) + buffer[3];
- val >>= 7;
- break;
-
- case '8':
- val = (buffer[2] << 8) + buffer[3];
- val >>= 10;
- break;
-
- default:
- abort ();
- }
-
- switch (bits)
- {
- case 3:
- return val & 7;
- case 4:
- return val & 017;
- case 5:
- return val & 037;
- case 6:
- return val & 077;
- case 7:
- return val & 0177;
- case 8:
- return val & 0377;
- case 12:
- return val & 07777;
- default:
- abort ();
- }
-}
-
-/* Print an indexed argument. The base register is BASEREG (-1 for pc).
- P points to extension word, in buffer.
- ADDR is the nominal core address of that extension word. */
-
-static unsigned char *
-print_indexed (basereg, p, addr, stream)
- int basereg;
- unsigned char *p;
- FILE *stream;
- CORE_ADDR addr;
-{
- register int word;
- static char *scales[] = {"", "*2", "*4", "*8"};
- register int base_disp;
- register int outer_disp;
- char buf[40];
-
- word = NEXTWORD (p);
-
- /* Generate the text for the index register.
- Where this will be output is not yet determined. */
- sprintf (buf, "[%s.%c%s]",
- reg_names[(word >> 12) & 0xf],
- (word & 0x800) ? 'l' : 'w',
- scales[(word >> 9) & 3]);
-
- /* Handle the 68000 style of indexing. */
-
- if ((word & 0x100) == 0)
- {
- print_base (basereg,
- ((word & 0x80) ? word | 0xff00 : word & 0xff)
- + ((basereg == -1) ? addr : 0),
- stream);
- fprintf (stream, "%s", buf);
- return p;
- }
-
- /* Handle the generalized kind. */
- /* First, compute the displacement to add to the base register. */
-
- if (word & 0200)
- basereg = -2;
- if (word & 0100)
- buf[0] = 0;
- base_disp = 0;
- switch ((word >> 4) & 3)
- {
- case 2:
- base_disp = NEXTWORD (p);
- break;
- case 3:
- base_disp = NEXTLONG (p);
- }
- if (basereg == -1)
- base_disp += addr;
-
- /* Handle single-level case (not indirect) */
-
- if ((word & 7) == 0)
- {
- print_base (basereg, base_disp, stream);
- fprintf (stream, "%s", buf);
- return p;
- }
-
- /* Two level. Compute displacement to add after indirection. */
-
- outer_disp = 0;
- switch (word & 3)
- {
- case 2:
- outer_disp = NEXTWORD (p);
- break;
- case 3:
- outer_disp = NEXTLONG (p);
- }
-
- fprintf (stream, "%d(", outer_disp);
- print_base (basereg, base_disp, stream);
-
- /* If postindexed, print the closeparen before the index. */
- if (word & 4)
- fprintf (stream, ")%s", buf);
- /* If preindexed, print the closeparen after the index. */
- else
- fprintf (stream, "%s)", buf);
-
- return p;
-}
-
-/* Print a base register REGNO and displacement DISP, on STREAM.
- REGNO = -1 for pc, -2 for none (suppressed). */
-
-static void
-print_base (regno, disp, stream)
- int regno;
- int disp;
- FILE *stream;
-{
- if (regno == -2)
- fprintf (stream, "%d", disp);
- else if (regno == -1)
- fprintf (stream, "0x%x", disp);
- else
- fprintf (stream, "%d(%s)", disp, reg_names[regno]);
-}
-\f
-/* This is not part of insn printing, but it is machine-specific,
- so this is a convenient place to put it.
-
- Convert a 68881 extended float to a double.
- FROM is the address of the extended float.
- Store the double in *TO. */
-
-#ifdef mac_aux
-#ifdef __STDC__
-#define asm16(str) asm ("short " str#)
-#else
-#define asm16(str) asm ("short str")
-#endif
-#else
-#ifdef __STDC__
-#define asm16(str) asm (".word " str#)
-#else
-#define asm16(str) asm (".word str")
-#endif
-#endif
-
-convert_from_68881 (from, to)
- char *from;
- double *to;
-{
-#if 0
- asm ("movl a6@@(8),a0");
- asm ("movl a6@@(12),a1");
- asm ("fmovex a0@@,fp0");
- asm ("fmoved fp0,a1@@");
-#else
- /* Hand-assemble those insns since some assemblers lose
- and some have different syntax. */
- asm16 (020156);
- asm16 (8);
- asm16 (021156);
- asm16 (12);
- asm16 (0xf210);
- asm16 (0x4800);
- asm16 (0xf211);
- asm16 (0x7400);
-#endif
-}
-
-/* The converse: convert the double *FROM to an extended float
- and store where TO points. */
-
-convert_to_68881 (from, to)
- double *from;
- char *to;
-{
-#if 0
- asm ("movl a6@@(8),a0");
- asm ("movl a6@@(12),a1");
- asm ("fmoved a0@@,fp0");
- asm ("fmovex fp0,a1@@");
-#else
- /* Hand-assemble those insns since some assemblers lose. */
- asm16 (020156);
- asm16 (8);
- asm16 (021156);
- asm16 (12);
- asm16 (0xf210);
- asm16 (0x5400);
- asm16 (0xf211);
- asm16 (0x6800);
-#endif
-}
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d713 14
-d739 8
-a746 6
- asm (".word 020156");
- asm (".word 8");
- asm (".word 021156");
- asm (".word 12");
- asm (".long 0xf2104800");
- asm (".long 0xf2117400");
-d764 8
-a771 6
- asm (".word 020156");
- asm (".word 8");
- asm (".word 021156");
- asm (".word 12");
- asm (".long 0xf2105400");
- asm (".long 0xf2116800");
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.09.12; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.21.04.23.16; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Original from RMS development on wheaties, 20Jan88
-@
-
-
-1.2
-log
-@Add <sys/types.h>
-@
-text
-@/* Top level for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include <sys/types.h>
-#include <sys/file.h>
-#include <stdio.h>
-#include <setjmp.h>
-#include <signal.h>
-#include <sys/param.h>
-#include "defs.h"
-#include "command.h"
-#include "param.h"
-
-#ifdef SET_STACK_LIMIT_HUGE
-#include <sys/time.h>
-#include <sys/resource.h>
-#endif
-
-/* Version number of GDB, as a string. */
-
-extern char *version;
-
-/* Chain containing all defined commands. */
-
-struct cmd_list_element *cmdlist;
-
-/* Chain containing all defined info subcommands. */
-
-struct cmd_list_element *infolist;
-
-/* stdio stream that command input is being read from. */
-
-FILE *instream;
-
-/* Nonzero if we should refrain from using an X window. */
-
-int inhibit_windows = 0;
-
-/* Function to call before reading a command, if nonzero.
- The function receives two args: an input stream,
- and a prompt string. */
-
-void (*window_hook) ();
-
-void free_command_lines ();
-char *read_line ();
-static void initialize_main ();
-void command_loop ();
-static void source_command ();
-void print_gdb_version ();
-
-/* gdb prints this when reading a command interactively */
-static char *prompt;
-
-/* Buffer used for reading command lines, and the size
- allocated for it so far. */
-
-char *line;
-int linesize;
-
-/* This is how `error' returns to command level. */
-
-jmp_buf to_top_level;
-
-return_to_top_level ()
-{
- quit_flag = 0;
- immediate_quit = 0;
- clear_breakpoint_commands ();
- clear_momentary_breakpoints ();
- do_cleanups (0);
- longjmp (to_top_level, 1);
-}
-\f
-main (argc, argv, envp)
- int argc;
- char **argv;
- char **envp;
-{
- extern void request_quit ();
- int count;
- int inhibit_gdbinit = 0;
- int quiet = 0;
- int batch = 0;
- register int i;
-
- quit_flag = 0;
- linesize = 100;
- line = (char *) xmalloc (linesize);
- instream = stdin;
-
-#ifdef SET_STACK_LIMIT_HUGE
- {
- struct rlimit rlim;
-
- /* Set the stack limit huge so that alloca (particularly stringtab
- * in dbxread.c) does not fail. */
- getrlimit (RLIMIT_STACK, &rlim);
- rlim.rlim_cur = rlim.rlim_max;
- setrlimit (RLIMIT_STACK, &rlim);
- }
-#endif /* SET_STACK_LIMIT_HUGE */
-
- /* Look for flag arguments. */
-
- for (i = 1; i < argc; i++)
- {
- if (!strcmp (argv[i], "-q") || !strcmp (argv[i], "-quiet"))
- quiet = 1;
- else if (!strcmp (argv[i], "-nx"))
- inhibit_gdbinit = 1;
- else if (!strcmp (argv[i], "-nw"))
- inhibit_windows = 1;
- else if (!strcmp (argv[i], "-batch"))
- batch = 1, quiet = 1;
- else if (argv[i][0] == '-')
- i++;
- }
-
- /* Run the init function of each source file */
-
- initialize_all_files ();
- initialize_main (); /* But that omits this file! Do it now */
-
- signal (SIGINT, request_quit);
- signal (SIGQUIT, SIG_IGN);
-
- if (!quiet)
- print_gdb_version ();
-
- /* Process the command line arguments. */
-
- count = 0;
- for (i = 1; i < argc; i++)
- {
- register char *arg = argv[i];
- /* Args starting with - say what to do with the following arg
- as a filename. */
- if (arg[0] == '-')
- {
- extern void exec_file_command (), symbol_file_command ();
- extern void core_file_command (), directory_command ();
- extern void tty_command ();
-
- if (!strcmp (arg, "-q") || !strcmp (arg, "-nx")
- || !strcmp (arg, "quiet") || !strcmp (arg, "-batch"))
- /* Already processed above */
- continue;
-
- if (++i == argc)
- fprintf (stderr, "No argument follows \"%s\".\n", arg);
- if (!setjmp (to_top_level))
- {
- /* -s foo: get syms from foo. -e foo: execute foo.
- -se foo: do both with foo. -c foo: use foo as core dump. */
- if (!strcmp (arg, "-se"))
- {
- exec_file_command (argv[i], !batch);
- symbol_file_command (argv[i], !batch);
- }
- else if (!strcmp (arg, "-s") || !strcmp (arg, "-symbols"))
- symbol_file_command (argv[i], !batch);
- else if (!strcmp (arg, "-e") || !strcmp (arg, "-exec"))
- exec_file_command (argv[i], !batch);
- else if (!strcmp (arg, "-c") || !strcmp (arg, "-core"))
- core_file_command (argv[i], !batch);
- /* -x foo: execute commands from foo. */
- else if (!strcmp (arg, "-x") || !strcmp (arg, "-command")
- || !strcmp (arg, "-commands"))
- source_command (argv[i]);
- /* -d foo: add directory `foo' to source-file directory
- search-list */
- else if (!strcmp (arg, "-d") || !strcmp (arg, "-dir")
- || !strcmp (arg, "-directory"))
- directory_command (argv[i], 0);
- /* -t /def/ttyp1: use /dev/ttyp1 for inferior I/O. */
- else if (!strcmp (arg, "-t") || !strcmp (arg, "-tty"))
- tty_command (argv[i], 0);
- else
- error ("Unknown command-line switch: \"%s\"\n", arg);
- }
- }
- else
- {
- /* Args not thus accounted for
- are treated as, first, the symbol/executable file
- and, second, the core dump file. */
- count++;
- if (!setjmp (to_top_level))
- switch (count)
- {
- case 1:
- exec_file_command (arg, !batch);
- symbol_file_command (arg, !batch);
- break;
-
- case 2:
- core_file_command (arg, !batch);
- break;
-
- case 3:
- fprintf (stderr, "Excess command line args ignored. (%s%s)\n",
- arg, (i == argc - 1) ? "" : " ...");
- }
- }
- }
-
- /* Read init file, if it exists in home directory */
- if (getenv ("HOME"))
- {
- char *s;
- s = (char *) xmalloc (strlen (getenv ("HOME")) + 10);
- strcpy (s, getenv ("HOME"));
- strcat (s, "/.gdbinit");
- if (!inhibit_gdbinit && access (s, R_OK) == 0)
- if (!setjmp (to_top_level))
- source_command (s);
- }
-
- /* Read init file, if it exists in current directory. */
- if (!inhibit_gdbinit && access (".gdbinit", R_OK) == 0)
- if (!setjmp (to_top_level))
- source_command (".gdbinit");
-
- if (batch)
- fatal ("Attempt to read commands from stdin in batch mode.");
-
- if (!quiet)
- printf ("Type \"help\" for a list of commands.\n");
-
- /* The command loop. */
-
- while (1)
- {
- if (!setjmp (to_top_level))
- command_loop ();
- clearerr (stdin); /* Don't get hung if C-d is typed. */
- }
-}
-
-/* Execute the line P as a command.
- Pass FROM_TTY as second argument to the defining function. */
-
-void
-execute_command (p, from_tty)
- char *p;
- int from_tty;
-{
- register struct cmd_list_element *c;
- register struct command_line *cmdlines;
-
- free_all_values ();
- while (*p == ' ' || *p == '\t') p++;
- if (*p)
- {
- c = lookup_cmd (&p, cmdlist, "", 0);
- if (c->function == 0)
- error ("That is not a command, just a help topic.");
- else if (c->class == (int) class_user)
- {
- if (*p)
- error ("User-defined commands cannot take command-line arguments: \"%s\"",
- p);
- cmdlines = (struct command_line *) c->function;
- if (cmdlines == (struct command_line *) 0)
- /* Null command */
- return;
- while (cmdlines)
- {
- execute_command (cmdlines->line, 0);
- cmdlines = cmdlines->next;
- }
- }
- else
- /* Pass null arg rather than an empty one. */
- (*c->function) (*p ? p : 0, from_tty);
- }
-}
-
-static void
-do_nothing ()
-{
-}
-
-/* Read commands from `instream' and execute them
- until end of file. */
-void
-command_loop ()
-{
- struct cleanup *old_chain;
- while (!feof (instream))
- {
- if (instream == stdin)
- printf ("%s", prompt);
- fflush (stdout);
-
- if (window_hook && instream == stdin)
- (*window_hook) (instream, prompt);
-
- quit_flag = 0;
- old_chain = make_cleanup (do_nothing, 0);
- execute_command (read_line (instream == stdin), instream == stdin);
- /* Do any commands attached to breakpoint we stopped at. */
- do_breakpoint_commands ();
- do_cleanups (old_chain);
- }
-}
-\f
-static void
-stop_sig ()
-{
- signal (SIGTSTP, SIG_DFL);
- sigsetmask (0);
- kill (getpid (), SIGTSTP);
- signal (SIGTSTP, stop_sig);
- printf ("%s", prompt);
- fflush (stdout);
-
- /* Forget about any previous command -- null line now will do nothing. */
- *line = 0;
-}
-
-/* Commands call this if they do not want to be repeated by null lines. */
-
-void
-dont_repeat ()
-{
- *line = 0;
-}
-
-/* Read one line from the command input stream `instream'
- into the buffer `line' (whose current length is `linesize').
- The buffer is made bigger as necessary.
- Returns the address of the start of the line. */
-
-char *
-read_line (repeat)
- int repeat;
-{
- register char *p = line;
- register char *p1;
- register int c;
- char *nline;
-
- /* Control-C quits instantly if typed while in this loop
- since it should not wait until the user types a newline. */
- immediate_quit++;
- signal (SIGTSTP, stop_sig);
-
- while (1)
- {
- c = fgetc (instream);
- if (c == -1 || c == '\n')
- break;
- if (p - line == linesize - 1)
- {
- linesize *= 2;
- nline = (char *) xrealloc (line, linesize);
- p += nline - line;
- line = nline;
- }
- *p++ = c;
- }
-
- signal (SIGTSTP, SIG_DFL);
- immediate_quit--;
-
- /* If we just got an empty line, and that is supposed
- to repeat the previous command, leave the last input unchanged. */
- if (p == line && repeat)
- return line;
-
- /* If line is a comment, clear it out. */
- p1 = line;
- while ((c = *p1) == ' ' || c == '\t') p1++;
- if (c == '#')
- p = line;
-
- *p = 0;
-
- return line;
-}
-\f
-/* Read lines from the input stream
- and accumulate them in a chain of struct command_line's
- which is then returned. */
-
-struct command_line *
-read_command_lines ()
-{
- struct command_line *first = 0;
- register struct command_line *next, *tail = 0;
- register char *p, *p1;
- struct cleanup *old_chain = 0;
-
- while (1)
- {
- dont_repeat ();
- p = read_line (1);
- /* Remove leading and trailing blanks. */
- while (*p == ' ' || *p == '\t') p++;
- p1 = p + strlen (p);
- while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t')) p1--;
-
- /* Is this "end"? */
- if (p1 - p == 3 && !strncmp (p, "end", 3))
- break;
-
- /* No => add this line to the chain of command lines. */
- next = (struct command_line *) xmalloc (sizeof (struct command_line));
- next->line = savestring (p, p1 - p);
- next->next = 0;
- if (tail)
- {
- tail->next = next;
- }
- else
- {
- /* We just read the first line.
- From now on, arrange to throw away the lines we have
- if we quit or get an error while inside this function. */
- first = next;
- old_chain = make_cleanup (free_command_lines, &first);
- }
- tail = next;
- }
-
- dont_repeat ();
-
- /* Now we are about to return the chain to our caller,
- so freeing it becomes his responsibility. */
- if (first)
- discard_cleanups (old_chain);
- return first;
-}
-
-/* Free a chain of struct command_line's. */
-
-void
-free_command_lines (lptr)
- struct command_line **lptr;
-{
- register struct command_line *l = *lptr;
- register struct command_line *next;
-
- while (l)
- {
- next = l->next;
- free (l->line);
- free (l);
- l = next;
- }
-}
-\f
-/* Add an element to the list of info subcommands. */
-
-void
-add_info (name, fun, doc)
- char *name;
- void (*fun) ();
- char *doc;
-{
- add_cmd (name, 0, fun, doc, &infolist);
-}
-
-/* Add an alias to the list of info subcommands. */
-
-void
-add_info_alias (name, oldname, abbrev_flag)
- char *name;
- char *oldname;
- int abbrev_flag;
-{
- add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
-}
-
-/* The "info" command is defined as a prefix, with allow_unknown = 0.
- Therefore, its own definition is called only for "info" with no args. */
-
-static void
-info_command ()
-{
- printf ("\"info\" must be followed by the name of an info command.\n");
- help_cmd (0, infolist, "info ", -1, stdout);
-}
-\f
-/* Add an element to the list of commands. */
-
-void
-add_com (name, class, fun, doc)
- char *name;
- int class;
- void (*fun) ();
- char *doc;
-{
- add_cmd (name, class, fun, doc, &cmdlist);
-}
-
-/* Add an alias or abbreviation command to the list of commands. */
-
-void
-add_com_alias (name, oldname, class, abbrev_flag)
- char *name;
- char *oldname;
- int class;
- int abbrev_flag;
-{
- add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
-}
-
-void
-error_no_arg (why)
- char *why;
-{
- error ("Argument required (%s).", why);
-}
-
-static void
-help_command (command, from_tty)
- char *command;
- int from_tty; /* Ignored */
-{
- help_cmd (command, cmdlist, "", -2, stdout);
-}
-\f
-static void
-validate_comname (comname)
- char *comname;
-{
- register char *p;
-
- if (comname == 0)
- error_no_arg ("name of command to define");
-
- p = comname;
- while (*p)
- {
- if (!(*p >= 'A' && *p <= 'Z')
- && !(*p >= 'a' && *p <= 'z')
- && !(*p >= '1' && *p <= '9')
- && *p != '-')
- error ("Junk in argument list: \"%s\"", p);
- p++;
- }
-}
-
-static void
-define_command (comname, from_tty)
- char *comname;
- int from_tty;
-{
- register struct command_line *cmds;
- register struct cmd_list_element *c;
- char *tem = comname;
-
- validate_comname (comname);
-
- c = lookup_cmd (&tem, cmdlist, "", -1);
- if (c)
- {
- if (c->class == (int) class_user || c->class == (int) class_alias)
- tem = "Redefine command \"%s\"? ";
- else
- tem = "Really redefine built-in command \"%s\"? ";
- if (!query (tem, comname))
- error ("Command \"%s\" not redefined.", comname);
- }
-
- if (from_tty)
- printf ("Type commands for definition of \"%s\".\n\
-End with a line saying just \"end\".\n", comname);
-
- comname = savestring (comname, strlen (comname));
-
- cmds = read_command_lines ();
-
- if (c && c->class == (int) class_user)
- free_command_lines (&c->function);
-
- add_com (comname, class_user, cmds,
- (c && c->class == (int) class_user)
- ? c->doc : savestring ("User-defined.", 13));
-}
-
-static void
-document_command (comname, from_tty)
- char *comname;
- int from_tty;
-{
- struct command_line *doclines;
- register struct cmd_list_element *c;
- char *tem = comname;
-
- validate_comname (comname);
-
- c = lookup_cmd (&tem, cmdlist, "", 0);
-
- if (c->class != (int) class_user)
- error ("Command \"%s\" is built-in.", comname);
-
- if (from_tty)
- printf ("Type documentation for \"%s\".\n\
-End with a line saying just \"end\".\n", comname);
-
- doclines = read_command_lines ();
-
- if (c->doc) free (c->doc);
-
- {
- register struct command_line *cl1;
- register int len = 0;
-
- for (cl1 = doclines; cl1; cl1 = cl1->next)
- len += strlen (cl1->line) + 1;
-
- c->doc = (char *) xmalloc (len + 1);
- *c->doc = 0;
-
- for (cl1 = doclines; cl1; cl1 = cl1->next)
- {
- strcat (c->doc, cl1->line);
- if (cl1->next)
- strcat (c->doc, "\n");
- }
- }
-
- free_command_lines (&doclines);
-}
-\f
-static void
-copying_info ()
-{
- immediate_quit++;
- printf (" GDB GENERAL PUBLIC LICENSE\n\
-\n\
- Copyright (C) 1986 Richard M. Stallman\n\
- Everyone is permitted to copy and distribute verbatim copies\n\
- of this license, but changing it is not allowed.\n\
-\n\
- The license agreements of most software companies keep you at the\n\
-mercy of those companies. By contrast, our general public license is\n\
-intended to give everyone the right to share GDB. To make sure that\n\
-you get the rights we want you to have, we need to make restrictions\n\
-that forbid anyone to deny you these rights or to ask you to surrender\n\
-the rights. Hence this license agreement.\n\
-\n\
- Specifically, we want to make sure that you have the right to give\n\
-away copies of GDB, that you receive source code or else can get it\n\
-if you want it, that you can change GDB or use pieces of it in new\n\
-free programs, and that you know you can do these things.\n\
---Type Return to print more--");
- fflush (stdout);
- read_line ();
-
- printf ("\
- To make sure that everyone has such rights, we have to forbid you to\n\
-deprive anyone else of these rights. For example, if you distribute\n\
-copies of GDB, you must give the recipients all the rights that you\n\
-have. You must make sure that they, too, receive or can get the\n\
-source code. And you must tell them their rights.\n\
-\n\
- Also, for our own protection, we must make certain that everyone\n\
-finds out that there is no warranty for GDB. If GDB is modified by\n\
-someone else and passed on, we want its recipients to know that what\n\
-they have is not what we distributed, so that any problems introduced\n\
-by others will not reflect on our reputation.\n\
-\n\
- Therefore we (Richard Stallman and the Free Software Foundation,\n\
-Inc.) make the following terms which say what you must do to be\n\
-allowed to distribute or change GDB.\n\
---Type Return to print more--");
- fflush (stdout);
- read_line ();
-
- printf ("\
- COPYING POLICIES\n\
-\n\
- 1. You may copy and distribute verbatim copies of GDB source code as\n\
-you receive it, in any medium, provided that you conspicuously and\n\
-appropriately publish on each copy a valid copyright notice \"Copyright\n\
-\(C) 1987 Free Software Foundation, Inc.\" (or with the year updated if\n\
-that is appropriate); keep intact the notices on all files that refer\n\
-to this License Agreement and to the absence of any warranty; and give\n\
-any other recipients of the GDB program a copy of this License\n\
-Agreement along with the program. You may charge a distribution fee\n\
-for the physical act of transferring a copy.\n\
-\n\
- 2. You may modify your copy or copies of GDB or any portion of it,\n\
-and copy and distribute such modifications under the terms of\n\
-Paragraph 1 above, provided that you also do the following:\n\
-\n\
- a) cause the modified files to carry prominent notices stating\n\
- that you changed the files and the date of any change; and\n\
---Type Return to print more--");
- fflush (stdout);
- read_line ();
-
- printf ("\
- b) cause the whole of any work that you distribute or publish,\n\
- that in whole or in part contains or is a derivative of GDB\n\
- or any part thereof, to be licensed to all third parties on terms\n\
- identical to those contained in this License Agreement (except that\n\
- you may choose to grant more extensive warranty protection to third\n\
- parties, at your option).\n\
-\n");
- printf ("\
- c) if the modified program serves as a debugger, cause it\n\
- when started running in the simplest and usual way, to print\n\
- an announcement including a valid copyright notice\n\
- \"Copyright (C) 1987 Free Software Foundation, Inc.\" (or with\n\
- the year updated if appropriate), saying that there\n\
- is no warranty (or else, saying that you provide\n\
- a warranty) and that users may redistribute the program under\n\
- these conditions, and telling the user how to view a copy of\n\
- this License Agreement.\n\
-\n\
- d) You may charge a distribution fee for the physical act of\n\
- transferring a copy, and you may at your option offer warranty\n\
- protection in exchange for a fee.\n\
---Type Return to print more--");
- fflush (stdout);
- read_line ();
-
- printf ("\
- 3. You may copy and distribute GDB or any portion of it in\n\
-compiled, executable or object code form under the terms of Paragraphs\n\
-1 and 2 above provided that you do the following:\n\
-\n\
- a) cause each such copy to be accompanied by the\n\
- corresponding machine-readable source code, which must\n\
- be distributed under the terms of Paragraphs 1 and 2 above; or,\n\
-\n\
- b) cause each such copy to be accompanied by a\n\
- written offer, with no time limit, to give any third party\n\
- free (except for a nominal shipping charge) a machine readable\n\
- copy of the corresponding source code, to be distributed\n\
- under the terms of Paragraphs 1 and 2 above; or,\n\n");
-
- printf ("\
- c) in the case of a recipient of GDB in compiled, executable\n\
- or object code form (without the corresponding source code) you\n\
- shall cause copies you distribute to be accompanied by a copy\n\
- of the written offer of source code which you received along\n\
- with the copy you received.\n\
---Type Return to print more--");
- fflush (stdout);
- read_line ();
-
- printf ("\
- 4. You may not copy, sublicense, distribute or transfer GDB\n\
-except as expressly provided under this License Agreement. Any attempt\n\
-otherwise to copy, sublicense, distribute or transfer GDB is void and\n\
-your rights to use the program under this License agreement shall be\n\
-automatically terminated. However, parties who have received computer\n\
-software programs from you with this License Agreement will not have\n\
-their licenses terminated so long as such parties remain in full compliance.\n\
-\n\
- 5. If you wish to incorporate parts of GDB into other free\n\
-programs whose distribution conditions are different, write to the Free\n\
-Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet\n\
-worked out a simple rule that can be stated here, but we will often permit\n\
-this. We will be guided by the two goals of preserving the free status of\n\
-all derivatives of our free software and of promoting the sharing and reuse\n\
-of software.\n\
-\n\
-In other words, go ahead and share GDB, but don't try to stop\n\
-anyone else from sharing it farther. Help stamp out software hoarding!\n\
-");
- immediate_quit--;
-}
-
-static void
-warranty_info ()
-{
- immediate_quit++;
- printf (" NO WARRANTY\n\
-\n\
- BECAUSE GDB IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO\n\
-WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT\n\
-WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,\n\
-RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GDB \"AS IS\" WITHOUT\n\
-WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT\n\
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\
-A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND\n\
-PERFORMANCE OF GDB IS WITH YOU. SHOULD GDB PROVE DEFECTIVE, YOU\n\
-ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n");
-
- printf ("\
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.\n\
-STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY\n\
-WHO MAY MODIFY AND REDISTRIBUTE GDB, BE LIABLE TO\n\
-YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER\n\
-SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR\n\
-INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA\n\
-BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A\n\
-FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GDB, EVEN\n\
-IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR\n\
-ANY CLAIM BY ANY OTHER PARTY.\n");
- immediate_quit--;
-}
-\f
-static void
-print_gdb_version ()
-{
- printf ("GDB %s, Copyright (C) 1987 Free Software Foundation, Inc.\n\
-There is ABSOLUTELY NO WARRANTY for GDB; type \"info warranty\" for details.\n\
-GDB is free software and you are welcome to distribute copies of it\n\
- under certain conditions; type \"info copying\" to see the conditions.\n",
- version);
-}
-
-static void
-version_info ()
-{
- immediate_quit++;
- print_gdb_version ();
- immediate_quit--;
-}
-\f
-static void
-set_prompt_command (text)
- char *text;
-{
- char *p, *q;
- register int c;
- char *new;
-
- if (text == 0)
- error_no_arg ("string to which to set prompt");
-
- new = (char *) xmalloc (strlen (text) + 2);
- p = text; q = new;
- while (c = *p++)
- {
- if (c == '\\')
- {
- /* \ at end of argument is used after spaces
- so they won't be lost. */
- if (*p == 0)
- break;
- c = parse_escape (&p);
- if (c == 0)
- break; /* C loses */
- else if (c > 0)
- *q++ = c;
- }
- else
- *q++ = c;
- }
- if (*(p - 1) != '\\')
- *q++ = ' ';
- *q++ = '\0';
- new = (char *) xrealloc (new, q - new);
- free (prompt);
- prompt = new;
-}
-\f
-static void
-quit_command ()
-{
- if (have_inferior_p ())
- {
- if (query ("The program is running. Quit anyway? "))
- {
- /* Prevent any warning message from reopen_exec_file, in case
- we have a core file that's inconsistent with the exec file. */
- exec_file_command (0, 0);
- kill_inferior ();
- }
- else
- error ("Not confirmed.");
- }
- exit (0);
-}
-
-int
-input_from_terminal_p ()
-{
- return instream == stdin;
-}
-\f
-static void
-pwd_command (arg, from_tty)
- char *arg;
- int from_tty;
-{
- char buf[MAXPATHLEN];
- if (arg) error ("The \"pwd\" command does not take an argument: %s", arg);
- printf ("Working directory %s.\n", getwd (buf));
-}
-
-static void
-cd_command (dir, from_tty)
- char *dir;
- int from_tty;
-{
- if (dir == 0)
- error_no_arg ("new working directory");
-
- if (chdir (dir) < 0)
- perror_with_name (dir);
- if (from_tty)
- pwd_command ((char *) 0, 1);
-}
-
-\f
-/* Clean up on error during a "source" command.
- Close the file opened by the command
- and restore the previous input stream. */
-
-static void
-source_cleanup (stream)
- FILE *stream;
-{
- fclose (instream);
- instream = stream;
-}
-
-static void
-source_command (file)
- char *file;
-{
- FILE *stream;
- struct cleanup *cleanups;
-
- if (file == 0)
- error_no_arg ("file to read commands from");
-
- stream = fopen (file, "r");
- if (stream == 0)
- perror_with_name (file);
-
- cleanups = make_cleanup (source_cleanup, instream);
-
- instream = stream;
-
- command_loop ();
-
- do_cleanups (cleanups);
-}
-
-static void
-echo_command (text)
- char *text;
-{
- char *p = text;
- register int c;
-
- if (text)
- while (c = *p++)
- {
- if (c == '\\')
- {
- /* \ at end of argument is used after spaces
- so they won't be lost. */
- if (*p == 0)
- return;
-
- c = parse_escape (&p);
- if (c >= 0)
- fputc (c, stdout);
- }
- else
- fputc (c, stdout);
- }
-}
-
-static void
-dump_me_command ()
-{
- if (query ("Should GDB dump core? "))
- {
- signal (SIGQUIT, SIG_DFL);
- kill (getpid (), SIGQUIT);
- }
-}
-
-\f
-static void
-initialize_main ()
-{
- prompt = savestring ("(gdb) ", 6);
-
- /* Define the classes of commands.
- They will appear in the help list in the reverse of this order. */
-
- add_cmd ("obscure", class_obscure, 0, "Obscure features.", &cmdlist);
- add_cmd ("alias", class_alias, 0, "Aliases of other commands.", &cmdlist);
- add_cmd ("user", class_user, 0, "User-defined commands.\n\
-The commands in this class are those defined by the user.\n\
-Use the \"define\" command to define a command.", &cmdlist);
- add_cmd ("support", class_support, 0, "Support facilities.", &cmdlist);
- add_cmd ("status", class_info, 0, "Status inquiries.", &cmdlist);
- add_cmd ("files", class_files, 0, "Specifying and examining files.", &cmdlist);
- add_cmd ("breakpoints", class_breakpoint, 0, "Making program stop at certain points.", &cmdlist);
- add_cmd ("data", class_vars, 0, "Examining data.", &cmdlist);
- add_cmd ("stack", class_stack, 0, "Examining the stack.\n\
-The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
-counting from zero for the innermost (currently executing) frame.\n\n\
-At any time gdb identifies one frame as the \"selected\" frame.\n\
-Variable lookups are done with respect to the selected frame.\n\
-When the program being debugged stops, gdb selects the innermost frame.\n\
-The commands below can be used to select other frames by number or address.",
- &cmdlist);
- add_cmd ("running", class_run, 0, "Running the program.", &cmdlist);
-
- add_com ("pwd", class_files, pwd_command,
- "Print working directory. This is used for your program as well.");
- add_com ("cd", class_files, cd_command,
- "Set working directory to DIR for debugger and program being debugged.\n\
-The change does not take effect for the program being debugged\n\
-until the next time it is started.");
-
- add_com ("set-prompt", class_support, set_prompt_command,
- "Change gdb's prompt from the default of \"(gdb)\"");
- add_com ("echo", class_support, echo_command,
- "Print a constant string. Give string as argument.\n\
-C escape sequences may be used in the argument.\n\
-No newline is added at the end of the argument;\n\
-use \"\\n\" if you want a newline to be printed.\n\
-Since leading and trailing whitespace are ignored in command arguments,\n\
-if you want to print some you must use \"\\\" before leading whitespace\n\
-to be printed or after trailing whitespace.");
- add_com ("document", class_support, document_command,
- "Document a user-defined command.\n\
-Give command name as argument. Give documentation on following lines.\n\
-End with a line of just \"end\".");
- add_com ("define", class_support, define_command,
- "Define a new command name. Command name is argument.\n\
-Definition appears on following lines, one command per line.\n\
-End with a line of just \"end\".\n\
-Use the \"document\" command to give documentation for the new command.\n\
-Commands defined in this way do not take arguments.");
-
- add_com ("source", class_support, source_command,
- "Read commands from a file named FILE.\n\
-Note that the file \".gdbinit\" is read automatically in this way\n\
-when gdb is started.");
- add_com ("quit", class_support, quit_command, "Exit gdb.");
- add_com ("help", class_support, help_command, "Print list of commands.");
- add_com_alias ("q", "quit", class_support, 1);
- add_com_alias ("h", "help", class_support, 1);
-
- add_com ("dump-me", class_obscure, dump_me_command,
- "Get fatal error; make debugger dump its core.");
-
- add_prefix_cmd ("info", class_info, info_command,
- "Generic command for printing status.",
- &infolist, "info ", 0, &cmdlist);
- add_com_alias ("i", "info", class_info, 1);
-
- add_info ("copying", copying_info, "Conditions for redistributing copies of GDB.");
- add_info ("warranty", warranty_info, "Various kinds of warranty you do not have.");
- add_info ("version", version_info, "Report what version of GDB this is.");
-}
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d21 1
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.09.34; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.21.04.30.11; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Original from RMS development sources on wheaties, 20Jan88
-@
-
-
-1.2
-log
-@Add <sys/types.h>
-@
-text
-@/* List lines of source files for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/file.h>
-#include "defs.h"
-#include "initialize.h"
-#include "symtab.h"
-
-/* Path of directories to search for source files.
- Same format as the PATH environment variable's value. */
-
-static char *source_path;
-
-/* Symtab of default file for listing lines of. */
-
-struct symtab *current_source_symtab;
-
-/* Default next line to list. */
-
-int current_source_line;
-
-/* Line for "info line" to work on if no line specified. */
-
-static int line_info_default_line;
-
-/* First line number listed by last listing command. */
-
-static int first_line_listed;
-
-START_FILE
-\f
-/* Set the source file default for the "list" command,
- specifying a symtab. */
-
-void
-select_source_symtab (s)
- register struct symtab *s;
-{
- if (s)
- {
- struct symtab_and_line sal;
-
- /* Make the default place to list be the function `main'
- if one exists. */
- if (lookup_symbol ("main", 0, VAR_NAMESPACE))
- {
- sal = decode_line_spec ("main", 1);
- current_source_symtab = sal.symtab;
- current_source_line = sal.line - 9;
- return;
- }
-
- /* If there is no `main', use the last symtab in the list,
- which is actually the first found in the file's symbol table.
- But ignore .h files. */
- do
- {
- char *name = s->filename;
- int len = strlen (name);
- if (! (len > 2 && !strcmp (&name[len - 2], ".h")))
- current_source_symtab = s;
- s = s->next;
- }
- while (s);
- current_source_line = 1;
- }
-}
-\f
-static void
-directories_info ()
-{
- printf ("Source directories searched: %s\n", source_path);
-}
-
-static void
-init_source_path ()
-{
- register struct symtab *s;
- char wd[MAXPATHLEN];
- if (getwd (wd) == NULL)
- perror_with_name ("getwd");
-
- source_path = savestring (wd, strlen (wd));
-
- /* Forget what we learned about line positions in source files;
- must check again now since files may be found in
- a different directory now. */
- for (s = symtab_list; s; s = s->next)
- if (s->line_charpos != 0)
- {
- free (s->line_charpos);
- s->line_charpos = 0;
- }
-}
-
-void
-directory_command (dirname, from_tty)
- char *dirname;
- int from_tty;
-{
- char *old = source_path;
-
- char wd[MAXPATHLEN];
- if (getwd (wd) == NULL)
- perror_with_name ("getwd");
-
- if (dirname == 0)
- {
- if (query ("Reinitialize source path to %s? ", wd))
- {
- init_source_path ();
- free (old);
- }
- }
- else
- {
- struct stat st;
- register int len = strlen (dirname);
- register char *tem;
- extern char *index ();
-
- if (index (dirname, ':'))
- error ("Please add one directory at a time to the source path.");
- if (dirname[len - 1] == '/')
- /* Sigh. "foo/" => "foo" */
- dirname[--len] == '\0';
-
- while (dirname[len - 1] == '.')
- {
- if (len == 1)
- {
- /* "." => getwd () */
- dirname = wd;
- goto append;
- }
- else if (dirname[len - 2] == '/')
- {
- if (len == 2)
- {
- /* "/." => "/" */
- dirname[--len] = '\0';
- goto append;
- }
- else
- {
- /* "...foo/." => "...foo" */
- dirname[len -= 2] = '\0';
- continue;
- }
- }
- break;
- }
-
- if (dirname[0] != '/')
- dirname = concat (wd, "/", dirname);
- else
- dirname = savestring (dirname, len);
- make_cleanup (free, dirname);
-
- if (stat (dirname, &st) < 0)
- perror_with_name (dirname);
- if ((st.st_mode & S_IFMT) != S_IFDIR)
- error ("%s is not a directory.", dirname);
-
- append:
- len = strlen (dirname);
- tem = source_path;
- while (1)
- {
- if (!strncmp (tem, dirname, len)
- && (tem[len] == '\0' || tem[len] == ':'))
- {
- printf ("\"%s\" is already in the source path.\n",
- dirname);
- break;
- }
- tem = index (tem, ':');
- if (tem)
- tem++;
- else
- {
- source_path = concat (old, ":", dirname);
- free (old);
- break;
- }
- }
- if (from_tty)
- directories_info ();
- }
-}
-\f
-/* Open a file named STRING, searching path PATH (dir names sep by colons)
- using mode MODE and protection bits PROT in the calls to open.
- If TRY_CWD_FIRST, try to open ./STRING before searching PATH.
- (ie pretend the first element of PATH is ".")
- If FILENAMED_OPENED is non-null, set it to a newly allocated string naming
- the actual file opened (this string will always start with a "/"
-
- If a file is found, return the descriptor.
- Otherwise, return -1, with errno set for the last name we tried to open. */
-
-/* >>>> This should only allow files of certain types,
- >>>> eg executable, non-directory */
-int
-openp (path, try_cwd_first, string, mode, prot, filename_opened)
- char *path;
- int try_cwd_first;
- char *string;
- int mode;
- int prot;
- char **filename_opened;
-{
- register int fd;
- register char *filename;
- register char *p, *p1;
- register int len;
-
- /* ./foo => foo */
- while (string[0] == '.' && string[1] == '/')
- string += 2;
-
- if (try_cwd_first || string[0] == '/')
- {
- filename = string;
- fd = open (filename, mode, prot);
- if (fd >= 0 || string[0] == '/')
- goto done;
- }
-
- filename = (char *) alloca (strlen (path) + strlen (string) + 2);
- fd = -1;
- for (p = path; p; p = p1 ? p1 + 1 : 0)
- {
- p1 = (char *) index (p, ':');
- if (p1)
- len = p1 - p;
- else
- len = strlen (p);
-
- strncpy (filename, p, len);
- filename[len] = 0;
- strcat (filename, "/");
- strcat (filename, string);
-
- fd = open (filename, mode, prot);
- if (fd >= 0) break;
- }
-
- done:
- if (filename_opened)
- if (fd < 0)
- *filename_opened = (char *) 0;
- else if (filename[0] == '/')
- *filename_opened = savestring (filename, strlen (filename));
- else
- {
- char dirname[MAXPATHLEN];
- if (getwd (dirname) == NULL)
- perror_with_name ("getwd");
- *filename_opened = concat (dirname, "/", filename);
- }
-
- return fd;
-}
-\f
-/* Create and initialize the table S->line_charpos that records
- the positions of the lines in the source file, which is assumed
- to be open on descriptor DESC.
- All set S->nlines to the number of such lines. */
-
-static void
-find_source_lines (s, desc)
- struct symtab *s;
- int desc;
-{
- struct stat st;
- register char *data, *p, *end;
- int nlines = 0;
- int lines_allocated = 1000;
- int *line_charpos = (int *) xmalloc (lines_allocated * sizeof (int));
- extern int exec_mtime;
-
- fstat (desc, &st);
- if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
- printf ("Source file is more recent than executable.\n");
-
- data = (char *) alloca (st.st_size);
- myread (desc, data, st.st_size);
- end = data + st.st_size;
- p = data;
- line_charpos[0] = 0;
- nlines = 1;
- while (p != end)
- {
- if (*p++ == '\n')
- {
- if (nlines == lines_allocated)
- line_charpos = (int *) xrealloc (line_charpos,
- sizeof (int) * (lines_allocated *= 2));
- line_charpos[nlines++] = p - data;
- }
- }
- s->nlines = nlines;
- s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int));
-}
-
-/* Return the character position of a line LINE in symtab S.
- Return 0 if anything is invalid. */
-
-int
-source_line_charpos (s, line)
- struct symtab *s;
- int line;
-{
- if (!s) return 0;
- if (!s->line_charpos || line <= 0) return 0;
- if (line > s->nlines)
- line = s->nlines;
- return s->line_charpos[line - 1];
-}
-
-/* Return the line number of character position POS in symtab S. */
-
-int
-source_charpos_line (s, chr)
- register struct symtab *s;
- register int chr;
-{
- register int line = 0;
- register int *lnp;
-
- if (s == 0 || s->line_charpos == 0) return 0;
- lnp = s->line_charpos;
- /* Files are usually short, so sequential search is Ok */
- while (line < s->nlines && *lnp <= chr)
- {
- line++;
- lnp++;
- }
- if (line >= s->nlines)
- line = s->nlines;
- return line;
-}
-\f
-/* Get full pathname and line number positions for a symtab.
- Return nonzero if line numbers may have changed.
- Set *FULLNAME to actual name of the file as found by `openp',
- or to 0 if the file is not found. */
-
-int
-get_filename_and_charpos (s, line, fullname)
- struct symtab *s;
- int line;
- char **fullname;
-{
- register int desc, linenums_changed = 0;
-
- desc = openp (source_path, 0, s->filename, O_RDONLY, 0, fullname);
- if (desc < 0)
- {
- *fullname = NULL;
- return 0;
- }
- if (s->line_charpos == 0) linenums_changed = 1;
- if (linenums_changed) find_source_lines (s, desc);
- close (desc);
- return linenums_changed;
-}
-\f
-/* Print source lines from the file of symtab S,
- starting with line number LINE and stopping before line number STOPLINE. */
-
-void
-print_source_lines (s, line, stopline)
- struct symtab *s;
- int line, stopline;
-{
- register int c;
- register int desc;
- register FILE *stream;
- int nlines = stopline - line;
-
- desc = openp (source_path, 0, s->filename, O_RDONLY, 0, (char **) 0);
- if (desc < 0)
- perror_with_name (s->filename);
-
- if (s->line_charpos == 0)
- find_source_lines (s, desc);
-
- if (line < 1 || line >= s->nlines)
- {
- close (desc);
- error ("Line number out of range; %s has %d lines.",
- s->filename, s->nlines);
- }
-
- if (lseek (desc, s->line_charpos[line - 1], 0) < 0)
- {
- close (desc);
- perror_with_name (s->filename);
- }
-
- current_source_symtab = s;
- current_source_line = line;
- first_line_listed = line;
-
- stream = fdopen (desc, "r");
- clearerr (stream);
-
- while (nlines-- > 0)
- {
- c = fgetc (stream);
- if (c == EOF) break;
- line_info_default_line = current_source_line;
- printf ("%d\t", current_source_line++);
- do
- {
- if (c < 040 && c != '\t' && c != '\n')
- {
- fputc ('^', stdout);
- fputc (c + 0100, stdout);
- }
- else if (c == 0177)
- printf ("^?");
- else
- fputc (c, stdout);
- } while (c != '\n' && (c = fgetc (stream)) >= 0);
- }
-
- fclose (stream);
-}
-\f
-static void
-list_command (arg, from_tty)
- char *arg;
- int from_tty;
-{
- struct symtab_and_line sal, sal_end;
- struct symbol *sym;
- char *arg1;
- int no_end = 1;
- int dummy_end = 0;
- int dummy_beg = 0;
- int linenum_beg = 0;
- char *p;
-
- if (symtab_list == 0)
- error ("Listing source lines requires symbols.");
-
- /* "l" or "l +" lists next ten lines. */
-
- if (arg == 0 || !strcmp (arg, "+"))
- {
- if (current_source_symtab == 0)
- error ("No default source file yet. Do \"help list\".");
- print_source_lines (current_source_symtab, current_source_line,
- current_source_line + 10);
- return;
- }
-
- /* "l -" lists previous ten lines, the ones before the ten just listed. */
- if (!strcmp (arg, "-"))
- {
- if (current_source_symtab == 0)
- error ("No default source file yet. Do \"help list\".");
- print_source_lines (current_source_symtab,
- max (first_line_listed - 10, 1),
- first_line_listed);
- return;
- }
-
- /* Now if there is only one argument, decode it in SAL
- and set NO_END.
- If there are two arguments, decode them in SAL and SAL_END
- and clear NO_END; however, if one of the arguments is blank,
- set DUMMY_BEG or DUMMY_END to record that fact. */
-
- arg1 = arg;
- if (*arg1 == ',')
- dummy_beg = 1;
- else
- sal = decode_line_1 (&arg1, 0, 0, 0);
-
- /* Record whether the BEG arg is all digits. */
-
- for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
- linenum_beg = (p == arg1);
-
- while (*arg1 == ' ' || *arg1 == '\t')
- arg1++;
- if (*arg1 == ',')
- {
- no_end = 0;
- arg1++;
- while (*arg1 == ' ' || *arg1 == '\t')
- arg1++;
- if (*arg1 == 0)
- dummy_end = 1;
- else if (dummy_beg)
- sal_end = decode_line_1 (&arg1, 0, 0, 0);
- else
- sal_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line);
- }
-
- if (*arg1)
- error ("Junk at end of line specification.");
-
- if (!no_end && !dummy_beg && !dummy_end
- && sal.symtab != sal_end.symtab)
- error ("Specified start and end are in different files.");
- if (dummy_beg && dummy_end)
- error ("Two empty args do not say what lines to list.");
-
- /* if line was specified by address,
- first print exactly which line, and which file.
- In this case, sal.symtab == 0 means address is outside
- of all known source files, not that user failed to give a filename. */
- if (*arg == '*')
- {
- if (sal.symtab == 0)
- error ("No source file for address 0x%x.", sal.pc);
- sym = find_pc_function (sal.pc);
- if (sym)
- printf ("0x%x is in %s (%s, line %d).\n",
- sal.pc, SYMBOL_NAME (sym), sal.symtab->filename, sal.line);
- else
- printf ("0x%x is in %s, line %d.\n",
- sal.pc, sal.symtab->filename, sal.line);
- }
-
- /* If line was not specified by just a line number,
- and it does not imply a symtab, it must be an undebuggable symbol
- which means no source code. */
-
- if (! linenum_beg && sal.symtab == 0)
- error ("No line number known for %s.", arg);
-
- /* If this command is repeated with RET,
- turn it into the no-arg variant. */
-
- if (from_tty)
- *arg = 0;
-
- if (dummy_beg && sal_end.symtab == 0)
- error ("No default source file yet. Do \"help list\".");
- if (dummy_beg)
- print_source_lines (sal_end.symtab, max (sal_end.line - 9, 1),
- sal_end.line + 1);
- else if (sal.symtab == 0)
- error ("No default source file yet. Do \"help list\".");
- else if (no_end)
- print_source_lines (sal.symtab, max (sal.line - 5, 1), sal.line + 5);
- else
- print_source_lines (sal.symtab, sal.line,
- dummy_end ? sal.line + 10 : sal_end.line + 1);
-}
-\f
-/* Print info on range of pc's in a specified line. */
-
-static void
-line_info (arg, from_tty)
- char *arg;
- int from_tty;
-{
- struct symtab_and_line sal;
- int start_pc, end_pc;
-
- if (arg == 0)
- {
- sal.symtab = current_source_symtab;
- sal.line = line_info_default_line;
- }
- else
- {
- sal = decode_line_spec (arg);
-
- /* If this command is repeated with RET,
- turn it into the no-arg variant. */
-
- if (from_tty)
- *arg = 0;
- }
-
- if (sal.symtab == 0)
- error ("No source file specified.");
- if (sal.line > 0
- && find_line_pc_range (sal.symtab, sal.line, &start_pc, &end_pc))
- {
- if (start_pc == end_pc)
- printf ("Line %d of \"%s\" is at pc 0x%x but contains no code.\n",
- sal.line, sal.symtab->filename, start_pc);
- else
- printf ("Line %d of \"%s\" starts at pc 0x%x and ends at 0x%x.\n",
- sal.line, sal.symtab->filename, start_pc, end_pc);
- /* x/i should display this line's code. */
- set_next_address (start_pc);
- /* Repeating "info line" should do the following line. */
- line_info_default_line = sal.line + 1;
- }
- else
- printf ("Line number %d is out of range for \"%s\".\n",
- sal.line, sal.symtab->filename);
-}
-\f
-static
-initialize ()
-{
- current_source_symtab = 0;
- init_source_path ();
-
- add_com ("directory", class_files, directory_command,
- "Add directory DIR to end of search path for source files.\n\
-With no argument, reset the search path to just the working directory\n\
-and forget cached info on line positions in source files.");
-
- add_info ("directories", directories_info,
- "Current search path for finding source files.");
-
- add_info ("line", line_info,
- "Core addresses of the code for a source line.\n\
-Line can be specified as\n\
- LINENUM, to list around that line in current file,\n\
- FILE:LINENUM, to list around that line in that file,\n\
- FUNCTION, to list around beginning of that function,\n\
- FILE:FUNCTION, to distinguish among like-named static functions.\n\
-Default is to describe the last source line that was listed.\n\n\
-This sets the default address for \"x\" to the line's first instruction\n\
-so that \"x/i\" suffices to start examining the machine code.\n\
-The address is also stored as the value of \"$_\".");
-
- add_com ("list", class_files, list_command,
- "List specified function or line.\n\
-With no argument, lists ten more lines after or around previous listing.\n\
-\"list -\" lists the ten lines before a previous ten-line listing.\n\
-One argument specifies a line, and ten lines are listed around that line.\n\
-Two arguments with comma between specify starting and ending lines to list.\n\
-Lines can be specified in these ways:\n\
- LINENUM, to list around that line in current file,\n\
- FILE:LINENUM, to list around that line in that file,\n\
- FUNCTION, to list around beginning of that function,\n\
- FILE:FUNCTION, to distinguish among like-named static functions.\n\
- *ADDRESS, to list around the line containing that address.\n\
-With two args if one is empty it stands for ten lines away from the other arg.");
-}
-
-END_FILE
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d22 1
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.09.53; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.26.04.25.22; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Original from RMS's devl sources on wheaties
-@
-
-
-1.2
-log
-@Check for null pointer passed to free()...
-@
-text
-@/* Do various things to symbol tables (other than lookup)), for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-
-#include "defs.h"
-#include "initialize.h"
-#include "symtab.h"
-
-#include <stdio.h>
-#include <obstack.h>
-
-static void free_symtab ();
-
-START_FILE
-\f
-/* Free all the symtabs that are currently installed,
- and all storage associated with them.
- Leaves us in a consistent state with no symtabs installed. */
-
-void
-free_all_symtabs ()
-{
- register struct symtab *s, *snext;
-
- /* All values will be invalid because their types will be! */
-
- clear_value_history ();
- clear_displays ();
- clear_internalvars ();
- clear_breakpoints ();
- set_default_breakpoint (0, 0, 0, 0);
-
- current_source_symtab = 0;
-
- for (s = symtab_list; s; s = snext)
- {
- snext = s->next;
- free_symtab (s);
- }
- symtab_list = 0;
- obstack_free (symbol_obstack, 0);
- obstack_init (symbol_obstack);
-
- if (misc_function_vector)
- free (misc_function_vector);
- misc_function_count = 0;
- misc_function_vector = 0;
-}
-
-/* Free a struct block <- B and all the symbols defined in that block. */
-
-static void
-free_symtab_block (b)
- struct block *b;
-{
- register int i, n;
- n = BLOCK_NSYMS (b);
- for (i = 0; i < n; i++)
- {
- free (SYMBOL_NAME (BLOCK_SYM (b, i)));
- free (BLOCK_SYM (b, i));
- }
- free (b);
-}
-
-/* Free all the storage associated with the struct symtab <- S.
- Note that some symtabs have contents malloc'ed structure by structure,
- while some have contents that all live inside one big block of memory,
- and some share the contents of another symbol table and so you should
- not free the contents on their behalf (except sometimes the linetable,
- which maybe per symtab even when the rest is not).
- It is s->free_code that says which alternative to use. */
-
-static void
-free_symtab (s)
- register struct symtab *s;
-{
- register int i, n;
- register struct blockvector *bv;
- register struct type *type;
- register struct typevector *tv;
-
- switch (s->free_code)
- {
- case free_nothing:
- /* All the contents are part of a big block of memory
- and some other symtab is in charge of freeing that block.
- Therefore, do nothing. */
- break;
-
- case free_explicit:
- /* All the contents are part of a big block of memory
- and that is our `free_ptr' and will be freed below. */
- break;
-
- case free_contents:
- /* Here all the contents were malloc'ed structure by structure
- and must be freed that way. */
- /* First free the blocks (and their symbols. */
- bv = BLOCKVECTOR (s);
- n = BLOCKVECTOR_NBLOCKS (bv);
- for (i = 0; i < n; i++)
- free_symtab_block (BLOCKVECTOR_BLOCK (bv, i));
- /* Free the blockvector itself. */
- free (bv);
- /* Free the type vector. */
- tv = TYPEVECTOR (s);
- if (tv) /* FIXME, should this happen? It does... */
- free (tv);
- /* Also free the linetable. */
-
- case free_linetable:
- /* Everything will be freed either by our `free_ptr'
- or by some other symbatb, except for our linetable.
- Free that now. */
- free (LINETABLE (s));
- break;
- }
-
- /* If there is a single block of memory to free, free it. */
- if (s->free_ptr)
- free (s->free_ptr);
-
- if (s->line_charpos)
- free (s->line_charpos);
- free (s->filename);
- free (s);
-}
-\f
-/* Convert a raw symbol-segment to a struct symtab,
- and relocate its internal pointers so that it is valid. */
-
-/* This is how to relocate one pointer, given a name for it.
- Works independent of the type of object pointed to. */
-#define RELOCATE(slot) (slot ? (* (char **) &slot += relocation) : 0)
-
-/* This is the inverse of RELOCATE. We use it when storing
- a core address into a slot that has yet to be relocated. */
-#define UNRELOCATE(slot) (slot ? (* (char **) &slot -= relocation) : 0)
-
-/* During the process of relocation, this holds the amount to relocate by
- (the address of the file's symtab data, in core in the debugger). */
-static int relocation;
-
-#define CORE_RELOCATE(slot) \
- ((slot) += (((slot) < data_start) ? text_relocation \
- : ((slot) < bss_start) ? data_relocation : bss_relocation))
-
-#define TEXT_RELOCATE(slot) ((slot) += text_relocation)
-
-/* Relocation amounts for addresses in the program's core image. */
-static int text_relocation, data_relocation, bss_relocation;
-
-/* Boundaries that divide program core addresses into text, data and bss;
- used to determine which relocation amount to use. */
-static int data_start, bss_start;
-
-static void relocate_typevector ();
-static void relocate_blockvector ();
-static void relocate_type ();
-static void relocate_block ();
-static void relocate_symbol ();
-
-/* Relocate a file symbol table so that all the pointers
- are valid C pointers. Pass the struct symtab for the file
- and the amount to relocate by. */
-
-static struct symtab *
-relocate_symtab (root)
- struct symbol_root *root;
-{
- struct symtab *sp = (struct symtab *) xmalloc (sizeof (struct symtab));
- bzero (sp, sizeof (struct symtab));
-
- relocation = (int) root;
- text_relocation = root->textrel;
- data_relocation = root->datarel;
- bss_relocation = root->bssrel;
- data_start = root->databeg;
- bss_start = root->bssbeg;
-
- sp->filename = root->filename;
- sp->ldsymoff = root->ldsymoff;
- sp->language = root->language;
- sp->compilation = root->compilation;
- sp->version = root->version;
- sp->blockvector = root->blockvector;
- sp->typevector = root->typevector;
- sp->free_code = free_explicit;
- sp->free_ptr = (char *) root;
-
- RELOCATE (TYPEVECTOR (sp));
- RELOCATE (BLOCKVECTOR (sp));
- RELOCATE (sp->version);
- RELOCATE (sp->compilation);
- RELOCATE (sp->filename);
-
- relocate_typevector (TYPEVECTOR (sp));
- relocate_blockvector (BLOCKVECTOR (sp));
-
- return sp;
-}
-
-static void
-relocate_typevector (tv)
- struct typevector *tv;
-{
- register int ntypes = TYPEVECTOR_NTYPES (tv);
- register int i;
-
- for (i = 0; i < ntypes; i++)
- RELOCATE (TYPEVECTOR_TYPE (tv, i));
- for (i = 0; i < ntypes; i++)
- relocate_type (TYPEVECTOR_TYPE (tv, i));
-}
-
-static void
-relocate_blockvector (blp)
- register struct blockvector *blp;
-{
- register int nblocks = BLOCKVECTOR_NBLOCKS (blp);
- register int i;
- for (i = 0; i < nblocks; i++)
- RELOCATE (BLOCKVECTOR_BLOCK (blp, i));
- for (i = 0; i < nblocks; i++)
- relocate_block (BLOCKVECTOR_BLOCK (blp, i));
-}
-
-static void
-relocate_block (bp)
- register struct block *bp;
-{
- register int nsyms = BLOCK_NSYMS (bp);
- register int i;
-
- TEXT_RELOCATE (BLOCK_START (bp));
- TEXT_RELOCATE (BLOCK_END (bp));
-
- /* These two should not be recursively processed.
- The superblock need not be because all blocks are
- processed from relocate_blockvector.
- The function need not be because it will be processed
- under the block which is its scope. */
- RELOCATE (BLOCK_SUPERBLOCK (bp));
- RELOCATE (BLOCK_FUNCTION (bp));
-
- for (i = 0; i < nsyms; i++)
- RELOCATE (BLOCK_SYM (bp, i));
-
- for (i = 0; i < nsyms; i++)
- relocate_symbol (BLOCK_SYM (bp, i));
-}
-
-static void
-relocate_symbol (sp)
- register struct symbol *sp;
-{
- RELOCATE (SYMBOL_NAME (sp));
- if (SYMBOL_CLASS (sp) == LOC_BLOCK)
- {
- RELOCATE (SYMBOL_BLOCK_VALUE (sp));
- /* We can assume the block that belongs to this symbol
- is not relocated yet, since it comes after
- the block that contains this symbol. */
- BLOCK_FUNCTION (SYMBOL_BLOCK_VALUE (sp)) = sp;
- UNRELOCATE (BLOCK_FUNCTION (SYMBOL_BLOCK_VALUE (sp)));
- }
- else if (SYMBOL_CLASS (sp) == LOC_STATIC)
- CORE_RELOCATE (SYMBOL_VALUE (sp));
- else if (SYMBOL_CLASS (sp) == LOC_LABEL)
- TEXT_RELOCATE (SYMBOL_VALUE (sp));
- RELOCATE (SYMBOL_TYPE (sp));
-}
-
-/* We cannot come up with an a priori spanning tree
- for the network of types, since types can be used
- for many symbols and also as components of other types.
- Therefore, we need to be able to mark types that we
- already have relocated (or are already in the middle of relocating)
- as in a garbage collector. */
-
-static void
-relocate_type (tp)
- register struct type *tp;
-{
- register int nfields = TYPE_NFIELDS (tp);
- register int i;
-
- RELOCATE (TYPE_NAME (tp));
- RELOCATE (TYPE_TARGET_TYPE (tp));
- RELOCATE (TYPE_FIELDS (tp));
- RELOCATE (TYPE_POINTER_TYPE (tp));
-
- for (i = 0; i < nfields; i++)
- {
- RELOCATE (TYPE_FIELD_TYPE (tp, i));
- RELOCATE (TYPE_FIELD_NAME (tp, i));
- }
-}
-\f
-/* Read symsegs from file named NAME open on DESC,
- make symtabs from them, and return a chain of them.
- Assumes DESC is prepositioned at the end of the string table,
- just before the symsegs if there are any. */
-
-struct symtab *
-read_symsegs (desc, name)
- int desc;
- char *name;
-{
- struct symbol_root root;
- register char *data;
- register struct symtab *sp, *chain = 0;
- register int len;
-
- while (1)
- {
- len = myread (desc, &root, sizeof root);
- if (len == 0 || root.format == 0)
- break;
- if (root.format != 1 ||
- root.length < sizeof root)
- error ("Invalid symbol segment format code");
- data = (char *) xmalloc (root.length);
- bcopy (&root, data, sizeof root);
- len = myread (desc, data + sizeof root,
- root.length - sizeof root);
- sp = relocate_symtab (data);
- sp->next = chain;
- chain = sp;
- }
-
- return chain;
-}
-\f
-static int block_depth ();
-static void print_spaces ();
-static void print_symbol ();
-
-print_symtabs (filename)
- char *filename;
-{
- FILE *outfile;
- register struct symtab *s;
- register int i, j;
- int len, line, blen;
- register struct linetable *l;
- struct blockvector *bv;
- register struct block *b;
- int depth;
- struct cleanup *cleanups;
- extern int fclose();
-
- if (filename == 0)
- error_no_arg ("file to write symbol data in");
- outfile = fopen (filename, "w");
-
- cleanups = make_cleanup (fclose, outfile);
- immediate_quit++;
-
- for (s = symtab_list; s; s = s->next)
- {
- /* First print the line table. */
- fprintf (outfile, "Symtab for file %s\n\n", s->filename);
- fprintf (outfile, "Line table:\n\n");
- l = LINETABLE (s);
- len = l->nitems;
- for (i = 0; i < len; i++)
- {
- if (l->item[i] < 0)
- line = - l->item[i] - 1;
- else
- fprintf (outfile, " line %d at %x\n", ++line, l->item[i]);
- }
- /* Now print the block info. */
- fprintf (outfile, "\nBlockvector:\n\n");
- bv = BLOCKVECTOR (s);
- len = BLOCKVECTOR_NBLOCKS (bv);
- for (i = 0; i < len; i++)
- {
- b = BLOCKVECTOR_BLOCK (bv, i);
- depth = block_depth (b) * 2;
- print_spaces (depth, outfile);
- fprintf (outfile, "block #%03d (object 0x%x) ", i, b);
- fprintf (outfile, "[0x%x..0x%x]", BLOCK_START (b), BLOCK_END (b));
- if (BLOCK_SUPERBLOCK (b))
- fprintf (outfile, " (under 0x%x)", BLOCK_SUPERBLOCK (b));
- if (BLOCK_FUNCTION (b))
- fprintf (outfile, " %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
- fputc ('\n', outfile);
- blen = BLOCK_NSYMS (b);
- for (j = 0; j < blen; j++)
- {
- print_symbol (BLOCK_SYM (b, j), depth + 1, outfile);
- }
- }
-
- fprintf (outfile, "\n\n");
- }
-
- immediate_quit--;
- do_cleanups (cleanups);
-}
-
-static void
-print_symbol (symbol, depth, outfile)
- struct symbol *symbol;
- int depth;
- FILE *outfile;
-{
- print_spaces (depth, outfile);
- if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
- {
- fprintf (outfile, "label %s at 0x%x", SYMBOL_NAME (symbol),
- SYMBOL_VALUE (symbol));
- return;
- }
- if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
- {
- if (TYPE_NAME (SYMBOL_TYPE (symbol)))
- {
- type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
- }
- else
- {
- fprintf (outfile, "%s %s = ",
- (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
- ? "enum"
- : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
- ? "struct" : "union")),
- SYMBOL_NAME (symbol));
- type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
- }
- fprintf (outfile, ";\n");
- }
- else
- {
- if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
- fprintf (outfile, "typedef ");
- if (SYMBOL_TYPE (symbol))
- {
- type_print_1 (SYMBOL_TYPE (symbol), SYMBOL_NAME (symbol),
- outfile, 1, depth);
- fprintf (outfile, "; ");
- }
- else
- fprintf (outfile, "%s ", SYMBOL_NAME (symbol));
-
- switch (SYMBOL_CLASS (symbol))
- {
- case LOC_CONST:
- fprintf (outfile, "const %d (0x%x),",
- SYMBOL_VALUE (symbol), SYMBOL_VALUE (symbol));
- break;
-
- case LOC_CONST_BYTES:
- fprintf (outfile, "const %d hex bytes:",
- TYPE_LENGTH (SYMBOL_TYPE (symbol)));
- {
- int i;
- for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (symbol)); i++)
- fprintf (outfile, " %2x", SYMBOL_VALUE_BYTES (symbol) [i]);
- fprintf (outfile, ",");
- }
- break;
-
- case LOC_STATIC:
- fprintf (outfile, "static at 0x%x,", SYMBOL_VALUE (symbol));
- break;
-
- case LOC_REGISTER:
- fprintf (outfile, "register %d,", SYMBOL_VALUE (symbol));
- break;
-
- case LOC_ARG:
- fprintf (outfile, "arg at 0x%x,", SYMBOL_VALUE (symbol));
- break;
-
- case LOC_LOCAL:
- fprintf (outfile, "local at 0x%x,", SYMBOL_VALUE (symbol));
- break;
-
- case LOC_TYPEDEF:
- break;
-
- case LOC_LABEL:
- fprintf (outfile, "label at 0x%x", SYMBOL_VALUE (symbol));
- break;
-
- case LOC_BLOCK:
- fprintf (outfile, "block (object 0x%x) starting at 0x%x,",
- SYMBOL_VALUE (symbol),
- BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)));
- break;
- }
- }
- fprintf (outfile, "\n");
-}
-
-/* Return the nexting depth of a block within other blocks in its symtab. */
-
-static int
-block_depth (block)
- struct block *block;
-{
- register int i = 0;
- while (block = BLOCK_SUPERBLOCK (block)) i++;
- return i;
-}
-\f
-static
-initialize ()
-{
- add_com ("printsyms", class_obscure, print_symtabs,
- "Print dump of current symbol definitions to file OUTFILE.");
-}
-
-END_FILE
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d125 2
-a126 1
- free (tv);
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.10.33; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.26.02.18.56; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@Original from RMS's wheaties devel sources
-@
-
-
-1.2
-log
-@Permit SYS V regular expression library as well as real Unix one.
-@
-text
-@/* Symbol table lookup for the GNU debugger, GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include "defs.h"
-#include "initialize.h"
-#include "symtab.h"
-#include "param.h"
-
-#include <stdio.h>
-#include <obstack.h>
-
-#ifdef mac_aux
-#define REGCMP
-#endif
-
-START_FILE
-
-/* Allocate an obstack to hold objects that should be freed
- when we load a new symbol table.
- This includes the symbols made by dbxread
- and the types that are not permanent. */
-
-struct obstack obstack1;
-
-struct obstack *symbol_obstack = &obstack1;
-
-/* These variables point to the objects
- representing the predefined C data types. */
-
-struct type *builtin_type_void;
-struct type *builtin_type_char;
-struct type *builtin_type_short;
-struct type *builtin_type_int;
-struct type *builtin_type_long;
-struct type *builtin_type_unsigned_char;
-struct type *builtin_type_unsigned_short;
-struct type *builtin_type_unsigned_int;
-struct type *builtin_type_unsigned_long;
-struct type *builtin_type_float;
-struct type *builtin_type_double;
-
-/* Lookup the symbol table of a source file named NAME. */
-
-struct symtab *
-lookup_symtab (name)
- char *name;
-{
- register struct symtab *s;
- register char *copy;
-
- for (s = symtab_list; s; s = s->next)
- if (!strcmp (name, s->filename))
- return s;
-
- /* If name not found as specified, see if adding ".c" helps. */
-
- copy = (char *) alloca (strlen (name) + 3);
- strcpy (copy, name);
- strcat (copy, ".c");
- for (s = symtab_list; s; s = s->next)
- if (!strcmp (copy, s->filename))
- return s;
-
- return 0;
-}
-\f
-/* Lookup a typedef or primitive type named NAME,
- visible in lexical block BLOCK.
- If NOERR is nonzero, return zero if NAME is not suitably defined. */
-
-struct type *
-lookup_typename (name, block, noerr)
- char *name;
- struct block *block;
- int noerr;
-{
- register struct symbol *sym = lookup_symbol (name, block, VAR_NAMESPACE);
- if (sym == 0 || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
- {
- if (!strcmp (name, "int"))
- return builtin_type_int;
- if (!strcmp (name, "long"))
- return builtin_type_long;
- if (!strcmp (name, "short"))
- return builtin_type_short;
- if (!strcmp (name, "char"))
- return builtin_type_char;
- if (!strcmp (name, "float"))
- return builtin_type_float;
- if (!strcmp (name, "double"))
- return builtin_type_double;
- if (!strcmp (name, "void"))
- return builtin_type_void;
-
- if (noerr)
- return 0;
- error ("No type named %s.", name);
- }
- return SYMBOL_TYPE (sym);
-}
-
-struct type *
-lookup_unsigned_typename (name)
- char *name;
-{
- if (!strcmp (name, "int"))
- return builtin_type_unsigned_int;
- if (!strcmp (name, "long"))
- return builtin_type_unsigned_long;
- if (!strcmp (name, "short"))
- return builtin_type_unsigned_short;
- if (!strcmp (name, "char"))
- return builtin_type_unsigned_char;
- error ("No type named unsigned %s.", name);
-}
-
-/* Lookup a structure type named "struct NAME",
- visible in lexical block BLOCK. */
-
-struct type *
-lookup_struct (name, block)
- char *name;
- struct block *block;
-{
- register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
- if (sym == 0)
- error ("No struct type named %s.", name);
- if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
- error ("This context has union or enum %s, not a struct.", name);
- return SYMBOL_TYPE (sym);
-}
-
-/* Lookup a union type named "union NAME",
- visible in lexical block BLOCK. */
-
-struct type *
-lookup_union (name, block)
- char *name;
- struct block *block;
-{
- register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
- if (sym == 0)
- error ("No union type named %s.", name);
- if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
- error ("This context has struct or enum %s, not a union.", name);
- return SYMBOL_TYPE (sym);
-}
-
-/* Lookup an enum type named "enum NAME",
- visible in lexical block BLOCK. */
-
-struct type *
-lookup_enum (name, block)
- char *name;
- struct block *block;
-{
- register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
- if (sym == 0)
- error ("No enum type named %s.", name);
- if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
- error ("This context has struct or union %s, not an enum.", name);
- return SYMBOL_TYPE (sym);
-}
-
-/* Given a type TYPE, return a type of pointers to that type.
- May need to construct such a type if this is the first use. */
-
-struct type *
-lookup_pointer_type (type)
- struct type *type;
-{
- register struct type *ptype = TYPE_POINTER_TYPE (type);
- if (ptype) return ptype;
-
- /* This is the first time anyone wanted a pointer to a TYPE. */
- if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
- ptype = (struct type *) xmalloc (sizeof (struct type));
- else
- ptype = (struct type *) obstack_alloc (symbol_obstack,
- sizeof (struct type));
-
- bzero (ptype, sizeof (struct type));
- TYPE_TARGET_TYPE (ptype) = type;
- TYPE_POINTER_TYPE (type) = ptype;
- /* New type is permanent if type pointed to is permanent. */
- if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
- TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
- /* We assume the machine has only one representation for pointers! */
- TYPE_LENGTH (ptype) = sizeof (char *);
- TYPE_CODE (ptype) = TYPE_CODE_PTR;
- return ptype;
-}
-
-/* Given a type TYPE, return a type of functions that return that type.
- May need to construct such a type if this is the first use. */
-
-struct type *
-lookup_function_type (type)
- struct type *type;
-{
- register struct type *ptype = TYPE_FUNCTION_TYPE (type);
- if (ptype) return ptype;
-
- /* This is the first time anyone wanted a function returning a TYPE. */
- if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
- ptype = (struct type *) xmalloc (sizeof (struct type));
- else
- ptype = (struct type *) obstack_alloc (symbol_obstack,
- sizeof (struct type));
-
- bzero (ptype, sizeof (struct type));
- TYPE_TARGET_TYPE (ptype) = type;
- TYPE_FUNCTION_TYPE (type) = ptype;
- /* New type is permanent if type returned is permanent. */
- if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
- TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
- TYPE_LENGTH (ptype) = 1;
- TYPE_CODE (ptype) = TYPE_CODE_FUNC;
- TYPE_NFIELDS (ptype) = 0;
- return ptype;
-}
-\f
-/* Smash TYPE to be a type of pointers to TO_TYPE.
- If TO_TYPE is not permanent and has no pointer-type yet,
- record TYPE as its pointer-type. */
-
-void
-smash_to_pointer_type (type, to_type)
- struct type *type, *to_type;
-{
- bzero (type, sizeof (struct type));
- TYPE_TARGET_TYPE (type) = to_type;
- /* We assume the machine has only one representation for pointers! */
- TYPE_LENGTH (type) = sizeof (char *);
- TYPE_CODE (type) = TYPE_CODE_PTR;
-
- if (TYPE_POINTER_TYPE (to_type) == 0
- && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
- {
- TYPE_POINTER_TYPE (to_type) = type;
- }
-}
-
-/* Smash TYPE to be a type of functions returning TO_TYPE.
- If TO_TYPE is not permanent and has no function-type yet,
- record TYPE as its function-type. */
-
-void
-smash_to_function_type (type, to_type)
- struct type *type, *to_type;
-{
- bzero (type, sizeof (struct type));
- TYPE_TARGET_TYPE (type) = to_type;
- TYPE_LENGTH (type) = 1;
- TYPE_CODE (type) = TYPE_CODE_FUNC;
- TYPE_NFIELDS (type) = 0;
-
- if (TYPE_FUNCTION_TYPE (to_type) == 0
- && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
- {
- TYPE_FUNCTION_TYPE (to_type) = type;
- }
-}
-\f
-static struct symbol *lookup_block_symbol ();
-
-/* Find the definition for a specified symbol name NAME
- in namespace NAMESPACE, visible from lexical block BLOCK.
- Returns the struct symbol pointer, or zero if no symbol is found. */
-
-struct symbol *
-lookup_symbol (name, block, namespace)
- char *name;
- register struct block *block;
- enum namespace namespace;
-{
- register int i, n;
- register struct symbol *sym;
- register struct symtab *s;
- struct blockvector *bv;
-
- /* Search specified block and its superiors. */
-
- while (block != 0)
- {
- sym = lookup_block_symbol (block, name, namespace);
- if (sym) return sym;
- block = BLOCK_SUPERBLOCK (block);
- }
-
- /* Now search all symtabs' global blocks. */
-
- for (s = symtab_list; s; s = s->next)
- {
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, 0);
- sym = lookup_block_symbol (block, name, namespace);
- if (sym) return sym;
- }
-
- /* Now search all symtabs' per-file blocks.
- Not strictly correct, but more useful than an error. */
-
- for (s = symtab_list; s; s = s->next)
- {
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, 1);
- sym = lookup_block_symbol (block, name, namespace);
- if (sym) return sym;
- }
- return 0;
-}
-
-/* Look for a symbol in block BLOCK using binary search. */
-
-static struct symbol *
-lookup_block_symbol (block, name, namespace)
- register struct block *block;
- char *name;
- enum namespace namespace;
-{
- register int bot, top, inc;
- register struct symbol *sym;
-
- top = BLOCK_NSYMS (block);
- bot = 0;
-
- /* First, advance BOT to not far before
- the first symbol whose name is NAME. */
-
- while (1)
- {
- inc = (top - bot + 1);
- /* No need to keep binary searching for the last few bits worth. */
- if (inc < 7)
- break;
- inc >>= 1;
- sym = BLOCK_SYM (block, bot + inc);
- if (strcmp (SYMBOL_NAME (sym), name) < 0)
- bot += inc;
- else
- top = bot + inc;
- }
-
- /* Now scan forward until we run out of symbols,
- find one whose name is greater than NAME,
- or find one we want.
- If there is more than one symbol with the right name and namespace,
- we return the first one. dbxread.c is careful to make sure
- that if one is a register then it comes first. */
-
- top = BLOCK_NSYMS (block);
- while (bot < top)
- {
- sym = BLOCK_SYM (block, bot);
- inc = strcmp (SYMBOL_NAME (sym), name);
- if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
- return sym;
- if (inc > 0)
- return 0;
- bot++;
- }
- return 0;
-}
-\f
-/* Return the symbol for the function which contains a specified
- lexical block, described by a struct block BL. */
-
-struct symbol *
-block_function (bl)
- struct block *bl;
-{
- while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
- bl = BLOCK_SUPERBLOCK (bl);
-
- return BLOCK_FUNCTION (bl);
-}
-
-/* Subroutine of find_pc_line */
-
-static struct symtab *
-find_pc_symtab (pc)
- register CORE_ADDR pc;
-{
- register struct block *b;
- struct blockvector *bv;
- register struct symtab *s;
-
- /* Search all symtabs for one whose file contains our pc */
-
- for (s = symtab_list; s; s = s->next)
- {
- bv = BLOCKVECTOR (s);
- b = BLOCKVECTOR_BLOCK (bv, 0);
- if (BLOCK_START (b) <= pc
- && BLOCK_END (b) > pc)
- break;
- }
-
- return s;
-}
-
-/* Find the source file and line number for a given PC value.
- Return a structure containing a symtab pointer, a line number,
- and a pc range for the entire source line.
- The value's .pc field is NOT the specified pc.
- NOTCURRENT nonzero means, if specified pc is on a line boundary,
- use the line that ends there. Otherwise, in that case, the line
- that begins there is used. */
-
-struct symtab_and_line
-find_pc_line (pc, notcurrent)
- CORE_ADDR pc;
- int notcurrent;
-{
- struct symtab *s;
- register struct linetable *l;
- register int len;
- register int i, item;
- int line;
- struct symtab_and_line value;
- struct blockvector *bv;
-
- /* Info on best line seen so far, and where it starts, and its file. */
-
- int best_line = 0;
- CORE_ADDR best_pc = 0;
- CORE_ADDR best_end = 0;
- struct symtab *best_symtab = 0;
-
- /* Store here the first line number
- of a file which contains the line at the smallest pc after PC.
- If we don't find a line whose range contains PC,
- we will use a line one less than this,
- with a range from the start of that file to the first line's pc. */
- int alt_line = 0;
- CORE_ADDR alt_pc = 0;
- struct symtab *alt_symtab = 0;
-
- /* Info on best line seen in this file. */
-
- int prev_line;
- CORE_ADDR prev_pc;
-
- /* Info on first line of this file. */
-
- int first_line;
- CORE_ADDR first_pc;
-
- /* If this pc is not from the current frame,
- it is the address of the end of a call instruction.
- Quite likely that is the start of the following statement.
- But what we want is the statement containing the instruction.
- Fudge the pc to make sure we get that. */
-
- if (notcurrent) pc -= 1;
-
- s = find_pc_symtab (pc);
- if (s == 0)
- {
- value.symtab = 0;
- value.line = 0;
- value.pc = pc;
- return value;
- }
-
- bv = BLOCKVECTOR (s);
-
- /* Look at all the symtabs that share this blockvector.
- They all have the same apriori range, that we found was right;
- but they have different line tables. */
-
- for (; s && BLOCKVECTOR (s) == bv; s = s->next)
- {
- /* Find the best line in this symtab. */
- l = LINETABLE (s);
- len = l->nitems;
- prev_line = -1;
- first_line = -1;
- for (i = 0; i < len; i++)
- {
- item = l->item[i];
- if (item < 0)
- line = - item - 1;
- else
- {
- line++;
- if (first_line < 0)
- {
- first_line = line;
- first_pc = item;
- }
- /* Return the last line that did not start after PC. */
- if (pc >= item)
- {
- prev_line = line;
- prev_pc = item;
- }
- else
- break;
- }
- }
-
- /* Is this file's best line closer than the best in the other files?
- If so, record this file, and its best line, as best so far. */
- if (prev_line >= 0 && prev_pc > best_pc)
- {
- best_pc = prev_pc;
- best_line = prev_line;
- best_symtab = s;
- if (i < len)
- best_end = item;
- else
- best_end = 0;
- }
- /* Is this file's first line closer than the first lines of other files?
- If so, record this file, and its first line, as best alternate. */
- if (first_line >= 0 && first_pc > pc
- && (alt_pc == 0 || first_pc < alt_pc))
- {
- alt_pc = first_pc;
- alt_line = first_line;
- alt_symtab = s;
- }
- }
- if (best_symtab == 0)
- {
- value.symtab = alt_symtab;
- value.line = alt_line - 1;
- value.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0));
- value.end = alt_pc;
- }
- else
- {
- value.symtab = best_symtab;
- value.line = best_line;
- value.pc = best_pc;
- value.end = (best_end ? best_end
- : (alt_pc ? alt_pc
- : BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0))));
- }
- return value;
-}
-
-/* Find the range of pc values in a line.
- Store the starting pc of the line into *STARTPTR
- and the ending pc (start of next line) into *ENDPTR.
- Returns 1 to indicate success.
- Returns 0 if could not find the specified line. */
-
-int
-find_line_pc_range (symtab, thisline, startptr, endptr)
- struct symtab *symtab;
- int thisline;
- CORE_ADDR *startptr, *endptr;
-{
- register struct linetable *l;
- register int i, line, item;
- int len;
- register CORE_ADDR prev_pc;
- CORE_ADDR last_pc;
-
- if (symtab == 0)
- return 0;
-
- l = LINETABLE (symtab);
- len = l->nitems;
- prev_pc = -1;
- for (i = 0; i < len; i++)
- {
- item = l->item[i];
- if (item < 0)
- line = - item - 1;
- else
- {
- line++;
- /* As soon as we find a line following the specified one
- we know the end pc and can return. */
- if (line > thisline)
- {
- /* If we have not seen an entry for the specified line,
- assume that means the specified line has zero bytes. */
- *startptr = prev_pc == -1 ? item : prev_pc;
- *endptr = item;
- return 1;
- }
- /* If we see an entry for the specified line,
- it gives the beginning. */
- if (line == thisline)
- prev_pc = item;
- last_pc = item;
- }
- }
- if (prev_pc != -1)
- {
- /* If we found the specified line but no later line, it's file's last.
- Its range is from line's pc to file's end pc. */
- *startptr = last_pc;
- *endptr = BLOCK_END (BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), 0));
- return 1;
- }
-
- return 0;
-}
-
-/* Find the PC value for a given source file and line number.
- Returns zero for invalid line number.
- The source file is specified with a struct symtab. */
-
-CORE_ADDR
-find_line_pc (symtab, line)
- struct symtab *symtab;
- int line;
-{
- register struct linetable *l;
- register int len;
- register int i;
- register int item;
- register int nextline = -1;
-
- if (line <= 0)
- return 0;
-
- l = LINETABLE (symtab);
- len = l->nitems;
- for (i = 0; i < len; i++)
- {
- item = l->item[i];
- if (item < 0)
- nextline = - item - 1;
- else
- {
- nextline++;
- if (line <= nextline)
- return item;
- }
- }
- return 0;
-}
-
-int
-find_pc_line_pc_range (pc, startptr, endptr)
- CORE_ADDR pc;
- CORE_ADDR *startptr, *endptr;
-{
- struct symtab_and_line sal;
- sal = find_pc_line (pc, 0);
- *startptr = sal.pc;
- *endptr = sal.end;
- return sal.symtab != 0;
-}
-\f
-/* Parse a string that specifies a line number.
- Pass the address of a char * variable; that variable will be
- advanced over the characters actually parsed.
-
- The string can be:
-
- LINENUM -- that line number in current file. PC returned is 0.
- FILE:LINENUM -- that line in that file. PC returned is 0.
- FUNCTION -- line number of openbrace of that function.
- PC returned is the start of the function.
- FILE:FUNCTION -- likewise, but prefer functions in that file.
- *EXPR -- line in which address EXPR appears.
-
- FUNCTION may be an undebuggable function found in misc_function_vector.
-
- If the argument FUNFIRSTLINE is nonzero, we want the first line
- of real code inside a function when a function is specified.
-
- DEFAULT_SYMTAB specifies the file to use if none is specified.
- It defaults to current_source_symtab.
- DEFAULT_LINE specifies the line number to use for relative
- line numbers (that start with signs). Defaults to current_source_line.
-
- Note that it is possible to return zero for the symtab
- if no file is validly specified. Callers must check that.
- Also, the line number returned may be invalid. */
-
-struct symtab_and_line
-decode_line_1 (argptr, funfirstline, default_symtab, default_line)
- char **argptr;
- int funfirstline;
- struct symtab *default_symtab;
- int default_line;
-{
- struct symtab_and_line value;
- register char *p, *p1;
- register struct symtab *s;
- register struct symbol *sym;
- register CORE_ADDR pc;
- register int i;
- char *copy;
-
- /* Defaults have defaults. */
-
- if (default_symtab == 0)
- {
- default_symtab = current_source_symtab;
- default_line = current_source_line;
- }
-
- /* See if arg is *PC */
-
- if (**argptr == '*')
- {
- (*argptr)++;
- pc = parse_and_eval_address_1 (argptr);
- value = find_pc_line (pc, 0);
- value.pc = pc;
- return value;
- }
-
- /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
-
- s = 0;
-
- for (p = *argptr; *p; p++)
- {
- if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
- break;
- }
- while (p[0] == ' ' || p[0] == '\t') p++;
-
- if (p[0] == ':')
- {
- /* Extract the file name. */
- p1 = p;
- while (p != *argptr && p[-1] == ' ') --p;
- copy = (char *) alloca (p - *argptr + 1);
- bcopy (*argptr, copy, p - *argptr);
- copy[p - *argptr] = 0;
-
- /* Find that file's data. */
- s = lookup_symtab (copy);
- if (s == 0)
- {
- if (symtab_list == 0)
- error ("No symbol table is loaded. Use the \"symbol-file\" command.");
- error ("No source file named %s.", copy);
- }
-
- /* Discard the file name from the arg. */
- p = p1 + 1;
- while (*p == ' ' || *p == '\t') p++;
- *argptr = p;
- }
-
- /* S is specified file's symtab, or 0 if no file specified.
- arg no longer contains the file name. */
-
- /* Check whether arg is all digits (and sign) */
-
- p = *argptr;
- if (*p == '-' || *p == '+') p++;
- while (*p >= '0' && *p <= '9')
- p++;
-
- if (p != *argptr && (*p == 0 || *p == ' ' || *p == '\t' || *p == ','))
- {
- /* We found a token consisting of all digits -- at least one digit. */
- enum sign {none, plus, minus} sign = none;
-
- if (**argptr == '+')
- sign = plus, (*argptr)++;
- else if (**argptr == '-')
- sign = minus, (*argptr)++;
- value.line = atoi (*argptr);
- switch (sign)
- {
- case plus:
- if (p == *argptr)
- value.line = 5;
- if (s == 0)
- value.line = default_line + value.line;
- break;
- case minus:
- if (p == *argptr)
- value.line = 15;
- if (s == 0)
- value.line = default_line - value.line;
- else
- value.line = 1;
- break;
- }
-
- while (*p == ' ' || *p == '\t') p++;
- *argptr = p;
- if (s == 0)
- s = default_symtab;
- value.symtab = s;
- value.pc = 0;
- return value;
- }
-
- /* Arg token is not digits => try it as a function name
- Find the next token (everything up to end or next whitespace). */
- p = *argptr;
- while (*p && *p != ' ' && *p != '\t' && *p != ',') p++;
- copy = (char *) alloca (p - *argptr + 1);
- bcopy (*argptr, copy, p - *argptr);
- copy[p - *argptr] = 0;
- while (*p == ' ' || *p == '\t') p++;
- *argptr = p;
-
- /* Look up that token as a function.
- If file specified, use that file's per-file block to start with. */
-
- sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
- VAR_NAMESPACE);
-
- if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
- {
- /* Arg is the name of a function */
- pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
- if (funfirstline)
- SKIP_PROLOGUE (pc);
- value = find_pc_line (pc, 0);
- value.pc = (value.end && value.pc != pc) ? value.end : pc;
- return value;
- }
-
- if (sym)
- error ("%s is not a function.", copy);
-
- for (i = 0; i < misc_function_count; i++)
- if (!strcmp (misc_function_vector[i].name, copy))
- {
- value.symtab = 0;
- value.line = 0;
- value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
- if (funfirstline)
- SKIP_PROLOGUE (value.pc);
- return value;
- }
-
- if (symtab_list == 0)
- error ("No symbol table is loaded. Use the \"symbol-file\" command.");
- error ("Function %s not defined.", copy);
-}
-
-struct symtab_and_line
-decode_line_spec (string, funfirstline)
- char *string;
- int funfirstline;
-{
- struct symtab_and_line sal;
- if (string == 0)
- error ("Empty line specification.");
- sal = decode_line_1 (&string, funfirstline,
- current_source_symtab, current_source_line);
- if (*string)
- error ("Junk at end of line specification: %s", string);
- return sal;
-}
-\f
-static void
-sources_info ()
-{
- register struct symtab *s;
- register int column = 0;
-
- if (symtab_list == 0)
- {
- printf ("No symbol table is loaded.\n");
- return;
- }
- printf ("Source files for which symbol table is known:\n");
- for (s = symtab_list; s; s = s->next)
- {
- if (column != 0 && column + strlen (s->filename) >= 70)
- {
- printf ("\n");
- column = 0;
- }
- else if (column != 0)
- {
- printf (" ");
- column++;
- }
- printf ("%s", s->filename);
- column += strlen (s->filename);
- if (s->next)
- {
- printf (",");
- column++;
- }
- }
- printf ("\n");
-}
-
-/* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
- If CLASS is zero, list all symbols except functions and type names.
- If CLASS is 1, list only functions.
- If CLASS is 2, list only type names. */
-
-#define MORE \
-{ print_count++; \
- if (print_count >= 21) \
- { printf ("--Type Return to print more--"); \
- print_count = 0; \
- fflush (stdout); \
- read_line (); } }
-
-static void
-list_symbols (regexp, class)
- char *regexp;
- int class;
-{
- register struct symtab *s;
- register struct blockvector *bv;
- struct blockvector *prev_bv = 0;
- register struct block *b;
- register int i, j;
- register struct symbol *sym;
- char *val = 0;
- int found_in_file;
- static char *classnames[]
- = {"variable", "function", "type"};
- int print_count = 0;
-#ifdef REGCMP
- extern char *regcmp(), *regex(), *loc1;
-#endif
-
- if (regexp) {
-#ifdef REGCMP
- val = regcmp(regexp, (char *)0);
- if (val == 0)
- error ("Invalid regexp: %s", regexp);
-#else
- if (val = (char *) re_comp (regexp))
- error ("Invalid regexp: %s", val);
-#endif
- }
-
- printf (regexp
- ? "All %ss matching regular expression \"%s\":\n"
- : "All defined %ss:\n",
- classnames[class],
- regexp);
-
- for (s = symtab_list; s; s = s->next)
- {
- found_in_file = 0;
- bv = BLOCKVECTOR (s);
- /* Often many files share a blockvector.
- Scan each blockvector only once so that
- we don't get every symbol many times.
- It happens that the first symtab in the list
- for any given blockvector is the main file. */
- if (bv != prev_bv)
- for (i = 0; i < 2; i++)
- {
- b = BLOCKVECTOR_BLOCK (bv, i);
- for (j = 0; j < BLOCK_NSYMS (b); j++)
- {
- QUIT;
- sym = BLOCK_SYM (b, j);
- if (regexp) {
-#ifdef REGCMP
- if (!regex(val, SYMBOL_NAME (sym)))
- continue;
-#else
- if (!re_exec (SYMBOL_NAME (sym)))
- continue;
-#endif
- }
- if ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
- && SYMBOL_CLASS (sym) != LOC_BLOCK)
- || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
- || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))
- {
- if (!found_in_file)
- {
- printf ("\nFile %s:\n", s->filename);
- print_count += 2;
- }
- found_in_file = 1;
- MORE;
- if (class != 2 && i == 1)
- printf ("static ");
- if (class == 2
- && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
- printf ("typedef ");
-
- type_print (SYMBOL_TYPE (sym),
- (SYMBOL_CLASS (sym) == LOC_TYPEDEF
- ? "" : SYMBOL_NAME (sym)),
- stdout, 0);
- if (class == 2
- && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE
- && (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0
- || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))),
- SYMBOL_NAME (sym))))
- printf (" %s", SYMBOL_NAME (sym));
- printf (";\n");
- }
- }
- }
- prev_bv = bv;
- }
-#ifdef REGCMP
- if (val)
- (void)free(val);
-#endif
-}
-
-static void
-variables_info (regexp)
- char *regexp;
-{
- list_symbols (regexp, 0);
-}
-
-static void
-functions_info (regexp)
- char *regexp;
-{
- list_symbols (regexp, 1);
-}
-
-static void
-types_info (regexp)
- char *regexp;
-{
- list_symbols (regexp, 2);
-}
-\f
-/* Initialize the standard C scalar types. */
-
-static
-struct type *
-init_type (code, length, uns, name)
- enum type_code code;
- int length, uns;
- char *name;
-{
- register struct type *type;
-
- type = (struct type *) xmalloc (sizeof (struct type));
- bzero (type, sizeof *type);
- TYPE_CODE (type) = code;
- TYPE_LENGTH (type) = length;
- TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0;
- TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
- TYPE_NFIELDS (type) = 0;
- TYPE_NAME (type) = name;
-
- return type;
-}
-
-static
-initialize ()
-{
- add_info ("variables", variables_info,
- "All global and static variable names, or those matching REGEXP.");
- add_info ("functions", functions_info,
- "All function names, or those matching REGEXP.");
- add_info ("types", types_info,
- "All types names, or those matching REGEXP.");
- add_info ("sources", sources_info,
- "Source files in the program.");
-
- obstack_init (symbol_obstack);
-
- builtin_type_void = init_type (TYPE_CODE_VOID, 0, 0, "void");
-
- builtin_type_float = init_type (TYPE_CODE_FLT, sizeof (float), 0, "float");
- builtin_type_double = init_type (TYPE_CODE_FLT, sizeof (double), 0, "double");
-
- builtin_type_char = init_type (TYPE_CODE_INT, sizeof (char), 0, "char");
- builtin_type_short = init_type (TYPE_CODE_INT, sizeof (short), 0, "short");
- builtin_type_long = init_type (TYPE_CODE_INT, sizeof (long), 0, "long");
- builtin_type_int = init_type (TYPE_CODE_INT, sizeof (int), 0, "int");
-
- builtin_type_unsigned_char = init_type (TYPE_CODE_INT, sizeof (char), 1, "unsigned char");
- builtin_type_unsigned_short = init_type (TYPE_CODE_INT, sizeof (short), 1, "unsigned short");
- builtin_type_unsigned_long = init_type (TYPE_CODE_INT, sizeof (long), 1, "unsigned long");
- builtin_type_unsigned_int = init_type (TYPE_CODE_INT, sizeof (int), 1, "unsigned int");
-}
-
-END_FILE
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d29 4
-d933 1
-a933 1
- char *val;
-d938 3
-d942 6
-a947 1
- if (regexp)
-d950 2
-d976 10
-a985 2
- if ((regexp == 0 || re_exec (SYMBOL_NAME (sym)))
- && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
-d988 1
-a988 1
- || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)))
-d1019 4
-@
+++ /dev/null
-head 1.2;
-access ;
-symbols RMS-has:1.2;
-locks ; strict;
-comment @ * @;
-
-
-1.2
-date 88.01.26.05.11.12; author gnu; state Exp;
-branches ;
-next 1.1;
-
-1.1
-date 88.01.21.05.11.11; author gnu; state Exp;
-branches ;
-next ;
-
-
-desc
-@From RMS's development sources on wheaties, 20Jan88
-@
-
-
-1.2
-log
-@Avoid using TIOCFLUSH if it is not defined.
-@
-text
-@/* General utility routines for GDB, the GNU debugger.
- Copyright (C) 1986 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include <stdio.h>
-#include <sys/ioctl.h>
-#include "defs.h"
-
-void error ();
-void fatal ();
-
-/* Chain of cleanup actions established with make_cleanup,
- to be executed if an error happens. */
-
-static struct cleanup *cleanup_chain;
-
-/* Nonzero means a quit has been requested. */
-
-int quit_flag;
-
-/* Nonzero means quit immediately if Control-C is typed now,
- rather than waiting until QUIT is executed. */
-
-int immediate_quit;
-\f
-/* Add a new cleanup to the cleanup_chain,
- and return the previous chain pointer
- to be passed later to do_cleanups or discard_cleanups.
- Args are FUNCTION to clean up with, and ARG to pass to it. */
-
-struct cleanup *
-make_cleanup (function, arg)
- void (*function) ();
- int arg;
-{
- register struct cleanup *new
- = (struct cleanup *) xmalloc (sizeof (struct cleanup));
- register struct cleanup *old_chain = cleanup_chain;
-
- new->next = cleanup_chain;
- new->function = function;
- new->arg = arg;
- cleanup_chain = new;
-
- return old_chain;
-}
-
-/* Discard cleanups and do the actions they describe
- until we get back to the point OLD_CHAIN in the cleanup_chain. */
-
-void
-do_cleanups (old_chain)
- register struct cleanup *old_chain;
-{
- register struct cleanup *ptr;
- while ((ptr = cleanup_chain) != old_chain)
- {
- (*ptr->function) (ptr->arg);
- cleanup_chain = ptr->next;
- free (ptr);
- }
-}
-
-/* Discard cleanups, not doing the actions they describe,
- until we get back to the point OLD_CHAIN in the cleanup_chain. */
-
-void
-discard_cleanups (old_chain)
- register struct cleanup *old_chain;
-{
- register struct cleanup *ptr;
- while ((ptr = cleanup_chain) != old_chain)
- {
- cleanup_chain = ptr->next;
- free (ptr);
- }
-}
-
-/* This function is useful for cleanups.
- Do
-
- foo = xmalloc (...);
- old_chain = make_cleanup (free_current_contents, &foo);
-
- to arrange to free the object thus allocated. */
-
-void
-free_current_contents (location)
- char **location;
-{
- free (*location);
-}
-\f
-/* Generally useful subroutines used throughout the program. */
-
-/* Like malloc but get error if no storage available. */
-
-char *
-xmalloc (size)
- long size;
-{
- register char *val = (char *) malloc (size);
- if (!val)
- fatal ("virtual memory exhausted.", 0);
- return val;
-}
-
-/* Like realloc but get error if no storage available. */
-
-char *
-xrealloc (ptr, size)
- char *ptr;
- long size;
-{
- register char *val = (char *) realloc (ptr, size);
- if (!val)
- fatal ("virtual memory exhausted.", 0);
- return val;
-}
-
-/* Print the system error message for errno, and also mention STRING
- as the file name for which the error was encountered.
- Then return to command level. */
-
-void
-perror_with_name (string)
- char *string;
-{
- extern int sys_nerr;
- extern char *sys_errlist[];
- extern int errno;
- char *err;
- char *combined;
-
- if (errno < sys_nerr)
- err = sys_errlist[errno];
- else
- err = "unknown error";
-
- combined = (char *) alloca (strlen (err) + strlen (string) + 3);
- strcpy (combined, string);
- strcat (combined, ": ");
- strcat (combined, err);
-
- error ("%s.", combined);
-}
-
-/* Print the system error message for ERRCODE, and also mention STRING
- as the file name for which the error was encountered. */
-
-void
-print_sys_errmsg (string, errcode)
- char *string;
- int errcode;
-{
- extern int sys_nerr;
- extern char *sys_errlist[];
- char *err;
- char *combined;
-
- if (errcode < sys_nerr)
- err = sys_errlist[errcode];
- else
- err = "unknown error";
-
- combined = (char *) alloca (strlen (err) + strlen (string) + 3);
- strcpy (combined, string);
- strcat (combined, ": ");
- strcat (combined, err);
-
- printf ("%s.\n", combined);
-}
-
-void
-quit ()
-{
- fflush (stdout);
-#ifdef TIOCFLUSH
- ioctl (fileno (stdout), TIOCFLUSH, 0);
-#endif
- error ("Quit");
-}
-
-/* Control C comes here */
-
-void
-request_quit ()
-{
- quit_flag = 1;
- if (immediate_quit)
- quit ();
-}
-
-/* Print an error message and return to command level.
- STRING is the error message, used as a fprintf string,
- and ARG is passed as an argument to it. */
-
-void
-error (string, arg1, arg2, arg3)
- char *string;
- int arg1, arg2, arg3;
-{
- fflush (stdout);
- fprintf (stderr, string, arg1, arg2, arg3);
- fprintf (stderr, "\n");
- return_to_top_level ();
-}
-
-/* Print an error message and exit reporting failure.
- This is for a error that we cannot continue from.
- STRING and ARG are passed to fprintf. */
-
-void
-fatal (string, arg)
- char *string;
- int arg;
-{
- fprintf (stderr, "gdb: ");
- fprintf (stderr, string, arg);
- fprintf (stderr, "\n");
- exit (1);
-}
-
-/* Make a copy of the string at PTR with SIZE characters
- (and add a null character at the end in the copy).
- Uses malloc to get the space. Returns the address of the copy. */
-
-char *
-savestring (ptr, size)
- char *ptr;
- int size;
-{
- register char *p = (char *) xmalloc (size + 1);
- bcopy (ptr, p, size);
- p[size] = 0;
- return p;
-}
-
-char *
-concat (s1, s2, s3)
- char *s1, *s2, *s3;
-{
- register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
- register char *val = (char *) xmalloc (len);
- strcpy (val, s1);
- strcat (val, s2);
- strcat (val, s3);
- return val;
-}
-
-void
-print_spaces (n, file)
- register int n;
- register FILE *file;
-{
- while (n-- > 0)
- fputc (' ', file);
-}
-
-/* Ask user a y-or-n question and return 1 iff answer is yes.
- Takes three args which are given to printf to print the question.
- The first, a control string, should end in "? ".
- It should not say how to answer, because we do that. */
-
-int
-query (ctlstr, arg1, arg2)
- char *ctlstr;
-{
- register int answer;
-
- /* Automatically answer "yes" if input is not from a terminal. */
- if (!input_from_terminal_p ())
- return 1;
-
- while (1)
- {
- printf (ctlstr, arg1, arg2);
- printf ("(y or n) ");
- fflush (stdout);
- answer = fgetc (stdin);
- clearerr (stdin); /* in case of C-d */
- if (answer != '\n')
- while (fgetc (stdin) != '\n') clearerr (stdin);
- if (answer >= 'a')
- answer -= 040;
- if (answer == 'Y')
- return 1;
- if (answer == 'N')
- return 0;
- printf ("Please answer y or n.\n");
- }
-}
-\f
-/* Parse a C escape sequence. STRING_PTR points to a variable
- containing a pointer to the string to parse. That pointer
- is updated past the characters we use. The value of the
- escape sequence is returned.
-
- A negative value means the sequence \ newline was seen,
- which is supposed to be equivalent to nothing at all.
-
- If \ is followed by a null character, we return a negative
- value and leave the string pointer pointing at the null character.
-
- If \ is followed by 000, we return 0 and leave the string pointer
- after the zeros. A value of 0 does not mean end of string. */
-
-int
-parse_escape (string_ptr)
- char **string_ptr;
-{
- register int c = *(*string_ptr)++;
- switch (c)
- {
- case 'a':
- return '\a';
- case 'b':
- return '\b';
- case 'e':
- return 033;
- case 'f':
- return '\f';
- case 'n':
- return '\n';
- case 'r':
- return '\r';
- case 't':
- return '\t';
- case 'v':
- return '\v';
- case '\n':
- return -2;
- case 0:
- (*string_ptr)--;
- return 0;
- case '^':
- c = *(*string_ptr)++;
- if (c == '\\')
- c = parse_escape (string_ptr);
- if (c == '?')
- return 0177;
- return (c & 0200) | (c & 037);
-
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- {
- register int i = c - '0';
- register int count = 0;
- while (++count < 3)
- {
- if ((c = *(*string_ptr)++) >= '0' && c <= '7')
- {
- i *= 8;
- i += c - '0';
- }
- else
- {
- (*string_ptr)--;
- break;
- }
- }
- return i;
- }
- default:
- return c;
- }
-}
-\f
-void
-printchar (ch, stream)
- unsigned char ch;
- FILE *stream;
-{
- register int c = ch;
- if (c < 040 || c >= 0177)
- {
- if (c == '\n')
- fprintf (stream, "\\n");
- else if (c == '\b')
- fprintf (stream, "\\b");
- else if (c == '\t')
- fprintf (stream, "\\t");
- else if (c == '\f')
- fprintf (stream, "\\f");
- else if (c == '\r')
- fprintf (stream, "\\r");
- else if (c == 033)
- fprintf (stream, "\\e");
- else if (c == '\a')
- fprintf (stream, "\\a");
- else
- fprintf (stream, "\\%03o", c);
- }
- else
- {
- if (c == '\\' || c == '"' || c == '\'')
- fputc ('\\', stream);
- fputc (c, stream);
- }
-}
-@
-
-
-1.1
-log
-@Initial revision
-@
-text
-@d194 1
-d196 1
-@
+++ /dev/null
-This is GDB, a source-level debugger intended for GNU,
-presently running under un*x.
-
-Before compiling GDB, you must set three files according to
-the kind of machine you are running on.
-
-param.h must be set up to #include an m- file for the machine.
-The m- files written so far are m-vax.h, m-sun2.h and m-sun3.h.
-(I believe that it is the operating system version and not
-the cpu type which determines which of the two is right on a Sun.)
-This file contains macro definitions that express information
-about the machine's registers, stack frame format and instructions.
-
-initialize.h must be set up to #include an m-...init.h file.
-There are two of them written: m-vaxinit.h and m-suninit.h.
-This file defines one macro, which says how to round up from the
-address of the end of the text of one .o file to the beginning of
-the text of the next .o file.
-
-pinsn.c must be set up to include the instruction printer for
-your cpu type. The two printers that exist are vax-pinsn.c
-and m68k-pinsn.c.
-
-`Makefile' must be changed to say `OBSTACK = obstack.o' instead of
-`OBSTACK=-lobstack' (unless you want to install obstack.o as
-/lib/libobstack.a).
-
-Once these files are set up, just `make' will do everything,
-producing an executable `gdb' in this directory.
+++ /dev/null
-\f
-blockframe.c,436
-block_for_pc \7f221,5337
-block_innermost_frame \7f308,7200
-find_pc_function \7f276,6473
-find_pc_misc_function \7f290,6806
-get_current_block \7f182,4485
-get_current_frame \7f47,1553
-get_frame_block \7f172,4336
-get_frame_function \7f208,5053
-get_frame_info \7f90,2661
-get_frame_pc \7f150,3800
-get_frame_saved_regs \7f161,3986
-get_pc_function_start \7f188,4557
-get_prev_frame \7f66,1893
-get_prev_frame_info \7f128,3455
-initialize \7f329,7603
-set_current_frame \7f56,1705
-\f
-breakpoint.c,1102
-#define ALL_BREAKPOINTS(\7f71,2545
-break_command \7f604,14937
-break_command_1 \7f528,13121
-breakpoint_1 \7f360,9438
-breakpoint_auto_delete \7f687,16916
-breakpoint_here_p \7f288,7887
-breakpoint_stop_status \7f308,8410
-breakpoints_info \7f409,10520
-check_duplicates \7f443,11290
-clear_breakpoint_commands \7f218,6186
-clear_breakpoints \7f757,18298
-clear_command \7f620,15179
-clear_momentary_breakpoints \7f513,12821
-commands_command \7f154,4443
-condition_command \7f109,3533
-delete_breakpoint \7f704,17221
-delete_command \7f733,17741
-disable_breakpoint \7f873,20658
-disable_command \7f882,20791
-do_breakpoint_commands \7f200,5626
-enable_breakpoint \7f857,20419
-enable_command \7f866,20550
-enable_delete_breakpoint \7f910,21276
-enable_delete_command \7f919,21413
-enable_once_breakpoint \7f894,21020
-enable_once_command \7f903,21158
-ignore_command \7f797,19190
-initialize \7f933,21666
-insert_breakpoints \7f230,6503
-map_breakpoint_numbers \7f822,19738
-mark_breakpoints_out \7f275,7576
-remove_breakpoints \7f251,7042
-set_default_breakpoint \7f426,10820
-set_ignore_count \7f767,18523
-set_momentary_breakpoint \7f501,12597
-set_raw_breakpoint \7f464,11810
-tbreak_command \7f612,15057
-\f
-command.c,151
-add_alias_cmd \7f141,6077
-add_cmd \7f116,5529
-add_prefix_cmd \7f177,7140
-delete_cmd \7f198,7681
-help_cmd \7f230,8515
-lookup_cmd \7f336,11651
-savestring \7f446,13891
-\f
-core.c,397
-#define N_DATADDR(\7f41,1348
-#define N_TXTADDR(\7f37,1278
-close_exec_file \7f268,7417
-core_file_command \7f104,2838
-exec_file_command \7f221,6183
-files_info \7f330,8673
-get_exec_file \7f315,8446
-have_core_file_p \7f324,8612
-initialize \7f548,13957
-myread \7f505,13219
-read_memory \7f373,9666
-register_addr \7f531,13685
-reopen_exec_file \7f275,7501
-validate_files \7f291,7907
-write_memory \7f389,10073
-xfer_core_file \7f400,10338
-\f
-dbxread.c,1108
-add_new_header_file \7f346,10622
-add_old_header_file \7f317,9604
-add_symbol_to_list \7f496,14905
-add_this_object_header_file \7f297,8977
-compare_misc_functions \7f931,26566
-compare_symbols \7f1000,28016
-condense_misc_bunches \7f957,27070
-dbx_alloc_type \7f454,13833
-dbx_lookup_type \7f404,12394
-define_symbol \7f1516,42011
-discard_misc_bunches \7f944,26878
-end_symtab \7f756,22240
-explicit_lookup_type \7f475,14373
-finish_block \7f512,15299
-free_header_files \7f273,8395
-get_sym_file \7f1174,32423
-hash_symsegs \7f1343,36983
-hashname \7f1318,36533
-init_header_files \7f260,8046
-init_misc_functions \7f903,25961
-initialize \7f2078,57588
-make_blockvector \7f590,17428
-new_object_header_files \7f286,8705
-next_symbol_text \7f1309,36368
-pop_subfile \7f861,25120
-process_one_symbol \7f1374,37801
-push_subfile \7f847,24770
-read_dbx_symtab \7f1186,32790
-read_enum_type \7f1892,52804
-read_number \7f2041,57023
-read_range_type \7f1962,54881
-read_struct_type \7f1809,50421
-read_type \7f1685,47313
-read_type_number \7f1658,46658
-record_line \7f627,18511
-record_misc_function \7f911,26075
-sort_syms \7f1012,28407
-start_subfile \7f699,20484
-start_symtab \7f662,19485
-symbol_file_command \7f1036,28951
-\f
-environ.c,213
-environ_vector \7f164,6337
-free_environ \7f118,5334
-get_in_environ \7f173,6472
-init_environ \7f134,5661
-make_environ \7f103,5036
-#define max(\7f96,4912
-#define min(\7f95,4870
-set_in_environ \7f192,6807
-unset_in_environ \7f232,7561
-\f
-eval.c,309
-evaluate_expression \7f95,2716
-evaluate_subexp \7f114,3104
-evaluate_subexp_for_address \7f440,13032
-evaluate_subexp_for_sizeof \7f509,14789
-evaluate_subexp_with_coercion \7f477,13979
-evaluate_type \7f106,2961
-initialize \7f550,15888
-parse_and_eval \7f64,1977
-parse_and_eval_address \7f33,1188
-parse_and_eval_address_1 \7f50,1650
-\f
-expprint.c,49
-print_expression \7f88,3265
-print_subexp \7f102,3660
-\f
-expread.tab.c,358
-copy_name \7f538,12121
-end_arglist \7f125,2565
-free_funcalls \7f139,2867
-length_of_subexp \7f572,13025
-parse_c_1 \7f751,17140
-parse_c_expression \7f790,18194
-parse_number \7f217,5038
-prefixify_expression \7f552,12457
-prefixify_subexp \7f644,14362
-start_arglist \7f111,2206
-write_exp_elt \7f156,3206
-write_exp_string \7f173,3660
-yyerror \7f529,11966
-yylex \7f315,7081
-yyparse(\7f985,25972
-\f
-findvar.c,309
-find_saved_register \7f38,1432
-initialize \7f386,10456
-locate_var_value \7f334,9235
-read_register \7f165,4621
-read_register_bytes \7f140,4050
-read_relative_register_raw_bytes \7f68,2095
-read_var_value \7f202,5600
-supply_register \7f190,5277
-value_of_register \7f102,2842
-write_register \7f175,4862
-write_register_bytes \7f151,4328
-\f
-firstfile.c,89
-initialize_all_files \7f128,6009
-initialize_dummy_1 \7f140,6338
-initialize_dummy_2 \7f148,6497
-\f
-infcmd.c,550
-cont_command \7f165,3979
-environment_info \7f479,11280
-finish_command \7f397,9291
-have_inferior_p \7f106,2907
-initialize \7f682,15823
-jump_command \7f269,6035
-next_command \7f202,4695
-nexti_command \7f216,4897
-program_info \7f457,10675
-read_memory_integer \7f542,12697
-read_pc \7f575,13293
-registers_info \7f589,13488
-run_command \7f121,3120
-run_stack_dummy \7f355,8179
-set_args_command \7f112,2972
-set_environment_command \7f499,11682
-signal_command \7f314,7007
-step_1 \7f222,4974
-step_command \7f194,4543
-stepi_command \7f210,4820
-unset_environment_command \7f531,12458
-write_pc \7f580,13357
-\f
-inflow.c,551
-create_inferior \7f187,5073
-fetch_inferior_registers \7f271,6793
-fetch_inferior_registers \7f317,8482
-inferior_died \7f244,6286
-initialize \7f483,13062
-kill_command \7f226,5974
-kill_inferior \7f235,6161
-read_inferior_memory \7f388,10475
-resume \7f258,6596
-store_inferior_registers \7f294,7707
-store_inferior_registers \7f343,9249
-term_status_command \7f165,4365
-terminal_inferior \7f87,2428
-terminal_init_inferior \7f71,2074
-terminal_ours \7f121,3326
-terminal_ours_1 \7f127,3383
-terminal_ours_for_output \7f111,3126
-try_writing_regs_command \7f457,12556
-write_inferior_memory \7f416,11420
-\f
-infrun.c,286
-clear_proceed_status \7f111,3347
-handle_command \7f728,21384
-initialize \7f848,24793
-insert_step_breakpoint \7f706,20807
-normal_stop \7f618,18254
-proceed \7f138,4172
-remove_step_breakpoint \7f718,21109
-signals_info \7f810,23832
-start_inferior \7f214,6079
-wait_for_inferior \7f242,7039
-writing_pc \7f202,5763
-\f
-kdb-start.c,14
-start \7f10,140
-\f
-lastfile.c,28
-initialize_last_file \7f4,144
-\f
-m68k-pinsn.c,361
-#define NEXTBYTE(\7f43,1554
-#define NEXTDOUBLE(\7f54,1819
-#define NEXTEXTEND(\7f57,1877
-#define NEXTLONG(\7f48,1671
-#define NEXTPACKED(\7f61,1995
-#define NEXTSINGLE(\7f51,1762
-#define NEXTWORD(\7f45,1602
-convert_from_68881 \7f713,16392
-convert_to_68881 \7f732,16806
-fetch_arg \7f504,12082
-print_base \7f693,15890
-print_indexed \7f603,13871
-print_insn \7f71,2389
-print_insn_arg \7f163,4738
-\f
-main.c,841
-add_com \7f487,11896
-add_com_alias \7f499,12123
-add_info \7f455,11186
-add_info_alias \7f466,11372
-cd_command \7f885,24375
-command_loop \7f288,7462
-copying_info \7f628,14816
-define_command \7f545,12933
-do_nothing \7f281,7362
-document_command \7f583,13895
-dont_repeat \7f323,8255
-dump_me_command \7f961,25608
-echo_command \7f935,25224
-error_no_arg \7f509,12321
-execute_command \7f245,6496
-free_command_lines \7f437,10877
-help_command \7f516,12415
-info_command \7f478,11700
-initialize_main \7f972,25764
-input_from_terminal_p \7f869,24072
-main \7f81,2147
-print_gdb_version \7f800,22767
-pwd_command \7f875,24143
-quit_command \7f856,23880
-read_command_lines \7f386,9603
-read_line \7f334,8514
-return_to_top_level \7f71,1965
-set_prompt_command \7f818,23215
-source_cleanup \7f904,24752
-source_command \7f912,24854
-stop_sig \7f307,7915
-validate_comname \7f524,12566
-version_info \7f810,23117
-warranty_info \7f770,21356
-\f
-obstack.c,77
-_obstack_begin \7f101,4993
-_obstack_free \7f148,6461
-_obstack_newchunk \7f121,5631
-\f
-pinsn.c,0
-\f
-printcmd.c,585
-address_info \7f385,9015
-clear_displays \7f661,15183
-decode_format \7f70,2061
-display_command \7f606,14214
-display_info \7f769,17310
-do_displays \7f731,16450
-do_examine \7f231,5522
-free_display \7f649,14965
-initialize \7f888,20497
-output_command \7f346,8219
-print_address \7f208,4990
-print_command \7f306,7398
-print_formatted \7f109,2860
-print_frame_args \7f810,18392
-print_frame_nameless_args \7f870,20125
-print_variable_value \7f795,17951
-ptype_command \7f525,12189
-set_command \7f374,8765
-set_next_address \7f193,4626
-undisplay_command \7f677,15445
-validate_format \7f291,6959
-whatis_command \7f500,11716
-x_command \7f452,10410
-\f
-source.c,249
-directories_info \7f53,1637
-directory_command \7f79,2168
-find_source_lines \7f264,6263
-init_source_path \7f59,1735
-initialize \7f535,13376
-line_info \7f490,12220
-list_command \7f363,8569
-openp \7f186,4596
-print_source_lines \7f303,7291
-select_source_symtab \7f250,5960
-\f
-stack.c,502
-args_info \7f350,8833
-backtrace_command \7f232,6280
-down_command \7f498,12939
-find_relative_frame \7f391,10010
-frame_command \7f444,11623
-frame_info \7f149,4137
-get_selected_block \7f371,9306
-initialize \7f542,13968
-locals_info \7f312,8132
-print_block_frame_locals \7f257,6820
-print_frame_arg_vars \7f318,8214
-print_frame_info \7f70,2167
-print_frame_local_vars \7f291,7614
-print_sel_frame \7f131,3689
-print_selected_frame \7f140,3894
-print_stack_frame \7f57,1964
-return_command \7f516,13439
-select_frame \7f359,9033
-up_command \7f477,12347
-\f
-standalone.c,1165
-_exit \7f436,8533
-_flsbuf \7f326,6852
-access \7f76,1743
-chdir \7f62,1588
-close \7f164,4224
-core_file_command \7f340,7028
-exec_file_command \7f337,7003
-execle \7f433,8519
-exit \7f81,1771
-fault \7f514,9963
-fclose \7f189,4597
-fdopen \7f183,4539
-fflush \7f331,6910
-fgetc \7f247,5466
-fopen \7f175,4414
-fprintf \7f298,6263
-fputc \7f314,6593
-fread \7f229,5154
-fstat \7f195,4647
-fwrite \7f305,6422
-get_exec_file \7f344,7060
-getpid \7f54,1543
-getrlimit \7f474,9005
-getwd \7f66,1608
-have_core_file_p \7f350,7176
-initialize \7f585,11686
-ioctl \7f45,1478
-kill \7f51,1531
-kill_command \7f355,7213
-lseek \7f266,5714
-malloc_warning \7f441,8575
-myread \7f208,4831
-open \7f129,3606
-printf \7f291,6110
-ptrace \7f427,8490
-read_inferior_register \7f372,7361
-read_memory \7f375,7391
-read_register \7f397,7764
-restore_gdb \7f528,10282
-resume \7f490,9429
-save_frame_pointer \7f502,9633
-save_registers \7f540,10627
-sbrk \7f451,8691
-setpgrp \7f430,8504
-int (* signal \7f48,1506
-sigsetmask \7f59,1570
-int kdb_stack_beg[STACK_SIZE / sizeof \7f581,11613
-terminal_inferior \7f360,7254
-terminal_init_inferior \7f366,7300
-terminal_ours \7f363,7279
-ulimit \7f463,8913
-vfork \7f417,8200
-vlimit \7f469,8955
-wait \7f554,10975
-write_inferior_register \7f369,7330
-write_memory \7f385,7564
-write_register \7f406,7933
-\f
-stuff.c,70
-err \7f162,5253
-find_symbol \7f141,4686
-get_offset \7f97,3038
-main \7f32,1184
-\f
-symmisc.c,473
-#define CORE_RELOCATE(\7f158,4817
-#define RELOCATE(\7f148,4378
-#define TEXT_RELOCATE(\7f162,4972
-#define UNRELOCATE(\7f152,4573
-block_depth \7f499,13854
-free_all_symtabs \7f38,1310
-free_symtab \7f92,2701
-free_symtab_block \7f70,1994
-initialize \7f508,13995
-print_symbol \7f413,11786
-print_symtabs \7f353,10199
-read_symsegs \7f320,9451
-relocate_block \7f243,7195
-relocate_blockvector \7f231,6886
-relocate_symbol \7f268,7855
-relocate_symtab \7f182,5675
-relocate_type \7f296,8833
-relocate_typevector \7f218,6602
-\f
-symtab.c,716
-block_function \7f383,10928
-decode_line_1 \7f694,18782
-decode_line_spec \7f853,22739
-find_line_pc \7f624,16888
-find_line_pc_range \7f565,15457
-find_pc_line \7f425,11975
-find_pc_line_pc_range \7f655,17363
-find_pc_symtab \7f395,11161
-functions_info \7f995,26000
-init_type \7f1012,26230
-initialize \7f1032,26680
-list_symbols \7f916,24143
-lookup_block_symbol \7f330,9572
-lookup_enum \7f166,4758
-lookup_function_type \7f211,6260
-lookup_pointer_type \7f182,5269
-lookup_struct \7f134,3824
-lookup_symbol \7f285,8458
-lookup_symtab \7f58,1929
-lookup_typename \7f85,2559
-lookup_union \7f150,4293
-lookup_unsigned_typename \7f116,3346
-smash_to_function_type \7f262,7816
-smash_to_pointer_type \7f241,7206
-sources_info \7f868,23119
-types_info \7f1002,26088
-variables_info \7f988,25912
-\f
-test2.c,11
-main \7f6,86
-\f
-test3.c,25
-bar \7f12,123
-newfun \7f5,51
-\f
-testbit.c,11
-main \7f7,58
-\f
-testfun.c,44
-do_add \7f7,62
-do_float_add \7f13,104
-main \7f1,0
-\f
-testkill.c,11
- main(\7f2,1
-\f
-testrec.c,20
-foo \7f6,24
-main \7f1,0
-\f
-testreg.c,22
-foo \7f19,341
-main \7f1,0
-\f
-testregs.c,23
-foo \7f2,11
-main \7f15,321
-\f
-utils.c,382
-concat \7f254,5912
-discard_cleanups \7f84,2483
-do_cleanups \7f68,2104
-error \7f213,5038
-fatal \7f228,5397
-free_current_contents \7f104,2893
-make_cleanup \7f48,1636
-parse_escape \7f323,7736
-perror_with_name \7f142,3676
-print_spaces \7f266,6154
-print_sys_errmsg \7f168,4235
-printchar \7f390,8781
-query \7f280,6518
-quit \7f191,4675
-request_quit \7f201,4799
-savestring \7f243,5745
-xmalloc \7f115,3106
-xrealloc \7f127,3326
-\f
-valarith.c,215
-initialize \7f352,8246
-value_add \7f31,1128
-value_binop \7f116,3276
-value_equal \7f257,5535
-value_less \7f301,6746
-value_lognot \7f342,7998
-value_neg \7f328,7619
-value_sub \7f70,2102
-value_subscript \7f105,2971
-value_zerop \7f233,5184
-\f
-valops.c,395
-call_function \7f388,10791
-initialize \7f594,16295
-push_bytes \7f314,9135
-push_word \7f294,8769
-value_addr \7f247,7400
-value_arg_coerce \7f354,9928
-value_arg_push \7f373,10344
-value_assign \7f85,2697
-value_at \7f68,2289
-value_cast \7f34,1302
-value_coerce_array \7f219,6610
-value_ind \7f274,8155
-value_of_variable \7f209,6404
-value_push \7f333,9476
-value_repeat \7f186,5819
-value_string \7f485,13581
-value_struct_elt \7f555,15503
-\f
-valprint.c,237
-initialize \7f533,13661
-set_maximum_command \7f525,13515
-type_print \7f272,7365
-type_print_1 \7f283,7591
-type_print_base \7f403,10889
-type_print_varspec_prefix \7f316,8617
-type_print_varspec_suffix \7f352,9476
-val_print \7f113,3308
-value_print \7f46,1539
-\f
-values.c,762
-access_value_history \7f212,5551
-allocate_repeat_value \7f83,2505
-allocate_value \7f59,1948
-clear_internalvars \7f371,9239
-clear_value_history \7f251,6511
-convenience_info \7f386,9475
-free_all_values \7f108,3143
-history_info \7f270,6920
-initialize \7f737,18259
-internalvar_name \7f361,9048
-lookup_internalvar \7f308,7852
-modify_field \7f602,14750
-record_latest_value \7f178,4634
-release_value \7f125,3410
-set_internalvar \7f351,8879
-set_internalvar_component \7f336,8485
-set_return_value \7f709,17666
-unpack_double \7f486,11851
-unpack_field_as_long \7f578,14176
-unpack_long \7f430,10615
-value_as_double \7f418,10252
-value_as_long \7f411,10132
-value_being_returned \7f688,17121
-value_copy \7f151,3834
-value_field \7f542,13135
-value_from_double \7f654,16089
-value_from_long \7f626,15329
-value_of_internalvar \7f327,8298
-\f
-vax-pinsn.c,44
-print_insn \7f42,1456
-print_insn_arg \7f86,2396
-\f
-version.c,0
-\f
-command.h,0
-\f
-defs.h,42
-#define max(\7f24,1043
-#define min(\7f23,1001
-\f
-environ.h,0
-\f
-expression.h,0
-\f
-frame.h,0
-\f
-inferior.h,0
-\f
-initialize.h,0
-\f
-m-isi-ov.h,852
-#define ABOUT_TO_RETURN(\7f136,4974
-#define FIX_CALL_DUMMY(\7f447,17543
-#define FRAME_ARGS_ADDRESS(\7f275,9997
-#define FRAME_CHAIN(\7f264,9636
-#define FRAME_CHAIN_COMBINE(\7f269,9825
-#define FRAME_CHAIN_VALID(\7f266,9706
-#define FRAME_FIND_SAVED_REGS(\7f305,11191
-#define FRAME_LOCALS_ADDRESS(\7f277,10040
-#define FRAME_NUM_ARGS(\7f282,10176
-#define FRAME_SAVED_PC(\7f273,9929
-#define INIT_STACK(\7f471,18339
-#define INVALID_FLOAT(\7f140,5108
-#define N_DATADDR(\7f120,4437
-#define N_TXTADDR(\7f125,4616
-#define REGISTER_BYTE(\7f194,7220
-#define REGISTER_CONVERTIBLE(\7f222,8151
-#define REGISTER_CONVERT_TO_RAW(\7f236,8614
-#define REGISTER_CONVERT_TO_VIRTUAL(\7f227,8318
-#define REGISTER_RAW_SIZE(\7f203,7555
-#define REGISTER_U_ADDR(\7f174,6379
-#define REGISTER_VIRTUAL_SIZE(\7f209,7811
-#define REGISTER_VIRTUAL_TYPE(\7f245,8895
-#define SAVED_PC_AFTER_CALL(\7f97,3881
-#define SKIP_PROLOGUE(\7f77,3210
-\f
-m-sun2.h,824
-#define ABOUT_TO_RETURN(\7f79,2505
-#define FIX_CALL_DUMMY(\7f344,12862
-#define FRAME_ARGS_ADDRESS(\7f196,6448
-#define FRAME_CHAIN(\7f185,6087
-#define FRAME_CHAIN_COMBINE(\7f190,6276
-#define FRAME_CHAIN_VALID(\7f187,6157
-#define FRAME_FIND_SAVED_REGS(\7f232,7817
-#define FRAME_LOCALS_ADDRESS(\7f198,6491
-#define FRAME_NUM_ARGS(\7f205,6746
-#define FRAME_NUM_ARGS(\7f208,6795
-#define FRAME_SAVED_PC(\7f194,6380
-#define INIT_STACK(\7f368,13658
-#define INVALID_FLOAT(\7f83,2639
-#define REGISTER_BYTE(\7f121,3997
-#define REGISTER_CONVERTIBLE(\7f144,4615
-#define REGISTER_CONVERT_TO_RAW(\7f154,4927
-#define REGISTER_CONVERT_TO_VIRTUAL(\7f149,4749
-#define REGISTER_RAW_SIZE(\7f126,4162
-#define REGISTER_U_ADDR(\7f166,5375
-#define REGISTER_VIRTUAL_SIZE(\7f131,4317
-#define REGISTER_VIRTUAL_TYPE(\7f159,5092
-#define SAVED_PC_AFTER_CALL(\7f51,1836
-#define SKIP_PROLOGUE(\7f38,1400
-\f
-m-sun3.h,790
-#define ABOUT_TO_RETURN(\7f78,2454
-#define FIX_CALL_DUMMY(\7f392,15189
-#define FRAME_ARGS_ADDRESS(\7f213,7102
-#define FRAME_CHAIN(\7f202,6741
-#define FRAME_CHAIN_COMBINE(\7f207,6930
-#define FRAME_CHAIN_VALID(\7f204,6811
-#define FRAME_FIND_SAVED_REGS(\7f249,8471
-#define FRAME_LOCALS_ADDRESS(\7f215,7145
-#define FRAME_NUM_ARGS(\7f222,7400
-#define FRAME_NUM_ARGS(\7f225,7449
-#define FRAME_SAVED_PC(\7f211,7034
-#define INIT_STACK(\7f416,15985
-#define INVALID_FLOAT(\7f82,2588
-#define REGISTER_BYTE(\7f123,4130
-#define REGISTER_CONVERTIBLE(\7f151,5061
-#define REGISTER_CONVERT_TO_RAW(\7f165,5524
-#define REGISTER_CONVERT_TO_VIRTUAL(\7f156,5228
-#define REGISTER_RAW_SIZE(\7f132,4465
-#define REGISTER_VIRTUAL_SIZE(\7f138,4721
-#define REGISTER_VIRTUAL_TYPE(\7f174,5805
-#define SAVED_PC_AFTER_CALL(\7f55,1929
-#define SKIP_PROLOGUE(\7f42,1493
-\f
-m-suninit.h,29
-#define FILEADDR_ROUND(\7f5,94
-\f
-m-vax.h,791
-#define ABOUT_TO_RETURN(\7f80,2551
-#define FIX_CALL_DUMMY(\7f294,10681
-#define FRAME_ARGS_ADDRESS(\7f199,6661
-#define FRAME_CHAIN(\7f185,6120
-#define FRAME_CHAIN_COMBINE(\7f190,6314
-#define FRAME_CHAIN_VALID(\7f187,6195
-#define FRAME_FIND_SAVED_REGS(\7f222,7517
-#define FRAME_LOCALS_ADDRESS(\7f204,6836
-#define FRAME_NUM_ARGS(\7f209,6972
-#define FRAME_SAVED_PC(\7f194,6418
-#define INIT_STACK(\7f317,11455
-#define INVALID_FLOAT(\7f84,2681
-#define REGISTER_BYTE(\7f127,4329
-#define REGISTER_CONVERTIBLE(\7f150,4942
-#define REGISTER_CONVERT_TO_RAW(\7f161,5257
-#define REGISTER_CONVERT_TO_VIRTUAL(\7f155,5076
-#define REGISTER_RAW_SIZE(\7f132,4491
-#define REGISTER_U_ADDR(\7f112,3753
-#define REGISTER_VIRTUAL_SIZE(\7f137,4644
-#define REGISTER_VIRTUAL_TYPE(\7f167,5425
-#define SAVED_PC_AFTER_CALL(\7f53,1877
-#define SKIP_PROLOGUE(\7f42,1480
-\f
-m-vaxinit.h,29
-#define FILEADDR_ROUND(\7f5,94
-\f
-m68k-opcode.h,138
-#define one(\7f130,5680
-int numopcodes=sizeof(\7f1270,68164
-struct m68k_opcode *endop = m68k_opcodes+sizeof(\7f1272,68226
-#define two(\7f131,5707
-\f
-obstack.h,618
-#define obstack_1grow(\7f252,11387
-#define obstack_1grow_fast(\7f275,12190
-#define obstack_alignment_mask(\7f228,10489
-#define obstack_alloc(\7f263,11796
-#define obstack_base(\7f216,10145
-#define obstack_begin(\7f232,10606
-#define obstack_blank(\7f257,11569
-#define obstack_blank_fast(\7f277,12257
-#define obstack_copy(\7f266,11889
-#define obstack_copy0(\7f269,11994
-#define obstack_finish(\7f279,12314
-#define obstack_free(\7f290,12730
-#define obstack_grow(\7f237,10784
-#define obstack_grow0(\7f244,11064
-#define obstack_init(\7f230,10547
-#define obstack_next_free(\7f220,10254
-#define obstack_object_size(\7f224,10341
-#define obstack_room(\7f272,12101
-\f
-param.h,0
-\f
-symseg.h,0
-\f
-symtab.h,1291
-#define BLOCKLIST(\7f108,3923
-#define BLOCKLIST_BLOCK(\7f137,4911
-#define BLOCKLIST_NBLOCKS(\7f136,4853
-#define BLOCKVECTOR(\7f109,3971
-#define BLOCKVECTOR_BLOCK(\7f139,5030
-#define BLOCKVECTOR_NBLOCKS(\7f138,4970
-#define BLOCK_END(\7f145,5244
-#define BLOCK_FUNCTION(\7f148,5354
-#define BLOCK_NSYMS(\7f146,5280
-#define BLOCK_START(\7f144,5204
-#define BLOCK_SUPERBLOCK(\7f149,5396
-#define BLOCK_SYM(\7f147,5316
-#define LINELIST(\7f113,4071
-#define LINETABLE(\7f114,4116
-#define SYMBOL_BLOCK_VALUE(\7f155,5635
-#define SYMBOL_CLASS(\7f153,5539
-#define SYMBOL_NAME(\7f151,5443
-#define SYMBOL_NAMESPACE(\7f152,5486
-#define SYMBOL_TYPE(\7f156,5692
-#define SYMBOL_VALUE(\7f154,5584
-#define TYPEVECTOR(\7f111,4022
-#define TYPEVECTOR_NTYPES(\7f141,5092
-#define TYPEVECTOR_TYPE(\7f142,5147
-#define TYPE_CODE(\7f170,6307
-#define TYPE_FIELD(\7f174,6453
-#define TYPE_FIELDS(\7f172,6403
-#define TYPE_FIELD_BITPOS(\7f178,6712
-#define TYPE_FIELD_BITSIZE(\7f179,6780
-#define TYPE_FIELD_NAME(\7f176,6571
-#define TYPE_FIELD_PACKED(\7f180,6850
-#define TYPE_FIELD_TYPE(\7f175,6507
-#define TYPE_FIELD_VALUE(\7f177,6635
-#define TYPE_FLAGS(\7f168,6187
-#define TYPE_FUNCTION_TYPE(\7f166,6075
-#define TYPE_LENGTH(\7f167,6138
-#define TYPE_NAME(\7f163,5910
-#define TYPE_NFIELDS(\7f171,6352
-#define TYPE_POINTER_TYPE(\7f165,6014
-#define TYPE_TARGET_TYPE(\7f164,5955
-#define TYPE_UNSIGNED(\7f169,6234
-\f
-value.h,399
-#define COERCE_ARRAY(\7f58,1961
-#define VALUE_ADDRESS(\7f48,1560
-#define VALUE_BITPOS(\7f52,1752
-#define VALUE_BITSIZE(\7f51,1710
-#define VALUE_CONTENTS(\7f46,1469
-#define VALUE_INTERNALVAR(\7f49,1611
-#define VALUE_LVAL(\7f47,1524
-#define VALUE_NEXT(\7f53,1792
-#define VALUE_OFFSET(\7f50,1670
-#define VALUE_REGNO(\7f56,1922
-#define VALUE_REPEATED(\7f54,1828
-#define VALUE_REPETITIONS(\7f55,1872
-#define VALUE_TYPE(\7f45,1433
-\f
-vax-opcode.h,0
-\f
-wait.h,331
-#define WCOREDUMP(\7f13,439
-#define WCOREDUMP(\7f21,690
-#define WIFEXITED(\7f10,338
-#define WIFSIGNALED(\7f9,274
-#define WIFSTOPPED(\7f8,231
-#define WRETCODE(\7f11,377
-#define WRETCODE(\7f19,622
-#define WSETSTOP(\7f15,511
-#define WSETSTOP(\7f23,760
-#define WSTOPSIG(\7f12,408
-#define WSTOPSIG(\7f20,656
-#define WTERMSIG(\7f14,478
-#define WTERMSIG(\7f22,726
-\f
-expread.y,349
-copy_name \7f929,20955
-end_arglist \7f516,11399
-free_funcalls \7f530,11701
-length_of_subexp \7f963,21859
-parse_c_1 \7f1142,25974
-parse_c_expression \7f1181,27028
-parse_number \7f608,13872
-prefixify_expression \7f943,21291
-prefixify_subexp \7f1035,23196
-start_arglist \7f502,11040
-write_exp_elt \7f547,12040
-write_exp_string \7f564,12494
-yyerror \7f920,20800
-yylex \7f706,15915
+++ /dev/null
-/*
- alloca -- (mostly) portable public-domain implementation -- D A Gwyn
-
- last edit: 86/05/30 rms
- include config.h, since on VMS it renames some symbols.
- Use xmalloc instead of malloc.
-
- This implementation of the PWB library alloca() function,
- which is used to allocate space off the run-time stack so
- that it is automatically reclaimed upon procedure exit,
- was inspired by discussions with J. Q. Johnson of Cornell.
-
- It should work under any C implementation that uses an
- actual procedure stack (as opposed to a linked list of
- frames). There are some preprocessor constants that can
- be defined when compiling for your specific system, for
- improved efficiency; however, the defaults should be okay.
-
- The general concept of this implementation is to keep
- track of all alloca()-allocated blocks, and reclaim any
- that are found to be deeper in the stack than the current
- invocation. This heuristic does not reclaim storage as
- soon as it becomes invalid, but it will do so eventually.
-
- As a special case, alloca(0) reclaims storage without
- allocating any. It is a good idea to use alloca(0) in
- your main control loop, etc. to force garbage collection.
-*/
-#ifndef lint
-static char SCCSid[] = "@(#)alloca.c 1.1"; /* for the "what" utility */
-#endif
-
-#ifdef emacs
-#include "config.h"
-#ifdef static
-/* actually, only want this if static is defined as ""
- -- this is for usg, in which emacs must undefine static
- in order to make unexec workable
- */
-#ifndef STACK_DIRECTION
-you
-lose
--- must know STACK_DIRECTION at compile-time
-#endif /* STACK_DIRECTION undefined */
-#endif static
-#endif emacs
-
-#ifdef X3J11
-typedef void *pointer; /* generic pointer type */
-#else
-typedef char *pointer; /* generic pointer type */
-#endif
-
-#define NULL 0 /* null pointer constant */
-
-extern void free();
-extern pointer xmalloc();
-
-/*
- Define STACK_DIRECTION if you know the direction of stack
- growth for your system; otherwise it will be automatically
- deduced at run-time.
-
- STACK_DIRECTION > 0 => grows toward higher addresses
- STACK_DIRECTION < 0 => grows toward lower addresses
- STACK_DIRECTION = 0 => direction of growth unknown
-*/
-
-#ifndef STACK_DIRECTION
-#define STACK_DIRECTION 0 /* direction unknown */
-#endif
-
-#if STACK_DIRECTION != 0
-
-#define STACK_DIR STACK_DIRECTION /* known at compile-time */
-
-#else /* STACK_DIRECTION == 0; need run-time code */
-
-static int stack_dir; /* 1 or -1 once known */
-#define STACK_DIR stack_dir
-
-static void
-find_stack_direction (/* void */)
-{
- static char *addr = NULL; /* address of first
- `dummy', once known */
- auto char dummy; /* to get stack address */
-
- if (addr == NULL)
- { /* initial entry */
- addr = &dummy;
-
- find_stack_direction (); /* recurse once */
- }
- else /* second entry */
- if (&dummy > addr)
- stack_dir = 1; /* stack grew upward */
- else
- stack_dir = -1; /* stack grew downward */
-}
-
-#endif /* STACK_DIRECTION == 0 */
-
-/*
- An "alloca header" is used to:
- (a) chain together all alloca()ed blocks;
- (b) keep track of stack depth.
-
- It is very important that sizeof(header) agree with malloc()
- alignment chunk size. The following default should work okay.
-*/
-
-#ifndef ALIGN_SIZE
-#define ALIGN_SIZE sizeof(double)
-#endif
-
-typedef union hdr
-{
- char align[ALIGN_SIZE]; /* to force sizeof(header) */
- struct
- {
- union hdr *next; /* for chaining headers */
- char *deep; /* for stack depth measure */
- } h;
-} header;
-
-/*
- alloca( size ) returns a pointer to at least `size' bytes of
- storage which will be automatically reclaimed upon exit from
- the procedure that called alloca(). Originally, this space
- was supposed to be taken from the current stack frame of the
- caller, but that method cannot be made to work for some
- implementations of C, for example under Gould's UTX/32.
-*/
-
-static header *last_alloca_header = NULL; /* -> last alloca header */
-
-pointer
-alloca (size) /* returns pointer to storage */
- unsigned size; /* # bytes to allocate */
-{
- auto char probe; /* probes stack depth: */
- register char *depth = &probe;
-
-#if STACK_DIRECTION == 0
- if (STACK_DIR == 0) /* unknown growth direction */
- find_stack_direction ();
-#endif
-
- /* Reclaim garbage, defined as all alloca()ed storage that
- was allocated from deeper in the stack than currently. */
-
- {
- register header *hp; /* traverses linked list */
-
- for (hp = last_alloca_header; hp != NULL;)
- if (STACK_DIR > 0 && hp->h.deep > depth
- || STACK_DIR < 0 && hp->h.deep < depth)
- {
- register header *np = hp->h.next;
-
- free ((pointer) hp); /* collect garbage */
-
- hp = np; /* -> next header */
- }
- else
- break; /* rest are not deeper */
-
- last_alloca_header = hp; /* -> last valid storage */
- }
-
- if (size == 0)
- return NULL; /* no allocation required */
-
- /* Allocate combined header + user data storage. */
-
- {
- register pointer new = xmalloc (sizeof (header) + size);
- /* address of header */
-
- ((header *)new)->h.next = last_alloca_header;
- ((header *)new)->h.deep = depth;
-
- last_alloca_header = (header *)new;
-
- /* User storage begins just after header. */
-
- return (pointer)((char *)new + sizeof(header));
- }
-}
-
+++ /dev/null
-main() {
- int i;
-
- for (i = 0; i >= 0; i++)
- bar();
-}
-
-bar()
-{
- int i;
-
- i = 10;
-}
+++ /dev/null
-0000003e - 00 0002 RBRAC
-000020de - 00 000d SLINE
-000020d6 - 00 000c SLINE
-000020c8 - 00 0009 SLINE
-000020c4 - 00 0006 SLINE
-00000024 - 00 0002 RBRAC
-000020be - 00 0004 SLINE
-000020b8 - 00 0005 SLINE
-000020ae - 00 0004 SLINE
-0000000e - 00 0002 LBRAC
-000020d6 - 00 0009 SLINE
-000020e4 - 00 ffff SLINE
-000020ae - 00 0001 SLINE
-000020a0 - 00 0001 SLINE
-00000036 - 00 0002 LBRAC
-000020e4 t -lg
-00000000 - 00 0000 LSYM ???:t(0,12)=(0,1)
-00002098 t Fcrt1.o
-0002001c D _Fmode
-00020020 D _Fstatus
-0000215c T __cleanup
-00002164 T __exit
-00020052 D __exit_nhandlers
-00020056 D __exit_tnames
-00020018 D __skybase
-000020c8 T _bar
-00020000 D _environ
-00020118 D _errno
-00002110 T _exit
-00002164 t _exit.o
-000020e4 T _finitfp_
-00020010 D _fp_state_mc68881
-0002000c D _fp_state_skyffp
-00020008 D _fp_state_software
-00020014 D _fp_state_sunfpa
-00020004 D _fp_switch
-000020a0 T _main
-000020a0 - 00 0000 SO bar.c
-000020a0 t bar.o
-000020c8 - 00 0004 FUN bar:F(0,1)
-0000216c T cerror
-0000216c t cerror.o
-00000000 - 00 0000 LSYM char:t(0,2)=r(0,2);0;127;
-00002020 t crt0.o
-00000000 - 00 0000 LSYM double:t(0,10)=r(0,1);8;0;
-00002110 t exit.o
-0000215c t fakcu.o
-000020e4 t finitfp.o
-00000000 - 00 0000 LSYM float:t(0,9)=r(0,1);4;0;
-00002110 t fp_globals.o
-00002098 T fsoft_used
-fffffffc - 00 0004 LSYM i:(0,1)
-fffffffc - 00 0004 LSYM i:(0,1)
-00000000 - 00 0000 LSYM int:t(0,1)=r(0,1);-2147483648;2147483647;
-000020e4 - 00 0000 SO libg.s
-00000000 - 00 0000 LSYM long:t(0,3)=r(0,1);-2147483648;2147483647;
-000020a0 - 00 0004 FUN main:F(0,1)
-00000000 - 00 0000 LSYM short:t(0,4)=r(0,1);-32768;32767;
-00002020 T start
-00002098 T start_float
-00000000 - 00 0000 LSYM unsigned char:t(0,5)=r(0,1);0;255;
-00000000 - 00 0000 LSYM unsigned int:t(0,8)=r(0,1);0;-1;
-00000000 - 00 0000 LSYM unsigned long:t(0,7)=r(0,1);0;-1;
-00000000 - 00 0000 LSYM unsigned short:t(0,6)=r(0,1);0;65535;
-00000000 - 00 0000 LSYM void:t(0,11)=(0,11)
+++ /dev/null
- .stabs "bar.c",0144,0,0,LL0
-LL0:
- .data
- .stabs "int:t(0,1)=r(0,1);-2147483648;2147483647;",0x80,0,0,0
- .stabs "char:t(0,2)=r(0,2);0;127;",0x80,0,0,0
- .stabs "long:t(0,3)=r(0,1);-2147483648;2147483647;",0x80,0,0,0
- .stabs "short:t(0,4)=r(0,1);-32768;32767;",0x80,0,0,0
- .stabs "unsigned char:t(0,5)=r(0,1);0;255;",0x80,0,0,0
- .stabs "unsigned short:t(0,6)=r(0,1);0;65535;",0x80,0,0,0
- .stabs "unsigned long:t(0,7)=r(0,1);0;-1;",0x80,0,0,0
- .stabs "unsigned int:t(0,8)=r(0,1);0;-1;",0x80,0,0,0
- .stabs "float:t(0,9)=r(0,1);4;0;",0x80,0,0,0
- .stabs "double:t(0,10)=r(0,1);8;0;",0x80,0,0,0
- .stabs "void:t(0,11)=(0,11)",0x80,0,0,0
- .stabs "???:t(0,12)=(0,1)",0x80,0,0,0
- .stabs "main:F(0,1)",0x24,0,4,_main
- .text
- .stabn 0104,0,1,LL1
-LL1:
-|#PROC# 04
- .globl _main
-_main:
-|#PROLOGUE# 0
- link a6,#0
- addl #-LF12,sp
- moveml #LS12,sp@
-|#PROLOGUE# 1
- .stabn 0104,0,1,LL2
-LL2:
- .stabs "i:(0,1)",0x80,0,4,-4
- .stabn 0300,0,2,LL3
-LL3:
- .stabn 0104,0,4,LL4
-LL4:
- clrl a6@(-0x4)
-L16:
- tstl a6@(-0x4)
- jlt L15
- .stabn 0104,0,5,LL5
-LL5:
- jbsr _bar
-L14:
- .stabn 0104,0,4,LL6
-LL6:
- addql #0x1,a6@(-0x4)
- jra L16
-L15:
- .stabn 0340,0,2,LL7
-LL7:
- .stabn 0104,0,6,LL8
-LL8:
-LE12:
- unlk a6
- rts
- LF12 = 4
- LS12 = 0x0
- LFF12 = 4
- LSS12 = 0x0
- LP12 = 0x8
- .data
- .stabs "bar:F(0,1)",0x24,0,4,_bar
- .text
- .stabn 0104,0,9,LL9
-LL9:
-|#PROC# 04
- .globl _bar
-_bar:
-|#PROLOGUE# 0
- link a6,#0
- addl #-LF18,sp
- moveml #LS18,sp@
-|#PROLOGUE# 1
- .stabn 0104,0,9,LL10
-LL10:
- .stabs "i:(0,1)",0x80,0,4,-4
- .stabn 0300,0,2,LL11
-LL11:
- .stabn 0104,0,12,LL12
-LL12:
- movl #0xa,a6@(-0x4)
- .stabn 0340,0,2,LL13
-LL13:
- .stabn 0104,0,13,LL14
-LL14:
-LE18:
- unlk a6
- rts
- LF18 = 4
- LS18 = 0x0
- LFF18 = 4
- LSS18 = 0x0
- LP18 = 0x8
- .data
+++ /dev/null
-Symtab for file libg.s
-
-Line table:
-
- line 2 at 20e4
-
-Blockvector:
-
-block #000 (object 0x56f90) [0x20e4..0x20e4]
- block #001 (object 0x56f7c) [0x20e4..0x20e4] (under 0x56f90)
-
-
-Symtab for file bar.c
-
-Line table:
-
- line 1 at 20a0
- line 1 at 20ae
- line 4 at 20ae
- line 5 at 20b8
- line 4 at 20be
- line 6 at 20c4
- line 9 at 20c8
- line 9 at 20d6
- line 12 at 20d6
- line 13 at 20de
-
-Blockvector:
-
-block #000 (object 0x56f4c) [0x20a0..0x20e4]
- int bar; block (object 0x56ef0) starting at 0x20c8,
- int main; block (object 0x56ea8) starting at 0x20a0,
- block #001 (object 0x56f08) [0x20a0..0x20e4] (under 0x56f4c)
- typedef int ???;
- typedef char char;
- typedef double double;
- typedef float float;
- typedef int int;
- typedef int long;
- typedef short short;
- typedef unsigned char unsigned char;
- typedef unsigned int unsigned int;
- typedef unsigned int unsigned long;
- typedef unsigned short unsigned short;
- typedef void void;
- block #002 (object 0x56ea8) [0x20a0..0x20c8] (under 0x56f08) main
- int i; local at 0xfffffffc,
- block #003 (object 0x56ef0) [0x20c8..0x20e4] (under 0x56f08) bar
- int i; local at 0xfffffffc,
-
-
/* Get info from stack frames;
convert between frames, blocks, functions and pc values.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
int
find_pc_misc_function (pc)
- CORE_ADDR pc;
+ register CORE_ADDR pc;
{
- register int i;
+ register int lo = 0;
+ register int hi = misc_function_count-1;
+ register int new;
+ register int distance;
/* Note that the last thing in the vector is always _etext. */
- for (i = 0; i < misc_function_count; i++)
- {
- if (pc < misc_function_vector[i].address)
- return i - 1;
- }
- return -1;
+
+ /* trivial reject range test */
+ if (pc < misc_function_vector[0].address ||
+ pc > misc_function_vector[hi].address)
+ return -1;
+
+ do {
+ new = (lo + hi) >> 1;
+ distance = misc_function_vector[new].address - pc;
+ if (distance == 0)
+ return new; /* an exact match */
+ else if (distance > 0)
+ hi = new;
+ else
+ lo = new;
+ } while (hi-lo != 1);
+
+ /* if here, we had no exact match, so return the lower choice */
+ return lo;
}
/* Return the innermost stack frame executing inside of the specified block,
while (*p == ' ' || *p == '\t') p++;
arg = p;
- b->cond = (struct expression *) parse_c_1 (&arg, block_for_pc (b->address));
+ b->cond = (struct expression *) parse_c_1 (&arg, block_for_pc (b->address), 0);
+ if (*arg)
+ error ("Junk at end of expression");
}
return;
}
}
\f
/* Set a breakpoint according to ARG (function, linenum or *address)
- and make it temporary if TEMPFLAG is nonzero. */
+ and make it temporary if TEMPFLAG is nonzero.
+
+ LINE_NUM is for C++. */
static void
-break_command_1 (arg, tempflag, from_tty)
+break_command_1 (arg, tempflag, from_tty, line_num)
char *arg;
- int tempflag, from_tty;
+ int tempflag, from_tty, line_num;
{
+ struct symtabs_and_lines sals;
struct symtab_and_line sal;
register struct expression *cond = 0;
register struct breakpoint *b;
+ char *save_arg;
+ int i;
+
+ sals.sals = NULL;
+ sals.nelts = 0;
- sal.pc = 0;
+ sal.line = sal.pc = sal.end = 0;
+ sal.symtab = 0;
if (arg)
{
- sal = decode_line_1 (&arg, 1, 0, 0);
+ CORE_ADDR pc;
+ sals = decode_line_1 (&arg, 1, 0, 0);
- if (sal.pc == 0 && sal.symtab != 0)
+ if (! sals.nelts) return;
+ save_arg = arg;
+ for (i = 0; i < sals.nelts; i++)
{
- sal.pc = find_line_pc (sal.symtab, sal.line);
- if (sal.pc == 0)
- error ("No line %d in file \"%s\".",
- sal.line, sal.symtab->filename);
- }
+ sal = sals.sals[i];
+ if (sal.pc == 0 && sal.symtab != 0)
+ {
+ pc = find_line_pc (sal.symtab, sal.line);
+ if (pc == 0)
+ error ("No line %d in file \"%s\".",
+ sal.line, sal.symtab->filename);
+ }
+ else pc = sal.pc;
- while (*arg)
- {
- if (arg[0] == 'i' && arg[1] == 'f'
- && (arg[2] == ' ' || arg[2] == '\t'))
- cond = (struct expression *) parse_c_1 ((arg += 2, &arg),
- block_for_pc (sal.pc));
- else
- error ("Junk at end of arguments.");
+ while (*arg)
+ {
+ if (arg[0] == 'i' && arg[1] == 'f'
+ && (arg[2] == ' ' || arg[2] == '\t'))
+ cond = (struct expression *) parse_c_1 ((arg += 2, &arg),
+ block_for_pc (pc), 0);
+ else
+ error ("Junk at end of arguments.");
+ }
+ arg = save_arg;
+ sals.sals[i].pc = pc;
}
}
else if (default_breakpoint_valid)
{
+ sals.sals = (struct symtab_and_line *) malloc (sizeof (struct symtab_and_line));
sal.pc = default_breakpoint_address;
sal.line = default_breakpoint_line;
sal.symtab = default_breakpoint_symtab;
+ sals.sals[0] = sal;
+ sals.nelts = 1;
}
else
error ("No default breakpoint address now.");
- if (from_tty)
- describe_other_breakpoints (sal.pc);
+ for (i = 0; i < sals.nelts; i++)
+ {
+ sal = sals.sals[i];
+ sal.line += line_num; /** C++ **/
+ if (line_num != 0)
+ { /* get the pc for a particular line */
+ sal.pc = find_line_pc (sal.symtab, sal.line);
+ }
- b = set_raw_breakpoint (sal);
- b->number = ++breakpoint_count;
- b->cond = cond;
- if (tempflag)
- b->enable = temporary;
-
- printf ("Breakpoint %d at 0x%x", b->number, b->address);
- if (b->symtab)
- printf (": file %s, line %d.", b->symtab->filename, b->line_number);
- printf ("\n");
+ if (from_tty)
+ describe_other_breakpoints (sal.pc);
+
+ b = set_raw_breakpoint (sal);
+ b->number = ++breakpoint_count;
+ b->cond = cond;
+ if (tempflag)
+ b->enable = temporary;
+
+ printf ("Breakpoint %d at 0x%x", b->number, b->address);
+ if (b->symtab)
+ printf (": file %s, line %d.", b->symtab->filename, b->line_number);
+ printf ("\n");
+ }
+ free (sals.sals);
}
static void
char *arg;
int from_tty;
{
- break_command_1 (arg, 0, from_tty);
+ break_command_1 (arg, 0, from_tty, 0);
}
static void
char *arg;
int from_tty;
{
- break_command_1 (arg, 1, from_tty);
+ break_command_1 (arg, 1, from_tty, 0);
}
\f
static void
int from_tty;
{
register struct breakpoint *b, *b1;
+ struct symtabs_and_lines sals;
struct symtab_and_line sal;
register struct breakpoint *found;
+ int i;
if (arg)
- sal = decode_line_spec (arg, 1);
+ {
+ sals = decode_line_spec (arg, 1);
+ }
else
{
+ sals.sals = (struct symtab_and_line *) malloc (sizeof (struct symtab_and_line));
sal.line = default_breakpoint_line;
sal.symtab = default_breakpoint_symtab;
sal.pc = 0;
if (sal.symtab == 0)
error ("No source file specified.");
- }
- /* If exact pc given, clear bpts at that pc.
- But if sal.pc is zero, clear all bpts on specified line. */
+ sals.sals[0] = sal;
+ sals.nelts = 1;
+ }
- found = (struct breakpoint *) 0;
- while (breakpoint_chain
- && (sal.pc ? breakpoint_chain->address == sal.pc
- : (breakpoint_chain->symtab == sal.symtab
- && breakpoint_chain->line_number == sal.line)))
+ for (i = 0; i < sals.nelts; i++)
{
- b1 = breakpoint_chain;
- breakpoint_chain = b1->next;
- b1->next = found;
- found = b1;
- }
+ /* If exact pc given, clear bpts at that pc.
+ But if sal.pc is zero, clear all bpts on specified line. */
+ sal = sals.sals[i];
+ found = (struct breakpoint *) 0;
+ while (breakpoint_chain
+ && (sal.pc ? breakpoint_chain->address == sal.pc
+ : (breakpoint_chain->symtab == sal.symtab
+ && breakpoint_chain->line_number == sal.line)))
+ {
+ b1 = breakpoint_chain;
+ breakpoint_chain = b1->next;
+ b1->next = found;
+ found = b1;
+ }
- ALL_BREAKPOINTS (b)
- while (b->next
- && (sal.pc ? b->next->address == sal.pc
- : (b->next->symtab == sal.symtab
- && b->next->line_number == sal.line)))
- {
- b1 = b->next;
- b->next = b1->next;
- b1->next = found;
- found = b1;
- }
+ ALL_BREAKPOINTS (b)
+ while (b->next
+ && (sal.pc ? b->next->address == sal.pc
+ : (b->next->symtab == sal.symtab
+ && b->next->line_number == sal.line)))
+ {
+ b1 = b->next;
+ b->next = b1->next;
+ b1->next = found;
+ found = b1;
+ }
- if (found == 0)
- error ("No breakpoint at %s.", arg);
+ if (found == 0)
+ error ("No breakpoint at %s.", arg);
- if (found->next) from_tty = 1; /* Alwats report if deleted more than one */
- if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
- while (found)
- {
- if (from_tty) printf ("%d ", found->number);
- b1 = found->next;
- delete_breakpoint (found);
- found = b1;
+ if (found->next) from_tty = 1; /* Always report if deleted more than one */
+ if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
+ while (found)
+ {
+ if (from_tty) printf ("%d ", found->number);
+ b1 = found->next;
+ delete_breakpoint (found);
+ found = b1;
+ }
+ if (from_tty) putchar ('\n');
}
- if (from_tty) putchar ('\n');
+ free (sals.sals);
}
/* Delete breakpoint number BNUM if it is a `delete' breakpoint.
#include <a.out.h>
#include <stdio.h>
#include <obstack.h>
-#include <sys/types.h>
#include <sys/param.h>
#include <sys/file.h>
/* File name symbols were loaded from. */
static char *symfile;
-
-int debug = 1;
-
\f
/* Look up a coff type-number index. Return the address of the slot
where the type for that index is stored.
static AUXENT main_aux;
int num_object_files = 0;
- int next_file_symnum = 0;
+ int next_file_symnum;
char *filestring;
int depth;
int fcn_first_line;
{
read_one_sym (cs, &main_sym, &main_aux);
- /*
- * If we are finished with the previous file's symbols, and the
- * next thing is not a C_FILE, then we have hit the global symbols.
- */
if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
{
CORE_ADDR last_file_end = cur_src_end_addr;
/* done with all files, everything from here on out is globals */
}
+ /* Special case for file with type declarations only, no text. */
+ if (!last_source_file && cs->c_type != T_NULL && cs->c_secnum == N_DEBUG)
+ complete_symtab (filestring, 0, 0);
+
if (ISFCN (cs->c_type))
{
/*
end_symtab ();
start_symtab ();
}
- complete_symtab (filestring, 0, 0); /* FIXME, 0 0 is wrong */
num_object_files++;
break;
case C_STAT:
if (cs->c_type == T_NULL && cs->c_secnum > N_UNDEF)
{
- /* These ".text", ".data", ".bss" entries don't seem to
- * appear in A/UX COFF output. -- gnu@toad.com 4Apr88
- */
if (strcmp (cs->c_name, _TEXT) == 0)
{
- /* We have a ".text" symbol */
if (num_object_files == 1)
{
/* Record end address of first file, crt0.s */
if (myread (chan, (char *)file_hdr, FILHSZ) < 0)
return -1;
- if (BADMAG(file_hdr))
- return -1; /* Non understood file */
- return file_hdr->f_nsyms; /* OK magic number, return # syms */
+ switch (file_hdr->f_magic)
+ {
+ case NS32GMAGIC:
+ case NS32SMAGIC:
+ return file_hdr->f_nsyms;
+
+ default:
+ return -1;
+ }
}
read_aout_hdr (chan, aout_hdr, size)
cs->c_secnum = sym->n_scnum;
cs->c_type = (unsigned) sym->n_type;
-#ifdef DEBUG
- if (debug) {
- fprintf(stderr, "sym %3x: %2x %s %x %x %x", cs->c_symnum,
- cs->c_sclass, cs->c_name, cs->c_value, cs->c_secnum, cs->c_type);
- if (cs->c_nsyms > 1)
- fprintf(stderr, " +aux %s\n", (char *)aux);
- else
- fprintf(stderr, "\n");
- }
-#endif
-
symnum += cs->c_nsyms;
}
\f
return -1;
val = myread (chan, (char *)&buffer, sizeof buffer);
-
- /* If no string table, we get 0 bytes back from the read. That's OK. */
- if (val == 0) {
- free_stringtab();
- return 0;
- }
-
if (val != sizeof buffer)
return -1;
if (symbol_entry->n_zeroes == 0)
{
- if (!stringtab)
- error("Symbol entry references nonexistent string table");
result = stringtab + symbol_entry->n_offset;
}
else
char *result;
extern char *rindex ();
-#ifndef mac_aux
if (aux_entry->x_file.x_foff != 0)
strcpy (buffer, stringtab + aux_entry->x_file.x_foff);
else
-#endif
{
strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
buffer[FILNMLEN] = '\0';
switch (c_type)
{
case T_NULL:
- /* NULL seems to be used as the basic type of void functions */
- return builtin_type_void;
+ /* shouldn't show up here */
break;
case T_ARG:
case T_ULONG:
return builtin_type_unsigned_long;
}
- printf ("unexpected type %d at symnum %d, name %s\n", c_type, cs->c_symnum,
- cs->c_name);
+ printf ("unexpected type %d at symnum %d\n", c_type, cs->c_symnum);
return builtin_type_void;
}
\f
that in whole or in part contains or is a derivative of this
program or any part thereof, to be licensed at no charge to all
third parties on terms identical to those contained in this
- License Agreement (except that you may choose to grant more
- extensive warranty protection to third parties, at your option).
+ License Agreement (except that you may choose to grant more extensive
+ warranty protection to some or all third parties, at your option).
c) You may charge a distribution fee for the physical act of
transferring a copy, and you may at your option offer warranty
protection in exchange for a fee.
- 3. You may copy and distribute this program or any portion of it in
-compiled, executable or object code form under the terms of Paragraphs
-1 and 2 above provided that you do the following:
-
- a) cause each such copy to be accompanied by the
- corresponding machine-readable source code, which must
- be distributed under the terms of Paragraphs 1 and 2 above; or,
-
- b) cause each such copy to be accompanied by a
- written offer, with no time limit, to give any third party
- free (except for a nominal shipping charge) a machine readable
- copy of the corresponding source code, to be distributed
- under the terms of Paragraphs 1 and 2 above; or,
-
- c) in the case of a recipient of this program in compiled, executable
- or object code form (without the corresponding source code) you
- shall cause copies you distribute to be accompanied by a copy
- of the written offer of source code which you received along
- with the copy you received.
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+ 3. You may copy and distribute this program (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the following:
+
+ a) accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ b) accompany it with a written offer, valid for at least three
+ years, to give any third party free (except for a nominal
+ shipping charge) a complete machine-readable copy of the
+ corresponding source code, to be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ c) accompany it with the information you received as to where the
+ corresponding source code may be obtained. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
4. You may not copy, sublicense, distribute or transfer this program
except as expressly provided under this License Agreement. Any attempt
that in whole or in part contains or is a derivative of this
program or any part thereof, to be licensed at no charge to all
third parties on terms identical to those contained in this
- License Agreement (except that you may choose to grant more
- extensive warranty protection to third parties, at your option).
+ License Agreement (except that you may choose to grant more extensive
+ warranty protection to some or all third parties, at your option).
c) You may charge a distribution fee for the physical act of
transferring a copy, and you may at your option offer warranty
protection in exchange for a fee.
- 3. You may copy and distribute this program or any portion of it in
-compiled, executable or object code form under the terms of Paragraphs
-1 and 2 above provided that you do the following:
-
- a) cause each such copy to be accompanied by the
- corresponding machine-readable source code, which must
- be distributed under the terms of Paragraphs 1 and 2 above; or,
-
- b) cause each such copy to be accompanied by a
- written offer, with no time limit, to give any third party
- free (except for a nominal shipping charge) a machine readable
- copy of the corresponding source code, to be distributed
- under the terms of Paragraphs 1 and 2 above; or,
-
- c) in the case of a recipient of this program in compiled, executable
- or object code form (without the corresponding source code) you
- shall cause copies you distribute to be accompanied by a copy
- of the written offer of source code which you received along
- with the copy you received.
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+ 3. You may copy and distribute this program (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the following:
+
+ a) accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ b) accompany it with a written offer, valid for at least three
+ years, to give any third party free (except for a nominal
+ shipping charge) a complete machine-readable copy of the
+ corresponding source code, to be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ c) accompany it with the information you received as to where the
+ corresponding source code may be obtained. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
4. You may not copy, sublicense, distribute or transfer this program
except as expressly provided under this License Agreement. Any attempt
#include <a.out.h>
#include <stdio.h>
-#include <sys/types.h>
+#include <signal.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <sys/file.h>
#ifdef UMAX_CORE
#include <sys/ptrace.h>
#else /* not UMAX_CORE */
-#ifdef mac_aux
-#include <sys/seg.h>
-#include <sys/mmu.h>
-#include <sys/signal.h>
-#include <sys/time.h>
#include <sys/user.h>
-#else
-#include <sys/user.h>
-#endif /* mac_aux */
-#endif /* UMAX_CORE */
+#endif
#endif /* NEW_SUN_CORE */
#ifndef N_TXTADDR
#define AOUTHDR struct exec
#endif
+extern char *sys_siglist[];
+
START_FILE
/* Hook for `exec_file_command' command to call. */
/* Virtual addresses of bounds of two areas of memory in the exec file.
Note that the data area in the exec file is used only when there is no core file. */
-static CORE_ADDR text_start;
-static CORE_ADDR text_end;
+CORE_ADDR text_start;
+CORE_ADDR text_end;
+
static CORE_ADDR exec_data_start;
static CORE_ADDR exec_data_end;
bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec));
printf ("Core file is from \"%s\".\n", corestr.c_cmdname);
+ if (corestr.c_signo > 0)
+ printf ("Program terminated with signal %d, %s.\n",
+ corestr.c_signo,
+ corestr.c_signo < NSIG
+ ? sys_siglist[corestr.c_signo]
+ : "(undocumented)");
}
#else /* not NEW_SUN_CORE */
/* 4.2-style (and perhaps also sysV-style) core dump file. */
reg_offset = 0;
bcopy (&u.pt_aouthdr, &core_aouthdr, sizeof (AOUTHDR));
-
+ printf ("Core file is from \"%s\".\n", u.pt_comm);
+ if (u.pt_signal > 0)
+ printf ("Program terminated with signal %d, %s.\n",
+ u.pt_signal,
+ u.pt_signal < NSIG
+ ? sys_siglist[u.pt_signal]
+ : "(undocumented)");
#else /* not UMAX_CORE */
-#ifdef mac_aux
- /* This may well not work for 0407 (nonshared text) a.out's */
- data_end = data_start + u.u_dsize << PAGESHIFT;
- stack_start = stack_end - u.u_ssize << PAGESHIFT;
- data_offset = USIZE;
- stack_offset = USIZE + u.u_dsize << PAGESHIFT;
- reg_offset = (int) &u.u_ar0[0] - (int) &u;
-
- core_aouthdr.a_magic = u.u_exdata.ux_mag;
-#else
data_end = data_start + NBPG * u.u_dsize;
stack_start = stack_end - NBPG * u.u_ssize;
data_offset = NBPG * UPAGES;
/* I don't know where to find this info.
So, for now, mark it as not available. */
core_aouthdr.a_magic = 0;
-#endif /* not mac_aux */
#endif /* not UMAX_CORE */
/* Read the register values out of the core file and store
corefile = savestring (filename, strlen (filename));
else
{
- char dirname[MAXPATHLEN];
-
- getwd (dirname);
- corefile = concat (dirname, "/", filename);
+ corefile = concat (current_directory, "/", filename);
}
set_current_frame (read_register (FP_REGNUM));
if (regno < 0 || regno >= NUM_REGS)
error ("Invalid register number %d.", regno);
-#ifdef mac_aux
-/* FIXME, we don't know where the regs are. Maybe the test command
- * that tests what parts of the upage are writeable will find 'em for us.
- */
-#define REGISTER_U_ADDR(addr, foo, bar) addr = 0;
-#endif
REGISTER_U_ADDR (addr, blockend, regno);
return addr;
/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
+ Hacked by Michael Tiemann (tiemann@mcc.com)
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
static void start_subfile ();
static int hashname ();
static void hash_symsegs ();
+
extern struct symtab *read_symsegs ();
+extern void free_all_symtabs ();
+
+/* C++ */
+static struct type **read_args ();
START_FILE
type = (struct type *) obstack_alloc (symbol_obstack,
sizeof (struct type));
bzero (type, sizeof (struct type));
+ TYPE_VPTR_FIELDNO (type) = -1;
*type_addr = type;
}
return type;
if (s->ldsymoff == symnum * sizeof (struct nlist))
break;
current_symseg = s;
+ if (s != 0)
+ return;
type_vector_length = 160;
type_vector = (struct typevector *) xmalloc (sizeof (struct typevector) + type_vector_length * sizeof (struct type *));
register struct linetable *lv;
struct subfile *nextsub;
+ if (current_symseg != 0)
+ {
+ last_source_file = 0;
+ current_symseg = 0;
+ return;
+ }
+
/* Finish the lexical context of the last function in the file. */
if (context_stack)
}
/* Finish defining all the blocks of this symtab. */
- if (current_symseg == 0)
- {
- finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
- finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
- blockvector = make_blockvector ();
- }
+ finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
+ finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
+ blockvector = make_blockvector ();
+
current_subfile->line_vector_index = line_vector_index;
/* Now create the symtab objects proper, one for each subfile. */
for (subfile = subfiles; subfile; subfile = nextsub)
{
symtab = (struct symtab *) xmalloc (sizeof (struct symtab));
+ symtab->free_ptr = 0;
+
/* Fill in its components. */
- if (current_symseg)
- {
- bcopy (current_symseg, symtab, sizeof (struct symtab));
- symtab->free_code = free_linetable;
- symtab->free_ptr = 0;
- }
- else
- {
- symtab->blockvector = blockvector;
- type_vector->length = type_vector_length;
- symtab->typevector = type_vector;
- symtab->free_code = free_linetable;
- if (subfile->next == 0)
- symtab->free_ptr = (char *) type_vector;
- }
+ symtab->blockvector = blockvector;
+ type_vector->length = type_vector_length;
+ symtab->typevector = type_vector;
+ symtab->free_code = free_linetable;
+ if (subfile->next == 0)
+ symtab->free_ptr = (char *) type_vector;
+
symtab->filename = subfile->name;
lv = subfile->line_vector;
lv->nitems = subfile->line_vector_index;
register int val;
extern void close ();
struct cleanup *old_chain;
+ struct symtab *symseg;
dont_repeat ();
return;
}
+ printf ("Reading symbol data from %s...", name);
+ fflush (stdout);
+
/* Now read the string table, all at once. */
val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
if (val < 0)
if (val < 0)
perror_with_name (name);
stringtab = (char *) alloca (buffer);
+ if (stringtab == NULL)
+ {
+ free_all_symtabs ();
+ printf("%s: symbol table too large for alloca: %d bytes.\n", name,
+ buffer);
+ fflush (stdout);
+ return;
+ }
bcopy (&buffer, stringtab, sizeof buffer);
val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
if (val < 0)
perror_with_name (name);
+ /* Throw away the old symbol table. */
+
+ free_all_symtabs ();
+
#ifdef READ_GDB_SYMSEGS
/* That puts us at the symsegs. Read them. */
symseg_chain = read_symsegs (desc, name);
hash_symsegs ();
+
+ /* Free the symtabs made by read_symsegs, but not their contents,
+ which have been copied into symtabs on symtab_list. */
+ for (symseg = symseg_chain; symseg; symseg = symseg->next)
+ {
+ int i;
+ struct sourcevector *sv = (struct sourcevector *) symseg->linetable;
+
+ for (i = 0; i < sv->length; i++)
+ {
+ int j;
+ struct source *source = sv->source[i];
+ struct symtab *sp1
+ = (struct symtab *) xmalloc (sizeof (struct symtab));
+
+ bcopy (symseg, sp1, sizeof (struct symtab));
+ sp1->filename = savestring (source->name, strlen (source->name));
+ sp1->linetable = &source->contents;
+ sp1->free_code = free_nothing;
+ sp1->free_ptr = (i == 0) ? (char *) symseg : 0;
+
+ sp1->next = symtab_list;
+ symtab_list = sp1;
+ }
+ }
#else
/* Where people are using the 4.2 ld program, must not check for
symsegs, because that ld puts randonm garbage at the end of
if (val < 0)
perror_with_name (name);
- printf ("Reading symbol data from %s...", name);
- fflush (stdout);
-
- /* Throw away the old symbol table. */
-
- free_all_symtabs ();
-
init_misc_functions ();
make_cleanup (discard_misc_bunches, 0);
init_header_files ();
register struct symbol *sym, *prev;
int hash;
int num_object_files = 0;
+ struct cleanup *old_chain;
#ifdef N_BINCL
subfile_stack = 0;
#endif
+ old_chain = make_cleanup (free_all_symtabs, 0);
nlist_stream_global = stream;
nlist_size_global = nlistlen;
stringtab_global = stringtab;
for (symnum = 0; symnum < nlistlen; symnum++)
{
+ QUIT; /* allow this to be interruptable */
fread (&buf, sizeof buf, 1, stream);
namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : "";
if (buf.n_type & N_STAB)
end_symtab (end_of_text_addr);
fclose (stream);
+ discard_cleanups (old_chain);
}
/* dbx allows the text of a symbol name to be continued into the
}
}
\f
+/************************ READ_ADDL_SYM() ***********************************/
+
+static void
+read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
+ int desc;
+ register char *stringtab;
+ register int nlistlen;
+ unsigned text_addr;
+ int text_size;
+{
+ FILE *stream = fdopen (desc, "r");
+ struct nlist buf;
+ register char *namestring;
+ register struct symbol *sym, *prev;
+ int hash;
+ int num_object_files = 0;
+
+#ifdef N_BINCL
+ subfile_stack = 0;
+#endif
+
+ nlist_stream_global = stream;
+ nlist_size_global = nlistlen;
+ stringtab_global = stringtab;
+ last_source_file = 0;
+ bzero (global_sym_chain, sizeof global_sym_chain);
+
+ for (symnum = 0; symnum < nlistlen; symnum++)
+ {
+ unsigned type;
+
+ fread (&buf, sizeof buf, 1, stream);
+
+ type = buf.n_type & N_TYPE;
+ if( (type == N_TEXT) || (type == N_DATA) || (type == N_BSS) )
+ {
+ buf.n_value += text_addr;
+ } /* Right?? ###### */
+
+
+ namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : "";
+ if (buf.n_type & N_STAB)
+ process_one_symbol (buf.n_type, buf.n_desc,
+ buf.n_value, namestring);
+ /* A static text symbol whose name ends in ".o"
+ can only mean the start of another object file.
+ So end the symtab of the source file we have been processing.
+ This is how we avoid counting the libraries as part
+ or the last source file.
+ Also this way we find end of first object file (crt0). */
+ else if (buf.n_type == N_TEXT
+ && !strcmp (namestring + strlen (namestring) - 2, ".o"))
+ {
+ if (num_object_files++ == 1)
+ first_object_file_end = buf.n_value;
+ if (last_source_file)
+ {
+ end_symtab (buf.n_value); /* All this not used##### */
+ }
+ }
+ else if (buf.n_type & N_EXT || buf.n_type == N_TEXT)
+ {
+ int used_up = 0;
+
+ /* Record the location of _etext. */
+ if (buf.n_type == (N_TEXT | N_EXT)
+ && !strcmp (namestring, "_etext"))
+ {
+ end_of_text_addr = buf.n_value;
+ }
+
+ /* Global symbol: see if we came across a dbx definition
+ for a corresponding symbol. If so, store the value.
+ Remove syms from the chain when their values are stored,
+ but search the whole chain, as there may be several syms
+ from different files with the same name. */
+ if (buf.n_type & N_EXT)
+ {
+ prev = 0;
+#ifdef NAMES_HAVE_UNDERSCORE
+ hash = hashname (namestring + 1);
+#else /* not NAMES_HAVE_UNDERSCORE */
+ hash = hashname (namestring);
+#endif /* not NAMES_HAVE_UNDERSCORE */
+ for (sym = global_sym_chain[hash];
+ sym;)
+ {
+ if (
+#ifdef NAMES_HAVE_UNDERSCORE
+ *namestring == '_'
+ && namestring[1] == SYMBOL_NAME (sym)[0]
+ &&
+ !strcmp (namestring + 2, SYMBOL_NAME (sym) + 1)
+#else /* NAMES_HAVE_UNDERSCORE */
+ namestring[0] == SYMBOL_NAME (sym)[0]
+ &&
+ !strcmp (namestring + 1, SYMBOL_NAME (sym) + 1)
+#endif /* NAMES_HAVE_UNDERSCORE */
+ )
+ {
+ if (prev)
+ SYMBOL_VALUE (prev) = SYMBOL_VALUE (sym);
+ else
+ global_sym_chain[hash]
+ = (struct symbol *) SYMBOL_VALUE (sym);
+ SYMBOL_VALUE (sym) = buf.n_value;
+ if (prev)
+ sym = (struct symbol *) SYMBOL_VALUE (prev);
+ else
+ sym = global_sym_chain[hash];
+
+ used_up = 1;
+ }
+ else
+ {
+ prev = sym;
+ sym = (struct symbol *) SYMBOL_VALUE (sym);
+ }
+ }
+ }
+
+ /* Defined global or text symbol: record as a misc function
+ if it didn't give its address to a debugger symbol above. */
+ if (buf.n_type <= (N_TYPE | N_EXT)
+ && buf.n_type != N_EXT
+ && ! used_up)
+ record_misc_function (namestring, buf.n_value);
+ }
+ }
+
+ if (last_source_file)
+ {
+ end_symtab (text_addr + text_size);
+ }
+
+ fclose (stream);
+}
+
+/***************************** CONDENSE_ADDL_MISC_BUNCHES *******************/
+
+static void
+condense_addl_misc_bunches ()
+{
+ register int i, j;
+ register struct misc_bunch *bunch;
+#ifdef NAMES_HAVE_UNDERSCORE
+ int offset = 1;
+#else
+ int offset = 0;
+#endif
+
+ misc_function_vector
+ = (struct misc_function *) xrealloc (misc_function_vector,
+ (misc_count + misc_function_count) * sizeof (struct misc_function));
+
+ j = misc_function_count;
+ bunch = misc_bunch;
+ while (bunch)
+ {
+ for (i = 0; i < misc_bunch_index; i++)
+ {
+ misc_function_vector[j] = bunch->contents[i];
+ misc_function_vector[j].name
+ = concat (misc_function_vector[j].name
+ + (misc_function_vector[j].name[0] == '_' ? offset : 0),
+ "", "");
+ j++;
+ }
+ bunch = bunch->next;
+ misc_bunch_index = MISC_BUNCH_SIZE;
+ }
+
+ misc_function_count += misc_count;
+
+ /* Sort the misc functions by address. */
+
+ qsort (misc_function_vector, misc_function_count,
+ sizeof (struct misc_function), compare_misc_functions);
+}
+\f
+/**************************** ADD_FILE_COMMAND() ****************************/
+/* This function allows the addition of incrementally linked object files.
+ Useful for debugging `sun_kick'. */
+
+void
+add_file_command (arg_string)
+ char* arg_string;
+{
+ register int desc;
+ struct exec hdr;
+ struct nlist *nlist;
+ char *stringtab;
+ long buffer;
+ register int val;
+ extern void close ();
+ struct cleanup *old_chain;
+ char* name;
+ unsigned text_addr;
+
+ for( ; *arg_string == ' '; arg_string++ );
+ name = arg_string;
+ for( ; *arg_string != ' ' ; arg_string++ );
+ *arg_string++ = (char) 0;
+ for( ; *arg_string == ' '; arg_string++ );
+ text_addr = (unsigned) atoi(arg_string);
+
+ printf("filename \"%s\", and text_addr = 0x%x\n", name, text_addr );
+
+ dont_repeat ();
+
+ if (name == 0)
+ {
+ if (symtab_list && !query ("Discard symbol table? ", 0))
+ error ("Not confirmed.");
+ free_all_symtabs ();
+ return;
+ }
+
+ /* if (symtab_list && !query ("Add new symbols from \"%s\"? ", name))
+ error ("Not confirmed.");
+ */
+ {
+ char *absolute_name;
+ desc = openp (getenv ("PATH"), 1, name, O_RDONLY, 0, &absolute_name);
+ if (desc < 0)
+ perror_with_name (name);
+ else
+ name = absolute_name;
+ }
+
+ old_chain = make_cleanup (close, desc);
+ make_cleanup (free_current_contents, &name);
+
+ val = myread (desc, &hdr, sizeof hdr);
+ if (val < 0)
+ perror_with_name (name);
+
+ if (N_BADMAG (hdr))
+ error ("File \"%s\" has a bad header.", name);
+
+ if (hdr.a_syms == 0)
+ {
+ printf ("%s does not have a symbol-table.\n", name);
+ fflush (stdout);
+ return;
+ }
+
+ /* Now read the string table, all at once. */
+ val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
+ if (val < 0)
+ perror_with_name (name);
+ val = myread (desc, &buffer, sizeof buffer);
+ if (val < 0)
+ perror_with_name (name);
+ stringtab = (char *) alloca (buffer);
+ bcopy (&buffer, stringtab, sizeof buffer);
+ val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
+ if (val < 0)
+ perror_with_name (name);
+
+ /* That puts us at the symsegs. Read them. ########## Also need other
+ changes if they exist. */
+
+
+ /* Position to read the symbol table. Do not read it all at once. */
+ val = lseek (desc, N_SYMOFF (hdr), 0);
+ if (val < 0)
+ perror_with_name (name);
+
+ printf ("Reading symbol data from %s...", name);
+ fflush (stdout);
+
+ init_misc_functions ();
+ make_cleanup (discard_misc_bunches, 0);
+ init_header_files ();
+ make_cleanup (free_header_files, 0);
+
+ read_addl_syms (desc, stringtab, hdr.a_syms / sizeof(struct nlist)
+ ,text_addr, hdr.a_text) ;
+
+ /* Sort symbols alphabetically within each block. */
+
+ sort_syms ();
+
+ /* Go over the all misc functions and install them in vector. */
+
+ condense_addl_misc_bunches ();
+
+ /* Don't allow char * to have a typename (else would get caddr_t.) */
+
+ TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
+
+ /* Make a default for file to list. */
+
+ select_source_symtab (symtab_list);
+
+ do_cleanups (old_chain);
+
+ /* Free the symtabs made by read_symsegs, but not their contents,
+ which have been copied into symtabs on symtab_list. */
+ while (symseg_chain)
+ {
+ register struct symtab *s = symseg_chain->next;
+ free (symseg_chain);
+ symseg_chain = s;
+ }
+
+ printf ("done.\n");
+ fflush (stdout);
+}
+\f
static struct symbol *
define_symbol (value, string, desc)
int value;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
&& (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
TYPE_NAME (SYMBOL_TYPE (sym)) = concat (SYMBOL_NAME (sym), "", "");
+ /* C++ vagaries: we may have a type which is derived from
+ a base type which did not have its name defined when the
+ derived class was output. We fill in the derived class's
+ base part member's name here in that case. */
+ else if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
+ || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
+ && TYPE_BASECLASS (SYMBOL_TYPE (sym))
+ && TYPE_FIELD_NAME (SYMBOL_TYPE (sym), 0) == 0)
+ TYPE_FIELD_NAME (SYMBOL_TYPE (sym), 0) = TYPE_NAME (TYPE_BASECLASS (SYMBOL_TYPE (sym)));
+
add_symbol_to_list (sym, &file_symbols);
break;
break;
}
/* Skip the name the cross-ref points to. */
+ /* Note: for C++, the cross reference may be to a base type which
+ has not yet been seen. In this case, we skip to the comma,
+ which will mark the end of the base class name. (The ':'
+ at the end of the base class name will be skipped as well.) */
*pp = (char *) index (*pp, ',');
/* Just allocate the type and leave it zero if nothing known */
return dbx_alloc_type (typenums);
smash_to_pointer_type (type, read_type (pp));
break;
+ case '@':
+ {
+ struct type *domain = read_type (pp);
+ char c;
+ struct type *ptrtype;
+
+ if (*(*pp)++ != ',')
+ error ("invalid member pointer data format, at symtab pos %d.",
+ symnum);
+
+ ptrtype = read_type (pp);
+ type = dbx_alloc_type (typenums);
+ smash_to_member_pointer_type (type, domain, ptrtype);
+ }
+ break;
+
+ case '&':
+ type = dbx_alloc_type (typenums);
+ smash_to_reference_type (type, read_type (pp));
+ break;
+
case 'f':
type = dbx_alloc_type (typenums);
smash_to_function_type (type, read_type (pp));
struct nextfield
{
struct nextfield *next;
+ int visibility;
struct field field;
};
+ struct next_fnfield
+ {
+ struct next_fnfield *next;
+ int visibility;
+ struct fn_field fn_field;
+ };
+
+ struct next_fnfieldlist
+ {
+ struct next_fnfieldlist *next;
+ struct fn_fieldlist fn_fieldlist;
+ };
+
register struct nextfield *list = 0;
struct nextfield *new;
int totalsize;
int nfields = 0;
register int n;
+ register struct next_fnfieldlist *mainlist = 0;
+ int nfn_fields = 0;
+ struct type *baseclass = NULL;
+ int read_possible_virtual_info = 0;
+
TYPE_CODE (type) = TYPE_CODE_STRUCT;
/* First comes the total size in bytes. */
TYPE_LENGTH (type) = read_number (pp, 0);
- /* Now come the fields, as NAME:TYPENUM,BITPOS,BITSIZE; for each one.
- At the end, we see a semicolon instead of a field. */
+ /* C++: Now, if the class is a derived class, then the next character
+ will be a '!', followed by the type of the base class. Allocate
+ pretend that that base class is a sub-structure of this one,
+ with its field name being the type name of the derived class. This
+ cannot cause a naming conflict, since field names cannot be
+ type names. This will magically recurse itself to gound terms
+ when all is read and done. */
+ if (**pp == '!')
+ {
+ *pp += 1;
+
+ switch (*(*pp)++)
+ {
+ case '0':
+ break;
+ case '1':
+ TYPE_VIA_PROTECTED (type) = 1;
+ break;
+ case '2':
+ TYPE_VIA_PUBLIC (type) = 1;
+ break;
+ default:
+ error ("Invalid symbol data: bad visibility format at symtab pos %d.",
+ symnum);
+ }
+
+ if (**pp == '\\') *pp = next_symbol_text ();
+ new = (struct nextfield *) alloca (sizeof (struct nextfield));
+ new->next = list;
+ list = new;
+
+ baseclass = read_type (pp);
+ list->field.type = baseclass;
+ list->field.name = TYPE_NAME (baseclass);
+ *pp += 1; /* skip ',' */
+ list->field.bitpos = 0;
+ list->field.bitsize = 0; /* this should be an unpacked field! */
+ nfields++;
+ }
+
+ /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
+ At the end, we see a semicolon instead of a field.
+
+ In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
+ a static field.
+
+ The `?' is a placeholder for one of '+' (public visibility),
+ '0' (protected visibility), and '-' (private visibility). */
while (**pp != ';')
{
+ int visibility;
+
/* Check for and handle cretinous dbx symbol name continuation! */
- if (**pp == '\\')
- *pp = next_symbol_text ();
+ if (**pp == '\\') *pp = next_symbol_text ();
/* Get space to record the next field's data. */
new = (struct nextfield *) alloca (sizeof (struct nextfield));
p = *pp;
while (*p != ':') p++;
list->field.name = savestring (*pp, p - *pp);
+
+ /* Check to see if we have hit the methods yet. */
+ if (p[1] == ':')
+ break;
+
*pp = p + 1;
+
+ /* This means we have a visibility for a field coming. */
+ if (**pp == '/')
+ {
+ switch (*++*pp)
+ {
+ case '0':
+ visibility = 0;
+ *pp += 1;
+ break;
+
+ case '1':
+ visibility = 1;
+ *pp += 1;
+ break;
+
+ case '2':
+ visibility = 2;
+ *pp += 1;
+ break;
+ }
+ }
+ /* else normal dbx-style format. */
+
list->field.type = read_type (pp);
- if (**pp != ',')
+ if (**pp == ':')
+ {
+ list->field.bitpos = (long)-1;
+ p = ++(*pp);
+ while (*p != ';') p++;
+ list->field.bitsize = (long) savestring (*pp, p - *pp);
+ *pp = p + 1;
+ nfields++;
+ continue;
+ }
+ else if (**pp != ',')
error ("Invalid symbol data: bad structure-type format at symtab pos %d.",
symnum);
(*pp)++; /* Skip the comma. */
nfields++;
}
- (*pp)++; /* Skip the terminating ';'. */
+ /* Now come the method fields, as NAME::methods
+ where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
+ At the end, we see a semicolon instead of a field.
+
+ For the case of overloaded operators, the format is
+ OPERATOR::*.methods, where OPERATOR is the string "operator",
+ `*' holds the place for an operator name (such as `+=')
+ and `.' marks the end of the operator name. */
+ if (p[1] == ':')
+ {
+ /* Now, read in the methods. To simplify matters, we
+ "unread" the name that has been read, so that we can
+ start from the top. */
+
+ p = *pp;
+
+ /* chill the list of fields: the last entry (at the head)
+ is a partially constructed entry which we now scrub. */
+ list = list->next;
+
+ /* For each list of method lists... */
+ do
+ {
+ int i;
+ struct next_fnfield *sublist = 0;
+ struct fn_field *fn_fields = 0;
+ int length = 0;
+ struct next_fnfieldlist *new_mainlist =
+ (struct next_fnfieldlist *)alloca (sizeof (struct next_fnfieldlist));
+
+ /* read in the name. */
+ while (*p != ':') p++;
+ if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && (*pp)[2] == '$')
+ {
+ static char opname[32] = "operator ";
+ char *o = opname + 9;
+
+ /* Skip past '::'. */
+ p += 2;
+ while (*p != '.')
+ *o++ = *p++;
+ new_mainlist->fn_fieldlist.name = savestring (opname, o - opname);
+ /* Skip past '.' */
+ *pp = p + 1;
+ }
+ else
+ {
+ i = 0;
+ new_mainlist->fn_fieldlist.name = savestring (*pp, p - *pp);
+ /* Skip past '::'. */
+ *pp = p + 2;
+ }
+
+ do
+ {
+ struct next_fnfield *new_sublist =
+ (struct next_fnfield *)alloca (sizeof (struct next_fnfield));
+
+ /* Check for and handle cretinous dbx symbol name continuation! */
+ if (**pp == '\\') *pp = next_symbol_text ();
+
+ new_sublist->fn_field.type = read_type (pp);
+ new_sublist->fn_field.args = read_args (pp, ':');
+ p = *pp;
+ while (*p != ';') p++;
+ new_sublist->fn_field.physname = savestring (*pp, p - *pp);
+ *pp = p + 1;
+ new_sublist->visibility = *(*pp)++ - '0';
+ if (**pp == '\\') *pp = next_symbol_text ();
+
+ if (*(*pp)++ == '*')
+ new_sublist->fn_field.voffset = read_number (pp, ';') + 1;
+ else
+ new_sublist->fn_field.voffset = 0;
+
+ new_sublist->next = sublist;
+ sublist = new_sublist;
+ length++;
+ }
+ while (**pp != ';');
+
+ *pp += 1;
+
+ new_mainlist->fn_fieldlist.fn_fields =
+ (struct fn_field *) obstack_alloc (symbol_obstack,
+ sizeof (struct fn_field) * length);
+ TYPE_FN_PRIVATE_BITS (new_mainlist->fn_fieldlist) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (length >> 5)));
+
+ TYPE_FN_PROTECTED_BITS (new_mainlist->fn_fieldlist) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (length >> 5)));
+
+ for (i = length; sublist; sublist = sublist->next)
+ {
+ new_mainlist->fn_fieldlist.fn_fields[--i] = sublist->fn_field;
+ if (sublist->visibility == 0)
+ B_SET (new_mainlist->fn_fieldlist.private_fn_field_bits, i);
+ else if (sublist->visibility == 1)
+ B_SET (new_mainlist->fn_fieldlist.protected_fn_field_bits, i);
+ }
+
+ new_mainlist->fn_fieldlist.length = length;
+ new_mainlist->next = mainlist;
+ mainlist = new_mainlist;
+ nfn_fields++;
+ }
+ while (**pp != ';');
+
+ *pp += 2;
+
+ if (**pp == '~')
+ {
+ read_possible_virtual_info = 1;
+ *pp += 1;
+ }
+ if (**pp == '-')
+ {
+ TYPE_HAS_DESTRUCTOR (type) = 1;
+ TYPE_HAS_CONSTRUCTOR (type) = 1;
+ *pp += 1;
+ }
+ else if (**pp == '+')
+ {
+ TYPE_HAS_CONSTRUCTOR (type) = 1;
+ *pp += 1;
+ }
+ }
+ else *pp += 1;
/* Now create the vector of fields, and record how big it is. */
TYPE_NFIELDS (type) = nfields;
TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack,
sizeof (struct field) * nfields);
+ TYPE_FIELD_PRIVATE_BITS (type) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (nfields >> 5)));
+ TYPE_FIELD_PROTECTED_BITS (type) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (nfields >> 5)));
+
+ TYPE_NFN_FIELDS (type) = nfn_fields;
+ TYPE_NFN_FIELDS_TOTAL (type) = nfn_fields;
+ if (baseclass)
+ TYPE_NFN_FIELDS_TOTAL (type) += TYPE_NFN_FIELDS_TOTAL (baseclass);
+
+ TYPE_FN_FIELDLISTS (type) =
+ (struct fn_fieldlist *) obstack_alloc (symbol_obstack,
+ sizeof (struct fn_fieldlist) * nfn_fields);
/* Copy the saved-up fields into the field vector. */
for (n = nfields; list; list = list->next)
- TYPE_FIELD (type, --n) = list->field;
+ {
+ TYPE_FIELD (type, --n) = list->field;
+ if (list->visibility == 0)
+ SET_TYPE_FIELD_PRIVATE (type, n);
+ else if (list->visibility == 1)
+ SET_TYPE_FIELD_PROTECTED (type, n);
+ }
+
+ for (n = nfn_fields; mainlist; mainlist = mainlist->next)
+ TYPE_FN_FIELDLISTS (type)[--n] = mainlist->fn_fieldlist;
+
+ TYPE_BASECLASS (type) = baseclass;
+
+ if (read_possible_virtual_info)
+ {
+ /* Read either a '%' or the final ';'. */
+ if (*(*pp)++ == '%')
+ {
+ /* Now we must record the virtual function table pointer's
+ field information. */
+
+ struct type *t;
+ int i;
+
+ t = read_type (pp);
+ p = (*pp)++;
+ while (*p != ';') p++;
+ TYPE_VPTR_BASETYPE (type) = t;
+ if (type == t)
+ {
+ if (TYPE_FIELD_NAME (t, 0) == 0)
+ TYPE_VPTR_FIELDNO (type) = i = 0;
+ else for (i = TYPE_NFIELDS (t) - 1; i >= 0; --i)
+ if (! strncmp (TYPE_FIELD_NAME (t, i), *pp,
+ strlen (TYPE_FIELD_NAME (t, i))))
+ {
+ TYPE_VPTR_FIELDNO (type) = i;
+ break;
+ }
+ if (i < 0)
+ error ("virtual function table field not found");
+ }
+ else
+ TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type));
+ *pp = p;
+ }
+ else
+ {
+ TYPE_VPTR_BASETYPE (type) = 0;
+ TYPE_VPTR_FIELDNO (type) = -1;
+ }
+ }
+ else
+ {
+ TYPE_VPTR_BASETYPE (type) = 0;
+ TYPE_VPTR_FIELDNO (type) = -1;
+ }
return type;
}
while (**pp && **pp != ';')
{
/* Check for and handle cretinous dbx symbol name continuation! */
- if (**pp == '\\')
- *pp = next_symbol_text ();
+ if (**pp == '\\') *pp = next_symbol_text ();
p = *pp;
while (*p != ':') p++;
return n * sign;
}
+/* Read in an argument list. This is a list of types. It is terminated with
+ a ':', FYI. Return the list of types read in. */
+static struct type **
+read_args (pp, end)
+ char **pp;
+ int end;
+{
+ struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
+ int n = 0;
+
+ while (**pp != end)
+ {
+ if (**pp != ',')
+ error ("Invalid argument list: no ',', at symtab pos %d", symnum);
+ *pp += 1;
+ types[n++] = read_type (pp);
+ }
+ *pp += 1; /* get past `end' (the ':' character) */
+
+ if (n == 1)
+ {
+ rval = (struct type **) xmalloc (2 * sizeof (struct type *));
+ }
+ else
+ {
+ rval = (struct type **) xmalloc (n * sizeof (struct type *));
+ }
+ bcopy (types, rval, n * sizeof (struct type *));
+ return rval;
+}
+
+/* This function is really horrible, but to avoid it, there would need
+ to be more filling in of forward references. */
+int
+fill_in_vptr_fieldno (type)
+ struct type *type;
+{
+ if (TYPE_VPTR_FIELDNO (type) < 0)
+ TYPE_VPTR_FIELDNO (type) = fill_in_vptr_fieldno (TYPE_BASECLASS (type));
+ return TYPE_VPTR_FIELDNO (type);
+}
+
static
initialize ()
{
add_com ("symbol-file", class_files, symbol_file_command,
"Load symbol table (in dbx format) from executable file FILE.");
+
+ add_com ("add-file", class_files, add_file_command,
+ "Load the symbols from FILE, assuming its codes is at TEXT_START.") ;
}
END_FILE
};
struct command_line *read_command_lines ();
+
+/* String containing the current directory (what getwd would return). */
+
+char *current_directory;
that in whole or in part contains or is a derivative of this
program or any part thereof, to be licensed at no charge to all
third parties on terms identical to those contained in this
- License Agreement (except that you may choose to grant more
- extensive warranty protection to third parties, at your option).
+ License Agreement (except that you may choose to grant more extensive
+ warranty protection to some or all third parties, at your option).
c) You may charge a distribution fee for the physical act of
transferring a copy, and you may at your option offer warranty
protection in exchange for a fee.
- 3. You may copy and distribute this program or any portion of it in
-compiled, executable or object code form under the terms of Paragraphs
-1 and 2 above provided that you do the following:
-
- a) cause each such copy to be accompanied by the
- corresponding machine-readable source code, which must
- be distributed under the terms of Paragraphs 1 and 2 above; or,
-
- b) cause each such copy to be accompanied by a
- written offer, with no time limit, to give any third party
- free (except for a nominal shipping charge) a machine readable
- copy of the corresponding source code, to be distributed
- under the terms of Paragraphs 1 and 2 above; or,
-
- c) in the case of a recipient of this program in compiled, executable
- or object code form (without the corresponding source code) you
- shall cause copies you distribute to be accompanied by a copy
- of the written offer of source code which you received along
- with the copy you received.
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+ 3. You may copy and distribute this program (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the following:
+
+ a) accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ b) accompany it with a written offer, valid for at least three
+ years, to give any third party free (except for a nominal
+ shipping charge) a complete machine-readable copy of the
+ corresponding source code, to be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ c) accompany it with the information you received as to where the
+ corresponding source code may be obtained. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
4. You may not copy, sublicense, distribute or transfer this program
except as expressly provided under this License Agreement. Any attempt
parse_and_eval_address_1 (expptr)
char **expptr;
{
- struct expression *expr = parse_c_1 (expptr, 0);
+ struct expression *expr = parse_c_1 (expptr, 0, 0);
register CORE_ADDR addr;
register struct cleanup *old_chain
= make_cleanup (free_current_contents, &expr);
do_cleanups (old_chain);
return val;
}
+
+/* Parse up to a comma (or to a closeparen)
+ in the string EXPP as an expression, evaluate it, and return the value.
+ EXPP is advanced to point to the comma. */
+
+value
+parse_to_comma_and_eval (expp)
+ char **expp;
+{
+ struct expression *expr = parse_c_1 (expp, 0, 1);
+ register value val;
+ register struct cleanup *old_chain
+ = make_cleanup (free_current_contents, &expr);
+
+ val = evaluate_expression (expr);
+ do_cleanups (old_chain);
+ return val;
+}
\f
/* Evaluate an expression in internal prefix form
such as is constructed by expread.y.
{
enum exp_opcode op;
int tem;
- register int pc;
- register value arg1, arg2;
+ register int pc, pc2, *oldpos;
+ register value arg1, arg2, arg3;
int nargs;
value *argvec;
switch (op)
{
+ case OP_SCOPE:
+ tem = strlen (&exp->elts[pc + 2].string);
+ (*pos) += 3 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+ return value_static_field (exp->elts[pc + 1].type,
+ &exp->elts[pc + 2].string, -1);
+
case OP_LONG:
(*pos) += 3;
return value_from_long (exp->elts[pc + 1].type,
(*pos) += 2;
return value_of_internalvar (exp->elts[pc + 1].internalvar);
- case OP_FUNCALL:
- (*pos) += 2;
- nargs = exp->elts[pc + 1].longconst;
- argvec = (value *) alloca (sizeof (value) * (nargs + 1));
- for (tem = 0; tem <= nargs; tem++)
-
- /* Ensure that array expressions are coerced into pointer objects. */
- argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
-
- if (noside == EVAL_SKIP)
- goto nosideret;
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
- return call_function (argvec[0], nargs, argvec + 1);
-
case OP_STRING:
tem = strlen (&exp->elts[pc + 1].string);
(*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
return arg2;
}
+ case OP_FUNCALL:
+ (*pos) += 2;
+ op = exp->elts[*pos].opcode;
+ if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
+ {
+ int fnptr;
+ int tem2;
+
+ nargs = exp->elts[pc + 1].longconst + 1;
+ /* First, evaluate the structure into arg2 */
+ pc2 = (*pos)++;
+
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+
+ if (op == STRUCTOP_MEMBER)
+ {
+ arg2 = evaluate_subexp_for_address (exp, pos, noside);
+ }
+ else
+ {
+ arg2 = evaluate_subexp (exp, pos, noside);
+ }
+
+ /* If the function is a virtual function, then the
+ aggregate value (providing the structure) plays
+ its part by providing the vtable. Otherwise,
+ it is just along for the ride: call the function
+ directly. */
+
+ arg1 = evaluate_subexp (exp, pos, noside);
+
+ fnptr = value_as_long (arg1);
+ if (fnptr < 128)
+ {
+ struct type *basetype;
+ int i, j;
+ basetype = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
+ basetype = TYPE_VPTR_BASETYPE (basetype);
+ for (i = TYPE_NFN_FIELDS (basetype) - 1; i >= 0; i--)
+ {
+ struct fn_field *f = TYPE_FN_FIELDLIST1 (basetype, i);
+ /* If one is virtual, then all are virtual. */
+ if (TYPE_FN_FIELD_VIRTUAL_P (f, 0))
+ for (j = TYPE_FN_FIELDLIST_LENGTH (basetype, i) - 1; j >= 0; --j)
+ if (TYPE_FN_FIELD_VOFFSET (f, j) == fnptr)
+ {
+ value vtbl;
+ value base = value_ind (arg2);
+ struct type *fntype = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
+
+ if (TYPE_VPTR_FIELDNO (basetype) < 0)
+ TYPE_VPTR_FIELDNO (basetype)
+ = fill_in_vptr_fieldno (basetype);
+
+ VALUE_TYPE (base) = basetype;
+ vtbl = value_field (base, TYPE_VPTR_FIELDNO (basetype));
+ VALUE_TYPE (vtbl) = lookup_pointer_type (fntype);
+ VALUE_TYPE (arg1) = builtin_type_int;
+ arg1 = value_subscript (vtbl, arg1);
+ VALUE_TYPE (arg1) = fntype;
+ goto got_it;
+ }
+ }
+ if (i < 0)
+ error ("virtual function at index %d not found", fnptr);
+ }
+ else
+ {
+ VALUE_TYPE (arg1) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)));
+ }
+ got_it:
+
+ /* Now, say which argument to start evaluating from */
+ tem = 2;
+ }
+ else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
+ {
+ /* Hair for method invocations */
+ int tem2;
+
+ nargs = exp->elts[pc + 1].longconst + 1;
+ /* First, evaluate the structure into arg2 */
+ pc2 = (*pos)++;
+ tem2 = strlen (&exp->elts[pc2 + 1].string);
+ *pos += 2 + (tem2 + sizeof (union exp_element)) / sizeof (union exp_element);
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+
+ if (op == STRUCTOP_STRUCT)
+ {
+ arg2 = evaluate_subexp_for_address (exp, pos, noside);
+ }
+ else
+ {
+ arg2 = evaluate_subexp (exp, pos, noside);
+ }
+ /* Now, say which argument to start evaluating from */
+ tem = 2;
+ }
+ else
+ {
+ nargs = exp->elts[pc + 1].longconst;
+ tem = 0;
+ }
+ argvec = (value *) alloca (sizeof (value) * (nargs + 2));
+ for (; tem <= nargs; tem++)
+ /* Ensure that array expressions are coerced into pointer objects. */
+ argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+
+ /* signal end of arglist */
+ argvec[tem] = 0;
+
+ if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
+ {
+ argvec[1] = arg2;
+ argvec[0] =
+ value_struct_elt (arg2, argvec+1, &exp->elts[pc2 + 1].string,
+ op == STRUCTOP_STRUCT
+ ? "structure" : "structure pointer");
+ }
+ else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
+ {
+ argvec[1] = arg2;
+ argvec[0] = arg1;
+ }
+
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
+ return call_function (argvec[0], nargs, argvec + 1);
+
case STRUCTOP_STRUCT:
tem = strlen (&exp->elts[pc + 1].string);
(*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
arg1 = evaluate_subexp (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- return value_struct_elt (arg1, &exp->elts[pc + 1].string,
+ return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string,
"structure");
case STRUCTOP_PTR:
arg1 = evaluate_subexp (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- return value_struct_elt (arg1, &exp->elts[pc + 1].string,
+ return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string,
"structure pointer");
+ case STRUCTOP_MEMBER:
+ arg1 = evaluate_subexp_for_address (exp, pos, noside);
+ arg2 = evaluate_subexp (exp, pos, noside);
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+ /* Now, convert these values to an address.
+ @@ We do not know what type we are looking for,
+ @@ so we must assume that the value requested is a
+ @@ member address (as opposed to a member function address). */
+ arg3 = value_from_long (builtin_type_long,
+ value_as_long (arg1) + value_as_long (arg2));
+ VALUE_TYPE (arg3) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)));
+ return value_ind (arg3);
+
+ case STRUCTOP_MPTR:
+ arg1 = evaluate_subexp (exp, pos, noside);
+ arg2 = evaluate_subexp (exp, pos, noside);
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+ /* Now, convert these values to an address.
+ @@ We do not know what type we are looking for,
+ @@ so we must assume that the value requested is a
+ @@ member address (as opposed to a member function address). */
+ arg3 = value_from_long (builtin_type_long,
+ value_as_long (arg1) + value_as_long (arg2));
+ VALUE_TYPE (arg3) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)));
+ return value_ind (arg3);
+
case BINOP_ASSIGN:
arg1 = evaluate_subexp (exp, pos, noside);
arg2 = evaluate_subexp (exp, pos, noside);
evaluate_subexp (exp, pos, EVAL_SKIP);
goto nosideret;
}
- return evaluate_subexp_for_address (exp, pos, noside);
+ /* C++: check for and handle pointer to members. */
+
+ op = exp->elts[*pos].opcode;
+ if (op == OP_SCOPE)
+ {
+ char *name = &exp->elts[pc+3].string;
+ int tem = strlen (name);
+ struct type *domain = exp->elts[pc+2].type;
+ (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+ arg1 = value_struct_elt_for_address (domain, 0, name);
+ if (arg1)
+ return arg1;
+ error ("no field `%s' in structure", name);
+ }
+ else
+ return evaluate_subexp_for_address (exp, pos, noside);
case UNOP_SIZEOF:
if (noside == EVAL_SKIP)
return arg1;
value_assign (arg1, arg2);
return arg1;
+
+ case OP_THIS:
+ (*pos) += 1;
+ return value_of_this (1);
+
+ default:
+ error ("internal error: I dont know how to evaluation what you gave me");
}
nosideret:
{"&", UNOP_ADDR, PREC_PREFIX, 0},
{"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
{"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
- {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}
+ {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
+ /* C++ */
+ {"::", BINOP_SCOPE, PREC_PREFIX, 0},
};
\f
static void print_subexp ();
opcode = exp->elts[pc].opcode;
switch (opcode)
{
+ case OP_SCOPE:
+ myprec = PREC_PREFIX;
+ assoc = 0;
+ (*pos) += 2;
+ print_subexp (exp, pos, stream, (int) myprec + assoc);
+ fprintf (stream, " :: ");
+ nargs = strlen (&exp->elts[pc + 2].string);
+ (*pos) += 1 + (nargs + sizeof (union exp_element)) / sizeof (union exp_element);
+
+ fprintf (stream, &exp->elts[pc + 2].string);
+ return;
+
case OP_LONG:
(*pos) += 3;
value_print (value_from_long (exp->elts[pc + 1].type,
--- /dev/null
+
+/* A Bison parser, made from expread.y */
+
+#define INT 258
+#define CHAR 259
+#define FLOAT 260
+#define NAME 261
+#define TYPENAME 262
+#define STRING 263
+#define STRUCT 264
+#define UNION 265
+#define ENUM 266
+#define SIZEOF 267
+#define UNSIGNED 268
+#define COLONCOLON 269
+#define LAST 270
+#define REGNAME 271
+#define VARIABLE 272
+#define ASSIGN_MODIFY 273
+#define THIS 274
+#define ABOVE_COMMA 275
+#define OR 276
+#define AND 277
+#define EQUAL 278
+#define NOTEQUAL 279
+#define LEQ 280
+#define GEQ 281
+#define LSH 282
+#define RSH 283
+#define UNARY 284
+#define INCREMENT 285
+#define DECREMENT 286
+#define ARROW 287
+
+#line 30 "expread.y"
+
+#include "defs.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+#include "expression.h"
+
+#include <stdio.h>
+
+static struct expression *expout;
+static int expout_size;
+static int expout_ptr;
+
+static int yylex ();
+static yyerror ();
+static void write_exp_elt ();
+static void write_exp_string ();
+static void start_arglist ();
+static int end_arglist ();
+static void free_funcalls ();
+static char *copy_name ();
+
+/* If this is nonzero, this block is used as the lexical context
+ for symbol names. */
+
+static struct block *expression_context_block;
+
+/* Number of arguments seen so far in innermost function call. */
+static int arglist_len;
+
+/* Data structure for saving values of arglist_len
+ for function calls whose arguments contain other function calls. */
+
+struct funcall
+ {
+ struct funcall *next;
+ int arglist_len;
+ };
+
+struct funcall *funcall_chain;
+
+/* This kind of datum is used to represent the name
+ of a symbol token. */
+
+struct stoken
+ {
+ char *ptr;
+ int length;
+ };
+
+#line 85 "expread.y"
+typedef union
+ {
+ long lval;
+ double dval;
+ struct symbol *sym;
+ struct type *tval;
+ struct stoken sval;
+ int voidval;
+ struct block *bval;
+ enum exp_opcode opcode;
+ struct internalvar *ivar;
+
+ struct type **tvec;
+ int *ivec;
+ } YYSTYPE;
+
+#ifndef YYLTYPE
+typedef
+ struct yyltype
+ {
+ int timestamp;
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+ char *text;
+ }
+ yyltype;
+
+#define YYLTYPE yyltype
+#endif
+
+#define YYACCEPT return(0)
+#define YYABORT return(1)
+#define YYERROR return(1)
+#include <stdio.h>
+
+#ifndef __STDC__
+#define const
+#endif
+
+
+
+#define YYFINAL 152
+#define YYFLAG -32768
+#define YYNTBASE 57
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 287 ? yytranslate[x] : 68)
+
+static const char yytranslate[] = { 0,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 48, 2, 2, 2, 40, 27, 2, 51,
+ 52, 38, 36, 20, 37, 46, 39, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 56, 2, 30,
+ 22, 31, 55, 41, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 47, 2, 50, 26, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 53, 25, 54, 49, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 21, 23, 24, 28, 29, 32,
+ 33, 34, 35, 42, 43, 44, 45
+};
+
+static const short yyrline[] = { 0,
+ 152, 156, 157, 162, 165, 168, 172, 176, 180, 184,
+ 188, 192, 196, 200, 206, 210, 216, 220, 224, 228,
+ 234, 237, 241, 245, 251, 257, 263, 267, 271, 275,
+ 279, 283, 287, 291, 295, 299, 303, 307, 311, 315,
+ 319, 323, 327, 331, 335, 339, 343, 347, 353, 360,
+ 367, 374, 377, 383, 389, 395, 402, 409, 416, 437,
+ 448, 461, 474, 510, 575, 576, 578, 580, 582, 584,
+ 586, 592, 595, 598, 601, 604, 609, 614, 621, 622
+};
+
+static const char * const yytname[] = { 0,
+"error","$illegal.","INT","CHAR","FLOAT","NAME","TYPENAME","STRING","STRUCT","UNION",
+"ENUM","SIZEOF","UNSIGNED","COLONCOLON","LAST","REGNAME","VARIABLE","ASSIGN_MODIFY","THIS","','",
+"ABOVE_COMMA","'='","OR","AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'",
+"'>'","LEQ","GEQ","LSH","RSH","'+'","'-'","'*'","'/'","'%'",
+"'@'","UNARY","INCREMENT","DECREMENT","ARROW","'.'","'['","'!'","'~'","']'",
+"'('","')'","'{'","'}'","'?'","':'","start"
+};
+
+static const short yyr1[] = { 0,
+ 57, 58, 58, 59, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 59, 59, 59, 59, 59, 60, 59,
+ 61, 61, 61, 59, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 59, 59, 59, 59, 59, 62, 62,
+ 63, 63, 63, 63, 64, 64, 64, 64, 64, 64,
+ 64, 65, 65, 65, 65, 65, 66, 66, 67, 67
+};
+
+static const short yyr2[] = { 0,
+ 1, 1, 3, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 3, 4, 3, 4, 4, 0, 5,
+ 0, 1, 3, 4, 4, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 5, 3, 3, 1, 1,
+ 1, 1, 1, 1, 1, 4, 1, 1, 1, 3,
+ 3, 3, 2, 1, 1, 2, 2, 3, 6, 8,
+ 9, 1, 2, 2, 2, 2, 1, 3, 1, 1
+};
+
+static const short yydefact[] = { 0,
+ 49, 50, 51, 64, 72, 57, 0, 0, 0, 0,
+ 0, 0, 53, 54, 55, 58, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 2, 0, 52, 0,
+ 59, 79, 80, 73, 74, 75, 0, 13, 76, 63,
+ 5, 6, 4, 9, 10, 7, 8, 0, 0, 65,
+ 72, 0, 65, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 11, 12, 0, 0, 0,
+ 19, 0, 0, 0, 0, 26, 67, 66, 0, 0,
+ 0, 0, 0, 3, 48, 47, 45, 44, 43, 42,
+ 41, 35, 36, 39, 40, 37, 38, 33, 34, 31,
+ 32, 28, 29, 30, 27, 0, 14, 0, 16, 0,
+ 21, 0, 61, 62, 56, 0, 25, 68, 24, 15,
+ 17, 18, 22, 0, 0, 0, 0, 20, 46, 0,
+ 23, 69, 0, 70, 77, 0, 0, 71, 78, 0,
+ 0, 0
+};
+
+static const short yydefgoto[] = { 150,
+ 48, 27, 121, 134, 28, 29, 49, 30, 146, 31
+};
+
+static const short yypact[] = { 125,
+-32768,-32768,-32768, 1,-32768,-32768, 24, 24, 24, 176,
+ 24, 24,-32768,-32768,-32768,-32768, 125, 125, 125, 125,
+ 125, 125, 125, 125, 515, 0, 243, 14,-32768, 18,
+-32768,-32768,-32768,-32768,-32768,-32768, 125, 472,-32768,-32768,
+ 472, 472, 472, 472, 472, 472, 472, 21, 52, 19,
+-32768, 58, 20, 125, 125, 125, 125, 125, 125, 125,
+ 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
+ 125, 125, 125, 125, 125,-32768,-32768, -1, 29, 125,
+-32768, 125, 24, 24, 119,-32768,-32768,-32768, 515, 125,
+ 32, 125, -14, 243, 243, 243, 275, 306, 336, 365,
+ 393, 419, 419, 441, 441, 441, 441, 161, 161, 459,
+ 459, 104, 104, 104, 472, 125,-32768, 125,-32768, 49,
+ 125, 208, 26,-32768, 125, 57, 472,-32768, 472, 104,
+ 104,-32768, 243, 22, 125, 38, 125,-32768, 243, 25,
+ 243, 27, 16,-32768, 54, 23, 515,-32768, 54, 84,
+ 86,-32768
+};
+
+static const short yypgoto[] = {-32768,
+ 3, -10,-32768,-32768,-32768,-32768, -21, -23,-32768, 10
+};
+
+
+#define YYLAST 528
+
+
+static const short yytable[] = { 38,
+ 50, 53, 26, 52, 32, 33, 41, 42, 43, 44,
+ 45, 46, 47, 50, -79, 85, 34, 35, 36, 54,
+ 39, 40, 51, 128, 7, 8, 9, 83, 11, 32,
+ 33, 84, 91, 93, 32, 33, 116, 32, 33, -60,
+ 54, 137, 147, 94, 95, 96, 97, 98, 99, 100,
+ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+ 111, 112, 113, 114, 115, 126, 118, 144, 54, 128,
+ 136, 122, 86, 138, 148, 140, 142, 143, 87, 127,
+ 87, 129, 120, 151, 87, 152, 0, 117, 119, 88,
+ 0, 88, 123, 124, 0, 88, 0, 0, 132, 0,
+ 124, 0, 89, 90, 89, 130, 0, 131, 89, 0,
+ 133, 92, 0, 0, 127, 0, 0, 0, 0, 53,
+ 0, 145, 0, 53, 139, 149, 141, 1, 2, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 0, 16, 75, 87, 76, 77, 78, 79,
+ 80, 17, 0, 0, 81, 0, 88, 0, 82, 0,
+ 0, 18, 19, 0, 0, 0, 0, 20, 21, 89,
+ 125, 0, 22, 23, 0, 24, 0, 25, 1, 2,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 14, 15, 0, 16, 0, 70, 71, 72, 73,
+ 74, 75, 17, 76, 77, 78, 79, 80, 0, 0,
+ 0, 81, 18, 19, 0, 82, 0, 0, 20, 21,
+ 0, 0, 0, 22, 23, 55, 37, 0, 25, 56,
+ 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 0,
+ 76, 77, 78, 79, 80, 0, 0, 0, 81, 0,
+ 55, 0, 82, 135, 56, 57, 58, 59, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
+ 72, 73, 74, 75, 0, 76, 77, 78, 79, 80,
+ 0, 0, 0, 81, 0, 0, 0, 82, 58, 59,
+ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+ 70, 71, 72, 73, 74, 75, 0, 76, 77, 78,
+ 79, 80, 0, 0, 0, 81, 0, 0, 0, 82,
+ 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 0, 76, 77,
+ 78, 79, 80, 0, 0, 0, 81, 0, 0, 0,
+ 82, 60, 61, 62, 63, 64, 65, 66, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 0, 76, 77,
+ 78, 79, 80, 0, 0, 0, 81, 0, 0, 0,
+ 82, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+ 70, 71, 72, 73, 74, 75, 0, 76, 77, 78,
+ 79, 80, 0, 0, 0, 81, 0, 0, 0, 82,
+ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
+ 72, 73, 74, 75, 0, 76, 77, 78, 79, 80,
+ 0, 0, 0, 81, 0, 0, 0, 82, 64, 65,
+ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
+ 0, 76, 77, 78, 79, 80, 0, 0, 0, 81,
+ 0, 0, 0, 82, 68, 69, 70, 71, 72, 73,
+ 74, 75, 0, 76, 77, 78, 79, 80, 0, 0,
+ 0, 81, 0, 0, 0, 82, 72, 73, 74, 75,
+ 0, 76, 77, 78, 79, 80, 0, 0, 0, 81,
+ 0, 0, 0, 82, 76, 77, 78, 79, 80, 0,
+ 0, 51, 81, 7, 8, 9, 82, 11
+};
+
+static const short yycheck[] = { 10,
+ 24, 25, 0, 25, 6, 7, 17, 18, 19, 20,
+ 21, 22, 23, 37, 14, 37, 7, 8, 9, 20,
+ 11, 12, 7, 38, 9, 10, 11, 14, 13, 6,
+ 7, 14, 14, 14, 6, 7, 38, 6, 7, 14,
+ 20, 20, 20, 54, 55, 56, 57, 58, 59, 60,
+ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 89, 38, 52, 20, 38,
+ 14, 82, 52, 52, 52, 38, 52, 51, 27, 90,
+ 27, 92, 80, 0, 27, 0, -1, 78, 79, 38,
+ -1, 38, 83, 84, -1, 38, -1, -1, 50, -1,
+ 91, -1, 51, 52, 51, 116, -1, 118, 51, -1,
+ 121, 54, -1, -1, 125, -1, -1, -1, -1, 143,
+ -1, 143, -1, 147, 135, 147, 137, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, -1, 19, 41, 27, 43, 44, 45, 46,
+ 47, 27, -1, -1, 51, -1, 38, -1, 55, -1,
+ -1, 37, 38, -1, -1, -1, -1, 43, 44, 51,
+ 52, -1, 48, 49, -1, 51, -1, 53, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, -1, 19, -1, 36, 37, 38, 39,
+ 40, 41, 27, 43, 44, 45, 46, 47, -1, -1,
+ -1, 51, 37, 38, -1, 55, -1, -1, 43, 44,
+ -1, -1, -1, 48, 49, 18, 51, -1, 53, 22,
+ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, 40, 41, -1,
+ 43, 44, 45, 46, 47, -1, -1, -1, 51, -1,
+ 18, -1, 55, 56, 22, 23, 24, 25, 26, 27,
+ 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, -1, 43, 44, 45, 46, 47,
+ -1, -1, -1, 51, -1, -1, -1, 55, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, -1, 43, 44, 45,
+ 46, 47, -1, -1, -1, 51, -1, -1, -1, 55,
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+ 35, 36, 37, 38, 39, 40, 41, -1, 43, 44,
+ 45, 46, 47, -1, -1, -1, 51, -1, -1, -1,
+ 55, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+ 35, 36, 37, 38, 39, 40, 41, -1, 43, 44,
+ 45, 46, 47, -1, -1, -1, 51, -1, -1, -1,
+ 55, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, -1, 43, 44, 45,
+ 46, 47, -1, -1, -1, 51, -1, -1, -1, 55,
+ 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, -1, 43, 44, 45, 46, 47,
+ -1, -1, -1, 51, -1, -1, -1, 55, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+ -1, 43, 44, 45, 46, 47, -1, -1, -1, 51,
+ -1, -1, -1, 55, 34, 35, 36, 37, 38, 39,
+ 40, 41, -1, 43, 44, 45, 46, 47, -1, -1,
+ -1, 51, -1, -1, -1, 55, 38, 39, 40, 41,
+ -1, 43, 44, 45, 46, 47, -1, -1, -1, 51,
+ -1, -1, -1, 55, 43, 44, 45, 46, 47, -1,
+ -1, 7, 51, 9, 10, 11, 55, 13
+};
+#define YYPURE 1
+
+#line 2 "bison.simple"
+
+/* Skeleton output parser for bison,
+ copyright (C) 1984 Bob Corbett and Richard Stallman
+
+ NO WARRANTY
+
+ BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+ GENERAL PUBLIC LICENSE TO COPY
+
+ 1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1985 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License. You may charge a distribution fee for the
+physical act of transferring a copy.
+
+ 2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+ a) cause the modified files to carry prominent notices stating
+ that you changed the files and the date of any change; and
+
+ b) cause the whole of any work that you distribute or publish,
+ that in whole or in part contains or is a derivative of this
+ program or any part thereof, to be licensed at no charge to all
+ third parties on terms identical to those contained in this
+ License Agreement (except that you may choose to grant more
+ extensive warranty protection to third parties, at your option).
+
+ c) You may charge a distribution fee for the physical act of
+ transferring a copy, and you may at your option offer warranty
+ protection in exchange for a fee.
+
+ 3. You may copy and distribute this program or any portion of it in
+compiled, executable or object code form under the terms of Paragraphs
+1 and 2 above provided that you do the following:
+
+ a) cause each such copy to be accompanied by the
+ corresponding machine-readable source code, which must
+ be distributed under the terms of Paragraphs 1 and 2 above; or,
+
+ b) cause each such copy to be accompanied by a
+ written offer, with no time limit, to give any third party
+ free (except for a nominal shipping charge) a machine readable
+ copy of the corresponding source code, to be distributed
+ under the terms of Paragraphs 1 and 2 above; or,
+
+ c) in the case of a recipient of this program in compiled, executable
+ or object code form (without the corresponding source code) you
+ shall cause copies you distribute to be accompanied by a copy
+ of the written offer of source code which you received along
+ with the copy you received.
+
+ 4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement. Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated. However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+ 5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this. We will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software.
+
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them. Help stamp out software-hoarding! */
+
+/* This is the parser code that is written into each bison parser
+ when the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
+
+/* Note: there must be only one dollar sign in this file.
+ It is replaced by the list of actions, each action
+ as one case of the switch. */
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYFAIL goto yyerrlab;
+
+#define YYTERROR 1
+
+#ifndef YYIMPURE
+#define YYLEX yylex()
+#endif
+
+#ifndef YYPURE
+#define YYLEX yylex(&yylval, &yylloc)
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYIMPURE
+
+int yychar; /* the lookahead symbol */
+YYSTYPE yylval; /* the semantic value of the */
+ /* lookahead symbol */
+
+YYLTYPE yylloc; /* location data for the lookahead */
+ /* symbol */
+
+int yydebug = 0; /* nonzero means print parse trace */
+
+#endif /* YYIMPURE */
+
+
+/* YYMAXDEPTH indicates the initial size of the parser's stacks */
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 200
+#endif
+
+/* YYMAXLIMIT is the maximum size the stacks can grow to
+ (effective only if the built-in stack extension method is used). */
+
+#ifndef YYMAXLIMIT
+#define YYMAXLIMIT 10000
+#endif
+
+
+#line 87 "bison.simple"
+int
+yyparse()
+{
+ register int yystate;
+ register int yyn;
+ register short *yyssp;
+ register YYSTYPE *yyvsp;
+ YYLTYPE *yylsp;
+ int yyerrstatus; /* number of tokens to shift before error messages enabled */
+ int yychar1; /* lookahead token as an internal (translated) token number */
+
+ short yyssa[YYMAXDEPTH]; /* the state stack */
+ YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */
+ YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */
+
+ short *yyss = yyssa; /* refer to the stacks thru separate pointers */
+ YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
+ YYLTYPE *yyls = yylsa;
+
+ int yymaxdepth = YYMAXDEPTH;
+
+#ifndef YYPURE
+
+ int yychar;
+ YYSTYPE yylval;
+ YYLTYPE yylloc;
+
+ extern int yydebug;
+
+#endif
+
+
+ YYSTYPE yyval; /* the variable used to return */
+ /* semantic values from the action */
+ /* routines */
+
+ int yylen;
+
+ if (yydebug)
+ fprintf(stderr, "Starting parse\n");
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+
+ /* Initialize stack pointers.
+ Waste one element of value and location stack
+ so that they stay on the same level as the state stack. */
+
+ yyssp = yyss - 1;
+ yyvsp = yyvs;
+ yylsp = yyls;
+
+/* Push a new state, which is found in yystate . */
+/* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks. */
+yynewstate:
+
+ *++yyssp = yystate;
+
+ if (yyssp >= yyss + yymaxdepth - 1)
+ {
+ /* Give user a chance to reallocate the stack */
+ /* Use copies of these so that the &'s don't force the real ones into memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ YYLTYPE *yyls1 = yyls;
+ short *yyss1 = yyss;
+
+ /* Get the current used size of the three stacks, in elements. */
+ int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ /* Each stack pointer address is followed by the size of
+ the data in use in that stack, in bytes. */
+ yyoverflow("parser stack overflow",
+ &yyss1, size * sizeof (*yyssp),
+ &yyvs1, size * sizeof (*yyvsp),
+ &yyls1, size * sizeof (*yylsp),
+ &yymaxdepth);
+
+ yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
+#else /* no yyoverflow */
+ /* Extend the stack our own way. */
+ if (yymaxdepth >= YYMAXLIMIT)
+ yyerror("parser stack overflow");
+ yymaxdepth *= 2;
+ if (yymaxdepth > YYMAXLIMIT)
+ yymaxdepth = YYMAXLIMIT;
+ yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
+ bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+ yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
+ bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
+ yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
+ bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
+#endif /* no yyoverflow */
+
+ yyssp = yyss + size - 1;
+ yylsp = yyls + size - 1;
+ yyvsp = yyvs + size - 1;
+
+ if (yydebug)
+ fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
+
+ if (yyssp >= yyss + yymaxdepth - 1)
+ YYERROR;
+ }
+
+ if (yydebug)
+ fprintf(stderr, "Entering state %d\n", yystate);
+
+/* Do appropriate processing given the current state. */
+/* Read a lookahead token if we need one and don't already have one. */
+yyresume:
+
+ /* First try to decide what to do without reference to lookahead token. */
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* yychar is either YYEMPTY or YYEOF
+ or a valid token in external form. */
+
+ if (yychar == YYEMPTY)
+ {
+ yychar = YYLEX;
+ }
+
+ /* Convert token to internal form (in yychar1) for indexing tables with */
+
+ if (yychar <= 0) /* This means end of input. */
+ {
+ yychar1 = 0;
+ yychar = YYEOF; /* Don't call YYLEX any more */
+
+ if (yydebug)
+ fprintf(stderr, "Now at end of input.\n");
+ }
+ else
+ {
+ yychar1 = YYTRANSLATE(yychar);
+
+ if (yydebug)
+ fprintf(stderr, "Parsing next token; it is %d (%s)\n", yychar, yytname[yychar1]);
+ }
+
+ yyn += yychar1;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+ goto yydefault;
+
+ yyn = yytable[yyn];
+
+ /* yyn is what to do for this token type in this state.
+ Negative => reduce, -yyn is rule number.
+ Positive => shift, yyn is new state.
+ New state is final state => don't bother to shift,
+ just return success.
+ 0, or most negative number => error. */
+
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrlab;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ /* Shift the lookahead token. */
+
+ if (yydebug)
+ fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+
+ /* Discard the token being shifted unless it is eof. */
+ if (yychar != YYEOF)
+ yychar = YYEMPTY;
+
+ *++yyvsp = yylval;
+ *++yylsp = yylloc;
+
+ /* count tokens shifted since error; after three, turn off error status. */
+ if (yyerrstatus) yyerrstatus--;
+
+ yystate = yyn;
+ goto yynewstate;
+
+/* Do the default action for the current state. */
+yydefault:
+
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+
+/* Do a reduction. yyn is the number of a rule to reduce with. */
+yyreduce:
+ yylen = yyr2[yyn];
+ yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+ if (yydebug)
+ {
+ if (yylen == 1)
+ fprintf (stderr, "Reducing 1 value via line %d, ",
+ yyrline[yyn]);
+ else
+ fprintf (stderr, "Reducing %d values via line %d, ",
+ yylen, yyrline[yyn]);
+ }
+
+
+ switch (yyn) {
+
+case 3:
+#line 158 "expread.y"
+{ write_exp_elt (BINOP_COMMA); ;
+ break;}
+case 4:
+#line 163 "expread.y"
+{ write_exp_elt (UNOP_IND); ;
+ break;}
+case 5:
+#line 166 "expread.y"
+{ write_exp_elt (UNOP_ADDR); ;
+ break;}
+case 6:
+#line 169 "expread.y"
+{ write_exp_elt (UNOP_NEG); ;
+ break;}
+case 7:
+#line 173 "expread.y"
+{ write_exp_elt (UNOP_ZEROP); ;
+ break;}
+case 8:
+#line 177 "expread.y"
+{ write_exp_elt (UNOP_LOGNOT); ;
+ break;}
+case 9:
+#line 181 "expread.y"
+{ write_exp_elt (UNOP_PREINCREMENT); ;
+ break;}
+case 10:
+#line 185 "expread.y"
+{ write_exp_elt (UNOP_PREDECREMENT); ;
+ break;}
+case 11:
+#line 189 "expread.y"
+{ write_exp_elt (UNOP_POSTINCREMENT); ;
+ break;}
+case 12:
+#line 193 "expread.y"
+{ write_exp_elt (UNOP_POSTDECREMENT); ;
+ break;}
+case 13:
+#line 197 "expread.y"
+{ write_exp_elt (UNOP_SIZEOF); ;
+ break;}
+case 14:
+#line 201 "expread.y"
+{ write_exp_elt (STRUCTOP_PTR);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt (STRUCTOP_PTR); ;
+ break;}
+case 15:
+#line 207 "expread.y"
+{ write_exp_elt (STRUCTOP_MPTR); ;
+ break;}
+case 16:
+#line 211 "expread.y"
+{ write_exp_elt (STRUCTOP_STRUCT);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt (STRUCTOP_STRUCT); ;
+ break;}
+case 17:
+#line 217 "expread.y"
+{ write_exp_elt (STRUCTOP_MEMBER); ;
+ break;}
+case 18:
+#line 221 "expread.y"
+{ write_exp_elt (BINOP_SUBSCRIPT); ;
+ break;}
+case 19:
+#line 227 "expread.y"
+{ start_arglist (); ;
+ break;}
+case 20:
+#line 229 "expread.y"
+{ write_exp_elt (OP_FUNCALL);
+ write_exp_elt (end_arglist ());
+ write_exp_elt (OP_FUNCALL); ;
+ break;}
+case 22:
+#line 238 "expread.y"
+{ arglist_len = 1; ;
+ break;}
+case 23:
+#line 242 "expread.y"
+{ arglist_len++; ;
+ break;}
+case 24:
+#line 246 "expread.y"
+{ write_exp_elt (UNOP_MEMVAL);
+ write_exp_elt (yyvsp[-2].tval);
+ write_exp_elt (UNOP_MEMVAL); ;
+ break;}
+case 25:
+#line 252 "expread.y"
+{ write_exp_elt (UNOP_CAST);
+ write_exp_elt (yyvsp[-2].tval);
+ write_exp_elt (UNOP_CAST); ;
+ break;}
+case 26:
+#line 258 "expread.y"
+{ ;
+ break;}
+case 27:
+#line 264 "expread.y"
+{ write_exp_elt (BINOP_REPEAT); ;
+ break;}
+case 28:
+#line 268 "expread.y"
+{ write_exp_elt (BINOP_MUL); ;
+ break;}
+case 29:
+#line 272 "expread.y"
+{ write_exp_elt (BINOP_DIV); ;
+ break;}
+case 30:
+#line 276 "expread.y"
+{ write_exp_elt (BINOP_REM); ;
+ break;}
+case 31:
+#line 280 "expread.y"
+{ write_exp_elt (BINOP_ADD); ;
+ break;}
+case 32:
+#line 284 "expread.y"
+{ write_exp_elt (BINOP_SUB); ;
+ break;}
+case 33:
+#line 288 "expread.y"
+{ write_exp_elt (BINOP_LSH); ;
+ break;}
+case 34:
+#line 292 "expread.y"
+{ write_exp_elt (BINOP_RSH); ;
+ break;}
+case 35:
+#line 296 "expread.y"
+{ write_exp_elt (BINOP_EQUAL); ;
+ break;}
+case 36:
+#line 300 "expread.y"
+{ write_exp_elt (BINOP_NOTEQUAL); ;
+ break;}
+case 37:
+#line 304 "expread.y"
+{ write_exp_elt (BINOP_LEQ); ;
+ break;}
+case 38:
+#line 308 "expread.y"
+{ write_exp_elt (BINOP_GEQ); ;
+ break;}
+case 39:
+#line 312 "expread.y"
+{ write_exp_elt (BINOP_LESS); ;
+ break;}
+case 40:
+#line 316 "expread.y"
+{ write_exp_elt (BINOP_GTR); ;
+ break;}
+case 41:
+#line 320 "expread.y"
+{ write_exp_elt (BINOP_LOGAND); ;
+ break;}
+case 42:
+#line 324 "expread.y"
+{ write_exp_elt (BINOP_LOGXOR); ;
+ break;}
+case 43:
+#line 328 "expread.y"
+{ write_exp_elt (BINOP_LOGIOR); ;
+ break;}
+case 44:
+#line 332 "expread.y"
+{ write_exp_elt (BINOP_AND); ;
+ break;}
+case 45:
+#line 336 "expread.y"
+{ write_exp_elt (BINOP_OR); ;
+ break;}
+case 46:
+#line 340 "expread.y"
+{ write_exp_elt (TERNOP_COND); ;
+ break;}
+case 47:
+#line 344 "expread.y"
+{ write_exp_elt (BINOP_ASSIGN); ;
+ break;}
+case 48:
+#line 348 "expread.y"
+{ write_exp_elt (BINOP_ASSIGN_MODIFY);
+ write_exp_elt (yyvsp[-1].opcode);
+ write_exp_elt (BINOP_ASSIGN_MODIFY); ;
+ break;}
+case 49:
+#line 354 "expread.y"
+{ write_exp_elt (OP_LONG);
+ write_exp_elt (builtin_type_long);
+ write_exp_elt (yyvsp[0].lval);
+ write_exp_elt (OP_LONG); ;
+ break;}
+case 50:
+#line 361 "expread.y"
+{ write_exp_elt (OP_LONG);
+ write_exp_elt (builtin_type_char);
+ write_exp_elt (yyvsp[0].lval);
+ write_exp_elt (OP_LONG); ;
+ break;}
+case 51:
+#line 368 "expread.y"
+{ write_exp_elt (OP_DOUBLE);
+ write_exp_elt (builtin_type_double);
+ write_exp_elt (yyvsp[0].dval);
+ write_exp_elt (OP_DOUBLE); ;
+ break;}
+case 53:
+#line 378 "expread.y"
+{ write_exp_elt (OP_LAST);
+ write_exp_elt (yyvsp[0].lval);
+ write_exp_elt (OP_LAST); ;
+ break;}
+case 54:
+#line 384 "expread.y"
+{ write_exp_elt (OP_REGISTER);
+ write_exp_elt (yyvsp[0].lval);
+ write_exp_elt (OP_REGISTER); ;
+ break;}
+case 55:
+#line 390 "expread.y"
+{ write_exp_elt (OP_INTERNALVAR);
+ write_exp_elt (yyvsp[0].ivar);
+ write_exp_elt (OP_INTERNALVAR); ;
+ break;}
+case 56:
+#line 396 "expread.y"
+{ write_exp_elt (OP_LONG);
+ write_exp_elt (builtin_type_int);
+ write_exp_elt ((long) TYPE_LENGTH (yyvsp[-1].tval));
+ write_exp_elt (OP_LONG); ;
+ break;}
+case 57:
+#line 403 "expread.y"
+{ write_exp_elt (OP_STRING);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt (OP_STRING); ;
+ break;}
+case 58:
+#line 410 "expread.y"
+{ write_exp_elt (OP_THIS);
+ write_exp_elt (OP_THIS); ;
+ break;}
+case 59:
+#line 417 "expread.y"
+{
+ struct symtab *tem = lookup_symtab (copy_name (yyvsp[0].sval));
+ struct symbol *sym;
+
+ if (tem)
+ yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
+ else
+ {
+ sym = lookup_symbol (copy_name (yyvsp[0].sval),
+ expression_context_block,
+ VAR_NAMESPACE);
+ if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ yyval.bval = SYMBOL_BLOCK_VALUE (sym);
+ else
+ error ("No file or function \"%s\".",
+ copy_name (yyvsp[0].sval));
+ }
+ ;
+ break;}
+case 60:
+#line 438 "expread.y"
+{
+ struct symbol *tem
+ = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, VAR_NAMESPACE);
+ if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
+ error ("No function \"%s\" in specified context.",
+ copy_name (yyvsp[-2].bval));
+ yyval.bval = SYMBOL_BLOCK_VALUE (tem);
+ ;
+ break;}
+case 61:
+#line 449 "expread.y"
+{
+ struct symbol *sym;
+ sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, VAR_NAMESPACE);
+ if (sym == 0)
+ error ("No symbol \"%s\" in specified context.",
+ copy_name (yyvsp[0].sval));
+ write_exp_elt (OP_VAR_VALUE);
+ write_exp_elt (sym);
+ write_exp_elt (OP_VAR_VALUE);
+ ;
+ break;}
+case 62:
+#line 462 "expread.y"
+{
+ struct type *type = yyvsp[-2].tval;
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION)
+ error ("`%s' is not defined as an aggregate type.",
+ TYPE_NAME (type));
+
+ write_exp_elt (OP_SCOPE);
+ write_exp_elt (type);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt (OP_SCOPE);
+ ;
+ break;}
+case 63:
+#line 475 "expread.y"
+{
+ char *name = copy_name (yyvsp[0].sval);
+ struct symbol *sym;
+ int i;
+
+ sym = lookup_symbol_2 (name, 0, VAR_NAMESPACE);
+ if (sym)
+ {
+ write_exp_elt (OP_VAR_VALUE);
+ write_exp_elt (sym);
+ write_exp_elt (OP_VAR_VALUE);
+ break;
+ }
+ for (i = 0; i < misc_function_count; i++)
+ if (!strcmp (misc_function_vector[i].name, name))
+ break;
+
+ if (i < misc_function_count)
+ {
+ write_exp_elt (OP_LONG);
+ write_exp_elt (builtin_type_int);
+ write_exp_elt (misc_function_vector[i].address);
+ write_exp_elt (OP_LONG);
+ write_exp_elt (UNOP_MEMVAL);
+ write_exp_elt (builtin_type_char);
+ write_exp_elt (UNOP_MEMVAL);
+ }
+ else
+ if (symtab_list == 0)
+ error ("No symbol table is loaded. Use the \"symbol-file\" command.");
+ else
+ error ("No symbol \"%s\" in current context.", name);
+ ;
+ break;}
+case 64:
+#line 511 "expread.y"
+{ struct symbol *sym;
+ sym = lookup_symbol_1 (copy_name (yyvsp[0].sval),
+ expression_context_block,
+ VAR_NAMESPACE);
+ if (sym)
+ {
+ write_exp_elt (OP_VAR_VALUE);
+ write_exp_elt (sym);
+ write_exp_elt (OP_VAR_VALUE);
+ }
+ else
+ {
+ register char *arg = copy_name (yyvsp[0].sval);
+ register int i;
+ int v, val;
+ /* C++: see if it hangs off of `this'. Must
+ not inadvertently convert from a method call
+ to data ref. */
+ v = (int)value_of_this (0);
+ if (v)
+ {
+ val = check_field (v, arg);
+ if (val)
+ {
+ write_exp_elt (OP_THIS);
+ write_exp_elt (OP_THIS);
+ write_exp_elt (STRUCTOP_PTR);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt (STRUCTOP_PTR);
+ break;
+ }
+ }
+ sym = lookup_symbol_2 (arg, 0, VAR_NAMESPACE);
+ if (sym)
+ {
+ write_exp_elt (OP_VAR_VALUE);
+ write_exp_elt (sym);
+ write_exp_elt (OP_VAR_VALUE);
+ break; /* YACC-dependent */
+ }
+ for (i = 0; i < misc_function_count; i++)
+ if (!strcmp (misc_function_vector[i].name, arg))
+ break;
+
+ if (i < misc_function_count)
+ {
+ write_exp_elt (OP_LONG);
+ write_exp_elt (builtin_type_int);
+ write_exp_elt (misc_function_vector[i].address);
+ write_exp_elt (OP_LONG);
+ write_exp_elt (UNOP_MEMVAL);
+ write_exp_elt (builtin_type_char);
+ write_exp_elt (UNOP_MEMVAL);
+ }
+ else
+ if (symtab_list == 0)
+ error ("No symbol table is loaded. Use the \"symbol-file\" command.");
+ else
+ error ("No symbol \"%s\" in current context.",
+ copy_name (yyvsp[0].sval));
+ }
+ ;
+ break;}
+case 66:
+#line 577 "expread.y"
+{ yyval.tval = lookup_pointer_type (yyvsp[-1].tval); ;
+ break;}
+case 67:
+#line 579 "expread.y"
+{ yyval.tval = lookup_reference_type (yyvsp[-1].tval); ;
+ break;}
+case 68:
+#line 581 "expread.y"
+{ yyval.tval = lookup_member_pointer_type (builtin_type_int, yyvsp[-2].tval); ;
+ break;}
+case 69:
+#line 583 "expread.y"
+{ yyval.tval = lookup_member_pointer_type (yyvsp[-5].tval, yyvsp[-3].tval); ;
+ break;}
+case 70:
+#line 585 "expread.y"
+{ yyval.tval = lookup_member_pointer_type (lookup_function_type (yyvsp[-7].tval, 0), yyvsp[-5].tval); ;
+ break;}
+case 71:
+#line 587 "expread.y"
+{ yyval.tval = lookup_member_pointer_type (lookup_function_type (yyvsp[-8].tval, yyvsp[-1].tvec), yyvsp[-6].tval);
+ free (yyvsp[-1].tvec); ;
+ break;}
+case 72:
+#line 593 "expread.y"
+{ yyval.tval = lookup_typename (copy_name (yyvsp[0].sval),
+ expression_context_block, 0); ;
+ break;}
+case 73:
+#line 596 "expread.y"
+{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
+ expression_context_block); ;
+ break;}
+case 74:
+#line 599 "expread.y"
+{ yyval.tval = lookup_union (copy_name (yyvsp[0].sval),
+ expression_context_block); ;
+ break;}
+case 75:
+#line 602 "expread.y"
+{ yyval.tval = lookup_enum (copy_name (yyvsp[0].sval),
+ expression_context_block); ;
+ break;}
+case 76:
+#line 605 "expread.y"
+{ yyval.tval = lookup_unsigned_typename (copy_name (yyvsp[0].sval)); ;
+ break;}
+case 77:
+#line 610 "expread.y"
+{ yyval.tvec = (struct type **)xmalloc (sizeof (struct type *) * 2);
+ yyval.tvec[0] = (struct type *)0;
+ yyval.tvec[1] = yyvsp[0].tval;
+ ;
+ break;}
+case 78:
+#line 615 "expread.y"
+{ int len = sizeof (struct type *) * ++(yyvsp[-2].ivec[0]);
+ yyval.tvec = (struct type **)xrealloc (yyvsp[-2].tvec, len);
+ yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval;
+ ;
+ break;}
+}
+ /* the action file gets copied in in place of this dollarsign */
+#line 303 "bison.simple"
+\f
+ yyvsp -= yylen;
+ yylsp -= yylen;
+ yyssp -= yylen;
+
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "state stack now", yyssp-yyss);
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+
+ *++yyvsp = yyval;
+
+ yylsp++;
+ if (yylen == 0)
+ {
+ yylsp->first_line = yylloc.first_line;
+ yylsp->first_column = yylloc.first_column;
+ yylsp->last_line = (yylsp-1)->last_line;
+ yylsp->last_column = (yylsp-1)->last_column;
+ yylsp->text = 0;
+ }
+ else
+ {
+ yylsp->last_line = (yylsp+yylen-1)->last_line;
+ yylsp->last_column = (yylsp+yylen-1)->last_column;
+ }
+
+ /* Now "shift" the result of the reduction.
+ Determine what state that goes to,
+ based on the state we popped back to
+ and the rule number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+ if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTBASE];
+
+ goto yynewstate;
+
+yyerrlab: /* here on detecting error */
+
+ if (! yyerrstatus)
+ /* If not already recovering from an error, report this error. */
+ {
+#ifdef ESKIT
+ db_yyerror("parse error", yyssp, yychar);
+#else
+ yyerror("parse error");
+#endif
+ }
+
+ if (yyerrstatus == 3)
+ {
+ /* if just tried and failed to reuse lookahead token after an error, discard it. */
+
+ /* return failure if at end of input */
+ if (yychar == YYEOF)
+ YYERROR;
+
+ if (yydebug)
+ fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+
+ yychar = YYEMPTY;
+ }
+
+ /* Else will try to reuse lookahead token
+ after shifting the error token. */
+
+ yyerrstatus = 3; /* Each real token shifted decrements this */
+
+ goto yyerrhandle;
+
+yyerrdefault: /* current state does not do anything special for the error token. */
+
+#if 0
+ /* This is wrong; only states that explicitly want error tokens
+ should shift them. */
+ yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
+ if (yyn) goto yydefault;
+#endif
+
+yyerrpop: /* pop the current state because it cannot handle the error token */
+
+ if (yyssp == yyss) YYERROR;
+ yyvsp--;
+ yylsp--;
+ yystate = *--yyssp;
+
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "Error: state stack now", yyssp-yyss);
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+
+yyerrhandle:
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yyerrdefault;
+
+ yyn += YYTERROR;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+ goto yyerrdefault;
+
+ yyn = yytable[yyn];
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrpop;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrpop;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ if (yydebug)
+ fprintf(stderr, "Shifting error token, ");
+
+ *++yyvsp = yylval;
+ *++yylsp = yylloc;
+
+ yystate = yyn;
+ goto yynewstate;
+}
+#line 624 "expread.y"
+
+\f
+/* Begin counting arguments for a function call,
+ saving the data about any containing call. */
+
+static void
+start_arglist ()
+{
+ register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
+
+ new->next = funcall_chain;
+ new->arglist_len = arglist_len;
+ arglist_len = 0;
+ funcall_chain = new;
+}
+
+/* Return the number of arguments in a function call just terminated,
+ and restore the data for the containing function call. */
+
+static int
+end_arglist ()
+{
+ register int val = arglist_len;
+ register struct funcall *call = funcall_chain;
+ funcall_chain = call->next;
+ arglist_len = call->arglist_len;
+ free (call);
+ return val;
+}
+
+/* Free everything in the funcall chain.
+ Used when there is an error inside parsing. */
+
+static void
+free_funcalls ()
+{
+ register struct funcall *call, *next;
+
+ for (call = funcall_chain; call; call = next)
+ {
+ next = call->next;
+ free (call);
+ }
+}
+\f
+/* This page contains the functions for adding data to the struct expression
+ being constructed. */
+
+/* Add one element to the end of the expression. */
+
+static void
+write_exp_elt (expelt)
+ union exp_element expelt;
+{
+ if (expout_ptr >= expout_size)
+ {
+ expout_size *= 2;
+ expout = (struct expression *) xrealloc (expout,
+ sizeof (struct expression)
+ + expout_size * sizeof (union exp_element));
+ }
+ expout->elts[expout_ptr++] = expelt;
+}
+
+/* Add a string constant to the end of the expression.
+ Follow it by its length in bytes, as a separate exp_element. */
+
+static void
+write_exp_string (str)
+ struct stoken str;
+{
+ register int len = str.length;
+ register int lenelt
+ = (len + sizeof (union exp_element)) / sizeof (union exp_element);
+
+ expout_ptr += lenelt;
+
+ if (expout_ptr >= expout_size)
+ {
+ expout_size = max (expout_size * 2, expout_ptr + 10);
+ expout = (struct expression *) xrealloc (expout,
+ sizeof (struct expression)
+ + expout_size * sizeof (union exp_element));
+ }
+ bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
+ ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
+ write_exp_elt (len);
+}
+\f
+/* During parsing of a C expression, the pointer to the next character
+ is in this variable. */
+
+static char *lexptr;
+
+/* Tokens that refer to names do so with explicit pointer and length,
+ so they can share the storage that lexptr is parsing.
+
+ When it is necessary to pass a name to a function that expects
+ a null-terminated string, the substring is copied out
+ into a block of storage that namecopy points to.
+
+ namecopy is allocated once, guaranteed big enough, for each parsing. */
+
+static char *namecopy;
+
+/* Current depth in parentheses within the expression. */
+
+static int paren_depth;
+
+/* Nonzero means stop parsing on first comma (if not within parentheses). */
+
+static int comma_terminates;
+
+/* Take care of parsing a number (anything that starts with a digit).
+ Set yylval and return the token type; update lexptr.
+ LEN is the number of characters in it. */
+
+/*** Needs some error checking for the float case ***/
+
+static int
+parse_number (olen)
+ int olen;
+{
+ register char *p = lexptr;
+ register long n = 0;
+ register int c;
+ register int base = 10;
+ register int len = olen;
+ char *err_copy;
+
+ extern double atof ();
+
+ for (c = 0; c < len; c++)
+ if (p[c] == '.')
+ {
+ /* It's a float since it contains a point. */
+ yylval.dval = atof (p);
+ lexptr += len;
+ return FLOAT;
+ }
+
+ if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2)))
+ {
+ p += 2;
+ base = 16;
+ len -= 2;
+ }
+ else if (*p == '0')
+ base = 8;
+
+ while (len-- > 0)
+ {
+ c = *p++;
+ n *= base;
+ if (c >= '0' && c <= '9')
+ n += c - '0';
+ else
+ {
+ if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
+ if (base == 16 && c >= 'a' && c <= 'f')
+ n += c - 'a' + 10;
+ else if (len == 0 && c == 'l')
+ ;
+ else
+ {
+ err_copy = (char *) alloca (olen + 1);
+ bcopy (lexptr, err_copy, olen);
+ err_copy[olen] = 0;
+ error ("Invalid number \"%s\".", err_copy);
+ }
+ }
+ }
+
+ lexptr = p;
+ yylval.lval = n;
+ return INT;
+}
+
+struct token
+{
+ char *operator;
+ int token;
+ enum exp_opcode opcode;
+};
+
+static struct token tokentab3[] =
+ {
+ {">>=", ASSIGN_MODIFY, BINOP_RSH},
+ {"<<=", ASSIGN_MODIFY, BINOP_LSH}
+ };
+
+static struct token tokentab2[] =
+ {
+ {"+=", ASSIGN_MODIFY, BINOP_ADD},
+ {"-=", ASSIGN_MODIFY, BINOP_SUB},
+ {"*=", ASSIGN_MODIFY, BINOP_MUL},
+ {"/=", ASSIGN_MODIFY, BINOP_DIV},
+ {"%=", ASSIGN_MODIFY, BINOP_REM},
+ {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
+ {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
+ {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
+ {"++", INCREMENT, BINOP_END},
+ {"--", DECREMENT, BINOP_END},
+ {"->", ARROW, BINOP_END},
+ {"&&", AND, BINOP_END},
+ {"||", OR, BINOP_END},
+ {"::", COLONCOLON, BINOP_END},
+ {"<<", LSH, BINOP_END},
+ {">>", RSH, BINOP_END},
+ {"==", EQUAL, BINOP_END},
+ {"!=", NOTEQUAL, BINOP_END},
+ {"<=", LEQ, BINOP_END},
+ {">=", GEQ, BINOP_END}
+ };
+
+/* Read one token, getting characters through lexptr. */
+
+static int
+yylex ()
+{
+ register int c;
+ register int namelen;
+ register int i;
+ register char *tokstart;
+
+ retry:
+
+ tokstart = lexptr;
+ /* See if it is a special token of length 3. */
+ for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
+ if (!strncmp (tokstart, tokentab3[i].operator, 3))
+ {
+ lexptr += 3;
+ yylval.opcode = tokentab3[i].opcode;
+ return tokentab3[i].token;
+ }
+
+ /* See if it is a special token of length 2. */
+ for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
+ if (!strncmp (tokstart, tokentab2[i].operator, 2))
+ {
+ lexptr += 2;
+ yylval.opcode = tokentab2[i].opcode;
+ return tokentab2[i].token;
+ }
+
+ switch (c = *tokstart)
+ {
+ case 0:
+ return 0;
+
+ case ' ':
+ case '\t':
+ case '\n':
+ lexptr++;
+ goto retry;
+
+ case '\'':
+ lexptr++;
+ c = *lexptr++;
+ if (c == '\\')
+ c = parse_escape (&lexptr);
+ yylval.lval = c;
+ c = *lexptr++;
+ if (c != '\'')
+ error ("Invalid character constant.");
+ return CHAR;
+
+ case '(':
+ paren_depth++;
+ lexptr++;
+ return c;
+
+ case ')':
+ if (paren_depth == 0)
+ return 0;
+ paren_depth--;
+ lexptr++;
+ return c;
+
+ case ',':
+ if (comma_terminates && paren_depth == 0)
+ return 0;
+ lexptr++;
+ return c;
+
+ case '+':
+ case '-':
+ case '*':
+ case '/':
+ case '%':
+ case '|':
+ case '&':
+ case '^':
+ case '~':
+ case '!':
+ case '@':
+ case '<':
+ case '>':
+ case '[':
+ case ']':
+ case '.':
+ case '?':
+ case ':':
+ case '=':
+ case '{':
+ case '}':
+ lexptr++;
+ return c;
+
+ case '"':
+ for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
+ if (c == '\\')
+ {
+ c = tokstart[++namelen];
+ if (c >= '0' && c <= '9')
+ {
+ c = tokstart[++namelen];
+ if (c >= '0' && c <= '9')
+ c = tokstart[++namelen];
+ }
+ }
+ yylval.sval.ptr = tokstart + 1;
+ yylval.sval.length = namelen - 1;
+ lexptr += namelen + 1;
+ return STRING;
+ }
+ if (c >= '0' && c <= '9')
+ {
+ /* It's a number */
+ for (namelen = 0;
+ c = tokstart[namelen],
+ (c == '_' || c == '$' || c == '.' || (c >= '0' && c <= '9')
+ || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
+ namelen++)
+ ;
+ return parse_number (namelen);
+ }
+
+ if (!(c == '_' || c == '$'
+ || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
+ error ("Invalid token in expression.");
+
+ /* It is a name. See how long it is. */
+
+ for (namelen = 0;
+ c = tokstart[namelen],
+ (c == '_' || c == '$' || (c >= '0' && c <= '9')
+ || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
+ namelen++)
+ ;
+
+ /* The token "if" terminates the expression and is NOT
+ removed from the input stream. */
+ if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
+ {
+ return 0;
+ }
+
+ lexptr += namelen;
+
+ /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
+ and $$digits (equivalent to $<-digits> if you could type that).
+ Make token type LAST, and put the number (the digits) in yylval. */
+
+ if (*tokstart == '$')
+ {
+ register int negate = 0;
+ c = 1;
+ /* Double dollar means negate the number and add -1 as well.
+ Thus $$ alone means -1. */
+ if (namelen >= 2 && tokstart[1] == '$')
+ {
+ negate = 1;
+ c = 2;
+ }
+ if (c == namelen)
+ {
+ /* Just dollars (one or two) */
+ yylval.lval = - negate;
+ return LAST;
+ }
+ /* Is the rest of the token digits? */
+ for (; c < namelen; c++)
+ if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
+ break;
+ if (c == namelen)
+ {
+ yylval.lval = atoi (tokstart + 1 + negate);
+ if (negate)
+ yylval.lval = - yylval.lval;
+ return LAST;
+ }
+ }
+
+ /* Handle tokens that refer to machine registers:
+ $ followed by a register name. */
+
+ if (*tokstart == '$')
+ for (c = 0; c < NUM_REGS; c++)
+ if (namelen - 1 == strlen (reg_names[c])
+ && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
+ {
+ yylval.lval = c;
+ return REGNAME;
+ }
+
+ if (namelen == 6 && !strncmp (tokstart, "struct", 6))
+ {
+ return STRUCT;
+ }
+ if (namelen == 5)
+ {
+ if (!strncmp (tokstart, "union", 5))
+ {
+ return UNION;
+ }
+ }
+ if (namelen == 4)
+ {
+ if (!strncmp (tokstart, "enum", 4))
+ {
+ return ENUM;
+ }
+ if (!strncmp (tokstart, "this", 4))
+ {
+ return THIS;
+ }
+ }
+ if (namelen == 6 && !strncmp (tokstart, "sizeof", 6))
+ {
+ return SIZEOF;
+ }
+ if (namelen == 8 && !strncmp (tokstart, "unsigned", 6))
+ {
+ return UNSIGNED;
+ }
+ yylval.sval.ptr = tokstart;
+ yylval.sval.length = namelen;
+
+ /* Any other names starting in $ are debugger internal variables. */
+
+ if (*tokstart == '$')
+ {
+ yylval.ivar = (struct internalvar *) lookup_internalvar (copy_name (yylval.sval) + 1);
+ return VARIABLE;
+ }
+
+ /* Use token-type TYPENAME for symbols that happen to be defined
+ currently as names of types; NAME for other symbols.
+ The caller is not constrained to care about the distinction. */
+ if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
+ return TYPENAME;
+ return NAME;
+}
+
+static
+yyerror ()
+{
+ error ("Invalid syntax in expression.");
+}
+
+/* Return a null-terminated temporary copy of the name
+ of a string token. */
+
+static char *
+copy_name (token)
+ struct stoken token;
+{
+ bcopy (token.ptr, namecopy, token.length);
+ namecopy[token.length] = 0;
+ return namecopy;
+}
+\f
+/* Reverse an expression from suffix form (in which it is constructed)
+ to prefix form (in which we can conveniently print or execute it). */
+
+static void prefixify_subexp ();
+
+static void
+prefixify_expression (expr)
+ register struct expression *expr;
+{
+ register int len = sizeof (struct expression) +
+ expr->nelts * sizeof (union exp_element);
+ register struct expression *temp;
+ register int inpos = expr->nelts, outpos = 0;
+
+ temp = (struct expression *) alloca (len);
+
+ /* Copy the original expression into temp. */
+ bcopy (expr, temp, len);
+
+ prefixify_subexp (temp, expr, inpos, outpos);
+}
+
+/* Return the number of exp_elements in the subexpression of EXPR
+ whose last exp_element is at index ENDPOS - 1 in EXPR. */
+
+static int
+length_of_subexp (expr, endpos)
+ register struct expression *expr;
+ register int endpos;
+{
+ register int oplen = 1;
+ register int args = 0;
+ register int i;
+
+ if (endpos < 0)
+ error ("?error in length_of_subexp");
+
+ i = (int) expr->elts[endpos - 1].opcode;
+
+ switch (i)
+ {
+ /* C++ */
+ case OP_SCOPE:
+ oplen = 4 + ((expr->elts[endpos - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+ break;
+
+ case OP_LONG:
+ case OP_DOUBLE:
+ oplen = 4;
+ break;
+
+ case OP_VAR_VALUE:
+ case OP_LAST:
+ case OP_REGISTER:
+ case OP_INTERNALVAR:
+ oplen = 3;
+ break;
+
+ case OP_FUNCALL:
+ oplen = 3;
+ args = 1 + expr->elts[endpos - 2].longconst;
+ break;
+
+ case UNOP_CAST:
+ case UNOP_MEMVAL:
+ oplen = 3;
+ args = 1;
+ break;
+
+ case STRUCTOP_STRUCT:
+ case STRUCTOP_PTR:
+ args = 1;
+ case OP_STRING:
+ oplen = 3 + ((expr->elts[endpos - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+ break;
+
+ case TERNOP_COND:
+ args = 3;
+ break;
+
+ case BINOP_ASSIGN_MODIFY:
+ oplen = 3;
+ args = 2;
+ break;
+
+ /* C++ */
+ case OP_THIS:
+ oplen = 2;
+ break;
+
+ default:
+ args = 1 + (i < (int) BINOP_END);
+ }
+
+ while (args > 0)
+ {
+ oplen += length_of_subexp (expr, endpos - oplen);
+ args--;
+ }
+
+ return oplen;
+}
+
+/* Copy the subexpression ending just before index INEND in INEXPR
+ into OUTEXPR, starting at index OUTBEG.
+ In the process, convert it from suffix to prefix form. */
+
+static void
+prefixify_subexp (inexpr, outexpr, inend, outbeg)
+ register struct expression *inexpr;
+ struct expression *outexpr;
+ register int inend;
+ int outbeg;
+{
+ register int oplen = 1;
+ register int args = 0;
+ register int i;
+ int *arglens;
+ enum exp_opcode opcode;
+
+ /* Compute how long the last operation is (in OPLEN),
+ and also how many preceding subexpressions serve as
+ arguments for it (in ARGS). */
+
+ opcode = inexpr->elts[inend - 1].opcode;
+ switch (opcode)
+ {
+ /* C++ */
+ case OP_SCOPE:
+ oplen = 4 + ((inexpr->elts[inend - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+ break;
+
+ case OP_LONG:
+ case OP_DOUBLE:
+ oplen = 4;
+ break;
+
+ case OP_VAR_VALUE:
+ case OP_LAST:
+ case OP_REGISTER:
+ case OP_INTERNALVAR:
+ oplen = 3;
+ break;
+
+ case OP_FUNCALL:
+ oplen = 3;
+ args = 1 + inexpr->elts[inend - 2].longconst;
+ break;
+
+ case UNOP_CAST:
+ case UNOP_MEMVAL:
+ oplen = 3;
+ args = 1;
+ break;
+
+ case STRUCTOP_STRUCT:
+ case STRUCTOP_PTR:
+ args = 1;
+ case OP_STRING:
+ oplen = 3 + ((inexpr->elts[inend - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+
+ break;
+
+ case TERNOP_COND:
+ args = 3;
+ break;
+
+ case BINOP_ASSIGN_MODIFY:
+ oplen = 3;
+ args = 2;
+ break;
+
+ /* C++ */
+ case OP_THIS:
+ oplen = 2;
+ break;
+
+ default:
+ args = 1 + ((int) opcode < (int) BINOP_END);
+ }
+
+ /* Copy the final operator itself, from the end of the input
+ to the beginning of the output. */
+ inend -= oplen;
+ bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
+ oplen * sizeof (union exp_element));
+ outbeg += oplen;
+
+ /* Find the lengths of the arg subexpressions. */
+ arglens = (int *) alloca (args * sizeof (int));
+ for (i = args - 1; i >= 0; i--)
+ {
+ oplen = length_of_subexp (inexpr, inend);
+ arglens[i] = oplen;
+ inend -= oplen;
+ }
+
+ /* Now copy each subexpression, preserving the order of
+ the subexpressions, but prefixifying each one.
+ In this loop, inend starts at the beginning of
+ the expression this level is working on
+ and marches forward over the arguments.
+ outbeg does similarly in the output. */
+ for (i = 0; i < args; i++)
+ {
+ oplen = arglens[i];
+ inend += oplen;
+ prefixify_subexp (inexpr, outexpr, inend, outbeg);
+ outbeg += oplen;
+ }
+}
+\f
+/* This page contains the two entry points to this file. */
+
+/* Read a C expression from the string *STRINGPTR points to,
+ parse it, and return a pointer to a struct expression that we malloc.
+ Use block BLOCK as the lexical context for variable names;
+ if BLOCK is zero, use the block of the selected stack frame.
+ Meanwhile, advance *STRINGPTR to point after the expression,
+ at the first nonwhite character that is not part of the expression
+ (possibly a null character).
+
+ If COMMA is nonzero, stop if a comma is reached. */
+
+struct expression *
+parse_c_1 (stringptr, block, comma)
+ char **stringptr;
+ struct block *block;
+{
+ struct cleanup *old_chain;
+
+ lexptr = *stringptr;
+
+ comma_terminates = comma;
+
+ if (lexptr == 0 || *lexptr == 0)
+ error_no_arg ("expression to compute");
+
+ old_chain = make_cleanup (free_funcalls, 0);
+ funcall_chain = 0;
+
+ expression_context_block = block ? block : get_selected_block ();
+
+ namecopy = (char *) alloca (strlen (lexptr) + 1);
+ expout_size = 10;
+ expout_ptr = 0;
+ expout = (struct expression *) xmalloc (sizeof (struct expression)
+ + expout_size * sizeof (union exp_element));
+ make_cleanup (free_current_contents, &expout);
+ if (yyparse ())
+ yyerror ();
+ discard_cleanups (old_chain);
+ expout->nelts = expout_ptr;
+ expout = (struct expression *)
+ xrealloc (expout,
+ sizeof (struct expression)
+ + expout_ptr * sizeof (union exp_element));
+ prefixify_expression (expout);
+ *stringptr = lexptr;
+ return expout;
+}
+
+/* Parse STRING as an expression, and complain if this fails
+ to use up all of the contents of STRING. */
+
+struct expression *
+parse_c_expression (string)
+ char *string;
+{
+ register struct expression *exp;
+ exp = parse_c_1 (&string, 0, 0);
+ if (*string)
+ error ("Junk after end of expression.");
+ return exp;
+}
struct block *bval;
enum exp_opcode opcode;
struct internalvar *ivar;
+
+ struct type **tvec;
+ int *ivec;
}
%type <voidval> exp exp1 start variable
%type <tval> type typebase
+%type <tvec> nonempty_typelist
%type <bval> block
%token <lval> INT CHAR
%token <opcode> ASSIGN_MODIFY
+/* C++ */
+%token THIS
+
%left ','
%left ABOVE_COMMA
%right '=' ASSIGN_MODIFY
write_exp_elt (STRUCTOP_PTR); }
;
+exp : exp ARROW '*' exp
+ { write_exp_elt (STRUCTOP_MPTR); }
+ ;
+
exp : exp '.' name
{ write_exp_elt (STRUCTOP_STRUCT);
write_exp_string ($3);
write_exp_elt (STRUCTOP_STRUCT); }
;
+exp : exp '.' '*' exp
+ { write_exp_elt (STRUCTOP_MEMBER); }
+ ;
+
exp : exp '[' exp1 ']'
{ write_exp_elt (BINOP_SUBSCRIPT); }
;
write_exp_elt (OP_STRING); }
;
+/* C++. */
+exp : THIS
+ { write_exp_elt (OP_THIS);
+ write_exp_elt (OP_THIS); }
+ ;
+
+/* end of C++. */
+
block : name
- { struct symtab *tem = lookup_symtab (copy_name ($1));
+ {
+ struct symtab *tem = lookup_symtab (copy_name ($1));
struct symbol *sym;
if (tem)
else
error ("No file or function \"%s\".",
copy_name ($1));
- }}
+ }
+ }
;
block : block COLONCOLON name
- { struct symbol *tem
+ {
+ struct symbol *tem
= lookup_symbol (copy_name ($3), $1, VAR_NAMESPACE);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
- copy_name ($3));
- $$ = SYMBOL_BLOCK_VALUE (tem); }
+ copy_name ($1));
+ $$ = SYMBOL_BLOCK_VALUE (tem);
+ }
;
variable: block COLONCOLON name
- { struct symbol *sym;
- sym = lookup_symbol ($3, copy_name ($1), VAR_NAMESPACE);
+ {
+ struct symbol *sym;
+ sym = lookup_symbol (copy_name ($3), $1, VAR_NAMESPACE);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name ($3));
write_exp_elt (OP_VAR_VALUE);
write_exp_elt (sym);
- write_exp_elt (OP_VAR_VALUE); }
+ write_exp_elt (OP_VAR_VALUE);
+ }
+ ;
+
+variable: typebase COLONCOLON name
+ {
+ struct type *type = $1;
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION)
+ error ("`%s' is not defined as an aggregate type.",
+ TYPE_NAME (type));
+
+ write_exp_elt (OP_SCOPE);
+ write_exp_elt (type);
+ write_exp_string ($3);
+ write_exp_elt (OP_SCOPE);
+ }
+ | COLONCOLON name
+ {
+ char *name = copy_name ($2);
+ struct symbol *sym;
+ int i;
+
+ sym = lookup_symbol_2 (name, 0, VAR_NAMESPACE);
+ if (sym)
+ {
+ write_exp_elt (OP_VAR_VALUE);
+ write_exp_elt (sym);
+ write_exp_elt (OP_VAR_VALUE);
+ break;
+ }
+ for (i = 0; i < misc_function_count; i++)
+ if (!strcmp (misc_function_vector[i].name, name))
+ break;
+
+ if (i < misc_function_count)
+ {
+ write_exp_elt (OP_LONG);
+ write_exp_elt (builtin_type_int);
+ write_exp_elt (misc_function_vector[i].address);
+ write_exp_elt (OP_LONG);
+ write_exp_elt (UNOP_MEMVAL);
+ write_exp_elt (builtin_type_char);
+ write_exp_elt (UNOP_MEMVAL);
+ }
+ else
+ if (symtab_list == 0)
+ error ("No symbol table is loaded. Use the \"symbol-file\" command.");
+ else
+ error ("No symbol \"%s\" in current context.", name);
+ }
;
variable: NAME
{ struct symbol *sym;
- sym = lookup_symbol (copy_name ($1),
- expression_context_block,
- VAR_NAMESPACE);
+ sym = lookup_symbol_1 (copy_name ($1),
+ expression_context_block,
+ VAR_NAMESPACE);
if (sym)
{
write_exp_elt (OP_VAR_VALUE);
{
register char *arg = copy_name ($1);
register int i;
+ int v, val;
+ /* C++: see if it hangs off of `this'. Must
+ not inadvertently convert from a method call
+ to data ref. */
+ v = (int)value_of_this (0);
+ if (v)
+ {
+ val = check_field (v, arg);
+ if (val)
+ {
+ write_exp_elt (OP_THIS);
+ write_exp_elt (OP_THIS);
+ write_exp_elt (STRUCTOP_PTR);
+ write_exp_string ($1);
+ write_exp_elt (STRUCTOP_PTR);
+ break;
+ }
+ }
+ sym = lookup_symbol_2 (arg, 0, VAR_NAMESPACE);
+ if (sym)
+ {
+ write_exp_elt (OP_VAR_VALUE);
+ write_exp_elt (sym);
+ write_exp_elt (OP_VAR_VALUE);
+ break; /* YACC-dependent */
+ }
for (i = 0; i < misc_function_count; i++)
if (!strcmp (misc_function_vector[i].name, arg))
break;
type : typebase
| type '*'
{ $$ = lookup_pointer_type ($1); }
+ | type '&'
+ { $$ = lookup_reference_type ($1); }
+ | typebase COLONCOLON '*'
+ { $$ = lookup_member_pointer_type (builtin_type_int, $1); }
+ | type '(' typebase COLONCOLON '*' ')'
+ { $$ = lookup_member_pointer_type ($1, $3); }
+ | type '(' typebase COLONCOLON '*' ')' '(' ')'
+ { $$ = lookup_member_pointer_type (lookup_function_type ($1, 0), $3); }
+ | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
+ { $$ = lookup_member_pointer_type (lookup_function_type ($1, $8), $3);
+ free ($8); }
;
typebase
{ $$ = lookup_unsigned_typename (copy_name ($2)); }
;
+nonempty_typelist
+ : type
+ { $$ = (struct type **)xmalloc (sizeof (struct type *) * 2);
+ $$[0] = (struct type *)0;
+ $$[1] = $1;
+ }
+ | nonempty_typelist ',' type
+ { int len = sizeof (struct type *) * ++($<ivec>1[0]);
+ $$ = (struct type **)xrealloc ($1, len);
+ $$[$<ivec>$[0]] = $3;
+ }
+ ;
+
name : NAME
| TYPENAME
;
static char *namecopy;
+/* Current depth in parentheses within the expression. */
+
+static int paren_depth;
+
+/* Nonzero means stop parsing on first comma (if not within parentheses). */
+
+static int comma_terminates;
+
/* Take care of parsing a number (anything that starts with a digit).
Set yylval and return the token type; update lexptr.
LEN is the number of characters in it. */
error ("Invalid character constant.");
return CHAR;
+ case '(':
+ paren_depth++;
+ lexptr++;
+ return c;
+
+ case ')':
+ if (paren_depth == 0)
+ return 0;
+ paren_depth--;
+ lexptr++;
+ return c;
+
+ case ',':
+ if (comma_terminates && paren_depth == 0)
+ return 0;
+ lexptr++;
+ return c;
+
case '+':
case '-':
case '*':
case '@':
case '<':
case '>':
- case '(':
- case ')':
case '[':
case ']':
case '.':
case '=':
case '{':
case '}':
- case ',':
lexptr++;
return c;
{
return STRUCT;
}
- if (namelen == 5 && !strncmp (tokstart, "union", 5))
+ if (namelen == 5)
{
- return UNION;
+ if (!strncmp (tokstart, "union", 5))
+ {
+ return UNION;
+ }
}
- if (namelen == 4 && !strncmp (tokstart, "enum", 4))
+ if (namelen == 4)
{
- return ENUM;
+ if (!strncmp (tokstart, "enum", 4))
+ {
+ return ENUM;
+ }
+ if (!strncmp (tokstart, "this", 4))
+ {
+ return THIS;
+ }
}
if (namelen == 6 && !strncmp (tokstart, "sizeof", 6))
{
register int args = 0;
register int i;
+ if (endpos < 0)
+ error ("?error in length_of_subexp");
+
i = (int) expr->elts[endpos - 1].opcode;
switch (i)
{
+ /* C++ */
+ case OP_SCOPE:
+ oplen = 4 + ((expr->elts[endpos - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+ break;
+
case OP_LONG:
case OP_DOUBLE:
oplen = 4;
oplen = 3 + ((expr->elts[endpos - 2].longconst
+ sizeof (union exp_element))
/ sizeof (union exp_element));
-
break;
case TERNOP_COND:
args = 2;
break;
+ /* C++ */
+ case OP_THIS:
+ oplen = 2;
+ break;
+
default:
args = 1 + (i < (int) BINOP_END);
}
opcode = inexpr->elts[inend - 1].opcode;
switch (opcode)
{
+ /* C++ */
+ case OP_SCOPE:
+ oplen = 4 + ((inexpr->elts[inend - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+ break;
+
case OP_LONG:
case OP_DOUBLE:
oplen = 4;
args = 2;
break;
+ /* C++ */
+ case OP_THIS:
+ oplen = 2;
+ break;
+
default:
args = 1 + ((int) opcode < (int) BINOP_END);
}
if BLOCK is zero, use the block of the selected stack frame.
Meanwhile, advance *STRINGPTR to point after the expression,
at the first nonwhite character that is not part of the expression
- (possibly a null character). */
+ (possibly a null character).
+
+ If COMMA is nonzero, stop if a comma is reached. */
struct expression *
-parse_c_1 (stringptr, block)
+parse_c_1 (stringptr, block, comma)
char **stringptr;
struct block *block;
{
lexptr = *stringptr;
+ comma_terminates = comma;
+
if (lexptr == 0 || *lexptr == 0)
error_no_arg ("expression to compute");
char *string;
{
register struct expression *exp;
- exp = parse_c_1 (&string, 0);
+ exp = parse_c_1 (&string, 0, 0);
if (*string)
error ("Junk after end of expression.");
return exp;
BINOP_COMMA, /* , */
BINOP_SUBSCRIPT, /* x[y] */
BINOP_EXP, /* Exponentiation */
+
+/* C++. */
+ BINOP_SCOPE, /* :: */
+
+ /* STRUCTOP_MEMBER is used for pointer-to-member constructs.
+ X . * Y translates into X STRUCTOP_MEMBER Y. */
+ STRUCTOP_MEMBER,
+ /* STRUCTOP_MPTR is used for pointer-to-member constructs
+ when X is a pointer instead of an aggregate. */
+ STRUCTOP_MPTR,
+/* end of C++. */
+
BINOP_END,
BINOP_ASSIGN_MODIFY, /* +=, -=, *=, and so on.
(after the string), followed by another STRUCTOP_... code. */
STRUCTOP_STRUCT,
STRUCTOP_PTR,
+
+/* C++ */
+ /* OP_THIS is just a placeholder for the class instance variable.
+ It just comes in a tight (OP_THIS, OP_THIS) pair. */
+ OP_THIS,
+
+ /* OP_SCOPE surrounds a type name and a field name. The type
+ name is encoded as one element, but the field name stays as
+ a string, which, of course, is variable length. */
+ OP_SCOPE,
+
};
union exp_element
register int len;
if (SYMBOL_CLASS (var) == LOC_BLOCK)
- type = lookup_function_type (type);
+ type = lookup_function_type (type, 0);
v = allocate_value (type);
VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
test.i = 1;
if (test.c != 1 && len < REGISTER_RAW_SIZE (val))
/* Big-endian, and we want less than full size. */
- addr+ = REGISTER_RAW_SIZE (val) - len;
+ addr += REGISTER_RAW_SIZE (val) - len;
break;
}
error ("Address requested for identifier \"%s\" which is in a register.",
that in whole or in part contains or is a derivative of this
program or any part thereof, to be licensed at no charge to all
third parties on terms identical to those contained in this
- License Agreement (except that you may choose to grant more
- extensive warranty protection to third parties, at your option).
+ License Agreement (except that you may choose to grant more extensive
+ warranty protection to some or all third parties, at your option).
c) You may charge a distribution fee for the physical act of
transferring a copy, and you may at your option offer warranty
protection in exchange for a fee.
- 3. You may copy and distribute this program or any portion of it in
-compiled, executable or object code form under the terms of Paragraphs
-1 and 2 above provided that you do the following:
-
- a) cause each such copy to be accompanied by the
- corresponding machine-readable source code, which must
- be distributed under the terms of Paragraphs 1 and 2 above; or,
-
- b) cause each such copy to be accompanied by a
- written offer, with no time limit, to give any third party
- free (except for a nominal shipping charge) a machine readable
- copy of the corresponding source code, to be distributed
- under the terms of Paragraphs 1 and 2 above; or,
-
- c) in the case of a recipient of this program in compiled, executable
- or object code form (without the corresponding source code) you
- shall cause copies you distribute to be accompanied by a copy
- of the written offer of source code which you received along
- with the copy you received.
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+ 3. You may copy and distribute this program (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the following:
+
+ a) accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ b) accompany it with a written offer, valid for at least three
+ years, to give any third party free (except for a nominal
+ shipping charge) a complete machine-readable copy of the
+ corresponding source code, to be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ c) accompany it with the information you received as to where the
+ corresponding source code may be obtained. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
4. You may not copy, sublicense, distribute or transfer this program
except as expressly provided under this License Agreement. Any attempt
+++ /dev/null
-main() {
- int i;
-
- for (i = 0; i >= 0; i++)
- bar();
-}
-
-bar()
-{
- int i;
-
- i = 10;
-}
+++ /dev/null
-
-
-Symbols from foo:
-
-Name Value Class Type Size Line Section
-
-crt0.s | | file | | | |
-foo.c | | file | | | |
-main | 228|extern| int( )| 66| |.text
-.bf | 228|fcn | | | 1|.text
-i | -4|auto | int| | |
-.ef | 274|fcn | | | 6|.text
-bar | 294|extern| int( )| 50| |.text
-.bf | 294|fcn | | | 9|.text
-i | -4|auto | int| | |
-.ef | 324|fcn | | | 5|.text
-dbxxx.s | | file | | | |
-initfpu.s | | file | | | |
-cuexit.s | | file | | | |
-fakcu.c | | file | | | |
-_cleanup | 404|extern| ( )| 42| |.text
-.bf | 404|fcn | | | 23|.text
-.ef | 426|fcn | | | 2|.text
-_ac_r | 4194760|static| *char| | |.data
-copyright.c | | file | | | |
-_ac_r | 4194764|static| *char| | |.data
-_start | 168|extern| | | |.text
-_dbargs | 4195016|extern| | | |.bss
-exit | 388|extern| | | |.text
-initfpu | 380|extern| | | |.text
-environ | 4194756|extern| | | |.data
-splimit% | 4194752|extern| | | |.data
-_dbsubc | 344|extern| | | |.text
-_dbsubn | 376|extern| | | |.text
-_ac_s | 4194768|extern| char[0]| | |.data
-etext | 448|extern| | | |
-edata | 4195016|extern| | | |
-end | 4195528|extern| | | |
-_sorigin | 4195528|extern| | | |
+++ /dev/null
-0000000 0150 0003 21fc 7629 0000 0310 0000 0032
- 001 P \0 003 ! 374 v ) \0 \0 003 020 \0 \0 \0 2
-0000020 001c 0103 010b 0000 0000 0118 0000 0108
- \0 034 001 003 001 013 \0 \0 \0 \0 001 030 \0 \0 001 \b
-0000040 0000 0200 0000 00a8 0000 00a8 0040 01c0
- \0 \0 002 \0 \0 \0 \0 250 \0 \0 \0 250 \0 @ 001 300
-0000060 2e74 6578 7400 0000 0000 00a8 0000 00a8
- . t e x t \0 \0 \0 \0 \0 \0 250 \0 \0 \0 250
-0000100 0000 0118 0000 00a8 0000 0000 0000 02c8
- \0 \0 001 030 \0 \0 \0 250 \0 \0 \0 \0 \0 \0 002 310
-0000120 0000 000c 0000 0020 2e64 6174 6100 0000
- \0 \0 \0 \f \0 \0 \0 . d a t a \0 \0 \0
-0000140 0040 01c0 0040 01c0 0000 0108 0000 01c0
- \0 @ 001 300 \0 @ 001 300 \0 \0 001 \b \0 \0 001 300
-0000160 0000 0000 0000 0000 0000 0000 0000 0040
- \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 @
-0000200 2e62 7373 0000 0000 0040 02c8 0040 02c8
- . b s s \0 \0 \0 \0 \0 @ 002 310 \0 @ 002 310
-0000220 0000 0200 0000 0000 0000 0000 0000 0000
- \0 \0 002 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
-0000240 0000 0000 0000 0080 23c0 0040 01c0 518f
- \0 \0 \0 \0 \0 \0 \0 200 # 300 \0 @ 001 300 Q 217
-0000260 2eaf 0008 41ef 000c 2f48 0004 2248 4a98
- . 257 \0 \b A 357 \0 \f / H \0 004 " H J 230
-0000300 66fc 2f48 0008 23c8 0040 01c4 4eb9 0000
- f 374 / H \0 \b # 310 \0 @ 001 304 N 271 \0 \0
-0000320 017c 4eb9 0000 00e4 2e80 4eb9 0000 0184
- 001 | N 271 \0 \0 \0 344 . 200 N 271 \0 \0 001 204
-0000340 7001 4e40 480e ffff fff8 48ef 0000 0004
- p 001 N @ H 016 377 377 377 370 H 357 \0 \0 \0 004
-0000360 f237 f000 0170 0000 0004 42ae fffc 4aae
- 362 7 360 \0 001 p \0 \0 \0 004 B 256 377 374 J 256
-0000400 fffc 6d00 000e 4eba 001e 52ae fffc 6000
- 377 374 m \0 \0 016 N 272 \0 036 R 256 377 374 ` \0
-0000420 ffee 4cef 0000 0004 f237 d000 0170 0000
- 377 356 L 357 \0 \0 \0 004 362 7 320 \0 001 p \0 \0
-0000440 0004 4e5e 4e75 480e ffff fff8 48ef 0000
- \0 004 N ^ N u H 016 377 377 377 370 H 357 \0 \0
-0000460 0004 f237 f000 0170 0000 0004 2d7c 0000
- \0 004 362 7 360 \0 001 p \0 \0 \0 004 - | \0 \0
-0000500 000a fffc 4cef 0000 0004 f237 d000 0170
- \0 \n 377 374 L 357 \0 \0 \0 004 362 7 320 \0 001 p
-0000520 0000 0004 4e5e 4e75 4e56 0000 207c 0040
- \0 \0 \0 004 N ^ N u N V \0 \0 | \0 @
-0000540 02c8 2258 2018 2200 e581 d1c1 6002 2f20
- 002 310 " X 030 " \0 345 201 321 301 ` 002 /
-0000560 51c8 fffc 4e91 4e5e 4e41 4e71 4e56 fffc
- Q 310 377 374 N 221 N ^ N A N q N V 377 374
-0000600 4e5e 4e75 4eb9 0000 0194 7001 4e40 4e72
- N ^ N u N 271 \0 \0 001 224 p 001 N @ N r
-0000620 0000 4e71 480e ffff fffc 48ef 0000 0004
- \0 \0 N q H 016 377 377 377 374 H 357 \0 \0 \0 004
-0000640 f237 f000 0170 0000 0004 4cef 0000 0004
- 362 7 360 \0 001 p \0 \0 \0 004 L 357 \0 \0 \0 004
-0000660 f237 d000 0170 0000 0004 4e5e 4e75 4e71
- 362 7 320 \0 001 p \0 \0 \0 004 N ^ N u N q
-0000700 0000 0000 0000 0000 0040 01d0 0040 01d0
- \0 \0 \0 \0 \0 \0 \0 \0 \0 @ 001 320 \0 @ 001 320
-0000720 436f 7079 7269 6768 7420 2863 2920 3139
- C o p y r i g h t ( c ) 1 9
-0000740 3837 2041 7070 6c65 2043 6f6d 7075 7465
- 8 7 A p p l e C o m p u t e
-0000760 722c 2049 6e63 2e2c 2031 3938 3520 4164
- r , I n c . , 1 9 8 5 A d
-0001000 6f62 6520 5379 7374 656d 7320 496e 636f
- o b e S y s t e m s I n c o
-0001020 7270 6f72 6174 6564 2c20 3139 3833 2d38
- r p o r a t e d , 1 9 8 3 - 8
-0001040 3720 4154 2654 2d49 532c 2031 3938 352d
- 7 A T & T - I S , 1 9 8 5 -
-0001060 3837 204d 6f74 6f72 6f6c 6120 496e 632e
- 8 7 M o t o r o l a I n c .
-0001100 2c20 3139 3830 2d38 3720 5375 6e20 4d69
- , 1 9 8 0 - 8 7 S u n M i
-0001120 6372 6f73 7973 7465 6d73 2049 6e63 2e2c
- c r o s y s t e m s I n c . ,
-0001140 2031 3938 302d 3837 2054 6865 2052 6567
- 1 9 8 0 - 8 7 T h e R e g
-0001160 656e 7473 206f 6620 7468 6520 556e 6976
- e n t s o f t h e U n i v
-0001200 6572 7369 7479 206f 6620 4361 6c69 666f
- e r s i t y o f C a l i f o
-0001220 726e 6961 2c20 3139 3835 2d38 3720 556e
- r n i a , 1 9 8 5 - 8 7 U n
-0001240 6973 6f66 7420 436f 7270 6f72 6174 696f
- i s o f t C o r p o r a t i o
-0001260 6e2c 2041 6c6c 2052 6967 6874 7320 5265
- n , A l l R i g h t s R e
-0001300 7365 7276 6564 2e00 0000 0004 0000 0000
- s e r v e d . \0 \0 \0 \0 004 \0 \0 \0 \0
-0001320 00e4 0001 0000 00fa 0004 0000 0106 0005
- \0 344 \0 001 \0 \0 \0 372 \0 004 \0 \0 001 006 \0 005
-0001340 0000 0112 0006 0000 000b 0000 0000 0126
- \0 \0 001 022 \0 006 \0 \0 \0 013 \0 \0 \0 \0 001 &
-0001360 0001 0000 013c 0004 0000 0144 0005 0000
- \0 001 \0 \0 001 < \0 004 \0 \0 001 D \0 005 \0 \0
-0001400 001a 0000 0000 0194 0001 0000 01aa 0002
- \0 032 \0 \0 \0 \0 001 224 \0 001 \0 \0 001 252 \0 002
-0001420 2e66 696c 6500 0000 0000 0002 fffe 0000
- . f i l e \0 \0 \0 \0 \0 \0 002 377 376 \0 \0
-0001440 6701 6372 7430 2e73 0000 0000 0000 0000
- g 001 c r t 0 . s \0 \0 \0 \0 \0 \0 \0 \0
-0001460 0000 0000 2e66 696c 6500 0000 0000 0012
- \0 \0 \0 \0 . f i l e \0 \0 \0 \0 \0 \0 022
-0001500 fffe 0000 6701 666f 6f2e 6300 0000 0000
- 377 376 \0 \0 g 001 f o o . c \0 \0 \0 \0 \0
-0001520 0000 0000 0000 0000 6d61 696e 0000 0000
- \0 \0 \0 \0 \0 \0 \0 \0 m a i n \0 \0 \0 \0
-0001540 0000 00e4 0001 0024 0201 0000 0000 0000
- \0 \0 \0 344 \0 001 \0 $ 002 001 \0 \0 \0 \0 \0 \0
-0001560 0042 0000 02c8 0000 000b 0000 2e62 6600
- \0 B \0 \0 002 310 \0 \0 \0 013 \0 \0 . b f \0
-0001600 0000 0000 0000 00e4 0001 0000 6501 0000
- \0 \0 \0 \0 \0 \0 \0 344 \0 001 \0 \0 e 001 \0 \0
-0001620 0000 0001 0000 0000 0000 0000 0000 0000
- \0 \0 \0 001 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
-0001640 6900 0000 0000 0000 ffff fffc ffff 0004
- i \0 \0 \0 \0 \0 \0 \0 377 377 377 374 377 377 \0 004
-0001660 0100 2e65 6600 0000 0000 0000 0112 0001
- 001 \0 . e f \0 \0 \0 \0 \0 \0 \0 001 022 \0 001
-0001700 0000 6501 0000 0000 0006 0000 0000 0000
- \0 \0 e 001 \0 \0 \0 \0 \0 006 \0 \0 \0 \0 \0 \0
-0001720 0000 0000 0000 6261 7200 0000 0000 0000
- \0 \0 \0 \0 \0 \0 b a r \0 \0 \0 \0 \0 \0 \0
-0001740 0126 0001 0024 0201 0000 0000 0000 0032
- 001 & \0 001 \0 $ 002 001 \0 \0 \0 \0 \0 \0 \0 2
-0001760 0000 02e6 0000 0012 0000 2e62 6600 0000
- \0 \0 002 346 \0 \0 \0 022 \0 \0 . b f \0 \0 \0
-0002000 0000 0000 0126 0001 0000 6501 0000 0000
- \0 \0 \0 \0 001 & \0 001 \0 \0 e 001 \0 \0 \0 \0
-0002020 0009 0000 0000 0000 0000 0000 0000 6900
- \0 \t \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 i \0
-0002040 0000 0000 0000 ffff fffc ffff 0004 0100
- \0 \0 \0 \0 \0 \0 377 377 377 374 377 377 \0 004 001 \0
-0002060 2e65 6600 0000 0000 0000 0144 0001 0000
- . e f \0 \0 \0 \0 \0 \0 \0 001 D \0 001 \0 \0
-0002100 6501 0000 0000 0005 0000 0000 0000 0000
- e 001 \0 \0 \0 \0 \0 005 \0 \0 \0 \0 \0 \0 \0 \0
-0002120 0000 0000 2e66 696c 6500 0000 0000 0014
- \0 \0 \0 \0 . f i l e \0 \0 \0 \0 \0 \0 024
-0002140 fffe 0000 6701 6462 7878 782e 7300 0000
- 377 376 \0 \0 g 001 d b x x x . s \0 \0 \0
-0002160 0000 0000 0000 0000 2e66 696c 6500 0000
- \0 \0 \0 \0 \0 \0 \0 \0 . f i l e \0 \0 \0
-0002200 0000 0016 fffe 0000 6701 696e 6974 6670
- \0 \0 \0 026 377 376 \0 \0 g 001 i n i t f p
-0002220 752e 7300 0000 0000 0000 0000 2e66 696c
- u . s \0 \0 \0 \0 \0 \0 \0 \0 \0 . f i l
-0002240 6500 0000 0000 0018 fffe 0000 6701 6375
- e \0 \0 \0 \0 \0 \0 030 377 376 \0 \0 g 001 c u
-0002260 6578 6974 2e73 0000 0000 0000 0000 0000
- e x i t . s \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
-0002300 2e66 696c 6500 0000 0000 0021 fffe 0000
- . f i l e \0 \0 \0 \0 \0 \0 ! 377 376 \0 \0
-0002320 6701 6661 6b63 752e 6300 0000 0000 0000
- g 001 f a k c u . c \0 \0 \0 \0 \0 \0 \0
-0002340 0000 0000 5f63 6c65 616e 7570 0000 0194
- \0 \0 \0 \0 _ c l e a n u p \0 \0 001 224
-0002360 0001 0020 0201 0000 0000 0000 002a 0000
- \0 001 \0 002 001 \0 \0 \0 \0 \0 \0 \0 * \0 \0
-0002400 02fe 0000 0020 0000 2e62 6600 0000 0000
- 002 376 \0 \0 \0 \0 \0 . b f \0 \0 \0 \0 \0
-0002420 0000 0194 0001 0000 6501 0000 0000 0017
- \0 \0 001 224 \0 001 \0 \0 e 001 \0 \0 \0 \0 \0 027
-0002440 0000 0000 0000 0000 0000 0000 2e65 6600
- \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 . e f \0
-0002460 0000 0000 0000 01aa 0001 0000 6501 0000
- \0 \0 \0 \0 \0 \0 001 252 \0 001 \0 \0 e 001 \0 \0
-0002500 0000 0002 0000 0000 0000 0000 0000 0000
- \0 \0 \0 002 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
-0002520 5f61 635f 7200 0000 0040 01c8 0002 0012
- _ a c _ r \0 \0 \0 \0 @ 001 310 \0 002 \0 022
-0002540 0300 2e66 696c 6500 0000 0000 0024 fffe
- 003 \0 . f i l e \0 \0 \0 \0 \0 \0 $ 377 376
-0002560 0000 6701 636f 7079 7269 6768 742e 6300
- \0 \0 g 001 c o p y r i g h t . c \0
-0002600 0000 0000 0000 5f61 635f 7200 0000 0040
- \0 \0 \0 \0 \0 \0 _ a c _ r \0 \0 \0 \0 @
-0002620 01cc 0002 0012 0300 5f73 7461 7274 0000
- 001 314 \0 002 \0 022 003 \0 _ s t a r t \0 \0
-0002640 0000 00a8 0001 0000 0200 5f64 6261 7267
- \0 \0 \0 250 \0 001 \0 \0 002 \0 _ d b a r g
-0002660 7300 0040 02c8 0003 0000 0200 6578 6974
- s \0 \0 @ 002 310 \0 003 \0 \0 002 \0 e x i t
-0002700 0000 0000 0000 0184 0001 0000 0200 696e
- \0 \0 \0 \0 \0 \0 001 204 \0 001 \0 \0 002 \0 i n
-0002720 6974 6670 7500 0000 017c 0001 0000 0200
- i t f p u \0 \0 \0 001 | \0 001 \0 \0 002 \0
-0002740 656e 7669 726f 6e00 0040 01c4 0002 0000
- e n v i r o n \0 \0 @ 001 304 \0 002 \0 \0
-0002760 0200 7370 6c69 6d69 7425 0040 01c0 0002
- 002 \0 s p l i m i t % \0 @ 001 300 \0 002
-0003000 0000 0200 5f64 6273 7562 6300 0000 0158
- \0 \0 002 \0 _ d b s u b c \0 \0 \0 001 X
-0003020 0001 0000 0200 5f64 6273 7562 6e00 0000
- \0 001 \0 \0 002 \0 _ d b s u b n \0 \0 \0
-0003040 0178 0001 0000 0200 5f61 635f 7300 0000
- 001 x \0 001 \0 \0 002 \0 _ a c _ s \0 \0 \0
-0003060 0040 01d0 0002 0032 0201 0000 0000 0000
- \0 @ 001 320 \0 002 \0 2 002 001 \0 \0 \0 \0 \0 \0
-0003100 0000 0000 0000 0000 0000 0000 6574 6578
- \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 e t e x
-0003120 7400 0000 0000 01c0 ffff 0000 0200 6564
- t \0 \0 \0 \0 \0 001 300 377 377 \0 \0 002 \0 e d
-0003140 6174 6100 0000 0040 02c8 ffff 0000 0200
- a t a \0 \0 \0 \0 @ 002 310 377 377 \0 \0 002 \0
-0003160 656e 6400 0000 0000 0040 04c8 ffff 0000
- e n d \0 \0 \0 \0 \0 \0 @ 004 310 377 377 \0 \0
-0003200 0200 5f73 6f72 6967 696e 0040 04c8 ffff
- 002 \0 _ s o r i g i n \0 @ 004 310 377 377
-0003220 0000 0200
- \0 \0 002 \0
-0003224
+++ /dev/null
- file "foo.c"
- data 1
- text
- def main; val main; scl 2; type 044; endef
- global main
-main:
- ln 1
- def ~bf; val ~; scl 101; line 1; endef
- link.l %fp,&F%1
- movm.l &M%1,(4,%sp)
- fmovm &FPM%1,(FPO%1,%sp)
- def i; val -4+S%1; scl 1; type 04; endef
- ln 4
- clr.l ((S%1-4).w,%fp)
-L%15:
- tst.l ((S%1-4).w,%fp)
- blt L%14
- ln 5
- jsr bar
-L%13:
- add.l &1,((S%1-4).w,%fp)
- bra L%15
-L%14:
-L%12:
- def ~ef; val ~; scl 101; line 6; endef
- ln 6
- movm.l (4,%sp),&M%1
- fmovm (FPO%1,%sp),&FPM%1
- unlk %fp
- rts
- def main; val ~; scl -1; endef
- set S%1,0
- set T%1,0
- set F%1,-8
- set FPO%1,4
- set FPM%1,0x0000
- set M%1,0x0000
- data 1
- text
- def bar; val bar; scl 2; type 044; endef
- global bar
-bar:
- ln 1
- def ~bf; val ~; scl 101; line 9; endef
- link.l %fp,&F%2
- movm.l &M%2,(4,%sp)
- fmovm &FPM%2,(FPO%2,%sp)
- def i; val -4+S%2; scl 1; type 04; endef
- ln 4
- mov.l &10,((S%2-4).w,%fp)
-L%17:
- def ~ef; val ~; scl 101; line 5; endef
- ln 5
- movm.l (4,%sp),&M%2
- fmovm (FPO%2,%sp),&FPM%2
- unlk %fp
- rts
- def bar; val ~; scl -1; endef
- set S%2,0
- set T%2,0
- set F%2,-8
- set FPO%2,4
- set FPM%2,0x0000
- set M%2,0x0000
- data 1
+++ /dev/null
-Symtab for file _globals_
-
-Line table:
-
-
-Blockvector:
-
-block #000 (object 0x41a5cc) [0x0..0x0]
- char _ac_s[0]; static at 0x4001d0,
- int _dbargs; static at 0x4002c8,
- int environ; static at 0x4001c4,
- int splimit%; static at 0x4001c0,
- block #001 (object 0x41a5a8) [0x0..0x0] (under 0x41a5cc)
-
-
-Symtab for file copyright.c
-
-Line table:
-
-
-Blockvector:
-
-block #000 (object 0x41a460) [0x0..0x0]
- block #001 (object 0x41a444) [0x0..0x0] (under 0x41a460)
- char *_ac_r; static at 0x4001cc,
-
-
-Symtab for file fakcu.c
-
-Line table:
-
- line 23 at 194
- line 24 at 1aa
-
-Blockvector:
-
-block #000 (object 0x41a3f0) [0x0..0x0]
- void _cleanup; block (object 0x41a380) starting at 0x194,
- block #001 (object 0x41a3d4) [0x0..0x0] (under 0x41a3f0)
- char *_ac_r; static at 0x4001c8,
- block #002 (object 0x41a380) [0x194..0x1b0] (under 0x41a3d4) _cleanup
-
-
-Symtab for file cuexit.s
-
-Line table:
-
-
-Blockvector:
-
-block #000 (object 0x41f210) [0x0..0x0]
- block #001 (object 0x41f1ec) [0x0..0x0] (under 0x41f210)
-
-
-Symtab for file initfpu.s
-
-Line table:
-
-
-Blockvector:
-
-block #000 (object 0x41e1c4) [0x0..0x0]
- block #001 (object 0x41e1a0) [0x0..0x0] (under 0x41e1c4)
-
-
-Symtab for file dbxxx.s
-
-Line table:
-
-
-Blockvector:
-
-block #000 (object 0x41d178) [0x0..0x0]
- block #001 (object 0x41d154) [0x0..0x0] (under 0x41d178)
-
-
-Symtab for file foo.c
-
-Line table:
-
- line 1 at e4
- line 2 at fa
- line 4 at fa
- line 5 at 106
- line 6 at 112
- line 7 at 126
- line 9 at 126
- line 10 at 13c
- line 12 at 13c
- line 13 at 144
-
-Blockvector:
-
-block #000 (object 0x41a2d8) [0x0..0x0]
- int bar; block (object 0x41a2b0) starting at 0x126,
- int main; block (object 0x41a220) starting at 0xe4,
- block #001 (object 0x41a23c) [0x0..0x0] (under 0x41a2d8)
- block #002 (object 0x41a220) [0xe4..0x120] (under 0x41a23c) main
- int i; local at 0xfffffffc,
- block #003 (object 0x41a2b0) [0x126..0x150] (under 0x41a23c) bar
- int i; local at 0xfffffffc,
-
-
-Symtab for file crt0.s
-
-Line table:
-
-
-Blockvector:
-
-block #000 (object 0x41b178) [0x0..0x0]
- block #001 (object 0x41b154) [0x0..0x0] (under 0x41b178)
-
-
--- /dev/null
+\input texinfo
+@setfilename ../info/gdb
+@settitle GDB+, The GNU Debugger for GNU C++
+@ifinfo
+This file documents the GNU debugger GDB+.
+
+Copyright (C) 1988 Richard M. Stallman.
+Modified by Michael Tiemann
+
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+
+@ignore
+Permission is granted to process this file through Tex and print the
+results, provided the printed document carries copying permission
+notice identical to this one except for the removal of this paragraph
+(this paragraph not being relevant to the printed manual).
+
+@end ignore
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+sections entitled ``Distribution'' and ``GDB General Public License'' are
+included exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the sections entitled ``Distribution'' and ``GDB General Public
+License'' may be included in a translation approved by the author instead
+of in the original English.
+@end ifinfo
+
+@setchapternewpage odd
+@settitle GDB+ Manual
+@titlepage
+@sp 6
+@center @titlefont{GDB+ Manual}
+@sp 1
+@center The GNU Source-Level Debugger for GNU C++
+@sp 4
+@center Second Edition, GDB+ version 2.5.0
+@sp 1
+@center February 1988
+@sp 5
+@center Richard M. Stallman
+@page
+@vskip 0pt plus 1filll
+Copyright @copyright{} 1988 Richard M. Stallman.
+Modified by Michael Tiemann
+
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+sections entitled ``Distribution'' and ``GDB General Public License'' are
+included exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the sections entitled ``Distribution'' and ``GDB General Public
+License'' may be included in a translation approved by the author instead
+of in the original English.
+@end titlepage
+@page
+
+@node Top, Commands,, (DIR)
+@unnumbered Summary of GDB+
+
+The purpose of a debugger such as GDB+ is to allow you to execute another
+program while examining what is going on inside it. We call the other
+program ``your program'' or ``the program being debugged''.
+
+GDB+ can do four kinds of things (plus other things in support of these):
+
+@enumerate
+@item
+Start the program, specifying anything that might affect its behavior.
+
+@item
+Make the program stop on specified conditions.
+
+@item
+Examine what has happened, when the program has stopped, so that you
+can see bugs happen.
+
+@item
+Change things in the program, so you can correct the effects of one bug
+and go on to learn about another without having to recompile first.
+@end enumerate
+
+@menu
+* License:: The GDB General Public License gives you permission
+ to redistribute GDB+ on certain terms; and also
+ explains that there is no warranty.
+* Input:: GDB+ command syntax and input conventions.
+* Files:: Specifying files for GDB+ to operate on.
+* Options:: GDB+ arguments and options.
+* Compilation::Compiling your program so you can debug it.
+* Running:: Running your program under GDB+.
+* Stopping:: Making your program stop. Why it may stop. What to do then.
+* Stack:: Examining your program's stack.
+* Source:: Examining your program's source files.
+* Data:: Examining data in your program.
+* Symbols:: Examining the debugger's symbol table.
+* Altering:: Altering things in your program.
+* Sequences:: Canned command sequences for repeated use.
+* Emacs:: Using GDB through GNU Emacs.
+* Remote:: Remote kernel debugging across a serial line.
+* Commands:: Index of GDB+ commands.
+* Concepts:: Index of GDB+ concepts.
+@end menu
+
+@node License, Input, Top, Top
+@unnumbered GDB General Public License
+@center (Clarified 11 Feb 1988)
+
+ The license agreements of most software companies keep you at the mercy
+of those companies. By contrast, our general public license is intended to
+give everyone the right to share GDB. To make sure that you get the rights
+we want you to have, we need to make restrictions that forbid anyone to
+deny you these rights or to ask you to surrender the rights. Hence this
+license agreement.
+
+ Specifically, we want to make sure that you have the right to give away
+copies of GDB, that you receive source code or else can get it if you want
+it, that you can change GDB or use pieces of it in new free programs, and
+that you know you can do these things.
+
+ To make sure that everyone has such rights, we have to forbid you to
+deprive anyone else of these rights. For example, if you distribute copies
+of GDB, you must give the recipients all the rights that you have. You
+must make sure that they, too, receive or can get the source code. And you
+must tell them their rights.
+
+ Also, for our own protection, we must make certain that everyone finds
+out that there is no warranty for GDB. If GDB is modified by someone else
+and passed on, we want its recipients to know that what they have is not
+what we distributed, so that any problems introduced by others will not
+reflect on our reputation.
+
+ Therefore we (Richard Stallman and the Free Software Foundation,
+Inc.) make the following terms which say what you must do to be
+allowed to distribute or change GDB.
+
+@unnumberedsec Copying Policies
+
+@enumerate
+@item
+You may copy and distribute verbatim copies of GDB source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each file a valid copyright notice ``Copyright
+@copyright{} 1988 Free Software Foundation, Inc.'' (or with whatever year
+is appropriate); keep intact the notices on all files that
+refer to this License Agreement and to the absence of any warranty; and
+give any other recipients of the GDB program a copy of this License
+Agreement along with the program. You may charge a distribution fee
+for the physical act of transferring a copy.
+
+@item
+You may modify your copy or copies of GDB source code or any portion
+of it, and copy and distribute such modifications under the terms of
+Paragraph 1 above, provided that you also do the following:
+
+@itemize @bullet
+@item
+cause the modified files to carry prominent notices stating
+that you changed the files and the date of any change; and
+
+@item
+cause the whole of any work that you distribute or publish, that
+in whole or in part contains or is a derivative of GDB or any
+part thereof, to be licensed at no charge to all third parties on
+terms identical to those contained in this License Agreement
+(except that you may choose to grant more extensive warranty
+protection to some or all third parties, at your option).
+
+@item
+if the modified program serves as a debugger, cause it, when
+started running in the simplest and usual way, to print an
+announcement including a valid copyright notice ``Copyright
+@copyright{} 1988 Free Software Foundation, Inc.'' (or with the
+year that is appropriate), saying that there is no warranty (or
+else, saying that you provide a warranty) and that users may
+redistribute the program under these conditions, and telling the
+user how to view a copy of this License Agreement.
+
+@item
+You may charge a distribution fee for the physical act of
+transferring a copy, and you may at your option offer warranty
+protection in exchange for a fee.
+@end itemize
+
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+@item
+You may copy and distribute GDB (or a portion or derivative of it,
+under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the
+following:
+
+@itemize @bullet
+@item
+accompany it with the complete corresponding machine-readable
+source code, which must be distributed under the terms of
+Paragraphs 1 and 2 above; or,
+
+@item
+accompany it with a written offer, valid for at least three
+years, to give any third party free (except for a nominal
+shipping charge) a complete machine-readable copy of the
+corresponding source code, to be distributed under the terms of
+Paragraphs 1 and 2 above; or,
+
+@item
+accompany it with the information you received as to where the
+corresponding source code may be obtained. (This alternative is
+allowed only for noncommercial distribution and only if you
+received the program in object code or executable form alone.)
+@end itemize
+
+For an executable file, complete source code means all the source code
+for all modules it contains; but, as a special exception, it need not
+include source code for modules which are standard libraries that
+accompany the operating system on which the executable file runs.
+
+@item
+You may not copy, sublicense, distribute or transfer GDB except as
+expressly provided under this License Agreement. Any attempt
+otherwise to copy, sublicense, distribute or transfer GDB is void and
+your rights to use GDB under this License agreement shall be
+automatically terminated. However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full
+compliance.
+
+@item
+If you wish to incorporate parts of GDB into other free programs whose
+distribution conditions are different, write to the Free Software
+Foundation. We have not yet worked out a simple rule that can be
+stated here, but we will often permit this. We will be guided by the
+two goals of preserving the free status of all derivatives our free
+software and of promoting the sharing and reuse of software.
+@end enumerate
+
+@iftex
+@vfil
+@eject
+@end iftex
+@unnumberedsec NO WARRANTY
+
+ BECAUSE GDB IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
+WHEN OTHERWISE STATED IN WRITING, THE FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GDB ``AS IS''
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE GDB
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
+SERVICING, REPAIR OR CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL FREE SOFTWARE
+FOUNDATION, INC., RICHARD M. STALLMAN, AND/OR ANY OTHER PARTY WHO MAY
+MODIFY AND REDISTRIBUTE GDB AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER
+SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
+INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
+BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
+FAILURE OF THE PROGRAM TO OPERATE WITH PROGRAMS NOT DISTRIBUTED BY
+FREE SOFTWARE FOUNDATION, INC.) THE PROGRAM, EVEN IF YOU HAVE BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM BY ANY
+OTHER PARTY.
+
+@node Input, Files, License, Top
+@chapter GDB+ Input Conventions
+
+GDB+ is invoked with the shell command @samp{gdb+}. Once started, it reads
+commands from the terminal until you tell it to exit.
+
+A GDB+ command is a single line of input. There is no limit on how long
+it can be. It starts with a command name, which is followed by arguments
+whose meaning depends on the command name. Some command names do not
+allow arguments.
+
+GDB+ command names may always be abbreviated if the abbreviation is
+unambiguous. Sometimes even ambiguous abbreviations are allowed; for
+example, @samp{s} is specially defined as equivalent to @samp{step}
+even though there are other commands whose names start with @samp{s}.
+Possible command abbreviations are often stated in the documentation
+of the individual commands.
+
+A blank line as input to GDB+ means to repeat the previous command verbatim.
+Certain commands do not allow themselves to be repeated this way; these are
+commands for which unintentional repetition might cause trouble and which
+you are unlikely to want to repeat. Certain others (@samp{list} and
+@samp{x}) act differently when repeated because that is more useful.
+
+A line of input starting with @samp{#} is a comment; it does nothing.
+This is useful mainly in command files (@xref{Command Files}).
+
+GDB+ @dfn{prompts} for commands with a string that is normally @samp{(gdb+)}.
+When debugging GDB+ with GDB+, it is useful to change the prompt in one of
+the GDB+s so that you can distinguish them. This can be done with the
+@samp{set-prompt} command.
+
+@table @code
+@item set-prompt @var{newprompt}
+@kindex set-prompt
+Directs GDB+ to use @var{newprompt} as its prompt string henceforth.
+@end table
+
+@cindex exiting GDB+
+@kindex quit
+To exit GDB+, use the @samp{quit} command (abbreviated @samp{q}).
+@kbd{Ctrl-c} will not exit from GDB+, but rather will terminate the action
+of any GDB+ command that is in progress and return to GDB+ command level.
+It is safe to type @kbd{Ctrl-c} at any time because GDB+ does not allow
+it to take effect until a time when it is safe.
+
+@node Files, Options, Input, Top
+@chapter Specifying GDB+'s Files
+
+@cindex core dump file
+@cindex executable file
+@cindex symbol table
+GDB+ needs to know the filename of the program to be debugged. To debug a
+core dump of a previous run, GDB+ must be told the filename of the core
+dump.
+
+@menu
+* Arguments: File Arguments. Specifying files with arguments
+ (when you start GDB+).
+* Commands: File Commands. Specifying files with GDB+ commands.
+@end menu
+
+@node File Arguments, File Commands, Files, Files
+@section Specifying Files with Arguments
+
+The usual way to specify the executable and core dump file names is with
+two command arguments given when you start GDB+. The first argument is used
+as the file for execution and symbols, and the second argument (if any) is
+used as the core dump file name. Thus,
+
+@example
+GDB+ progm core
+@end example
+
+@noindent
+specifies @file{progm} as the executable program and @file{core} as a core
+dump file to examine. (You do not need to have a core dump file if what
+you plan to do is debug the program interactively.)
+
+@xref{Options}, for full information on command options and arguments for
+GDB+.
+
+@node File Commands,, File Arguments, Files
+@section Specifying Files with Commands
+
+Usually you specify the files for GDB+ to work with by giving arguments when
+you invoke GDB+. But occasionally it is necessary to change to a different
+file during a GDB+ session. Or you may run GDB+ and forget to specify the
+files you want to use. In these situations the GDB+ commands to specify new
+files are useful.
+
+@table @code
+@item exec-file @var{filename}
+@kindex exec-file
+Specify that the program to be run is found in @var{filename}. If you
+do not specify a directory and the file is not found in GDB+'s working
+directory, GDB+ will use the environment variable @samp{PATH} as a list
+of directories to search, just as the shell does when looking for a
+program to run.
+
+@item symbol-file @var{filename}
+@kindex symbol-file
+Read symbol table information from file @var{filename}. @samp{PATH}
+is searched when necessary. Most of the time you will use both the
+@samp{exec-file} and @samp{symbol-file} commands on the same file.
+
+@samp{symbol-file} with no argument clears out GDB+'s symbol table.
+
+@item core-file @var{filename}
+@kindex core-file
+Specify the whereabouts of a core dump file to be used as the
+``contents of memory''. Note that the core dump contains only the
+writable parts of memory; the read-only parts must come from the
+executable file.
+
+@samp{core-file} with no argument specifies that no core file is
+to be used.
+
+@item kill
+@kindex kill
+Cancel running the program under GDB+. This could be used if you wish
+to debug a core dump instead. GDB+ ignores any core dump file if it is
+actually running the program, so the @samp{kill} command is the only
+sure way to go back to using the core dump file.
+
+@item info files
+@kindex info files
+Print the names of the executable and core dump files currently in
+use by GDB+, and the file from which symbols were loaded.
+@end table
+
+While all three file-specifying commands allow both absolute and relative
+file names as arguments, GDB+ always converts the file name to an absolute
+one and remembers it that way.
+
+The @samp{symbol-file} command causes GDB+ to forget the contents of its
+convenience variables, the value history, and all breakpoints and
+auto-display expressions. This is because they may contain pointers to the
+internal data recording symbols and data types, which are part of the old
+symbol table data being discarded inside GDB+.
+
+@node Options, Compilation, Files, Top
+@chapter Options and Arguments for GDB+
+
+When you invoke GDB+, you can pass commands telling it what files to
+operate on and what other things to do.
+
+@menu
+* Mode Options:: Options controlling modes of operation.
+* File Options:: Options to specify files (executable, coredump, commands)
+* Other Arguments:: Any other arguments without options
+ also specify files.
+@end menu
+
+@node Mode Options, File Options, Options, Options
+@section Mode Options
+
+@table @samp
+@item -nx
+Do not execute commands from the init files @file{.gdbinit}.
+Normally, the commands in these files are executed after all the
+command options and arguments have been processed. @xref{Command
+Files}.
+
+@item -q
+``Quiet''. Do not print the usual introductory messages.
+
+@item -batch
+Run in batch mode. Exit with code 1 after processing all the command
+files specified with @samp{-x} (and @file{./.gdbinit}, if not inhibited).
+Exit also if, due to an error, GDB+ would otherwise attempt to read a
+command from the terminal.
+
+@item -fullname
+This option is used when Emacs runs GDB as a subprocess. It tells GDB
+to output the full file name and line number in a standard,
+recognizable fashion each time a stack frame is displayed (which
+includes each time the program stops). This recognizable format looks
+like two @samp{\032} characters, followed by the filename, line number
+and character position separated by colons, and a newline. The
+Emacs-to-GDB interface program uses the two @samp{\032} characters as
+a signal to display the source code for the frame.
+@end table
+
+@node File Options, Other Arguments, Mode Options, Options
+@section File-specifying Options
+
+All the options and command line arguments given are processed
+in sequential order. The order makes a difference when the
+@samp{-x} command is used.
+
+@table @samp
+@item -s @var{file}
+Read symbol table from file @var{file}.
+
+@item -e @var{file}
+Use file @var{file} as the executable file to execute when
+appropriate, and for examining pure data in conjunction with a core
+dump.
+
+@item -se @var{file}
+Read symbol table from file @var{file} and use it as the executable
+file.
+
+@item -c @var{file}
+Use file @var{file} as a core dump to examine.
+
+@item -x @var{file}
+Execute GDB+ commands from file @var{file}.
+
+@item -d @var{directory}
+Add @var{directory} to the path to search for source files.
+@end table
+
+@node Other Arguments,, File Options, Options
+@section Other Arguments
+
+If there are arguments to GDB+ that are not options or associated with
+options, the first one specifies the symbol table and executable file name
+(as if it were preceded by @samp{-se}) and the second one specifies a core
+dump file name (as if it were preceded by @samp{-c}).
+
+@node Compilation, Running, Options, Top
+@chapter Compiling Your Program for Debugging
+
+In order to debug a program effectively, you need to ask for debugging
+information when you compile it. This information in the object file
+describes the data type of each variable or function and the correspondence
+between source line numbers and addresses in the executable code.
+
+To request debugging information, specify the @samp{-g} option when you run
+the compiler.
+
+The Unix C compiler is unable to handle the @samp{-g} and @samp{-O} options
+together. This means that you cannot ask for optimization if you ask for
+debugger information.
+
+The GNU C compiler supports @samp{-g} with or without @samp{-O}, making it
+possible to debug optimized code. We recommend that you @emph{always} use
+@samp{-g} whenever you compile a program. You may think the program is
+correct, but there's no sense in pushing your luck.
+
+If you are using the GNU C compiler, the GNU assembler and the GNU linker,
+you can choose between two formats of debugging information: the standard
+Unix format, which is what you get with @samp{-g}, and GDB's own format,
+which you request by using @samp{-gg} instead of @samp{-g}. This stores
+debugging information in the executable file in a format much like that
+which is used inside GDB. This has these advantages and disadvantages:
+
+@itemize @bullet
+@item
+GDB can read @samp{-gg} format more than twice as fast as Unix
+@samp{-g} format.
+
+@item
+The @samp{-gg} format uses much more disk space than Unix format.
+
+@item
+The Unix debuggers can understand only Unix format, so you cannot use
+Unix source-level debuggers if you compile with @samp{-gg}. (The
+@code{adb} debugger works with either format; it does not use this
+information in any case.)
+@end itemize
+
+@node Running, Stopping, Compilation, Top
+@chapter Running Your Program Under GDB+
+
+@cindex running
+@kindex run
+To start your program under GDB+, use the @samp{run} command. The program
+must already have been specified using the @samp{exec-file} command or with
+an argument to GDB+ (@pxref{Files}); what @samp{run} does is create an
+inferior process, load the program into it, and set it in motion.
+
+The execution of a program is affected by certain information it receives
+from its superior. GDB+ provides ways to specify them, which you must do
+@i{before} starting the program. (You can change them after starting the
+program, but such changes do not affect the program unless you start it
+over again.)
+
+@table @asis
+@item The @i{arguments.}
+You specify the arguments to give the program as the arguments of the
+@samp{run} command.
+
+@item The @i{environment.}
+The program normally inherits its environment from GDB+, but you can
+use the GDB+ commands @samp{set-environment} and
+@samp{unset-environment} to change parts of the environment that will
+be given to the program.@refill
+
+@item The @i{working directory.}
+The program inherits its working directory from GDB+. You can set GDB+'s
+working directory with the @samp{cd} command in GDB+.
+@end table
+
+After the @samp{run} command, the debugger does nothing but wait for your
+program to stop. @xref{Stopping}.
+
+@menu
+* Arguments:: Specifying the arguments for your program.
+* Environment:: Specifying the environment for your program.
+* Working Directory:: Specifying the working directory for giving
+ to your program when it is run.
+* Input/Output:: Specifying the program's standard input and output.
+* Attach:: Debugging a process started outside GDB.
+@end menu
+
+@node Arguments, Environment, Running, Running
+@section Your Program's Arguments
+
+@cindex arguments (to your program)
+You specify the arguments to give the program as the arguments of the
+@samp{run} command. They are passed to a shell, which expands wildcard
+characters and performs redirection of I/O, and thence to the program.
+
+@samp{run} with no arguments uses the same arguments used by the previous
+@samp{run}.
+
+@kindex set-args
+The command @samp{set-args} can be used to specify the arguments to be used
+the next time the program is run. If @samp{set-args} has no arguments, it
+means to use no arguments the next time the program is run. If you have
+run your program with arguments and want to run it again with no arguments,
+this is the only way to do so.
+
+@node Environment, Working Directory, Arguments, Running
+@section Your Program's Environment
+
+@cindex environment (of your program)
+The @dfn{environment} consists of a set of @dfn{environment variables} and
+their values. Environment variables conventionally record such things as
+your user name, your home directory, your terminal type, and your search
+path for programs to run. Usually you set up environment variables with
+the shell and they are inherited by all the other programs you run. When
+debugging, it can be useful to try running the program with different
+environments without having to start the debugger over again.
+
+@table @code
+@item info environment @var{varname}
+@kindex info environment
+Print the value of environment variable @var{varname} to be given to
+your program when it is started. This command can be abbreviated
+@samp{i env @var{varname}}.
+
+@item info environment
+Print the names and values of all environment variables to be given to
+your program when it is started. This command can be abbreviated
+@samp{i env}.
+
+@item set-environment @var{varname} @var{value}
+@kindex set-environment
+Sets environment variable @var{varname} to @var{value}, for your
+program only, not for GDB+ itself. @var{value} may be any string; the
+values of environment variables are just strings, and any
+interpretation is supplied by your program itself. This command
+can be abbreviated as short as @samp{set-e}.
+
+@item unset-environment @var{varname}
+@kindex unset-environment
+Remove variable @var{varname} from the environment to be passed to
+your program. This is different from @samp{set-env @var{varname} =}
+because @samp{unset-environment} makes a variable not be defined at
+all, which is distinguishable from an empty value. This command can
+be abbreviated @samp{unset}.
+@end table
+
+@node Working Directory, Input/Output, Environment, Running
+@section Your Program's Working Directory
+
+@cindex working directory (of your program)
+Each time you start your program with @samp{run}, it inherits its working
+directory from the current working directory of GDB+. GDB+'s working
+directory is initially whatever it inherited from its superior, but you can
+specify the working directory for GDB+ with the @samp{cd} command.
+
+The GDB+ working directory also serves as a default for the commands
+that specify files for GDB+ to operate on. @xref{Files}.
+
+@table @code
+@item cd @var{directory}
+@kindex cd
+Set GDB+'s working directory to @var{directory}.
+
+@item pwd
+@kindex pwd
+Print GDB+'s working directory.
+@end table
+
+@node Input/Output, Attach, Working Directory, Running
+@section Your Program's Input and Output
+
+@cindex redirection
+By default, the program you run under GDB does input and output to the same
+terminal that GDB uses.
+
+You can redirect the program's input and/or output using @samp{sh}-style
+redirection commands in the @samp{run} command. For example,
+
+@example
+run > outfile
+@end example
+
+@noindent
+starts the program, diverting its output to the file @file{outfile}.
+
+@kindex tty
+Another way to specify where the program should do input and output is with
+the @samp{tty} command. This command accepts a file name as argument, and
+causes this file to be the default for future @samp{run} commands. For
+example,
+
+@example
+tty /dev/ttyb
+@end example
+
+@noindent
+directs that processes started with subsequent @samp{run} commands default
+to do input and output on the terminal @file{/dev/ttyb}. An explicit
+redirection in @samp{run} overrides the @samp{tty} command.
+
+When you use the @samp{tty} command or redirect input in the @samp{run}
+command, the @emph{input for your program} comes from the specified file,
+but the input for GDB still comes from your terminal. The program's
+controlling terminal is your (GDB's) terminal, not the terminal that the
+program is reading from; so if you want to type @kbd{C-c} to stop the
+program, you must type it on your (GDB's) terminal. A @kbd{C-c} typed on
+the program's terminal is available to the program as ordinary input.
+
+@node Attach,, Input/Output, Running
+@section Debugging an Already-Running Process
+@kindex detach
+@kindex attach
+@cindex attach
+
+Some operating systems (in particular, Sun) allow GDB to begin debugging an
+already-running process that was started outside of GDB. To do this you
+must use the @samp{attach} command instead of the @samp{run} command.
+
+The @samp{attach} command requires one argument, which is the process-id of
+the process you want to debug. (The usual way to find out the process-id
+of the process is with the @samp{ps} utility.)
+
+The first thing GDB after arranging to debug the process is to stop it.
+You can examine and modify an attached process with all the GDB commands
+that ordinarily available when you start processes with @samp{run}. You
+can insert breakpoints; you can step and continue; you can modify storage.
+If you would rather the process continue running, use the @samp{continue}
+command after attaching.
+
+When you are finished debugging the attached process, you can use the
+@samp{detach} command to release it from GDB's control. Detaching
+the process continues its execution. After the @samp{detach} command,
+that process and GDB become completely independent once more, and you
+are ready to @samp{attach} another process or start one with @samp{run}.
+
+If you exit GDB or use the @samp{run} command while you have an attached
+process, you kill that process. You will be asked for confirmation if you
+try to do either of these things.
+
+@node Stopping, Stack, Running, Top
+@chapter Stopping and Continuing
+
+When you run a program normally, it runs until exiting. The purpose
+of using a debugger is so that you can stop it before that point;
+or so that if the program runs into trouble you can find out why.
+
+@menu
+* Signals:: Fatal signals in your program just stop it;
+ then you can use GDB+ to see what is going on.
+* Breakpoints:: Breakpoints let you stop your program when it
+ reaches a specified point in the code.
+* Continuing:: Resuming execution until the next signal or breakpoint.
+* Stepping:: Stepping runs the program a short distance and
+ then stops it wherever it has come to.
+@end menu
+
+@node Signals, Breakpoints, Stopping, Stopping
+@section Signals
+
+A signal is an asynchronous event that can happen in a program. The
+operating system defines the possible kinds of signals, and gives each kind
+a name and a number. For example, @code{SIGINT} is the signal a program
+gets when you type @kbd{Ctrl-c}; @code{SIGSEGV} is the signal a program
+gets from referencing a place in memory far away from all the areas in use;
+@code{SIGALRM} occurs when the alarm clock timer goes off (which happens
+only if the program has requested an alarm).
+
+Some signals, including @code{SIGALRM}, are a normal part of the
+functioning of the program. Others, such as @code{SIGSEGV}, indicate
+errors; these signals are @dfn{fatal} (kill the program immediately) if the
+program has not specified in advance some other way to handle the signal.
+@code{SIGINT} does not indicate an error in the program, but it is normally
+fatal so it can carry out the purpose of @kbd{Ctrl-c}: to kill the program.
+
+GDB+ has the ability to detect any occurrence of a signal in the program
+running under GDB+'s control. You can tell GDB+ in advance what to do for
+each kind of signal.
+
+Normally, GDB+ is set up to ignore non-erroneous signals like @code{SIGALRM}
+(so as not to interfere with their role in the functioning of the program)
+but to stop the program immediately whenever an error signal happens.
+You can change these settings with the @samp{handle} command. You must
+specify which signal you are talking about with its number.
+
+@table @code
+@item info signal
+@kindex info signal
+Print a table of all the kinds of signals and how GDB+ has been told to
+handle each one. You can use this to see the signal numbers of all
+the defined types of signals.
+
+@item handle @var{signalnum} @var{keywords}@dots{}
+@kindex handle
+Change the way GDB+ handles signal @var{signalnum}. The @var{keywords}
+say what change to make.
+@end table
+
+To use the @samp{handle} command you must know the code number of the
+signal you are concerned with. To find the code number, type @samp{info
+signal} which prints a table of signal names and numbers.
+
+The keywords allowed by the handle command can be abbreviated. Their full
+names are
+
+@table @code
+@item stop
+GDB+ should stop the program when this signal happens. This implies
+the @samp{print} keyword as well.
+
+@item print
+GDB+ should print a message when this signal happens.
+
+@item nostop
+GDB+ should not stop the program when this signal happens. It may
+still print a message telling you that the signal has come in.
+
+@item noprint
+GDB+ should not mention the occurrence of the signal at all. This
+implies the @samp{nostop} keyword as well.
+
+@item pass
+GDB+ should allow the program to see this signal; the program will be
+able to handle the signal, or may be terminated if the signal is fatal
+and not handled.
+
+@item nopass
+GDB+ should not allow the program to see this signal.
+@end table
+
+When a signal has been set to stop the program, the program cannot see the
+signal until you continue. It will see the signal then, if @samp{pass} is
+in effect for the signal in question @i{at that time}. In other words,
+after GDB+ reports a signal, you can use the @samp{handle} command with
+@samp{pass} or @samp{nopass} to control whether that signal will be seen by
+the program when you later continue it.
+
+You can also use the @samp{signal} command to prevent the program from
+seeing a signal, or cause it to see a signal it normally would not see,
+or to give it any signal at any time. @xref{Signaling}.
+
+@node Breakpoints, Continuing, Signals, Stopping
+@section Breakpoints
+
+@cindex breakpoints
+A @dfn{breakpoint} makes your program stop whenever a certain point in the
+program is reached. You set breakpoints explicitly with GDB+ commands,
+specifying the place where the program should stop by line number, function
+name or exact address in the program. You can add various other conditions
+to control whether the program will stop.
+
+Each breakpoint is assigned a number when it is created; these numbers are
+successive integers starting with 1. In many of the commands for controlling
+various features of breakpoints you use the breakpoint number to say which
+breakpoint you want to change. Each breakpoint may be @dfn{enabled} or
+@dfn{disabled}; if disabled, it has no effect on the program until you
+enable it again.
+
+@kindex info break
+@kindex $_
+The command @samp{info break} prints a list of all breakpoints set and not
+cleared, showing their numbers, where in the program they are, and any
+special features in use for them. Disabled breakpoints are included in the
+list, but marked as disabled. @samp{info break} with a breakpoint number
+as argument lists only that breakpoint. The convenience variable @samp{$_}
+and the default examining-address for the @samp{x} command are set to the
+address of the last breakpoint listed (@pxref{Memory}).
+
+@menu
+* Set Breaks:: How to establish breakpoints.
+* Clear Breaks:: How to remove breakpoints no longer needed.
+* Disabling:: How to disable breakpoints (turn them off temporarily).
+* Conditions:: Making extra conditions on whether to stop.
+* Break Commands:: Commands to be executed at a breakpoint.
+* Error in Breakpoints:: "Cannot insert breakpoints" error--why, what to do.
+@end menu
+
+@node Set Breaks, Clear Breaks, Breakpoints, Breakpoints
+@subsection Setting Breakpoints
+
+@kindex break
+Breakpoints are set with the @samp{break} command (abbreviated @samp{b}).
+You have several ways to say where the breakpoint should go.
+
+@table @code
+@item break @var{function}
+Set a breakpoint at entry to function @var{function}.
+
+@item break @var{linenum}
+Set a breakpoint at line @var{linenum} in the current source file.
+That file is the last file whose source text was printed. This
+breakpoint will stop the program just before it executes any of the
+code on that line.
+
+@item break @var{filename}:@var{linenum}
+Set a breakpoint at line @var{linenum} in source file @var{filename}.
+
+@item break @var{filename}:@var{function}
+Set a breakpoint at entry to function @var{function} found in file
+@var{filename}. Specifying a filename as well as a function name is
+superfluous except when multiple files contain similarly named
+functions.
+
+@item break *@var{address}
+Set a breakpoint at address @var{address}. You can use this to set
+breakpoints in parts of the program which do not have debugging
+information or source files.
+
+@item break
+Set a breakpoint at the next instruction to be executed in the
+selected stack frame (@pxref{Stack}). This is a silly thing to do in
+the innermost stack frame because the program would stop immediately
+after being started, but it is very useful with another stack frame,
+because it will cause the program to stop as soon as control returns
+to that frame.
+
+@item break @dots{} if @var{cond}
+Set a breakpoint with condition @var{cond}; evaluate the expression
+@var{cond} each time the breakpoint is reached, and stop only if the
+value is nonzero. @samp{@dots{}} stands for one of the possible
+arguments described above (or no argument) specifying where to break.
+@xref{Conditions}, for more information on breakpoint conditions.
+
+@item tbreak @var{args}
+@kindex tbreak
+Set a breakpoint enabled only for one stop. @var{args} are the
+same as in the @samp{break} command, and the breakpoint is set in the same
+way, but the breakpoint is automatically @dfn{disabled} the first time it
+is hit.
+@end table
+
+GDB allows you to set any number of breakpoints at the same place in the
+program. There is nothing silly or meaningless about this. When the
+breakpoints are conditional, this is even useful (@pxref{Conditions}).
+
+@node Clear Breaks, Disabling, Set Breaks, Breakpoints
+@subsection Clearing Breakpoints
+
+@cindex clear breakpoint
+@cindex delete breakpoints
+It is often necessary to eliminate a breakpoint once it has done its job
+and you no longer want the program to stop there. This is called
+@dfn{clearing} or @samp{deleting} the breakpoint. A breakpoint that
+has been cleared no longer exists in any sense.
+
+With the @samp{clear} command you can clear breakpoints according to where
+they are in the program. With the @samp{delete} command you can clear
+individual breakpoints by specifying their breakpoint numbers.
+
+@b{It is not necessary to clear a breakpoint to proceed past it.} GDB+
+automatically ignores breakpoints in the first instruction to be executed
+when you continue execution at the same address where the program stopped.
+
+@table @code
+@item clear
+@kindex clear
+Clear any breakpoints at the next instruction to be executed in the
+selected stack frame (@pxref{Selection}). When the innermost frame
+is selected, this is a good way to clear a breakpoint that the program
+just stopped at.
+
+@item clear @var{function}
+@itemx clear @var{filename}:@var{function}
+Clear any breakpoints set at entry to the function @var{function}.
+
+@item clear @var{linenum}
+@item clear @var{filename}:@var{linenum}
+Clear any breakpoints set at or within the code of the specified line.
+
+@item delete @var{bnums}@dots{}
+@kindex delete
+Delete the breakpoints of the numbers specified as arguments.
+A breakpoint deleted is forgotten completely.
+@end table
+
+@node Disabling, Conditions, Clear Breaks, Breakpoints
+@subsection Disabling Breakpoints
+
+@cindex disabled breakpoints
+@cindex enabled breakpoints
+Rather than clearing a breakpoint, you might prefer to @dfn{disable} it.
+This makes the breakpoint inoperative as if it had been cleared, but
+remembers the information on the breakpoint so that you can @dfn{enable}
+it again later.
+
+You disable and enable breakpoints with the @samp{enable} and
+@samp{disable} commands, specifying one or more breakpoint numbers as
+arguments. Use @samp{info break} to print a list of breakpoints if you
+don't know which breakpoint numbers to use.
+
+A breakpoint can have any of four different states of enablement:
+
+@itemize @bullet
+@item
+Enabled. The breakpoint will stop the program. A breakpoint made
+with the @samp{break} command starts out in this state.
+@item
+Disabled. The breakpoint has no effect on the program.
+@item
+Enabled once. The breakpoint will stop the program, but
+when it does so it will become disabled. A breakpoint made
+with the @samp{tbreak} command starts out in this state.
+@item
+Enabled for deletion. The breakpoint will stop the program, but
+immediately after it does so it will be deleted permanently.
+@end itemize
+
+You change the state of enablement of a breakpoint with the following
+commands:
+
+@table @code
+@item disable @var{bnums}@dots{}
+@kindex disable
+Disable the specified breakpoints. A disabled breakpoint has no
+effect but is not forgotten. All options such as ignore-counts,
+conditions and commands are remembered in case the breakpoint is
+enabled again later.
+
+@item enable @var{bnums}@dots{}
+@kindex enable
+Enable the specified breakpoints. They become effective once again in
+stopping the program, until you specify otherwise.
+
+@item enable once @var{bnums}@dots{}
+Enable the specified breakpoints temporarily. Each will be disabled
+again the next time it stops the program (unless you have used one of
+these commands to specify a different state before that time comes).
+
+@item enable delete @var{bnums}@dots{}
+Enable the specified breakpoints to work once and then die. Each of
+the breakpoints will be deleted the next time it stops the program
+(unless you have used one of these commands to specify a different
+state before that time comes).
+@end table
+
+Aside from the automatic disablement or deletion of a breakpoint when it
+stops the program, which happens only in certain states, the state of
+enablement of a breakpoint changes only when one of the commands above
+is used.
+
+@node Conditions, Break Commands, Disabling, Breakpoints
+@subsection Break Conditions
+
+@cindex conditions
+The simplest sort of breakpoint breaks every time the program reaches a
+specified place. You can also specify a @dfn{condition} for a breakpoint.
+A condition is just a boolean expression in your programming language.
+A breakpoint with a condition evaluates the expression each time the
+program reaches it, and the program stops only if the condition is true.
+
+Break conditions may have side effects, and may even call functions in your
+program. These may sound like strange things to do, but their effects are
+completely predictable unless there is another enabled breakpoint at the
+same address. (In that case, GDB+ might see the other breakpoint first and
+stop the program without checking the condition of this one.) Note that
+breakpoint commands are usually more convenient and flexible for the
+purpose of performing side effects when a breakpoint is reached
+(@pxref{Break Commands}).
+
+Break conditions can be specified when a breakpoint is set, by using
+@samp{if} in the arguments to the @samp{break} command. @xref{Set Breaks}.
+They can also be changed at any time with the @samp{condition} command:
+
+@table @code
+@item condition @var{bnum} @var{expression}
+@kindex condition
+Specify @var{expression} as the break condition for breakpoint number
+@var{bnum}. From now on, this breakpoint will stop the program only if
+the value of @var{expression} is true (nonzero, in C). @var{expression}
+is not evaluated at the time the @samp{condition} command is given.
+
+@item condition @var{bnum}
+Remove the condition from breakpoint number @var{bnum}. It becomes
+an ordinary unconditional breakpoint.
+@end table
+
+@cindex ignore count (of breakpoint)
+A special feature is provided for one kind of condition: to prevent the
+breakpoint from doing anything until it has been reached a certain number
+of times. This is done with the @dfn{ignore count} of the breakpoint.
+When the program reaches a breakpoint whose ignore count is positive, then
+instead of stopping, it just decrements the ignore count by one and
+continues.
+
+@table @code
+@item ignore @var{bnum} @var{count}
+@kindex ignore
+Set the ignore count of breakpoint number @var{bnum} to @var{count}.
+The next @var{count} times the breakpoint is reached, it will not stop.
+
+To make the breakpoint stop the next time it is reached, specify
+a count of zero.
+
+@item cont @var{count}
+Continue execution of the program, setting the ignore count of the
+breakpoint that the program stopped at to @var{count} minus one.
+Continuing through the breakpoint does not itself count as one of
+@var{count}. Thus, the program will not stop at this breakpoint until the
+@var{count}'th time it is hit.
+
+This command is allowed only when the program stopped due to a
+breakpoint. At other times, the argument to @samp{cont} is ignored.
+@end table
+
+If a breakpoint has a positive ignore count and a condition, the condition
+is not checked. Once the ignore count reaches zero, the condition will
+start to be checked.
+
+Note that you could achieve the effect of the ignore count with a condition
+such as @samp{$foo-- <= 0} using a debugger convenience variable that is
+decremented each time. That is why the ignore count is considered a
+special case of a condition. @xref{Convenience Vars}.
+
+@node Break Commands, Error in Breakpoints, Conditions, Breakpoints
+@subsection Commands Executed on Breaking
+
+@cindex breakpoint commands
+You can give any breakpoint a series of commands to execute when the
+program stops due to that breakpoint. For example, you might want to
+print the values of certain expressions, or enable other breakpoints.
+
+@table @code
+@item commands @var{bnum}
+Specify commands for breakpoint number @var{bnum}. The commands
+themselves appear on the following lines. Type a line containing just
+@samp{end} to terminate the commands.
+
+To remove all commands from a breakpoint, use the command
+@samp{commands} and follow it immediately by @samp{end}; that is, give
+no commands.
+@end table
+
+It is possible for breakpoint commands to start the program up again.
+Simply use the @samp{cont} command, or @samp{step}, or any other command
+to resume execution. However, any remaining breakpoint commands are
+ignored. When the program stops again, GDB+ will act according to why
+that stop took place.
+
+@kindex silent
+If the first command specified is @samp{silent}, the usual message about
+stopping at a breakpoint is not printed. This may be desirable for
+breakpoints that are to print a specific message and then continue.
+If the remaining commands too print nothing, you will see no sign that
+the breakpoint was reached at all. @samp{silent} is not really a command;
+it is meaningful only at the beginning of the commands for a breakpoint.
+
+The commands @samp{echo} and @samp{output} that allow you to print precisely
+controlled output are often useful in silent breakpoints. @xref{Output}.
+
+For example, here is how you could use breakpoint commands to print the
+value of @code{x} at entry to @code{foo} whenever it is positive. We
+assume that the newly created breakpoint is number 4; @samp{break} will
+print the number that is assigned.
+
+@example
+break foo if x>0
+commands 4
+silent
+echo x is\040
+output x
+echo \n
+cont
+end
+@end example
+
+One application for breakpoint commands is to correct one bug so you can
+test another. Put a breakpoint just after the erroneous line of code, give
+it a condition to detect the case in which something erroneous has been
+done, and give it commands to assign correct values to any variables that
+need them. End with the @samp{cont} command so that the program does not
+stop, and start with the @samp{silent} command so that no output is
+produced. Here is an example:
+
+@example
+break 403
+commands 5
+silent
+set x = y + 4
+cont
+end
+@end example
+
+One deficiency in the operation of automatically continuing breakpoints
+under Unix appears when your program uses raw mode for the terminal.
+GDB+ options back to its own terminal modes (not raw) before executing
+commands, and then must switch back to raw mode when your program is
+continued. This causes any pending terminal input to be lost.
+
+In the GNU system, this will be fixed by changing the behavior of
+terminal modes.
+
+Under Unix, when you have this problem, you might be able to get around
+it by putting your actions into the breakpoint condition instead of
+commands. For example
+
+@example
+condition 5 (x = y + 4), 0
+@end example
+
+@noindent
+is a condition expression that will change @code{x} as needed, then always
+have the value 0 so the program will not stop. Loss of input is avoided
+here because break conditions are evaluated without changing the terminal
+modes. When you want to have nontrivial conditions for performing the side
+effects, the operators @samp{&&}, @samp{||} and @samp{?@: @dots{} :@:} may be useful.
+
+@node Error in Breakpoints,, Break Commands, Breakpoints
+@subsection ``Cannot Insert Breakpoints'' Error
+
+Under Unix, breakpoints cannot be used in a program if any other process
+is running that program. Attempting to run or continue the program with
+a breakpoint in this case will cause GDB+ to stop it.
+
+When this happens, you have two ways to proceed:
+
+@enumerate
+@item
+Remove or disable the breakpoints, then continue.
+
+@item
+Suspend GDB+, and copy the file containing the program to a new name.
+Resume GDB+ and use the @samp{exec-file} command to specify that GDB+
+should run the program under that name. Then start the program again.
+@end enumerate
+
+@node Continuing, Stepping, Breakpoints, Stopping
+@section Continuing
+
+After your program stops, most likely you will want it to run some more if
+the bug you are looking for has not happened yet.
+
+@table @code
+@item cont
+Continue running the program at the place where it stopped.
+@end table
+
+If the program stopped at a breakpoint, the place to continue running
+is the address of the breakpoint. You might expect that continuing would
+just stop at the same breakpoint immediately. In fact, @samp{cont}
+takes special care to prevent that from happening. You do not need
+to clear the breakpoint to proceed through it after stopping at it.
+
+You can, however, specify an ignore-count for the breakpoint that the
+program stopped at, by means of an argument to the @samp{cont} command.
+@xref{Conditions}.
+
+If the program stopped because of a signal other than @code{SIGINT} or
+@code{SIGTRAP}, continuing will cause the program to see that signal.
+You may not want this to happen. For example, if the program stopped
+due to some sort of memory reference error, you might store correct
+values into the erroneous variables and continue, hoping to see more
+execution; but the program would probably terminate immediately as
+a result of the fatal signal once it sees the signal. To prevent this,
+you can continue with @samp{signal 0}. @xref{Signaling}. You can
+also act in advance to prevent the program from seeing certain kinds
+of signals, using the @samp{handle} command (@pxref{Signals}).
+
+@node Stepping,, Continuing, Stopping
+@section Stepping
+
+@cindex stepping
+@dfn{Stepping} means setting your program in motion for a limited time, so
+that control will return automatically to the debugger after one line of
+code or one machine instruction. Breakpoints are active during stepping
+and the program will stop for them even if it has not gone as far as the
+stepping command specifies.
+
+@table @code
+@item step
+@kindex step
+Proceed the program until control reaches a different line, then stop
+it and return to the debugger. This command is abbreviated @samp{s}.
+
+@item step @var{count}
+Proceed as in @samp{step}, but do so @var{count} times. If a breakpoint
+or a signal not related to stepping is reached before @var{count} steps,
+stepping stops right away.
+
+@item next
+@kindex next
+Similar to @samp{step}, but any function calls appearing within the line of
+code are executed without stopping. Execution stops when control reaches a
+different line of code at the stack level which was executing when the
+@samp{next} command was given. This command is abbreviated @samp{n}.
+
+An argument is a repeat count, as in @samp{step}.
+
+@item finish
+@kindex finish
+Continue running until just after the selected stack frame returns
+(or until there is some other reason to stop, such as a fatal signal
+or a breakpoint).
+
+Contrast this with the @samp{return} command (@pxref{Returning}).
+
+@item stepi
+@itemx si
+@kindex stepi
+@kindex si
+Proceed one machine instruction, then stop and return to the debugger.
+
+It is often useful to do @samp{display/i $pc} when stepping by machine
+instructions. This will cause the next instruction to be executed to
+be displayed automatically at each stop. @xref{Auto Display}.
+
+An argument is a repeat count, as in @samp{step}.
+
+@item nexti
+@itemx ni
+@kindex nexti
+@kindex ni
+Proceed one machine instruction, but if it is a subroutine call,
+proceed until the subroutine returns.
+
+An argument is a repeat count, as in @samp{next}.
+@end table
+
+A typical technique for using stepping is to put a breakpoint
+(@pxref{Breakpoints}) at the beginning of the function or the section of
+the program in which a problem is believed to lie, and then step through
+the suspect area, examining the variables that are interesting, until the
+problem happens.
+
+The @samp{cont} command can be used after stepping to resume execution
+until the next breakpoint or signal.
+
+@node Stack, Source, Stopping, Top
+@chapter Examining the Stack
+
+When your program has stopped, the first thing you need to know is where it
+stopped and how it got there.
+
+@cindex call stack
+Each time your program performs a function call, the information about
+where in the program the call was made from is saved in a block of data
+called a @dfn{stack frame}. The frame also contains the arguments of the
+call and the local variables of the function that was called. All the
+stack frames are allocated in a region of memory called the @dfn{call
+stack}.
+
+When your program stops, the GDB+ commands for examining the stack allow you
+to see all of this information.
+
+One of the stack frames is @dfn{selected} by GDB+ and many GDB+ commands
+refer implicitly to the selected frame. In particular, whenever you ask
+GDB+ for the value of a variable in the program, the value is found in the
+selected frame. There are special GDB+ commands to select whichever frame
+you are interested in.
+
+When the program stops, GDB+ automatically selects the currently executing
+frame and describes it briefly as the @samp{frame} command does
+(@pxref{Frame Info, Info}).
+
+@menu
+* Frames:: Explanation of stack frames and terminology.
+* Backtrace:: Summarizing many frames at once.
+* Selection:: How to select a stack frame.
+* Info: Frame Info, Commands to print information on stack frames.
+@end menu
+
+@node Frames, Backtrace, Stack, Stack
+@section Stack Frames
+
+@cindex frame
+The call stack is divided up into contiguous pieces called @dfn{frames};
+each frame is the data associated with one call to one function. The frame
+contains the arguments given to the function, the function's local
+variables, and the address at which the function is executing.
+
+@cindex initial frame
+@cindex outermost frame
+@cindex innermost frame
+When your program is started, the stack has only one frame, that of the
+function @code{main}. This is called the @dfn{initial} frame or the
+@dfn{outermost} frame. Each time a function is called, a new frame is
+made. Each time a function returns, the frame for that function invocation
+is eliminated. If a function is recursive, there can be many frames for
+the same function. The frame for the function in which execution is
+actually occurring is called the @dfn{innermost} frame. This is the most
+recently created of all the stack frames that still exist.
+
+@cindex frame pointer
+Inside your program, stack frames are identified by their addresses. A
+stack frame consists of many bytes, each of which has its own address; each
+kind of computer has a convention for choosing one of those bytes whose
+address serves as the address of the frame. Usually this address is kept
+in a register called the @dfn{frame pointer register} while execution is
+going on in that frame.
+
+@cindex frame number
+GDB+ assigns numbers to all existing stack frames, starting with zero for
+the innermost frame, one for the frame that called it, and so on upward.
+These numbers do not really exist in your program; they are to give you a
+way of talking about stack frames in GDB+ commands.
+
+@cindex selected frame
+Many GDB+ commands refer implicitly to one stack frame. GDB+ records a stack
+frame that is called the @dfn{selected} stack frame; you can select any
+frame using one set of GDB+ commands, and then other commands will operate
+on that frame. When your program stops, GDB+ automatically selects the
+innermost frame.
+
+@node Backtrace, Selection, Frames, Stack
+@section Backtraces
+
+A backtrace is a summary of how the program got where it is. It shows one
+line per frame, for many frames, starting with the currently executing
+frame (frame zero), followed by its caller (frame one), and on up the
+stack.
+
+@table @code
+@item backtrace
+@itemx bt
+Print a backtrace of the entire stack: one line per frame for all
+frames in the stack.
+
+You can stop the backtrace at any time by typing the system interrupt
+character, normally @kbd{Control-C}.
+
+@item backtrace @var{n}
+@itemx bt @var{n}
+Similar, but stop after @var{n} frames.
+@end table
+
+Each line in a backtrace shows the frame number, the program counter, the
+function and its arguments, and the source file name and line number (if
+known). The program counter is is omitted if is the beginning of the code for
+the source line. This is the same as the first of the two lines printed
+when you select a frame.
+
+@node Selection, Frame Info, Backtrace, Stack
+@section Selecting a Frame
+
+Most commands for examining the stack and other data in the program work on
+whichever stack frame is selected at the moment. Here are the commands for
+selecting a stack frame; all of them finish by printing a brief description
+of the stack frame just selected.
+
+@table @code
+@item frame @var{n}
+@kindex frame
+Select frame number @var{n}. Recall that frame zero is the innermost
+(currently executing) frame, frame one is the frame that called the
+innermost one, and so on. The highest-numbered frame is @code{main}'s
+frame.
+
+@item frame @var{addr}
+Select the frame at address @var{addr}. This is useful mainly if the
+chaining of stack frames has been damaged by a bug, making it
+impossible for GDB+ to assign numbers properly to all frames. In
+addition, this can be useful when the program has multiple stacks and
+options between them.
+
+@item up @var{n}
+@kindex up
+Select the frame @var{n} frames up from the frame previously selected.
+For positive numbers @var{n}, this advances toward the outermost
+frame, to higher frame numbers, to frames that have existed longer.
+@var{n} defaults to one.
+
+@item down @var{n}
+@kindex down
+Select the frame @var{n} frames down from the frame previously
+selected. For positive numbers @var{n}, this advances toward the
+innermost frame, to lower frame numbers, to frames that were created
+more recently. @var{n} defaults to one.
+@end table
+
+All of these commands end by printing some information on the frame that
+has been selected: the frame number, the function name, the arguments, the
+source file and line number of execution in that frame, and the text of
+that source line. For example:
+
+@example
+#3 main (argc=3, argv=??, env=??) at main.c, line 67
+67 read_input_file (argv[i]);
+@end example
+
+After such a printout, the @samp{list} command with no arguments will print
+ten lines centered on the point of execution in the frame. @xref{List}.
+
+@node Frame Info,, Selection, Stack
+@section Information on a Frame
+
+There are several other commands to print information about the selected
+stack frame.
+
+@table @code
+@item frame
+This command prints a brief description of the selected stack frame.
+It can be abbreviated @samp{f}. With an argument, this command is
+used to select a stack frame; with no argument, it does not change
+which frame is selected, but still prints the same information.
+
+@item info frame
+@kindex info frame
+This command prints a verbose description of the selected stack frame,
+including the address of the frame, the addresses of the next frame in
+(called by this frame) and the next frame out (caller of this frame),
+the address of the frame's arguments, the program counter saved in it
+(the address of execution in the caller frame), and which registers
+were saved in the frame. The verbose description is useful when
+something has gone wrong that has made the stack format fail to fit
+the usual conventions.
+
+@item info frame @var{addr}
+Print a verbose description of the frame at address @var{addr},
+without selecting that frame. The selected frame remains unchanged by
+this command.
+
+@item info args
+@kindex info args
+Print the arguments of the selected frame, each on a separate line.
+
+@item info locals
+@kindex info locals
+Print the local variables of the selected frame, each on a separate
+line. These are all variables declared static or automatic within all
+program blocks that execution in this frame is currently inside of.
+@end table
+
+@node Source, Data, Stack, Top
+@chapter Examining Source Files
+
+GDB+ knows which source files your program was compiled from, and
+can print parts of their text. When your program stops, GDB+
+spontaneously prints the line it stopped in. Likewise, when you
+select a stack frame (@pxref{Selection}), GDB+ prints the line
+which execution in that frame has stopped in. You can also
+print parts of source files by explicit command.
+
+@menu
+* List:: Using the @samp{list} command to print source files.
+* Search:: Commands for searching source files.
+* Source Path:: Specifying the directories to search for source files.
+@end menu
+
+@node List, Search, Source, Source
+@section Printing Source Lines
+
+@kindex list
+To print lines from a source file, use the @samp{list} command
+(abbreviated @samp{l}). There are several ways to specify what part
+of the file you want to print.
+
+Here are the forms of @samp{list} command most commonly used:
+
+@table @code
+@item list @var{linenum}
+Print ten lines centered around line number @var{linenum} in the
+current source file.
+
+@item list @var{function}
+Print ten lines centered around the beginning of function
+@var{function}.
+
+@item list
+Print ten more lines. If the last lines printed were printed with a
+@samp{list} command, this prints ten lines following the last lines
+printed; however, if the last line printed was a solitary line printed
+as part of displaying a stack frame (@pxref{Stack}), this prints ten
+lines centered around that line.
+
+@item list @minus{}
+Print ten lines just before the lines last printed.
+@end table
+
+Repeating a @samp{list} command with @key{RET} discards the argument,
+so it is equivalent to typing just @samp{list}. This is more useful
+than listing the same lines again. An exception is made for an
+argument of @samp{-}; that argument is preserved in repetition so that
+each repetition moves up in the file.
+
+In general, the @samp{list} command expects you to supply zero, one or two
+@dfn{linespecs}. Linespecs specify source lines; there are several ways
+of writing them but the effect is always to specify some source line.
+Here is a complete description of the possible arguments for @samp{list}:
+
+@table @code
+@item list @var{linespec}
+Print ten lines centered around the line specified by @var{linespec}.
+
+@item list @var{first},@var{last}
+Print lines from @var{first} to @var{last}. Both arguments are
+linespecs.
+
+@item list ,@var{last}
+Print ten lines ending with @var{last}.
+
+@item list @var{first},
+Print ten lines starting with @var{first}.
+
+@item list +
+Print ten lines just after the lines last printed.
+
+@item list @minus{}
+Print ten lines just before the lines last printed.
+
+@item list
+As described in the preceding table.
+@end table
+
+Here are the ways of specifying a single source line---all the
+kinds of linespec.
+
+@table @asis
+@item @var{linenum}
+Specifies line @var{linenum} of the current source file.
+When a @samp{list} command has two linespecs, this refers to
+the same source file as the first linespec.
+
+@item +@var{offset}
+Specifies the line @var{offset} lines after the last line printed.
+When used as the second linespec in a @samp{list} command that has
+two, this specifies the line @var{offset} lines down from the
+first linespec.
+
+@item @minus{}@var{offset}
+Specifies the line @var{offset} lines before the last line printed.
+
+@item @var{filename}:@var{linenum}
+Specifies line @var{linenum} in the source file @var{filename}.
+
+@item @var{function}
+Specifies the line of the open-brace that begins the body of the
+function @var{function}.
+
+@item @var{filename}:@var{function}
+Specifies the line of the open-brace that begins the body of the
+function @var{function} in the file @var{filename}. The file name is
+needed with a function name only for disambiguation of identically
+named functions in different source files.
+
+@item *@var{address}
+Specifies the line containing the program address @var{address}.
+@var{address} may be any expression.
+@end table
+
+One other command is used to map source lines to program addresses.
+
+@table @code
+@item info line @var{linenum}
+@kindex info line
+Print the starting and ending addresses of the compiled code for
+source line @var{linenum}.
+
+@kindex $_
+The default examine address for the @samp{x} command is changed to the
+starting address of the line, so that @samp{x/i} is sufficient to
+begin examining the machine code (@pxref{Memory}). Also, this address
+is saved as the value of the convenience variable @samp{$_}
+(@pxref{Convenience Vars}).
+@end table
+
+@node Search, Source Path, List, Source
+@section Searching Source Files
+@cindex searching
+@kindex forward-search
+@kindex reverse-search
+
+There are two commands for searching through the current source file for a
+regular expression.
+
+The command @samp{forward-search @var{regexp}} checks each line, starting
+with the one following the last line listed, for a match for @var{regexp}.
+It lists the line that is found. You can abbreviate the command name
+as @samp{fo}.
+
+The command @samp{reverse-search @var{regexp}} checks each line, starting
+with the one before the last line listed and going backward, for a match
+for @var{regexp}. It lists the line that is found. You can abbreviate
+this command with as little as @samp{rev}.
+
+@node Source Path,, Search, Source
+@section Specifying Source Directories
+
+@cindex source path
+@cindex directories for source files
+Executable programs do not record the directories of the source files they
+were compiled from, just the names. GDB+ remembers a list of directories to
+search for source files; this is called the @dfn{source path}. Each time
+GDB+ wants a source file, it tries all the directories in the list, in the
+order they are present in the list, until it finds a file with the desired
+name.
+
+@kindex directory
+When you start GDB+, its source path contains just the current working
+directory. To add other directories, use the @samp{directory} command.
+@b{Note that the search path for executable files and the working directory
+are @i{not} used for finding source files.}
+
+@table @code
+@item directory @var{dirname}
+Add directory @var{dirname} to the end of the source path.
+
+@item directory
+Reset the source path to just the current working directory of GDB+.
+This requires confirmation.
+
+@samp{directory} with no argument can cause source files previously
+found by GDB+ to be found in a different directory. To make this work
+correctly, this command also clears out the tables GDB+ maintains
+about the source files it has already found.
+
+@item info directories
+@kindex info directories
+Print the source path: show which directories it contains.
+@end table
+
+Because the @samp{directory} command adds to the end of the source path,
+it does not affect any file that GDB+ has already found. If the source
+path contains directories that you do not want, and these directories
+contain misleading files with names matching your source files, the
+way to correct the situation is as follows:
+
+@enumerate
+@item
+Choose the directory you want at the beginning of the source path.
+Use the @samp{cd} command to make that the current working directory.
+
+@item
+Use @samp{directory} with no argument to reset the source path to just
+that directory.
+
+@item
+Use @samp{directory} with suitable arguments to add any other
+directories you want in the source path.
+@end enumerate
+
+@node Data, Symbols, Source, Top
+@chapter Examining Data
+
+@cindex printing data
+@cindex examining data
+@kindex print
+The usual way of examining data in your program is with the @samp{print}
+command (abbreviated @samp{p}). It evaluates and prints the value of any
+valid expression of the language the program is written in (for now, C).
+You type
+
+@example
+print @var{exp}
+@end example
+
+@noindent
+where @var{exp} is any valid expression, and the value of @var{exp}
+is printed in a format appropriate to its data type.
+
+A more low-level way of examining data is with the @samp{x} command.
+It examines data in memory at a specified address and prints it in a
+specified format.
+
+@menu
+* Expressions:: Expressions that can be computed and printed.
+* Variables:: Using your program's variables in expressions.
+* Assignment:: Setting your program's variables.
+* Arrays:: Examining part of memory as an array.
+* Formats:: Specifying formats for printing values.
+* Memory:: Examining memory explicitly.
+* Auto Display:: Printing certain expressions whenever program stops.
+* Value History:: Referring to values previously printed.
+* Convenience Vars:: Giving names to values for future reference.
+* Registers:: Referring to and storing in machine registers.
+@end menu
+
+@node Expressions, Variables, Data, Data
+@section Expressions
+
+@cindex expressions
+Many different GDB+ commands accept an expression and compute its value.
+Any kind of constant, variable or operator defined by the programming
+language you are using is legal in an expression in GDB+. This includes
+conditional expressions, function calls, casts and string constants.
+
+In addition to supporting operators normally found in the C programming
+language, GDB+ also supports some C++ constructs. For example, one can
+call member functions (GDB+ automatically uses @code{this} when necessary),
+and examine and manipulate pointers to members, pointers to member
+functions (virtual or otherwise).
+
+Casts are supported in all languages, not just in C, because it is so
+useful to cast a number into a pointer so as to examine a structure
+at that address in memory. GDB+ allows pointers to members and pointer to
+member functions to be cast to any type and vice-versa.
+
+GDB+ supports three kinds of operator in addition to those of programming
+languages:
+
+@table @code
+@item @@
+@samp{@@} is a binary operator for treating parts of memory as arrays.
+@xref{Arrays}, for more information.
+
+@item ::
+@samp{::} allows you to specify a variable in terms of the file or
+function it is defined in. @xref{Variables}. It also supports the C++
+convention of qualifying a variable reference according to a type name (or
+the global scope). This makes it easy to examing static class variables,
+for example.
+
+@item @{@var{type}@} @var{addr}
+Refers to an object of type @var{type} stored at address @var{addr} in
+memory. @var{addr} may be any expression whose value is an integer or
+pointer (but parentheses are required around nonunary operators, just as in
+a cast). This construct is allowed regardless of what kind of data is
+officially supposed to reside at @var{addr}.@refill
+@end table
+
+@node Variables, Arrays, Expressions, Data
+@section Program Variables
+
+The most common kind of expression to use is the name of a variable
+in your program.
+
+Variables in expressions are understood in the selected stack frame
+(@pxref{Selection}); they must either be global (or static) or be visible
+according to the scope rules of the programming language from the point of
+execution in that frame. This means that in the function
+
+@example
+foo (a)
+ int a;
+@{
+ bar (a);
+ @{
+ int b = test ();
+ bar (b);
+ @}
+@}
+@end example
+
+@noindent
+the variable @code{a} is usable whenever the program is executing
+within the function @code{foo}, but the variable @code{b} is visible
+only while the program is executing inside the block in which @code{b}
+is declared.
+
+@node Arrays, Formats, Variables, Data
+@section Artificial Arrays
+
+@cindex artificial array
+It is often useful to print out several successive objects of the
+same type in memory; a section of an array, or an array of
+dynamically determined size for which only a pointer exists in the
+program.
+
+This can be done by constructing an @dfn{artificial array} with the
+binary operator @samp{@@}. The left operand of @samp{@@} should be
+the first element of the desired array, as an individual object.
+The right operand should be the length of the array. The result is
+an array value whose elements are all of the type of the left argument.
+The first element is actually the left argument; the second element
+comes from bytes of memory immediately following those that hold the
+first element, and so on. Here is an example. If a program says
+
+@example
+int *array = (int *) malloc (len * sizeof (int));
+@end example
+
+@noindent
+you can print the contents of @code{array} with
+
+@example
+p *array@@len
+@end example
+
+The left operand of @samp{@@} must reside in memory. Array values made
+with @samp{@@} in this way behave just like other arrays in terms of
+subscripting, and are coerced to pointers when used in expressions.
+(It would probably appear in an expression via the value history,
+after you had printed it out.)
+
+@node Formats, Memory, Arrays, Data
+@section Formats
+
+@cindex formatted output
+@cindex output formats
+GDB+ normally prints all values according to their data types. Sometimes
+this is not what you want. For example, you might want to print a number
+in hex, or a pointer in decimal. Or you might want to view data in memory
+at a certain address as a character string or an instruction. These things
+can be done with @dfn{output formats}.
+
+The simplest use of output formats is to say how to print a value
+already computed. This is done by starting the arguments of the
+@samp{print} command with a slash and a format letter. The format
+letters supported are:
+
+@table @samp
+@item x
+Regard the bits of the value as an integer, and print the integer in
+hexadecimal.
+
+@item d
+Print as integer in signed decimal.
+
+@item u
+Print as integer in unsigned decimal.
+
+@item o
+Print as integer in octal.
+
+@item a
+Print as an address, both absolute in hex and then relative
+to a symbol defined as an address below it.
+
+@item c
+Regard as an integer and print it as a character constant.
+
+@item f
+Regard the bits of the value as a floating point number and print
+using typical floating point syntax.
+@end table
+
+For example, to print the program counter in hex (@pxref{Registers}), type
+
+@example
+p/x $pc
+@end example
+
+@noindent
+Note that no space is required before the slash; this is because command
+names in GDB+ cannot contain a slash.
+
+To reprint the last value in the value history with a different format,
+you can use the @samp{print} command with just a format and no
+expression. For example, @samp{p/x} reprints the last value in hex.
+
+@node Memory, Auto Display, Formats, Data
+@subsection Examining Memory
+
+@cindex examining memory
+@kindex x
+The command @samp{x} (for `examine') can be used to examine memory under
+explicit control of formats, without reference to the program's data types.
+
+@samp{x} is followed by a slash and an output format specification,
+followed by an expression for an address. The expression need not have
+a pointer value (though it may); it is used as an integer, as the
+address of a byte of memory.
+
+The output format in this case specifies both how big a unit of memory
+to examine and how to print the contents of that unit. It is done
+with one or two of the following letters:
+
+These letters specify just the size of unit to examine:
+
+@table @samp
+@item b
+Examine individual bytes.
+
+@item h
+Examine halfwords (two bytes each).
+
+@item w
+Examine words (four bytes each).
+
+@cindex word
+Many assemblers and cpu designers still use `word' for a 16-bit quantity,
+as a holdover from specific predecessor machines of the 1970's that really
+did use two-byte words. But more generally the term `word' has always
+referred to the size of quantity that a machine normally operates on and
+stores in its registers. This is 32 bits for all the machines that GNU
+runs on.
+
+@item g
+Examine giant words (8 bytes).
+@end table
+
+These letters specify just the way to print the contents:
+
+@table @samp
+@item x
+Print as integers in unsigned hexadecimal.
+
+@item d
+Print as integers in signed decimal.
+
+@item u
+Print as integers in unsigned decimal.
+
+@item o
+Print as integers in unsigned octal.
+
+@item a
+Print as an address, both absolute in hex and then relative
+to a symbol defined as an address below it.
+
+@item c
+Print as character constants.
+
+@item f
+Print as floating point. This works only with sizes @samp{w} and
+@samp{g}.
+
+@item s
+Print a null-terminated string of characters. The specified unit size
+is ignored; instead, the unit is however many bytes it takes to reach
+a null character (including the null character).
+
+@item i
+Print a machine instruction in assembler syntax (or nearly). The
+specified unit size is ignored; the number of bytes in an instruction
+varies depending on the type of machine, the opcode and the addressing
+modes used.
+@end table
+
+If either the manner of printing or the size of unit fails to be specified,
+the default is to use the same one that was used last. If you don't want
+to use any letters after the slash, you can omit the slash as well.
+
+You can also omit the address to examine. Then the address used is
+just after the last unit examined. This is why string and instruction
+formats actually compute a unit-size based on the data: so that the
+next string or instruction examined will start in the right place.
+The @samp{print} command sometimes sets the default address for
+the @samp{x} command; when the value printed resides in memory, the
+default is set to examine the same location. @samp{info line} also
+sets the default for @samp{x}, to the address of the start of the
+machine code for the specified line and @samp{info breakpoints} sets
+it to the address of the last breakpoint listed.
+
+When you use @key{RET} to repeat an @samp{x} command, it does not repeat
+exactly the same: the address specified previously (if any) is ignored, so
+that the repeated command examines the successive locations in memory
+rather than the same ones.
+
+You can examine several consecutive units of memory with one command by
+writing a repeat-count after the slash (before the format letters, if any).
+The repeat count must be a decimal integer. It has the same effect as
+repeating the @samp{x} command that many times except that the output may
+be more compact with several units per line.
+
+@example
+x/10i $pc
+@end example
+
+@noindent
+Prints ten instructions starting with the one to be executed next in the
+selected frame. After doing this, you could print another ten following
+instructions with
+
+@example
+x/10
+@end example
+
+@noindent
+in which the format and address are allowed to default.
+
+@kindex $_
+@kindex $__
+The addresses and contents printed by the @samp{x} command are not put in
+the value history because there is often too much of them and they would
+get in the way. Instead, GDB+ makes these values available for subsequent
+use in expressions as values of the convenience variables @samp{$_} and
+@samp{$__}.
+
+After an @samp{x} command, the last address examined is available for use
+in expressions in the convenience variable @samp{$_}. The contents of that
+address, as examined, are available in the convenience variable @samp{$__}.
+
+If the @samp{x} command has a repeat count, the address and contents saved
+are from the last memory unit printed; this is not the same as the last
+address printed if several units were printed on the last line of output.
+
+@node Auto Display, Value History, Memory, Data
+@section Automatic Display
+
+If you find that you want to print the value of an expression frequently
+(to see how it changes), you might want to add it to the @dfn{automatic
+display list} so that GDB+ will print its value each time the program stops.
+Each expression added to the list is given a number to identify it;
+to remove an expression from the list, you specify that number.
+The automatic display looks like this:
+
+@example
+2: foo = 38
+3: bar[5] = (struct hack *) 0x3804
+@end example
+
+@noindent
+showing item numbers, expressions and their current values.
+
+@table @code
+@item display @var{exp}
+@kindex display
+Add the expression @var{exp} to the list of expressions to display
+each time the program stops.
+
+@item display/@var{fmt} @var{exp}
+For @var{fmt} specifying only a display format and not a size or
+count, add the expression @var{exp} to the auto-display list but
+arranges to display it each time in the specified format @var{fmt}.
+
+@item display/@var{fmt} @var{addr}
+For @var{fmt} @samp{i} or @samp{s}, or including a unit-size or a
+number of units, add the expression @var{addr} as a memory address to
+be examined each time the program stops. Examining means in effect
+doing @samp{x/@var{fmt} @var{addr}}. @xref{Memory}.
+
+@item undisplay @var{n}
+@kindex undisplay
+Remove item number @var{n} from the list of expressions to display.
+
+@item display
+Display the current values of the expressions on the list, just as is
+done when the program stops.
+
+@item info display
+@kindex info display
+Print the list of expressions to display automatically, each one
+with its item number, but without showing the values.
+@end table
+
+@node Value History, Convenience Vars, Auto Display, Data
+@section Value History
+
+@cindex value history
+Every value printed by the @samp{print} command is saved for the entire
+session in GDB+'s @dfn{value history} so that you can refer to it in
+other expressions.
+
+@cindex $
+@cindex $$
+The values printed are given @dfn{history numbers} for you to refer to them
+by. These are successive integers starting with 1. @samp{print} shows you
+the history number assigned to a value by printing @samp{$@var{n} = }
+before the value; here @var{n} is the history number.
+
+To refer to any previous value, use @samp{$} followed by the value's
+history number. The output printed by @samp{print} is designed to remind
+you of this. Just @samp{$} refers to the most recent value in the history,
+and @samp{$$} refers to the value before that.
+
+For example, suppose you have just printed a pointer to a structure and
+want to see the contents of the structure. It suffices to type
+
+@example
+p *$
+@end example
+
+If you have a chain of structures where the component @samp{next} points
+to the next one, you can print the contents of the next one with
+
+@example
+p *$.next
+@end example
+
+It might be useful to repeat this command many times by typing @key{RET}.
+
+Note that the history records values, not expressions. If the value of
+@code{x} is 4 and you type
+
+@example
+print x
+set x=5
+@end example
+
+@noindent
+then the value recorded in the value history by the @samp{print} command
+remains 4 even though @code{x}'s value has changed.
+
+@table @code
+@item info history
+@kindex info history
+Print the last ten values in the value history, with their item
+numbers. This is like @samp{p $$9} repeated ten times, except that
+@samp{info history} does not change the history.
+
+@item info history @var{n}
+Print ten history values centered on history item number @var{n}.
+@end table
+
+@node Convenience Vars, Registers, Value History, Data
+@section Convenience Variables
+
+@cindex convenience variables
+GDB+ provides @dfn{convenience variables} that you can use within GDB+ to
+hold on to a value and refer to it later. These variables exist entirely
+within GDB+; they are not part of your program, and setting a convenience
+variable has no effect on further execution of your program. That's why
+you can use them freely.
+
+Convenience variables have names starting with @samp{$}. Any name starting
+with @samp{$} can be used for a convenience variable, unless it is one of
+the predefined set of register names (@pxref{Registers}).
+
+You can save a value in a convenience variable with an assignment
+expression, just as you would set a variable in your program. Example:
+
+@example
+set $foo = *object_ptr
+@end example
+
+@noindent
+would save in @samp{$foo} the value contained in the object pointed to by
+@code{object_ptr}.
+
+Using a convenience variable for the first time creates it; but its value
+is @code{void} until you assign a new value. You can alter the value with
+another assignment at any time.
+
+Convenience variables have no fixed types. You can assign a convenience
+variable any type of value, even if it already has a value of a different
+type. The convenience variable as an expression has whatever type its
+current value has.
+
+@table @code
+@item info convenience
+@kindex info convenience
+Print a list of convenience variables used so far, and their values.
+Abbreviated @samp{i con}.
+@end table
+
+One of the ways to use a convenience variable is as a counter to be
+incremented or a pointer to be advanced. For example:
+
+@example
+set $i = 0
+print bar[$i++]->contents
+@i{@dots{}repeat that command by typing @key{RET}.}
+@end example
+
+Some convenience variables are created automatically by GDB+ and given
+values likely to be useful.
+
+@table @samp
+@item $_
+The variable @samp{$_} is automatically set by the @samp{x} command to
+the last address examined (@pxref{Memory}). Other commands which
+provide a default address for @samp{x} to examine also set @samp{$_}
+to that address; these commands include @samp{info line} and @samp{info
+breakpoint}.
+
+@item $__
+The variable @samp{$__} is automatically set by the @samp{x} command
+to the value found in the last address examined.
+@end table
+
+@node Registers,, Convenience Vars, Data
+@section Registers
+
+@cindex registers
+Machine register contents can be referred to in expressions as variables
+with names starting with @samp{$}. The names of registers are different
+for each machine; use @samp{info registers} to see the names used on your
+machine. The names @samp{$pc} and @samp{$sp} are used on all machines for
+the program counter register and the stack pointer. Often @samp{$fp} is
+used for a register that contains a pointer to the current stack frame.
+
+GDB+ always considers the contents of an ordinary register as an integer
+when the register is examined in this way. Programs can store floating
+point values in registers also, but there is currently no GDB+ command
+to examine a specified register in floating point. (However, if the
+variable in your program which is stored in the register is a floating
+point variable, you can see the floating point value by examining
+the variable.)
+
+Some machines have special floating point registers. GDB+ considers these
+registers' values as floating point when you examine them explicitly.
+
+Some registers have distinct ``raw'' and ``virtual'' data formats. This
+means that the data format in which the register contents are saved by the
+operating system is not the same one that your program normally sees. For
+example, the registers of the 68881 floating point coprocessor are always
+saved in ``extended'' format, but all C programs expect to work with
+``double'' format. In such cases, GDB+ normally works with the virtual
+format only (the format that makes sense for your program), but the
+@samp{info registers} command prints the data in both formats.
+
+Register values are relative to the selected stack frame
+(@pxref{Selection}). This means that you get the value that the register
+would contain if all stack frames farther in were exited and their saved
+registers restored. In order to see the real contents of all registers,
+you must select the innermost frame (with @samp{frame 0}).
+
+Some registers are never saved (typically those numbered zero or one)
+because they are used for returning function values; for these registers,
+relativization makes no difference.
+
+@table @code
+@item info registers
+@kindex info registers
+Print the names and relativized values of all registers.
+
+@item info registers @var{regname}
+Print the relativized value of register @var{regname}. @var{regname}
+may be any register name valid on the machine you are using, with
+or without the initial @samp{$}.
+@end table
+
+@subsection Examples
+
+You could print the program counter in hex with
+
+@example
+p/x $pc
+@end example
+
+@noindent
+or print the instruction to be executed next with
+
+@example
+x/i $pc
+@end example
+
+@noindent
+or add four to the stack pointer with
+
+@example
+set $sp += 4
+@end example
+
+@noindent
+The last is a way of removing one word from the stack, on machines where
+stacks grow downward in memory (most machines, nowadays). This assumes
+that the innermost stack frame is selected. Setting @samp{$sp} is
+not allowed when other stack frames are selected.
+
+@node Symbols, Altering, Data, Top
+@chapter Examining the Symbol Table
+
+The commands described in this section allow you to make inquiries for
+information about the symbols (names of variables, functions and types)
+defined in your program. This information is found by GDB+ in the symbol
+table loaded by the @samp{symbol-file} command; it is inherent in the text
+of your program and does not change as the program executes.
+
+@table @code
+@item whatis @var{exp}
+@kindex whatis
+Print the data type of expression @var{exp}. @var{exp} is not
+actually evaluated, and any side-effecting operations (such as
+assignments or function calls) inside it do not take place.
+
+@item whatis
+Print the data type of @samp{$}, the last value in the value history.
+
+@item info address @var{symbol}
+@kindex info address
+Describe where the data for @var{symbol} is stored. For register
+variables, this says which register. For other automatic variables,
+this prints the stack-frame offset at which the variable is always
+stored. Note the contrast with @samp{print &@var{symbol}}, which does
+not work at all for register variables and for automatic variables
+prints the exact address of the current instantiation of the variable.
+
+@item ptype @var{typename}
+@kindex ptype
+Print a description of data type @var{typename}. @var{typename} may be
+the name of a type, or for C code it may have the form
+@samp{struct @var{struct-tag}}, @samp{union @var{union-tag}} or
+@samp{enum @var{enum-tag}}.@refill
+
+@item info sources
+@kindex info sources
+Print the names of all source files in the program for which there
+is debugging information.
+
+@item info functions
+@kindex info functions
+Print the names and data types of all defined functions.
+
+@item info functions @var{regexp}
+Print the names and data types of all defined functions
+whose names contain a match for regular expression @var{regexp}.
+Thus, @samp{info fun step} finds all functions whose names
+include @samp{step}; @samp{info fun ^step} finds those whose names
+start with @samp{step}.
+
+@item info variables
+@kindex info variables
+Print the names and data types of all variables that are declared
+outside of functions.
+
+@item info variables @var{regexp}
+Print the names and data types of all variables, declared outside of
+functions, whose names contain a match for regular expression
+@var{regexp}.
+
+@item info types
+@kindex info types
+Print all data types that are defined in the program.
+
+@item info types @var{regexp}
+Print all data types that are defined in the program whose names
+contain a match for regular expression @var{regexp}.
+
+@item printsyms @var{filename}
+@kindex printsyms
+Write a complete dump of the debugger's symbol data into the
+file @var{filename}.
+@end table
+
+@node Altering, Sequences, Symbols, Top
+@chapter Altering Execution
+
+There are several ways to alter the execution of your program with GDB+
+commands.
+
+@menu
+* Assignment:: Altering variable values or memory contents.
+* Jumping:: Altering control flow.
+* Signaling:: Making signals happen in the program.
+* Returning:: Making a function return prematurely.
+@end menu
+
+@node Assignment, Jumping, Altering, Altering
+@section Assignment to Variables
+
+@cindex assignment
+@cindex setting variables
+To alter the value of a variable, evaluate an assignment expression.
+For example,
+
+@example
+print x=4
+@end example
+
+@noindent
+would store the value 4 into the variable @code{x}, and then print
+the value of the assignment expression (which is 4).
+
+@kindex set
+If you are not interested in seeing the value of the assignment, use the
+@samp{set} command instead of the @samp{print} command. @samp{set} is
+really the same as @samp{print} except that the expression's value is not
+printed and is not put in the value history (@pxref{Value History}). The
+expression is evaluated only for side effects.
+
+GDB+ allows more implicit conversions in assignments than C does; you can
+freely store an integer value into a pointer variable or vice versa, and
+any structure can be converted to any other structure that is the same
+length or shorter.
+
+In C, all the other assignment operators such as @samp{+=} and @samp{++}
+are supported as well.
+
+To store into arbitrary places in memory, use the @samp{@{@dots{}@}}
+construct to generate a value of specified type at a specified address
+(@pxref{Expressions}). For example,
+
+@example
+set @{int@}0x83040 = 4
+@end example
+
+@node Jumping, Signaling, Assignment, Altering
+@section Continuing at a Different Address
+
+@table @code
+@item jump @var{linenum}
+@kindex jump
+Resume execution at line number @var{linenum}. Execution may stop
+immediately if there is a breakpoint there.
+
+The @samp{jump} command does not change the current stack frame, or
+the stack pointer, or the contents of any memory location or any
+register other than the program counter. If line @var{linenum} is in
+a different function from the one currently executing, the results may
+be wild if the two functions expect different patterns of arguments or
+of local variables. For his reason, the @samp{jump} command requests
+confirmation if the specified line is not in the function currently
+executing. However, even wild results are predictable based on
+changing the program counter.
+
+@item jump *@var{address}
+Resume execution at the instruction at address @var{address}.
+@end table
+
+A similar effect can be obtained by storing a new value into the register
+@samp{$pc}, but not exactly the same.
+
+@example
+set $pc = 0x485
+@end example
+
+@noindent
+specifies the address at which execution will resume, but does not resume
+execution. That does not happen until you use the @samp{cont} command or a
+stepping command (@pxref{Stepping}).
+
+@node Signaling, Returning, Jumping, Altering
+@section Giving the Program a Signal
+
+@table @code
+@item signal @var{signalnum}
+@kindex signal
+Resume execution where the program stopped, but give it immediately
+the signal number @var{signalnum}.
+
+Alternatively, if @var{signalnum} is zero, continue execution and give
+no signal. This may be useful when the program has received a signal
+and the @samp{cont} command would allow the program to see that
+signal.
+@end table
+
+@node Returning,, Signaling, Altering
+@section Returning from a Function
+
+@cindex returning from a function
+@kindex return
+You can make any function call return immediately, using the @samp{return}
+command.
+
+First select the stack frame that you wish to return from
+(@pxref{Selection}). Then type the @samp{return} command. If you wish to
+specify the value to be returned, give that as an argument.
+
+This pops the selected stack frame (and any other frames inside of it),
+leaving its caller as the innermost remaining frame. That frame becomes
+selected. The specified value is stored in the registers used for
+returning values of functions.
+
+The @samp{return} command does not resume execution; it leaves the program
+stopped in the state that would exist if the function had just returned.
+Contrast this with the @samp{finish} command (@pxref{Stepping}), which
+resumes execution @i{until} the selected stack frame returns naturally.
+
+@node Sequences, Emacs, Altering, Top
+@chapter Canned Sequences of Commands
+
+GDB+ provides two ways to store sequences of commands for execution as a
+unit: user-defined commands and command files.
+
+@menu
+* Define:: User-defined commands.
+* Command Files:: Command files.
+* Output:: Controlled output commands useful in
+ user-defined commands and command files.
+@end menu
+
+@node Define, Command Files, Sequences, Sequences
+@section User-Defined Commands
+
+@cindex user-defined commands
+A @dfn{user-defined command} is a sequence of GDB+ commands to which you
+assign a new name as a command. This is done with the @samp{define}
+command.
+
+@table @code
+@item define @var{commandname}
+@kindex define
+Define a command named @var{commandname}. If there is already a command
+by that name, you are asked to confirm that you want to redefine it.
+
+The definition of the command is made up of other GDB+ command lines,
+which are given following the @samp{define} command. The end of these
+commands is marked by a line containing @samp{end}.
+
+@item document @var{commandname}
+@kindex document
+Give documentation to the user-defined command @var{commandname}. The
+command @var{commandname} must already be defined. This command reads
+lines of documentation just as @samp{define} reads the lines of the
+command definition. After the @samp{document} command is finished,
+@samp{help} on command @var{commandname} will print the documentation
+you have specified.
+
+You may use the @samp{document} command again to change the
+documentation of a command. Redefining the command with @samp{define}
+does not change the documentation.
+@end table
+
+User-defined commands do not take arguments. When they are executed, the
+commands of the definition are not printed. An error in any command
+stops execution of the user-defined command.
+
+Commands that would ask for confirmation if used interactively proceed
+without asking when used inside a user-defined command. Many GDB+ commands
+that normally print messages to say what they are doing omit the messages
+when used in user-defined command.
+
+@node Command Files, Output, Define, Sequences
+@section Command Files
+
+@cindex command files
+A command file for GDB+ is a file of lines that are GDB+ commands. Comments
+(lines starting with @samp{#}) may also be included. An empty line in a
+command file does nothing; it does not mean to repeat the last command, as
+it would from the terminal.
+
+@cindex init file
+@cindex .gdbinit
+When GDB+ starts, it automatically executes its @dfn{init files}, command
+files named @file{.gdbinit}. GDB+ reads the init file (if any) in your home
+directory and then the init file (if any) in the current working
+directory. (The init files are not executed if the @samp{-nx} option
+is given.) You can also request the execution of a command file with the
+@samp{source} command:
+
+@table @code
+@item source @var{filename}
+@kindex source
+Execute the command file @var{filename}.
+@end table
+
+The lines in a command file are executed sequentially. They are not
+printed as they are executed. An error in any command terminates execution
+of the command file.
+
+Commands that would ask for confirmation if used interactively proceed
+without asking when used in a command file. Many GDB+ commands that
+normally print messages to say what they are doing omit the messages
+when used in a command file.
+
+@node Output,, Command Files, Sequences
+@section Commands for Controlled Output
+
+During the execution of a command file or a user-defined command, the only
+output that appears is what is explicitly printed by the commands of the
+definition. This section describes three commands useful for generating
+exactly the output you want.
+
+@table @code
+@item echo @var{text}
+@kindex echo
+Print @var{text}. Nonprinting characters can be included in
+@var{text} using C escape sequences, such as @samp{\n} to print a
+newline. @b{No newline will be printed unless you specify one.}
+
+A backslash at the end of @var{text} is ignored. It is useful for
+outputting a string ending in spaces, since trailing spaces are
+trimmed from all arguments. A backslash at the beginning preserves
+leading spaces in the same way, because @samp{\ } as an escape
+sequence stands for a space. Thus, to print @samp{ and foo = }, do
+
+@example
+echo \ and foo = \
+@end example
+
+@item output @var{expression}
+@kindex output
+Print the value of @var{expression} and nothing but that value: no
+newlines, no @samp{$@var{nn} = }. The value is not entered in the
+value history either.
+
+@item output/@var{fmt} @var{expression}
+Print the value of @var{expression} in format @var{fmt}.
+@xref{Formats}, for more information.
+
+@item printf @var{string}, @var{expressions}@dots{}
+@kindex printf
+Print the values of the @var{expressions} under the control of
+@var{string}. The @var{expressions} are separated by commas and may
+be either numbers or pointers. Their values are printed as specified
+by @var{string}, exactly as if the program were to execute
+
+@example
+printf (@var{string}, @var{expressions}@dots{});
+@end example
+
+For example, you can print two values in hex like this:
+
+@example
+printf "foo, bar-foo = 0x%x, 0x%x\n", foo, bar-foo
+@end example
+
+The only backslash-escape sequences that you can use in the string are
+the simple ones that consist of backslash followed by a letter.
+@end table
+
+@node Emacs, Remote, Sequences, Top
+@chapter Using GDB under GNU Emacs
+
+A special interface allows you to use GNU Emacs to view (and
+edit) the source files for the program you are debugging with
+GDB.
+
+To use this interface, use the command @kbd{M-x gdb} in Emacs.
+Give the executable file you want to debug as an argument. This
+command starts a GDB process as a subprocess of Emacs, with input
+and output through a newly created Emacs buffer.
+
+Using this GDB process is just like using GDB normally except for two things:
+
+@itemize @bullet
+@item
+All ``terminal'' input and output goes through the Emacs buffer. This
+applies both to GDB commands and their output, and to the input and
+output done by the program you are debugging.
+
+This is useful because it means that you can copy the text of previous
+commands and input them again; you can even use parts of the output
+in this way.
+
+All the facilities of Emacs's Shell mode are available for this purpose.
+
+@item
+GDB displays source code through Emacs. Each time GDB displays a
+stack frame, Emacs automatically finds the source file for that frame
+and puts an arrow (@samp{=>}) at the left margin of the current line.
+
+Explicit GDB @samp{list} or search commands still produce output as
+usual, but you probably will have no reason to use them.
+@end itemize
+
+In the GDB I/O buffer, you can use these special Emacs commands:
+
+@table @kbd
+@item M-s
+Execute to another source line, like the GDB @samp{step} command.
+
+@item M-n
+Execute to next source line in this function, skipping all function
+calls, like the GDB @samp{next} command.
+
+@item M-i
+Execute one instruction, like the GDB @samp{stepi} command.
+
+@item M-u
+Move up one stack frame (and display that frame's source file in
+Emacs), like the GDB @samp{up} command.
+
+@item M-d
+Move down one stack frame (and display that frame's source file in
+Emacs), like the GDB @samp{down} command. (This means that you cannot
+delete words in the usual fashion in the GDB buffer; I am guessing you
+won't often want to do that.)
+
+@item C-c C-f
+Execute until exit from the selected stack frame, like the GDB
+@samp{finish} command.
+@end table
+
+In any source file, the Emacs command @kbd{C-x SPC} (@code{gdb-break})
+tells GDB to set a breakpoint on the source line point is on.
+
+The source files displayed in Emacs are in ordinary Emacs buffers
+which are visiting the source files in the usual way. You can edit
+the files with these buffers if you wish; but keep in mind that GDB
+communicates with Emacs in terms of line numbers. If you add or
+delete lines from the text, the line numbers that GDB knows will cease
+to correspond properly to the code.
+
+@node Remote, Commands, Emacs, Top
+@chapter Remote Kernel Debugging
+
+GDB has a special facility for debugging a remote machine via a serial
+connection. This can be used for kernel debugging.
+
+The program to be debugged on the remote machine needs to contain a
+debugging device driver which talks to GDB over the serial line using the
+protocol described below. The same version of GDB that is used ordinarily
+can be used for this.
+
+@menu
+* Remote Commands:: Commands used to start and finish remote debugging.
+@end menu
+
+For details of the communication protocol, see the comments in the GDB
+source file @file{remote.c}.
+
+@node Remote Commands,, Remote, Remote
+@section Commands for Remote Debugging
+
+To start remote debugging, first run GDB and specify as an executable file
+the program that is running in the remote machine. This tells GDB how
+to find the program's symbols and the contents of its pure text. Then
+establish communication using the @samp{attach} command with a device
+name rather than a pid as an argument. For example:
+
+@example
+attach /dev/ttyd
+@end example
+
+@noindent
+if the serial line is connected to the device named @file{/dev/ttyd}. This
+will stop the remote machine if it is not already stopped.
+
+Now you can use all the usual commands to examine and change data and to
+step and continue the remote program.
+
+To resume the remote program and stop debugging it, use the @samp{detach}
+command.
+
+@node Commands, Concepts, Remote, Top
+@unnumbered Command Index
+
+@printindex ky
+
+@node Concepts,, Commands, Top
+@unnumbered Concept Index
+
+@printindex cp
+
+@contents
+@bye
+++ /dev/null
-.TH GDB 1 "13 April 1987"
-.UC 4
-.SH NAME
-gdb \- Project GNU's DeBugger
-.SH SYNOPSIS
-\fBgdb\fP [ \fBoptions\fP ] See documentation mentioned below.
-.SH DESCRIPTION
-\fIgdb\fP is a source level symbolic debugger for C programs, created by
-Richard M. Stallman (rms) for the GNU Project, and distributed by the
-Free Software Foundation. Eventually GNU (Gnu's Not Unix) will be a
-complete replacement for Berkeley Unix, all of which everyone will be
-able to use freely. See the \fIGNU Emacs\fP man page for pointers to more
-information.
-.PP
-\fIgdb\fP has something of the flavor of \fIdbx\fP,
-but has more features and power. It can also be used to debug o/s
-kernels, but needs to be configured differently for that task.
-.PP
-Project GNU isn't using Unix man pages. Its style of complete
-documentation can be found by:
-.PP
-The help and info commands inside \fIgdb\fP.
-.PP
-In the Info system in \fIGNU Emacs\fP. Type C-h i, and follow the
-directions. This is equivalent to the reference manual for
-\fIgdb\fP, and has about 55 pages of text.
-.PP
-\fIgdb\fP could be extended to work with other languages (e.g. Pascal) and
-machines (e.g. encores). If you like, copy the sources and give it a
-try. When you have it working send \fIdiff -c\fP's of the changed files to
-bug-gdb@prep.ai.mit.edu (fuller details below), so they can benefit everyone.
-.SH DISTRIBUTION
-\fIgdb\fP is free; anyone may redistribute copies of
-\fIgdb\fP to anyone under the terms stated in the
-\fIgdb\fP General Public License, a copy of which accompanies each copy of
-\fIgdb\fP, is readable with the info command inside \fIgdb\fP,
-and which also appears in the \fIgdb\fP reference manual.
-.PP
-Copies of \fIgdb\fP may sometimes be received packaged with
-distributions of Unix systems, but it is never included in the scope
-of any license covering those systems. Such inclusion would violate
-the terms on which distribution is permitted. In fact, the primary
-purpose of the General Public License is to prohibit anyone from
-attaching any other restrictions to redistribution of \fIgdb\fP.
-.PP
-You can order printed copies of the \fIgdb\fP reference manual for $10.00/copy
-postpaid from the Free Software Foundation, which develops GNU software
-(contact them for quantity prices on the manual). Their address is:
-.nf
- Free Software Foundation
- 1000 Mass Ave.
- Cambridge, MA 02138
-.fi
-As with all software and publications from FSF, everyone is permitted to
-make and distribute copies of the \fIgdb\fP reference manual.
-The TeX source to the \fIgdb\fP reference
-manual is also included in the \fIGNU Emacs\fP source distribution.
-.PP
-.SH OPTIONS
-See documentation.
-.SH EXAMPLES
-See documentation.
-.SH "SEE ALSO"
-adb(1), sdb(1), dbx(1)
-.SH BUGS
-There is a mailing list, bug-gdb@prep.ai.mit.edu on the internet
-(ucbvax!prep.ai.mit.edu!bug-gdb on UUCPnet), for reporting \fIgdb\fP
-bugs and fixes. But before reporting something as a bug, please try
-to be sure that it really is a bug, not a misunderstanding or a
-deliberate feature. We ask you to read the section ``Reporting Emacs
-Bugs'' near the end of the \fIGNU Emacs\fP reference manual
-(or Info system) for hints
-on how and when to report bugs. Also, include the version number of
-the \fIgdb\fP you are running in \fIevery\fR bug report that you send in.
-.PP
-Do not expect a personal answer to a bug report. The purpose of reporting
-bugs is to get them fixed for everyone in the next release, if possible.
-For personal assistance, look in the SERVICE file
-(see the \fIGNU Emacs\fP man page) for
-a list of people who offer it.
-.PP
-Please do not send anything but bug reports to this mailing list.
-Send other stuff to gnu@prep.ai.mit.edu (or the
-corresponding UUCP address). For more information about GNU mailing
-lists, see the file MAILINGLISTS (see the \fIGNU Emacs\fP man page). Bugs tend
-actually to be fixed if they can be isolated, so it is in your
-interest to report them in such a way that they can be easily
-reproduced.
-.PP
-No bugs are known at this time.
-
+++ /dev/null
-BABYL OPTIONS:
-Version: 5
-Labels:
-Note: This is the header of an rmail file.
-Note: If you are seeing it in rmail,
-Note: it means the file has no messages in it.
-\1f\f
-From: mly@MICHAEL.AI.MIT.EDU (Richard Mlynarik)
-To: rms@prep.ai.mit.edu
-Subject: gdb suggestions (from hpux cdb)
-Reply-To: mly-prep@prep.ai.mit.edu
-
-"find-bug" command says "I can see the problem, but it will do you
-good to find it yourself"
-
-The gdb manual should explicitly state that gdb has no control over
-forked (or execed or whatever) subprocesses.
-
-I'd still like it if "delete" said what it had done.
-
-\f
-Date: Tuesday, 13 May 1986, 00:40-EDT
-From: <rms@LMI-ANGEL>
-Sender: JC@LMI-ANGEL
-Subject: interesting sdb features
-To: rms@angel
-
-output format p = pointer to procedure.
-
-foo/x or foo/4x uses size of foo as size to print.
-
-foo[1;4] to get elements 1 thru 4.
-
-Continue to specified line number.
-
-Interactively delete all breakpoints (asking about each one).
-
-
-\f
-Command to write backtrace into a file, or even better to duplicate all
-output to a file. This could work by playing with descriptor 1,
-making it a pipe to `tee'. The original descriptor 1 is saved and
-this mode can be turned off by putting it back.
- Date: Wed, 18 Feb 87 15:37:14 EST
- From: rms (Richard M. Stallman)
- Message-Id: <8702182037.AA16492@prep.ai.mit.edu>
- To: mly-prep@prep.ai.mit.edu
- In-Reply-To: <8702181913.AA16118@prep.ai.mit.edu>
- Subject: gdb "photo" command
-
- I don't think all this is worth the trouble to do now,
- because the right way to do it on TRIX is totally different
- and much easier.
-
-
-Commands to enable and disable the autodisplays. Associate
-autodisplays with breakpoints perhaps, so they only display
-at those breakpoints; this is easier than using breakpoint commands.
-
-Remember how each breakpoint's position was specified.
-Have command to reread symbol table and respecify each
-breakpoint using same args (line number or function name) as before.
-
-Have way to proceed process in background so that can then suspend
-gdb but have subprocess continue
-
-\f
-Date: Fri, 24 Jul 87 21:30:25 EDT
-From: phr@PREP.AI.MIT.EDU (Paul Rubin)
-To: bug-gdb@PREP.AI.MIT.EDU
-
-After rereading the symbol table when user runs the "symbol-file"
-command, when GDB notices that some of the source files are newer
-it should reload them rather than just printing a message saying
-they are newer.
-
-
-\f
-Message-Id: <8704171941.AA05045@orville.arpa>
-To: mly@prep.ai.mit.edu
-Cc: raible@orville.arpa, fouts@orville.arpa, creon@orville.arpa
-Subject: gdb hack/questions, etc
-Date: 17 Apr 87 11:41:42 PST (Fri)
-From: raible@orville.arpa
-
-
-A couple of things:
-
-1) Will gdb ever get dbx-sytly tracing? Wouldn't it be fairly easy to add?
-
-2) How about an xemacs gdb mode which has various windows, perhaps using
- terminal.el for generality?
-
-3) Any word about that stupid IRIS SIGIOT problem? Do you know of anyone
- else who has gotten IRIS subprocesses to work more reliably?
-
-4) Below is a hack adapted from ramsdell@linus.uucp which can be pretty
- useful in gdb. Instead of using gdb to patch extensive changes to a
- particular function, you can do the following (assuming the 50 lines
- of code below is part of your executable):
- 1) create a new file (foo.c) containing the new function
- 2) run cc -c foo.c
- 3) in gdb, and patch in the new function as follows:
-
-(gdb) info breakpoints
-/* Load in the new object code... */
-#1 y 0x00000125 in main (dyn.c line 46)
- break only if $function = funload ("foo"), 1
- silent
- echo new code for func ($function) initialized\n
- cont
-
-/* ...and use it instead of the old code. */
-#2 y 0x000001c2 in func (dyn.c line 59)
- break only if $ret = $function (a), 1
- silent
- set a = $ret
- j 60 /* func has a return on line 60 */
-
- This is more complicated than it has to be because of 2 bugs in v2.1:
- 1) function calls in a breakpoint command list seem to abort
- the execution of the rest of the command list. This is
- why all function calls are in the conditional part.
- (gdb reference manual section 5.5).
-
- 2) A 'return' in a command list also aborts the execution, and
- in addition, prompts you for a y/n.
- (gdb reference manual section 11.1).
-
- On the other hand, after doing 'cc -c foo.c' (which is pretty fast),
- you can simply rerun your program to check out the changes.
- This can be a big win!
-
-The code for this is included below (compile with cc -g):
-========================================================
-
-#include <stdio.h>
-#include <a.out.h>
-
-typedef int (*intfun)();
-char *myname;
-
-intfun funload (filename) /* Dynamically load 1st function from a .o */
- char *filename;
-{
- int fd, size;
- struct exec hdr;
- char buf[100];
- intfun fun;
-
- /* -A => incremental loading - use dyn as the base symbol table
- -T => set the text segment origin to the following hex address
- -N => magic number 407 (text not read-only)
- */
- sprintf (buf, "ld -A %s -T %x -N %s.o -o %s -lc",
- myname, sbrk (0), filename, filename);
-
- /* NOTE: if anything mallocs space between here and below, this will fail */
- system (buf);
-
- fd = open (filename, 0);
- read (fd, &hdr, sizeof(hdr));
- size = hdr.a_text + hdr.a_data + hdr.a_bss;
-
- if ((fun = (intfun) sbrk (size)) < 0)
- printf ("Couldn't find the space"), exit();
-
- read (fd, fun, size); /* Load code. */
- /* NOTE: if anything mallocs space between here and above, this will fail */
-
- close (fd);
- return ((intfun) fun);
-}
-
-main (argc, argv)
- char **argv;
-{
- intfun fun1, fun2;
-
- myname = *argv;
-
- fun1 = funload("fun1");
- printf ("The answer is %d.\n", (*fun1)(11) );
-
- fun2 = funload("fun2");
- printf ("The answer is %d.\n", (*fun2)() );
-}\f
-1,edited,,
-Received: by PREP.AI.MIT.EDU; Tue, 16 Jun 87 03:12:54 EDT
-Date: Tue, 16 Jun 87 03:12:54 EDT
-From: rms (Richard M. Stallman)
-Message-Id: <8706160712.AA07910@prep.ai.mit.edu>
-To: rms
-Subject: GDB ideas
-
-*** EOOH ***
-Date: Tue, 16 Jun 87 03:12:54 EDT
-From: rms (Richard M. Stallman)
-To: rms
-Subject: GDB ideas
-
-* Within a user-defined command, have local convenience variables,
-local functions, local defined commands.
-
-** Optionally echo commands within a user-defined command.
-
-** Optionally record all user-typed commands in a log file.
-Optionally record GDB output there too, marked as output so it
-will not be executed if replayed.
-
-* Execution commands
-
-** Step until next branch, or next call.
-(finish is step until next return).
-
-step branch
-or should it be
-continue branch
-
-** Stop on any branch, call or return
-affecting ordinary step and continue commands.
-
-stop branch
-
-** Trace all branches, calls, returns.
-This could be done by stopping on those events
-and having a continue command to be executed after.
-
-stop branch
-commands branch
-continue
-end
-
-** Commands to continue or step without any display after stop.
-These may be useful in user-defined commands.
-
-Have one prefix command that does this, modifying whatever other
-command you might use. For example,
-
-silent step 5
-silent cont
-
-** Clear all breakpoint ignore-counts when inferior exits or is killed.
-
-** Trace changes to a location (watchpoint).
-Enable and disable them.
-
-** Info command to show command-line for running the program.
-
-* Auto-display
-
-** Enable and disable display expressions.
-Allow syntax 1d, 2d, etc. in enable, disable and delete commands.
-Then there is no more need for an undisplay command.
-
-** Displaying an auto variable should not do it in the wrong stack frame.
-Either it should search for the proper stack frame to apply to
-or it should deactivate itself when in the wrong frame.
-
-* Printing
-
-** Print an address as <file:line>+offset.
-
-** Abbreviate initial whitespace modulo 16.
-
-** p/x of an array should print each element with /x.
-
-** Change the stack scan so that it has a more general idea
-of what info is needed to describe a frame fully.
-
-* Expressions
-
-** Array slices. Can replace @.
-
-** %name for use of symbol names containing funny characters.
-
-** User-defined convenience functions that can appear in expressions.
-
-** Expression syntax to convert line number to address.
-
-** Expression syntax to specify a name scope with an address, line number
-or frame number.
-
-Use the line number by itself, or an address with *, just as in b or l cmd:
-38:foo or *0x40a:foo. No good; the latter would be parsed as
-*(0x40a:foo).
-
-** Expression syntax to convert a frame number to its pc.
-Perhaps unary %.
-
-* Possible bugs
-
-** Does set $pc= cause the current scope to be recalculated?
-It should.
-\1f\f
-1,,
-Received: by PREP.AI.MIT.EDU; Wed, 17 Jun 87 09:59:37 EDT
-From: phr@ATHENA.MIT.EDU
-Received: by ATHENA (5.45/4.7)
- id AA09084; Wed, 17 Jun 87 08:54:36 EDT
-Received: by ORPHEUS.MIT.EDU (5.45/4.7) id AA02565; Wed, 17 Jun 87 08:54:29 EDT
-Date: Wed, 17 Jun 87 08:54:29 EDT
-Message-Id: <8706171254.AA02565@ORPHEUS.MIT.EDU>
-To: rms@prep.ai.mit.edu
-Subject: gdb suggestion
-Status: RO
-
-*** EOOH ***
-From: phr@ATHENA.MIT.EDU
-Date: Wed, 17 Jun 87 08:54:29 EDT
-To: rms@prep.ai.mit.edu
-Subject: gdb suggestion
-
-Completion of file and function names; e.g. typing
- break XWriteBi
-prints
- No such symbol: XWriteBi.
- Setting default command to "break XWriteBitmapFile"
-so you can set a break at XWriteBitmapFile by hitting return a second
-time. Other interfaces ("complete to XWriteBitmapFile? (y/n)")
-are also possible.
-
-\1f\f
-1,edited,,
-Received: by PREP.AI.MIT.EDU; Wed, 24 Sep 86 16:33:11 EDT
-Date: Wed, 24 Sep 86 16:33:11 EDT
-From: mly (Richard Mlynarik)
-Message-Id: <8609242033.AA11520@prep.ai.mit.edu>
-To: rms
-Cc: mly-prep
-Subject: gdb gripes/suggestions/requests
-
-*** EOOH ***
-Date: Wed, 24 Sep 86 16:33:11 EDT
-From: mly (Richard Mlynarik)
-To: rms
-Cc: mly-prep
-Subject: gdb gripes/suggestions/requests
-
-If would be really nice to have some way to do conditionals in user
- commands -- though this is really stretching the functionality of
- gdb a little too much, perhaps. (see ~mly/e/.gdbint for some of
- the contortions I go through with || to get conditional
- evaluation...)
-
-A -real- win wuold be some way to execute until he next function-call
- (like c-d in the cadr debugger) This would even be useful if it
- were rather slow -- it would probably be faster than setting
- temporary breakpoints in all the functions which might be called,
- and would certainly be faster than "step"ping one's way until a
- funcall happened.
-
-"info source" should mention what the directory search-path is (ie
- what "info dir" says) and in which directory it found each of the
- source files (and which source files it cannot locate in the
- search-path)
-
-\1f\f
-1,,
-Received: by xcssun.Berkeley.EDU (5.57/1.25)
- id AA22869; Thu, 22 Oct 87 09:50:30 PDT
-Received: from prep.ai.mit.edu by wheaties.ai.mit.edu; Thu, 22 Oct 87 12:17:59 EDT
-Received: by PREP.AI.MIT.EDU; Thu, 22 Oct 87 12:21:00 EDT
-Received: from pp.mcc.com by MCC.COM with TCP; Thu 22 Oct 87 10:54:41-CDT
-Posted-Date: Thu, 22 Oct 87 10:55:13 CDT
-Received: from big-d.aca.mcc.com by pp.mcc.com (4.12/KA70822)
- id AA16571; Thu, 22 Oct 87 10:55:19 cdt
-Return-Path: <tiemann@big-d.aca.mcc.com>
-Received: by big-d.aca.mcc.com (3.2/KA70106)
- id AA04247; Thu, 22 Oct 87 10:55:13 CDT
-Date: Thu, 22 Oct 87 10:55:13 CDT
-From: tiemann%pp.mcc.com@mcc.com (Michael Tiemann)
-Message-Id: <8710221555.AA04247@big-d.aca.mcc.com>
-To: bug-gdb@prep.ai.mit.edu
-Subject: expanding file names
-
-*** EOOH ***
-Posted-Date: Thu, 22 Oct 87 10:55:13 CDT
-Return-Path: <tiemann@big-d.aca.mcc.com>
-Date: Thu, 22 Oct 87 10:55:13 CDT
-From: tiemann%pp.mcc.com@mcc.com (Michael Tiemann)
-To: bug-gdb@prep.ai.mit.edu
-Subject: expanding file names
-
-When running a program, gdb thoughtfully passes the argument list
-through the shell, expanding files and environment variables as
-needed. It would be nice if the same facility were added to the
-command which adds directories to search paths. For example, it would
-be nice to say "dir ~/foo" .
-
-Michael
-
-\1f\f
-1,,
-Received: by xcssun.Berkeley.EDU (5.57/1.25)
- id AA25075; Fri, 23 Oct 87 10:42:52 PDT
-Received: from prep.ai.mit.edu by wheaties.ai.mit.edu; Fri, 23 Oct 87 13:39:37 EDT
-Received: by PREP.AI.MIT.EDU; Fri, 23 Oct 87 13:42:53 EDT
-Received: from relay2.cs.net by RELAY.CS.NET id ac11193; 23 Oct 87 13:03 EDT
-Received: from umb.edu by RELAY.CS.NET id ac05949; 23 Oct 87 13:01 EDT
-Received: by umb.umb.edu; Fri, 23 Oct 87 10:18:40 EDT
-Received: by ileaf.uucp (1.1/SMI-3.0DEV3)
- id AA00599; Wed, 21 Oct 87 10:56:52 EDT
-Received: from marvin.io.uucp by io.uucp (1.1/SMI-3.0DEV3)
- id AA01359; Wed, 21 Oct 87 10:58:45 EDT
-Received: by marvin.io.uucp (3.2/SMI-3.2)
- id AA00334; Wed, 21 Oct 87 11:02:20 EDT
-Date: Wed, 21 Oct 87 11:02:20 EDT
-From: Mark Dionne <io!marvin!md%ileaf.uucp%umb.umb.edu@relay.cs.net>
-Message-Id: <8710211502.AA00334@marvin.io.uucp>
-To: ileaf!umb!bug-gdb@prep.ai.mit.edu
-Subject: gdb bug
-
-*** EOOH ***
-Date: Wed, 21 Oct 87 11:02:20 EDT
-From: Mark Dionne <io!marvin!md%ileaf.uucp%umb.umb.edu@relay.cs.net>
-To: ileaf!umb!bug-gdb@prep.ai.mit.edu
-Subject: gdb bug
-
-The /FMT and @ options of the "print" command seem to interact
-in GDB 2.1. For example:
-
-(gdb) p ($cmpn.buf[-1])@($cmpn.gapb - $cmpn.buf + 1)
-$17 = {-16383, -24285, 55, 27944, -24285, -24285, 55, 28010, -24285,
--24285, 55, 28076, -24285, -24285, 55, 28142, -24285}
-(gdb) p/x ($cmpn.buf[-1])@($cmpn.gapb - $cmpn.buf + 1)
-$18 = 0xc001
-
-I guess I see what's happening: the /x is applying to the whole
-array rather than to the individual elements. Feature or bug?
-
- ...!harvard!umb!ileaf!md Mark Dionne, Interleaf
- ...!sun!sunne!ileaf!md Ten Canal Park, Cambridge, MA 02141
- (617) 577-9813 x5551
-
-
-\1f\f
-1,,
-Received: by PREP.AI.MIT.EDU; Sun, 6 Sep 87 14:27:19 EDT
-Message-Id: <8709061827.AA18170@prep.ai.mit.edu>
-Received: from relay2.cs.net by RELAY.CS.NET id af03990; 6 Sep 87 14:22 EDT
-Received: from umb.edu by RELAY.CS.NET id ab03029; 6 Sep 87 14:16 EDT
-Received: by umb.umb.edu; Sun, 6 Sep 87 12:10:34 EDT
-Date: Sun, 6 Sep 87 12:10:34 EDT
-Received: by typo.umb.edu; Sun, 6 Sep 87 12:04:21 EDT
-From: Robert Morris <ram%typo.umb.edu@RELAY.CS.NET>
-To: bug-gdb@PREP.AI.MIT.EDU
-Subject: convenient script
-
-*** EOOH ***
-Date: Sun, 6 Sep 87 12:10:34 EDT
-From: Robert Morris <ram%typo.umb.edu@RELAY.CS.NET>
-To: bug-gdb@PREP.AI.MIT.EDU
-Subject: convenient script
-
-I find it easier to maintain binaries on our heterogenous
-network if I keep this trivial script in gdb source directory. Use it
-if you want.
-
-
-------------
-
-#! /bin/csh -f
-# SETUP
-# setup gdb files for presently known machines
-# ram@umb.edu
-# (ram%umb.edu@relay.cs.net if you have an incomplete mailer)
-# or ...!harvard!umb!ram
-#
-# e.g. SETUP sun3
-# note that sunX means major release X of sun software, generally
-# sun3 at this writing (gnu 18.41)
-#
-# note GDB with gnuemacs 18.41 is already configured for vaxen
-
-# Bob Morris, UMASS-Boston 9/6/87
-switch ($1)
- case "sun2":
- ;
- case "sun3" :
- set cputype="m68k";
- set inittype="suninit";
- breaksw;
- default :
- set cputype=$1;
- set inittype=$1init;
- breaksw;
-endsw
-echo \#include \"m-$1.h\" > param.h
-echo \#include \"$cputype-pinsn.c\" > pinsn.c
-ed initialize.h <<! >& /dev/null
-/init.h/
-c
-#include "m-$inittype.h"
-.
-w
-q
-!
-
-
-
-\1f\f
-1,answered,,
-Received: from prep.ai.mit.edu by wheaties.ai.mit.edu; Sat, 19 Dec 87 18:18:50 EST
-Received: by PREP.AI.MIT.EDU; Sat, 19 Dec 87 18:24:38 EST
-Received: from big-d.aca.mcc.com by MCC.COM with TCP; Sat 19 Dec 87 17:19:48-CST
-Date: Sat, 19 Dec 87 17:19:41 CST
-From: tiemann@mcc.com (Michael Tiemann)
-Posted-Date: Sat, 19 Dec 87 17:19:41 CST
-Message-Id: <8712192319.AA26775@big-d.aca.mcc.com>
-Received: by big-d.aca.mcc.com (3.2/ACA-V2.1)
- id AA26775; Sat, 19 Dec 87 17:19:41 CST
-To: rms@prep.ai.mit.edu
-Subject: gdb
-
-*** EOOH ***
-Date: Sat, 19 Dec 87 17:19:41 CST
-From: tiemann@mcc.com (Michael Tiemann)
-Posted-Date: Sat, 19 Dec 87 17:19:41 CST
-To: rms@prep.ai.mit.edu
-Subject: gdb
-
-file values.c, function unpack_field_as_long:
-
- val &= (1 << bitsize) - 1;
-
-This is not as machine independent as it could be. If you feel like
-fixing this potential problem, there are many other instances to worry
-about.
-
-Michael
-
-\1f\f
-1,,
-Received: by xcssun.Berkeley.EDU (5.57/1.25)
- id AA04771; Thu, 20 Aug 87 22:33:25 PDT
-Received: from [128.52.22.14] by ucbvax.Berkeley.EDU (5.58/1.27)
- id AA07119; Thu, 20 Aug 87 00:37:04 PDT
-Received: by PREP.AI.MIT.EDU; Thu, 20 Aug 87 03:37:35 EDT
-Date: Thu, 20 Aug 87 03:37:35 EDT
-From: rms@prep.ai.mit.edu (Richard M. Stallman)
-Message-Id: <8708200737.AA15589@prep.ai.mit.edu>
-To: rms@prep.ai.mit.edu
-Subject: GDB changes for next version
-
-*** EOOH ***
-Date: Thu, 20 Aug 87 03:37:35 EDT
-From: rms@prep.ai.mit.edu (Richard M. Stallman)
-To: rms@prep.ai.mit.edu
-Subject: GDB changes for next version
-
-1. Use links, rather than editing some files, to configure it.
-
-2. Can misc functions eval as their addresses rather than as
- a char in that address? Is this reasonable in all cases
- given that non-functions cannot be distinguished
- and that you might use the result in various ways (arithmetic, etc.).
-
-\1f\f
-1,,
-Received: by xcssun.Berkeley.EDU (5.57/1.25)
- id AA09136; Sat, 29 Aug 87 02:20:15 PDT
-Received: from PREP.AI.MIT.EDU by ucbvax.Berkeley.EDU (5.58/1.27)
- id AA26072; Sat, 29 Aug 87 02:21:51 PDT
-Received: by PREP.AI.MIT.EDU; Sat, 29 Aug 87 05:22:30 EDT
-Received: by RUTGERS.EDU (5.54/1.14) with UUCP
- id AA22247; Sat, 29 Aug 87 05:21:13 EDT
-Received: from sequent.UUCP by spool.wisc.edu; Sat, 29 Aug 87 04:18:41 CDT
-Received: from reed.UUCP by ogcvax.OGC.EDU (5.51/OGC_4.8)
- id AA08044; Fri, 28 Aug 87 20:06:41 PDT
-Received: by reed.UUCP (5.51/5.17)
- id AA05059; Fri, 28 Aug 87 19:19:15 PDT
-From: uwvax!sequent!ogcvax!reed!keith@rutgers.edu (Keith Packard)
-Message-Id: <8708290219.AA05059@reed.UUCP>
-To: rms@prep.ai.mit.edu
-Subject: Re: GDB
-In-Reply-To: Your message of Thu, 20 Aug 87 03:39:37 EDT.
- <8708200735.AA26546@EDDIE.MIT.EDU>
-Date: Fri, 28 Aug 87 19:19:13 PDT
-
-*** EOOH ***
-From: uwvax!sequent!ogcvax!reed!keith@rutgers.edu (Keith Packard)
-To: rms@prep.ai.mit.edu
-Subject: Re: GDB
-In-Reply-To: Your message of Thu, 20 Aug 87 03:39:37 EDT.
- <8708200735.AA26546@EDDIE.MIT.EDU>
-Date: Fri, 28 Aug 87 19:19:13 PDT
-
-
-Here is a simple test program for exibiting the trouble with signals:
-
------
-# include <signal.h>
-
-main ()
-{
- int handle ();
- int i;
- signal (SIGALRM, handle);
- alarm (5);
- for (i = 0; i < 100000; i++)
- printf ("%d\n", i);
-}
-
-handle ()
-{
- printf ("signal!\n");
- alarm (5);
-}
------
-
-To demonstrate the problem, simply place a breakpoint before the call to
-alarm and then start stepping through the program:
-
-(gdb) break 7
-(gdb) step
-...
-...
-
-Eventually, the alarm call occurs and the program ends up in some
-signal handling code -- unfortuantely a machine dependent location. At this
-point, because the fp has moved out of the current function (in fact on
-many machines the frame is not in a consistent state at this point) gdb
-assumes that a new function has started and suspends execution with another
-prompt.
-
-A reasonable solution would be to have gdb insert a breakpoint at the
-expected signal return address and continue to that breakpoint -- I've
-implemented this and found that it works. There is, however, one nasty
-problem -- longjmp around the suspended frame and the breakpoint is not hit
-at the expected time.
-
-Have fun...
-
-keith packard
-
-tektronix!reed!keith
-
-\1f\f
-1,,
-Received: by xcssun.Berkeley.EDU (5.57/1.25)
- id AA09143; Sat, 29 Aug 87 02:24:58 PDT
-Received: by neptune.Berkeley.EDU (5.57/1.25)
- id AA03738; Sat, 29 Aug 87 02:24:50 PDT
-Date: Sat, 29 Aug 87 02:24:50 PDT
-From: rms@neptune.berkeley.edu (Richard Stallman)
-Message-Id: <8708290924.AA03738@neptune.Berkeley.EDU>
-To: rms@neptune.Berkeley.EDU
-Subject: GDB bug
-Reply-To: rms@prep.ai.mit.edu
-
-*** EOOH ***
-Date: Sat, 29 Aug 87 02:24:50 PDT
-From: rms@neptune.berkeley.edu (Richard Stallman)
-To: rms@neptune.Berkeley.EDU
-Subject: GDB bug
-Reply-To: rms@prep.ai.mit.edu
-
-Is there any way to make GDB, when stepping across a function call,
-notice any attempt to longjump out of that call?
-Perhaps an implicit breakpoint at longjump.
-If longjump is called, find the pc in the jmp_buf and put
-a self-deleting breakpoint there.
-
-\1f\f
-1,,
-Received: by xcssun.Berkeley.EDU (5.57/1.25)
- id AA07976; Fri, 28 Aug 87 09:26:12 PDT
-Received: from PREP.AI.MIT.EDU by ucbvax.Berkeley.EDU (5.58/1.27)
- id AA03230; Fri, 28 Aug 87 09:28:04 PDT
-Received: by PREP.AI.MIT.EDU; Fri, 28 Aug 87 12:28:43 EDT
-Date: Fri, 28 Aug 87 12:28:43 EDT
-From: phr@prep.ai.mit.edu (Paul Rubin)
-Message-Id: <8708281628.AA09926@prep.ai.mit.edu>
-To: rms@prep.ai.mit.edu
-Subject: gdb suggestions
-
-*** EOOH ***
-Date: Fri, 28 Aug 87 12:28:43 EDT
-From: phr@prep.ai.mit.edu (Paul Rubin)
-To: rms@prep.ai.mit.edu
-Subject: gdb suggestions
-
-1. I wish gdb had a command to re-read the sources so that I can edit
-the program and recompile it without having to kill and restart gdb.
-
-2. Would be nice if gdb could somehow connect the subprocess's tty channels
-to a pty, so I can run gdb in an X window and the subprocess in a different
-(xterm) window.
-
-This might need hair to detect if the subprocess is running when you try
-to examine variables, etc. and stop the subproc or report an error if it is.
-
-\1f
\ No newline at end of file
/* Memory-access and commands for inferior process, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
#include <signal.h>
#include <sys/param.h>
-#ifdef mac_aux
-/* Warning! This table is positional and highly dependent on the local
- system. Check it closely against <sys/signal.h> when porting. */
-char *sys_siglist[] = {
- "Signal 0",
- "Hangup",
- "Interrupt",
- "Quit",
- "Invalid instruction",
- "Trace/breakpoint trap",
- "IOT trap",
- "EMT trap",
- "Floating point exception",
- "Killed",
- "Bus error",
- "Segmentation fault",
- "Bad system call",
- "Broken pipe",
- "Alarm clock",
- "Terminated",
- "User signal 1",
- "User signal 2",
- "Child exited",
- "Power-fail restart",
- "Stopped",
- "Stopped (tty input)",
- "Stopped (tty output)",
- "Stopped (signal)",
- "Cputime limit exceeded",
- "File size limit exceeded",
- "Virtual timer expired",
- "Profiling timer expired",
- "Window changed",
- "Continued",
- "Urgent I/O condition",
- "I/O possible",
-};
-#else
-/* More portable systems do it for you */
extern char *sys_siglist[];
-#endif
#define ERROR_NO_INFERIOR \
if (inferior_pid == 0) error ("The program is not being run.");
if (!args) args = "";
inferior_args = concat (" ", args, "");
}
-
+
void
tty_command (file)
char *file;
error ("Program already started.");
}
- if (args)
- set_args_command (args);
-
- exec_file = (char *) get_exec_file ();
- if (from_tty)
+ if (remote_debugging)
{
- printf ("Starting program: %s%s\n",
- exec_file, inferior_args);
- fflush (stdout);
+ free (allargs);
+ if (from_tty)
+ {
+ printf ("Starting program: %s%s\n",
+ exec_file, inferior_args);
+ fflush (stdout);
+ }
}
+ else
+ {
+ if (args)
+ set_args_command (args);
- allargs = concat ("exec ", exec_file, inferior_args);
- inferior_pid = create_inferior (allargs, environ_vector (inferior_environ));
+ exec_file = (char *) get_exec_file ();
+ if (from_tty)
+ {
+ printf ("Starting program: %s%s\n",
+ exec_file, inferior_args);
+ fflush (stdout);
+ }
+
+ allargs = concat ("exec ", exec_file, inferior_args);
+ inferior_pid = create_inferior (allargs, environ_vector (inferior_environ));
+ }
clear_proceed_status ();
int from_tty;
{
register CORE_ADDR addr;
+ struct symtabs_and_lines sals;
struct symtab_and_line sal;
ERROR_NO_INFERIOR;
if (!arg)
error_no_arg ("starting address");
- sal = decode_line_spec (arg, 1);
+ sals = decode_line_spec (arg, 1);
+ if (sals.nelts != 1)
+ {
+ error ("Unreasonable jump request");
+ }
+
+ sal = sals.sals[0];
+ free (sals.sals);
if (sal.symtab == 0 && sal.pc == 0)
error ("No source file has been specified.");
/*
* attach_command --
* takes a program started up outside of gdb and ``attaches'' to it.
- * This stops it cold in it's tracks and allows us to start tracing
- * it. For this to work, we must be able to send the process a
+ * This stops it cold in its tracks and allows us to start tracing it.
+ * For this to work, we must be able to send the process a
* signal and we must have the same effective uid as the program.
*/
static void
{
char *exec_file;
int pid;
+ int remote;
dont_repeat();
if (!args)
error_no_arg ("process-id to attach");
+
+ while (*args == ' ' || *args == '\t') args++;
+
+ if (args[0] == '/')
+ remote = 1;
else
pid = atoi (args);
if (from_tty)
{
- printf ("Attaching program: %s pid %d\n",
- exec_file, pid);
+ if (remote)
+ printf ("Attaching remote machine\n");
+ else
+ printf ("Attaching program: %s pid %d\n",
+ exec_file, pid);
fflush (stdout);
}
- attach_program (pid);
+ if (remote)
+ {
+ remote_open (args, from_tty);
+ start_remote ();
+ }
+ else
+ attach_program (pid);
}
/*
extern int inferior_pid;
+/* Nonzero if debugging a remote machine via a serial link or ethernet. */
+
+extern int remote_debugging;
+
/* Last signal that the inferior received (why it stopped). */
extern int stop_signal;
#include "inferior.h"
#include <stdio.h>
-#include <sys/types.h>
#include <sys/param.h>
#include <sys/dir.h>
+#include <sys/user.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sgtty.h>
#include <fcntl.h>
-#ifdef mac_aux
-#include <sys/seg.h>
-#include <sys/mmu.h>
-#include <sys/signal.h>
-#include <sys/time.h>
-#include <sys/user.h>
-#else
-#include <sys/user.h>
-#endif /* mac_aux */
-
-
#ifdef UMAX_PTRACE
#include <a.out.h>
#endif
#include <machine/reg.h>
#endif
-#ifdef SYSV_TTYS
-#include <termio.h>
-#endif
-
extern int errno;
/* Nonzero if we are debugging an attached outside process
static int attach_flag;
-#define UPAGE_MASK 0x00003FFF
-
START_FILE
\f
/* Record terminal status separately for debugger and inferior. */
-#ifdef SYSV_TTYS
-static struct termio ti_inferior;
-#else
static struct sgttyb sg_inferior;
static struct tchars tc_inferior;
static struct ltchars ltc_inferior;
static int lmode_inferior;
-#endif
static int tflags_inferior;
static int pgrp_inferior;
-#ifdef SYSV_TTYS
-static struct termio ti_ours;
-#else
static struct sgttyb sg_ours;
static struct tchars tc_ours;
static struct ltchars ltc_ours;
static int lmode_ours;
-#endif
static int tflags_ours;
static int pgrp_ours;
void
terminal_init_inferior ()
{
+ if (remote_debugging)
+ return;
-#ifdef SYSV_TTYS
- ti_inferior = ti_ours;
-#else
sg_inferior = sg_ours;
tc_inferior = tc_ours;
ltc_inferior = ltc_ours;
lmode_inferior = lmode_ours;
-#endif
tflags_inferior = tflags_ours;
pgrp_inferior = inferior_pid;
void
terminal_inferior ()
{
+ if (remote_debugging)
+ return;
+
if (terminal_is_ours) /* && inferior_thisrun_terminal == 0) */
{
fcntl (0, F_SETFL, tflags_inferior);
fcntl (0, F_SETFL, tflags_inferior);
-#ifdef SYSV_TTYS
- ioctl (0, TCSETA, &ti_inferior);
-#else
ioctl (0, TIOCSETN, &sg_inferior);
ioctl (0, TIOCSETC, &tc_inferior);
ioctl (0, TIOCSLTC, <c_inferior);
ioctl (0, TIOCLSET, &lmode_inferior);
-#endif
ioctl (0, TIOCSPGRP, &pgrp_inferior);
}
terminal_is_ours = 0;
void
terminal_ours_for_output ()
{
+ if (remote_debugging)
+ return;
+
terminal_ours_1 (1);
}
void
terminal_ours ()
{
+ if (remote_debugging)
+ return;
+
terminal_ours_1 (0);
}
signal (SIGTTOU, osigttou);
tflags_inferior = fcntl (0, F_GETFL, 0);
-#ifdef SYSV_TTYS
- ioctl (0, TCGETA, &ti_inferior);
-#else
ioctl (0, TIOCGETP, &sg_inferior);
ioctl (0, TIOCGETC, &tc_inferior);
ioctl (0, TIOCGLTC, <c_inferior);
ioctl (0, TIOCLGET, &lmode_inferior);
-#endif
}
- fcntl (0, F_SETFL, tflags_ours);
- fcntl (0, F_SETFL, tflags_ours);
-
-
-#ifdef SYSV_TTYS
- ti_ours.c_lflag |= ICANON | ISIG;
- if (output_only)
- ti_ours.c_lflag &= ~((ICANON|ISIG)&ti_inferior.c_lflag);
- ioctl (0, TCSETA, &ti_ours);
- ti_ours.c_lflag |= ICANON | ISIG;
-#else
sg_ours.sg_flags &= ~RAW & ~CBREAK;
if (output_only)
sg_ours.sg_flags |= (RAW | CBREAK) & sg_inferior.sg_flags;
+
+ fcntl (0, F_SETFL, tflags_ours);
+ fcntl (0, F_SETFL, tflags_ours);
ioctl (0, TIOCSETN, &sg_ours);
ioctl (0, TIOCSETC, &tc_ours);
ioctl (0, TIOCSLTC, <c_ours);
ioctl (0, TIOCLSET, &lmode_ours);
sg_ours.sg_flags &= ~RAW & ~CBREAK;
-#endif
}
static void
term_status_command ()
{
register int i;
+
+ if (remote_debugging)
+ {
+ printf ("No terminal status when remote debugging.\n");
+ return;
+ }
+
printf ("Inferior's terminal status (currently saved by GDB):\n");
-#ifdef SYSV_TTYS
- printf ("fcntl flags = 0x%x, owner pid = %d.\n",
- tflags_inferior, pgrp_inferior);
- printf ("iflag = 0x%04x, oflag = 0x%04x, cflag = 0x%04x, lflag = 0x%04x\n",
- ti_inferior.c_iflag, ti_inferior.c_oflag,
- ti_inferior.c_cflag, ti_inferior.c_lflag);
- printf ("line discipline = %d\n", ti_inferior.c_line);
- printf ("control chars: ");
- for (i = 0; i < NCC; i++)
- printf ("0x%x ", ti_inferior.c_cc[i]);
- printf ("\n");
-#else
printf ("fcntl flags = 0x%x, lmode = 0x%x,\nsgttyb.sg_flags = 0x%x, owner pid = %d.\n",
tflags_inferior, lmode_inferior,
sg_inferior.sg_flags, pgrp_inferior);
for (i = 0; i < sizeof (struct ltchars); i++)
printf ("0x%x ", ((char *)<c_inferior)[i]);
printf ("\n");
-#endif
}
\f
static void
static void
kill_command ()
{
+ if (remote_debugging)
+ return;
if (inferior_pid == 0)
error ("The program is not being run.");
if (!query ("Kill the inferior process? "))
kill_inferior ()
{
+ if (remote_debugging)
+ return;
if (inferior_pid == 0)
return;
ptrace (8, inferior_pid, 0, 0);
int signal;
{
errno = 0;
- ptrace (step ? 9 : 7, inferior_pid, 1, signal);
- if (errno)
- perror_with_name ("ptrace");
+ if (remote_debugging)
+ remote_resume (step, signal);
+ else
+ {
+ ptrace (step ? 9 : 7, inferior_pid, 1, signal);
+ if (errno)
+ perror_with_name ("ptrace");
+ }
}
\f
#ifdef NEW_SUN_PTRACE
struct fp_status inferior_fp_registers;
extern char registers[];
- ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers);
- ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers);
-
- bcopy (&inferior_registers, registers, 16 * 4);
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
- sizeof inferior_fp_registers.fps_regs);
- *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
- *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
- bcopy (&inferior_fp_registers.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+ if (remote_debugging)
+ remote_fetch_registers (registers);
+ else
+ {
+ ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers);
+ ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers);
+
+ bcopy (&inferior_registers, registers, 16 * 4);
+ bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ sizeof inferior_fp_registers.fps_regs);
+ *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
+ *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+ bcopy (&inferior_fp_registers.fps_control,
+ ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+ }
}
/* Store our register values back into the inferior.
struct fp_status inferior_fp_registers;
extern char registers[];
- bcopy (registers, &inferior_registers, 16 * 4);
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
- sizeof inferior_fp_registers.fps_regs);
- inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
- inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.fps_control,
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
-
- ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
- ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers);
+ if (remote_debugging)
+ remote_store_registers (registers);
+ else
+ {
+ bcopy (registers, &inferior_registers, 16 * 4);
+ bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+ sizeof inferior_fp_registers.fps_regs);
+ inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
+ inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
+ bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &inferior_fp_registers.fps_control,
+ sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+
+ ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
+ ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers);
+ }
}
#else
#else
struct user u;
unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
- offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
+ offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
#endif
for (regno = 0; regno < NUM_REGS; regno++)
#else
struct user u;
unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
- offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
+ offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
#endif
if (regno >= 0)
/* Read all the longwords */
for (i = 0; i < count; i++, addr += sizeof (int))
- buffer[i] = ptrace (1, inferior_pid, addr, 0);
+ {
+ if (remote_debugging)
+ buffer[i] = remote_fetch_word (addr);
+ else
+ buffer[i] = ptrace (1, inferior_pid, addr, 0);
+ }
/* Copy appropriate bytes out of the buffer. */
bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
}
-/* Copy LEN bytes of data from debugger memnory at MYADDR
+/* Copy LEN bytes of data from debugger memory at MYADDR
to inferior's memory at MEMADDR.
On failure (cannot write the inferior)
returns the value of errno. */
/* Fill start and end extra bytes of buffer with existing memory data. */
- buffer[0] = ptrace (1, inferior_pid, addr, 0);
+ if (remote_debugging)
+ buffer[0] = remote_fetch_word (addr);
+ else
+ buffer[0] = ptrace (1, inferior_pid, addr, 0);
+
if (count > 1)
- buffer[count - 1]
- = ptrace (1, inferior_pid,
- addr + (count - 1) * sizeof (int), 0);
+ {
+ if (remote_debugging)
+ buffer[count - 1]
+ = remote_fetch_word (addr + (count - 1) * sizeof (int));
+ else
+ buffer[count - 1]
+ = ptrace (1, inferior_pid,
+ addr + (count - 1) * sizeof (int), 0);
+ }
/* Copy data to be written over corresponding part of buffer */
for (i = 0; i < count; i++, addr += sizeof (int))
{
errno = 0;
- ptrace (4, inferior_pid, addr, buffer[i]);
+ if (remote_debugging)
+ remote_store_word (addr, buffer[i]);
+ else
+ ptrace (4, inferior_pid, addr, buffer[i]);
if (errno)
return errno;
}
extern int errno;
if (inferior_pid == 0)
- error ("The program is not being run.");
+ error ("There is no inferior process now.");
for (i = 0; ; i += 2)
{
inferior_pid = 0;
-#ifdef SYSV_TTYS
- ioctl (0, TCGETA, &ti_ours);
-#else
ioctl (0, TIOCGETP, &sg_ours);
ioctl (0, TIOCGETC, &tc_ours);
ioctl (0, TIOCGLTC, <c_ours);
ioctl (0, TIOCLGET, &lmode_ours);
-#endif
fcntl (0, F_GETFL, tflags_ours);
ioctl (0, TIOCGPGRP, &pgrp_ours);
/* Start and stop the inferior process, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
int pc_changed;
+/* Nonzero if debugging a remote machine via a serial link or ethernet. */
+
+int remote_debugging;
+
/* Save register contents here when about to pop a stack dummy frame. */
char stop_registers[REGISTER_BYTES];
/* Install inferior's terminal modes. */
terminal_inferior ();
+ if (remote_debugging)
+ {
+ trap_expected = 0;
+ fetch_inferior_registers();
+ set_current_frame (read_register(FP_REGNUM));
+ stop_frame = get_current_frame();
+ inferior_pid = 3;
+ if (insert_breakpoints())
+ fatal("Can't insert breakpoints");
+ breakpoints_inserted = 1;
+ proceed(-1, -1, 0);
+ }
+ else
+ {
+ wait_for_inferior ();
+ normal_stop ();
+ }
+}
+
+/* Start remote-debugging of a machine over a serial link. */
+
+void
+start_remote ()
+{
+ clear_proceed_status ();
+ running_in_shell = 0;
+ trap_expected = 0;
+ inferior_pid = 3;
+ breakpoints_inserted = 0;
+ mark_breakpoints_out ();
wait_for_inferior ();
- normal_stop ();
+ normal_stop();
}
#ifdef ATTACH_DETACH
while (1)
{
prev_pc = read_pc ();
- pid = wait (&w);
+
+ if (remote_debugging)
+ remote_wait (&w);
+ else
+ {
+ pid = wait (&w);
+ if (pid != inferior_pid)
+ continue;
+ }
+
pc_changed = 0;
fetch_inferior_registers ();
stop_pc = read_pc ();
else if (!random_signal && step_range_end)
{
newfun = find_pc_function (stop_pc);
+ newmisc = -1;
if (newfun)
{
newfun_pc = BLOCK_START (SYMBOL_BLOCK_VALUE (newfun))
that in whole or in part contains or is a derivative of this
program or any part thereof, to be licensed at no charge to all
third parties on terms identical to those contained in this
- License Agreement (except that you may choose to grant more
- extensive warranty protection to third parties, at your option).
+ License Agreement (except that you may choose to grant more extensive
+ warranty protection to some or all third parties, at your option).
c) You may charge a distribution fee for the physical act of
transferring a copy, and you may at your option offer warranty
protection in exchange for a fee.
- 3. You may copy and distribute this program or any portion of it in
-compiled, executable or object code form under the terms of Paragraphs
-1 and 2 above provided that you do the following:
-
- a) cause each such copy to be accompanied by the
- corresponding machine-readable source code, which must
- be distributed under the terms of Paragraphs 1 and 2 above; or,
-
- b) cause each such copy to be accompanied by a
- written offer, with no time limit, to give any third party
- free (except for a nominal shipping charge) a machine readable
- copy of the corresponding source code, to be distributed
- under the terms of Paragraphs 1 and 2 above; or,
-
- c) in the case of a recipient of this program in compiled, executable
- or object code form (without the corresponding source code) you
- shall cause copies you distribute to be accompanied by a copy
- of the written offer of source code which you received along
- with the copy you received.
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+ 3. You may copy and distribute this program (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the following:
+
+ a) accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ b) accompany it with a written offer, valid for at least three
+ years, to give any third party free (except for a nominal
+ shipping charge) a complete machine-readable copy of the
+ corresponding source code, to be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ c) accompany it with the information you received as to where the
+ corresponding source code may be obtained. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
4. You may not copy, sublicense, distribute or transfer this program
except as expressly provided under this License Agreement. Any attempt
+++ /dev/null
-/* Parameters for execution on Macintosh under A/UX, for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#ifndef mac_aux
-#define mac_aux
-#endif
-
-/* Get rid of any system-imposed stack limit if possible. */
-
-#undef SET_STACK_LIMIT_HUGE
-
-/* Define this if the C compiler puts an underscore at the front
- of external names before giving them to the linker. */
-
-#undef NAMES_HAVE_UNDERSCORE
-
-/* COFF format object files */
-
-#define COFF_FORMAT
-
-/* System eVil ttys */
-
-#define SYSV_TTYS
-
-/* Debugger information will not be in DBX format. */
-
-#undef READ_DBX_FORMAT
-
-/* Offset from address of function to start of its code.
- Zero on most machines. */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
-
-#define SKIP_PROLOGUE(pc) \
-{ register int op = read_memory_integer (pc, 2); \
- if (op == 0047126) \
- pc += 4; /* Skip link #word */ \
- else if (op == 0044016) \
- pc += 6; /* Skip link #long */ \
-}
-
-/* Immediately after a function call, return the saved pc.
- Can't go through the frames for this because on some machines
- the new frame is not set up until the new function executes
- some instructions. */
-
-#define SAVED_PC_AFTER_CALL(frame) \
-read_memory_integer (read_register (SP_REGNUM), 4)
-
-/* Address of end of stack space. */
-
-#define STACK_END_ADDR 0x20000000
-
-/* Stack grows downward. */
-
-#define INNER_THAN <
-
-/* Sequence of bytes for breakpoint instruction. */
-
-#define BREAKPOINT {0x4e, 0x4f}
-
-/* Amount PC must be decremented by after a breakpoint.
- This is often the number of bytes in BREAKPOINT
- but not always. */
-
-#define DECR_PC_AFTER_BREAK 2
-
-/* Nonzero if instruction at PC is a return instruction. */
-
-#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
-
-/* Return 1 if P points to an invalid floating point value. */
-
-#define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */
-
-/* Say how long (ordinary) registers are. */
-
-#define REGISTER_TYPE long
-
-/* Number of machine registers */
-
-#define NUM_REGS 31
-
-/* Initializer for an array of names of registers.
- There should be NUM_REGS strings in this initializer. */
-
-#define REGISTER_NAMES \
- {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
- "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
- "ps", "pc", \
- "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
- "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags" }
-
-/* Register numbers of various important registers.
- Note that some of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and some are "phony" register numbers which are too large
- to be actual register numbers as far as the user is concerned
- but do serve to get the desired values when passed to read_register. */
-
-#define FP_REGNUM 14 /* Contains address of executing stack frame */
-#define SP_REGNUM 15 /* Contains address of top of stack */
-#define PS_REGNUM 16 /* Contains processor status */
-#define PC_REGNUM 17 /* Contains program counter */
-#define FP0_REGNUM 18 /* Floating point register 0 */
-#define FPC_REGNUM 26 /* 68881 control register */
-
-/* Total amount of space needed to store our copies of the machine's
- register state, the array `registers'. */
-#define REGISTER_BYTES (16*4+8*12+8+20)
-
-/* Index within `registers' of the first byte of the space for
- register N. */
-
-#define REGISTER_BYTE(N) \
- ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168 \
- : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72 \
- : (N) * 4)
-
-/* Number of bytes of storage in the actual machine representation
- for register N. On the 68000, all regs are 4 bytes
- except the floating point regs which are 12 bytes. */
-
-#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
-
-/* Number of bytes of storage in the program's representation
- for register N. On the 68000, all regs are 4 bytes
- except the floating point regs which are 8-byte doubles. */
-
-#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
-
-/* Largest value REGISTER_RAW_SIZE can have. */
-
-#define MAX_REGISTER_RAW_SIZE 12
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Nonzero if register N requires conversion
- from raw format to virtual format. */
-
-#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
-
-/* Convert data from raw format for register REGNUM
- to virtual format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
-{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
- convert_from_68881 ((FROM), (TO)); \
- else \
- bcopy ((FROM), (TO), 4); }
-
-/* Convert data from virtual format for register REGNUM
- to raw format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
-{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
- convert_to_68881 ((FROM), (TO)); \
- else \
- bcopy ((FROM), (TO), 4); }
-
-/* Return the GDB type object for the "standard" data type
- of data in register N. */
-
-#define REGISTER_VIRTUAL_TYPE(N) \
- (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
-
-/* Extract from an array REGBUF containing the (raw) register state
- a function return value of type TYPE, and copy that, in virtual format,
- into VALBUF. */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
-
-/* Write into appropriate registers a function return value
- of type TYPE, given in virtual format. */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
- write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
-
-/* Extract from an array REGBUF containing the (raw) register state
- the address in which a function should return its structure value,
- as a CORE_ADDR (or an expression that can be used as one). */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
-
-/* Enable use of alternate code to read and write registers. */
-
-#undef NEW_SUN_PTRACE
-
-/* Enable use of alternate code for Sun's format of core dump file. */
-
-#undef NEW_SUN_CORE
-
-/* Do implement the attach and detach commands. */
-
-#undef ATTACH_DETACH
-
-/* It is safe to look for symsegs on a Sun, because Sun's ld
- does not screw up with random garbage at end of file. */
-
-#define READ_GDB_SYMSEGS
-\f
-/* Describe the pointer in each stack frame to the previous stack frame
- (its caller). */
-
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer.
-
- FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
- and produces the nominal address of the caller frame.
-
- However, if FRAME_CHAIN_VALID returns zero,
- it means the given frame is the outermost one and has no caller.
- In that case, FRAME_CHAIN_COMBINE is not used. */
-
-/* In the case of the Sun, the frame's nominal address
- is the address of a 4-byte word containing the calling frame's address. */
-
-#define FRAME_CHAIN(thisframe) (read_memory_integer (thisframe, 4))
-
-#define FRAME_CHAIN_VALID(chain, thisframe) \
- (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
-
-#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-
-/* Define other aspects of the stack frame. */
-
-#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
-
-#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
-
-#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
-
-/* Set VAL to the number of args passed to frame described by FI.
- Can set VAL to -1, meaning no way to tell. */
-
-/* We can't tell how many args there are
- now that the C compiler delays popping them. */
-#define FRAME_NUM_ARGS(val,fi) (val = -1)
-
-#if 0
-#define FRAME_NUM_ARGS(val, fi) \
-{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame); \
- register int insn = 0177777 & read_memory_integer (pc, 2); \
- val = 0; \
- if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */ \
- val = read_memory_integer (pc + 2, 2); \
- else if ((insn & 0170777) == 0050217 /* addql #N, sp */ \
- || (insn & 0170777) == 0050117) /* addqw */ \
- { val = (insn >> 9) & 7; if (val == 0) val = 8; } \
- else if (insn == 0157774) /* addal #WW, sp */ \
- val = read_memory_integer (pc + 2, 4); \
- val >>= 2; }
-#endif
-
-/* Return number of bytes at start of arglist that are not really args. */
-
-#define FRAME_ARGS_SKIP 8
-
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
-
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
-{ register int regnum; \
- register int regmask; \
- register CORE_ADDR next_addr; \
- register CORE_ADDR pc; \
- int nextinsn; \
- bzero (&frame_saved_regs, sizeof frame_saved_regs); \
- if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
- && (frame_info).pc <= (frame_info).frame) \
- { next_addr = (frame_info).frame; \
- pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
- else \
- { pc = get_pc_function_start ((frame_info).pc); \
- /* Verify we have a link a6 instruction next; \
- if not we lose. If we win, find the address above the saved \
- regs using the amount of storage from the link instruction. */\
- if (044016 == read_memory_integer (pc, 2)) \
- next_addr = (frame_info).frame + read_memory_integer (pc += 2, 4), pc+=4; \
- else if (047126 == read_memory_integer (pc, 2)) \
- next_addr = (frame_info).frame + read_memory_integer (pc += 2, 2), pc+=2; \
- else goto lose; \
- /* If have an addal #-n, sp next, adjust next_addr. */ \
- if ((0177777 & read_memory_integer (pc, 2)) == 0157774) \
- next_addr += read_memory_integer (pc += 2, 4), pc += 4; \
- } \
- /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */ \
- regmask = read_memory_integer (pc + 2, 2); \
- /* But before that can come an fmovem. Check for it. */ \
- nextinsn = 0xffff & read_memory_integer (pc, 2); \
- if (0xf227 == nextinsn \
- && (regmask & 0xff00) == 0xe000) \
- { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */ \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr -= 12); \
- regmask = read_memory_integer (pc + 2, 2); } \
- if (0044327 == read_memory_integer (pc, 2)) \
- { pc += 4; /* Regmask's low bit is for register 0, the first written */ \
- for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; } \
- else if (0044347 == read_memory_integer (pc, 2)) \
- { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \
- for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \
- else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2)) \
- { regnum = 0xf & read_memory_integer (pc, 2); pc += 2; \
- (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \
- /* fmovemx to index of sp may follow. */ \
- regmask = read_memory_integer (pc + 2, 2); \
- nextinsn = 0xffff & read_memory_integer (pc, 2); \
- if (0xf236 == nextinsn \
- && (regmask & 0xff00) == 0xf000) \
- { pc += 10; /* Regmask's low bit is for register fp0, the first written */ \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr += 12) - 12; \
- regmask = read_memory_integer (pc + 2, 2); } \
- /* clrw -(sp); movw ccr,-(sp) may follow. */ \
- if (0x426742e7 == read_memory_integer (pc, 4)) \
- (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4); \
- lose: ; \
- (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8; \
- (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame; \
- (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4; \
-}
-\f
-/* Things needed for making the inferior call functions. */
-
-/* Push an empty stack frame, to record the current PC, etc. */
-
-#define PUSH_DUMMY_FRAME \
-{ register CORE_ADDR sp = read_register (SP_REGNUM); \
- register int regnum; \
- char raw_buffer[12]; \
- sp = push_word (sp, read_register (PC_REGNUM)); \
- sp = push_word (sp, read_register (FP_REGNUM)); \
- write_register (FP_REGNUM, sp); \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \
- { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \
- sp = push_bytes (sp, raw_buffer, 12); } \
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \
- sp = push_word (sp, read_register (regnum)); \
- sp = push_word (sp, read_register (PS_REGNUM)); \
- write_register (SP_REGNUM, sp); }
-
-/* Discard from the stack the innermost frame,
- restoring all saved registers. */
-
-#define POP_FRAME \
-{ register CORE_ADDR fp = read_register (FP_REGNUM); \
- register int regnum; \
- struct frame_saved_regs fsr; \
- struct frame_info fi; \
- char raw_buffer[12]; \
- fi = get_frame_info (fp); \
- get_frame_saved_regs (&fi, &fsr); \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \
- if (fsr.regs[regnum]) \
- { read_memory (fsr.regs[regnum], raw_buffer, 12); \
- write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \
- if (fsr.regs[regnum]) \
- write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
- if (fsr.regs[PS_REGNUM]) \
- write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
- write_register (FP_REGNUM, read_memory_integer (fp, 4)); \
- write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \
- write_register (SP_REGNUM, fp + 8); \
- set_current_frame (read_register (FP_REGNUM)); }
-
-/* This sequence of words is the instructions
- fmovem 0xff,-(sp)
- moveml 0xfffc,-(sp)
- clrw -(sp)
- movew ccr,-(sp)
- /..* The arguments are pushed at this point by GDB;
- no code is needed in the dummy for this.
- The CALL_DUMMY_START_OFFSET gives the position of
- the following jsr instruction. *../
- jsr @#32323232
- addl #69696969,sp
- bpt
- nop
-Note this is 28 bytes.
-We actually start executing at the jsr, since the pushing of the
-registers is done by PUSH_DUMMY_FRAME. If this were real code,
-the arguments for the function called by the jsr would be pushed
-between the moveml and the jsr, and we could allow it to execute through.
-But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
-and we cannot allow the moveml to push the registers again lest they be
-taken for the arguments. */
-
-#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
-
-#define CALL_DUMMY_LENGTH 28
-
-#define CALL_DUMMY_START_OFFSET 12
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
-
-#define FIX_CALL_DUMMY(dummyname, fun, nargs) \
-{ *(int *)((char *) dummyname + 20) = nargs * 4; \
- *(int *)((char *) dummyname + 14) = fun; }
-\f
-/* Interface definitions for kernel debugger KDB. */
-
-/* Map machine fault codes into signal numbers.
- First subtract 0, divide by 4, then index in a table.
- Faults for which the entry in this table is 0
- are not handled by KDB; the program's own trap handler
- gets to handle then. */
-
-#define FAULT_CODE_ORIGIN 0
-#define FAULT_CODE_UNITS 4
-#define FAULT_TABLE \
-{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
- 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
- 0, 0, 0, 0, 0, 0, 0, 0, \
- SIGILL }
-
-/* Start running with a stack stretching from BEG to END.
- BEG and END should be symbols meaningful to the assembler.
- This is used only for kdb. */
-
-#define INIT_STACK(beg, end) \
-{ asm (".globl end"); \
- asm ("movel #end, sp"); \
- asm ("movel #0,a6"); }
-
-/* Push the frame pointer register on the stack. */
-#define PUSH_FRAME_PTR \
- asm ("movel a6,sp@-");
-
-/* Copy the top-of-stack to the frame pointer register. */
-#define POP_FRAME_PTR \
- asm ("movl sp@,a6");
-
-/* After KDB is entered by a fault, push all registers
- that GDB thinks about (all NUM_REGS of them),
- so that they appear in order of ascending GDB register number.
- The fault code will be on the stack beyond the last register. */
-
-#define PUSH_REGISTERS \
-{ asm ("clrw -(sp)"); \
- asm ("pea sp@(10)"); \
- asm ("movem #0xfffe,sp@-"); }
-
-/* Assuming the registers (including processor status) have been
- pushed on the stack in order of ascending GDB register number,
- restore them and return to the address in the saved PC register. */
-
-#define POP_REGISTERS \
-{ asm ("subil #8,sp@(28)"); \
- asm ("movem sp@,#0xffff"); \
- asm ("rte"); }
+++ /dev/null
-
-/* This is how the size of an individual .o file's text segment
- is rounded on a mac under a/ux. */
-
-#define FILEADDR_ROUND(addr) (addr)
+++ /dev/null
-/* Definitions to make GDB run on a merlin under utek 2.1
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#ifndef ns16000
-#define ns16000
-#endif
-
-# include <machine/reg.h>
-
-/* Define this if the C compiler puts an underscore at the front
- of external names before giving them to the linker. */
-
-#define NAMES_HAVE_UNDERSCORE
-
-/* Debugger information will be in DBX format. */
-
-#define READ_DBX_FORMAT
-
-/* Offset from address of function to start of its code.
- Zero on most machines. */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
-
-#define SKIP_PROLOGUE(pc) \
-{ register int op = read_memory_integer (pc, 1); \
- if (op == 0x82) \
- { op = read_memory_integer (pc+2,1); \
- if ((op & 0x80) == 0) pc += 3; \
- else if ((op & 0xc0) == 0x80) pc += 4; \
- else pc += 6; \
- }}
-
-/* Immediately after a function call, return the saved pc.
- Can't always go through the frames for this because on some machines
- the new frame is not set up until the new function executes
- some instructions. */
-
-#define SAVED_PC_AFTER_CALL(frame) \
- read_memory_integer (read_register (SP_REGNUM), 4)
-
-/* This is the amount to subtract from u.u_ar0
- to get the offset in the core file of the register values. */
-
-#define KERNEL_U_ADDR (0xfef000)
-
-/* Address of end of stack space. */
-
-#define STACK_END_ADDR (0x800000)
-
-/* Stack grows downward. */
-
-#define INNER_THAN <
-
-/* Sequence of bytes for breakpoint instruction. */
-
-#define BREAKPOINT {0xf2}
-
-/* Amount PC must be decremented by after a breakpoint.
- This is often the number of bytes in BREAKPOINT
- but not always. */
-
-#define DECR_PC_AFTER_BREAK 0
-
-/* Nonzero if instruction at PC is a return instruction. */
-
-#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12)
-
-/* Return 1 if P points to an invalid floating point value. */
-
-#define INVALID_FLOAT(p, len) 0
-
-/* Define this to say that the "svc" insn is followed by
- codes in memory saying which kind of system call it is. */
-
-#define NS32K_SVC_IMMED_OPERANDS
-
-/* Say how long (ordinary) registers are. */
-
-#define REGISTER_TYPE long
-
-/* Number of machine registers */
-
-#define NUM_REGS 25
-
-#define NUM_GENERAL_REGS 8
-
-/* Initializer for an array of names of registers.
- There should be NUM_REGS strings in this initializer. */
-
-#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
- "pc", "sp", "fp", "ps", \
- "fsr", \
- "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
- "l0", "l1", "l2", "l3", "l4", \
- }
-
-/* Register numbers of various important registers.
- Note that some of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and some are "phony" register numbers which are too large
- to be actual register numbers as far as the user is concerned
- but do serve to get the desired values when passed to read_register. */
-
-#define AP_REGNUM FP_REGNUM
-#define FP_REGNUM 10 /* Contains address of executing stack frame */
-#define SP_REGNUM 9 /* Contains address of top of stack */
-#define PC_REGNUM 8 /* Contains program counter */
-#define PS_REGNUM 11 /* Contains processor status */
-#define FPS_REGNUM 12 /* Floating point status register */
-#define FP0_REGNUM 13 /* Floating point register 0 */
-#define LP0_REGNUM 21 /* Double register 0 (same as FP0) */
-
-#define REGISTER_U_ADDR(addr, blockend, regno) \
-{ \
- switch (regno) { \
- case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: \
- addr = blockend + (R0 - regno) * sizeof (int); break; \
- case PC_REGNUM: \
- addr = blockend + PC * sizeof (int); break; \
- case SP_REGNUM: \
- addr = blockend + SP * sizeof (int); break; \
- case FP_REGNUM: \
- addr = blockend + FP * sizeof (int); break; \
- case PS_REGNUM: \
- addr = blockend + 12 * sizeof (int); break; \
- case FPS_REGNUM: \
- addr = 108; break; \
- case FP0_REGNUM + 0: case FP0_REGNUM + 1: \
- case FP0_REGNUM + 2: case FP0_REGNUM + 3: \
- case FP0_REGNUM + 4: case FP0_REGNUM + 5: \
- case FP0_REGNUM + 6: case FP0_REGNUM + 7: \
- addr = 76 + (regno - FP0_REGNUM) * sizeof (float); break; \
- case LP0_REGNUM + 0: case LP0_REGNUM + 1: \
- case LP0_REGNUM + 2: case LP0_REGNUM + 3: \
- addr = 76 + (regno - LP0_REGNUM) * sizeof (double); break; \
- default: \
- printf ("bad argument to REGISTER_U_ADDR %d\n", regno); \
- abort (); \
- } \
-}
-
-/* Total amount of space needed to store our copies of the machine's
- register state, the array `registers'. */
-#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double))
-
-/* Index within `registers' of the first byte of the space for
- register N. */
-
-#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \
- LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4)
-
-/* Number of bytes of storage in the actual machine representation
- for register N. On the 32000, all regs are 4 bytes
- except for the doubled floating registers. */
-
-#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
-
-/* Number of bytes of storage in the program's representation
- for register N. On the 32000, all regs are 4 bytes
- except for the doubled floating registers. */
-
-#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
-
-/* Largest value REGISTER_RAW_SIZE can have. */
-
-#define MAX_REGISTER_RAW_SIZE 8
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Nonzero if register N requires conversion
- from raw format to virtual format. */
-
-#define REGISTER_CONVERTIBLE(N) 0
-
-/* Convert data from raw format for register REGNUM
- to virtual format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
-
-/* Convert data from virtual format for register REGNUM
- to raw format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
-
-/* Return the GDB type object for the "standard" data type
- of data in register N. */
-
-#define REGISTER_VIRTUAL_TYPE(N) \
- ((N) >= FP0_REGNUM ? \
- ((N) >= LP0_REGNUM ? \
- builtin_type_double \
- : builtin_type_float) \
- : builtin_type_int)
-
-/* Extract from an array REGBUF containing the (raw) register state
- a function return value of type TYPE, and copy that, in virtual format,
- into VALBUF. */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
-
-/* Write into appropriate registers a function return value
- of type TYPE, given in virtual format. */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
- write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
-
-/* Extract from an array REGBUF containing the (raw) register state
- the address in which a function should return its structure value,
- as a CORE_ADDR (or an expression that can be used as one). */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
-\f
-/* Describe the pointer in each stack frame to the previous stack frame
- (its caller). */
-
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer.
-
- FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
- and produces the nominal address of the caller frame.
-
- However, if FRAME_CHAIN_VALID returns zero,
- it means the given frame is the outermost one and has no caller.
- In that case, FRAME_CHAIN_COMBINE is not used. */
-
-/* In the case of the Merlin, the frame's nominal address is the FP value,
- and at that address is saved previous FP value as a 4-byte word. */
-
-#define FRAME_CHAIN(thisframe) (read_memory_integer (thisframe, 4))
-
-#define FRAME_CHAIN_VALID(chain, thisframe) \
- (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
-
-#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-
-/* Define other aspects of the stack frame. */
-
-#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
-
-/* compute base of arguments */
-#define FRAME_ARGS_ADDRESS(fi) ((fi).frame)
-
-#define FRAME_LOCALS_ADDRESS(fi) ((fi).frame)
-
-/* Return number of args passed to a frame.
- Can return -1, meaning no way to tell. */
-
-#define FRAME_NUM_ARGS(numargs, fi) \
-{ CORE_ADDR pc; \
- int insn; \
- int addr_mode; \
- int width; \
- \
- pc = FRAME_SAVED_PC (fi.frame); \
- insn = read_memory_integer (pc,2); \
- addr_mode = (insn >> 11) & 0x1f; \
- insn = insn & 0x7ff; \
- if ((insn & 0x7fc) == 0x57c \
- && addr_mode == 0x14) /* immediate */ \
- { if (insn == 0x57c) /* adjspb */ \
- width = 1; \
- else if (insn == 0x57d) /* adjspw */ \
- width = 2; \
- else if (insn == 0x57f) /* adjspd */ \
- width = 4; \
- numargs = read_memory_integer (pc+2,width); \
- if (width > 1) \
- flip_bytes (&numargs, width); \
- numargs = - sign_extend (numargs, width*8) / 4; } \
- else numargs = -1; \
-}
-
-/* Return number of bytes at start of arglist that are not really args. */
-
-#define FRAME_ARGS_SKIP 8
-
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
-
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
-{ int regmask,regnum; \
- int localcount; \
- CORE_ADDR enter_addr; \
- CORE_ADDR next_addr; \
- \
- enter_addr = get_pc_function_start ((frame_info).pc); \
- regmask = read_memory_integer (enter_addr+1, 1); \
- localcount = ns32k_localcount (enter_addr); \
- next_addr = (frame_info).frame + localcount; \
- for (regnum = 0; regnum < 8; regnum++, regmask >>= 1) \
- (frame_saved_regs).regs[regnum] \
- = (regmask & 1) ? (next_addr -= 4) : 0; \
- (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 4; \
- (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4; \
- (frame_saved_regs).regs[FP_REGNUM] \
- = read_memory_integer ((frame_info).frame, 4); }
-\f
-/* Things needed for making the inferior call functions. */
-
-/* Push an empty stack frame, to record the current PC, etc. */
-
-#define PUSH_DUMMY_FRAME \
-{ register CORE_ADDR sp = read_register (SP_REGNUM); \
- register int regnum; \
- sp = push_word (sp, read_register (PC_REGNUM)); \
- sp = push_word (sp, read_register (FP_REGNUM)); \
- write_register (FP_REGNUM, sp); \
- for (regnum = 0; regnum < 8; regnum++) \
- sp = push_word (sp, read_register (regnum)); \
- write_register (SP_REGNUM, sp); \
-}
-
-/* Discard from the stack the innermost frame, restoring all registers. */
-
-#define POP_FRAME \
-{ register CORE_ADDR fp = read_register (FP_REGNUM); \
- register int regnum; \
- struct frame_saved_regs fsr; \
- struct frame_info fi; \
- fi = get_frame_info (fp); \
- get_frame_saved_regs (&fi, &fsr); \
- for (regnum = 0; regnum < 8; regnum++) \
- if (fsr.regs[regnum]) \
- write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
- write_register (FP_REGNUM, read_memory_integer (fp, 4)); \
- write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \
- write_register (SP_REGNUM, fp + 8); \
-}
-
-/* This sequence of words is the instructions
- enter 0xff,0 82 ff 00
- jsr @0x00010203 7f ae c0 01 02 03
- adjspd 0x69696969 7f a5 01 02 03 04
- bpt f2
- Note this is 16 bytes. */
-
-#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 }
-
-#define CALL_DUMMY_START_OFFSET 3
-#define CALL_DUMMY_LENGTH 16
-#define CALL_DUMMY_ADDR 5
-#define CALL_DUMMY_NARGS 11
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
-
-#define FIX_CALL_DUMMY(dummyname, fun, nargs) \
-{ int flipped = fun | 0xc0000000; \
- flip_bytes (&flipped, 4); \
- *((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped; \
- flipped = - nargs * 4; \
- flip_bytes (&flipped, 4); \
- *((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped; \
-}
-\f
-#ifdef notdef
-/* Interface definitions for kernel debugger KDB. */
-
-/* Map machine fault codes into signal numbers.
- First subtract 0, divide by 4, then index in a table.
- Faults for which the entry in this table is 0
- are not handled by KDB; the program's own trap handler
- gets to handle then. */
-
-#define FAULT_CODE_ORIGIN 0
-#define FAULT_CODE_UNITS 4
-#define FAULT_TABLE \
-{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \
- 0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \
- 0, 0, 0, 0, 0, 0, 0, 0}
-
-/* Start running with a stack stretching from BEG to END.
- BEG and END should be symbols meaningful to the assembler.
- This is used only for kdb. */
-
-#define INIT_STACK(beg, end) \
-{ asm (".globl end"); \
- asm ("movl $ end, sp"); \
- asm ("clrl fp"); }
-
-/* Push the frame pointer register on the stack. */
-#define PUSH_FRAME_PTR \
- asm ("pushl fp");
-
-/* Copy the top-of-stack to the frame pointer register. */
-#define POP_FRAME_PTR \
- asm ("movl (sp), fp");
-
-/* After KDB is entered by a fault, push all registers
- that GDB thinks about (all NUM_REGS of them),
- so that they appear in order of ascending GDB register number.
- The fault code will be on the stack beyond the last register. */
-
-#define PUSH_REGISTERS \
-{ asm ("pushl 8(sp)"); \
- asm ("pushl 8(sp)"); \
- asm ("pushal 0x14(sp)"); \
- asm ("pushr $037777"); }
-
-/* Assuming the registers (including processor status) have been
- pushed on the stack in order of ascending GDB register number,
- restore them and return to the address in the saved PC register. */
-
-#define POP_REGISTERS \
-{ asm ("popr $037777"); \
- asm ("subl2 $8,(sp)"); \
- asm ("movl (sp),sp"); \
- asm ("rei"); }
-#endif
+++ /dev/null
-/* Parameters for execution on a Sony/NEWS, for GDB, the GNU debugger.
-
-Here is an m-news800.h file for gdb version 2.1. It supports the 68881
-registers.
-
-Now(9/2 '87) NEWS's printf has a bug.
-And support Sun assembly format instead of Motorola one.
-Probably not well support floating registers from core file rarely that
-I do not know detail.
-(hikichi@srava.sra.junet or hikichi%srava.sra.junet%kddlabs%seismo.CSS.GOV)
-
-Here is IEEE nan routine to use such bug fixed.
-
- printf("%g\n", Nan);
-
-> struct ieee { |* IEEE floating format *|
-> unsigned int s:1;
-> unsigned int e:11;
-> unsigned int f1:20;
-> unsigned int f2;
-> };
->
-> #define ZERO_F(x) ((x.f1 == 0) && (x.f2 == 0)) |* zero fraction ? *|
-> #define ZERO_E(x) (x.e == 0) |* zero exponential ? *|
-> #define MAX_E(x) (x.e == 0x7ff) |* max exponential ? *|
-> #define MINUS_S(x) (x.s == 1) |* minus ? *|
->
-> int
-> is_nan(arg) |* Not a Number ? *|
-> struct ieee arg;
-> {
-> if (MAX_E(arg) && !ZERO_F(arg))
-> return (1);
-> else
-> return (0);
-> }
->
-> int
-> is_plus_infinity(arg)
-> struct ieee arg;
-> {
-> if (!MINUS_S(arg) && MAX_E(arg) && ZERO_F(arg))
-> return (1);
-> else
-> return (0);
-> }
->
-> int
-> is_minus_infinity(arg)
-> struct ieee arg;
-> {
-> if (MINUS_S(arg) && MAX_E(arg) && ZERO_F(arg))
-> return (1);
-> else
-> return (0);
-> }
->
-> int
-> is_denormal(arg)
-> struct ieee arg;
-> {
-> if (ZERO_E(arg))
-> return (1);
-> else
-> return (0);
-> }
-
- Copyright (C) 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#ifdef 0 /* cannot use RCS id since initialize routine fails. */
-static char *RCSid =
-"$Header: m-news800.h,v 1.1 87/09/21 21:27:52 hikichi Exp $";
-#endif lint
-
-/*
- * $Log: m-news800.h,v $
- * Revision 1.1 87/09/21 21:27:52 hikichi
- * Initial revision
- *
- */
-
-/* Identify this machine */
-#ifndef news800
-#define news800
-#endif
-
-/* #define USE_GAS */
-
-/* Motorola assembly format */
-#ifndef USE_GAS
-#define MOTOROLA
-#endif
-
-/* bug when printf special number; NAN */
-#define PRINTF_BUG
-
-/* Define this if the C compiler puts an underscore at the front
- of external names before giving them to the linker. */
-
-#define NAMES_HAVE_UNDERSCORE
-
-/* Offset from address of function to start of its code.
- Zero on most machines. */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
-
-#define SKIP_PROLOGUE(pc) \
-{ register int op = read_memory_integer (pc, 2); \
- if (op == 0047126) \
- pc += 4; /* Skip link #word */ \
- else if (op == 0044016) \
- pc += 6; /* Skip link #long */ \
-}
-
-
-/* Immediately after a function call, return the saved pc.
- Can't always go through the frames for this because on some machines
- the new frame is not set up until the new function executes
- some instructions. */
-
-#define SAVED_PC_AFTER_CALL(frame) \
-read_memory_integer (read_register (SP_REGNUM), 4)
-
-/* THis is the amount to subtract from u.u_ar0
- to get the offset in the core file of the register values. */
-
-#define KERNEL_U_ADDR UADDR
-
-/* Address of end of stack space. */
-
-#define STACK_END_ADDR (0x80000000 - ctob(UPAGES + 1))
-
-/* Stack grows downward. */
-
-#define INNER_THAN <
-
-/* Sequence of bytes for breakpoint instruction. */
-
-#define BREAKPOINT {0x4e, 0x4f}
-
-/* Amount PC must be decremented by after a breakpoint.
- This is often the number of bytes in BREAKPOINT
- but not always. */
-
-#define DECR_PC_AFTER_BREAK 2
-
-/* Nonzero if instruction at PC is a return instruction. */
-
-#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
-
-/* Return 1 if P points to an invalid floating point value. */
-
-#define INVALID_FLOAT(p) 0 /* Just a first guess; not checked */
-
-/* Say how long registers are. */
-
-#define REGISTER_TYPE long
-
-/* Number of machine registers */
-
-#define NUM_REGS 29
-
-/* Initializer for an array of names of registers.
- There should be NUM_REGS strings in this initializer. */
-
-#define REGISTER_NAMES \
- {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
- "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
- "pc", "ps", \
- "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
- "fpcontrol", "fpstatus", "fpiaddr" }
-
-/* Register numbers of various important registers.
- Note that some of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and some are "phony" register numbers which are too large
- to be actual register numbers as far as the user is concerned
- but do serve to get the desired values when passed to read_register. */
-
-#define FP_REGNUM 14 /* Contains address of executing stack frame */
-#define SP_REGNUM 15 /* Contains address of top of stack */
-#define PC_REGNUM 16 /* Contains program counter */
-#define PS_REGNUM 17 /* Contains processor status */
-#define FP0_REGNUM 18 /* Floating point register 0 */
-#define FPC_REGNUM 26 /* 68881 control register */
-
-#define REGISTER_U_ADDR(addr, blockend, regno) \
-{ if (regno <= FP_REGNUM) \
- addr = blockend + 4 + regno * 4; \
- else if (regno == SP_REGNUM) \
- addr = blockend - 4 * 4; \
- else if (regno <= PS_REGNUM) \
- addr = blockend + (regno - PS_REGNUM) * 4; \
- else if (regno < FPC_REGNUM) \
- addr = blockend + 4 + 4 * 14 + 4 * 5 + (regno - FP0_REGNUM) * 12; \
- else \
- addr = blockend + 4 + 4 * 16 + (regno - FPC_REGNUM) * 4; \
-}
-
-/* Total amount of space needed to store our copies of the machine's
- register state, the array `registers'. */
-#define REGISTER_BYTES (16*4+8*12+8+12)
-
-/* Index within `registers' of the first byte of the space for
- register N. */
-
-#define REGISTER_BYTE(N) \
- ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168 \
- : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72 \
- : (N) * 4)
-
-/* Number of bytes of storage in the actual machine representation
- for register N. On the 68000, all regs are 4 bytes
- except the floating point regs which are 12 bytes. */
-
-#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
-
-/* Number of bytes of storage in the program's representation
- for register N. On the 68000, all regs are 4 bytes
- except the floating point regs which are 8-byte doubles. */
-
-#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
-
-/* Largest value REGISTER_RAW_SIZE can have. */
-
-#define MAX_REGISTER_RAW_SIZE 12
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Nonzero if register N requires conversion
- from raw format to virtual format. */
-
-#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
-
-/* Convert data from raw format for register REGNUM
- to virtual format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
-{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
- convert_from_68881 ((FROM), (TO)); \
- else \
- bcopy ((FROM), (TO), 4); }
-
-/* Convert data from virtual format for register REGNUM
- to raw format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
-{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
- convert_to_68881 ((FROM), (TO)); \
- else \
- bcopy ((FROM), (TO), 4); }
-
-/* Return the GDB type object for the "standard" data type
- of data in register N. */
-
-#define REGISTER_VIRTUAL_TYPE(N) \
- (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
-\f
-/* Describe the pointer in each stack frame to the previous stack frame
- (its caller). */
-
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer.
-
- FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
- and produces the nominal address of the caller frame.
-
- However, if FRAME_CHAIN_VALID returns zero,
- it means the given frame is the outermost one and has no caller.
- In that case, FRAME_CHAIN_COMBINE is not used. */
-
-/* In the case of the NEWS, the frame's nominal address
- is the address of a 4-byte word containing the calling frame's address. */
-
-#define FRAME_CHAIN(thisframe) (read_memory_integer (thisframe, 4))
-
-#define FRAME_CHAIN_VALID(chain, thisframe) \
- (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
-
-#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-
-/* Define other aspects of the stack frame. */
-
-#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
-
-#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
-
-#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
-
-/* Return number of args passed to a frame.
- Can return -1, meaning no way to tell. */
-
-#define FRAME_NUM_ARGS(val, fi) \
-{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame); \
- register int insn = 0177777 & read_memory_integer (pc, 2); \
- val = 0; \
- if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */ \
- val = read_memory_integer (pc + 2, 2); \
- else if ((insn & 0170777) == 0050217 /* addql #N, sp */ \
- || (insn & 0170777) == 0050117) /* addqw */ \
- { val = (insn >> 9) & 7; if (val == 0) val = 8; } \
- else if (insn == 0157774) /* addal #WW, sp */ \
- val = read_memory_integer (pc + 2, 4); \
- val >>= 2; }
-
-/* Return number of bytes at start of arglist that are not really args. */
-
-#define FRAME_ARGS_SKIP 8
-
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
-
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
-{ register int regnum; \
- register int regmask; \
- register CORE_ADDR next_addr; \
- register CORE_ADDR pc; \
- register int insn; \
- register int offset; \
- bzero (&frame_saved_regs, sizeof frame_saved_regs); \
- if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
- && (frame_info).pc <= (frame_info).frame) \
- { next_addr = (frame_info).frame; \
- pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
- else \
- { pc = get_pc_function_start ((frame_info).pc); \
- /* Verify we have a link a6 instruction next, \
- or a branch followed by a link a6 instruction; \
- if not we lose. If we win, find the address above the saved \
- regs using the amount of storage from the link instruction. */\
-retry: \
- insn = read_memory_integer (pc, 2); \
- if (insn == 044016) \
- next_addr = (frame_info).frame - read_memory_integer (pc += 2, 4), pc+=4; \
- else if (insn == 047126) \
- next_addr = (frame_info).frame - read_memory_integer (pc += 2, 2), pc+=2; \
- else if ((insn & 0177400) == 060000) /* bra insn */ \
- { offset = insn & 0377; \
- pc += 2; /* advance past bra */ \
- if (offset == 0) /* bra #word */ \
- offset = read_memory_integer (pc, 2), pc += 2; \
- else if (offset == 0377) /* bra #long */ \
- offset = read_memory_integer (pc, 4), pc += 4; \
- pc += offset; \
- goto retry; \
- } else goto lose; \
- /* If have an addal #-n, sp next, adjust next_addr. */ \
- if ((0177777 & read_memory_integer (pc, 2)) == 0157774) \
- next_addr += read_memory_integer (pc += 2, 4), pc += 4; \
- } \
- /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */ \
- insn = read_memory_integer (pc, 2), pc += 2; \
- regmask = read_memory_integer (pc, 2); \
- if ((insn & 0177760) == 022700) /* movl rn, (sp) */ \
- (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr; \
- else if ((insn & 0177760) == 024700) /* movl rn, -(sp) */ \
- (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr-=4; \
- else if (insn == 0044327) /* moveml mask, (sp) */ \
- { pc += 2; \
- /* Regmask's low bit is for register 0, the first written */ \
- next_addr -= 4; \
- for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr += 4); \
- } else if (insn == 0044347) /* moveml mask, -(sp) */ \
- { pc += 2; \
- /* Regmask's low bit is for register 15, the first pushed */ \
- for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) \
- if (regmask & 1) \
- (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \
- /* clrw -(sp); movw ccr,-(sp) may follow. */ \
- if (read_memory_integer (pc, 2) == 041147 \
- && read_memory_integer (pc+2, 2) == 042347) \
- (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4); \
- lose: ; \
- (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8; \
- (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame; \
- (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4; \
-}
-\f
-/* Things needed for making the inferior call functions. */
-
-/* Push an empty stack frame, to record the current PC, etc. */
-
-#define PUSH_DUMMY_FRAME \
-{ register CORE_ADDR sp = read_register (SP_REGNUM); \
- register int regnum; \
- char raw_buffer[12]; \
- sp = push_word (sp, read_register (PC_REGNUM)); \
- sp = push_word (sp, read_register (FP_REGNUM)); \
- write_register (FP_REGNUM, sp); \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \
- { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \
- sp = push_bytes (sp, raw_buffer, 12); } \
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \
- sp = push_word (sp, read_register (regnum)); \
- sp = push_word (sp, read_register (PS_REGNUM)); \
- write_register (SP_REGNUM, sp); }
-
-/* Discard from the stack the innermost frame, restoring all registers. */
-
-#define POP_FRAME \
-{ register CORE_ADDR fp = read_register (FP_REGNUM); \
- register int regnum; \
- struct frame_saved_regs fsr; \
- struct frame_info fi; \
- char raw_buffer[12]; \
- fi = get_frame_info (fp); \
- get_frame_saved_regs (&fi, &fsr); \
- for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \
- if (fsr.regs[regnum]) \
- { read_memory (fsr.regs[regnum], raw_buffer, 12); \
- write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \
- if (fsr.regs[regnum]) \
- write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
- if (fsr.regs[PS_REGNUM]) \
- write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
- write_register (FP_REGNUM, read_memory_integer (fp, 4)); \
- write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \
- write_register (SP_REGNUM, fp + 8); \
-}
-
-/* This sequence of words is the instructions
- fmove.m #<f0-f7>,-(sp)
- movem.l 0xfffc,-(sp)
- clr.w -(sp)
- move.w ccr,-(sp)
- /..* The arguments are pushed at this point by GDB;
- no code is needed in the dummy for this.
- The CALL_DUMMY_START_OFFSET gives the position of
- the following jsr instruction. *../
- jbsr (#32323232)
- add.l #69696969,sp
- bpt
- nop
-Note this is 24 bytes.
-We actually start executing at the jsr, since the pushing of the
-registers is done by PUSH_DUMMY_FRAME. If this were real code,
-the arguments for the function called by the jsr would be pushed
-between the moveml and the jsr, and we could allow it to execute through.
-But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
-and we cannot allow the moveml to push the registers again lest they be
-taken for the arguments. */
-
-#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
-
-#define CALL_DUMMY_LENGTH 28
-
-#define CALL_DUMMY_START_OFFSET 12
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
-
-#define FIX_CALL_DUMMY(dummyname, fun, nargs) \
-{ *(int *)((char *) dummyname + 20) = nargs * 4; \
- *(int *)((char *) dummyname + 14) = fun; }
-\f
-/* Interface definitions for kernel debugger KDB. */
-
-/* Map machine fault codes into signal numbers.
- First subtract 0, divide by 4, then index in a table.
- Faults for which the entry in this table is 0
- are not handled by KDB; the program's own trap handler
- gets to handle then. */
-
-#define FAULT_CODE_ORIGIN 0
-#define FAULT_CODE_UNITS 4
-#define FAULT_TABLE \
-{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
- 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
- 0, 0, 0, 0, 0, 0, 0, 0, \
- SIGILL }
-
-/* Start running with a stack stretching from BEG to END.
- BEG and END should be symbols meaningful to the assembler.
- This is used only for kdb. */
-
-#ifdef MOTOROLA
-#define INIT_STACK(beg, end) \
-{ asm (".globl end"); \
- asm ("move.l $ end, sp"); \
- asm ("clr.l fp"); }
-#else
-#define INIT_STACK(beg, end) \
-{ asm (".globl end"); \
- asm ("movel $ end, sp"); \
- asm ("clrl fp"); }
-#endif
-
-/* Push the frame pointer register on the stack. */
-#ifdef MOTOROLA
-#define PUSH_FRAME_PTR \
- asm ("move.l fp, -(sp)");
-#else
-#define PUSH_FRAME_PTR \
- asm ("movel fp, -(sp)");
-#endif
-
-/* Copy the top-of-stack to the frame pointer register. */
-#ifdef MOTOROLA
-#define POP_FRAME_PTR \
- asm ("move.l (sp), fp");
-#else
-#define POP_FRAME_PTR \
- asm ("movl (sp), fp");
-#endif
-
-/* After KDB is entered by a fault, push all registers
- that GDB thinks about (all NUM_REGS of them),
- so that they appear in order of ascending GDB register number.
- The fault code will be on the stack beyond the last register. */
-
-#ifdef MOTOROLA
-#define PUSH_REGISTERS \
-{ asm ("clr.w -(sp)"); \
- asm ("pea (10,sp)"); \
- asm ("movem $ 0xfffe,-(sp)"); }
-#else
-#define PUSH_REGISTERS \
-{ asm ("clrw -(sp)"); \
- asm ("pea 10(sp)"); \
- asm ("movem $ 0xfffe,-(sp)"); }
-#endif
-
-/* Assuming the registers (including processor status) have been
- pushed on the stack in order of ascending GDB register number,
- restore them and return to the address in the saved PC register. */
-
-#ifdef MOTOROLA
-#define POP_REGISTERS \
-{ asm ("subi.l $8,28(sp)"); \
- asm ("movem (sp),$ 0xffff"); \
- asm ("rte"); }
-#else
-#define POP_REGISTERS \
-{ asm ("subil $8,28(sp)"); \
- asm ("movem (sp),$ 0xffff"); \
- asm ("rte"); }
-#endif
-
+++ /dev/null
-/* This is how the size of an individual .o file's text segment
- is rounded on a SONY NEWS. */
-
-#define FILEADDR_ROUND(addr) ((addr + 3) & -4)
the following jsr instruction. *../
jsr @#32323232
addl #69696969,sp
- bpt
+ trap #15
nop
Note this is 28 bytes.
We actually start executing at the jsr, since the pushing of the
/* This is how the size of an individual .o file's text segment
is rounded on a sun. */
-#define FILEADDR_ROUND(addr) (addr)
+#define FILEADDR_ROUND(addr) ((addr + 3) & -4)
+++ /dev/null
-/* Definitions to make GDB run on an encore under umax 4.2
- Copyright (C) 1987 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#ifndef ns16000
-#define ns16000
-#endif
-
-#define HAVE_WAIT_STRUCT
-
-/* Encore's modifications to ptrace format */
-
-#define UMAX_PTRACE
-
-/* Encore's modifications to core-file format */
-
-#define UMAX_CORE
-
-/* Define this if the C compiler puts an underscore at the front
- of external names before giving them to the linker. */
-
-#define NAMES_HAVE_UNDERSCORE
-
-/* Exec files and symbol tables are in COFF format */
-
-#define COFF_FORMAT
-
-/* Offset from address of function to start of its code.
- Zero on most machines. */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
-
-#define SKIP_PROLOGUE(pc) \
-{ register unsigned char op = read_memory_integer (pc, 1); \
- if (op == 0x82) { op = read_memory_integer (pc+2,1); \
- if ((op & 0x80) == 0) pc += 3; \
- else if ((op & 0xc0) == 0x80) pc += 4; \
- else pc += 6; \
- } \
-}
-
-/* Immediately after a function call, return the saved pc.
- Can't always go through the frames for this because on some machines
- the new frame is not set up until the new function executes
- some instructions. */
-
-#define SAVED_PC_AFTER_CALL(frame) \
- read_memory_integer (read_register (SP_REGNUM), 4)
-
-/* Address of end of stack space. */
-
-#define STACK_END_ADDR (0xfffff000)
-
-/* Stack grows downward. */
-
-#define INNER_THAN <
-
-/* Sequence of bytes for breakpoint instruction. */
-
-#define BREAKPOINT {0xf2}
-
-/* Amount PC must be decremented by after a breakpoint.
- This is often the number of bytes in BREAKPOINT
- but not always. */
-
-#define DECR_PC_AFTER_BREAK 0
-
-/* Nonzero if instruction at PC is a return instruction. */
-
-#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12)
-
-#ifndef NaN
-#include <nan.h>
-#endif NaN
-
-/* Return 1 if P points to an invalid floating point value. */
-
-#define INVALID_FLOAT(p, s) \
- ((s == sizeof (float))? \
- NaF (*(float *) p) : \
- NaD (*(double *) p))
-
-/* Say how long (ordinary) registers are. */
-
-#define REGISTER_TYPE long
-
-/* Number of machine registers */
-
-#define NUM_REGS 25
-
-#define NUM_GENERAL_REGS 8
-
-/* Initializer for an array of names of registers.
- There should be NUM_REGS strings in this initializer. */
-
-#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
- "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
- "sp", "fp", "pc", "ps", \
- "fsr", \
- "l0", "l1", "l2", "l3", "xx", \
- }
-
-/* Register numbers of various important registers.
- Note that some of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and some are "phony" register numbers which are too large
- to be actual register numbers as far as the user is concerned
- but do serve to get the desired values when passed to read_register. */
-
-#define FP0_REGNUM 8 /* Floating point register 0 */
-#define SP_REGNUM 16 /* Contains address of top of stack */
-#define AP_REGNUM FP_REGNUM
-#define FP_REGNUM 17 /* Contains address of executing stack frame */
-#define PC_REGNUM 18 /* Contains program counter */
-#define PS_REGNUM 19 /* Contains processor status */
-#define FPS_REGNUM 20 /* Floating point status register */
-#define LP0_REGNUM 21 /* Double register 0 (same as FP0) */
-
-/* called from register_addr() -- blockend not used for now */
-#define REGISTER_U_ADDR(addr, blockend, regno) \
-{ \
- switch (regno) { \
- case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: \
- addr = PU_R0 - (regno * sizeof (int)); break; \
- case SP_REGNUM: \
- addr = PU_SP; break; \
- case PC_REGNUM: \
- addr = PU_PC; break; \
- case FP_REGNUM: \
- addr = PU_FP; break; \
- case PS_REGNUM: \
- addr = PU_PSL; break; \
- case FPS_REGNUM: \
- addr = PU_FSR; break; \
- case FP0_REGNUM + 0: case FP0_REGNUM + 1: \
- case FP0_REGNUM + 2: case FP0_REGNUM + 3: \
- case FP0_REGNUM + 4: case FP0_REGNUM + 5: \
- case FP0_REGNUM + 6: case FP0_REGNUM + 7: \
- addr = PU_F0 + (regno - FP0_REGNUM) * sizeof (float); break; \
- case LP0_REGNUM + 0: case LP0_REGNUM + 1: \
- case LP0_REGNUM + 2: case LP0_REGNUM + 3: \
- addr = PU_F0 + (regno - LP0_REGNUM) * sizeof (double); break; \
- default: \
- printf ("bad argument to REGISTER_U_ADDR %d\n", regno); \
- abort (); \
- } \
-}
-
-/* Total amount of space needed to store our copies of the machine's
- register state, the array `registers'. */
-#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double))
-
-/* Index within `registers' of the first byte of the space for
- register N. */
-
-#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \
- LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4)
-
-/* Number of bytes of storage in the actual machine representation
- for register N. On the 32000, all regs are 4 bytes
- except for the doubled floating registers. */
-
-#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
-
-/* Number of bytes of storage in the program's representation
- for register N. On the 32000, all regs are 4 bytes
- except for the doubled floating registers. */
-
-#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
-
-/* Largest value REGISTER_RAW_SIZE can have. */
-
-#define MAX_REGISTER_RAW_SIZE 8
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Nonzero if register N requires conversion
- from raw format to virtual format. */
-
-#define REGISTER_CONVERTIBLE(N) 0
-
-/* Convert data from raw format for register REGNUM
- to virtual format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
-
-/* Convert data from virtual format for register REGNUM
- to raw format for register REGNUM. */
-
-#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
- bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
-
-/* Return the GDB type object for the "standard" data type
- of data in register N. */
-
-#define REGISTER_VIRTUAL_TYPE(N) \
- (((N) < FP0_REGNUM) ? \
- builtin_type_int : \
- ((N) < FP0_REGNUM + 8) ? \
- builtin_type_float : \
- ((N) < LP0_REGNUM) ? \
- builtin_type_int : \
- builtin_type_double)
-
-/* Extract from an array REGBUF containing the (raw) register state
- a function return value of type TYPE, and copy that, in virtual format,
- into VALBUF. */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF+REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE))
-
-/* Write into appropriate registers a function return value
- of type TYPE, given in virtual format. */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
- write_register_bytes (REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE))
-
-/* Extract from an array REGBUF containing the (raw) register state
- the address in which a function should return its structure value,
- as a CORE_ADDR (or an expression that can be used as one). */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
-\f
-/* Describe the pointer in each stack frame to the previous stack frame
- (its caller). */
-
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer.
-
- FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
- and produces the nominal address of the caller frame.
-
- However, if FRAME_CHAIN_VALID returns zero,
- it means the given frame is the outermost one and has no caller.
- In that case, FRAME_CHAIN_COMBINE is not used. */
-
-/* In the case of the ns32000 series, the frame's nominal address is the FP
- value, and at that address is saved previous FP value as a 4-byte word. */
-
-#define FRAME_CHAIN(thisframe) (read_memory_integer (thisframe, 4))
-
-#define FRAME_CHAIN_VALID(chain, thisframe) \
- (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
-
-#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-
-/* Define other aspects of the stack frame. */
-
-#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
-
-/* Compute base of arguments. */
-
-#define FRAME_ARGS_ADDRESS(fi) \
- ((n32k_get_enter_addr (fi.pc) > 1) ? \
- ((fi).frame) : (read_register (SP_REGNUM) - 4))
-
-#define FRAME_LOCALS_ADDRESS(fi) ((fi).frame)
-
-/* Get the address of the enter opcode for this function, if it is active.
- Returns positive address > 1 if pc is between enter/exit,
- 1 if pc before enter or after exit, 0 otherwise. */
-
-extern CORE_ADDR n32k_get_enter_addr ();
-
-/* Return number of args passed to a frame.
- Can return -1, meaning no way to tell.
- Encore's C compiler often reuses same area on stack for args,
- so this will often not work properly. If the arg names
- are known, it's likely most of them will be printed. */
-
-#define FRAME_NUM_ARGS(numargs, fi) \
-{ CORE_ADDR pc; \
- CORE_ADDR enter_addr; \
- unsigned int insn; \
- unsigned int addr_mode; \
- int width; \
- \
- numargs = -1; \
- enter_addr = n32k_get_enter_addr (fi.pc); \
- if (enter_addr > 0) \
- { \
- pc = (enter_addr == 1) ? \
- SAVED_PC_AFTER_CALL () : \
- FRAME_SAVED_PC (fi.frame); \
- insn = read_memory_integer (pc,2); \
- addr_mode = (insn >> 11) & 0x1f; \
- insn = insn & 0x7ff; \
- if ((insn & 0x7fc) == 0x57c && \
- addr_mode == 0x14) /* immediate */ \
- { \
- if (insn == 0x57c) /* adjspb */ \
- width = 1; \
- else if (insn == 0x57d) /* adjspw */ \
- width = 2; \
- else if (insn == 0x57f) /* adjspd */ \
- width = 4; \
- numargs = read_memory_integer (pc+2,width); \
- if (width > 1) \
- flip_bytes (&numargs, width); \
- numargs = - sign_extend (numargs, width*8) / 4;\
- } \
- } \
-}
-
-/* Return number of bytes at start of arglist that are not really args. */
-
-#define FRAME_ARGS_SKIP 8
-
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
-
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
-{ \
- register int regmask, regnum; \
- int localcount; \
- register CORE_ADDR enter_addr; \
- register CORE_ADDR next_addr; \
- \
- bzero (&(frame_saved_regs), sizeof (frame_saved_regs)); \
- enter_addr = n32k_get_enter_addr ((frame_info).pc); \
- if (enter_addr > 1) \
- { \
- regmask = read_memory_integer (enter_addr+1, 1) & 0xff; \
- localcount = n32k_localcount (enter_addr); \
- next_addr = (frame_info).frame + localcount; \
- for (regnum = 0; regnum < 8; regnum++, regmask >>= 1) \
- (frame_saved_regs).regs[regnum] = (regmask & 1) ? \
- (next_addr -= 4) : 0; \
- (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 4;\
- (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;\
- (frame_saved_regs).regs[FP_REGNUM] = \
- (read_memory_integer ((frame_info).frame, 4));\
- } \
- else if (enter_addr == 1) \
- { \
- CORE_ADDR sp = read_register (SP_REGNUM); \
- (frame_saved_regs).regs[PC_REGNUM] = sp; \
- (frame_saved_regs).regs[SP_REGNUM] = sp + 4; \
- } \
-}
-\f
-/* Things needed for making the inferior call functions. */
-
-/* Push an empty stack frame, to record the current PC, etc. */
-
-#define PUSH_DUMMY_FRAME \
-{ register CORE_ADDR sp = read_register (SP_REGNUM);\
- register int regnum; \
- sp = push_word (sp, read_register (PC_REGNUM)); \
- sp = push_word (sp, read_register (FP_REGNUM)); \
- write_register (FP_REGNUM, sp); \
- for (regnum = 0; regnum < 8; regnum++) \
- sp = push_word (sp, read_register (regnum)); \
- write_register (SP_REGNUM, sp); \
-}
-
-/* Discard from the stack the innermost frame, restoring all registers. */
-
-#define POP_FRAME \
-{ register CORE_ADDR fp = read_register (FP_REGNUM); \
- register int regnum; \
- struct frame_saved_regs fsr; \
- struct frame_info fi; \
- fi = get_frame_info (fp); \
- get_frame_saved_regs (&fi, &fsr); \
- for (regnum = 0; regnum < 8; regnum++) \
- if (fsr.regs[regnum]) \
- write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
- write_register (FP_REGNUM, read_memory_integer (fp, 4)); \
- write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \
- write_register (SP_REGNUM, fp + 8); \
-}
-
-/* This sequence of words is the instructions
- enter 0xff,0 82 ff 00
- jsr @0x00010203 7f ae c0 01 02 03
- adjspd 0x69696969 7f a5 01 02 03 04
- bpt f2
- Note this is 16 bytes. */
-
-#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 }
-
-#define CALL_DUMMY_START_OFFSET 3
-#define CALL_DUMMY_LENGTH 16
-#define CALL_DUMMY_ADDR 5
-#define CALL_DUMMY_NARGS 11
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
-
-#define FIX_CALL_DUMMY(dummyname, fun, nargs) \
-{ \
- int flipped; \
- flipped = fun | 0xc0000000; \
- flip_bytes (&flipped, 4); \
- *((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped; \
- flipped = - nargs * 4; \
- flip_bytes (&flipped, 4); \
- *((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped; \
-}
case 'd':
val = NEXTWORD (p);
- fprintf (stream, "%d(%s)", val, fetch_arg (buffer, place, 3));
+ fprintf (stream, "%d(%s)", val, reg_names[fetch_arg (buffer, place, 3)]);
break;
case 's':
FROM is the address of the extended float.
Store the double in *TO. */
-#ifdef mac_aux
-#ifdef __STDC__
-#define asm16(str) asm ("short " str#)
-#else
-#define asm16(str) asm ("short str")
-#endif
-#else
-#ifdef __STDC__
-#define asm16(str) asm (".word " str#)
-#else
-#define asm16(str) asm (".word str")
-#endif
-#endif
-
convert_from_68881 (from, to)
char *from;
double *to;
#else
/* Hand-assemble those insns since some assemblers lose
and some have different syntax. */
- asm16 (020156);
- asm16 (8);
- asm16 (021156);
- asm16 (12);
- asm16 (0xf210);
- asm16 (0x4800);
- asm16 (0xf211);
- asm16 (0x7400);
+ asm (".word 020156");
+ asm (".word 8");
+ asm (".word 021156");
+ asm (".word 12");
+ asm (".long 0xf2104800");
+ asm (".long 0xf2117400");
#endif
}
asm ("fmovex fp0,a1@");
#else
/* Hand-assemble those insns since some assemblers lose. */
- asm16 (020156);
- asm16 (8);
- asm16 (021156);
- asm16 (12);
- asm16 (0xf210);
- asm16 (0x5400);
- asm16 (0xf211);
- asm16 (0x6800);
+ asm (".word 020156");
+ asm (".word 8");
+ asm (".word 021156");
+ asm (".word 12");
+ asm (".long 0xf2105400");
+ asm (".long 0xf2116800");
#endif
}
anyone else from sharing it farther. Help stamp out software hoarding!
*/
-#include <sys/types.h>
#include <sys/file.h>
#include <stdio.h>
#include <setjmp.h>
FILE *instream;
+/* Current working directory. */
+
+char *current_directory;
+
+/* The directory name is actually stored here. */
+static char dirbuf[MAXPATHLEN];
+
/* Nonzero if we should refrain from using an X window. */
int inhibit_windows = 0;
void (*window_hook) ();
+extern int frame_file_full_name;
+
void free_command_lines ();
char *read_line ();
static void initialize_main ();
line = (char *) xmalloc (linesize);
instream = stdin;
+ getwd (dirbuf);
+ current_directory = dirbuf;
+
#ifdef SET_STACK_LIMIT_HUGE
{
struct rlimit rlim;
}
#endif /* SET_STACK_LIMIT_HUGE */
+ /* Run the init function of each source file */
+
/* Look for flag arguments. */
for (i = 1; i < argc; i++)
inhibit_gdbinit = 1;
else if (!strcmp (argv[i], "-nw"))
inhibit_windows = 1;
+ else if (!strcmp (argv[i], "-fullname"))
+ frame_file_full_name = 1;
else if (!strcmp (argv[i], "-batch"))
batch = 1, quiet = 1;
else if (argv[i][0] == '-')
extern void tty_command ();
if (!strcmp (arg, "-q") || !strcmp (arg, "-nx")
- || !strcmp (arg, "quiet") || !strcmp (arg, "-batch"))
+ || !strcmp (arg, "-quiet") || !strcmp (arg, "-batch")
+ || !strcmp (arg, "-fullname"))
/* Already processed above */
continue;
c = fgetc (instream);
if (c == -1 || c == '\n')
break;
+ else if (c == '\\')
+ if ((c = fgetc (instream)) == '\n')
+ continue;
+ else ungetc (c, instream);
if (p - line == linesize - 1)
{
linesize *= 2;
}
*p++ = c;
}
-
signal (SIGTSTP, SIG_DFL);
immediate_quit--;
{
immediate_quit++;
printf (" GDB GENERAL PUBLIC LICENSE\n\
+\n (Clarified 11 Feb 1988)\
\n\
- Copyright (C) 1986 Richard M. Stallman\n\
+ Copyright (C) 1988 Richard M. Stallman\n\
Everyone is permitted to copy and distribute verbatim copies\n\
of this license, but changing it is not allowed.\n\
+ You can also use this wording to make the terms for other programs.\n\
\n\
The license agreements of most software companies keep you at the\n\
mercy of those companies. By contrast, our general public license is\n\
1. You may copy and distribute verbatim copies of GDB source code as\n\
you receive it, in any medium, provided that you conspicuously and\n\
appropriately publish on each copy a valid copyright notice \"Copyright\n\
-\(C) 1987 Free Software Foundation, Inc.\" (or with the year updated if\n\
-that is appropriate); keep intact the notices on all files that refer\n\
+\(C) 1988 Free Software Foundation, Inc.\" (or with whatever year is\n\
+appropriate); keep intact the notices on all files that refer\n\
to this License Agreement and to the absence of any warranty; and give\n\
any other recipients of the GDB program a copy of this License\n\
Agreement along with the program. You may charge a distribution fee\n\
that in whole or in part contains or is a derivative of GDB\n\
or any part thereof, to be licensed to all third parties on terms\n\
identical to those contained in this License Agreement (except that\n\
- you may choose to grant more extensive warranty protection to third\n\
- parties, at your option).\n\
+ you may choose to grant more extensive warranty protection to some\n\
+ or all third parties, at your option).\n\
\n");
printf ("\
c) if the modified program serves as a debugger, cause it\n\
when started running in the simplest and usual way, to print\n\
an announcement including a valid copyright notice\n\
- \"Copyright (C) 1987 Free Software Foundation, Inc.\" (or with\n\
- the year updated if appropriate), saying that there\n\
- is no warranty (or else, saying that you provide\n\
- a warranty) and that users may redistribute the program under\n\
- these conditions, and telling the user how to view a copy of\n\
- this License Agreement.\n\
+ \"Copyright (C) 1988 Free Software Foundation, Inc.\" (or with\n\
+ the year that is appropriate), saying that there is no warranty\n\
+ (or else, saying that you provide a warranty) and that users may\n\
+ redistribute the program under these conditions, and telling the user\n\
+ how to view a copy of this License Agreement.\n\
\n\
d) You may charge a distribution fee for the physical act of\n\
transferring a copy, and you may at your option offer warranty\n\
protection in exchange for a fee.\n\
+\n\
+Mere aggregation of another unrelated program with this program (or its\n\
+derivative) on a volume of a storage or distribution medium does not bring\n\
+the other program under the scope of these terms.\n\
--Type Return to print more--");
fflush (stdout);
read_line ();
printf ("\
- 3. You may copy and distribute GDB or any portion of it in\n\
-compiled, executable or object code form under the terms of Paragraphs\n\
-1 and 2 above provided that you do the following:\n\
+ 3. You may copy and distribute GDB (or a portion or derivative of it,\n\
+under Paragraph 2) in object code or executable form under the terms of\n\
+Paragraphs 1 and 2 above provided that you also do one of the following:\n\
\n\
- a) cause each such copy to be accompanied by the\n\
- corresponding machine-readable source code, which must\n\
- be distributed under the terms of Paragraphs 1 and 2 above; or,\n\
+ a) accompany it with the complete corresponding machine-readable\n\
+ source code, which must be distributed under the terms of\n\
+ Paragraphs 1 and 2 above; or,\n\
\n\
- b) cause each such copy to be accompanied by a\n\
- written offer, with no time limit, to give any third party\n\
- free (except for a nominal shipping charge) a machine readable\n\
- copy of the corresponding source code, to be distributed\n\
- under the terms of Paragraphs 1 and 2 above; or,\n\n");
+ b) accompany it with a written offer, valid for at least three\n\
+ years, to give any third party free (except for a nominal\n\
+ shipping charge) a complete machine-readable copy of the\n\
+ corresponding source code, to be distributed under the terms of\n\
+ Paragraphs 1 and 2 above; or,\n\n");
printf ("\
- c) in the case of a recipient of GDB in compiled, executable\n\
- or object code form (without the corresponding source code) you\n\
- shall cause copies you distribute to be accompanied by a copy\n\
- of the written offer of source code which you received along\n\
- with the copy you received.\n\
+ c) accompany it with the information you received as to where the\n\
+ corresponding source code may be obtained. (This alternative is\n\
+ allowed only for noncommercial distribution and only if you\n\
+ received the program in object code or executable form alone.)\n\
+\n\
+For an executable file, complete source code means all the source code for\n\
+all modules it contains; but, as a special exception, it need not include\n\
+source code for modules which are standard libraries that accompany the\n\
+operating system on which the executable file runs.\n\
--Type Return to print more--");
fflush (stdout);
read_line ();
static void
print_gdb_version ()
{
- printf ("GDB %s, Copyright (C) 1987 Free Software Foundation, Inc.\n\
+ printf ("GDB %s, Copyright (C) 1988 Free Software Foundation, Inc.\n\
There is ABSOLUTELY NO WARRANTY for GDB; type \"info warranty\" for details.\n\
GDB is free software and you are welcome to distribute copies of it\n\
under certain conditions; type \"info copying\" to see the conditions.\n",
char *arg;
int from_tty;
{
- char buf[MAXPATHLEN];
if (arg) error ("The \"pwd\" command does not take an argument: %s", arg);
- printf ("Working directory %s.\n", getwd (buf));
+ printf ("Working directory %s.\n", dirbuf);
}
static void
if (chdir (dir) < 0)
perror_with_name (dir);
+ getwd (dirbuf);
if (from_tty)
pwd_command ((char *) 0, 1);
}
static void
initialize_main ()
{
- prompt = savestring ("(gdb) ", 6);
+ prompt = savestring ("(gdb+) ", 7);
/* Define the classes of commands.
They will appear in the help list in the reverse of this order. */
+++ /dev/null
-/* ns32k-opcode.h */
-
-#ifndef ns32k_opcodeT
-#define ns32k_opcodeT int
-#endif /* no ns32k_opcodeT */
-
-struct not_wot /* ns32k opcode table: wot to do with this */
- /* particular opcode */
-{
- int obits; /* number of opcode bits */
- int ibits; /* number of instruction bits */
- ns32k_opcodeT code; /* op-code (may be > 8 bits!) */
- char *args; /* how to compile said opcode */
-};
-
-struct not /* ns32k opcode text */
-{
- char * name; /* opcode name: lowercase string [key] */
- struct not_wot detail; /* rest of opcode table [datum] */
-};
-
-/* F : 32 bit float
- * L : 64 bit float
- * B : byte
- * W : word
- * D : double-word
- * Q : quad-word
- * d : displacement
- * q : quick
- * i : immediate (8 bits)
- * r : register number (3 bits)
- * p : displacement - pc relative addressing
-*/
-static struct not
-notstrs[] =
-{
- { "absf", 14,24, 0x35be, "1F2F" },
- { "absl", 14,24, 0x34be, "1L2L" },
- { "absb", 14,24, 0x304e, "1B2B" },
- { "absw", 14,24, 0x314e, "1W2W" },
- { "absd", 14,24, 0x334e, "1D2D" },
- { "acbb", 7,16, 0x4c, "2B1q3p" },
- { "addf", 14,24, 0x01be, "1F2F" },
- { "addl", 14,24, 0x00be, "1L2L" },
- { "addb", 6,16, 0x00, "1B2B" },
- { "addw", 6,16, 0x01, "1W2W" },
- { "addd", 6,16, 0x03, "1D2D" },
- { "addcb", 6,16, 0x10, "1B2B" },
- { "addcw", 6,16, 0x11, "1W2W" },
- { "addcd", 6,16, 0x13, "1D2D" },
- { "addpb", 14,24, 0x3c4e, "1B2B" },
- { "addpw", 14,24, 0x3d4e, "1W2W" },
- { "addpd", 14,24, 0x3f4e, "1D2D" },
- { "addqb", 7,16, 0x0c, "2B1q" },
- { "addqw", 7,16, 0x0d, "2W1q" },
- { "addqd", 7,16, 0x0f, "2D1q" },
- { "addr", 6,16, 0x27, "1D2D" },
- { "adjspb", 11,16, 0x057c, "1B" },
- { "adjspw", 11,16, 0x057d, "1W" },
- { "adjspd", 11,16, 0x057f, "1D" },
- { "andb", 6,16, 0x28, "1B2B" },
- { "andw", 6,16, 0x29, "1W2W" },
- { "andd", 6,16, 0x2b, "1D2D" },
- { "ashb", 14,24, 0x044e, "1B2B" },
- { "ashw", 14,24, 0x054e, "1B2W" },
- { "ashd", 14,24, 0x074e, "1B2D" },
- { "beq", 8,8, 0x0a, "1p" },
- { "bne", 8,8, 0x1a, "1p" },
- { "bcs", 8,8, 0x2a, "1p" },
- { "bcc", 8,8, 0x3a, "1p" },
- { "bhi", 8,8, 0x4a, "1p" },
- { "bls", 8,8, 0x5a, "1p" },
- { "bgt", 8,8, 0x6a, "1p" },
- { "ble", 8,8, 0x7a, "1p" },
- { "bfs", 8,8, 0x8a, "1p" },
- { "bfc", 8,8, 0x9a, "1p" },
- { "blo", 8,8, 0xaa, "1p" },
- { "bhs", 8,8, 0xba, "1p" },
- { "blt", 8,8, 0xca, "1p" },
- { "bge", 8,8, 0xda, "1p" },
- { "bicb", 6,16, 0x08, "1B2B" },
- { "bicw", 6,16, 0x09, "1W2W" },
- { "bicd", 6,16, 0x0b, "1D2D" },
- { "bicpsrb", 11,16, 0x17c, "1B" },
- { "bicpsrw", 11,16, 0x17d, "1W" },
- { "bispsrb", 11,16, 0x37c, "1B" },
- { "bispsrw", 11,16, 0x37d, "1W" },
- { "bpt", 8,8, 0xf2, "" },
- { "br", 8,8, 0xea, "1p" },
- { "bsr", 8,8, 0x02, "1p" },
- { "caseb", 11,16, 0x77c, "1B" },
- { "casew", 11,16, 0x77d, "1W" },
- { "cased", 11,16, 0x77f, "1D" },
- { "cbitb", 14,24, 0x084e, "1B2D" },
- { "cbitw", 14,24, 0x094e, "1W2D" },
- { "cbitd", 14,24, 0x0b4e, "1D2D" },
- { "cbitib", 14,24, 0x0c4e, "1B2D" },
- { "cbitiw", 14,24, 0x0d4e, "1W2D" },
- { "cbitid", 14,24, 0x0f4e, "1D2D" },
- { "checkb", 11,24, 0x0ee, "2A3B1r" },
- { "checkw", 11,24, 0x1ee, "2A3B1r" },
- { "checkd", 11,24, 0x3ee, "2A3D1r" },
- { "cmpf", 14,24, 0x09be, "1F2F" },
- { "cmpl", 14,24, 0x08be, "1L2L" },
- { "cmpb", 6,16, 0x04, "1B2B" },
- { "cmpw", 6,16, 0x05, "1W2W" },
- { "cmpd", 6,16, 0x07, "1D2D" },
- { "cmpmb", 14,24, 0x04ce, "1D2D3d" },
- { "cmpmw", 14,24, 0x05ce, "1D2D3d" },
- { "cmpmd", 14,24, 0x07ce, "1D2D3d" },
- { "cmpqb", 7,16, 0x1c, "2B1q" },
- { "cmpqw", 7,16, 0x1d, "2W1q" },
- { "cmpqd", 7,16, 0x1f, "2D1q" },
- { "cmpsb", 16,16, 0x040e, "1i" },
- { "cmpsw", 16,16, 0x050e, "1i" },
- { "cmpsd", 16,16, 0x070e, "1i" },
- { "cmpst", 16,16, 0x840e, "1i" },
- { "comb", 14,24, 0x344e, "1B2B" },
- { "comw", 14,24, 0x354e, "1W2W" },
- { "comd", 14,24, 0x374e, "1D2D" },
- { "cvtp", 11,24, 0x036e, "2D3D1r" },
- { "cxp", 8,8, 0x22, "1p" },
- { "cxpd", 11,16, 0x07f, "1D" },
- { "deib", 14,24, 0x2cce, "1B2W" },
- { "deiw", 14,24, 0x2cce, "1W2D" },
- { "deid", 14,24, 0x2cce, "1D2Q" },
- { "dia", 8,8, 0xc2, "" },
- { "divf", 14,24, 0x21be, "1F2F" },
- { "divl", 14,24, 0x20be, "1L2L" },
- { "divb", 14,24, 0x3cce, "1B2B" },
- { "divw", 14,24, 0x3dce, "1W2W" },
- { "divd", 14,24, 0x3fce, "1D2D" },
- { "enter", 8,8, 0x82, "1i2d" },
- { "exit", 8,8, 0x92, "1i" },
- { "extb", 11,24, 0x02e, "2D3B1r4d" },
- { "extw", 11,24, 0x12e, "2D3W1r4d" },
- { "extd", 11,24, 0x32e, "2D3D1r4d" },
- { "extsb", 14,24, 0x0cce, "1D2B3i" },
- { "extsw", 14,24, 0x0dce, "1D2W3i" },
- { "extsd", 14,24, 0x0fce, "1D2D3i" },
- { "ffsb", 14,24, 0x046e, "1B2B" },
- { "ffsw", 14,24, 0x056e, "1W2B" },
- { "ffsd", 14,24, 0x076e, "1D2B" },
- { "flag", 8,8, 0xd2, "" },
- { "floorfb", 14,24, 0x3c3e, "1F2B" },
- { "floorfw", 14,24, 0x3d3e, "1F2W" },
- { "floorfd", 14,24, 0x3f3e, "1F2D" },
- { "floorlb", 14,24, 0x383e, "1L2B" },
- { "floorlw", 14,24, 0x393e, "1L2W" },
- { "floorld", 14,24, 0x3b3e, "1L2D" },
- { "ibitb", 14,24, 0x384e, "1B2D" },
- { "ibitw", 14,24, 0x394e, "1W2D" },
- { "ibitd", 14,24, 0x3b4e, "1D2D" },
- { "indexb", 11,24, 0x42e, "2B3B1r" },
- { "indexw", 11,24, 0x52e, "2W3W1r" },
- { "indexd", 11,24, 0x72e, "2D3D1r" },
- { "insb", 11,24, 0x0ae, "2B3B1r4d" },
- { "insw", 11,24, 0x1ae, "2W3W1r4d" },
- { "insd", 11,24, 0x3ae, "2D3D1r4d" },
- { "inssb", 14,24, 0x08ce, "1B2D3i" },
- { "inssw", 14,24, 0x09ce, "1W2D3i" },
- { "inssd", 14,24, 0x0bce, "1D2D3i" },
- { "jsr", 11,16, 0x67f, "1A" },
- { "jump", 11,16, 0x27f, "1A" },
- { "lfsr", 19,24, 0x00f3e,"1D" },
- { "lmr", 15,24, 0x0b1e, "2D1q" },
- { "lprb", 7,16, 0x6c, "2B1q" },
- { "lprw", 7,16, 0x6d, "2W1q" },
- { "lprd", 7,16, 0x6f, "2D1q" },
- { "lshb", 14,24, 0x144e, "1B2B" },
- { "lshw", 14,24, 0x154e, "1B2W" },
- { "lshd", 14,24, 0x174e, "1B2D" },
- { "meib", 14,24, 0x24ce, "1B2W" },
- { "meiw", 14,24, 0x25ce, "1W2D" },
- { "meid", 14,24, 0x27ce, "1D2Q" },
- { "modb", 14,24, 0x38ce, "1B2B" },
- { "modw", 14,24, 0x39ce, "1W2W" },
- { "modd", 14,24, 0x3bce, "1D2D" },
- { "movf", 14,24, 0x05be, "1F2F" },
- { "movl", 14,24, 0x04be, "1L2L" },
- { "movb", 6,16, 0x14, "1B2B" },
- { "movw", 6,16, 0x15, "1W2W" },
- { "movd", 6,16, 0x17, "1D2D" },
- { "movbf", 14,24, 0x043e, "1B2F" },
- { "movwf", 14,24, 0x053e, "1W2F" },
- { "movdf", 14,24, 0x073e, "1D2F" },
- { "movbl", 14,24, 0x003e, "1B2L" },
- { "movwl", 14,24, 0x013e, "1W2L" },
- { "movdl", 14,24, 0x033e, "1D2L" },
- { "movfl", 14,24, 0x1b3e, "1F2L" },
- { "movlf", 14,24, 0x163e, "1L2F" },
- { "movmb", 14,24, 0x00ce, "1D2D3d" },
- { "movmw", 14,24, 0x00de, "1D2D3d" },
- { "movmd", 14,24, 0x00fe, "1D2D3d" },
- { "movqb", 7,16, 0x5c, "2B1q" },
- { "movqw", 7,16, 0x5d, "2B1q" },
- { "movqd", 7,16, 0x5f, "2B1q" },
- { "movsb", 16,16, 0x000e, "1i" },
- { "movsw", 16,16, 0x010e, "1i" },
- { "movsd", 16,16, 0x030e, "1i" },
- { "movst", 16,16, 0x800e, "1i" },
- { "movsub", 14,24, 0x0cae, "1A1A" },
- { "movsuw", 14,24, 0x0dae, "1A1A" },
- { "movsud", 14,24, 0x0fae, "1A1A" },
- { "movusb", 14,24, 0x1cae, "1A1A" },
- { "movusw", 14,24, 0x1dae, "1A1A" },
- { "movusd", 14,24, 0x1fae, "1A1A" },
- { "movxbd", 14,24, 0x1cce, "1B2D" },
- { "movxwd", 14,24, 0x1dce, "1W2D" },
- { "movxbw", 14,24, 0x10ce, "1B2W" },
- { "movzbd", 14,24, 0x18ce, "1B2D" },
- { "movzwd", 14,24, 0x19ce, "1W2D" },
- { "movzbw", 14,24, 0x14ce, "1B2W" },
- { "mulf", 14,24, 0x31be, "1F2F" },
- { "mull", 14,24, 0x30be, "1L2L" },
- { "mulb", 14,24, 0x20ce, "1B2B" },
- { "mulw", 14,24, 0x21ce, "1W2W" },
- { "muld", 14,24, 0x23ce, "1D2D" },
- { "negf", 14,24, 0x15be, "1F2F" },
- { "negl", 14,24, 0x14be, "1L2L" },
- { "negb", 14,24, 0x204e, "1B2B" },
- { "negw", 14,24, 0x214e, "1W2W" },
- { "negd", 14,24, 0x234e, "1D2D" },
- { "nop", 8,8, 0xa2, "" },
- { "notb", 14,24, 0x244e, "1B2B" },
- { "notw", 14,24, 0x254e, "1W2W" },
- { "notd", 14,24, 0x274e, "1D2D" },
- { "orb", 6,16, 0x18, "1B1B" },
- { "orw", 6,16, 0x19, "1W1W" },
- { "ord", 6,16, 0x1b, "1D1D" },
- { "quob", 14,24, 0x30ce, "1B2B" },
- { "quow", 14,24, 0x31ce, "1W2W" },
- { "quod", 14,24, 0x33ce, "1D2D" },
- { "rdval", 19,24, 0x0031e,"1A" },
- { "remb", 14,24, 0x34ce, "1B2B" },
- { "remw", 14,24, 0x35ce, "1W2W" },
- { "remd", 14,24, 0x37ce, "1D2D" },
- { "restore", 8,8, 0x72, "1i" },
- { "ret", 8,8, 0x12, "1d" },
- { "reti", 8,8, 0x52, "" },
- { "rett", 8,8, 0x42, "" },
- { "rotb", 14,24, 0x004e, "1B2B" },
- { "rotw", 14,24, 0x014e, "1B2W" },
- { "rotd", 14,24, 0x034e, "1B2D" },
- { "roundfb", 14,24, 0x243e, "1F2B" },
- { "roundfw", 14,24, 0x253e, "1F2W" },
- { "roundfd", 14,24, 0x273e, "1F2D" },
- { "roundlb", 14,24, 0x203e, "1L2B" },
- { "roundlw", 14,24, 0x213e, "1L2W" },
- { "roundld", 14,24, 0x233e, "1L2D" },
- { "rxp", 8,8, 0x32, "1d" },
- { "sCONDb", 7,16, 0x3c, "2B1q" },
- { "sCONDw", 7,16, 0x3d, "2D1q" },
- { "sCONDd", 7,16, 0x3f, "2D1q" },
- { "save", 8,8, 0x62, "1i" },
- { "sbitb", 14,24, 0x184e, "1B2A" },
- { "sbitw", 14,24, 0x194e, "1W2A" },
- { "sbitd", 14,24, 0x1b4e, "1D2A" },
- { "sbitib", 14,24, 0x1c4e, "1B2A" },
- { "sbitiw", 14,24, 0x1d4e, "1W2A" },
- { "sbitid", 14,24, 0x1f4e, "1D2A" },
- { "setcfg", 15,24, 0x0b0e, "5D1q" },
- { "sfsr", 14,24, 0x673e, "5D1D" },
- { "skpsb", 16,16, 0x0c0e, "1i" },
- { "skpsw", 16,16, 0x0d0e, "1i" },
- { "skpsd", 16,16, 0x0f0e, "1i" },
- { "skpst", 16,16, 0x8c0e, "1i" },
- { "smr", 15,24, 0x0f1e, "2D1q" },
- { "sprb", 7,16, 0x2c, "2B1q" },
- { "sprw", 7,16, 0x2d, "2W1q" },
- { "sprd", 7,16, 0x2f, "2D1q" },
- { "subf", 14,24, 0x11be, "1F2F" },
- { "subl", 14,24, 0x10be, "1L2L" },
- { "subb", 6,16, 0x20, "1B2B" },
- { "subw", 6,16, 0x21, "1W2W" },
- { "subd", 6,16, 0x23, "1D2D" },
- { "subcb", 6,16, 0x30, "1B2B" },
- { "subcw", 6,16, 0x31, "1W2W" },
- { "subcd", 6,16, 0x33, "1D2D" },
- { "subpb", 14,24, 0x2c4e, "1B2B" },
- { "subpw", 14,24, 0x2d4e, "1W2W" },
- { "subpd", 14,24, 0x2f4e, "1D2D" },
-#ifndef NS32K_SVC_IMMED_OPERANDS
- { "svc", 8,8, 0xe2, "2i1i" }, /* not really, but unix uses it */
-#else
- { "svc", 8,8, 0xe2, "" }, /* not really, but unix uses it */
-#endif
- { "tbitb", 6,16, 0x34, "1B2A" },
- { "tbitw", 6,16, 0x35, "1W2A" },
- { "tbitd", 6,16, 0x37, "1D2A" },
- { "truncfb", 14,24, 0x2c3e, "1F2B" },
- { "truncfw", 14,24, 0x2d3e, "1F2W" },
- { "truncfd", 14,24, 0x2f3e, "1F2D" },
- { "trunclb", 14,24, 0x283e, "1L2B" },
- { "trunclw", 14,24, 0x293e, "1L2W" },
- { "truncld", 14,24, 0x2b3e, "1L2D" },
- { "wait", 8,8, 0xb2, "" },
- { "wrval", 19,24, 0x0071e,"1A" },
- { "xorb", 6,16, 0x38, "1B2B" },
- { "xorw", 6,16, 0x39, "1W2W" },
- { "xord", 6,16, 0x3b, "1D2D" },
-}; /* notstrs */
-
-/* end: ns32k.opcode.h */
-
-#define MAX_ARGS 4
-#define ARG_LEN 50
+++ /dev/null
-/* Print 32000 instructions for GDB, the GNU debugger.
- Copyright (C) 1986 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include <stdio.h>
-
-#include "defs.h"
-#include "param.h"
-#include "symtab.h"
-#include "ns32k-opcode.h"
-
-/* 32000 instructions are never longer than this. */
-#define MAXLEN 62
-
-/* Number of elements in the opcode table. */
-#define NOPCODES (sizeof notstrs / sizeof notstrs[0])
-
-extern char *reg_names[];
-
-#define NEXT_IS_ADDR '|'
-
-/*
- * extract "count" bits starting "offset" bits
- * into buffer
- */
-
-int
-bit_extract (buffer, offset, count)
- char *buffer;
- int offset;
- int count;
-{
- int result;
- int mask;
- int bit;
-
- buffer += offset >> 3;
- offset &= 7;
- bit = 1;
- result = 0;
- while (count--)
- {
- if ((*buffer & (1 << offset)))
- result |= bit;
- if (++offset == 8)
- {
- offset = 0;
- buffer++;
- }
- bit <<= 1;
- }
- return result;
-}
-
-double
-dbit_extract (buffer, offset, count)
-{
- union {
- struct {int low, high; } ival;
- double dval;
- } foo;
-
- foo.ival.low = bit_extract (buffer, offset, 32);
- foo.ival.high = bit_extract (buffer, offset+32, 32);
- return foo.dval;
-}
-
-sign_extend (value, bits)
-{
- value = value & ((1 << bits) - 1);
- return (value & (1 << (bits-1))
- ? value | (~((1 << bits) - 1))
- : value);
-}
-
-flip_bytes (ptr, count)
- char *ptr;
- int count;
-{
- char tmp;
-
- while (count > 0)
- {
- tmp = *ptr;
- ptr[0] = ptr[count-1];
- ptr[count-1] = tmp;
- ptr++;
- count -= 2;
- }
-}
-
-\f
-/* Print the 32000 instruction at address MEMADDR in debugged memory,
- on STREAM. Returns length of the instruction, in bytes. */
-
-int
-print_insn (memaddr, stream)
-CORE_ADDR memaddr;
-FILE *stream;
-{
- unsigned char buffer[MAXLEN];
- register int i;
- register unsigned char *p;
- register char *d;
- unsigned short first_word;
- int gen, disp;
- int ioffset; /* bits into instruction */
- int aoffset; /* bits into arguments */
- char arg_bufs[MAX_ARGS+1][ARG_LEN];
- int argnum;
- int maxarg;
-
- read_memory (memaddr, buffer, MAXLEN);
-
- first_word = *(unsigned short *) buffer;
- for (i = 0; i < NOPCODES; i++)
- if ((first_word & ((1 << notstrs[i].detail.obits) - 1))
- == notstrs[i].detail.code)
- break;
-
- /* Handle undefined instructions. */
- if (i == NOPCODES)
- {
- fprintf (stream, "0%o", buffer[0]);
- return 1;
- }
-
- fprintf (stream, "%s", notstrs[i].name);
-
- ioffset = notstrs[i].detail.ibits;
- aoffset = notstrs[i].detail.ibits;
- d = notstrs[i].detail.args;
-
- if (*d)
- {
- fputc ('\t', stream);
-
- maxarg = 0;
- while (*d)
- {
- argnum = *d - '1';
- d++;
- if (argnum > maxarg && argnum < MAX_ARGS)
- maxarg = argnum;
- ioffset = print_insn_arg (*d, ioffset, &aoffset, buffer,
- memaddr, arg_bufs[argnum]);
- d++;
- }
- for (argnum = 0; argnum <= maxarg; argnum++)
- {
- CORE_ADDR addr;
- char *ch, *index ();
- for (ch = arg_bufs[argnum]; *ch;)
- {
- if (*ch == NEXT_IS_ADDR)
- {
- ++ch;
- addr = atoi (ch);
- print_address (addr, stream);
- while (*ch && *ch != NEXT_IS_ADDR)
- ++ch;
- if (*ch)
- ++ch;
- }
- else
- putc (*ch++, stream);
- }
- if (argnum < maxarg)
- fprintf (stream, ", ");
- }
- }
- return aoffset / 8;
-}
-
-print_insn_arg (d, ioffset, aoffsetp, buffer, addr, result)
- char d;
- int ioffset, *aoffsetp;
- char *buffer;
- CORE_ADDR addr;
- char *result;
-{
- int addr_mode;
- float Fvalue;
- double Lvalue;
- int Ivalue;
- int disp1, disp2;
- int index;
-
- switch (d)
- {
- case 'F':
- case 'L':
- case 'B':
- case 'W':
- case 'D':
- case 'A':
- addr_mode = bit_extract (buffer, ioffset-5, 5);
- ioffset -= 5;
- switch (addr_mode)
- {
- case 0x0: case 0x1: case 0x2: case 0x3:
- case 0x4: case 0x5: case 0x6: case 0x7:
- sprintf (result, "r%d", addr_mode);
- break;
- case 0x8: case 0x9: case 0xa: case 0xb:
- case 0xc: case 0xd: case 0xe: case 0xf:
- disp1 = get_displacement (buffer, aoffsetp);
- sprintf (result, "%d(r%d)", disp1, addr_mode & 7);
- break;
- case 0x10:
- case 0x11:
- case 0x12:
- disp1 = get_displacement (buffer, aoffsetp);
- disp2 = get_displacement (buffer, aoffsetp);
- sprintf (result, "%d(%d(%s))", disp2, disp1,
- addr_mode==0x10?"fp":addr_mode==0x11?"sp":"sb");
- break;
- case 0x13:
- sprintf (result, "reserved");
- break;
- case 0x14:
- switch (d)
- {
- case 'B':
- Ivalue = bit_extract (buffer, *aoffsetp, 8);
- Ivalue = sign_extend (Ivalue, 8);
- *aoffsetp += 8;
- sprintf (result, "$%d", Ivalue);
- break;
- case 'W':
- Ivalue = bit_extract (buffer, *aoffsetp, 16);
- flip_bytes (&Ivalue, 2);
- *aoffsetp += 16;
- Ivalue = sign_extend (Ivalue, 16);
- sprintf (result, "$%d", Ivalue);
- break;
- case 'D':
- Ivalue = bit_extract (buffer, *aoffsetp, 32);
- flip_bytes (&Ivalue, 4);
- *aoffsetp += 32;
- sprintf (result, "$%d", Ivalue);
- break;
- case 'A':
- Ivalue = bit_extract (buffer, *aoffsetp, 32);
- flip_bytes (&Ivalue, 4);
- *aoffsetp += 32;
- sprintf (result, "$|%d|", Ivalue);
- break;
- case 'F':
- Fvalue = (float) bit_extract (buffer, *aoffsetp, 32);
- flip_bytes (&Fvalue, 4);
- *aoffsetp += 32;
- sprintf (result, "$%g", Fvalue);
- break;
- case 'L':
- Lvalue = dbit_extract (buffer, *aoffsetp, 64);
- flip_bytes (&Lvalue, 8);
- *aoffsetp += 64;
- sprintf (result, "$%g", Lvalue);
- break;
- }
- break;
- case 0x15:
- disp1 = get_displacement (buffer, aoffsetp);
- sprintf (result, "@|%d|", disp1);
- break;
- case 0x16:
- disp1 = get_displacement (buffer, aoffsetp);
- disp2 = get_displacement (buffer, aoffsetp);
- sprintf (result, "EXT(%d) + %d", disp1, disp2);
- break;
- case 0x17:
- sprintf (result, "tos");
- break;
- case 0x18:
- disp1 = get_displacement (buffer, aoffsetp);
- sprintf (result, "%d(fp)", disp1);
- break;
- case 0x19:
- disp1 = get_displacement (buffer, aoffsetp);
- sprintf (result, "%d(sp)", disp1);
- break;
- case 0x1a:
- disp1 = get_displacement (buffer, aoffsetp);
- sprintf (result, "%d(sb)", disp1);
- break;
- case 0x1b:
- disp1 = get_displacement (buffer, aoffsetp);
- sprintf (result, "|%d|", addr + disp1);
- break;
- case 0x1c:
- case 0x1d:
- case 0x1e:
- case 0x1f:
- index = bit_extract (buffer, *aoffsetp, 8);
- *aoffsetp += 8;
- print_insn_arg (d, *aoffsetp, aoffsetp, buffer, addr,
- result);
- {
- static char *ind[] = {"b", "w", "d", "q"};
- char *off;
-
- off = result + strlen (result);
- sprintf (off, "[r%d:%s]", index & 7,
- ind[addr_mode & 3]);
- }
- break;
- }
- break;
- case 'q':
- Ivalue = bit_extract (buffer, ioffset-4, 4);
- Ivalue = sign_extend (Ivalue, 4);
- sprintf (result, "%d", Ivalue);
- ioffset -= 4;
- break;
- case 'r':
- Ivalue = bit_extract (buffer, ioffset-3, 3);
- sprintf (result, "r%d", Ivalue&7);
- ioffset -= 3;
- break;
- case 'd':
- sprintf (result, "%d", get_displacement (buffer, aoffsetp));
- break;
- case 'p':
- sprintf (result, "%c%d%c", NEXT_IS_ADDR,
- addr + get_displacement (buffer, aoffsetp),
- NEXT_IS_ADDR);
- break;
- case 'i':
- Ivalue = bit_extract (buffer, *aoffsetp, 8);
- *aoffsetp += 8;
- sprintf (result, "0x%x", Ivalue);
- break;
- }
- return ioffset;
-}
-
-get_displacement (buffer, aoffsetp)
- char *buffer;
- int *aoffsetp;
-{
- int Ivalue;
-
- Ivalue = bit_extract (buffer, *aoffsetp, 8);
- switch (Ivalue & 0xc0)
- {
- case 0x00:
- case 0x40:
- Ivalue = sign_extend (Ivalue, 7);
- *aoffsetp += 8;
- break;
- case 0x80:
- Ivalue = bit_extract (buffer, *aoffsetp, 16);
- flip_bytes (&Ivalue, 2);
- Ivalue = sign_extend (Ivalue, 14);
- *aoffsetp += 16;
- break;
- case 0xc0:
- Ivalue = bit_extract (buffer, *aoffsetp, 32);
- flip_bytes (&Ivalue, 4);
- Ivalue = sign_extend (Ivalue, 30);
- *aoffsetp += 32;
- break;
- }
- return Ivalue;
-}
-\f
-/* Return the number of locals in the current frame given a pc
- pointing to the enter instruction. This is used in the macro
- FRAME_FIND_SAVED_REGS. */
-
-ns32k_localcount (enter_pc)
- CORE_ADDR enter_pc;
-{
- unsigned char localtype;
- int localcount;
-
- localtype = read_memory_integer (enter_pc+2, 1);
- if ((localtype & 0x80) == 0)
- localcount = localtype;
- else if ((localtype & 0xc0) == 0x80)
- localcount = (((localtype & 0x3f) << 8)
- | (read_memory_integer (enter_pc+3, 1) & 0xff));
- else
- localcount = (((localtype & 0x3f) << 24)
- | ((read_memory_integer (enter_pc+3, 1) & 0xff) << 16)
- | ((read_memory_integer (enter_pc+4, 1) & 0xff) << 8 )
- | (read_memory_integer (enter_pc+5, 1) & 0xff));
- return localcount;
-}
-
-/*
- * Get the address of the enter opcode for the function
- * containing PC, if there is an enter for the function,
- * and if the pc is between the enter and exit.
- * Returns positive address if pc is between enter/exit,
- * 1 if pc before enter or after exit, 0 otherwise.
- */
-
-CORE_ADDR
-n32k_get_enter_addr (pc)
- CORE_ADDR pc;
-{
- CORE_ADDR enter_addr;
- unsigned char op;
-
- if (ABOUT_TO_RETURN (pc))
- return 1; /* after exit */
-
- enter_addr = get_pc_function_start (pc);
-
- if (pc == enter_addr)
- return 1; /* before enter */
-
- op = read_memory_integer (enter_addr, 1);
-
- if (op != 0x82)
- return 0; /* function has no enter/exit */
-
- return enter_addr; /* pc is between enter and exit */
-}
+++ /dev/null
-../gcc/gcc-1.22/obstack.c
\ No newline at end of file
--- /dev/null
+/* obstack.c - subroutines used implicitly by object stack macros
+ Copyright (C) 1988 Free Software Foundation, Inc.
+
+ NO WARRANTY
+
+ BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+ GENERAL PUBLIC LICENSE TO COPY
+
+ 1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+ (C) 1988 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License. You may charge a distribution fee for the
+physical act of transferring a copy.
+
+ 2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+ a) cause the modified files to carry prominent notices stating
+ that you changed the files and the date of any change; and
+
+ b) cause the whole of any work that you distribute or publish,
+ that in whole or in part contains or is a derivative of this
+ program or any part thereof, to be licensed at no charge to all
+ third parties on terms identical to those contained in this
+ License Agreement (except that you may choose to grant more extensive
+ warranty protection to some or all third parties, at your option).
+
+ c) You may charge a distribution fee for the physical act of
+ transferring a copy, and you may at your option offer warranty
+ protection in exchange for a fee.
+
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+ 3. You may copy and distribute this program (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the following:
+
+ a) accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ b) accompany it with a written offer, valid for at least three
+ years, to give any third party free (except for a nominal
+ shipping charge) a complete machine-readable copy of the
+ corresponding source code, to be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ c) accompany it with the information you received as to where the
+ corresponding source code may be obtained. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
+
+ 4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement. Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated. However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+ 5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this. We will be guided by the two goals of preserving the free status of
+all derivatives our free software and of promoting the sharing and reuse of
+software.
+
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them. Help stamp out software-hoarding! */
+
+
+#include "obstack.h"
+
+#ifdef __STDC__
+#define POINTER void *
+#else
+#define POINTER char *
+#endif
+
+/* The non-GNU-C macros copy the obstack into this global variable
+ to avoid multiple evaluation. */
+
+struct obstack *_obstack;
+\f
+/* Initialize an obstack H for use. Specify chunk size SIZE.
+ Objects start on multiples of ALIGNMENT.
+ CHUNKFUN is the function to use to allocate chunks,
+ and FREEFUN the function to free them. */
+
+void
+_obstack_begin (h, size, alignment, chunkfun, freefun)
+ struct obstack *h;
+ int size;
+ int alignment;
+ POINTER (*chunkfun) ();
+ void (*freefun) ();
+{
+ register struct _obstack_chunk* chunk; /* points to new chunk */
+ h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun;
+ h->freefun = freefun;
+ h->chunk_size = size;
+ h->alignment_mask = alignment - 1;
+
+ chunk = h->chunk = (*h->chunkfun) (h->chunk_size);
+ h->next_free = h->object_base = chunk->contents;
+ h->chunk_limit = chunk->limit
+ = (char *) chunk + h->chunk_size;
+ chunk->prev = 0;
+}
+
+/* Allocate a new current chunk for the obstack *H
+ on the assumption that LENGTH bytes need to be added
+ to the current object, or a new object of length LENGTH allocated.
+ Copies any partial object from the end of the old chunk
+ to the beginning of the new one. */
+
+void
+_obstack_newchunk (h, length)
+ struct obstack *h;
+ int length;
+{
+ register struct _obstack_chunk* old_chunk = h->chunk;
+ register struct _obstack_chunk* new_chunk;
+ register long new_size;
+ register int obj_size = h->next_free - h->object_base;
+ register int i;
+
+ /* Compute size for new chunk. */
+ new_size = (obj_size + length) << 1;
+ if (new_size < h->chunk_size)
+ new_size = h->chunk_size;
+
+ /* Allocate and initialize the new chunk. */
+ new_chunk = h->chunk = (*h->chunkfun) (new_size);
+ new_chunk->prev = old_chunk;
+ new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;
+
+ /* Move the existing object to the new chunk.
+ Word at a time is fast and is safe because these
+ structures are aligned at least that much. */
+ for (i = (obj_size + sizeof (int) - 1) / sizeof (int); i >= 0; i--)
+ ((int *)new_chunk->contents)[i] = ((int *)h->object_base)[i];
+
+ h->object_base = new_chunk->contents;
+ h->next_free = h->object_base + obj_size;
+}
+
+/* Free objects in obstack H, including OBJ and everything allocate
+ more recently than OBJ. If OBJ is zero, free everything in H. */
+
+void
+#ifdef __STDC__
+#undef obstack_free
+obstack_free (h, obj)
+
+#else
+_obstack_free (h, obj)
+#endif
+ struct obstack *h;
+ POINTER obj;
+{
+ register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */
+ register struct _obstack_chunk* plp; /* point to previous chunk if any */
+
+ lp = (h)->chunk;
+ while (lp != 0 && ((POINTER)lp > obj || (POINTER)(lp)->limit < obj))
+ {
+ plp = lp -> prev;
+ (*h->freefun) (lp);
+ lp = plp;
+ }
+ if (lp)
+ {
+ (h)->object_base = (h)->next_free = (char *)(obj);
+ (h)->chunk_limit = lp->limit;
+ (h)->chunk = lp;
+ }
+ else if (obj != 0)
+ /* obj is not in any of the chunks! */
+ abort ();
+}
+\f
+/* Now define the functional versions of the obstack macros.
+ Define them to simply use the corresponding macros to do the job. */
+
+#ifdef __STDC__
+/* These function definitions do not work with non-ANSI preprocessors;
+ they won't pass through the macro names in parentheses. */
+
+/* The function names appear in parentheses in order to prevent
+ the macro-definitions of the names from being expanded there. */
+
+POINTER (obstack_base) (obstack)
+ struct obstack *obstack;
+{
+ return obstack_base (obstack);
+}
+
+POINTER (obstack_next_free) (obstack)
+ struct obstack *obstack;
+{
+ return obstack_next_free (obstack);
+}
+
+int (obstack_object_size) (obstack)
+ struct obstack *obstack;
+{
+ return obstack_object_size (obstack);
+}
+
+int (obstack_room) (obstack)
+ struct obstack *obstack;
+{
+ return obstack_room (obstack);
+}
+
+void (obstack_grow) (obstack, pointer, length)
+ struct obstack *obstack;
+ POINTER pointer;
+ int length;
+{
+ obstack_grow (obstack, pointer, length);
+}
+
+void (obstack_grow0) (obstack, pointer, length)
+ struct obstack *obstack;
+ POINTER pointer;
+ int length;
+{
+ obstack_grow0 (obstack, pointer, length);
+}
+
+void (obstack_1grow) (obstack, character)
+ struct obstack *obstack;
+ int character;
+{
+ obstack_1grow (obstack, character);
+}
+
+void (obstack_blank) (obstack, length)
+ struct obstack *obstack;
+ int length;
+{
+ obstack_blank (obstack, length);
+}
+
+void (obstack_1grow_fast) (obstack, character)
+ struct obstack *obstack;
+ int character;
+{
+ obstack_1grow_fast (obstack, character);
+}
+
+void (obstack_blank_fast) (obstack, length)
+ struct obstack *obstack;
+ int length;
+{
+ obstack_blank_fast (obstack, length);
+}
+
+POINTER (obstack_finish) (obstack)
+ struct obstack *obstack;
+{
+ return obstack_finish (obstack);
+}
+
+POINTER (obstack_alloc) (obstack, length)
+ struct obstack *obstack;
+ int length;
+{
+ return obstack_alloc (obstack, length);
+}
+
+POINTER (obstack_copy) (obstack, pointer, length)
+ struct obstack *obstack;
+ POINTER pointer;
+ int length;
+{
+ return obstack_copy (obstack, pointer, length);
+}
+
+POINTER (obstack_copy0) (obstack, pointer, length)
+ struct obstack *obstack;
+ POINTER pointer;
+ int length;
+{
+ return obstack_copy0 (obstack, pointer, length);
+}
+
+#endif /* __STDC__ */
+++ /dev/null
-../gcc/gcc-1.19/obstack.h
\ No newline at end of file
--- /dev/null
+/* obstack.h - object stack macros
+ Copyright (C) 1986, 1988 Free Software Foundation, Inc.
+
+ NO WARRANTY
+
+ BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+ GENERAL PUBLIC LICENSE TO COPY
+
+ 1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1988 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License. You may charge a distribution fee for the
+physical act of transferring a copy.
+
+ 2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+ a) cause the modified files to carry prominent notices stating
+ that you changed the files and the date of any change; and
+
+ b) cause the whole of any work that you distribute or publish,
+ that in whole or in part contains or is a derivative of this
+ program or any part thereof, to be licensed at no charge to all
+ third parties on terms identical to those contained in this
+ License Agreement (except that you may choose to grant more extensive
+ warranty protection to some or all third parties, at your option).
+
+ c) You may charge a distribution fee for the physical act of
+ transferring a copy, and you may at your option offer warranty
+ protection in exchange for a fee.
+
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+ 3. You may copy and distribute this program (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the terms
+of Paragraphs 1 and 2 above provided that you also do one of the following:
+
+ a) accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ b) accompany it with a written offer, valid for at least three
+ years, to give any third party free (except for a nominal
+ shipping charge) a complete machine-readable copy of the
+ corresponding source code, to be distributed under the terms of
+ Paragraphs 1 and 2 above; or,
+
+ c) accompany it with the information you received as to where the
+ corresponding source code may be obtained. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
+
+ 4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement. Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated. However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+ 5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this. We will be guided by the two goals of preserving the free status of
+all derivatives our free software and of promoting the sharing and reuse of
+software.
+
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them. Help stamp out software-hoarding! */
+
+
+/* Summary:
+
+All the apparent functions defined here are macros. The idea
+is that you would use these pre-tested macros to solve a
+very specific set of problems, and they would run fast.
+Caution: no side-effects in arguments please!! They may be
+evaluated MANY times!!
+
+These macros operate a stack of objects. Each object starts life
+small, and may grow to maturity. (Consider building a word syllable
+by syllable.) An object can move while it is growing. Once it has
+been "finished" it never changes address again. So the "top of the
+stack" is typically an immature growing object, while the rest of the
+stack is of mature, fixed size and fixed address objects.
+
+These routines grab large chunks of memory, using a function you
+supply, called `obstack_chunk_alloc'. On occasion, they free chunks,
+by calling `obstack_chunk_free'. You must define them and declare
+them before using any obstack macros.
+
+Each independent stack is represented by a `struct obstack'.
+Each of the obstack macros expects a pointer to such a structure
+as the first argument.
+
+One motivation for this package is the problem of growing char strings
+in symbol tables. Unless you are "facist pig with a read-only mind"
+[Gosper's immortal quote from HAKMEM item 154, out of context] you
+would not like to put any arbitrary upper limit on the length of your
+symbols.
+
+In practice this often means you will build many short symbols and a
+few long symbols. At the time you are reading a symbol you don't know
+how long it is. One traditional method is to read a symbol into a
+buffer, realloc()ating the buffer every time you try to read a symbol
+that is longer than the buffer. This is beaut, but you still will
+want to copy the symbol from the buffer to a more permanent
+symbol-table entry say about half the time.
+
+With obstacks, you can work differently. Use one obstack for all symbol
+names. As you read a symbol, grow the name in the obstack gradually.
+When the name is complete, finalize it. Then, if the symbol exists already,
+free the newly read name.
+
+The way we do this is to take a large chunk, allocating memory from
+low addresses. When you want to build a aymbol in the chunk you just
+add chars above the current "high water mark" in the chunk. When you
+have finished adding chars, because you got to the end of the symbol,
+you know how long the chars are, and you can create a new object.
+Mostly the chars will not burst over the highest address of the chunk,
+because you would typically expect a chunk to be (say) 100 times as
+long as an average object.
+
+In case that isn't clear, when we have enough chars to make up
+the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
+so we just point to it where it lies. No moving of chars is
+needed and this is the second win: potentially long strings need
+never be explicitly shuffled. Once an object is formed, it does not
+change its address during its lifetime.
+
+When the chars burst over a chunk boundary, we allocate a larger
+chunk, and then copy the partly formed object from the end of the old
+chunk to the beggining of the new larger chunk. We then carry on
+accreting characters to the end of the object as we normaly would.
+
+A special macro is provided to add a single char at a time to a
+growing object. This allows the use of register variables, which
+break the ordinary 'growth' macro.
+
+Summary:
+ We allocate large chunks.
+ We carve out one object at a time from the current chunk.
+ Once carved, an object never moves.
+ We are free to append data of any size to the currently
+ growing object.
+ Exactly one object is growing in an obstack at any one time.
+ You can run one obstack per control block.
+ You may have as many control blocks as you dare.
+ Because of the way we do it, you can `unwind' a obstack
+ back to a previous state. (You may remove objects much
+ as you would with a stack.)
+*/
+
+
+/* Don't do the contents of this file more than once. */
+
+#ifndef __OBSTACKS__
+#define __OBSTACKS__
+\f
+#ifdef __STDC__
+
+/* Do the function-declarations before defining the macros. */
+
+void obstack_init (struct obstack *obstack);
+
+void * obstack_alloc (struct obstack *obstack, int size);
+
+void * obstack_copy (struct obstack *obstack, void *address, int size);
+void * obstack_copy0 (struct obstack *obstack, void *address, int size);
+
+void obstack_free (struct obstack *obstack, void *block);
+
+void obstack_blank (struct obstack *obstack, int size);
+
+void obstack_grow (struct obstack *obstack, void *data, int size);
+void obstack_grow0 (struct obstack *obstack, void *data, int size);
+
+void obstack_1grow (struct obstack *obstack, int data_char);
+
+void * obstack_finish (struct obstack *obstack);
+
+int obstack_object_size (struct obstack *obstack);
+
+int obstack_room (struct obstack *obstack);
+void obstack_1grow_fast (struct obstack *obstack, int data_char);
+void obstack_blank_fast (struct obstack *obstack, int size);
+
+void * object_base (struct obstack *obstack);
+void * object_next_free (struct obstack *obstack);
+int obstack_alignment_mask (struct obstack *obstack);
+int obstack_chunk_size (struct obstack *obstack);
+
+#endif /* __STDC__ */
+
+/* Non-ANSI C cannot really support alternative functions for these macros,
+ so we do not declare them. */
+\f
+struct _obstack_chunk /* Lives at front of each chunk. */
+{
+ char *limit; /* 1 past end of this chunk */
+ struct _obstack_chunk *prev; /* address of prior chunk or NULL */
+ char contents[4]; /* objects begin here */
+};
+
+struct obstack /* control current object in current chunk */
+{
+ long chunk_size; /* preferred size to allocate chunks in */
+ struct _obstack_chunk* chunk; /* address of current struct obstack_chunk */
+ char *object_base; /* address of object we are building */
+ char *next_free; /* where to add next char to current object */
+ char *chunk_limit; /* address of char after current chunk */
+ int temp; /* Temporary for some macros. */
+ int alignment_mask; /* Mask of alignment for each object. */
+ struct _obstack_chunk *(*chunkfun) (); /* User's fcn to allocate a chunk. */
+ void (*freefun) (); /* User's function to free a chunk. */
+};
+
+/* Pointer to beginning of object being allocated or to be allocated next.
+ Note that this might not be the final address of the object
+ because a new chunk might be needed to hold the final size. */
+
+#define obstack_base(h) ((h)->object_base)
+
+/* Size for allocating ordinary chunks. */
+
+#define obstack_chunk_size(h) ((h)->chunk_size)
+
+/* Pointer to next byte not yet allocated in current chunk. */
+
+#define obstack_next_free(h) ((h)->next_free)
+
+/* Mask specifying low bits that should be clear in address of an object. */
+
+#define obstack_alignment_mask(h) ((h)->alignment_mask)
+
+#define obstack_init(h) \
+ _obstack_begin ((h), 4096 - 4, 4, obstack_chunk_alloc, obstack_chunk_free)
+
+#define obstack_begin(h, size) \
+ _obstack_begin ((h), (size), 4, obstack_chunk_alloc, obstack_chunk_free)
+
+#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar)
+
+#define obstack_blank_fast(h,n) ((h)->next_free += (n))
+\f
+#if defined (__GNU__) && defined (__STDC__)
+
+/* For GNU C we can define these macros to compute all args only once
+ without using a global variable.
+ Also, we can avoid using the `temp' slot, to make faster code.
+
+ By checking both __GNU__ and __STDC__, we can make sure
+ both GNU language extensions and ANSI preprocessing are available. */
+
+#define obstack_object_size(OBSTACK) \
+ ({ struct obstack *__o = (OBSTACK); \
+ (unsigned) (__o->next_free - __o->object_base); })
+
+#define obstack_room(OBSTACK) \
+ ({ struct obstack *__o = (OBSTACK); \
+ (unsigned) (__o->chunk_limit - __o->next_free); })
+
+#define obstack_grow(OBSTACK,where,length) \
+({ struct obstack *__o = (OBSTACK); \
+ int __len = (length); \
+ ((__o->next_free + __len > __o->chunk_limit) \
+ ? _obstack_newchunk (__o, __len) : 0); \
+ bcopy (where, __o->next_free, __len); \
+ __o->next_free += __len; \
+ (void) 0; })
+
+#define obstack_grow0(OBSTACK,where,length) \
+({ struct obstack *__o = (OBSTACK); \
+ int __len = (length); \
+ ((__o->next_free + __len + 1 > __o->chunk_limit) \
+ ? _obstack_newchunk (__o, __len + 1) : 0), \
+ bcopy (where, __o->next_free, __len), \
+ __o->next_free += __len, \
+ *(__o->next_free)++ = 0; \
+ (void) 0; })
+
+#define obstack_1grow(OBSTACK,datum) \
+({ struct obstack *__o = (OBSTACK); \
+ ((__o->next_free + 1 > __o->chunk_limit) \
+ ? _obstack_newchunk (__o, 1) : 0), \
+ *(__o->next_free)++ = (datum); \
+ (void) 0; })
+
+#define obstack_blank(OBSTACK,length) \
+({ struct obstack *__o = (OBSTACK); \
+ int __len = (length); \
+ ((__o->next_free + __len > __o->chunk_limit) \
+ ? _obstack_newchunk (__o, __len) : 0); \
+ __o->next_free += __len; \
+ (void) 0; })
+
+#define obstack_alloc(OBSTACK,length) \
+({ struct obstack *__h = (OBSTACK); \
+ obstack_blank (__h, (length)); \
+ obstack_finish (__h); })
+
+#define obstack_copy(OBSTACK,where,length) \
+({ struct obstack *__h = (OBSTACK); \
+ obstack_grow (__h, (where), (length)); \
+ obstack_finish (__h); })
+
+#define obstack_copy0(OBSTACK,where,length) \
+({ struct obstack *__h = (OBSTACK); \
+ obstack_grow0 (__h, (where), (length)); \
+ obstack_finish (__h); })
+
+#define obstack_finish(OBSTACK) \
+({ struct obstack *__o = (OBSTACK); \
+ void *value = (void *) __o->object_base; \
+ __o->next_free \
+ = (char*)((int)(__o->next_free+__o->alignment_mask) \
+ & ~ (__o->alignment_mask)); \
+ ((__o->next_free - (char *)__o->chunk \
+ > __o->chunk_limit - (char *)__o->chunk) \
+ ? __o->next_free = __o->chunk_limit : 0); \
+ __o->object_base = __o->next_free; \
+ value; })
+
+#define obstack_free(OBSTACK, OBJ) \
+({ struct obstack *__o = (OBSTACK); \
+ void *__obj = (OBJ); \
+ if (__obj >= (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \
+ __o->next_free = __o->object_base = __obj; \
+ else (obstack_free) (__o, __obj); })
+\f
+#else /* not __GNU__ */
+
+/* The non-GNU macros copy the obstack-pointer into this global variable
+ to avoid multiple evaluation. */
+
+extern struct obstack *_obstack;
+
+#define obstack_object_size(h) \
+ (unsigned) (_obstack = (h), (h)->next_free - (h)->object_base)
+
+#define obstack_room(h) \
+ (unsigned) (_obstack = (h), (h)->chunk_limit - (h)->next_free)
+
+#define obstack_grow(h,where,length) \
+( (h)->temp = (length), \
+ (((h)->next_free + (h)->temp > (h)->chunk_limit) \
+ ? _obstack_newchunk ((h), (h)->temp) : 0), \
+ bcopy (where, (h)->next_free, (h)->temp), \
+ (h)->next_free += (h)->temp)
+
+#define obstack_grow0(h,where,length) \
+( (h)->temp = (length), \
+ (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \
+ ? _obstack_newchunk ((h), (h)->temp + 1) : 0), \
+ bcopy (where, (h)->next_free, (h)->temp), \
+ (h)->next_free += (h)->temp, \
+ *((h)->next_free)++ = 0)
+
+#define obstack_1grow(h,datum) \
+( (((h)->next_free + 1 > (h)->chunk_limit) \
+ ? _obstack_newchunk ((h), 1) : 0), \
+ *((h)->next_free)++ = (datum))
+
+#define obstack_blank(h,length) \
+( (h)->temp = (length), \
+ (((h)->next_free + (h)->temp > (h)->chunk_limit) \
+ ? _obstack_newchunk ((h), (h)->temp) : 0), \
+ (h)->next_free += (h)->temp)
+
+#define obstack_alloc(h,length) \
+ (obstack_blank ((h), (length)), obstack_finish ((h)))
+
+#define obstack_copy(h,where,length) \
+ (obstack_grow ((h), (where), (length)), obstack_finish ((h)))
+
+#define obstack_copy0(h,where,length) \
+ (obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
+
+#define obstack_finish(h) \
+( (h)->temp = (int) (h)->object_base, \
+ (h)->next_free \
+ = (char*)((int)((h)->next_free+(h)->alignment_mask) \
+ & ~ ((h)->alignment_mask)), \
+ (((h)->next_free - (char *)(h)->chunk \
+ > (h)->chunk_limit - (char *)(h)->chunk) \
+ ? (h)->next_free = (h)->chunk_limit : 0), \
+ (h)->object_base = (h)->next_free, \
+ (char *) (h)->temp)
+
+#ifdef __STDC__
+#define obstack_free(h,obj) \
+( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \
+ (((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
+ ? (int) ((h)->next_free = (h)->object_base \
+ = (h)->temp + (char *) (h)->chunk) \
+ : (int) (obstack_free) ((h), (h)->temp + (char *) (h)->chunk)))
+#else
+#define obstack_free(h,obj) \
+( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \
+ (((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
+ ? (int) ((h)->next_free = (h)->object_base \
+ = (h)->temp + (char *) (h)->chunk) \
+ : (int) _obstack_free ((h), (h)->temp + (char *) (h)->chunk)))
+#endif
+
+#endif /* not __GNU__ */
+
+#endif /* not __OBSTACKS__ */
+
-#include "m-mac-aux.h"
+#include "m-sun3.h"
--- /dev/null
+#include <stdio.h>
+
+class math_stuff
+{
+ char name[40];
+ int value;
+
+public:
+
+ void bla();
+
+ math_stuff(char*);
+
+ ~math_stuff();
+
+ void add(int);
+
+ void print_value(char*);
+};
+
+void math_stuff::bla()
+{
+ printf("bla\n");
+}
+
+math_stuff::math_stuff(char* new_name)
+{
+ sprintf((char *)this->name,(char *)"MATH_STUFF_%s",new_name);
+ value = 0;
+}
+
+math_stuff::~math_stuff()
+{
+ printf((char *)"Deleting MATH_STUFF instance '%s'\n",this->name);
+}
+
+void math_stuff::add(int x)
+{
+ this->value += x;
+}
+
+void math_stuff::print_value(char *where)
+{
+ printf((char *)"current value of '%s' at '%s' = %d\n", this->name, where, this->value);
+}
+
+class derived : public math_stuff
+{
+ char *dname;
+ int val;
+
+public:
+ math_stuff stuff;
+ derived(char*);
+ ~derived();
+ void print_all(char*);
+};
+
+derived::derived(char *der_name)
+ : ((char *)"hello, world!"), stuff("derived stuff"), val(10)
+{
+ printf((char *)"derived name = %s\n", der_name);
+ dname = der_name;
+ stuff.add(6);
+ stuff.print_value ((char *)"grind");
+}
+
+derived::~derived()
+{
+ printf ((char *)"Good bye! \n");
+}
+
+derived::print_all(char *msg)
+{
+ printf((char *)"Here's the lowdown:\n");
+ printf((char *)"My name is %s\n", dname);
+ printf((char *)"My value = %d\n", val);
+ stuff.print_value ((char *)"low");
+ this->print_value((char *)"down");
+ printf((char *)"That's all you get tonight.\n\n");
+}
+
+main()
+{
+ int pid;
+ int i;
+
+ pid = vfork();
+ if (pid > 0)
+ printf(" the inferior pid of the child is %d\n",pid);
+ if (pid == 0)
+ {
+/* execl ("/bin/sh", "sh", "-c",argv[1],0);*/
+
+ math_stuff* a;
+ derived* d;
+ math_stuff b $ (" no gnus are good gnus ");
+ int child;
+ child = getpid();
+ printf( " the child from parent.c is %d\n",child);
+ ptrace (0);
+
+ a = new math_stuff((char *)"a");
+
+ d = new derived((char *)"two words");
+
+ a->add(2);
+ a->add(4);
+ a->add(5);
+ a->print_value((char *)"here");
+ a->add(7);
+ a->print_value((char *)"there");
+ a->add(3);
+ a->add(1);
+ a->print_value((char *)"end");
+
+ d->print_all ((char *)"all");
+
+ delete a;
+ delete d;
+ exit(0);
+ }
+ i = 5;
+ i = 6;
+ i = 7;
+}
/* Print values for GNU debugger gdb.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
break;
}
+ /* Make sure 'g' size is not used on integer types. */
+ if (val.size == 'g' && val.format != 'f')
+ val.size = 'w';
+
while (*p == ' ' || *p == '\t') p++;
*string_ptr = p;
\f
/* Print value VAL on stdout according to FORMAT, a letter or 0.
Do not end with a newline.
- 0 means print VAL according to its own type. */
+ 0 means print VAL according to its own type.
+ SIZE is the letter for the size of datum being printed.
+ This is used to pad hex numbers so they line up. */
static void
-print_formatted (val, format)
+print_formatted (val, format, size)
register value val;
register char format;
+ char size;
{
register CORE_ADDR val_long;
int len = TYPE_LENGTH (VALUE_TYPE (val));
break;
case 'x':
- printf ("0x%x", val_long);
+ switch (size)
+ {
+ case 'b':
+ printf ("0x%02x", val_long);
+ break;
+ case 'h':
+ printf ("0x%04x", val_long);
+ break;
+ case 0: /* no size specified, like in print */
+ case 'w':
+ printf ("0x%08x", val_long);
+ break;
+ case 'g':
+ printf ("0x%16x", val_long);
+ break;
+ default:
+ error ("Undefined output size \"%c\".", size);
+ }
break;
case 'd':
while (count > 0)
{
print_address (next_address, stdout);
+ fputc (':', stdout);
for (i = maxelts;
i > 0 && count > 0;
i--, count--)
/* Note that this sets next_address for the next object. */
last_examine_address = next_address;
last_examine_value = value_at (val_type, next_address);
- print_formatted (last_examine_value, format);
+ print_formatted (last_examine_value, format, size);
}
fputc ('\n', stdout);
fflush (stdout);
else
val = access_value_history (0);
+ if (!val) return; /* C++ */
histindex = record_latest_value (val);
printf ("$%d = ", histindex);
- print_formatted (val, format);
+ print_formatted (val, format, fmt.size);
printf ("\n");
if (cleanup)
val = evaluate_expression (expr);
- print_formatted (val, format);
+ print_formatted (val, format, fmt.size);
do_cleanups (old_chain);
}
do_cleanups (old_chain);
}
+/* C++: Modified to give useful information about variable which
+ hang off of `this'. */
static void
address_info (exp)
char *exp;
{
register struct symbol *sym;
register CORE_ADDR val;
+ struct block *block, *get_selected_block ();
if (exp == 0)
error ("Argument required.");
- sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE);
+ block = get_selected_block ();
+ sym = lookup_symbol_1 (exp, block, VAR_NAMESPACE);
+ if (! sym)
+ {
+ value v;
+
+ /* C++: see if it hangs off of `this'. Must
+ not inadvertently convert from a method call
+ to data ref. */
+ v = value_of_this (0);
+ if (v)
+ {
+ val = check_field (v, exp);
+ if (val)
+ {
+ printf ("Symbol \"%s\" is a field of the local class variable `this'\n", exp);
+ return;
+ }
+ }
+ else
+ sym = lookup_symbol_2 (exp, 0, VAR_NAMESPACE);
+ }
if (sym == 0)
{
register int i;
else
val = access_value_history (0);
- printf ("type = ");
- type_print (VALUE_TYPE (val), "", stdout, 1);
- printf ("\n");
+ if (val != 0)
+ {
+ printf ("type = ");
+ type_print (VALUE_TYPE (val), "", stdout, 1);
+ printf ("\n");
+ }
if (exp)
do_cleanups (old_chain);
type_print (type, "", stdout, 1);
printf ("\n");
}
+
+/* Print all the methods that correspond to the name METHOD.
+ Can optionally qualify the method with a CLASSNAME, as
+ in CLASSNAME :: METHODNAME. This routine does not call
+ parse_c_expression, so the input must conform to one of
+ these two forms. */
+
+static void
+pmethod_command (exp)
+ char *exp;
+{
+# if 0
+ struct expression *expr;
+ register value val;
+ register struct cleanup *old_chain;
+ char *classname, *methodname;
+
+ methodname = exp;
+ while (*exp++ <= ' ') ; /* remove leading whitespace */
+ if (exp[-1] == ':')
+ if (*exp == ':')
+ classname = (char *)1;
+ else error ("Invalid syntax: \"%s\"", methodname);
+ else
+ {
+ classname = exp-1;
+ while (*exp++ != ':') ;
+ exp[-1] = '\0';
+ if (*exp == ':')
+ {
+ while (*exp++ <= ' ') ; /* remove leading 2nd whitespace */
+ methodname = exp-1;
+ while (((*exp | 0x20) >= 'a' && ((*exp | 0x20) <= 'z')) || *exp == '_')
+ exp++;
+ if (*exp)
+ {
+ *exp++ = '\0';
+ while (*exp)
+ if (*exp > ' ') error ("junk after method name");
+ }
+ }
+ else error ("Invalid syntax: \"%s\"", methodname);
+ }
+ if (classname)
+ {
+ if (classname != (char *)1)
+ classtype = lookup_typename (classname);
+ else
+ {
+ register struct symtab *s;
+ register struct blockvector *bv;
+ struct blockvector *prev_bv = 0;
+ register struct block *b;
+ register int i, j;
+ register struct symbol *sym;
+ char *val;
+ int found_in_file;
+ static char *classnames[]
+ = {"variable", "function", "type", "method"};
+ int print_count = 0;
+
+ if (regexp)
+ if (val = (char *) re_comp (regexp))
+ error ("Invalid regexp: %s", val);
+
+ printf (regexp
+ ? "All %ss matching regular expression \"%s\":\n"
+ : "All defined %ss:\n",
+ classnames[class],
+ regexp);
+
+ for (s = symtab_list; s; s = s->next)
+ {
+ found_in_file = 0;
+ bv = BLOCKVECTOR (s);
+ /* Often many files share a blockvector.
+ Scan each blockvector only once so that
+ we don't get every symbol many times.
+ It happens that the first symtab in the list
+ for any given blockvector is the main file. */
+ if (bv != prev_bv)
+ for (i = 0; i < 2; i++)
+ {
+ b = BLOCKVECTOR_BLOCK (bv, i);
+ for (j = 0; j < BLOCK_NSYMS (b); j++)
+ {
+ QUIT;
+ sym = BLOCK_SYM (b, j);
+ if ((regexp == 0 || re_exec (SYMBOL_NAME (sym)))
+ && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+ && SYMBOL_CLASS (sym) != LOC_BLOCK)
+ || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))
+ {
+ if (!found_in_file)
+ {
+ printf ("\nFile %s:\n", s->filename);
+ print_count += 2;
+ }
+ found_in_file = 1;
+ MORE;
+ if (i == 1)
+ printf ("static ");
+
+ type_print (SYMBOL_TYPE (sym),
+ (SYMBOL_CLASS (sym) == LOC_TYPEDEF
+ ? "" : SYMBOL_NAME (sym)),
+ stdout, 0);
+ printf (";\n");
+ }
+ }
+ }
+ prev_bv = bv;
+ }
+ }
+ }
+ if (exp)
+ {
+ expr = parse_c_expression (exp);
+ old_chain = make_cleanup (free_current_contents, &expr);
+ val = evaluate_type (expr);
+ }
+ else
+ val = access_value_history (0);
+
+ if (val != 0)
+ {
+ printf ("type = ");
+ type_print (VALUE_TYPE (val), "", stdout, 1);
+ printf ("\n");
+ }
+
+ if (exp)
+ do_cleanups (old_chain);
+# endif
+}
\f
struct display
{
printf ("/%c ", d->format.format);
print_expression (d->exp, stdout);
printf (" = ");
- print_formatted (evaluate_expression (d->exp), d->format.format);
+ print_formatted (evaluate_expression (d->exp),
+ d->format.format, d->format.size);
printf ("\n");
}
fflush (stdout);
}
}
\f
+static void
+printf_command (arg)
+ char *arg;
+{
+ register char *f;
+ register char *s = arg;
+ char *string;
+ value *val_args;
+ int nargs = 0;
+ int allocated_args = 20;
+ char *arg_bytes;
+ char *argclass;
+ int i;
+ int argindex;
+ int nargs_wanted;
+
+ val_args = (value *) xmalloc (allocated_args * sizeof (value));
+
+ if (s == 0)
+ error_no_arg ("format-control string and values to print");
+
+ /* Skip white space before format string */
+ while (*s == ' ' || *s == '\t') s++;
+
+ /* A format string should follow, enveloped in double quotes */
+ if (*s++ != '"')
+ error ("Bad format string, missing '\"'.");
+
+ /* Parse the format-control string and copy it into the string STRING,
+ processing some kinds of escape sequence. */
+
+ f = string = (char *) alloca (strlen (s) + 1);
+ while (*s != '"')
+ {
+ int c = *s++;
+ switch (c)
+ {
+ case '\0':
+ error ("Bad format string, non-terminated '\"'.");
+ /* doesn't return */
+
+ case '\\':
+ switch (c = *s++)
+ {
+ case '\\':
+ *f++ = '\\';
+ break;
+ case 'n':
+ *f++ = '\n';
+ break;
+ case 't':
+ *f++ = '\t';
+ break;
+ case 'r':
+ *f++ = '\r';
+ break;
+ case '"':
+ *f++ = '"';
+ break;
+ default:
+ /* ??? TODO: handle other escape sequences */
+ error ("Unrecognized \\ escape character in format string.");
+ }
+ break;
+
+ default:
+ *f++ = c;
+ }
+ }
+
+ /* Skip over " and following space and comma. */
+ s++;
+ *f++ = '\0';
+ while (*s == ' ' || *s == '\t') s++;
+
+ if (*s != ',' && *s != 0)
+ error ("Invalid argument syntax");
+
+ if (*s == ',') s++;
+ while (*s == ' ' || *s == '\t') s++;
+
+ /* Now scan the string for %-specs and see what kinds of args they want.
+ argclass[I] is set to 1 if the Ith arg should be a string. */
+
+ argclass = (char *) alloca (strlen (s));
+ nargs_wanted = 0;
+ f = string;
+ while (*f)
+ if (*f++ == '%')
+ {
+ while (index ("0123456789.hlL-+ #", *f)) f++;
+ if (*f == 's')
+ argclass[nargs_wanted++] = 1;
+ else if (*f != '%')
+ argclass[nargs_wanted++] = 0;
+ f++;
+ }
+
+ /* Now, parse all arguments and evaluate them.
+ Store the VALUEs in VAL_ARGS. */
+
+ while (*s != '\0')
+ {
+ char *s1;
+ if (nargs == allocated_args)
+ val_args = (value *) xrealloc (val_args,
+ (allocated_args *= 2)
+ * sizeof (value));
+ s1 = s;
+ val_args[nargs++] = parse_to_comma_and_eval (&s1);
+ s = s1;
+ if (*s == ',')
+ s++;
+ }
+
+ if (nargs != nargs_wanted)
+ error ("Wrong number of arguments for specified format-string");
+
+ /* Now lay out an argument-list containing the arguments
+ as doubles, integers and C pointers. */
+
+ arg_bytes = (char *) alloca (sizeof (double) * nargs);
+ argindex = 0;
+ for (i = 0; i < nargs; i++)
+ {
+ if (argclass[i])
+ {
+ char *str;
+ int tem, j;
+ tem = value_as_long (val_args[i]);
+
+ /* This is a %s argument. Find the length of the string. */
+ for (j = 0; ; j++)
+ {
+ char c;
+ QUIT;
+ read_memory (tem + j, &c, 1);
+ if (c == 0)
+ break;
+ }
+
+ /* Copy the string contents into a string inside GDB. */
+ str = (char *) alloca (j + 1);
+ read_memory (tem, str, j);
+ str[j] = 0;
+
+ /* Pass address of internal copy as the arg to vprintf. */
+ *((int *) &arg_bytes[argindex]) = (int) str;
+ argindex += sizeof (int);
+ }
+ else if (VALUE_TYPE (val_args[i])->code == TYPE_CODE_FLT)
+ {
+ *((double *) &arg_bytes[argindex]) = value_as_double (val_args[i]);
+ argindex += sizeof (double);
+ }
+ else
+ {
+ *((int *) &arg_bytes[argindex]) = value_as_long (val_args[i]);
+ argindex += sizeof (int);
+ }
+ }
+
+ vprintf (string, arg_bytes);
+}
+\f
static
initialize ()
{
add_com ("whatis", class_vars, whatis_command,
"Print data type of expression EXP.");
+ add_com ("pmethod", class_vars, pmethod_command,
+ "Print definitions of method METHOD.\n\
+Argument must resolve to a method name within the containing scope.\n\
+All definitions found go into history array.");
+
add_info ("display", display_info,
"Expressions to display when program stops, with code numbers.");
add_com ("undisplay", class_vars, undisplay_command,
With no argument, display all currently requested auto-display expressions.\n\
Use \"undisplay\" to cancel display requests previously made.");
+ add_com ("printf", class_vars, printf_command,
+ "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
+This is useful for formatted output in user-defined commands.");
add_com ("output", class_vars, output_command,
"Like \"print\" but don't put in value history and don't print newline.\n\
This is useful in user-defined commands.");
--- /dev/null
+/* Memory-access and commands for inferior process, for GDB.
+ Copyright (C) 1988 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY. No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License. A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities. It
+should be in a file named COPYING. Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther. Help stamp out software hoarding!
+*/
+
+/* Remote communication protocol.
+ All values are encoded in ascii hex digits.
+
+ Request Packet
+
+ read registers g
+ reply XX....X Each byte of register data
+ is described by two hex digits.
+ Registers are in the internal order
+ for GDB, and the bytes in a register
+ are in the same order the machine uses.
+ or ENN for an error.
+
+ write regs GXX..XX Each byte of register data
+ is described by two hex digits.
+ reply OK for success
+ ENN for an error
+
+ read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
+ reply XX..XX XX..XX is mem contents
+ or ENN NN is errno
+
+ write mem MAA..AA,LLLL:XX..XX
+ AA..AA is address,
+ LLLL is number of bytes,
+ XX..XX is data
+ reply OK for success
+ ENN for an error
+
+ cont cAA..AA AA..AA is address to resume
+ If AA..AA is omitted,
+ resume at same address.
+
+ step sAA..AA AA..AA is address to resume
+ If AA..AA is omitted,
+ resume at same address.
+
+ There is no immediate reply to step or cont.
+ The reply comes when the machine stops.
+ It is SAA AA is the "signal number"
+
+ kill req k
+*/
+
+#include <stdio.h>
+#include <signal.h>
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "frame.h"
+#include "inferior.h"
+
+#include <sys/wait.h>
+#include <sys/ioctl.h>
+#include <a.out.h>
+#include <sys/file.h>
+#include <sgtty.h>
+
+int kiodebug;
+
+int icache;
+
+/* Descriptor for I/O to remote machine. */
+int remote_desc;
+
+#define PBUFSIZ 300
+
+static void remote_send ();
+static void putpkt ();
+static void getpkt ();
+static void dcache_flush ();
+
+START_FILE
+\f
+/* Open a connection to a remote debugger.
+ NAME is the filename used for communication. */
+
+void
+remote_open (name, from_tty)
+ char *name;
+ int from_tty;
+{
+ struct sgttyb sg;
+
+ remote_debugging = 0;
+ dcache_init ();
+
+ remote_desc = open (name, O_RDWR);
+ if (remote_desc < 0)
+ perror_with_name (name);
+
+ ioctl (remote_desc, TIOCGETP, &sg);
+ sg.sg_flags = RAW;
+ ioctl (remote_desc, TIOCSETP, &sg);
+
+ if (from_tty)
+ printf ("Remote debugging using %s\n", name);
+ remote_debugging = 1;
+}
+
+/* Convert hex digit A to a number. */
+
+static int
+fromhex (a)
+ int a;
+{
+ if (a >= '0' && a <= '9')
+ return a - '0';
+ else if (a >= 'a' && a <= 'f')
+ return a - 'a' + 10;
+ else
+ error ("Reply contains invalid hex digit");
+}
+
+/* Convert number NIB to a hex digit. */
+
+static int
+tohex (nib)
+ int nib;
+{
+ if (nib < 10)
+ return '0'+nib;
+ else
+ return 'a'+nib-10;
+}
+\f
+/* Tell the remote machine to resume. */
+
+int
+remote_resume (step, signal)
+ int step, signal;
+{
+ char buf[PBUFSIZ];
+
+ dcache_flush ();
+
+ strcpy (buf, step ? "s": "c");
+
+ putpkt (buf);
+}
+
+/* Wait until the remote machine stops, then return,
+ storing status in STATUS just as `wait' would. */
+
+int
+remote_wait (status)
+ union wait *status;
+{
+ char buf[PBUFSIZ];
+
+ status->w_status = 0;
+ getpkt (buf);
+ if (buf[0] == 'E')
+ error ("Remote failure reply: %s", buf);
+ if (buf[0] != 'S')
+ error ("Invalid remote reply: %s", buf);
+ status->w_stopval = WSTOPPED;
+ status->w_stopsig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
+}
+
+/* Read the remote registers into the block REGS. */
+
+void
+remote_fetch_registers (regs)
+ char *regs;
+{
+ char buf[PBUFSIZ];
+ int i;
+ char *p;
+
+ sprintf (buf, "g");
+ remote_send (buf);
+
+ /* Reply describes registers byte by byte,
+ each byte encoded as two hex characters. */
+
+ p = buf;
+ for (i = 0; i < REGISTER_BYTES; i++)
+ {
+ if (p[0] == 0 || p[1] == 0)
+ error ("Remote reply is too short: %s", buf);
+ regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
+ p += 2;
+ }
+}
+
+/* Store the remote registers from the contents of the block REGS. */
+
+void
+remote_store_registers (regs)
+ char *regs;
+{
+ char buf[PBUFSIZ];
+ int i;
+ char *p;
+
+ buf[0] = 'G';
+
+ /* Command describes registers byte by byte,
+ each byte encoded as two hex characters. */
+
+ p = buf + 1;
+ for (i = 0; i < REGISTER_BYTES; i++)
+ {
+ *p++ = (regs[i] > 4) & 0xf;
+ *p++ = regs[i] & 0xf;
+ }
+
+ remote_send (buf);
+}
+
+/* Read a word from remote address ADDR and return it.
+ This goes through the data cache. */
+
+int
+remote_fetch_word (addr)
+ CORE_ADDR addr;
+{
+ if (icache)
+ {
+ extern CORE_ADDR text_start, text_end;
+
+ if (addr >= text_start && addr < text_end)
+ {
+ int buffer;
+ xfer_core_file (addr, &buffer, sizeof (int));
+ return buffer;
+ }
+ }
+ return dcache_fetch (addr);
+}
+
+/* Write a word WORD into remote address ADDR.
+ This goes through the data cache. */
+
+void
+remote_store_word (addr, word)
+ CORE_ADDR addr;
+ int word;
+{
+ dcache_poke (addr, word);
+}
+\f
+/* Write memory data directly to the remote machine.
+ This does not inform the data cache; the data cache uses this.
+ MEMADDR is the address in the remote memory space.
+ MYADDR is the address of the buffer in our space.
+ LEN is the number of bytes. */
+
+void
+remote_write_bytes (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+ char buf[PBUFSIZ];
+ int i;
+ char *p;
+
+ if (len > PBUFSIZ / 2 - 20)
+ abort ();
+
+ sprintf (buf, "M%x,%x:", memaddr, len);
+
+ /* Command describes registers byte by byte,
+ each byte encoded as two hex characters. */
+
+ p = buf + strlen (buf);
+ for (i = 0; i < len; i++)
+ {
+ *p++ = (myaddr[i] > 4) & 0xf;
+ *p++ = myaddr[i] & 0xf;
+ }
+
+ remote_send (buf);
+}
+
+/* Read memory data directly from the remote machine.
+ This does not use the data cache; the data cache uses this.
+ MEMADDR is the address in the remote memory space.
+ MYADDR is the address of the buffer in our space.
+ LEN is the number of bytes. */
+
+void
+remote_read_bytes (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+ char buf[PBUFSIZ];
+ int i;
+ char *p;
+
+ if (len > PBUFSIZ / 2 - 1)
+ abort ();
+
+ sprintf (buf, "m%x,%x", memaddr, len);
+ remote_send (buf);
+
+ /* Reply describes registers byte by byte,
+ each byte encoded as two hex characters. */
+
+ p = buf;
+ for (i = 0; i < REGISTER_BYTES; i++)
+ {
+ if (p[0] == 0 || p[1] == 0)
+ error ("Remote reply is too short: %s", buf);
+ myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
+ p += 2;
+ }
+}
+\f
+/*
+
+A debug packet whose contents are <data>
+is encapsulated for transmission in the form:
+
+ $ <data> # CSUM1 CSUM2
+
+ <data> must be ASCII alphanumeric and cannot include characters
+ '$' or '#'
+
+ CSUM1 and CSUM2 are ascii hex representation of an 8-bit
+ checksum of <data>, the most significant nibble is sent first.
+ the hex digits 0-9,a-f are used.
+
+Receiver responds with:
+
+ + - if CSUM is correct and ready for next packet
+ - - if CSUM is incorrect
+
+*/
+
+/* Send the command in BUF to the remote machine,
+ and read the reply into BUF.
+ Report an error if we get an error reply. */
+
+static void
+remote_send (buf)
+ char *buf;
+{
+ int i;
+ putpkt (buf);
+ getpkt (buf);
+
+ if (buf[0] == 'E')
+ error ("Remote failure reply: %s", buf);
+}
+
+/* Send a packet to the remote machine, with error checking.
+ The data of the packet is in BUF. */
+
+static void
+putpkt (buf)
+ char *buf;
+{
+ int i;
+ char csum = 0;
+ char buf2[500];
+ char buf3[1];
+ int cnt = strlen (buf);
+ char *p;
+
+ if (kiodebug)
+ fprintf (stderr, "Sending packet: %s\n", buf);
+
+ /* Copy the packet into buffer BUF2, encapsulating it
+ and giving it a checksum. */
+
+ p = buf2;
+ *p++ = '$';
+
+ for (i = 0; i < cnt; i++)
+ {
+ csum += buf[i];
+ *p++ = buf[i];
+ }
+ *p++ = '#';
+ *p++ = tohex ((csum >> 4) & 0xf);
+ *p++ = tohex (csum & 0xf);
+
+ /* Send it over and over until we get a positive ack. */
+
+ do {
+ write (remote_desc, buf2, p - buf2);
+ read (remote_desc, buf3, 1);
+ } while (buf3[0] != '+');
+}
+
+static int
+readchar ()
+{
+ char buf[1];
+ while (read (remote_desc, buf, 1) != 1) ;
+ return buf[0] & 0x7f;
+}
+
+/* Read a packet from the remote machine, with error checking,
+ and store it in BUF. */
+
+static void
+getpkt (buf)
+ char *buf;
+{
+ char *bp;
+ char csum = 0;
+ int c, c1, c2;
+ extern kiodebug;
+
+ while (1)
+ {
+ while ((c = readchar()) != '$');
+
+ bp = buf;
+ while (1)
+ {
+ c = readchar ();
+ if (c == '#')
+ break;
+ *bp++ = c;
+ csum += c;
+ }
+ *bp = 0;
+
+ c1 = fromhex (readchar ());
+ c2 = fromhex (readchar ());
+ if (csum == (c1 << 4) + c2)
+ break;
+ printf ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
+ (c1 << 4) + c2, csum, buf);
+ write (remote_desc, "-", 1);
+ }
+
+ write (remote_desc, "+", 1);
+
+ if (kiodebug)
+ fprintf (stderr,"Packet received :%s\n", buf);
+}
+\f
+/* The data cache records all the data read from the remote machine
+ since the last time it stopped.
+
+ Each cache block holds 16 bytes of data
+ starting at a multiple-of-16 address. */
+
+#define DCACHE_SIZE 64 /* Number of cache blocks */
+
+struct dcache_block {
+ struct dcache_block *next, *last;
+ unsigned int addr; /* Address for which data is recorded. */
+ int data[4];
+};
+
+struct dcache_block dcache_free, dcache_valid;
+
+/* Free all the data cache blocks, thus discarding all cached data. */
+
+static void
+dcache_flush ()
+{
+ register struct dcache_block *db;
+
+ while ((db = dcache_valid.next) != &dcache_valid)
+ {
+ remque (db);
+ insque (db, &dcache_free);
+ }
+}
+
+/*
+ * If addr is present in the dcache, return the address of the block
+ * containing it.
+ */
+
+struct dcache_block *
+dcache_hit (addr)
+{
+ register struct dcache_block *db;
+
+ if (addr & 3)
+ abort ();
+
+ /* Search all cache blocks for one that is at this address. */
+ db = dcache_valid.next;
+ while (db != &dcache_valid)
+ {
+ if ((addr & 0xfffffff0) == db->addr)
+ return db;
+ db = db->next;
+ }
+ return NULL;
+}
+
+/* Return the int data at address ADDR in dcache block DC. */
+
+int
+dcache_value (db, addr)
+ struct dcache_block *db;
+ unsigned int addr;
+{
+ if (addr & 3)
+ abort ();
+ return (db->data[(addr>>2)&3]);
+}
+
+/* Get a free cache block, put it on the valid list,
+ and return its address. The caller should store into the block
+ the address and data that it describes. */
+
+struct dcache_block *
+dcache_alloc ()
+{
+ register struct dcache_block *db;
+
+ if ((db = dcache_free.next) == &dcache_free)
+ /* If we can't get one from the free list, take last valid */
+ db = dcache_valid.last;
+
+ remque (db);
+ insque (db, &dcache_valid);
+ return (db);
+}
+
+/* Return the contents of the word at address ADDR in the remote machine,
+ using the data cache. */
+
+int
+dcache_fetch (addr)
+ CORE_ADDR addr;
+{
+ register struct dcache_block *db;
+
+ db = dcache_hit (addr);
+ if (db == 0)
+ {
+ db = dcache_alloc ();
+ remote_read_bytes (addr & ~0xf, db->data, 16);
+ db->addr = addr & ~0xf;
+ }
+ return (dcache_value (db, addr));
+}
+
+/* Write the word at ADDR both in the data cache and in the remote machine. */
+
+dcache_poke (addr, data)
+ CORE_ADDR addr;
+ int data;
+{
+ register struct dcache_block *db;
+
+ /* First make sure the word is IN the cache. DB is its cache block. */
+ db = dcache_hit (addr);
+ if (db == 0)
+ {
+ db = dcache_alloc ();
+ remote_read_bytes (addr & ~0xf, db->data, 16);
+ db->addr = addr & ~0xf;
+ }
+
+ /* Modify the word in the cache. */
+ db->data[(addr>>2)&3] = data;
+
+ /* Send the changed word. */
+ remote_write_bytes (addr, &data, 4);
+}
+
+/* Initialize the data cache. */
+
+dcache_init ()
+{
+ register i;
+ register struct dcache_block *db;
+
+ db = (struct dcache_block *) xmalloc (sizeof (struct dcache_block) *
+ DCACHE_SIZE);
+ dcache_free.next = dcache_free.last = &dcache_free;
+ dcache_valid.next = dcache_valid.last = &dcache_valid;
+ for (i=0;i<DCACHE_SIZE;i++,db++)
+ insque (db, &dcache_free);
+}
+
+static initialize ()
+{
+}
+
+END_FILE
+++ /dev/null
-Date: Tue, 6 Oct 87 08:52:07 PDT
-To: bug-gnu-emacs@prep.ai.mit.edu
-From: Lynn Slater <silvlis!wobegon!lrs@sun.com>
-Sender: silvlis!wobegon!lrs@sun.com
-Organization: Silvar-Lisco, 1080 Marsh Road, Menlo Park, CA 94025-1053
-Phone.......: (415) 853-6336 (Office); (415) 796-4149 (Home)
-Subject: GDB sing-along
-
-
-Somebody asked us what was GDB. With apologies to Oscar Hemmerstein
-II, Richard Rodgers, and Julie Andrews, we offered the following reply:
-
-Let's start at the very beginning, a very good place to start,
- When you're learning to sing, its Do, Re, Mi;
- When you're learning to code, its G, D, B.
- (background) G, D, B.
- The first three letters just happen to be, G, D, B.
- (background) G, D, B.
-
-(Chorus)
- G!, GNU!, it's Stallman's hope,
-
- B, a break I set myself.
-
- D, debug that rotten code,
-
- Run, a far, far way to go.
-
- Print, to see what you have done,
-
- Set, a patch that follows print.
-
- Quit, and recompile your code - - -
-
-That will bring it back to G,
- D,
- B,
- <link>
-
-(Resume from the Chorus)
-
-
-:-) Joel Bion, Mark Baushke, and Lynn Slater :-)
-
/* List lines of source files for GDB, the GNU debugger.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
*/
#include <stdio.h>
-#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/file.h>
int current_source_line;
-/* Line for "info line" to work on if no line specified. */
+/* Line number of last line printed. Default for various commands.
+ current_source_line is usually, but not always, the same as this. */
-static int line_info_default_line;
+static int last_line_listed;
/* First line number listed by last listing command. */
{
if (s)
{
+ struct symtabs_and_lines sals;
struct symtab_and_line sal;
/* Make the default place to list be the function `main'
if one exists. */
if (lookup_symbol ("main", 0, VAR_NAMESPACE))
{
- sal = decode_line_spec ("main", 1);
+ sals = decode_line_spec ("main", 1);
+ sal = sals.sals[0];
+ free (sals.sals);
current_source_symtab = sal.symtab;
current_source_line = sal.line - 9;
return;
*filename_opened = savestring (filename, strlen (filename));
else
{
- char dirname[MAXPATHLEN];
- if (getwd (dirname) == NULL)
- perror_with_name ("getwd");
- *filename_opened = concat (dirname, "/", filename);
+ *filename_opened = concat (current_directory, "/", filename);
}
return fd;
{
register int desc, linenums_changed = 0;
- desc = openp (source_path, 0, s->filename, O_RDONLY, 0, fullname);
+ desc = openp (source_path, 0, s->filename, O_RDONLY, 0, &s->fullname);
if (desc < 0)
{
- *fullname = NULL;
+ if (fullname)
+ *fullname = NULL;
return 0;
}
+ if (fullname)
+ *fullname = s->fullname;
if (s->line_charpos == 0) linenums_changed = 1;
if (linenums_changed) find_source_lines (s, desc);
close (desc);
return linenums_changed;
}
+
+/* Print text describing the full name of the source file S
+ and the line number LINE and its corresponding character position.
+ The text starts with two Ctrl-z so that the Emacs-GDB interface
+ can easily find it.
+
+ Return 1 if successful, 0 if could not find the file. */
+
+int
+identify_source_line (s, line)
+ struct symtab *s;
+ int line;
+{
+ if (s->line_charpos == 0)
+ get_filename_and_charpos (s, line, 0);
+ if (s->fullname == 0)
+ return 0;
+ printf ("\032\032%s:%d:%d\n", s->fullname, line, s->line_charpos[line - 1]);
+ return 1;
+}
\f
/* Print source lines from the file of symtab S,
starting with line number LINE and stopping before line number STOPLINE. */
register FILE *stream;
int nlines = stopline - line;
- desc = openp (source_path, 0, s->filename, O_RDONLY, 0, (char **) 0);
+ desc = openp (source_path, 0, s->filename, O_RDONLY, 0, &s->fullname);
if (desc < 0)
perror_with_name (s->filename);
{
c = fgetc (stream);
if (c == EOF) break;
- line_info_default_line = current_source_line;
+ last_line_listed = current_source_line;
printf ("%d\t", current_source_line++);
do
{
char *arg;
int from_tty;
{
+ struct symtabs_and_lines sals, sals_end;
struct symtab_and_line sal, sal_end;
struct symbol *sym;
char *arg1;
if (*arg1 == ',')
dummy_beg = 1;
else
- sal = decode_line_1 (&arg1, 0, 0, 0);
+ {
+ sals = decode_line_1 (&arg1, 0, 0, 0);
+
+ if (! sals.nelts) return; /* C++ */
+ if (sals.nelts != 1)
+ {
+ error ("Unreasonable listing request");
+ }
+
+ sal = sals.sals[0];
+ free (sals.sals);
+ }
/* Record whether the BEG arg is all digits. */
arg1++;
if (*arg1 == 0)
dummy_end = 1;
- else if (dummy_beg)
- sal_end = decode_line_1 (&arg1, 0, 0, 0);
else
- sal_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line);
+ {
+ if (dummy_beg)
+ sals_end = decode_line_1 (&arg1, 0, 0, 0);
+ else
+ sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line);
+ if (! sals_end.nelts) return; /* C++ */
+ sal_end = sals_end.sals[0];
+ free (sals_end.sals);
+ }
}
if (*arg1)
char *arg;
int from_tty;
{
+ struct symtabs_and_lines sals;
struct symtab_and_line sal;
int start_pc, end_pc;
if (arg == 0)
{
sal.symtab = current_source_symtab;
- sal.line = line_info_default_line;
+ sal.line = last_line_listed;
}
else
{
- sal = decode_line_spec (arg);
-
+ sals = decode_line_spec (arg);
+
+ if (sals.nelts == 0)
+ return; /* C++ */
+ if (sals.nelts != 1)
+ error ("unreasonable line info request");
+
+ sal = sals.sals[0];
+ free (sals.sals);
/* If this command is repeated with RET,
turn it into the no-arg variant. */
/* x/i should display this line's code. */
set_next_address (start_pc);
/* Repeating "info line" should do the following line. */
- line_info_default_line = sal.line + 1;
+ last_line_listed = sal.line + 1;
}
else
printf ("Line number %d is out of range for \"%s\".\n",
sal.line, sal.symtab->filename);
}
\f
+/* Commands to search the source file for a regexp. */
+
+static void
+forward_search_command (regex, from_tty)
+ char *regex;
+{
+ register int c;
+ register int desc;
+ register FILE *stream;
+ int line = last_line_listed + 1;
+ char *msg;
+
+ msg = (char *) re_comp (regex);
+ if (msg)
+ error (msg);
+
+ if (current_source_symtab == 0)
+ error ("No default source file yet. Do \"help list\".");
+
+ /* Search from last_line_listed+1 in current_source_symtab */
+
+ desc = openp (source_path, 0, current_source_symtab->filename,
+ O_RDONLY, 0, ¤t_source_symtab->fullname);
+ if (desc < 0)
+ perror_with_name (current_source_symtab->filename);
+
+ if (current_source_symtab->line_charpos == 0)
+ find_source_lines (current_source_symtab, desc);
+
+ if (line < 1 || line >= current_source_symtab->nlines)
+ {
+ close (desc);
+ error ("Expression not found");
+ }
+
+ if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0)
+ {
+ close (desc);
+ perror_with_name (current_source_symtab->filename);
+ }
+
+ stream = fdopen (desc, "r");
+ clearerr (stream);
+ while (1) {
+ char buf[4096]; /* Should be reasonable??? */
+ register char *p = buf;
+
+ c = fgetc (stream);
+ if (c == EOF)
+ break;
+ do {
+ *p++ = c;
+ } while (c != '\n' && (c = fgetc (stream)) >= 0);
+
+ /* we now have a source line in buf, null terminate and match */
+ *p = 0;
+ if (re_exec (buf) > 0)
+ {
+ /* Match! */
+ fclose (stream);
+ print_source_lines (current_source_symtab,
+ line, line+1);
+ current_source_line = max (line - 5, 1);
+ return;
+ }
+ line++;
+ }
+
+ printf ("Expression not found\n");
+ fclose (stream);
+}
+
+static void
+reverse_search_command (regex, from_tty)
+ char *regex;
+{
+ register int c;
+ register int desc;
+ register FILE *stream;
+ int line = last_line_listed - 1;
+ char *msg;
+
+ msg = (char *) re_comp (regex);
+ if (msg)
+ error (msg);
+
+ if (current_source_symtab == 0)
+ error ("No default source file yet. Do \"help list\".");
+
+ /* Search from last_line_listed-1 in current_source_symtab */
+
+ desc = openp (source_path, 0, current_source_symtab->filename,
+ O_RDONLY, 0, ¤t_source_symtab->fullname);
+ if (desc < 0)
+ perror_with_name (current_source_symtab->filename);
+
+ if (current_source_symtab->line_charpos == 0)
+ find_source_lines (current_source_symtab, desc);
+
+ if (line < 1 || line >= current_source_symtab->nlines)
+ {
+ close (desc);
+ error ("Expression not found");
+ }
+
+ if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0)
+ {
+ close (desc);
+ perror_with_name (current_source_symtab->filename);
+ }
+
+ stream = fdopen (desc, "r");
+ clearerr (stream);
+ while (1)
+ {
+ char buf[4096]; /* Should be reasonable??? */
+ register char *p = buf;
+
+ c = fgetc (stream);
+ if (c == EOF)
+ break;
+ do {
+ *p++ = c;
+ } while (c != '\n' && (c = fgetc (stream)) >= 0);
+
+ /* We now have a source line in buf; null terminate and match. */
+ *p = 0;
+ if (re_exec (buf) > 0)
+ {
+ /* Match! */
+ fclose (stream);
+ print_source_lines (current_source_symtab,
+ line, line+1);
+ current_source_line = max (line - 5, 1);
+ return;
+ }
+ line--;
+ if (fseek (stream, current_source_symtab->line_charpos[line - 1], 0) < 0)
+ {
+ fclose (stream);
+ perror_with_name (current_source_symtab->filename);
+ }
+ }
+
+ printf ("Expression not found\n");
+ fclose (stream);
+ return;
+}
+\f
static
initialize ()
{
so that \"x/i\" suffices to start examining the machine code.\n\
The address is also stored as the value of \"$_\".");
+ add_com ("forward-search", class_files, forward_search_command,
+ "Search for regular expression (see regex(3)) from last line listed.");
+ add_com_alias ("search", "forward-search", class_files, 0);
+
+ add_com ("reverse-search", class_files, reverse_search_command,
+ "Search backward for regular expression (see regex(3)) from last line listed.");
+
add_com ("list", class_files, list_command,
"List specified function or line.\n\
With no argument, lists ten more lines after or around previous listing.\n\
int selected_frame_level;
+/* Nonzero means print the full filename and linenumber
+ when a frame is printed, and do so in a format programs can parse. */
+
+int frame_file_full_name = 0;
+
static void select_calling_frame ();
void print_frame_info ();
if (source != 0 && sal.symtab)
{
+ int done = 0;
if (source < 0 && fi->pc != sal.pc)
printf ("0x%x\t", fi->pc);
- print_source_lines (sal.symtab, sal.line, sal.line + 1);
+ if (frame_file_full_name)
+ done = identify_source_line (sal.symtab, sal.line);
+ if (!done)
+ print_source_lines (sal.symtab, sal.line, sal.line + 1);
current_source_line = max (sal.line - 5, 1);
}
if (source != 0)
Therefore, do nothing. */
break;
- case free_explicit:
- /* All the contents are part of a big block of memory
- and that is our `free_ptr' and will be freed below. */
- break;
-
case free_contents:
/* Here all the contents were malloc'ed structure by structure
and must be freed that way. */
free (bv);
/* Free the type vector. */
tv = TYPEVECTOR (s);
- if (tv) /* FIXME, should this happen? It does... */
- free (tv);
+ free (tv);
/* Also free the linetable. */
case free_linetable:
static void relocate_type ();
static void relocate_block ();
static void relocate_symbol ();
+static void relocate_source ();
-/* Relocate a file symbol table so that all the pointers
- are valid C pointers. Pass the struct symtab for the file
- and the amount to relocate by. */
+/* Relocate a file's symseg so that all the pointers are valid C pointers.
+ Value is a `struct symtab'; but it is not suitable for direct
+ insertion into the `symtab_list' because it describes several files. */
static struct symtab *
relocate_symtab (root)
sp->version = root->version;
sp->blockvector = root->blockvector;
sp->typevector = root->typevector;
- sp->free_code = free_explicit;
- sp->free_ptr = (char *) root;
RELOCATE (TYPEVECTOR (sp));
RELOCATE (BLOCKVECTOR (sp));
}
static void
-relocate_typevector (tv)
- struct typevector *tv;
-{
- register int ntypes = TYPEVECTOR_NTYPES (tv);
- register int i;
-
- for (i = 0; i < ntypes; i++)
- RELOCATE (TYPEVECTOR_TYPE (tv, i));
- for (i = 0; i < ntypes; i++)
- relocate_type (TYPEVECTOR_TYPE (tv, i));
-}
-
-static void
relocate_blockvector (blp)
register struct blockvector *blp;
{
RELOCATE (SYMBOL_TYPE (sp));
}
+static void
+relocate_typevector (tv)
+ struct typevector *tv;
+{
+ register int ntypes = TYPEVECTOR_NTYPES (tv);
+ register int i;
+
+ for (i = 0; i < ntypes; i++)
+ RELOCATE (TYPEVECTOR_TYPE (tv, i));
+ for (i = 0; i < ntypes; i++)
+ relocate_type (TYPEVECTOR_TYPE (tv, i));
+}
+
/* We cannot come up with an a priori spanning tree
for the network of types, since types can be used
for many symbols and also as components of other types.
RELOCATE (TYPE_FIELD_NAME (tp, i));
}
}
+
+static void
+relocate_sourcevector (svp)
+ register struct sourcevector *svp;
+{
+ register int nfiles = svp->length;
+ register int i;
+ for (i = 0; i < nfiles; i++)
+ RELOCATE (svp->source[i]);
+ for (i = 0; i < nfiles; i++)
+ relocate_source (svp->source[i]);
+}
+
+static void
+relocate_source (sp)
+ register struct source *sp;
+{
+ register int nitems = sp->contents.nitems;
+ register int i;
+
+ RELOCATE (sp->name);
+ for (i = 0; i < nitems; i++)
+ if (sp->contents.item[i] > 0)
+ TEXT_RELOCATE (sp->contents.item[i]);
+}
\f
/* Read symsegs from file named NAME open on DESC,
make symtabs from them, and return a chain of them.
- Assumes DESC is prepositioned at the end of the string table,
+ These symtabs are not suitable for direct use in `symtab_list'
+ because each one describes a single object file, perhaps many source files.
+ `symbol_file_command' takes each of these, makes many real symtabs
+ from it, and then frees it.
+
+ We assume DESC is prepositioned at the end of the string table,
just before the symsegs if there are any. */
struct symtab *
{
struct symbol_root root;
register char *data;
- register struct symtab *sp, *chain = 0;
+ register struct symtab *sp, *sp1, *chain = 0;
register int len;
while (1)
len = myread (desc, data + sizeof root,
root.length - sizeof root);
sp = relocate_symtab (data);
+ RELOCATE (((struct symbol_root *)data)->sourcevector);
+ relocate_sourcevector (((struct symbol_root *)data)->sourcevector);
sp->next = chain;
chain = sp;
+ sp->linetable = (struct linetable *) ((struct symbol_root *)data)->sourcevector;
}
return chain;
/* GDB symbol table format definitions.
Copyright (C) 1986 Free Software Foundation, Inc.
+ Hacked by Michael Tiemann (tiemann@mcc.com)
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
int textrel; /* Relocation for text addresses */
int datarel; /* Relocation for data addresses */
int bssrel; /* Relocation for bss addresses */
- char *filename; /* Name of source file compiled */
+ char *filename; /* Name of main source file compiled */
char *filedir; /* Name of directory it was reached from */
- struct blockvector *blockvector; /* Vector of all symbol naming blocks */
+ struct blockvector *blockvector; /* Vector of all symbol-naming blocks */
struct typevector *typevector; /* Vector of all data types */
enum language language; /* Code identifying the language used */
char *version; /* Version info. Not fully specified */
char *compilation; /* Compilation info. Not fully specified */
int databeg; /* Address within the file of data start */
int bssbeg; /* Address within the file of bss start */
+ struct sourcevector *sourcevector; /* Vector of line-number info */
};
\f
/* All data types of symbols in the compiled program
struct typevector
{
- int length;
+ int length; /* Number of types described */
struct type *type[1];
};
TYPE_CODE_SET, /* Pascal sets */
TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */
TYPE_CODE_PASCAL_ARRAY, /* Array with explicit type of index */
+
+ /* C++ */
+ TYPE_CODE_MPTR, /* Member pointer type */
+ TYPE_CODE_REF, /* C++ Reference types */
};
/* This appears in a type's flags word for an unsigned integer type. */
The debugger may add the address of such a type
if it has to construct one later. */
struct type *pointer_type;
+ /* C++: also need a reference type. */
+ struct type *reference_type;
/* Type that is a function returning this type.
Zero if no such function type is known here.
The debugger may add the address of such a type
if it has to construct one later. */
struct type *function_type;
+
+/* Handling of pointers to members:
+ TYPE_MAIN_VARIANT is used for pointer and pointer
+ to member types. Normally it the value of the address of its
+ containing type. However, for pointers to members, we must be
+ able to allocate pointer to member types and look them up
+ from some place of reference. */
+ struct type *main_variant;
+
/* Flags about this type. */
short flags;
/* Number of fields described for this type */
Zero for range bounds and array domains. */
char *name;
} *fields;
+
+ /* C++ */
+ int *private_field_bits;
+ int *protected_field_bits;
+
+ /* Some flags to make life easier. */
+ unsigned char has_constructor;
+ unsigned char has_destructor;
+
+ /* Number of methods described for this type */
+ short nfn_fields;
+
+ /* Number of methods described for this type plus all the
+ methods that it derives from. */
+ int nfn_fields_total;
+
+ /* For classes, structures, and unions, a description of each field,
+ which consists of an overloaded name, followed by the types of
+ arguments that the method expects, and then the name after it
+ has been renamed to make it distinct. */
+ struct fn_fieldlist
+ {
+ /* The overloaded name. */
+ char *name;
+ /* The number of methods with this name. */
+ int length;
+ /* The list of methods. */
+ struct fn_field
+ {
+#if 0
+ /* The overloaded name */
+ char *name;
+#endif
+ /* The type of the argument */
+ struct type *type;
+ /* The argument list */
+ struct type **args;
+ /* The name after it has been processed */
+ char *physname;
+ /* If this is a virtual function, the offset into the vtbl-1,
+ else 0. */
+ int voffset;
+ } *fn_fields;
+
+ int *private_fn_field_bits;
+ int *protected_fn_field_bits;
+
+ } *fn_fieldlists;
+
+ unsigned char via_protected;
+ unsigned char via_public;
+
+ /* For types with virtual functions, VPTR_BASETYPE is the base class which
+ defined the virtual function table pointer. VPTR_FIELDNO is
+ the field number of that pointer in the structure.
+
+ For types that are pointer to member types, VPTR_BASETYPE
+ ifs the type that this pointer is a member of.
+
+ Unused otherwise. */
+ struct type *vptr_basetype;
+
+ int vptr_fieldno;
+
+ /* If this type has a base class, put it here.
+ If this type is a pointer type, the chain of member pointer
+ types goes here.
+ Unused otherwise. */
+ struct type *baseclass;
};
\f
/* All of the name-scope contours of the program
}
value;
};
+\f
+/* Source-file information.
+ This describes the relation between source files and line numbers
+ and addresses in the program text. */
+
+struct sourcevector
+{
+ int length; /* Number of source files described */
+ struct source *source[1]; /* Descriptions of the files */
+};
+
+/* Each item is either minus a line number, or a program counter.
+ If it represents a line number, that is the line described by the next
+ program counter value. If it is positive, it is the program
+ counter at which the code for the next line starts.
+
+ Consecutive lines can be recorded by program counter entries
+ with no line number entries between them. Line number entries
+ are used when there are lines to skip with no code on them.
+ This is to make the table shorter. */
+
+struct linetable
+ {
+ int nitems;
+ int item[1];
+ };
+
+/* All the information on one source file. */
+
+struct source
+{
+ char *name; /* Name of file */
+ struct linetable contents;
+};
/* Symbol table lookup for the GNU debugger, GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
#include <stdio.h>
#include <obstack.h>
-#ifdef mac_aux
-#define REGCMP
-#endif
-
START_FILE
/* Allocate an obstack to hold objects that should be freed
if (sym == 0)
error ("No struct type named %s.", name);
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
- error ("This context has union or enum %s, not a struct.", name);
+ error ("This context has class, union or enum %s, not a struct.", name);
return SYMBOL_TYPE (sym);
}
if (sym == 0)
error ("No union type named %s.", name);
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
- error ("This context has struct or enum %s, not a union.", name);
+ error ("This context has class, struct or enum %s, not a union.", name);
return SYMBOL_TYPE (sym);
}
if (sym == 0)
error ("No enum type named %s.", name);
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
- error ("This context has struct or union %s, not an enum.", name);
+ error ("This context has class, struct or union %s, not an enum.", name);
return SYMBOL_TYPE (sym);
}
/* Given a type TYPE, return a type of pointers to that type.
- May need to construct such a type if this is the first use. */
+ May need to construct such a type if this is the first use.
+
+ C++: use TYPE_MAIN_VARIANT and TYPE_CHAIN to keep pointer
+ to member types under control. */
struct type *
lookup_pointer_type (type)
struct type *type;
{
register struct type *ptype = TYPE_POINTER_TYPE (type);
- if (ptype) return ptype;
+ if (ptype) return TYPE_MAIN_VARIANT (ptype);
/* This is the first time anyone wanted a pointer to a TYPE. */
if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
sizeof (struct type));
bzero (ptype, sizeof (struct type));
+ TYPE_MAIN_VARIANT (ptype) = ptype;
TYPE_TARGET_TYPE (ptype) = type;
TYPE_POINTER_TYPE (type) = ptype;
/* New type is permanent if type pointed to is permanent. */
return ptype;
}
+struct type *
+lookup_reference_type (type)
+ struct type *type;
+{
+ register struct type *rtype = TYPE_REFERENCE_TYPE (type);
+ if (rtype) return TYPE_MAIN_VARIANT (rtype);
+
+ /* This is the first time anyone wanted a pointer to a TYPE. */
+ if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+ rtype = (struct type *) xmalloc (sizeof (struct type));
+ else
+ rtype = (struct type *) obstack_alloc (symbol_obstack,
+ sizeof (struct type));
+
+ bzero (rtype, sizeof (struct type));
+ TYPE_MAIN_VARIANT (rtype) = rtype;
+ TYPE_TARGET_TYPE (rtype) = type;
+ TYPE_REFERENCE_TYPE (type) = rtype;
+ /* New type is permanent if type pointed to is permanent. */
+ if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+ TYPE_FLAGS (rtype) |= TYPE_FLAG_PERM;
+ /* We assume the machine has only one representation for pointers! */
+ TYPE_LENGTH (rtype) = sizeof (char *);
+ TYPE_CODE (rtype) = TYPE_CODE_REF;
+ return rtype;
+}
+
+
+/* Given a type TYPE, return a type of pointers to that type.
+ May need to construct such a type if this is the first use.
+ The TYPE is the type of the member. The DOMAIN is the type
+ of the aggregate that the member belongs to. */
+
+struct type *
+lookup_member_pointer_type (type, domain)
+ struct type *type, *domain;
+{
+ register struct type *ptype = TYPE_POINTER_TYPE (type);
+ struct type *main_type;
+
+ if (ptype)
+ {
+ ptype = TYPE_MAIN_VARIANT (ptype);
+ main_type = ptype;
+ while (ptype)
+ {
+ if (TYPE_DOMAIN_TYPE (ptype) == domain)
+ return ptype;
+ ptype = TYPE_CHAIN (ptype);
+ }
+ }
+ else
+ {
+ main_type = lookup_pointer_type (type);
+ TYPE_POINTER_TYPE (type) = main_type;
+ }
+
+ /* This is the first time anyone wanted a pointer to a TYPE. */
+ if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+ ptype = (struct type *) xmalloc (sizeof (struct type));
+ else
+ ptype = (struct type *) obstack_alloc (symbol_obstack,
+ sizeof (struct type));
+
+ bzero (ptype, sizeof (struct type));
+ TYPE_MAIN_VARIANT (ptype) = main_type;
+ TYPE_TARGET_TYPE (ptype) = type;
+ TYPE_DOMAIN_TYPE (ptype) = domain;
+ TYPE_POINTER_TYPE (type) = ptype;
+ /* New type is permanent if type pointed to is permanent. */
+ if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+ TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
+ /* We assume the machine has only one representation for pointers! */
+ TYPE_LENGTH (ptype) = sizeof (char *);
+ TYPE_CODE (ptype) = TYPE_CODE_MPTR;
+
+ /* Now splice in the new member pointer type. */
+ if (main_type)
+ {
+ /* This type was not "smashed". */
+ TYPE_CHAIN (ptype) = TYPE_CHAIN (main_type);
+ TYPE_CHAIN (main_type) = ptype;
+ }
+
+ return ptype;
+}
+
/* Given a type TYPE, return a type of functions that return that type.
May need to construct such a type if this is the first use. */
struct type *
-lookup_function_type (type)
+lookup_function_type (type, argtypes)
struct type *type;
+ struct type **argtypes;
{
register struct type *ptype = TYPE_FUNCTION_TYPE (type);
if (ptype) return ptype;
TYPE_LENGTH (type) = sizeof (char *);
TYPE_CODE (type) = TYPE_CODE_PTR;
+ TYPE_MAIN_VARIANT (type) = type;
+
if (TYPE_POINTER_TYPE (to_type) == 0
&& !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
{
}
}
+/* Smash TYPE to be a type of pointers to TO_TYPE.
+ If TO_TYPE is not permanent and has no pointer-type yet,
+ record TYPE as its pointer-type.
+
+ TYPE is the type of the member. DOMAIN is the type of
+ the aggregate that the member belongs to. */
+
+void
+smash_to_member_pointer_type (type, domain, to_type)
+ struct type *type, *domain, *to_type;
+{
+ bzero (type, sizeof (struct type));
+ TYPE_TARGET_TYPE (type) = to_type;
+ TYPE_DOMAIN_TYPE (type) = domain;
+ /* We assume the machine has only one representation for pointers! */
+ TYPE_LENGTH (type) = sizeof (char *);
+ TYPE_CODE (type) = TYPE_CODE_MPTR;
+
+ TYPE_MAIN_VARIANT (type) = lookup_pointer_type (to_type);
+
+ if (TYPE_POINTER_TYPE (to_type) == 0
+ && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
+ {
+ TYPE_POINTER_TYPE (to_type) = type;
+ }
+}
+
+/* Smash TYPE to be a type of reference to TO_TYPE.
+ If TO_TYPE is not permanent and has no pointer-type yet,
+ record TYPE as its pointer-type. */
+
+void
+smash_to_reference_type (type, to_type)
+ struct type *type, *to_type;
+{
+ bzero (type, sizeof (struct type));
+ TYPE_TARGET_TYPE (type) = to_type;
+ /* We assume the machine has only one representation for pointers! */
+ TYPE_LENGTH (type) = sizeof (char *);
+ TYPE_CODE (type) = TYPE_CODE_REF;
+
+ TYPE_MAIN_VARIANT (type) = type;
+
+ if (TYPE_REFERENCE_TYPE (to_type) == 0
+ && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
+ {
+ TYPE_REFERENCE_TYPE (to_type) = type;
+ }
+}
+
/* Smash TYPE to be a type of functions returning TO_TYPE.
If TO_TYPE is not permanent and has no function-type yet,
record TYPE as its function-type. */
Returns the struct symbol pointer, or zero if no symbol is found. */
struct symbol *
+lookup_symbol_1 (name, block, namespace)
+ char *name;
+ register struct block *block;
+ enum namespace namespace;
+{
+ register int i, n;
+ register struct symbol *sym;
+ register struct symtab *s;
+ struct blockvector *bv;
+
+ /* Search specified block and its superiors. */
+
+ while (block != 0)
+ {
+ sym = lookup_block_symbol (block, name, namespace);
+ if (sym) return sym;
+ block = BLOCK_SUPERBLOCK (block);
+ }
+ return 0;
+}
+
+struct symbol *
+lookup_symbol_2 (name, block, namespace)
+ char *name;
+ register struct block *block; /* ignored as parameter */
+ enum namespace namespace;
+{
+ register int i, n;
+ register struct symbol *sym;
+ register struct symtab *s;
+ struct blockvector *bv;
+
+ /* Now search all symtabs' global blocks. */
+
+ for (s = symtab_list; s; s = s->next)
+ {
+ bv = BLOCKVECTOR (s);
+ block = BLOCKVECTOR_BLOCK (bv, 0);
+ sym = lookup_block_symbol (block, name, namespace);
+ if (sym) return sym;
+ }
+
+ /* Now search all symtabs' per-file blocks.
+ Not strictly correct, but more useful than an error. */
+
+ for (s = symtab_list; s; s = s->next)
+ {
+ bv = BLOCKVECTOR (s);
+ block = BLOCKVECTOR_BLOCK (bv, 1);
+ sym = lookup_block_symbol (block, name, namespace);
+ if (sym) return sym;
+ }
+ return 0;
+}
+
+struct symbol *
lookup_symbol (name, block, namespace)
char *name;
register struct block *block;
}
return value;
}
+\f
+/* Find the PC value for a given source file and line number.
+ Returns zero for invalid line number.
+ The source file is specified with a struct symtab. */
+
+CORE_ADDR
+find_line_pc (symtab, line)
+ struct symtab *symtab;
+ int line;
+{
+ register struct linetable *l;
+ register int index;
+ int dummy;
+
+ if (symtab == 0)
+ return 0;
+ l = LINETABLE (symtab);
+ index = find_line_common(l, line, &dummy);
+ return index ? l->item[index] : 0;
+}
/* Find the range of pc values in a line.
Store the starting pc of the line into *STARTPTR
CORE_ADDR *startptr, *endptr;
{
register struct linetable *l;
- register int i, line, item;
- int len;
+ register int index;
+ int exact_match; /* did we get an exact linenumber match */
register CORE_ADDR prev_pc;
CORE_ADDR last_pc;
return 0;
l = LINETABLE (symtab);
- len = l->nitems;
- prev_pc = -1;
- for (i = 0; i < len; i++)
+ index = find_line_common (l, thisline, &exact_match);
+ if (index)
{
- item = l->item[i];
- if (item < 0)
- line = - item - 1;
+ *startptr = l->item[index];
+ /* If we have not seen an entry for the specified line,
+ assume that means the specified line has zero bytes. */
+ if (!exact_match || index == l->nitems-1)
+ *endptr = *startptr;
else
- {
- line++;
- /* As soon as we find a line following the specified one
- we know the end pc and can return. */
- if (line > thisline)
- {
- /* If we have not seen an entry for the specified line,
- assume that means the specified line has zero bytes. */
- *startptr = prev_pc == -1 ? item : prev_pc;
- *endptr = item;
- return 1;
- }
- /* If we see an entry for the specified line,
- it gives the beginning. */
- if (line == thisline)
- prev_pc = item;
- last_pc = item;
- }
- }
- if (prev_pc != -1)
- {
- /* If we found the specified line but no later line, it's file's last.
- Its range is from line's pc to file's end pc. */
- *startptr = last_pc;
- *endptr = BLOCK_END (BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), 0));
+ /* Perhaps the following entry is for the following line.
+ It's worth a try. */
+ if (l->item[index+1] > 0)
+ *endptr = l->item[index+1];
+ else
+ *endptr = find_line_pc (symtab, thisline+1);
return 1;
}
return 0;
}
-/* Find the PC value for a given source file and line number.
- Returns zero for invalid line number.
- The source file is specified with a struct symtab. */
+/* Given a line table and a line number, return the index into the line
+ table for the pc of the nearest line whose number is >= the specified one.
+ Return 0 if none is found. The value is never zero is it is an index.
-CORE_ADDR
-find_line_pc (symtab, line)
- struct symtab *symtab;
- int line;
+ Set *EXACT_MATCH nonzero if the value returned is an exact match. */
+
+static int
+find_line_common (l, lineno, exact_match)
+ register struct linetable *l;
+ register int lineno;
+ int *exact_match;
{
- register struct linetable *l;
- register int len;
register int i;
- register int item;
- register int nextline = -1;
+ register int len;
+
+ /* BEST is the smallest linenumber > LINENO so far seen,
+ or 0 if none has been seen so far.
+ BEST_INDEX identifies the item for it. */
- if (line <= 0)
+ int best_index = 0;
+ int best = 0;
+
+ int nextline = -1;
+
+ if (lineno <= 0)
return 0;
- l = LINETABLE (symtab);
len = l->nitems;
for (i = 0; i < len; i++)
{
- item = l->item[i];
+ register int item = l->item[i];
+
if (item < 0)
nextline = - item - 1;
else
{
nextline++;
- if (line <= nextline)
- return item;
+ if (nextline == lineno)
+ {
+ *exact_match = 1;
+ return i;
+ }
+
+ if (nextline > lineno && (best == 0 || nextline < best))
+ {
+ best = lineno;
+ best_index = i;
+ }
}
}
- return 0;
+
+ /* If we got here, we didn't get an exact match. */
+
+ *exact_match = 0;
+ return best_index;
}
int
if no file is validly specified. Callers must check that.
Also, the line number returned may be invalid. */
-struct symtab_and_line
+struct symtabs_and_lines
decode_line_1 (argptr, funfirstline, default_symtab, default_line)
char **argptr;
int funfirstline;
struct symtab *default_symtab;
int default_line;
{
+ struct symtabs_and_lines decode_line_2 ();
+ struct symtabs_and_lines values;
struct symtab_and_line value;
register char *p, *p1;
register struct symtab *s;
register CORE_ADDR pc;
register int i;
char *copy;
-
+ struct symbol *sym_class;
+ char *class_name, *method_name, *phys_name;
+ int method_counter;
+ int i1;
+ struct symbol **sym_arr;
+ struct type *t, *field;
+ char **physnames;
+
/* Defaults have defaults. */
if (default_symtab == 0)
{
(*argptr)++;
pc = parse_and_eval_address_1 (argptr);
- value = find_pc_line (pc, 0);
- value.pc = pc;
- return value;
+ values.sals = (struct symtab_and_line *)malloc (sizeof (struct symtab_and_line));
+ values.nelts = 1;
+ values.sals[0] = find_pc_line (pc, 0);
+ values.sals[0].pc = pc;
+ return values;
}
/* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
if (p[0] == ':')
{
+
+ /* C++ */
+ if (p[1] ==':')
+ {
+ /* Extract the class name. */
+ p1 = p;
+ while (p != *argptr && p[-1] == ' ') --p;
+ copy = (char *) alloca (p - *argptr + 1);
+ bcopy (*argptr, copy, p - *argptr);
+ copy[p - *argptr] = 0;
+
+ /* Discard the class name from the arg. */
+ p = p1 + 2;
+ while (*p == ' ' || *p == '\t') p++;
+ *argptr = p;
+
+ sym_class = lookup_symbol (copy, 0, STRUCT_NAMESPACE);
+
+ if (sym_class &&
+ (TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_STRUCT
+ || TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_UNION))
+ {
+ /* Arg token is not digits => try it as a function name
+ Find the next token (everything up to end or next whitespace). */
+ p = *argptr;
+ while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p !=':') p++;
+ copy = (char *) alloca (p - *argptr + 1);
+ bcopy (*argptr, copy, p - *argptr);
+ copy[p - *argptr] = '\0';
+
+ /* no line number may be specified */
+ while (*p == ' ' || *p == '\t') p++;
+ *argptr = p;
+
+ sym = 0;
+ i1 = 0; /* counter for the symbol array */
+ t = SYMBOL_TYPE (sym_class);
+ sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
+ physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
+
+ if (destructor_name_p (copy, t))
+ {
+ /* destructors are a special case. */
+ struct fn_field *f = TYPE_FN_FIELDLIST1 (t, 0);
+ int len = TYPE_FN_FIELDLIST_LENGTH (t, 0) - 1;
+ phys_name = TYPE_FN_FIELD_PHYSNAME (f, len);
+ physnames[i1] = (char *)alloca (strlen (phys_name) + 1);
+ strcpy (physnames[i1], phys_name);
+ sym_arr[i1] = lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class), VAR_NAMESPACE);
+ if (sym_arr[i1]) i1++;
+ }
+ else while (t)
+ {
+ int constructor_p;
+
+ class_name = TYPE_NAME (t);
+ while (*class_name++ != ' ');
+
+ constructor_p = ! strcmp (class_name, copy);
+
+ sym_class = lookup_symbol (class_name, 0, STRUCT_NAMESPACE);
+ for (method_counter = TYPE_NFN_FIELDS (SYMBOL_TYPE (sym_class)) - 1;
+ method_counter >= 0;
+ --method_counter)
+ {
+ int field_counter;
+ struct fn_field *f =
+ TYPE_FN_FIELDLIST1 (SYMBOL_TYPE (sym_class), method_counter);
+
+ method_name = TYPE_FN_FIELDLIST_NAME (SYMBOL_TYPE (sym_class), method_counter);
+ if (!strcmp (copy, method_name))
+ for (field_counter = TYPE_FN_FIELDLIST_LENGTH (SYMBOL_TYPE (sym_class), method_counter) - (1 + constructor_p);
+ field_counter >= 0;
+ --field_counter)
+ {
+ phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
+ physnames[i1] = (char*) alloca (strlen (phys_name) + 1);
+ strcpy (physnames[i1], phys_name);
+ sym_arr[i1] = lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class), VAR_NAMESPACE);
+ if (sym_arr[i1]) i1++;
+ }
+ }
+ t = TYPE_BASECLASS(t);
+ }
+
+ if (i1 == 1)
+ {
+ sym = sym_arr[0];
+
+ if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ {
+ /* Arg is the name of a function */
+ pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
+ if (funfirstline)
+ SKIP_PROLOGUE (pc);
+ values.sals = (struct symtab_and_line *)malloc (sizeof (struct symtab_and_line));
+ values.nelts = 1;
+ values.sals[0] = find_pc_line (pc, 0);
+ values.sals[0].pc = (values.sals[0].end && values.sals[0].pc != pc) ? values.sals[0].end : pc;
+ }
+ else
+ {
+ values.nelts = 0;
+ }
+ return values;
+ }
+ if (i1 > 0)
+ {
+ return decode_line_2 (argptr, sym_arr, physnames, i1, funfirstline);
+ }
+ else
+ error ("that class does not have any method named %s",copy);
+ }
+ else
+ error("no class, struct, or union named %s", copy );
+ }
+ /* end of C++ */
+
+
/* Extract the file name. */
p1 = p;
while (p != *argptr && p[-1] == ' ') --p;
s = default_symtab;
value.symtab = s;
value.pc = 0;
- return value;
+ values.sals = (struct symtab_and_line *)malloc (sizeof (struct symtab_and_line));
+ values.sals[0] = value;
+ values.nelts = 1;
+ return values;
}
/* Arg token is not digits => try it as a function name
SKIP_PROLOGUE (pc);
value = find_pc_line (pc, 0);
value.pc = (value.end && value.pc != pc) ? value.end : pc;
- return value;
+ values.sals = (struct symtab_and_line *)malloc (sizeof (struct symtab_and_line));
+ values.sals[0] = value;
+ values.nelts = 1;
+ return values;
}
if (sym)
error ("%s is not a function.", copy);
- for (i = 0; i < misc_function_count; i++)
- if (!strcmp (misc_function_vector[i].name, copy))
- {
- value.symtab = 0;
- value.line = 0;
- value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
- if (funfirstline)
- SKIP_PROLOGUE (value.pc);
- return value;
- }
+ if ((i = lookup_misc_func (copy)) < 0)
+ error ("Function %s not defined.", copy);
+ else
+ {
+ value.symtab = 0;
+ value.line = 0;
+ value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
+ if (funfirstline)
+ SKIP_PROLOGUE (value.pc);
+ values.sals = (struct symtab_and_line *)malloc (sizeof (struct symtab_and_line));
+ values.sals[0] = value;
+ values.nelts = 1;
+ return values;
+ }
if (symtab_list == 0)
error ("No symbol table is loaded. Use the \"symbol-file\" command.");
error ("Function %s not defined.", copy);
}
-struct symtab_and_line
+struct symtabs_and_lines
decode_line_spec (string, funfirstline)
char *string;
int funfirstline;
{
- struct symtab_and_line sal;
+ struct symtabs_and_lines sals;
if (string == 0)
error ("Empty line specification.");
- sal = decode_line_1 (&string, funfirstline,
- current_source_symtab, current_source_line);
+ sals = decode_line_1 (&string, funfirstline,
+ current_source_symtab, current_source_line);
if (*string)
error ("Junk at end of line specification: %s", string);
- return sal;
+ return sals;
+}
+
+struct symtabs_and_lines
+decode_line_2 (argptr, sym_arr, physnames, nelts, funfirstline)
+ char **argptr;
+ struct symbol *sym_arr[];
+ char *physnames[];
+ int nelts;
+ int funfirstline;
+{
+ char *getenv();
+ struct symtabs_and_lines values, return_values;
+ register CORE_ADDR pc;
+ char *args, *arg1, *read_line ();
+ int i;
+ char *prompt;
+
+ values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
+ return_values.sals = (struct symtab_and_line *) malloc (nelts * sizeof(struct symtab_and_line));
+
+ i = 0;
+ printf("[0] cancel\n[1] all\n");
+ while (i < nelts)
+ {
+ if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
+ {
+ /* Arg is the name of a function */
+ pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr[i]))
+ + FUNCTION_START_OFFSET;
+ if (funfirstline)
+ SKIP_PROLOGUE (pc);
+ values.sals[i] = find_pc_line (pc, 0);
+ printf("[%d] file:%s; line number:%d\n",
+ (i+2), values.sals[i].symtab->filename, values.sals[i].line);
+ }
+ else printf ("?HERE\n");
+ i++;
+ }
+
+ if ((prompt = getenv ("PS2")) == NULL)
+ {
+ prompt = ">";
+ }
+ printf("%s ",prompt);
+ fflush(stdout);
+
+ args = read_line (0);
+
+ if (args == 0)
+ error_no_arg ("one or more choice numbers");
+
+ i = 0;
+ while (*args)
+ {
+ int num;
+
+ arg1 = args;
+ while (*arg1 >= '0' && *arg1 <= '9') arg1++;
+ if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
+ error ("Arguments must be choice numbers.");
+
+ num = atoi (args);
+
+ if (num == 0)
+ error ("cancelled");
+ else if (num == 1)
+ {
+ bcopy (values.sals, return_values.sals, (nelts * sizeof(struct symtab_and_line)));
+ return_values.nelts = nelts;
+ return return_values;
+ }
+
+ if (num > nelts + 2)
+ {
+ printf ("No choice number %d.\n", num);
+ }
+ else
+ {
+ num -= 2;
+ if (values.sals[num].pc)
+ {
+ return_values.sals[i++] = values.sals[num];
+ values.sals[num].pc = 0;
+ }
+ else
+ {
+ printf ("duplicate request for %d ignored.\n", num);
+ }
+ }
+
+ args = arg1;
+ while (*args == ' ' || *args == '\t') args++;
+ }
+ return_values.nelts = i;
+ return return_values;
+}
+
+/* Return the index of misc function named NAME. */
+
+static
+lookup_misc_func (name)
+ register char *name;
+{
+ register int i;
+
+ for (i = 0; i < misc_function_count; i++)
+ if (!strcmp (misc_function_vector[i].name, name))
+ return i;
+ return -1; /* not found */
}
\f
static void
register struct block *b;
register int i, j;
register struct symbol *sym;
- char *val = 0;
+ char *val;
int found_in_file;
static char *classnames[]
- = {"variable", "function", "type"};
+ = {"variable", "function", "type", "method"};
int print_count = 0;
-#ifdef REGCMP
- extern char *regcmp(), *regex(), *loc1;
-#endif
-
- if (regexp) {
-#ifdef REGCMP
- val = regcmp(regexp, (char *)0);
- if (val == 0)
- error ("Invalid regexp: %s", regexp);
-#else
+
+ if (regexp)
if (val = (char *) re_comp (regexp))
error ("Invalid regexp: %s", val);
-#endif
- }
printf (regexp
? "All %ss matching regular expression \"%s\":\n"
{
QUIT;
sym = BLOCK_SYM (b, j);
- if (regexp) {
-#ifdef REGCMP
- if (!regex(val, SYMBOL_NAME (sym)))
- continue;
-#else
- if (!re_exec (SYMBOL_NAME (sym)))
- continue;
-#endif
- }
- if ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+ if ((regexp == 0 || re_exec (SYMBOL_NAME (sym)))
+ && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
&& SYMBOL_CLASS (sym) != LOC_BLOCK)
|| (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
- || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))
+ || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))
{
if (!found_in_file)
{
&& SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
printf ("typedef ");
- type_print (SYMBOL_TYPE (sym),
- (SYMBOL_CLASS (sym) == LOC_TYPEDEF
- ? "" : SYMBOL_NAME (sym)),
- stdout, 0);
+ if (class < 3)
+ {
+ type_print (SYMBOL_TYPE (sym),
+ (SYMBOL_CLASS (sym) == LOC_TYPEDEF
+ ? "" : SYMBOL_NAME (sym)),
+ stdout, 0);
+ printf (";\n");
+ }
+ else
+ {
+ char buf[1024];
+# if 0
+ type_print_base (TYPE_FN_FIELD_TYPE(t, i), stdout, 0, 0);
+ type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i), stdout, 0);
+ sprintf (buf, " %s::", TYPE_NAME (t));
+ type_print_method_args (TYPE_FN_FIELD_ARGS (t, i), buf, name, stdout);
+# endif
+ }
if (class == 2
&& SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE
&& (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0
|| 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))),
SYMBOL_NAME (sym))))
printf (" %s", SYMBOL_NAME (sym));
- printf (";\n");
}
}
}
prev_bv = bv;
}
-#ifdef REGCMP
- if (val)
- (void)free(val);
-#endif
}
static void
{
list_symbols (regexp, 2);
}
+
+static void
+methods_info (regexp)
+ char *regexp;
+{
+ list_symbols (regexp, 3);
+}
\f
/* Initialize the standard C scalar types. */
type = (struct type *) xmalloc (sizeof (struct type));
bzero (type, sizeof *type);
+ TYPE_MAIN_VARIANT (type) = type;
TYPE_CODE (type) = code;
TYPE_LENGTH (type) = length;
TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0;
TYPE_NFIELDS (type) = 0;
TYPE_NAME (type) = name;
+ /* C++ fancies. */
+ TYPE_NFN_FIELDS (type) = 0;
+ TYPE_BASECLASS (type) = 0;
return type;
}
"All function names, or those matching REGEXP.");
add_info ("types", types_info,
"All types names, or those matching REGEXP.");
+ add_info ("methods", methods_info,
+ "All method names, or those matching REGEXP::REGEXP.\n\
+If the class qualifier is ommited, it is assumed to be the current scope.\n\
+If the first REGEXP is ommited, then all methods matching the second REGEXP\n\
+are listed.");
add_info ("sources", sources_info,
"Source files in the program.");
\f
#include "symseg.h"
-/* Each source file is represented by a struct symtab.
- These objects are chained through the `next' field. */
+/* Each source file is represented by a struct symtab. */
+/* These objects are chained through the `next' field. */
struct symtab
{
char *filename;
/* This component says how to free the data we point to:
free_contents => do a tree walk and free each object.
- free_explicit => free what free_ptr points at, and the linetable.
free_nothing => do nothing; some other symtab will free
the data this one uses.
free_linetable => free just the linetable. */
- enum free_code {free_nothing, free_contents, free_explicit, free_linetable}
+ enum free_code {free_nothing, free_contents, free_linetable}
free_code;
- /* Pointer to one block storage to be freed, if nonzero. */
+ /* Pointer to one block of storage to be freed, if nonzero. */
char *free_ptr;
/* Total number of lines found in source file. */
int nlines;
/* Offset within loader symbol table
of first local symbol for this file. */
int ldsymoff;
+ /* Full name of file as found by searching the source path.
+ 0 if not yet known. */
+ char *fullname;
};
/* This is the list of struct symtab's that gdb considers current. */
#define LINELIST(symtab) (symtab)->linetable
#define LINETABLE(symtab) (symtab)->linetable
\f
-/* Recording the code addresses of source lines. */
-
-struct linetable
- {
- int nitems;
- int item[1];
- };
-
-/* Each item is either minus a line number, or a program counter.
- If it represents a line number, that is the line described by the next
- program counter value. If it is positive, it is the program
- counter at which the code for the next line starts.
-
- Consecutive lines can be recorded by program counter entries
- with no line number entries between them. Line number entries
- are used when there are lines to skip with no code on them.
- This is to make the table shorter. */
-\f
/* Macros normally used to access components of symbol table structures. */
#define BLOCKLIST_NBLOCKS(blocklist) (blocklist)->nblocks
These types are never freed. */
#define TYPE_FLAG_PERM 4
+/* Some macros for bitfields. */
+#define B_SET(a,x) (a[x>>5] |= (1 << (x&31)))
+#define B_CLR(a,x) (a[x>>5] &= ~(1 << (x&31)))
+#define B_TST(a,x) (a[x>>5] & (1 << (x&31)))
+
#define TYPE_NAME(thistype) (thistype)->name
#define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
#define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
+#define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
#define TYPE_FUNCTION_TYPE(thistype) (thistype)->function_type
+#define TYPE_MAIN_VARIANT(thistype) (thistype)->main_variant
#define TYPE_LENGTH(thistype) (thistype)->length
#define TYPE_FLAGS(thistype) (thistype)->flags
#define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
#define TYPE_CODE(thistype) (thistype)->code
#define TYPE_NFIELDS(thistype) (thistype)->nfields
#define TYPE_FIELDS(thistype) (thistype)->fields
+/* C++ */
+#define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
+#define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype
+#define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno
+#define TYPE_FN_FIELDS(thistype) (thistype)->fn_fields
+#define TYPE_NFN_FIELDS(thistype) (thistype)->nfn_fields
+#define TYPE_NFN_FIELDS_TOTAL(thistype) (thistype)->nfn_fields_total
+#define TYPE_BASECLASS(thistype) (thistype)->baseclass
+#define TYPE_VIA_PUBLIC(thistype) (thistype)->via_public
+#define TYPE_VIA_PROTECTED(thistype) (thistype)->via_protected
+#define TYPE_CHAIN(thistype) (thistype)->baseclass
#define TYPE_FIELD(thistype, n) (thistype)->fields[n]
#define TYPE_FIELD_TYPE(thistype, n) (thistype)->fields[n].type
#define TYPE_FIELD_BITPOS(thistype, n) (thistype)->fields[n].bitpos
#define TYPE_FIELD_BITSIZE(thistype, n) (thistype)->fields[n].bitsize
#define TYPE_FIELD_PACKED(thistype, n) (thistype)->fields[n].bitsize
+
+#define TYPE_FIELD_PRIVATE_BITS(thistype) (thistype)->private_field_bits
+#define TYPE_FIELD_PROTECTED_BITS(thistype) (thistype)->protected_field_bits
+#define SET_TYPE_FIELD_PRIVATE(thistype, n) B_SET ((thistype)->private_field_bits, (n))
+#define SET_TYPE_FIELD_PROTECTED(thistype, n) B_SET ((thistype)->protected_field_bits, (n))
+#define TYPE_FIELD_PRIVATE(thistype, n) B_TST((thistype)->private_field_bits, (n))
+#define TYPE_FIELD_PROTECTED(thistype, n) B_TST((thistype)->protected_field_bits, (n))
+
+#define TYPE_HAS_DESTRUCTOR(thistype) ((thistype)->has_destructor)
+#define TYPE_HAS_CONSTRUCTOR(thistype) ((thistype)->has_constructor)
+
+#define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitpos == -1)
+#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) ((char *)(thistype)->fields[n].bitsize)
+
+#define TYPE_FN_FIELDLISTS(thistype) (thistype)->fn_fieldlists
+#define TYPE_FN_FIELDLIST(thistype, n) (thistype)->fn_fieldlists[n]
+#define TYPE_FN_FIELDLIST1(thistype, n) (thistype)->fn_fieldlists[n].fn_fields
+#define TYPE_FN_FIELDLIST_NAME(thistype, n) (thistype)->fn_fieldlists[n].name
+#define TYPE_FN_FIELDLIST_LENGTH(thistype, n) (thistype)->fn_fieldlists[n].length
+
+#define TYPE_FN_FIELD(thistype) (thistype)[n]
+#define TYPE_FN_FIELD_NAME(thistype, n) (thistype)[n].name
+#define TYPE_FN_FIELD_TYPE(thistype, n) (thistype)[n].type
+#define TYPE_FN_FIELD_ARGS(thistype, n) (thistype)[n].args
+#define TYPE_FN_FIELD_PHYSNAME(thistype, n) (thistype)[n].physname
+#define TYPE_FN_FIELD_VIRTUAL_P(thistype, n) (thistype)[n].voffset
+#define TYPE_FN_FIELD_VOFFSET(thistype, n) ((thistype)[n].voffset-1)
+
+#define TYPE_FN_PRIVATE_BITS(thistype) (thistype).private_fn_field_bits
+#define TYPE_FN_PROTECTED_BITS(thistype) (thistype).protected_fn_field_bits
+#define SET_TYPE_FN_PRIVATE(thistype, n) B_SET ((thistype).private_fn_field_bits, n)
+#define SET_TYPE_FN_PROTECTED(thistype, n) B_SET ((thistype).protected_fn_field_bits, n)
+#define TYPE_FN_PRIVATE(thistype, n) B_TST ((thistype).private_fn_field_bits, n)
+#define TYPE_FN_PROTECTED(thistype, n) B_TST ((thistype).protected_fn_field_bits, n)
\f
/* Functions that work on the objects described above */
extern struct symtab *lookup_symtab ();
extern struct symbol *lookup_symbol ();
+extern struct symbol *lookup_symbol_1 (), *lookup_symbol_2 ();
extern struct type *lookup_typename ();
extern struct type *lookup_unsigned_typename ();
extern struct type *lookup_struct ();
extern struct symbol *find_pc_function ();
extern int find_pc_misc_function ();
+/* C++ stuff. */
+extern struct type *lookup_reference_type ();
+extern struct type *lookup_member_pointer_type ();
+extern struct type *lookup_class ();
+/* end of C++ stuff. */
+
extern struct type *builtin_type_void;
extern struct type *builtin_type_char;
extern struct type *builtin_type_short;
CORE_ADDR end;
};
+struct symtabs_and_lines
+{
+ struct symtab_and_line *sals;
+ int nelts;
+};
+
/* Given a pc value, return line number it is in.
Second arg nonzero means if pc is on the boundary
use the previous statement's line number. */
/* Given a string, return the line specified by it.
For commands like "list" and "breakpoint". */
-struct symtab_and_line decode_line_spec ();
-struct symtab_and_line decode_line_1 ();
+struct symtabs_and_lines decode_line_spec ();
+struct symtabs_and_lines decode_line_1 ();
+++ /dev/null
-#include <sys/param.h>
-#include <sys/dir.h>
-#include <sys/user.h>
-#include <stdio.h>
-
-main ()
-{
- struct user u;
- printf ("&u.u_ar0 - &u = %d, 0%o\n", (int) &u.u_ar0 - (int) &u,
- (int) &u.u_ar0 - (int) &u);
- printf ("sizeof (struct pcb) = %d, 0%o\n",
- sizeof (struct pcb), sizeof (struct pcb));
-}
+++ /dev/null
-enum foo {foo1, foo2};
-
-static double statdouble;
-
-newfun (ac)
- struct haha {int a; } ac;
-{
-}
-
-struct temp {int a; };
-
-bar (a)
- enum foo a;
-{
- static int lose;
- double happy;
- typedef int myint;
-
- {
- union wow { int a; char b; } wowvar;
- static union wow wowvar1;
- typedef int yourint;
- char *winner;
- }
-}
+++ /dev/null
-main ()
-{
- int x = 0;
-
- while (1)
- {
- sleep (1);
- x++;
- }
-}
+++ /dev/null
-struct foo
-{
- int a : 5, : 4, b : 5;
- char c;
- int : 3, d : 8, : 0, e : 5;
-};
-
-struct foo x;
-
-main ()
-{
- printf (x);
-}
+++ /dev/null
-/* Source file for showing ENUM lossage in GDB.
- Compile with "cc -o foo -g foo.c". */
-
-enum bar { value1, value2, value3 };
-
-struct foo {
- enum bar enum_value;
- int int_value;
- char *pointer_value;
-};
-
-struct foo foo_instance;
-struct foo *foo_instance_pointer;
-
-main ()
-{
- foo_instance_pointer = &foo_instance;
- foo_instance.enum_value = value2;
- foo_instance.int_value = 1;
- foo_instance.pointer_value = "Text to make a char *";
-
- /* In GDB, set a breakpoint at this line. Then try to change the
- value of foo_instance.enum_value in any way. I can't do it. */
-}
-
+++ /dev/null
-
-main ()
-{
- foo(2);
- foo(3);
-}
-
-foo (i)
-{
- printf ("i is %d, ", i);
- printf ("i*i is %d\n", i * i);
-}
+++ /dev/null
-main ()
-{
- register int ntabs;
- register short x;
- short stops[30];
-
- foo ();
-}
-
-foo ()
-{
- register int ntabs;
- register short x;
-
- printf (x, ntabs);
-}
+++ /dev/null
-# include <signal.h>
-
-main ()
-{
- int handle ();
- int i;
- signal (SIGALRM, handle);
- alarm (5);
- for (i = 0; i < 100000; i++)
- printf ("%d\n", i);
-}
-
-handle ()
-{
- printf ("signal!\n");
- alarm (5);
-}
quit ()
{
fflush (stdout);
-#ifdef TIOCFLUSH
ioctl (fileno (stdout), TIOCFLUSH, 0);
-#endif
error ("Quit");
}
In other words, go ahead and share GDB, but don't try to stop
anyone else from sharing it farther. Help stamp out software hoarding!
*/
-
+#include "stdio.h"
#include "defs.h"
#include "initialize.h"
#include "param.h"
return value_from_long (type, value_as_long (arg2));
else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
{
+ if ((code1 == TYPE_CODE_MPTR) ^ (code2 == TYPE_CODE_MPTR))
+ printf ("warning: assignment between pointer-to-member and non pointer-to-member types\n");
+
VALUE_TYPE (arg2) = type;
return arg2;
}
else if (VALUE_LVAL (arg2) == lval_memory)
- return value_at (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
+ {
+ if ((code1 == TYPE_CODE_MPTR) ^ (code2 == TYPE_CODE_MPTR))
+ printf ("warning: assignment between pointer-to-member and non pointer-to-member types\n");
+
+ return value_at (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
+ }
else
error ("Invalid cast.");
}
{
COERCE_ARRAY (arg1);
+ if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_MPTR)
+ error ("not implemented: member pointers in value_ind");
+
/* Allow * on an integer so we can cast it to whatever we want. */
if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
return value_at (builtin_type_long,
else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
return value_at (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
(CORE_ADDR) value_as_long (arg1));
+ else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF)
+ return value_at (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
+ (CORE_ADDR) value_as_long (arg1));
error ("Attempt to take contents of a non-pointer value.");
}
\f
register struct type *ftype = VALUE_TYPE (function);
register enum type_code code = TYPE_CODE (ftype);
+ if (code == TYPE_CODE_MPTR)
+ error ("not implemented: member pointer to call_function");
+
/* Determine address to call. */
if (code == TYPE_CODE_FUNC)
{
/* Given ARG1, a value of type (pointer to a)* structure/union,
extract the component named NAME from the ultimate target structure/union
and return it as a value with its appropriate type.
- ERR is used in the error message if ARG1's type is wrong. */
+ ERR is used in the error message if ARG1's type is wrong.
+
+ C++: ARGS is a list of argument types to aid in the selection of
+ an appropriate method. Also, handle derived types.
+
+ ERR is an error message to be printed in case the field is not found. */
value
-value_struct_elt (arg1, name, err)
- register value arg1;
+value_struct_elt (arg1, args, name, err)
+ register value arg1, *args;
char *name;
char *err;
{
register struct type *t;
register int i;
+ int found = 0;
+
+ struct type *baseclass;
COERCE_ARRAY (arg1);
/* Follow pointers until we get to a non-pointer. */
- while (TYPE_CODE (t) == TYPE_CODE_PTR)
+ while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
{
arg1 = value_ind (arg1);
COERCE_ARRAY (arg1);
t = VALUE_TYPE (arg1);
}
+ if (TYPE_CODE (t) == TYPE_CODE_MPTR)
+ error ("not implemented: member pointers in value_struct_elt");
+
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- &&
- TYPE_CODE (t) != TYPE_CODE_UNION)
+ && TYPE_CODE (t) != TYPE_CODE_UNION)
error ("Attempt to extract a component of a value that is not a %s.", err);
- for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
+ baseclass = t;
+
+ if (!args)
+ {
+ /* if there are no arguments ...do this... */
+
+ /* Try as a variable first, because if we succeed, there
+ is less work to be done. */
+ while (t)
+ {
+ for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
+ {
+ if (!strcmp (TYPE_FIELD_NAME (t, i), name))
+ {
+ found = 1;
+ break;
+ }
+ }
+
+ if (i >= 0)
+ return TYPE_FIELD_STATIC (t, i)
+ ? value_static_field (t, name, i) : value_field (arg1, i);
+
+ t = TYPE_BASECLASS (t);
+ VALUE_TYPE (arg1) = t; /* side effect! */
+ }
+
+ /* C++: If it was not found as a data field, then try to
+ return it as a pointer to a method. */
+ t = baseclass;
+ VALUE_TYPE (arg1) = t; /* side effect! */
+
+ if (destructor_name_p (name, t))
+ error ("use `info method' command to print out value of destructor");
+
+ while (t)
+ {
+ for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
+ {
+ if (! strcmp (TYPE_FN_FIELDLIST_NAME (t, i), name))
+ {
+ error ("use `info method' command to print value of method \"%s\"", name);
+ }
+ }
+ t = TYPE_BASECLASS (t);
+ }
+
+ if (found == 0)
+ error("there is no field named %s", name);
+ return 0;
+ }
+
+ if (destructor_name_p (name, t))
+ {
+ if (!args[1])
+ {
+ /* destructors are a special case. */
+ return (value)value_fn_field (arg1, 0, TYPE_FN_FIELDLIST_LENGTH (t, 0));
+ }
+ else
+ {
+ error ("destructor should not have any argument");
+ }
+ }
+
+ /* This following loop is for methods with arguments. */
+ while (t)
+ {
+ /* Look up as method first, because that is where we
+ expect to find it first. */
+ for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; i--)
+ {
+ struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
+
+ if (!strcmp (TYPE_FN_FIELDLIST_NAME (t, i), name))
+ {
+ int j;
+ struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
+
+ found = 1;
+ for (j = TYPE_FN_FIELDLIST_LENGTH (t, i) - 1; j >= 0; --j)
+ {
+ if (!typecmp (TYPE_FN_FIELD_ARGS (f, j), args))
+ {
+ if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
+ {
+ /* First, get the virtual function table pointer.
+ That comes with a strange type, so cast
+ it to type `pointer to long' (which
+ should serve just fine as a function type).
+ Then, index into the table, and convert
+ final value to appropriate function type. */
+ value vfn, vtbl;
+ value vi = value_from_long (builtin_type_int,
+ TYPE_FN_FIELD_VOFFSET (f, j));
+ VALUE_TYPE (arg1) = TYPE_VPTR_BASETYPE (t);
+
+ if (TYPE_VPTR_FIELDNO (t) < 0)
+ TYPE_VPTR_FIELDNO (t)
+ = fill_in_vptr_fieldno (t);
+
+ vtbl = value_field (arg1, TYPE_VPTR_FIELDNO (t));
+ vfn = value_subscript (vtbl, vi);
+ VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
+ return vfn;
+ }
+ else
+ return (value)value_fn_field (arg1, i, j);
+ }
+ }
+ }
+ }
+ t = TYPE_BASECLASS (t);
+ VALUE_TYPE (arg1) = t; /* side effect! */
+ }
+
+ if (found)
+ {
+ error ("Structure method %s not defined for arglist.", name);
+ return 0;
+ }
+ else
+ {
+ /* See if user tried to invoke data as function */
+ t = baseclass;
+ while (t)
+ {
+ for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
+ {
+ if (!strcmp (TYPE_FIELD_NAME (t, i), name))
+ {
+ found = 1;
+ break;
+ }
+ }
+
+ if (i >= 0)
+ return TYPE_FIELD_STATIC (t, i)
+ ? value_static_field (t, name, i) : value_field (arg1, i);
+
+ t = TYPE_BASECLASS (t);
+ VALUE_TYPE (arg1) = t; /* side effect! */
+ }
+ error ("Structure has no component named %s.", name);
+ }
+}
+
+/* C++: return 1 is NAME is a legitimate name for the destructor
+ of type TYPE. If TYPE does not have a destructor, or
+ if NAME is inappropriate for TYPE, an error is signaled. */
+int
+destructor_name_p (name, type)
+ char *name;
+ struct type *type;
+{
+ /* destructors are a special case. */
+ char *dname = TYPE_NAME (type);
+
+ if (name[0] == '~')
+ {
+ if (! TYPE_HAS_DESTRUCTOR (type))
+ error ("type `%s' does not have destructor defined",
+ TYPE_NAME (type));
+ /* Skip past the "struct " at the front. */
+ while (*dname++ != ' ') ;
+ if (strcmp (dname, name+1))
+ error ("destructor specification error");
+ else
+ return 1;
+ }
+ return 0;
+}
+
+/* C++: Given ARG1, a value of type (pointer to a)* structure/union,
+ return 1 if the component named NAME from the ultimate
+ target structure/union is defined, otherwise, return 0. */
+
+int
+check_field (arg1, name)
+ register value arg1;
+ char *name;
+{
+ register struct type *t;
+ register int i;
+ int found = 0;
+
+ struct type *baseclass;
+
+ COERCE_ARRAY (arg1);
+
+ t = VALUE_TYPE (arg1);
+
+ /* Follow pointers until we get to a non-pointer. */
+
+ while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
+ {
+ arg1 = value_ind (arg1);
+ COERCE_ARRAY (arg1);
+ t = VALUE_TYPE (arg1);
+ }
+
+ if (TYPE_CODE (t) == TYPE_CODE_MPTR)
+ error ("not implemented: member pointers in check_field");
+
+ if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+ && TYPE_CODE (t) != TYPE_CODE_UNION)
+ error ("Internal error: `this' is not an aggregate");
+
+ baseclass = t;
+
+ while (t)
{
- if (!strcmp (TYPE_FIELD_NAME (t, i), name))
- break;
+ for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
+ {
+ if (!strcmp (TYPE_FIELD_NAME (t, i), name))
+ {
+ return 1;
+ }
+ }
+ t = TYPE_BASECLASS (t);
+ VALUE_TYPE (arg1) = t; /* side effect! */
}
- if (i < 0)
- error ("Structure has no component named %s.", name);
+ /* C++: If it was not found as a data field, then try to
+ return it as a pointer to a method. */
+ t = baseclass;
+ VALUE_TYPE (arg1) = t; /* side effect! */
+
+ /* Destructors are a special case. */
+ if (destructor_name_p (name, t))
+ return 1;
+
+ while (t)
+ {
+ for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
+ {
+ if (!strcmp (TYPE_FN_FIELDLIST_NAME (t, i), name))
+ return 1;
+ }
+ t = TYPE_BASECLASS (t);
+ }
+ return 0;
+}
- return value_field (arg1, i);
+/* C++: Given an aggregate type DOMAIN, and a member name NAME,
+ return the address of this member as a pointer to member
+ type. If INTYPE is non-null, then it will be the type
+ of the member we are looking for. This will help us resolve
+ pointers to member functions. */
+
+value
+value_struct_elt_for_address (domain, intype, name)
+ struct type *domain, *intype;
+ char *name;
+{
+ register struct type *t = domain;
+ register int i;
+ int found = 0;
+ value v;
+
+ struct type *baseclass;
+
+ if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+ && TYPE_CODE (t) != TYPE_CODE_UNION)
+ error ("Internal error: non-aggregate type to value_struct_elt_for_address");
+
+ baseclass = t;
+
+ while (t)
+ {
+ for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
+ {
+ if (!strcmp (TYPE_FIELD_NAME (t, i), name))
+ {
+ if (TYPE_FIELD_PACKED (t, i))
+ error ("pointers to bitfield members not allowed");
+
+ v = value_from_long (builtin_type_int, TYPE_FIELD_BITPOS (t, i) >> 3);
+ VALUE_TYPE (v) = lookup_member_pointer_type (TYPE_FIELD_TYPE (t, i), baseclass);
+ return v;
+ }
+ }
+ t = TYPE_BASECLASS (t);
+ }
+
+ /* C++: If it was not found as a data field, then try to
+ return it as a pointer to a method. */
+ t = baseclass;
+
+ /* Destructors are a special case. */
+ if (destructor_name_p (name, t))
+ {
+ error ("pointers to destructors not implemented yet");
+ }
+
+ while (t)
+ {
+ for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
+ {
+ if (!strcmp (TYPE_FN_FIELDLIST_NAME (t, i), name))
+ {
+ int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
+ struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
+
+ if (intype == 0 && j > 1)
+ error ("non-unique member `%s' requires type instantiation", name);
+ if (intype)
+ {
+ while (j--)
+ if (TYPE_FN_FIELD_TYPE (f, j) == intype)
+ break;
+ if (j < 0)
+ error ("no member function matches that type instantiation");
+ }
+ else
+ j = 0;
+
+ if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
+ {
+ v = value_from_long (builtin_type_long,
+ TYPE_FN_FIELD_VOFFSET (f, j));
+ }
+ else
+ {
+ struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
+ 0, VAR_NAMESPACE);
+ v = locate_var_value (s, 0);
+ }
+ VALUE_TYPE (v) = lookup_member_pointer_type (TYPE_FN_FIELD_TYPE (f, j), baseclass);
+ return v;
+ }
+ }
+ t = TYPE_BASECLASS (t);
+ }
+ return 0;
+}
+
+/* Compare two argument lists and return the position in which they differ,
+ or zero if equal. Note that we ignore the first argument, which is
+ the type of the instance variable. This is because we want to handle
+ derived classes. This is not entirely correct: we should actually
+ check to make sure that a requested operation is type secure,
+ shouldn't we? */
+int typecmp(t1, t2)
+ struct type *t1[];
+ value t2[];
+{
+ int i;
+
+ if (t1[0]->code == TYPE_CODE_VOID) return 0;
+ if (!t1[1])return 0;
+ for (i = 1; t1[i]->code != TYPE_CODE_VOID; i++)
+ {
+ if (! t2[i]
+ || t1[i]->code != t2[i]->type->code
+ || t1[i]->target_type != t2[i]->type->target_type)
+ {
+ return i+1;
+ }
+ }
+ return t2[i] ? i+1 : 0;
+}
+
+#ifndef FRAME
+#include "frame.h"
+#endif
+
+/* C++: return the value of the class instance variable, if one exists.
+ Flag COMPLAIN signals an error if the request is made in an
+ inappropriate context. */
+value
+value_of_this (complain)
+ int complain;
+{
+ extern FRAME selected_frame;
+ struct symbol *func, *sym;
+ char *funname = 0;
+ struct block *b;
+ int i;
+
+ if (selected_frame == 0)
+ if (complain)
+ error ("no frame selected");
+ else return 0;
+
+ func = get_frame_function (selected_frame);
+ if (func)
+ funname = SYMBOL_NAME (func);
+ else
+ if (complain)
+ error ("no `this' in nameless context");
+ else return 0;
+
+ b = SYMBOL_BLOCK_VALUE (func);
+ i = BLOCK_NSYMS (b);
+ if (i <= 0)
+ if (complain)
+ error ("no args, no `this'");
+ else return 0;
+
+ sym = BLOCK_SYM (b, 0);
+ if (strncmp ("$this", SYMBOL_NAME (sym), 5))
+ if (complain)
+ error ("current stack frame not in method");
+ else return 0;
+
+ return read_var_value (sym, selected_frame);
}
\f
static
static void type_print_varspec_suffix ();
static void type_print_varspec_prefix ();
static void type_print_base ();
+static void type_print_method_args ();
START_FILE
}
else
{
- /* A simple (nonrepeated) value */
- /* If it is a pointer, indicate what it points to. */
+ /* If it is a pointer, indicate what it points to.
+
+ C++: if it is a member pointer, we will take care
+ of that when we print it. */
if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR)
{
fprintf (stream, "(");
}
break;
+ case TYPE_CODE_MPTR:
+ {
+ struct type *domain = TYPE_DOMAIN_TYPE (type);
+ struct type *target = TYPE_TARGET_TYPE (type);
+ struct fn_field *f;
+ int j, len2;
+ char *kind = "";
+
+ val = unpack_long (builtin_type_int, valaddr);
+ if (TYPE_CODE (target) == TYPE_CODE_FUNC)
+ {
+ if (val < 128)
+ {
+ len = TYPE_NFN_FIELDS (domain);
+ for (i = 0; i < len; i++)
+ {
+ f = TYPE_FN_FIELDLIST1 (domain, i);
+ len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
+
+ for (j = 0; j < len2; j++)
+ {
+ QUIT;
+ if (TYPE_FN_FIELD_VOFFSET (f, j) == val)
+ {
+ kind = " virtual";
+ goto common;
+ }
+ }
+ }
+ }
+ else
+ {
+ struct symbol *sym = find_pc_function (val);
+ if (sym == 0)
+ error ("invalid pointer to member function");
+ len = TYPE_NFN_FIELDS (domain);
+ for (i = 0; i < len; i++)
+ {
+ f = TYPE_FN_FIELDLIST1 (domain, i);
+ len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
+
+ for (j = 0; j < len2; j++)
+ {
+ QUIT;
+ if (!strcmp (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
+ goto common;
+ }
+ }
+ }
+ common:
+ if (i < len)
+ {
+ fprintf (stream, "& ");
+ type_print_base (domain, stream, 0, 0);
+ fprintf (stream, "::%s", kind);
+ type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (f, j), stream, 0, 0);
+ if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
+ && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == '$')
+ type_print_method_args
+ (TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
+ TYPE_FN_FIELDLIST_NAME (domain, i), stream);
+ else
+ type_print_method_args
+ (TYPE_FN_FIELD_ARGS (f, j), "",
+ TYPE_FN_FIELDLIST_NAME (domain, i), stream);
+ break;
+ }
+ }
+ else
+ {
+ /* VAL is a byte offset into the structure type DOMAIN.
+ Find the name of the field for that offset and
+ print it. */
+ int extra = 0;
+ int bits = 0;
+ len = TYPE_NFIELDS (domain);
+ val <<= 3; /* @@ Make VAL into bit offset */
+ for (i = 0; i < len; i++)
+ {
+ int bitpos = TYPE_FIELD_BITPOS (domain, i);
+ QUIT;
+ if (val == bitpos)
+ break;
+ if (val < bitpos && i > 0)
+ {
+ int ptrsize = (TYPE_LENGTH (builtin_type_char) * TYPE_LENGTH (target));
+ /* Somehow pointing into a field. */
+ i -= 1;
+ extra = (val - TYPE_FIELD_BITPOS (domain, i));
+ if (extra & 0x3)
+ bits = 1;
+ else
+ extra >>= 3;
+ break;
+ }
+ }
+ if (i < len)
+ {
+ fprintf (stream, "& ");
+ type_print_base (domain, stream, 0, 0);
+ fprintf (stream, "::");
+ fprintf (stream, "%s", TYPE_FIELD_NAME (domain, i));
+ if (extra)
+ fprintf (stream, " + %d bytes", extra);
+ if (bits)
+ fprintf (stream, " (offset in bits)");
+ break;
+ }
+ }
+ fputc ('(', stream);
+ type_print (type, "", stream, -1);
+ fprintf (stream, ") %d", val >> 3);
+ break;
+ }
+
+ case TYPE_CODE_REF:
+ fprintf (stream, "(0x%x &) = ", * (int *) valaddr);
+ /* De-reference the reference. */
+ if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
+ {
+ value val = value_at (TYPE_TARGET_TYPE (type), * (int *)valaddr);
+ val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
+ VALUE_ADDRESS (val), stream);
+ }
+ else
+ fprintf (stream, "???");
+ break;
+
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
fprintf (stream, "{");
len = TYPE_NFIELDS (type);
- for (i = 0; i < len; i++)
+ if (TYPE_BASECLASS (type))
+ {
+ i = 1;
+ fprintf (stream, "<%s> = ", TYPE_NAME (TYPE_BASECLASS (type)));
+ val_print (TYPE_FIELD_TYPE (type, 0),
+ valaddr + TYPE_FIELD_BITPOS (type, 0) / 8,
+ 0, stream);
+
+ }
+ else i = 0;
+ for (; i < len; i++)
{
if (i) fprintf (stream, ", ");
fprintf (stream, "%s = ", TYPE_FIELD_NAME (type, i));
- if (TYPE_FIELD_PACKED (type, i))
+ /* check if static field */
+ if (TYPE_FIELD_STATIC (type, i))
+ {
+ value v;
+
+ v = value_static_field (type, TYPE_FIELD_NAME (type, i), i);
+ val_print (TYPE_FIELD_TYPE (type, i),
+ VALUE_CONTENTS (v), 0, stream);
+ }
+ else if (TYPE_FIELD_PACKED (type, i))
{
val = unpack_field_as_long (type, valaddr, i);
val_print (TYPE_FIELD_TYPE (type, i), &val, 0, stream);
}
else
- val_print (TYPE_FIELD_TYPE (type, i),
- valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
- 0, stream);
+ {
+ val_print (TYPE_FIELD_TYPE (type, i),
+ valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
+ 0, stream);
+ }
}
fprintf (stream, "}");
break;
((show > 0 || TYPE_NAME (type) == 0)
&&
(code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
- || code == TYPE_CODE_ARRAY)))
+ || code == TYPE_CODE_ARRAY
+ || code == TYPE_CODE_MPTR
+ || code == TYPE_CODE_REF)))
fprintf (stream, " ");
type_print_varspec_prefix (type, stream, show, 0);
fprintf (stream, "%s", varstring);
type_print_varspec_suffix (type, stream, show, 0);
}
+/* Print the method arguments ARGS to the file STREAM. */
+static void
+type_print_method_args (args, prefix, varstring, stream)
+ struct type **args;
+ char *prefix, *varstring;
+ FILE *stream;
+{
+ int i;
+
+ fprintf (stream, " %s%s (", prefix, varstring);
+ if (args[1] && args[1]->code != TYPE_CODE_VOID)
+ {
+ i = 1; /* skip the class variable */
+ while (1)
+ {
+ type_print (args[i++], "", stream, 0);
+ if (args[i]->code != TYPE_CODE_VOID)
+ {
+ fprintf (stream, ", ");
+ }
+ else break;
+ }
+ }
+ fprintf (stream, ")");
+}
+
/* Print any asterisks or open-parentheses needed before the
variable name (to describe its type).
fputc ('*', stream);
break;
+ case TYPE_CODE_MPTR:
+ type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
+ if (passed_a_ptr)
+ fputc ('(', stream);
+ type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, 1);
+ fprintf (stream, "::*");
+ break;
+
+ case TYPE_CODE_REF:
+ type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
+ fputc ('&', stream);
+ break;
+
case TYPE_CODE_FUNC:
- case TYPE_CODE_ARRAY:
- type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+ type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
+ passed_a_ptr);
if (passed_a_ptr)
fputc ('(', stream);
break;
+
+ case TYPE_CODE_ARRAY:
+ type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
+ passed_a_ptr);
}
}
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
- if (passed_a_ptr)
- fprintf (stream, ")");
+ type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
+ passed_a_ptr);
fprintf (stream, "[");
if (TYPE_LENGTH (type) >= 0)
fprintf (stream, "%d",
fprintf (stream, "]");
break;
+ case TYPE_CODE_MPTR:
+ if (passed_a_ptr)
+ fputc (')', stream);
+ /* Fall through. */
case TYPE_CODE_PTR:
+ case TYPE_CODE_REF:
type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1);
break;
case TYPE_CODE_FUNC:
- type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+ type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
+ passed_a_ptr);
if (passed_a_ptr)
fprintf (stream, ")");
fprintf (stream, "()");
{
case TYPE_CODE_ARRAY:
case TYPE_CODE_PTR:
+ case TYPE_CODE_MPTR:
+ case TYPE_CODE_REF:
case TYPE_CODE_FUNC:
type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
break;
fprintf (stream, "{...}");
else
{
+ struct type *basetype, *dtype;
+
+ dtype = type;
+ basetype = TYPE_BASECLASS (type);
+ while (basetype)
+ {
+ if (TYPE_NAME (basetype) && (name = TYPE_NAME (basetype)))
+ {
+ while (*name != ' ') name++;
+ fprintf (stream, ": %s %s ",
+ TYPE_VIA_PUBLIC (dtype) ? "public" : "private",
+ name + 1);
+ }
+ dtype = basetype;
+ basetype = TYPE_BASECLASS (basetype);
+ }
fprintf (stream, "{");
len = TYPE_NFIELDS (type);
- fprintf (stream, "\n");
- for (i = 0; i < len; i++)
+ if (len) fprintf (stream, "\n");
+ else fprintf (stream, "<no data fields>\n");
+
+ /* If there is a base class for this type,
+ do not print the field that it occupies. */
+ for (i = !! TYPE_BASECLASS (type); i < len; i++)
{
QUIT;
- print_spaces (level + 4, stream);
+ /* Don't print out virtual function table. */
+ if (! strncmp (TYPE_FIELD_NAME (type, i),
+ "_vptr$", 6))
+ continue;
- /* If this is a bit-field and there is a gap before it,
- print a nameless field to account for the gap. */
-
- if (TYPE_FIELD_PACKED (type, i))
+ print_spaces (level + 4, stream);
+ if (TYPE_FIELD_STATIC (type, i))
{
- int gap = (TYPE_FIELD_BITPOS (type, i)
- - (i > 0
- ? (TYPE_FIELD_BITPOS (type, i - 1)
- + (TYPE_FIELD_PACKED (type, i - 1)
- ? TYPE_FIELD_BITSIZE (type, i - 1)
- : TYPE_LENGTH (TYPE_FIELD_TYPE (type, i - 1)) * 8))
- : 0));
- if (gap != 0)
- {
- fprintf (stream, "int : %d;\n", gap);
- print_spaces (level + 4, stream);
- }
+ fprintf (stream, "static ");
}
-
- /* Print the declaration of this field. */
-
type_print_1 (TYPE_FIELD_TYPE (type, i),
TYPE_FIELD_NAME (type, i),
stream, show - 1, level + 4);
+ if (!TYPE_FIELD_STATIC (type, i)
+ && TYPE_FIELD_PACKED (type, i))
+ {
+ /* ??? don't know what to put here ??? */;
+ }
+ fprintf (stream, ";\n");
+ }
- /* Print the field width. */
-
- if (TYPE_FIELD_PACKED (type, i))
- fprintf (stream, " : %d", TYPE_FIELD_BITSIZE (type, i));
+ /* C++: print out the methods */
+ len = TYPE_NFN_FIELDS (type);
+ if (len) fprintf (stream, "\n");
+ for (i = 0; i < len; i++)
+ {
+ struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
+ int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
- fprintf (stream, ";\n");
+ for (j = 0; j < len2; j++)
+ {
+ QUIT;
+ print_spaces (level + 4, stream);
+ if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
+ fprintf (stream, "virtual ");
+ type_print_base (TYPE_FN_FIELD_TYPE (f, j), stream, 0, level);
+ type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (f, j), stream, 0, 0);
+ if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
+ && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == '$')
+ type_print_method_args
+ (TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
+ TYPE_FN_FIELDLIST_NAME (type, i), stream);
+ else
+ type_print_method_args
+ (TYPE_FN_FIELD_ARGS (f, j), "",
+ TYPE_FN_FIELDLIST_NAME (type, i), stream);
+
+ fprintf (stream, ";\n");
+ }
+ if (len2) fprintf (stream, "\n");
}
+
print_spaces (level, stream);
fputc ('}', stream);
}
value value_assign ();
value value_neg ();
value value_lognot ();
-value value_struct_elt ();
+value value_struct_elt (), value_struct_elt_for_address ();
value value_field ();
value value_cast ();
value value_repeat ();
value evaluate_expression ();
value evaluate_type ();
value parse_and_eval ();
+value parse_to_comma_and_eval ();
value access_value_history ();
value value_of_internalvar ();
int value_equal ();
int value_less ();
int value_zerop ();
+
+/* C++ */
+value value_of_this ();
+value value_static_field ();
/* Unpack raw data (copied from debugee) at VALADDR
as a long, or as a double, assuming the raw data is described
by type TYPE. Knows how to convert different sizes of values
- and can convert between fixed and floating point. */
+ and can convert between fixed and floating point.
+
+ C++: It is assumed that the front-end has taken care of
+ all matters concerning pointers to members. A pointer
+ to member which reaches here is considered to be equivalent
+ to an INT (or some size). After all, it is only an offset. */
long
unpack_long (type, valaddr)
if (len == sizeof (long))
return * (unsigned long *) valaddr;
}
- else if (code == TYPE_CODE_INT)
+ else if (code == TYPE_CODE_INT
+ || code == TYPE_CODE_MPTR)
{
if (len == sizeof (char))
return * (char *) valaddr;
if (len == sizeof (long))
return * (long *) valaddr;
}
- else if (code == TYPE_CODE_PTR)
+ else if (code == TYPE_CODE_PTR
+ || code == TYPE_CODE_REF)
{
if (len == sizeof (char *))
return (CORE_ADDR) * (char **) valaddr;
}
-
error ("Value not integer or pointer.");
}
\f
/* Given a value ARG1 of a struct or union type,
extract and return the value of one of its fields.
- FIELDNO says which field. */
+ FIELDNO says which field.
+
+ For C++, must also be able to return values from static fields */
value
value_field (arg1, fieldno)
return v;
}
+value
+value_fn_field (arg1, fieldno, subfieldno)
+ register value arg1;
+ register int fieldno;
+{
+ register value v;
+ struct fn_field *f = TYPE_FN_FIELDLIST1 (VALUE_TYPE (arg1), fieldno);
+ register struct type *type = TYPE_FN_FIELD_TYPE (f, subfieldno);
+ struct symbol *sym;
+
+ sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, subfieldno),
+ 0, VAR_NAMESPACE);
+ if (! sym) error ("Internal error: could not find physical method named %s",
+ TYPE_FN_FIELD_PHYSNAME (f, subfieldno));
+
+ v = allocate_value (type);
+ VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ VALUE_TYPE (v) = type;
+ return v;
+}
+
+/* The value of a static class member does not depend
+ on its instance, only on its type. If FIELDNO >= 0,
+ then fieldno is a valid field number and is used directly.
+ Otherwise, FIELDNAME is the name of the field we are
+ searching for. If it is not a static field name, an
+ error is signaled. TYPE is the type in which we look for the
+ static field member. */
+value
+value_static_field (type, fieldname, fieldno)
+ register struct type *type;
+ char *fieldname;
+ register int fieldno;
+{
+ register value v;
+ struct symbol *sym;
+
+ if (fieldno < 0)
+ {
+ register struct type *t = type;
+ /* Look for static field. */
+ while (t)
+ {
+ int i;
+ for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
+ if (! strcmp (TYPE_FIELD_NAME (t, i), fieldname))
+ {
+ if (TYPE_FIELD_STATIC (t, i))
+ {
+ fieldno = i;
+ goto found;
+ }
+ else
+ error ("field `%s' is not static");
+ }
+ t = TYPE_BASECLASS (t);
+ }
+
+ t = type;
+
+ if (destructor_name_p (fieldname, t))
+ error ("use `info method' command to print out value of destructor");
+
+ while (t)
+ {
+ int i, j;
+
+ for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; i--)
+ {
+ if (! strcmp (TYPE_FN_FIELDLIST_NAME (t, i), fieldname))
+ {
+ error ("use `info method' command to print value of method \"%s\"", fieldname);
+ }
+ }
+ t = TYPE_BASECLASS (t);
+ }
+ error("there is no field named %s", fieldname);
+ }
+
+ found:
+
+ sym = lookup_symbol (TYPE_FIELD_STATIC_PHYSNAME (type, fieldno),
+ 0, VAR_NAMESPACE);
+ if (! sym) error ("Internal error: could not find physical static variable named %s", TYPE_FIELD_BITSIZE (type, fieldno));
+
+ type = TYPE_FIELD_TYPE (type, fieldno);
+ v = value_at (type, (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
+ return v;
+}
+
long
unpack_field_as_long (type, valaddr, fieldno)
struct type *type;
/* Define the current version number of GDB. */
-char *version = "2.4+";
+char *version = "2.5.1 (GNU C++ 1.21.0 compatible)";
projects / external / binutils.git / commitdiff