96a91307beec5863a725115295c67055014202bd
[fw/sdcc] / as / link / mcs51 / lkarea.c
1 /* lkarea.c */
2
3 /*
4  * (C) Copyright 1989-1995
5  * All Rights Reserved
6  *
7  * Alan R. Baldwin
8  * 721 Berkeley St.
9  * Kent, Ohio  44240
10  *
11  *  3-Nov-97 JLH:
12  *           - change lkparea to use a_type == 0 as "virgin area" flag
13  * 02-Apr-98 JLH: add code to link 8051 data spaces
14  */
15
16 #include <stdio.h>
17 #include <string.h>
18 #include "aslink.h"
19
20 /*)Module   lkarea.c
21  *
22  *  The module lkarea.c contains the functions which
23  *  create and link together all area definitions read
24  *  from the .rel file(s).
25  *
26  *  lkarea.c contains the following functions:
27  *      VOID    lnkarea()
28  *      VOID    lnksect()
29  *      VOID    lkparea()
30  *      VOID    newarea()
31  *
32  *  lkarea.c contains no global variables.
33  */
34
35 /*)Function VOID    newarea()
36  *
37  *  The function newarea() creates and/or modifies area
38  *  and areax structures for each A directive read from
39  *  the .rel file(s).  The function lkparea() is called
40  *  to find the area structure associated with this name.
41  *  If the area does not yet exist then a new area
42  *  structure is created and linked to any existing
43  *  linked area structures. The area flags are copied
44  *  into the area flag variable.  For each occurence of
45  *  an A directive an areax structure is created and
46  *  linked to the areax structures associated with this
47  *  area.  The size of this area section is placed into
48  *  the areax structure.  The flag value for all subsequent
49  *  area definitions for the same area are compared and
50  *  flagged as an error if they are not identical.
51  *  The areax structure created for every occurence of
52  *  an A directive is loaded with a pointer to the base
53  *  area structure and a pointer to the associated
54  *  head structure.  And finally, a pointer to this
55  *  areax structure is loaded into the list of areax
56  *  structures in the head structure.  Refer to lkdata.c
57  *  for details of the structures and their linkage.
58  *
59  *  local variables:
60  *      areax **halp        pointer to an array of pointers
61  *      int     i           counter, loop variable, value
62  *      char    id[]        id string
63  *      int     narea       number of areas in this head structure
64  *      areax * taxp        pointer to an areax structure
65  *                          to areax structures
66  *
67  *  global variables:
68  *      area    *ap         Pointer to the current
69  *                          area structure
70  *      areax   *axp        Pointer to the current
71  *                          areax structure
72  *      head    *hp         Pointer to the current
73  *                          head structure
74  *      int     lkerr       error flag
75  *
76  *  functions called:
77  *      Addr_T  eval()      lkeval.c
78  *      VOID    exit()      c_library
79  *      int     fprintf()   c_library
80  *      VOID    getid()     lklex.c
81  *      VOID    lkparea()   lkarea.c
82  *      VOID    skip()      lklex.c
83  *
84  *  side effects:
85  *      The area and areax structures are created and
86  *      linked with the appropriate head structures.
87  *      Failure to allocate area or areax structure
88  *      space will terminate the linker.  Other internal
89  *      errors most likely caused by corrupted .rel
90  *      files will also terminate the linker.
91  */
92
93 /*
94  * Create an area entry.
95  *
96  * A xxxxxx size nnnn flags mm
97  *   |           |          |
98  *   |           |          `--  ap->a_flag
99  *   |           `------------- axp->a_size
100  *   `-------------------------  ap->a_id
101  *
102  */
103 VOID
104 newarea()
105 {
106     register int i, narea;
107     struct areax *taxp;
108     struct areax **halp;
109     char id[NCPS];
110
111     /*
112      * Create Area entry
113      */
114     getid(id, -1);
115     lkparea(id);
116     /*
117      * Evaluate area size
118      */
119     skip(-1);
120     axp->a_size = eval();
121     /*
122      * Evaluate flags
123      */
124     skip(-1);
125     i = 0;
126     taxp = ap->a_axp;
127     while (taxp->a_axp) {
128         ++i;
129         taxp = taxp->a_axp;
130     }
131     if (i == 0) {
132         ap->a_flag = eval();
133     } else {
134         i = eval();
135 /*      if (i && (ap->a_flag != i)) { */
136 /*          fprintf(stderr, "Conflicting flags in area %8s\n", id); */
137 /*          lkerr++; */
138 /*      } */
139     }
140     /*
141      * Evaluate area address
142      */
143     skip(-1);
144     axp->a_addr = eval();
145     /*
146      * Place pointer in header area list
147      */
148     if (headp == NULL) {
149         fprintf(stderr, "No header defined\n");
150         lkexit(1);
151     }
152     narea = hp->h_narea;
153     halp = hp->a_list;
154     for (i=0; i < narea ;++i) {
155         if (halp[i] == NULL) {
156             halp[i] = taxp;
157             return;
158         }
159     }
160     fprintf(stderr, "Header area list overflow\n");
161     lkexit(1);
162 }
163
164 /*)Function VOID    lkparea(id)
165  *
166  *      char *  id      pointer to the area name string
167  *
168  *  The function lkparea() searches the linked area structures
169  *  for a name match.  If the name is not found then an area
170  *  structure is created.  An areax structure is created and
171  *  appended to the areax structures linked to the area structure.
172  *  The associated base area and head structure pointers are
173  *  loaded into the areax structure.
174  *
175  *  local variables:
176  *      area *  tap         pointer to an area structure
177  *      areax * taxp        pointer to an areax structure
178  *
179  *  global variables:
180  *      area    *ap         Pointer to the current
181  *                          area structure
182  *      area    *areap      The pointer to the first
183  *                          area structure of a linked list
184  *      areax   *axp        Pointer to the current
185  *                          areax structure
186  *
187  *  functions called:
188  *      VOID *  new()       lksym()
189  *      char *  strcpy()    c_library
190  *      int     symeq()     lksym.c
191  *
192  *  side effects:
193  *      Area and/or areax structures are created.
194  *      Failure to allocate space for created structures
195  *      will terminate the linker.
196  */
197
198 VOID
199 lkparea(char *id)
200 {
201     register struct area *tap;
202     register struct areax *taxp;
203
204     ap = areap;
205     axp = (struct areax *) new (sizeof(struct areax));
206     axp->a_addr = -1; /* default: no address yet */
207     while (ap) {
208         if (symeq(id, ap->a_id)) {
209             taxp = ap->a_axp;
210             while (taxp->a_axp)
211                 taxp = taxp->a_axp;
212             taxp->a_axp = axp;
213             axp->a_bap = ap;
214             axp->a_bhp = hp;
215             return;
216         }
217         ap = ap->a_ap;
218     }
219     ap = (struct area *) new (sizeof(struct area));
220     if (areap == NULL) {
221         areap = ap;
222     } else {
223         tap = areap;
224         while (tap->a_ap)
225             tap = tap->a_ap;
226         tap->a_ap = ap;
227     }
228     ap->a_axp = axp;
229     axp->a_bap = ap;
230     axp->a_bhp = hp;
231     strncpy(ap->a_id, id, NCPS);
232     ap->a_addr = 0;
233 }
234
235 /*)Function VOID    lnkarea()
236  *
237  *  The function lnkarea() resolves all area addresses.
238  *  The function evaluates each area structure (and all
239  *  the associated areax structures) in sequence.  The
240  *  linking process supports four (4) possible area types:
241  *
242  *  ABS/OVR -   All sections (each individual areax
243  *          section) starts at the identical base
244  *          area address overlaying all other
245  *          areax sections for this area.  The
246  *          size of the area is largest of the area
247  *          sections.
248  *
249  *  ABS/CON -   All sections (each individual areax
250  *          section) are concatenated with the
251  *          first section starting at the base
252  *          area address.  The size of the area
253  *          is the sum of the section sizes.
254  *
255  *  NOTE:   Multiple absolute (ABS) areas are
256  *          never concatenated with each other,
257  *          thus absolute area A and absolute area
258  *          B will overlay each other if they begin
259  *          at the same location (the default is
260  *          always address 0 for absolute areas).
261  *
262  *  REL/OVR -   All sections (each individual areax
263  *          section) starts at the identical base
264  *          area address overlaying all other
265  *          areax sections for this area.  The
266  *          size of the area is largest of the area
267  *          sections.
268  *
269  *  REL/CON -   All sections (each individual areax
270  *          section) are concatenated with the
271  *          first section starting at the base
272  *          area address.  The size of the area
273  *          is the sum of the section sizes.
274  *
275  *  NOTE:   Relocatable (REL) areas are always concatenated
276  *          with each other, thus relocatable area B
277  *          (defined after area A) will follow
278  *          relocatable area A independent of the
279  *          starting address of area A.  Within a
280  *          specific area each areax section may be
281  *          overlayed or concatenated with other
282  *          areax sections.
283  *
284  *
285  *  If a base address for an area is specified then the
286  *  area will start at that address.  Any relocatable
287  *  areas defined subsequently will be concatenated to the
288  *  previous relocatable area if it does not have a base
289  *  address specified.
290  *
291  *  The names s_<areaname> and l_<areaname> are created to
292  *  define the starting address and length of each area.
293  *
294  *  local variables:
295  *      Addr_T  rloc        ;current relocation address
296  *      char    temp[]      ;temporary string
297  *      struct symbol   *sp ;symbol structure
298  *
299  *  global variables:
300  *      area    *ap         Pointer to the current
301  *                          area structure
302  *      area    *areap      The pointer to the first
303  *                          area structure of a linked list
304  *
305  *  functions called:
306  *      int     fprintf()   c_library
307  *      VOID    lnksect()   lkarea.c
308  *      symbol *lkpsym()    lksym.c
309  *      char *  strncpy()   c_library
310  *      int     symeq()     lksym.c
311  *
312  *  side effects:
313  *      All area and areax addresses and sizes are
314  *      determined and saved in their respective
315  *      structures.
316  */
317
318 /*
319  * Resolve all area addresses.
320  */
321 VOID
322 lnkarea()
323 {
324     Addr_T rloc[4];
325     int  locIndex;
326     char temp[NCPS];
327     struct sym *sp;
328     /*JCF: used to save the REG_BANK_[0-3] and SBIT_BYTES area pointers*/
329     struct area *ta[5];
330     int j;
331
332     rloc[0] = rloc[1] = rloc[2] = rloc[3] = 0;
333     ap = areap;
334     while (ap) {
335         if (ap->a_flag&A_ABS) {
336             /*
337              * Absolute sections
338              */
339             lnksect(ap);
340         } else {
341             /* Determine memory space */
342             locIndex = 0;
343             if (ap->a_flag & A_CODE) {
344                 locIndex = 1;
345             }
346             if (ap->a_flag & A_XDATA) {
347                 locIndex = 2;
348             }
349             if (ap->a_flag & A_BIT) {
350                 locIndex = 3;
351             }
352             /*
353              * Relocatable sections
354              */
355             if (ap->a_type == 0) {  /* JLH */
356                 ap->a_addr = rloc[ locIndex ];
357                 ap->a_type = 1;
358             }
359             lnksect(ap);
360             rloc[ locIndex ] = ap->a_addr + ap->a_size;
361         }
362
363         /*
364          * Create symbols called:
365          *  s_<areaname>    the start address of the area
366          *  l_<areaname>    the length of the area
367          */
368
369         if (! symeq(ap->a_id, _abs_)) {
370             strncpy(temp+2,ap->a_id,NCPS-2);
371             *(temp+1) = '_';
372
373             *temp = 's';
374             sp = lkpsym(temp, 1);
375             sp->s_addr = ap->a_addr ;
376             /* sp->s_axp = ap->a_axp;  JLH: was NULL; */
377             sp->s_type |= S_DEF;
378
379             *temp = 'l';
380             sp = lkpsym(temp, 1);
381             sp->s_addr = ap->a_size;
382             sp->s_axp = NULL;
383             sp->s_type |= S_DEF;
384
385         }
386
387         /*JCF: Since area BSEG is defined just before BSEG_BYTES, use the bit size of BSEG
388         to compute the byte size of BSEG_BYTES: */
389         if (!strcmp(ap->a_id, "BSEG")) {
390             ap->a_ap->a_axp->a_size += ((ap->a_addr + ap->a_size + 7)/8); /*Bits to bytes*/
391         }
392         else if (!strcmp(ap->a_id, "REG_BANK_0")) ta[0]=ap;
393         else if (!strcmp(ap->a_id, "REG_BANK_1")) ta[1]=ap;
394         else if (!strcmp(ap->a_id, "REG_BANK_2")) ta[2]=ap;
395         else if (!strcmp(ap->a_id, "REG_BANK_3")) ta[3]=ap;
396         else if (!strcmp(ap->a_id, "BSEG_BYTES"))
397         {
398             ta[4]=ap;
399             for(j=4; j>1; j--)
400             {
401                 /*If upper register banks are not used roll back the relocation counter*/
402                 if ( (ta[j]->a_size==0) && (ta[j-1]->a_size==0) )
403                 {
404                     rloc[0]-=8;
405                 }
406                 else break;
407             }
408         }
409         ap = ap->a_ap;
410     }
411 }
412
413 /*)Function VOID    lnksect()
414  *
415  *      area *  tap         pointer to an area structure
416  *
417  *  The function lnksect() is the function called by
418  *  lnkarea() to resolve the areax addresses.  Refer
419  *  to the function lnkarea() for more detail. Pageing
420  *  boundary and length errors will be reported by this
421  *  function.
422  *
423  *  local variables:
424  *      Addr_T  size        size of area
425  *      Addr_T  addr        address of area
426  *      areax * taxp        pointer to an areax structure
427  *
428  *  global variables:
429  *      int     lkerr       error flag
430  *
431  *  functions called:
432  *      none
433  *
434  *  side effects:
435  *      All area and areax addresses and sizes area determined
436  *      and linked into the structures.
437  */
438
439 VOID
440 lnksect(register struct area *tap)
441 {
442     register Addr_T size, addr;
443     register struct areax *taxp;
444
445     size = 0;
446     addr = tap->a_addr;
447 #if 0
448     if ((tap->a_flag&A_PAG) && (addr & 0xFF)) {
449         fprintf(stderr,
450         "\n?ASlink-Warning-Paged Area %8s Boundary Error\n", tap->a_id);
451         lkerr++;
452     }
453 #endif
454     taxp = tap->a_axp;
455     if (tap->a_flag&A_OVR) {
456         /*
457          * Overlayed sections
458          */
459         while (taxp) {
460             taxp->a_addr = addr;
461             if (taxp->a_size > size)
462                 size = taxp->a_size;
463             taxp = taxp->a_axp;
464         }
465     } else {
466         /*
467          * Concatenated sections
468          */
469         while (taxp) {
470             taxp->a_addr = addr;
471             addr += taxp->a_size;
472             size += taxp->a_size;
473             taxp = taxp->a_axp;
474         }
475     }
476     tap->a_size = size;
477     if ((tap->a_flag&A_PAG) && (size > 256)) {
478         fprintf(stderr,
479         "\n?ASlink-Warning-Paged Area %8s Length Error\n", tap->a_id);
480         lkerr++;
481     }
482     if ((tap->a_flag&A_PAG) && (tap->a_size) &&
483         ((tap->a_addr & 0xFFFFFF00) != ((addr-1) & 0xFFFFFF00)))
484     {
485         fprintf(stderr,
486         "\n?ASlink-Warning-Paged Area %8s Boundary Error\n", tap->a_id);
487         lkerr++;
488     }
489 }
490
491 Addr_T lnksect2 (struct area *tap, int locIndex);
492 char idatamap[256];
493 unsigned long codemap[524288];
494 unsigned long xdatamap[131072];
495
496 /*Modified version of the functions for packing variables in internal data memory*/
497 VOID lnkarea2 (void)
498 {
499     Addr_T rloc[4]={0, 0, 0, 0};
500     Addr_T gs_size = 0;
501     int  locIndex;
502     char temp[NCPS];
503     struct sym *sp;
504     int j;
505     struct area *dseg_ap = NULL;
506     struct area *abs_ap = NULL;
507     struct area *gs0_ap = NULL;
508     struct sym *sp_dseg_s=NULL, *sp_dseg_l=NULL;
509
510     for(j=0; j<256; j++) idatamap[j]=' ';
511     memset(codemap, 0, sizeof(codemap));
512     memset(xdatamap, 0, sizeof(xdatamap));
513
514     /* first sort all absolute areas to the front */
515     ap = areap;
516     /* no need to check first area, it's in front anyway */
517     while (ap && ap->a_ap)
518     {
519         if (ap->a_ap->a_flag & A_ABS)
520         {/* next area is absolute, move it to front,
521             reversed sequence is no problem for absolutes */
522             abs_ap = ap->a_ap;
523             ap->a_ap = abs_ap->a_ap;
524             abs_ap->a_ap = areap;
525             areap = abs_ap;
526         }
527         else
528         {
529             ap = ap->a_ap;
530         }
531     }
532
533     /* next accumulate all GSINITx/GSFINAL area sizes
534        into GSINIT so they stay together */
535     ap = areap;
536     while (ap)
537     {
538         if (!strncmp(ap->a_id, "GS", 2))
539         {/* GSxxxxx area */
540             if (ap->a_size == 0)
541             {
542                 axp = ap->a_axp;
543                 while (axp)
544                 {
545                     ap->a_size += axp->a_size;
546                     axp = axp->a_axp;
547                 }
548             }
549             gs_size += ap->a_size;
550             if (!strcmp(ap->a_id, "GSINIT0"))
551             {/* GSINIT0 area */
552                 gs0_ap = ap;
553             }
554         }
555         ap = ap->a_ap;
556     }
557     if (gs0_ap)
558         gs0_ap->a_size = gs_size;
559
560     ap = areap;
561     while (ap)
562     {
563         /* Determine memory space */
564              if (ap->a_flag & A_CODE)  locIndex = 1;
565         else if (ap->a_flag & A_XDATA) locIndex = 2;
566         else if (ap->a_flag & A_BIT)   locIndex = 3;
567         else locIndex = 0;
568
569         if (ap->a_flag & A_ABS) /* Absolute sections */
570         {
571             lnksect2(ap, locIndex);
572         }
573         else /* Relocatable sections */
574         {
575             if (ap->a_type == 0)
576             {
577                 ap->a_addr = rloc[locIndex];
578                 ap->a_type = 1;
579             }
580
581             rloc[locIndex] = lnksect2(ap, locIndex);
582         }
583
584         /*
585          * Create symbols called:
586          *  s_<areaname>    the start address of the area
587          *  l_<areaname>    the length of the area
588          */
589
590         if (! symeq(ap->a_id, _abs_))
591         {
592             strncpy(temp+2,ap->a_id,NCPS-2);
593             *(temp+1) = '_';
594
595             *temp = 's';
596             sp = lkpsym(temp, 1);
597             sp->s_addr = ap->a_addr ;
598             sp->s_type |= S_DEF;
599             if (!strcmp(ap->a_id, "DSEG")) sp_dseg_s=sp;
600
601             *temp = 'l';
602             sp = lkpsym(temp, 1);
603             sp->s_addr = ap->a_size;
604             sp->s_axp = NULL;
605             sp->s_type |= S_DEF;
606             if (!strcmp(ap->a_id, "DSEG")) sp_dseg_l=sp;
607         }
608
609         /*Since area BSEG is defined just before BSEG_BYTES, use the bit size of BSEG
610         to compute the byte size of BSEG_BYTES: */
611         if (!strcmp(ap->a_id, "BSEG"))
612         {
613             ap->a_ap->a_axp->a_size = ((ap->a_addr + ap->a_size + 7)/8); /*Bits to bytes*/
614         }
615         else if (!strcmp(ap->a_id, "DSEG"))
616         {
617             dseg_ap=ap; /*Need it later to set its correct size*/
618         }
619         ap = ap->a_ap;
620     }
621
622     /*Compute the size of DSEG*/
623     if(dseg_ap!=NULL)
624     {
625         dseg_ap->a_addr=0;
626         dseg_ap->a_size=0;
627         for(j=0; j<0x80; j++) if(idatamap[j]!=' ') dseg_ap->a_size++;
628     }
629     if(sp_dseg_s!=NULL) sp_dseg_s->s_addr=0;
630     if(sp_dseg_l!=NULL) sp_dseg_l->s_addr=dseg_ap->a_size;
631 }
632
633 static
634 Addr_T find_empty_space(Addr_T start, Addr_T size, unsigned long *map)
635 {
636     int i, j, k;
637     unsigned long mask, b;
638
639     while (1)
640     {
641         Addr_T a = start;
642         i = start >> 5;
643         j = (start + size) >> 5;
644         mask = -(1 << (start & 0x1F));
645
646         while (i < j)
647         {
648             if (map[i] & mask)
649             {
650                 k = 32;
651                 for (b=0x80000000; b!=0; b>>=1, k--)
652                 {
653                     if (map[i] & b)
654                       break;
655                 }
656                 start = a + k;
657                 break;
658             }
659             i++;
660             mask = 0xFFFFFFFF;
661             a += 32;
662         }
663         if (start > a)
664           continue;
665
666         mask &= (1 << ((start + size) & 0x1F)) - 1;
667         if (map[i] & mask)
668         {
669             k = 32;
670             for (b=0x80000000; b!=0; b>>=1, k--)
671             {
672                 if (map[i] & b)
673                     break;
674             }
675             start = (a & ~0x1F) + k;
676         }
677         if (start <= a)
678           break;
679     }
680     return start;
681 }
682
683 static
684 Addr_T allocate_space(Addr_T start, Addr_T size, char* id, unsigned long *map)
685 {
686     int i, j;
687     unsigned long mask;
688     Addr_T a = start;
689     i = start >> 5;
690     j = (start + size) >> 5;
691     mask = -(1 << (start & 0x1F));
692
693     while (i < j)
694     {
695         if (map[i] & mask)
696         {
697             fprintf(stderr, "memory overlap near 0x%X for %s\n", a, id);
698         }
699         map[i++] |= mask;
700         mask = 0xFFFFFFFF;
701         a += 32;
702     }
703     mask &= (1 << ((start + size) & 0x1F)) - 1;
704     if (map[i] & mask)
705     {
706         fprintf(stderr, "memory overlap near 0x%X for %s\n", a, id);
707     }
708     map[i] |= mask;
709     return start;
710 }
711
712 Addr_T lnksect2 (struct area *tap, int locIndex)
713 {
714     register Addr_T size, addr;
715     register struct areax *taxp;
716     int j, k, ramlimit;
717     char fchar=' ', dchar='a';
718     char ErrMsg[]="?ASlink-Error-Could not get %d consecutive byte%s"
719                   " in internal RAM for area %s.\n";
720
721     tap->a_unaloc=0;
722
723     /*Notice that only ISEG and SSEG can be in the indirectly addressable internal RAM*/
724     if( (!strcmp(tap->a_id, "ISEG")) || (!strcmp(tap->a_id, "SSEG")) )
725     {
726         if((iram_size<=0)||(iram_size>0x100))
727             ramlimit=0x100;
728         else
729             ramlimit=iram_size;
730     }
731     else
732     {
733         if((iram_size<=0)||(iram_size>0x80))
734             ramlimit=0x80;
735         else
736             ramlimit=iram_size;
737     }
738
739     size = 0;
740     addr = tap->a_addr;
741 #if 0
742     if ((tap->a_flag&A_PAG) && (addr & 0xFF))
743     {
744         fprintf(stderr,
745           "\n?ASlink-Warning-Paged Area %8s Boundary Error\n", tap->a_id);
746         lkerr++;
747     }
748 #endif
749     taxp = tap->a_axp;
750
751     /*Use a letter to identify each area in the internal RAM layout map*/
752     if (locIndex==0)
753     {
754         /**/ if(!strcmp(tap->a_id, "DSEG"))
755             fchar='D'; /*It will be converted to letters 'a' to 'z' later for each areax*/
756         else if(!strcmp(tap->a_id, "ISEG"))
757             fchar='I';
758         else if(!strcmp(tap->a_id, "SSEG"))
759             fchar='S';
760         else if(!strcmp(tap->a_id, "OSEG"))
761             fchar='Q';
762         else if(!strcmp(tap->a_id, "REG_BANK_0"))
763             fchar='0';
764         else if(!strcmp(tap->a_id, "REG_BANK_1"))
765             fchar='1';
766         else if(!strcmp(tap->a_id, "REG_BANK_2"))
767             fchar='2';
768         else if(!strcmp(tap->a_id, "REG_BANK_3"))
769             fchar='3';
770         else if(!strcmp(tap->a_id, "BSEG_BYTES"))
771             fchar='B';
772         else if(!strcmp(tap->a_id, "BIT_BANK"))
773             fchar='T';
774         else
775             fchar=' ';/*???*/
776     }
777     else if (locIndex == 1)
778     {
779         /**/ if(!strcmp(tap->a_id, "GSINIT"))
780             fchar='G';
781     }
782     else if (locIndex == 2)
783     {
784         /**/ if(!strcmp(tap->a_id, "XSTK"))
785             fchar='K';
786     }
787
788     if (tap->a_flag&A_OVR) /* Overlayed sections */
789     {
790         while (taxp)
791         {
792             if ( (fchar=='0')||(fchar=='1')||(fchar=='2')||(fchar=='3') ) /*Reg banks*/
793             {
794                 addr=(fchar-'0')*8;
795                 taxp->a_addr=addr;
796                 size=taxp->a_size;
797                 for(j=addr; (j<(int)(addr+taxp->a_size)) && (j<ramlimit); j++)
798                     idatamap[j]=fchar;
799             }
800             else if( (fchar=='S') || (fchar=='Q') ) /*Overlay and stack in internal RAM*/
801             {
802                 /*Find the size of the space currently used for this areax overlay*/
803                 for(j=0, size=0; j<ramlimit; j++)
804                     if(idatamap[j]==fchar) size++;
805
806                 if( (fchar=='S') && (stacksize==0) )
807                 {
808                    /*Search for the largest space available and use it for stack*/
809                     for(j=0, k=0, taxp->a_size=0; j<ramlimit; j++)
810                     {
811                         if(idatamap[j]==' ')
812                         {
813                             if((++k)>(int)taxp->a_size) taxp->a_size=k;
814                         }
815                         else
816                         {
817                             k=0;
818                         }
819                     }
820                     stacksize=taxp->a_size;
821                 }
822
823                 /*If more space required, release the previously allocated areax in
824                 internal RAM and search for a bigger one*/
825                 if((int)taxp->a_size>size)
826                 {
827                     size=(int)taxp->a_size;
828
829                     for(j=0; j<ramlimit; j++)
830                         if(idatamap[j]==fchar) idatamap[j]=' ';
831
832                     /*Search for a space large enough in data memory for this overlay areax*/
833                     for(j=0, k=0; j<ramlimit; j++)
834                     {
835                         if(idatamap[j]==' ')
836                             k++;
837                         else
838                             k=0;
839                         if(k==(int)taxp->a_size) break;
840                     }
841
842                     if(k==(int)taxp->a_size)
843                     {
844                         taxp->a_addr = j-k+1;
845                         if(addr<(unsigned int)ramlimit)
846                         {
847                             for(j=ramlimit-1; (j>=0)&&(idatamap[j]==' '); j--);
848                             if(j>=0) addr=j+1;
849                         }
850                     }
851
852                     /*Mark the memory used for overlay*/
853                     if(k==(int)taxp->a_size)
854                     {
855                         for(j=taxp->a_addr; (j<(int)(taxp->a_addr+taxp->a_size)) && (j<ramlimit); j++)
856                             idatamap[j]=fchar;
857
858                         /*Set the new size of the data memory area*/
859                         size=ramlimit-addr;
860                     }
861                     else /*Couldn't find a chunk big enough: report the problem.*/
862                     {
863                         tap->a_unaloc=taxp->a_size;
864                         fprintf(stderr, ErrMsg, taxp->a_size, taxp->a_size>1?"s":"", tap->a_id);
865                         lkerr++;
866                     }
867                 }
868
869                 for(j=0; j<ramlimit; j++)
870                 {
871                     if (idatamap[j]==fchar)
872                     {
873                         addr=j;
874                         tap->a_addr=addr;
875                         taxp->a_addr=addr;
876                         break;
877                     }
878                 }
879             }
880             else if (fchar=='T') /*Bit addressable bytes in internal RAM*/
881             {
882                 /*Find the size of the space currently used for this areax overlay*/
883                 for(j=0x20, size=0; j<0x30; j++)
884                     if(idatamap[j]==fchar) size++;
885
886                 /*If more space required, release the previously allocated areax in
887                 internal RAM and search for a bigger one*/
888                 if((int)taxp->a_size>size)
889                 {
890                     size=(int)taxp->a_size;
891
892                     for(j=0x20; j<0x30; j++)
893                         if(idatamap[j]==fchar) idatamap[j]=' ';
894
895                     /*Search for a space large enough in data memory for this overlay areax*/
896                     for(j=0x20, k=0; j<0x30; j++)
897                     {
898                         if(idatamap[j]==' ')
899                             k++;
900                         else
901                             k=0;
902                         if(k==(int)taxp->a_size) break;
903                     }
904
905                     if(k==(int)taxp->a_size)
906                     {
907                         taxp->a_addr = j-k+1;
908                         if(addr<(unsigned int)0x30)
909                         {
910                             for(j=0x2F; (j>=0x20)&&(idatamap[j]==' '); j--);
911                             if(j>=0x20) addr=j+1;
912                         }
913                     }
914
915                     /*Mark the memory used for overlay*/
916                     if(k==(int)taxp->a_size)
917                     {
918                         for(j=taxp->a_addr; (j<(int)(taxp->a_addr+taxp->a_size)) && (j<0x30); j++)
919                             idatamap[j]=fchar;
920
921                         /*Set the new size of the data memory area*/
922                         size=ramlimit-addr;
923                     }
924                     else /*Couldn't find a chunk big enough: report the problem.*/
925                     {
926                         tap->a_unaloc=taxp->a_size;
927                         fprintf(stderr, ErrMsg, taxp->a_size, taxp->a_size>1?"s":"", tap->a_id);
928                         lkerr++;
929                     }
930                 }
931
932                 for(j=0x20; j<0x30; j++)
933                 {
934                     if (idatamap[j]==fchar)
935                     {
936                         addr=j;
937                         tap->a_addr=addr;
938                         taxp->a_addr=addr;
939                         break;
940                     }
941                 }
942             }
943             else /*Overlay areas not in internal ram*/
944             {
945                 taxp->a_addr = addr;
946                 if (taxp->a_size > size) size = taxp->a_size;
947             }
948             taxp = taxp->a_axp;
949         }
950     }
951     else if (tap->a_flag & A_ABS) /* Absolute sections */
952     {
953         while (taxp)
954         {
955             if (locIndex == 0)
956             {
957                 for (j=taxp->a_addr; (j<(int)(taxp->a_addr+taxp->a_size)) && (j<ramlimit); j++)
958                     idatamap[j] = 'A';
959             }
960             if (locIndex == 1)
961             {
962                 allocate_space(taxp->a_addr, taxp->a_size, tap->a_id, codemap);
963             }
964             if (locIndex == 2)
965             {
966                 allocate_space(taxp->a_addr, taxp->a_size, tap->a_id, xdatamap);
967             }
968             taxp->a_addr = 0; /* reset to zero so relative addresses become absolute */
969             size += taxp->a_size;
970             taxp = taxp->a_axp;
971         }
972     }
973     else /* Concatenated sections */
974     {
975         if ((locIndex == 1) && tap->a_size)
976         {
977             addr = find_empty_space(addr, tap->a_size, codemap);
978         }
979         if ((locIndex == 2) && tap->a_size)
980         {
981             addr = find_empty_space(addr, tap->a_size, xdatamap);
982         }
983         while (taxp)
984         {
985             if( (fchar=='D') || (fchar=='I') )
986             {
987                 if(taxp->a_size)
988                 {
989                     /*Search for a space large enough in internal RAM for this areax*/
990                     for(j=0, k=0; j<ramlimit; j++)
991                     {
992                         if(idatamap[j]==' ')
993                             k++;
994                         else
995                             k=0;
996                         if(k==(int)taxp->a_size) break;
997                     }
998
999                     if(k==(int)taxp->a_size)
1000                     {
1001                         taxp->a_addr = j-k+1;
1002                         if(addr<(unsigned int)ramlimit)
1003                         {
1004                             for(j=ramlimit-1; (j>=0)&&(idatamap[j]==' '); j--);
1005                             if(j>=0) addr=j+1;
1006                             size=ramlimit-addr;
1007                         }
1008
1009                         for(j=taxp->a_addr; (j<(int)(taxp->a_addr+taxp->a_size)) && (j<ramlimit); j++)
1010                             idatamap[j]=(fchar=='D')?dchar:fchar;
1011                         if((taxp->a_size>0)&&(fchar=='D'))dchar++;
1012                         if((dchar<'a')||(dchar>'z')) dchar='D'; /*Ran out of letters?*/
1013                     }
1014                     else /*We are in trouble, there is not enough memory for an areax chunk*/
1015                     {
1016                         taxp->a_addr = addr;
1017                         addr += taxp->a_size;
1018                         size += taxp->a_size;
1019                         tap->a_unaloc+=taxp->a_size;
1020                         fprintf(stderr, ErrMsg, taxp->a_size, taxp->a_size>1?"s":"", tap->a_id);
1021                         lkerr++;
1022                     }
1023                }
1024                taxp = taxp->a_axp;
1025             }
1026             else if(fchar=='B')
1027             {
1028                 if(taxp->a_size!=0)
1029                 {
1030                     for(j=addr; j<((int)(addr+taxp->a_size)); j++)
1031                         idatamap[j]=fchar;
1032                 }
1033
1034                 taxp->a_addr = addr;
1035                 addr += taxp->a_size;
1036                 size += taxp->a_size;
1037                 taxp = taxp->a_axp;
1038             }
1039             else /*For concatenated BIT, CODE, and XRAM areax's*/
1040             {
1041                 if((fchar=='K') && (taxp->a_size == 1))
1042                 {
1043                     taxp->a_size = 256-(addr & 0xFF);
1044                 }
1045                 //find next unused address now
1046                 if ((locIndex == 1) && taxp->a_size)
1047                 {
1048                     addr = find_empty_space(addr, taxp->a_size, codemap);
1049                     allocate_space(addr, taxp->a_size, tap->a_id, codemap);
1050                 }
1051                 if ((locIndex == 2) && taxp->a_size)
1052                 {
1053                     addr = find_empty_space(addr, taxp->a_size, xdatamap);
1054                     allocate_space(addr, taxp->a_size, tap->a_id, xdatamap);
1055                 }
1056                 taxp->a_addr = addr;
1057                 addr += taxp->a_size;
1058                 size += taxp->a_size;
1059                 taxp = taxp->a_axp;
1060             }
1061         }
1062     }
1063     tap->a_size = size;
1064
1065     if ((tap->a_flag&A_PAG) && (size > 256))
1066     {
1067         fprintf(stderr,
1068         "\n?ASlink-Warning-Paged Area %8s Length Error\n", tap->a_id);
1069         lkerr++;
1070     }
1071     if ((tap->a_flag&A_PAG) && (tap->a_size) &&
1072         ((tap->a_addr & 0xFFFFFF00) != ((addr-1) & 0xFFFFFF00)))
1073     {
1074         fprintf(stderr,
1075         "\n?ASlink-Warning-Paged Area %8s Boundary Error\n", tap->a_id);
1076         lkerr++;
1077     }
1078     return addr;
1079 }