Subversion Repositories Kolibri OS

Rev

Rev 1115 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. ; flat assembler core
  3. ; Copyright (c) 1999-2009, Tomasz Grysztar.
  4. ; All rights reserved.
  5.  
  6. simple_instruction_except64:
  7.         cmp     [code_type],64
  8.         je      illegal_instruction
  9. simple_instruction:
  10.         stos    byte [edi]
  11.         jmp     instruction_assembled
  12. simple_instruction_only64:
  13.         cmp     [code_type],64
  14.         jne     illegal_instruction
  15.         jmp     simple_instruction
  16. simple_instruction_16bit_except64:
  17.         cmp     [code_type],64
  18.         je      illegal_instruction
  19. simple_instruction_16bit:
  20.         cmp     [code_type],16
  21.         jne     size_prefix
  22.         stos    byte [edi]
  23.         jmp     instruction_assembled
  24.       size_prefix:
  25.         mov     ah,al
  26.         mov     al,66h
  27.         stos    word [edi]
  28.         jmp     instruction_assembled
  29. simple_instruction_32bit_except64:
  30.         cmp     [code_type],64
  31.         je      illegal_instruction
  32. simple_instruction_32bit:
  33.         cmp     [code_type],16
  34.         je      size_prefix
  35.         stos    byte [edi]
  36.         jmp     instruction_assembled
  37. simple_instruction_64bit:
  38.         cmp     [code_type],64
  39.         jne     illegal_instruction
  40.         mov     ah,al
  41.         mov     al,48h
  42.         stos    word [edi]
  43.         jmp     instruction_assembled
  44. simple_extended_instruction_64bit:
  45.         cmp     [code_type],64
  46.         jne     illegal_instruction
  47.         mov     byte [edi],48h
  48.         inc     edi
  49. simple_extended_instruction:
  50.         mov     ah,al
  51.         mov     al,0Fh
  52.         stos    word [edi]
  53.         jmp     instruction_assembled
  54. prefix_instruction:
  55.         stos    byte [edi]
  56.         or      [prefixed_instruction],-1
  57.         jmp     continue_line
  58. segment_prefix:
  59.         mov     ah,al
  60.         shr     ah,4
  61.         cmp     ah,6
  62.         jne     illegal_instruction
  63.         and     al,1111b
  64.         mov     [segment_register],al
  65.         call    store_segment_prefix
  66.         or      [prefixed_instruction],-1
  67.         jmp     continue_line
  68. int_instruction:
  69.         lods    byte [esi]
  70.         call    get_size_operator
  71.         cmp     ah,1
  72.         ja      invalid_operand_size
  73.         cmp     al,'('
  74.         jne     invalid_operand
  75.         call    get_byte_value
  76.         mov     ah,al
  77.         mov     al,0CDh
  78.         stos    word [edi]
  79.         jmp     instruction_assembled
  80. iret_instruction:
  81.         cmp     [code_type],64
  82.         jne     simple_instruction
  83.         call    operand_64bit
  84.         jmp     simple_instruction
  85. aa_instruction:
  86.         cmp     [code_type],64
  87.         je      illegal_instruction
  88.         push    eax
  89.         mov     bl,10
  90.         cmp     byte [esi],'('
  91.         jne     aa_store
  92.         inc     esi
  93.         xor     al,al
  94.         xchg    al,[operand_size]
  95.         cmp     al,1
  96.         ja      invalid_operand_size
  97.         call    get_byte_value
  98.         mov     bl,al
  99.       aa_store:
  100.         cmp     [operand_size],0
  101.         jne     invalid_operand
  102.         pop     eax
  103.         mov     ah,bl
  104.         stos    word [edi]
  105.         jmp     instruction_assembled
  106.  
  107. basic_instruction:
  108.         mov     [base_code],al
  109.         lods    byte [esi]
  110.         call    get_size_operator
  111.         cmp     al,10h
  112.         je      basic_reg
  113.         cmp     al,'['
  114.         jne     invalid_operand
  115.       basic_mem:
  116.         call    get_address
  117.         push    edx ebx ecx
  118.         lods    byte [esi]
  119.         cmp     al,','
  120.         jne     invalid_operand
  121.         lods    byte [esi]
  122.         call    get_size_operator
  123.         cmp     al,'('
  124.         je      basic_mem_imm
  125.         cmp     al,10h
  126.         jne     invalid_operand
  127.       basic_mem_reg:
  128.         lods    byte [esi]
  129.         call    convert_register
  130.         mov     [postbyte_register],al
  131.         pop     ecx ebx edx
  132.         mov     al,ah
  133.         cmp     al,1
  134.         je      instruction_ready
  135.         call    operand_autodetect
  136.         inc     [base_code]
  137.       instruction_ready:
  138.         call    store_instruction
  139.         jmp     instruction_assembled
  140.       basic_mem_imm:
  141.         mov     al,[operand_size]
  142.         cmp     al,1
  143.         jb      basic_mem_imm_nosize
  144.         je      basic_mem_imm_8bit
  145.         cmp     al,2
  146.         je      basic_mem_imm_16bit
  147.         cmp     al,4
  148.         je      basic_mem_imm_32bit
  149.         cmp     al,8
  150.         jne     invalid_operand_size
  151.       basic_mem_imm_64bit:
  152.         cmp     [size_declared],0
  153.         jne     long_immediate_not_encodable
  154.         call    operand_64bit
  155.         call    get_simm32
  156.         cmp     [value_type],4
  157.         jae     long_immediate_not_encodable
  158.         jmp     basic_mem_imm_32bit_ok
  159.       basic_mem_imm_nosize:
  160.         cmp     [error_line],0
  161.         jne     basic_mem_imm_8bit
  162.         mov     eax,[current_line]
  163.         mov     [error_line],eax
  164.         mov     [error],operand_size_not_specified
  165.       basic_mem_imm_8bit:
  166.         call    get_byte_value
  167.         mov     byte [value],al
  168.         mov     al,[base_code]
  169.         shr     al,3
  170.         mov     [postbyte_register],al
  171.         pop     ecx ebx edx
  172.         mov     [base_code],80h
  173.         call    store_instruction_with_imm8
  174.         jmp     instruction_assembled
  175.       basic_mem_imm_16bit:
  176.         call    operand_16bit
  177.         call    get_word_value
  178.         mov     word [value],ax
  179.         mov     al,[base_code]
  180.         shr     al,3
  181.         mov     [postbyte_register],al
  182.         pop     ecx ebx edx
  183.         cmp     [value_type],0
  184.         jne     basic_mem_imm_16bit_store
  185.         cmp     [size_declared],0
  186.         jne     basic_mem_imm_16bit_store
  187.         cmp     word [value],80h
  188.         jb      basic_mem_simm_8bit
  189.         cmp     word [value],-80h
  190.         jae     basic_mem_simm_8bit
  191.       basic_mem_imm_16bit_store:
  192.         mov     [base_code],81h
  193.         call    store_instruction_with_imm16
  194.         jmp     instruction_assembled
  195.       basic_mem_simm_8bit:
  196.         mov     [base_code],83h
  197.         call    store_instruction_with_imm8
  198.         jmp     instruction_assembled
  199.       basic_mem_imm_32bit:
  200.         call    operand_32bit
  201.         call    get_dword_value
  202.       basic_mem_imm_32bit_ok:
  203.         mov     dword [value],eax
  204.         mov     al,[base_code]
  205.         shr     al,3
  206.         mov     [postbyte_register],al
  207.         pop     ecx ebx edx
  208.         cmp     [value_type],0
  209.         jne     basic_mem_imm_32bit_store
  210.         cmp     [size_declared],0
  211.         jne     basic_mem_imm_32bit_store
  212.         cmp     dword [value],80h
  213.         jb      basic_mem_simm_8bit
  214.         cmp     dword [value],-80h
  215.         jae     basic_mem_simm_8bit
  216.       basic_mem_imm_32bit_store:
  217.         mov     [base_code],81h
  218.         call    store_instruction_with_imm32
  219.         jmp     instruction_assembled
  220.       get_simm32:
  221.         call    get_qword_value
  222.         mov     ecx,edx
  223.         cdq
  224.         cmp     ecx,edx
  225.         jne     value_out_of_range
  226.         cmp     [value_type],4
  227.         jne     get_simm32_ok
  228.         mov     [value_type],2
  229.       get_simm32_ok:
  230.         ret
  231.       basic_reg:
  232.         lods    byte [esi]
  233.         call    convert_register
  234.         mov     [postbyte_register],al
  235.         lods    byte [esi]
  236.         cmp     al,','
  237.         jne     invalid_operand
  238.         lods    byte [esi]
  239.         call    get_size_operator
  240.         cmp     al,10h
  241.         je      basic_reg_reg
  242.         cmp     al,'('
  243.         je      basic_reg_imm
  244.         cmp     al,'['
  245.         jne     invalid_operand
  246.       basic_reg_mem:
  247.         call    get_address
  248.         mov     al,[operand_size]
  249.         cmp     al,1
  250.         je      basic_reg_mem_8bit
  251.         call    operand_autodetect
  252.         add     [base_code],3
  253.         jmp     instruction_ready
  254.       basic_reg_mem_8bit:
  255.         add     [base_code],2
  256.         jmp     instruction_ready
  257.       basic_reg_reg:
  258.         lods    byte [esi]
  259.         call    convert_register
  260.         mov     bl,[postbyte_register]
  261.         mov     [postbyte_register],al
  262.         mov     al,ah
  263.         cmp     al,1
  264.         je      nomem_instruction_ready
  265.         call    operand_autodetect
  266.         inc     [base_code]
  267.       nomem_instruction_ready:
  268.         call    store_nomem_instruction
  269.         jmp     instruction_assembled
  270.       basic_reg_imm:
  271.         mov     al,[operand_size]
  272.         cmp     al,1
  273.         je      basic_reg_imm_8bit
  274.         cmp     al,2
  275.         je      basic_reg_imm_16bit
  276.         cmp     al,4
  277.         je      basic_reg_imm_32bit
  278.         cmp     al,8
  279.         jne     invalid_operand_size
  280.       basic_reg_imm_64bit:
  281.         cmp     [size_declared],0
  282.         jne     long_immediate_not_encodable
  283.         call    operand_64bit
  284.         call    get_simm32
  285.         cmp     [value_type],4
  286.         jae     long_immediate_not_encodable
  287.         jmp     basic_reg_imm_32bit_ok
  288.       basic_reg_imm_8bit:
  289.         call    get_byte_value
  290.         mov     dl,al
  291.         mov     bl,[base_code]
  292.         shr     bl,3
  293.         xchg    bl,[postbyte_register]
  294.         or      bl,bl
  295.         jz      basic_al_imm
  296.         mov     [base_code],80h
  297.         call    store_nomem_instruction
  298.         mov     al,dl
  299.         stos    byte [edi]
  300.         jmp     instruction_assembled
  301.       basic_al_imm:
  302.         mov     al,[base_code]
  303.         add     al,4
  304.         stos    byte [edi]
  305.         mov     al,dl
  306.         stos    byte [edi]
  307.         jmp     instruction_assembled
  308.       basic_reg_imm_16bit:
  309.         call    operand_16bit
  310.         call    get_word_value
  311.         mov     dx,ax
  312.         mov     bl,[base_code]
  313.         shr     bl,3
  314.         xchg    bl,[postbyte_register]
  315.         cmp     [value_type],0
  316.         jne     basic_reg_imm_16bit_store
  317.         cmp     [size_declared],0
  318.         jne     basic_reg_imm_16bit_store
  319.         cmp     dx,80h
  320.         jb      basic_reg_simm_8bit
  321.         cmp     dx,-80h
  322.         jae     basic_reg_simm_8bit
  323.       basic_reg_imm_16bit_store:
  324.         or      bl,bl
  325.         jz      basic_ax_imm
  326.         mov     [base_code],81h
  327.         call    store_nomem_instruction
  328.       basic_store_imm_16bit:
  329.         mov     ax,dx
  330.         call    mark_relocation
  331.         stos    word [edi]
  332.         jmp     instruction_assembled
  333.       basic_reg_simm_8bit:
  334.         mov     [base_code],83h
  335.         call    store_nomem_instruction
  336.         mov     al,dl
  337.         stos    byte [edi]
  338.         jmp     instruction_assembled
  339.       basic_ax_imm:
  340.         add     [base_code],5
  341.         call    store_instruction_code
  342.         jmp     basic_store_imm_16bit
  343.       basic_reg_imm_32bit:
  344.         call    operand_32bit
  345.         call    get_dword_value
  346.       basic_reg_imm_32bit_ok:
  347.         mov     edx,eax
  348.         mov     bl,[base_code]
  349.         shr     bl,3
  350.         xchg    bl,[postbyte_register]
  351.         cmp     [value_type],0
  352.         jne     basic_reg_imm_32bit_store
  353.         cmp     [size_declared],0
  354.         jne     basic_reg_imm_32bit_store
  355.         cmp     edx,80h
  356.         jb      basic_reg_simm_8bit
  357.         cmp     edx,-80h
  358.         jae     basic_reg_simm_8bit
  359.       basic_reg_imm_32bit_store:
  360.         or      bl,bl
  361.         jz      basic_eax_imm
  362.         mov     [base_code],81h
  363.         call    store_nomem_instruction
  364.       basic_store_imm_32bit:
  365.         mov     eax,edx
  366.         call    mark_relocation
  367.         stos    dword [edi]
  368.         jmp     instruction_assembled
  369.       basic_eax_imm:
  370.         add     [base_code],5
  371.         call    store_instruction_code
  372.         jmp     basic_store_imm_32bit
  373. single_operand_instruction:
  374.         mov     [base_code],0F6h
  375.         mov     [postbyte_register],al
  376.         lods    byte [esi]
  377.         call    get_size_operator
  378.         cmp     al,10h
  379.         je      single_reg
  380.         cmp     al,'['
  381.         jne     invalid_operand
  382.       single_mem:
  383.         call    get_address
  384.         mov     al,[operand_size]
  385.         cmp     al,1
  386.         je      single_mem_8bit
  387.         jb      single_mem_nosize
  388.         call    operand_autodetect
  389.         inc     [base_code]
  390.         jmp     instruction_ready
  391.       single_mem_nosize:
  392.         cmp     [error_line],0
  393.         jne     single_mem_8bit
  394.         mov     eax,[current_line]
  395.         mov     [error_line],eax
  396.         mov     [error],operand_size_not_specified
  397.       single_mem_8bit:
  398.         jmp     instruction_ready
  399.       single_reg:
  400.         lods    byte [esi]
  401.         call    convert_register
  402.         mov     bl,al
  403.         mov     al,ah
  404.         cmp     al,1
  405.         je      single_reg_8bit
  406.         call    operand_autodetect
  407.         inc     [base_code]
  408.       single_reg_8bit:
  409.         jmp     nomem_instruction_ready
  410. mov_instruction:
  411.         mov     [base_code],88h
  412.         lods    byte [esi]
  413.         call    get_size_operator
  414.         cmp     al,10h
  415.         je      mov_reg
  416.         cmp     al,'['
  417.         jne     invalid_operand
  418.       mov_mem:
  419.         call    get_address
  420.         push    edx ebx ecx
  421.         lods    byte [esi]
  422.         cmp     al,','
  423.         jne     invalid_operand
  424.         lods    byte [esi]
  425.         call    get_size_operator
  426.         cmp     al,'('
  427.         je      mov_mem_imm
  428.         cmp     al,10h
  429.         jne     invalid_operand
  430.       mov_mem_reg:
  431.         lods    byte [esi]
  432.         cmp     al,60h
  433.         jb      mov_mem_general_reg
  434.         cmp     al,70h
  435.         jb      mov_mem_sreg
  436.       mov_mem_general_reg:
  437.         call    convert_register
  438.         mov     [postbyte_register],al
  439.         pop     ecx ebx edx
  440.         cmp     ah,1
  441.         je      mov_mem_reg_8bit
  442.         mov     al,ah
  443.         call    operand_autodetect
  444.         mov     al,[postbyte_register]
  445.         or      al,bl
  446.         or      al,bh
  447.         jz      mov_mem_ax
  448.         inc     [base_code]
  449.         jmp     instruction_ready
  450.       mov_mem_reg_8bit:
  451.         or      al,bl
  452.         or      al,bh
  453.         jnz     instruction_ready
  454.       mov_mem_al:
  455.         test    ch,22h
  456.         jnz     mov_mem_address16_al
  457.         test    ch,44h
  458.         jnz     mov_mem_address32_al
  459.         test    ch,88h
  460.         jnz     mov_mem_address64_al
  461.         or      ch,ch
  462.         jnz     invalid_address_size
  463.         cmp     [code_type],64
  464.         je      mov_mem_address64_al
  465.         cmp     [code_type],32
  466.         je      mov_mem_address32_al
  467.         cmp     edx,10000h
  468.         jb      mov_mem_address16_al
  469.       mov_mem_address32_al:
  470.         call    store_segment_prefix_if_necessary
  471.         call    address_32bit_prefix
  472.         mov     [base_code],0A2h
  473.       store_mov_address32:
  474.         call    store_instruction_code
  475.         call    store_address_32bit_value
  476.         jmp     instruction_assembled
  477.       mov_mem_address16_al:
  478.         call    store_segment_prefix_if_necessary
  479.         call    address_16bit_prefix
  480.         mov     [base_code],0A2h
  481.       store_mov_address16:
  482.         cmp     [code_type],64
  483.         je      invalid_address
  484.         call    store_instruction_code
  485.         mov     eax,edx
  486.         stos    word [edi]
  487.         cmp     edx,10000h
  488.         jge     value_out_of_range
  489.         jmp     instruction_assembled
  490.       mov_mem_address64_al:
  491.         call    store_segment_prefix_if_necessary
  492.         mov     [base_code],0A2h
  493.       store_mov_address64:
  494.         call    store_instruction_code
  495.         call    store_address_64bit_value
  496.         jmp     instruction_assembled
  497.       mov_mem_ax:
  498.         test    ch,22h
  499.         jnz     mov_mem_address16_ax
  500.         test    ch,44h
  501.         jnz     mov_mem_address32_ax
  502.         test    ch,88h
  503.         jnz     mov_mem_address64_ax
  504.         or      ch,ch
  505.         jnz     invalid_address_size
  506.         cmp     [code_type],64
  507.         je      mov_mem_address64_ax
  508.         cmp     [code_type],32
  509.         je      mov_mem_address32_ax
  510.         cmp     edx,10000h
  511.         jb      mov_mem_address16_ax
  512.       mov_mem_address32_ax:
  513.         call    store_segment_prefix_if_necessary
  514.         call    address_32bit_prefix
  515.         mov     [base_code],0A3h
  516.         jmp     store_mov_address32
  517.       mov_mem_address16_ax:
  518.         call    store_segment_prefix_if_necessary
  519.         call    address_16bit_prefix
  520.         mov     [base_code],0A3h
  521.         jmp     store_mov_address16
  522.       mov_mem_address64_ax:
  523.         call    store_segment_prefix_if_necessary
  524.         mov     [base_code],0A3h
  525.         jmp     store_mov_address64
  526.       mov_mem_sreg:
  527.         sub     al,61h
  528.         mov     [postbyte_register],al
  529.         pop     ecx ebx edx
  530.         mov     ah,[operand_size]
  531.         or      ah,ah
  532.         jz      mov_mem_sreg_store
  533.         cmp     ah,2
  534.         jne     invalid_operand_size
  535.       mov_mem_sreg_store:
  536.         mov     [base_code],8Ch
  537.         jmp     instruction_ready
  538.       mov_mem_imm:
  539.         mov     al,[operand_size]
  540.         cmp     al,1
  541.         jb      mov_mem_imm_nosize
  542.         je      mov_mem_imm_8bit
  543.         cmp     al,2
  544.         je      mov_mem_imm_16bit
  545.         cmp     al,4
  546.         je      mov_mem_imm_32bit
  547.         cmp     al,8
  548.         jne     invalid_operand_size
  549.       mov_mem_imm_64bit:
  550.         cmp     [size_declared],0
  551.         jne     long_immediate_not_encodable
  552.         call    operand_64bit
  553.         call    get_simm32
  554.         cmp     [value_type],4
  555.         jae     long_immediate_not_encodable
  556.         jmp     mov_mem_imm_32bit_store
  557.       mov_mem_imm_8bit:
  558.         call    get_byte_value
  559.         mov     byte [value],al
  560.         mov     [postbyte_register],0
  561.         mov     [base_code],0C6h
  562.         pop     ecx ebx edx
  563.         call    store_instruction_with_imm8
  564.         jmp     instruction_assembled
  565.       mov_mem_imm_16bit:
  566.         call    operand_16bit
  567.         call    get_word_value
  568.         mov     word [value],ax
  569.         mov     [postbyte_register],0
  570.         mov     [base_code],0C7h
  571.         pop     ecx ebx edx
  572.         call    store_instruction_with_imm16
  573.         jmp     instruction_assembled
  574.       mov_mem_imm_nosize:
  575.         cmp     [error_line],0
  576.         jne     mov_mem_imm_32bit
  577.         mov     eax,[current_line]
  578.         mov     [error_line],eax
  579.         mov     [error],operand_size_not_specified
  580.       mov_mem_imm_32bit:
  581.         call    operand_32bit
  582.         call    get_dword_value
  583.       mov_mem_imm_32bit_store:
  584.         mov     dword [value],eax
  585.         mov     [postbyte_register],0
  586.         mov     [base_code],0C7h
  587.         pop     ecx ebx edx
  588.         call    store_instruction_with_imm32
  589.         jmp     instruction_assembled
  590.       mov_reg:
  591.         lods    byte [esi]
  592.         mov     ah,al
  593.         sub     ah,10h
  594.         and     ah,al
  595.         test    ah,0F0h
  596.         jnz     mov_sreg
  597.         call    convert_register
  598.         mov     [postbyte_register],al
  599.         lods    byte [esi]
  600.         cmp     al,','
  601.         jne     invalid_operand
  602.         lods    byte [esi]
  603.         call    get_size_operator
  604.         cmp     al,'['
  605.         je      mov_reg_mem
  606.         cmp     al,'('
  607.         je      mov_reg_imm
  608.         cmp     al,10h
  609.         jne     invalid_operand
  610.       mov_reg_reg:
  611.         lods    byte [esi]
  612.         mov     ah,al
  613.         sub     ah,10h
  614.         and     ah,al
  615.         test    ah,0F0h
  616.         jnz     mov_reg_sreg
  617.         call    convert_register
  618.         mov     bl,[postbyte_register]
  619.         mov     [postbyte_register],al
  620.         mov     al,ah
  621.         cmp     al,1
  622.         je      mov_reg_reg_8bit
  623.         call    operand_autodetect
  624.         inc     [base_code]
  625.       mov_reg_reg_8bit:
  626.         jmp     nomem_instruction_ready
  627.       mov_reg_sreg:
  628.         mov     bl,[postbyte_register]
  629.         mov     ah,al
  630.         and     al,1111b
  631.         mov     [postbyte_register],al
  632.         shr     ah,4
  633.         cmp     ah,5
  634.         je      mov_reg_creg
  635.         cmp     ah,7
  636.         je      mov_reg_dreg
  637.         ja      mov_reg_treg
  638.         dec     [postbyte_register]
  639.         cmp     [operand_size],8
  640.         je      mov_reg_sreg64
  641.         cmp     [operand_size],4
  642.         je      mov_reg_sreg32
  643.         cmp     [operand_size],2
  644.         jne     invalid_operand_size
  645.         call    operand_16bit
  646.         jmp     mov_reg_sreg_store
  647.       mov_reg_sreg64:
  648.         call    operand_64bit
  649.         jmp     mov_reg_sreg_store
  650.       mov_reg_sreg32:
  651.         call    operand_32bit
  652.       mov_reg_sreg_store:
  653.         mov     [base_code],8Ch
  654.         jmp     nomem_instruction_ready
  655.       mov_reg_treg:
  656.         cmp     ah,9
  657.         jne     invalid_operand
  658.         mov     [extended_code],24h
  659.         jmp     mov_reg_xrx
  660.       mov_reg_dreg:
  661.         mov     [extended_code],21h
  662.         jmp     mov_reg_xrx
  663.       mov_reg_creg:
  664.         mov     [extended_code],20h
  665.       mov_reg_xrx:
  666.         mov     [base_code],0Fh
  667.         cmp     [code_type],64
  668.         je      mov_reg_xrx_64bit
  669.         cmp     [operand_size],4
  670.         jne     invalid_operand_size
  671.         cmp     [postbyte_register],8
  672.         jne     mov_reg_xrx_store
  673.         cmp     [extended_code],20h
  674.         jne     mov_reg_xrx_store
  675.         mov     al,0F0h
  676.         stos    byte [edi]
  677.         mov     [postbyte_register],0
  678.       mov_reg_xrx_store:
  679.         jmp     nomem_instruction_ready
  680.       mov_reg_xrx_64bit:
  681.         cmp     [operand_size],8
  682.         jne     invalid_operand_size
  683.         jmp     nomem_instruction_ready
  684.       mov_reg_mem:
  685.         call    get_address
  686.         mov     al,[operand_size]
  687.         cmp     al,1
  688.         je      mov_reg_mem_8bit
  689.         call    operand_autodetect
  690.         mov     al,[postbyte_register]
  691.         or      al,bl
  692.         or      al,bh
  693.         jz      mov_ax_mem
  694.         add     [base_code],3
  695.         jmp     instruction_ready
  696.       mov_reg_mem_8bit:
  697.         mov     al,[postbyte_register]
  698.         or      al,bl
  699.         or      al,bh
  700.         jz      mov_al_mem
  701.         add     [base_code],2
  702.         jmp     instruction_ready
  703.       mov_al_mem:
  704.         test    ch,22h
  705.         jnz     mov_al_mem_address16
  706.         test    ch,44h
  707.         jnz     mov_al_mem_address32
  708.         test    ch,88h
  709.         jnz     mov_al_mem_address64
  710.         or      ch,ch
  711.         jnz     invalid_address_size
  712.         cmp     [code_type],64
  713.         je      mov_al_mem_address64
  714.         cmp     [code_type],32
  715.         je      mov_al_mem_address32
  716.         cmp     edx,10000h
  717.         jb      mov_al_mem_address16
  718.       mov_al_mem_address32:
  719.         call    store_segment_prefix_if_necessary
  720.         call    address_32bit_prefix
  721.         mov     [base_code],0A0h
  722.         jmp     store_mov_address32
  723.       mov_al_mem_address16:
  724.         call    store_segment_prefix_if_necessary
  725.         call    address_16bit_prefix
  726.         mov     [base_code],0A0h
  727.         jmp     store_mov_address16
  728.       mov_al_mem_address64:
  729.         call    store_segment_prefix_if_necessary
  730.         mov     [base_code],0A0h
  731.         jmp     store_mov_address64
  732.       mov_ax_mem:
  733.         test    ch,22h
  734.         jnz     mov_ax_mem_address16
  735.         test    ch,44h
  736.         jnz     mov_ax_mem_address32
  737.         test    ch,88h
  738.         jnz     mov_ax_mem_address64
  739.         or      ch,ch
  740.         jnz     invalid_address_size
  741.         cmp     [code_type],64
  742.         je      mov_ax_mem_address64
  743.         cmp     [code_type],32
  744.         je      mov_ax_mem_address32
  745.         cmp     edx,10000h
  746.         jb      mov_ax_mem_address16
  747.       mov_ax_mem_address32:
  748.         call    store_segment_prefix_if_necessary
  749.         call    address_32bit_prefix
  750.         mov     [base_code],0A1h
  751.         jmp     store_mov_address32
  752.       mov_ax_mem_address16:
  753.         call    store_segment_prefix_if_necessary
  754.         call    address_16bit_prefix
  755.         mov     [base_code],0A1h
  756.         jmp     store_mov_address16
  757.       mov_ax_mem_address64:
  758.         call    store_segment_prefix_if_necessary
  759.         mov     [base_code],0A1h
  760.         jmp     store_mov_address64
  761.       mov_reg_imm:
  762.         mov     al,[operand_size]
  763.         cmp     al,1
  764.         je      mov_reg_imm_8bit
  765.         cmp     al,2
  766.         je      mov_reg_imm_16bit
  767.         cmp     al,4
  768.         je      mov_reg_imm_32bit
  769.         cmp     al,8
  770.         jne     invalid_operand_size
  771.       mov_reg_imm_64bit:
  772.         call    operand_64bit
  773.         call    get_qword_value
  774.         mov     ecx,edx
  775.         cmp     [size_declared],0
  776.         jne     mov_reg_imm_64bit_store
  777.         cmp     [value_type],4
  778.         jae     mov_reg_imm_64bit_store
  779.         cdq
  780.         cmp     ecx,edx
  781.         je      mov_reg_64bit_imm_32bit
  782.       mov_reg_imm_64bit_store:
  783.         push    eax ecx
  784.         mov     al,0B8h
  785.         call    store_mov_reg_imm_code
  786.         pop     edx eax
  787.         call    mark_relocation
  788.         stos    dword [edi]
  789.         mov     eax,edx
  790.         stos    dword [edi]
  791.         jmp     instruction_assembled
  792.       mov_reg_imm_8bit:
  793.         call    get_byte_value
  794.         mov     dl,al
  795.         mov     al,0B0h
  796.         call    store_mov_reg_imm_code
  797.         mov     al,dl
  798.         stos    byte [edi]
  799.         jmp     instruction_assembled
  800.       mov_reg_imm_16bit:
  801.         call    get_word_value
  802.         mov     dx,ax
  803.         call    operand_16bit
  804.         mov     al,0B8h
  805.         call    store_mov_reg_imm_code
  806.         mov     ax,dx
  807.         call    mark_relocation
  808.         stos    word [edi]
  809.         jmp     instruction_assembled
  810.       mov_reg_imm_32bit:
  811.         call    operand_32bit
  812.         call    get_dword_value
  813.         mov     edx,eax
  814.         mov     al,0B8h
  815.         call    store_mov_reg_imm_code
  816.       mov_store_imm_32bit:
  817.         mov     eax,edx
  818.         call    mark_relocation
  819.         stos    dword [edi]
  820.         jmp     instruction_assembled
  821.       store_mov_reg_imm_code:
  822.         mov     ah,[postbyte_register]
  823.         test    ah,1000b
  824.         jz      mov_reg_imm_prefix_ok
  825.         or      [rex_prefix],41h
  826.       mov_reg_imm_prefix_ok:
  827.         and     ah,111b
  828.         add     al,ah
  829.         mov     [base_code],al
  830.         call    store_instruction_code
  831.         ret
  832.       mov_reg_64bit_imm_32bit:
  833.         mov     edx,eax
  834.         mov     bl,[postbyte_register]
  835.         mov     [postbyte_register],0
  836.         mov     [base_code],0C7h
  837.         call    store_nomem_instruction
  838.         jmp     mov_store_imm_32bit
  839.       mov_sreg:
  840.         mov     ah,al
  841.         and     al,1111b
  842.         mov     [postbyte_register],al
  843.         shr     ah,4
  844.         cmp     ah,5
  845.         je      mov_creg
  846.         cmp     ah,7
  847.         je      mov_dreg
  848.         ja      mov_treg
  849.         cmp     al,2
  850.         je      illegal_instruction
  851.         dec     [postbyte_register]
  852.         lods    byte [esi]
  853.         cmp     al,','
  854.         jne     invalid_operand
  855.         lods    byte [esi]
  856.         call    get_size_operator
  857.         cmp     al,'['
  858.         je      mov_sreg_mem
  859.         cmp     al,10h
  860.         jne     invalid_operand
  861.       mov_sreg_reg:
  862.         lods    byte [esi]
  863.         call    convert_register
  864.         or      ah,ah
  865.         jz      mov_sreg_reg_size_ok
  866.         cmp     ah,2
  867.         jne     invalid_operand_size
  868.         mov     bl,al
  869.       mov_sreg_reg_size_ok:
  870.         mov     [base_code],8Eh
  871.         jmp     nomem_instruction_ready
  872.       mov_sreg_mem:
  873.         call    get_address
  874.         mov     al,[operand_size]
  875.         or      al,al
  876.         jz      mov_sreg_mem_size_ok
  877.         cmp     al,2
  878.         jne     invalid_operand_size
  879.       mov_sreg_mem_size_ok:
  880.         mov     [base_code],8Eh
  881.         jmp     instruction_ready
  882.       mov_treg:
  883.         cmp     ah,9
  884.         jne     invalid_operand
  885.         mov     [extended_code],26h
  886.         jmp     mov_xrx
  887.       mov_dreg:
  888.         mov     [extended_code],23h
  889.         jmp     mov_xrx
  890.       mov_creg:
  891.         mov     [extended_code],22h
  892.       mov_xrx:
  893.         mov     [base_code],0Fh
  894.         lods    byte [esi]
  895.         cmp     al,','
  896.         jne     invalid_operand
  897.         lods    byte [esi]
  898.         cmp     al,10h
  899.         jne     invalid_operand
  900.         lods    byte [esi]
  901.         call    convert_register
  902.         mov     bl,al
  903.         cmp     [code_type],64
  904.         je      mov_xrx_64bit
  905.         cmp     ah,4
  906.         jne     invalid_operand_size
  907.         cmp     [postbyte_register],8
  908.         jne     mov_xrx_store
  909.         cmp     [extended_code],22h
  910.         jne     mov_xrx_store
  911.         mov     al,0F0h
  912.         stos    byte [edi]
  913.         mov     [postbyte_register],0
  914.       mov_xrx_store:
  915.         jmp     nomem_instruction_ready
  916.       mov_xrx_64bit:
  917.         cmp     ah,8
  918.         je      mov_xrx_store
  919.         jmp     invalid_operand_size
  920. cmov_instruction:
  921.         mov     [base_code],0Fh
  922.         mov     [extended_code],al
  923.         lods    byte [esi]
  924.         call    get_size_operator
  925.         cmp     al,10h
  926.         jne     invalid_operand
  927.         lods    byte [esi]
  928.         call    convert_register
  929.         mov     [postbyte_register],al
  930.         lods    byte [esi]
  931.         cmp     al,','
  932.         jne     invalid_operand
  933.         lods    byte [esi]
  934.         call    get_size_operator
  935.         cmp     al,'['
  936.         je      cmov_reg_mem
  937.         cmp     al,10h
  938.         jne     invalid_operand
  939.       cmov_reg_reg:
  940.         lods    byte [esi]
  941.         call    convert_register
  942.         mov     bl,al
  943.         mov     al,ah
  944.         call    operand_autodetect
  945.         jmp     nomem_instruction_ready
  946.       cmov_reg_mem:
  947.         call    get_address
  948.         mov     al,[operand_size]
  949.         call    operand_autodetect
  950.         jmp     instruction_ready
  951. test_instruction:
  952.         mov     [base_code],84h
  953.         lods    byte [esi]
  954.         call    get_size_operator
  955.         cmp     al,10h
  956.         je      test_reg
  957.         cmp     al,'['
  958.         jne     invalid_operand
  959.       test_mem:
  960.         call    get_address
  961.         push    edx ebx ecx
  962.         lods    byte [esi]
  963.         cmp     al,','
  964.         jne     invalid_operand
  965.         lods    byte [esi]
  966.         call    get_size_operator
  967.         cmp     al,'('
  968.         je      test_mem_imm
  969.         cmp     al,10h
  970.         jne     invalid_operand
  971.       test_mem_reg:
  972.         lods    byte [esi]
  973.         call    convert_register
  974.         mov     [postbyte_register],al
  975.         pop     ecx ebx edx
  976.         mov     al,ah
  977.         cmp     al,1
  978.         je      test_mem_reg_8bit
  979.         call    operand_autodetect
  980.         inc     [base_code]
  981.       test_mem_reg_8bit:
  982.         jmp     instruction_ready
  983.       test_mem_imm:
  984.         mov     al,[operand_size]
  985.         cmp     al,1
  986.         jb      test_mem_imm_nosize
  987.         je      test_mem_imm_8bit
  988.         cmp     al,2
  989.         je      test_mem_imm_16bit
  990.         cmp     al,4
  991.         je      test_mem_imm_32bit
  992.         cmp     al,8
  993.         jne     invalid_operand_size
  994.       test_mem_imm_64bit:
  995.         cmp     [size_declared],0
  996.         jne     long_immediate_not_encodable
  997.         call    operand_64bit
  998.         call    get_simm32
  999.         cmp     [value_type],4
  1000.         jae     long_immediate_not_encodable
  1001.         jmp     test_mem_imm_32bit_store
  1002.       test_mem_imm_8bit:
  1003.         call    get_byte_value
  1004.         mov     byte [value],al
  1005.         mov     [postbyte_register],0
  1006.         mov     [base_code],0F6h
  1007.         pop     ecx ebx edx
  1008.         call    store_instruction_with_imm8
  1009.         jmp     instruction_assembled
  1010.       test_mem_imm_16bit:
  1011.         call    operand_16bit
  1012.         call    get_word_value
  1013.         mov     word [value],ax
  1014.         mov     [postbyte_register],0
  1015.         mov     [base_code],0F7h
  1016.         pop     ecx ebx edx
  1017.         call    store_instruction_with_imm16
  1018.         jmp     instruction_assembled
  1019.       test_mem_imm_nosize:
  1020.         cmp     [error_line],0
  1021.         jne     test_mem_imm_32bit
  1022.         mov     eax,[current_line]
  1023.         mov     [error_line],eax
  1024.         mov     [error],operand_size_not_specified
  1025.       test_mem_imm_32bit:
  1026.         call    operand_32bit
  1027.         call    get_dword_value
  1028.       test_mem_imm_32bit_store:
  1029.         mov     dword [value],eax
  1030.         mov     [postbyte_register],0
  1031.         mov     [base_code],0F7h
  1032.         pop     ecx ebx edx
  1033.         call    store_instruction_with_imm32
  1034.         jmp     instruction_assembled
  1035.       test_reg:
  1036.         lods    byte [esi]
  1037.         call    convert_register
  1038.         mov     [postbyte_register],al
  1039.         lods    byte [esi]
  1040.         cmp     al,','
  1041.         jne     invalid_operand
  1042.         lods    byte [esi]
  1043.         call    get_size_operator
  1044.         cmp     al,'['
  1045.         je      test_reg_mem
  1046.         cmp     al,'('
  1047.         je      test_reg_imm
  1048.         cmp     al,10h
  1049.         jne     invalid_operand
  1050.       test_reg_reg:
  1051.         lods    byte [esi]
  1052.         call    convert_register
  1053.         mov     bl,[postbyte_register]
  1054.         mov     [postbyte_register],al
  1055.         mov     al,ah
  1056.         cmp     al,1
  1057.         je      test_reg_reg_8bit
  1058.         call    operand_autodetect
  1059.         inc     [base_code]
  1060.       test_reg_reg_8bit:
  1061.         jmp     nomem_instruction_ready
  1062.       test_reg_imm:
  1063.         mov     al,[operand_size]
  1064.         cmp     al,1
  1065.         je      test_reg_imm_8bit
  1066.         cmp     al,2
  1067.         je      test_reg_imm_16bit
  1068.         cmp     al,4
  1069.         je      test_reg_imm_32bit
  1070.         cmp     al,8
  1071.         jne     invalid_operand_size
  1072.       test_reg_imm_64bit:
  1073.         cmp     [size_declared],0
  1074.         jne     long_immediate_not_encodable
  1075.         call    operand_64bit
  1076.         call    get_simm32
  1077.         cmp     [value_type],4
  1078.         jae     long_immediate_not_encodable
  1079.         jmp     test_reg_imm_32bit_store
  1080.       test_reg_imm_8bit:
  1081.         call    get_byte_value
  1082.         mov     dl,al
  1083.         mov     bl,[postbyte_register]
  1084.         mov     [postbyte_register],0
  1085.         mov     [base_code],0F6h
  1086.         or      bl,bl
  1087.         jz      test_al_imm
  1088.         call    store_nomem_instruction
  1089.         mov     al,dl
  1090.         stos    byte [edi]
  1091.         jmp     instruction_assembled
  1092.       test_al_imm:
  1093.         mov     [base_code],0A8h
  1094.         call    store_instruction_code
  1095.         mov     al,dl
  1096.         stos    byte [edi]
  1097.         jmp     instruction_assembled
  1098.       test_reg_imm_16bit:
  1099.         call    operand_16bit
  1100.         call    get_word_value
  1101.         mov     dx,ax
  1102.         mov     bl,[postbyte_register]
  1103.         mov     [postbyte_register],0
  1104.         mov     [base_code],0F7h
  1105.         or      bl,bl
  1106.         jz      test_ax_imm
  1107.         call    store_nomem_instruction
  1108.         mov     ax,dx
  1109.         call    mark_relocation
  1110.         stos    word [edi]
  1111.         jmp     instruction_assembled
  1112.       test_ax_imm:
  1113.         mov     [base_code],0A9h
  1114.         call    store_instruction_code
  1115.         mov     ax,dx
  1116.         stos    word [edi]
  1117.         jmp     instruction_assembled
  1118.       test_reg_imm_32bit:
  1119.         call    operand_32bit
  1120.         call    get_dword_value
  1121.       test_reg_imm_32bit_store:
  1122.         mov     edx,eax
  1123.         mov     bl,[postbyte_register]
  1124.         mov     [postbyte_register],0
  1125.         mov     [base_code],0F7h
  1126.         or      bl,bl
  1127.         jz      test_eax_imm
  1128.         call    store_nomem_instruction
  1129.         mov     eax,edx
  1130.         call    mark_relocation
  1131.         stos    dword [edi]
  1132.         jmp     instruction_assembled
  1133.       test_eax_imm:
  1134.         mov     [base_code],0A9h
  1135.         call    store_instruction_code
  1136.         mov     eax,edx
  1137.         stos    dword [edi]
  1138.         jmp     instruction_assembled
  1139.       test_reg_mem:
  1140.         call    get_address
  1141.         mov     al,[operand_size]
  1142.         cmp     al,1
  1143.         je      test_reg_mem_8bit
  1144.         call    operand_autodetect
  1145.         inc     [base_code]
  1146.       test_reg_mem_8bit:
  1147.         jmp     instruction_ready
  1148. xchg_instruction:
  1149.         mov     [base_code],86h
  1150.         lods    byte [esi]
  1151.         call    get_size_operator
  1152.         cmp     al,10h
  1153.         je      xchg_reg
  1154.         cmp     al,'['
  1155.         jne     invalid_operand
  1156.       xchg_mem:
  1157.         call    get_address
  1158.         push    edx ebx ecx
  1159.         lods    byte [esi]
  1160.         cmp     al,','
  1161.         jne     invalid_operand
  1162.         lods    byte [esi]
  1163.         call    get_size_operator
  1164.         cmp     al,10h
  1165.         je      test_mem_reg
  1166.         jmp     invalid_operand
  1167.       xchg_reg:
  1168.         lods    byte [esi]
  1169.         call    convert_register
  1170.         mov     [postbyte_register],al
  1171.         lods    byte [esi]
  1172.         cmp     al,','
  1173.         jne     invalid_operand
  1174.         lods    byte [esi]
  1175.         call    get_size_operator
  1176.         cmp     al,'['
  1177.         je      test_reg_mem
  1178.         cmp     al,10h
  1179.         jne     invalid_operand
  1180.       xchg_reg_reg:
  1181.         lods    byte [esi]
  1182.         call    convert_register
  1183.         mov     bl,al
  1184.         mov     al,ah
  1185.         cmp     al,1
  1186.         je      xchg_reg_reg_8bit
  1187.         call    operand_autodetect
  1188.         cmp     [postbyte_register],0
  1189.         je      xchg_ax_reg
  1190.         or      bl,bl
  1191.         jnz     xchg_reg_reg_store
  1192.         mov     bl,[postbyte_register]
  1193.       xchg_ax_reg:
  1194.         cmp     [code_type],64
  1195.         jne     xchg_ax_reg_ok
  1196.         cmp     ah,4
  1197.         jne     xchg_ax_reg_ok
  1198.         or      bl,bl
  1199.         jz      xchg_reg_reg_store
  1200.       xchg_ax_reg_ok:
  1201.         test    bl,1000b
  1202.         jz      xchg_ax_reg_store
  1203.         or      [rex_prefix],41h
  1204.         and     bl,111b
  1205.       xchg_ax_reg_store:
  1206.         add     bl,90h
  1207.         mov     [base_code],bl
  1208.         call    store_instruction_code
  1209.         jmp     instruction_assembled
  1210.       xchg_reg_reg_store:
  1211.         inc     [base_code]
  1212.       xchg_reg_reg_8bit:
  1213.         jmp     nomem_instruction_ready
  1214. push_instruction:
  1215.         mov     [push_size],al
  1216.       push_next:
  1217.         lods    byte [esi]
  1218.         call    get_size_operator
  1219.         cmp     al,10h
  1220.         je      push_reg
  1221.         cmp     al,'('
  1222.         je      push_imm
  1223.         cmp     al,'['
  1224.         jne     invalid_operand
  1225.       push_mem:
  1226.         call    get_address
  1227.         mov     al,[operand_size]
  1228.         mov     ah,[push_size]
  1229.         cmp     al,2
  1230.         je      push_mem_16bit
  1231.         cmp     al,4
  1232.         je      push_mem_32bit
  1233.         cmp     al,8
  1234.         je      push_mem_64bit
  1235.         or      al,al
  1236.         jnz     invalid_operand_size
  1237.         cmp     ah,2
  1238.         je      push_mem_16bit
  1239.         cmp     ah,4
  1240.         je      push_mem_32bit
  1241.         cmp     ah,8
  1242.         je      push_mem_64bit
  1243.         cmp     [error_line],0
  1244.         jne     push_mem_store
  1245.         mov     eax,[current_line]
  1246.         mov     [error_line],eax
  1247.         mov     [error],operand_size_not_specified
  1248.         jmp     push_mem_store
  1249.       push_mem_16bit:
  1250.         test    ah,not 2
  1251.         jnz     invalid_operand_size
  1252.         call    operand_16bit
  1253.         jmp     push_mem_store
  1254.       push_mem_32bit:
  1255.         test    ah,not 4
  1256.         jnz     invalid_operand_size
  1257.         cmp     [code_type],64
  1258.         je      illegal_instruction
  1259.         call    operand_32bit
  1260.         jmp     push_mem_store
  1261.       push_mem_64bit:
  1262.         test    ah,not 8
  1263.         jnz     invalid_operand_size
  1264.         cmp     [code_type],64
  1265.         jne     illegal_instruction
  1266.       push_mem_store:
  1267.         mov     [base_code],0FFh
  1268.         mov     [postbyte_register],110b
  1269.         call    store_instruction
  1270.         jmp     push_done
  1271.       push_reg:
  1272.         lods    byte [esi]
  1273.         mov     ah,al
  1274.         sub     ah,10h
  1275.         and     ah,al
  1276.         test    ah,0F0h
  1277.         jnz     push_sreg
  1278.         call    convert_register
  1279.         test    al,1000b
  1280.         jz      push_reg_ok
  1281.         or      [rex_prefix],41h
  1282.         and     al,111b
  1283.       push_reg_ok:
  1284.         add     al,50h
  1285.         mov     [base_code],al
  1286.         mov     al,ah
  1287.         mov     ah,[push_size]
  1288.         cmp     al,2
  1289.         je      push_reg_16bit
  1290.         cmp     al,4
  1291.         je      push_reg_32bit
  1292.         cmp     al,8
  1293.         jne     invalid_operand_size
  1294.       push_reg_64bit:
  1295.         test    ah,not 8
  1296.         jnz     invalid_operand_size
  1297.         cmp     [code_type],64
  1298.         jne     illegal_instruction
  1299.         jmp     push_reg_store
  1300.       push_reg_32bit:
  1301.         test    ah,not 4
  1302.         jnz     invalid_operand_size
  1303.         cmp     [code_type],64
  1304.         je      illegal_instruction
  1305.         call    operand_32bit
  1306.         jmp     push_reg_store
  1307.       push_reg_16bit:
  1308.         test    ah,not 2
  1309.         jnz     invalid_operand_size
  1310.         call    operand_16bit
  1311.       push_reg_store:
  1312.         call    store_instruction_code
  1313.         jmp     push_done
  1314.       push_sreg:
  1315.         mov     bl,al
  1316.         mov     dl,[operand_size]
  1317.         mov     dh,[push_size]
  1318.         cmp     dl,2
  1319.         je      push_sreg16
  1320.         cmp     dl,4
  1321.         je      push_sreg32
  1322.         cmp     dl,8
  1323.         je      push_sreg64
  1324.         or      dl,dl
  1325.         jnz     invalid_operand_size
  1326.         cmp     dh,2
  1327.         je      push_sreg16
  1328.         cmp     dh,4
  1329.         je      push_sreg32
  1330.         cmp     dh,8
  1331.         je      push_sreg64
  1332.         jmp     push_sreg_store
  1333.       push_sreg16:
  1334.         test    dh,not 2
  1335.         jnz     invalid_operand_size
  1336.         call    operand_16bit
  1337.         jmp     push_sreg_store
  1338.       push_sreg32:
  1339.         test    dh,not 4
  1340.         jnz     invalid_operand_size
  1341.         cmp     [code_type],64
  1342.         je      illegal_instruction
  1343.         call    operand_32bit
  1344.         jmp     push_sreg_store
  1345.       push_sreg64:
  1346.         test    dh,not 8
  1347.         jnz     invalid_operand_size
  1348.         cmp     [code_type],64
  1349.         jne     illegal_instruction
  1350.       push_sreg_store:
  1351.         mov     al,bl
  1352.         cmp     al,70h
  1353.         jae     invalid_operand
  1354.         sub     al,61h
  1355.         jc      invalid_operand
  1356.         cmp     al,4
  1357.         jae     push_sreg_386
  1358.         shl     al,3
  1359.         add     al,6
  1360.         mov     [base_code],al
  1361.         cmp     [code_type],64
  1362.         je      illegal_instruction
  1363.         jmp     push_reg_store
  1364.       push_sreg_386:
  1365.         sub     al,4
  1366.         shl     al,3
  1367.         add     al,0A0h
  1368.         mov     [extended_code],al
  1369.         mov     [base_code],0Fh
  1370.         jmp     push_reg_store
  1371.       push_imm:
  1372.         mov     al,[operand_size]
  1373.         mov     ah,[push_size]
  1374.         or      al,al
  1375.         je      push_imm_size_ok
  1376.         or      ah,ah
  1377.         je      push_imm_size_ok
  1378.         cmp     al,ah
  1379.         jne     invalid_operand_size
  1380.       push_imm_size_ok:
  1381.         cmp     al,2
  1382.         je      push_imm_16bit
  1383.         cmp     al,4
  1384.         je      push_imm_32bit
  1385.         cmp     al,8
  1386.         je      push_imm_64bit
  1387.         cmp     ah,2
  1388.         je      push_imm_optimized_16bit
  1389.         cmp     ah,4
  1390.         je      push_imm_optimized_32bit
  1391.         cmp     ah,8
  1392.         je      push_imm_optimized_64bit
  1393.         or      al,al
  1394.         jnz     invalid_operand_size
  1395.         cmp     [code_type],16
  1396.         je      push_imm_optimized_16bit
  1397.         cmp     [code_type],32
  1398.         je      push_imm_optimized_32bit
  1399.       push_imm_optimized_64bit:
  1400.         cmp     [code_type],64
  1401.         jne     illegal_instruction
  1402.         call    get_simm32
  1403.         mov     edx,eax
  1404.         cmp     [value_type],0
  1405.         jne     push_imm_32bit_store
  1406.         cmp     eax,-80h
  1407.         jl      push_imm_32bit_store
  1408.         cmp     eax,80h
  1409.         jge     push_imm_32bit_store
  1410.         jmp     push_imm_8bit
  1411.       push_imm_optimized_32bit:
  1412.         cmp     [code_type],64
  1413.         je      illegal_instruction
  1414.         call    get_dword_value
  1415.         mov     edx,eax
  1416.         call    operand_32bit
  1417.         cmp     [value_type],0
  1418.         jne     push_imm_32bit_store
  1419.         cmp     eax,-80h
  1420.         jl      push_imm_32bit_store
  1421.         cmp     eax,80h
  1422.         jge     push_imm_32bit_store
  1423.         jmp     push_imm_8bit
  1424.       push_imm_optimized_16bit:
  1425.         call    get_word_value
  1426.         mov     dx,ax
  1427.         call    operand_16bit
  1428.         cmp     [value_type],0
  1429.         jne     push_imm_16bit_store
  1430.         cmp     ax,-80h
  1431.         jl      push_imm_16bit_store
  1432.         cmp     ax,80h
  1433.         jge     push_imm_16bit_store
  1434.       push_imm_8bit:
  1435.         mov     ah,al
  1436.         mov     [base_code],6Ah
  1437.         call    store_instruction_code
  1438.         mov     al,ah
  1439.         stos    byte [edi]
  1440.         jmp     push_done
  1441.       push_imm_16bit:
  1442.         call    get_word_value
  1443.         mov     dx,ax
  1444.         call    operand_16bit
  1445.       push_imm_16bit_store:
  1446.         mov     [base_code],68h
  1447.         call    store_instruction_code
  1448.         mov     ax,dx
  1449.         call    mark_relocation
  1450.         stos    word [edi]
  1451.         jmp     push_done
  1452.       push_imm_64bit:
  1453.         cmp     [code_type],64
  1454.         jne     illegal_instruction
  1455.         call    get_simm32
  1456.         mov     edx,eax
  1457.         jmp     push_imm_32bit_store
  1458.       push_imm_32bit:
  1459.         cmp     [code_type],64
  1460.         je      illegal_instruction
  1461.         call    get_dword_value
  1462.         mov     edx,eax
  1463.         call    operand_32bit
  1464.       push_imm_32bit_store:
  1465.         mov     [base_code],68h
  1466.         call    store_instruction_code
  1467.         mov     eax,edx
  1468.         call    mark_relocation
  1469.         stos    dword [edi]
  1470.       push_done:
  1471.         lods    byte [esi]
  1472.         dec     esi
  1473.         cmp     al,0Fh
  1474.         je      instruction_assembled
  1475.         or      al,al
  1476.         jz      instruction_assembled
  1477.         mov     [operand_size],0
  1478.         mov     [size_override],0
  1479.         mov     [operand_prefix],0
  1480.         mov     [rex_prefix],0
  1481.         jmp     push_next
  1482. pop_instruction:
  1483.         mov     [push_size],al
  1484.       pop_next:
  1485.         lods    byte [esi]
  1486.         call    get_size_operator
  1487.         cmp     al,10h
  1488.         je      pop_reg
  1489.         cmp     al,'['
  1490.         jne     invalid_operand
  1491.       pop_mem:
  1492.         call    get_address
  1493.         mov     al,[operand_size]
  1494.         mov     ah,[push_size]
  1495.         cmp     al,2
  1496.         je      pop_mem_16bit
  1497.         cmp     al,4
  1498.         je      pop_mem_32bit
  1499.         cmp     al,8
  1500.         je      pop_mem_64bit
  1501.         or      al,al
  1502.         jnz     invalid_operand_size
  1503.         cmp     ah,2
  1504.         je      pop_mem_16bit
  1505.         cmp     ah,4
  1506.         je      pop_mem_32bit
  1507.         cmp     ah,8
  1508.         je      pop_mem_64bit
  1509.         cmp     [error_line],0
  1510.         jne     pop_mem_store
  1511.         mov     eax,[current_line]
  1512.         mov     [error_line],eax
  1513.         mov     [error],operand_size_not_specified
  1514.         jmp     pop_mem_store
  1515.       pop_mem_16bit:
  1516.         test    ah,not 2
  1517.         jnz     invalid_operand_size
  1518.         call    operand_16bit
  1519.         jmp     pop_mem_store
  1520.       pop_mem_32bit:
  1521.         test    ah,not 4
  1522.         jnz     invalid_operand_size
  1523.         cmp     [code_type],64
  1524.         je      illegal_instruction
  1525.         call    operand_32bit
  1526.         jmp     pop_mem_store
  1527.       pop_mem_64bit:
  1528.         test    ah,not 8
  1529.         jnz     invalid_operand_size
  1530.         cmp     [code_type],64
  1531.         jne     illegal_instruction
  1532.       pop_mem_store:
  1533.         mov     [base_code],08Fh
  1534.         mov     [postbyte_register],0
  1535.         call    store_instruction
  1536.         jmp     pop_done
  1537.       pop_reg:
  1538.         lods    byte [esi]
  1539.         mov     ah,al
  1540.         sub     ah,10h
  1541.         and     ah,al
  1542.         test    ah,0F0h
  1543.         jnz     pop_sreg
  1544.         call    convert_register
  1545.         test    al,1000b
  1546.         jz      pop_reg_ok
  1547.         or      [rex_prefix],41h
  1548.         and     al,111b
  1549.       pop_reg_ok:
  1550.         add     al,58h
  1551.         mov     [base_code],al
  1552.         mov     al,ah
  1553.         mov     ah,[push_size]
  1554.         cmp     al,2
  1555.         je      pop_reg_16bit
  1556.         cmp     al,4
  1557.         je      pop_reg_32bit
  1558.         cmp     al,8
  1559.         je      pop_reg_64bit
  1560.         jmp     invalid_operand_size
  1561.       pop_reg_64bit:
  1562.         test    ah,not 8
  1563.         jnz     invalid_operand_size
  1564.         cmp     [code_type],64
  1565.         jne     illegal_instruction
  1566.         jmp     pop_reg_store
  1567.       pop_reg_32bit:
  1568.         test    ah,not 4
  1569.         jnz     invalid_operand_size
  1570.         cmp     [code_type],64
  1571.         je      illegal_instruction
  1572.         call    operand_32bit
  1573.         jmp     pop_reg_store
  1574.       pop_reg_16bit:
  1575.         test    ah,not 2
  1576.         jnz     invalid_operand_size
  1577.         call    operand_16bit
  1578.       pop_reg_store:
  1579.         call    store_instruction_code
  1580.       pop_done:
  1581.         lods    byte [esi]
  1582.         dec     esi
  1583.         cmp     al,0Fh
  1584.         je      instruction_assembled
  1585.         or      al,al
  1586.         jz      instruction_assembled
  1587.         mov     [operand_size],0
  1588.         mov     [size_override],0
  1589.         mov     [operand_prefix],0
  1590.         mov     [rex_prefix],0
  1591.         jmp     pop_next
  1592.       pop_sreg:
  1593.         mov     dl,[operand_size]
  1594.         mov     dh,[push_size]
  1595.         cmp     al,62h
  1596.         je      pop_cs
  1597.         mov     bl,al
  1598.         cmp     dl,2
  1599.         je      pop_sreg16
  1600.         cmp     dl,4
  1601.         je      pop_sreg32
  1602.         cmp     dl,8
  1603.         je      pop_sreg64
  1604.         or      dl,dl
  1605.         jnz     invalid_operand_size
  1606.         cmp     dh,2
  1607.         je      pop_sreg16
  1608.         cmp     dh,4
  1609.         je      pop_sreg32
  1610.         cmp     dh,8
  1611.         je      pop_sreg64
  1612.         jmp     pop_sreg_store
  1613.       pop_sreg16:
  1614.         test    dh,not 2
  1615.         jnz     invalid_operand_size
  1616.         call    operand_16bit
  1617.         jmp     pop_sreg_store
  1618.       pop_sreg32:
  1619.         test    dh,not 4
  1620.         jnz     invalid_operand_size
  1621.         cmp     [code_type],64
  1622.         je      illegal_instruction
  1623.         call    operand_32bit
  1624.         jmp     pop_sreg_store
  1625.       pop_sreg64:
  1626.         test    dh,not 8
  1627.         jnz     invalid_operand_size
  1628.         cmp     [code_type],64
  1629.         jne     illegal_instruction
  1630.       pop_sreg_store:
  1631.         mov     al,bl
  1632.         cmp     al,70h
  1633.         jae     invalid_operand
  1634.         sub     al,61h
  1635.         jc      invalid_operand
  1636.         cmp     al,4
  1637.         jae     pop_sreg_386
  1638.         shl     al,3
  1639.         add     al,7
  1640.         mov     [base_code],al
  1641.         cmp     [code_type],64
  1642.         je      illegal_instruction
  1643.         jmp     pop_reg_store
  1644.       pop_cs:
  1645.         cmp     [code_type],16
  1646.         jne     illegal_instruction
  1647.         cmp     dl,2
  1648.         je      pop_cs_store
  1649.         or      dl,dl
  1650.         jnz     invalid_operand_size
  1651.         cmp     dh,2
  1652.         je      pop_cs_store
  1653.         or      dh,dh
  1654.         jnz     illegal_instruction
  1655.       pop_cs_store:
  1656.         test    dh,not 2
  1657.         jnz     invalid_operand_size
  1658.         mov     al,0Fh
  1659.         stos    byte [edi]
  1660.         jmp     pop_done
  1661.       pop_sreg_386:
  1662.         sub     al,4
  1663.         shl     al,3
  1664.         add     al,0A1h
  1665.         mov     [extended_code],al
  1666.         mov     [base_code],0Fh
  1667.         jmp     pop_reg_store
  1668. inc_instruction:
  1669.         mov     [base_code],al
  1670.         lods    byte [esi]
  1671.         call    get_size_operator
  1672.         cmp     al,10h
  1673.         je      inc_reg
  1674.         cmp     al,'['
  1675.         je      inc_mem
  1676.         jne     invalid_operand
  1677.       inc_mem:
  1678.         call    get_address
  1679.         mov     al,[operand_size]
  1680.         cmp     al,1
  1681.         je      inc_mem_8bit
  1682.         jb      inc_mem_nosize
  1683.         call    operand_autodetect
  1684.         mov     al,0FFh
  1685.         xchg    al,[base_code]
  1686.         mov     [postbyte_register],al
  1687.         jmp     instruction_ready
  1688.       inc_mem_nosize:
  1689.         cmp     [error_line],0
  1690.         jne     inc_mem_8bit
  1691.         mov     eax,[current_line]
  1692.         mov     [error_line],eax
  1693.         mov     [error],operand_size_not_specified
  1694.       inc_mem_8bit:
  1695.         mov     al,0FEh
  1696.         xchg    al,[base_code]
  1697.         mov     [postbyte_register],al
  1698.         jmp     instruction_ready
  1699.       inc_reg:
  1700.         lods    byte [esi]
  1701.         call    convert_register
  1702.         mov     bl,al
  1703.         mov     al,0FEh
  1704.         xchg    al,[base_code]
  1705.         mov     [postbyte_register],al
  1706.         mov     al,ah
  1707.         cmp     al,1
  1708.         je      inc_reg_8bit
  1709.         call    operand_autodetect
  1710.         cmp     [code_type],64
  1711.         je      inc_reg_long_form
  1712.         mov     al,[postbyte_register]
  1713.         shl     al,3
  1714.         add     al,bl
  1715.         add     al,40h
  1716.         mov     [base_code],al
  1717.         call    store_instruction_code
  1718.         jmp     instruction_assembled
  1719.       inc_reg_long_form:
  1720.         inc     [base_code]
  1721.       inc_reg_8bit:
  1722.         jmp     nomem_instruction_ready
  1723. set_instruction:
  1724.         mov     [base_code],0Fh
  1725.         mov     [extended_code],al
  1726.         lods    byte [esi]
  1727.         call    get_size_operator
  1728.         cmp     al,10h
  1729.         je      set_reg
  1730.         cmp     al,'['
  1731.         jne     invalid_operand
  1732.       set_mem:
  1733.         call    get_address
  1734.         cmp     [operand_size],1
  1735.         ja      invalid_operand_size
  1736.         mov     [postbyte_register],0
  1737.         jmp     instruction_ready
  1738.       set_reg:
  1739.         lods    byte [esi]
  1740.         call    convert_register
  1741.         cmp     ah,1
  1742.         jne     invalid_operand_size
  1743.         mov     bl,al
  1744.         mov     [postbyte_register],0
  1745.         jmp     nomem_instruction_ready
  1746. arpl_instruction:
  1747.         cmp     [code_type],64
  1748.         je      illegal_instruction
  1749.         mov     [base_code],63h
  1750.         lods    byte [esi]
  1751.         call    get_size_operator
  1752.         cmp     al,10h
  1753.         je      arpl_reg
  1754.         cmp     al,'['
  1755.         jne     invalid_operand
  1756.         call    get_address
  1757.         lods    byte [esi]
  1758.         cmp     al,','
  1759.         jne     invalid_operand
  1760.         lods    byte [esi]
  1761.         cmp     al,10h
  1762.         jne     invalid_operand
  1763.         lods    byte [esi]
  1764.         call    convert_register
  1765.         mov     [postbyte_register],al
  1766.         cmp     ah,2
  1767.         jne     invalid_operand_size
  1768.         jmp     instruction_ready
  1769.       arpl_reg:
  1770.         lods    byte [esi]
  1771.         call    convert_register
  1772.         cmp     ah,2
  1773.         jne     invalid_operand_size
  1774.         mov     bl,al
  1775.         lods    byte [esi]
  1776.         cmp     al,','
  1777.         jne     invalid_operand
  1778.         lods    byte [esi]
  1779.         cmp     al,10h
  1780.         jne     invalid_operand
  1781.         lods    byte [esi]
  1782.         call    convert_register
  1783.         mov     [postbyte_register],al
  1784.         jmp     nomem_instruction_ready
  1785. bound_instruction:
  1786.         cmp     [code_type],64
  1787.         je      illegal_instruction
  1788.         lods    byte [esi]
  1789.         call    get_size_operator
  1790.         cmp     al,10h
  1791.         jne     invalid_operand
  1792.         lods    byte [esi]
  1793.         call    convert_register
  1794.         mov     [postbyte_register],al
  1795.         lods    byte [esi]
  1796.         cmp     al,','
  1797.         jne     invalid_operand
  1798.         lods    byte [esi]
  1799.         call    get_size_operator
  1800.         cmp     al,'['
  1801.         jne     invalid_operand
  1802.         call    get_address
  1803.         mov     al,[operand_size]
  1804.         cmp     al,2
  1805.         je      bound_store
  1806.         cmp     al,4
  1807.         jne     invalid_operand_size
  1808.       bound_store:
  1809.         call    operand_autodetect
  1810.         mov     [base_code],62h
  1811.         jmp     instruction_ready
  1812. enter_instruction:
  1813.         lods    byte [esi]
  1814.         call    get_size_operator
  1815.         cmp     ah,2
  1816.         je      enter_imm16_size_ok
  1817.         or      ah,ah
  1818.         jnz     invalid_operand_size
  1819.       enter_imm16_size_ok:
  1820.         cmp     al,'('
  1821.         jne     invalid_operand
  1822.         call    get_word_value
  1823.         cmp     [next_pass_needed],0
  1824.         jne     enter_imm16_ok
  1825.         cmp     [value_type],0
  1826.         jne     invalid_use_of_symbol
  1827.       enter_imm16_ok:
  1828.         push    eax
  1829.         mov     [operand_size],0
  1830.         lods    byte [esi]
  1831.         cmp     al,','
  1832.         jne     invalid_operand
  1833.         lods    byte [esi]
  1834.         call    get_size_operator
  1835.         cmp     ah,1
  1836.         je      enter_imm8_size_ok
  1837.         or      ah,ah
  1838.         jnz     invalid_operand_size
  1839.       enter_imm8_size_ok:
  1840.         cmp     al,'('
  1841.         jne     invalid_operand
  1842.         call    get_byte_value
  1843.         mov     dl,al
  1844.         pop     ebx
  1845.         mov     al,0C8h
  1846.         stos    byte [edi]
  1847.         mov     ax,bx
  1848.         stos    word [edi]
  1849.         mov     al,dl
  1850.         stos    byte [edi]
  1851.         jmp     instruction_assembled
  1852. ret_instruction_only64:
  1853.         cmp     [code_type],64
  1854.         jne     illegal_instruction
  1855.         jmp     ret_instruction
  1856. ret_instruction_32bit_except64:
  1857.         cmp     [code_type],64
  1858.         je      illegal_instruction
  1859. ret_instruction_32bit:
  1860.         call    operand_32bit
  1861.         jmp     ret_instruction
  1862. ret_instruction_16bit:
  1863.         call    operand_16bit
  1864.         jmp     ret_instruction
  1865. retf_instruction:
  1866.         cmp     [code_type],64
  1867.         jne     ret_instruction
  1868. ret_instruction_64bit:
  1869.         call    operand_64bit
  1870. ret_instruction:
  1871.         mov     [base_code],al
  1872.         lods    byte [esi]
  1873.         dec     esi
  1874.         or      al,al
  1875.         jz      simple_ret
  1876.         cmp     al,0Fh
  1877.         je      simple_ret
  1878.         lods    byte [esi]
  1879.         call    get_size_operator
  1880.         or      ah,ah
  1881.         jz      ret_imm
  1882.         cmp     ah,2
  1883.         je      ret_imm
  1884.         jmp     invalid_operand_size
  1885.       ret_imm:
  1886.         cmp     al,'('
  1887.         jne     invalid_operand
  1888.         call    get_word_value
  1889.         cmp     [next_pass_needed],0
  1890.         jne     ret_imm_ok
  1891.         cmp     [value_type],0
  1892.         jne     invalid_use_of_symbol
  1893.       ret_imm_ok:
  1894.         cmp     [size_declared],0
  1895.         jne     ret_imm_store
  1896.         or      ax,ax
  1897.         jz      simple_ret
  1898.       ret_imm_store:
  1899.         mov     dx,ax
  1900.         call    store_instruction_code
  1901.         mov     ax,dx
  1902.         stos    word [edi]
  1903.         jmp     instruction_assembled
  1904.       simple_ret:
  1905.         inc     [base_code]
  1906.         call    store_instruction_code
  1907.         jmp     instruction_assembled
  1908. lea_instruction:
  1909.         mov     [base_code],8Dh
  1910.         lods    byte [esi]
  1911.         call    get_size_operator
  1912.         cmp     al,10h
  1913.         jne     invalid_operand
  1914.         lods    byte [esi]
  1915.         call    convert_register
  1916.         mov     [postbyte_register],al
  1917.         lods    byte [esi]
  1918.         cmp     al,','
  1919.         jne     invalid_operand
  1920.         xor     al,al
  1921.         xchg    al,[operand_size]
  1922.         push    eax
  1923.         lods    byte [esi]
  1924.         call    get_size_operator
  1925.         cmp     al,'['
  1926.         jne     invalid_operand
  1927.         mov     [size_override],-1
  1928.         call    get_address
  1929.         pop     eax
  1930.         mov     [operand_size],al
  1931.         call    operand_autodetect
  1932.         jmp     instruction_ready
  1933. ls_instruction:
  1934.         or      al,al
  1935.         jz      les_instruction
  1936.         cmp     al,3
  1937.         jz      lds_instruction
  1938.         add     al,0B0h
  1939.         mov     [extended_code],al
  1940.         mov     [base_code],0Fh
  1941.         jmp     ls_code_ok
  1942.       les_instruction:
  1943.         mov     [base_code],0C4h
  1944.         jmp     ls_short_code
  1945.       lds_instruction:
  1946.         mov     [base_code],0C5h
  1947.       ls_short_code:
  1948.         cmp     [code_type],64
  1949.         je      illegal_instruction
  1950.       ls_code_ok:
  1951.         lods    byte [esi]
  1952.         call    get_size_operator
  1953.         cmp     al,10h
  1954.         jne     invalid_operand
  1955.         lods    byte [esi]
  1956.         call    convert_register
  1957.         mov     [postbyte_register],al
  1958.         lods    byte [esi]
  1959.         cmp     al,','
  1960.         jne     invalid_operand
  1961.         add     [operand_size],2
  1962.         lods    byte [esi]
  1963.         call    get_size_operator
  1964.         cmp     al,'['
  1965.         jne     invalid_operand
  1966.         call    get_address
  1967.         mov     al,[operand_size]
  1968.         cmp     al,4
  1969.         je      ls_16bit
  1970.         cmp     al,6
  1971.         je      ls_32bit
  1972.         cmp     al,10
  1973.         je      ls_64bit
  1974.         jmp     invalid_operand_size
  1975.       ls_16bit:
  1976.         call    operand_16bit
  1977.         jmp     instruction_ready
  1978.       ls_32bit:
  1979.         call    operand_32bit
  1980.         jmp     instruction_ready
  1981.       ls_64bit:
  1982.         call    operand_64bit
  1983.         jmp     instruction_ready
  1984. sh_instruction:
  1985.         mov     [postbyte_register],al
  1986.         lods    byte [esi]
  1987.         call    get_size_operator
  1988.         cmp     al,10h
  1989.         je      sh_reg
  1990.         cmp     al,'['
  1991.         jne     invalid_operand
  1992.       sh_mem:
  1993.         call    get_address
  1994.         push    edx ebx ecx
  1995.         mov     al,[operand_size]
  1996.         push    eax
  1997.         mov     [operand_size],0
  1998.         lods    byte [esi]
  1999.         cmp     al,','
  2000.         jne     invalid_operand
  2001.         lods    byte [esi]
  2002.         call    get_size_operator
  2003.         cmp     al,'('
  2004.         je      sh_mem_imm
  2005.         cmp     al,10h
  2006.         jne     invalid_operand
  2007.       sh_mem_reg:
  2008.         lods    byte [esi]
  2009.         cmp     al,11h
  2010.         jne     invalid_operand
  2011.         pop     eax ecx ebx edx
  2012.         cmp     al,1
  2013.         je      sh_mem_cl_8bit
  2014.         jb      sh_mem_cl_nosize
  2015.         call    operand_autodetect
  2016.         mov     [base_code],0D3h
  2017.         jmp     instruction_ready
  2018.       sh_mem_cl_nosize:
  2019.         cmp     [error_line],0
  2020.         jne     sh_mem_cl_8bit
  2021.         mov     eax,[current_line]
  2022.         mov     [error_line],eax
  2023.         mov     [error],operand_size_not_specified
  2024.       sh_mem_cl_8bit:
  2025.         mov     [base_code],0D2h
  2026.         jmp     instruction_ready
  2027.       sh_mem_imm:
  2028.         mov     al,[operand_size]
  2029.         or      al,al
  2030.         jz      sh_mem_imm_size_ok
  2031.         cmp     al,1
  2032.         jne     invalid_operand_size
  2033.       sh_mem_imm_size_ok:
  2034.         call    get_byte_value
  2035.         mov     byte [value],al
  2036.         pop     eax ecx ebx edx
  2037.         cmp     al,1
  2038.         je      sh_mem_imm_8bit
  2039.         jb      sh_mem_imm_nosize
  2040.         call    operand_autodetect
  2041.         cmp     byte [value],1
  2042.         je      sh_mem_1
  2043.         mov     [base_code],0C1h
  2044.         call    store_instruction_with_imm8
  2045.         jmp     instruction_assembled
  2046.       sh_mem_1:
  2047.         mov     [base_code],0D1h
  2048.         jmp     instruction_ready
  2049.       sh_mem_imm_nosize:
  2050.         cmp     [error_line],0
  2051.         jne     sh_mem_imm_8bit
  2052.         mov     eax,[current_line]
  2053.         mov     [error_line],eax
  2054.         mov     [error],operand_size_not_specified
  2055.       sh_mem_imm_8bit:
  2056.         cmp     byte [value],1
  2057.         je      sh_mem_1_8bit
  2058.         mov     [base_code],0C0h
  2059.         call    store_instruction_with_imm8
  2060.         jmp     instruction_assembled
  2061.       sh_mem_1_8bit:
  2062.         mov     [base_code],0D0h
  2063.         jmp     instruction_ready
  2064.       sh_reg:
  2065.         lods    byte [esi]
  2066.         call    convert_register
  2067.         mov     bx,ax
  2068.         mov     [operand_size],0
  2069.         lods    byte [esi]
  2070.         cmp     al,','
  2071.         jne     invalid_operand
  2072.         lods    byte [esi]
  2073.         call    get_size_operator
  2074.         cmp     al,'('
  2075.         je      sh_reg_imm
  2076.         cmp     al,10h
  2077.         jne     invalid_operand
  2078.       sh_reg_reg:
  2079.         lods    byte [esi]
  2080.         cmp     al,11h
  2081.         jne     invalid_operand
  2082.         mov     al,bh
  2083.         cmp     al,1
  2084.         je      sh_reg_cl_8bit
  2085.         call    operand_autodetect
  2086.         mov     [base_code],0D3h
  2087.         jmp     nomem_instruction_ready
  2088.       sh_reg_cl_8bit:
  2089.         mov     [base_code],0D2h
  2090.         jmp     nomem_instruction_ready
  2091.       sh_reg_imm:
  2092.         mov     al,[operand_size]
  2093.         or      al,al
  2094.         jz      sh_reg_imm_size_ok
  2095.         cmp     al,1
  2096.         jne     invalid_operand_size
  2097.       sh_reg_imm_size_ok:
  2098.         push    ebx
  2099.         call    get_byte_value
  2100.         mov     dl,al
  2101.         pop     ebx
  2102.         mov     al,bh
  2103.         cmp     al,1
  2104.         je      sh_reg_imm_8bit
  2105.         call    operand_autodetect
  2106.         cmp     dl,1
  2107.         je      sh_reg_1
  2108.         mov     [base_code],0C1h
  2109.         call    store_nomem_instruction
  2110.         mov     al,dl
  2111.         stos    byte [edi]
  2112.         jmp     instruction_assembled
  2113.       sh_reg_1:
  2114.         mov     [base_code],0D1h
  2115.         jmp     nomem_instruction_ready
  2116.       sh_reg_imm_8bit:
  2117.         cmp     dl,1
  2118.         je      sh_reg_1_8bit
  2119.         mov     [base_code],0C0h
  2120.         call    store_nomem_instruction
  2121.         mov     al,dl
  2122.         stos    byte [edi]
  2123.         jmp     instruction_assembled
  2124.       sh_reg_1_8bit:
  2125.         mov     [base_code],0D0h
  2126.         jmp     nomem_instruction_ready
  2127. shd_instruction:
  2128.         mov     [base_code],0Fh
  2129.         mov     [extended_code],al
  2130.         lods    byte [esi]
  2131.         call    get_size_operator
  2132.         cmp     al,10h
  2133.         je      shd_reg
  2134.         cmp     al,'['
  2135.         jne     invalid_operand
  2136.       shd_mem:
  2137.         call    get_address
  2138.         push    edx ebx ecx
  2139.         lods    byte [esi]
  2140.         cmp     al,','
  2141.         jne     invalid_operand
  2142.         lods    byte [esi]
  2143.         call    get_size_operator
  2144.         cmp     al,10h
  2145.         jne     invalid_operand
  2146.         lods    byte [esi]
  2147.         call    convert_register
  2148.         mov     [postbyte_register],al
  2149.         lods    byte [esi]
  2150.         cmp     al,','
  2151.         jne     invalid_operand
  2152.         mov     al,ah
  2153.         mov     [operand_size],0
  2154.         push    eax
  2155.         lods    byte [esi]
  2156.         call    get_size_operator
  2157.         cmp     al,'('
  2158.         je      shd_mem_reg_imm
  2159.         cmp     al,10h
  2160.         jne     invalid_operand
  2161.         lods    byte [esi]
  2162.         cmp     al,11h
  2163.         jne     invalid_operand
  2164.         pop     eax ecx ebx edx
  2165.         call    operand_autodetect
  2166.         inc     [extended_code]
  2167.         jmp     instruction_ready
  2168.       shd_mem_reg_imm:
  2169.         mov     al,[operand_size]
  2170.         or      al,al
  2171.         jz      shd_mem_reg_imm_size_ok
  2172.         cmp     al,1
  2173.         jne     invalid_operand_size
  2174.       shd_mem_reg_imm_size_ok:
  2175.         call    get_byte_value
  2176.         mov     byte [value],al
  2177.         pop     eax ecx ebx edx
  2178.         call    operand_autodetect
  2179.         call    store_instruction_with_imm8
  2180.         jmp     instruction_assembled
  2181.       shd_reg:
  2182.         lods    byte [esi]
  2183.         call    convert_register
  2184.         mov     [postbyte_register],al
  2185.         lods    byte [esi]
  2186.         cmp     al,','
  2187.         jne     invalid_operand
  2188.         lods    byte [esi]
  2189.         call    get_size_operator
  2190.         cmp     al,10h
  2191.         jne     invalid_operand
  2192.         lods    byte [esi]
  2193.         call    convert_register
  2194.         mov     bl,[postbyte_register]
  2195.         mov     [postbyte_register],al
  2196.         mov     al,ah
  2197.         push    eax ebx
  2198.         lods    byte [esi]
  2199.         cmp     al,','
  2200.         jne     invalid_operand
  2201.         mov     [operand_size],0
  2202.         lods    byte [esi]
  2203.         call    get_size_operator
  2204.         cmp     al,'('
  2205.         je      shd_reg_reg_imm
  2206.         cmp     al,10h
  2207.         jne     invalid_operand
  2208.         lods    byte [esi]
  2209.         cmp     al,11h
  2210.         jne     invalid_operand
  2211.         pop     ebx eax
  2212.         call    operand_autodetect
  2213.         inc     [extended_code]
  2214.         jmp     nomem_instruction_ready
  2215.       shd_reg_reg_imm:
  2216.         mov     al,[operand_size]
  2217.         or      al,al
  2218.         jz      shd_reg_reg_imm_size_ok
  2219.         cmp     al,1
  2220.         jne     invalid_operand_size
  2221.       shd_reg_reg_imm_size_ok:
  2222.         call    get_byte_value
  2223.         mov     dl,al
  2224.         pop     ebx eax
  2225.         call    operand_autodetect
  2226.         call    store_nomem_instruction
  2227.         mov     al,dl
  2228.         stos    byte [edi]
  2229.         jmp     instruction_assembled
  2230. movx_instruction:
  2231.         mov     [base_code],0Fh
  2232.         mov     [extended_code],al
  2233.         lods    byte [esi]
  2234.         call    get_size_operator
  2235.         cmp     al,10h
  2236.         jne     invalid_operand
  2237.         lods    byte [esi]
  2238.         call    convert_register
  2239.         mov     [postbyte_register],al
  2240.         mov     al,ah
  2241.         push    eax
  2242.         lods    byte [esi]
  2243.         cmp     al,','
  2244.         jne     invalid_operand
  2245.         mov     [operand_size],0
  2246.         lods    byte [esi]
  2247.         call    get_size_operator
  2248.         cmp     al,10h
  2249.         je      movx_reg
  2250.         cmp     al,'['
  2251.         jne     invalid_operand
  2252.         call    get_address
  2253.         pop     eax
  2254.         mov     ah,[operand_size]
  2255.         or      ah,ah
  2256.         jz      movx_unknown_size
  2257.         cmp     ah,al
  2258.         jae     invalid_operand_size
  2259.         cmp     ah,1
  2260.         je      movx_mem_store
  2261.         cmp     ah,2
  2262.         jne     invalid_operand_size
  2263.         inc     [extended_code]
  2264.       movx_mem_store:
  2265.         call    operand_autodetect
  2266.         jmp     instruction_ready
  2267.       movx_unknown_size:
  2268.         cmp     [error_line],0
  2269.         jne     movx_mem_store
  2270.         mov     eax,[current_line]
  2271.         mov     [error_line],eax
  2272.         mov     [error],operand_size_not_specified
  2273.         jmp     movx_mem_store
  2274.       movx_reg:
  2275.         lods    byte [esi]
  2276.         call    convert_register
  2277.         pop     ebx
  2278.         xchg    bl,al
  2279.         cmp     ah,al
  2280.         jae     invalid_operand_size
  2281.         cmp     ah,1
  2282.         je      movx_reg_8bit
  2283.         cmp     ah,2
  2284.         je      movx_reg_16bit
  2285.         jmp     invalid_operand_size
  2286.       movx_reg_8bit:
  2287.         call    operand_autodetect
  2288.         jmp     nomem_instruction_ready
  2289.       movx_reg_16bit:
  2290.         call    operand_autodetect
  2291.         inc     [extended_code]
  2292.         jmp     nomem_instruction_ready
  2293. movsxd_instruction:
  2294.         mov     [base_code],al
  2295.         lods    byte [esi]
  2296.         call    get_size_operator
  2297.         cmp     al,10h
  2298.         jne     invalid_operand
  2299.         lods    byte [esi]
  2300.         call    convert_register
  2301.         mov     [postbyte_register],al
  2302.         cmp     ah,8
  2303.         jne     invalid_operand_size
  2304.         lods    byte [esi]
  2305.         cmp     al,','
  2306.         jne     invalid_operand
  2307.         mov     [operand_size],0
  2308.         lods    byte [esi]
  2309.         call    get_size_operator
  2310.         cmp     al,10h
  2311.         je      movsxd_reg
  2312.         cmp     al,'['
  2313.         jne     invalid_operand
  2314.         call    get_address
  2315.         cmp     [operand_size],4
  2316.         je      movsxd_mem_store
  2317.         cmp     [operand_size],0
  2318.         jne     invalid_operand_size
  2319.       movsxd_mem_store:
  2320.         call    operand_64bit
  2321.         jmp     instruction_ready
  2322.       movsxd_reg:
  2323.         lods    byte [esi]
  2324.         call    convert_register
  2325.         cmp     ah,4
  2326.         jne     invalid_operand_size
  2327.         mov     bl,al
  2328.         call    operand_64bit
  2329.         jmp     nomem_instruction_ready
  2330. bt_instruction:
  2331.         mov     [postbyte_register],al
  2332.         shl     al,3
  2333.         add     al,83h
  2334.         mov     [extended_code],al
  2335.         mov     [base_code],0Fh
  2336.         lods    byte [esi]
  2337.         call    get_size_operator
  2338.         cmp     al,10h
  2339.         je      bt_reg
  2340.         cmp     al,'['
  2341.         jne     invalid_operand
  2342.         call    get_address
  2343.         push    eax ebx ecx
  2344.         lods    byte [esi]
  2345.         cmp     al,','
  2346.         jne     invalid_operand
  2347.         cmp     byte [esi],'('
  2348.         je      bt_mem_imm
  2349.         cmp     byte [esi],11h
  2350.         jne     bt_mem_reg
  2351.         cmp     byte [esi+2],'('
  2352.         je      bt_mem_imm
  2353.       bt_mem_reg:
  2354.         lods    byte [esi]
  2355.         call    get_size_operator
  2356.         cmp     al,10h
  2357.         jne     invalid_operand
  2358.         lods    byte [esi]
  2359.         call    convert_register
  2360.         mov     [postbyte_register],al
  2361.         pop     ecx ebx edx
  2362.         mov     al,ah
  2363.         call    operand_autodetect
  2364.         jmp     instruction_ready
  2365.       bt_mem_imm:
  2366.         xor     al,al
  2367.         xchg    al,[operand_size]
  2368.         push    eax
  2369.         lods    byte [esi]
  2370.         call    get_size_operator
  2371.         cmp     al,'('
  2372.         jne     invalid_operand
  2373.         mov     al,[operand_size]
  2374.         or      al,al
  2375.         jz      bt_mem_imm_size_ok
  2376.         cmp     al,1
  2377.         jne     invalid_operand_size
  2378.       bt_mem_imm_size_ok:
  2379.         call    get_byte_value
  2380.         mov     byte [value],al
  2381.         pop     eax
  2382.         or      al,al
  2383.         jz      bt_mem_imm_nosize
  2384.         call    operand_autodetect
  2385.       bt_mem_imm_store:
  2386.         pop     ecx ebx edx
  2387.         mov     [extended_code],0BAh
  2388.         call    store_instruction_with_imm8
  2389.         jmp     instruction_assembled
  2390.       bt_mem_imm_nosize:
  2391.         cmp     [error_line],0
  2392.         jne     bt_mem_imm_store
  2393.         mov     eax,[current_line]
  2394.         mov     [error_line],eax
  2395.         mov     [error],operand_size_not_specified
  2396.         jmp     bt_mem_imm_store
  2397.       bt_reg:
  2398.         lods    byte [esi]
  2399.         call    convert_register
  2400.         mov     bl,al
  2401.         lods    byte [esi]
  2402.         cmp     al,','
  2403.         jne     invalid_operand
  2404.         cmp     byte [esi],'('
  2405.         je      bt_reg_imm
  2406.         cmp     byte [esi],11h
  2407.         jne     bt_reg_reg
  2408.         cmp     byte [esi+2],'('
  2409.         je      bt_reg_imm
  2410.       bt_reg_reg:
  2411.         lods    byte [esi]
  2412.         call    get_size_operator
  2413.         cmp     al,10h
  2414.         jne     invalid_operand
  2415.         lods    byte [esi]
  2416.         call    convert_register
  2417.         mov     [postbyte_register],al
  2418.         mov     al,ah
  2419.         call    operand_autodetect
  2420.         jmp     nomem_instruction_ready
  2421.       bt_reg_imm:
  2422.         xor     al,al
  2423.         xchg    al,[operand_size]
  2424.         push    eax ebx
  2425.         lods    byte [esi]
  2426.         call    get_size_operator
  2427.         cmp     al,'('
  2428.         jne     invalid_operand
  2429.         mov     al,[operand_size]
  2430.         or      al,al
  2431.         jz      bt_reg_imm_size_ok
  2432.         cmp     al,1
  2433.         jne     invalid_operand_size
  2434.       bt_reg_imm_size_ok:
  2435.         call    get_byte_value
  2436.         mov     byte [value],al
  2437.         pop     ebx eax
  2438.         call    operand_autodetect
  2439.       bt_reg_imm_store:
  2440.         mov     [extended_code],0BAh
  2441.         call    store_nomem_instruction
  2442.         mov     al,byte [value]
  2443.         stos    byte [edi]
  2444.         jmp     instruction_assembled
  2445. bs_instruction:
  2446.         mov     [extended_code],al
  2447.         mov     [base_code],0Fh
  2448.         lods    byte [esi]
  2449.         call    get_size_operator
  2450.         cmp     al,10h
  2451.         jne     invalid_operand
  2452.         lods    byte [esi]
  2453.         call    convert_register
  2454.         mov     [postbyte_register],al
  2455.         lods    byte [esi]
  2456.         cmp     al,','
  2457.         jne     invalid_operand
  2458.         lods    byte [esi]
  2459.         call    get_size_operator
  2460.         cmp     al,10h
  2461.         je      bs_reg_reg
  2462.         cmp     al,'['
  2463.         jne     invalid_argument
  2464.         call    get_address
  2465.         mov     al,[operand_size]
  2466.         call    operand_autodetect
  2467.         jmp     instruction_ready
  2468.       bs_reg_reg:
  2469.         lods    byte [esi]
  2470.         call    convert_register
  2471.         mov     bl,al
  2472.         mov     al,ah
  2473.         call    operand_autodetect
  2474.         jmp     nomem_instruction_ready
  2475. imul_instruction:
  2476.         mov     [base_code],0F6h
  2477.         mov     [postbyte_register],5
  2478.         lods    byte [esi]
  2479.         call    get_size_operator
  2480.         cmp     al,10h
  2481.         je      imul_reg
  2482.         cmp     al,'['
  2483.         jne     invalid_operand
  2484.       imul_mem:
  2485.         call    get_address
  2486.         mov     al,[operand_size]
  2487.         cmp     al,1
  2488.         je      imul_mem_8bit
  2489.         jb      imul_mem_nosize
  2490.         call    operand_autodetect
  2491.         inc     [base_code]
  2492.         jmp     instruction_ready
  2493.       imul_mem_nosize:
  2494.         cmp     [error_line],0
  2495.         jne     imul_mem_8bit
  2496.         mov     eax,[current_line]
  2497.         mov     [error_line],eax
  2498.         mov     [error],operand_size_not_specified
  2499.       imul_mem_8bit:
  2500.         jmp     instruction_ready
  2501.       imul_reg:
  2502.         lods    byte [esi]
  2503.         call    convert_register
  2504.         cmp     byte [esi],','
  2505.         je      imul_reg_
  2506.         mov     bl,al
  2507.         mov     al,ah
  2508.         cmp     al,1
  2509.         je      imul_reg_8bit
  2510.         call    operand_autodetect
  2511.         inc     [base_code]
  2512.       imul_reg_8bit:
  2513.         jmp     nomem_instruction_ready
  2514.       imul_reg_:
  2515.         mov     [postbyte_register],al
  2516.         inc     esi
  2517.         cmp     byte [esi],'('
  2518.         je      imul_reg_imm
  2519.         cmp     byte [esi],11h
  2520.         jne     imul_reg_noimm
  2521.         cmp     byte [esi+2],'('
  2522.         je      imul_reg_imm
  2523.       imul_reg_noimm:
  2524.         lods    byte [esi]
  2525.         call    get_size_operator
  2526.         cmp     al,10h
  2527.         je      imul_reg_reg
  2528.         cmp     al,'['
  2529.         jne     invalid_operand
  2530.       imul_reg_mem:
  2531.         call    get_address
  2532.         push    edx ebx ecx
  2533.         cmp     byte [esi],','
  2534.         je      imul_reg_mem_imm
  2535.         mov     al,[operand_size]
  2536.         call    operand_autodetect
  2537.         pop     ecx ebx edx
  2538.         mov     [base_code],0Fh
  2539.         mov     [extended_code],0AFh
  2540.         jmp     instruction_ready
  2541.       imul_reg_mem_imm:
  2542.         inc     esi
  2543.         lods    byte [esi]
  2544.         call    get_size_operator
  2545.         cmp     al,'('
  2546.         jne     invalid_operand
  2547.         mov     al,[operand_size]
  2548.         cmp     al,2
  2549.         je      imul_reg_mem_imm_16bit
  2550.         cmp     al,4
  2551.         je      imul_reg_mem_imm_32bit
  2552.         cmp     al,8
  2553.         jne     invalid_operand_size
  2554.       imul_reg_mem_imm_64bit:
  2555.         cmp     [size_declared],0
  2556.         jne     long_immediate_not_encodable
  2557.         call    operand_64bit
  2558.         call    get_simm32
  2559.         cmp     [value_type],4
  2560.         jae     long_immediate_not_encodable
  2561.         jmp     imul_reg_mem_imm_32bit_ok
  2562.       imul_reg_mem_imm_16bit:
  2563.         call    operand_16bit
  2564.         call    get_word_value
  2565.         mov     word [value],ax
  2566.         cmp     [value_type],0
  2567.         jne     imul_reg_mem_imm_16bit_store
  2568.         cmp     [size_declared],0
  2569.         jne     imul_reg_mem_imm_16bit_store
  2570.         cmp     ax,-80h
  2571.         jl      imul_reg_mem_imm_16bit_store
  2572.         cmp     ax,80h
  2573.         jl      imul_reg_mem_imm_8bit_store
  2574.       imul_reg_mem_imm_16bit_store:
  2575.         pop     ecx ebx edx
  2576.         mov     [base_code],69h
  2577.         call    store_instruction_with_imm16
  2578.         jmp     instruction_assembled
  2579.       imul_reg_mem_imm_32bit:
  2580.         call    operand_32bit
  2581.         call    get_dword_value
  2582.       imul_reg_mem_imm_32bit_ok:
  2583.         mov     dword [value],eax
  2584.         cmp     [value_type],0
  2585.         jne     imul_reg_mem_imm_32bit_store
  2586.         cmp     [size_declared],0
  2587.         jne     imul_reg_mem_imm_32bit_store
  2588.         cmp     eax,-80h
  2589.         jl      imul_reg_mem_imm_32bit_store
  2590.         cmp     eax,80h
  2591.         jl      imul_reg_mem_imm_8bit_store
  2592.       imul_reg_mem_imm_32bit_store:
  2593.         pop     ecx ebx edx
  2594.         mov     [base_code],69h
  2595.         call    store_instruction_with_imm32
  2596.         jmp     instruction_assembled
  2597.       imul_reg_mem_imm_8bit_store:
  2598.         pop     ecx ebx edx
  2599.         mov     [base_code],6Bh
  2600.         call    store_instruction_with_imm8
  2601.         jmp     instruction_assembled
  2602.       imul_reg_imm:
  2603.         mov     bl,[postbyte_register]
  2604.         dec     esi
  2605.         jmp     imul_reg_reg_imm
  2606.       imul_reg_reg:
  2607.         lods    byte [esi]
  2608.         call    convert_register
  2609.         mov     bl,al
  2610.         cmp     byte [esi],','
  2611.         je      imul_reg_reg_imm
  2612.         mov     al,ah
  2613.         call    operand_autodetect
  2614.         mov     [base_code],0Fh
  2615.         mov     [extended_code],0AFh
  2616.         jmp     nomem_instruction_ready
  2617.       imul_reg_reg_imm:
  2618.         inc     esi
  2619.         lods    byte [esi]
  2620.         call    get_size_operator
  2621.         cmp     al,'('
  2622.         jne     invalid_operand
  2623.         mov     al,[operand_size]
  2624.         cmp     al,2
  2625.         je      imul_reg_reg_imm_16bit
  2626.         cmp     al,4
  2627.         je      imul_reg_reg_imm_32bit
  2628.         cmp     al,8
  2629.         jne     invalid_operand_size
  2630.       imul_reg_reg_imm_64bit:
  2631.         cmp     [size_declared],0
  2632.         jne     long_immediate_not_encodable
  2633.         call    operand_64bit
  2634.         push    ebx
  2635.         call    get_simm32
  2636.         cmp     [value_type],4
  2637.         jae     long_immediate_not_encodable
  2638.         jmp     imul_reg_reg_imm_32bit_ok
  2639.       imul_reg_reg_imm_16bit:
  2640.         call    operand_16bit
  2641.         push    ebx
  2642.         call    get_word_value
  2643.         pop     ebx
  2644.         mov     dx,ax
  2645.         cmp     [value_type],0
  2646.         jne     imul_reg_reg_imm_16bit_store
  2647.         cmp     [size_declared],0
  2648.         jne     imul_reg_reg_imm_16bit_store
  2649.         cmp     ax,-80h
  2650.         jl      imul_reg_reg_imm_16bit_store
  2651.         cmp     ax,80h
  2652.         jl      imul_reg_reg_imm_8bit_store
  2653.       imul_reg_reg_imm_16bit_store:
  2654.         mov     [base_code],69h
  2655.         call    store_nomem_instruction
  2656.         mov     ax,dx
  2657.         call    mark_relocation
  2658.         stos    word [edi]
  2659.         jmp     instruction_assembled
  2660.       imul_reg_reg_imm_32bit:
  2661.         call    operand_32bit
  2662.         push    ebx
  2663.         call    get_dword_value
  2664.       imul_reg_reg_imm_32bit_ok:
  2665.         pop     ebx
  2666.         mov     edx,eax
  2667.         cmp     [value_type],0
  2668.         jne     imul_reg_reg_imm_32bit_store
  2669.         cmp     [size_declared],0
  2670.         jne     imul_reg_reg_imm_32bit_store
  2671.         cmp     eax,-80h
  2672.         jl      imul_reg_reg_imm_32bit_store
  2673.         cmp     eax,80h
  2674.         jl      imul_reg_reg_imm_8bit_store
  2675.       imul_reg_reg_imm_32bit_store:
  2676.         mov     [base_code],69h
  2677.         call    store_nomem_instruction
  2678.         mov     eax,edx
  2679.         call    mark_relocation
  2680.         stos    dword [edi]
  2681.         jmp     instruction_assembled
  2682.       imul_reg_reg_imm_8bit_store:
  2683.         mov     [base_code],6Bh
  2684.         call    store_nomem_instruction
  2685.         mov     al,dl
  2686.         stos    byte [edi]
  2687.         jmp     instruction_assembled
  2688. in_instruction:
  2689.         lods    byte [esi]
  2690.         call    get_size_operator
  2691.         cmp     al,10h
  2692.         jne     invalid_operand
  2693.         lods    byte [esi]
  2694.         call    convert_register
  2695.         or      al,al
  2696.         jnz     invalid_operand
  2697.         lods    byte [esi]
  2698.         cmp     al,','
  2699.         jne     invalid_operand
  2700.         mov     al,ah
  2701.         push    eax
  2702.         mov     [operand_size],0
  2703.         lods    byte [esi]
  2704.         call    get_size_operator
  2705.         cmp     al,'('
  2706.         je      in_imm
  2707.         cmp     al,10h
  2708.         je      in_reg
  2709.         jmp     invalid_operand
  2710.       in_reg:
  2711.         lods    byte [esi]
  2712.         cmp     al,22h
  2713.         jne     invalid_operand
  2714.         pop     eax
  2715.         cmp     al,1
  2716.         je      in_al_dx
  2717.         cmp     al,2
  2718.         je      in_ax_dx
  2719.         cmp     al,4
  2720.         jne     invalid_operand_size
  2721.       in_ax_dx:
  2722.         call    operand_autodetect
  2723.         mov     [base_code],0EDh
  2724.         call    store_instruction_code
  2725.         jmp     instruction_assembled
  2726.       in_al_dx:
  2727.         mov     al,0ECh
  2728.         stos    byte [edi]
  2729.         jmp     instruction_assembled
  2730.       in_imm:
  2731.         mov     al,[operand_size]
  2732.         or      al,al
  2733.         jz      in_imm_size_ok
  2734.         cmp     al,1
  2735.         jne     invalid_operand_size
  2736.       in_imm_size_ok:
  2737.         call    get_byte_value
  2738.         mov     dl,al
  2739.         pop     eax
  2740.         cmp     al,1
  2741.         je      in_al_imm
  2742.         cmp     al,2
  2743.         je      in_ax_imm
  2744.         cmp     al,4
  2745.         jne     invalid_operand_size
  2746.       in_ax_imm:
  2747.         call    operand_autodetect
  2748.         mov     [base_code],0E5h
  2749.         call    store_instruction_code
  2750.         mov     al,dl
  2751.         stos    byte [edi]
  2752.         jmp     instruction_assembled
  2753.       in_al_imm:
  2754.         mov     al,0E4h
  2755.         stos    byte [edi]
  2756.         mov     al,dl
  2757.         stos    byte [edi]
  2758.         jmp     instruction_assembled
  2759. out_instruction:
  2760.         lods    byte [esi]
  2761.         call    get_size_operator
  2762.         cmp     al,'('
  2763.         je      out_imm
  2764.         cmp     al,10h
  2765.         jne     invalid_operand
  2766.         lods    byte [esi]
  2767.         cmp     al,22h