Subversion Repositories Kolibri OS

Rev

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

  1.  
  2. ; flat assembler core
  3. ; Copyright (c) 1999-2013, Tomasz Grysztar.
  4. ; All rights reserved.
  5.  
  6. avx_single_source_pd_instruction:
  7.         or      [vex_required],2
  8.         jmp     avx_pd_instruction
  9. avx_pd_instruction_imm8:
  10.         mov     [immediate_size],1
  11. avx_pd_instruction:
  12.         mov     [opcode_prefix],66h
  13.         mov     [mmx_size],0
  14.         jmp     avx_instruction
  15. avx_single_source_ps_instruction:
  16.         or      [vex_required],2
  17.         jmp     avx_ps_instruction
  18. avx_ps_instruction_imm8:
  19.         mov     [immediate_size],1
  20. avx_ps_instruction:
  21.         mov     [mmx_size],0
  22.         jmp     avx_instruction
  23. avx_sd_instruction_imm8:
  24.         mov     [immediate_size],1
  25. avx_sd_instruction:
  26.         mov     [opcode_prefix],0F2h
  27.         mov     [mmx_size],8
  28.         jmp     avx_instruction
  29. avx_ss_instruction_imm8:
  30.         mov     [immediate_size],1
  31. avx_ss_instruction:
  32.         mov     [opcode_prefix],0F3h
  33.         mov     [mmx_size],4
  34.         jmp     avx_instruction
  35. avx_cmp_pd_instruction:
  36.         mov     [opcode_prefix],66h
  37. avx_cmp_ps_instruction:
  38.         mov     [mmx_size],0
  39.         mov     byte [value],al
  40.         mov     al,0C2h
  41.         jmp     avx_instruction
  42. avx_cmp_sd_instruction:
  43.         mov     [opcode_prefix],0F2h
  44.         mov     [mmx_size],8
  45.         mov     byte [value],al
  46.         mov     al,0C2h
  47.         jmp     avx_instruction
  48. avx_cmp_ss_instruction:
  49.         mov     [opcode_prefix],0F3h
  50.         mov     [mmx_size],4
  51.         mov     byte [value],al
  52.         mov     al,0C2h
  53.         jmp     avx_instruction
  54. avx_comiss_instruction:
  55.         or      [vex_required],2
  56.         mov     [mmx_size],4
  57.         jmp     avx_instruction
  58. avx_comisd_instruction:
  59.         or      [vex_required],2
  60.         mov     [opcode_prefix],66h
  61.         mov     [mmx_size],8
  62.         jmp     avx_instruction
  63. avx_haddps_instruction:
  64.         mov     [opcode_prefix],0F2h
  65.         mov     [mmx_size],0
  66.         jmp     avx_instruction
  67. avx_movshdup_instruction:
  68.         or      [vex_required],2
  69.         mov     [opcode_prefix],0F3h
  70.         mov     [mmx_size],0
  71.         jmp     avx_instruction
  72. avx_128bit_instruction:
  73.         mov     [mmx_size],16
  74.         mov     [opcode_prefix],66h
  75. avx_instruction:
  76.         mov     [base_code],0Fh
  77.         mov     [extended_code],al
  78.       avx_common:
  79.         or      [vex_required],1
  80.         lods    byte [esi]
  81.         call    get_size_operator
  82.         cmp     al,10h
  83.         jne     invalid_operand
  84.       avx_reg:
  85.         lods    byte [esi]
  86.         call    convert_avx_register
  87.         mov     [postbyte_register],al
  88.       avx_vex_reg:
  89.         test    [vex_required],2
  90.         jnz     avx_vex_reg_ok
  91.         lods    byte [esi]
  92.         cmp     al,','
  93.         jne     invalid_operand
  94.         call    take_avx_register
  95.         mov     [vex_register],al
  96.       avx_vex_reg_ok:
  97.         cmp     [mmx_size],0
  98.         je      avx_regs_size_ok
  99.         cmp     ah,16
  100.         jne     invalid_operand
  101.       avx_regs_size_ok:
  102.         lods    byte [esi]
  103.         cmp     al,','
  104.         jne     invalid_operand
  105.         call    take_avx_rm
  106.         jc      avx_regs_reg
  107.         mov     al,[extended_code]
  108.         mov     ah,[supplemental_code]
  109.         cmp     al,0C2h
  110.         je      sse_cmp_mem_ok
  111.         cmp     ax,443Ah
  112.         je      sse_cmp_mem_ok
  113.         mov     al,[base_code]
  114.         and     al,11011100b
  115.         cmp     al,11001100b
  116.         je      sse_cmp_mem_ok
  117.         cmp     [immediate_size],1
  118.         je      mmx_imm8
  119.         cmp     [immediate_size],0
  120.         jge     instruction_ready
  121.         cmp     byte [esi],','
  122.         jne     invalid_operand
  123.         inc     esi
  124.         call    take_avx_register
  125.         shl     al,4
  126.         or      byte [value],al
  127.         test    al,80h
  128.         jz      avx_regs_mem_reg_store
  129.         cmp     [code_type],64
  130.         jne     invalid_operand
  131.       avx_regs_mem_reg_store:
  132.         call    take_imm4_if_needed
  133.         call    store_instruction_with_imm8
  134.         jmp     instruction_assembled
  135.       avx_regs_reg:
  136.         mov     bl,al
  137.         mov     al,[extended_code]
  138.         mov     ah,[supplemental_code]
  139.         cmp     al,0C2h
  140.         je      sse_cmp_nomem_ok
  141.         cmp     ax,443Ah
  142.         je      sse_cmp_nomem_ok
  143.         mov     al,[base_code]
  144.         and     al,11011100b
  145.         cmp     al,11001100b
  146.         je      sse_cmp_nomem_ok
  147.         cmp     [immediate_size],1
  148.         je      mmx_nomem_imm8
  149.         cmp     [immediate_size],0
  150.         jge     nomem_instruction_ready
  151.         lods    byte [esi]
  152.         cmp     al,','
  153.         jne     invalid_operand
  154.         mov     al,bl
  155.         shl     al,4
  156.         or      byte [value],al
  157.         test    al,80h
  158.         jz      avx_regs_reg_
  159.         cmp     [code_type],64
  160.         jne     invalid_operand
  161.       avx_regs_reg_:
  162.         call    take_avx_rm
  163.         jc      avx_regs_reg_reg
  164.         cmp     [immediate_size],-2
  165.         jg      invalid_operand
  166.         or      [rex_prefix],8
  167.         call    take_imm4_if_needed
  168.         call    store_instruction_with_imm8
  169.         jmp     instruction_assembled
  170.       avx_regs_reg_reg:
  171.         shl     al,4
  172.         and     byte [value],1111b
  173.         or      byte [value],al
  174.         call    take_imm4_if_needed
  175.         call    store_nomem_instruction
  176.         mov     al,byte [value]
  177.         stos    byte [edi]
  178.         jmp     instruction_assembled
  179.       take_avx_rm:
  180.         xor     cl,cl
  181.         xchg    cl,[operand_size]
  182.         lods    byte [esi]
  183.         call    get_size_operator
  184.         cmp     al,'['
  185.         je      take_avx_mem
  186.         mov     [operand_size],cl
  187.         cmp     al,10h
  188.         jne     invalid_operand
  189.         lods    byte [esi]
  190.         call    convert_avx_register
  191.         cmp     [mmx_size],0
  192.         je      avx_reg_ok
  193.         cmp     ah,16
  194.         jne     invalid_operand
  195.       avx_reg_ok:
  196.         stc
  197.         ret
  198.       take_avx_mem:
  199.         push    ecx
  200.         call    get_address
  201.         pop     eax
  202.         cmp     [mmx_size],0
  203.         jne     avx_smem
  204.         xchg    al,[operand_size]
  205.         or      al,al
  206.         jz      avx_mem_ok
  207.         cmp     al,[operand_size]
  208.         jne     operand_sizes_do_not_match
  209.       avx_mem_ok:
  210.         clc
  211.         ret
  212.       avx_smem:
  213.         xchg    al,[operand_size]
  214.         or      al,al
  215.         jz      avx_smem_ok
  216.         cmp     al,[mmx_size]
  217.         jne     invalid_operand_size
  218.       avx_smem_ok:
  219.         clc
  220.         ret
  221.       take_imm4_if_needed:
  222.         cmp     [immediate_size],-3
  223.         jne     imm4_ok
  224.         push    ebx ecx edx
  225.         lods    byte [esi]
  226.         cmp     al,','
  227.         jne     invalid_operand
  228.         lods    byte [esi]
  229.         cmp     al,'('
  230.         jne     invalid_operand
  231.         call    get_byte_value
  232.         test    al,11110000b
  233.         jnz     value_out_of_range
  234.         or      byte [value],al
  235.         pop     edx ecx ebx
  236.       imm4_ok:
  237.         ret
  238.  
  239. avx_single_source_128bit_instruction_38:
  240.         or      [vex_required],2
  241. avx_128bit_instruction_38:
  242.         mov     [mmx_size],16
  243.         jmp     avx_instruction_38_setup
  244. avx_single_source_instruction_38:
  245.         or      [vex_required],2
  246. avx_instruction_38:
  247.         mov     [mmx_size],0
  248.       avx_instruction_38_setup:
  249.         mov     [opcode_prefix],66h
  250.         mov     [supplemental_code],al
  251.         mov     al,38h
  252.         jmp     avx_instruction
  253. avx_instruction_38_w1:
  254.         or      [rex_prefix],8
  255.         jmp     avx_instruction_38
  256.  
  257. avx_ss_instruction_3a_imm8:
  258.         mov     [mmx_size],4
  259.         jmp     avx_instruction_3a_imm8_setup
  260. avx_sd_instruction_3a_imm8:
  261.         mov     [mmx_size],8
  262.         jmp     avx_instruction_3a_imm8_setup
  263. avx_single_source_128bit_instruction_3a_imm8:
  264.         or      [vex_required],2
  265. avx_128bit_instruction_3a_imm8:
  266.         mov     [mmx_size],16
  267.         jmp     avx_instruction_3a_imm8_setup
  268. avx_triple_source_instruction_3a:
  269.         mov     [mmx_size],0
  270.         mov     [immediate_size],-1
  271.         mov     byte [value],0
  272.         jmp     avx_instruction_3a_setup
  273. avx_single_source_instruction_3a_imm8:
  274.         or      [vex_required],2
  275. avx_instruction_3a_imm8:
  276.         mov     [mmx_size],0
  277.       avx_instruction_3a_imm8_setup:
  278.         mov     [immediate_size],1
  279.       avx_instruction_3a_setup:
  280.         mov     [opcode_prefix],66h
  281.         mov     [supplemental_code],al
  282.         mov     al,3Ah
  283.         jmp     avx_instruction
  284. avx_pclmulqdq_instruction:
  285.         mov     byte [value],al
  286.         mov     [mmx_size],16
  287.         mov     al,44h
  288.         jmp     avx_instruction_3a_setup
  289.  
  290. avx_permq_instruction:
  291.         or      [vex_required],2
  292.         or      [rex_prefix],8
  293. avx_perm2f128_instruction:
  294.         mov     [immediate_size],1
  295.         mov     ah,3Ah
  296.         jmp     avx_perm_instruction
  297. avx_permd_instruction:
  298.         mov     ah,38h
  299.       avx_perm_instruction:
  300.         mov     [opcode_prefix],66h
  301.         mov     [base_code],0Fh
  302.         mov     [extended_code],ah
  303.         mov     [supplemental_code],al
  304.         mov     [mmx_size],0
  305.         or      [vex_required],1
  306.         call    take_avx_register
  307.         cmp     ah,32
  308.         jne     invalid_operand_size
  309.         mov     [postbyte_register],al
  310.         jmp     avx_vex_reg
  311.  
  312. avx_movdqu_instruction:
  313.         mov     [opcode_prefix],0F3h
  314.         jmp     avx_movps_instruction
  315. avx_movpd_instruction:
  316.         mov     [opcode_prefix],66h
  317. avx_movps_instruction:
  318.         mov     [mmx_size],0
  319.         or      [vex_required],2
  320.         mov     [base_code],0Fh
  321.         mov     [extended_code],al
  322.         lods    byte [esi]
  323.         call    get_size_operator
  324.         cmp     al,10h
  325.         je      avx_reg
  326.         inc     [extended_code]
  327.         test    [extended_code],1
  328.         jnz     avx_mem
  329.         add     [extended_code],-1+10h
  330.       avx_mem:
  331.         cmp     al,'['
  332.         jne     invalid_operand
  333.         call    get_address
  334.         lods    byte [esi]
  335.         cmp     al,','
  336.         jne     invalid_operand
  337.         call    take_avx_register
  338.         mov     [postbyte_register],al
  339.         jmp     instruction_ready
  340. avx_movntpd_instruction:
  341.         mov     [opcode_prefix],66h
  342. avx_movntps_instruction:
  343.         or      [vex_required],1
  344.         mov     [base_code],0Fh
  345.         mov     [extended_code],al
  346.         lods    byte [esi]
  347.         call    get_size_operator
  348.         jmp     avx_mem
  349. avx_lddqu_instruction:
  350.         mov     [opcode_prefix],0F2h
  351.         mov     [mmx_size],0
  352.         xor     cx,cx
  353.       avx_load_instruction:
  354.         mov     [base_code],0Fh
  355.         mov     [extended_code],al
  356.         or      [vex_required],1
  357.         call    take_avx_register
  358.         or      cl,cl
  359.         jz      avx_load_reg_ok
  360.         cmp     ah,cl
  361.         jne     invalid_operand
  362.       avx_load_reg_ok:
  363.         cmp     [mmx_size],0
  364.         je      avx_load_reg_
  365.         xor     ah,ah
  366.       avx_load_reg_:
  367.         xchg    ah,[operand_size]
  368.         push    eax
  369.         lods    byte [esi]
  370.         cmp     al,','
  371.         jne     invalid_operand
  372.         lods    byte [esi]
  373.         call    get_size_operator
  374.         cmp     al,10h
  375.         je      avx_load_reg_reg
  376.         cmp     al,'['
  377.         jne     invalid_operand
  378.         call    get_address
  379.         pop     eax
  380.         xchg    ah,[operand_size]
  381.         mov     [postbyte_register],al
  382.         mov     al,[mmx_size]
  383.         or      al,al
  384.         jz      instruction_ready
  385.         or      ah,ah
  386.         jz      instruction_ready
  387.         cmp     al,ah
  388.         jne     invalid_operand_size
  389.         jmp     instruction_ready
  390.       avx_load_reg_reg:
  391.         lods    byte [esi]
  392.         call    convert_avx_register
  393.         cmp     ch,ah
  394.         jne     invalid_operand
  395.         mov     bl,al
  396.         pop     eax
  397.         xchg    ah,[operand_size]
  398.         mov     [postbyte_register],al
  399.         jmp     nomem_instruction_ready
  400.  
  401. avx_movntdqa_instruction:
  402.         mov     [mmx_size],0
  403.         xor     cx,cx
  404.         jmp     avx_load_instruction_38
  405. avx_broadcastss_instruction:
  406.         mov     [mmx_size],4
  407.         xor     cl,cl
  408.         mov     ch,16
  409.         jmp     avx_load_instruction_38
  410. avx_broadcastsd_instruction:
  411.         mov     [mmx_size],8
  412.         mov     cl,32
  413.         mov     ch,16
  414.         jmp     avx_load_instruction_38
  415. avx_pbroadcastb_instruction:
  416.         mov     [mmx_size],1
  417.         jmp     avx_pbroadcast_instruction
  418. avx_pbroadcastw_instruction:
  419.         mov     [mmx_size],2
  420.         jmp     avx_pbroadcast_instruction
  421. avx_pbroadcastd_instruction:
  422.         mov     [mmx_size],4
  423.         jmp     avx_pbroadcast_instruction
  424. avx_pbroadcastq_instruction:
  425.         mov     [mmx_size],8
  426.       avx_pbroadcast_instruction:
  427.         xor     cl,cl
  428.         mov     ch,16
  429.         jmp     avx_load_instruction_38
  430. avx_broadcastf128_instruction:
  431.         mov     [mmx_size],16
  432.         mov     cl,32
  433.         xor     ch,ch
  434.       avx_load_instruction_38:
  435.         mov     [opcode_prefix],66h
  436.         mov     [supplemental_code],al
  437.         mov     al,38h
  438.         jmp     avx_load_instruction
  439. avx_movlpd_instruction:
  440.         mov     [opcode_prefix],66h
  441. avx_movlps_instruction:
  442.         mov     [base_code],0Fh
  443.         mov     [extended_code],al
  444.         mov     [mmx_size],8
  445.         or      [vex_required],1
  446.         lods    byte [esi]
  447.         call    get_size_operator
  448.         cmp     al,10h
  449.         jne     avx_movlps_mem
  450.         lods    byte [esi]
  451.         call    convert_avx_register
  452.         mov     [postbyte_register],al
  453.         lods    byte [esi]
  454.         cmp     al,','
  455.         jne     invalid_operand
  456.         call    take_avx_register
  457.         mov     [vex_register],al
  458.         cmp     [operand_size],16
  459.         jne     invalid_operand
  460.         mov     [operand_size],0
  461.         lods    byte [esi]
  462.         cmp     al,','
  463.         jne     invalid_operand
  464.         call    take_avx_rm
  465.         jc      invalid_operand
  466.         jmp     instruction_ready
  467.       avx_movlps_mem:
  468.         cmp     al,'['
  469.         jne     invalid_operand
  470.         call    get_address
  471.         mov     al,[operand_size]
  472.         or      al,al
  473.         jz      avx_movlps_mem_size_ok
  474.         cmp     al,[mmx_size]
  475.         jne     invalid_operand_size
  476.         mov     [operand_size],0
  477.       avx_movlps_mem_size_ok:
  478.         lods    byte [esi]
  479.         cmp     al,','
  480.         jne     invalid_operand
  481.         call    take_avx_register
  482.         cmp     ah,16
  483.         jne     invalid_operand
  484.         mov     [postbyte_register],al
  485.         inc     [extended_code]
  486.         jmp     instruction_ready
  487. avx_movhlps_instruction:
  488.         mov     [base_code],0Fh
  489.         mov     [extended_code],al
  490.         or      [vex_required],1
  491.         call    take_avx_register
  492.         cmp     ah,16
  493.         jne     invalid_operand
  494.         mov     [postbyte_register],al
  495.         lods    byte [esi]
  496.         cmp     al,','
  497.         jne     invalid_operand
  498.         call    take_avx_register
  499.         mov     [vex_register],al
  500.         lods    byte [esi]
  501.         cmp     al,','
  502.         jne     invalid_operand
  503.         call    take_avx_register
  504.         mov     bl,al
  505.         jmp     nomem_instruction_ready
  506. avx_maskmov_w1_instruction:
  507.         or      [rex_prefix],8
  508. avx_maskmov_instruction:
  509.         call    setup_66_0f_38
  510.         mov     [mmx_size],0
  511.         or      [vex_required],1
  512.         lods    byte [esi]
  513.         call    get_size_operator
  514.         cmp     al,10h
  515.         jne     avx_maskmov_mem
  516.         lods    byte [esi]
  517.         call    convert_avx_register
  518.         mov     [postbyte_register],al
  519.         lods    byte [esi]
  520.         cmp     al,','
  521.         jne     invalid_operand
  522.         call    take_avx_register
  523.         mov     [vex_register],al
  524.         lods    byte [esi]
  525.         cmp     al,','
  526.         jne     invalid_operand
  527.         call    take_avx_rm
  528.         jc      invalid_operand
  529.         jmp     instruction_ready
  530.       avx_maskmov_mem:
  531.         cmp     al,'['
  532.         jne     invalid_operand
  533.         call    get_address
  534.         lods    byte [esi]
  535.         cmp     al,','
  536.         jne     invalid_operand
  537.         call    take_avx_register
  538.         mov     [vex_register],al
  539.         lods    byte [esi]
  540.         cmp     al,','
  541.         jne     invalid_operand
  542.         call    take_avx_register
  543.         mov     [postbyte_register],al
  544.         add     [supplemental_code],2
  545.         jmp     instruction_ready
  546.       setup_66_0f_38:
  547.         mov     [extended_code],38h
  548.         mov     [supplemental_code],al
  549.         mov     [base_code],0Fh
  550.         mov     [opcode_prefix],66h
  551.         ret
  552. avx_movd_instruction:
  553.         or      [vex_required],1
  554.         jmp     movd_instruction
  555. avx_movq_instruction:
  556.         or      [vex_required],1
  557.         jmp     movq_instruction
  558. avx_movddup_instruction:
  559.         or      [vex_required],1
  560.         mov     [opcode_prefix],0F2h
  561.         mov     [base_code],0Fh
  562.         mov     [extended_code],al
  563.         lods    byte [esi]
  564.         call    get_size_operator
  565.         cmp     al,10h
  566.         jne     invalid_operand
  567.         lods    byte [esi]
  568.         call    convert_avx_register
  569.         mov     [postbyte_register],al
  570.         mov     [mmx_size],0
  571.         cmp     ah,32
  572.         je      avx_regs_size_ok
  573.         mov     [mmx_size],8
  574.         jmp     avx_regs_size_ok
  575. avx_movmskpd_instruction:
  576.         mov     [opcode_prefix],66h
  577. avx_movmskps_instruction:
  578.         mov     [base_code],0Fh
  579.         mov     [extended_code],50h
  580.         or      [vex_required],1
  581.         lods    byte [esi]
  582.         call    get_size_operator
  583.         cmp     al,10h
  584.         jne     invalid_operand
  585.         lods    byte [esi]
  586.         call    convert_register
  587.         mov     [postbyte_register],al
  588.         cmp     ah,4
  589.         je      avx_movmskps_reg_ok
  590.         cmp     ah,8
  591.         jne     invalid_operand_size
  592.         cmp     [code_type],64
  593.         jne     invalid_operand
  594.       avx_movmskps_reg_ok:
  595.         mov     [operand_size],0
  596.         lods    byte [esi]
  597.         cmp     al,','
  598.         jne     invalid_operand
  599.         call    take_avx_register
  600.         mov     bl,al
  601.         jmp     nomem_instruction_ready
  602. avx_movsd_instruction:
  603.         mov     [opcode_prefix],0F2h
  604.         mov     [mmx_size],8
  605.         jmp     avx_movs_instruction
  606. avx_movss_instruction:
  607.         mov     [opcode_prefix],0F3h
  608.         mov     [mmx_size],4
  609.       avx_movs_instruction:
  610.         or      [vex_required],1
  611.         mov     [base_code],0Fh
  612.         mov     [extended_code],10h
  613.         lods    byte [esi]
  614.         call    get_size_operator
  615.         cmp     al,10h
  616.         jne     avx_movlps_mem
  617.         lods    byte [esi]
  618.         call    convert_xmm_register
  619.         mov     [postbyte_register],al
  620.         xor     cl,cl
  621.         xchg    cl,[operand_size]
  622.         lods    byte [esi]
  623.         cmp     al,','
  624.         jne     invalid_operand
  625.         lods    byte [esi]
  626.         call    get_size_operator
  627.         cmp     al,10h
  628.         jne     avx_movs_reg_mem
  629.         mov     [operand_size],cl
  630.         lods    byte [esi]
  631.         call    convert_avx_register
  632.         mov     [vex_register],al
  633.         lods    byte [esi]
  634.         cmp     al,','
  635.         jne     invalid_operand
  636.         call    take_avx_register
  637.         mov     bl,al
  638.         cmp     bl,8
  639.         jb      nomem_instruction_ready
  640.         inc     [extended_code]
  641.         xchg    bl,[postbyte_register]
  642.         jmp     nomem_instruction_ready
  643.       avx_movs_reg_mem:
  644.         cmp     al,'['
  645.         jne     invalid_operand
  646.         call    get_address
  647.         mov     al,[operand_size]
  648.         or      al,al
  649.         jz      avx_movs_reg_mem_ok
  650.         cmp     al,[mmx_size]
  651.         jne     invalid_operand_size
  652.       avx_movs_reg_mem_ok:
  653.         jmp     instruction_ready
  654.  
  655. avx_cvtdq2pd_instruction:
  656.         mov     [opcode_prefix],0F3h
  657. avx_cvtps2pd_instruction:
  658.         mov     [base_code],0Fh
  659.         mov     [extended_code],al
  660.         or      [vex_required],1
  661.         call    take_avx_register
  662.         mov     [postbyte_register],al
  663.         lods    byte [esi]
  664.         cmp     al,','
  665.         jne     invalid_operand
  666.         xor     cl,cl
  667.         xchg    cl,[operand_size]
  668.         lods    byte [esi]
  669.         call    get_size_operator
  670.         cmp     al,10h
  671.         jne     avx_cvtdq2pd_reg_mem
  672.         lods    byte [esi]
  673.         call    convert_xmm_register
  674.         mov     bl,al
  675.         mov     [operand_size],cl
  676.         jmp     nomem_instruction_ready
  677.       avx_cvtdq2pd_reg_mem:
  678.         cmp     al,'['
  679.         jne     invalid_operand
  680.         mov     [mmx_size],cl
  681.         call    get_address
  682.         mov     al,[mmx_size]
  683.         mov     ah,al
  684.         xchg    al,[operand_size]
  685.         or      al,al
  686.         jz      instruction_ready
  687.         shl     al,1
  688.         cmp     al,ah
  689.         jne     invalid_operand_size
  690.         jmp     instruction_ready
  691. avx_cvtpd2dq_instruction:
  692.         mov     [opcode_prefix],0F2h
  693.         jmp     avx_cvtpd_instruction
  694. avx_cvtpd2ps_instruction:
  695.         mov     [opcode_prefix],66h
  696.       avx_cvtpd_instruction:
  697.         mov     [base_code],0Fh
  698.         mov     [extended_code],al
  699.         or      [vex_required],1
  700.         call    take_avx_register
  701.         mov     [postbyte_register],al
  702.         cmp     ah,16
  703.         jne     invalid_operand
  704.         lods    byte [esi]
  705.         cmp     al,','
  706.         jne     invalid_operand
  707.         mov     [operand_size],0
  708.         lods    byte [esi]
  709.         call    get_size_operator
  710.         cmp     al,10h
  711.         jne     avx_cvtpd2dq_reg_mem
  712.         lods    byte [esi]
  713.         call    convert_avx_register
  714.         mov     bl,al
  715.         jmp     nomem_instruction_ready
  716.       avx_cvtpd2dq_reg_mem:
  717.         cmp     al,'['
  718.         jne     invalid_operand
  719.         call    get_address
  720.         mov     al,[operand_size]
  721.         or      al,al
  722.         jz      operand_size_not_specified
  723.         cmp     al,16
  724.         je      instruction_ready
  725.         cmp     al,32
  726.         jne     invalid_operand_size
  727.         jmp     instruction_ready
  728. avx_cvttps2dq_instruction:
  729.         or      [vex_required],2
  730.         mov     [opcode_prefix],0F3h
  731.         mov     [mmx_size],0
  732.         jmp     avx_instruction
  733. avx_cvtsd2si_instruction:
  734.         or      [vex_required],1
  735.         jmp     cvtsd2si_instruction
  736. avx_cvtss2si_instruction:
  737.         or      [vex_required],1
  738.         jmp     cvtss2si_instruction
  739. avx_cvtsi2ss_instruction:
  740.         mov     [opcode_prefix],0F3h
  741.         jmp     avx_cvtsi_instruction
  742. avx_cvtsi2sd_instruction:
  743.         mov     [opcode_prefix],0F2h
  744.       avx_cvtsi_instruction:
  745.         mov     [base_code],0Fh
  746.         mov     [extended_code],al
  747.         or      [vex_required],1
  748.         call    take_avx_register
  749.         cmp     ah,16
  750.         jne     invalid_operand_size
  751.         mov     [postbyte_register],al
  752.         lods    byte [esi]
  753.         cmp     al,','
  754.         jne     invalid_operand
  755.         call    take_avx_register
  756.         mov     [vex_register],al
  757.         jmp     cvtsi_xmmreg
  758.  
  759. avx_extractf128_instruction:
  760.         or      [vex_required],1
  761.         call    setup_66_0f_3a
  762.         lods    byte [esi]
  763.         call    get_size_operator
  764.         cmp     al,10h
  765.         je      avx_extractf128_reg
  766.         cmp     al,'['
  767.         jne     invalid_operand
  768.         call    get_address
  769.         xor     al,al
  770.         xchg    al,[operand_size]
  771.         or      al,al
  772.         jz      avx_extractf128_mem_size_ok
  773.         cmp     al,16
  774.         jne     invalid_operand_size
  775.       avx_extractf128_mem_size_ok:
  776.         lods    byte [esi]
  777.         cmp     al,','
  778.         jne     invalid_operand
  779.         call    take_avx_register
  780.         cmp     ah,32
  781.         jne     invalid_operand_size
  782.         mov     [postbyte_register],al
  783.         jmp     mmx_imm8
  784.       avx_extractf128_reg:
  785.         lods    byte [esi]
  786.         call    convert_xmm_register
  787.         mov     [operand_size],0
  788.         push    eax
  789.         lods    byte [esi]
  790.         cmp     al,','
  791.         jne     invalid_operand
  792.         call    take_avx_register
  793.         cmp     ah,32
  794.         jne     invalid_operand_size
  795.         mov     [postbyte_register],al
  796.         pop     ebx
  797.         jmp     mmx_nomem_imm8
  798.       setup_66_0f_3a:
  799.         mov     [extended_code],3Ah
  800.         mov     [supplemental_code],al
  801.         mov     [base_code],0Fh
  802.         mov     [opcode_prefix],66h
  803.         ret
  804. avx_insertf128_instruction:
  805.         or      [vex_required],1
  806.         call    setup_66_0f_3a
  807.         call    take_avx_register
  808.         cmp     ah,32
  809.         jne     invalid_operand
  810.         mov     [postbyte_register],al
  811.         lods    byte [esi]
  812.         cmp     al,','
  813.         jne     invalid_operand
  814.         call    take_avx_register
  815.         mov     [vex_register],al
  816.         mov     [operand_size],0
  817.         mov     [mmx_size],16
  818.         lods    byte [esi]
  819.         cmp     al,','
  820.         jne     invalid_operand
  821.         call    take_avx_rm
  822.         mov     [operand_size],32
  823.         jnc     mmx_imm8
  824.         mov     bl,al
  825.         jmp     mmx_nomem_imm8
  826. avx_extractps_instruction:
  827.         or      [vex_required],1
  828.         jmp     extractps_instruction
  829. avx_insertps_instruction:
  830.         or      [vex_required],1
  831.         call    take_avx_register
  832.         cmp     ah,16
  833.         jne     invalid_operand_size
  834.         mov     [postbyte_register],al
  835.         lods    byte [esi]
  836.         cmp     al,','
  837.         jne     invalid_operand
  838.         call    take_avx_register
  839.         mov     [vex_register],al
  840.         jmp     insertps_xmmreg
  841. avx_pextrb_instruction:
  842.         or      [vex_required],1
  843.         jmp     pextrb_instruction
  844. avx_pextrw_instruction:
  845.         or      [vex_required],1
  846.         jmp     pextrw_instruction
  847. avx_pextrd_instruction:
  848.         or      [vex_required],1
  849.         jmp     pextrd_instruction
  850. avx_pextrq_instruction:
  851.         or      [vex_required],1
  852.         jmp     pextrq_instruction
  853. avx_pinsrb_instruction:
  854.         mov     [mmx_size],1
  855.         or      [vex_required],1
  856.         jmp     avx_pinsr_instruction_3a
  857. avx_pinsrw_instruction:
  858.         mov     [mmx_size],2
  859.         or      [vex_required],1
  860.         jmp     avx_pinsr_instruction
  861. avx_pinsrd_instruction:
  862.         mov     [mmx_size],4
  863.         or      [vex_required],1
  864.         jmp     avx_pinsr_instruction_3a
  865. avx_pinsrq_instruction:
  866.         mov     [mmx_size],8
  867.         or      [vex_required],1
  868.         call    operand_64bit
  869.       avx_pinsr_instruction_3a:
  870.         mov     [supplemental_code],al
  871.         mov     al,3Ah
  872.       avx_pinsr_instruction:
  873.         mov     [opcode_prefix],66h
  874.         mov     [base_code],0Fh
  875.         mov     [extended_code],al
  876.         call    take_avx_register
  877.         cmp     ah,16
  878.         jne     invalid_operand_size
  879.         mov     [postbyte_register],al
  880.         lods    byte [esi]
  881.         cmp     al,','
  882.         jne     invalid_operand
  883.         call    take_avx_register
  884.         mov     [vex_register],al
  885.         jmp     pinsr_xmmreg
  886. avx_maskmovdqu_instruction:
  887.         or      [vex_required],1
  888.         jmp     maskmovdqu_instruction
  889. avx_pmovmskb_instruction:
  890.         or      [vex_required],1
  891.         mov     [opcode_prefix],66h
  892.         mov     [base_code],0Fh
  893.         mov     [extended_code],al
  894.         lods    byte [esi]
  895.         call    get_size_operator
  896.         cmp     al,10h
  897.         jne     invalid_operand
  898.         lods    byte [esi]
  899.         call    convert_register
  900.         cmp     ah,4
  901.         je      avx_pmovmskb_reg_size_ok
  902.         cmp     [code_type],64
  903.         jne     invalid_operand_size
  904.         cmp     ah,8
  905.         jnz     invalid_operand_size
  906.       avx_pmovmskb_reg_size_ok:
  907.         mov     [postbyte_register],al
  908.         mov     [operand_size],0
  909.         lods    byte [esi]
  910.         cmp     al,','
  911.         jne     invalid_operand
  912.         call    take_avx_register
  913.         mov     bl,al
  914.         jmp     nomem_instruction_ready
  915. avx_pshufd_instruction:
  916.         or      [vex_required],1
  917.         mov     [mmx_size],0
  918.         mov     [opcode_prefix],al
  919.         mov     [base_code],0Fh
  920.         mov     [extended_code],70h
  921.         call    take_avx_register
  922.         mov     [postbyte_register],al
  923.         lods    byte [esi]
  924.         cmp     al,','
  925.         jne     invalid_operand
  926.         call    take_avx_rm
  927.         jnc     mmx_imm8
  928.         mov     bl,al
  929.         jmp     mmx_nomem_imm8
  930.  
  931. avx_pmovsxbw_instruction:
  932.         mov     [mmx_size],8
  933.         jmp     avx_pmovsx_instruction
  934. avx_pmovsxbd_instruction:
  935.         mov     [mmx_size],4
  936.         jmp     avx_pmovsx_instruction
  937. avx_pmovsxbq_instruction:
  938.         mov     [mmx_size],2
  939.         jmp     avx_pmovsx_instruction
  940. avx_pmovsxwd_instruction:
  941.         mov     [mmx_size],8
  942.         jmp     avx_pmovsx_instruction
  943. avx_pmovsxwq_instruction:
  944.         mov     [mmx_size],4
  945.         jmp     avx_pmovsx_instruction
  946. avx_pmovsxdq_instruction:
  947.         mov     [mmx_size],8
  948.       avx_pmovsx_instruction:
  949.         or      [vex_required],1
  950.         call    setup_66_0f_38
  951.         call    take_avx_register
  952.         mov     [postbyte_register],al
  953.         lods    byte [esi]
  954.         cmp     al,','
  955.         jne     invalid_operand
  956.         xor     al,al
  957.         xchg    al,[operand_size]
  958.         push    eax
  959.         lods    byte [esi]
  960.         call    get_size_operator
  961.         cmp     al,10h
  962.         je      avx_pmovsx_xmmreg_reg
  963.         cmp     al,'['
  964.         jne     invalid_operand
  965.         call    get_address
  966.         pop     eax
  967.         cmp     al,32
  968.         jb      avx_pmovsx_size_check
  969.         shl     [mmx_size],1
  970.       avx_pmovsx_size_check:
  971.         xchg    al,[operand_size]
  972.         test    al,al
  973.         jz      instruction_ready
  974.         cmp     al,[mmx_size]
  975.         jne     invalid_operand_size
  976.         jmp     instruction_ready
  977.       avx_pmovsx_xmmreg_reg:
  978.         lods    byte [esi]
  979.         call    convert_xmm_register
  980.         mov     bl,al
  981.         pop     eax
  982.         mov     [operand_size],al
  983.         jmp     nomem_instruction_ready
  984. avx_permil_instruction:
  985.         call    setup_66_0f_3a
  986.         or      [vex_required],1
  987.         call    take_avx_register
  988.         mov     [postbyte_register],al
  989.         lods    byte [esi]
  990.         cmp     al,','
  991.         jne     invalid_operand
  992.         lods    byte [esi]
  993.         call    get_size_operator
  994.         cmp     al,'['
  995.         je      avx_permil_reg_mem
  996.         cmp     al,10h
  997.         jne     invalid_operand
  998.         lods    byte [esi]
  999.         call    convert_avx_register
  1000.         mov     [vex_register],al
  1001.         lods    byte [esi]
  1002.         cmp     al,','
  1003.         jne     invalid_operand
  1004.         push    esi
  1005.         xor     cl,cl
  1006.         xchg    cl,[operand_size]
  1007.         lods    byte [esi]
  1008.         call    get_size_operator
  1009.         xchg    cl,[operand_size]
  1010.         pop     esi
  1011.         cmp     al,'['
  1012.         je      avx_permil_reg_reg_mem
  1013.         cmp     al,10h
  1014.         jne     avx_permil_reg_reg_imm8
  1015.         call    take_avx_register
  1016.         mov     bl,al
  1017.         mov     [extended_code],38h
  1018.         add     [supplemental_code],8
  1019.         jmp     nomem_instruction_ready
  1020.       avx_permil_reg_reg_mem:
  1021.         lods    byte [esi]
  1022.         call    get_size_operator
  1023.         call    get_address
  1024.         mov     [extended_code],38h
  1025.         add     [supplemental_code],8
  1026.         jmp     instruction_ready
  1027.       avx_permil_reg_reg_imm8:
  1028.         dec     esi
  1029.         xor     bl,bl
  1030.         xchg    bl,[vex_register]
  1031.         jmp     mmx_nomem_imm8
  1032.       avx_permil_reg_mem:
  1033.         call    get_address
  1034.         jmp     mmx_imm8
  1035. avx_bit_shift_instruction:
  1036.         mov     [opcode_prefix],66h
  1037.         mov     [base_code],0Fh
  1038.         mov     [extended_code],al
  1039.         or      [vex_required],1
  1040.         call    take_avx_register
  1041.         mov     [postbyte_register],al
  1042.         lods    byte [esi]
  1043.         cmp     al,','
  1044.         jne     invalid_operand
  1045.         call    take_avx_register
  1046.         mov     [vex_register],al
  1047.         lods    byte [esi]
  1048.         cmp     al,','
  1049.         jne     invalid_operand
  1050.         push    esi
  1051.         xor     cl,cl
  1052.         xchg    cl,[operand_size]
  1053.         lods    byte [esi]
  1054.         call    get_size_operator
  1055.         cmp     al,10h
  1056.         je      avx_bit_shift_regs_reg
  1057.         pop     esi
  1058.         cmp     al,'['
  1059.         je      avx_bit_shift_regs_mem
  1060.         xchg    cl,[operand_size]
  1061.         dec     esi
  1062.         mov     bl,[extended_code]
  1063.         mov     al,bl
  1064.         shr     bl,4
  1065.         and     al,1111b
  1066.         add     al,70h
  1067.         mov     [extended_code],al
  1068.         sub     bl,0Ch
  1069.         shl     bl,1
  1070.         xchg    bl,[postbyte_register]
  1071.         xchg    bl,[vex_register]
  1072.         jmp     mmx_nomem_imm8
  1073.       avx_bit_shift_regs_reg:
  1074.         pop     eax
  1075.         lods    byte [esi]
  1076.         call    convert_xmm_register
  1077.         xchg    cl,[operand_size]
  1078.         mov     bl,al
  1079.         jmp     nomem_instruction_ready
  1080.       avx_bit_shift_regs_mem:
  1081.         push    ecx
  1082.         lods    byte [esi]
  1083.         call    get_size_operator
  1084.         call    get_address
  1085.         pop     eax
  1086.         xchg    al,[operand_size]
  1087.         test    al,al
  1088.         jz      instruction_ready
  1089.         cmp     al,16
  1090.         jne     invalid_operand_size
  1091.         jmp     instruction_ready
  1092. avx_pslldq_instruction:
  1093.         mov     [postbyte_register],al
  1094.         mov     [opcode_prefix],66h
  1095.         mov     [base_code],0Fh
  1096.         mov     [extended_code],73h
  1097.         or      [vex_required],1
  1098.         call    take_avx_register
  1099.         mov     [vex_register],al
  1100.         lods    byte [esi]
  1101.         cmp     al,','
  1102.         jne     invalid_operand
  1103.         call    take_avx_register
  1104.         mov     bl,al
  1105.         jmp     mmx_nomem_imm8
  1106.  
  1107. vzeroall_instruction:
  1108.         mov     [operand_size],32
  1109. vzeroupper_instruction:
  1110.         mov     [base_code],0Fh
  1111.         mov     [extended_code],al
  1112.         or      [vex_required],1
  1113.         call    store_instruction_code
  1114.         jmp     instruction_assembled
  1115. vldmxcsr_instruction:
  1116.         or      [vex_required],1
  1117.         jmp     fxsave_instruction
  1118. vcvtph2ps_instruction:
  1119.         mov     [opcode_prefix],66h
  1120.         mov     [supplemental_code],al
  1121.         mov     al,38h
  1122.         jmp     avx_cvtps2pd_instruction
  1123. vcvtps2ph_instruction:
  1124.         call    setup_66_0f_3a
  1125.         or      [vex_required],1
  1126.         lods    byte [esi]
  1127.         call    get_size_operator
  1128.         cmp     al,10h
  1129.         je      vcvtps2ph_reg
  1130.         cmp     al,'['
  1131.         jne     invalid_operand
  1132.         call    get_address
  1133.         lods    byte [esi]
  1134.         cmp     al,','
  1135.         jne     invalid_operand
  1136.         shl     [operand_size],1
  1137.         call    take_avx_register
  1138.         mov     [postbyte_register],al
  1139.         jmp     mmx_imm8
  1140.       vcvtps2ph_reg:
  1141.         lods    byte [esi]
  1142.         call    convert_xmm_register
  1143.         mov     bl,al
  1144.         mov     [operand_size],0
  1145.         lods    byte [esi]
  1146.         cmp     al,','
  1147.         jne     invalid_operand
  1148.         call    take_avx_register
  1149.         mov     [postbyte_register],al
  1150.         jmp     mmx_nomem_imm8
  1151.  
  1152. bmi_instruction:
  1153.         mov     [base_code],0Fh
  1154.         mov     [extended_code],38h
  1155.         mov     [supplemental_code],0F3h
  1156.         mov     [postbyte_register],al
  1157.       bmi_reg:
  1158.         or      [vex_required],1
  1159.         lods    byte [esi]
  1160.         call    get_size_operator
  1161.         cmp     al,10h
  1162.         jne     invalid_operand
  1163.         lods    byte [esi]
  1164.         call    convert_register
  1165.         mov     [vex_register],al
  1166.         lods    byte [esi]
  1167.         cmp     al,','
  1168.         jne     invalid_operand
  1169.         lods    byte [esi]
  1170.         call    get_size_operator
  1171.         cmp     al,10h
  1172.         je      bmi_reg_reg
  1173.         cmp     al,'['
  1174.         jne     invalid_argument
  1175.         call    get_address
  1176.         call    operand_32or64
  1177.         jmp     instruction_ready
  1178.       bmi_reg_reg:
  1179.         lods    byte [esi]
  1180.         call    convert_register
  1181.         mov     bl,al
  1182.         call    operand_32or64
  1183.         jmp     nomem_instruction_ready
  1184.       operand_32or64:
  1185.         mov     al,[operand_size]
  1186.         cmp     al,4
  1187.         je      operand_32or64_ok
  1188.         cmp     al,8
  1189.         jne     invalid_operand_size
  1190.         cmp     [code_type],64
  1191.         jne     invalid_operand
  1192.         or      [rex_prefix],8
  1193.       operand_32or64_ok:
  1194.         ret
  1195. pdep_instruction:
  1196.         mov     [opcode_prefix],0F2h
  1197.         jmp     andn_instruction
  1198. pext_instruction:
  1199.         mov     [opcode_prefix],0F3h
  1200. andn_instruction:
  1201.         mov     [base_code],0Fh
  1202.         mov     [extended_code],38h
  1203.         mov     [supplemental_code],al
  1204.         or      [vex_required],1
  1205.         lods    byte [esi]
  1206.         call    get_size_operator
  1207.         cmp     al,10h
  1208.         jne     invalid_operand
  1209.         lods    byte [esi]
  1210.         call    convert_register
  1211.         mov     [postbyte_register],al
  1212.         lods    byte [esi]
  1213.         cmp     al,','
  1214.         jne     invalid_operand
  1215.         jmp     bmi_reg
  1216. sarx_instruction:
  1217.         mov     [opcode_prefix],0F3h
  1218.         jmp     bzhi_instruction
  1219. shrx_instruction:
  1220.         mov     [opcode_prefix],0F2h
  1221.         jmp     bzhi_instruction
  1222. shlx_instruction:
  1223.         mov     [opcode_prefix],66h
  1224. bzhi_instruction:
  1225.         mov     [base_code],0Fh
  1226.         mov     [extended_code],38h
  1227.         mov     [supplemental_code],al
  1228.         or      [vex_required],1
  1229.         call    get_reg_mem
  1230.         jc      bzhi_reg_reg
  1231.         call    get_vex_source_register
  1232.         jc      invalid_operand
  1233.         call    operand_32or64
  1234.         jmp     instruction_ready
  1235.       bzhi_reg_reg:
  1236.         call    get_vex_source_register
  1237.         jc      invalid_operand
  1238.         call    operand_32or64
  1239.         jmp     nomem_instruction_ready
  1240.       get_vex_source_register:
  1241.         lods    byte [esi]
  1242.         cmp     al,','
  1243.         jne     invalid_operand
  1244.         lods    byte [esi]
  1245.         call    get_size_operator
  1246.         cmp     al,10h
  1247.         jne     no_vex_source_register
  1248.         lods    byte [esi]
  1249.         call    convert_register
  1250.         mov     [vex_register],al
  1251.         clc
  1252.         ret
  1253.       no_vex_source_register:
  1254.         stc
  1255.         ret
  1256. bextr_instruction:
  1257.         mov     [base_code],0Fh
  1258.         mov     [extended_code],38h
  1259.         mov     [supplemental_code],al
  1260.         or      [vex_required],1
  1261.         call    get_reg_mem
  1262.         jc      bextr_reg_reg
  1263.         call    get_vex_source_register
  1264.         jc      bextr_reg_mem_imm32
  1265.         call    operand_32or64
  1266.         jmp     instruction_ready
  1267.       bextr_reg_reg:
  1268.         call    get_vex_source_register
  1269.         jc      bextr_reg_reg_imm32
  1270.         call    operand_32or64
  1271.         jmp     nomem_instruction_ready
  1272.       setup_bextr_imm_opcode:
  1273.         mov     [xop_opcode_map],0Ah
  1274.         mov     [base_code],10h
  1275.         call    operand_32or64
  1276.         ret
  1277.       bextr_reg_mem_imm32:
  1278.         call    get_imm32
  1279.         call    setup_bextr_imm_opcode
  1280.         jmp     store_instruction_with_imm32
  1281.       bextr_reg_reg_imm32:
  1282.         call    get_imm32
  1283.         call    setup_bextr_imm_opcode
  1284.       store_nomem_instruction_with_imm32:
  1285.         call    store_nomem_instruction
  1286.         mov     eax,dword [value]
  1287.         call    mark_relocation
  1288.         stos    dword [edi]
  1289.         jmp     instruction_assembled
  1290.       get_imm32:
  1291.         cmp     al,'('
  1292.         jne     invalid_operand
  1293.         push    edx ebx ecx
  1294.         call    get_dword_value
  1295.         mov     dword [value],eax
  1296.         pop     ecx ebx edx
  1297.         ret
  1298. rorx_instruction:
  1299.         mov     [opcode_prefix],0F2h
  1300.         mov     [base_code],0Fh
  1301.         mov     [extended_code],3Ah
  1302.         mov     [supplemental_code],al
  1303.         or      [vex_required],1
  1304.         call    get_reg_mem
  1305.         jc      rorx_reg_reg
  1306.         call    operand_32or64
  1307.         jmp     mmx_imm8
  1308.       rorx_reg_reg:
  1309.         call    operand_32or64
  1310.         jmp     mmx_nomem_imm8
  1311.  
  1312. fma_instruction_pd:
  1313.         or      [rex_prefix],8
  1314. fma_instruction_ps:
  1315.         mov     [mmx_size],0
  1316.         jmp     avx_instruction_38_setup
  1317. fma_instruction_sd:
  1318.         or      [rex_prefix],8
  1319.         mov     [mmx_size],8
  1320.         jmp     avx_instruction_38_setup
  1321. fma_instruction_ss:
  1322.         mov     [mmx_size],4
  1323.         jmp     avx_instruction_38_setup
  1324.  
  1325. fma4_instruction_p:
  1326.         mov     [mmx_size],0
  1327.         jmp     fma4_instruction_setup
  1328. fma4_instruction_sd:
  1329.         mov     [mmx_size],8
  1330.         jmp     fma4_instruction_setup
  1331. fma4_instruction_ss:
  1332.         mov     [mmx_size],4
  1333.       fma4_instruction_setup:
  1334.         mov     [immediate_size],-2
  1335.         mov     byte [value],0
  1336.         jmp     avx_instruction_3a_setup
  1337.  
  1338. xop_single_source_sd_instruction:
  1339.         or      [vex_required],2
  1340.         mov     [mmx_size],8
  1341.         jmp     xop_instruction_9
  1342. xop_single_source_ss_instruction:
  1343.         or      [vex_required],2
  1344.         mov     [mmx_size],4
  1345.         jmp     xop_instruction_9
  1346. xop_single_source_instruction:
  1347.         or      [vex_required],2
  1348.         mov     [mmx_size],0
  1349.       xop_instruction_9:
  1350.         mov     [base_code],al
  1351.         mov     [xop_opcode_map],9
  1352.         jmp     avx_common
  1353. xop_single_source_128bit_instruction:
  1354.         or      [vex_required],2
  1355.         mov     [mmx_size],16
  1356.         jmp     xop_instruction_9
  1357. xop_triple_source_128bit_instruction:
  1358.         mov     [immediate_size],-1
  1359.         mov     byte [value],0
  1360.         mov     [mmx_size],16
  1361.         jmp     xop_instruction_8
  1362. xop_128bit_instruction:
  1363.         mov     [immediate_size],-2
  1364.         mov     byte [value],0
  1365.         mov     [mmx_size],16
  1366.       xop_instruction_8:
  1367.         mov     [base_code],al
  1368.         mov     [xop_opcode_map],8
  1369.         jmp     avx_common
  1370. xop_pcom_b_instruction:
  1371.         mov     ah,0CCh
  1372.         jmp     xop_pcom_instruction
  1373. xop_pcom_d_instruction:
  1374.         mov     ah,0CEh
  1375.         jmp     xop_pcom_instruction
  1376. xop_pcom_q_instruction:
  1377.         mov     ah,0CFh
  1378.         jmp     xop_pcom_instruction
  1379. xop_pcom_w_instruction:
  1380.         mov     ah,0CDh
  1381.         jmp     xop_pcom_instruction
  1382. xop_pcom_ub_instruction:
  1383.         mov     ah,0ECh
  1384.         jmp     xop_pcom_instruction
  1385. xop_pcom_ud_instruction:
  1386.         mov     ah,0EEh
  1387.         jmp     xop_pcom_instruction
  1388. xop_pcom_uq_instruction:
  1389.         mov     ah,0EFh
  1390.         jmp     xop_pcom_instruction
  1391. xop_pcom_uw_instruction:
  1392.         mov     ah,0EDh
  1393.       xop_pcom_instruction:
  1394.         mov     byte [value],al
  1395.         mov     [mmx_size],16
  1396.         mov     [base_code],ah
  1397.         mov     [xop_opcode_map],8
  1398.         jmp     avx_common
  1399. vpcmov_instruction:
  1400.         or      [vex_required],1
  1401.         mov     [immediate_size],-2
  1402.         mov     byte [value],0
  1403.         mov     [mmx_size],0
  1404.         mov     [base_code],al
  1405.         mov     [xop_opcode_map],8
  1406.         jmp     avx_common
  1407. xop_shift_instruction:
  1408.         mov     [base_code],al
  1409.         or      [vex_required],1
  1410.         mov     [xop_opcode_map],9
  1411.         call    take_avx_register
  1412.         cmp     ah,16
  1413.         jne     invalid_operand
  1414.         mov     [postbyte_register],al
  1415.         lods    byte [esi]
  1416.         cmp     al,','
  1417.         jne     invalid_operand
  1418.         lods    byte [esi]
  1419.         call    get_size_operator
  1420.         cmp     al,'['
  1421.         je      xop_shift_reg_mem
  1422.         cmp     al,10h
  1423.         jne     invalid_operand
  1424.         lods    byte [esi]
  1425.         call    convert_xmm_register
  1426.         mov     [vex_register],al
  1427.         lods    byte [esi]
  1428.         cmp     al,','
  1429.         jne     invalid_operand
  1430.         push    esi
  1431.         xor     cl,cl
  1432.         xchg    cl,[operand_size]
  1433.         lods    byte [esi]
  1434.         call    get_size_operator
  1435.         pop     esi
  1436.         xchg    cl,[operand_size]
  1437.         cmp     al,'['
  1438.         je      xop_shift_reg_reg_mem
  1439.         cmp     al,10h
  1440.         jne     xop_shift_reg_reg_imm
  1441.         call    take_avx_register
  1442.         mov     bl,al
  1443.         xchg    bl,[vex_register]
  1444.         jmp     nomem_instruction_ready
  1445.       xop_shift_reg_reg_mem:
  1446.         or      [rex_prefix],8
  1447.         lods    byte [esi]
  1448.         call    get_size_operator
  1449.         call    get_address
  1450.         jmp     instruction_ready
  1451.       xop_shift_reg_reg_imm:
  1452.         xor     bl,bl
  1453.         xchg    bl,[vex_register]
  1454.         cmp     [base_code],94h
  1455.         jae     invalid_operand
  1456.         add     [base_code],30h
  1457.         mov     [xop_opcode_map],8
  1458.         dec     esi
  1459.         jmp     mmx_nomem_imm8
  1460.       xop_shift_reg_mem:
  1461.         call    get_address
  1462.         lods    byte [esi]
  1463.         cmp     al,','
  1464.         jne     invalid_operand
  1465.         push    esi
  1466.         xor     cl,cl
  1467.         xchg    cl,[operand_size]
  1468.         lods    byte [esi]
  1469.         call    get_size_operator
  1470.         pop     esi
  1471.         xchg    cl,[operand_size]
  1472.         cmp     al,10h
  1473.         jne     xop_shift_reg_mem_imm
  1474.         call    take_avx_register
  1475.         mov     [vex_register],al
  1476.         jmp     instruction_ready
  1477.       xop_shift_reg_mem_imm:
  1478.         cmp     [base_code],94h
  1479.         jae     invalid_operand
  1480.         add     [base_code],30h
  1481.         mov     [xop_opcode_map],8
  1482.         dec     esi
  1483.         jmp     mmx_imm8
  1484.  
  1485. vpermil_2pd_instruction:
  1486.         mov     [immediate_size],-2
  1487.         mov     byte [value],al
  1488.         mov     al,49h
  1489.         jmp     vpermil2_instruction_setup
  1490. vpermil_2ps_instruction:
  1491.         mov     [immediate_size],-2
  1492.         mov     byte [value],al
  1493.         mov     al,48h
  1494.         jmp     vpermil2_instruction_setup
  1495. vpermil2_instruction:
  1496.         mov     [immediate_size],-3
  1497.         mov     byte [value],0
  1498.       vpermil2_instruction_setup:
  1499.         mov     [base_code],0Fh
  1500.         mov     [supplemental_code],al
  1501.         mov     al,3Ah
  1502.         mov     [mmx_size],0
  1503.         jmp     avx_instruction
  1504.  
  1505. tbm_instruction:
  1506.         mov     [xop_opcode_map],9
  1507.         mov     ah,al
  1508.         shr     ah,4
  1509.         and     al,111b
  1510.         mov     [base_code],ah
  1511.         mov     [postbyte_register],al
  1512.         jmp     bmi_reg
  1513.  
  1514. llwpcb_instruction:
  1515.         or      [vex_required],1
  1516.         mov     [xop_opcode_map],9
  1517.         mov     [base_code],12h
  1518.         mov     [postbyte_register],al
  1519.         lods    byte [esi]
  1520.         call    get_size_operator
  1521.         cmp     al,10h
  1522.         jne     invalid_operand
  1523.         lods    byte [esi]
  1524.         call    convert_register
  1525.         mov     bl,al
  1526.         call    operand_32or64
  1527.         jmp     nomem_instruction_ready
  1528. lwpins_instruction:
  1529.         or      [vex_required],1
  1530.         mov     [xop_opcode_map],0Ah
  1531.         mov     [base_code],12h
  1532.         mov     [vex_register],al
  1533.         lods    byte [esi]
  1534.         call    get_size_operator
  1535.         cmp     al,10h
  1536.         jne     invalid_operand
  1537.         lods    byte [esi]
  1538.         call    convert_register
  1539.         mov     [postbyte_register],al
  1540.         lods    byte [esi]
  1541.         cmp     al,','
  1542.         jne     invalid_operand
  1543.         xor     cl,cl
  1544.         xchg    cl,[operand_size]
  1545.         lods    byte [esi]
  1546.         call    get_size_operator
  1547.         cmp     al,10h
  1548.         je      lwpins_reg_reg
  1549.         cmp     al,'['
  1550.         jne     invalid_argument
  1551.         push    ecx
  1552.         call    get_address
  1553.         pop     eax
  1554.         xchg    al,[operand_size]
  1555.         test    al,al
  1556.         jz      lwpins_reg_mem_size_ok
  1557.         cmp     al,4
  1558.         jne     invalid_operand_size
  1559.       lwpins_reg_mem_size_ok:
  1560.         call    prepare_lwpins
  1561.         jmp     store_instruction_with_imm32
  1562.       lwpins_reg_reg:
  1563.         lods    byte [esi]
  1564.         call    convert_register
  1565.         cmp     ah,4
  1566.         jne     invalid_operand_size
  1567.         mov     [operand_size],cl
  1568.         mov     bl,al
  1569.         call    prepare_lwpins
  1570.         jmp     store_nomem_instruction_with_imm32
  1571.       prepare_lwpins:
  1572.         lods    byte [esi]
  1573.         cmp     al,','
  1574.         jne     invalid_operand
  1575.         lods    byte [esi]
  1576.         call    get_imm32
  1577.         call    operand_32or64
  1578.         mov     al,[vex_register]
  1579.         xchg    al,[postbyte_register]
  1580.         mov     [vex_register],al
  1581.         ret
  1582.  
  1583. gather_instruction_pd:
  1584.         or      [rex_prefix],8
  1585. gather_instruction_ps:
  1586.         call    setup_66_0f_38
  1587.         or      [vex_required],4
  1588.         call    take_avx_register
  1589.         mov     [postbyte_register],al
  1590.         lods    byte [esi]
  1591.         cmp     al,','
  1592.         jne     invalid_operand
  1593.         xor     cl,cl
  1594.         xchg    cl,[operand_size]
  1595.         push    ecx
  1596.         lods    byte [esi]
  1597.         call    get_size_operator
  1598.         cmp     al,'['
  1599.         jne     invalid_argument
  1600.         call    get_address
  1601.         pop     eax
  1602.         xchg    al,[operand_size]
  1603.         test    al,al
  1604.         jz      gather_elements_size_ok
  1605.         test    [rex_prefix],8
  1606.         jnz     gather_elements_64bit
  1607.         cmp     al,4
  1608.         jne     invalid_operand_size
  1609.         jmp     gather_elements_size_ok
  1610.       gather_elements_64bit:
  1611.         cmp     al,8
  1612.         jne     invalid_operand_size
  1613.       gather_elements_size_ok:
  1614.         lods    byte [esi]
  1615.         cmp     al,','
  1616.         jne     invalid_operand
  1617.         call    take_avx_register
  1618.         mov     [vex_register],al
  1619.         cmp     al,[postbyte_register]
  1620.         je      disallowed_combination_of_registers
  1621.         mov     al,bl
  1622.         and     al,1111b
  1623.         cmp     al,[postbyte_register]
  1624.         je      disallowed_combination_of_registers
  1625.         cmp     al,[vex_register]
  1626.         je      disallowed_combination_of_registers
  1627.         mov     al,bl
  1628.         shr     al,4
  1629.         cmp     al,0Ch
  1630.         je      gather_vr_128bit
  1631.         mov     al,[rex_prefix]
  1632.         shr     al,3
  1633.         xor     al,[supplemental_code]
  1634.         test    al,1
  1635.         jz      gather_256bit
  1636.         test    [supplemental_code],1
  1637.         jz      invalid_operand_size
  1638.         mov     al,32
  1639.         xchg    al,[operand_size]
  1640.         cmp     al,16
  1641.         jne     invalid_operand_size
  1642.         jmp     instruction_ready
  1643.       gather_256bit:
  1644.         cmp     ah,32
  1645.         jne     invalid_operand_size
  1646.         jmp     instruction_ready
  1647.       gather_vr_128bit:
  1648.         cmp     ah,16
  1649.         je      instruction_ready
  1650.         test    [supplemental_code],1
  1651.         jnz     invalid_operand_size
  1652.         test    [rex_prefix],8
  1653.         jz      invalid_operand_size
  1654.         jmp     instruction_ready
  1655.  
  1656. take_avx_register:
  1657.         lods    byte [esi]
  1658.         call    get_size_operator
  1659.         cmp     al,10h
  1660.         jne     invalid_operand
  1661.         lods    byte [esi]
  1662. convert_avx_register:
  1663.         mov     ah,al
  1664.         and     al,0Fh
  1665.         and     ah,0F0h
  1666.         sub     ah,0B0h
  1667.         jbe     invalid_operand
  1668.         cmp     ah,32
  1669.         ja      invalid_operand
  1670.         cmp     al,8
  1671.         jb      match_register_size
  1672.         cmp     [code_type],64
  1673.         jne     invalid_operand
  1674.         jmp     match_register_size
  1675. store_vex_instruction_code:
  1676.         mov     al,[base_code]
  1677.         cmp     al,0Fh
  1678.         jne     store_xop_instruction_code
  1679.         mov     ah,[extended_code]
  1680.         cmp     ah,38h
  1681.         je      store_vex_0f38_instruction_code
  1682.         cmp     ah,3Ah
  1683.         je      store_vex_0f3a_instruction_code
  1684.         test    [rex_prefix],1011b
  1685.         jnz     store_vex_0f_instruction_code
  1686.         mov     [edi+2],ah
  1687.         mov     byte [edi],0C5h
  1688.         mov     al,[vex_register]
  1689.         not     al
  1690.         shl     al,3
  1691.         mov     ah,[rex_prefix]
  1692.         shl     ah,5
  1693.         and     ah,80h
  1694.         xor     al,ah
  1695.         call    get_vex_lpp_bits
  1696.         mov     [edi+1],al
  1697.         call    check_vex
  1698.         add     edi,3
  1699.         ret
  1700.       get_vex_lpp_bits:
  1701.         cmp     [operand_size],32
  1702.         jne     vex_l_bit_ok
  1703.         or      al,100b
  1704.       vex_l_bit_ok:
  1705.         mov     ah,[opcode_prefix]
  1706.         cmp     ah,66h
  1707.         je      vex_66
  1708.         cmp     ah,0F3h
  1709.         je      vex_f3
  1710.         cmp     ah,0F2h
  1711.         je      vex_f2
  1712.         test    ah,ah
  1713.         jnz     disallowed_combination_of_registers
  1714.         ret
  1715.       vex_f2:
  1716.         or      al,11b
  1717.         ret
  1718.       vex_f3:
  1719.         or      al,10b
  1720.         ret
  1721.       vex_66:
  1722.         or      al,1
  1723.         ret
  1724.       store_vex_0f38_instruction_code:
  1725.         mov     al,11100010b
  1726.         mov     ah,[supplemental_code]
  1727.         jmp     make_c4_vex
  1728.       store_vex_0f3a_instruction_code:
  1729.         mov     al,11100011b
  1730.         mov     ah,[supplemental_code]
  1731.         jmp     make_c4_vex
  1732.       store_vex_0f_instruction_code:
  1733.         mov     al,11100001b
  1734.       make_c4_vex:
  1735.         mov     [edi+3],ah
  1736.         mov     byte [edi],0C4h
  1737.         mov     ah,[rex_prefix]
  1738.         shl     ah,5
  1739.         xor     al,ah
  1740.         mov     [edi+1],al
  1741.         call    check_vex
  1742.         mov     al,[vex_register]
  1743.         xor     al,1111b
  1744.         shl     al,3
  1745.         mov     ah,[rex_prefix]
  1746.         shl     ah,4
  1747.         and     ah,80h
  1748.         or      al,ah
  1749.         call    get_vex_lpp_bits
  1750.         mov     [edi+2],al
  1751.         add     edi,4
  1752.         ret
  1753.       check_vex:
  1754.         cmp     [code_type],64
  1755.         je      vex_ok
  1756.         not     al
  1757.         test    al,11000000b
  1758.         jnz     invalid_operand
  1759.         test    [rex_prefix],40h
  1760.         jnz     invalid_operand
  1761.       vex_ok:
  1762.         ret
  1763. store_xop_instruction_code:
  1764.         mov     [edi+3],al
  1765.         mov     byte [edi],8Fh
  1766.         mov     al,[xop_opcode_map]
  1767.         mov     ah,[rex_prefix]
  1768.         test    ah,40h
  1769.         jz      xop_ok
  1770.         cmp     [code_type],64
  1771.         jne     invalid_operand
  1772.       xop_ok:
  1773.         not     ah
  1774.         shl     ah,5
  1775.         xor     al,ah
  1776.         mov     [edi+1],al
  1777.         mov     al,[vex_register]
  1778.         xor     al,1111b
  1779.         shl     al,3
  1780.         mov     ah,[rex_prefix]
  1781.         shl     ah,4
  1782.         and     ah,80h
  1783.         or      al,ah
  1784.         call    get_vex_lpp_bits
  1785.         mov     [edi+2],al
  1786.         add     edi,4
  1787.         ret
  1788.