lx.c

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

    memcpy(headbuf,stubData,stubSize ) ;

    *(bit_32_ptr)( headbuf + 0x3c) = headerStart ; /* Pointer to PE header */
    lxhead = (lx_header_ptr)(headbuf + headerStart) ;

    If lxfile.val
     Then
      LXHead.sig = LX_SIGNATURE ;
     Else
      LXHead.sig = LE_SIGNATURE ;
     EndIf
    LXHead.cpu_level = LX_CPU_386 ;
    LXHead.os_type = LX_OS_DOS ;
    LXHead.module_version = lx_version.val ;
    LXHead.module_flags = 0; //LX_MF_INTERNALFIXUPSAPPLIED ;
    LXHead.page_size = lx_page_size.val ;
    If lxfile.val
     Then
      LXHead.page_offset_shift = lx_page_shift.val ;
     Else
      LXHead.page_offset_shift = lx_page_size.val ;
     EndIf
    LXHead.object_table_offset =  sizeof(LXHead) ;
    LXHead.object_count = n_lx_sections ;
    LXHead.object_page_table_offset  = sizeof(LXHead) + n_lx_sections * sizeof(LXObject);

    If start_address_found IsTrue
     Then
      fixup                 = start_address;
      LXHead.eip_object = 1 ;
      LXHead.eip = target(&import) - lx_outList[0]->base ; /* RVA */
     Else  /* No start address found. */
      linker_error(4,"No start address.\n");
     EndIf;

    LXHead.esp_object = i+1 ;
    LXHead.esp = stackSize.val ; // highest address

    lxobject = headbuf + headerStart + sizeof(LXHead) ;

    /* make the objects */
    For i=0; i < n_lx_sections; i++, lxobject++
     BeginFor
      lx_outList[i]->page_table_entries = (lx_outList[i]->length + lx_page_size.val-1)/ lx_page_size.val;
      LXObject.virtual_size = lx_outList[i]->virtualSize ;
      LXObject.reloc_base_addr = lx_outList[i]->base ;
      LXObject.object_flags = lx_outList[i]->Flags ;
      LXObject.page_table_index = currentPage + 1;
      currentPage += 
         LXObject.page_table_entries = lx_outList[i]->page_table_entries ;
     EndFor
    
    /* make the object pages */
    If lxfile.val
     Then
      p = (byte_ptr)lxobjectPage = (lx_object_page_ptr)allocate_memory(sizeof(LXObjectPage) * currentPage) ;

      k = 1 ;

      For i=0; i < n_lx_sections; i++
       BeginFor
        size = 0 ;
        For j=0; j < lx_outList[i]->page_table_entries; j++,lxobjectPage++
         BeginFor
          If size GreaterThanOrEqualTo lx_outList[i]->initlength
           Then
            LXObjectPage.flags = LX_OPF_ZERO ;
            LXObjectPage.data_offset = 0 ;
            LXObjectPage.data_size = lx_page_size.val ;
           Else
            LXObjectPage.flags = LX_OPF_ENUMERATED ;
            LXObjectPage.data_offset = k++ ;
            size +=
             LXObjectPage.data_size = lx_page_size.val ;
           EndIf
         EndFor
       EndFor 
       LXHead.loader_section_size = currentPage * sizeof (LXObjectPage) + n_lx_sections * sizeof(LXObject) ;
     Else
      p = (byte_ptr)leobjectPage = (le_object_page_ptr)allocate_memory(sizeof(LEObjectPage) * currentPage) ;

      k = 1 ;

      For i=0; i < n_lx_sections; i++
       BeginFor
        size = 0 ;
        For j=0; j < lx_outList[i]->page_table_entries; j++,leobjectPage++
         BeginFor
          If size GreaterThanOrEqualTo lx_outList[i]->initlength
           Then
            LEObjectPage.flags = LE_OPF_ZERO ;
            LEObjectPage.high_offs = LEObjectPage.med_offs = LEObjectPage.low_offs = 0 ;
           Else
            LEObjectPage.flags = LE_OPF_ENUMERATED ;
            LEObjectPage.high_offs = k/65536 ;
            LEObjectPage.med_offs = k/256 ;
            LEObjectPage.low_offs = k++ ;
            size += lx_page_size.val ;
           EndIf
         EndFor
       EndFor 
       leobjectPage[-1].flags |= LE_OPF_LASTPAGE ;
       LXHead.loader_section_size = currentPage * sizeof (LEObjectPage) + n_lx_sections * sizeof(LXObject) ;
      EndIf

    lxobjectPage = leobjectPage = p ;
    LXHead.module_page_count = k-1 ;
    LXHead.instance_preload_count = currentPage ;
    LXHead.preload_pages_count = k-1 ;
    If n_lx_fixups IsNotZero
     Then

      lxfixupPage = (lx_fixup_page_ptr)allocate_memory(sizeof(lx_fixup_page_type) * (lxfile.val ? (1 + currentPage) : k)) ;

      If lxfile.val
       Then
        LXHead.fixup_page_table_offset = LXHead.object_page_table_offset + currentPage * sizeof (LXObjectPage);
       Else
        LXHead.fixup_page_table_offset = LXHead.object_page_table_offset + currentPage * sizeof (LEObjectPage);
       EndIf
      LXHead.fixup_record_table_offset = LXHead.fixup_page_table_offset + sizeof(lx_fixup_page_type) * (lxfile.val ? (1 + currentPage) : k);

      SortLXFixups() ;
      size = 0 ;
      asize = 0 ;
      j=0 ;
      l=0 ;
      For i=0; i < n_lx_sections ; i++
       BeginFor
        xsize = lx_outList[i]->base ;
        For k = 0; k < lx_outList[i]->page_table_entries; k++,leobjectPage++
         BeginFor
          If lxfile.val IsTrue OrIf LEObjectPage.flags Is LX_OPF_ENUMERATED
           Then
            lxfixupPage[l].offset = size ;
            If j < n_lx_fixups AndIf (int)(lx_fixup_array[j]->offset - xsize) < (int)lx_page_size.val 
             Then
              For ; j < n_lx_fixups AndIf (int)(lx_fixup_array[j]->offset - xsize) < (int)lx_page_size.val ;j++
               BeginFor
                // embed the fixup - only doing 32-bit offsets
                fixuplen = 0 ;
                fixupbuf[fixuplen++] = LX_FM_OFFSET32 ;
                fixupbuf[fixuplen++] = LX_FT_INTERNAL + LX_FF_TARGET32 ;
                *(bit_16_ptr)(fixupbuf+fixuplen) = lx_fixup_array[j]->offset - xsize ;
                fixuplen += sizeof(bit_16);
                fixupbuf[fixuplen++] = lx_fixup_array[j]->target_object+1 ;
                *(bit_32 *)(fixupbuf + fixuplen) = lx_fixup_array[j]->target - lx_outList[lx_fixup_array[j]->target_object]->base ;
                fixuplen += sizeof(bit_32) ;

                If asize - size < fixuplen 
                 Then
                  asize += 2048 ;
                  lxfixupRecord = (byte *)reallocate_memory(lxfixupRecord, asize) ;
                 EndIf
                memcpy(lxfixupRecord+size, fixupbuf, fixuplen) ;
                size += fixuplen ;
                // Check for fixup crossing a page boundary
                If (int)(lx_fixup_array[j]->offset + sizeof(bit_32) - xsize) > (int)lx_page_size.val
                 Then
                  ExitLoop ;
                 EndIf 
               EndFor
             EndIf
            l++ ;
           EndIf
          xsize += lx_page_size.val ;
         EndFor
       EndFor

      lxfixupPage[l].offset = size ;
      LXHead.fixup_section_size = size + (currentPage+1) * sizeof(lx_fixup_page_type) ;
      LXHead.data_pages_offset = ((LXHead.fixup_page_table_offset + LXHead.fixup_section_size + headerStart + lx_page_size.val-1)/ lx_page_size.val) * lx_page_size.val ;
     Else
      LXHead.data_pages_offset = ((LXHead.object_page_table_offset + LXHead.module_page_count * sizeof(LXObjectPage) + headerStart + lx_page_size.val-1)/lx_page_size.val) * lx_page_size.val ;
     EndIf

    lxobjectPage = leobjectPage = p ;

    far_set(BytePtr(object_file_element), 0, MAX_ELEMENT_SIZE);

    file_open_for_write(exe_file_list.first) ;
    file_write(headbuf,headerSize) ;
    file_write(lxobjectPage,currentPage * (lxfile.val ? sizeof(lx_object_page_type) : sizeof(le_object_page_type))) ;
    If n_lx_fixups IsNotZero
     Then
      file_write(lxfixupPage,(lxfile.val ? (currentPage+1) : LXHead.module_page_count+1) * sizeof(lx_fixup_page_type)) ;
      file_write(lxfixupRecord,size) ;
      write_gap(LXHead.data_pages_offset-(LXHead.fixup_record_table_offset + headerStart+size));
     Else
      write_gap(LXHead.data_pages_offset-(LXHead.object_page_table_offset + headerStart + sizeof (LXObjectPage) * currentPage));
     EndIf 

 next_available_address = 0 ;
 TraverseList(segment_list, seg)
  BeginTraverse
   LoopIf((*Seg.lsegs.first).align Is absolute_segment);
   LoopIf(Seg.pe_section_number Is PE_bss_seg);
   LoopIf(Seg.pe_section_number Is LXHead.esp_object-1) ;

   If current_section IsNotEqualTo Seg.pe_section_number
    Then
       current_section = Seg.pe_section_number ;
    EndIf ;

   TraverseList(Seg.lsegs, lseg)
    BeginTraverse
       If Lseg.address - next_available_address IsNotZero
        Then
         write_gap(Lseg.address - next_available_address) ;
        EndIf ;
       next_available_address = Lseg.address + Lseg.length ;
       If Seg.combine Is blank_common_combine
        Then
         write_gap(Lseg.length) ;
        Else
         file_write(Addr(Lseg.data[0]), Lseg.length) ;
        EndIf ;
    EndTraverse;
   
  EndTraverse ;
  file_close_for_write() ;
EndCode