]> git.sur5r.net Git - cc65/blob - src/ca65/objcode.c
Added condes tables to c64 config
[cc65] / src / ca65 / objcode.c
1 /*****************************************************************************/
2 /*                                                                           */
3 /*                                 objcode.c                                 */
4 /*                                                                           */
5 /*             Objectcode management for the ca65 macroassembler             */
6 /*                                                                           */
7 /*                                                                           */
8 /*                                                                           */
9 /* (C) 1998-2000 Ullrich von Bassewitz                                       */
10 /*               Wacholderweg 14                                             */
11 /*               D-70597 Stuttgart                                           */
12 /* EMail:        uz@musoftware.de                                            */
13 /*                                                                           */
14 /*                                                                           */
15 /* This software is provided 'as-is', without any expressed or implied       */
16 /* warranty.  In no event will the authors be held liable for any damages    */
17 /* arising from the use of this software.                                    */
18 /*                                                                           */
19 /* Permission is granted to anyone to use this software for any purpose,     */
20 /* including commercial applications, and to alter it and redistribute it    */
21 /* freely, subject to the following restrictions:                            */
22 /*                                                                           */
23 /* 1. The origin of this software must not be misrepresented; you must not   */
24 /*    claim that you wrote the original software. If you use this software   */
25 /*    in a product, an acknowledgment in the product documentation would be  */
26 /*    appreciated but is not required.                                       */
27 /* 2. Altered source versions must be plainly marked as such, and must not   */
28 /*    be misrepresented as being the original software.                      */
29 /* 3. This notice may not be removed or altered from any source              */
30 /*    distribution.                                                          */
31 /*                                                                           */
32 /*****************************************************************************/
33
34
35
36 #include <string.h>
37 #include <errno.h>
38 #include <ctype.h>
39
40 /* common */
41 #include "check.h"
42 #include "segdefs.h"
43 #include "xmalloc.h"
44
45 /* cc65 */
46 #include "error.h"
47 #include "fragment.h"
48 #include "global.h"
49 #include "listing.h"
50 #include "objfile.h"
51 #include "scanner.h"
52 #include "symtab.h"
53 #include "objcode.h"
54
55
56
57 /*****************************************************************************/
58 /*                                   Data                                    */
59 /*****************************************************************************/
60
61
62
63 /* Are we in absolute mode or in relocatable mode? */
64 int             RelocMode = 1;
65 unsigned long   AbsPC     = 0;          /* PC if in absolute mode */
66
67
68
69 typedef struct Segment_ Segment;
70 struct Segment_ {
71     Segment*        List;               /* List of all segments */
72     Fragment*       Root;               /* Root of fragment list */
73     Fragment*       Last;               /* Pointer to last fragment */
74     unsigned char   Align;              /* Segment alignment */
75     unsigned char   SegType;            /* True if zero page segment */
76     unsigned long   PC;
77     unsigned        Num;                /* Segment number */
78     char*           Name;               /* Segment name */
79 };
80
81
82
83 /* Predefined segments */
84 static Segment NullSeg = {
85     0, 0, 0, 0, SEGTYPE_ABS, 0, 5, "NULL"
86 };
87 static Segment ZeropageSeg = {
88     &NullSeg, 0, 0, 0, SEGTYPE_ZP, 0, 4, "ZEROPAGE"
89 };
90 static Segment DataSeg = {
91     &ZeropageSeg, 0, 0, 0, SEGTYPE_ABS, 0, 3, "DATA"
92 };
93 static Segment BssSeg = {
94     &DataSeg, 0, 0, 0, SEGTYPE_ABS, 0, 2, "BSS"
95 };
96 static Segment RODataSeg = {
97     &BssSeg, 0, 0, 0, SEGTYPE_ABS, 0, 1, "RODATA"
98 };
99 static Segment CodeSeg = {
100     &RODataSeg, 0, 0, 0, SEGTYPE_ABS, 0, 0, "CODE"
101 };
102
103 /* Number of segments */
104 static unsigned SegmentCount = 6;
105
106 /* List of all segments */
107 static Segment* SegmentList = &CodeSeg;
108 static Segment* SegmentLast = &NullSeg;
109
110 /* Currently active segment */
111 static Segment* ActiveSeg = &CodeSeg;
112
113
114
115 /*****************************************************************************/
116 /*                            Segment management                             */
117 /*****************************************************************************/
118
119
120
121 static Segment* NewSegment (const char* Name, unsigned SegType)
122 /* Create a new segment, insert it into the global list and return it */
123 {
124     Segment* S;
125     const char* N;
126
127     /* Check for too many segments */
128     if (SegmentCount >= 256) {
129         Fatal (FAT_TOO_MANY_SEGMENTS);
130     }
131
132     /* Check the segment name for invalid names */
133     N = Name;
134     if ((*N != '_' && !isalpha (*N)) || strlen (Name) > 80) {
135         Error (ERR_ILLEGAL_SEGMENT, Name);
136     }
137     do {
138         if (*N != '_' && !isalnum (*N)) {
139             Error (ERR_ILLEGAL_SEGMENT, Name);
140             break;
141         }
142         ++N;
143     } while (*N);
144
145     /* Create a new segment */
146     S = xmalloc (sizeof (*S));
147
148     /* Initialize it */
149     S->List    = 0;
150     S->Root    = 0;
151     S->Last    = 0;
152     S->Align   = 0;
153     S->SegType = SegType;
154     S->PC      = 0;
155     S->Num     = SegmentCount++;
156     S->Name    = xstrdup (Name);
157
158     /* Insert it into the segment list */
159     SegmentLast->List = S;
160     SegmentLast = S;
161
162     /* And return it... */
163     return S;
164 }
165
166
167
168 void UseCodeSeg (void)
169 /* Use the code segment */
170 {
171     ActiveSeg = &CodeSeg;
172 }
173
174
175
176 void UseRODataSeg (void)
177 /* Use the r/o data segment */
178 {
179     ActiveSeg = &RODataSeg;
180 }
181
182
183
184 void UseDataSeg (void)
185 /* Use the data segment */
186 {
187     ActiveSeg = &DataSeg;
188 }
189
190
191
192 void UseBssSeg (void)
193 /* Use the BSS segment */
194 {
195     ActiveSeg = &BssSeg;
196 }
197
198
199
200 void UseZeropageSeg (void)
201 /* Use the zero page segment */
202 {
203     ActiveSeg = &ZeropageSeg;
204 }
205
206
207
208 void UseNullSeg (void)
209 /* Use the null segment */
210 {
211     ActiveSeg = &NullSeg;
212 }
213
214
215
216 void UseSeg (const char* Name, unsigned SegType)
217 /* Use the segment with the given name */
218 {
219     Segment* Seg = SegmentList;
220     while (Seg) {
221         if (strcmp (Seg->Name, Name) == 0) {
222             /* We found this segment. Check if the type is identical */
223             if (SegType != SEGTYPE_DEFAULT && Seg->SegType != SegType) {
224                 Error (ERR_SEG_ATTR_MISMATCH);
225                 /* Use the new attribute to avoid errors */
226                 Seg->SegType = SegType;
227             }
228             ActiveSeg = Seg;
229             return;
230         }
231         /* Check next segment */
232         Seg = Seg->List;
233     }
234
235     /* Segment is not in list, create a new one */
236     if (SegType == SEGTYPE_DEFAULT) {
237         SegType = SEGTYPE_ABS;
238     }
239     Seg = NewSegment (Name, SegType);
240     ActiveSeg = Seg;
241 }
242
243
244
245 unsigned long GetPC (void)
246 /* Get the program counter of the current segment */
247 {
248     return RelocMode? ActiveSeg->PC : AbsPC;
249 }
250
251
252
253 void SetAbsPC (unsigned long PC)
254 /* Set the program counter in absolute mode */
255 {
256     RelocMode = 0;
257     AbsPC = PC;
258 }
259
260
261
262 unsigned GetSegNum (void)
263 /* Get the number of the current segment */
264 {
265     return ActiveSeg->Num;
266 }
267
268
269
270 void SegAlign (unsigned Power, int Val)
271 /* Align the PC segment to 2^Power. If Val is -1, emit fill fragments (the
272  * actual fill value will be determined by the linker), otherwise use the
273  * given value.
274  */
275 {
276     unsigned char Data [4];
277     unsigned long Align = (1UL << Power) - 1;
278     unsigned long NewPC = (ActiveSeg->PC + Align) & ~Align;
279     unsigned long Count = NewPC - ActiveSeg->PC;
280
281     if (Val != -1) {
282         /* User defined fill value */
283         memset (Data, Val, sizeof (Data));
284         while (Count) {
285             if (Count > sizeof (Data)) {
286                 EmitData (Data, sizeof (Data));
287                 Count -= sizeof (Data);
288             } else {
289                 EmitData (Data, Count);
290                 Count = 0;
291             }
292         }
293     } else {
294         /* Linker defined fill value */
295         EmitFill (Count);
296     }
297
298     /* Remember the alignment in the header */
299     if (ActiveSeg->Align < Power) {
300         ActiveSeg->Align = Power;
301     }
302 }
303
304
305
306 int IsZPSeg (void)
307 /* Return true if the current segment is a zeropage segment */
308 {
309     return (ActiveSeg->SegType == SEGTYPE_ZP);
310 }
311
312
313
314 int IsFarSeg (void)
315 /* Return true if the current segment is a far segment */
316 {
317     return (ActiveSeg->SegType == SEGTYPE_FAR);
318 }
319
320
321
322 unsigned GetSegType (unsigned SegNum)
323 /* Return the type of the segment with the given number */
324 {
325     /* Search for the segment */
326     Segment* S = SegmentList;
327     while (S && SegNum) {
328         --SegNum;
329         S = S->List;
330     }
331
332     /* Did we find it? */
333     if (S == 0) {
334         FAIL ("Invalid segment number");
335     }
336
337     /* Return the segment type */
338     return S->SegType;
339 }
340
341
342
343 void SegCheck (void)
344 /* Check the segments for range and other errors */
345 {
346     Segment* S = SegmentList;
347     while (S) {
348         Fragment* F = S->Root;
349         while (F) {
350             if (F->Type == FRAG_EXPR || F->Type == FRAG_SEXPR) {
351                 F->V.Expr = FinalizeExpr (F->V.Expr);
352                 if (IsConstExpr (F->V.Expr)) {
353                     /* We are able to evaluate the expression. Get the value
354                      * and check for range errors.
355                      */
356                     unsigned I;
357                     long Val = GetExprVal (F->V.Expr);
358                     int Abs = (F->Type != FRAG_SEXPR);
359
360                     if (F->Len == 1) {
361                         if (Abs) {
362                             /* Absolute value */
363                             if (Val > 255) {
364                                 PError (&F->Pos, ERR_RANGE);
365                             }
366                         } else {
367                             /* PC relative value */
368                             if (Val < -128 || Val > 127) {
369                                 PError (&F->Pos, ERR_RANGE);
370                             }
371                         }
372                     } else if (F->Len == 2) {
373                         if (Abs) {
374                             /* Absolute value */
375                             if (Val > 65535) {
376                                 PError (&F->Pos, ERR_RANGE);
377                             }
378                         } else {
379                             /* PC relative value */
380                             if (Val < -32768 || Val > 32767) {
381                                 PError (&F->Pos, ERR_RANGE);
382                             }
383                         }
384                     }
385
386                     /* Convert the fragment into a literal fragment */
387                     for (I = 0; I < F->Len; ++I) {
388                         F->V.Data [I] = Val & 0xFF;
389                         Val >>= 8;
390                     }
391                     F->Type = FRAG_LITERAL;
392                 } else {
393                     /* We cannot evaluate the expression now, leave the job for
394                      * the linker. However, we are able to check for explicit
395                      * byte expressions and we will do so.
396                      */
397                     if (F->Type == FRAG_EXPR && F->Len == 1 && !IsByteExpr (F->V.Expr)) {
398                         PError (&F->Pos, ERR_RANGE);
399                     }
400                 }
401             }
402             F = F->Next;
403         }
404         S = S->List;
405     }
406 }
407
408
409
410 void SegDump (void)
411 /* Dump the contents of all segments */
412 {
413     unsigned X = 0;
414     Segment* S = SegmentList;
415     printf ("\n");
416     while (S) {
417         unsigned I;
418         Fragment* F;
419         int State = -1;
420         printf ("New segment: %s", S->Name);
421         F = S->Root;
422         while (F) {
423             if (F->Type == FRAG_LITERAL) {
424                 if (State != 0) {
425                     printf ("\n  Literal:");
426                     X = 15;
427                     State = 0;
428                 }
429                 for (I = 0; I < F->Len; ++I) {
430                     printf (" %02X", F->V.Data [I]);
431                     X += 3;
432                 }
433             } else if (F->Type == FRAG_EXPR || F->Type == FRAG_SEXPR) {
434                 State = 1;
435                 printf ("\n  Expression (%u): ", F->Len);
436                 DumpExpr (F->V.Expr);
437             } else if (F->Type == FRAG_FILL) {
438                 State = 1;
439                 printf ("\n  Fill bytes (%u)", F->Len);
440             } else {
441                 Internal ("Unknown fragment type: %u", F->Type);
442             }
443             if (X > 65) {
444                 State = -1;
445             }
446             F = F->Next;
447         }
448         printf ("\n  End PC = $%04X\n", (unsigned)(S->PC & 0xFFFF));
449         S = S->List;
450     }
451     printf ("\n");
452 }
453
454
455
456 static void WriteOneSeg (Segment* Seg)
457 /* Write one segment to the object file */
458 {
459     Fragment* Frag;
460     Fragment* F;
461     unsigned long Size;
462
463     /* Write the segment name followed by the byte count in this segment */
464     ObjWriteStr (Seg->Name);
465     ObjWrite32 (Seg->PC);
466     ObjWrite8 (Seg->Align);
467     ObjWrite8 (Seg->SegType);
468
469     /* Now walk through the fragment list for this segment and write the
470      * fragments.
471      */
472     Frag = Seg->Root;
473     while (Frag) {
474
475         /* Write data depending on the type */
476         switch (Frag->Type) {
477
478             case FRAG_LITERAL:
479                 /* To make the object file somewhat smaller, write all literal
480                  * data of this and the following fragments preceeded by the
481                  * length.
482                  */
483                 F = Frag;
484                 Size = 0;
485                 while (F && F->Type == FRAG_LITERAL) {
486                     Size += F->Len;
487                     F = F->Next;
488                 }
489                 ObjWrite8 (FRAG_LITERAL);
490                 ObjWriteVar (Size);
491
492                 /* Now write the literal data */
493                 F = Frag;
494                 while (F && F->Type == FRAG_LITERAL) {
495                     ObjWriteData (F->V.Data, F->Len);
496                     Frag = F;
497                     F = F->Next;
498                 }
499                 break;
500
501             case FRAG_EXPR:
502                 switch (Frag->Len) {
503                     case 1:   ObjWrite8 (FRAG_EXPR8);   break;
504                     case 2:   ObjWrite8 (FRAG_EXPR16);  break;
505                     case 3:   ObjWrite8 (FRAG_EXPR24);  break;
506                     case 4:   ObjWrite8 (FRAG_EXPR32);  break;
507                     default:  Internal ("Invalid fragment size: %u", Frag->Len);
508                 }
509                 WriteExpr (Frag->V.Expr);
510                 break;
511
512             case FRAG_SEXPR:
513                 switch (Frag->Len) {
514                     case 1:   ObjWrite8 (FRAG_SEXPR8);  break;
515                     case 2:   ObjWrite8 (FRAG_SEXPR16); break;
516                     case 3:   ObjWrite8 (FRAG_SEXPR24); break;
517                     case 4:   ObjWrite8 (FRAG_SEXPR32); break;
518                     default:  Internal ("Invalid fragment size: %u", Frag->Len);
519                 }
520                 WriteExpr (Frag->V.Expr);
521                 break;
522
523             case FRAG_FILL:
524                 ObjWrite8 (FRAG_FILL);
525                 ObjWriteVar (Frag->Len);
526                 break;
527
528             default:
529                 Internal ("Invalid fragment type: %u", Frag->Type);
530
531         }
532
533         /* Write the file position of this fragment */
534         ObjWritePos (&Frag->Pos);
535
536         /* Next fragment */
537         Frag = Frag->Next;
538     }
539 }
540
541
542
543 void WriteSegments (void)
544 /* Write the segment data to the object file */
545 {
546     Segment* Seg;
547
548     /* Tell the object file module that we're about to start the seg list */
549     ObjStartSegments ();
550
551     /* First thing is segment count */
552     ObjWriteVar (SegmentCount);
553
554     /* Now walk through all segments and write them to the object file */
555     Seg = SegmentList;
556     while (Seg) {
557         /* Write one segment */
558         WriteOneSeg (Seg);
559         /* Next segment */
560         Seg = Seg->List;
561     }
562
563     /* Done writing segments */
564     ObjEndSegments ();
565 }
566
567
568
569 /*****************************************************************************/
570 /*                                   Code                                    */
571 /*****************************************************************************/
572
573
574
575 static void IncPC (unsigned Value)
576 /* Increment the PC counter */
577 {
578     ActiveSeg->PC += Value;
579     if (!RelocMode) {
580         AbsPC += Value;
581     }
582 }
583
584
585
586 static Fragment* NewFragment (unsigned char Type, unsigned short Len)
587 /* Create, initialize and return a new fragment. The fragment will be inserted
588  * into the current segment.
589  */
590 {
591     Fragment* F;
592
593     /* Create a new fragment */
594     F = xmalloc (sizeof (*F));
595
596     /* Initialize it */
597     F->List     = 0;
598     F->Next     = 0;
599     F->LineList = 0;
600     F->Pos      = CurPos;
601     F->Len      = Len;
602     F->Type     = Type;
603
604     /* Insert it into the list of all segments */
605     if (FragList == 0) {
606         FragList = F;
607     } else {
608         FragLast->List = F;
609     }
610     FragLast = F;
611
612     /* Insert it into the current segment */
613     if (ActiveSeg->Root) {
614         ActiveSeg->Last->Next = F;
615         ActiveSeg->Last = F;
616     } else {
617         ActiveSeg->Root = ActiveSeg->Last = F;
618     }
619
620     /* Add this fragment to the current listing line */
621     if (LineCur) {
622         if (LineCur->FragList == 0) {
623             LineCur->FragList = F;
624         } else {
625             LineCur->FragLast->LineList = F;
626         }
627         LineCur->FragLast = F;
628     }
629
630     /* Increment the program counter */
631     IncPC (Len);
632
633     /* And return it */
634     return F;
635 }
636
637
638
639 void Emit0 (unsigned char OPC)
640 /* Emit an instruction with a zero sized operand */
641 {
642     /* First fragment, wrong type or out of space, create new one */
643     Fragment* F = NewFragment (FRAG_LITERAL, 1);
644     F->V.Data [0] = OPC;
645 }
646
647
648
649 void Emit1 (unsigned char OPC, ExprNode* Value)
650 /* Emit an instruction with an one byte argument */
651 {
652     Emit0 (OPC);
653     EmitByte (Value);
654 }
655
656
657
658 void Emit2 (unsigned char OPC, ExprNode* Value)
659 /* Emit an instruction with a two byte argument */
660 {
661     Emit0 (OPC);
662     EmitWord (Value);
663 }
664
665
666
667 void Emit3 (unsigned char OPC, ExprNode* Expr)
668 /* Emit an instruction with a three byte argument */
669 {
670     Emit0 (OPC);
671     EmitFarAddr (Expr);
672 }
673
674
675
676 void Emit3b (unsigned char OPC, ExprNode* Expr, ExprNode* Bank)
677 /* Emit an instruction with a three byte argument and separate bank */
678 {
679     Emit0 (OPC);
680     EmitWord (Expr);
681     EmitByte (Bank);
682 }
683
684
685
686 void EmitPCRel (unsigned char OPC, ExprNode* Expr, unsigned Size)
687 /* Emit an opcode with a PC relative argument of one or two bytes */
688 {
689     Fragment* F;
690     Emit0 (OPC);
691     F = NewFragment (FRAG_SEXPR, Size);
692     F->V.Expr = Expr;
693 }
694
695
696
697 void EmitData (const unsigned char* Data, unsigned Size)
698 /* Emit data into the current segment */
699 {
700     /* Create lots of fragments for the data */
701     while (Size) {
702         Fragment* F;
703
704         /* Determine the length of the next fragment */
705         unsigned Len = Size;
706         if (Len > sizeof (F->V.Data)) {
707             Len = sizeof (F->V.Data);
708         }
709
710         /* Create a new fragment */
711         F = NewFragment (FRAG_LITERAL, Len);
712
713         /* Copy the data */
714         memcpy (F->V.Data, Data, Len);
715
716         /* Next chunk */
717         Data += Len;
718         Size -= Len;
719
720     }
721 }
722
723
724
725 void EmitByte (ExprNode* Expr)
726 /* Emit one byte */
727 {
728     if (IsConstExpr (Expr)) {
729         /* Constant expression, emit literal byte */
730         long Val = GetExprVal (Expr);
731         FreeExpr (Expr);
732         if ((Val & ~0xFF) != 0) {
733             Error (ERR_RANGE);
734         }
735         Emit0 (Val & 0xFF);
736     } else {
737         /* Create a new fragment */
738         Fragment* F = NewFragment (FRAG_EXPR, 1);
739
740         /* Set the data */
741         F->V.Expr = Expr;
742     }
743 }
744
745
746
747 void EmitWord (ExprNode* Expr)
748 /* Emit one word */
749 {
750     if (IsConstExpr (Expr)) {
751         /* Constant expression, emit literal byte */
752         long Val = GetExprVal (Expr);
753         FreeExpr (Expr);
754         if ((Val & ~0xFFFF) != 0) {
755             Error (ERR_RANGE);
756         }
757         Emit0 (Val & 0xFF);
758         Emit0 ((Val >> 8) & 0xFF);
759     } else {
760         /* Create a new fragment */
761         Fragment* F = NewFragment (FRAG_EXPR, 2);
762
763         /* Set the data */
764         F->V.Expr = Expr;
765     }
766 }
767
768
769
770 void EmitFarAddr (ExprNode* Expr)
771 /* Emit a 24 bit expression */
772 {
773     if (IsConstExpr (Expr)) {
774         /* Constant expression, emit literal byte */
775         long Val = GetExprVal (Expr);
776         FreeExpr (Expr);
777         if ((Val & ~0xFFFFFF) != 0) {
778             Error (ERR_RANGE);
779         }
780         Emit0 (Val & 0xFF);
781         Emit0 ((Val >> 8) & 0xFF);
782         Emit0 ((Val >> 16) & 0xFF);
783     } else {
784         /* Create a new fragment */
785         Fragment* F = NewFragment (FRAG_EXPR, 3);
786
787         /* Set the data */
788         F->V.Expr = Expr;
789     }
790 }
791
792
793
794 void EmitDWord (ExprNode* Expr)
795 /* Emit one dword */
796 {
797     if (IsConstExpr (Expr)) {
798         /* Constant expression, emit literal byte */
799         long Val = GetExprVal (Expr);
800         FreeExpr (Expr);
801         Emit0 (Val & 0xFF);
802         Emit0 ((Val >> 8) & 0xFF);
803         Emit0 ((Val >> 16) & 0xFF);
804         Emit0 ((Val >> 24) & 0xFF);
805     } else {
806         /* Create a new fragment */
807         Fragment* F = NewFragment (FRAG_EXPR, 4);
808
809         /* Set the data */
810         F->V.Expr = Expr;
811     }
812 }
813
814
815
816 void EmitFill (unsigned long Count)
817 /* Emit Count fill bytes */
818 {
819     while (Count) {
820         /* Calculate the size of the next chunk */
821         unsigned Chunk = (Count > 0xFFFF)? 0xFFFF : (unsigned) Count;
822         Count -= Chunk;
823
824         /* Emit one chunk */
825         NewFragment (FRAG_FILL, Chunk);
826     }
827 }
828
829
830