WebSVN – Kolibri OS – Diff – /programs/develop/fasm/trunk/formats.inc


; flat assembler core
; Copyright (c) 1999-2006, Tomasz Grysztar.
; All rights reserved.
 
formatter:
        cmp     [output_file],0
        jne     output_path_ok
        push    edi
        mov     esi,[input_file]
        mov     edi,[free_additional_memory]
      copy_output_path:
        lods    byte [esi]
        cmp     edi,[structures_buffer]
        jae     out_of_memory
        stos    byte [edi]
        or      al,al
        jnz     copy_output_path
        dec     edi
        mov     eax,edi
      find_extension:
        dec     eax
        cmp     eax,[free_additional_memory]
        jb      extension_found
        cmp     byte [eax],'\'
        je      extension_found
        cmp     byte [eax],'/'
        je      extension_found
        cmp     byte [eax],'.'
        jne     find_extension
        mov     edi,eax
      extension_found:
        lea     eax,[edi+9]
        cmp     eax,[structures_buffer]
        jae     out_of_memory
        cmp     [output_format],2
        je      exe_extension
        jb      bin_extension
        cmp     [output_format],4
        je      obj_extension
        cmp     [output_format],5
        je      o_extension
        cmp     [output_format],3
        jne     no_extension
        cmp     [subsystem],1
        je      sys_extension
        bt      [format_flags],8
        jnc     exe_extension
        mov     eax,'.dll'
        jmp     make_extension
      sys_extension:
        mov     eax,'.sys'
        jmp     make_extension
      bin_extension:
        mov     eax,'.bin'
        bt      [format_flags],0
        jnc     make_extension
        mov     eax,'.com'
        jmp     make_extension
      obj_extension:
        mov     eax,'.obj'
        jmp     make_extension
      o_extension:
        mov     eax,'.o'
        bt      [format_flags],0
        jnc     make_extension
      no_extension:
        xor     eax,eax
        jmp     make_extension
      exe_extension:
        mov     eax,'.exe'
      make_extension:
        xchg    eax,[edi]
        scas    dword [edi]
        mov     byte [edi],0
        scas    byte [edi]
        mov     esi,edi
        stos    dword [edi]
        sub     edi,9
        xor     eax,eax
        mov     ebx,characters
      adapt_case:
        mov     al,[esi]
        or      al,al
        jz      adapt_next
        xlat    byte [ebx]
        cmp     al,[esi]
        je      adapt_ok
        sub     byte [edi],20h
      adapt_ok:
        inc     esi
      adapt_next:
        inc     edi
        cmp     byte [edi],0
        jne     adapt_case
        mov     esi,edi
        lea     ecx,[esi+1]
        sub     ecx,[free_additional_memory]
        mov     edi,[structures_buffer]
        dec     edi
        std
        rep     movs byte [edi],[esi]
        cld
        inc     edi
        mov     [structures_buffer],edi
        mov     [output_file],edi
        pop     edi
      output_path_ok:
        cmp     [output_format],4
        je      coff_formatter
        cmp     [output_format],5
        jne     common_formatter
        bt      [format_flags],0
        jnc     elf_formatter
      common_formatter:
        mov     eax,edi
        sub     eax,[code_start]
        mov     [real_code_size],eax
        cmp     edi,[undefined_data_end]
        jne     calculate_code_size
        mov     edi,[undefined_data_start]
      calculate_code_size:
        sub     edi,[code_start]
        mov     [code_size],edi
        mov     [written_size],0
        mov     edx,[output_file]
        call    create
        jc      write_failed
        cmp     [output_format],3
        jne     stub_written
        mov     edx,[code_start]
        mov     ecx,[stub_size]
        sub     edx,ecx
        add     [written_size],ecx
        call    write
      stub_written:
        cmp     [output_format],2
        jne     write_output
        call    write_mz_header
      write_output:
        call    write_code
      output_written:
        call    close
        ret
      write_code:
        mov     eax,[written_size]
        mov     [headers_size],eax
        mov     edx,[code_start]
        mov     ecx,[code_size]
        add     [written_size],ecx
        call    write
        jc      write_failed
        ret
format_directive:
        cmp     edi,[code_start]
        jne     unexpected_instruction
        cmp     [virtual_data],0
        jne     unexpected_instruction
        cmp     [output_format],0
        jne     unexpected_instruction
        lods    byte [esi]
        cmp     al,17h
        je      format_prefix
        cmp     al,18h
        jne     invalid_argument
        lods    byte [esi]
      select_format:
        mov     dl,al
        shr     al,4
        mov     [output_format],al
        and     edx,0Fh
        or      [format_flags],edx
        cmp     al,2
        je      format_mz
        cmp     al,3
        je      format_pe
        cmp     al,4
        je      format_coff
        cmp     al,5
        je      format_elf
        jmp     instruction_assembled
      format_prefix:
        lods    byte [esi]
        mov     ah,al
        lods    byte [esi]
        cmp     al,18h
        jne     invalid_argument
        lods    byte [esi]
        mov     edx,eax
        shr     dl,4
        shr     dh,4
        cmp     dl,dh
        jne     invalid_argument
        or      al,ah
        jmp     select_format
entry_directive:
        bts     [format_flags],10h
        jc      setting_already_specified
        mov     al,[output_format]
        cmp     al,2
        je      mz_entry
        cmp     al,3
        je      pe_entry
        cmp     al,5
        jne     illegal_instruction
        bt      [format_flags],0
        jc      elf_entry
        jmp     illegal_instruction
stack_directive:
        bts     [format_flags],11h
        jc      setting_already_specified
        mov     al,[output_format]
        cmp     al,2
        je      mz_stack
        cmp     al,3
        je      pe_stack
        jmp     illegal_instruction
heap_directive:
        bts     [format_flags],12h
        jc      setting_already_specified
        mov     al,[output_format]
        cmp     al,2
        je      mz_heap
        cmp     al,3
        je      pe_heap
        jmp     illegal_instruction
segment_directive:
        cmp     [virtual_data],0
        jne     illegal_instruction
        mov     al,[output_format]
        cmp     al,2
        je      mz_segment
        cmp     al,5
        je      elf_segment
        jmp     illegal_instruction
section_directive:
        cmp     [virtual_data],0
        jne     illegal_instruction
        mov     al,[output_format]
        cmp     al,3
        je      pe_section
        cmp     al,4
        je      coff_section
        cmp     al,5
        je      elf_section
        jmp     illegal_instruction
public_directive:
        mov     al,[output_format]
        cmp     al,4
        je      public_allowed
        cmp     al,5
        jne     illegal_instruction
        bt      [format_flags],0
        jc      illegal_instruction
      public_allowed:
        lods    byte [esi]
        cmp     al,2
        jne     invalid_argument
        lods    dword [esi]
        cmp     eax,0Fh
        jb      invalid_use_of_symbol
        je      reserved_word_used_as_symbol
        mov     dx,[current_pass]
        mov     [eax+18],dx
        or      byte [eax+8],8
        inc     esi
        mov     ebx,[free_additional_memory]
        lea     edx,[ebx+10h]
        cmp     edx,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],edx
        mov     [ebx+8],eax
        mov     eax,[current_line]
        mov     [ebx+0Ch],eax
        lods    byte [esi]
        cmp     al,86h
        jne     invalid_argument
        lods    word [esi]
        cmp     ax,'('
        jne     invalid_argument
        mov     [ebx+4],esi
        lods    dword [esi]
        lea     esi,[esi+eax+1]
        mov     byte [ebx],80h
        jmp     instruction_assembled
extrn_directive:
        mov     al,[output_format]
        cmp     al,4
        je      extrn_allowed
        cmp     al,5
        jne     illegal_instruction
        bt      [format_flags],0
        jc      illegal_instruction
      extrn_allowed:
        lods    word [esi]
        cmp     ax,'('
        jne     invalid_argument
        mov     ebx,esi
        lods    dword [esi]
        lea     esi,[esi+eax+1]
        mov     edx,[free_additional_memory]
        lea     eax,[edx+0Ch]
        cmp     eax,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],eax
        mov     byte [edx],81h
        mov     [edx+4],ebx
        lods    byte [esi]
        cmp     al,86h
        jne     invalid_argument
        lods    byte [esi]
        cmp     al,2
        jne     invalid_argument
        lods    dword [esi]
        cmp     eax,0Fh
        jb      invalid_use_of_symbol
        je      reserved_word_used_as_symbol
        inc     esi
        mov     ebx,eax
        xor     ah,ah
        lods    byte [esi]
        cmp     al,':'
        je      get_extrn_size
        dec     esi
        cmp     al,11h
        jne     extrn_size_ok
      get_extrn_size:
        lods    word [esi]
        cmp     al,11h
        jne     invalid_argument
      extrn_size_ok:
        mov     [address_symbol],edx
        movzx   ecx,ah
        mov     [edx+8],ecx
        xor     eax,eax
        xor     edx,edx
        xor     ebp,ebp
        mov     ch,2
        test    [format_flags],8
        jz      make_free_label
        mov     ch,4
        jmp     make_free_label
mark_relocation:
        cmp     [value_type],0
        je      relocation_ok
        cmp     [virtual_data],0
        jne     relocation_ok
        cmp     [output_format],2
        je      mark_mz_relocation
        cmp     [output_format],3
        je      mark_pe_relocation
        cmp     [output_format],4
        je      mark_coff_relocation
        cmp     [output_format],5
        je      mark_elf_relocation
      relocation_ok:
        ret
close_pass:
        mov     al,[output_format]
        cmp     al,3
        je      close_pe
        cmp     al,4
        je      close_coff
        cmp     al,5
        je      close_elf
        ret
 
format_mz:
        mov     edx,[additional_memory]
        push    edi
        mov     edi,edx
        mov     ecx,1Ch shr 2
        xor     eax,eax
        rep     stos dword [edi]
        mov     [free_additional_memory],edi
        pop     edi
        mov     word [edx+0Ch],0FFFFh
        mov     word [edx+10h],1000h
        mov     [code_type],16
        jmp     instruction_assembled
mark_mz_relocation:
        push    eax ebx
        inc     [number_of_relocations]
        mov     ebx,[free_additional_memory]
        mov     eax,edi
        sub     eax,[code_start]
        mov     [ebx],ax
        shr     eax,16
        shl     ax,12
        mov     [ebx+2],ax
        cmp     word [ebx],0FFFFh
        jne     mz_relocation_ok
        inc     word [ebx+2]
        sub     word [ebx],10h
      mz_relocation_ok:
        add     ebx,4
        cmp     ebx,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],ebx
        pop     ebx eax
        ret
mz_segment:
        lods    byte [esi]
 
 
 
 
        cmp     al,2
        jne     invalid_argument
        lods    dword [esi]
        cmp     eax,0Fh
        jb      invalid_use_of_symbol
        je      reserved_word_used_as_symbol
        inc     esi
        mov     ebx,eax
        mov     eax,edi
        sub     eax,[code_start]
        mov     ecx,0Fh
        add     eax,0Fh
        and     eax,1111b
        sub     ecx,eax
        mov     edx,edi
        xor     al,al
        rep     stos byte [edi]
        mov     dword [org_origin],edi
        mov     dword [org_origin+4],0
        mov     [org_registers],0
        mov     [org_start],edi
        mov     eax,edx
        call    undefined_data
        mov     eax,edi
        sub     eax,[code_start]
        shr     eax,4
        cmp     eax,10000h
        jae     value_out_of_range
        mov     edx,eax
        mov     al,16
        cmp     byte [esi],13h
        jne     segment_type_ok
        inc     esi
        lods    byte [esi]
      segment_type_ok:
        mov     [code_type],al
        mov     eax,edx
        mov     cx,0100h
        xor     edx,edx
        xor     ebp,ebp
        mov     [address_symbol],edx
        jmp     make_free_label
mz_entry:
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        call    get_word_value
        cmp     [value_type],1
        je      initial_cs_ok
        cmp     [error_line],0
        jne     initial_cs_ok
        mov     eax,[current_line]
        mov     [error_line],eax
        mov     [error],invalid_address
      initial_cs_ok:
        mov     edx,[additional_memory]
        mov     [edx+16h],ax
        lods    byte [esi]
        cmp     al,':'
        jne     invalid_argument
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        ja      invalid_address
        call    get_word_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[additional_memory]
        mov     [edx+14h],ax
        jmp     instruction_assembled
mz_stack:
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        call    get_word_value
        cmp     byte [esi],':'
        je      stack_pointer
        cmp     ax,10h
        jb      invalid_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[additional_memory]
        mov     [edx+10h],ax
        jmp     instruction_assembled
      stack_pointer:
        cmp     [value_type],1
        je      initial_ss_ok
        cmp     [error_line],0
        jne     initial_ss_ok
        mov     eax,[current_line]
        mov     [error_line],eax
        mov     [error],invalid_address
      initial_ss_ok:
        mov     edx,[additional_memory]
        mov     [edx+0Eh],ax
        lods    byte [esi]
        cmp     al,':'
        jne     invalid_argument
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        call    get_word_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[additional_memory]
        mov     [edx+10h],ax
        bts     [format_flags],4
        jmp     instruction_assembled
mz_heap:
        cmp     [output_format],2
        jne     illegal_instruction
        lods    byte [esi]
        call    get_size_operator
        cmp     ah,1
        je      invalid_value
        cmp     ah,2
        ja      invalid_value
        cmp     al,'('
        jne     invalid_argument
        call    get_word_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[additional_memory]
        mov     [edx+0Ch],ax
        jmp     instruction_assembled
write_mz_header:
        mov     edx,[additional_memory]
        bt      [format_flags],4
        jc      mz_stack_ok
        mov     eax,[real_code_size]
        dec     eax
        shr     eax,4
        inc     eax
        mov     [edx+0Eh],ax
        shl     eax,4
        movzx   ecx,word [edx+10h]
        add     eax,ecx
        mov     [real_code_size],eax
      mz_stack_ok:
        mov     edi,[free_additional_memory]
        mov     eax,[number_of_relocations]
        shl     eax,2
        add     eax,1Ch
        sub     edi,eax
        xchg    edi,[free_additional_memory]
        mov     ecx,0Fh
        add     eax,0Fh
        and     eax,1111b
        sub     ecx,eax
        xor     al,al
        rep     stos byte [edi]
        sub     edi,[free_additional_memory]
        mov     ecx,edi
        shr     edi,4
        mov     word [edx],'MZ'         ; signature
        mov     [edx+8],di              ; header size in paragraphs
        mov     eax,[number_of_relocations]
        mov     [edx+6],ax              ; number of relocation entries
        mov     eax,[code_size]
        add     eax,ecx
        mov     esi,eax
        shr     esi,9
        and     eax,1FFh
        inc     si
        or      ax,ax
        jnz     mz_size_ok
        mov     ax,200h
        dec     si
      mz_size_ok:
        mov     [edx+2],ax              ; number of bytes in last page
        mov     [edx+4],si              ; number of pages
        mov     eax,[real_code_size]
        dec     eax
        shr     eax,4
        inc     eax
        mov     esi,[code_size]
        dec     esi
        shr     esi,4
        inc     esi
        sub     eax,esi
        mov     [edx+0Ah],ax            ; minimum memory in addition to code
        add     [edx+0Ch],ax            ; maximum memory in addition to code
        salc
        mov     ah,al
        or      [edx+0Ch],ax
        mov     word [edx+18h],1Ch      ; offset of relocation table
        add     [written_size],ecx
        call    write
        jc      write_failed
        ret
 
