home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / devel / lisp / kcl_tar.z / kcl_tar / c / fasl_reloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  9.9 KB  |  506 lines
  1. /*
  2. (C) Copyright Taiichi Yuasa and Masami Hagiya, 1984.  All rights reserved.
  3. */
  4.  
  5. /*
  6.     fasl_reloc.c
  7.     DG-SPECIFIC
  8.  
  9.     fasl relocation routines
  10. */
  11.  
  12. #include <stdio.h>
  13. #include "../h/fasl.h"
  14. #include "../h/fasl_global.h"
  15. #include "../h/fasl_reloc.h"
  16.  
  17. int    fas_base;        /* base */
  18. int    fas_dword;        /* data word */
  19. int    fas_pc;            /* program counter */
  20. int    fas_result;        /* result */
  21.  
  22. bit_relocation(reloc, bit_p, dword_p)
  23. short        reloc;        /* extended relocation */
  24. FAS_BIT_P    bit_p;        /* bit dictionary pointer */
  25. short        *dword_p;    /* dictionaried word pointer */
  26. {
  27.  
  28. }
  29.  
  30. relocation(reloc, base_p, dword_p)
  31. short        reloc;        /* extended relocation */
  32. short        *base_p;    /* base pointer */
  33. short        *dword_p;    /* dictionaried word pointer */
  34. {
  35.     short        base_no;    /* base no */
  36.  
  37.     if (reloc < RL_ADDR_WORD_32_31)
  38.         FEerror("Illegal relocation.", 0);
  39.  
  40.     base_no = *base_p;        /* get base */
  41.  
  42.     if (fas_relocation_by_table == TRUE) {
  43.         part_table_p = fasl_get_table(base_no);
  44.         fas_base = part_table_p->part_addr;
  45.     } else
  46.         fas_base = fasl_get_addr(base_no);
  47.     if (reloc > RL_DATA_SUB2_32_32)
  48.         fas_dword = *dword_p;        /* 16 bits data word */
  49.         else
  50.         fas_dword = *((int *)dword_p);    /* 32 bits data word */
  51.     fas_pc = dword_p;
  52.  
  53.     switch(reloc) {
  54.  
  55.       case RL_ADDR_WORD_32_31:    addr_word_32_31();
  56.                     break;
  57.       case RL_ADDR_BYTE_32_31:    addr_byte_32_31();
  58.                     break;
  59.       case RL_ADDR_PC_REL_32_31:    addr_pc_rel_32_31();
  60.                     break;
  61.       case RL_ADDR_PC_BYTE_32_31:    addr_pc_byte_32_31();
  62.                     break;
  63.       case RL_ADDR_WORD_32_28:    addr_word_32_28();
  64.                     break;
  65.       case RL_ADDR_BYTE_32_28:    addr_byte_32_28();
  66.                     break;
  67.       case RL_ADDR_PC_REL_32_28:    addr_pc_rel_32_28();
  68.                     break;
  69.       case RL_ADDR_PC_BYTE_32_28:    addr_pc_byte_32_28();
  70.                     break;
  71.       case RL_ADDR_WORD_28_31:    addr_word_28_31();
  72.                     break;
  73.       case RL_ADDR_BYTE_28_31:    addr_byte_28_31();
  74.                     break;
  75.       case RL_ADDR_PC_REL_28_31:    addr_pc_rel_28_31();
  76.                     break;
  77.       case RL_ADDR_PC_BYTE_28_31:    addr_pc_byte_28_31();
  78.                     break;
  79.       case RL_DATA_ADD_32_32:    data_add_32_32();
  80.                     break;
  81.       case RL_DATA_SUB1_32_32:    data_sub1_32_32();
  82.                     break;
  83.       case RL_DATA_MUL_32_32:    data_mul_32_32();
  84.                     break;
  85.       case RL_DATA_SUB2_32_32:    data_sub2_32_32();
  86.                     break;
  87.       case RL_DATA_ADD_32_16S:    data_add_32_16s();
  88.                     break;
  89.       case RL_DATA_SUB1_32_16S:    data_sub1_32_16s();
  90.                     break;
  91.       case RL_DATA_MUL_32_16S:    data_mul_32_16s();
  92.                     break;
  93.       case RL_DATA_SUB2_32_16S:    data_sub2_32_16s();
  94.                     break;
  95.       case RL_DATA_ADD_32_16U:    data_add_32_16u();
  96.                     break;
  97.       case RL_DATA_SUB1_32_16U:    data_sub1_32_16u();
  98.                     break;
  99.       case RL_DATA_MUL_32_16U:    data_mul_32_16u();
  100.                     break;
  101.       case RL_DATA_SUB2_32_16U:    data_sub2_32_16u();
  102.                     break;
  103.       case RL_DATA_ADD_32_16:    data_add_32_16();
  104.                     break;
  105.       case RL_DATA_SUB1_32_16:    data_sub1_32_16();
  106.                     break;
  107.       case RL_DATA_MUL_32_16:    data_mul_32_16();
  108.                     break;
  109.       case RL_DATA_SUB2_32_16:    data_sub2_32_16();
  110.                     break;
  111.       case RL_ADDR_WORD_32_15U:    addr_word_32_15u();
  112.                     break;
  113.       case RL_ADDR_BYTE_32_15U:    addr_byte_32_15u();
  114.                     break;
  115.       case RL_ADDR_PC_REL_32_15U:    addr_pc_rel_32_15u();
  116.                     break;
  117.       case RL_ADDR_PC_BYTE_32_15U:    addr_pc_byte_32_15u();
  118.                     break;
  119.       case RL_ADDR_WORD_32_15S:    addr_word_32_15s();
  120.                     break;
  121.       case RL_ADDR_BYTE_32_15S:    addr_byte_32_15s();
  122.                     break;
  123.       case RL_ADDR_PC_REL_32_15S:    addr_pc_rel_32_15s();
  124.                     break;
  125.       case RL_ADDR_PC_BYTE_32_15S:    addr_pc_byte_32_15s();
  126.                     break;
  127.       default:            unexpect_reloc(reloc);
  128.                     break;
  129.       }        /* end of switch */
  130.  
  131.     if (reloc > RL_DATA_SUB2_32_32)
  132.         *dword_p = fas_result & LOW16_BITS;    /* 16 bits */
  133.         else
  134.         *((int *)dword_p) = fas_result;        /* 32 bits */
  135. }
  136. addr_word_32_31()
  137. {
  138.     int    indirect;
  139.  
  140.     indirect = fas_dword & INDIRECT_BIT;
  141.     fas_dword &= LOW31_BITS;
  142.     fas_result = fas_base + fas_dword;
  143.     fas_result = indirect | (fas_result & LOW31_BITS);
  144. }
  145.  
  146. addr_byte_32_31()
  147. {
  148.     fas_result = fas_base * 2 + fas_dword;
  149. }
  150.  
  151. addr_pc_rel_32_31()
  152. {
  153.     int    indirect;
  154.  
  155.     indirect = fas_dword & INDIRECT_BIT;
  156.     fas_dword &= LOW31_BITS;
  157.     fas_pc &= LOW28_BITS;
  158.     fas_result = fas_base + fas_dword;
  159.     fas_result = (fas_result - fas_pc) | indirect;
  160. }
  161.  
  162. addr_pc_byte_32_31()
  163. {
  164.     fas_result = fas_base * 2 + fas_dword;
  165.     fas_result -= (fas_pc & LOW28_BITS);
  166. }
  167.  
  168. addr_word_32_28()
  169. {
  170.     int    ring;
  171.  
  172.     ring = fas_dword & RING_BITS;
  173.     fas_result = fas_base + (fas_dword & LOW28_BITS);
  174.     if ((fas_result < 0) |
  175.         (fas_result >= 02000000000))
  176.         rloverflow();
  177.     fas_result |= ring;
  178. }
  179.  
  180. addr_byte_32_28()
  181. {
  182.     int    ring;
  183.  
  184.     ring = fas_dword & RING_BITS;
  185.     fas_result = fas_base + 2 * (fas_dword & LOW28_BITS);
  186.     if ((fas_result < 0) |
  187.         (fas_result >= 04000000000))
  188.         rloverflow();
  189.     fas_result |= (2 * ring);
  190. }
  191.  
  192. addr_pc_rel_32_28()
  193. {
  194.     int    indirect;
  195.  
  196.     fas_pc &= LOW28_BITS;
  197.     indirect = fas_dword & INDIRECT_BIT;
  198.     fas_result = fas_base + (fas_dword & LOW28_BITS);
  199.     if ((fas_result < 0) |
  200.         (fas_result >= 2000000000))
  201.         rloverflow();
  202.     fas_result = ((fas_result - fas_pc) & LOW31_BITS) | indirect;
  203. }
  204.  
  205. addr_pc_byte_32_28()
  206. {
  207.     fas_result = fas_base + 2 * (fas_dword | LOW28_BITS);
  208.     if ((fas_result < 0) |
  209.         (fas_result >= 04000000000))
  210.         rloverflow();
  211.     fas_result -= 2 * fas_pc;
  212. }
  213.  
  214. addr_word_28_31()
  215. {
  216.     int    ring, indirect;
  217.  
  218.     ring = fas_base & RING_BITS;
  219.     fas_base &= LOW28_BITS;
  220.     indirect = fas_dword & INDIRECT_BIT;
  221.     fas_dword &= LOW31_BITS;
  222.     fas_result = fas_base + fas_dword;
  223.     if ((fas_result < 0) |
  224.         (fas_result >= 02000000000))
  225.         rloverflow();
  226.     fas_result = indirect | ring | fas_result;
  227. }
  228.  
  229. addr_byte_28_31()
  230. {
  231.     int    ring;
  232.  
  233.     ring = fas_base & RING_BITS;
  234.     fas_base &= LOW28_BITS;
  235.     fas_result = 2 * fas_base + fas_dword;
  236.     if ((fas_result < 0) |
  237.         (fas_result >= 04000000000))
  238.         rloverflow();
  239.     fas_result |= ring * 2;
  240. }
  241.  
  242. addr_pc_rel_28_31()
  243. {
  244.     int    indirect;
  245.  
  246.     indirect = fas_dword & INDIRECT_BIT;
  247.     fas_base &= LOW28_BITS;
  248.     fas_dword &= LOW31_BITS;
  249.     fas_pc &= LOW28_BITS;
  250.     fas_result = fas_base + fas_dword;
  251.     if ((fas_result < 0) |
  252.         (fas_result >= 02000000000))
  253.         rloverflow();
  254.     fas_result = ((fas_result - fas_pc) & LOW31_BITS) | indirect;
  255. }
  256.  
  257. addr_pc_byte_28_31()
  258. {
  259.     fas_base &= LOW28_BITS;
  260.     fas_pc &= LOW28_BITS;
  261.     fas_result = 2 * fas_base + fas_dword;
  262.     if ((fas_result < 0) |
  263.         (fas_result >= 04000000000))
  264.         rloverflow();
  265.     fas_result -= 2 * fas_pc;
  266. }
  267.  
  268. data_add_32_32()
  269. {
  270.     fas_result = fas_base + fas_dword;
  271. }
  272.  
  273. data_sub1_32_32()
  274. {
  275.     fas_result = fas_base - fas_dword;
  276. }
  277.  
  278. data_mul_32_32()
  279. {
  280.     fas_result = fas_base * fas_dword;
  281. }
  282.  
  283. data_sub2_32_32()
  284. {
  285.     fas_result = fas_dword - fas_base;
  286. }
  287.  
  288. data_add_32_16s()
  289. {
  290.     fas_result = fas_base + fas_dword;
  291.     if ((fas_result < -0100000) |
  292.         (fas_result >= 0100000))
  293.         rloverflow();
  294. }
  295.  
  296. data_sub1_32_16s()
  297. {
  298.     fas_result = fas_base - fas_dword;
  299.     if ((fas_result < -100000) |
  300.         (fas_result >= 0100000))
  301.         rloverflow();
  302. }
  303.  
  304. data_mul_32_16s()
  305. {
  306.     fas_result = fas_base * fas_dword;
  307.     if ((fas_result < -0100000) |
  308.         (fas_result >= 0100000))
  309.         rloverflow();
  310. }
  311.  
  312. data_sub2_32_16s()
  313. {
  314.     fas_result = fas_dword - fas_base;
  315.     if ((fas_result < -0100000) |
  316.         (fas_result >= 0100000))
  317.         rloverflow();
  318. }
  319.  
  320. data_add_32_16u()
  321. {
  322.     data_16u();
  323.     fas_result = fas_base + fas_dword;
  324.     if ((fas_result < 0) |
  325.         (fas_result >= 0200000))
  326.         rloverflow();
  327. }
  328.  
  329. data_sub1_32_16u()
  330. {
  331.     data_16u();
  332.     fas_result = fas_base - fas_dword;
  333.     if ((fas_result < 0) |
  334.         (fas_result >= 0200000))
  335.         rloverflow();
  336. }
  337.  
  338. data_mul_32_16u()
  339. {
  340.     data_16u();
  341.     fas_result = fas_base * fas_dword;
  342.     if ((fas_result < 0) |
  343.         (fas_result >= 0200000))
  344.         rloverflow();
  345. }
  346.  
  347. data_sub2_32_16u()
  348. {
  349.     data_16u();
  350.     fas_result = fas_dword - fas_base;
  351.     if ((fas_result < 0) |
  352.         (fas_result >= 0200000))
  353.         rloverflow();
  354. }
  355.  
  356. data_add_32_16()
  357. {
  358.     data_16u();
  359.     fas_result = fas_base + fas_dword;
  360. }
  361.  
  362. data_sub1_32_16()
  363. {
  364.     data_16u();
  365.     fas_result = fas_base - fas_dword;
  366. }
  367.  
  368. data_mul_32_16()
  369. {
  370.     data_16u();
  371.     fas_result = fas_base * fas_dword;
  372. }
  373.  
  374. data_sub2_32_16()
  375. {
  376.     data_16u();
  377.     fas_result = fas_dword - fas_base;
  378. }
  379. addr_word_32_15u()
  380. {
  381.  
  382.     int    high_4bits;
  383.  
  384.     high_4bits = fas_dword & HIGH4_BITS16;
  385.     data_15u();        /* 15 bits unsigned */
  386.     fas_dword &= LOW15_BITS;
  387.     fas_base &= LOW28_BITS;
  388.     fas_result = fas_base + fas_dword;
  389.     if ((fas_result < 0) ||
  390.         (fas_result >= 0100000))
  391.         rloverflow();
  392.     fas_result = (high_4bits | fas_result) & LOW16_BITS;
  393. }
  394.  
  395. addr_byte_32_15u()
  396. {
  397.     fas_base &= LOW28_BITS;
  398.     fas_result = 2 * fas_base + fas_dword;
  399.     if ((fas_result < 0) |
  400.         (fas_result >= 0200000))
  401.         rloverflow();
  402.     fas_result &= LOW8_BITS;
  403. }
  404.  
  405. addr_pc_rel_32_15u()
  406. {
  407.     int    indirect;
  408.  
  409.     indirect = fas_dword & INDIRECT_BIT16;
  410.     data_15u();
  411.     fas_base &= LOW28_BITS;
  412.     fas_pc &= LOW28_BITS;
  413.     fas_result = fas_base - fas_pc + fas_dword;
  414.     if ((fas_result < 0) |
  415.         (fas_result >= 0100000))
  416.         rloverflow();
  417.     fas_result |= indirect;
  418. }
  419.  
  420. addr_pc_byte_32_15u()
  421. {
  422.     fas_base &= LOW28_BITS;
  423.     fas_pc &= LOW28_BITS;
  424.     fas_result = 2 * fas_base + 2 * fas_pc + fas_dword;
  425.     if ((fas_result < 0) |
  426.         (fas_result >= 0200000))
  427.         rloverflow();
  428.     fas_result &= LOW8_BITS;
  429. }
  430.  
  431. addr_word_32_15s()
  432. {
  433.     int    indirect;
  434.  
  435.     indirect = fas_dword & INDIRECT_BIT16;
  436.     data_15s();
  437.     fas_base &= LOW28_BITS;
  438.     fas_result = fas_base + fas_dword;
  439.     if ((fas_result < -040000) |
  440.         (fas_result >= 040000))
  441.         rloverflow();
  442.     fas_result = (fas_result & LOW15_BITS) | indirect;
  443. }
  444.  
  445. addr_byte_32_15s()
  446. {
  447.     fas_base &= LOW28_BITS;
  448.     fas_result = 2 * fas_base + fas_dword;
  449.     if ((fas_result < -0100000) |
  450.         (fas_result >= 0100000))
  451.         rloverflow();
  452. }
  453.  
  454. addr_pc_rel_32_15s()
  455. {
  456.     int    indirect;
  457.  
  458.     indirect = fas_dword & INDIRECT_BIT16;
  459.     data_15s();
  460.     fas_base &= LOW28_BITS;
  461.     fas_pc &= LOW28_BITS;
  462.     fas_result = fas_base + fas_pc - fas_dword;
  463.     if ((fas_result < -040000) |
  464.         (fas_result >= 040000))
  465.         rloverflow();
  466.     fas_result = (fas_result & LOW15_BITS) | indirect;
  467. }
  468.  
  469. addr_pc_byte_32_15s()
  470. {
  471.     fas_base &= LOW28_BITS;
  472.     fas_pc &= LOW28_BITS;
  473.     fas_result = 2 * fas_base - 2 * fas_pc + fas_dword;
  474.     if ((fas_result < -010000) |
  475.         (fas_result >= 010000))
  476.         rloverflow();
  477.     fas_result &= LOW8_BITS;
  478. }
  479. data_15u()
  480. {
  481.     fas_dword &= LOW15_BITS;
  482. }
  483.  
  484. data_15s()
  485. {
  486.     if ((fas_dword & BIT_17) != 0)
  487.         fas_dword |= ( ~LOW15_BITS);
  488.         else
  489.         fas_dword &= LOW15_BITS;
  490. }
  491.  
  492. data_16u()
  493. {
  494.     fas_dword &= LOW16_BITS;
  495. }
  496.  
  497. rloverflow()
  498. {
  499.     FEerror("Relocation overflow.", 0);
  500. }
  501. unexpect_reloc(reloc)
  502. short    reloc;
  503. {
  504.     FEerror("Unexpected relocation.", 0);
  505. }
  506.