Someone67

Untitled

Sep 15th, 2025
143
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 57.55 KB | None | 0 0
  1. import sys
  2.  
  3. import idc
  4. import ida_ua
  5. import ida_ida
  6. import ida_idp
  7. import ida_funcs
  8. import ida_allins
  9. import ida_idaapi
  10. import ida_loader
  11. import ida_kernwin
  12. import ida_typeinf
  13. import ida_hexrays
  14. import traceback
  15.  
  16. #-----------------------------------------------------------------------------
  17. # Util
  18. #-----------------------------------------------------------------------------
  19.  
  20. # an empty / NULL mop_t
  21. NO_MOP = None
  22.  
  23. # EVEX-encoded instruction, intel.hpp (ida sdk)
  24. AUX_EVEX = 0x10000
  25.  
  26. # register widths (bytes)
  27. XMM_SIZE = 16
  28. YMM_SIZE = 32
  29. ZMM_SIZE = 64
  30.  
  31. # type sizes (bytes)
  32. FLOAT_SIZE = 4
  33. DOUBLE_SIZE = 8
  34. DWORD_SIZE = 4
  35. QWORD_SIZE = 8
  36.  
  37. R_ax = 0
  38. R_r15 = 15
  39.  
  40. def size_of_operand(op):
  41.     """
  42.    From ...
  43.        https://reverseengineering.stackexchange.com/questions/19843/how-can-i-get-the-byte-size-of-an-operand-in-ida-pro
  44.    """
  45.     tbyte = 8
  46.     dt_ldbl = 8
  47.     n_bytes = [ 1, 2, 4, 4, 8,
  48.             tbyte, -1, 8, 16, -1,
  49.             -1, 6, -1, 4, 4,
  50.             dt_ldbl, 32, 64 ]
  51.     return n_bytes[op.dtype]
  52.  
  53. def is_x86_idb():
  54.     """
  55.    Return true if an x86 or x86_64 IDB is open.
  56.    """
  57.     return ida_idp.ph.id == ida_idp.PLFM_386
  58.  
  59. def bytes2bits(n):
  60.     """
  61.    Return the number of bits repersented by 'n' bytes.
  62.    """
  63.     return n * 8
  64.  
  65. def is_mem_op(op):
  66.     """
  67.    Return true if the given operand *looks* like a mem op.
  68.    """
  69.     return op.type in [ida_ua.o_mem, ida_ua.o_displ, ida_ua.o_phrase]
  70.  
  71. def is_reg_op(op):
  72.     """
  73.    Return true if the given operand is a register.
  74.    """
  75.     return op.type in [ida_ua.o_reg]
  76.  
  77. def is_avx_reg(op):
  78.     """
  79.    Return true if the given operand is a XMM or YMM register.
  80.    """
  81.     return bool(is_xmm_reg(op) or is_ymm_reg(op))
  82.  
  83. def is_xmm_reg(op):
  84.     """
  85.    Return true if the given operand is a XMM register.
  86.    """
  87.     if op.type != ida_ua.o_reg:
  88.         return False
  89.     if op.dtype != ida_ua.dt_byte16:
  90.         return False
  91.     return True
  92.  
  93. def is_ymm_reg(op):
  94.     """
  95.    Return true if the given operand is a YMM register.
  96.    """
  97.     if op.type != ida_ua.o_reg:
  98.         return False
  99.     if op.dtype != ida_ua.dt_byte32:
  100.         return False
  101.     return True
  102.  
  103. def is_avx_512(insn):
  104.     """
  105.    Return true if the given insn_t is an AVX512 instruction.
  106.    """
  107.     return bool(insn.auxpref & AUX_EVEX)
  108.  
  109. def is_gpr32(op):
  110.     return op.type == ida_ua.o_reg and op.dtype == ida_ua.dt_dword and R_ax <= op.reg <= R_di
  111.  
  112. def is_gpr64(op):
  113.     return op.type == ida_ua.o_reg and op.dtype == ida_ua.dt_qword and R_ax <= op.reg <= R_r15
  114.  
  115. def is_gpr(op):
  116.     return is_gpr32(op) or is_gpr64(op)
  117.  
  118. #-----------------------------------------------------------------------------
  119. # Microcode Helpers
  120. #-----------------------------------------------------------------------------
  121.  
  122. def get_ymm_mreg(xmm_mreg):
  123.     """
  124.    Return the YMM microcode register for a given XMM register.
  125.    """
  126.     xmm_reg = ida_hexrays.mreg2reg(xmm_mreg, XMM_SIZE)
  127.     xmm_name = ida_idp.get_reg_name(xmm_reg, XMM_SIZE)
  128.     xmm_number = int(xmm_name.split("mm")[-1])
  129.  
  130.     # compute the ymm mreg id
  131.     ymm_reg = ida_idp.str2reg("ymm%u" % xmm_number)
  132.     ymm_mreg = ida_hexrays.reg2mreg(ymm_reg)
  133.  
  134.     # sanity check...
  135.     xmm_name = ida_hexrays.get_mreg_name(xmm_mreg, XMM_SIZE)
  136.     ymm_name = ida_hexrays.get_mreg_name(ymm_mreg, YMM_SIZE)
  137.     assert xmm_name[1:] == ymm_name[1:], "Reg escalation did not work... (%s, %s)" % (xmm_name, ymm_name)
  138.  
  139.     # return the ymm microcode register id
  140.     return ymm_mreg
  141.  
  142. def clear_upper(cdg, xmm_mreg, op_size=XMM_SIZE):
  143.     """
  144.    Extend the given xmm reg, clearing the upper bits (through ymm).
  145.    """
  146.     ymm_mreg = get_ymm_mreg(xmm_mreg)
  147.  
  148.     xmm_mop = ida_hexrays.mop_t(xmm_mreg, op_size)
  149.     ymm_mop = ida_hexrays.mop_t(ymm_mreg, YMM_SIZE)
  150.  
  151.     return cdg.emit(ida_hexrays.m_xdu, xmm_mop, NO_MOP, ymm_mop)
  152.  
  153. def store_operand_hack(cdg, op_num, new_mop):
  154.     """
  155.    XXX: why is there a load_operand(), but no inverse.. ?
  156.    """
  157.  
  158.     # emit a 'load' operation...
  159.     memX = cdg.load_operand(op_num)
  160.     assert memX != ida_hexrays.mr_none, "Invalid op_num..."
  161.  
  162.     # since this is gonna be kind of hacky, let's make sure a load was actually emitted
  163.     ins = cdg.mb.tail
  164.     if ins.opcode != ida_hexrays.m_ldx:
  165.         if ins.prev.opcode != ida_hexrays.m_ldx:
  166.             raise ValueError("Hehe, hack failed :-( (insn 0x%08X op 0x%02X)" % (cdg.insn.ea, ins.opcode))
  167.         prev = ins.prev
  168.         cdg.mb.make_nop(ins)
  169.         ins = prev
  170.     assert ins.d.size == new_mop.size, "%u vs %u" % (new_mop.size, ins.d.size)
  171.  
  172.     # convert the load to a store :^)
  173.     ins.opcode = ida_hexrays.m_stx
  174.     ins.d = ins.r   # d = op mem offset
  175.     ins.r = ins.l   # r = op mem segm
  176.     ins.l = new_mop # l = value to store (mop_t)
  177.  
  178.     return ins
  179.  
  180. #-----------------------------------------------------------------------------
  181. # Intrinsic Helper
  182. #-----------------------------------------------------------------------------
  183.  
  184. class AVXIntrinsic(object):
  185.     """
  186.    This class helps with generating simple intrinsic calls in microcode.
  187.    """
  188.  
  189.     def __init__(self, cdg, name):
  190.         self.cdg = cdg
  191.  
  192.         # call info, sort of like func_type_data_t()
  193.         self.call_info = ida_hexrays.mcallinfo_t()
  194.         self.call_info.cc = ida_typeinf.CM_CC_FASTCALL
  195.         self.call_info.callee = ida_idaapi.BADADDR
  196.         self.call_info.solid_args = 0
  197.         self.call_info.role = ida_hexrays.ROLE_UNK
  198.         self.call_info.flags = ida_hexrays.FCI_SPLOK | ida_hexrays.FCI_FINAL | ida_hexrays.FCI_PROP
  199.  
  200.         # the actual 'call' microcode insn
  201.         self.call_insn = ida_hexrays.minsn_t(cdg.insn.ea)
  202.         self.call_insn.opcode = ida_hexrays.m_call
  203.         self.call_insn.l.make_helper(name)
  204.         self.call_insn.d.t = ida_hexrays.mop_f
  205.         self.call_insn.d.f = self.call_info
  206.  
  207.         # temp return type
  208.         self.call_info.return_type = ida_typeinf.tinfo_t()
  209.         self.call_insn.d.size = 0
  210.  
  211.     def set_return_reg(self, mreg, type_string):
  212.         """
  213.        Set the return register of the function call, with a type string.
  214.        """
  215.         ret_tinfo = ida_typeinf.tinfo_t()
  216.         ret_tinfo.get_named_type(None, type_string)
  217.         return self.set_return_reg_type(mreg, ret_tinfo)
  218.  
  219.     def set_return_reg_basic(self, mreg, basic_type):
  220.         """
  221.        Set the return register of the function call, with a basic type assigned.
  222.        """
  223.         ret_tinfo = ida_typeinf.tinfo_t(basic_type)
  224.         return self.set_return_reg_type(mreg, ret_tinfo)
  225.  
  226.     def set_return_reg_type(self, mreg, ret_tinfo):
  227.         """
  228.        Set the return register of the function call, with a complex type.
  229.        """
  230.         self.call_info.return_type = ret_tinfo
  231.         self.call_insn.d.size = ret_tinfo.get_size()
  232.  
  233.         self.mov_insn = ida_hexrays.minsn_t(self.cdg.insn.ea)
  234.         self.mov_insn.opcode = ida_hexrays.m_mov
  235.         self.mov_insn.l.t = ida_hexrays.mop_d
  236.         self.mov_insn.l.d = self.call_insn
  237.         self.mov_insn.l.size = self.call_insn.d.size
  238.         self.mov_insn.d.t = ida_hexrays.mop_r
  239.         self.mov_insn.d.r = mreg
  240.         self.mov_insn.d.size = self.call_insn.d.size
  241.  
  242.         if ret_tinfo.is_decl_floating():
  243.             self.mov_insn.set_fpinsn()
  244.  
  245.     def add_argument_reg(self, mreg, type_string):
  246.         """
  247.        Add a regeister argument with a given type string to the function argument list.
  248.        """
  249.         op_tinfo = ida_typeinf.tinfo_t()
  250.         op_tinfo.get_named_type(None, type_string)
  251.         return self.add_argument_reg_type(mreg, op_tinfo)
  252.  
  253.     def add_argument_reg_basic(self, mreg, basic_type):
  254.         """
  255.        Add a regeister argument with a basic type to the function argument list.
  256.        """
  257.         op_tinfo = ida_typeinf.tinfo_t(basic_type)
  258.         return self.add_argument_reg_type(mreg, op_tinfo)
  259.  
  260.     def add_argument_reg_type(self, mreg, op_tinfo):
  261.         """
  262.        Add a register argument of the given type to the function argument list.
  263.        """
  264.         call_arg = ida_hexrays.mcallarg_t()
  265.         call_arg.t = ida_hexrays.mop_r
  266.         call_arg.r = mreg
  267.         call_arg.type = op_tinfo
  268.         call_arg.size = op_tinfo.get_size()
  269.  
  270.         self.call_info.args.push_back(call_arg)
  271.         self.call_info.solid_args += 1
  272.  
  273.     def add_argument_imm(self, value, basic_type):
  274.         """
  275.        Add an immediate value to the function argument list.
  276.        """
  277.         op_tinfo = ida_typeinf.tinfo_t(basic_type)
  278.  
  279.         mop_imm = ida_hexrays.mop_t()
  280.         mop_imm.make_number(value, op_tinfo.get_size())
  281.        
  282.         call_arg = ida_hexrays.mcallarg_t()
  283.         call_arg.make_number(value, op_tinfo.get_size())
  284.         call_arg.type = op_tinfo
  285.  
  286.         self.call_info.args.push_back(call_arg)
  287.         self.call_info.solid_args += 1
  288.  
  289.     def emit(self):
  290.         """
  291.        Emit the intrinsic call to the generated microcode.
  292.        """
  293.         self.cdg.mb.insert_into_block(self.mov_insn, self.cdg.mb.tail)
  294.  
  295.  
  296. class garbage_remover_t(ida_hexrays.minsn_visitor_t):
  297.     """
  298.    remove duplicate instructions introduced by store_operand_hack?
  299.    """
  300.     def __init__(self, ea):
  301.         ida_hexrays.minsn_visitor_t.__init__(self)
  302.         self.addr = ea
  303.         self.insns = []
  304.  
  305.     def visit_minsn(self):
  306.         ins = self.curins
  307.  
  308.         if ins.ea == self.addr:
  309.             self.insns.append(ins)
  310.         return 0
  311.  
  312. #-----------------------------------------------------------------------------
  313. # AVX Lifter
  314. #-----------------------------------------------------------------------------
  315.  
  316. class AVXLifter(ida_hexrays.microcode_filter_t):
  317.     """
  318.    A Hex-Rays microcode filter to lift AVX instructions during decompilation.
  319.    """
  320.  
  321.     def __init__(self):
  322.         super(AVXLifter, self).__init__()
  323.         self.cdg = None
  324.         self._avx_handlers = \
  325.         {
  326.  
  327.             # Compares (Scalar, Single / Double-Precision)
  328.             ida_allins.NN_vcomiss: self.vcomiss,
  329.             ida_allins.NN_vcomisd: self.vcomisd,
  330.             ida_allins.NN_vucomiss: self.vucomiss,
  331.             ida_allins.NN_vucomisd: self.vucomisd,
  332.  
  333.             # Conversions
  334.             ida_allins.NN_vcvttss2si: self.vcvttss2si,
  335.             ida_allins.NN_vcvttsd2si: self.vcvttsd2si,
  336.             ida_allins.NN_vcvtdq2ps: self.vcvtdq2ps,
  337.             ida_allins.NN_vcvtsi2ss: self.vcvtsi2ss,
  338.             ida_allins.NN_vcvtsi2sd: self.vcvtsi2sd,
  339.             ida_allins.NN_vcvtps2pd: self.vcvtps2pd,
  340.             ida_allins.NN_vcvtss2sd: self.vcvtss2sd,
  341.             ida_allins.NN_vcvtsd2ss: self.vcvtsd2ss,
  342.  
  343.             # Mov (DWORD / QWORD)
  344.             ida_allins.NN_vmovd: self.vmovd,
  345.             ida_allins.NN_vmovq: self.vmovq,
  346.  
  347.             # Mov (Scalar, Single / Double-Precision)
  348.             ida_allins.NN_vmovss: self.vmovss,
  349.             ida_allins.NN_vmovsd: self.vmovsd,
  350.  
  351.             # Mov (Packed Single-Precision, Packed Integers)
  352.             ida_allins.NN_vmovaps: self.v_mov_ps_dq,
  353.             ida_allins.NN_vmovups: self.v_mov_ps_dq,
  354.             ida_allins.NN_vmovdqa: self.v_mov_ps_dq,
  355.             ida_allins.NN_vmovdqu: self.v_mov_ps_dq,
  356.  
  357.             ida_allins.NN_vmovupd: self.v_mov_ps_dq,
  358.             ida_allins.NN_vmovapd: self.v_mov_ps_dq,
  359.  
  360.             # Bitwise (Packed Single-Precision)
  361.             ida_allins.NN_vorps: self.v_bitwise_ps,
  362.             ida_allins.NN_vandps: self.v_bitwise_ps,
  363.             ida_allins.NN_vandpd: self.v_bitwise_ps,
  364.             ida_allins.NN_vxorps: self.v_bitwise_ps,
  365.             ida_allins.NN_vxorpd: self.v_bitwise_ps,
  366.  
  367.             # Math (Scalar Single-Precision)
  368.             ida_allins.NN_vaddss: self.v_math_ss,
  369.             ida_allins.NN_vsubss: self.v_math_ss,
  370.             ida_allins.NN_vmulss: self.v_math_ss,
  371.             ida_allins.NN_vdivss: self.v_math_ss,
  372.  
  373.             # Math (Scalar Double-Precision)
  374.             ida_allins.NN_vaddsd: self.v_math_sd,
  375.             ida_allins.NN_vsubsd: self.v_math_sd,
  376.             ida_allins.NN_vmulsd: self.v_math_sd,
  377.             ida_allins.NN_vdivsd: self.v_math_sd,
  378.  
  379.             # Math (Packed Single-Precision)
  380.             ida_allins.NN_vaddps: self.v_math_ps,
  381.             ida_allins.NN_vsubps: self.v_math_ps,
  382.             ida_allins.NN_vmulps: self.v_math_ps,
  383.             ida_allins.NN_vdivps: self.v_math_ps,
  384.  
  385.             ida_allins.NN_vaddpd: self.v_math_ps,
  386.             ida_allins.NN_vsubpd: self.v_math_ps,
  387.             ida_allins.NN_vmulpd: self.v_math_ps,
  388.  
  389.             # Square Root
  390.             ida_allins.NN_vsqrtss: self.vsqrtss,
  391.             ida_allins.NN_vsqrtps: self.vsqrtps,
  392.  
  393.             # Shuffle (Packed Single-Precision)
  394.             ida_allins.NN_vshufps: self.vshufps,
  395.  
  396.             ida_allins.NN_vfmadd132sd: self.vfmadd132sd,
  397.             ida_allins.NN_vfmadd213sd: self.vfmadd213sd,
  398.             ida_allins.NN_vfmadd231sd: self.vfmadd231sd,
  399.             ida_allins.NN_vfnmadd132sd: self.vfnmadd132sd,
  400.             ida_allins.NN_vfnmadd213sd: self.vfnmadd213sd,
  401.             ida_allins.NN_vfnmadd231sd: self.vfnmadd231sd,
  402.             ida_allins.NN_vmaxsd: self.vmaxsd,
  403.             ida_allins.NN_vminsd: self.vminsd,
  404.             ida_allins.NN_vpxor: self.vpxor,
  405.             ida_allins.NN_vfmsub132sd: self.vfmsub132sd,
  406.             ida_allins.NN_vfmsub213sd: self.vfmsub213sd,
  407.             ida_allins.NN_vfmsub231sd: self.vfmsub231sd,
  408.             ida_allins.NN_vroundsd: self.vroundsd,
  409.  
  410.             #vblendvpd
  411.             #vfmadd231pd
  412.             #vcmpnltsd
  413.  
  414.             #vsqrtsd
  415.             #vunpckhpd
  416.             #vextractf128
  417.             #vpermilpd
  418.             #vperm2f128
  419.             #vblendpd
  420.         }
  421.  
  422.     def match(self, cdg):
  423.         """
  424.        Return true if the lifter supports this AVX instruction.
  425.        """
  426.         if is_avx_512(cdg.insn):
  427.             return False
  428.         return cdg.insn.itype in self._avx_handlers
  429.  
  430.     def remove_store_operand_hack_dupinstrs(self, cdg, insn):
  431.         gc = garbage_remover_t(insn.ea)
  432.         cdg.mb.for_all_insns(gc)
  433.         if len(gc.insns) >= 1:
  434.             print(f'found {len(gc.insns)} duplicate microcode instructions for {insn.ea:x} ')
  435.             for instr in gc.insns:
  436.                 cdg.mb.remove_from_block(instr)
  437.  
  438.     def apply(self, cdg):
  439.         """
  440.        Generate microcode for the current instruction.
  441.        """
  442.         try:
  443.             cdg.store_operand = lambda x, y: store_operand_hack(cdg, x, y)
  444.             self.remove_store_operand_hack_dupinstrs(cdg, cdg.insn)
  445.             self.cdg = cdg
  446.             result = self._avx_handlers[cdg.insn.itype](cdg, cdg.insn)
  447.             self.cdg = None
  448.             return result
  449.         except Exception as err:
  450.             print(f'addr = {cdg.insn.ea:x}, x  = {traceback.format_exc()}')
  451.             return ida_hexrays.MERR_INSN
  452.  
  453.     def install(self):
  454.         """
  455.        Install the AVX codegen lifter.
  456.        """
  457.         ida_hexrays.install_microcode_filter(self, True)
  458.         print("Installed AVX lifter... (%u instr supported)" % len(self._avx_handlers))
  459.  
  460.     def remove(self):
  461.         """
  462.        Remove the AVX codegen lifter.
  463.        """
  464.         ida_hexrays.install_microcode_filter(self, False)
  465.         print("Removed AVX lifter...")
  466.  
  467.     def decode_error(self, msg):
  468.         print(f'{self.cdg.insn.ea:x}: {msg}')
  469.         return ida_hexrays.MERR_INSN
  470.  
  471.     def xmmreg(self, op):
  472.         if is_xmm_reg(op):
  473.             result = ida_hexrays.reg2mreg(op.reg)
  474.         else:
  475.             result = None
  476.         return result
  477.  
  478.     def xmm_or_mem(self, op):
  479.         if is_xmm_reg(op):
  480.             result = ida_hexrays.reg2mreg(op.reg)
  481.         elif is_mem_op(op):
  482.             result = self.cdg.load_operand(op.n)
  483.         else:
  484.             result = None
  485.         return result
  486.  
  487.     def xmm1_xmm2_or_mem2(self):
  488.         result = None
  489.         insn = self.cdg.insn
  490.         s = self.xmm_or_mem(insn.Op2)
  491.         if s is not None:
  492.             d = self.xmmreg(insn.Op1)
  493.             if d is not None:
  494.                 result = (d, s)
  495.             else:
  496.                 self.decode_error('op1')
  497.         else:
  498.             self.decode_error('op2')
  499.         return result
  500.  
  501.     def xmm1_xmm2_xmm3_or_mem3(self):
  502.         result = None
  503.         insn = self.cdg.insn
  504.         c = self.xmm_or_mem(insn.Op3)
  505.         if c is not None:
  506.             b = self.xmmreg(insn.Op2)
  507.             if b is not None:
  508.                 a = self.xmmreg(insn.Op1)
  509.                 if a is not None:
  510.                     result = (a, b, c)
  511.                 else:
  512.                     self.decode_error('op1')
  513.             else:
  514.                 self.decode_error('op2')
  515.         else:
  516.             self.decode_error('op3')
  517.         return result
  518.  
  519.     def save_upper_bits(self, mreg, reg_size):
  520.         # create a temp register to compute the final result into
  521.         treg = self.cdg.mba.alloc_kreg(reg_size)
  522.  
  523.         # populate the dest reg
  524.         self.cdg.emit(ida_hexrays.m_mov, reg_size, mreg, 0, treg, 0)
  525.         return treg
  526.  
  527.     def alloc_reg(self, reg_size):
  528.         return self.cdg.mba.alloc_kreg(reg_size)
  529.  
  530.     def free_reg(self, reg, reg_size):
  531.         self.cdg.mba.free_kreg(reg, reg_size)
  532.  
  533.     def emit_fp_instr_l_r_d(self, opcode, l, r, d):
  534.         instr = ida_hexrays.minsn_t(self.cdg.insn.ea)
  535.         instr.opcode = opcode
  536.         instr.l = l
  537.         instr.r = r
  538.         instr.d = d
  539.         instr.set_fpinsn()
  540.         self.cdg.mb.insert_into_block(instr, self.cdg.mb.tail)
  541.  
  542.     def emit_fp_instr_l_d(self, opcode, l, d):
  543.         instr = ida_hexrays.minsn_t(self.cdg.insn.ea)
  544.         instr.opcode = opcode
  545.         instr.l = l
  546.         instr.r.zero()
  547.         instr.d = d
  548.         instr.set_fpinsn()
  549.         self.cdg.mb.insert_into_block(instr, self.cdg.mb.tail)
  550.  
  551.     def emit_clear_dst(self, d):
  552.         nil = ida_hexrays.mop_t()
  553.         nil.make_number(0, d.size)
  554.         instr = ida_hexrays.minsn_t(self.cdg.insn.ea)
  555.         instr.opcode = ida_hexrays.m_mov
  556.         instr.l = nil
  557.         instr.r.zero()
  558.         instr.d = d
  559.         self.cdg.mb.insert_into_block(instr, self.cdg.mb.tail)
  560.  
  561.     def emit_clear_ymm(self, xmm_mreg):
  562.         #nil = ida_hexrays.mop_t()
  563.         #nil.make_number(0, YMM_SIZE)
  564.         t = self.alloc_reg(YMM_SIZE)
  565.         t_mop = ida_hexrays.mop_t(t, YMM_SIZE)
  566.  
  567.         xmm_mop = ida_hexrays.mop_t(xmm_mreg, XMM_SIZE)
  568.  
  569.         ymm_mreg = get_ymm_mreg(xmm_mreg)
  570.         ymm_mop = ida_hexrays.mop_t(ymm_mreg, YMM_SIZE)
  571.         self.cdg.emit(ida_hexrays.m_xdu, xmm_mop, NO_MOP, t_mop)
  572.         self.cdg.emit(ida_hexrays.m_mov, t_mop, NO_MOP, ymm_mop)
  573.         self.free_reg(t, YMM_SIZE)
  574.  
  575.  
  576.     def emit_clear_flag(self, mreg):
  577.         self.emit_clear_dst(ida_hexrays.mop_t(mreg, 1))
  578.  
  579.     def emit_copy_bits_xmm_wide(self, dst, src):
  580.         self.cdg.emit(ida_hexrays.m_mov, ida_hexrays.mop_t(src, XMM_SIZE), NO_MOP, ida_hexrays.mop_t(dst, XMM_SIZE))
  581.  
  582.     def emit_function_call2(self, r, func_name, p1, p2, is_pure):
  583.         avx_intrinsic = AVXIntrinsic(self.cdg, func_name)
  584.         (reg, typ) = p1
  585.         avx_intrinsic.add_argument_reg_basic(reg, typ)
  586.         (reg, typ) = p2
  587.         avx_intrinsic.add_argument_reg_basic(reg, typ)
  588.         (reg, typ) = r
  589.         avx_intrinsic.set_return_reg_basic(reg, typ)
  590.         if is_pure:
  591.             avx_intrinsic.call_info.flags |= ida_hexrays.FCI_PURE
  592.         avx_intrinsic.emit()
  593.  
  594.     #--------------------------------------------------------------------------
  595.     # Compare Instructions
  596.     #--------------------------------------------------------------------------
  597.  
  598.     def v_comis_(self, data_size):
  599.         """
  600.        COMISS (all versions)
  601.        RESULT := OrderedCompare(DEST[31:0] <> SRC[31:0]) {
  602.        (V)UCOMISS (all versions)
  603.        RESULT := UnorderedCompare(DEST[31:0] <> SRC[31:0]) {
  604.        COMISD (all versions)
  605.        RESULT := OrderedCompare(DEST[63:0] <> SRC[63:0]) {
  606.        (V)UCOMISD (all versions)
  607.        RESULT := UnorderedCompare(DEST[63:0] <> SRC[63:0]) {
  608.  
  609.        (* Set EFLAGS *) CASE (RESULT) OF
  610.        UNORDERED: ZF,PF,CF := 111;
  611.        GREATER_THAN: ZF,PF,CF := 000;
  612.        LESS_THAN: ZF,PF,CF := 001;
  613.        EQUAL: ZF,PF,CF := 100;
  614.        ESAC;
  615.        OF, AF, SF := 0; }
  616.        """
  617.         regs = self.xmm1_xmm2_or_mem2()
  618.         if regs is None:
  619.             return ida_hexrays.MERR_INSN
  620.  
  621.         (l_reg, r_reg) = regs
  622.         L = ida_hexrays.mop_t(l_reg, data_size)
  623.         R = ida_hexrays.mop_t(r_reg, data_size)
  624.         self.emit_function_call2(
  625.             (ida_hexrays.mr_pf, ida_typeinf.BTF_BOOL),
  626.             'std::isunordered',
  627.             (l_reg, ida_typeinf.BTF_DOUBLE),
  628.             (r_reg, ida_typeinf.BTF_DOUBLE),
  629.             True)
  630.         self.emit_fp_instr_l_r_d(ida_hexrays.m_setb, L, R, ida_hexrays.mop_t(ida_hexrays.mr_cf, 1))
  631.         self.emit_fp_instr_l_r_d(ida_hexrays.m_setz, L, R, ida_hexrays.mop_t(ida_hexrays.mr_zf, 1))
  632.         self.emit_clear_flag(ida_hexrays.mr_of)
  633.         #self.emit_clear_flag(ida_hexrays.reg2mreg(R_af))
  634.         self.emit_clear_flag(ida_hexrays.mr_sf)
  635.  
  636.         return ida_hexrays.MERR_OK
  637.  
  638.     def vcomiss(self, cdg, insn):
  639.         """
  640.        VCOMISS xmm1, xmm2/m32
  641.        """
  642.         return self.v_comis_(FLOAT_SIZE)
  643.  
  644.     def vucomiss(self, cdg, insn):
  645.         """
  646.        VUCOMISS xmm1, xmm2/m32
  647.        """
  648.         return self.v_comis_(FLOAT_SIZE)
  649.  
  650.     def vcomisd(self, cdg, insn):
  651.         """
  652.        VCOMISD xmm1, xmm2/m64
  653.        """
  654.         return self.v_comis_(DOUBLE_SIZE)
  655.  
  656.     def vucomisd(self, cdg, insn):
  657.         """
  658.        VUCOMISD xmm1, xmm2/m64
  659.        """
  660.         return self.v_comis_(DOUBLE_SIZE)
  661.  
  662.     #-------------------------------------------------------------------------
  663.     # Conversion Instructions
  664.     #-------------------------------------------------------------------------
  665.  
  666.     def vcvttss2si(self, cdg, insn):
  667.         """
  668.        CVTTSS2SI r64, xmm1/m32
  669.        CVTTSS2SI r32, xmm1/m32
  670.        """
  671.         insn.itype = ida_allins.NN_cvttss2si
  672.         return ida_hexrays.MERR_INSN
  673.  
  674.     def vcvttsd2si(self, cdg, insn):
  675.         """
  676.        VCVTTSD2SI r32, xmm1/m64
  677.        VCVTTSD2SI r64, xmm1/m64
  678.        """
  679.         s1 = self.xmm_or_mem(insn.Op2)
  680.         if s1 is None:
  681.             return self.decode_error('op2 - expected xmm reg or mem ptr')
  682.  
  683.         dst_size = 0
  684.         if is_gpr32(insn.Op1):
  685.             dst_size = 4
  686.         elif is_gpr64(insn.Op1):
  687.             dst_size = 8
  688.         else:
  689.             return self.decode_error('op1 - expected gpr32 or gpr64')
  690.  
  691.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  692.  
  693.         s1_mop = ida_hexrays.mop_t(s1, DOUBLE_SIZE)
  694.         t1 = self.alloc_reg(dst_size)
  695.         t1_mop = ida_hexrays.mop_t(t1, dst_size)
  696.         cdg.emit(ida_hexrays.m_f2i, s1_mop, NO_MOP, t1_mop)
  697.         cdg.emit(ida_hexrays.m_mov, dst_size, t1, 0, d_reg, 0)
  698.         return ida_hexrays.MERR_OK
  699.  
  700.     def vcvtdq2ps(self, cdg, insn):
  701.         """
  702.        VCVTDQ2PS xmm1, xmm2/m128
  703.        VCVTDQ2PS ymm1, ymm2/m256
  704.        """
  705.         op_size = XMM_SIZE if is_xmm_reg(insn.Op1) else YMM_SIZE
  706.  
  707.         # op2 -- m128/m256
  708.         if is_mem_op(insn.Op2):
  709.             r_reg = cdg.load_operand(1)
  710.  
  711.         # op2 -- xmm2/ymm2
  712.         else:
  713.             assert is_avx_reg(insn.Op2)
  714.             r_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  715.  
  716.         # op1 -- xmm1/ymm1
  717.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  718.  
  719.         #
  720.         # intrinsics:
  721.         #     __m128 _mm_cvtepi32_ps (__m128i a)
  722.         #     __m256 _mm256_cvtepi32_ps (__m256i a)
  723.         #
  724.  
  725.         bit_size = bytes2bits(op_size)
  726.         bit_str = str(bit_size) if op_size == YMM_SIZE else ""
  727.         intrinsic_name = "_mm%s_cvtepi32_ps" % bit_str
  728.  
  729.         avx_intrinsic = AVXIntrinsic(cdg, intrinsic_name)
  730.         avx_intrinsic.add_argument_reg(r_reg, "__m%ui" % bit_size)
  731.         avx_intrinsic.set_return_reg(d_reg, "__m%u" % bit_size)
  732.         avx_intrinsic.emit()
  733.  
  734.         # clear upper 128 bits of ymm1
  735.         if op_size == XMM_SIZE:
  736.             clear_upper(cdg, d_reg)
  737.  
  738.         return ida_hexrays.MERR_OK
  739.  
  740.     def _vcvtsi2_ss_sd(self, cdg, insn, dst_size):
  741.         """
  742.        VCVTSI2SS xmm1, xmm2, r/m32
  743.        VCVTSI2SS xmm1, xmm2, r/m64
  744.  
  745.        VCVTSI2SD xmm1, xmm2, r/m32
  746.        VCVTSI2SD xmm1, xmm2, r/m64
  747.        """
  748.         src2_size = size_of_operand(insn.Op3)
  749.  
  750.         # op3 -- m32/m64
  751.         if is_mem_op(insn.Op3):
  752.             r_reg = cdg.load_operand(2)
  753.  
  754.         # op3 -- r32/r64
  755.         else:
  756.             assert is_reg_op(insn.Op3)
  757.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  758.  
  759.         # op2 -- xmm2
  760.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  761.  
  762.         # op1 -- xmm1
  763.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  764.  
  765.         # create a temp register to compute the final result into
  766.         src1_treg = cdg.mba.alloc_kreg(XMM_SIZE)
  767.         src1_treg_mop_data_size = ida_hexrays.mop_t(src1_treg, dst_size)
  768.  
  769.         # create a temp register to downcast a double to a float (if needed)
  770.         src2_treg = cdg.mba.alloc_kreg(src2_size)
  771.         src2_treg_mop_src2_size = ida_hexrays.mop_t(src2_treg, src2_size)
  772.  
  773.         # copy xmm2 into the temp result reg, as we need its upper 3 dwords
  774.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, l_reg, 0, src1_treg, 0)
  775.  
  776.         # convert the integer (op3) to a float/double depending on its size
  777.         cdg.emit(ida_hexrays.m_i2f, src2_size, r_reg, 0, src2_treg, 0)
  778.  
  779.         if dst_size != src2_size:
  780.             # reduce precision on the converted floating point value if needed (only r64/m64)
  781.             cdg.emit(ida_hexrays.m_f2f, src2_treg_mop_src2_size, NO_MOP, src1_treg_mop_data_size)
  782.         else:
  783.             cdg.emit(ida_hexrays.m_mov, src2_treg_mop_src2_size, NO_MOP, src1_treg_mop_data_size)
  784.  
  785.         # transfer the fully computed temp register to the real dest reg
  786.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, src1_treg, 0, d_reg, 0)
  787.         cdg.mba.free_kreg(src1_treg, XMM_SIZE)
  788.         cdg.mba.free_kreg(src2_treg, src2_size)
  789.  
  790.         # clear upper 128 bits of ymm1
  791.         clear_upper(cdg, d_reg)
  792.  
  793.         return ida_hexrays.MERR_OK
  794.  
  795.     def vcvtsi2ss(self, cdg, insn):
  796.         return self._vcvtsi2_ss_sd(cdg, insn, FLOAT_SIZE)
  797.  
  798.     def vcvtsi2sd(self, cdg, insn):
  799.         return self._vcvtsi2_ss_sd(cdg, insn, DOUBLE_SIZE)
  800.  
  801.     def vcvtps2pd(self, cdg, insn):
  802.         """
  803.        VCVTPS2PD xmm1, xmm2/m64
  804.        VCVTPS2PD ymm1, ymm2/m128
  805.        """
  806.         src_size = QWORD_SIZE if is_xmm_reg(insn.Op1) else XMM_SIZE
  807.  
  808.         # op2 -- m64/m128
  809.         if is_mem_op(insn.Op2):
  810.             r_reg = cdg.load_operand(1)
  811.  
  812.         # op2 -- xmm2/ymm2
  813.         else:
  814.             assert is_avx_reg(insn.Op2)
  815.             r_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  816.  
  817.         # op1 -- xmm1/ymm1
  818.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  819.  
  820.         #
  821.         # intrinsics:
  822.         #   - __m128d _mm_cvtps_pd (__m128 a)
  823.         #   - __m256d _mm256_cvtps_pd (__m128 a)
  824.         #
  825.  
  826.         bit_size = bytes2bits(src_size * 2)
  827.         bit_str = "256" if (src_size * 2) == YMM_SIZE else ""
  828.         intrinsic_name = "_mm%s_cvtps_pd" % bit_str
  829.  
  830.         avx_intrinsic = AVXIntrinsic(cdg, intrinsic_name)
  831.         avx_intrinsic.add_argument_reg(r_reg, "__m128")
  832.         avx_intrinsic.set_return_reg(d_reg, "__m%ud" % bit_size)
  833.         avx_intrinsic.emit()
  834.        
  835.         # clear upper 128 bits of ymm1
  836.         if src_size == QWORD_SIZE:
  837.             clear_upper(cdg, d_reg)
  838.  
  839.         return ida_hexrays.MERR_OK
  840.  
  841.     def vcvtss2sd(self, cdg, insn):
  842.         """
  843.        VCVTSS2SD xmm1, xmm2, r/m32
  844.        """
  845.  
  846.         # op3 -- m32
  847.         if is_mem_op(insn.Op3):
  848.             r_reg = cdg.load_operand(2)
  849.  
  850.         # op3 -- r32
  851.         else:
  852.             assert is_reg_op(insn.Op3)
  853.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  854.        
  855.         r_mop = ida_hexrays.mop_t(r_reg, FLOAT_SIZE)
  856.  
  857.         # op2 -- xmm2
  858.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  859.  
  860.         # op1 -- xmm1
  861.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  862.  
  863.         # create a temp register to compute the final result into
  864.         t0_result = cdg.mba.alloc_kreg(XMM_SIZE)
  865.         t0_mop = ida_hexrays.mop_t(t0_result, DOUBLE_SIZE)
  866.  
  867.         # copy xmm2 into the temp result reg, as we need its upper quadword
  868.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, l_reg, 0, t0_result, 0)
  869.  
  870.         # convert float (op3) to a double, storing it in the lower 64 of the temp result reg
  871.         cdg.emit(ida_hexrays.m_f2f, r_mop, NO_MOP, t0_mop)
  872.  
  873.         # transfer the fully computed temp register to the real dest reg
  874.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, t0_result, 0, d_reg, 0)
  875.         cdg.mba.free_kreg(t0_result, XMM_SIZE)
  876.  
  877.         # clear upper 128 bits of ymm1
  878.         clear_upper(cdg, d_reg)
  879.  
  880.         return ida_hexrays.MERR_OK
  881.  
  882.     def vcvtsd2ss(self, cdg, insn):
  883.         """
  884.        VCVTSD2SS xmm1,xmm2,xmm3/m64
  885.        """
  886.         regs = self.xmm1_xmm2_xmm3_or_mem3()
  887.         if regs is None:
  888.             return ida_hexrays.MERR_INSN
  889.         (d_reg, l_reg, r_reg) = regs
  890.  
  891.         r_mop = ida_hexrays.mop_t(r_reg, DOUBLE_SIZE)
  892.  
  893.         # op2 -- xmm2
  894.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  895.  
  896.         # op1 -- xmm1
  897.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  898.  
  899.         # create a temp register to compute the final result into
  900.         t0_result = cdg.mba.alloc_kreg(XMM_SIZE)
  901.         t0_mop = ida_hexrays.mop_t(t0_result, FLOAT_SIZE)
  902.  
  903.         # copy xmm2 into the temp result reg, as we need its upper quadword
  904.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, l_reg, 0, t0_result, 0)
  905.  
  906.         # convert float (op3) to a double, storing it in the lower 64 of the temp result reg
  907.         cdg.emit(ida_hexrays.m_f2f, r_mop, NO_MOP, t0_mop)
  908.  
  909.         # transfer the fully computed temp register to the real dest reg
  910.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, t0_result, 0, d_reg, 0)
  911.         cdg.mba.free_kreg(t0_result, XMM_SIZE)
  912.  
  913.         # clear upper 128 bits of ymm1
  914.         clear_upper(cdg, d_reg)
  915.  
  916.         return ida_hexrays.MERR_OK
  917.  
  918.     #-------------------------------------------------------------------------
  919.     # Mov Instructions
  920.     #-------------------------------------------------------------------------
  921.  
  922.     def vmovss(self, cdg, insn):
  923.         """
  924.         VMOVSS xmm1, xmm2, xmm3
  925.        VMOVSS xmm1, m32
  926.         VMOVSS xmm1, xmm2, xmm3
  927.        VMOVSS m32, xmm1
  928.        """
  929.         return self.vmovs_(cdg, insn, FLOAT_SIZE)
  930.  
  931.     def vmovsd(self, cdg, insn):
  932.         """
  933.        VMOVSD xmm1, xmm2, xmm3
  934.        VMOVSD xmm1, m64
  935.        VMOVSD xmm1, xmm2, xmm3
  936.        VMOVSD m64, xmm1
  937.        """
  938.         return self.vmovs_(cdg, insn, DOUBLE_SIZE)
  939.  
  940.     def vmovs_(self, cdg, insn, data_size):
  941.         """
  942.        Templated handler for scalar float/double mov instructions.
  943.        """
  944.  
  945.         # op form: X, Y -- (2 operands)
  946.         if insn.Op3.type == ida_ua.o_void:
  947.  
  948.             # op form: xmm1, m32/m64
  949.             if is_xmm_reg(insn.Op1) and is_mem_op(insn.Op2):
  950.                 (d_reg, l_reg) = self.xmm1_xmm2_or_mem2()
  951.                 self.emit_clear_ymm(d_reg)
  952.                 self.emit_fp_instr_l_d(ida_hexrays.m_mov, ida_hexrays.mop_t(l_reg, data_size), ida_hexrays.mop_t(d_reg, data_size))
  953.                 # clear_upper(cdg, d_reg, data_size)
  954.  
  955.             # op form: m32/m64, xmm1
  956.             elif is_mem_op(insn.Op1) and is_xmm_reg(insn.Op2):
  957.                 l_reg = self.xmmreg(insn.Op2)
  958.                 l_mop = ida_hexrays.mop_t(l_reg, data_size)
  959.                 # store xmm1[:data_size] into memory at [m32/m64] (op1)
  960.                 insn = cdg.store_operand(0, l_mop)
  961.                 insn.set_fpinsn()
  962.             else:
  963.                 return self.decode_error('unknown format')
  964.         # op form: xmm1, xmm2, xmm3 -- (3 operands)
  965.         else:
  966.             regs = (self.xmmreg(insn.Op1), self.xmmreg(insn.Op2), self.xmmreg(insn.Op3))
  967.             if not all(regs):
  968.                 return self.decode_error("expected xmm, xmm, xmm form")
  969.  
  970.             (d_reg, l_reg, r_reg) = regs
  971.  
  972.             self.emit_clear_ymm(d_reg)
  973.             self.emit_copy_bits_xmm_wide(d_reg, l_reg)
  974.             self.emit_fp_instr_l_d(ida_hexrays.m_mov, ida_hexrays.mop_t(r_reg, data_size), ida_hexrays.mop_t(d_reg, data_size))
  975.  
  976.         return ida_hexrays.MERR_OK
  977.  
  978.         # failsafe
  979.         assert "Unreachable..."
  980.         return ida_hexrays.MERR_INSN
  981.  
  982.     def vmovd(self, cdg, insn):
  983.         """
  984.        VMOVD xmm1, r32/m32
  985.        VMOVD r32/m32, xmm1
  986.        """
  987.         return self._vmov(cdg, insn, DWORD_SIZE)
  988.    
  989.     def vmovq(self, cdg, insn):
  990.         """
  991.        VMOVQ xmm1, r64/m64
  992.        VMOVQ r64/m64, xmm1
  993.        """
  994.         return self._vmov(cdg, insn, QWORD_SIZE)
  995.  
  996.     def _vmov(self, cdg, insn, data_size):
  997.         """
  998.        Templated handler for dword/qword mov instructions.
  999.        """
  1000.  
  1001.         # op form: xmm1, rXX/mXX
  1002.         if is_xmm_reg(insn.Op1):
  1003.  
  1004.             # op2 -- m32/m64
  1005.             if is_mem_op(insn.Op2):
  1006.                 l_reg = cdg.load_operand(1)
  1007.  
  1008.             # op2 -- r32/r64
  1009.             else:
  1010.                 l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1011.  
  1012.             # wrap the source micro-reg as a micro-operand of the specified size
  1013.             l_mop = ida_hexrays.mop_t(l_reg, data_size)
  1014.  
  1015.             # op1 -- xmm1
  1016.             d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1017.             d_mop = ida_hexrays.mop_t(d_reg, XMM_SIZE)
  1018.  
  1019.             # emit the microcode for this insn
  1020.             cdg.emit(ida_hexrays.m_xdu, l_mop, NO_MOP, d_mop)
  1021.  
  1022.             # clear upper 128 bits of ymm1
  1023.             clear_upper(cdg, d_reg)
  1024.  
  1025.             return ida_hexrays.MERR_OK
  1026.  
  1027.         # op form: rXX/mXX, xmm1
  1028.         else:
  1029.             assert is_xmm_reg(insn.Op2)
  1030.  
  1031.             # op2 -- xmm1
  1032.             l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1033.             l_mop = ida_hexrays.mop_t(l_reg, data_size)
  1034.  
  1035.             # op1 -- m32/m64
  1036.             if is_mem_op(insn.Op1):
  1037.                 cdg.store_operand(0, l_mop)
  1038.  
  1039.             # op1 -- r32/r64
  1040.             else:
  1041.                 d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1042.                 d_mop = ida_hexrays.mop_t(d_reg, data_size)
  1043.                 cdg.emit(ida_hexrays.m_mov, l_mop, NO_MOP, d_mop)
  1044.  
  1045.                 #
  1046.                 # TODO: the intel manual doesn't make it entierly clear here
  1047.                 # if the upper bits of a r32 operation need to be cleared ?
  1048.                 #
  1049.  
  1050.             return ida_hexrays.MERR_OK
  1051.        
  1052.         # failsafe
  1053.         assert "Unreachable..."
  1054.         return ida_hexrays.MERR_INSN
  1055.  
  1056.     def v_mov_ps_dq(self, cdg, insn):
  1057.         """
  1058.        VMOVAPS xmm1, xmm2/m128
  1059.        VMOVAPS ymm1, ymm2/m256
  1060.        VMOVAPS xmm2/m128, xmm1
  1061.        VMOVAPS ymm2/m256, ymm1
  1062.  
  1063.        VMOVUPS xmm1, xmm2/m128
  1064.        VMOVUPS ymm1, ymm2/m256
  1065.        VMOVUPS xmm2/m128, xmm1
  1066.        VMOVUPS ymm2/m256, ymm1
  1067.  
  1068.        VMOVDQA xmm1, xmm2/m128
  1069.        VMOVDQA xmm2/m128, xmm1
  1070.        VMOVDQA ymm1, ymm2/m256
  1071.        VMOVDQA ymm2/m256, ymm1
  1072.  
  1073.        VMOVDQU xmm1, xmm2/m128
  1074.        VMOVDQU xmm2/m128, xmm1
  1075.        VMOVDQU ymm1, ymm2/m256
  1076.        VMOVDQU ymm2/m256, ymm1
  1077.  
  1078.        VMOVAPD xmm1, xmm2/m128
  1079.        VMOVAPD xmm2/m128, xmm1
  1080.        VMOVAPD ymm1, ymm2/m256
  1081.        VMOVAPD ymm2/m256, ymm1
  1082.        """
  1083.  
  1084.         # op form: reg, [mem]
  1085.         if is_avx_reg(insn.Op1):
  1086.             op_size = XMM_SIZE if is_xmm_reg(insn.Op1) else YMM_SIZE
  1087.  
  1088.             # op2 -- m128/m256
  1089.             if is_mem_op(insn.Op2):
  1090.                 l_reg = cdg.load_operand(1)
  1091.  
  1092.             # op2 -- xmm1/ymm1
  1093.             else:
  1094.                 assert is_avx_reg(insn.Op2)
  1095.                 l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1096.  
  1097.             # wrap the source micro-reg as a micro-operand
  1098.             l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1099.  
  1100.             # op1 -- xmmX/ymmX
  1101.             d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1102.             d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1103.  
  1104.             # clear upper 128 bits of ymm1
  1105.             if op_size == XMM_SIZE:
  1106.                 # clear_upper(cdg, d_reg)
  1107.                 self.emit_clear_ymm(d_reg)
  1108.  
  1109.             # emit the microcode for this insn
  1110.             cdg.emit(ida_hexrays.m_mov, l_mop, NO_MOP, d_mop)
  1111.  
  1112.             return ida_hexrays.MERR_OK
  1113.  
  1114.         # op form: [mem], reg
  1115.         else:
  1116.             assert is_mem_op(insn.Op1) and is_avx_reg(insn.Op2)
  1117.             op_size = XMM_SIZE if is_xmm_reg(insn.Op2) else YMM_SIZE
  1118.  
  1119.             # op1 -- xmm1/ymm1
  1120.             l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1121.             l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1122.  
  1123.             # [m128/m256] = xmm1/ymm1
  1124.             cdg.store_operand(0, l_mop)
  1125.             return ida_hexrays.MERR_OK
  1126.  
  1127.         # failsafe
  1128.         assert "Unreachable..."
  1129.         return ida_hexrays.MERR_INSN
  1130.  
  1131.     #-------------------------------------------------------------------------
  1132.     # Bitwise Instructions
  1133.     #-------------------------------------------------------------------------
  1134.  
  1135.     def v_bitwise_ps(self, cdg, insn):
  1136.         """
  1137.        VORPS xmm1, xmm2, xmm3/m128
  1138.        VORPS ymm1, ymm2, ymm3/m256
  1139.  
  1140.        VXORPS xmm1, xmm2, xmm3/m128
  1141.        VXORPS ymm1, ymm2, ymm3/m256
  1142.  
  1143.        VANDPS xmm1, xmm2, xmm3/m128
  1144.        VANDPS ymm1, ymm2, ymm3/m256
  1145.  
  1146.        VXORPD xmm1, xmm2, xmm3/m128
  1147.        VXORPD ymm1, ymm2, ymm3/m256
  1148.        """
  1149.         assert is_avx_reg(insn.Op1) and is_avx_reg(insn.Op2)
  1150.         op_size = XMM_SIZE if is_xmm_reg(insn.Op1) else YMM_SIZE
  1151.  
  1152.         # op3 -- m128/m256
  1153.         if is_mem_op(insn.Op3):
  1154.             r_reg = cdg.load_operand(2)
  1155.  
  1156.         # op3 -- xmm3/ymm3
  1157.         else:
  1158.             assert is_avx_reg(insn.Op3)
  1159.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  1160.  
  1161.         itype2mcode = \
  1162.         {
  1163.             ida_allins.NN_vorps: ida_hexrays.m_or,
  1164.             ida_allins.NN_vandps: ida_hexrays.m_and,
  1165.             ida_allins.NN_vandpd: ida_hexrays.m_and,
  1166.             ida_allins.NN_vxorps: ida_hexrays.m_xor,
  1167.             ida_allins.NN_vxorpd: ida_hexrays.m_xor,
  1168.         }
  1169.  
  1170.         # get the hexrays microcode op to use for this instruction
  1171.         mcode_op = itype2mcode[insn.itype]
  1172.  
  1173.         # wrap the source micro-reg as a micro-operand
  1174.         r_mop = ida_hexrays.mop_t(r_reg, op_size)
  1175.  
  1176.         # op2 -- xmm2/ymm2
  1177.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1178.         l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1179.  
  1180.         # op1 -- xmm1/ymm1
  1181.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1182.         d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1183.  
  1184.         # emit the microcode for this insn
  1185.         cdg.emit(mcode_op, l_mop, r_mop, d_mop)
  1186.  
  1187.         # clear upper 128 bits of ymm1
  1188.         if op_size == XMM_SIZE:
  1189.             clear_upper(cdg, d_reg)
  1190.  
  1191.         return ida_hexrays.MERR_OK
  1192.  
  1193.     #-------------------------------------------------------------------------
  1194.     # Arithmetic Instructions
  1195.     #-------------------------------------------------------------------------
  1196.  
  1197.     def v_math_ss(self, cdg, insn):
  1198.         """
  1199.        VADDSS    xmm1, xmm2, xmm3/m32
  1200.        VSUBSS    xmm1, xmm2, xmm3/m32
  1201.        VMULSS    xmm1, xmm2, xmm3/m32
  1202.        VDIVSS    xmm1, xmm2, xmm3/m32
  1203.        """
  1204.         return self._v_math_ss_sd(cdg, insn, FLOAT_SIZE)
  1205.  
  1206.     def v_math_sd(self, cdg, insn):
  1207.         """
  1208.        VADDSD    xmm1, xmm2, xmm3/m64
  1209.        VSUBSD    xmm1, xmm2, xmm3/m64
  1210.        VMULSD    xmm1, xmm2, xmm3/m64
  1211.        VDIVSD    xmm1, xmm2, xmm3/m64
  1212.        """
  1213.         return self._v_math_ss_sd(cdg, insn, DOUBLE_SIZE)
  1214.  
  1215.     def _v_math_ss_sd(self, cdg, insn, op_size):
  1216.         """
  1217.        Templated handler for scalar float/double math instructions.
  1218.        """
  1219.         assert is_avx_reg(insn.Op1) and is_avx_reg(insn.Op2)
  1220.  
  1221.         # op3 -- m32/m64
  1222.         if is_mem_op(insn.Op3):
  1223.             r_reg = cdg.load_operand(2)
  1224.  
  1225.         # op3 -- xmm3
  1226.         else:
  1227.             assert is_xmm_reg(insn.Op3)
  1228.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  1229.  
  1230.         # op2 -- xmm2
  1231.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1232.  
  1233.         # op1 -- xmm1
  1234.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1235.  
  1236.         itype2mcode = \
  1237.         {
  1238.             ida_allins.NN_vaddss: ida_hexrays.m_fadd,
  1239.             ida_allins.NN_vaddsd: ida_hexrays.m_fadd,
  1240.  
  1241.             ida_allins.NN_vsubss: ida_hexrays.m_fsub,
  1242.             ida_allins.NN_vsubsd: ida_hexrays.m_fsub,
  1243.  
  1244.             ida_allins.NN_vmulss: ida_hexrays.m_fmul,
  1245.             ida_allins.NN_vmulsd: ida_hexrays.m_fmul,
  1246.  
  1247.             ida_allins.NN_vdivss: ida_hexrays.m_fdiv,
  1248.             ida_allins.NN_vdivsd: ida_hexrays.m_fdiv,
  1249.         }
  1250.  
  1251.         # get the hexrays microcode op to use for this instruction
  1252.         mcode_op = itype2mcode[insn.itype]
  1253.  
  1254.         # emit the microcode for this insn
  1255.         self.emit_clear_ymm(d_reg)
  1256.         l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1257.         r_mop = ida_hexrays.mop_t(r_reg, op_size)
  1258.         d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1259.         self.emit_fp_instr_l_r_d(mcode_op, l_mop, r_mop, d_mop)
  1260.  
  1261.         return ida_hexrays.MERR_OK
  1262.  
  1263.     def _vfmaddxxxsd(self, cdg, insn):
  1264.         """
  1265.        VFMADD132SD xmm1, xmm2, xmm3/m64
  1266.        VFMADD213SD xmm1, xmm2, xmm3/m64
  1267.        VFMADD231SD xmm1, xmm2, xmm3/m64
  1268.        """
  1269.  
  1270.         regs = self.xmm1_xmm2_xmm3_or_mem3()
  1271.         if regs is None:
  1272.             return ida_hexrays.MERR_INSN
  1273.         (d_reg, l_reg, r_reg) = regs
  1274.  
  1275.         op_size = DOUBLE_SIZE
  1276.         # wrap the source micro-reg as a micro-operand
  1277.         r_mop = ida_hexrays.mop_t(r_reg, op_size)
  1278.         l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1279.         d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1280.  
  1281.         order = []
  1282.         if insn.itype == ida_allins.NN_vfmadd132sd:
  1283.             order = [d_mop, r_mop, l_mop]
  1284.         elif insn.itype == ida_allins.NN_vfmadd213sd:
  1285.             order = [l_mop, d_mop, r_mop]
  1286.         elif insn.itype == ida_allins.NN_vfmadd231sd:
  1287.             order = [l_mop, r_mop, d_mop]
  1288.         else:
  1289.             return ida_hexrays.MERR_INSN
  1290.  
  1291.         t1 = cdg.mba.alloc_kreg(XMM_SIZE)
  1292.         t1_mop = ida_hexrays.mop_t(t1, op_size)
  1293.  
  1294.         # t1 = l * r
  1295.         cdg.emit(ida_hexrays.m_fmul, order[0], order[1], t1_mop)
  1296.         # t2 = t1 + d
  1297.         cdg.emit(ida_hexrays.m_fadd, t1_mop, order[2], d_mop)
  1298.  
  1299.         cdg.mba.free_kreg(t1, XMM_SIZE)
  1300.  
  1301.         # clear upper 128 bits of ymm1
  1302.         clear_upper(cdg, d_reg)
  1303.  
  1304.         return ida_hexrays.MERR_OK
  1305.  
  1306.     def vfmadd132sd(self, cdg, insn):
  1307.         return self._vfmaddxxxsd(cdg, insn)
  1308.  
  1309.     def vfmadd213sd(self, cdg, insn):
  1310.         return self._vfmaddxxxsd(cdg, insn)
  1311.  
  1312.     def vfmadd231sd(self, cdg, insn):
  1313.         return self._vfmaddxxxsd(cdg, insn)
  1314.  
  1315.     def _vfnmaddxxxsd(self, cdg, insn):
  1316.         """
  1317.        VFNMADD132SD xmm1, xmm2,xmm3/m64
  1318.        VFNMADD213SD xmm1, xmm2,xmm3/m64
  1319.        VFNMADD231SD xmm1, xmm2,xmm3/m64
  1320.        """
  1321.  
  1322.         regs = self.xmm1_xmm2_xmm3_or_mem3()
  1323.         if regs is None:
  1324.             return ida_hexrays.MERR_INSN
  1325.         (d_reg, l_reg, r_reg) = regs
  1326.  
  1327.         op_size = DOUBLE_SIZE
  1328.         # wrap the source micro-reg as a micro-operand
  1329.         r_mop = ida_hexrays.mop_t(r_reg, op_size)
  1330.         l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1331.         d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1332.  
  1333.         order = []
  1334.         if insn.itype == ida_allins.NN_vfnmadd132sd:
  1335.             order = [d_mop, r_mop, l_mop]
  1336.         elif insn.itype == ida_allins.NN_vfnmadd213sd:
  1337.             order = [l_mop, d_mop, r_mop]
  1338.         elif insn.itype == ida_allins.NN_vfnmadd231sd:
  1339.             order = [l_mop, r_mop, d_mop]
  1340.         else:
  1341.             return ida_hexrays.MERR_INSN
  1342.  
  1343.         t1 = cdg.mba.alloc_kreg(XMM_SIZE)
  1344.         t1_mop = ida_hexrays.mop_t(t1, op_size)
  1345.  
  1346.         t2 = cdg.mba.alloc_kreg(XMM_SIZE)
  1347.         t2_mop = ida_hexrays.mop_t(t2, op_size)
  1348.  
  1349.         # t1 = l * r
  1350.         cdg.emit(ida_hexrays.m_fmul, order[0], order[1], t1_mop)
  1351.         # t2 = -t1
  1352.         cdg.emit(ida_hexrays.m_fneg, t1_mop, NO_MOP, t2_mop)
  1353.         # t3 = t2 + d
  1354.         cdg.emit(ida_hexrays.m_fadd, t2_mop, order[2], d_mop)
  1355.  
  1356.         cdg.mba.free_kreg(t1, XMM_SIZE)
  1357.         cdg.mba.free_kreg(t2, XMM_SIZE)
  1358.  
  1359.         # clear upper 128 bits of ymm1
  1360.         clear_upper(cdg, d_reg)
  1361.  
  1362.         return ida_hexrays.MERR_OK
  1363.  
  1364.     def vfnmadd132sd(self, cdg, insn):
  1365.         return self._vfnmaddxxxsd(cdg, insn)
  1366.  
  1367.     def vfnmadd213sd(self, cdg, insn):
  1368.         return self._vfnmaddxxxsd(cdg, insn)
  1369.  
  1370.     def vfnmadd231sd(self, cdg, insn):
  1371.         return self._vfnmaddxxxsd(cdg, insn)
  1372.  
  1373.     def _vfmsubxxxsd(self, cdg, insn):
  1374.         regs = self.xmm1_xmm2_xmm3_or_mem3()
  1375.         if regs is None:
  1376.             return ida_hexrays.MERR_INSN
  1377.         (d_reg, l_reg, r_reg) = regs
  1378.  
  1379.         op_size = DOUBLE_SIZE
  1380.         # wrap the source micro-reg as a micro-operand
  1381.         r_mop = ida_hexrays.mop_t(r_reg, op_size)
  1382.         l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1383.         d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1384.  
  1385.         order = []
  1386.         if insn.itype == ida_allins.NN_vfmsub132sd:
  1387.             order = [d_mop, r_mop, l_mop]
  1388.         elif insn.itype == ida_allins.NN_vfmsub213sd:
  1389.             order = [l_mop, d_mop, r_mop]
  1390.         elif insn.itype == ida_allins.NN_vfmsub231sd:
  1391.             order = [l_mop, r_mop, d_mop]
  1392.         else:
  1393.             return ida_hexrays.MERR_INSN
  1394.  
  1395.         t1 = cdg.mba.alloc_kreg(XMM_SIZE)
  1396.         t1_mop = ida_hexrays.mop_t(t1, op_size)
  1397.  
  1398.         # t1 = l * r
  1399.         cdg.emit(ida_hexrays.m_fmul, order[0], order[1], t1_mop)
  1400.         # t2 = t1 - d
  1401.         cdg.emit(ida_hexrays.m_fsub, t1_mop, order[2], d_mop)
  1402.  
  1403.         cdg.mba.free_kreg(t1, XMM_SIZE)
  1404.  
  1405.         # clear upper 128 bits of ymm1
  1406.         clear_upper(cdg, d_reg)
  1407.  
  1408.         return ida_hexrays.MERR_OK
  1409.  
  1410.     def vfmsub132sd(self, cdg, insn):
  1411.         return self._vfmsubxxxsd(cdg, insn)
  1412.  
  1413.     def vfmsub213sd(self, cdg, insn):
  1414.         return self._vfmsubxxxsd(cdg, insn)
  1415.  
  1416.     def vfmsub231sd(self, cdg, insn):
  1417.         return self._vfmsubxxxsd(cdg, insn)
  1418.  
  1419.     def v_math_ps(self, cdg, insn):
  1420.         """
  1421.        VADDPS    xmm1, xmm2, xmm3/m128
  1422.        VADDPS    ymm1, ymm2, ymm3/m256
  1423.  
  1424.        VSUBPS    xmm1, xmm2, xmm3/m128
  1425.        VSUBPS    ymm1, ymm2, ymm3/m256
  1426.  
  1427.        VMULPS    xmm1, xmm2, xmm3/m128
  1428.        VMULPS    ymm1, ymm2, ymm3/m256
  1429.  
  1430.        VDIVPS    xmm1, xmm2, xmm3/m128
  1431.        VDIVPS    ymm1, ymm2, ymm3/m256
  1432.        """
  1433.         assert is_avx_reg(insn.Op1) and is_avx_reg(insn.Op2)
  1434.         op_size = XMM_SIZE if is_xmm_reg(insn.Op1) else YMM_SIZE
  1435.  
  1436.         # op3 -- m128/m256
  1437.         if is_mem_op(insn.Op3):
  1438.             r_reg = cdg.load_operand(2)
  1439.  
  1440.         # op3 -- xmm3/ymm3
  1441.         else:
  1442.             assert is_avx_reg(insn.Op3)
  1443.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  1444.  
  1445.         # op2 -- xmm2/ymm2
  1446.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1447.        
  1448.         # op1 -- xmm1/ymm1
  1449.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1450.         d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1451.  
  1452.         itype2name = \
  1453.         {
  1454.             ida_allins.NN_vaddps: "_mm%u_add_ps",
  1455.             ida_allins.NN_vsubps: "_mm%u_sub_ps",
  1456.             ida_allins.NN_vmulps: "_mm%u_mul_ps",
  1457.             ida_allins.NN_vdivps: "_mm%u_div_ps",
  1458.  
  1459.             ida_allins.NN_vaddpd: "_mm%u_add_pd",
  1460.             ida_allins.NN_vsubpd: "_mm%u_sub_pd",
  1461.             ida_allins.NN_vmulpd: "_mm%u_mul_pd",
  1462.         }
  1463.  
  1464.         # create the intrinsic
  1465.         bit_size = bytes2bits(op_size)
  1466.         bit_str = "256" if op_size == YMM_SIZE else ""
  1467.         intrinsic_name = itype2name[insn.itype] % bytes2bits(op_size)
  1468.  
  1469.         avx_intrinsic = AVXIntrinsic(cdg, intrinsic_name)
  1470.         avx_intrinsic.add_argument_reg(l_reg, "__m%u" % bit_size)
  1471.         avx_intrinsic.add_argument_reg(r_reg, "__m%u" % bit_size)
  1472.         avx_intrinsic.set_return_reg(d_reg, "__m%u" % bit_size)
  1473.         avx_intrinsic.emit()
  1474.        
  1475.         # clear upper 128 bits of ymm1
  1476.         if op_size == XMM_SIZE:
  1477.             clear_upper(cdg, d_reg)
  1478.  
  1479.         return ida_hexrays.MERR_OK
  1480.  
  1481.     #-------------------------------------------------------------------------
  1482.     # Misc Instructions
  1483.     #-------------------------------------------------------------------------
  1484.  
  1485.     def vsqrtss(self, cdg, insn):
  1486.         """
  1487.        VSQRTSS xmm1, xmm2, xmm3/m32
  1488.        """
  1489.         assert is_xmm_reg(insn.Op1) and is_xmm_reg(insn.Op2)
  1490.  
  1491.         # op3 -- xmm3
  1492.         if is_xmm_reg(insn.Op3):
  1493.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  1494.  
  1495.         # op3 -- m32
  1496.         else:
  1497.             assert is_mem_op(insn.Op3)
  1498.             r_reg = cdg.load_operand(2)
  1499.  
  1500.         # op2 - xmm2
  1501.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1502.        
  1503.         # op1 - xmm1
  1504.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1505.  
  1506.         # create a temp register to compute the final result into
  1507.         t0_result = cdg.mba.alloc_kreg(XMM_SIZE)
  1508.  
  1509.         # populate the dest reg
  1510.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, l_reg, 0, t0_result, 0)
  1511.  
  1512.         # mov.fpu call !fsqrt<fast:float xmm1_4.4>.4, t0_result_4.4
  1513.         avx_intrinsic = AVXIntrinsic(cdg, "fsqrt")
  1514.         avx_intrinsic.add_argument_reg_basic(r_reg, ida_typeinf.BT_FLOAT)
  1515.         avx_intrinsic.set_return_reg_basic(t0_result, ida_typeinf.BT_FLOAT)
  1516.         avx_intrinsic.emit()
  1517.  
  1518.         # store the fully computed result
  1519.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, t0_result, 0, d_reg, 0)
  1520.         cdg.mba.free_kreg(t0_result, XMM_SIZE)
  1521.  
  1522.         # clear upper 128 bits of ymm1
  1523.         clear_upper(cdg, d_reg)
  1524.  
  1525.         return ida_hexrays.MERR_OK
  1526.  
  1527.     def vsqrtps(self, cdg, insn):
  1528.         """
  1529.        VSQRTPS xmm1, xmm2/m128
  1530.        VSQRTPS ymm1, ymm2/m256
  1531.        """
  1532.         op_size = XMM_SIZE if is_xmm_reg(insn.Op1) else YMM_SIZE
  1533.  
  1534.         # op2 -- m128/m256
  1535.         if is_mem_op(insn.Op2):
  1536.             r_reg = cdg.load_operand(1)
  1537.  
  1538.         # op2 -- xmm2/ymm2
  1539.         else:
  1540.             assert is_avx_reg(insn.Op2)
  1541.             r_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1542.  
  1543.         # op1 -- xmm1/ymm1
  1544.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1545.  
  1546.         # intrinsic: __m256 _mm256_cvtepi32_ps (__m256i a)
  1547.         bit_size = bytes2bits(op_size)
  1548.         bit_str = str(bit_size) if op_size == YMM_SIZE else ""
  1549.         intrinsic_name = "_mm%s_sqrt_ps" % bit_str
  1550.  
  1551.         avx_intrinsic = AVXIntrinsic(cdg, intrinsic_name)
  1552.         avx_intrinsic.add_argument_reg(r_reg, "__m%u" % bit_size)
  1553.         avx_intrinsic.set_return_reg(d_reg, "__m%u" % bit_size)
  1554.         avx_intrinsic.emit()
  1555.  
  1556.         # clear upper 128 bits of ymm1
  1557.         if op_size == XMM_SIZE:
  1558.             clear_upper(cdg, d_reg)
  1559.  
  1560.         return ida_hexrays.MERR_OK
  1561.  
  1562.     def vshufps(self, cdg, insn):
  1563.         """
  1564.        VSHUFPS xmm1, xmm2, xmm3/m128, imm8
  1565.        VSHUFPS ymm1, ymm2, ymm3/m256, imm8
  1566.        """
  1567.         op_size = XMM_SIZE if is_xmm_reg(insn.Op1) else YMM_SIZE
  1568.  
  1569.         # op4 -- imm8
  1570.         assert insn.Op4.type == ida_ua.o_imm
  1571.         mask_value = insn.Op4.value
  1572.        
  1573.         # op3 -- m128/m256
  1574.         if is_mem_op(insn.Op3):
  1575.             r_reg = cdg.load_operand(2)
  1576.  
  1577.         # op3 -- xmm3/ymm3
  1578.         else:
  1579.             assert is_avx_reg(insn.Op3)
  1580.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  1581.  
  1582.         # op2 -- xmm2/ymm2
  1583.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1584.  
  1585.         # op1 -- xmm1/ymm1
  1586.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1587.  
  1588.         #
  1589.         # intrinsics:
  1590.         #   __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int imm8)
  1591.         #   __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8)
  1592.         #
  1593.  
  1594.         bit_size = bytes2bits(op_size)
  1595.         bit_str = str(bit_size) if op_size == YMM_SIZE else ""
  1596.         intrinsic_name = "_mm%s_shuffle_ps" % bit_str
  1597.  
  1598.         avx_intrinsic = AVXIntrinsic(cdg, intrinsic_name)
  1599.         avx_intrinsic.add_argument_reg(l_reg, "__m%u" % bit_size)
  1600.         avx_intrinsic.add_argument_reg(r_reg, "__m%u" % bit_size)
  1601.         avx_intrinsic.add_argument_imm(mask_value, ida_typeinf.BT_INT8)
  1602.         avx_intrinsic.set_return_reg(d_reg, "__m%u" % bit_size)
  1603.         avx_intrinsic.emit()
  1604.  
  1605.         # clear upper 128 bits of ymm1
  1606.         if op_size == XMM_SIZE:
  1607.             clear_upper(cdg, d_reg)
  1608.  
  1609.         return ida_hexrays.MERR_OK
  1610.  
  1611.     def minmaxsd(self, cdg, insn, funcName):
  1612.         """
  1613.        VMINSD xmm1, xmm2, xmm3/m64
  1614.        VMAXSD xmm1, xmm2, xmm3/m64
  1615.        """
  1616.         # op3 -- xmm3
  1617.         regs = self.xmm1_xmm2_xmm3_or_mem3()
  1618.         if regs is None:
  1619.             return ida_hexrays.MERR_INSN
  1620.         (d_reg, l_reg, r_reg) = regs
  1621.  
  1622.         t0_result = self.save_upper_bits(l_reg, XMM_SIZE)
  1623.  
  1624.         avx_intrinsic = AVXIntrinsic(cdg, funcName)
  1625.         avx_intrinsic.add_argument_reg_basic(l_reg, ida_typeinf.BTF_DOUBLE)
  1626.         avx_intrinsic.add_argument_reg_basic(r_reg, ida_typeinf.BTF_DOUBLE)
  1627.         avx_intrinsic.set_return_reg_basic(t0_result, ida_typeinf.BTF_DOUBLE)
  1628.         avx_intrinsic.emit()
  1629.  
  1630.         # store the fully computed result
  1631.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, t0_result, 0, d_reg, 0)
  1632.         cdg.mba.free_kreg(t0_result, XMM_SIZE)
  1633.  
  1634.         # clear upper 128 bits of ymm1
  1635.         clear_upper(cdg, d_reg)
  1636.  
  1637.         return ida_hexrays.MERR_OK
  1638.  
  1639.     def vmaxsd(self, cdg, insn):
  1640.         return self.minmaxsd(cdg, insn, "fmax")
  1641.  
  1642.     def vminsd(self, cdg, insn):
  1643.         return self.minmaxsd(cdg, insn, "fmin")
  1644.  
  1645.     def vpxor(self, cdg, insn):
  1646.         """
  1647.        VPXOR xmm1, xmm2, xmm3/m128 // AVX
  1648.        VPXOR ymm1, ymm2, ymm3/m256 // AVX2
  1649.        """
  1650.         if is_xmm_reg(insn.Op1) and is_xmm_reg(insn.Op2):
  1651.             op_size = XMM_SIZE
  1652.         elif is_ymm_reg(insn.Op1) and is_ymm_reg(insn.Op2):
  1653.             op_size = YMM_SIZE
  1654.         else:
  1655.             return ida_hexrays.MERR_INSN
  1656.  
  1657.         # op3 -- m128/m256
  1658.         if is_mem_op(insn.Op3):
  1659.             r_reg = cdg.load_operand(2)
  1660.  
  1661.         # op3 -- xmm3/ymm3
  1662.         elif is_xmm_reg(insn.Op3) and op_size == XMM_SIZE or is_ymm_reg(insn.Op3) and op_size == YMM_SIZE:
  1663.             r_reg = ida_hexrays.reg2mreg(insn.Op3.reg)
  1664.         else:
  1665.             return ida_hexrays.MERR_INSN
  1666.  
  1667.         # wrap the source micro-reg as a micro-operand
  1668.         r_mop = ida_hexrays.mop_t(r_reg, op_size)
  1669.  
  1670.         # op2 -- xmm2/ymm2
  1671.         l_reg = ida_hexrays.reg2mreg(insn.Op2.reg)
  1672.         l_mop = ida_hexrays.mop_t(l_reg, op_size)
  1673.  
  1674.         # op1 -- xmm1/ymm1
  1675.         d_reg = ida_hexrays.reg2mreg(insn.Op1.reg)
  1676.         d_mop = ida_hexrays.mop_t(d_reg, op_size)
  1677.  
  1678.         # emit the microcode for this insn
  1679.         cdg.emit(ida_hexrays.m_xor, l_mop, r_mop, d_mop)
  1680.  
  1681.         # clear upper 128 bits of ymm1
  1682.         if op_size == XMM_SIZE:
  1683.             clear_upper(cdg, d_reg)
  1684.  
  1685.         return ida_hexrays.MERR_OK
  1686.  
  1687.     def vroundsd(self, cdg, insn):
  1688.         """
  1689.        VROUNDSD xmm1, xmm2, xmm3/m64, imm8
  1690.        """
  1691.         # op3 -- xmm3
  1692.         regs = self.xmm1_xmm2_xmm3_or_mem3()
  1693.         if regs is None:
  1694.             return ida_hexrays.MERR_INSN
  1695.         (d_reg, l_reg, r_reg) = regs
  1696.         if insn.Op4.type != ida_ua.o_imm:
  1697.             return self.decode_error('op4')
  1698.  
  1699.         t0_result = self.save_upper_bits(l_reg, XMM_SIZE)
  1700.  
  1701.         avx_intrinsic = AVXIntrinsic(cdg, 'roundsd_avx' )
  1702.         avx_intrinsic.add_argument_reg_basic(l_reg, ida_typeinf.BTF_DOUBLE)
  1703.         avx_intrinsic.add_argument_reg_basic(r_reg, ida_typeinf.BTF_DOUBLE)
  1704.         avx_intrinsic.add_argument_imm(insn.Op4.value, ida_typeinf.BTF_BYTE)
  1705.         avx_intrinsic.set_return_reg_basic(t0_result, ida_typeinf.BTF_DOUBLE)
  1706.         avx_intrinsic.emit()
  1707.  
  1708.         # store the fully computed result
  1709.         cdg.emit(ida_hexrays.m_mov, XMM_SIZE, t0_result, 0, d_reg, 0)
  1710.         cdg.mba.free_kreg(t0_result, XMM_SIZE)
  1711.  
  1712.         # clear upper 128 bits of ymm1
  1713.         clear_upper(cdg, d_reg)
  1714.  
  1715.         return ida_hexrays.MERR_OK
  1716.  
  1717. #-----------------------------------------------------------------------------
  1718. # Plugin
  1719. #-----------------------------------------------------------------------------
  1720.  
  1721. def PLUGIN_ENTRY():
  1722.     """
  1723.    Required plugin entry point for IDAPython Plugins.
  1724.    """
  1725.     return MicroAVX()
  1726.  
  1727. class MicroAVX(ida_idaapi.plugin_t):
  1728.     """
  1729.    The IDA plugin stub for MicroAVX.
  1730.    """
  1731.  
  1732.     flags = ida_idaapi.PLUGIN_PROC | ida_idaapi.PLUGIN_HIDE
  1733.     comment = "AVX support for the Hex-Rays Decompiler"
  1734.     help = ""
  1735.     wanted_name = "MicroAVX"
  1736.     wanted_hotkey = ""
  1737.     loaded = False
  1738.  
  1739.     #--------------------------------------------------------------------------
  1740.     # IDA Plugin Overloads
  1741.     #--------------------------------------------------------------------------
  1742.  
  1743.     def init(self):
  1744.         """
  1745.        This is called by IDA when it is loading the plugin.
  1746.        """
  1747.  
  1748.         # only bother to load the plugin for relevant sessions
  1749.         if not is_x86_idb():
  1750.             return ida_idaapi.PLUGIN_SKIP
  1751.  
  1752.         # ensure the decompiler is loaded
  1753.         if not ida_loader.load_plugin("hexx64"):
  1754.             print("failed to load decompiler plugin...")
  1755.             return ida_idaapi.PLUGIN_SKIP
  1756.  
  1757.         if not ida_hexrays.init_hexrays_plugin():
  1758.             print("failed to init decompiler plugin...")
  1759.             return ida_idaapi.PLUGIN_SKIP
  1760.  
  1761.         NO_MOP = ida_hexrays.mop_t()
  1762.         NO_MOP.zero()
  1763.  
  1764.         # initialize the AVX lifter
  1765.         self.avx_lifter = AVXLifter()
  1766.         self.avx_lifter.install()
  1767.         sys.modules["__main__"].lifter = self.avx_lifter
  1768.  
  1769.         # mark the plugin as loaded
  1770.         self.loaded = True
  1771.         return ida_idaapi.PLUGIN_KEEP
  1772.  
  1773.     def run(self, arg):
  1774.         """
  1775.        This is called by IDA when this file is loaded as a script.
  1776.        """
  1777.         ida_kernwin.warning("%s cannot be run as a script in IDA." % self.wanted_name)
  1778.  
  1779.     def term(self):
  1780.         """
  1781.        This is called by IDA when it is unloading the plugin.
  1782.        """
  1783.         if not self.loaded:
  1784.             return
  1785.  
  1786.         # hex-rays automatically cleans up decompiler hooks, so not much to do here...
  1787.         self.avx_lifter = None
Advertisement
Add Comment
Please, Sign In to add comment