Version bump for last patch; now at v1.13.4.
[rmac] / sect.c
1 //
2 // RMAC - Reboot's Macro Assembler for all Atari computers
3 // SECT.C - Code Generation, Fixups and Section Management
4 // Copyright (C) 199x Landon Dyer, 2011-2018 Reboot and Friends
5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
6 // Source utilised with the kind permission of Landon Dyer
7 //
8
9 #include "sect.h"
10 #include "6502.h"
11 #include "direct.h"
12 #include "error.h"
13 #include "expr.h"
14 #include "listing.h"
15 #include "mach.h"
16 #include "mark.h"
17 #include "riscasm.h"
18 #include "symbol.h"
19 #include "token.h"
20
21
22 // Function prototypes
23 void MakeSection(int, uint16_t);
24 void SwitchSection(int);
25
26 // Section descriptors
27 SECT sect[NSECTS];              // All sections...
28 int cursect;                    // Current section number
29
30 // These are copied from the section descriptor, the current code chunk
31 // descriptor and the current fixup chunk descriptor when a switch is made into
32 // a section. They are copied back to the descriptors when the section is left.
33 uint16_t scattr;                // Section attributes
34 uint32_t sloc;                  // Current loc in section
35
36 CHUNK * scode;                  // Current (last) code chunk
37 uint32_t challoc;               // # bytes alloc'd to code chunk
38 uint32_t ch_size;               // # bytes used in code chunk
39 uint8_t * chptr;                // Deposit point in code chunk buffer
40 uint8_t * chptr_opcode; // Backup of chptr, updated before entering code generators
41
42 // Return a size (SIZB, SIZW, SIZL) or 0, depending on what kind of fixup is
43 // associated with a location.
44 static uint8_t fusiztab[] = {
45         0,      // FU_QUICK
46         1,      // FU_BYTE
47         2,      // FU_WORD
48         2,      // FU_WBYTE
49         4,      // FU_LONG
50         1,      // FU_BBRA
51         0,      // (unused)
52         1,      // FU_6BRA
53 };
54
55 // Offset to REAL fixup location
56 static uint8_t fusizoffs[] = {
57         0,      // FU_QUICK
58         0,      // FU_BYTE
59         0,      // FU_WORD
60         1,      // FU_WBYTE
61         0,      // FU_LONG
62         1,      // FU_BBRA
63         0,      // (unused)
64         0,      // FU_6BRA
65 };
66
67
68 //
69 // Initialize sections; setup initial ABS, TEXT, DATA and BSS sections
70 //
71 void InitSection(void)
72 {
73         // Initialize all sections
74         for(int i=0; i<NSECTS; i++)
75                 MakeSection(i, 0);
76
77         // Construct default sections, make TEXT the current section
78         MakeSection(ABS,   SUSED | SABS | SBSS);        // ABS
79         MakeSection(TEXT,  SUSED | TEXT       );        // TEXT
80         MakeSection(DATA,  SUSED | DATA       );        // DATA
81         MakeSection(BSS,   SUSED | BSS  | SBSS);        // BSS
82         MakeSection(M6502, SUSED | TEXT       );        // 6502 code section
83
84         // Switch to TEXT for starters
85         SwitchSection(TEXT);
86 }
87
88
89 //
90 // Make a new (clean) section
91 //
92 void MakeSection(int sno, uint16_t attr)
93 {
94         SECT * p = &sect[sno];
95         p->scattr = attr;
96         p->sloc = 0;
97         p->orgaddr = 0;
98         p->scode = p->sfcode = NULL;
99         p->sfix = p->sffix = NULL;
100 }
101
102
103 //
104 // Switch to another section (copy section & chunk descriptors to global vars
105 // for fast access)
106 //
107 void SwitchSection(int sno)
108 {
109         CHUNK * cp;
110         cursect = sno;
111         SECT * p = &sect[sno];
112
113         m6502 = (sno == M6502); // Set 6502-mode flag
114
115         // Copy section vars
116         scattr = p->scattr;
117         sloc = p->sloc;
118         scode = p->scode;
119         orgaddr = p->orgaddr;
120
121         // Copy code chunk vars
122         if ((cp = scode) != NULL)
123         {
124                 challoc = cp->challoc;
125                 ch_size = cp->ch_size;
126                 chptr = cp->chptr + ch_size;
127
128                 // For 6502 mode, add the last org'd address
129                 if (m6502)
130                         chptr = cp->chptr + orgaddr;
131         }
132         else
133                 challoc = ch_size = 0;
134 }
135
136
137 //
138 // Save current section
139 //
140 void SaveSection(void)
141 {
142         SECT * p = &sect[cursect];
143
144         p->scattr = scattr;                             // Bailout section vars
145         p->sloc = sloc;
146         p->orgaddr = orgaddr;
147
148         if (scode != NULL)                              // Bailout code chunk
149                 scode->ch_size = ch_size;
150 }
151
152
153 //
154 // Test to see if a location has a fixup set on it. This is used by the
155 // listing generator to print 'xx's instead of '00's for forward references
156 //
157 int fixtest(int sno, uint32_t loc)
158 {
159         // Force update to sect[] variables
160         StopMark();
161
162         // Ugly linear search for a mark on our location. The speed doesn't
163         // matter, since this is only done when generating a listing, which is
164         // SLOW anyway.
165         for(FIXUP * fp=sect[sno].sffix; fp!=NULL; fp=fp->next)
166         {
167                 uint32_t w = fp->attr;
168                 uint32_t xloc = fp->loc + (int)fusizoffs[w & FUMASK];
169
170                 if (xloc == loc)
171                         return (int)fusiztab[w & FUMASK];
172         }
173
174         return 0;
175 }
176
177
178 //
179 // Check that there are at least 'amt' bytes left in the current chunk. If
180 // there are not, allocate another chunk of at least CH_CODE_SIZE bytes or
181 // 'amt', whichever is larger.
182 //
183 // If 'amt' is zero, ensure there are at least CH_THRESHOLD bytes, likewise.
184 //
185 void chcheck(uint32_t amt)
186 {
187         DEBUG { printf("chcheck(%u)\n", amt); }
188
189         // If in BSS section, no allocation required
190         if (scattr & SBSS)
191                 return;
192
193         if (amt == 0)
194                 amt = CH_THRESHOLD;
195
196         DEBUG { printf("    challoc=%i, ch_size=%i, diff=%i\n", challoc, ch_size, challoc - ch_size); }
197
198         if ((int)(challoc - ch_size) >= (int)amt)
199                 return;
200
201         if (amt < CH_CODE_SIZE)
202                 amt = CH_CODE_SIZE;
203
204         DEBUG { printf("    amt (adjusted)=%u\n", amt); }
205         SECT * p = &sect[cursect];
206         CHUNK * cp = malloc(sizeof(CHUNK) + amt);
207
208         // First chunk in section
209         if (scode == NULL)
210         {
211                 cp->chprev = NULL;
212                 p->sfcode = cp;
213         }
214         // Add chunk to other chunks
215         else
216         {
217                 cp->chprev = scode;
218                 scode->chnext = cp;
219                 scode->ch_size = ch_size;       // Save old chunk's globals
220         }
221
222         // Setup chunk and global vars
223         cp->chloc = sloc;
224         cp->chnext = NULL;
225         challoc = cp->challoc = amt;
226         ch_size = cp->ch_size = 0;
227         chptr = cp->chptr = ((uint8_t *)cp) + sizeof(CHUNK);
228         scode = p->scode = cp;
229
230         return;
231 }
232
233
234 //
235 // Arrange for a fixup on a location
236 //
237 int AddFixup(uint32_t attr, uint32_t loc, TOKEN * fexpr)
238 {
239         uint16_t exprlen = 0;
240         SYM * symbol = NULL;
241         uint32_t _orgaddr = 0;
242
243         // First, check to see if the expression is a bare label, otherwise, force
244         // the FU_EXPR flag into the attributes and count the tokens.
245         if ((fexpr[0] == SYMBOL) && (fexpr[2] == ENDEXPR))
246         {
247                 symbol = symbolPtr[fexpr[1]];
248
249                 // Save the org address for JR RISC instruction
250                 if ((attr & FUMASKRISC) == FU_JR)
251                         _orgaddr = orgaddr;
252         }
253         else
254         {
255                 attr |= FU_EXPR;
256                 exprlen = ExpressionLength(fexpr);
257         }
258
259         // Allocate space for the fixup + any expression
260         FIXUP * fixup = malloc(sizeof(FIXUP) + (sizeof(TOKEN) * exprlen));
261
262         // Store the relevant fixup information in the FIXUP
263         fixup->next = NULL;
264         fixup->attr = attr;
265         fixup->loc = loc;
266         fixup->fileno = cfileno;
267         fixup->lineno = curlineno;
268         fixup->expr = NULL;
269         fixup->symbol = symbol;
270         fixup->orgaddr = _orgaddr;
271
272         // Copy the passed in expression to the FIXUP, if any
273         if (exprlen > 0)
274         {
275                 fixup->expr = (TOKEN *)((uint8_t *)fixup + sizeof(FIXUP));
276                 memcpy(fixup->expr, fexpr, sizeof(TOKEN) * exprlen);
277         }
278
279         // Finally, put the FIXUP in the current section's linked list
280         if (sect[cursect].sffix == NULL)
281         {
282                 sect[cursect].sffix = fixup;
283                 sect[cursect].sfix = fixup;
284         }
285         else
286         {
287                 sect[cursect].sfix->next = fixup;
288                 sect[cursect].sfix = fixup;
289         }
290
291         DEBUG { printf("AddFixup: sno=%u, l#=%u, attr=$%X, loc=$%X, expr=%p, sym=%p, org=$%X\n", cursect, fixup->lineno, fixup->attr, fixup->loc, (void *)fixup->expr, (void *)fixup->symbol, fixup->orgaddr);
292                 if (symbol != NULL)
293                         printf("          name: %s, value: $%lX\n", symbol->sname, symbol->svalue);
294         }
295
296         return 0;
297 }
298
299
300 //
301 // Resolve fixups in the passed in section
302 //
303 int ResolveFixups(int sno)
304 {
305         SECT * sc = &sect[sno];
306
307         // "Cache" first chunk
308         CHUNK * cch = sc->sfcode;
309
310         // Can't fixup a section with nothing in it
311         if (cch == NULL)
312                 return 0;
313
314         // Wire the 6502 segment's size to its allocated size (64K)
315         if (sno == M6502)
316                 cch->ch_size = cch->challoc;
317
318         // Get first fixup for the passed in section
319         FIXUP * fixup = sect[sno].sffix;
320
321         while (fixup != NULL)
322         {
323                 // We do it this way because we have continues everywhere... :-P
324                 FIXUP * fup = fixup;
325                 fixup = fixup->next;
326
327                 uint32_t w = fup->attr;         // Fixup long (type + modes + flags)
328                 uint32_t loc = fup->loc;        // Location to fixup
329                 cfileno = fup->fileno;
330                 curlineno = fup->lineno;
331                 DEBUG { printf("ResolveFixups: sect#=%u, l#=%u, attr=$%X, loc=$%X, expr=%p, sym=%p, org=$%X\n", sno, fup->lineno, fup->attr, fup->loc, (void *)fup->expr, (void *)fup->symbol, fup->orgaddr); }
332
333                 // This is based on global vars cfileno, curfname :-P
334                 // This approach is kinda meh as well. I think we can do better
335                 // than this.
336                 SetFilenameForErrorReporting();
337
338                 // Search for chunk containing location to fix up; compute a
339                 // pointer to the location (in the chunk). Often we will find the
340                 // Fixup is in the "cached" chunk, so the linear-search is seldom
341                 // executed.
342                 if (loc < cch->chloc || loc >= (cch->chloc + cch->ch_size))
343                 {
344                         for(cch=sc->sfcode; cch!=NULL; cch=cch->chnext)
345                         {
346                                 if (loc >= cch->chloc && loc < (cch->chloc + cch->ch_size))
347                                         break;
348                         }
349
350                         if (cch == NULL)
351                         {
352                                 // Fixup (loc) is out of range--this should never happen!
353                                 // Once we call this function, it winds down immediately; it
354                                 // doesn't return.
355                                 interror(7);
356                         }
357                 }
358
359                 // Location to fix (in current chunk)
360                 // We use the address of the chunk that loc is actually in, then
361                 // subtract the chunk's starting location from loc to get the offset
362                 // into the current chunk.
363                 uint8_t * locp = cch->chptr + (loc - cch->chloc);
364
365                 uint16_t eattr = 0;                     // Expression attrib
366                 SYM * esym = NULL;                      // External symbol involved in expr
367                 uint64_t eval;                          // Expression value
368                 uint16_t flags;                         // Mark flags
369
370                 // Compute expression/symbol value and attributes
371
372                 // Complex expression
373                 if (w & FU_EXPR)
374                 {
375                         if (evexpr(fup->expr, &eval, &eattr, &esym) != OK)
376                                 continue;
377                 }
378                 // Simple symbol
379                 else
380                 {
381                         SYM * sy = fup->symbol;
382                         eattr = sy->sattr;
383
384                         if (eattr & DEFINED)
385                                 eval = sy->svalue;
386                         else
387                                 eval = 0;
388
389                         // If the symbol is not defined, but global, set esym to sy
390                         if ((eattr & (GLOBAL | DEFINED)) == GLOBAL)
391                                 esym = sy;
392                 }
393
394                 uint16_t tdb = eattr & TDB;
395
396                 // If the expression/symbol is undefined and no external symbol is
397                 // involved, then that's an error.
398                 if (!(eattr & DEFINED) && (esym == NULL))
399                 {
400                         error(undef_error);
401                         continue;
402                 }
403
404                 // Do the fixup
405                 //
406                 // If a PC-relative fixup is undefined, its value is *not* subtracted
407                 // from the location (that will happen in the linker when the external
408                 // reference is resolved).
409                 //
410                 // MWC expects PC-relative things to have the LOC subtracted from the
411                 // value, if the value is external (that is, undefined at this point).
412                 //
413                 // PC-relative fixups must be DEFINED and either in the same section
414                 // (whereupon the subtraction takes place) or ABS (with no subtract).
415                 if (w & FU_PCREL)
416                 {
417                         if (eattr & DEFINED)
418                         {
419                                 if (tdb == sno)
420                                         eval -= loc;
421                                 else if (tdb)
422                                 {
423                                         // Allow cross-section PCREL fixups in Alcyon mode
424                                         if (prg_flag)
425                                         {
426                                                 switch (tdb)
427                                                 {
428                                                 case TEXT:
429 // Shouldn't there be a break here, since otherwise, it will point to the DATA section?
430 //                                                      break;
431                                                 case DATA:
432                                                         eval += sect[TEXT].sloc;
433                                                         break;
434                                                 case BSS:
435                                                         eval += sect[TEXT].sloc + sect[DATA].sloc;
436                                                         break;
437                                                 default:
438                                                         error("invalid section");
439                                                 break;
440                                                 }
441
442                                                 eval -= loc;
443                                         }
444                                         else
445                                         {
446                                                 error("PC-relative expr across sections");
447                                                 continue;
448                                         }
449                                 }
450
451                                 if (sbra_flag && (w & FU_LBRA) && (eval + 0x80 < 0x100))
452                                         warn("unoptimized short branch");
453                         }
454                         else if (obj_format == MWC)
455                                 eval -= loc;
456
457                         tdb = 0;
458                         eattr &= ~TDB;
459                 }
460
461                 // Handle fixup classes
462                 switch (w & FUMASK)
463                 {
464                 // FU_BBRA fixes up a one-byte branch offset.
465                 case FU_BBRA:
466                         if (!(eattr & DEFINED))
467                         {
468                                 error("external short branch");
469                                 continue;
470                         }
471
472                         eval -= 2;
473
474                         if (eval + 0x80 >= 0x100)
475                                 goto rangeErr;
476
477                         if (eval == 0)
478                         {
479                                 if (CHECK_OPTS(OPT_NULL_BRA))
480                                 {
481                                         // Just output a NOP
482                                         *locp++ = 0x4E;
483                                         *locp = 0x71;
484                                         continue;
485                                 }
486                                 else
487                                 {
488                                         error("illegal bra.s with zero offset");
489                                         continue;
490                                 }
491                         }
492
493                         *++locp = (uint8_t)eval;
494                         break;
495
496                 // Fixup one-byte value at locp + 1.
497                 case FU_WBYTE:
498                         locp++;
499                         // FALLTHROUGH
500
501                 // Fixup one-byte forward references
502                 case FU_BYTE:
503                         if (!(eattr & DEFINED))
504                         {
505                                 error("external byte reference");
506                                 continue;
507                         }
508
509                         if (tdb)
510                         {
511                                 error("non-absolute byte reference");
512                                 continue;
513                         }
514
515                         if ((w & FU_PCREL) && ((eval + 0x80) >= 0x100))
516                                 goto rangeErr;
517
518                         if (w & FU_SEXT)
519                         {
520                                 if ((eval + 0x100) >= 0x200)
521                                         goto rangeErr;
522                         }
523                         else if (eval >= 0x100)
524                                 goto rangeErr;
525
526                         *locp = (uint8_t)eval;
527                         break;
528
529                 // Fixup high/low byte off word for 6502
530                 case FU_BYTEH:
531                         if (!(eattr & DEFINED))
532                         {
533                                 error("external byte reference");
534                                 continue;
535                         }
536
537                         *locp = (uint8_t)(eval >> 8);
538                         break;
539
540                 case FU_BYTEL:
541                         if (!(eattr & DEFINED))
542                         {
543                                 error("external byte reference");
544                                 continue;
545                         }
546
547                         *locp = (uint8_t)eval;
548                         break;
549
550                 // Fixup WORD forward references; the word could be unaligned in the
551                 // section buffer, so we have to be careful.
552                 case FU_WORD:
553                         if ((w & FUMASKRISC) == FU_JR)
554                         {
555                                 int reg;
556
557                                 if (fup->orgaddr)
558                                         reg = (signed)((eval - (fup->orgaddr + 2)) / 2);
559                                 else
560                                         reg = (signed)((eval - (loc + 2)) / 2);
561
562                                 if ((reg < -16) || (reg > 15))
563                                 {
564                                         error("relative jump out of range");
565                                         break;
566                                 }
567
568                                 *locp |= ((uint8_t)reg >> 3) & 0x03;
569                                 locp++;
570                                 *locp |= ((uint8_t)reg & 0x07) << 5;
571                                 break;
572                         }
573                         else if ((w & FUMASKRISC) == FU_NUM15)
574                         {
575                                 if (((int)eval < -16) || ((int)eval > 15))
576                                 {
577                                         error("constant out of range (-16 - +15)");
578                                         break;
579                                 }
580
581                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
582                                 locp++;
583                                 *locp |= ((uint8_t)eval & 0x07) << 5;
584                                 break;
585                         }
586                         else if ((w & FUMASKRISC) == FU_NUM31)
587                         {
588                                 if (eval > 31)
589                                 {
590                                         error("constant out of range (0-31)");
591                                         break;
592                                 }
593
594                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
595                                 locp++;
596                                 *locp |= ((uint8_t)eval & 0x07) << 5;
597                                 break;
598                         }
599                         else if ((w & FUMASKRISC) == FU_NUM32)
600                         {
601                                 if ((eval < 1) || (eval > 32))
602                                 {
603                                         error("constant out of range (1-32)");
604                                         break;
605                                 }
606
607                                 if (w & FU_SUB32)
608                                         eval = (32 - eval);
609
610                                 eval = (eval == 32) ? 0 : eval;
611                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
612                                 locp++;
613                                 *locp |= ((uint8_t)eval & 0x07) << 5;
614                                 break;
615                         }
616                         else if ((w & FUMASKRISC) == FU_REGONE)
617                         {
618                                 if (eval > 31)
619                                 {
620                                         error("register one value out of range");
621                                         break;
622                                 }
623
624                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
625                                 locp++;
626                                 *locp |= ((uint8_t)eval & 0x07) << 5;
627                                 break;
628                         }
629                         else if ((w & FUMASKRISC) == FU_REGTWO)
630                         {
631                                 if (eval > 31)
632                                 {
633                                         error("register two value out of range");
634                                         break;
635                                 }
636
637                                 locp++;
638                                 *locp |= (uint8_t)eval & 0x1F;
639                                 break;
640                         }
641
642                         if (!(eattr & DEFINED))
643                         {
644                                 flags = MWORD;
645
646                                 if (w & FU_PCREL)
647                                         flags |= MPCREL;
648
649                                 MarkRelocatable(sno, loc, 0, flags, esym);
650                         }
651                         else
652                         {
653                                 if (tdb)
654                                         MarkRelocatable(sno, loc, tdb, MWORD, NULL);
655
656                                 if (w & FU_SEXT)
657                                 {
658                                         if (eval + 0x10000 >= 0x20000)
659                                                 goto rangeErr;
660                                 }
661                                 else
662                                 {
663                                         // Range-check BRA and DBRA
664                                         if (w & FU_ISBRA)
665                                         {
666                                                 if (eval + 0x8000 >= 0x10000)
667                                                         goto rangeErr;
668                                         }
669                                         else if (eval >= 0x10000)
670                                                 goto rangeErr;
671                                 }
672                         }
673
674                         // 6502 words are little endian, so handle that here
675                         if (sno == M6502)
676                                 SETLE16(locp, 0, eval)
677                         else
678                                 SETBE16(locp, 0, eval)
679
680                         break;
681
682                 // Fixup LONG forward references; the long could be unaligned in the
683                 // section buffer, so be careful (again).
684                 case FU_LONG:
685                         flags = MLONG;
686
687                         if ((w & FUMASKRISC) == FU_MOVEI)
688                         {
689                                 // Long constant in MOVEI # is word-swapped, so fix it here
690                                 eval = WORDSWAP32(eval);
691                                 flags |= MMOVEI;
692                         }
693
694                         // If the symbol is undefined, make sure to pass the symbol in
695                         // to the MarkRelocatable() function.
696                         if (!(eattr & DEFINED))
697                                 MarkRelocatable(sno, loc, 0, flags, esym);
698                         else if (tdb)
699                                 MarkRelocatable(sno, loc, tdb, flags, NULL);
700
701                         SETBE32(locp, 0, eval);
702                         break;
703
704                 // Fixup QUAD forward references (mainly used by the OP assembler)
705                 case FU_QUAD:
706                         if (w & FU_OBJLINK)
707                         {
708                                 uint64_t quad = GETBE64(locp, 0);
709                                 uint64_t addr = eval;
710
711                                 if (fup->orgaddr)
712                                         addr = fup->orgaddr;
713
714
715                                 eval = (quad & 0xFFFFFC0000FFFFFFLL) | ((addr & 0x3FFFF8) << 21);
716                         }
717                         else if (w & FU_OBJDATA)
718                         {
719                                 // If it's in a TEXT or DATA section, be sure to mark for a
720                                 // fixup later
721                                 if (tdb)
722                                         MarkRelocatable(sno, loc, tdb, MQUAD, NULL);
723
724                                 uint64_t quad = GETBE64(locp, 0);
725                                 uint64_t addr = eval;
726
727                                 if (fup->orgaddr)
728                                         addr = fup->orgaddr;
729
730                                 eval = (quad & 0x000007FFFFFFFFFFLL) | ((addr & 0xFFFFF8) << 40);
731                         }
732
733                         SETBE64(locp, 0, eval);
734                         break;
735
736                 // Fixup a 3-bit "QUICK" reference in bits 9..1
737                 // (range of 1..8) in a word. [Really bits 1..3 in a byte.]
738                 case FU_QUICK:
739                         if (!(eattr & DEFINED))
740                         {
741                                 error("External quick reference");
742                                 continue;
743                         }
744
745                         if ((eval < 1) || (eval > 8))
746                                 goto rangeErr;
747
748                         *locp |= (eval & 7) << 1;
749                         break;
750
751                 // Fix up 6502 funny branch
752                 case FU_6BRA:
753                         eval -= (loc + 1);
754
755                         if (eval + 0x80 >= 0x100)
756                                 goto rangeErr;
757
758                         *locp = (uint8_t)eval;
759                         break;
760
761                 // Fixup a 4-byte float
762                 case FU_FLOATSING:
763                         warn("FU_FLOATSING missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
764                         break;
765
766                 // Fixup a 8-byte float
767                 case FU_FLOATDOUB:
768                         warn("FU_FLOATDOUB missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
769                         break;
770
771                 // Fixup a 12-byte float
772                 case FU_FLOATEXT:
773                         warn("FU_FLOATEXT missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
774                         break;
775
776                 default:
777                         // Bad fixup type--this should *never* happen!
778                         // Once we call this function, it winds down immediately; it
779                         // doesn't return.
780                         interror(4);
781                 }
782
783                 continue;
784 rangeErr:
785                 error("expression out of range");
786         }
787
788         return 0;
789 }
790
791
792 //
793 // Resolve all fixups
794 //
795 int ResolveAllFixups(void)
796 {
797         // Make undefined symbols GLOBL
798         if (glob_flag)
799                 ForceUndefinedSymbolsGlobal();
800
801         DEBUG printf("Resolving TEXT sections...\n");
802         ResolveFixups(TEXT);
803         DEBUG printf("Resolving DATA sections...\n");
804         ResolveFixups(DATA);
805         DEBUG printf("Resolving 6502 sections...\n");
806         ResolveFixups(M6502);           // Fixup 6502 section (if any)
807
808         return 0;
809 }
810