![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / as|
Return to stab.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / as |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)stab.c 1.1 86/02/03 Copyr 1983 Sun Micro";
3: #endif
4:
5: /*
6: * Copyright (c) 1983 by Sun Microsystems, Inc.
7: */
8:
9: #include "scan.h"
10: #include "as.h"
11:
12: extern struct sym_bkt *sym_hash_tab[];
13: extern long dot; /* current offset in csect (i.e. addr)*/
14:
15:
16: struct stab_sym_bkt *stab_free = NULL;
17: #define STAB_INCR 50
18:
19: #ifdef EBUG
20: # define DEBUG( X ) printf(X)
21: #else
22: # define DEBUG( X )
23: #endif
24:
25: struct stab_sym_bkt *
26: gstab()
27: {
28: /* get a stab symbol bucket -- analogous with gsbkt()/sym.c */
29: register struct stab_sym_bkt *sbp;
30: register int i;
31:
32: if ((sbp = stab_free) != NULL) {
33: stab_free = sbp->next_stab;
34: } else {
35: sbp = (struct stab_sym_bkt *) calloc( STAB_INCR, sizeof(struct stab_sym_bkt));
36: if (sbp == NULL) sys_error("Stab storage exceeded\n", 0);
37: for (i=STAB_INCR-1;i--;) {
38: sbp->next_stab = stab_free;
39: stab_free = sbp++;
40: }
41: }
42: return sbp;
43: }
44:
45: stab_op( ip )
46: struct ins_bkt *ip;
47: {
48: /*
49: allocate a new stab bucket, and process the stabs/d/n
50: arguments which have already been parsed for us.
51: */
52: struct stab_sym_bkt *s;
53: register int opno;
54: opcode_t opcode = ip->op_i;
55:
56: if (pass != 2) return;
57: s = gstab();
58: if (opcode==OP_STABS){
59: /* have a string operand -- parse it a la Ascii(), and save it off */
60: register char *cp;
61: register nchars;
62: char *sp;
63: if (numops != 5 ){
64: PROG_ERROR( E_NUMOPS); return;
65: }
66: if (operands[0].type_o != T_STRING ) {
67: DEBUG("first stabs operand not a string\n");
68: PROG_ERROR( E_OPERAND); return;
69: }
70: nchars = 0;
71: cp = operands[0].stringval_o;
72: while (*cp++)++nchars;
73: cp = operands[0].stringval_o;
74: s->ch = sp = (char *) calloc( nchars +1, sizeof(char));
75: if (sp==NULL) sys_error( "Out of string space\n", 0);
76: /* nchars is only an approximate character count -- recount for real */
77: nchars = 0;
78: while (*cp){
79: nchars++;
80: if ((*sp = *cp++)!= '\\'){
81: sp++;
82: }
83: else switch (*cp) {
84: int i;
85: int c;
86: /* bet none of this is ever executed */
87: case '\\':
88: case '"':
89: *sp++ = *cp++;
90: break;
91: default:
92: /* \ octal */
93: for(i=0,c=0; i<3; i++) {
94: if((*cp >= '0') && (*cp <= '7'))
95: c = (c<<3) + *cp-- - '0';
96: else
97: break;
98: }
99: *sp++ = c;
100: }
101: }
102: s->id = nchars;
103: opno = 1;
104: } else if ( opcode == OP_STABD ) {
105: if (numops != 3 ) {
106: DEBUG("stabd has the wrong number of operands\n");
107: PROG_ERROR(E_NUMOPS);
108: return;
109: }
110: opno = 0;
111: s->id = 0;
112: } else { /* opcode == OP_STABN */
113: if (numops != 4 ) {
114: DEBUG("stabn has the wrong number of operands\n");
115: PROG_ERROR(E_NUMOPS);
116: return;
117: }
118: opno = 0;
119: s->id = 0;
120: }
121: /* stuff the next three numbers without too much thought */
122: if (operands[opno].sym_o != NULL || operands[opno].type_o != T_NORMAL){
123: DEBUG("stab first numeric operand bad\n");
124: PROG_ERROR( E_OPERAND); return;
125: }
126: s->type = operands[opno++].value_o;
127: if (operands[opno].sym_o != NULL || operands[opno].type_o != T_NORMAL){
128: DEBUG("stab second numeric operand bad\n");
129: PROG_ERROR( E_OPERAND); return;
130: }
131: s->other = operands[opno++].value_o;
132: if (operands[opno].sym_o != NULL || operands[opno].type_o != T_NORMAL){
133: DEBUG("stab third numeric operand bad\n");
134: PROG_ERROR( E_OPERAND); return;
135: }
136: s->desc = operands[opno++].value_o;
137:
138: if (opcode == OP_STABD) {
139: /* value is dot */
140: s->value = dot;
141: } else {
142: /* value is either a label or its a number */
143: if (operands[opno].type_o != T_NORMAL){
144: DEBUG("stab last operand isn't `normal'\n");
145: PROG_ERROR(E_OPERAND); return;
146: }
147: switch (s->type) {
148: case N_FUN:
1.1.1.2 ! root 149: case N_EFUN:
1.1 root 150: case N_STSYM:
151: case N_LCSYM:
152: case N_SLINE:
153: case N_SO:
1.1.1.2 ! root 154: case N_ESO:
1.1 root 155: case N_SOL:
156: case N_ENTRY:
157: case N_LBRAC:
158: case N_RBRAC:
159: case N_ECOML:
160: /* it a label */
161: if (!operands[opno].sym_o) {
162: DEBUG("stab last operand isn't a label\n");
163: PROG_ERROR(E_OPERAND); return;
164: }
165: break;
166: default:
167: /* its a number */
168: if ( operands[opno].sym_o) {
169: DEBUG("stab last operand isn't just a number\n");
170: PROG_ERROR(E_OPERAND); return;
171: }
172: break;
173: }
174: s->value = operands[opno].value_o;
175: }
176: link_stab_tab( s );
177: }
178: /* ************************************************************************* */
179:
180: /* Link the incoming stab bucket to the stab symbol table. */
181: /* The addition of the incoming stab is linked to the end of the */
182: /* current linked list. */
183:
184:
185: link_stab_tab(s)
186: struct stab_sym_bkt *s;
187:
188:
189: { if (stabkt_head == NULL) /* if no entry on linked list */
190: { stabkt_head = s; /* let both head and tail */
191: stabkt_tail = s; /* pointing to this entry s */
192: stabkt_head->next_stab = NULL; /* and make the next one null */
193: }
194: else { stabkt_tail->next_stab = s; /* otherwise make this entry */
195: stabkt_tail = stabkt_tail->next_stab; /* the next entry and move */
196: stabkt_tail->next_stab = NULL; /* tail pointing to this one */
197: }
198: } /* end Link_Stab_Tab */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.