![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pseudoop.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / c2|
Return to pseudoop.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)pseudoop.c 1.1 86/02/03 Copyr 1985 Sun Micro";
3: #endif
4:
5: /*
6: * Copyright (c) 1985 by Sun Microsystems, Inc.
7: */
8:
9: #include "as.h"
10: #include "c2.h"
11:
12: /* Csect descriptor */
13: struct csect {
14: char *name_cs; /* print name */
15: long len_cs; /* Length in machine addresses, */
16: /* i.e., highest address referenced */
17: long dot_cs; /* current dot in this cs, in machine addresses */
18: short id_cs; /* UNIX a.out name for this csect */
19: short which_cs; /* our name for this csect (see below) */
20: };
21:
22: /* table used to determine node type. */
23: /*
24: * we would really like this table to be subscripted by the enumerated type
25: * opcode_t, but C cannot hack that. Order here is VERY IMPORTANT,
26: * and this table must change if the opcode order or number changes!!
27: */
28: char opcodetypes[] = {
29: 0, /* FIRST */
30: PSEUDONOCODE, /* COMMENT */
31: 0, /* LABEL */
32: PSEUDOCODE, /* LONG */
33: PSEUDOCODE, /* WORD */
34: PSEUDOCODE, /* BYTE */
35: PSEUDONOCODE, /* TEXT */
36: PSEUDONOCODE, /* DATA */
37: PSEUDONOCODE, /* DATA1 */
38: PSEUDONOCODE, /* DATA2 */
39: PSEUDONOCODE, /* BSS */
40: PSEUDONOCODE, /* GLOBL */
41: PSEUDONOCODE, /* COMM */
42: PSEUDOCODE, /* EVEN */
43: PSEUDOCODE, /* ALIGN */
44: PSEUDOCODE, /* ASCIZ */
45: PSEUDOCODE, /* ASCII */
46: PSEUDOCODE, /* SINGLE */
47: PSEUDOCODE, /* DOUBLE */
48: PSEUDONOCODE, /* STABS */
49: PSEUDONOCODE, /* STABD */
50: PSEUDONOCODE, /* STABN */
51: PSEUDOCODE, /* SKIP */
52: PSEUDONOCODE, /* LCOMM */
53: PSEUDONOCODE, /* CPID */
54: INSTRTYPE|BRANCHTYPE, /* CSWITCH */
55: INSTRTYPE|BRANCHTYPE, /* FSWITCH */
56: INSTRTYPE|BRANCHTYPE, /* BRANCH */
57: INSTRTYPE, /* MOVE */
58: INSTRTYPE, /* MOVEM */
59: INSTRTYPE|BRANCHTYPE, /* EXIT */
60: INSTRTYPE|BRANCHTYPE, /* DBRA */
61: INSTRTYPE, /* CALL */
62: INSTRTYPE|BRANCHTYPE|JUMPTYPE, /* JUMP */
63: INSTRTYPE|BRANCHTYPE|JUMPTYPE, /* DJMP */
64: INSTRTYPE, /* LINK */
65: INSTRTYPE, /* CMP */
66: INSTRTYPE, /* PEA */
67: INSTRTYPE, /* ADD */
68: INSTRTYPE, /* AND */
69: INSTRTYPE, /* EXT */
70: INSTRTYPE, /* OR */
71: INSTRTYPE, /* TST */
72: INSTRTYPE, /* ASL */
73: INSTRTYPE, /* ASR */
74: INSTRTYPE, /* SUB */
75: INSTRTYPE, /* UNLK */
76: INSTRTYPE, /* LEA */
77: INSTRTYPE, /* CLR */
78: INSTRTYPE, /* BOP */
79: INSTRTYPE, /* EOR */
80: INSTRTYPE, /* FTST */
81: INSTRTYPE, /* OTHER */
82: };
83: extern struct sym_bkt *dot_bkt;
84:
85: struct csect csects[] = {
86: ".text", 0,0,0,C_TEXT, /* text csect */
87: ".data", 0,0,0,C_DATA, /* data csect */
88: ".data1",0,0,0,C_DATA1, /* data csect */
89: ".data2",0,0,0,C_DATA2, /* data csect */
90: ".bss", 0,0,0, C_BSS, /* uninitialized csect */
91: 0
92: } ;
93:
94: struct csect *cur_csect = &(csects[0]);/* ptr to current csect */
95: struct csect *all_csects[] = { 0 ,
96: &(csects[0]), &(csects[1]), &(csects[2]), &(csects[3]), &(csects[4])
97: };
98:
99: short cur_csect_name = C_TEXT;
100:
101: void
102: init_csects(){
103: register struct sym_bkt *sbp;
104: struct csect *csp;
105: for (csp = csects; csp->name_cs != NULL; csp++){
106: sbp = lookup(csp->name_cs);
107: sbp->attr_s |= S_DEC | S_DEF | S_LOCAL;
108: sbp->csect_s = csp->which_cs;
109: sbp->value_s = 0;
110: }
111: }
112:
113: void
114: new_csect()
115: {
116: extern struct csect *cur_csect; /* ptr to current csect */
117: extern struct sym_bkt *dot_bkt; /* sym_bkt for location counter */
118:
119: cur_csect = all_csects[cur_csect_name];
120: dot = cur_csect->dot_cs;
121: dot_bkt->csect_s = cur_csect_name;/* update dot's csect. dot_bkt->value_s */
122: /* will be updated in the main loop */
123: }
124:
125: int
126: ascii(csectname)
127: { register char *p;
128: int count;
129: extern char *malloc();
130:
131: if (numops!=1 || operands[0].type_o!=T_STRING)
132: { PROG_ERROR(E_OPERAND); return 0; }
133: if (csectname == C_TEXT){
134: count = strlen(operands[0].stringval_o);
135: p = malloc( count+1);
136: strcpy( p, operands[0].stringval_o);
137: operands[0].stringval_o = p;
138: } else
139: p = operands[0].stringval_o;
140: /* scan out the string, so we can figure how much space it will take */
141: count = 0;
142: while (*p) {
143: count++;
144: if ( *p++ == '\\' )
145: switch ( *p ){
146: case '\\':
147: case '"':
148: p++;
149: break;
150: default:
151: {
152: register i;
153: /* \octal number. Max of 3 octal digits */
154:
155: for(i=0;i<3;i++,p++) {
156: if (!((*p >= '0') && (*p <= '7')))
157: break;
158: }
159: }
160: }
161: }
162: return count;
163: }
164:
165: int
166: pseudo_size( ip )
167: struct ins_bkt *ip;
168: {
169: int val, delta;
170: switch( ip->op_i ){
171: case OP_LONG:
172: return numops*sizeof(long);
173: case OP_WORD:
174: return numops*sizeof(short);
175: case OP_BYTE:
176: return numops*sizeof(char);
177: case OP_SKIP:
178: return operands[0].value_o;
179: case OP_EVEN:
180: return dot&1;
181: case OP_ALIGN:
182: val = operands[0].value_o;
183: delta = val - (dot%val);
184: if (delta == val) delta = 0;
185: return delta;
186: }
187: return 0;
188: }
189:
190: int
191: pseudo_code( op ) opcode_t op;
192: {
193: /*
194: * 1 => can generate code
195: * 0 => cannot generate code
196: * -1 => not a pseudo-op
197: */
198: if (opcodetypes[(int)op]&PSEUDONOCODE) return 0;
199: if (opcodetypes[(int)op]&PSEUDOCODE ) return 1;
200: return -1;
201: }
202:
203: void
204: save_stabs(csectname)
205: {
206: char *p;
207: /* IF IN TEXT, save stabs string */
208: if (csectname != C_TEXT) return;
209: /* like ascii above */
210: p = malloc( 1 + strlen(operands[0].stringval_o));
211: strcpy( p, operands[0].stringval_o);
212: operands[0].stringval_o = p;
213: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.