4 * (C) Copyright 1989-1995
12 * - outsym: show s_id as string rather than array [NCPS]
13 * - Added outr11 to support 8051's 11 bit destination address
19 #if !defined(_MSC_VER)
27 * The module asout.c contains all the functions used to
28 * generate the .REL assembler output file.
31 * The assemblers' output object file is an ascii file containing
32 * the information needed by the linker to bind multiple object
33 * modules into a complete loadable memory image.
35 * The object module contains the following designators:
42 * H Most significant byte first
43 * L Least significant byte first
50 * R Relocation information
51 * P Paging information
56 * The first line of an object module contains the [XDQ][HL]
57 * format specifier (i.e. XH indicates a hexadecimal file with
58 * most significant byte first) for the following designators.
63 * H aa areas gg global symbols
65 * The header line specifies the number of areas(aa) and the
66 * number of global symbols(gg) defined or referenced in this ob-
67 * ject module segment.
74 * The module line specifies the module name from which this
75 * header segment was assembled. The module line will not appear
76 * if the .module directive was not used in the source program.
87 * The symbol line defines (Def) or references (Ref) the symbol
88 * 'string' with the value nnnn. The defined value is relative to
89 * the current area base address. References to constants and ex-
90 * ternal global symbols will always appear before the first area
91 * definition. References to external symbols will have a value of
97 * A label size ss flags ff
99 * The area line defines the area label, the size (ss) of the
100 * area in bytes, and the area flags (ff). The area flags specify
101 * the ABS, REL, CON, OVR, and PAG parameters:
103 * OVR/CON (0x04/0x00 i.e. bit position 2)
105 * ABS/REL (0x08/0x00 i.e. bit position 3)
107 * PAG (0x10 i.e. bit position 4)
112 * T xx xx nn nn nn nn nn ...
114 * The T line contains the assembled code output by the assem-
115 * bler with xx xx being the offset address from the current area
116 * base address and nn being the assembled instructions and data in
122 * R 0 0 nn nn n1 n2 xx xx ...
124 * The R line provides the relocation information to the linker.
125 * The nn nn value is the current area index, i.e. which area the
126 * current values were assembled. Relocation information is en-
127 * coded in groups of 4 bytes:
129 * 1. n1 is the relocation mode and object format
130 * 1. bit 0 word(0x00)/byte(0x01)
131 * 2. bit 1 relocatable area(0x00)/symbol(0x02)
132 * 3. bit 2 normal(0x00)/PC relative(0x04) relocation
133 * 4. bit 3 1-byte(0x00)/2-byte(0x08) object format for
135 * 5. bit 4 signed(0x00)/unsigned(0x10) byte data
136 * 6. bit 5 normal(0x00)/page '0'(0x20) reference
137 * 7. bit 6 normal(0x00)/page 'nnn'(0x40) reference
138 * 8. bit 7 normal(0x00)/MSB of value
140 * 2. n2 is a byte index into the corresponding (i.e. pre-
141 * ceeding) T line data (i.e. a pointer to the data to be
142 * updated by the relocation). The T line data may be
143 * 1-byte or 2-byte byte data format or 2-byte word
146 * 3. xx xx is the area/symbol index for the area/symbol be-
147 * ing referenced. the corresponding area/symbol is found
148 * in the header area/symbol lists.
151 * The groups of 4 bytes are repeated for each item requiring relo-
152 * cation in the preceeding T line.
157 * P 0 0 nn nn n1 n2 xx xx
159 * The P line provides the paging information to the linker as
160 * specified by a .setdp directive. The format of the relocation
161 * information is identical to that of the R line. The correspond-
162 * ing T line has the following information:
163 * T xx xx aa aa bb bb
165 * Where aa aa is the area reference number which specifies the
166 * selected page area and bb bb is the base address of the page.
167 * bb bb will require relocation processing if the 'n1 n2 xx xx' is
168 * specified in the P line. The linker will verify that the base
169 * address is on a 256 byte boundary and that the page length of an
170 * area defined with the PAG type is not larger than 256 bytes.
172 * The linker defaults any direct page references to the first
173 * area defined in the input REL file. All ASxxxx assemblers will
174 * specify the _CODE area first, making this the default page area.
177 * asout.c contains the following functions:
198 * The module asout.c contains the following local variables:
199 * int rel[] relocation data for code/data array
200 * int * relp pointer to rel array
201 * int txt[] assembled code/data array
202 * int * txtp pointer to txt array
211 char *txtp = { &txt[0] };
212 char *relp = { &rel[0] };
214 /*)Function VOID outab(b)
216 * int b assembler data word
218 * The function outab() processes a single word of
219 * assembled data in absolute format.
222 * int * txtp pointer to data word
225 * int oflag -o, generate relocatable output flag
226 * int pass assembler pass number
229 * VOID outchk() asout.c
230 * VOID out_lb() asout.c
233 * The current assembly address is incremented by 1.
249 /*)Function VOID outaw(w)
251 * int w assembler data word
253 * The function outaw() processes a single word of
254 * assembled data in absolute format.
257 * int * txtp pointer to data word
260 * int oflag -o, generate relocatable output flag
261 * int pass assembler pass number
264 * VOID outchk() asout.c
265 * VOID out_lw() asout.c
268 * The current assembly address is incremented by 2.
284 /*)Function VOID write_rmode(r)
286 * int r relocation mode
288 * write_rmode puts the passed relocation mode into the
289 * output relp buffer, escaping it if necessary.
292 * int * relp pointer to rel array
295 * VOID rerr() assubr.c
298 * relp is incremented appropriately.
303 /* We need to escape the relocation mode if it is greater
304 * than a byte, or if it happens to look like an escape.
305 * (I don't think that the latter case is legal, but
306 * better safe than sorry).
308 if ((r > 0xff) || ((r & R_ESCAPE_MASK) == R_ESCAPE_MASK))
310 /* Hack in up to an extra 4 bits of flags with escape. */
313 /* uh-oh.. we have more than 4 extra bits. */
315 "Internal error: relocation mode 0x%X too big.\n",
319 /* printf("escaping relocation mode\n"); */
320 *relp++ = R_ESCAPE_MASK | (r >> 8);
329 /*)Function VOID outrb(esp, r)
331 * expr * esp pointer to expr structure
332 * int r relocation mode
334 * The function outrb() processes a byte of generated code
335 * in either absolute or relocatable format dependent upon
336 * the data contained in the expr structure esp. If the
337 * .REL output is enabled then the appropriate information
338 * is loaded into the txt and rel buffers.
341 * int n symbol/area reference number
342 * int * relp pointer to rel array
343 * int * txtp pointer to txt array
346 * sym dot defined as sym[0]
347 * int oflag -o, generate relocatable output flag
348 * int pass assembler pass number
351 * VOID aerr() assubr.c
352 * VOID outchk() asout.c
353 * VOID out_lb() asout.c
354 * VOID out_rb() asout.c
355 * VOID out_tb() asout.c
358 * The current assembly address is incremented by 1.
362 outrb(struct expr *esp, int r)
367 if (esp->e_flag==0 && esp->e_base.e_ap==NULL) {
368 /* This is a constant; simply write the
369 * const byte to the T line and don't
370 * generate any relocation info.
372 out_lb(lobyte(esp->e_addr),0);
375 *txtp++ = lobyte(esp->e_addr);
378 /* We are generating a single byte of relocatable
381 * In 8051 mode, we generate a 16 bit address. The
382 * linker will later select a single byte based on
383 * whether R_MSB is set.
385 * In flat24 mode, we generate a 24 bit address. The
386 * linker will select a single byte based on
387 * whether R_MSB or R_HIB is set.
391 r |= R_BYTE | R_BYT2 | esp->e_rlcf;
393 out_lb(hibyte(esp->e_addr),r|R_RELOC|R_HIGH);
395 out_lb(lobyte(esp->e_addr),r|R_RELOC);
401 n = esp->e_base.e_sp->s_ref;
404 n = esp->e_base.e_ap->a_ref;
407 *relp++ = txtp - txt - 2;
414 r |= R_BYTE | R_BYT3 | esp->e_rlcf;
417 /* Probably should mark this differently in the
420 out_lb(byte3(esp->e_addr),r|R_RELOC|R_HIGH);
422 else if (r & R_MSB) {
423 out_lb(hibyte(esp->e_addr),r|R_RELOC|R_HIGH);
425 out_lb(lobyte(esp->e_addr),r|R_RELOC);
429 out_t24(esp->e_addr);
431 n = esp->e_base.e_sp->s_ref;
434 n = esp->e_base.e_ap->a_ref;
437 *relp++ = txtp - txt - 3;
446 /*)Function VOID outrw(esp, r)
448 * expr * esp pointer to expr structure
449 * int r relocation mode
451 * The function outrw() processes a word of generated code
452 * in either absolute or relocatable format dependent upon
453 * the data contained in the expr structure esp. If the
454 * .REL output is enabled then the appropriate information
455 * is loaded into the txt and rel buffers.
458 * int n symbol/area reference number
459 * int * relp pointer to rel array
460 * int * txtp pointer to txt array
463 * sym dot defined as sym[0]
464 * int oflag -o, generate relocatable output flag
465 * int pass assembler pass number
468 * VOID aerr() assubr.c
469 * VOID outchk() asout.c
470 * VOID out_lw() asout.c
471 * VOID out_rw() asout.c
472 * VOID out_tw() asout.c
475 * The current assembly address is incremented by 2.
479 outrw(struct expr *esp, int r)
485 if (esp->e_addr > 0xffff)
489 "large constant 0x%x truncated to 16 bits\n",
492 if (esp->e_flag==0 && esp->e_base.e_ap==NULL) {
493 out_lw(esp->e_addr,0);
499 r |= R_WORD | esp->e_rlcf;
503 out_lw(hibyte(esp->e_addr),r|R_RELOC);
505 out_lw(lobyte(esp->e_addr),r|R_RELOC);
508 out_lw(esp->e_addr,r|R_RELOC);
514 n = esp->e_base.e_sp->s_ref;
517 n = esp->e_base.e_ap->a_ref;
522 /* If this happens, the linker will
523 * attempt to process this 16 bit field
524 * as 24 bits. That would be bad.
527 "***Internal error: C24 out in "
532 *relp++ = txtp - txt - 2;
540 /*)Function VOID outr24(esp, r)
542 * expr * esp pointer to expr structure
543 * int r relocation mode
545 * The function outr24() processes 24 bits of generated code
546 * in either absolute or relocatable format dependent upon
547 * the data contained in the expr structure esp. If the
548 * .REL output is enabled then the appropriate information
549 * is loaded into the txt and rel buffers.
552 * int n symbol/area reference number
553 * int * relp pointer to rel array
554 * int * txtp pointer to txt array
557 * sym dot defined as sym[0]
558 * int oflag -o, generate relocatable output flag
559 * int pass assembler pass number
562 * VOID aerr() assubr.c
563 * VOID outchk() asout.c
564 * VOID out_l24() asout.c
565 * VOID out_rw() asout.c
566 * VOID out_t24() asout.c
569 * The current assembly address is incremented by 3.
573 outr24(struct expr *esp, int r)
578 if (esp->e_flag==0 && esp->e_base.e_ap==NULL) {
579 /* This is a constant expression. */
580 out_l24(esp->e_addr,0);
583 out_t24(esp->e_addr);
586 /* This is a symbol. */
587 r |= R_WORD | esp->e_rlcf;
589 /* I have no idea what this case is. */
592 out_lw(hibyte(esp->e_addr),r|R_RELOC);
594 out_lw(lobyte(esp->e_addr),r|R_RELOC);
597 out_l24(esp->e_addr,r|R_RELOC);
601 out_t24(esp->e_addr);
603 n = esp->e_base.e_sp->s_ref;
606 n = esp->e_base.e_ap->a_ref;
611 /* If this occurs, we cannot properly
612 * code the relocation data with the
613 * R_C24 flag. This means the linker
614 * will fail to do the 24 bit relocation.
618 "***Internal error: BYTE out in 24 "
619 "bit flat mode unexpected.\n");
623 write_rmode(r | R_C24);
624 *relp++ = txtp - txt - 3;
632 /*)Function VOID outdp(carea, esp)
634 * area * carea pointer to current area strcuture
635 * expr * esp pointer to expr structure
637 * The function outdp() flushes the output buffer and
638 * outputs paging information to the .REL file.
641 * int n symbol/area reference number
642 * int r relocation mode
643 * int * relp pointer to rel array
644 * int * txtp pointer to txt array
647 * int oflag -o, generate relocatable output flag
648 * int pass assembler pass number
651 * VOID outbuf() asout.c
652 * VOID outchk() asout.c
653 * VOID out_rw() asout.c
654 * VOID out_tw() asout.c
657 * Output buffer flushed to .REL fiel.
658 * Paging information dumped to .REL file.
663 register struct area *carea;
664 register struct expr *esp;
668 if (oflag && pass==2) {
670 out_tw(carea->a_ref);
672 if (esp->e_flag || esp->e_base.e_ap!=NULL) {
675 n = esp->e_base.e_sp->s_ref;
678 n = esp->e_base.e_ap->a_ref;
681 *relp++ = txtp - txt - 2;
688 /*)Function VOID outall()
690 * The function outall() will output any bufferred assembled
691 * data and relocation information (during pass 2 if the .REL
692 * output has been enabled).
698 * int oflag -o, generate relocatable output flag
699 * int pass assembler pass number
702 * VOID outbuf() asout.c
705 * assembled data and relocation buffers will be cleared.
711 if (oflag && pass==2)
715 /*)Function VOID outdot()
717 * The function outdot() outputs information about the
718 * current program counter value (during pass 2 if the .REL
719 * output has been enabled).
725 * int oflag -o, generate relocatable output flag
726 * int pass assembler pass number
729 * int fprintf() c_library
733 * assembled data and relocation buffers will be cleared.
739 if (oflag && pass==2) {
741 out(txt,(int) (txtp-txt));
744 out(rel,(int) (relp-rel));
751 /*)Function outchk(nt, nr)
753 * int nr number of additional relocation words
754 * int nt number of additional data words
756 * The function outchk() checks the data and relocation buffers
757 * for space to insert the nt data words and nr relocation words.
758 * If space is not available then output the current data and
759 * initialize the data buffers to receive the new data.
762 * area * ap pointer to an area structure
763 * int * relp pointer to rel array
764 * int * txtp pointer to txt array
767 * sym dot defined as sym[0]
770 * VOID outbuf() asout.c
773 * Data and relocation buffers may be emptied and initialized.
779 register struct area *ap;
781 if (txtp+nt > &txt[NTXT] || relp+nr > &rel[NREL]) {
786 if ((ap = dot.s_area) != NULL) {
787 write_rmode(R_WORD|R_AREA);
794 /*)Function VOID outbuf()
796 * The function outbuf() will output any bufferred data
797 * and relocation information to the .REL file. The output
798 * buffer pointers and counters are initialized.
801 * int rel[] relocation data for code/data array
802 * int * relp pointer to rel array
803 * int txt[] assembled code/data array
804 * int * txtp pointer to txt array
807 * FILE * ofp relocation output file handle
813 * All bufferred data written to .REL file and
814 * buffer pointers and counters initialized.
821 if (txtp > &txt[2]) {
823 out(txt,(int) (txtp-txt));
825 fprintf(ofp, "%s", s);
826 out(rel,(int) (relp-rel));
833 /*)Function VOID outgsd()
835 * The function outgsd() performs the following:
836 * (1) outputs the .REL file radix
837 * (2) outputs the header specifying the number
838 * of areas and global symbols
839 * (3) outputs the module name
840 * (4) set the reference number and output a symbol line
841 * for all external global variables and absolutes
842 * (5) output an area name, set reference number and output
843 * a symbol line for all global relocatables in the area.
844 * Repeat this proceedure for all areas.
847 * area * ap pointer to an area structure
848 * sym * sp pointer to a sym structure
851 * int c string character value
852 * int narea number of code areas
853 * char * ptr string pointer
854 * int nglob number of global symbols
855 * int rn symbol reference number
858 * area * areap pointer to an area structure
859 * char module[] module name string
860 * sym * symhash[] array of pointers to NHASH
861 * linked symbol lists
862 * int xflag -x, listing radix flag
865 * int fprintf() c_library
866 * VOID outarea() asout.c
867 * VOID outsym() asout.c
868 * int putc() c_library
871 * All symbols are given reference numbers, all symbol
872 * and area information is output to the .REL file.
878 register struct area *ap;
879 register struct sym *sp;
882 int c, narea, nglob, rn;
887 narea = areap->a_ref + 1;
890 * Number of global references/absolutes
893 for (i = 0; i < NHASH; ++i) {
896 if (sp->s_flag&S_GBL)
903 * Output Radix and number of areas and symbols
906 fprintf(ofp, "X%c\n", hilo ? 'H' : 'L');
907 fprintf(ofp, "H %X areas %X global symbols\n", narea, nglob);
910 fprintf(ofp, "Q%c\n", hilo ? 'H' : 'L');
911 fprintf(ofp, "H %o areas %o global symbols\n", narea, nglob);
914 fprintf(ofp, "D%c\n", hilo ? 'H' : 'L');
915 fprintf(ofp, "H %u areas %u global symbols\n", narea, nglob);
924 while (ptr < &module[NCPS]) {
925 if ((c = *ptr++) != 0)
932 * Global references and absolutes.
935 for (i=0; i<NHASH; ++i) {
938 if (sp->s_area==NULL && sp->s_flag&S_GBL) {
947 * Global relocatables.
949 for (i=0; i<narea; ++i) {
951 while (ap->a_ref != i)
954 for (j=0; j<NHASH; ++j) {
957 if (sp->s_area==ap && sp->s_flag&S_GBL) {
967 /*)Function VOID outarea(ap)
969 * area * ap pointer to an area structure
971 * The function outarea() outputs the A line to the .REL
972 * file. The A line contains the area's name, size, and
976 * char * ptr pointer to area id string
977 * int c character value
980 * FILE * ofp relocation output file handle
981 * int xflag -x, listing radix flag
984 * int fprintf() c_library
985 * int putc() c_library
988 * The A line is sent to the .REL file.
993 register struct area *ap;
1000 while (ptr < &ap->a_id[NCPS]) {
1001 if ((c = *ptr++) != 0)
1005 fprintf(ofp, " size %X flags %X\n", ap->a_size, ap->a_flag);
1008 fprintf(ofp, " size %o flags %o\n", ap->a_size, ap->a_flag);
1011 fprintf(ofp, " size %u flags %u\n", ap->a_size, ap->a_flag);
1015 /*)Function VOID outsym(sp)
1017 * sym * sp pointer to a sym structure
1019 * The function outsym() outputs the S line to the .REL
1020 * file. The S line contains the symbols name and whether the
1021 * the symbol is defined or referenced.
1024 * char * ptr pointer to symbol id string
1025 * int c character value
1028 * FILE * ofp relocation output file handle
1029 * int xflag -x, listing radix flag
1032 * int fprintf() c_library
1033 * int putc() c_library
1036 * The S line is sent to the .REL file.
1041 register struct sym *sp;
1047 fprintf(ofp, "%s", ptr );
1048 fprintf(ofp, " %s", sp->s_type==S_NEW ? "Ref" : "Def");
1050 fprintf(ofp, "%04X\n", sp->s_addr);
1053 fprintf(ofp, "%06o\n", sp->s_addr);
1056 fprintf(ofp, "%05u\n", sp->s_addr);
1060 /*)Function VOID out(p, n)
1062 * int n number of words to output
1063 * int * p pointer to data words
1065 * The function out() outputs the data words to the .REL file
1066 * int the specified radix.
1072 * FILE * ofp relocation output file handle
1073 * int xflag -x, listing radix flag
1076 * int fprintf() c_library
1079 * Data is sent to the .REL file.
1087 fprintf(ofp, " %02X", (*p++)&0xff);
1090 fprintf(ofp, " %03o", (*p++)&0xff);
1093 fprintf(ofp, " %03u", (*p++)&0xff);
1098 /*)Function VOID out_lb(b, t)
1100 * int b assembled data
1101 * int t relocation type
1103 * The function out_lb() copies the assembled data and
1104 * its relocation type to the list data buffers.
1110 * int * cp pointer to assembler output array cb[]
1111 * int * cpt pointer to assembler relocation type
1112 * output array cbt[]
1118 * Pointers to data and relocation buffers incremented by 1.
1125 if (cp < &cb[NCODE]) {
1131 /*)Function VOID out_lw(n, t)
1133 * int n assembled data
1134 * int t relocation type
1136 * The function out_lw() copies the assembled data and
1137 * its relocation type to the list data buffers.
1143 * int * cp pointer to assembler output array cb[]
1144 * int * cpt pointer to assembler relocation type
1145 * output array cbt[]
1151 * Pointers to data and relocation buffers incremented by 2.
1159 out_lb(hibyte(n),t ? t|R_HIGH : 0);
1160 out_lb(lobyte(n),t);
1162 out_lb(lobyte(n),t);
1163 out_lb(hibyte(n),t ? t|R_HIGH : 0);
1167 /*)Function VOID out_l24(n, t)
1169 * int n assembled data
1170 * int t relocation type
1172 * The function out_l24() copies the assembled data and
1173 * its relocation type to the list data buffers.
1179 * int * cp pointer to assembler output array cb[]
1180 * int * cpt pointer to assembler relocation type
1181 * output array cbt[]
1187 * Pointers to data and relocation buffers incremented by 3.
1191 out_l24(int n, int t)
1194 out_lb(byte3(n),t ? t|R_HIGH : 0);
1195 out_lb(hibyte(n),t);
1196 out_lb(lobyte(n),t);
1198 out_lb(lobyte(n),t);
1199 out_lb(hibyte(n),t);
1200 out_lb(byte3(n),t ? t|R_HIGH : 0);
1204 /*)Function VOID out_rw(n)
1208 * The function out_rw() outputs the relocation (R)
1209 * data word as two bytes ordered according to hilo.
1212 * int * relp pointer to rel array
1218 * int lobyte() asout.c
1219 * int hibyte() asout.c
1222 * Pointer to relocation buffer incremented by 2.
1230 *relp++ = hibyte(n);
1231 *relp++ = lobyte(n);
1233 *relp++ = lobyte(n);
1234 *relp++ = hibyte(n);
1238 /*)Function VOID out_tw(n)
1242 * The function out_tw() outputs the text (T)
1243 * data word as two bytes ordered according to hilo.
1246 * int * txtp pointer to txt array
1252 * int lobyte() asout.c
1253 * int hibyte() asout.c
1256 * Pointer to relocation buffer incremented by 2.
1264 *txtp++ = hibyte(n);
1265 *txtp++ = lobyte(n);
1267 *txtp++ = lobyte(n);
1268 *txtp++ = hibyte(n);
1272 /*)Function VOID out_t24(n)
1276 * The function out_t24() outputs the text (T)
1277 * data word as three bytes ordered according to hilo.
1280 * int * txtp pointer to txt array
1286 * int lobyte() asout.c
1287 * int hibyte() asout.c
1290 * Pointer to relocation buffer incremented by 3.
1298 *txtp++ = hibyte(n);
1299 *txtp++ = lobyte(n);
1301 *txtp++ = lobyte(n);
1302 *txtp++ = hibyte(n);
1307 /*)Function int lobyte(n)
1311 * The function lobyte() returns the lower byte of
1333 /*)Function int hibyte(n)
1337 * The function hibyte() returns the higher byte of
1356 return ((n>>8)&0377);
1359 /*)Function int byte3(n)
1363 * The function byte3() returns the MSB of the
1381 return ((n >> 16) & 0xff);
1385 * JLH: Output relocatable 11 bit jump/call
1387 * This function is derived from outrw(), adding the parameter for the
1388 * 11 bit address. This form of address is used only on the 8051 and 8048.
1392 register struct expr *esp;
1399 if (esp->e_flag==0 && esp->e_base.e_ap==NULL) {
1400 /* equated absolute destination. Assume value
1401 * relative to current area */
1402 esp->e_base.e_ap = dot.s_area;
1405 /* Relocatable destination. Build THREE
1406 * byte output: relocatable word, followed
1407 * by op-code. Linker will combine them.
1408 * Listing shows only the address.
1410 r |= R_WORD | esp->e_rlcf;
1411 out_lw(esp->e_addr,r|R_RELOC);
1414 out_tw(esp->e_addr);
1418 n = esp->e_base.e_sp->s_ref;
1421 n = esp->e_base.e_ap->a_ref;
1424 *relp++ = txtp - txt - 3;
1432 * Output relocatable 19 bit jump/call
1434 * This function is derived from outrw(), adding the parameter for the
1435 * 19 bit address. This form of address is used only in the DS80C390
1439 outr19(struct expr * esp, int op, int r)
1444 if (esp->e_flag==0 && esp->e_base.e_ap==NULL) {
1445 /* equated absolute destination. Assume value
1446 * relative to current area */
1447 esp->e_base.e_ap = dot.s_area;
1450 /* Relocatable destination. Build FOUR
1451 * byte output: relocatable 24-bit entity, followed
1452 * by op-code. Linker will combine them.
1453 * Listing shows only the address.
1455 r |= R_WORD | esp->e_rlcf;
1456 out_l24(esp->e_addr,r|R_RELOC);
1459 out_t24(esp->e_addr);
1463 n = esp->e_base.e_sp->s_ref;
1466 n = esp->e_base.e_ap->a_ref;
1469 *relp++ = txtp - txt - 4;