make_stub:
        mov     [stub_file],edx
        or      edx,edx
        jnz     stub_from_file
        push    esi
        mov     edx,edi
        xor     eax,eax
        mov     ecx,20h
        rep     stos dword [edi]
        mov     eax,40h+default_stub_end-default_stub
        mov     cx,100h+default_stub_end-default_stub
        mov     word [edx],'MZ'
        mov     word [edx+4],1
        mov     word [edx+2],ax
        mov     word [edx+8],4
        mov     word [edx+0Ah],10h
        mov     word [edx+0Ch],0FFFFh
        mov     word [edx+10h],cx
        mov     word [edx+3Ch],ax
        mov     word [edx+18h],40h
        lea     edi,[edx+40h]
        mov     esi,default_stub
        mov     ecx,default_stub_end-default_stub
        rep     movs byte [edi],[esi]
        pop     esi
        jmp     stub_ok
      default_stub:
        use16
        push    cs
        pop     ds
        mov     dx,stub_message-default_stub
        mov     ah,9
        int     21h
        mov     ax,4C01h
        int     21h
      stub_message db 'This program cannot be run in DOS mode.',0Dh,0Ah,24h
        rq      1
      default_stub_end:
        use32
      stub_from_file:
        push    esi
        mov     esi,edx
        call    open_binary_file
        mov     edx,edi
        mov     ecx,1Ch
        mov     esi,edx
        call    read
        jc      binary_stub
        cmp     word [esi],'MZ'
        jne     binary_stub
        add     edi,1Ch
        movzx   ecx,word [esi+6]
        add     ecx,11b
 
        and     ecx,not 11b
 
        add     ecx,(40h-1Ch) shr 2
        lea     eax,[edi+ecx*4]
        cmp     edi,[display_buffer]
        jae     out_of_memory
        xor     eax,eax
        rep     stos dword [edi]
        mov     edx,40h
        xchg    dx,[esi+18h]
        xor     al,al
        call    lseek
        movzx   ecx,word [esi+6]
        shl     ecx,2
        lea     edx,[esi+40h]
        call    read
        mov     edx,edi
        sub     edx,esi
        shr     edx,4
        xchg    dx,[esi+8]
        shl     edx,4
        xor     al,al
        call    lseek
        movzx   ecx,word [esi+4]
        dec     ecx
        shl     ecx,9
        movzx   edx,word [esi+2]
        add     ecx,edx
        mov     edx,edi
        sub     ecx,eax
        je      read_stub_code
        jb      stub_code_ok
        push    ecx
        dec     ecx
        shr     ecx,3
        inc     ecx
        shl     ecx,1
        lea     eax,[edi+ecx*4]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        xor     eax,eax
        rep     stos dword [edi]
        pop     ecx
     read_stub_code:
        call    read
     stub_code_ok:
        call    close
        mov     edx,edi
        sub     edx,esi
        mov     ax,dx
        and     ax,1FFh
        mov     [esi+2],ax
        dec     edx
        shr     edx,9
        inc     edx
        mov     [esi+4],dx
        mov     eax,edi
        sub     eax,esi
        mov     [esi+3Ch],eax
        pop     esi
      stub_ok:
        ret
      binary_stub:
        mov     esi,edi
        mov     ecx,40h shr 2
        xor     eax,eax
        rep     stos dword [edi]
        mov     al,2
        xor     edx,edx
        call    lseek
        push    eax
        xor     al,al
        xor     edx,edx
        call    lseek
        mov     ecx,[esp]
        add     ecx,40h+111b
        and     ecx,not 111b
        mov     ax,cx
        and     ax,1FFh
        mov     [esi+2],ax
        lea     eax,[ecx+1FFh]
        shr     eax,9
        mov     [esi+4],ax
        mov     [esi+3Ch],ecx
        sub     ecx,40h
        mov     eax,10000h
        sub     eax,ecx
        jbe     binary_heap_ok
        shr     eax,4
        mov     [esi+0Ah],ax
      binary_heap_ok:
        mov     word [esi],'MZ'
        mov     word [esi+8],4
        mov     ax,0FFFFh
        mov     [esi+0Ch],ax
        dec     ax
        mov     [esi+10h],ax
        sub     ax,0Eh
        mov     [esi+0Eh],ax
        mov     [esi+16h],ax
        mov     word [esi+14h],100h
        mov     word [esi+18h],40h
        mov     eax,[display_buffer]
        sub     eax,ecx
        cmp     edi,eax
        jae     out_of_memory
        mov     edx,edi
        shr     ecx,2
        xor     eax,eax
        rep     stos dword [edi]
        pop     ecx
        call    read
        call    close
        pop     esi
        ret
 
format_pe:
        xor     edx,edx
        mov     [machine],14Ch
        mov     [subsystem],3
        mov     [subsystem_version],3 + 10 shl 16
        mov     [image_base],400000h
        test    [format_flags],8
        jz      pe_settings
        mov     [machine],8664h
        mov     [subsystem_version],5 + 0 shl 16
        mov     [image_base_high],0
      pe_settings:
        cmp     byte [esi],84h
        je      get_stub_name
        cmp     byte [esi],80h
        je      get_pe_base
        cmp     byte [esi],1Bh
        jne     pe_settings_ok
        lods    byte [esi]
        lods    byte [esi]
        test    al,80h+40h
        jz      subsystem_setting
        cmp     al,80h
        je      dll_flag
        cmp     al,81h
        je      wdm_flag
        jmp     pe_settings
      dll_flag:
        bts     [format_flags],8
        jc      setting_already_specified
        jmp     pe_settings
      wdm_flag:
        bts     [format_flags],9
        jc      setting_already_specified
        jmp     pe_settings
      subsystem_setting:
        bts     [format_flags],7
        jc      setting_already_specified
        and     ax,3Fh
        mov     [subsystem],ax
        cmp     byte [esi],'('
        jne     pe_settings
        inc     esi
        cmp     byte [esi],'.'
        jne     invalid_value
        inc     esi
        push    edx
        cmp     byte [esi+11],0
        jne     invalid_value
        cmp     byte [esi+10],2
        ja      invalid_value
        mov     dx,[esi+8]
        cmp     dx,8000h
        je      zero_version
        mov     eax,[esi+4]
        cmp     dx,7
        jg      invalid_value
        mov     cx,7
        sub     cx,dx
        mov     eax,[esi+4]
        shr     eax,cl
        mov     ebx,eax
        shr     ebx,24
        cmp     bl,100
        jae     invalid_value
        and     eax,0FFFFFFh
        mov     ecx,100
        mul     ecx
        shrd    eax,edx,24
        jnc     version_value_ok
        inc     eax
      version_value_ok:
        shl     eax,16
        mov     ax,bx
        jmp     subsystem_version_ok
      zero_version:
        xor     eax,eax
      subsystem_version_ok:
        pop     edx
        add     esi,13
        mov     [subsystem_version],eax
        jmp     pe_settings
      get_pe_base:
        bts     [format_flags],10
        jc      setting_already_specified
        lods    word [esi]
        cmp     ah,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        push    edx edi
        add     edi,[stub_size]
        test    [format_flags],8
        jnz     get_pe64_base
        call    get_dword_value
        mov     [image_base],eax
        jmp     pe_base_ok
      get_pe64_base:
        call    get_qword_value
        mov     [image_base],eax
        mov     [image_base_high],edx
      pe_base_ok:
        pop     edi edx
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        cmp     byte [esi],84h
        jne     pe_settings_ok
      get_stub_name:
        lods    byte [esi]
        lods    word [esi]
        cmp     ax,'('
        jne     invalid_argument
        lods    dword [esi]
        mov     edx,esi
        add     esi,eax
        inc     esi
      pe_settings_ok:
        mov     ebp,[stub_size]
        or      ebp,ebp
        jz      make_pe_stub
        cmp     edx,[stub_file]
        je      pe_stub_ok
        sub     edi,[stub_size]
        mov     [code_start],edi
      make_pe_stub:
        call    make_stub
        mov     eax,edi
        sub     eax,[code_start]
        mov     [stub_size],eax
        mov     [code_start],edi
        mov     ebp,eax
      pe_stub_ok:
        mov     edx,edi
        mov     ecx,18h+0E0h
        test    [format_flags],8
        jz      zero_pe_header
        add     ecx,10h
      zero_pe_header:
        add     ebp,ecx
        shr     ecx,2
        xor     eax,eax
        rep     stos dword [edi]
        mov     word [edx],'PE'         ; signature
        mov     ax,[machine]
        mov     word [edx+4],ax
        mov     dword [edx+38h],1000h   ; section alignment
        mov     dword [edx+3Ch],200h    ; file alignment
        mov     word [edx+40h],1        ; OS version
        mov     eax,[subsystem_version]
        mov     [edx+48h],eax
        mov     ax,[subsystem]
        mov     [edx+5Ch],ax
        cmp     ax,1
        jne     pe_alignment_ok
        mov     eax,20h
        mov     dword [edx+38h],eax
        mov     dword [edx+3Ch],eax
      pe_alignment_ok:
        mov     word [edx+1Ah],VERSION_MAJOR + VERSION_MINOR shl 8
        test    [format_flags],8
        jnz     init_pe64_specific
        mov     dword [edx+14h],0E0h    ; size of optional header
        mov     dword [edx+16h],10B010Eh; flags and magic value
        mov     eax,[image_base]
        mov     dword [edx+34h],eax
        mov     dword [edx+60h],1000h   ; stack reserve
        mov     dword [edx+64h],1000h   ; stack commit
        mov     dword [edx+68h],10000h  ; heap reserve
        mov     dword [edx+6Ch],0       ; heap commit
        mov     dword [edx+74h],16      ; number of directories
        jmp     pe_header_ok
      init_pe64_specific:
        mov     dword [edx+14h],0F0h    ; size of optional header
        mov     dword [edx+16h],20B002Eh; flags and magic value
        mov     eax,[image_base]
        mov     dword [edx+30h],eax
        mov     eax,[image_base_high]
        mov     dword [edx+34h],eax
        mov     dword [edx+60h],1000h   ; stack reserve
        mov     dword [edx+68h],1000h   ; stack commit
        mov     dword [edx+70h],10000h  ; heap reserve
        mov     dword [edx+78h],0       ; heap commit
        mov     dword [edx+84h],16      ; number of directories
      pe_header_ok:
        bsf     ecx,[edx+3Ch]
        imul    ebx,[number_of_sections],28h
        or      ebx,ebx
        jnz     reserve_space_for_section_headers
        mov     ebx,28h
      reserve_space_for_section_headers:
        add     ebx,ebp
        dec     ebx
        shr     ebx,cl
        inc     ebx
        shl     ebx,cl
        sub     ebx,ebp
        mov     ecx,ebx
        mov     eax,[display_buffer]
        sub     eax,ecx
        cmp     edi,eax
        jae     out_of_memory
        shr     ecx,2
        xor     eax,eax
        rep     stos dword [edi]
        mov     eax,edi
        sub     eax,[code_start]
        add     eax,[stub_size]
        mov     [edx+54h],eax           ; size of headers
        mov     ecx,[edx+38h]
        dec     ecx
        add     eax,ecx
        not     ecx
        and     eax,ecx
        bt      [format_flags],8
        jc      pe_entry_init_ok
        mov     [edx+28h],eax           ; entry point rva
      pe_entry_init_ok:
        mov     [number_of_sections],0
        movzx   ebx,word [edx+14h]
        lea     ebx,[edx+18h+ebx]
        mov     [current_section],ebx
        mov     dword [ebx],'.fla'
        mov     dword [ebx+4],'t'
        mov     [ebx+14h],edi
        mov     [ebx+0Ch],eax
        mov     dword [ebx+24h],0E0000060h
        xor     ecx,ecx
        not     eax
        not     ecx
        add     eax,1
        adc     ecx,0
        add     eax,edi
        adc     ecx,0
        test    [format_flags],8
        jnz     pe64_org
        sub     eax,[edx+34h]
        sbb     ecx,0
        mov     bl,2
        mov     [code_type],32
        jmp     pe_org_ok
      pe64_org:
        sub     eax,[edx+30h]
        sbb     ecx,[edx+34h]
        mov     bl,4
        mov     [code_type],64
      pe_org_ok:
        bt      [resolver_flags],0
        jc      pe_labels_type_ok
        xor     bl,bl
      pe_labels_type_ok:
        mov     [labels_type],bl
        mov     dword [org_origin],eax
        mov     dword [org_origin+4],ecx
        mov     [org_registers],0
        mov     [org_start],edi
        bt      [format_flags],8
        jnc     dll_flag_ok
        or      dword [edx+16h],2000h
      dll_flag_ok:
        bt      [format_flags],9
        jnc     wdm_flag_ok
        or      word [edx+5Eh],2000h
      wdm_flag_ok:
        jmp     instruction_assembled
pe_section:
        call    close_pe_section
        bts     [format_flags],5
        lea     ecx,[ebx+28h]
        add     edx,[edx+54h]
        sub     edx,[stub_size]
        cmp     ecx,edx
        jbe     new_section
        lea     ebx,[edx-28h]
        or      [next_pass_needed],-1
        push    edi
        mov     edi,ebx
        mov     ecx,28h shr 4
        xor     eax,eax
        rep     stos dword [edi]
        pop     edi
      new_section:
        mov     [ebx+0Ch],eax
        lods    word [esi]
        cmp     ax,'('
        jne     invalid_argument
        lea     edx,[esi+4]
        mov     ecx,[esi]
        lea     esi,[esi+4+ecx+1]
        cmp     ecx,8
        ja      name_too_long
        xor     eax,eax
        mov     [ebx],eax
        mov     [ebx+4],eax
        push    esi edi
        mov     edi,ebx
        mov     esi,edx
        rep     movs byte [edi],[esi]
        pop     edi esi
        mov     dword [ebx+24h],0
        mov     [ebx+14h],edi
        mov     edx,[code_start]
        mov     eax,edi
        xor     ecx,ecx
        sub     eax,[ebx+0Ch]
        sbb     ecx,0
        test    [format_flags],8
        jnz     pe64_section_org
        sub     eax,[edx+34h]
        sbb     ecx,0
        mov     [labels_type],2
        mov     [code_type],32
        bt      [resolver_flags],0
        jc      pe_section_org_ok
        mov     [labels_type],0
        jmp     pe_section_org_ok
      pe64_section_org:
        sub     eax,[edx+30h]
        sbb     ecx,[edx+34h]
        mov     [labels_type],4
        mov     [code_type],64
        bt      [resolver_flags],0
        jc      pe_section_org_ok
        mov     [labels_type],0
      pe_section_org_ok:
        mov     dword [org_origin],eax
        mov     dword [org_origin+4],ecx
        mov     [org_registers],0
        mov     [org_start],edi
      get_section_flags:
        lods    byte [esi]
        cmp     al,1Ah
        je      set_directory
        cmp     al,19h
        je      section_flag
        dec     esi
        jmp     instruction_assembled
      set_directory:
        movzx   eax,byte [esi]
        inc     esi
        mov     ecx,ebx
        test    [format_flags],8
        jnz     pe64_directory
        xchg    ecx,[edx+78h+eax*8]
        mov     dword [edx+78h+eax*8+4],-1
        jmp     pe_directory_set
      pe64_directory:
        xchg    ecx,[edx+88h+eax*8]
        mov     dword [edx+88h+eax*8+4],-1
      pe_directory_set:
        or      ecx,ecx
        jnz     data_already_defined
        push    ebx edx
        call    generate_pe_data
        pop     edx ebx
        jmp     get_section_flags
      section_flag:
        lods    byte [esi]
        cmp     al,9
        je      invalid_argument
        cmp     al,11
        je      invalid_argument
        mov     cl,al
        mov     eax,1
        shl     eax,cl
        test    dword [ebx+24h],eax
        jnz     setting_already_specified
        or      dword [ebx+24h],eax
        jmp     get_section_flags
      close_pe_section:
        mov     ebx,[current_section]
        mov     edx,[code_start]
        mov     eax,edi
        sub     eax,[ebx+14h]
        jnz     finish_section
        bt      [format_flags],5
        jc      finish_section
        mov     eax,[ebx+0Ch]
        ret
      finish_section:
        mov     [ebx+8],eax
        cmp     edi,[undefined_data_end]
        jne     align_section
        cmp     dword [edx+38h],1000h
        jb      align_section
        mov     edi,[undefined_data_start]
      align_section:
        mov     [undefined_data_end],0
        mov     ebp,edi
        sub     ebp,[ebx+14h]
        mov     ecx,[edx+3Ch]
        dec     ecx
        lea     eax,[ebp+ecx]
        not     ecx
        and     eax,ecx
        mov     [ebx+10h],eax
        sub     eax,ebp
        mov     ecx,eax
        xor     al,al
        rep     stos byte [edi]
        mov     eax,[code_start]
        sub     eax,[stub_size]
        sub     [ebx+14h],eax
        mov     eax,[ebx+8]
        or      eax,eax
        jz      udata_ok
        cmp     dword [ebx+10h],0
        jne     udata_ok
        or      byte [ebx+24h],80h
      udata_ok:
        mov     ecx,[edx+38h]
        dec     ecx
        add     eax,ecx
        not     ecx
        and     eax,ecx
        add     eax,[ebx+0Ch]
        add     ebx,28h
        mov     [current_section],ebx
        inc     word [number_of_sections]
        jz      format_limitations_exceeded
        ret
