![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asjxxx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / bin / as|
Return to asjxxx.c CVS log | Up to [CSRG BSD Unix] / 42BSD / bin / as |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California
3: */
4: #ifndef lint
5: static char sccsid[] = "@(#)asjxxx.c 4.7 6/30/83";
6: #endif not lint
7:
8: #include <stdio.h>
9: #include "as.h"
10: #include "assyms.h"
11:
12: #define JBR 0x11
13: #define BRW 0x31
14: #define JMP 0x17
15:
16: /*
17: * The number of bytes to add if the jxxx must be "exploded"
18: * into the long form
19: */
20: #define JBRDELTA 1 /* brb <byte> ==> brw <byte> <byte> */
21: #define JXXXDELTA 3 /* brb <byte> ==> brb <byte> brw <byte> <byte> */
22: #define JBRJDELTA d124 /* brb <byte> ==> jmp L^(pc) <byte>*d124 */
23: #define JXXXJDELTA d124+2 /* brb <byte> ==> brb <byte> jmp L^(pc) <byte>*d124 */
24:
25: int jbrfsize = JBRDELTA;
26: int jxxxfsize = JXXXDELTA;
27:
28: /*
29: * These variables are filled by asscan.c with the
30: * last name encountered (a pointer buried in the intermediate file),
31: * and the last jxxx symbol table entry encountered.
32: */
33: struct symtab *lastnam;
34: struct symtab *lastjxxx;
35:
36: initijxxx()
37: {
38: jbrfsize = jxxxJUMP ? JBRJDELTA : JBRDELTA;
39: jxxxfsize = jxxxJUMP ? JXXXJDELTA : JXXXDELTA;
40: /*
41: * Note: ifjxxxJUMP is set, then we do NOT do any tunnelling;
42: * this was too complicated to figure out, and in the first
43: * version of the assembler, tunnelling proved to be the hardest
44: * to get to work!
45: */
46: }
47: /*
48: * Handle jxxx instructions
49: */
50: ijxout(opcode, ap, nact)
51: struct Opcode opcode;
52: struct arg *ap;
53: int nact;
54: {
55: if (passno == 1){
56: /*
57: * READ THIS BEFORE LOOKING AT jxxxfix()
58: *
59: * Record the jxxx in a special symbol table entry
60: */
61: register struct symtab *jumpfrom;
62:
63: /*
64: * We assume the MINIMAL length
65: */
66: putins(opcode, ap, nact);
67: jumpfrom = lastjxxx;
68: jumpfrom->s_tag = JXACTIVE;
69: jumpfrom->s_jxbump = 0;
70: if (opcode.Op_popcode == JBR)
71: jumpfrom->s_jxfear = jbrfsize;
72: else
73: jumpfrom->s_jxfear = jxxxfsize;
74: if (lastnam == 0)
75: yyerror("jxxx destination not a label");
76: jumpfrom->s_dest = lastnam;
77: jumpfrom->s_type = dotp->e_xtype; /*only TEXT or DATA*/
78: jumpfrom->s_index = dotp-usedot;
79: /*
80: * value ALWAYS (ALWAYS!!!) indexes the next instruction
81: * after the jump, even in the jump must be exploded
82: * (bumped)
83: */
84: jumpfrom->s_value = dotp->e_xvalue;
85: njxxx++;
86: } else {/* pass2, resolve */
87: /*
88: * READ THIS AFTER LOOKING AT jxxxfix()
89: */
90: reg long oxvalue;
91: reg struct exp *xp;
92: reg struct symtab *tunnel;
93: reg struct arg *aplast;
94: struct Opcode nopcode;
95:
96: aplast = ap + nact - 1;
97: xp = aplast->a_xp;
98: if (lastjxxx->s_tag == JXTUNNEL){
99: lastjxxx->s_tag = JXINACTIVE;
100: tunnel = lastjxxx->s_dest;
101: xp->e_xvalue = tunnel->s_value /*index of instruction following*/
102: - 3 /* size of brw + word*/
103: + ( ( (tunnel->s_jxfear == jbrfsize) &&
104: (tunnel->s_jxbump == 0))?1:0);
105: /*non bumped branch byteis only 2 back*/
106: }
107: if (lastjxxx->s_jxbump == 0){ /*wasn't bumped, so is short form*/
108: putins(opcode, ap, nact);
109: } else {
110: if (opcode.Op_popcode != JBR){
111: /*
112: * branch reverse conditional byte over
113: * branch unconditional word
114: */
115: oxvalue = xp->e_xvalue;
116: xp->e_xvalue = lastjxxx->s_value;
117: nopcode = opcode;
118: nopcode.Op_popcode ^= 1;
119: putins(nopcode, ap, nact);
120: xp->e_xvalue = oxvalue;
121: }
122: nopcode.Op_eopcode = CORE;
123: nopcode.Op_popcode = jxxxJUMP ? JMP : BRW;
124: putins(nopcode, aplast, 1);
125: }
126: }
127: }
128:
129: jalign(xp, sp)
130: register struct exp *xp;
131: register struct symtab *sp;
132: {
133: register int mask;
134: /*
135: * Problem with .align
136: *
137: * When the loader constructs an executable file from
138: * a number of objects, it effectively concatnates
139: * together all of the text segments from all objects,
140: * and then all of the data segments.
141: *
142: * If we do an align by a large value, we can align
143: * within the a.out this assembly produces, but
144: * after the loader concatnates, the alignment can't
145: * be guaranteed if the objects preceding this one
146: * in the load are also aligned to the same size.
147: *
148: * Currently, the loader guarantees full word alignment.
149: * So, ridiculous aligns are caught here and converted
150: * to a .align 2, if possible.
151: */
152: if ( ( (xp->e_xtype & XTYPE) != XABS)
153: || (xp->e_xvalue < 0)
154: || (xp->e_xvalue > 16)
155: ) {
156: yyerror("Illegal `align' argument");
157: return;
158: }
159: if (xp->e_xvalue > 2){
160: if (passno == 1){
161: yywarning(".align %d is NOT preserved by the loader",
162: xp->e_xvalue);
163: yywarning(".align %d converted to .align 2",
164: xp->e_xvalue);
165: }
166: xp->e_xvalue = 2;
167: }
168: flushfield(NBPW/4);
169: if (passno == 1) {
170: sp->s_tag = JXALIGN;
171: sp->s_jxfear = (1 << xp->e_xvalue) - 1;
172: sp->s_type = dotp->e_xtype;
173: sp->s_index = dotp-usedot;
174: /*
175: * We guess that the align will take up at least one
176: * byte in the code output. We will correct for this
177: * initial high guess when we explode (bump) aligns
178: * when we fix the jxxxes. We must do this guess
179: * so that the symbol table is sorted correctly
180: * and labels declared to fall before the align
181: * really get their, instead of guessing zero size
182: * and have the label (incorrectly) fall after the jxxx.
183: * This is a quirk of our requirement that indices into
184: * the code stream point to the next byte following
185: * the logical entry in the symbol table
186: */
187: dotp->e_xvalue += 1;
188: sp->s_value = dotp->e_xvalue;
189: njxxx++;
190: } else {
191: mask = (1 << xp->e_xvalue) - 1;
192: while (dotp->e_xvalue & mask)
193: Outb(0);
194: }
195: }
196:
197: /*
198: * Pass 1.5, resolve jxxx instructions and .align in .text
199: */
200: jxxxfix()
201: {
202: register struct symtab *jumpfrom;
203: struct symtab **cojumpfrom, *ubjumpfrom;
204: register struct symtab *dest;
205: register struct symtab *intdest; /*intermediate dest*/
206: register struct symtab **cointdest, *ubintdest;
207:
208: register struct symtab *tunnel;
209: int displ,nchange;
210: int badjxalign; /*if jump across an align*/
211: int stillactives; /*if still active jxxxes*/
212: int segno; /*current segment number*/
213: int topono; /*which iteration in the topo sort*/
214: register unsigned char tag;
215: /*
216: * consider each segment in turn...
217: */
218: for (segno = 0; segno < NLOC + NLOC; segno++){
219: badjxalign = 0; /*done on a per segment basis*/
220: /*
221: * Do a lazy topological sort.
222: */
223: for (topono = 1, nchange = 1; nchange != 0; topono++){
224: #ifdef lint
225: topno = topno;
226: #endif lint
227: #ifdef DEBUG
228: if (debug)
229: printf("\nSegment %d, topo iteration %d\n",
230: segno, topono);
231: #endif
232: nchange = 0;
233: stillactives = 0;
234: /*
235: * We keep track of one possible tunnel location.
236: * A tunnel will eventually be an unconditional
237: * branch to the same place that another jxxx
238: * will want to branch to. We will turn a
239: * branch conditional/unconditional (word) that would
240: * have to get bumped because its destination is too
241: * far away, into a branch conditional/unconditional
242: * byte to the tunnel branch conditional/unconditional.
243: * Of course, the tunnel must branch to the same place
244: * as we want to go.
245: */
246: tunnel = 0; /*initially, no tunnel*/
247: SEGITERATE(segno, 0, 0, cojumpfrom, jumpfrom, ubjumpfrom, ++){
248: tag = jumpfrom->s_tag;
249: if (tag <= IGNOREBOUND)
250: continue; /*just an ordinary symbol*/
251: if (tag == JXALIGN){
252: tunnel = 0; /*avoid tunneling across a flex alocation*/
253: continue; /*we take care of these later*/
254: }
255: if ( jumpfrom->s_jxfear == jbrfsize /*unconditional*/
256: || ( tag == JXINACTIVE /*inactive bumped*/
257: && (jumpfrom->s_jxbump != 0)
258: )
259: ) tunnel = jumpfrom;
260: if (tag != JXACTIVE)
261: continue;
262: dest = jumpfrom->s_dest;
263: if (jumpfrom->s_index != dest->s_index){
264: yyerror("Intersegment jxxx");
265: continue;
266: }
267: displ = dest->s_value - jumpfrom->s_value;
268: if (displ < MINBYTE || displ > MAXBYTE) {
269: /*
270: * This is an immediate lose!
271: *
272: * We first attempt to tunnel
273: * by finding an intervening jump that
274: * has the same destination.
275: * The tunnel is always the first preceeding
276: * jxxx instruction, so the displacement
277: * to the tunnel is less than zero, and
278: * its relative position will be unaffected
279: * by future jxxx expansions.
280: *
281: * No tunnels if doing jumps...
282: */
283: if ( (!jxxxJUMP)
284: && (jumpfrom->s_jxfear > jbrfsize)
285: && (tunnel)
286: && (tunnel->s_dest == jumpfrom->s_dest)
287: && (tunnel->s_index == jumpfrom->s_index)
288: && (tunnel->s_value - jumpfrom->s_value >=
289: MINBYTE + jxxxfsize)
290: ) {
291: /*
292: * tunnelling is OK
293: */
294: jumpfrom->s_dest = tunnel;
295: /*
296: * no bumping needed, this
297: * is now effectively inactive
298: * but must be remembered
299: */
300: jumpfrom->s_tag = JXTUNNEL;
301: #ifdef DEBUG
302: if(debug)
303: printf("Tunnel from %s from line %d\n",
304: FETCHNAME(jumpfrom),
305: lineno);
306: #endif
307: continue;
308: } else { /*tunneling not possible*/
309: /*
310: * since this will be turned
311: * into a bumped jump, we can
312: * use the unconditional jump
313: * as a tunnel
314: */
315: tunnel = jumpfrom;
316: jumpfrom->s_tag = JXNOTYET;
317: ++nchange;
318: continue;
319: }
320: } /*end of immediate lose*/
321: /*
322: * Do a forward search for an intervening jxxx
323: */
324: if (displ >= 0) {
325: SEGITERATE(segno, cojumpfrom + 1,0,cointdest,
326: intdest, ubintdest, ++){
327: if (intdest->s_value > dest->s_value)
328: break; /* beyond destination */
329: if (intdest->s_tag <= JXQUESTIONABLE)
330: continue; /*frozen solid*/
331: if (intdest->s_tag == JXALIGN){
332: jumpfrom->s_jxoveralign = 1;
333: badjxalign++;
334: }
335: /*
336: * we assume the worst case
337: * for unfrozen jxxxxes
338: */
339: displ += intdest->s_jxfear;
340: }
341: if (displ <= MAXBYTE){
342: /*
343: * the worst possible conditions
344: * can't hurt us, so forget about
345: * this jump
346: */
347: jumpfrom->s_tag = JXINACTIVE;
348: } else {
349: stillactives++;
350: }
351: } else {
352: /*
353: * backward search for intervening jxxx
354: */
355: SEGITERATE(segno, cojumpfrom - 1,1,cointdest,
356: intdest, ubintdest, --){
357: if (intdest->s_value <= dest->s_value)
358: break; /* beyond destination */
359: if (intdest->s_tag <= JXQUESTIONABLE)
360: continue; /*frozen solid*/
361: if (intdest->s_tag == JXALIGN){
362: jumpfrom->s_jxoveralign = 1;
363: badjxalign++;
364: }
365: displ -= intdest->s_jxfear;
366: }
367: if (displ >= MINBYTE) {
368: jumpfrom->s_tag = JXINACTIVE;
369: } else {
370: stillactives++;
371: }
372: } /*end of backwards search*/
373: } /*end of iterating through all symbols in this seg*/
374:
375: if (nchange == 0) {
376: /*
377: * Now, if there are still active jxxx entries,
378: * we are partially deadlocked. We can leave
379: * these jxxx entries in their assumed short jump
380: * form, as all initial displacement calcualtions
381: * are hanging on unresolved jxxx instructions
382: * that might explode into a long form, causing
383: * other jxxxes jumping across the first set of
384: * jxxxes to explode, etc.
385: * However, if a jxxx jumps across a .align,
386: * we assume the worst for the deadlock cycle,
387: * and resolve all of them towards the long
388: * jump.
389: * Currently, the C compiler does not produce
390: * jumps across aligns, as aligns are only used
391: * in data segments, or in text segments to align
392: * functions.
393: */
394: if (stillactives){
395: SEGITERATE(segno, 0, 0, cojumpfrom, jumpfrom,
396: ubjumpfrom, ++){
397: if (jumpfrom->s_tag == JXACTIVE){
398: jumpfrom->s_tag =
399: badjxalign?JXNOTYET:JXINACTIVE;
400: }
401: }
402: if (badjxalign){
403: jxxxbump(segno, (struct symtab **)0);
404: }
405: }
406: /*
407: * Handle all of the .align s
408: */
409: SEGITERATE(segno, 0, 0, cojumpfrom, jumpfrom,
410: ubjumpfrom, ++){
411: if (jumpfrom->s_tag == JXALIGN){
412: /*
413: * Predict the true displacement
414: * needed, irregardless of the
415: * fact that we guessed 1
416: */
417: displ = (jumpfrom->s_value - 1) & (unsigned)jumpfrom->s_jxfear;
418: if (displ == 0){ /*no virtual displacement*/
419: jumpfrom->s_jxfear = -1;
420: } else {
421: jumpfrom->s_jxfear = (jumpfrom->s_jxfear + 1) - displ;
422: /*
423: * assert jumpfrom->s_jxfear > 0
424: */
425: if (jumpfrom->s_jxfear == 1){
426: /*our prediction was correct*/
427: continue;
428: }
429: /*
430: * assert jumpfrom->s_jxfear > 1
431: */
432: jumpfrom->s_jxfear -= 1; /*correct guess*/
433: }
434: /*
435: * assert jumpfrom->s_jxfear = -1, +1...2**n-1
436: */
437: jumpfrom->s_tag = JXNOTYET; /*signal*/
438: jxxxbump(segno, cojumpfrom);
439: jumpfrom->s_tag = JXINACTIVE;
440: /*
441: * Assert jxfrom->jxvalue indexes the first
442: * code byte after the added bytes, and
443: * has n low order zeroes.
444: */
445: }
446: } /*end of walking through each segment*/
447: } /*end of no changes */
448: else { /*changes, and still have to try another pass*/
449: jxxxbump(segno, (struct symtab **)0);
450: }
451: } /*end of doing the topologic sort*/
452: } /*end of iterating through all segments*/
453: } /*end of jxxxfix*/
454:
455: /*
456: * Go through the symbols in a given segment number,
457: * and see which entries are jxxx entries that have
458: * been logically "exploded" (expanded), but for which
459: * the value of textually following symbols has not been
460: * increased
461: */
462:
463: jxxxbump(segno, starthint)
464: int segno;
465: struct symtab **starthint;
466: {
467: register struct symtab **cosp, *sp;
468: register struct symtab *ub;
469: register int cum_bump;
470: register unsigned char tag;
471:
472: cum_bump = 0;
473: SEGITERATE(segno, starthint, 0, cosp, sp, ub, ++){
474: tag = sp->s_tag;
475: if (tag == JXNOTYET){
476: #ifdef DEBUG
477: if (debug){
478: if (sp->s_dest != 0)
479: printf("Explode jump to %s on line %d\n",
480: FETCHNAME(sp->s_dest), lineno);
481: else
482: printf("Explode an align!\n");
483: }
484: #endif
485: sp->s_tag = JXINACTIVE;
486: sp->s_jxbump = 1;
487: cum_bump += sp->s_jxfear;
488: }
489: /*
490: * Only bump labels and jxxxes. Ignored entries can
491: * be incremented, as they are thrown away later on.
492: * Stabds are given their final value in the second
493: * pass.
494: */
495: if (tag >= OKTOBUMP) /*only bump labels and jxxxes and floating stabs*/
496: sp->s_value += cum_bump;
497: }
498: usedot[segno].e_xvalue += cum_bump;
499: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.