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