data_directive:
        cmp     [output_format],3
        jne     illegal_instruction
        lods    byte [esi]
        cmp     al,1Ah
        je      predefined_data_type
        cmp     al,'('
        jne     invalid_argument
        call    get_byte_value
        cmp     al,16
        jb      data_type_ok
        jmp     invalid_value
      predefined_data_type:
        movzx   eax,byte [esi]
        inc     esi
      data_type_ok:
        mov     ebx,[current_section]
        mov     ecx,edi
        sub     ecx,[ebx+14h]
        add     ecx,[ebx+0Ch]
        mov     edx,[code_start]
        test    [format_flags],8
        jnz     pe64_data
        xchg    ecx,[edx+78h+eax*8]
        jmp     init_pe_data
      pe64_data:
        xchg    ecx,[edx+88h+eax*8]
      init_pe_data:
        or      ecx,ecx
        jnz     data_already_defined
        call    allocate_structure_data
        mov     word [ebx],data_directive-assembler
        mov     [ebx+2],al
        mov     edx,[current_line]
        mov     [ebx+4],edx
        call    generate_pe_data
        jmp     instruction_assembled
      end_data:
        cmp     [output_format],3
        jne     illegal_instruction
        call    find_structure_data
        jc      unexpected_instruction
        movzx   eax,byte [ebx+2]
        mov     edx,[current_section]
        mov     ecx,edi
        sub     ecx,[edx+14h]
        add     ecx,[edx+0Ch]
        mov     edx,[code_start]
        test    [format_flags],8
        jnz     end_pe64_data
        sub     ecx,[edx+78h+eax*8]
        mov     [edx+78h+eax*8+4],ecx
        jmp     remove_structure_data
      end_pe64_data:
        sub     ecx,[edx+88h+eax*8]
        mov     [edx+88h+eax*8+4],ecx
        jmp     remove_structure_data
pe_entry:
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        test    [format_flags],8
        jnz     pe64_entry
        call    get_dword_value
        mov     bl,2
        bt      [resolver_flags],0
        jc      check_pe_entry_label_type
        xor     bl,bl
      check_pe_entry_label_type:
        cmp     [value_type],bl
        je      pe_entry_ok
        cmp     [error_line],0
        jne     pe_entry_ok
        mov     edx,[current_line]
        mov     [error_line],edx
        mov     [error],invalid_address
      pe_entry_ok:
        mov     edx,[code_start]
        sub     eax,[edx+34h]
        mov     [edx+28h],eax
        jmp     instruction_assembled
      pe64_entry:
        call    get_qword_value
        mov     bl,4
        bt      [resolver_flags],0
        jc      check_pe64_entry_label_type
        xor     bl,bl
      check_pe64_entry_label_type:
        cmp     [value_type],bl
        je      pe64_entry_type_ok
        cmp     [error_line],0
        jne     pe64_entry_type_ok
        mov     edx,[current_line]
        mov     [error_line],edx
        mov     [error],invalid_address
      pe64_entry_type_ok:
        mov     ecx,[code_start]
        sub     eax,[ecx+30h]
        sbb     edx,[ecx+34h]
        jz      pe64_entry_range_ok
        mov     edx,[current_line]
        mov     [error_line],edx
        mov     [error],value_out_of_range
      pe64_entry_range_ok:
        mov     [ecx+28h],eax
        jmp     instruction_assembled
pe_stack:
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        test    [format_flags],8
        jnz     pe64_stack
        call    get_dword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[code_start]
        mov     [edx+60h],eax
        cmp     byte [esi],','
        jne     default_stack_commit
        lods    byte [esi]
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        call    get_dword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[code_start]
        mov     [edx+64h],eax
        cmp     eax,[edx+60h]
        ja      value_out_of_range
        jmp     instruction_assembled
      default_stack_commit:
        mov     dword [edx+64h],1000h
        mov     eax,[edx+60h]
        cmp     eax,1000h
        ja      instruction_assembled
        mov     dword [edx+64h],eax
        jmp     instruction_assembled
      pe64_stack:
        call    get_qword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     ecx,[code_start]
        mov     [ecx+60h],eax
        mov     [ecx+64h],edx
        cmp     byte [esi],','
        jne     default_pe64_stack_commit
        lods    byte [esi]
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        call    get_qword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     ecx,[code_start]
        mov     [ecx+68h],eax
        mov     [ecx+6Ch],edx
        cmp     edx,[ecx+64h]
        ja      value_out_of_range
        jb      instruction_assembled
        cmp     eax,[edx+60h]
        ja      value_out_of_range
        jmp     instruction_assembled
      default_pe64_stack_commit:
        mov     dword [edx+68h],1000h
        cmp     dword [edx+64h],0
        jne     instruction_assembled
        mov     eax,[edx+60h]
        cmp     eax,1000h
        ja      instruction_assembled
        mov     dword [edx+68h],eax
        jmp     instruction_assembled
pe_heap:
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        test    [format_flags],8
        jnz     pe64_heap
        call    get_dword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[code_start]
        mov     [edx+68h],eax
        cmp     byte [esi],','
        jne     instruction_assembled
        lods    byte [esi]
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        call    get_dword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[code_start]
        mov     [edx+6Ch],eax
        cmp     eax,[edx+68h]
        ja      value_out_of_range
        jmp     instruction_assembled
      pe64_heap:
        call    get_qword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     ecx,[code_start]
        mov     [ecx+70h],eax
        mov     [ecx+74h],edx
        cmp     byte [esi],','
        jne     instruction_assembled
        lods    byte [esi]
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        call    get_qword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     ecx,[code_start]
        mov     [ecx+78h],eax
        mov     [ecx+7Ch],edx
        cmp     edx,[ecx+74h]
        ja      value_out_of_range
        jb      instruction_assembled
        cmp     eax,[edx+70h]
        ja      value_out_of_range
        jmp     instruction_assembled
mark_pe_relocation:
        push    eax ebx
        mov     al,2
        test    [format_flags],8
        jz      check_pe_relocation_type
        mov     al,4
      check_pe_relocation_type:
        cmp     [value_type],al
        je      pe_relocation_type_ok
        cmp     [error_line],0
        jne     pe_relocation_type_ok
        mov     eax,[current_line]
        mov     [error_line],eax
        mov     [error],invalid_use_of_symbol
      pe_relocation_type_ok:
        mov     ebx,[current_section]
        mov     eax,edi
        sub     eax,[ebx+14h]
        add     eax,[ebx+0Ch]
        mov     ebx,[free_additional_memory]
        inc     [number_of_relocations]
        jz      invalid_use_of_symbol
        mov     [ebx],eax
        add     ebx,4
        cmp     ebx,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],ebx
        pop     ebx eax
        ret
generate_pe_data:
        cmp     al,2
        je      make_pe_resource
        cmp     al,5
        je      make_pe_fixups
        ret
make_pe_resource:
        cmp     byte [esi],82h
        jne     resource_done
        inc     esi
        lods    word [esi]
        cmp     ax,'('
        jne     invalid_argument
        lods    dword [esi]
        mov     edx,esi
        lea     esi,[esi+eax+1]
        cmp     [next_pass_needed],0
        je      resource_from_file
        cmp     [current_pass],0
        jne     reserve_space_for_resource
        mov     [resource_size],0
      reserve_space_for_resource:
        add     edi,[resource_size]
        cmp     edi,[display_buffer]
        ja      out_of_memory
        jmp     resource_done
      resource_from_file:
        push    esi
        mov     esi,edx
        call    open_binary_file
        push    ebx
        mov     esi,[free_additional_memory]
        lea     eax,[esi+20h]
        cmp     eax,[structures_buffer]
        ja      out_of_memory
        mov     edx,esi
        mov     ecx,20h
        call    read
        jc      invalid_file_format
        xor     eax,eax
        cmp     [esi],eax
        jne     invalid_file_format
        mov     ax,0FFFFh
        cmp     [esi+8],eax
        jne     invalid_file_format
        cmp     [esi+12],eax
        jne     invalid_file_format
        mov     eax,20h
        cmp     [esi+4],eax
        jne     invalid_file_format
      read_resource_headers:
        test    eax,11b
        jz      resource_file_alignment_ok
        mov     edx,4
        and     eax,11b
        sub     edx,eax
        mov     al,1
        call    lseek
      resource_file_alignment_ok:
        mov     [esi],eax
        lea     edx,[esi+12]
        mov     ecx,8
        call    read
        jc      resource_headers_ok
        mov     ecx,[esi+16]
        add     [esi],ecx
        lea     edx,[esi+20]
        sub     ecx,8
        mov     [esi+16],ecx
        lea     eax,[edx+ecx]
        cmp     eax,[structures_buffer]
        ja      out_of_memory
        call    read
        jc      invalid_file_format
        mov     edx,[esi]
        add     edx,[esi+12]
        mov     eax,[esi+16]
        lea     ecx,[esi+20]
        lea     esi,[ecx+eax]
        add     ecx,2
        cmp     word [ecx-2],0FFFFh
        je      resource_header_type_ok
      check_resource_header_type:
        cmp     ecx,esi
        jae     invalid_file_format
        cmp     word [ecx],0
        je      resource_header_type_ok
        add     ecx,2
        jmp     check_resource_header_type
      resource_header_type_ok:
        add     ecx,2
        cmp     word [ecx],0FFFFh
        je      resource_header_name_ok
      check_resource_header_name:
        cmp     ecx,esi
        jae     invalid_file_format
        cmp     word [ecx],0
        je      resource_header_name_ok
        add     ecx,2
        jmp     check_resource_header_name
      resource_header_name_ok:
        xor     al,al
        call    lseek
        jmp     read_resource_headers
      resource_headers_ok:
        xor     eax,eax
        mov     [esi],eax
        mov     [resource_data],edi
        lea     eax,[edi+16]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        xor     eax,eax
        stos    dword [edi]
        call    make_timestamp
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        xor     ebx,ebx
      make_type_name_directory:
        mov     esi,[free_additional_memory]
        xor     edx,edx
      find_type_name:
        cmp     dword [esi],0
        je      type_name_ok
        add     esi,20
        cmp     word [esi],0FFFFh
        je      check_next_type_name
        or      ebx,ebx
        jz      check_this_type_name
        xor     ecx,ecx
      compare_with_previous_type_name:
        mov     ax,[esi+ecx]
        cmp     ax,[ebx+ecx]
        ja      check_this_type_name
        jb      check_next_type_name
        add     ecx,2
        mov     ax,[esi+ecx]
        or      ax,[ebx+ecx]
        jnz     compare_with_previous_type_name
        jmp     check_next_type_name
      check_this_type_name:
        or      edx,edx
        jz      type_name_found
        xor     ecx,ecx
      compare_with_current_type_name:
        mov     ax,[esi+ecx]
        cmp     ax,[edx+ecx]
        ja      check_next_type_name
        jb      type_name_found
        add     ecx,2
        mov     ax,[esi+ecx]
        or      ax,[edx+ecx]
        jnz     compare_with_current_type_name
        jmp     same_type_name
      type_name_found:
        mov     edx,esi
      same_type_name:
        mov     [esi-16],edi
      check_next_type_name:
        mov     eax,[esi-4]
        add     esi,eax
        jmp     find_type_name
      type_name_ok:
        or      edx,edx
        jz      type_name_directory_done
        mov     ebx,edx
      make_type_name_entry:
        mov     eax,[resource_data]
        inc     word [eax+12]
        lea     eax,[edi+8]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        mov     eax,ebx
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        jmp     make_type_name_directory
      type_name_directory_done:
        mov     ebx,-1
      make_type_id_directory:
        mov     esi,[free_additional_memory]
        mov     edx,10000h
      find_type_id:
        cmp     dword [esi],0
        je      type_id_ok
        add     esi,20
        cmp     word [esi],0FFFFh
        jne     check_next_type_id
        movzx   eax,word [esi+2]
        cmp     eax,ebx
        jle     check_next_type_id
        cmp     eax,edx
        jg      check_next_type_id
        mov     edx,eax
        mov     [esi-16],edi
      check_next_type_id:
        mov     eax,[esi-4]
        add     esi,eax
        jmp     find_type_id
      type_id_ok:
        cmp     edx,10000h
        je      type_id_directory_done
        mov     ebx,edx
      make_type_id_entry:
        mov     eax,[resource_data]
        inc     word [eax+14]
        lea     eax,[edi+8]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        mov     eax,ebx
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        jmp     make_type_id_directory
      type_id_directory_done:
        mov     esi,[resource_data]
        add     esi,10h
        mov     ecx,[esi-4]
        or      cx,cx
        jz      resource_directories_ok
      make_resource_directories:
        push    ecx
        push    edi
        mov     edx,edi
        sub     edx,[resource_data]
        bts     edx,31
        mov     [esi+4],edx
        lea     eax,[edi+16]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        xor     eax,eax
        stos    dword [edi]
        call    make_timestamp
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        mov     ebp,esi
        xor     ebx,ebx
      make_resource_name_directory:
        mov     esi,[free_additional_memory]
        xor     edx,edx
      find_resource_name:
        cmp     dword [esi],0
        je      resource_name_ok
        push    esi
        cmp     [esi+4],ebp
        jne     check_next_resource_name
        add     esi,20
        call    skip_resource_name
        cmp     word [esi],0FFFFh
        je      check_next_resource_name
        or      ebx,ebx
        jz      check_this_resource_name
        xor     ecx,ecx
      compare_with_previous_resource_name:
        mov     ax,[esi+ecx]
        cmp     ax,[ebx+ecx]
        ja      check_this_resource_name
        jb      check_next_resource_name
        add     ecx,2
        mov     ax,[esi+ecx]
        or      ax,[ebx+ecx]
        jnz     compare_with_previous_resource_name
        jmp     check_next_resource_name
      skip_resource_name:
        cmp     word [esi],0FFFFh
        jne     skip_unicode_string
        add     esi,4
        ret
      skip_unicode_string:
        add     esi,2
        cmp     word [esi-2],0
        jne     skip_unicode_string
        ret
      check_this_resource_name:
        or      edx,edx
        jz      resource_name_found
        xor     ecx,ecx
      compare_with_current_resource_name:
        mov     ax,[esi+ecx]
        cmp     ax,[edx+ecx]
        ja      check_next_resource_name
        jb      resource_name_found
        add     ecx,2
        mov     ax,[esi+ecx]
        or      ax,[edx+ecx]
        jnz     compare_with_current_resource_name
        jmp     same_resource_name
      resource_name_found:
        mov     edx,esi
      same_resource_name:
        mov     eax,[esp]
        mov     [eax+8],edi
      check_next_resource_name:
        pop     esi
        mov     eax,[esi+16]
        lea     esi,[esi+20+eax]
        jmp     find_resource_name
      resource_name_ok:
        or      edx,edx
        jz      resource_name_directory_done
        mov     ebx,edx
      make_resource_name_entry:
        mov     eax,[esp]
        inc     word [eax+12]
        lea     eax,[edi+8]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        mov     eax,ebx
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        jmp     make_resource_name_directory
      resource_name_directory_done:
        mov     ebx,-1
      make_resource_id_directory:
        mov     esi,[free_additional_memory]
        mov     edx,10000h
      find_resource_id:
        cmp     dword [esi],0
        je      resource_id_ok
        push    esi
        cmp     [esi+4],ebp
        jne     check_next_resource_id
        add     esi,20
        call    skip_resource_name
        cmp     word [esi],0FFFFh
        jne     check_next_resource_id
        movzx   eax,word [esi+2]
        cmp     eax,ebx
        jle     check_next_resource_id
        cmp     eax,edx
        jg      check_next_resource_id
        mov     edx,eax
        mov     eax,[esp]
        mov     [eax+8],edi
      check_next_resource_id:
        pop     esi
        mov     eax,[esi+16]
        lea     esi,[esi+20+eax]
        jmp     find_resource_id
      resource_id_ok:
        cmp     edx,10000h
        je      resource_id_directory_done
        mov     ebx,edx
      make_resource_id_entry:
        mov     eax,[esp]
        inc     word [eax+14]
        lea     eax,[edi+8]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        mov     eax,ebx
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        jmp     make_resource_id_directory
      resource_id_directory_done:
        pop     eax
        mov     esi,ebp
        pop     ecx
        add     esi,8
        dec     cx
        jnz     make_resource_directories
      resource_directories_ok:
        shr     ecx,16
        jnz     make_resource_directories
        mov     esi,[resource_data]
        add     esi,10h
        movzx   eax,word [esi-4]
        movzx   edx,word [esi-2]
        add     eax,edx
        lea     esi,[esi+eax*8]
        push    edi                     ; address of language directories
      update_resource_directories:
        cmp     esi,[esp]
        je      resource_directories_updated
        add     esi,10h
        mov     ecx,[esi-4]
        or      cx,cx
        jz      language_directories_ok
      make_language_directories:
        push    ecx
        push    edi
        mov     edx,edi
        sub     edx,[resource_data]
        bts     edx,31
        mov     [esi+4],edx
        lea     eax,[edi+16]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        xor     eax,eax
        stos    dword [edi]
        call    make_timestamp
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        mov     ebp,esi
        mov     ebx,-1
      make_language_id_directory:
        mov     esi,[free_additional_memory]
        mov     edx,10000h
      find_language_id:
        cmp     dword [esi],0
        je      language_id_ok
        push    esi
        cmp     [esi+8],ebp
        jne     check_next_language_id
        add     esi,20
        mov     eax,esi
        call    skip_resource_name
        call    skip_resource_name
        neg     eax
        add     eax,esi
        and     eax,11b
        add     esi,eax
      get_language_id:
        movzx   eax,word [esi+6]
        cmp     eax,ebx
        jle     check_next_language_id
        cmp     eax,edx
        jge     check_next_language_id
        mov     edx,eax
        mov     eax,[esp]
        mov     [current_offset],eax
      check_next_language_id:
        pop     esi
        mov     eax,[esi+16]
        lea     esi,[esi+20+eax]
        jmp     find_language_id
      language_id_ok:
        cmp     edx,10000h
        je      language_id_directory_done
        mov     ebx,edx
      make_language_id_entry:
        mov     eax,[esp]
        inc     word [eax+14]
        lea     eax,[edi+8]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        mov     eax,ebx
        stos    dword [edi]
        mov     eax,[current_offset]
        stos    dword [edi]
        jmp     make_language_id_directory
      language_id_directory_done:
        pop     eax
        mov     esi,ebp
        pop     ecx
        add     esi,8
        dec     cx
        jnz     make_language_directories
      language_directories_ok:
        shr     ecx,16
        jnz     make_language_directories
        jmp     update_resource_directories
      resource_directories_updated:
        mov     esi,[resource_data]
        push    edi
      make_name_strings:
        add     esi,10h
        movzx   eax,word [esi-2]
        movzx   ecx,word [esi-4]
        add     eax,ecx
        lea     eax,[esi+eax*8]
        push    eax
        or      ecx,ecx
        jz      string_entries_processed
      process_string_entries:
        push    ecx
        mov     edx,edi
        sub     edx,[resource_data]
        bts     edx,31
        xchg    [esi],edx
        mov     ebx,edi
        xor     ax,ax
        stos    word [edi]
      copy_string_data:
        lea     eax,[edi+2]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        mov     ax,[edx]
        or      ax,ax
        jz      string_data_copied
        stos    word [edi]
        inc     word [ebx]
        add     edx,2
        jmp     copy_string_data
      string_data_copied:
        add     esi,8
        pop     ecx
        loop    process_string_entries
      string_entries_processed:
        pop     esi
        cmp     esi,[esp]
        jb      make_name_strings
        mov     eax,edi
        sub     eax,[resource_data]
        test    al,11b
        jz      resource_strings_alignment_ok
        xor     ax,ax
        stos    word [edi]
      resource_strings_alignment_ok:
        pop     edx
        pop     ebx                     ; address of language directories
        mov     ebp,edi
      update_language_directories:
        add     ebx,10h
        movzx   eax,word [ebx-2]
        movzx   ecx,word [ebx-4]
        add     ecx,eax
      make_data_records:
        push    ecx
        mov     esi,edi
        sub     esi,[resource_data]
        xchg    esi,[ebx+4]
        lea     eax,[edi+16]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        mov     eax,esi
        stos    dword [edi]
        mov     eax,[esi+12]
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        pop     ecx
        add     ebx,8
        loop    make_data_records
        cmp     ebx,edx
        jb      update_language_directories
        pop     ebx                     ; file handle
        mov     esi,ebp
        mov     ebp,edi
      update_data_records:
        push    ebp
        mov     ecx,edi
        mov     eax,[current_section]
        sub     ecx,[eax+14h]
        add     ecx,[eax+0Ch]
        xchg    ecx,[esi]
        mov     edx,[ecx]
        xor     al,al
        call    lseek
        mov     edx,edi
        mov     ecx,[esi+4]
        add     edi,ecx
        cmp     edi,[display_buffer]
        ja      out_of_memory
        call    read
        mov     eax,edi
        sub     eax,[resource_data]
        and     eax,11b
        jz      resource_data_alignment_ok
        mov     ecx,4
        sub     ecx,eax
        xor     al,al
        rep     stos byte [edi]
      resource_data_alignment_ok:
        pop     ebp
        add     esi,16
        cmp     esi,ebp
        jb      update_data_records
        pop     esi
        call    close
        mov     eax,edi
        sub     eax,[resource_data]
        mov     [resource_size],eax
      resource_done:
        ret
