![[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] / 43BSDReno / pgrm / as.tahoe|
Return to asjxxx.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe |
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 0x13
14: #define JMP 0x71
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: u_char 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 == 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:
95: aplast = ap + nact - 1;
96: xp = aplast->a_xp;
97: if (lastjxxx->s_tag == JXTUNNEL){
98: lastjxxx->s_tag = JXINACTIVE;
99: tunnel = lastjxxx->s_dest;
100: xp->e_xvalue = tunnel->s_value /*index of instruction following*/
101: - 3 /* size of brw + word*/
102: + ( ( (tunnel->s_jxfear == jbrfsize) &&
103: (tunnel->s_jxbump == 0))?1:0);
104: /*non bumped branch byteis only 2 back*/
105: }
106: if (lastjxxx->s_jxbump == 0){ /*wasn't bumped, so is short form*/
107: putins(opcode, ap, nact);
108: } else {
109: if (opcode != JBR){
110: /*
111: * branch reverse conditional byte over
112: * branch unconditional word
113: */
114: oxvalue = xp->e_xvalue;
115: xp->e_xvalue = lastjxxx->s_value;
116: putins(opcode^0x10, ap, nact);
117: xp->e_xvalue = oxvalue;
118: }
119: putins(jxxxJUMP ? JMP : BRW, aplast, 1);
120: }
121: }
122: }
123:
124: jalign(xp, sp)
125: register struct exp *xp;
126: register struct symtab *sp;
127: {
128: register int mask;
129: /*
130: * Problem with .align
131: *
132: * When the loader constructs an executable file from
133: * a number of objects, it effectively concatnates
134: * together all of the text segments from all objects,
135: * and then all of the data segments.
136: *
137: * If we do an align by a large value, we can align
138: * within the a.out this assembly produces, but
139: * after the loader concatnates, the alignment can't
140: * be guaranteed if the objects preceding this one
141: * in the load are also aligned to the same size.
142: *
143: * Currently, the loader guarantees full word alignment.
144: * So, ridiculous aligns are caught here and converted
145: * to a .align 2, if possible.
146: */
147: if ( ( (xp->e_xtype & XTYPE) != XABS)
148: || (xp->e_xvalue < 0)
149: || (xp->e_xvalue > 16)
150: ) {
151: yyerror("Illegal `align' argument");
152: return;
153: }
154: if (xp->e_xvalue > 2){
155: if (passno == 1){
156: yywarning(".align %d is NOT preserved by the loader",
157: xp->e_xvalue);
158: yywarning(".align %d converted to .align 2",
159: xp->e_xvalue);
160: }
161: xp->e_xvalue = 2;
162: }
163: flushfield(NBPW/4);
164: if (passno == 1) {
165: sp->s_tag = JXALIGN;
166: sp->s_jxfear = (1 << xp->e_xvalue) - 1;
167: sp->s_type = dotp->e_xtype;
168: sp->s_index = dotp-usedot;
169: /*
170: * We guess that the align will take up at least one
171: * byte in the code output. We will correct for this
172: * initial high guess when we explode (bump) aligns
173: * when we fix the jxxxes. We must do this guess
174: * so that the symbol table is sorted correctly
175: * and labels declared to fall before the align
176: * really get their, instead of guessing zero size
177: * and have the label (incorrectly) fall after the jxxx.
178: * This is a quirk of our requirement that indices into
179: * the code stream point to the next byte following
180: * the logical entry in the symbol table
181: */
182: dotp->e_xvalue += 1;
183: sp->s_value = dotp->e_xvalue;
184: njxxx++;
185: } else {
186: mask = (1 << xp->e_xvalue) - 1;
187: while (dotp->e_xvalue & mask)
188: {
189: Outb(0);
190: if (liston)
191: {
192: *layoutpos++ = '0';
193: *layoutpos++ = '0';
194: }
195: }
196: }
197: }
198:
199: djalign(xp, sp)
200: register struct exp *xp;
201: register struct symtab *sp;
202: {
203: register int mask;
204:
205: if ( ( (xp->e_xtype & XTYPE) != XABS)
206: || (xp->e_xvalue < 0)
207: || (xp->e_xvalue > 16)
208: ) {
209: yyerror("Illegal `align' argument");
210: return;
211: }
212: if (xp->e_xvalue > 2){
213: if (passno == 1){
214: yywarning(".align %d is NOT preserved by the loader",
215: xp->e_xvalue);
216: yywarning(".align %d converted to .align 2",
217: xp->e_xvalue);
218: }
219: xp->e_xvalue = 2;
220: }
221: flushfield(NBPW/4);
222: mask = (1 << xp->e_xvalue) - 1;
223: if (passno == 1) {
224: sp->s_tag = JXALIGN;
225: sp->s_jxfear = (1 << xp->e_xvalue) - 1;
226: sp->s_type = dotp->e_xtype;
227: sp->s_index = dotp-usedot;
228: while (dotp->e_xvalue & mask)
229: dotp->e_xvalue ++;
230: sp->s_value = dotp->e_xvalue;
231: njxxx++;
232: } else {
233: while (dotp->e_xvalue & mask)
234: {
235: Outb(0);
236: if (liston)
237: {
238: *layoutpos++ = '0';
239: *layoutpos++ = '0';
240: }
241: }
242: }
243: }
244:
245:
246: /*
247: * Pass 1.5, resolve jxxx instructions and .align in .text
248: */
249: jxxxfix()
250: {
251: register struct symtab *jumpfrom;
252: struct symtab **cojumpfrom, *ubjumpfrom;
253: register struct symtab *dest;
254: register struct symtab *intdest; /*intermediate dest*/
255: register struct symtab **cointdest, *ubintdest;
256:
257: register struct symtab *tunnel;
258: int displ,nchange;
259: int badjxalign; /*if jump across an align*/
260: int stillactives; /*if still active jxxxes*/
261: int segno; /*current segment number*/
262: int topono; /*which iteration in the topo sort*/
263: register unsigned char tag;
264: /*
265: * consider each segment in turn...
266: */
267: for (segno = 0; segno < NLOC + NLOC; segno++){
268: badjxalign = 0; /*done on a per segment basis*/
269: /*
270: * Do a lazy topological sort.
271: */
272: for (topono = 1, nchange = 1; nchange != 0; topono++){
273: #ifdef lint
274: topno = topno;
275: #endif lint
276: #ifdef DEBUG
277: if (debug)
278: printf("\nSegment %d, topo iteration %d\n",
279: segno, topono);
280: #endif
281: nchange = 0;
282: stillactives = 0;
283: /*
284: * We keep track of one possible tunnel location.
285: * A tunnel will eventually be an unconditional
286: * branch to the same place that another jxxx
287: * will want to branch to. We will turn a
288: * branch conditional/unconditional (word) that would
289: * have to get bumped because its destination is too
290: * far away, into a branch conditional/unconditional
291: * byte to the tunnel branch conditional/unconditional.
292: * Of course, the tunnel must branch to the same place
293: * as we want to go.
294: */
295: tunnel = 0; /*initially, no tunnel*/
296: SEGITERATE(segno, 0, 0, cojumpfrom, jumpfrom, ubjumpfrom, ++){
297: tag = jumpfrom->s_tag;
298: if (tag <= IGNOREBOUND)
299: continue; /*just an ordinary symbol*/
300: if (tag == JXALIGN){
301: tunnel = 0; /*avoid tunneling across a flex alocation*/
302: continue; /*we take care of these later*/
303: }
304: if ( jumpfrom->s_jxfear == jbrfsize /*unconditional*/
305: || ( tag == JXINACTIVE /*inactive bumped*/
306: && (jumpfrom->s_jxbump != 0)
307: )
308: ) tunnel = jumpfrom;
309: if (tag != JXACTIVE)
310: continue;
311: dest = jumpfrom->s_dest;
312: if (jumpfrom->s_index != dest->s_index){
313: yyerror("Intersegment jxxx");
314: continue;
315: }
316: displ = dest->s_value - jumpfrom->s_value;
317: if (displ < MINBYTE || displ > MAXBYTE) {
318: /*
319: * This is an immediate lose!
320: *
321: * We first attempt to tunnel
322: * by finding an intervening jump that
323: * has the same destination.
324: * The tunnel is always the first preceeding
325: * jxxx instruction, so the displacement
326: * to the tunnel is less than zero, and
327: * its relative position will be unaffected
328: * by future jxxx expansions.
329: *
330: * No tunnels if doing jumps...
331: */
332: if ( (!jxxxJUMP)
333: && (jumpfrom->s_jxfear > jbrfsize)
334: && (tunnel)
335: && (tunnel->s_dest == jumpfrom->s_dest)
336: && (tunnel->s_index == jumpfrom->s_index)
337: && (tunnel->s_value - jumpfrom->s_value >=
338: MINBYTE + jxxxfsize)
339: ) {
340: /*
341: * tunnelling is OK
342: */
343: jumpfrom->s_dest = tunnel;
344: /*
345: * no bumping needed, this
346: * is now effectively inactive
347: * but must be remembered
348: */
349: jumpfrom->s_tag = JXTUNNEL;
350: #ifdef DEBUG
351: if(debug)
352: printf("Tunnel from %s from line %d\n",
353: FETCHNAME(jumpfrom),
354: lineno);
355: #endif
356: continue;
357: } else { /*tunneling not possible*/
358: /*
359: * since this will be turned
360: * into a bumped jump, we can
361: * use the unconditional jump
362: * as a tunnel
363: */
364: tunnel = jumpfrom;
365: jumpfrom->s_tag = JXNOTYET;
366: ++nchange;
367: continue;
368: }
369: } /*end of immediate lose*/
370: /*
371: * Do a forward search for an intervening jxxx
372: */
373: if (displ >= 0) {
374: SEGITERATE(segno, cojumpfrom + 1,0,cointdest,
375: intdest, ubintdest, ++){
376: if (intdest->s_value > dest->s_value)
377: break; /* beyond destination */
378: if (intdest->s_tag <= JXQUESTIONABLE)
379: continue; /*frozen solid*/
380: if (intdest->s_tag == JXALIGN){
381: jumpfrom->s_jxoveralign = 1;
382: badjxalign++;
383: }
384: /*
385: * we assume the worst case
386: * for unfrozen jxxxxes
387: */
388: displ += intdest->s_jxfear;
389: }
390: if (displ <= MAXBYTE){
391: /*
392: * the worst possible conditions
393: * can't hurt us, so forget about
394: * this jump
395: */
396: jumpfrom->s_tag = JXINACTIVE;
397: } else {
398: stillactives++;
399: }
400: } else {
401: /*
402: * backward search for intervening jxxx
403: */
404: SEGITERATE(segno, cojumpfrom - 1,1,cointdest,
405: intdest, ubintdest, --){
406: if (intdest->s_value <= dest->s_value)
407: break; /* beyond destination */
408: if (intdest->s_tag <= JXQUESTIONABLE)
409: continue; /*frozen solid*/
410: if (intdest->s_tag == JXALIGN){
411: jumpfrom->s_jxoveralign = 1;
412: badjxalign++;
413: }
414: displ -= intdest->s_jxfear;
415: }
416: if (displ >= MINBYTE) {
417: jumpfrom->s_tag = JXINACTIVE;
418: } else {
419: stillactives++;
420: }
421: } /*end of backwards search*/
422: } /*end of iterating through all symbols in this seg*/
423:
424: if (nchange == 0) {
425: /*
426: * Now, if there are still active jxxx entries,
427: * we are partially deadlocked. We can leave
428: * these jxxx entries in their assumed short jump
429: * form, as all initial displacement calcualtions
430: * are hanging on unresolved jxxx instructions
431: * that might explode into a long form, causing
432: * other jxxxes jumping across the first set of
433: * jxxxes to explode, etc.
434: * However, if a jxxx jumps across a .align,
435: * we assume the worst for the deadlock cycle,
436: * and resolve all of them towards the long
437: * jump.
438: * Currently, the C compiler does not produce
439: * jumps across aligns, as aligns are only used
440: * in data segments, or in text segments to align
441: * functions.
442: */
443: if (stillactives){
444: SEGITERATE(segno, 0, 0, cojumpfrom, jumpfrom,
445: ubjumpfrom, ++){
446: if (jumpfrom->s_tag == JXACTIVE){
447: jumpfrom->s_tag =
448: badjxalign?JXNOTYET:JXINACTIVE;
449: }
450: }
451: if (badjxalign){
452: jxxxbump(segno, (struct symtab **)0);
453: }
454: }
455: /*
456: * Handle all of the .align s
457: */
458: SEGITERATE(segno, 0, 0, cojumpfrom, jumpfrom,
459: ubjumpfrom, ++){
460: if (jumpfrom->s_tag == JXALIGN){
461: /*
462: * Predict the true displacement
463: * needed, irregardless of the
464: * fact that we guessed 1
465: */
466: displ = (jumpfrom->s_value - 1) & (unsigned)jumpfrom->s_jxfear;
467: if (displ == 0){ /*no virtual displacement*/
468: jumpfrom->s_jxfear = -1;
469: } else {
470: jumpfrom->s_jxfear = (jumpfrom->s_jxfear + 1) - displ;
471: /*
472: * assert jumpfrom->s_jxfear > 0
473: */
474: if (jumpfrom->s_jxfear == 1){
475: /*our prediction was correct*/
476: continue;
477: }
478: /*
479: * assert jumpfrom->s_jxfear > 1
480: */
481: jumpfrom->s_jxfear -= 1; /*correct guess*/
482: }
483: /*
484: * assert jumpfrom->s_jxfear = -1, +1...2**n-1
485: */
486: jumpfrom->s_tag = JXNOTYET; /*signal*/
487: jxxxbump(segno, cojumpfrom);
488: jumpfrom->s_tag = JXINACTIVE;
489: /*
490: * Assert jxfrom->jxvalue indexes the first
491: * code byte after the added bytes, and
492: * has n low order zeroes.
493: */
494: }
495: } /*end of walking through each segment*/
496: } /*end of no changes */
497: else { /*changes, and still have to try another pass*/
498: jxxxbump(segno, (struct symtab **)0);
499: }
500: } /*end of doing the topologic sort*/
501: } /*end of iterating through all segments*/
502: } /*end of jxxxfix*/
503:
504: /*
505: * Go through the symbols in a given segment number,
506: * and see which entries are jxxx entries that have
507: * been logically "exploded" (expanded), but for which
508: * the value of textually following symbols has not been
509: * increased
510: */
511:
512: jxxxbump(segno, starthint)
513: int segno;
514: struct symtab **starthint;
515: {
516: register struct symtab **cosp, *sp;
517: register struct symtab *ub;
518: register int cum_bump;
519: register unsigned char tag;
520:
521: cum_bump = 0;
522: SEGITERATE(segno, starthint, 0, cosp, sp, ub, ++){
523: tag = sp->s_tag;
524: if (tag == JXNOTYET){
525: #ifdef DEBUG
526: if (debug){
527: if (sp->s_dest != 0)
528: printf("Explode jump to %s on line %d\n",
529: FETCHNAME(sp->s_dest), lineno);
530: else
531: printf("Explode an align!\n");
532: }
533: #endif
534: sp->s_tag = JXINACTIVE;
535: sp->s_jxbump = 1;
536: cum_bump += sp->s_jxfear;
537: }
538: /*
539: * Only bump labels and jxxxes. Ignored entries can
540: * be incremented, as they are thrown away later on.
541: * Stabds are given their final value in the second
542: * pass.
543: */
544: if (tag >= OKTOBUMP) /*only bump labels and jxxxes and floating stabs*/
545: sp->s_value += cum_bump;
546: }
547: usedot[segno].e_xvalue += cum_bump;
548: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.