]> git.sur5r.net Git - cc65/blob - src/ca65/segment.c
Add the new include files geos-apple.inc and geos-cbm.inc to the svn ignore
[cc65] / src / ca65 / segment.c
1 /*****************************************************************************/
2 /*                                                                           */
3 /*                                 segment.c                                 */
4 /*                                                                           */
5 /*                   Segments for the ca65 macroassembler                    */
6 /*                                                                           */
7 /*                                                                           */
8 /*                                                                           */
9 /* (C) 1998-2011, Ullrich von Bassewitz                                      */
10 /*                Roemerstrasse 52                                           */
11 /*                D-70794 Filderstadt                                        */
12 /* EMail:         uz@cc65.org                                                */
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
39 /* common */
40 #include "addrsize.h"
41 #include "alignment.h"
42 #include "coll.h"
43 #include "mmodel.h"
44 #include "segnames.h"
45 #include "xmalloc.h"
46
47 /* cc65 */
48 #include "error.h"
49 #include "fragment.h"
50 #include "global.h"
51 #include "lineinfo.h"
52 #include "listing.h"
53 #include "objcode.h"
54 #include "objfile.h"
55 #include "segment.h"
56 #include "span.h"
57 #include "spool.h"
58 #include "studyexpr.h"
59 #include "symtab.h"
60
61
62
63 /*****************************************************************************/
64 /*                                   Data                                    */
65 /*****************************************************************************/
66
67
68
69 /* If OrgPerSeg is false, all segments share the RelocMode flag and a PC
70  * used when in absolute mode. OrgPerSeg may be set by .feature org_per_seg
71  */
72 static int              RelocMode = 1;
73 static unsigned long    AbsPC     = 0;          /* PC if in absolute mode */
74
75 /* Definitions for predefined segments */
76 SegDef NullSegDef     = STATIC_SEGDEF_INITIALIZER (SEGNAME_NULL,     ADDR_SIZE_ABS);
77 SegDef ZeropageSegDef = STATIC_SEGDEF_INITIALIZER (SEGNAME_ZEROPAGE, ADDR_SIZE_ZP);
78 SegDef DataSegDef     = STATIC_SEGDEF_INITIALIZER (SEGNAME_DATA,     ADDR_SIZE_ABS);
79 SegDef BssSegDef      = STATIC_SEGDEF_INITIALIZER (SEGNAME_BSS,      ADDR_SIZE_ABS);
80 SegDef RODataSegDef   = STATIC_SEGDEF_INITIALIZER (SEGNAME_RODATA,   ADDR_SIZE_ABS);
81 SegDef CodeSegDef     = STATIC_SEGDEF_INITIALIZER (SEGNAME_CODE,     ADDR_SIZE_ABS);
82
83 /* Collection containing all segments */
84 Collection SegmentList = STATIC_COLLECTION_INITIALIZER;
85
86 /* Currently active segment */
87 Segment* ActiveSeg;
88
89
90
91 /*****************************************************************************/
92 /*                                   Code                                    */
93 /*****************************************************************************/
94
95
96
97 static Segment* NewSegFromDef (SegDef* Def)
98 /* Create a new segment from a segment definition. Used only internally, no
99  * checks.
100  */
101 {
102     /* Create a new segment */
103     Segment* S = xmalloc (sizeof (*S));
104
105     /* Initialize it */
106     S->Root      = 0;
107     S->Last      = 0;
108     S->FragCount = 0;
109     S->Num       = CollCount (&SegmentList);
110     S->Align     = 1;
111     S->RelocMode = 1;
112     S->PC        = 0;
113     S->AbsPC     = 0;
114     S->Def       = Def;
115
116     /* Insert it into the segment list */
117     CollAppend (&SegmentList, S);
118
119     /* And return it... */
120     return S;
121 }
122
123
124
125 static Segment* NewSegment (const char* Name, unsigned char AddrSize)
126 /* Create a new segment, insert it into the global list and return it */
127 {
128     /* Check for too many segments */
129     if (CollCount (&SegmentList) >= 256) {
130         Fatal ("Too many segments");
131     }
132
133     /* Check the segment name for invalid names */
134     if (!ValidSegName (Name)) {
135         Error ("Illegal segment name: `%s'", Name);
136     }
137
138     /* Create a new segment and return it */
139     return NewSegFromDef (NewSegDef (Name, AddrSize));
140 }
141
142
143
144 Fragment* GenFragment (unsigned char Type, unsigned short Len)
145 /* Generate a new fragment, add it to the current segment and return it. */
146 {
147     /* Create the new fragment */
148     Fragment* F = NewFragment (Type, Len);
149
150     /* Insert the fragment into the current segment */
151     if (ActiveSeg->Root) {
152         ActiveSeg->Last->Next = F;
153         ActiveSeg->Last = F;
154     } else {
155         ActiveSeg->Root = ActiveSeg->Last = F;
156     }
157     ++ActiveSeg->FragCount;
158
159     /* Add this fragment to the current listing line */
160     if (LineCur) {
161         if (LineCur->FragList == 0) {
162             LineCur->FragList = F;
163         } else {
164             LineCur->FragLast->LineList = F;
165         }
166         LineCur->FragLast = F;
167     }
168
169     /* Increment the program counter */
170     ActiveSeg->PC += F->Len;
171     if (OrgPerSeg) {
172         /* Relocatable mode is switched per segment */
173         if (!ActiveSeg->RelocMode) {
174             ActiveSeg->AbsPC += F->Len;
175         }
176     } else {
177         /* Relocatable mode is switched globally */
178         if (!RelocMode) {
179             AbsPC += F->Len;
180         }
181     }
182
183     /* Return the fragment */
184     return F;
185 }
186
187
188
189 void UseSeg (const SegDef* D)
190 /* Use the segment with the given name */
191 {
192     unsigned I;
193     for (I = 0; I < CollCount (&SegmentList); ++I) {
194         Segment* Seg = CollAtUnchecked (&SegmentList, I);
195         if (strcmp (Seg->Def->Name, D->Name) == 0) {
196             /* We found this segment. Check if the type is identical */
197             if (D->AddrSize != ADDR_SIZE_DEFAULT &&
198                 Seg->Def->AddrSize != D->AddrSize) {
199                 Error ("Segment attribute mismatch");
200                 /* Use the new attribute to avoid errors */
201                 Seg->Def->AddrSize = D->AddrSize;
202             }
203             ActiveSeg = Seg;
204             return;
205         }
206     }
207
208     /* Segment is not in list, create a new one */
209     if (D->AddrSize == ADDR_SIZE_DEFAULT) {
210         ActiveSeg = NewSegment (D->Name, ADDR_SIZE_ABS);
211     } else {
212         ActiveSeg = NewSegment (D->Name, D->AddrSize);
213     }
214 }
215
216
217
218 unsigned long GetPC (void)
219 /* Get the program counter of the current segment */
220 {
221     if (OrgPerSeg) {
222         /* Relocatable mode is switched per segment */
223         return ActiveSeg->RelocMode? ActiveSeg->PC : ActiveSeg->AbsPC;
224     } else {
225         /* Relocatable mode is switched globally */
226         return RelocMode? ActiveSeg->PC : AbsPC;
227     }
228 }
229
230
231
232 void EnterAbsoluteMode (unsigned long PC)
233 /* Enter absolute (non relocatable mode). Depending on the OrgPerSeg flag,
234  * this will either switch the mode globally or for the current segment.
235  */
236 {
237     if (OrgPerSeg) {
238         /* Relocatable mode is switched per segment */
239         ActiveSeg->RelocMode = 0;
240         ActiveSeg->AbsPC = PC;
241     } else {
242         /* Relocatable mode is switched globally */
243         RelocMode = 0;
244         AbsPC = PC;
245     }
246 }
247
248
249
250 int GetRelocMode (void)
251 /* Return true if we're currently in relocatable mode */
252 {
253     if (OrgPerSeg) {
254         /* Relocatable mode is switched per segment */
255         return ActiveSeg->RelocMode;
256     } else {
257         /* Relocatable mode is switched globally */
258         return RelocMode;
259     }
260 }
261
262
263
264 void EnterRelocMode (void)
265 /* Enter relocatable mode. Depending on the OrgPerSeg flag, this will either
266  * switch the mode globally or for the current segment.
267  */
268 {
269     if (OrgPerSeg) {
270         /* Relocatable mode is switched per segment */
271         ActiveSeg->RelocMode = 1;
272     } else {
273         /* Relocatable mode is switched globally */
274         RelocMode = 1;
275     }
276 }
277
278
279
280 void SegAlign (unsigned long Alignment, int FillVal)
281 /* Align the PC segment to Alignment. If FillVal is -1, emit fill fragments
282  * (the actual fill value will be determined by the linker), otherwise use
283  * the given value.
284  */
285 {
286     unsigned char Data [4];
287     unsigned long CombinedAlignment;
288     unsigned long Count;
289
290     /* The segment must have the combined alignment of all separate alignments
291      * in the source. Calculate this alignment and check it for sanity.
292      */
293     CombinedAlignment = LeastCommonMultiple (ActiveSeg->Align, Alignment);
294     if (CombinedAlignment > MAX_ALIGNMENT) {
295         Error ("Combined alignment for active segment is %lu which exceeds %lu",
296                CombinedAlignment, MAX_ALIGNMENT);
297
298         /* Avoid creating large fills for an object file that is thrown away
299          * later.
300          */
301         Count = 1;
302
303     } else {
304         ActiveSeg->Align = CombinedAlignment;
305
306         /* Output a warning for larger alignments if not suppressed */
307         if (CombinedAlignment > LARGE_ALIGNMENT && !LargeAlignment) {
308             Warning (0, "Combined alignment is suspiciously large (%lu)",
309                      CombinedAlignment);
310         }
311
312         /* Calculate the number of fill bytes */
313         Count = AlignCount (ActiveSeg->PC, Alignment) - ActiveSeg->PC;
314
315     }
316
317
318     /* Emit the data or a fill fragment */
319     if (FillVal != -1) {
320         /* User defined fill value */
321         memset (Data, FillVal, sizeof (Data));
322         while (Count) {
323             if (Count > sizeof (Data)) {
324                 EmitData (Data, sizeof (Data));
325                 Count -= sizeof (Data);
326             } else {
327                 EmitData (Data, Count);
328                 Count = 0;
329             }
330         }
331     } else {
332         /* Linker defined fill value */
333         EmitFill (Count);
334     }
335 }
336
337
338
339 unsigned char GetSegAddrSize (unsigned SegNum)
340 /* Return the address size of the segment with the given number */
341 {
342     /* Is there such a segment? */
343     if (SegNum >= CollCount (&SegmentList)) {
344         FAIL ("Invalid segment number");
345     }
346
347     /* Return the address size */
348     return ((Segment*) CollAtUnchecked (&SegmentList, SegNum))->Def->AddrSize;
349 }
350
351
352
353 void SegDone (void)
354 /* Check the segments for range and other errors. Do cleanup. */
355 {
356     static const unsigned long U_Hi[4] = {
357         0x000000FFUL, 0x0000FFFFUL, 0x00FFFFFFUL, 0xFFFFFFFFUL
358     };
359     static const long S_Hi[4] = {
360         0x0000007FL, 0x00007FFFL, 0x007FFFFFL, 0x7FFFFFFFL
361     };
362
363     unsigned I;
364     for (I = 0; I < CollCount (&SegmentList); ++I) {
365         Segment* S = CollAtUnchecked (&SegmentList, I);
366         Fragment* F = S->Root;
367         while (F) {
368             if (F->Type == FRAG_EXPR || F->Type == FRAG_SEXPR) {
369
370                 /* We have an expression, study it */
371                 ExprDesc ED;
372                 ED_Init (&ED);
373                 StudyExpr (F->V.Expr, &ED);
374
375                 /* Check if the expression is constant */
376                 if (ED_IsConst (&ED)) {
377
378                     unsigned J;
379
380                     /* The expression is constant. Check for range errors. */
381                     CHECK (F->Len <= 4);
382                     if (F->Type == FRAG_SEXPR) {
383                         long Hi = S_Hi[F->Len-1];
384                         long Lo = ~Hi;
385                         if (ED.Val > Hi || ED.Val < Lo) {
386                             LIError (&F->LI,
387                                      "Range error (%ld not in [%ld..%ld])",
388                                      ED.Val, Lo, Hi);
389                         }
390                     } else {
391                         if (((unsigned long)ED.Val) > U_Hi[F->Len-1]) {
392                             LIError (&F->LI,
393                                      "Range error (%lu not in [0..%lu])",
394                                      (unsigned long)ED.Val, U_Hi[F->Len-1]);
395                         }
396                     }
397
398                     /* We don't need the expression tree any longer */
399                     FreeExpr (F->V.Expr);
400
401                     /* Convert the fragment into a literal fragment */
402                     for (J = 0; J < F->Len; ++J) {
403                         F->V.Data[J] = ED.Val & 0xFF;
404                         ED.Val >>= 8;
405                     }
406                     F->Type = FRAG_LITERAL;
407
408                 } else {
409
410                     /* Finalize the expression */
411                     F->V.Expr = FinalizeExpr (F->V.Expr, &F->LI);        
412
413                     /* Simplify the expression */
414                     /* ### F->V.Expr = SimplifyExpr (F->V.Expr, &ED); */
415
416                     /* We cannot evaluate the expression now, leave the job for
417                      * the linker. However, we can check if the address size
418                      * matches the fragment size, and we will do so.
419                      */
420                     if ((F->Len == 1 && ED.AddrSize > ADDR_SIZE_ZP)  ||
421                         (F->Len == 2 && ED.AddrSize > ADDR_SIZE_ABS) ||
422                         (F->Len == 3 && ED.AddrSize > ADDR_SIZE_FAR)) {
423                         LIError (&F->LI, "Range error");
424                     }
425                 }
426
427                 /* Release memory allocated for the expression decriptor */
428                 ED_Done (&ED);
429             }
430             F = F->Next;
431         }
432     }
433 }
434
435
436
437 void SegDump (void)
438 /* Dump the contents of all segments */
439 {
440     unsigned I;
441     unsigned X = 0;
442
443     printf ("\n");
444     for (I = 0; I < CollCount (&SegmentList); ++I) {
445         Segment* S = CollAtUnchecked (&SegmentList, I);
446         unsigned I;
447         Fragment* F;
448         int State = -1;
449         printf ("New segment: %s", S->Def->Name);
450         F = S->Root;
451         while (F) {
452             if (F->Type == FRAG_LITERAL) {
453                 if (State != 0) {
454                     printf ("\n  Literal:");
455                     X = 15;
456                     State = 0;
457                 }
458                 for (I = 0; I < F->Len; ++I) {
459                     printf (" %02X", F->V.Data [I]);
460                     X += 3;
461                 }
462             } else if (F->Type == FRAG_EXPR || F->Type == FRAG_SEXPR) {
463                 State = 1;
464                 printf ("\n  Expression (%u): ", F->Len);
465                 DumpExpr (F->V.Expr, SymResolve);
466             } else if (F->Type == FRAG_FILL) {
467                 State = 1;
468                 printf ("\n  Fill bytes (%u)", F->Len);
469             } else {
470                 Internal ("Unknown fragment type: %u", F->Type);
471             }
472             if (X > 65) {
473                 State = -1;
474             }
475             F = F->Next;
476         }
477         printf ("\n  End PC = $%04X\n", (unsigned)(S->PC & 0xFFFF));
478     }
479     printf ("\n");
480 }
481
482
483
484 void SegInit (void)
485 /* Initialize segments */
486 {
487     /* Create the predefined segments. Code segment is active */
488     ActiveSeg = NewSegFromDef (&CodeSegDef);
489     NewSegFromDef (&RODataSegDef);
490     NewSegFromDef (&BssSegDef);
491     NewSegFromDef (&DataSegDef);
492     NewSegFromDef (&ZeropageSegDef);
493     NewSegFromDef (&NullSegDef);
494 }
495
496
497
498 void SetSegmentSizes (void)
499 /* Set the default segment sizes according to the memory model */
500 {
501     /* Initialize segment sizes. The segment definitions do already contain
502      * the correct values for the default case (near), so we must only change
503      * things that should be different.
504      */
505     switch (MemoryModel) {
506
507         case MMODEL_NEAR:
508             break;
509
510         case MMODEL_FAR:
511             CodeSegDef.AddrSize = ADDR_SIZE_FAR;
512             break;
513
514         case MMODEL_HUGE:
515             CodeSegDef.AddrSize   = ADDR_SIZE_FAR;
516             DataSegDef.AddrSize   = ADDR_SIZE_FAR;
517             BssSegDef.AddrSize    = ADDR_SIZE_FAR;
518             RODataSegDef.AddrSize = ADDR_SIZE_FAR;
519             break;
520
521         default:
522             Internal ("Invalid memory model: %d", MemoryModel);
523     }
524 }
525
526
527
528 static void WriteOneSeg (Segment* Seg)
529 /* Write one segment to the object file */
530 {
531     Fragment* Frag;
532     unsigned long DataSize;
533     unsigned long EndPos;
534
535     /* Remember the file position, then write a dummy for the size of the
536      * following data
537      */
538     unsigned long SizePos = ObjGetFilePos ();
539     ObjWrite32 (0);
540
541     /* Write the segment data */
542     ObjWriteVar (GetStringId (Seg->Def->Name)); /* Name of the segment */
543     ObjWriteVar (Seg->PC);                      /* Size */
544     ObjWriteVar (Seg->Align);                   /* Segment alignment */
545     ObjWrite8 (Seg->Def->AddrSize);             /* Address size of the segment */
546     ObjWriteVar (Seg->FragCount);               /* Number of fragments */
547
548     /* Now walk through the fragment list for this segment and write the
549      * fragments.
550      */
551     Frag = Seg->Root;
552     while (Frag) {
553
554         /* Write data depending on the type */
555         switch (Frag->Type) {
556
557             case FRAG_LITERAL:
558                 ObjWrite8 (FRAG_LITERAL);
559                 ObjWriteVar (Frag->Len);
560                 ObjWriteData (Frag->V.Data, Frag->Len);
561                 break;
562
563             case FRAG_EXPR:
564                 switch (Frag->Len) {
565                     case 1:   ObjWrite8 (FRAG_EXPR8);   break;
566                     case 2:   ObjWrite8 (FRAG_EXPR16);  break;
567                     case 3:   ObjWrite8 (FRAG_EXPR24);  break;
568                     case 4:   ObjWrite8 (FRAG_EXPR32);  break;
569                     default:  Internal ("Invalid fragment size: %u", Frag->Len);
570                 }
571                 WriteExpr (Frag->V.Expr);
572                 break;
573
574             case FRAG_SEXPR:
575                 switch (Frag->Len) {
576                     case 1:   ObjWrite8 (FRAG_SEXPR8);  break;
577                     case 2:   ObjWrite8 (FRAG_SEXPR16); break;
578                     case 3:   ObjWrite8 (FRAG_SEXPR24); break;
579                     case 4:   ObjWrite8 (FRAG_SEXPR32); break;
580                     default:  Internal ("Invalid fragment size: %u", Frag->Len);
581                 }
582                 WriteExpr (Frag->V.Expr);
583                 break;
584
585             case FRAG_FILL:
586                 ObjWrite8 (FRAG_FILL);
587                 ObjWriteVar (Frag->Len);
588                 break;
589
590             default:
591                 Internal ("Invalid fragment type: %u", Frag->Type);
592
593         }
594
595         /* Write the line infos for this fragment */
596         WriteLineInfo (&Frag->LI);
597
598         /* Next fragment */
599         Frag = Frag->Next;
600     }
601
602     /* Calculate the size of the data, seek back and write it */
603     EndPos = ObjGetFilePos ();          /* Remember where we are */
604     DataSize = EndPos - SizePos - 4;    /* Don't count size itself */
605     ObjSetFilePos (SizePos);            /* Seek back to the size */
606     ObjWrite32 (DataSize);              /* Write the size */
607     ObjSetFilePos (EndPos);             /* Seek back to the end */
608 }
609
610
611
612 void WriteSegments (void)
613 /* Write the segment data to the object file */
614 {
615     unsigned I;
616
617     /* Tell the object file module that we're about to start the seg list */
618     ObjStartSegments ();
619
620     /* First thing is segment count */
621     ObjWriteVar (CollCount (&SegmentList));
622
623     /* Now walk through all segments and write them to the object file */
624     for (I = 0; I < CollCount (&SegmentList); ++I) {
625         /* Write one segment */
626         WriteOneSeg (CollAtUnchecked (&SegmentList, I));
627     }
628
629     /* Done writing segments */
630     ObjEndSegments ();
631 }
632
633
634
635