make_pe_fixups:
        bts     [resolver_flags],0
        jc      pe_relocatable_ok
        or      [next_pass_needed],-1
     pe_relocatable_ok:
        push    esi
        mov     ecx,[number_of_relocations]
        mov     esi,[free_additional_memory]
 
        mov     eax,ecx
        shl     eax,2
        sub     esi,eax
        mov     [free_additional_memory],esi
        or      [number_of_relocations],-1
        xor     edx,edx
        mov     ebp,edi
      make_fixups:
        cmp     [esi],edx
        jb      store_fixup
        mov     eax,edi
        sub     eax,ebp
        test    eax,11b
        jz      fixups_block
        xor     ax,ax
        stos    word [edi]
        add     dword [ebx],2
      fixups_block:
        mov     eax,edx
        add     edx,1000h
        cmp     [esi],edx
        jae     fixups_block
        stos    dword [edi]
        mov     ebx,edi
        mov     eax,8
        stos    dword [edi]
      store_fixup:
        jecxz   fixups_done
        add     dword [ebx],2
        mov     eax,[esi]
        and     ax,0FFFh
        test    [format_flags],8
        jnz     fixup_64bit
        or      ax,3000h
        jmp     fixup_ok
      fixup_64bit:
        or      ax,0A000h
      fixup_ok:
        stos    word [edi]
        add     esi,4
        loop    make_fixups
      fixups_done:
        pop     esi
        ret
close_pe:
        call    close_pe_section
        mov     edx,[code_start]
        mov     [edx+50h],eax
        call    make_timestamp
        mov     edx,[code_start]
        mov     [edx+8],eax
        mov     eax,[number_of_relocations]
        cmp     eax,-1
        je      pe_relocations_ok
        shl     eax,2
 
        sub     [free_additional_memory],eax
        btr     [resolver_flags],0
        jnc     pe_relocations_ok
        or      [next_pass_needed],-1
      pe_relocations_ok:
        mov     eax,[number_of_sections]
        mov     [edx+6],ax
        imul    eax,28h
        movzx   ecx,word [edx+14h]
        lea     eax,[eax+18h+ecx]
        add     eax,[stub_size]
        mov     ecx,[edx+3Ch]
        dec     ecx
        add     eax,ecx
        not     ecx
        and     eax,ecx
        cmp     eax,[edx+54h]
        je      pe_sections_ok
        or      [next_pass_needed],-1
      pe_sections_ok:
        xor     ecx,ecx
        add     edx,78h
        test    [format_flags],8
        jz      process_directories
        add     edx,10h
      process_directories:
        mov     eax,[edx+ecx*8]
        or      eax,eax
        jz      directory_ok
        cmp     dword [edx+ecx*8+4],-1
        jne     directory_ok
      section_data:
        mov     ebx,[edx+ecx*8]
        mov     eax,[ebx+0Ch]
        mov     [edx+ecx*8],eax         ; directory rva
        mov     eax,[ebx+8]
        mov     [edx+ecx*8+4],eax       ; directory size
      directory_ok:
        inc     cl
        cmp     cl,10h
        jb      process_directories
        mov     ebx,[code_start]
        sub     ebx,[stub_size]
        mov     ecx,edi
        sub     ecx,ebx
        mov     ebp,ecx
        shr     ecx,1
        xor     eax,eax
        cdq
      calculate_checksum:
        mov     dx,[ebx]
        add     eax,edx
        mov     dx,ax
        shr     eax,16
        add     eax,edx
        add     ebx,2
        loop    calculate_checksum
        add     eax,ebp
        mov     ebx,[code_start]
        mov     [ebx+58h],eax
        ret
 
format_coff:
        mov     eax,[additional_memory]
        mov     [symbols_stream],eax
        mov     ebx,eax
        add     eax,20h
        cmp     eax,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],eax
        xor     eax,eax
        mov     [ebx],al
        mov     [ebx+4],eax
        mov     [ebx+8],edi
        mov     al,4
        mov     [ebx+10h],eax
        mov     al,60h
        bt      [format_flags],0
        jnc     flat_section_flags_ok
        or      eax,0E0000000h
      flat_section_flags_ok:
        mov     dword [ebx+14h],eax
        mov     [current_section],ebx
        mov     [number_of_sections],0
        mov     dword [org_origin],edi
        mov     dword [org_origin+4],0
        mov     [org_registers],0
        mov     [org_start],edi
        mov     [org_symbol],ebx
        mov     [labels_type],2
        mov     [code_type],32
        test    [format_flags],8
        jz      instruction_assembled
        mov     [labels_type],4
        mov     [code_type],64
        jmp     instruction_assembled
coff_section:
        call    close_coff_section
        mov     ebx,[free_additional_memory]
        lea     eax,[ebx+20h]
        cmp     eax,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],eax
        mov     [current_section],ebx
        inc     [number_of_sections]
        xor     eax,eax
        mov     [ebx],al
        mov     [ebx+8],edi
        mov     dword [org_origin],edi
        mov     dword [org_origin+4],0
        mov     [org_registers],0
        mov     [org_start],edi
        mov     [org_symbol],ebx
        mov     [labels_type],2
        test    [format_flags],8
        jz      coff_labels_type_ok
        mov     [labels_type],4
      coff_labels_type_ok:
        mov     [ebx+10h],eax
        mov     [ebx+14h],eax
        lods    word [esi]
        cmp     ax,'('
        jne     invalid_argument
        mov     [ebx+4],esi
        mov     ecx,[esi]
        lea     esi,[esi+4+ecx+1]
        cmp     ecx,8
        ja      name_too_long
      coff_section_flags:
        cmp     byte [esi],1Ch
        je      coff_section_alignment
        cmp     byte [esi],19h
        jne     coff_section_settings_ok
        inc     esi
        lods    byte [esi]
        bt      [format_flags],0
        jc      coff_section_flag_ok
        cmp     al,7
        ja      invalid_argument
      coff_section_flag_ok:
        mov     cl,al
        mov     eax,1
        shl     eax,cl
        test    dword [ebx+14h],eax
        jnz     setting_already_specified
        or      dword [ebx+14h],eax
        jmp     coff_section_flags
      coff_section_alignment:
        bt      [format_flags],0
        jnc     invalid_argument
        inc     esi
        lods    byte [esi]
        or      al,al
        jnz     invalid_argument
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        push    ebx
        call    get_dword_value
        pop     ebx
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,eax
        dec     edx
        test    eax,edx
        jnz     invalid_value
        or      eax,eax
        jz      invalid_value
        cmp     eax,2000h
        ja      invalid_value
        bsf     edx,eax
        inc     edx
        shl     edx,20
        or      [ebx+14h],edx
        xchg    [ebx+10h],eax
        or      eax,eax
        jnz     setting_already_specified
        jmp     coff_section_flags
      coff_section_settings_ok:
        cmp     dword [ebx+10h],0
        jne     instruction_assembled
        mov     dword [ebx+10h],4
        bt      [format_flags],0
        jnc     instruction_assembled
        or      dword [ebx+14h],300000h
        jmp     instruction_assembled
      close_coff_section:
        mov     ebx,[current_section]
        mov     eax,edi
        mov     edx,[ebx+8]
        sub     eax,edx
        mov     [ebx+0Ch],eax
        xor     eax,eax
        xchg    [undefined_data_end],eax
        cmp     eax,edi
        jne     coff_section_ok
        cmp     edx,[undefined_data_start]
        jne     coff_section_ok
        mov     edi,edx
        or      byte [ebx+14h],80h
      coff_section_ok:
        ret
mark_coff_relocation:
        cmp     [value_type],3
        je      coff_relocation_relative
        push    ebx eax
        test    [format_flags],8
        jnz     coff_64bit_relocation
        mov     al,6
        jmp     coff_relocation
      coff_64bit_relocation:
        mov     al,1
        cmp     [value_type],4
        je      coff_relocation
        mov     al,2
        jmp     coff_relocation
      coff_relocation_relative:
        push    ebx
        bt      [format_flags],0
        jnc     relative_ok
        mov     ebx,[current_section]
        mov     ebx,[ebx+8]
        sub     ebx,edi
        sub     eax,ebx
        add     eax,4
      relative_ok:
        push    eax
        mov     al,20
        test    [format_flags],8
        jnz     relative_coff_64bit_relocation
        cmp     [labels_type],2
        jne     invalid_use_of_symbol
        jmp     coff_relocation
      relative_coff_64bit_relocation:
        mov     al,4
        cmp     [labels_type],4
        jne     invalid_use_of_symbol
      coff_relocation:
        mov     ebx,[free_additional_memory]
        add     ebx,0Ch
        cmp     ebx,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],ebx
        mov     byte [ebx-0Ch],al
        mov     eax,[current_section]
        mov     eax,[eax+8]
        neg     eax
        add     eax,edi
        mov     [ebx-0Ch+4],eax
        mov     eax,[symbol_identifier]
        mov     [ebx-0Ch+8],eax
        pop     eax ebx
        ret
close_coff:
        call    close_coff_section
        cmp     [next_pass_needed],0
        je      coff_closed
        mov     eax,[symbols_stream]
        mov     [free_additional_memory],eax
      coff_closed:
        ret
