Subversion Repositories Kolibri OS

Rev

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

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