home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / PGMUTL / VAL_LINK.ARC / MAP.C < prev    next >
Encoding:
Text File  |  1989-02-18  |  16.4 KB  |  507 lines
  1. /*                                 MAP.C                                   */
  2.  
  3. /*+-------------------------------------------------------------------------+
  4.   |                                                                         |
  5.   |                               link_map                                  |
  6.   |                                                                         |
  7.   +-------------------------------------------------------------------------+*/
  8. void link_map()
  9. BeginDeclarations
  10. file_info_ptr                          file;
  11. #define File                           (*file)
  12. group_entry_ptr                        grp;
  13. #define Grp                            (*grp)
  14. bit_16                                 i;
  15. lseg_ptr                               lseg;
  16. #define Lseg                           (*lseg)
  17. lseg_ptr                               last_location_lseg;
  18. public_entry_ptr                       pub;
  19. #define Pub                            (*pub)
  20. segment_entry_ptr                      seg;
  21. #define Seg                            (*seg)
  22. bit_32                                 stop_address;
  23. EndDeclarations
  24. BeginCode
  25.  map_start_time = Now;
  26.  If lst_file_list.first IsNull
  27.   Then  /*  No map file to be created. */
  28.    return;
  29.   EndIf;
  30.  file_open_for_write(lst_file_list.first);
  31.  print("\n");
  32.  print(" Start  Stop   Length Name                   Class\n");
  33.  TraverseList(segment_list, seg)
  34.   BeginTraverse
  35.    stop_address = Seg.address+Seg.length;
  36.    If Seg.length Exceeds 0L
  37.     Then
  38.      stop_address--;
  39.     EndIf;
  40.    print(" %05lXH %05lXH %05lXH %-22Fs %-22Fs\n",
  41.          Seg.address,
  42.          stop_address,
  43.          Seg.length,
  44.          (*Seg.segment_name).symbol,
  45.          (*Seg.class_name).symbol);
  46.   EndTraverse;
  47.  
  48.  If map.set IsTrue
  49.   Then
  50.    If First(group_list) IsNotNull
  51.     Then
  52.      print("\n");
  53.      print(" Origin   Group\n");
  54.      TraverseList(group_list, grp)
  55.       BeginTraverse
  56.        print(" %04X:%1X   %Fs\n",
  57.              CanonicFrame((*Grp.first_segment).address),
  58.              Bit_16((*Grp.first_segment).address & 0xFL),
  59.              (*Grp.group_name).symbol);
  60.       EndTraverse;
  61.     EndIf;
  62.  
  63.     public_sort_array = (public_entry_ptr_array)
  64.                           allocate_memory
  65.                            (Addr(dynamic_pool),
  66.                             Bit_32(sizeof(public_entry_ptr)) *
  67.                              Bit_32(MAX_PUBLICS_IN_LIBRARY));
  68.    n_publics_to_sort = 0;
  69.    TraverseList(external_list, pub)
  70.     BeginTraverse
  71.      LoopIf(Pub.type_entry IsNot internal);
  72.      public_sort_array[n_publics_to_sort++] = pub;
  73.     EndTraverse;
  74.    TraverseList(lib_file_list, file)
  75.     BeginTraverse
  76.      TraverseList(File.external_list, pub)
  77.       BeginTraverse
  78.        LoopIf(Pub.type_entry IsNot internal);
  79.        public_sort_array[n_publics_to_sort++] = pub;
  80.       EndTraverse;
  81.     EndTraverse;
  82.    If n_publics_to_sort Exceeds 0
  83.     Then
  84.      sort_publics_by_name(0, n_publics_to_sort-1);
  85.      print("\n");
  86.      print("  Address         Publics by Name\n");
  87.      print("\n");
  88.      For i=0; i LessThan n_publics_to_sort; i++
  89.       BeginFor
  90.        pub = public_sort_array[i];
  91.        print(" %04X:%04X  ",
  92.              CanonicFrame(public_frame_address(pub)),
  93.              Bit_16(public_target_address(pub) -
  94.                     public_frame_address(pub)));
  95.        If Pub.Internal.lseg IsNull
  96.         Then
  97.          print("Abs  ");
  98.         Else
  99.          print("     ");
  100.         EndIf;
  101.        print("%Fs\n", Pub.symbol);
  102.       EndFor;
  103.      sort_publics_by_value(0, n_publics_to_sort-1);
  104.      print("\n");
  105.      print("  Address         Publics by Value\n");
  106.      print("\n");
  107.      For i=0; i LessThan n_publics_to_sort; i++
  108.       BeginFor
  109.        pub = public_sort_array[i];
  110.        print(" %04X:%04X  ",
  111.              CanonicFrame(public_frame_address(pub)),
  112.              Bit_16(public_target_address(pub) -
  113.                     public_frame_address(pub)));
  114.        If Pub.Internal.lseg IsNull
  115.         Then
  116.          print("Abs  ");
  117.         Else
  118.          print("     ");
  119.         EndIf;
  120.        print("%Fs\n", Pub.symbol);
  121.       EndFor;
  122.     EndIf;
  123.  
  124.  
  125.    print("\n");
  126.    If start_address_found IsTrue
  127.     Then
  128.      print("Program entry point at %04X:%04X\n",
  129.             initial_CS,
  130.             initial_IP);
  131.     EndIf;
  132.   EndIf;
  133.  
  134.  If detail_level.val Exceeds 0
  135.   Then
  136.    print("\n");
  137.    print("Next Uninitialized Byte(%05lX), EXE header Relocation Items(%u)\n",
  138.          highest_uninitialized_byte,
  139.          n_relocation_items);
  140.    print("\n");
  141.    print("Segment order expression:\n");
  142.    print("\t\"%Fs\"\n", String(ordering.val));
  143.    TraverseList(segment_list, seg)
  144.     BeginTraverse
  145.      print("\n");
  146.      print("Segment(%Fs) Class(%Fs)",
  147.            (*Seg.segment_name).symbol,
  148.            (*Seg.class_name).symbol);
  149.      If Seg.owning_group IsNotNull
  150.       Then
  151.        print(" Group(%Fs)",
  152.              (*(*Seg.owning_group).group_name).symbol);
  153.       EndIf;
  154.      print(" Combine(%s)\n",
  155.            combine_text[Seg.combine]);
  156.      print("\tStart(%05lX) Length(%05lX) Next Uninitialized Byte(%05lX)\n",
  157.            Seg.address,
  158.            Seg.length,
  159.            Seg.highest_uninitialized_byte);
  160.      If detail_level.val Exceeds 1
  161.       Then
  162.        TraverseList(Seg.lsegs, lseg)
  163.         BeginTraverse
  164.          LoopIf(Lseg.length IsZero);
  165.          print("\n");
  166.          print("File(%Fs) Next Uninitialized Byte(%05lX)\n",
  167.                (*Lseg.file).filename,
  168.                Lseg.highest_uninitialized_byte+Lseg.address);
  169.          print("\tModule(%Fs) Address(%05lX) Length(%05lX) Align(%s)\n",
  170.                (*Lseg.tmodule).symbol,
  171.                Lseg.address,
  172.                Lseg.length,
  173.                align_text[Lseg.align]);
  174.          If (detail_level.val Exceeds 2)             AndIf 
  175.             (Lseg.align IsNot absolute_segment)      AndIf
  176.             (Seg.combine IsNot blank_common_combine)
  177.           Then
  178.            map_memory(Lseg.data, Lseg.address, Lseg.length);
  179.           EndIf;
  180.         EndTraverse;
  181.       EndTraverse;
  182.     EndIf;
  183.    If (detail_level.val Exceeds 3) AndIf (exefile IsTrue)
  184.     Then
  185.      print("\n");
  186.      print("EXE file header:\n");
  187.      map_memory(BytePtr(exe_header), 0L, exe_header_size);
  188.     EndIf;
  189.    If detail_level.val Exceeds 4
  190.     Then
  191.      last_location_lseg = Null;
  192.      print("\n");
  193.      print("Fixups:\n");
  194.      file_open_for_read(temp_file);
  195.      file_read(BytePtr(Addr(temp_file_header)), sizeof(temp_file_header));
  196.      While temp_file_header.rec_typ IsNotZero
  197.       BeginWhile
  198.        If temp_file_header.rec_typ IsNot FIXUPP_record
  199.         Then
  200.          file_position(Bit_32(infile.byte_position) +
  201.                        infile.start_of_buffer_position +
  202.                        Bit_32(temp_file_header.rec_len));
  203.          file_read(BytePtr(Addr(temp_file_header)), sizeof(temp_file_header));
  204.          ContinueLoop;
  205.         Else
  206.          file_read(BytePtr(Addr(fixup)), temp_file_header.rec_len);
  207.         EndIf;
  208.        If last_location_lseg IsNot temp_file_header.lseg
  209.         Then
  210.          lseg = temp_file_header.lseg;
  211.          seg  = Lseg.segment;
  212.          print("\n");
  213.          print("Fixups for File(%Fs), Module(%Fs), Segment(%Fs)\n",
  214.                (*Lseg.file).filename,
  215.                (*Lseg.tmodule).symbol,
  216.                (*Seg.segment_name).symbol);
  217.         EndIf;
  218.        last_location_lseg = temp_file_header.lseg;
  219.        print("\tLocation(%05lX) Type(%s) Mode(%s)\n",
  220.              (*temp_file_header.lseg).address +
  221.               Bit_32(temp_file_header.offset),
  222.              type_text[fixup.location_type],
  223.              mode_text[fixup.mode]);
  224.        print("\t\tFrame(");
  225.        Using fixup.frame_method
  226.         BeginCase
  227.          When 0:
  228.           lseg = (lseg_ptr) fixup.frame_referent;
  229.           seg  = Lseg.segment;
  230.           print("Seg(%Fs)", (*Seg.segment_name).symbol);
  231.           break;
  232.          When 1:
  233.           grp = (group_entry_ptr) fixup.frame_referent;
  234.           print("Grp(%Fs)", (*Grp.group_name).symbol);
  235.           break;
  236.          When 2:
  237.           pub = (public_entry_ptr) fixup.frame_referent;
  238.           print("Ext(%Fs)", Pub.symbol);
  239.           break;
  240.          When 3:
  241.           print("Abs(%04lX)", ((bit_32)(fixup.frame_referent)));
  242.           break;
  243.          When 4:
  244.           print("Location");
  245.           break;
  246.          When 5:
  247.           print("Target");
  248.           break;
  249.          When 6:
  250.           print("None");
  251.           break;
  252.         EndCase;
  253.        print(") Target(");
  254.        Using fixup.target_method
  255.         BeginCase
  256.          When 0:
  257.           lseg = (lseg_ptr) fixup.target_referent;
  258.           seg  = Lseg.segment;
  259.           print("Seg(%Fs)+%04lX",
  260.                 (*Seg.segment_name).symbol,
  261.                 Bit_32(fixup.target_offset) +
  262.                  (Lseg.address - Seg.address));
  263.           break;
  264.          When 1:
  265.           grp = (group_entry_ptr) fixup.target_referent;
  266.           print("Grp(%Fs)+%04lX",
  267.                 (*Grp.group_name).symbol,
  268.                 Bit_32(fixup.target_offset));
  269.           break;
  270.          When 2:
  271.           pub = (public_entry_ptr) fixup.target_referent;
  272.           print("Ext(%Fs)+%04lX",
  273.                 Pub.symbol,
  274.                 Bit_32(fixup.target_offset));
  275.           break;
  276.          When 3:
  277.           print("Abs(%04lX)", ((bit_32)(fixup.target_referent)));
  278.           break;
  279.         EndCase;
  280.        print(")\n");
  281.        file_read(BytePtr(Addr(temp_file_header)), sizeof(temp_file_header));
  282.       EndWhile;
  283.      file_close_for_read();
  284.     EndIf;
  285.   EndIf;
  286.  file_close_for_write();
  287.  return;
  288. EndCode
  289. #undef File
  290. #undef Grp
  291. #undef Pub
  292. #undef Seg
  293. #undef Lseg
  294.  
  295. /*+-------------------------------------------------------------------------+
  296.   |                                                                         |
  297.   |                               map_memory                                |
  298.   |                                                                         |
  299.   +-------------------------------------------------------------------------+*/
  300. void map_memory(byte_ptr data, bit_32 address, bit_32 length)
  301. BeginDeclarations
  302. bit_16                                 i;
  303. bit_32                                 line_address;
  304. char                                   ascii[20];
  305. EndDeclarations
  306. BeginCode
  307.  line_address = address & 0xFFFF0L;
  308.  While length Exceeds 0
  309.   BeginWhile
  310.    print("%05X: ", line_address);
  311.    far_set(BytePtr(ascii), 0, 20);
  312.    For i=0; i<16; i++
  313.     BeginFor
  314.      If i Is 8
  315.       Then
  316.        print(" :");
  317.        strcat(ascii, " : ");
  318.       EndIf;
  319.      If (line_address LessThan address) OrIf (length IsZero)
  320.       Then
  321.        print(" ..");
  322.        ascii[strlen(ascii)] = ' ';
  323.        line_address++;
  324.       Else
  325.        print(" %02X", *data);
  326.        If isprint(*data)
  327.         Then
  328.          ascii[strlen(ascii)] = (char) *data;
  329.         Else
  330.          ascii[strlen(ascii)] = '.';
  331.         EndIf;
  332.        data++;
  333.        line_address++;
  334.        address++;
  335.        length--;
  336.       EndIf;
  337.     EndFor;
  338.    print("  %s\n", ascii);
  339.   EndWhile;
  340.  return;
  341. EndCode
  342.  
  343. /*+-------------------------------------------------------------------------+
  344.   |                                                                         |
  345.   |                          sort_publics_by_name                           |
  346.   |                                                                         |
  347.   +-------------------------------------------------------------------------+*/
  348. void sort_publics_by_name(bit_16 left, bit_16 right)
  349. BeginDeclarations
  350. bit_16                                 i;
  351. bit_16                                 j;
  352. public_entry_ptr                       temp;
  353. EndDeclarations
  354. BeginCode
  355.  If left NotLessThan right
  356.   Then
  357.    return;
  358.   EndIf;
  359.  i = left;
  360.  j = right;
  361.  While i LessThan j
  362.   BeginWhile
  363.    While i LessThan j
  364.     BeginWhile
  365.      If far_compare((*public_sort_array[i]).symbol,
  366.                     (*public_sort_array[j]).symbol,
  367.                     (*public_sort_array[i]).length+1) Exceeds 0
  368.       Then
  369.        temp                 = public_sort_array[i];
  370.        public_sort_array[i] = public_sort_array[j];
  371.        public_sort_array[j] = temp;
  372.        ExitLoop;
  373.       EndIf;
  374.      j--;
  375.     EndWhile;
  376.    While i LessThan j
  377.     BeginWhile
  378.      If far_compare((*public_sort_array[i]).symbol,
  379.                     (*public_sort_array[j]).symbol,
  380.                     (*public_sort_array[i]).length+1) Exceeds 0
  381.       Then
  382.        temp                 = public_sort_array[i];
  383.        public_sort_array[i] = public_sort_array[j];
  384.        public_sort_array[j] = temp;
  385.        ExitLoop;
  386.       EndIf;
  387.      i++;
  388.     EndWhile;
  389.   EndWhile;
  390.   If i Exceeds 0
  391.    Then
  392.     sort_publics_by_name(left, i-1);
  393.    EndIf;
  394.  sort_publics_by_name(i+1,  right);
  395.  return;
  396. EndCode
  397.  
  398. /*+-------------------------------------------------------------------------+
  399.   |                                                                         |
  400.   |                          sort_publics_by_value                          |
  401.   |                                                                         |
  402.   +-------------------------------------------------------------------------+*/
  403. void sort_publics_by_value(bit_16 left, bit_16 right)
  404. BeginDeclarations
  405. bit_16                                 i;
  406. bit_16                                 j;
  407. public_entry_ptr                       temp;
  408. EndDeclarations
  409. BeginCode
  410.  If left NotLessThan right
  411.   Then
  412.    return;
  413.   EndIf;
  414.  i = left;
  415.  j = right;
  416.  While i LessThan j
  417.   BeginWhile
  418.    While i LessThan j
  419.     BeginWhile
  420.      If (((*public_sort_array[i]).Internal.lseg IsNull) AndIf
  421.          ((*public_sort_array[j]).Internal.lseg IsNotNull)) OrIf
  422.         (public_target_address(public_sort_array[i]) Exceeds
  423.          public_target_address(public_sort_array[j]))
  424.       Then
  425.        temp                 = public_sort_array[i];
  426.        public_sort_array[i] = public_sort_array[j];
  427.        public_sort_array[j] = temp;
  428.        ExitLoop;
  429.       EndIf;
  430.      j--;
  431.     EndWhile;
  432.    While i LessThan j
  433.     BeginWhile
  434.      If (((*public_sort_array[i]).Internal.lseg IsNull) AndIf
  435.          ((*public_sort_array[j]).Internal.lseg IsNotNull)) OrIf
  436.         (public_target_address(public_sort_array[i]) Exceeds
  437.          public_target_address(public_sort_array[j]))
  438.       Then
  439.        temp                 = public_sort_array[i];
  440.        public_sort_array[i] = public_sort_array[j];
  441.        public_sort_array[j] = temp;
  442.        ExitLoop;
  443.       EndIf;
  444.      i++;
  445.     EndWhile;
  446.   EndWhile;
  447.   If i Exceeds 0
  448.    Then
  449.     sort_publics_by_value(left, i-1);
  450.    EndIf;
  451.  sort_publics_by_value(i+1,  right);
  452.  return;
  453. EndCode
  454.  
  455.  
  456. /*
  457.  Start  Stop   Length Name                   Class
  458.  00000H 016F7H 016F8H _TEXT                  CODE
  459.  016F8H 016F8H 00000H C_ETEXT                ENDCODE
  460.  01700H 01741H 00042H NULL                   BEGDATA
  461.  01742H 01967H 00226H _DATA                  DATA
  462.  01968H 01975H 0000EH CDATA                  DATA
  463.  01976H 01976H 00000H XIFB                   DATA
  464.  01976H 01976H 00000H XIF                    DATA
  465.  01976H 01976H 00000H XIFE                   DATA
  466.  01976H 01976H 00000H XIB                    DATA
  467.  01976H 01976H 00000H XI                     DATA
  468.  01976H 01976H 00000H XIE                    DATA
  469.  01976H 01976H 00000H XPB                    DATA
  470.  01976H 01977H 00002H XP                     DATA
  471.  01978H 01978H 00000H XPE                    DATA
  472.  01978H 01978H 00000H XCB                    DATA
  473.  01978H 01978H 00000H XC                     DATA
  474.  01978H 01978H 00000H XCE                    DATA
  475.  01978H 01978H 00000H XCFB                   DATA
  476.  01978H 01978H 00000H XCF                    DATA
  477.  01978H 01978H 00000H XCFE                   DATA
  478.  01978H 01978H 00000H CONST                  CONST
  479.  01978H 0197FH 00008H HDR                    MSG
  480.  01980H 01A4DH 000CEH MSG                    MSG
  481.  01A4EH 01A4FH 00002H PAD                    MSG
  482.  01A50H 01A50H 00001H EPAD                   MSG
  483.  01A52H 01A77H 00026H _BSS                   BSS
  484.  01A78H 01A78H 00000H XOB                    BSS
  485.  01A78H 01A78H 00000H XO                     BSS
  486.  01A78H 01A78H 00000H XOE                    BSS
  487.  01A80H 02085H 00606H c_common               BSS
  488.  02090H 0288FH 00800H STACK                  STACK
  489.  
  490.  Origin   Group
  491.  0170:0   DGROUP
  492.  
  493.   Address         Publics by Name
  494.  
  495.  0170:005C       STKHQQ
  496.  
  497.   Address         Publics by Value
  498.  
  499.  0000:0010       _main
  500.  0000:9876  Abs  __acrtmsg
  501.  0000:9876  Abs  __acrtused
  502.  
  503. Program entry point at 0000:0294
  504.  
  505.  
  506. */
  507.