coff_formatter:
        sub     edi,[code_start]
        mov     [code_size],edi
        call    prepare_default_section
        mov     edi,[free_additional_memory]
        mov     ebx,edi
        mov     ecx,28h shr 2
        imul    ecx,[number_of_sections]
        add     ecx,14h shr 2
        lea     eax,[edi+ecx*4]
        cmp     eax,[structures_buffer]
        jae     out_of_memory
        xor     eax,eax
        rep     stos dword [edi]
        mov     word [ebx],14Ch
        test    [format_flags],8
        jz      coff_magic_ok
        mov     word [ebx],8664h
      coff_magic_ok:
        mov     word [ebx+12h],104h
        bt      [format_flags],0
        jnc     coff_flags_ok
        or      byte [ebx+12h],80h
      coff_flags_ok:
        push    ebx
        call    make_timestamp
        pop     ebx
        mov     [ebx+4],eax
        mov     eax,[number_of_sections]
        mov     [ebx+2],ax
        mov     esi,[symbols_stream]
        xor     eax,eax
        xor     ecx,ecx
      enumerate_symbols:
        cmp     esi,[free_additional_memory]
        je      symbols_enumerated
        mov     dl,[esi]
        or      dl,dl
        jz      enumerate_section
        cmp     dl,80h
        je      enumerate_public
        ja      enumerate_extrn
        add     esi,0Ch
        jmp     enumerate_symbols
      enumerate_section:
        mov     edx,eax
        shl     edx,8
        mov     [esi],edx
        inc     eax
        inc     ecx
        mov     [esi+1Eh],cx
        add     esi,20h
        jmp     enumerate_symbols
      enumerate_public:
        mov     edx,eax
        shl     edx,8
        mov     dl,80h
        mov     [esi],edx
        mov     edx,[esi+8]
        add     esi,10h
        inc     eax
        cmp     byte [edx+11],2
        jne     enumerate_symbols
        mov     edx,[edx+20]
        cmp     byte [edx],81h
        jne     enumerate_symbols
        inc     eax
        jmp     enumerate_symbols
      enumerate_extrn:
        mov     edx,eax
        shl     edx,8
        mov     dl,81h
        mov     [esi],edx
        add     esi,0Ch
        inc     eax
        jmp     enumerate_symbols
      prepare_default_section:
        mov     ebx,[symbols_stream]
        cmp     dword [ebx+0Ch],0
        jne     default_section_ok
        cmp     [number_of_sections],0
        je      default_section_ok
        mov     edx,ebx
      find_references_to_default_section:
        cmp     ebx,[free_additional_memory]
        jne     check_reference
        add     [symbols_stream],20h
        ret
      check_reference:
        mov     al,[ebx]
        or      al,al
        jz      skip_other_section
        cmp     al,80h
        je      check_public_reference
        ja      next_reference
        cmp     edx,[ebx+8]
        je      default_section_ok
      next_reference:
        add     ebx,0Ch
        jmp     find_references_to_default_section
      check_public_reference:
        mov     eax,[ebx+8]
        add     ebx,10h
        test    byte [eax+8],1
        jz      find_references_to_default_section
        mov     cx,[current_pass]
        cmp     cx,[eax+16]
        jne     find_references_to_default_section
        cmp     edx,[eax+20]
        je      default_section_ok
        jmp     find_references_to_default_section
      skip_other_section:
        add     ebx,20h
        jmp     find_references_to_default_section
      default_section_ok:
        inc     [number_of_sections]
        ret
      symbols_enumerated:
        mov     [ebx+0Ch],eax
        mov     ebp,edi
        sub     ebp,ebx
        push    ebp
        lea     edi,[ebx+14h]
        mov     esi,[symbols_stream]
      find_section:
        cmp     esi,[free_additional_memory]
        je      sections_finished
        mov     al,[esi]
        or      al,al
        jz      section_found
        add     esi,0Ch
        cmp     al,80h
        jne     find_section
        add     esi,4
        jmp     find_section
      section_found:
        push    esi edi
        mov     esi,[esi+4]
        or      esi,esi
        jz      default_section
        mov     ecx,[esi]
        add     esi,4
        rep     movs byte [edi],[esi]
        jmp     section_name_ok
      default_section:
        mov     al,'.'
        stos    byte [edi]
        mov     eax,'flat'
        stos    dword [edi]
      section_name_ok:
        pop     edi esi
        mov     eax,[esi+0Ch]
        mov     [edi+10h],eax
        mov     eax,[esi+14h]
        mov     [edi+24h],eax
        test    al,80h
        jnz     section_ptr_ok
        mov     eax,[esi+8]
        sub     eax,[code_start]
        add     eax,ebp
        mov     [edi+14h],eax
      section_ptr_ok:
        mov     ebx,[code_start]
        mov     edx,[code_size]
        add     ebx,edx
        add     edx,ebp
        xor     ecx,ecx
        add     esi,20h
      find_relocations:
        cmp     esi,[free_additional_memory]
        je      section_relocations_done
        mov     al,[esi]
        or      al,al
        jz      section_relocations_done
        cmp     al,80h
        jb      add_relocation
        ja      next_relocation
        add     esi,10h
        jmp     find_relocations
      add_relocation:
        lea     eax,[ebx+0Ah]
        cmp     eax,[display_buffer]
        ja      out_of_memory
        mov     eax,[esi+4]
        mov     [ebx],eax
        mov     eax,[esi+8]
        mov     eax,[eax]
        shr     eax,8
        mov     [ebx+4],eax
        movzx   ax,byte [esi]
        mov     [ebx+8],ax
        add     ebx,0Ah
        inc     ecx
      next_relocation:
        add     esi,0Ch
        jmp     find_relocations
      section_relocations_done:
        cmp     ecx,10000h
        jb      section_relocations_count_16bit
        bt      [format_flags],0
        jnc     format_limitations_exceeded
        mov     word [edi+20h],0FFFFh
        or      dword [edi+24h],1000000h
        mov     [edi+18h],edx
        push    esi edi
        push    ecx
        lea     esi,[ebx-1]
        add     ebx,0Ah
        lea     edi,[ebx-1]
        imul    ecx,0Ah
        std
        rep     movs byte [edi],[esi]
        cld
        pop     ecx
        inc     esi
        inc     ecx
        mov     [esi],ecx
        xor     eax,eax
        mov     [esi+4],eax
        mov     [esi+8],ax
        pop     edi esi
        jmp     section_relocations_ok
      section_relocations_count_16bit:
        mov     [edi+20h],cx
        jcxz    section_relocations_ok
        mov     [edi+18h],edx
      section_relocations_ok:
        sub     ebx,[code_start]
        mov     [code_size],ebx
        add     edi,28h
        jmp     find_section
      sections_finished:
        mov     edx,[free_additional_memory]
        mov     ebx,[code_size]
        add     ebp,ebx
        mov     [edx+8],ebp
        add     ebx,[code_start]
        mov     edi,ebx
        mov     ecx,[edx+0Ch]
        imul    ecx,12h shr 1
        xor     eax,eax
        shr     ecx,1
        jnc     zero_symbols_table
        stos    word [edi]
      zero_symbols_table:
        rep     stos dword [edi]
        mov     edx,edi
        stos    dword [edi]
        mov     esi,[symbols_stream]
      make_symbols_table:
        cmp     esi,[free_additional_memory]
        je      symbols_table_ok
        mov     al,[esi]
        cmp     al,80h
        je      add_public_symbol
        ja      add_extrn_symbol
        or      al,al
        jz      add_section_symbol
        add     esi,0Ch
        jmp     make_symbols_table
 
 
 
      add_section_symbol:
        call    store_symbol_name
        movzx   eax,word [esi+1Eh]
        mov     [ebx+0Ch],ax
 
 
        mov     byte [ebx+10h],3
        add     esi,20h
        add     ebx,12h
        jmp     make_symbols_table
 
 
 
 
 
 
 
 
 
 
 
 
 
 
      add_extrn_symbol:
        call    store_symbol_name
        mov     byte [ebx+10h],2
        add     esi,0Ch
        add     ebx,12h
        jmp     make_symbols_table
      add_public_symbol:
        call    store_symbol_name
        mov     eax,[esi+0Ch]
        mov     [current_line],eax
        mov     eax,[esi+8]
        test    byte [eax+8],1
        jz      undefined_symbol
        mov     cx,[current_pass]
        cmp     cx,[eax+16]
        jne     undefined_symbol
        mov     cl,[eax+11]
        or      cl,cl
        jz      public_constant
        test    [format_flags],8
        jnz     check_64bit_public_symbol
        cmp     cl,2
        je      public_symbol_type_ok
        jmp     invalid_use_of_symbol
      check_64bit_public_symbol:
        cmp     cl,4
        jne     invalid_use_of_symbol
      public_symbol_type_ok:
        mov     ecx,[eax+20]
        cmp     byte [ecx],81h
 
        je      alias_symbol
        cmp     byte [ecx],0
        jne     invalid_use_of_symbol
        mov     cx,[ecx+1Eh]
        mov     [ebx+0Ch],cx
 
      public_symbol_section_ok:
        cmp     dword [eax+4],0
        je      store_public_symbol
        cmp     dword [eax+4],-1
        jne     value_out_of_range
        bt      dword [eax],31
        jnc     value_out_of_range
      store_public_symbol:
        mov     eax,[eax]
        mov     [ebx+8],eax
        mov     byte [ebx+10h],2
        add     esi,10h
        add     ebx,12h
        jmp     make_symbols_table
      alias_symbol:
        bt      [format_flags],0
        jnc     invalid_use_of_symbol
        mov     ecx,[eax]
        or      ecx,[eax+4]
        jnz     invalid_use_of_symbol
        mov     byte [ebx+10h],69h
        mov     byte [ebx+11h],1
        add     ebx,12h
        mov     ecx,[eax+20]
        mov     ecx,[ecx]
        shr     ecx,8
        mov     [ebx],ecx
        mov     byte [ebx+4],3
        add     esi,10h
        add     ebx,12h
        jmp     make_symbols_table
      public_constant:
        mov     word [ebx+0Ch],0FFFFh
        jmp     public_symbol_section_ok
      symbols_table_ok:
        mov     eax,edi
        sub     eax,edx
        mov     [edx],eax
        sub     edi,[code_start]
        mov     [code_size],edi
        mov     [written_size],0
        mov     edx,[output_file]
        call    create
        jc      write_failed
        mov     edx,[free_additional_memory]
        pop     ecx
        add     [written_size],ecx
        call    write
        jc      write_failed
        jmp     write_output
      store_symbol_name:
        push    esi
        mov     esi,[esi+4]
        or      esi,esi
        jz      default_name
        lods    dword [esi]
        mov     ecx,eax
        cmp     ecx,8
        ja      add_string
        push    edi
        mov     edi,ebx
        rep     movs byte [edi],[esi]
        pop     edi esi
        ret
      default_name:
        mov     dword [ebx],'.fla'
        mov     dword [ebx+4],'t'
        pop     esi
        ret
      add_string:
        mov     eax,edi
        sub     eax,edx
        mov     [ebx+4],eax
        inc     ecx
        rep     movs byte [edi],[esi]
        pop     esi
        ret
 
format_elf:
        test    [format_flags],8
        jnz     format_elf64
        mov     edx,edi
        mov     ecx,34h shr 2
        lea     eax,[edi+ecx*4]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        xor     eax,eax
        rep     stos dword [edi]
        mov     dword [edx],7Fh + 'ELF' shl 8
        mov     al,1
        mov     [edx+4],al
        mov     [edx+5],al
        mov     [edx+6],al
        mov     [edx+14h],al
        mov     byte [edx+12h],3
        mov     byte [edx+28h],34h
        mov     byte [edx+2Eh],28h
        mov     [code_type],32
        cmp     word [esi],1D19h
        je      format_elf_exe
        mov     [labels_type],2
      elf_header_ok:
        mov     byte [edx+10h],1
        mov     eax,[additional_memory]
        mov     [symbols_stream],eax
        mov     ebx,eax
        add     eax,20h
        cmp     eax,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],eax
        xor     eax,eax
        mov     [current_section],ebx
        mov     [number_of_sections],eax
        mov     dword [org_origin],edi
        mov     dword [org_origin+4],eax
        mov     [org_registers],eax
        mov     [org_start],edi
        mov     [org_symbol],ebx
        mov     [ebx],al
        mov     [ebx+4],eax
        mov     [ebx+8],edi
        mov     al,111b
        mov     [ebx+14h],eax
        mov     al,4
        mov     [ebx+10h],eax
        test    [format_flags],8
        jz      instruction_assembled
        mov     byte [ebx+10h],8
        jmp     instruction_assembled
      format_elf64:
        mov     edx,edi
        mov     ecx,40h shr 2
        lea     eax,[edi+ecx*4]
        cmp     eax,[display_buffer]
        jae     out_of_memory
        xor     eax,eax
        rep     stos dword [edi]
        mov     dword [edx],7Fh + 'ELF' shl 8
        mov     al,1
        mov     [edx+5],al
        mov     [edx+6],al
        mov     [edx+14h],al
        mov     byte [edx+4],2
        mov     byte [edx+12h],62
        mov     byte [edx+34h],40h
        mov     byte [edx+3Ah],40h
        mov     [code_type],64
        cmp     word [esi],1D19h
        je      format_elf64_exe
        mov     [labels_type],4
        jmp     elf_header_ok
elf_section:
        bt      [format_flags],0
        jc      illegal_instruction
        call    close_coff_section
        mov     ebx,[free_additional_memory]
        lea     eax,[ebx+20h]
        cmp     eax,[structures_buffer]
        jae     out_of_memory
        mov     [free_additional_memory],eax
        mov     [current_section],ebx
        inc     word [number_of_sections]
        jz      format_limitations_exceeded
        xor     eax,eax
        mov     [ebx],al
        mov     [ebx+8],edi
        mov     dword [org_origin],edi
        mov     dword [org_origin+4],0
        mov     [org_registers],0
        mov     [org_start],edi
        mov     [org_symbol],ebx
        test    [format_flags],8
        jnz     elf64_labels_type
        mov     [labels_type],2
        jmp     elf_labels_type_ok
      elf64_labels_type:
        mov     [labels_type],4
      elf_labels_type_ok:
        mov     [ebx+10h],eax
        mov     al,10b
        mov     [ebx+14h],eax
        lods    word [esi]
        cmp     ax,'('
        jne     invalid_argument
        mov     [ebx+4],esi
        mov     ecx,[esi]
        lea     esi,[esi+4+ecx+1]
      elf_section_flags:
        cmp     byte [esi],1Ch
        je      elf_section_alignment
        cmp     byte [esi],19h
        jne     elf_section_settings_ok
        inc     esi
        lods    byte [esi]
        sub     al,28
        xor     al,11b
        test    al,not 10b
        jnz     invalid_argument
        mov     cl,al
        mov     al,1
        shl     al,cl
        test    byte [ebx+14h],al
        jnz     setting_already_specified
        or      byte [ebx+14h],al
        jmp     elf_section_flags
      elf_section_alignment:
        inc     esi
        lods    byte [esi]
        or      al,al
        jnz     invalid_argument
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        push    ebx
        call    get_dword_value
        pop     ebx
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,eax
        dec     edx
        test    eax,edx
        jnz     invalid_value
        or      eax,eax
        jz      invalid_value
        xchg    [ebx+10h],eax
        or      eax,eax
        jnz     setting_already_specified
        jmp     elf_section_flags
      elf_section_settings_ok:
        cmp     dword [ebx+10h],0
        jne     instruction_assembled
        mov     dword [ebx+10h],4
        test    [format_flags],8
        jz      instruction_assembled
        mov     byte [ebx+10h],8
        jmp     instruction_assembled
mark_elf_relocation:
        cmp     [value_type],3
        je      elf_relocation_relative
        push    ebx eax
        cmp     [value_type],3
        je      elf_gotoff_relocation
        mov     al,1
        test    [format_flags],8
        jz      coff_relocation
        cmp     [value_type],4
        je      coff_relocation
        mov     al,11
        jmp     coff_relocation
      elf_gotoff_relocation:
        mov     al,9
        jmp     coff_relocation
      elf_relocation_relative:
        cmp     [labels_type],0
        je      invalid_use_of_symbol
        push    ebx
        mov     ebx,[current_section]
        mov     ebx,[ebx+8]
        sub     ebx,edi
        sub     eax,ebx
        push    eax
        mov     al,2
        jmp     coff_relocation
close_elf:
        bt      [format_flags],0
        jc      close_elf_exe
        call    close_coff_section
        cmp     [next_pass_needed],0
        je      elf_closed
        mov     eax,[symbols_stream]
        mov     [free_additional_memory],eax
      elf_closed:
        ret
