sdcc/sdas/linksrc/lkrloc.c

   1 /* lkrloc.c */
   2
   3 /*
   4  *  Copyright (C) 1989-2009  Alan R. Baldwin
   5  *
   6  *  This program is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  *
  20  * Alan R. Baldwin
  21  * 721 Berkeley St.
  22  * Kent, Ohio  44240
  23  *
  24  *   With enhancements from:
  25  *
  26  *      John L. Hartman (JLH)
  27  *      jhartman@compuserve.com
  28  *
  29  *      Bill McKinnon (BM)
  30  *      w_mckinnon@conknet.com
  31  */
  32
  33 #include <ctype.h>
  34 #include "aslink.h"
  35
  36 /*)Module       lkrloc.c
  37  *
  38  *      The module lkrloc.c contains the functions which
  39  *      perform the relocation calculations.
  40  *
  41  *      lkrloc.c contains the following functions:
  42  *              a_uint  adb_1b()
  43  *              a_uint  adb_2b()
  44  *              a_uint  adb_3b()
  45  *              a_uint  adb_4b()
  46  *              a_uint  adb_xb()
  47  *              a_uint  evword()
  48  *              VOID    prntval()
  49  *              VOID    reloc()
  50  *
  51  *
  52  */
  53
  54 /*)Function VOID        reloc(c)
  55  *
  56  *                      int c           process code
  57  *
  58  *      The function reloc() calls the proper version
  59  *      of the linker code.
  60  *
  61  *      local variable:
  62  *              none
  63  *
  64  *      global variables:
  65  *              ASxxxx_VERSION          ASxxxx REL file version
  66  *
  67  *      called functions:
  68  *              VOID    reloc3()        lkrloc3.c
  69  *              VOID    reloc4()        lkrloc4.c
  70  *
  71  *      side effects:
  72  *              Refer to the called relocation functions.
  73  *
  74  */
  75
  76 VOID
  77 reloc(int c)
  78 {
  79         switch(ASxxxx_VERSION) {
  80         case 3:
  81                 reloc3(c);
  82                 break;
  83
  84 //      case 4:
  85 //              reloc4(c);
  86 //              break;
  87
  88         default:
  89                 fprintf(stderr, "Internal Version Error");
  90                 lkexit(ER_FATAL);
  91                 break;
  92         }
  93 }
  94
  95
  96 /*)Function a_uint              evword()
  97  *
  98  *      The function evword() combines two byte values
  99  *      into a single word value.
 100  *
 101  *      local variable:
 102  *              a_uint  v               temporary evaluation variable
 103  *
 104  *      global variables:
 105  *              hilo                    byte ordering parameter
 106  *
 107  *      called functions:
 108  *              int eval()              lkeval.c
 109  *
 110  *      side effects:
 111  *              Relocation text line is scanned to combine
 112  *              two byte values into a single word value.
 113  *
 114  */
 115
 116 a_uint
 117 evword(void)
 118 {
 119         a_uint v;
 120
 121         if (hilo) {
 122                 v =  (eval() << 8);
 123                 v +=  eval();
 124         } else {
 125                 v =   eval();
 126                 v += (eval() << 8);
 127         }
 128         return(v);
 129 }
 130
 131 /*)Function a_uint              adb_1b(v, i)
 132  *
 133  *              a_uint v        value to add to byte
 134  *              int i           rtval[] index
 135  *
 136  *      The function adb_1b() adds the value of v to
 137  *      the single byte value contained in rtval[i].
 138  *      The new value of rtval[i] is returned.
 139  *
 140  *      local variable:
 141  *              a_uint  j               temporary evaluation variable
 142  *
 143  *      global variables:
 144  *              none
 145  *
 146  *      called functions:
 147  *              none
 148  *
 149  *      side effects:
 150  *              The byte value of rtval[] is changed.
 151  *
 152  */
 153
 154 a_uint
 155 adb_1b(a_uint v, int i)
 156 {
 157         a_uint j;
 158
 159         j = v + rtval[i];
 160         rtval[i] = j & ((a_uint) 0x000000FF);
 161
 162         return(j);
 163 }
 164
 165 /*)Function     a_uint  adb_2b(v, i)
 166  *
 167  *              a_uint  v               value to add to word
 168  *              int     i               rtval[] index
 169  *
 170  *      The function adb_2b() adds the value of v to the
 171  *      2 byte value contained in rtval[i] and rtval[i+1].
 172  *      The new value of rtval[i] / rtval[i+1] is returned.
 173  *
 174  *      local variable:
 175  *              a_uint  j               temporary evaluation variable
 176  *
 177  *      global variables:
 178  *              hilo                    byte ordering parameter
 179  *
 180  *      called functions:
 181  *              none
 182  *
 183  *      side effects:
 184  *              The 2 byte value of rtval[] is changed.
 185  *
 186  */
 187
 188 a_uint
 189 adb_2b(a_uint v, int i)
 190 {
 191         a_uint j;
 192
 193         if (hilo) {
 194                 j = v + (rtval[i+0] << 8) +
 195                         (rtval[i+1] << 0);
 196                 rtval[i+0] = (j >> 8) & ((a_uint) 0x000000FF);
 197                 rtval[i+1] = (j >> 0) & ((a_uint) 0x000000FF);
 198         } else {
 199                 j = v + (rtval[i+0] << 0) +
 200                         (rtval[i+1] << 8);
 201                 rtval[i+0] = (j >> 0) & ((a_uint) 0x000000FF);
 202                 rtval[i+1] = (j >> 8) & ((a_uint) 0x000000FF);
 203         }
 204         return(j);
 205 }
 206
 207 /*)Function     a_uint  adb_3b(v, i)
 208  *
 209  *              a_uint  v               value to add to word
 210  *              int     i               rtval[] index
 211  *
 212  *      The function adb_3b() adds the value of v to the
 213  *      three byte value contained in rtval[i], rtval[i+1], and rtval[i+2].
 214  *      The new value of rtval[i] / rtval[i+1] / rtval[i+2] is returned.
 215  *
 216  *      local variable:
 217  *              a_uint  j               temporary evaluation variable
 218  *
 219  *      global variables:
 220  *              hilo                    byte ordering parameter
 221  *
 222  *      called functions:
 223  *              none
 224  *
 225  *      side effects:
 226  *              The 3 byte value of rtval[] is changed.
 227  *
 228  */
 229
 230 a_uint
 231 adb_3b(a_uint v, int i)
 232 {
 233         a_uint j;
 234
 235         if (hilo) {
 236                 j = v + (rtval[i+0] << 16) +
 237                         (rtval[i+1] <<  8) +
 238                         (rtval[i+2] <<  0);
 239                 rtval[i+0] = (j >> 16) & ((a_uint) 0x000000FF);
 240                 rtval[i+1] = (j >>  8) & ((a_uint) 0x000000FF);
 241                 rtval[i+2] = (j >>  0) & ((a_uint) 0x000000FF);
 242         } else {
 243                 j = v + (rtval[i+0] <<  0) +
 244                         (rtval[i+1] <<  8) +
 245                         (rtval[i+2] << 16);
 246                 rtval[i+0] = (j >>  0) & ((a_uint) 0x000000FF);
 247                 rtval[i+1] = (j >>  8) & ((a_uint) 0x000000FF);
 248                 rtval[i+2] = (j >> 16) & ((a_uint) 0x000000FF);
 249         }
 250         return(j);
 251 }
 252
 253 /*)Function     a_uint  adb_4b(v, i)
 254  *
 255  *              a_uint  v               value to add to word
 256  *              int     i               rtval[] index
 257  *
 258  *      The function adb_4b() adds the value of v to the
 259  *      four byte value contained in rtval[i], ..., rtval[i+3].
 260  *      The new value of rtval[i], ...,  rtval[i+3] is returned.
 261  *
 262  *      local variable:
 263  *              a_uint  j               temporary evaluation variable
 264  *
 265  *      global variables:
 266  *              hilo                    byte ordering parameter
 267  *
 268  *      called functions:
 269  *              none
 270  *
 271  *      side effects:
 272  *              The 4 byte value of rtval[] is changed.
 273  *
 274  */
 275
 276 a_uint
 277 adb_4b(a_uint v, int i)
 278 {
 279         a_uint j;
 280
 281         if (hilo) {
 282                 j = v + (rtval[i+0] << 24) +
 283                         (rtval[i+1] << 16) +
 284                         (rtval[i+2] <<  8) +
 285                         (rtval[i+3] <<  0);
 286                 rtval[i+0] = (j >> 24) & ((a_uint) 0x000000FF);
 287                 rtval[i+1] = (j >> 16) & ((a_uint) 0x000000FF);
 288                 rtval[i+2] = (j >>  8) & ((a_uint) 0x000000FF);
 289                 rtval[i+3] = (j >>  0) & ((a_uint) 0x000000FF);
 290         } else {
 291                 j = v + (rtval[i+0] <<  0) +
 292                         (rtval[i+1] <<  8) +
 293                         (rtval[i+2] << 16) +
 294                         (rtval[i+3] << 24);
 295                 rtval[i+0] = (j >>  0) & ((a_uint) 0x000000FF);
 296                 rtval[i+1] = (j >>  8) & ((a_uint) 0x000000FF);
 297                 rtval[i+2] = (j >> 16) & ((a_uint) 0x000000FF);
 298                 rtval[i+3] = (j >> 24) & ((a_uint) 0x000000FF);
 299         }
 300         return(j);
 301 }
 302
 303 /*)Function     a_uint  adb_xb(v, i)
 304  *
 305  *              a_uint  v               value to add to x-bytes
 306  *              int     i               rtval[] index
 307  *
 308  *      The function adb_xb() adds the value of v to
 309  *      the value contained in rtval[i] for x-bytes.
 310  *      The new value of rtval[i] for x-bytes is returned.
 311  *
 312  *      local variable:
 313  *              none
 314  *
 315  *      global variables:
 316  *              int     a_bytes         T Line Address Bytes
 317  *
 318  *      called functions:
 319  *              a_uint  adb_1b()        lkrloc.c
 320  *              a_uint  adb_2b()        lkrloc.c
 321  *              a_uint  adb_3b()        lkrloc.c
 322  *              a_uint  adb_4b()        lkrloc.c
 323  *
 324  *      side effects:
 325  *              The x-byte value of rtval[] is changed.
 326  *
 327  */
 328
 329 a_uint
 330 adb_xb(a_uint v, int i)
 331 {
 332         a_uint j;
 333
 334         switch(a_bytes){
 335         case 1:
 336                 j = adb_1b(v, i);
 337                 j = (j & ((a_uint) 0x00000080) ? j | ~((a_uint) 0x0000007F) : j & ((a_uint) 0x0000007F));
 338                 break;
 339         case 2:
 340                 j = adb_2b(v, i);
 341                 j = (j & ((a_uint) 0x00008000) ? j | ~((a_uint) 0x00007FFF) : j & ((a_uint) 0x00007FFF));
 342                 break;
 343         case 3:
 344                 j = adb_3b(v, i);
 345                 j = (j & ((a_uint) 0x00800000) ? j | ~((a_uint) 0x007FFFFF) : j & ((a_uint) 0x007FFFFF));
 346                 break;
 347         case 4:
 348                 j = adb_4b(v, i);
 349                 j = (j & ((a_uint) 0x80000000) ? j | ~((a_uint) 0x7FFFFFFF) : j & ((a_uint) 0x7FFFFFFF));
 350                 break;
 351         default:
 352                 j = 0;
 353                 break;
 354         }
 355         return(j);
 356 }
 357
 358 /*)Function VOID prntval(fptr, v)
 359  *
 360  *              FILE    *fptr           output file handle
 361  *              a_uint  v               value to output
 362  *
 363  *      The function prntval() outputs the value v, in the
 364  *      currently selected radix, to the device specified
 365  *      by fptr.
 366  *
 367  *      local variable:
 368  *              none
 369  *
 370  *      global variables:
 371  *              int xflag               current radix
 372  *
 373  *      called functions:
 374  *              int fprintf()   c_library
 375  *
 376  *      side effects:
 377  *              none
 378  *
 379  */
 380
 381 VOID
 382 prntval(FILE *fptr, a_uint v)
 383 {
 384         char *frmt;
 385
 386         switch(xflag) {
 387         default:
 388         case 0:
 389                 switch(a_bytes) {
 390                 default:
 391                 case 2: frmt = "       %04X\n"; break;
 392                 case 3: frmt = "     %06X\n"; break;
 393                 case 4: frmt = "   %08X\n"; break;
 394                 }
 395                 break;
 396         case 1:
 397                 switch(a_bytes) {
 398                 default:
 399                 case 2: frmt = "     %06o\n"; break;
 400                 case 3: frmt = "   %08o\n"; break;
 401                 case 4: frmt = "%011o\n"; break;
 402                 }
 403                 break;
 404         case 2:
 405                 switch(a_bytes) {
 406                 default:
 407                 case 2: frmt = "      %05u\n"; break;
 408                 case 3: frmt = "   %08u\n"; break;
 409                 case 4: frmt = " %010u\n"; break;
 410                 }
 411                 break;
 412         }
 413         fprintf(fptr, frmt, v & a_mask);
 414 }