-#ifndef lint
+#include <sys/file.h>
+/*#include <sys/ptrace.h> defs.h*/
+/*#include <sys/types.h> sys/file.h*/
+#include <sys/vmmac.h>
+/*#include <vax/machparam.h> defs.h*/
+/*#include <vax/pte.h> sys/file.h*/
+#include "defs.h"
+#include "head.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)access.c 4.8 10/13/84";
#endif
/*
* to translate virtual to physical addresses.
*/
-#include "defs.h"
-
+/*#include "defs.h"*/
struct map txtmap;
struct map datmap;
* Primitives: put a value in a space, get a value from a space
* and get a word or byte not returning if an error occurred.
*/
-put(addr, space, value)
- off_t addr; { (void) _access(WT, addr, space, value); }
+int put(addr, space, value) off_t addr; int space; int value; { (void) _access(WT, addr, space, value); }
-u_int
-get(addr, space)
- off_t addr; { return (_access(RD, addr, space, 0)); };
+u_int get(addr, space) off_t addr; int space; { return (_access(RD, addr, space, 0)); };
-u_int
-chkget(addr, space)
- off_t addr; { u_int w = get(addr, space); chkerr(); return(w); }
+u_int chkget(addr, space) off_t addr; int space; { u_int w = get(addr, space); chkerr(); return(w); }
-u_int
-bchkget(addr, space)
- off_t addr; { return(chkget(addr, space) & 0xff); }
+u_int bchkget(addr, space) off_t addr; int space; { return(chkget(addr, space) & 0xff); }
/*
* Read/write according to mode at address addr in i/d space.
* relative to the ``current'' process (as specified by its p_addr in
* <p) and mapping system space addresses through the system page tables.
*/
-_access(mode, addr, space, value)
- int mode, space, value;
- off_t addr;
-{
+int _access(mode, addr, space, value) int mode; off_t addr; int space; int value; {
int rd = mode == RD;
int file, w;
* When looking at kernel data space through /dev/mem or
* with a core file, do virtual memory mapping.
*/
-vtophys(addr)
- off_t addr;
-{
+int vtophys(addr) off_t addr; {
int oldaddr = addr;
int v;
struct pte pte;
return (ptob(pte.pg_pfnum) + (oldaddr & PGOFSET));
}
-rwerr(space)
- int space;
-{
+int rwerr(space) int space; {
if (space & DSP)
errflg = "data address not found";
errflg = "text address not found";
}
-physrw(file, addr, aw, rd)
- off_t addr;
- int *aw, rd;
-{
+int physrw(file, addr, aw, rd) int file; off_t addr; int *aw; int rd; {
if (longseek(file,addr)==0 ||
(rd ? read(file,aw,sizeof(int)) : write(file,aw,sizeof(int))) < 1)
return (0);
}
-chkmap(addr,space)
- register long *addr;
- register short space;
-{
+int chkmap(addr, space) register long *addr; int space; {
register struct map *amap;
amap=((space&DSP?&datmap:&txtmap));
if (space&STAR || !within(*addr,amap->b1,amap->e1)) {
return(1);
}
-within(addr,lbd,ubd)
- u_int addr, lbd, ubd; { return(addr>=lbd && addr<ubd); }
+int within(addr, lbd, ubd) u_int addr; u_int lbd; u_int ubd; { return(addr>=lbd && addr<ubd); }
-longseek(f, a)
- off_t a; { return(lseek(f, a, 0) != -1); }
+int longseek(f, a) int f; off_t a; { return(lseek(f, a, 0) != -1); }
-#ifndef lint
+/*#include <sys/ptrace.h> defs.h*/
+#include "defs.h"
+#include "head.h"
+#include "machine.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)command.c 4.6 10/13/84";
#endif
/*
*
*/
-#include "defs.h"
+/*#include "defs.h"*/
extern char BADEQ[];
extern char NOMATCH[];
extern long cntval;
extern short cntflg;
-
-
-
/* command decoding */
-command(buf,defcom)
-char *buf;
-char defcom;
-{
+int command(buf, defcom) char *buf; int defcom; {
short itype, ptype, modifier, regptr;
bool longpr, eqcom;
char wformat[1];
if (buf) { lp=savlp; } else { lp--; }
return(adrflg && dot!=0);
}
-
+#ifndef _DEFS_H_
+#define _DEFS_H_
+
+#include <sys/ptrace.h>
+#include <vax/machparam.h>
+#include <vax/pcb.h>
+
/* defs.h 4.6 86/03/26 */
/*
* adb - vax string table version; common definitions
*/
-#include <machine/psl.h>
-#include <machine/pte.h>
+/*#include <machine/psl.h>*/
+/*#include <machine/pte.h>*/
-#include <sys/param.h>
-#include <sys/dir.h>
-#include <sys/user.h>
+/*#include <sys/param.h>*/
+/*#include <sys/dir.h>*/
+/*#include <sys/user.h>*/
-#include <ctype.h>
-#include <a.out.h>
-#include <sys/ptrace.h>
+/*#include <ctype.h>*/
+/*#include <a.out.h>*/
+/*#include <sys/ptrace.h>*/
-#include "mode.h"
-#include "head.h"
+/*#include "mode.h"*/
+/*#include "head.h"*/
/* access modes */
#define RD 0
#define MAXLIN 128
/* result type declarations */
-long inkdot();
-unsigned get();
-unsigned chkget();
-char *exform();
-long round();
-struct bkpt *scanbkpt();
-void fault();
+/*long inkdot();*/
+/*unsigned get();*/
+/*unsigned chkget();*/
+/*char *exform();*/
+/*long round();*/
+/*struct bkpt *scanbkpt();*/
+/*void fault();*/
extern struct pcb pcb;
extern int kernel;
extern struct pte *sbr;
extern int slr;
extern int masterpcbb;
+
+#endif
-#ifndef lint
+#include <a.out.h>
+#include <ctype.h>
+#include <strings.h>
+#include "defs.h"
+#include "head.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)expr.c 4.8 8/11/83";
#endif
/*
*
*/
-#include "defs.h"
+/*#include "defs.h"*/
extern char BADSYM[];
extern char BADVAR[];
intptr_t savpc;
intptr_t callpc;
-
-
extern char *lp;
extern short radix;
extern char *errflg;
extern long var[];
extern long expv;
-
-
-
-expr(a)
-{ /* term | term dyadic expr | */
+int expr(a) int a; { /* term | term dyadic expr | */
short rc;
long lhs;
return(rc);
}
-term(a)
-{ /* item | monadic item | (expr) | */
+int term(a) int a; { /* item | monadic item | (expr) | */
switch ((int)readchar()) {
}
}
-item(a)
-{ /* name [ . local ] | number | . | ^ | <var | <register | 'x | | */
+int item(a) int a; { /* name [ . local ] | number | . | ^ | <var | <register | 'x | | */
short base, d;
char savc;
bool hex;
}
/* service routines for expression reading */
-getnum(rdf) int (*rdf)();
-{
+int getnum(rdf) int (*rdf)(); {
short base,d,frpt;
bool hex;
union{float r; long i;} real;
}
}
-readsym()
-{
+int readsym() {
register char *p;
p = isymbol;
*p++ = 0;
}
-convdig(c)
-char c;
-{
+int convdig(c) int c; {
if (isdigit(c)) {
return(c-'0');
}
}
}
-symchar(dig)
-{
+int symchar(dig) int dig; {
if (lastc=='\\') { readchar(); return(-1); }
return( isalpha(lastc) || lastc=='_' || dig && isdigit(lastc) );
}
-varchk(name)
-{
+int varchk(name) int name; {
if (isdigit(name)) { return(name-'0'); }
if (isalpha(name)) { return((name&037)-1+10); }
return(-1);
}
-chkloc(frame)
-long frame;
-{
+int chkloc(frame) long frame; {
readsym();
do {
/* Nick added ",frame" below */
} while (!eqsym(cursym->n_un.n_name,isymbol,'~'));
}
-eqsym(s1, s2, c)
- register char *s1, *s2;
-{
+int eqsym(s1, s2, c) register char *s1; register char *s2; int c; {
if (!strcmp(s1,s2))
return (1);
-#ifndef lint
+#include <gen.h>
+/*#include <sys/exec.h> gen.h*/
+/*#include <sys/proc.h> gen.h*/
+/*#include <sys/signal.h> gen.h*/
+#include <sys/wait.h>
+#include "defs.h"
+#include "head.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)format.c 4.3 2/27/86";
#endif
/*
*
*/
-#include "defs.h"
+/*#include "defs.h"*/
extern char BADMOD[];
extern char NOFORK[];
extern long expv;
extern long var[];
-
char *fphack;
-rdfp()
-{
+int rdfp() {
return(lastc= *fphack++);
}
-scanform(icount,ifp,itype,ptype)
-long icount;
-char *ifp;
-{
+int scanform(icount, ifp, itype, ptype) long icount; char *ifp; int itype; int ptype; {
char *fp;
char modifier;
short fcount, init=1;
}
}
-char *
-exform(fcount,ifp,itype,ptype)
-short fcount;
-char *ifp;
-{
+char *exform(fcount, ifp, itype, ptype) int fcount; char *ifp; int itype; int ptype; {
/* execute single format item `fcount' times
* sets `dotinc' and moves `dot'
* returns address of next format item
return(fp);
}
-shell()
-{
+int shell() {
#ifndef EDDT
short rc, status, unixpid;
char *argp = lp;
#endif
}
-
-printesc(c)
-{
+int printesc(c) int c; {
c &= 0x7f;
if (c==0177) {
_printf("^?");
}
}
-long inkdot(incr)
-{
+long inkdot(incr) int incr; {
long newdot;
newdot=dot+incr;
return(newdot);
}
-digit(c)
-{
+int digit(c) int c; {
return c >= '0' && c <= '9';
}
+#ifndef _HEAD_H_
+#define _HEAD_H_
+
+#include <a.out.h>
+/*#include <sys/exec.h> a.out.h*/
+/*#include <sys/types.h> sys/user.h*/
+#include <sys/user.h>
+#include <vax/frame.h>
+/*#include <vax/machparam.h> sys/user.h*/
+#include "mode.h"
+
/* head.h 4.1 81/05/14 */
extern long maxoff;
extern struct nlist *symtab, *esymtab;
extern struct nlist *cursym;
-extern struct nlist *lookup();
+/*extern struct nlist *lookup();*/
extern struct exec filhdr;
#define u udot.U
extern char *corfil, *symfil;
+
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif
+
+/* access.c */
+int put __P((off_t addr, int space, int value));
+u_int get __P((off_t addr, int space));
+u_int chkget __P((off_t addr, int space));
+u_int bchkget __P((off_t addr, int space));
+int _access __P((int mode, off_t addr, int space, int value));
+int vtophys __P((off_t addr));
+int rwerr __P((int space));
+int physrw __P((int file, off_t addr, int *aw, int rd));
+int chkmap __P((register long *addr, int space));
+int within __P((u_int addr, u_int lbd, u_int ubd));
+int longseek __P((int f, off_t a));
+
+/* command.c */
+int command __P((char *buf, int defcom));
+
+/* expr.c */
+int expr __P((int a));
+int term __P((int a));
+int item __P((int a));
+int getnum __P((int (*rdf)(void)));
+int readsym __P((void));
+int convdig __P((int c));
+int symchar __P((int dig));
+int varchk __P((int name));
+int chkloc __P((long frame));
+int eqsym __P((register char *s1, register char *s2, int c));
+
+/* format.c */
+int rdfp __P((void));
+int scanform __P((long icount, char *ifp, int itype, int ptype));
+char *exform __P((int fcount, char *ifp, int itype, int ptype));
+int shell __P((void));
+int printesc __P((int c));
+long inkdot __P((int incr));
+int digit __P((int c));
+
+/* input.c */
+int eol __P((int c));
+int rdc __P((void));
+int readchar __P((void));
+int nextchar __P((void));
+int quotchar __P((void));
+int getformat __P((char *deformat));
+
+/* main.c */
+int main __P((int argc, register char **argv));
+int done __P((void));
+long round __P((register long a, register long b));
+int chkerr __P((void));
+int error __P((char *n));
+int fault __P((int a));
+
+/* opset.c */
+int mapescbyte __P((int byte));
+int mkioptab __P((void));
+int printins __P((int fmt, int Idsp, int ins));
+int casebody __P((long base, long limit));
+long inkdot __P((int incr));
+int printc __P((int c));
+int psymoff __P((long v, int regnumber, char *fmt));
+int prdiff __P((int diff));
+
+/* output.c */
+int eqstr __P((register char *s1, register char *s2));
+int length __P((register char *s));
+int printc __P((int c));
+int charpos __P((void));
+int flushbuf __P((void));
+int _printf __P((char *fmat, ...));
+int printdate __P((long tvec));
+int prints __P((char *s));
+int newline __P((void));
+int convert __P((register char **cp));
+int printnum __P((int n, int fmat, int base));
+int printoct __P((long o, int s));
+int iclose __P((int stack, int err));
+int oclose __P((void));
+int endline __P((void));
+
+/* pcs.c */
+int subpcs __P((int modif));
+
+/* print.c */
+int printtrace __P((int modif));
+int printmap __P((char *s, struct map *amap));
+int printregs __P((void));
+int getreg __P((int regnam));
+int printpc __P((void));
+int sigprint __P((void));
+
+/* runpcs.c */
+int getsig __P((int sig));
+int runpcs __P((int runmode, int execsig));
+int endpcs __P((void));
+int nullsig __P((void));
+int setup __P((void));
+int execbkpt __P((struct bkpt *bkptr, int execsig));
+int doexec __P((void));
+struct bkpt *scanbkpt __P((intptr_t adr));
+int delbp __P((void));
+int setbp __P((void));
+int bpwait __P((void));
+int readregs __P((void));
+
+/* setup.c */
+int setsym __P((void));
+int setcor __P((void));
+int getpcb __P((void));
+int findstackframe __P((void));
+struct frame *checkintstack __P((int fcor));
+struct frame *getframe __P((int fcor, caddr_t fp));
+int checkframe __P((register struct frame *fp));
+int kstackaddr __P((caddr_t addr));
+int create __P((char *f));
+int getfile __P((char *filnam, int cnt));
+int setvar __P((void));
+
+/* sym.c */
+struct nlist *lookup __P((char *symstr));
+int findsym __P((long val, int type));
+int localsym __P((intptr_t cframe, intptr_t cargp));
+int psymoff __P((long v, int type, char *s));
+int valpr __P((long v, int idsp));
+
+#endif
-#ifndef lint
+#include <sys/file.h>
+#include "head.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)input.c 4.2 8/11/83";
#endif
/*
*
*/
-#include "defs.h"
+/*#include "defs.h"*/
extern short mkfault;
char line[LINSIZ];
/* input routines */
-eol(c)
-char c;
-{
+int eol(c) int c; {
return(c=='\n' || c==';');
}
-rdc()
-{
+int rdc() {
do {
readchar();
} while (lastc==' ' || lastc=='\t');
return(lastc);
}
-readchar()
-{
+int readchar() {
if (eof) {
lastc=0;
}
return(lastc);
}
-nextchar()
-{
+int nextchar() {
if (eol(rdc())) {
lp--; return(0);
}
}
}
-quotchar()
-{
+int quotchar() {
if (readchar()=='\\') {
return(readchar());
}
}
}
-getformat(deformat)
-char *deformat;
-{
+int getformat(deformat) char *deformat; {
register char *fptr;
register bool quote;
fptr=deformat; quote=0;
+#ifndef _MACHINE_H_
+#define _MACHINE_H_
+
+#include <vax/machparam.h>
+
/* machine.h 4.1 81/05/14 */
-#include <sys/vm.h>
+/*#include <sys/vm.h>*/
#define PAGSIZ (NBPG*CLSIZE)
#define KVTOPH(x) ((x)&~ 0x80000000)
#define KERNOFF 0x80000000
+
+#endif
+#include <a.out.h>
+#include <setjmp.h>
+#include <stdio.h>
+/*#include <sys/exec.h> a.out.h*/
+#include <sys/file.h>
+#include <sys/signal.h>
+/*#include <vax/pcb.h> defs.h*/
+/*#include <vax/pte.h> sys/file.h*/
+#include "defs.h"
+#include "head.h"
+#include "machine.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)main.c 4.3 4/1/82";
+#endif
/*
* adb - main command loop and error/interrupt handling
*/
-#include <setjmp.h>
-#include "defs.h"
+/*#include <setjmp.h>*/
+/*#include "defs.h"*/
extern char NOEOR[];
/* use this instead of original setexit() / reset() */
jmp_buf reset_buf;
-main(argc, argv)
- register char **argv;
- int argc;
-{
+int main(argc, argv) int argc; register char **argv; {
mkioptab();
another:
}
}
-done()
-{
+int done() {
endpcs();
exit(exitflg);
}
-long
-round(a,b)
-register long a, b;
-{
+long round(a, b) register long a; register long b; {
register long w;
w = (a/b)*b;
if (a!=w) { w += b; }
/*
* If there has been an error or a fault, take the error.
*/
-chkerr()
-{
+int chkerr() {
if (errflg || mkfault)
error(errflg);
}
* An error occurred; save the message for later printing,
* close open files, and reset to main command loop.
*/
-error(n)
- char *n;
-{
+int error(n) char *n; {
errflg = n;
iclose(0, 1); oclose();
/*reset();*/ longjmp(reset_buf, 1);
* catch, seek to the end of the current file
* and remember that there was a fault.
*/
-fault(a)
-{
+int fault(a) int a; {
signal(a, fault);
lseek(infile, 0L, 2);
mkfault++;
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)message.c 4.3 8/11/83";
#endif
/*
*
*/
-#include "mode.h"
+/*#include "mode.h"*/
char VERSION[] = "\nVERSION VM/VAX4.3 DATE 8/11/83\n";
+#ifndef _MODE_H_
+#define _MODE_H_
+
/* mode.h 4.2 81/05/14 */
-#include "machine.h"
+/*#include "machine.h"*/
/*
* sdb/adb - common definitions for old srb style code
*/
short roffs;
int *rkern;
};
+
+#endif
-#ifndef lint
+#include "../as/asnumber.h"
+#include "../as/instrs.h"
+/*#include <sys/types.h> ../as/asnumber.h*/
+#include "defs.h"
+#include "head.h"
+#include "machine.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)opset.c 4.5 5/27/85";
-#endif lint
+#endif
/*
* UNIX debugger
* Instruction printing routines.
*/
#ifdef ADB
-#include "defs.h"
-#endif ADB
+/*#include "defs.h"*/
+#endif
#ifdef SDB
-#include "head.h"
-#endif SDB
+/*#include "head.h"*/
+#endif
extern long dot;
extern short dotinc;
long insoutvar[36];
#ifdef ADB
extern long var[36];
-#endif ADB
+#endif
#undef INSTTAB
#include "instrs.h"
/*
* Definitions for registers and for operand classes
*/
-static char *insregname(); /* how to print a register */
+/*static char *insregname();*/ /* how to print a register */
#define R_PC 0xF
* Definitions for large numbers
*/
#include "asnumber.h"
-static struct as_number *snarf();
-static struct as_number *snarfreloc();
+/*static struct as_number *snarf();*/
+/*static struct as_number *snarfreloc();*/
/*
* Definitions for special instructions
*/
short ioptab[3][256]; /* two level 1-based index by opcode into insttab */
-int mapescbyte(byte)
- u_char byte;
-{
+static savevar __P((long val));
+static struct as_number *snarfreloc __P((int nbytes));
+static struct as_number *snarf __P((int nbytes));
+static u_char snarfuchar __P((void));
+static char *operandout __P((int mode, int optype));
+static dispaddress __P((struct as_number *valuep, int mode));
+static char *insregname __P((int regnumber));
+static shortliteral __P((int mode, int optype));
+static pcimmediate __P((int mode, int optype));
+static bignumprint __P((int nbytes, int optype));
+
+int mapescbyte(byte) int byte; {
switch(byte){
default: return(0);
case ESCD: return(1);
}
}
-mkioptab()
-{
+int mkioptab() {
register struct insttab *p;
int mapchar;
}
}
-static u_char snarfuchar();
+/*static u_char snarfuchar();*/
/*
* Global variables for communicating with the minions and printins
*/
static char insoutfmt[2]; /* how to format the relocated symbols */
#ifdef SDB
static struct proct *procp;
-#endif SDB
+#endif
-static savevar(val)
- long val;
-{
+static savevar(val) long val; {
var[argno] = val;
insoutvar[argno] = val;
}
-printins(fmt, Idsp, ins)
- char fmt;
-#ifndef vax
- u_char ins;
-#else
- u_char ins;
-#endif
- int Idsp;
-{
+int printins(fmt, Idsp, ins) int fmt; int Idsp; int ins; {
u_char mode; /* mode */
u_char ins2;
char *indexreg; /* print of which register indexes */
incp = 2;
goto ret;
}
-#endif SDB
+#endif
#ifdef ADB
insoutfmt[0] = 0;
-#endif ADB
+#endif
#ifdef SDB
insoutfmt[0] = fmt;
-#endif SDB
+#endif
incp = 1;
if ((mapchar = mapescbyte(ins)) != 0){
#ifdef SDB
oincr = incp;
-#endif SDB
+#endif
#ifdef ADB
dotinc = incp;
-#endif ADB
+#endif
}
-casebody(base, limit)
- long base;
- long limit;
-{
+int casebody(base, limit) long base; long limit; {
int i;
unsigned baseincp;
unsigned advincp;
printc('\n');
#ifdef SDB
_printf(" %d: ", i + base);
-#endif SDB
+#endif
#ifdef ADB
_printf(" %R: ", i + base);
-#endif ADB
+#endif
valuep = snarfreloc(OSIZE);
advincp = incp;
incp = baseincp;
/*
* Snarf up some bytes, and put in the magic relocation flags
*/
-static struct as_number *snarfreloc(nbytes)
- int nbytes;
-{
+static struct as_number *snarfreloc(nbytes) int nbytes; {
struct as_number *back;
back = snarf(nbytes);
if (back->num_ulong[0] & magic_masks[nbytes])
* The following code is NOT portable from the PDP 11 to the VAX
* because of the byte ordering problem.
*/
-static struct as_number *snarf(nbytes)
- int nbytes;
-{
+static struct as_number *snarf(nbytes) int nbytes; {
register int i;
static struct as_number backnumber;
/*
* Read one single character, and advance the dot
*/
-static u_char snarfuchar()
-{
+static u_char snarfuchar() {
u_char back;
/*
* assert: bchkget and inkdot don't have side effects
* normal operand; return non zero pointer to register
* name if this is an index instruction.
*/
-static char *operandout(mode, optype)
- u_char mode;
- u_char optype;
-{
+static char *operandout(mode, optype) int mode; int optype; {
char *r;
int regnumber;
int nbytes;
return(0);
}
-static dispaddress(valuep, mode)
- struct as_number *valuep;
- u_char mode;
-{
+static dispaddress(valuep, mode) struct as_number *valuep; int mode; {
int regnumber = OC_REGEXT(mode);
switch(OC_AMEXT(mode)){
_printf(insoutfmt);
_printf("(%s)", insregname(regnumber));
}
-#endif ADB
+#endif
#ifdef SDB
if(psymoff(valuep->num_ulong[0], regnumber, &insoutfmt[0])
&& (regnumber != R_PC)){
_printf("(%s)", insregname(regnumber));
}
-#endif SDB
+#endif
savevar((long)valuep->num_ulong[0]);
}
/*
* get a register name
*/
-static char *insregname(regnumber)
- int regnumber;
-{
+static char *insregname(regnumber) int regnumber; {
char *r;
r = regname[regnumber];
#ifdef SDB
&& (adrtoregvar(regnumber, procp) != -1)) {
r = sl_name;
}
-#endif SDB
+#endif
return(r);
}
/*
* print out a short literal
*/
-static shortliteral(mode, optype)
- u_char mode;
- u_char optype;
-{
+static shortliteral(mode, optype) int mode; int optype; {
savevar((long)mode);
switch(A_TYPEXT(optype)){
case TYPF:
default:
#ifdef ADB
_printf("$%r", mode);
-#endif ADB
+#endif
#ifdef SDB
_printf("$%d", mode);
-#endif SDB
+#endif
break;
}
}
-static pcimmediate(mode, optype)
- u_char mode;
- u_char optype;
-{
+static pcimmediate(mode, optype) int mode; int optype; {
int nbytes;
printc('$');
bignumprint(nbytes, optype);
}
-static bignumprint(nbytes, optype)
- int nbytes;
- u_char optype;
-{
+static bignumprint(nbytes, optype) int nbytes; int optype; {
struct as_number *valuep;
int leading_zero = 1;
register int bindex;
}
#ifdef SDB
-long inkdot(incr)
- int incr;
-{
+long inkdot(incr) int incr; {
long newdot;
newdot = dot + incr;
return(newdot);
}
-printc(c)
- char c;
-{
+int printc(c) int c; {
_printf("%c", c);
}
-psymoff(v, regnumber, fmt)
- long v;
- char *fmt;
-{
+int psymoff(v, regnumber, fmt) long v; int regnumber; char *fmt; {
struct proct *procp;
register int diff;
if (fmt[0] == 'i') {
return(1);
}
-prdiff(diff)
-{
+int prdiff(diff) int diff; {
if (diff) {
_printf("+");
prhex(diff);
}
}
-#endif SDB
+#endif
+#include "../as/instrs.h"
+#include "defs.h"
+#include "mode.h"
+
#ifndef lint
static char optab_sccsid[] = "@(#)optab.c 4.3 10/27/82";
-#endif not lint
+#endif
#ifdef ADB
-#include "defs.h"
-#endif ADB
+/*#include "defs.h"*/
+#endif
#ifdef SDB
-#include "defs.h"
-#endif SDB
+/*#include "defs.h"*/
+#endif
#undef INSTTAB
"r1", _R1,
"r0", _R0,
};
-#endif SDB
+#endif
-#ifndef lint
+#include <gen.h>
+#include <stdio.h>
+#include <sys/file.h>
+/*#include <time.h> gen.h*/
+#ifdef __STDC__
+#include <stdarg.h>
+#define _va_start(argp, arg) va_start(argp, arg)
+#else
+#include <varargs.h>
+#define _va_start(argp, arg) va_start(argp)
+#endif
+#include "defs.h"
+#include "head.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)output.c 4.4 4/26/85";
#endif
/*
*
*/
-#include "defs.h"
-#include <stdio.h>
-#include <varargs.h>
-
+/*#include "defs.h"*/
+/*#include <stdio.h>*/
+/*#include <varargs.h>*/
extern short mkfault;
extern short infile;
char *digitptr;
extern char TOODEEP[];
-
-eqstr(s1, s2)
- register char *s1, *s2;
-{
+int eqstr(s1, s2) register char *s1; register char *s2; {
register char *es1;
while (*s1++ == *s2) {
if (*s2++ == 0) {
return(0);
}
-length(s)
- register char *s;
-{
+int length(s) register char *s; {
short n = 0;
while (*s++) { n++; }
return(n);
}
-printc(c)
- char c;
-{
+int printc(c) int c; {
char d;
char *q;
short posn, tabs, p;
}
}
-charpos()
-{ return(printptr-printbuf);
+int charpos() { return(printptr-printbuf);
}
-flushbuf()
-{ if (printptr!=printbuf) {
+int flushbuf() { if (printptr!=printbuf) {
printc('\n');
}
}
-_printf(fmat,va_alist)
- char *fmat;
- va_dcl
+#ifdef __STDC__
+int _printf(char *fmat, ...)
+#else
+int _printf(fmat, va_alist) char *fmat; va_dcl
+#endif
{
char *fptr, *s;
va_list argp;
long lx;
char digits[64];
- fptr = fmat; va_start(argp);
+ fptr = fmat; _va_start(argp, fmt);
while (c = *fptr++) {
if (c!='%') {
}
}
-printdate(tvec)
- long tvec;
-{
+int printdate(tvec) long tvec; {
register short i;
register char *timeptr;
#ifndef EDDT
for (i=3; i<19; i++) { *digitptr++ = *(timeptr+i); }
} /*printdate*/
-prints(s)
-char *s;
-{ _printf("%s",s);
+int prints(s) char *s; { _printf("%s",s);
}
-newline()
-{
+int newline() {
printc('\n');
}
-convert(cp)
-register char **cp;
-{
+int convert(cp) register char **cp; {
register char c;
short n;
n=0;
return(n);
}
-printnum(n,fmat,base)
- register short n;
-{
+int printnum(n, fmat, base) int n; int fmat; int base; {
register char k;
register short *dptr;
short digs[15];
}
}
-printoct(o,s)
- long o;
- short s;
-{
+int printoct(o, s) long o; int s; {
short i;
long po = o;
char digs[12];
} istack[MAXIFD];
int ifiledepth;
-iclose(stack, err)
-{
+int iclose(stack, err) int stack; int err; {
if (err) {
if (infile) {
close(infile); infile=0;
}
}
-oclose()
-{
+int oclose() {
if (outfile!=1) {
flushbuf(); close(outfile); outfile=1;
}
}
-endline()
-{
+int endline() {
if (maxpos <= charpos())
_printf("\n");
-#ifndef lint
+#include <sys/proc.h>
+#include "defs.h"
+#include "head.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)pcs.c 4.2 8/11/83";
#endif
/*
*
*/
-#include "defs.h"
-
+/*#include "defs.h"*/
extern char NOBKPT[];
extern char SZBKPT[];
long entrypt;
extern short adrflg;
-
-
/* sub process control */
-subpcs(modif)
-{
+int subpcs(modif) int modif; {
register short check;
short execsig,runmode;
register struct bkpt *bkptr;
delbp();
printpc();
}
-
+#include <a.out.h>
+#include <strings.h>
+#include <sys/file.h>
+#include <sys/signal.h>
+/*#include <vax/machparam.h> defs.h*/
+/*#include <vax/pcb.h> defs.h*/
+/*#include <vax/pte.h> sys/file.h*/
+#include "defs.h"
+#include "head.h"
+#include "machine.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)print.c 4.11 5/2/85";
+#endif
/*
*
* UNIX debugger
*
*/
-#include "defs.h"
+/*#include "defs.h"*/
extern char LONGFIL[];
extern char NOTOPEN[];
short signo;
short sigcode;
-
long dot;
long var[];
char *symfil;
/* general printing routines ($) */
-printtrace(modif)
-{
+int printtrace(modif) int modif; {
short narg, i, stat, name, limit;
unsigned dynam;
register struct bkpt *bkptr;
}
-printmap(s,amap)
-char *s; struct map *amap;
-{
+int printmap(s, amap) char *s; struct map *amap; {
int file;
file=amap->ufd;
_printf("%s%12t`%s'\n", s,
printc('\n');
}
-printregs()
-{
+int printregs() {
register struct reglist *p;
long v;
printpc();
}
-getreg(regnam) {
+int getreg(regnam) int regnam; {
register struct reglist *p;
register char *regptr;
char *olp;
return(0);
}
-printpc()
-{
+int printpc() {
dot= *(intptr_t *)(((intptr_t)&u)+_PC);
psymoff(dot,ISYM,":%16t"); printins(0,_ISP,chkget(dot,_ISP));
printc('\n');
"floating undeflow fault"
};
-sigprint()
-{
+int sigprint() {
if ((signo>=0) && (signo<sizeof signals/sizeof signals[0])) { prints(signals[signo]); }
switch (signo) {
-#ifndef lint
+#include <stdio.h>
+/*#include <sys/errno.h> sys/file.h*/
+#include <sys/exec.h>
+#include <sys/file.h>
+#include <sys/proc.h>
+/*#include <sys/ptrace.h> defs.h*/
+/*#include <sys/signal.h> sys/user.h*/
+#include <sys/user.h>
+#include <sys/wait.h>
+#include "defs.h"
+#include "head.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)runpcs.c 4.6 4/25/85";
#endif
/*
*
*/
-#include "defs.h"
+/*#include "defs.h"*/
extern struct map txtmap;
extern short adrflg;
extern long loopcnt;
-
-
-
-
/* service routines for sub process control */
-getsig(sig)
-{ return(expr(0) ? expv : sig);
+int getsig(sig) int sig; { return(expr(0) ? expv : sig);
}
intptr_t userpc = 1;
-runpcs(runmode,execsig)
-{
+int runpcs(runmode, execsig) int runmode; int execsig; {
short rc;
register struct bkpt *bkpt;
if (adrflg) { userpc=dot; }
#define BPIN 1
short bpstate = BPOUT;
-endpcs()
-{
+int endpcs() {
register struct bkpt *bkptr;
if (pid) {
ptrace(PT_KILL,pid,0,0); pid=0; userpc=1;
}
#ifdef VFORK
-nullsig()
-{
+int nullsig() {
}
#endif
-setup()
-{
+int setup() {
close(fsym); fsym = -1;
#ifndef VFORK
if ((pid = fork()) == 0)
#else
if ((pid = vfork()) == 0)
-#endif)
+#endif
{
ptrace(PT_TRACE_ME,0,0,0);
#ifdef VFORK
bpstate=BPOUT;
}
-execbkpt(bkptr,execsig)
-struct bkpt *bkptr;
-{
+int execbkpt(bkptr, execsig) struct bkpt *bkptr; int execsig; {
#ifdef DEBUG
_printf("exbkpt: %d\n",bkptr->count);
#endif
bpwait(); chkerr(); readregs();
}
-
-doexec()
-{
+int doexec() {
char *argl[MAXARG];
char args[LINSIZ];
char *p, **ap, *filnam;
perror(symfil);
}
-struct bkpt *scanbkpt(adr)
-intptr_t adr;
-{
+struct bkpt *scanbkpt(adr) intptr_t adr; {
register struct bkpt *bkptr;
for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt) {
if (bkptr->flag && bkptr->loc==adr) {
return(bkptr);
}
-delbp()
-{
+int delbp() {
register intptr_t a;
register struct bkpt *bkptr;
if (bpstate!=BPOUT) {
#define SETBP(ins) (BPT | ((ins) &~ 0xFF))
#endif
-setbp()
-{
+int setbp() {
register intptr_t a;
register struct bkpt *bkptr;
}
}
-bpwait()
-{
+int bpwait() {
register intptr_t w;
intptr_t stat;
}
}
-readregs()
-{
+int readregs() {
/*get register values from pcs*/
register i;
for (i=24; --i>=0;) {
}
userpc= *(intptr_t *)(((intptr_t)&u)+_PC);
}
-
-
+/*#include <a.out.h> gen.h*/
+/*#include <ctype.h> gen.h*/
+#include <gen.h>
+#include <stdio.h>
+/*#include <sys/exec.h> a.out.h*/
+#include <sys/file.h>
+#include <sys/stat.h>
+/*#include <sys/types.h> gen.h*/
+#include <sys/user.h>
+#include <vax/frame.h>
+/*#include <vax/machparam.h> machine.h*/
+/*#include <vax/pcb.h> sys/user.h*/
+/*#include <vax/pte.h> gen.h*/
+#include <vax/rpb.h>
+#include "head.h"
+#include "machine.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)setup.c 4.10 (Berkeley) 85/05/09";
+#endif
/*
* adb - routines to read a.out+core at startup
*/
-#include "defs.h"
-#include <frame.h>
-#include <ctype.h>
-#include <sys/stat.h>
-#include <sys/file.h>
-#include <vax/rpb.h>
+/*#include "defs.h"*/
+/*#include <frame.h>*/
+/*#include <ctype.h>*/
+/*#include <sys/stat.h>*/
+/*#include <sys/file.h>*/
+/*#include <vax/rpb.h>*/
off_t datbas; /* offset of the base of the data segment */
off_t stksiz; /* stack size in the core image */
char *symfil = "a.out";
char *corfil = "core";
-setsym()
-{
+int setsym() {
off_t loc;
struct exec hdr;
register struct nlist *sp;
exit(1);
}
-setcor()
-{
+int setcor() {
fcor = datmap.ufd = getfile(corfil,2);
if (kernel && fcor != -1 && INKERNEL(filhdr.a_entry)) {
datmap.e2 = MAXSTOR;
}
-getpcb()
-{
+int getpcb() {
lseek(fcor, KVTOPH(masterpcbb), L_SET);
read(fcor, &pcb, sizeof (struct pcb));
caddr_t rpb, scb;
caddr_t intstack, eintstack;
caddr_t ustack, eustack;
-struct frame *getframe();
-struct frame *checkintstack();
+/*struct frame *getframe();*/
+/*struct frame *checkintstack();*/
/*
* Find the current stack frame when debugging the kernel.
* crash, then we must search the interrupt stack carefully
* looking for a valid frame.
*/
-findstackframe()
-{
+int findstackframe() {
char *panicstr, buf[256];
register struct frame *fp;
caddr_t addr;
/*
* Search interrupt stack for a valid frame.
*/
-struct frame *
-checkintstack(fcor)
-{
+struct frame *checkintstack(fcor) int fcor; {
char stack[NISP*NBPG];
off_t off = vtophys(intstack);
struct frame *fp;
* Get a stack frame and verify it looks like
* something which might be on a kernel stack.
*/
-struct frame *
-getframe(fcor, fp)
- int fcor;
- caddr_t fp;
-{
+struct frame *getframe(fcor, fp) int fcor; caddr_t fp; {
static struct frame frame;
off_t off;
* Check a call frame to see if it's ok as
* a kernel stack frame.
*/
-checkframe(fp)
- register struct frame *fp;
-{
+int checkframe(fp) register struct frame *fp; {
if (fp->fr_handler != 0 || fp->fr_s == 0)
return (0);
* interrupt stack, rpb stack (during restart sequence),
* or u. stack.
*/
-kstackaddr(addr)
- caddr_t addr;
-{
+int kstackaddr(addr) caddr_t addr; {
return (within(addr, intstack, eintstack) ||
within(addr, rpb + sizeof (struct rpb), scb) ||
within(addr, ustack, eustack));
}
-create(f)
- char *f;
-{
+int create(f) char *f; {
register int fd;
fd = creat(f, 0644);
return (open(f, wtflag));
}
-getfile(filnam, cnt)
- char *filnam;
-{
+int getfile(filnam, cnt) char *filnam; int cnt; {
register int fsym;
if (eqstr(filnam, "-"))
return (fsym);
}
-setvar()
-{
+int setvar() {
var[varchk('b')] = datbas;
var[varchk('d')] = filhdr.a_data;
+#include <a.out.h>
+#include <stab.h>
+#include <sys/types.h>
+#include "defs.h"
+#include "head.h"
+#include "machine.h"
+#include "mode.h"
+
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)sym.c 4.2 3/24/85";
+#endif
/*
* adb - symbol table routines
*/
-#include "defs.h"
-#include <stab.h>
+/*#include "defs.h"*/
+/*#include <stab.h>*/
/*
* Lookup a symbol by name.
*/
-struct nlist *
-lookup(symstr)
- char *symstr;
-{
+struct nlist *lookup(symstr) char *symstr; {
register struct nlist *sp;
cursym = 0;
* the difference between val and the symbol found.
* Leave a pointer to the symbol found as cursym.
*/
-findsym(val, type)
- long val;
- int type;
-{
+int findsym(val, type) long val; int type; {
long diff;
register struct nlist *sp;
* Leave its value in localval as a side effect.
* Return 0 at end of file.
*/
-localsym(cframe, cargp)
- intptr_t cframe, cargp;
-{
+int localsym(cframe, cargp) intptr_t cframe; intptr_t cargp; {
register int type;
register struct nlist *sp;
* that they match exactly or that they be more than maxoff
* bytes into kernel space.
*/
-psymoff(v, type, s)
- long v;
- int type;
- char *s;
-{
+int psymoff(v, type, s) long v; int type; char *s; {
long w;
if (v)
* interpretation as name+offset. If not, print nothing.
* Used in printing out registers $r.
*/
-valpr(v, idsp)
- long v;
-{
+int valpr(v, idsp) long v; int idsp; {
off_t d;
d = findsym(v, idsp);
+#ifndef ____AS_ASNUMBER_H_
+#define ____AS_ASNUMBER_H_
+
+#include <sys/types.h>
+
/*
* Copyright (c) 1982 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
#define MAXINT_1 ((unsigned)(1<<(CH_BITS - 1)))
#define MAXINT_10 ((unsigned)((MAXINT_1/(unsigned)10)))
#define MAXINT_5 ((unsigned)((MAXINT_1/(unsigned)5)))
-#else not 0
+#else
/*
* These values were computed using dc, so are exact.
* Only MAXINT_10 and MAXINT_5 are used in the programs.
#define MAXINT_1 2147483648
#define MAXINT_10 214748364
#define MAXINT_5 429496729
-#endif not 0
-
-Bignum as_atoi(); /* converts string to integer */
-Bignum as_atof(); /* converts string to float */
-Bignum bigatof(); /* converts string to float */
-Bignum floatconvert(); /* converts amongst float #s */
-Bignum intconvert(); /* converts amongst float #s */
-Bignum bignumconvert(); /* converts amongst float #s */
-Bignum bignumpack(); /* converts UNPACKED bignum to bignum */
-Bignum bignumunpack(); /* converts bignum to UNPACKED bignum */
+#endif
+
+/*Bignum as_atoi();*/ /* converts string to integer */
+/*Bignum as_atof();*/ /* converts string to float */
+/*Bignum bigatof();*/ /* converts string to float */
+/*Bignum floatconvert();*/ /* converts amongst float #s */
+/*Bignum intconvert();*/ /* converts amongst float #s */
+/*Bignum bignumconvert();*/ /* converts amongst float #s */
+/*Bignum bignumpack();*/ /* converts UNPACKED bignum to bignum */
+/*Bignum bignumunpack();*/ /* converts bignum to UNPACKED bignum */
\f
/*
* Definitions for overflows.
#define OVF_OVERFLOW (1<<9) /* overflow in conversion */
#define OVF_UNDERFLOW (1<<10) /* underflow in conversion */
-Ovf posovf();
-Ovf numclear();
-Ovf numshift();
-Ovf numaddv();
-Ovf numaddd();
-Ovf num1comp();
-Ovf numnegate();
+/*Ovf posovf();*/
+/*Ovf numclear();*/
+/*Ovf numshift();*/
+/*Ovf numaddv();*/
+/*Ovf numaddd();*/
+/*Ovf num1comp();*/
+/*Ovf numnegate();*/
\f
/*
* Definitions to unpack big numbers numbers into
#else
#define assert(x, str)
#endif
+
+#endif
+#ifndef ____AS_INSTRS_H_
+#define ____AS_INSTRS_H_
+
+#include <sys/types.h>
+#include <vax/mtpr.h>
+
/*
* Copyright (c) 1982 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
#define OP(name,eopcode,popdcode,nargs,a1,a2,a3,a4,a5,a6) {name,eopcode,popdcode,nargs,a1,a2,a3,a4,a5,a6}
-#endif INSTTAB
+#endif
/*
* Definitions for the escape bytes
#define NEW 1
#define ESCD 0xfd
#define ESCF 0xff
+
+#endif
public / 43bsd.git / commitdiff