elf_formatter:
        push    edi
        call    prepare_default_section
        mov     esi,[symbols_stream]
        mov     edi,[free_additional_memory]
        xor     eax,eax
        mov     ecx,4
        rep     stos dword [edi]
        test    [format_flags],8
        jz      find_first_section
        mov     ecx,2
        rep     stos dword [edi]
      find_first_section:
        mov     al,[esi]
        or      al,al
        jz      first_section_found
        cmp     al,80h
        jne     skip_other_symbol
        add     esi,4
      skip_other_symbol:
        add     esi,0Ch
        jmp     find_first_section
      first_section_found:
        mov     ebx,esi
        mov     ebp,esi
        add     esi,20h
        xor     ecx,ecx
        xor     edx,edx
      find_next_section:
        cmp     esi,[free_additional_memory]
        je      make_section_symbol
        mov     al,[esi]
        or      al,al
        jz      make_section_symbol
        cmp     al,80h
        je      skip_public
        ja      skip_extrn
        or      byte [ebx+14h],40h
      skip_extrn:
        add     esi,0Ch
        jmp     find_next_section
      skip_public:
        add     esi,10h
        jmp     find_next_section
      make_section_symbol:
        mov     eax,edi
        xchg    eax,[ebx+4]
        stos    dword [edi]
        test    [format_flags],8
        jnz     elf64_section_symbol
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        call    store_section_index
        jmp     section_symbol_ok
      store_section_index:
        inc     ecx
        mov     eax,ecx
        shl     eax,8
        mov     [ebx],eax
        inc     dx
        jz      format_limitations_exceeded
        mov     eax,edx
        shl     eax,16
        mov     al,3
        test    byte [ebx+14h],40h
        jz      section_index_ok
        or      ah,-1
        inc     dx
        jz      format_limitations_exceeded
      section_index_ok:
        stos    dword [edi]
        ret
      elf64_section_symbol:
        call    store_section_index
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        stos    dword [edi]
        stos    dword [edi]
      section_symbol_ok:
        mov     ebx,esi
        add     esi,20h
        cmp     ebx,[free_additional_memory]
        jne     find_next_section
        inc     dx
        jz      format_limitations_exceeded
        mov     [current_section],edx
        mov     esi,[symbols_stream]
      find_other_symbols:
        cmp     esi,[free_additional_memory]
        je      elf_symbol_table_ok
        mov     al,[esi]
        or      al,al
        jz      skip_section
        cmp     al,80h
        je      make_public_symbol
        ja      make_extrn_symbol
        add     esi,0Ch
        jmp     find_other_symbols
      skip_section:
        add     esi,20h
        jmp     find_other_symbols
      make_public_symbol:
        mov     eax,[esi+0Ch]
        mov     [current_line],eax
        mov     ebx,[esi+8]
        test    byte [ebx+8],1
        jz      undefined_symbol
        mov     ax,[current_pass]
        cmp     ax,[ebx+16]
        jne     undefined_symbol
        mov     dl,[ebx+11]
        or      dl,dl
        jz      public_absolute
        mov     eax,[ebx+20]
        cmp     byte [eax],0
        jne     invalid_use_of_symbol
        mov     eax,[eax+4]
        test    [format_flags],8
        jnz     elf64_public
        cmp     dl,2
        jne     invalid_use_of_symbol
        mov     dx,[eax+0Eh]
        jmp     section_for_public_ok
      elf64_public:
        cmp     dl,4
        jne     invalid_use_of_symbol
        mov     dx,[eax+6]
        jmp     section_for_public_ok
      public_absolute:
        mov     dx,0FFF1h
      section_for_public_ok:
        mov     eax,[esi+4]
        stos    dword [edi]
        test    [format_flags],8
        jnz     elf64_public_symbol
        call    get_public_value
        stos    dword [edi]
        xor     eax,eax
        mov     al,[ebx+10]
        stos    dword [edi]
        mov     eax,edx
        shl     eax,16
        mov     al,10h
        cmp     byte [ebx+10],0
        je      elf_public_function
        or      al,1
        jmp     store_elf_public_info
      elf_public_function:
        or      al,2
      store_elf_public_info:
        stos    dword [edi]
        jmp     public_symbol_ok
      elf64_public_symbol:
        mov     eax,edx
        shl     eax,16
        mov     al,10h
        cmp     byte [ebx+10],0
        je      elf64_public_function
        or      al,1
        jmp     store_elf64_public_info
      elf64_public_function:
        or      al,2
      store_elf64_public_info:
        stos    dword [edi]
        call    get_public_value
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        mov     al,[ebx+10]
        stos    dword [edi]
        xor     al,al
        stos    dword [edi]
      public_symbol_ok:
        inc     ecx
        mov     eax,ecx
        shl     eax,8
        mov     al,80h
        mov     [esi],eax
        add     esi,10h
        jmp     find_other_symbols
      get_public_value:
        mov     eax,[ebx]
        cmp     dword [ebx+4],0
        je      public_value_ok
        cmp     dword [ebx+4],-1
        jne     value_out_of_range
        bt      eax,31
        jnc     value_out_of_range
      public_value_ok:
        ret
      make_extrn_symbol:
        mov     eax,[esi+4]
        stos    dword [edi]
        test    [format_flags],8
        jnz     elf64_extrn_symbol
        xor     eax,eax
        stos    dword [edi]
        mov     eax,[esi+8]
        stos    dword [edi]
        mov     eax,10h
        stos    dword [edi]
        jmp     extrn_symbol_ok
      elf64_extrn_symbol:
        mov     eax,10h
        stos    dword [edi]
        xor     al,al
        stos    dword [edi]
        stos    dword [edi]
        mov     eax,[esi+8]
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
      extrn_symbol_ok:
        inc     ecx
        mov     eax,ecx
        shl     eax,8
        mov     al,81h
        mov     [esi],eax
        add     esi,0Ch
        jmp     find_other_symbols
      elf_symbol_table_ok:
        mov     edx,edi
        mov     ebx,[free_additional_memory]
        xor     al,al
        stos    byte [edi]
        add     edi,16
        mov     [edx+1],edx
        add     ebx,10h
        test    [format_flags],8
        jz      make_string_table
        add     ebx,8
      make_string_table:
        cmp     ebx,edx
        je      elf_string_table_ok
        test    [format_flags],8
        jnz     make_elf64_string
        cmp     byte [ebx+0Dh],0
        je      rel_prefix_ok
        mov     byte [ebx+0Dh],0
        mov     eax,'.rel'
        stos    dword [edi]
      rel_prefix_ok:
        mov     esi,edi
        sub     esi,edx
        xchg    esi,[ebx]
        add     ebx,10h
      make_elf_string:
        or      esi,esi
        jz      default_string
        lods    dword [esi]
        mov     ecx,eax
        rep     movs byte [edi],[esi]
        xor     al,al
        stos    byte [edi]
        jmp     make_string_table
      make_elf64_string:
        cmp     byte [ebx+5],0
        je      elf64_rel_prefix_ok
        mov     byte [ebx+5],0
        mov     eax,'.rel'
        stos    dword [edi]
        mov     al,'a'
        stos    byte [edi]
      elf64_rel_prefix_ok:
        mov     esi,edi
        sub     esi,edx
        xchg    esi,[ebx]
        add     ebx,18h
        jmp     make_elf_string
      default_string:
        mov     eax,'.fla'
        stos    dword [edi]
        mov     ax,'t'
        stos    word [edi]
        jmp     make_string_table
      elf_string_table_ok:
        mov     [edx+1+8],edi
        mov     ebx,[code_start]
        mov     eax,edi
        sub     eax,[free_additional_memory]
        test    [format_flags],8
        jnz     finish_elf64_header
        mov     [ebx+20h],eax
        mov     eax,[current_section]
        inc     ax
        jz      format_limitations_exceeded
        mov     [ebx+32h],ax
        inc     ax
        jz      format_limitations_exceeded
        mov     [ebx+30h],ax
        jmp     elf_header_finished
      finish_elf64_header:
        mov     [ebx+28h],eax
        mov     eax,[current_section]
        inc     ax
        jz      format_limitations_exceeded
        mov     [ebx+3Eh],ax
        inc     ax
        jz      format_limitations_exceeded
        mov     [ebx+3Ch],ax
      elf_header_finished:
        xor     eax,eax
        mov     ecx,10
        rep     stos dword [edi]
        test    [format_flags],8
        jz      elf_null_section_ok
        mov     ecx,6
        rep     stos dword [edi]
      elf_null_section_ok:
        mov     esi,ebp
        xor     ecx,ecx
      make_section_entry:
        mov     ebx,edi
        mov     eax,[esi+4]
        mov     eax,[eax]
        stos    dword [edi]
        mov     eax,1
        cmp     dword [esi+0Ch],0
        je      bss_section
        test    byte [esi+14h],80h
        jz      section_type_ok
      bss_section:
        mov     al,8
      section_type_ok:
        stos    dword [edi]
        mov     eax,[esi+14h]
        and     al,3Fh
        call    store_elf_machine_word
        xor     eax,eax
        call    store_elf_machine_word
        mov     eax,[esi+8]
        mov     [image_base],eax
        sub     eax,[code_start]
        call    store_elf_machine_word
        mov     eax,[esi+0Ch]
        call    store_elf_machine_word
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        mov     eax,[esi+10h]
        call    store_elf_machine_word
        xor     eax,eax
        call    store_elf_machine_word
        inc     ecx
        add     esi,20h
        xchg    edi,[esp]
        mov     ebp,edi
      convert_relocations:
        cmp     esi,[free_additional_memory]
        je      relocations_converted
        mov     al,[esi]
        or      al,al
        jz      relocations_converted
        cmp     al,80h
        jb      make_relocation_entry
        ja      relocation_entry_ok
        add     esi,10h
        jmp     convert_relocations
      make_relocation_entry:
        test    [format_flags],8
        jnz     make_elf64_relocation_entry
        mov     eax,[esi+4]
        stos    dword [edi]
        mov     eax,[esi+8]
        mov     eax,[eax]
        mov     al,[esi]
        stos    dword [edi]
        jmp     relocation_entry_ok
      make_elf64_relocation_entry:
        mov     eax,[esi+4]
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        movzx   eax,byte [esi]
        stos    dword [edi]
        mov     eax,[esi+8]
        mov     eax,[eax]
        shr     eax,8
        stos    dword [edi]
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
      relocation_entry_ok:
        add     esi,0Ch
        jmp     convert_relocations
      store_elf_machine_word:
        stos    dword [edi]
        test    [format_flags],8
        jz      elf_machine_word_ok
        mov     dword [edi],0
        add     edi,4
      elf_machine_word_ok:
        ret
      relocations_converted:
        cmp     edi,ebp
        xchg    edi,[esp]
        je      rel_section_ok
        mov     eax,[ebx]
        sub     eax,4
        test    [format_flags],8
        jz      store_relocations_name_offset
        dec     eax
      store_relocations_name_offset:
        stos    dword [edi]
        test    [format_flags],8
        jnz     rela_section
        mov     eax,9
        jmp     store_relocations_type
      rela_section:
        mov     eax,4
      store_relocations_type:
        stos    dword [edi]
        xor     al,al
        call    store_elf_machine_word
        call    store_elf_machine_word
        mov     eax,ebp
        sub     eax,[code_start]
        call    store_elf_machine_word
        mov     eax,[esp]
        sub     eax,ebp
        call    store_elf_machine_word
        mov     eax,[current_section]
        stos    dword [edi]
        mov     eax,ecx
        stos    dword [edi]
        inc     ecx
        test    [format_flags],8
        jnz     finish_elf64_rela_section
        mov     eax,4
        stos    dword [edi]
        mov     al,8
        stos    dword [edi]
        jmp     rel_section_ok
      finish_elf64_rela_section:
        mov     eax,8
        stos    dword [edi]
        xor     al,al
        stos    dword [edi]
        mov     al,24
        stos    dword [edi]
        xor     al,al
        stos    dword [edi]
      rel_section_ok:
        cmp     esi,[free_additional_memory]
        jne     make_section_entry
        pop     eax
        mov     ebx,[code_start]
        sub     eax,ebx
        mov     [code_size],eax
        mov     ecx,20h
        test    [format_flags],8
        jz      adjust_elf_section_headers_offset
        mov     ecx,28h
      adjust_elf_section_headers_offset:
        add     [ebx+ecx],eax
        mov     eax,1
        stos    dword [edi]
        mov     al,2
        stos    dword [edi]
        xor     al,al
        call    store_elf_machine_word
        call    store_elf_machine_word
        mov     eax,[code_size]
        call    store_elf_machine_word
        mov     eax,[edx+1]
        sub     eax,[free_additional_memory]
        call    store_elf_machine_word
        mov     eax,[current_section]
        inc     eax
        stos    dword [edi]
        mov     eax,[number_of_sections]
        inc     eax
        stos    dword [edi]
        test    [format_flags],8
        jnz     finish_elf64_sym_section
        mov     eax,4
        stos    dword [edi]
        mov     al,10h
        stos    dword [edi]
        jmp     sym_section_ok
      finish_elf64_sym_section:
        mov     eax,8
        stos    dword [edi]
        xor     al,al
        stos    dword [edi]
        mov     al,18h
        stos    dword [edi]
        xor     al,al
        stos    dword [edi]
      sym_section_ok:
        mov     al,1+8
        stos    dword [edi]
        mov     al,3
        stos    dword [edi]
        xor     al,al
        call    store_elf_machine_word
        call    store_elf_machine_word
        mov     eax,[edx+1]
        sub     eax,[free_additional_memory]
        add     eax,[code_size]
        call    store_elf_machine_word
        mov     eax,[edx+1+8]
        sub     eax,[edx+1]
        call    store_elf_machine_word
        xor     eax,eax
        stos    dword [edi]
        stos    dword [edi]
        mov     al,1
        call    store_elf_machine_word
        xor     eax,eax
        call    store_elf_machine_word
        mov     eax,'tab'
        mov     dword [edx+1],'.sym'
        mov     [edx+1+4],eax
        mov     dword [edx+1+8],'.str'
        mov     [edx+1+8+4],eax
        mov     [written_size],0
        mov     edx,[output_file]
        call    create
        jc      write_failed
        call    write_code
        mov     ecx,edi
        mov     edx,[free_additional_memory]
        sub     ecx,edx
        add     [written_size],ecx
        call    write
        jc      write_failed
        jmp     output_written
 
format_elf_exe:
        add     esi,2
        or      [format_flags],1
        mov     [image_base],8048000h
        cmp     byte [esi],80h
        jne     elf_exe_base_ok
        lods    word [esi]
        cmp     ah,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        push    edx
        call    get_dword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     [image_base],eax
        pop     edx
      elf_exe_base_ok:
        mov     byte [edx+10h],2
        mov     byte [edx+2Ah],20h
        mov     ebx,edi
        mov     ecx,20h shr 2
        cmp     [current_pass],0
        je      init_elf_segments
        imul    ecx,[number_of_sections]
      init_elf_segments:
        xor     eax,eax
        rep     stos dword [edi]
        mov     [number_of_sections],0
        mov     byte [ebx],1
        mov     word [ebx+1Ch],1000h
        mov     byte [ebx+18h],111b
        mov     eax,edi
        sub     eax,[code_start]
        mov     [ebx+4],eax
        add     eax,[image_base]
        mov     [ebx+8],eax
        mov     [ebx+0Ch],eax
        mov     [edx+18h],eax
        xor     edx,edx
        not     eax
        not     edx
        add     eax,1
        adc     edx,0
        add     eax,edi
        adc     edx,0
        mov     dword [org_origin],eax
        mov     dword [org_origin+4],edx
        mov     [org_registers],0
        mov     [org_start],edi
        mov     [symbols_stream],edi
        jmp     instruction_assembled
      format_elf64_exe:
        add     esi,2
        or      [format_flags],1
        mov     [image_base],400000h
        mov     [image_base_high],0
        cmp     byte [esi],80h
        jne     elf64_exe_base_ok
        lods    word [esi]
        cmp     ah,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        push    edx
        call    get_qword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     [image_base],eax
        mov     [image_base_high],edx
        pop     edx
      elf64_exe_base_ok:
        mov     byte [edx+10h],2
        mov     byte [edx+36h],38h
        mov     ebx,edi
        mov     ecx,38h shr 2
        cmp     [current_pass],0
        je      init_elf64_segments
        imul    ecx,[number_of_sections]
      init_elf64_segments:
        xor     eax,eax
        rep     stos dword [edi]
        mov     [number_of_sections],0
        mov     byte [ebx],1
        mov     word [ebx+30h],1000h
        mov     byte [ebx+4],111b
        push    edx
        mov     eax,edi
        sub     eax,[code_start]
        mov     [ebx+8],eax
        xor     edx,edx
        add     eax,[image_base]
        adc     edx,[image_base_high]
        mov     [ebx+10h],eax
        mov     [ebx+10h+4],edx
        mov     [ebx+18h],eax
        mov     [ebx+18h+4],edx
        pop     ebx
        mov     [ebx+18h],eax
        mov     [ebx+18h+4],edx
        not     eax
        not     edx
        add     eax,1
        adc     edx,0
        add     eax,edi
        adc     edx,0
        mov     dword [org_origin],eax
        mov     dword [org_origin+4],edx
        mov     [org_registers],0
        mov     [org_start],edi
        mov     [symbols_stream],edi
        jmp     instruction_assembled
elf_entry:
        lods    byte [esi]
        cmp     al,'('
        jne     invalid_argument
        cmp     byte [esi],'.'
        je      invalid_value
        test    [format_flags],8
        jnz     elf64_entry
        call    get_dword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     edx,[code_start]
        mov     [edx+18h],eax
        jmp     instruction_assembled
      elf64_entry:
        call    get_qword_value
        cmp     [value_type],0
        jne     invalid_use_of_symbol
        mov     ebx,[code_start]
        mov     [ebx+18h],eax
        mov     [ebx+1Ch],edx
        jmp     instruction_assembled
