![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to addr1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / as|
Return to addr1.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / as |
1.1 root 1: /*
2: * static char addr1_ID[] = "@(#) addr1.c: 1.6 12/10/83";
3: */
4:
5: #include <stdio.h>
6: #include <filehdr.h>
7: #include <reloc.h>
8: #include <syms.h>
9: #include <linenum.h>
10: #include "systems.h"
11: #include "gendefs.h"
12: #include "symbols.h"
13: #include "codeout.h"
14:
15: /*
16: *
17: * "addr1.c" is a file containing routines for implementing the
18: * various addressing modes from the intermediate file. The
19: * majority of the routines are passed a pointer to a
20: * character string and a pointer to the code buffer.
21: * The array "modes" is initialized to contain the addresses
22: * of the functions that implement the various addressing modes.
23: * Indexing this array with the addressing mode will give the
24: * correct routine for implementing that mode.
25: *
26: */
27:
28: #define outblock(a,b,c) fwrite((char *)(a),b,1,c)
29:
30: extern char
31: cfile[];
32:
33: extern unsigned short
34: line,
35: cline;
36:
37: extern short
38: type,
39: transvec,
40: sttop;
41:
42: extern int
43: setsym();
44:
45: extern long
46: newdot,
47: symbent,
48: gsymbent;
49:
50: extern long
51: getindx();
52:
53: extern symbol
54: *dot;
55:
56: extern FILHDR
57: filhead;
58:
59: extern upsymins
60: *lookup();
61:
62: extern stent
63: *pop();
64: static stent
65: *popptr;
66:
67: extern FILE
68: #if !ONEPROC
69: *fdstring,
70: #endif
71: *fdline,
72: *fdsymb,
73: *fdgsymb;
74:
75: symbol *savsym;
76:
77: unsigned short
78: lineent;
79:
80: short filedef = NO;
81:
82: #if FLEXNAMES
83: extern char *strtab; /* String table; referenced for symbol */
84: /* name to pass to getindx. */
85: #endif
86:
87: SYMENT sment;
88:
89: AUXENT axent;
90:
91: static short
92: dimcnt;
93:
94: static LINENO
95: lnent;
96:
97: /*ARGSUSED*/
98:
99: setmagic(sym,code)
100: symbol *sym;
101: codebuf *code;
102: {
103: filhead.f_magic = (short)(code->cvalue);
104: }
105:
106: setfile(sym,code)
107: upsymins sym;
108: codebuf *code;
109: {
110: register char c;
111: register char *auxchar;
112: register short index = 0;
113:
114: filedef = YES;
115:
116: sym = *lookup(".file",INSTALL,USRNAME);
117: define(sym.stp,code);
118:
119: sment.n_numaux = 1;
120: auxchar = ((union auxent *)(&axent))->x_file.x_fname;
121: #if ONEPROC
122: while (*auxchar++ = cfile[index++]) ;
123: #else
124: while (((c = getc(fdstring)) != '\n') && (index < FILNMLEN)) {
125: *auxchar++ = c;
126: cfile[index++] = c;
127: }
128: #endif
129: for ( ; index < FILNMLEN; index++)
130: *auxchar++ = '\0';
131:
132: cfile[index] = '\0';
133: code->cvalue = (long)C_FILE;
134: setscl(NULLSYM,code);
135: endef(NULLSYM,code);
136: } /* setfile */
137:
138: /*ARGSUSED*/
139:
140: newstmt(sym,code)
141: symbol *sym;
142: codebuf *code;
143: {
144: line = (unsigned short)(code->cvalue);
145: dot->value = newdot; /* resynchronize */
146: } /* newstmt */
147:
148: /*
149: *
150: * "lineno" is a function that creates a line number entry with
151: * the value of the program counter. A preliminary line number
152: * entry is created by writing to the file whose descriptor
153: * appears in "fdline". The preliminary line number entry contains
154: * the value of the program counter and the line number itself.
155: *
156: */
157:
158: lineno(sym,code)
159: register symbol *sym;
160: register codebuf *code;
161: {
162: if (sym != NULLSYM)
163: code->cvalue += sym->value;
164: lnent.l_lnno = cline = (unsigned short)(code->cvalue);
165: lnent.l_addr.l_paddr = newdot;
166: outblock(&lnent,LINESZ,fdline);
167: lineent++;
168: }
169:
170: /*
171: *
172: * "linenum" and "lineval" work in a pair to implement the two
173: * operand version of the ".ln" pseudo operation. This operation
174: * will generate two intermediate file entries. "linenum"
175: * evaluates the line number and stores it in the global
176: * variable "savline". "lineval" evaluates its argument to
177: * use it as the address for the line number. This address
178: * and the line number from "savline" are written to the file
179: * whose descriptor appears in "fdline" as a completed line
180: * number entry.
181: *
182: */
183:
184: linenum(sym,code)
185: register symbol *sym;
186: register codebuf *code;
187: {
188: if (sym != NULLSYM)
189: code->cvalue += sym->value;
190: lnent.l_lnno = cline = (unsigned short)(code->cvalue);
191: }
192:
193: lineval(sym,code)
194: register symbol *sym;
195: register codebuf *code;
196: {
197: if (sym != NULLSYM)
198: code->cvalue += sym->value;
199: lnent.l_addr.l_paddr = code->cvalue;
200: outblock(&lnent,LINESZ,fdline);
201: lineent++;
202: }
203:
204: /*
205: *
206: * The functions "define", "setval", "settyp", "setscl", "settag",
207: * "setlno", "setsiz", "setdim1" through "setdim5", "xform", and
208: * "endef" are all involved in creating the symbol table entries
209: * that appear in the object file. The call to "define" will
210: * initialize the symbol table entry. The calls to subsequent
211: * functions will store values into various fields of that entry.
212: * The call to "endef" will write out the completed symbol table
213: * entry to an intermediate file. The symbol table entry will be
214: * constructed in a structure called "sment". The auxiliary
215: * symbol table entry (if necessary) will be constructed in the
216: * structure "axent". The completed symbol table entry will be
217: * written either to the file whose descriptor appears in "fdsymb"
218: * or the file whose descriptor appears in "fdgsymb".
219: *
220: */
221:
222: /*
223: *
224: * "define" is a function that performs initialization of a symbol
225: * table entry to be written to the object file.
226: * The arguments to this function is a pointer to the symbol for
227: * which the entry is to be created. The symbol name is stored
228: * into the object file symbol table entry, and the remainder
229: * of the fields for the entry are set to zero.
230: *
231: */
232:
233: /*ARGSUSED*/
234:
235: define(sym,code)
236: register symbol *sym;
237: codebuf *code;
238: {
239: register short index;
240:
241: savsym = sym;
242: #if FLEXNAMES
243: /* Copy the internal symbol table entry for the name to the */
244: /* structure which will be written to the symbol table file. */
245:
246: if (sym->_name.tabentry.zeroes == 0)
247: {
248: sment.n_zeroes = 0L;
249: sment.n_offset = sym->_name.tabentry.offset;
250: }
251: else
252: {
253: #endif
254: for(index = 0; (index < SYMNMLEN) && (sment.n_name[index] = sym->_name.name[index]); index++)
255: ;
256:
257: for(; index < SYMNMLEN; index++)
258: sment.n_name[index] = '\0';
259: #if FLEXNAMES
260: }
261: #endif
262: sment.n_value = 0L;
263: sment.n_scnum = 0;
264: sment.n_type = 0;
265: sment.n_sclass = 0;
266: sment.n_numaux = 0;
267: axent.x_sym.x_tagndx = 0L;
268: axent.x_sym.x_misc.x_lnsz.x_lnno = 0;
269: axent.x_sym.x_misc.x_lnsz.x_size = 0;
270: for(index = 0; index < DIMNUM; ++index)
271: axent.x_sym.x_fcnary.x_ary.x_dimen[index] = 0;
272: axent.x_sym.x_tvndx = 0;
273: #if TRANVEC
274: if (transvec && (sym->styp & TVDEF)) {
275: sment.n_numaux = 1; /* we can do this since transfer */
276: axent.x_sym.x_tvndx = N_TV; /* vectors are always */
277: /* functions in .def's */
278: }
279: #endif
280: }
281:
282: /*
283: *
284: * "setval" is a function that sets the value field of a symbol
285: * table entry. The arguments are evaluated and the result is
286: * stored into the value field of the symbol table entry, and
287: * the section number is set according to the type of the result.
288: *
289: */
290:
291: setval(sym,code)
292: register symbol *sym;
293: register codebuf *code;
294: {
295: register short stype;
296:
297: if (sym != NULLSYM) {
298: code->cvalue += sym->value;
299: stype = sym->styp & TYPE;
300: }
301: else
302: stype = ABS;
303: sment.n_value = code->cvalue;
304: switch (stype){
305: case ABS:{
306: sment.n_scnum = N_ABS;
307: break;
308: }
309: case TXT:{
310: sment.n_scnum = 1;
311: break;
312: }
313: case DAT:{
314: sment.n_scnum = 2;
315: break;
316: }
317: case BSS:{
318: sment.n_scnum = 3;
319: break;
320: }
321: }
322: }
323:
324: /*
325: *
326: * "settyp" is a function that sets the type and derived type
327: * field in a symbol table entry. The arguments are evaluated to
328: * yield the numeric value to be stored into the type and derived
329: * type word. This value is stored into the appropriate field
330: * of "sment".
331: *
332: */
333:
334: settyp(sym,code)
335: register symbol *sym;
336: register codebuf *code;
337: {
338: if (sym != NULLSYM)
339: code->cvalue += sym->value;
340: sment.n_type = (short)(code->cvalue);
341: }
342:
343: /*
344: *
345: * "setscl" is a function that sets the storage class field in a
346: * symbol table entry. The arguments are evaluated to yield a
347: * value to be stored into the appropriate field of "sment".
348: *
349: */
350:
351: setscl(sym,code)
352: register symbol *sym;
353: register codebuf *code;
354: {
355: if (sym != NULLSYM)
356: code->cvalue += sym->value;
357: sment.n_sclass = (char)(code->cvalue);
358: }
359:
360: /*
361: *
362: * "settag" is a function that sets the tag field in an auxiliary
363: * symbol table entry. The argument to this function is the
364: * name of a structure, union, or enumeration tag. This name
365: * is passed to "getindx" to obtain the symbol table index of
366: * the tag entry. If it is found, a field in the symbol table
367: * entry is set indicating the presence of an auxiliary entry
368: * and the tag field of the auxiliary entry is set to the index.
369: * If the tag was not found, "yyerror" is called to print a
370: * diagnostic message.
371: *
372: */
373:
374: /*ARGSUSED*/
375:
376: settag(sym,code)
377: register symbol *sym;
378: codebuf *code;
379: {
380: register long index;
381: char *nameptr; /* We need a pointer to the name string */
382: /* to pass to getindx. */
383:
384: #if FLEXNAMES
385: if (sym->_name.tabentry.zeroes == 0)
386: nameptr = &strtab[sym->_name.tabentry.offset];
387: else
388: #endif
389: nameptr = sym->_name.name;
390: if ( ((index = getindx(nameptr,C_STRTAG)) < 0) &&
391: ((index = getindx(nameptr,C_UNTAG)) < 0) &&
392: ((index = getindx(nameptr,C_ENTAG)) < 0))
393: yyerror("Illegal structure, union, or enumeration tag");
394: sment.n_numaux = 1;
395: axent.x_sym.x_tagndx = index;
396: }
397:
398: /*
399: *
400: * "setlno" sets the line number field in an auxiliary symbol
401: * table entry. A field is set in the symbol table entry to
402: * indicate the presence of an auxiliary entry. The arguments
403: * are evaluated to obtain the value of the line number and
404: * this value is stored into the appropriate field of the
405: * auxiliary symbol table entry.
406: *
407: *
408: */
409:
410: setlno(sym,code)
411: register symbol *sym;
412: register codebuf *code;
413: {
414: sment.n_numaux = 1;
415: if (sym != NULLSYM)
416: code->cvalue += sym->value;
417: axent.x_sym.x_misc.x_lnsz.x_lnno = (unsigned short)(code->cvalue);
418: }
419:
420: /*
421: *
422: * "setsiz" sets the size field in an auxiliary symbol table entry.
423: * The arguments are evaluated to obtain the size of the object
424: * described by this symbol table entry. This value is stored into
425: * the appropriate field of the auxiliary symbol table entry and
426: * a field is set in the basic symbol table entry to indicate the
427: * presence of the auxiliary entry.
428: *
429: */
430:
431: setsiz(sym,code)
432: register symbol *sym;
433: register codebuf *code;
434: {
435: sment.n_numaux = 1;
436: if (sym != NULLSYM)
437: code->cvalue += sym->value;
438: axent.x_sym.x_misc.x_lnsz.x_size = (unsigned short)(code->cvalue);
439: }
440:
441: /* indicate that the function was expanded inline */
442: inline(sym,codeptr)
443: symbol *sym;
444: codebuf *codeptr;
445: {
446: axent.x_sym.x_misc.x_lnsz.x_size |= 0x1;
447: }
448:
449: /*
450: *
451: * "setdim1" and "setdim2" set the fields for array dimensions
452: * one through four in an auxiliary symbol table entry. The
453: * arguments to each function are evaluated to obtain the values
454: * for the array dimensions. The function "setdim1" set a field
455: * in the basic symbol table entry to indicate the presence of
456: * an auxiliary entry. The array dimensions are stored into the
457: * appropriate fields of the auxiliary symbol table entry.
458: *
459: */
460:
461: setdim1(sym,code)
462: register symbol *sym;
463: register codebuf *code;
464: {
465: sment.n_numaux = 1;
466: if (sym != NULLSYM)
467: code->cvalue += sym->value;
468: axent.x_sym.x_fcnary.x_ary.x_dimen[dimcnt=0] = (unsigned short)(code->cvalue);
469: }
470:
471: setdim2(sym,code)
472: register symbol *sym;
473: register codebuf *code;
474: {
475: if (sym != NULLSYM)
476: code->cvalue += sym->value;
477: if (++dimcnt < DIMNUM)
478: axent.x_sym.x_fcnary.x_ary.x_dimen[dimcnt] = (unsigned short)(code->cvalue);
479: else
480: werror("Too many array dimensions for symbolic debug");
481: }
482:
483: /*
484: * "dfaxent" defines an auxillary entry into the symbol table for
485: * the ".text." , ".data" , and ".bss" symbols. It is called from
486: * "symout" in file "obj.c". These auxillary entries allow the
487: * link editor to know the size of each of these sections in the
488: * original source code.
489: *
490: */
491:
492: dfaxent(size,nrel,nlin)
493: long size;
494: unsigned short nrel,
495: nlin;
496: {
497: sment.n_numaux = 1;
498: axent.x_scn.x_scnlen = size;
499: axent.x_scn.x_nreloc = nrel;
500: axent.x_scn.x_nlinno = nlin;
501: }
502:
503: /*
504: *
505: * "xform" is a function called by "endef" that performs any final
506: * transformations necessary on a symbol table entry before it is
507: * written out to a temporary file. The present transformations
508: * are as follows:
509: *
510: * 1. The section number for structure tags, union tags,
511: * enumeration tags, typedefs, and file names is set to
512: * indicate a special symbolic debugging symbol.
513: *
514: * 2. If the symbol table entry is for a function, a zero
515: * line number entry is generated that points to the symbol
516: * table entry. The index of the next entry to be
517: * generated appears in the global variable "symbent".
518: *
519: * 3. If the symbol table entry is for a function, a enu-
520: * meration tag, a union tag, or a structure tag
521: * "setsym" is called to remember the symbol table index
522: * for the associated auxiliary entry.
523: *
524: * 4. If the symbol table entry is for a end block, a
525: * end function, or a end of structure, pop is called
526: * to enter the symbol table index of the next symbol
527: * table entry onto the symbol table element stack.
528: *
529: */
530:
531: xform()
532: {
533:
534: switch (sment.n_sclass) {
535: case C_STRTAG:
536: case C_UNTAG:
537: case C_ENTAG:
538: setsym(-1);
539: /* No Break */
540: case C_TPDEF:
541: case C_FILE:
542: sment.n_scnum = N_DEBUG;
543: break;
544: case C_BLOCK: /* handles ".bb" and ".eb" */
545: if (sment.n_name[1] == 'b')
546: setsym(-1);
547: else
548: pop()->fwdindex = symbent + 1L
549: + sment.n_numaux;
550: break;
551: case C_FCN: /* handles ".bf" and ".ef" */
552: if (sment.n_name[1] == 'e') {
553: popptr = pop();
554: popptr->fwdindex = symbent + 1L
555: + sment.n_numaux;
556: if (sttop > 0)
557: aerror("Unbalanced Symbol Table Entries-Too Many Scope Beginnings");
558: } /* ".ef" */
559: break;
560: case C_EOS:
561: /* get around auxiliary entry */
562: pop()->fwdindex = symbent + 1L + sment.n_numaux;
563: break;
564: default:
565: /* process function entry */
566: if (ISFCN(sment.n_type)) {
567: popptr = NULL;
568: lnent.l_lnno = 0;
569: lnent.l_addr.l_symndx = symbent;
570: outblock(&lnent,LINESZ,fdline);
571: lineent++;
572: sment.n_numaux = 1;
573: setsym(0);
574: }
575: break;
576: } /* switch */
577: } /* xform */
578:
579: /*
580: *
581: * "endef" is a function that completes processing of a symbol
582: * table entry and writes it out to an intermediate file
583: * The arguments to this function are absolutely meaningless.
584: * The function "xform" is called to perform any final
585: * transformations necessary on the entry. A decision is made
586: * as to whether or not the symbol is a global symbol. It is
587: * global if the ".def" for it appears in the data section and
588: * it has a storage class of "C_EXT". If it is global, the
589: * entry will be written to the file whose descriptor appears
590: * in "fdgsymb" and the count "gsymbent" will be incremented.
591: * If it is not global, the entry will be written to the file
592: * whose descriptor appears in "fdsymb" and the count "symbent"
593: * will be incremented.
594: *
595: */
596:
597: /*ARGSUSED*/
598:
599: endef(sym,code)
600: symbol *sym;
601: codebuf *code;
602: {
603: FILE *fd;
604: register long *count;
605:
606: if (sment.n_sclass == (char) C_EFCN) {
607: if (popptr == NULL) {
608: popptr = pop();
609: popptr->fwdindex = symbent;
610: if (sttop > 0)
611: aerror("Unbalanced Symbol Table Entries-Too Many Scope Beginnings");
612: } /* popptr == NULL */
613: popptr->fcnlen = newdot - savsym->value;
614: /* don't put out this symbol table entry */
615: return;
616: } /* sment.n_sclass == C_EFCN */
617: xform();
618: if ((dot->styp == DAT) && (sment.n_sclass == C_EXT)) {
619: fd = fdgsymb;
620: count = &gsymbent;
621: }
622: else
623: {
624: fd = fdsymb;
625: count = &symbent;
626: putindx(savsym,sment.n_sclass,symbent);
627: }
628: outblock(&sment,SYMESZ,fd);
629: (*count)++;
630: if (sment.n_numaux != 0){
631: outblock(&axent,AUXESZ,fd);
632: (*count)++;
633: }
634: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.