Version bump for last commit + ws cleanups. Now at v2.0.18.
[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-2020 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 "dsp56k.h"
13 #include "error.h"
14 #include "expr.h"
15 #include "listing.h"
16 #include "mach.h"
17 #include "mark.h"
18 #include "riscasm.h"
19 #include "symbol.h"
20 #include "token.h"
21
22
23 // Function prototypes
24 void MakeSection(int, uint16_t);
25 void SwitchSection(int);
26
27 // Section descriptors
28 SECT sect[NSECTS];              // All sections...
29 int cursect;                    // Current section number
30
31 // These are copied from the section descriptor, the current code chunk
32 // descriptor and the current fixup chunk descriptor when a switch is made into
33 // a section. They are copied back to the descriptors when the section is left.
34 uint16_t scattr;                // Section attributes
35 uint32_t sloc;                  // Current loc in section
36
37 CHUNK * scode;                  // Current (last) code chunk
38 uint32_t challoc;               // # bytes alloc'd to code chunk
39 uint32_t ch_size;               // # bytes used in code chunk
40 uint8_t * chptr;                // Deposit point in code chunk buffer
41 uint8_t * chptr_opcode; // Backup of chptr, updated before entering code generators
42
43 // Return a size (SIZB, SIZW, SIZL) or 0, depending on what kind of fixup is
44 // associated with a location.
45 static uint8_t fusiztab[] = {
46         0,      // FU_QUICK
47         1,      // FU_BYTE
48         2,      // FU_WORD
49         2,      // FU_WBYTE
50         4,      // FU_LONG
51         1,      // FU_BBRA
52         0,      // (unused)
53         1,      // FU_6BRA
54 };
55
56 // Offset to REAL fixup location
57 static uint8_t fusizoffs[] = {
58         0,      // FU_QUICK
59         0,      // FU_BYTE
60         0,      // FU_WORD
61         1,      // FU_WBYTE
62         0,      // FU_LONG
63         1,      // FU_BBRA
64         0,      // (unused)
65         0,      // FU_6BRA
66 };
67
68
69 //
70 // Initialize sections; setup initial ABS, TEXT, DATA and BSS sections
71 //
72 void InitSection(void)
73 {
74         // Initialize all sections
75         for(int i=0; i<NSECTS; i++)
76                 MakeSection(i, 0);
77
78         // Construct default sections, make TEXT the current section
79         MakeSection(ABS,     SUSED | SABS | SBSS);      // ABS
80         MakeSection(TEXT,    SUSED | TEXT       );      // TEXT
81         MakeSection(DATA,    SUSED | DATA       );      // DATA
82         MakeSection(BSS,     SUSED | BSS  | SBSS);      // BSS
83         MakeSection(M6502,   SUSED | TEXT       );      // 6502 code section
84         MakeSection(M56001P, SUSED | SABS       );      // DSP 56001 Program RAM
85         MakeSection(M56001X, SUSED | SABS       );      // DSP 56001 X RAM
86         MakeSection(M56001Y, SUSED | SABS       );      // DSP 56001 Y RAM
87
88         // Switch to TEXT for starters
89         SwitchSection(TEXT);
90 }
91
92
93 //
94 // Make a new (clean) section
95 //
96 void MakeSection(int sno, uint16_t attr)
97 {
98         SECT * sp = &sect[sno];
99         sp->scattr = attr;
100         sp->sloc = 0;
101         sp->orgaddr = 0;
102         sp->scode = sp->sfcode = NULL;
103         sp->sfix = sp->sffix = NULL;
104 }
105
106
107 //
108 // Switch to another section (copy section & chunk descriptors to global vars
109 // for fast access)
110 //
111 void SwitchSection(int sno)
112 {
113         CHUNK * cp;
114         cursect = sno;
115         SECT * sp = &sect[sno];
116
117         m6502 = (sno == M6502); // Set 6502-mode flag
118
119         // Copy section vars
120         scattr = sp->scattr;
121         sloc = sp->sloc;
122         scode = sp->scode;
123         orgaddr = sp->orgaddr;
124
125         // Copy code chunk vars
126         if ((cp = scode) != NULL)
127         {
128                 challoc = cp->challoc;
129                 ch_size = cp->ch_size;
130                 chptr = cp->chptr + ch_size;
131
132                 // For 6502 mode, add the last org'd address
133 // Why?
134 /*
135 Because the way this is set up it treats the 6502 assembly space as a single 64K space (+ 16 bytes, for some unknown reason) and just bobbles around inside that space and uses a stack of org "pointers" to show where the data ended up.
136
137 This is a shitty way to handle things, and we can do better than this!  :-P
138
139 Really, there's no reason to have the 6502 (or DSP56001 for that matter) have their own private sections for this kind of thing, as there's literally *no* chance that it would be mingled with 68K+ code.  It should be able to use the TEXT, DATA & BSS sections just like the 68K.
140
141 Or should it?  After looking at the code, maybe it's better to keep the 56001 sections segregated from the rest.  But we can still make the 6502 stuff better.
142 */
143                 if (m6502)
144                         chptr = cp->chptr + orgaddr;
145         }
146         else
147                 challoc = ch_size = 0;
148 }
149
150
151 //
152 // Save current section
153 //
154 void SaveSection(void)
155 {
156         SECT * sp = &sect[cursect];
157
158         sp->scattr = scattr;                    // Bailout section vars
159         sp->sloc = sloc;
160         sp->orgaddr = orgaddr;
161
162         if (scode != NULL)                              // Bailout code chunk (if any)
163                 scode->ch_size = ch_size;
164 }
165
166
167 //
168 // Test to see if a location has a fixup set on it. This is used by the
169 // listing generator to print 'xx's instead of '00's for forward references
170 //
171 int fixtest(int sno, uint32_t loc)
172 {
173         // Force update to sect[] variables
174         StopMark();
175
176         // Ugly linear search for a mark on our location. The speed doesn't
177         // matter, since this is only done when generating a listing, which is
178         // SLOW anyway.
179         for(FIXUP * fp=sect[sno].sffix; fp!=NULL; fp=fp->next)
180         {
181                 uint32_t w = fp->attr;
182                 uint32_t xloc = fp->loc + (int)fusizoffs[w & FUMASK];
183
184                 if (xloc == loc)
185                         return (int)fusiztab[w & FUMASK];
186         }
187
188         return 0;
189 }
190
191
192 //
193 // Check that there are at least 'amt' bytes left in the current chunk. If
194 // there are not, allocate another chunk of at least CH_CODE_SIZE bytes or
195 // 'amt', whichever is larger.
196 //
197 // If 'amt' is zero, ensure there are at least CH_THRESHOLD bytes, likewise.
198 //
199 void chcheck(uint32_t amt)
200 {
201         DEBUG { printf("chcheck(%u)\n", amt); }
202
203         // If in BSS section, no allocation required
204         if (scattr & SBSS)
205                 return;
206
207         if (amt == 0)
208                 amt = CH_THRESHOLD;
209
210         DEBUG { printf("    challoc=%i, ch_size=%i, diff=%i\n", challoc, ch_size, challoc - ch_size); }
211
212         if ((int)(challoc - ch_size) >= (int)amt)
213                 return;
214
215         if (amt < CH_CODE_SIZE)
216                 amt = CH_CODE_SIZE;
217
218         DEBUG { printf("    amt (adjusted)=%u\n", amt); }
219         SECT * p = &sect[cursect];
220         CHUNK * cp = malloc(sizeof(CHUNK) + amt);
221         int first = 0;
222
223         if (scode == NULL)
224         {
225                 // First chunk in section
226                 cp->chprev = NULL;
227                 p->sfcode = cp;
228                 first = 1;
229         }
230         else
231         {
232                 // Add second and on to previous chunk
233                 cp->chprev = scode;
234                 scode->chnext = cp;
235                 scode->ch_size = ch_size;       // Save old chunk's globals
236         }
237
238         // Setup chunk and global vars
239 /*
240 So, whenever there's an ORG in a 56K section, it sets sloc TO THE ADDRESS IN THE ORG.  Also, the loc/sloc are incremented by 1s, which means to alias correctly to the byte-oriented memory model we have here, we have to fix that kind of crap.
241 */
242         cp->chloc = sloc; // <-- HERE'S THE PROBLEM FOR 56K  :-/
243         cp->chnext = NULL;
244         challoc = cp->challoc = amt;
245         ch_size = cp->ch_size = 0;
246         chptr = cp->chptr = ((uint8_t *)cp) + sizeof(CHUNK);
247         scode = p->scode = cp;
248
249         // A quick kludge
250 /*
251 OK, so this is a bit shite, but at least it gets things working the way they should.  The right way to do this is not rely on sloc & friends for the right fixup address but to have an accurate model of the thing.  That will probably come with v2.0.1  :-P
252
253 So the problem is, d_org sets sloc to the address of the ORG statement, and that gives an incorrect base for the fixup.  And so when a second (or later) chunk is allocated, it gets set wrong.  Further complicating things is that the orgaddress *does not* get used in a typical way with the DSP56001 code, and, as such, causes incorrect addresses to be generated.  All that has to be dealt with in order to get this right and do away with this kludge.
254 */
255         if (((cursect == M56001P) || (cursect == M56001X) || (cursect == M56001Y)) && !first)
256                 cp->chloc = cp->chprev->chloc + cp->chprev->ch_size;
257
258         return;
259 }
260
261
262 //
263 // Arrange for a fixup on a location
264 //
265 int AddFixup(uint32_t attr, uint32_t loc, TOKEN * fexpr)
266 {
267         uint16_t exprlen = 0;
268         SYM * symbol = NULL;
269         uint32_t _orgaddr = 0;
270
271         // First, check to see if the expression is a bare label, otherwise, force
272         // the FU_EXPR flag into the attributes and count the tokens.
273         if ((fexpr[0] == SYMBOL) && (fexpr[2] == ENDEXPR))
274         {
275                 symbol = symbolPtr[fexpr[1]];
276
277                 // Save the org address for JR RISC instruction
278                 if ((attr & FUMASKRISC) == FU_JR)
279                         _orgaddr = orgaddr;
280         }
281         else
282         {
283                 attr |= FU_EXPR;
284                 exprlen = ExpressionLength(fexpr);
285         }
286
287         // Second, check to see if it's a DSP56001 fixup, and force the FU_56001
288         // flag into the attributes if so; also save the current org address.
289         if (attr & FUMASKDSP)
290         {
291                 attr |= FU_56001;
292                 // Save the exact spot in this chunk where the fixup should go
293                 _orgaddr = chptr - scode->chptr + scode->chloc;
294         }
295
296         // Allocate space for the fixup + any expression
297         FIXUP * fixup = malloc(sizeof(FIXUP) + (sizeof(TOKEN) * exprlen));
298
299         // Store the relevant fixup information in the FIXUP
300         fixup->next = NULL;
301         fixup->attr = attr;
302         fixup->loc = loc;
303         fixup->fileno = cfileno;
304         fixup->lineno = curlineno;
305         fixup->expr = NULL;
306         fixup->symbol = symbol;
307         fixup->orgaddr = _orgaddr;
308
309         // Copy the passed in expression to the FIXUP, if any
310         if (exprlen > 0)
311         {
312                 fixup->expr = (TOKEN *)((uint8_t *)fixup + sizeof(FIXUP));
313                 memcpy(fixup->expr, fexpr, sizeof(TOKEN) * exprlen);
314         }
315
316         // Finally, put the FIXUP in the current section's linked list
317         if (sect[cursect].sffix == NULL)
318         {
319                 sect[cursect].sffix = fixup;
320                 sect[cursect].sfix = fixup;
321         }
322         else
323         {
324                 sect[cursect].sfix->next = fixup;
325                 sect[cursect].sfix = fixup;
326         }
327
328         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);
329                 if (symbol != NULL)
330                         printf("          name: %s, value: $%lX\n", symbol->sname, symbol->svalue);
331         }
332
333         return 0;
334 }
335
336
337 //
338 // Resolve fixups in the passed in section
339 //
340 int ResolveFixups(int sno)
341 {
342         SECT * sc = &sect[sno];
343
344         // "Cache" first chunk
345         CHUNK * cch = sc->sfcode;
346
347         // Can't fixup a section with nothing in it
348         if (cch == NULL)
349                 return 0;
350
351         // Wire the 6502 segment's size to its allocated size (64K)
352         if (sno == M6502)
353                 cch->ch_size = cch->challoc;
354
355         // Get first fixup for the passed in section
356         FIXUP * fixup = sect[sno].sffix;
357
358         while (fixup != NULL)
359         {
360                 // We do it this way because we have continues everywhere... :-P
361                 FIXUP * fup = fixup;
362                 fixup = fixup->next;
363
364                 uint32_t dw = fup->attr;        // Fixup long (type + modes + flags)
365                 uint32_t loc = fup->loc;        // Location to fixup
366                 cfileno = fup->fileno;
367                 curlineno = fup->lineno;
368                 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); }
369
370                 // This is based on global vars cfileno, curfname :-P
371                 // This approach is kinda meh as well. I think we can do better
372                 // than this.
373                 SetFilenameForErrorReporting();
374
375                 if ((sno == M56001P) || (sno == M56001X) || (sno == M56001Y) || (sno == M56001L))
376                         loc = fup->orgaddr;
377
378                 // Search for chunk containing location to fix up; compute a
379                 // pointer to the location (in the chunk). Often we will find the
380                 // Fixup is in the "cached" chunk, so the linear-search is seldom
381                 // executed.
382                 if (loc < cch->chloc || loc >= (cch->chloc + cch->ch_size))
383                 {
384                         for(cch=sc->sfcode; cch!=NULL; cch=cch->chnext)
385                         {
386                                 if (loc >= cch->chloc && loc < (cch->chloc + cch->ch_size))
387                                         break;
388                         }
389
390                         if (cch == NULL)
391                         {
392                                 // Fixup (loc) is out of range--this should never happen!
393                                 // Once we call this function, it winds down immediately; it
394                                 // doesn't return.
395                                 interror(7);
396                         }
397                 }
398
399                 // Location to fix (in current chunk)
400                 // We use the address of the chunk that loc is actually in, then
401                 // subtract the chunk's starting location from loc to get the offset
402                 // into the current chunk.
403                 uint8_t * locp = cch->chptr + (loc - cch->chloc);
404
405                 uint16_t eattr = 0;                     // Expression attrib
406                 SYM * esym = NULL;                      // External symbol involved in expr
407                 uint64_t eval;                          // Expression value
408                 uint16_t flags;                         // Mark flags
409
410                 // Compute expression/symbol value and attributes
411
412                 // Complex expression
413                 if (dw & FU_EXPR)
414                 {
415                         // evexpr presumably issues the errors/warnings here
416                         if (evexpr(fup->expr, &eval, &eattr, &esym) != OK)
417                                 continue;
418
419                         if ((CHECK_OPTS(OPT_PC_RELATIVE)) && (eattr & REFERENCED) && (eattr & DEFINED) && (!(eattr & EQUATED)))
420                         {
421                                 error("relocation not allowed");
422                                 continue;
423                         }
424                 }
425                 // Simple symbol
426                 else
427                 {
428                         SYM * sy = fup->symbol;
429                         eattr = sy->sattr;
430
431                         if ((CHECK_OPTS(OPT_PC_RELATIVE)) && (eattr & REFERENCED) && (eattr & DEFINED) && (!(eattr & EQUATED)))
432                         {
433                                 error("relocation not allowed");
434                                 continue;
435                         }
436
437                         if (eattr & DEFINED)
438                                 eval = sy->svalue;
439                         else
440                                 eval = 0;
441
442                         // If the symbol is not defined, but global, set esym to sy
443                         if ((eattr & (GLOBAL | DEFINED)) == GLOBAL)
444                                 esym = sy;
445
446                         DEBUG { printf("               name: %s, value: $%" PRIX64 "\n", sy->sname, sy->svalue); }
447                 }
448
449                 uint16_t tdb = eattr & TDB;
450
451                 // If the expression/symbol is undefined and no external symbol is
452                 // involved, then that's an error.
453                 if (!(eattr & DEFINED) && (esym == NULL))
454                 {
455                         error(undef_error);
456                         continue;
457                 }
458
459                 // Do the fixup
460                 //
461                 // If a PC-relative fixup is undefined, its value is *not* subtracted
462                 // from the location (that will happen in the linker when the external
463                 // reference is resolved).
464                 //
465                 // PC-relative fixups must be DEFINED and either in the same section
466                 // (whereupon the subtraction takes place) or ABS (with no subtract).
467                 if ((dw & FU_PCREL) || (dw & FU_PCRELX))
468                 {
469                         if (eattr & DEFINED)
470                         {
471                                 if (tdb == sno)
472                                 {
473                                         eval -= loc;
474
475                                         // In this instruction the PC is located a DWORD away
476                                         if (dw & FU_PCRELX)
477                                                 eval += 2;
478                                 }
479                                 else if (tdb)
480                                 {
481                                         // Allow cross-section PCREL fixups in Alcyon mode
482                                         if (prg_flag || (obj_format == RAW))
483                                         {
484                                                 switch (tdb)
485                                                 {
486                                                 case TEXT:
487 // Shouldn't there be a break here, since otherwise, it will point to the DATA section?
488 //                                                      break;
489                                                 case DATA:
490                                                         eval += sect[TEXT].sloc;
491                                                         break;
492                                                 case BSS:
493                                                         eval += sect[TEXT].sloc + sect[DATA].sloc;
494                                                         break;
495                                                 default:
496                                                         error("invalid section");
497                                                 break;
498                                                 }
499
500                                                 eval -= loc;
501
502                                                 // In this instruction the PC is located a DWORD away
503                                                 if (dw & FU_PCRELX)
504                                                         eval += 2;
505                                         }
506                                         else
507                                         {
508                                                 error("PC-relative expr across sections");
509                                                 continue;
510                                         }
511                                 }
512
513                                 if (optim_warn_flag && (dw & FU_LBRA) && (eval + 0x80 < 0x100))
514                                         warn("unoptimized short branch");
515                         }
516
517                         // Be sure to clear any TDB flags, since we handled it just now
518                         tdb = 0;
519                         eattr &= ~TDB;
520                 }
521
522                 // Handle fixup classes
523                 switch (dw & FUMASK)
524                 {
525                 // FU_BBRA fixes up a one-byte branch offset.
526                 case FU_BBRA:
527                         if (!(eattr & DEFINED))
528                         {
529                                 error("external short branch");
530                                 continue;
531                         }
532
533                         eval -= 2;
534
535                         if (eval + 0x80 >= 0x100)
536                                 goto rangeErr;
537
538                         if (eval == 0)
539                         {
540                                 if (*locp) // optim_flags[OPT_NULL_BRA] is stored there, check the comment in mach.s under m_br
541                                 {
542                                         // Just output a NOP
543                                         *locp++ = 0x4E;
544                                         *locp = 0x71;
545
546                                         if (optim_warn_flag)
547                                                 warn("bra.s with zero offset converted to NOP");
548
549                                         continue;
550                                 }
551                                 else
552                                 {
553                                         error("illegal bra.s with zero offset");
554                                         continue;
555                                 }
556                         }
557
558                         *++locp = (uint8_t)eval;
559                         break;
560
561                 // Fixup one-byte value at locp + 1.
562                 case FU_WBYTE:
563                         locp++;
564                         // FALLTHROUGH
565
566                 // Fixup one-byte forward references
567                 case FU_BYTE:
568                         if (!(eattr & DEFINED))
569                         {
570                                 error("external byte reference");
571                                 continue;
572                         }
573
574                         if (tdb)
575                         {
576                                 error("non-absolute byte reference");
577                                 continue;
578                         }
579
580                         if ((dw & FU_PCREL) && ((eval + 0x80) >= 0x100))
581                                 goto rangeErr;
582
583                         if (dw & FU_SEXT)
584                         {
585                                 if ((eval + 0x100) >= 0x200)
586                                         goto rangeErr;
587                         }
588                         else if (eval >= 0x100)
589                                 goto rangeErr;
590
591                         *locp = (uint8_t)eval;
592                         break;
593
594                 // Fixup high/low byte off word for 6502
595                 case FU_BYTEH:
596                         if (!(eattr & DEFINED))
597                         {
598                                 error("external byte reference");
599                                 continue;
600                         }
601
602                         *locp = (uint8_t)(eval >> 8);
603                         break;
604
605                 case FU_BYTEL:
606                         if (!(eattr & DEFINED))
607                         {
608                                 error("external byte reference");
609                                 continue;
610                         }
611
612                         *locp = (uint8_t)eval;
613                         break;
614
615                 // Fixup WORD forward references; the word could be unaligned in the
616                 // section buffer, so we have to be careful. (? careful about what?)
617                 case FU_WORD:
618                         if ((dw & FUMASKRISC) == FU_JR)
619                         {
620                                 int reg = (signed)((eval - ((fup->orgaddr ? fup->orgaddr : loc) + 2)) / 2);
621
622                                 if ((reg < -16) || (reg > 15))
623                                 {
624                                         error("relative jump out of range");
625                                         break;
626                                 }
627
628                                 *locp |= ((uint8_t)reg >> 3) & 0x03;
629                                 locp++;
630                                 *locp |= ((uint8_t)reg & 0x07) << 5;
631                                 break;
632                         }
633                         else if ((dw & FUMASKRISC) == FU_NUM15)
634                         {
635                                 if (((int)eval < -16) || ((int)eval > 15))
636                                 {
637                                         error("constant out of range (-16 - +15)");
638                                         break;
639                                 }
640
641                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
642                                 locp++;
643                                 *locp |= ((uint8_t)eval & 0x07) << 5;
644                                 break;
645                         }
646                         else if ((dw & FUMASKRISC) == FU_NUM31)
647                         {
648                                 if (eval > 31)
649                                 {
650                                         error("constant out of range (0-31)");
651                                         break;
652                                 }
653
654                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
655                                 locp++;
656                                 *locp |= ((uint8_t)eval & 0x07) << 5;
657                                 break;
658                         }
659                         else if ((dw & FUMASKRISC) == FU_NUM32)
660                         {
661                                 if ((eval < 1) || (eval > 32))
662                                 {
663                                         error("constant out of range (1-32)");
664                                         break;
665                                 }
666
667                                 if (dw & FU_SUB32)
668                                         eval = (32 - eval);
669
670                                 eval = (eval == 32) ? 0 : eval;
671                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
672                                 locp++;
673                                 *locp |= ((uint8_t)eval & 0x07) << 5;
674                                 break;
675                         }
676                         else if ((dw & FUMASKRISC) == FU_REGONE)
677                         {
678                                 if (eval > 31)
679                                 {
680                                         error("register one value out of range");
681                                         break;
682                                 }
683
684                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
685                                 locp++;
686                                 *locp |= ((uint8_t)eval & 0x07) << 5;
687                                 break;
688                         }
689                         else if ((dw & FUMASKRISC) == FU_REGTWO)
690                         {
691                                 if (eval > 31)
692                                 {
693                                         error("register two value out of range");
694                                         break;
695                                 }
696
697                                 locp++;
698                                 *locp |= (uint8_t)eval & 0x1F;
699                                 break;
700                         }
701
702                         if (!(eattr & DEFINED))
703                         {
704                                 flags = MWORD;
705
706                                 if (dw & FU_PCREL)
707                                         flags |= MPCREL;
708
709                                 MarkRelocatable(sno, loc, 0, flags, esym);
710                         }
711                         else
712                         {
713                                 if (tdb)
714                                         MarkRelocatable(sno, loc, tdb, MWORD, NULL);
715
716                                 if (dw & FU_SEXT)
717                                 {
718                                         if (eval + 0x10000 >= 0x20000)
719                                                 goto rangeErr;
720                                 }
721                                 else
722                                 {
723                                         // Range-check BRA and DBRA
724                                         if (dw & FU_ISBRA)
725                                         {
726                                                 if (eval + 0x8000 >= 0x10000)
727                                                         goto rangeErr;
728                                         }
729                                         else if (eval >= 0x10000)
730                                                 goto rangeErr;
731                                 }
732                         }
733
734                         // 6502 words are little endian, so handle that here
735                         if (sno == M6502)
736                                 SETLE16(locp, 0, eval)
737                         else
738                                 SETBE16(locp, 0, eval)
739
740                         break;
741
742                 // Fixup LONG forward references; the long could be unaligned in the
743                 // section buffer, so be careful (again).
744                 case FU_LONG:
745                         flags = MLONG;
746
747                         if ((dw & FUMASKRISC) == FU_MOVEI)
748                         {
749                                 // Long constant in MOVEI # is word-swapped, so fix it here
750                                 eval = WORDSWAP32(eval);
751                                 flags |= MMOVEI;
752                         }
753
754                         // If the symbol is undefined, make sure to pass the symbol in
755                         // to the MarkRelocatable() function.
756                         if (!(eattr & DEFINED))
757                                 MarkRelocatable(sno, loc, 0, flags, esym);
758                         else if (tdb)
759                                 MarkRelocatable(sno, loc, tdb, flags, NULL);
760
761                         SETBE32(locp, 0, eval);
762                         break;
763
764                 // Fixup QUAD forward references (mainly used by the OP assembler)
765                 case FU_QUAD:
766                         if (dw & FU_OBJLINK)
767                         {
768                                 uint64_t quad = GETBE64(locp, 0);
769                                 uint64_t addr = eval;
770
771 //Hmm, not sure how this can be set, since it's only set if it's a DSP56001 fixup or a FU_JR...  :-/
772 //                              if (fup->orgaddr)
773 //                                      addr = fup->orgaddr;
774
775                                 eval = (quad & 0xFFFFFC0000FFFFFFLL) | ((addr & 0x3FFFF8) << 21);
776                         }
777                         else if (dw & FU_OBJDATA)
778                         {
779                                 // If it's in a TEXT or DATA section, be sure to mark for a
780                                 // fixup later
781                                 if (tdb)
782                                         MarkRelocatable(sno, loc, tdb, MQUAD, NULL);
783
784                                 uint64_t quad = GETBE64(locp, 0);
785                                 uint64_t addr = eval;
786
787 //Hmm, not sure how this can be set, since it's only set if it's a DSP56001 fixup or a FU_JR...  :-/
788 //                              if (fup->orgaddr)
789 //                                      addr = fup->orgaddr;
790
791                                 eval = (quad & 0x000007FFFFFFFFFFLL) | ((addr & 0xFFFFF8) << 40);
792                         }
793
794                         SETBE64(locp, 0, eval);
795                         break;
796
797                 // Fixup a 3-bit "QUICK" reference in bits 9..1
798                 // (range of 1..8) in a word. [Really bits 1..3 in a byte.]
799                 case FU_QUICK:
800                         if (!(eattr & DEFINED))
801                         {
802                                 error("External quick reference");
803                                 continue;
804                         }
805
806                         if ((eval < 1) || (eval > 8))
807                                 goto rangeErr;
808
809                         *locp |= (eval & 7) << 1;
810                         break;
811
812                 // Fix up 6502 funny branch
813                 case FU_6BRA:
814                         eval -= (loc + 1);
815
816                         if (eval + 0x80 >= 0x100)
817                                 goto rangeErr;
818
819                         *locp = (uint8_t)eval;
820                         break;
821
822                 // Fixup DSP56001 addresses
823                 case FU_56001:
824                         switch (dw & FUMASKDSP)
825                         {
826                         // DSPIMM5 actually is clamped from 0 to 23 for our purposes
827                         // and does not use the full 5 bit range.
828                         case FU_DSPIMM5:
829                                 if (eval > 23)
830                                 {
831                                         error("immediate value must be between 0 and 23");
832                                         break;
833                                 }
834
835                                 locp[2] |= eval;
836                                 break;
837
838                         // This is a 12-bit address encoded into the lower 12
839                         // bits of a DSP word
840                         case FU_DSPADR12:
841                                 if (eval >= 0x1000)
842                                 {
843                                         error("address out of range ($0-$FFF)");
844                                         break;
845                                 }
846
847                                 locp[1] |= eval >> 8;
848                                 locp[2] = eval & 0xFF;
849                                 break;
850
851                         // This is a full DSP word containing Effective Address Extension
852                         case FU_DSPADR24:
853                         case FU_DSPIMM24:
854                                 if (eval >= 0x1000000)
855                                 {
856                                         error("value out of range ($0-$FFFFFF)");
857                                         break;
858                                 }
859
860                                 locp[0] = (uint8_t)((eval >> 16) & 0xFF);
861                                 locp[1] = (uint8_t)((eval >> 8) & 0xFF);
862                                 locp[2] = (uint8_t)(eval & 0xFF);
863                                 break;
864
865                         // This is a 16bit absolute address into a 24bit field
866                         case FU_DSPADR16:
867                                 if (eval >= 0x10000)
868                                 {
869                                         error("address out of range ($0-$FFFF)");
870                                         break;
871                                 }
872
873                                 locp[1] = (uint8_t)(eval >> 8);
874                                 locp[2] = (uint8_t)eval;
875                                 break;
876
877                         // This is 12-bit immediate short data
878                         // The upper nibble goes into the last byte's low nibble
879                         // while the remainder 8 bits go into the 2nd byte.
880                         case FU_DSPIMM12:
881                                 if (eval >= 0x1000)
882                                 {
883                                         error("immediate out of range ($0-$FFF)");
884                                         break;
885                                 }
886
887                                 locp[1] = (uint8_t)eval;
888                                 locp[2] |= (uint8_t)(eval >> 8);
889                                 break;
890
891                         // This is 8-bit immediate short data
892                         // which goes into the middle byte of a DSP word.
893                         case FU_DSPIMM8:
894                                 if (eval >= 0x100)
895                                 {
896                                         error("immediate out of range ($0-$FF)");
897                                         break;
898                                 }
899
900                                 locp[1] = (uint8_t)eval;
901                                 break;
902
903                         // This is a 6 bit absoulte short address. It occupies the low 6
904                         // bits of the middle byte of a DSP word.
905                         case FU_DSPADR06:
906                                 if (eval > 63)
907                                 {
908                                         error("address must be between 0 and 63");
909                                         break;
910                                 }
911
912                                 locp[1] |= eval;
913                                 break;
914
915                         // This is a 6 bit absoulte short address. It occupies the low 6
916                         // bits of the middle byte of a DSP word.
917                         case FU_DSPPP06:
918                                 if (eval < 0xFFFFFFC0)
919                                 {
920                                         error("address must be between $FFC0 and $FFFF");
921                                         break;
922                                 }
923
924                                 locp[1] |= eval & 0x3F;
925                                 break;
926
927                         // Shamus: I'm pretty sure these don't make any sense...
928                         case FU_DSPIMMFL8:
929                                 warn("FU_DSPIMMFL8 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
930                                 break;
931
932                         case FU_DSPIMMFL16:
933                                 warn("FU_DSPIMMFL16 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
934                                 break;
935
936                         case FU_DSPIMMFL24:
937                                 warn("FU_DSPIMMFL24 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
938                                 break;
939
940                         // Bad fixup type--this should *never* happen!
941                         default:
942                                 interror(4);
943                                 // NOTREACHED
944                         }
945                         break;
946
947                 // Fixup a 4-byte float
948                 case FU_FLOATSING:
949                         warn("FU_FLOATSING missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
950                         break;
951
952                 // Fixup a 8-byte float
953                 case FU_FLOATDOUB:
954                         warn("FU_FLOATDOUB missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
955                         break;
956
957                 // Fixup a 12-byte float
958                 case FU_FLOATEXT:
959                         warn("FU_FLOATEXT missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
960                         break;
961
962                 default:
963                         // Bad fixup type--this should *never* happen!
964                         // Once we call this function, it winds down immediately; it
965                         // doesn't return.
966                         interror(4);
967                 }
968
969                 continue;
970 rangeErr:
971                 error("expression out of range");
972         }
973
974         return 0;
975 }
976
977
978 //
979 // Resolve all fixups
980 //
981 int ResolveAllFixups(void)
982 {
983         // Make undefined symbols GLOBL
984         if (glob_flag)
985                 ForceUndefinedSymbolsGlobal();
986
987         DEBUG printf("Resolving TEXT sections...\n");
988         ResolveFixups(TEXT);
989         DEBUG printf("Resolving DATA sections...\n");
990         ResolveFixups(DATA);
991         DEBUG printf("Resolving 6502 sections...\n");
992         ResolveFixups(M6502);           // Fixup 6502 section (if any)
993         DEBUG printf("Resolving DSP56001 P: sections...\n");
994         ResolveFixups(M56001P);         // Fixup 56001 P: section (if any)
995         DEBUG printf("Resolving DSP56001 X: sections...\n");
996         ResolveFixups(M56001X);         // Fixup 56001 X: section (if any)
997         DEBUG printf("Resolving DSP56001 Y: sections...\n");
998         ResolveFixups(M56001Y);         // Fixup 56001 Y: section (if any)
999
1000         return 0;
1001 }
1002