elf_segment:
        bt      [format_flags],0
        jnc     illegal_instruction
        test    [format_flags],8
        jnz     elf64_segment
        call    close_elf_segment
        push    eax
        mov     ebx,[number_of_sections]
        shl     ebx,5
        add     ebx,[code_start]
        add     ebx,34h
        cmp     ebx,[symbols_stream]
        jb      new_elf_segment
        mov     ebx,[symbols_stream]
        sub     ebx,20h
        push    edi
        mov     edi,ebx
        mov     ecx,20h shr 2
        xor     eax,eax
        rep     stos dword [edi]
        pop     edi
        or      [next_pass_needed],-1
      new_elf_segment:
        mov     byte [ebx],1
        mov     word [ebx+1Ch],1000h
      elf_segment_flags:
        cmp     byte [esi],19h
        jne     elf_segment_flags_ok
        lods    word [esi]
        sub     ah,28
        jbe     invalid_argument
        cmp     ah,1
        je      mark_elf_segment_flag
        cmp     ah,3
        ja      invalid_argument
        xor     ah,1
        cmp     ah,2
        je      mark_elf_segment_flag
        inc     ah
      mark_elf_segment_flag:
        test    [ebx+18h],ah
        jnz     setting_already_specified
        or      [ebx+18h],ah
        jmp     elf_segment_flags
      elf_segment_flags_ok:
        mov     eax,edi
        sub     eax,[code_start]
        mov     [ebx+4],eax
        pop     edx
        and     eax,0FFFh
        add     edx,eax
        mov     [ebx+8],edx
        mov     [ebx+0Ch],edx
        mov     eax,edx
        xor     edx,edx
        not     eax
        not     edx
        add     eax,1
        adc     edx,0
        add     eax,edi
        adc     edx,0
        mov     dword [org_origin],eax
        mov     dword [org_origin+4],edx
        mov     [org_registers],0
        mov     [org_start],edi
        inc     [number_of_sections]
        jmp     instruction_assembled
      close_elf_segment:
        cmp     [number_of_sections],0
        jne     finish_elf_segment
        cmp     edi,[symbols_stream]
        jne     first_elf_segment_ok
        push    edi
        mov     edi,[code_start]
        add     edi,34h
        mov     ecx,20h shr 2
        xor     eax,eax
        rep     stos dword [edi]
        pop     edi
        mov     eax,[image_base]
        ret
      first_elf_segment_ok:
        inc     [number_of_sections]
      finish_elf_segment:
        mov     ebx,[number_of_sections]
        dec     ebx
        shl     ebx,5
        add     ebx,[code_start]
        add     ebx,34h
        mov     eax,edi
        sub     eax,[code_start]
        sub     eax,[ebx+4]
        mov     edx,edi
        cmp     edi,[undefined_data_end]
        jne     elf_segment_size_ok
        mov     edi,[undefined_data_start]
      elf_segment_size_ok:
        mov     [ebx+14h],eax
        add     eax,edi
        sub     eax,edx
        mov     [ebx+10h],eax
        mov     eax,[ebx+8]
        add     eax,[ebx+14h]
        add     eax,0FFFh
        and     eax,not 0FFFh
        ret
      elf64_segment:
        call    close_elf64_segment
        push    eax edx
        mov     ebx,[number_of_sections]
        imul    ebx,38h
        add     ebx,[code_start]
        add     ebx,40h
        cmp     ebx,[symbols_stream]
        jb      new_elf64_segment
        mov     ebx,[symbols_stream]
        sub     ebx,38h
        push    edi
        mov     edi,ebx
        mov     ecx,38h shr 2
        xor     eax,eax
        rep     stos dword [edi]
        pop     edi
        or      [next_pass_needed],-1
      new_elf64_segment:
        mov     byte [ebx],1
        mov     word [ebx+30h],1000h
      elf64_segment_flags:
        cmp     byte [esi],19h
        jne     elf64_segment_flags_ok
        lods    word [esi]
        sub     ah,28
        jbe     invalid_argument
        cmp     ah,1
        je      mark_elf64_segment_flag
        cmp     ah,3
        ja      invalid_argument
        xor     ah,1
        cmp     ah,2
        je      mark_elf64_segment_flag
        inc     ah
      mark_elf64_segment_flag:
        test    [ebx+4],ah
        jnz     setting_already_specified
        or      [ebx+4],ah
        jmp     elf64_segment_flags
      elf64_segment_flags_ok:
        mov     ecx,edi
        sub     ecx,[code_start]
        mov     [ebx+8],ecx
        pop     edx eax
        and     ecx,0FFFh
        add     eax,ecx
        adc     edx,0
        mov     [ebx+10h],eax
        mov     [ebx+10h+4],edx
        mov     [ebx+18h],eax
        mov     [ebx+18h+4],edx
        not     eax
        not     edx
        add     eax,1
        adc     edx,0
        add     eax,edi
        adc     edx,0
        mov     dword [org_origin],eax
        mov     dword [org_origin+4],edx
        mov     [org_registers],0
        mov     [org_start],edi
        inc     [number_of_sections]
        jmp     instruction_assembled
      close_elf64_segment:
        cmp     [number_of_sections],0
        jne     finish_elf64_segment
        cmp     edi,[symbols_stream]
        jne     first_elf64_segment_ok
        push    edi
        mov     edi,[code_start]
        add     edi,40h
        mov     ecx,38h shr 2
        xor     eax,eax
        rep     stos dword [edi]
        pop     edi
        mov     eax,[image_base]
        mov     edx,[image_base_high]
        ret
      first_elf64_segment_ok:
        inc     [number_of_sections]
      finish_elf64_segment:
        mov     ebx,[number_of_sections]
        dec     ebx
        imul    ebx,38h
        add     ebx,[code_start]
        add     ebx,40h
        mov     eax,edi
        sub     eax,[code_start]
        sub     eax,[ebx+8]
        mov     edx,edi
        cmp     edi,[undefined_data_end]
        jne     elf64_segment_size_ok
        mov     edi,[undefined_data_start]
      elf64_segment_size_ok:
        mov     [ebx+28h],eax
        add     eax,edi
        sub     eax,edx
        mov     [ebx+20h],eax
        mov     eax,[ebx+10h]
        mov     edx,[ebx+10h+4]
        add     eax,[ebx+28h]
        adc     edx,0
        sub     eax,1
        sbb     edx,0
        shrd    eax,edx,12
        shr     edx,12
        add     eax,1
        adc     edx,0
        shld    edx,eax,12
        shl     eax,12
        ret
