Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

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