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