close_elf_exe:
        test    [format_flags],8
        jnz     close_elf64_exe
        call    close_elf_segment
        mov     edx,[code_start]
        mov     eax,[number_of_sections]
        mov     byte [edx+1Ch],34h
        mov     [edx+2Ch],ax
        shl     eax,5
        add     eax,edx
        add     eax,34h
        cmp     eax,[symbols_stream]
        je      elf_exe_ok
        or      [next_pass_needed],-1
      elf_exe_ok:
        ret
      close_elf64_exe:
        call    close_elf64_segment
        mov     edx,[code_start]
        mov     eax,[number_of_sections]
        mov     byte [edx+20h],40h
        mov     [edx+38h],ax
        imul    eax,38h
        add     eax,edx
        add     eax,40h
        cmp     eax,[symbols_stream]
        je      elf64_exe_ok
        or      [next_pass_needed],-1
      elf64_exe_ok:
        ret

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Rev 31	Rev 109
1	; flat assembler core	1	; flat assembler core
2	; Copyright (c) 1999-2005, Tomasz Grysztar.	2	; Copyright (c) 1999-2006, Tomasz Grysztar.
3	; All rights reserved.	3	; All rights reserved.
4		4
5	formatter:	5	formatter:
6	cmp [output_file],0	6	cmp [output_file],0
7	jne output_path_ok	7	jne output_path_ok
8	push edi	8	push edi
9	mov esi,[input_file]	9	mov esi,[input_file]
10	mov edi,[free_additional_memory]	10	mov edi,[free_additional_memory]
11	copy_output_path:	11	copy_output_path:
12	lods byte [esi]	12	lods byte [esi]
13	cmp edi,[structures_buffer]	13	cmp edi,[structures_buffer]
14	jae out_of_memory	14	jae out_of_memory
15	stos byte [edi]	15	stos byte [edi]
16	or al,al	16	or al,al
17	jnz copy_output_path	17	jnz copy_output_path
18	dec edi	18	dec edi
19	mov eax,edi	19	mov eax,edi
20	find_extension:	20	find_extension:
21	dec eax	21	dec eax
22	cmp eax,[free_additional_memory]	22	cmp eax,[free_additional_memory]
23	jb extension_found	23	jb extension_found
24	cmp byte [eax],'\'	24	cmp byte [eax],'\'
25	je extension_found	25	je extension_found
26	cmp byte [eax],'/'	26	cmp byte [eax],'/'
27	je extension_found	27	je extension_found
28	cmp byte [eax],'.'	28	cmp byte [eax],'.'
29	jne find_extension	29	jne find_extension
30	mov edi,eax	30	mov edi,eax
31	extension_found:	31	extension_found:
32	lea eax,[edi+9]	32	lea eax,[edi+9]
33	cmp eax,[structures_buffer]	33	cmp eax,[structures_buffer]
34	jae out_of_memory	34	jae out_of_memory
35	cmp [output_format],2	35	cmp [output_format],2
36	je exe_extension	36	je exe_extension
37	jb bin_extension	37	jb bin_extension
38	cmp [output_format],4	38	cmp [output_format],4
39	je obj_extension	39	je obj_extension
40	cmp [output_format],5	40	cmp [output_format],5
41	je o_extension	41	je o_extension
42	cmp [output_format],3	42	cmp [output_format],3
43	jne no_extension	43	jne no_extension
44	cmp [subsystem],1	44	cmp [subsystem],1
45	je sys_extension	45	je sys_extension
46	bt [format_flags],8	46	bt [format_flags],8
47	jnc exe_extension	47	jnc exe_extension
48	mov eax,'.dll'	48	mov eax,'.dll'
49	jmp make_extension	49	jmp make_extension
50	sys_extension:	50	sys_extension:
51	mov eax,'.sys'	51	mov eax,'.sys'
52	jmp make_extension	52	jmp make_extension
53	bin_extension:	53	bin_extension:
54	mov eax,'.bin'	54	mov eax,'.bin'
55	bt [format_flags],0	55	bt [format_flags],0
56	jnc make_extension	56	jnc make_extension
57	mov eax,'.com'	57	mov eax,'.com'
58	jmp make_extension	58	jmp make_extension
59	obj_extension:	59	obj_extension:
60	mov eax,'.obj'	60	mov eax,'.obj'
61	jmp make_extension	61	jmp make_extension
62	o_extension:	62	o_extension:
63	mov eax,'.o'	63	mov eax,'.o'
64	bt [format_flags],0	64	bt [format_flags],0
65	jnc make_extension	65	jnc make_extension
66	no_extension:	66	no_extension:
67	xor eax,eax	67	xor eax,eax
68	jmp make_extension	68	jmp make_extension
69	exe_extension:	69	exe_extension:
70	mov eax,'.exe'	70	mov eax,'.exe'
71	make_extension:	71	make_extension:
72	xchg eax,[edi]	72	xchg eax,[edi]
73	scas dword [edi]	73	scas dword [edi]
74	mov byte [edi],0	74	mov byte [edi],0
75	scas byte [edi]	75	scas byte [edi]
76	mov esi,edi	76	mov esi,edi
77	stos dword [edi]	77	stos dword [edi]
78	sub edi,9	78	sub edi,9
79	xor eax,eax	79	xor eax,eax
80	mov ebx,characters	80	mov ebx,characters
81	adapt_case:	81	adapt_case:
82	mov al,[esi]	82	mov al,[esi]
83	or al,al	83	or al,al
84	jz adapt_next	84	jz adapt_next
85	xlat byte [ebx]	85	xlat byte [ebx]
86	cmp al,[esi]	86	cmp al,[esi]
87	je adapt_ok	87	je adapt_ok
88	sub byte [edi],20h	88	sub byte [edi],20h
89	adapt_ok:	89	adapt_ok:
90	inc esi	90	inc esi
91	adapt_next:	91	adapt_next:
92	inc edi	92	inc edi
93	cmp byte [edi],0	93	cmp byte [edi],0
94	jne adapt_case	94	jne adapt_case
95	mov esi,edi	95	mov esi,edi
96	lea ecx,[esi+1]	96	lea ecx,[esi+1]
97	sub ecx,[free_additional_memory]	97	sub ecx,[free_additional_memory]
98	mov edi,[structures_buffer]	98	mov edi,[structures_buffer]
99	dec edi	99	dec edi
100	std	100	std
101	rep movs byte [edi],[esi]	101	rep movs byte [edi],[esi]
102	cld	102	cld
103	inc edi	103	inc edi
104	mov [structures_buffer],edi	104	mov [structures_buffer],edi
105	mov [output_file],edi	105	mov [output_file],edi
106	pop edi	106	pop edi
107	output_path_ok:	107	output_path_ok:
108	cmp [output_format],4	108	cmp [output_format],4
109	je coff_formatter	109	je coff_formatter
110	cmp [output_format],5	110	cmp [output_format],5
111	jne common_formatter	111	jne common_formatter
112	bt [format_flags],0	112	bt [format_flags],0
113	jnc elf_formatter	113	jnc elf_formatter
114	common_formatter:	114	common_formatter:
115	mov eax,edi	115	mov eax,edi
116	sub eax,[code_start]	116	sub eax,[code_start]
117	mov [real_code_size],eax	117	mov [real_code_size],eax
118	cmp edi,[undefined_data_end]	118	cmp edi,[undefined_data_end]
119	jne calculate_code_size	119	jne calculate_code_size
120	mov edi,[undefined_data_start]	120	mov edi,[undefined_data_start]
121	calculate_code_size:	121	calculate_code_size:
122	sub edi,[code_start]	122	sub edi,[code_start]
123	mov [code_size],edi	123	mov [code_size],edi
124	mov [written_size],0	124	mov [written_size],0
125	mov edx,[output_file]	125	mov edx,[output_file]
126	call create	126	call create
127	jc write_failed	127	jc write_failed
128	cmp [output_format],3	128	cmp [output_format],3
129	jne stub_written	129	jne stub_written
130	mov edx,[code_start]	130	mov edx,[code_start]
131	mov ecx,[stub_size]	131	mov ecx,[stub_size]
132	sub edx,ecx	132	sub edx,ecx
133	add [written_size],ecx	133	add [written_size],ecx
134	call write	134	call write
135	stub_written:	135	stub_written:
136	cmp [output_format],2	136	cmp [output_format],2
137	jne write_output	137	jne write_output
138	call write_mz_header	138	call write_mz_header
139	write_output:	139	write_output:
140	call write_code	140	call write_code
141	output_written:	141	output_written:
142	call close	142	call close
143	ret	143	ret
144	write_code:	144	write_code:
145	mov eax,[written_size]	145	mov eax,[written_size]
146	mov [headers_size],eax	146	mov [headers_size],eax
147	mov edx,[code_start]	147	mov edx,[code_start]
148	mov ecx,[code_size]	148	mov ecx,[code_size]
149	add [written_size],ecx	149	add [written_size],ecx
150	call write	150	call write
151	jc write_failed	151	jc write_failed
152	ret	152	ret
153	format_directive:	153	format_directive:
154	cmp edi,[code_start]	154	cmp edi,[code_start]
155	jne unexpected_instruction	155	jne unexpected_instruction
156	cmp [virtual_data],0	156	cmp [virtual_data],0
157	jne unexpected_instruction	157	jne unexpected_instruction
158	cmp [output_format],0	158	cmp [output_format],0
159	jne unexpected_instruction	159	jne unexpected_instruction
160	lods byte [esi]	160	lods byte [esi]
161	cmp al,17h	161	cmp al,17h
162	je format_prefix	162	je format_prefix
163	cmp al,18h	163	cmp al,18h
164	jne invalid_argument	164	jne invalid_argument
165	lods byte [esi]	165	lods byte [esi]
166	select_format:	166	select_format:
167	mov dl,al	167	mov dl,al
168	shr al,4	168	shr al,4
169	mov [output_format],al	169	mov [output_format],al
170	and edx,0Fh	170	and edx,0Fh
171	or [format_flags],edx	171	or [format_flags],edx
172	cmp al,2	172	cmp al,2
173	je format_mz	173	je format_mz
174	cmp al,3	174	cmp al,3
175	je format_pe	175	je format_pe
176	cmp al,4	176	cmp al,4
177	je format_coff	177	je format_coff
178	cmp al,5	178	cmp al,5
179	je format_elf	179	je format_elf
180	jmp instruction_assembled	180	jmp instruction_assembled
181	format_prefix:	181	format_prefix:
182	lods byte [esi]	182	lods byte [esi]
183	mov ah,al	183	mov ah,al
184	lods byte [esi]	184	lods byte [esi]
185	cmp al,18h	185	cmp al,18h
186	jne invalid_argument	186	jne invalid_argument
187	lods byte [esi]	187	lods byte [esi]
188	mov edx,eax	188	mov edx,eax
189	shr dl,4	189	shr dl,4
190	shr dh,4	190	shr dh,4
191	cmp dl,dh	191	cmp dl,dh
192	jne invalid_argument	192	jne invalid_argument
193	or al,ah	193	or al,ah
194	jmp select_format	194	jmp select_format
195	entry_directive:	195	entry_directive:
196	bts [format_flags],10h	196	bts [format_flags],10h
197	jc setting_already_specified	197	jc setting_already_specified
198	mov al,[output_format]	198	mov al,[output_format]
199	cmp al,2	199	cmp al,2
200	je mz_entry	200	je mz_entry
201	cmp al,3	201	cmp al,3
202	je pe_entry	202	je pe_entry
203	cmp al,5	203	cmp al,5
204	jne illegal_instruction	204	jne illegal_instruction
205	bt [format_flags],0	205	bt [format_flags],0
206	jc elf_entry	206	jc elf_entry
207	jmp illegal_instruction	207	jmp illegal_instruction
208	stack_directive:	208	stack_directive:
209	bts [format_flags],11h	209	bts [format_flags],11h
210	jc setting_already_specified	210	jc setting_already_specified
211	mov al,[output_format]	211	mov al,[output_format]
212	cmp al,2	212	cmp al,2
213	je mz_stack	213	je mz_stack
214	cmp al,3	214	cmp al,3
215	je pe_stack	215	je pe_stack
216	jmp illegal_instruction	216	jmp illegal_instruction
217	heap_directive:	217	heap_directive:
218	bts [format_flags],12h	218	bts [format_flags],12h
219	jc setting_already_specified	219	jc setting_already_specified
220	mov al,[output_format]	220	mov al,[output_format]
221	cmp al,2	221	cmp al,2
222	je mz_heap	222	je mz_heap
223	cmp al,3	223	cmp al,3
224	je pe_heap	224	je pe_heap
225	jmp illegal_instruction	225	jmp illegal_instruction
226	section_directive:	226	segment_directive:
-		227	cmp [virtual_data],0
-		228	jne illegal_instruction
-		229	mov al,[output_format]
-		230	cmp al,2
-		231	je mz_segment
-		232	cmp al,5
-		233	je elf_segment
-		234	jmp illegal_instruction
-		235	section_directive:
227	cmp [virtual_data],0	236	cmp [virtual_data],0
228	jne illegal_instruction	237	jne illegal_instruction
229	mov al,[output_format]	238	mov al,[output_format]
230	cmp al,3	239	cmp al,3
231	je pe_section	240	je pe_section
232	cmp al,4	241	cmp al,4
233	je coff_section	242	je coff_section
234	cmp al,5	243	cmp al,5
235	je elf_section	244	je elf_section
236	jmp illegal_instruction	245	jmp illegal_instruction
237	public_directive:	246	public_directive:
238	mov al,[output_format]	247	mov al,[output_format]
239	cmp al,4	248	cmp al,4
240	je public_allowed	249	je public_allowed
241	cmp al,5	250	cmp al,5
242	jne illegal_instruction	251	jne illegal_instruction
243	bt [format_flags],0	252	bt [format_flags],0
244	jc illegal_instruction	253	jc illegal_instruction
245	public_allowed:	254	public_allowed:
246	lods byte [esi]	255	lods byte [esi]
247	cmp al,2	256	cmp al,2
248	jne invalid_argument	257	jne invalid_argument
249	lods dword [esi]	258	lods dword [esi]
250	cmp eax,0Fh	259	cmp eax,0Fh
251	jb invalid_use_of_symbol	260	jb invalid_use_of_symbol
252	je reserved_word_used_as_symbol	261	je reserved_word_used_as_symbol
253	mov dx,[current_pass]	262	mov dx,[current_pass]
254	mov [eax+18],dx	263	mov [eax+18],dx
255	or byte [eax+8],8	264	or byte [eax+8],8
256	inc esi	265	inc esi
257	mov ebx,[free_additional_memory]	266	mov ebx,[free_additional_memory]
258	lea edx,[ebx+10h]	267	lea edx,[ebx+10h]
259	cmp edx,[structures_buffer]	268	cmp edx,[structures_buffer]
260	jae out_of_memory	269	jae out_of_memory
261	mov [free_additional_memory],edx	270	mov [free_additional_memory],edx
262	mov [ebx+8],eax	271	mov [ebx+8],eax
263	mov eax,[current_line]	272	mov eax,[current_line]
264	mov [ebx+0Ch],eax	273	mov [ebx+0Ch],eax
265	lods byte [esi]	274	lods byte [esi]
266	cmp al,86h	275	cmp al,86h
267	jne invalid_argument	276	jne invalid_argument
268	lods word [esi]	277	lods word [esi]
269	cmp ax,'('	278	cmp ax,'('
270	jne invalid_argument	279	jne invalid_argument
271	mov [ebx+4],esi	280	mov [ebx+4],esi
272	lods dword [esi]	281	lods dword [esi]
273	lea esi,[esi+eax+1]	282	lea esi,[esi+eax+1]
274	mov byte [ebx],80h	283	mov byte [ebx],80h
275	jmp instruction_assembled	284	jmp instruction_assembled
276	extrn_directive:	285	extrn_directive:
277	mov al,[output_format]	286	mov al,[output_format]
278	cmp al,4	287	cmp al,4
279	je extrn_allowed	288	je extrn_allowed
280	cmp al,5	289	cmp al,5
281	jne illegal_instruction	290	jne illegal_instruction
282	bt [format_flags],0	291	bt [format_flags],0
283	jc illegal_instruction	292	jc illegal_instruction
284	extrn_allowed:	293	extrn_allowed:
285	lods word [esi]	294	lods word [esi]
286	cmp ax,'('	295	cmp ax,'('
287	jne invalid_argument	296	jne invalid_argument
288	mov ebx,esi	297	mov ebx,esi
289	lods dword [esi]	298	lods dword [esi]
290	lea esi,[esi+eax+1]	299	lea esi,[esi+eax+1]
291	mov edx,[free_additional_memory]	300	mov edx,[free_additional_memory]
292	lea eax,[edx+0Ch]	301	lea eax,[edx+0Ch]
293	cmp eax,[structures_buffer]	302	cmp eax,[structures_buffer]
294	jae out_of_memory	303	jae out_of_memory
295	mov [free_additional_memory],eax	304	mov [free_additional_memory],eax
296	mov byte [edx],81h	305	mov byte [edx],81h
297	mov [edx+4],ebx	306	mov [edx+4],ebx
298	lods byte [esi]	307	lods byte [esi]
299	cmp al,86h	308	cmp al,86h
300	jne invalid_argument	309	jne invalid_argument
301	lods byte [esi]	310	lods byte [esi]
302	cmp al,2	311	cmp al,2
303	jne invalid_argument	312	jne invalid_argument
304	lods dword [esi]	313	lods dword [esi]
305	cmp eax,0Fh	314	cmp eax,0Fh
306	jb invalid_use_of_symbol	315	jb invalid_use_of_symbol
307	je reserved_word_used_as_symbol	316	je reserved_word_used_as_symbol
308	inc esi	317	inc esi
309	mov ebx,eax	318	mov ebx,eax
310	xor ah,ah	319	xor ah,ah
311	lods byte [esi]	320	lods byte [esi]
312	cmp al,':'	321	cmp al,':'
313	je get_extrn_size	322	je get_extrn_size
314	dec esi	323	dec esi
315	cmp al,11h	324	cmp al,11h
316	jne extrn_size_ok	325	jne extrn_size_ok
317	get_extrn_size:	326	get_extrn_size:
318	lods word [esi]	327	lods word [esi]
319	cmp al,11h	328	cmp al,11h
320	jne invalid_argument	329	jne invalid_argument
321	extrn_size_ok:	330	extrn_size_ok:
322	mov [address_symbol],edx	331	mov [address_symbol],edx
323	movzx ecx,ah	332	movzx ecx,ah
324	mov [edx+8],ecx	333	mov [edx+8],ecx
325	xor eax,eax	334	xor eax,eax
326	xor edx,edx	335	xor edx,edx
327	xor ebp,ebp	336	xor ebp,ebp
328	mov ch,2	337	mov ch,2
329	test [format_flags],8	338	test [format_flags],8
330	jz make_free_label	339	jz make_free_label
331	mov ch,4	340	mov ch,4
332	jmp make_free_label	341	jmp make_free_label
333	mark_relocation:	342	mark_relocation:
334	cmp [value_type],0	343	cmp [value_type],0
335	je relocation_ok	344	je relocation_ok
336	cmp [virtual_data],0	345	cmp [virtual_data],0
337	jne relocation_ok	346	jne relocation_ok
338	cmp [output_format],2	347	cmp [output_format],2
339	je mark_mz_relocation	348	je mark_mz_relocation
340	cmp [output_format],3	349	cmp [output_format],3
341	je mark_pe_relocation	350	je mark_pe_relocation
342	cmp [output_format],4	351	cmp [output_format],4
343	je mark_coff_relocation	352	je mark_coff_relocation
344	cmp [output_format],5	353	cmp [output_format],5
345	je mark_elf_relocation	354	je mark_elf_relocation
346	relocation_ok:	355	relocation_ok:
347	ret	356	ret
348	close_pass:	357	close_pass:
349	mov al,[output_format]	358	mov al,[output_format]
350	cmp al,3	359	cmp al,3
351	je close_pe	360	je close_pe
352	cmp al,4	361	cmp al,4
353	je close_coff	362	je close_coff
354	cmp al,5	363	cmp al,5
355	je close_elf	364	je close_elf
356	ret	365	ret
357		366
358	format_mz:	367	format_mz:
359	mov edx,[additional_memory]	368	mov edx,[additional_memory]
360	push edi	369	push edi
361	mov edi,edx	370	mov edi,edx
362	mov ecx,1Ch shr 2	371	mov ecx,1Ch shr 2
363	xor eax,eax	372	xor eax,eax
364	rep stos dword [edi]	373	rep stos dword [edi]
365	mov [free_additional_memory],edi	374	mov [free_additional_memory],edi
366	pop edi	375	pop edi
367	mov word [edx+0Ch],0FFFFh	376	mov word [edx+0Ch],0FFFFh
368	mov word [edx+10h],1000h	377	mov word [edx+10h],1000h
369	mov [code_type],16	378	mov [code_type],16
370	jmp instruction_assembled	379	jmp instruction_assembled
371	mark_mz_relocation:	380	mark_mz_relocation:
372	push eax ebx	381	push eax ebx
373	inc [number_of_relocations]	382	inc [number_of_relocations]
374	mov ebx,[free_additional_memory]	383	mov ebx,[free_additional_memory]
375	mov eax,edi	384	mov eax,edi
376	sub eax,[code_start]	385	sub eax,[code_start]
377	mov [ebx],ax	386	mov [ebx],ax
378	shr eax,16	387	shr eax,16
379	shl ax,12	388	shl ax,12
380	mov [ebx+2],ax	389	mov [ebx+2],ax
381	cmp word [ebx],0FFFFh	390	cmp word [ebx],0FFFFh
382	jne mz_relocation_ok	391	jne mz_relocation_ok
383	inc word [ebx+2]	392	inc word [ebx+2]
384	sub word [ebx],10h	393	sub word [ebx],10h
385	mz_relocation_ok:	394	mz_relocation_ok:
386	add ebx,4	395	add ebx,4
387	cmp ebx,[structures_buffer]	396	cmp ebx,[structures_buffer]
388	jae out_of_memory	397	jae out_of_memory
389	mov [free_additional_memory],ebx	398	mov [free_additional_memory],ebx
390	pop ebx eax	399	pop ebx eax
391	ret	400	ret
392	segment_directive:	401	mz_segment:
393	cmp [output_format],2	402	lods byte [esi]
394	jne illegal_instruction	-
395	cmp [virtual_data],0	-
396	jne illegal_instruction	-
397	lods byte [esi]	-
398	cmp al,2	403	cmp al,2
399	jne invalid_argument	404	jne invalid_argument
400	lods dword [esi]	405	lods dword [esi]
401	cmp eax,0Fh	406	cmp eax,0Fh
402	jb invalid_use_of_symbol	407	jb invalid_use_of_symbol
403	je reserved_word_used_as_symbol	408	je reserved_word_used_as_symbol
404	inc esi	409	inc esi
405	mov ebx,eax	410	mov ebx,eax
406	mov eax,edi	411	mov eax,edi
407	sub eax,[code_start]	412	sub eax,[code_start]
408	mov ecx,0Fh	413	mov ecx,0Fh
409	add eax,0Fh	414	add eax,0Fh
410	and eax,1111b	415	and eax,1111b
411	sub ecx,eax	416	sub ecx,eax
412	mov edx,edi	417	mov edx,edi
413	xor al,al	418	xor al,al
414	rep stos byte [edi]	419	rep stos byte [edi]
415	mov dword [org_origin],edi	420	mov dword [org_origin],edi
416	mov dword [org_origin+4],0	421	mov dword [org_origin+4],0
417	mov [org_registers],0	422	mov [org_registers],0
418	mov [org_start],edi	423	mov [org_start],edi
419	mov eax,edx	424	mov eax,edx
420	call undefined_data	425	call undefined_data
421	mov eax,edi	426	mov eax,edi
422	sub eax,[code_start]	427	sub eax,[code_start]
423	shr eax,4	428	shr eax,4
424	cmp eax,10000h	429	cmp eax,10000h
425	jae value_out_of_range	430	jae value_out_of_range
426	mov edx,eax	431	mov edx,eax
427	mov al,16	432	mov al,16
428	cmp byte [esi],13h	433	cmp byte [esi],13h
429	jne segment_type_ok	434	jne segment_type_ok
430	inc esi	435	inc esi
431	lods byte [esi]	436	lods byte [esi]
432	segment_type_ok:	437	segment_type_ok:
433	mov [code_type],al	438	mov [code_type],al
434	mov eax,edx	439	mov eax,edx
435	mov cx,0100h	440	mov cx,0100h
436	xor edx,edx	441	xor edx,edx
437	xor ebp,ebp	442	xor ebp,ebp
438	mov [address_symbol],edx	443	mov [address_symbol],edx
439	jmp make_free_label	444	jmp make_free_label
440	mz_entry:	445	mz_entry:
441	lods byte [esi]	446	lods byte [esi]
442	cmp al,'('	447	cmp al,'('
443	jne invalid_argument	448	jne invalid_argument
444	call get_word_value	449	call get_word_value
445	cmp [value_type],1	450	cmp [value_type],1
446	je initial_cs_ok	451	je initial_cs_ok
447	cmp [error_line],0	452	cmp [error_line],0
448	jne initial_cs_ok	453	jne initial_cs_ok
449	mov eax,[current_line]	454	mov eax,[current_line]
450	mov [error_line],eax	455	mov [error_line],eax
451	mov [error],invalid_address	456	mov [error],invalid_address
452	initial_cs_ok:	457	initial_cs_ok:
453	mov edx,[additional_memory]	458	mov edx,[additional_memory]
454	mov [edx+16h],ax	459	mov [edx+16h],ax
455	lods byte [esi]	460	lods byte [esi]
456	cmp al,':'	461	cmp al,':'
457	jne invalid_argument	462	jne invalid_argument
458	lods byte [esi]	463	lods byte [esi]
459	cmp al,'('	464	cmp al,'('
460	jne invalid_argument	465	jne invalid_argument
461	ja invalid_address	466	ja invalid_address
462	call get_word_value	467	call get_word_value
463	cmp [value_type],0	468	cmp [value_type],0
464	jne invalid_use_of_symbol	469	jne invalid_use_of_symbol
465	mov edx,[additional_memory]	470	mov edx,[additional_memory]
466	mov [edx+14h],ax	471	mov [edx+14h],ax
467	jmp instruction_assembled	472	jmp instruction_assembled
468	mz_stack:	473	mz_stack:
469	lods byte [esi]	474	lods byte [esi]
470	cmp al,'('	475	cmp al,'('
471	jne invalid_argument	476	jne invalid_argument
472	call get_word_value	477	call get_word_value
473	cmp byte [esi],':'	478	cmp byte [esi],':'
474	je stack_pointer	479	je stack_pointer
475	cmp ax,10h	480	cmp ax,10h
476	jb invalid_value	481	jb invalid_value
477	cmp [value_type],0	482	cmp [value_type],0
478	jne invalid_use_of_symbol	483	jne invalid_use_of_symbol
479	mov edx,[additional_memory]	484	mov edx,[additional_memory]
480	mov [edx+10h],ax	485	mov [edx+10h],ax
481	jmp instruction_assembled	486	jmp instruction_assembled
482	stack_pointer:	487	stack_pointer:
483	cmp [value_type],1	488	cmp [value_type],1
484	je initial_ss_ok	489	je initial_ss_ok
485	cmp [error_line],0	490	cmp [error_line],0
486	jne initial_ss_ok	491	jne initial_ss_ok
487	mov eax,[current_line]	492	mov eax,[current_line]
488	mov [error_line],eax	493	mov [error_line],eax
489	mov [error],invalid_address	494	mov [error],invalid_address
490	initial_ss_ok:	495	initial_ss_ok:
491	mov edx,[additional_memory]	496	mov edx,[additional_memory]

Subversion Repositories Kolibri OS

(root)/programs/develop/fasm/trunk/formats.inc – Rev 31 → 109