git.gag.com Git - fw/sdcc/blob - as/hc08/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 tha 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          * Place pointer in header area list
 142          */
 143         if (headp == NULL) {
 144                 fprintf(stderr, "No header defined\n");
 145                 lkexit(1);
 146         }
 147         narea = hp->h_narea;
 148         halp = hp->a_list;
 149         for (i=0; i < narea ;++i) {
 150                 if (halp[i] == NULL) {
 151                         halp[i] = taxp;
 152                         return;
 153                 }
 154         }
 155         fprintf(stderr, "Header area list overflow\n");
 156         lkexit(1);
 157 }
 158
 159 /*)Function     VOID    lkparea(id)
 160  *
 161  *              char *  id              pointer to the area name string
 162  *
 163  *      The function lkparea() searches the linked area structures
 164  *      for a name match.  If the name is not found then an area
 165  *      structure is created.  An areax structure is created and
 166  *      appended to the areax structures linked to the area structure.
 167  *      The associated base area and head structure pointers are
 168  *      loaded into the areax structure.
 169  *
 170  *      local variables:
 171  *              area *  tap             pointer to an area structure
 172  *              areax * taxp            pointer to an areax structure
 173  *
 174  *      global variables:
 175  *              area    *ap             Pointer to the current
 176  *                                      area structure
 177  *              area    *areap          The pointer to the first
 178  *                                      area structure of a linked list
 179  *              areax   *axp            Pointer to the current
 180  *                                      areax structure
 181  *
 182  *      functions called:
 183  *              VOID *  new()           lksym()
 184  *              char *  strcpy()        c_library
 185  *              int     symeq()         lksym.c
 186  *
 187  *      side effects:
 188  *              Area and/or areax structures are created.
 189  *              Failure to allocate space for created structures
 190  *              will terminate the linker.
 191  */
 192
 193 VOID
 194 lkparea(id)
 195 char *id;
 196 {
 197         register struct area *tap;
 198         register struct areax *taxp;
 199
 200         ap = areap;
 201         axp = (struct areax *) new (sizeof(struct areax));
 202         while (ap) {
 203                 if (symeq(id, ap->a_id)) {
 204                         taxp = ap->a_axp;
 205                         while (taxp->a_axp)
 206                                 taxp = taxp->a_axp;
 207                         taxp->a_axp = axp;
 208                         axp->a_bap = ap;
 209                         axp->a_bhp = hp;
 210                         return;
 211                 }
 212                 ap = ap->a_ap;
 213         }
 214         ap = (struct area *) new (sizeof(struct area));
 215         if (areap == NULL) {
 216                 areap = ap;
 217         } else {
 218                 tap = areap;
 219                 while (tap->a_ap)
 220                         tap = tap->a_ap;
 221                 tap->a_ap = ap;
 222         }
 223         ap->a_axp = axp;
 224         axp->a_bap = ap;
 225         axp->a_bhp = hp;
 226         strncpy(ap->a_id, id, NCPS);
 227         ap->a_addr = 0;
 228 }
 229
 230 /*)Function     VOID    lnkarea()
 231  *
 232  *      The function lnkarea() resolves all area addresses.
 233  *      The function evaluates each area structure (and all
 234  *      the associated areax structures) in sequence.  The
 235  *      linking process supports four (4) possible area types:
 236  *
 237  *      ABS/OVR -       All sections (each individual areax
 238  *                      section) starts at the identical base
 239  *                      area address overlaying all other
 240  *                      areax sections for this area.  The
 241  *                      size of the area is largest of the area
 242  *                      sections.
 243  *
 244  *      ABS/CON -       All sections (each individual areax
 245  *                      section) are concatenated with the
 246  *                      first section starting at the base
 247  *                      area address.  The size of the area
 248  *                      is the sum of the section sizes.
 249  *
 250  *      NOTE:   Multiple absolute (ABS) areas are
 251  *                      never concatenated with each other,
 252  *                      thus absolute area A and absolute area
 253  *                      B will overlay each other if they begin
 254  *                      at the same location (the default is
 255  *                      always address 0 for absolute areas).
 256  *
 257  *      REL/OVR -       All sections (each individual areax
 258  *                      section) starts at the identical base
 259  *                      area address overlaying all other
 260  *                      areax sections for this area.  The
 261  *                      size of the area is largest of the area
 262  *                      sections.
 263  *
 264  *      REL/CON -       All sections (each individual areax
 265  *                      section) are concatenated with the
 266  *                      first section starting at the base
 267  *                      area address.  The size of the area
 268  *                      is the sum of the section sizes.
 269  *
 270  *      NOTE:   Relocatable (REL) areas ae always concatenated
 271  *                      with each other, thus relocatable area B
 272  *                      (defined after area A) will follow
 273  *                      relocatable area A independent of the
 274  *                      starting address of area A.  Within a
 275  *                      specific area each areax section may be
 276  *                      overlayed or concatenated with other
 277  *                      areax sections.
 278  *
 279  *
 280  *      If a base address for an area is specified then the
 281  *      area will start at that address.  Any relocatable
 282  *      areas defined subsequently will be concatenated to the
 283  *      previous relocatable area if it does not have a base
 284  *      address specified.
 285  *
 286  *      The names s_<areaname> and l_<areaname> are created to
 287  *      define the starting address and length of each area.
 288  *
 289  *      local variables:
 290  *              Addr_T  rloc            ;current relocation address
 291  *              char    temp[]          ;temporary string
 292  *              struct symbol   *sp     ;symbol structure
 293  *
 294  *      global variables:
 295  *              area    *ap                     Pointer to the current
 296  *                                                      area structure
 297  *              area    *areap          The pointer to the first
 298  *                                                      area structure of a linked list
 299  *
 300  *      functions called:
 301  *              int             fprintf()       c_library
 302  *              VOID    lnksect()       lkarea.c
 303  *              symbol *lkpsym()        lksysm.c
 304  *              char *  strncpy()       c_library
 305  *              int             symeq()         lksysm.c
 306  *
 307  *      side effects:
 308  *              All area and areax addresses and sizes are
 309  *              determined and saved in their respective
 310  *              structures.
 311  */
 312
 313 /*
 314  * Resolve all area addresses.
 315  */
 316 VOID
 317 lnkarea()
 318 {
 319         Addr_T rloc[4];
 320         int  locIndex;
 321         char temp[NCPS];
 322         struct sym *sp;
 323         /*JCF: used to save the REG_BANK_[0-3] and SBIT_BYTES area pointers*/
 324         struct area *ta[5];
 325         int j;
 326
 327         rloc[0] = rloc[1] = rloc[2] = rloc[3] = 0;
 328         ap = areap;
 329         while (ap) {
 330                 if (ap->a_flag&A_ABS) {
 331                         /*
 332                          * Absolute sections
 333                          */
 334                         lnksect(ap);
 335                 } else {
 336                         /* Determine memory space */
 337             locIndex = 0;
 338             #if 0
 339             if (ap->a_flag & A_CODE) {
 340                 locIndex = 1;
 341             }
 342             if (ap->a_flag & A_XDATA) {
 343                 locIndex = 2;
 344             }
 345             if (ap->a_flag & A_BIT) {
 346                 locIndex = 3;
 347             }
 348             #endif
 349                         /*
 350                          * Relocatable sections
 351                          */
 352                         if (ap->a_type == 0) {  /* JLH */
 353                                 ap->a_addr = rloc[ locIndex ];
 354                                 ap->a_type = 1;
 355                         }
 356                         lnksect(ap);
 357                         rloc[ locIndex ] = ap->a_addr + ap->a_size;
 358                 }
 359
 360                 /*
 361                  * Create symbols called:
 362                  *      s_<areaname>    the start address of the area
 363                  *      l_<areaname>    the length of the area
 364                  */
 365
 366                 if (! symeq(ap->a_id, _abs_)) {
 367                         strncpy(temp+2,ap->a_id,NCPS-2);
 368                         *(temp+1) = '_';
 369
 370                         *temp = 's';
 371                         sp = lkpsym(temp, 1);
 372                         sp->s_addr = ap->a_addr ;
 373                         /* sp->s_axp = ap->a_axp;  JLH: was NULL; */
 374                         sp->s_type |= S_DEF;
 375
 376                         *temp = 'l';
 377                         sp = lkpsym(temp, 1);
 378                         sp->s_addr = ap->a_size;
 379                         sp->s_axp = NULL;
 380                         sp->s_type |= S_DEF;
 381
 382                 }
 383
 384                 /*JCF: Since area BSEG is defined just before BSEG_BYTES, use the bit size of BSEG
 385                 to compute the byte size of BSEG_BYTES: */
 386                 if (!strcmp(ap->a_id, "BSEG")) {
 387                         ap->a_ap->a_axp->a_size=(ap->a_addr/8)+((ap->a_size+7)/8); /*Bits to bytes*/
 388                 }
 389                 else if (!strcmp(ap->a_id, "REG_BANK_0")) ta[0]=ap;
 390                 else if (!strcmp(ap->a_id, "REG_BANK_1")) ta[1]=ap;
 391                 else if (!strcmp(ap->a_id, "REG_BANK_2")) ta[2]=ap;
 392                 else if (!strcmp(ap->a_id, "REG_BANK_3")) ta[3]=ap;
 393                 else if (!strcmp(ap->a_id, "BSEG_BYTES"))
 394                 {
 395                         ta[4]=ap;
 396                         for(j=4; j>1; j--)
 397                         {
 398                                 /*If upper register banks are not used roll back the rellocation counter*/
 399                                 if ( (ta[j]->a_size==0) && (ta[j-1]->a_size==0) )
 400                                 {
 401                                         rloc[0]-=8;
 402                                 }
 403                                 else break;
 404                         }
 405                 }
 406                 ap = ap->a_ap;
 407         }
 408 }
 409
 410 /*)Function     VOID    lnksect()
 411  *
 412  *              area *  tap             pointer to an area structure
 413  *
 414  *      The function lnksect() is the function called by
 415  *      lnkarea() to resolve the areax addresses.  Refer
 416  *      to the function lnkarea() for more detail. Pageing
 417  *      boundary and length errors will be reported by this
 418  *      function.
 419  *
 420  *      local variables:
 421  *              Addr_T  size            size of area
 422  *              Addr_T  addr            address of area
 423  *              areax * taxp            pointer to an areax structure
 424  *
 425  *      global variables:
 426  *              int     lkerr           error flag
 427  *
 428  *      functions called:
 429  *              none
 430  *
 431  *      side effects:
 432  *              All area and areax addresses and sizes area determined
 433  *              and linked into the structures.
 434  */
 435
 436 VOID
 437 lnksect(tap)
 438 register struct area *tap;
 439 {
 440         register Addr_T size, addr;
 441         register struct areax *taxp;
 442
 443         size = 0;
 444         addr = tap->a_addr;
 445         if ((tap->a_flag&A_PAG) && (addr & 0xFF)) {
 446             fprintf(stderr,
 447             "\n?ASlink-Warning-Paged Area %8s Boundary Error\n", tap->a_id);
 448             lkerr++;
 449         }
 450         taxp = tap->a_axp;
 451         if (tap->a_flag&A_OVR) {
 452                 /*
 453                  * Overlayed sections
 454                  */
 455                 while (taxp) {
 456                         taxp->a_addr = addr;
 457                         if (taxp->a_size > size)
 458                                 size = taxp->a_size;
 459                         taxp = taxp->a_axp;
 460                 }
 461         } else {
 462                 /*
 463                  * Concatenated sections
 464                  */
 465                 while (taxp) {
 466                         taxp->a_addr = addr;
 467                         addr += taxp->a_size;
 468                         size += taxp->a_size;
 469                         taxp = taxp->a_axp;
 470                 }
 471         }
 472         tap->a_size = size;
 473         if ((tap->a_flag&A_PAG) && (size > 256)) {
 474             fprintf(stderr,
 475             "\n?ASlink-Warning-Paged Area %8s Length Error\n", tap->a_id);
 476             lkerr++;
 477         }
 478 }