home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 23 / IOPROG_23.ISO / SOFT / ASM / GRDBDL17.ZIP / ASMOPS.ASM < prev    next >
Encoding:
Assembly Source File  |  1998-10-26  |  32.8 KB  |  1,882 lines
  1. ;                     
  2. ; GRDB
  3. ;
  4. ; Copyright(c) LADsoft
  5. ;
  6. ; David Lindauer, camille@bluegrass.net
  7. ;
  8. ;
  9. ; ASMOPS.ASM
  10. ;
  11. ; Function: Assembler operand parsers
  12. ;
  13.     ;MASM MODE
  14.     .MODEL SMALL
  15.     .386
  16.  
  17. include iasm.inc
  18. include easm.inc
  19. include iopcodes.inc
  20. include eopcodes.inc
  21. include eopcom.inc
  22. include eprints.inc 
  23. include einput.inc 
  24. include emtrap.inc
  25. include    edispatc.inc
  26. include eoperand.inc
  27. include eoptions.inc
  28.  
  29.     PUBLIC    AOP0,  AOP1,  AOP2,  AOP3,  AOP4,  AOP5,  AOP6,  AOP7
  30.     PUBLIC    AOP8,  AOP9,  AOP10, AOP11, AOP12, AOP13, AOP14, AOP15
  31.     PUBLIC    AOP16, AOP17, AOP18, AOP19, AOP20, AOP21, AOP22, AOP23
  32.     PUBLIC    AOP24, AOP25, AOP26, AOP27, AOP28, AOP29, AOP30, AOP31
  33.     PUBLIC    AOP32, AOP33, AOP34, AOP35, AOP36, AOP37, AOP38, AOP39
  34.     PUBLIC    AOP40, AOP41, AOP42, AOP43, AOP44, AOP45, AOP46, AOP47
  35.     PUBLIC    AOP48, AOP49, AOP50, AOP51, aop52, AOP53, AOP54, AOP55
  36.     PUBLIC    AOP56, AOP57, AOP58
  37.  
  38.     .data
  39. base16c    dw    0ff03h,0ff05h,0ff07h,0ff06h,0705h,0605h, 0703h,0603h
  40.     dw    0ffffh,0ffffh,0ffffh,0ffffh,0507h,0506h, 0307h,0306h
  41.  
  42.     .code
  43.  
  44. ;Check if arg1.asize is 4 or less.  If greater, return error to caller's
  45. ;caller by mucking with the stack.
  46.  
  47. intsize PROC
  48.     cmp    [arg1.asize],DWORDSIZE    ;maybe this means the first argument
  49.     ja    rtnDirectlyToDispatcherWithCY    ;can't exceed dword size
  50.     ret
  51. intsize    ENDP
  52.  
  53. ;See if the mode field for this structure references a memory operand
  54. ;and return error to caller's caller if not
  55.  
  56. chkmem    PROC
  57.     cmp    [bx+asmop.mode],AM_MEM        ;this is 3
  58.     jne    rtnDirectlyToDispatcherWithCY    ;bomb if not memory operand
  59.     ret
  60. chkmem    ENDP
  61.  
  62. ;See if the mode field for this structure references an immediate operand
  63. ;and return error to caller's caller if not
  64.  
  65. chkimm    PROC
  66.     cmp    [bx+asmop.mode],AM_IMM        ;check if immediate
  67.     jne    rtnDirectlyToDispatcherWithCY    ;if not, bomb
  68.     ret
  69. chkimm    ENDP
  70.  
  71. ;See if the mode field for this structure references a segment
  72. ;and return error to caller's caller if not
  73.  
  74. chkseg    PROC
  75.     cmp    [bx+asmop.mode],AM_SEG
  76.     jne    rtnDirectlyToDispatcherWithCY
  77.     ret
  78. chkseg    ENDP
  79.  
  80. ;This is a little more complicated. Let's hypothesize that chkregw is 
  81. ;shorthand for checking a 16-bit register type opcode. In this case,maybe the
  82. ;opcode must contain more than a single byte.  So before we check if it
  83. ;is a register-type opcode, we must make sure it has extra byte(s). So
  84. ;we stop here first, and if the length makes us happy, then we check mode
  85. ;  Next guess - if this is a byte argument, we bomb since a word register
  86. ;requires a word operand.
  87.  
  88. chkregw    PROC
  89.     cmp    [bx+asmop.asize],BYTESIZE    ;is this a byte opcode
  90.     je    rtnDirectlyToDispatcherWithCY    ;if so, bomb
  91.     jmp    chkreg            ;else check mode for register type
  92. chkregw    ENDP
  93.  
  94. ;Possibly this is used for in and out, where DX is the only register
  95. ;allowed?
  96.  
  97. chkdx    PROC
  98.     cmp    [bx+asmop.asize],WORDSIZE    ;if not a word register
  99.     jne    rtnDirectlyToDispatcherWithCY    ;then bomb
  100.     cmp    [bx+asmop.areg1],isEDX        ;else see if DX register
  101.     jne    rtnDirectlyToDispatcherWithCY    ;if not, bomb
  102.     jmp    chkreg
  103. chkdx    ENDP
  104.  
  105. ;Not sure about the AX part of this, since all that is being checked is
  106. ;a size of byte
  107.  
  108. chkaxw    PROC
  109.     cmp    [bx+asmop.asize],BYTESIZE    ;if a byte register
  110.     je    rtnDirectlyToDispatcherWithCY    ;then bomb
  111. chkaxw    ENDP
  112.  
  113. ;This IS a check for AX (actually, 0 is EAX)
  114.  
  115. chkax    PROC
  116.     cmp    [bx+asmop.areg1],0            ;if not EAX (maybe AX or AL)
  117.     jne    rtnDirectlyToDispatcherWithCY    ;then bomb
  118. chkax    ENDP
  119.  
  120. ;Check for a register?  As opposed to ??
  121.  
  122. chkreg    PROC
  123.     cmp    [bx+asmop.mode],AM_REG        ;is this flag set?
  124.     jne    rtnDirectlyToDispatcherWithCY    ;if not, bomb
  125.     ret
  126. chkreg    ENDP
  127.  
  128. ;We bomb if arg3.mode isn't none, and if it is, we still bomb if arg2.mode
  129. ;is none.  So arg3 is required to have a 'mode', whatever that is, I guess
  130.  
  131. noarg3    PROC
  132.     cmp    [arg3.mode],AM_NONE
  133.     jne    rtnDirectlyToDispatcherWithCY
  134.     cmp    [arg2.mode],AM_NONE
  135.     je    rtnDirectlyToDispatcherWithCY
  136.     ret
  137. noarg3    ENDP
  138.  
  139. ;Same as above, except it applies to arg2
  140.  
  141. noarg2    PROC
  142.     cmp    [arg2.mode],AM_NONE
  143.     jne    rtnDirectlyToDispatcherWithCY
  144.     cmp    [arg1.mode],AM_NONE
  145.     je    rtnDirectlyToDispatcherWithCY
  146.     ret
  147. noarg2    ENDP
  148.  
  149. ;Whoa, lets see here.  If arg1.mode, whatever that is, is NOT 0, we jnz to
  150. ;rtnDirectlyToDispatcherWithCY. Since this routine was called, the return 
  151. ;address is on the stack. Which means rtnDirectlyToDispatcherWithCY strips 
  152. ;off the return address, and returns to the caller's caller. 
  153.  
  154. noarg1    PROC
  155.     cmp    [arg1.mode],AM_NONE
  156.     jne    rtnDirectlyToDispatcherWithCY
  157.     ret
  158. noarg1    ENDP
  159. ;
  160. ; pops the ret address from the AOP caller
  161. ; and goes directly back to the parser with a mismatch error
  162. ;
  163. rtnDirectlyToDispatcherWithCY    PROC
  164.     pop    ax
  165.     stc
  166.     ret
  167. rtnDirectlyToDispatcherWithCY    ENDP
  168.  
  169.  
  170. ;see if size of this opcode is 1. If not, we are returning NZ and AL=1. I
  171. ;assume that 1 is important, since without the OR line, we would also be
  172. ;returning NZ if the size was not 1. In fact, several callers immediately
  173. ;do a stosb, so at the very least we are ensuring an odd number???
  174. ;  Next guess: AL will eventually be used as part of the stored, assembled
  175. ;byte.  So apparently the purpose of this routine is to set bit 0 of the
  176. ;untimate assembled value if this is NOT a byte operand.
  177.  
  178. sizeb0    PROC
  179.     cmp    [bx+asmop.asize],BYTESIZE
  180.     je    szb0x
  181.     or    al,1
  182. szb0x:
  183.     ret
  184. sizeb0    ENDP
  185.  
  186. ;In which case, the purpose of this routine is to set bit 3 of AL if the
  187. ;operand is NOT a byte operand.
  188.  
  189. sizeb3    PROC
  190.     cmp    [bx+asmop.asize],BYTESIZE
  191.     je    szb3x
  192.     or    al,8
  193. szb3x:
  194.     ret
  195. sizeb3    ENDP
  196. ;
  197. ; main RM handler
  198. ;
  199. ; within this routine, CX = pointer to mod/RM byte and DX = flag for
  200. ; <e>bp based indexing
  201. ;
  202. ; all MOD/RM fields are set up assuming no offset and updated 
  203. ; later...
  204. ;
  205. asmfrm    PROC
  206.     cmp    [bx+asmop.mode],AM_FPREG ; check for register direct mode
  207.     jne    asmrm2
  208.     or    al,0c0h            ; modrm = 0c0+al+regval
  209.     or    al,[bx+asmop.areg1]
  210.     stosb
  211.     ret
  212.     
  213. asmfrm    ENDP
  214.  
  215.  
  216.  
  217. asmrm    PROC
  218.     shl    al,3            ; shift reg val into place
  219. asmrm    ENDP
  220.  
  221.  
  222. asmrm2    PROC
  223. ;
  224. ; registers are the same in both 16 & 32-bit
  225. ;
  226.     cmp    [bx+asmop.mode],AM_REG    ; 1check for register direct mode
  227.     jne    rmnreg
  228.     or    al,0c0h            ; modrm = 0c0+al+regval
  229.     or    al,[bx+asmop.areg1]
  230.     stosb
  231.     ret
  232. rmnreg:
  233.     cmp    [bx+asmop.msize],DWORDMODE    ; see which style of addressing
  234.     je    asmrm32
  235. ;
  236. ; 16-bit MEM handler
  237. ;
  238.     cmp    [bx+asmop.mode],AM_MEM    ; 16 bit, check for mem
  239.     jne    rm16nmem
  240.     or    al,6            ; MODRM = 6+al
  241.     stosb
  242.     jmp    rmwoffs
  243. rm16nmem:
  244.     cmp    [bx+asmop.mode],AM_BASED ; check for 16 bit based
  245.     jne    rtnDirectlyToDispatcherWithCY
  246. ;
  247. ; 16-bit base handler, restricted combos and no scaling
  248. ;
  249.     push    ax            ; yes, get the reg vals
  250.     sub    ax,ax
  251.     mov    al,[bx+asmop.areg1]
  252.     mov    ah,[bx+asmop.areg2]
  253.     mov    dx,ax
  254.     push    di            ; scan for a match and to get index
  255.     mov    di,offset base16c
  256.     mov    cx,16
  257.     repne    scasw
  258.     pop    di
  259.     pop    ax
  260.     jnz    rtnDirectlyToDispatcherWithCY    ; scan failed, exit
  261.     bt    cx,3
  262.     jc    rm16nswap
  263.     xchg    dl,dh
  264. rm16nswap:
  265.     and    cl,7
  266.     or    al,cl
  267.     mov    cx,di            ; cx points at modrm byte
  268.     stosb
  269.     jmp    rmanyoffs        ; check for offs
  270. ;
  271. ; 32-bit modes start here
  272. ;
  273. asmrm32:
  274.     cmp    [bx+asmop.mode],AM_MEM    ; 32 bit, check for mem
  275.     jne    rm32nmem
  276. ;
  277. ; generic mem handler
  278. ;
  279.     or    al,5            ; MODRM = 5+al
  280.     stosb
  281.     jmp    rmwoffs
  282. rm32nmem:
  283.     cmp    [bx+asmop.mode],AM_BASED     ; check for based
  284.     jne    rtnDirectlyToDispatcherWithCY    ; not legal if not
  285.     cmp    [bx+asmop.areg2],0FFh    ; else see if second reg defined
  286.     je    rm32bbonly
  287.     cmp    [bx+asmop.areg1],0FFh    ; else see if first reg defined
  288.     je    rm32bionly
  289. ;
  290. ; both a base AND an index
  291. ;
  292. ; the parser should have checked that ESP is not the scond arg
  293. ; and that we don't have two EBP args
  294. ;
  295.     cmp    [bx+asmop.areg1],isEBP    ; check for BP based
  296.     je    rm32bbsebp
  297.     or    al,4            ; flag MOD for SIB
  298.     mov    cx,di
  299.     stosb
  300.     bsf    ax,[bx+asmop.ascale]    ; calculate SIB byte
  301.     shl    ax,3
  302.     or    al,[bx +asmop.areg2]
  303.     shl    ax,3
  304.     or    al,[bx+asmop.areg1]
  305.     stosb
  306.     sub    dx,dx
  307.     jmp    rmanyoffs
  308. ;
  309. ; base and index, base is ebp
  310. rm32bbsebp:
  311.     or    al,4
  312.     mov    cx,di
  313.     stosb
  314.     bsf    ax,[bx+asmop.ascale]    ; calculate SIB byte
  315.     shl    ax,3
  316.     or    al,[bx+asmop.areg2]
  317.     shl    ax,3
  318.     or    al,5            ; bp based
  319.     stosb
  320.     mov    dx,0ff05h
  321.     jmp    rmanyoffs
  322. ;
  323. ; index only
  324. rm32bionly:
  325.     or    al,4             ; select SIB byte
  326.     stosb
  327.     bsf    ax,word ptr [bx+asmop.ascale] ; calculate scale factor
  328.     shl    ax,3            ; shift over
  329.     or    ax,word ptr [bx+asmop.areg2] ; add in index
  330.     shl    ax,3            ; shift over
  331.     or    ax,5            ; base = 5, that is none since mod = 0
  332.     stosb
  333.     mov    eax,[bx+asmop.addrx]    ; always 32-bit ofs in this mode
  334.     stosd
  335.     ret
  336. ;
  337. ; only a base reg
  338. ;
  339. rm32bbonly:
  340.     ; shouldn't get here if no regs
  341.     cmp    [ebx+asmop.areg1],isESP    ; only one reg, check for ESP
  342.     je    rm32besp
  343.     cmp    [ebx+asmop.areg1],isEBP    ; only one reg, check for EBP
  344.     je    rm32bebp
  345.     or    al,[ebx+asmop.areg1]    ; no, normal MODRM byte with no SIB
  346.     mov    cx,di
  347.     stosb
  348.     mov    dh,0FFh            ; pretend 16 bit
  349.     mov    dl,al
  350.     and    dl,7
  351.     jmp    rmanyoffs
  352. ;
  353. ; based ESP, no index
  354. ;
  355. rm32besp:
  356.     or    al,4            ; select SIB byte (sib needed
  357.     mov    cx,di            ; for indexing off ESP)
  358.     stosb
  359.     mov    al,24h            ; sib byte for [esp] mode
  360.     stosb
  361.     sub    dx,dx
  362.     jmp    rmanyoffs
  363. ;
  364. ; based ebp, no index
  365. ;
  366. rm32bebp:
  367.     or    al,5
  368.     mov    cx,di            ; so we can adjust mod later
  369.     stosb
  370.     mov    dx,0ff05h        ; MUST have offset, this is BP base reg
  371.     jmp    rmanyoffs
  372. ;
  373. ; now the auto offset routine.
  374. ; if (E)BP, we ALWAYS have an offset    
  375. ; otherwise we see if the offset is zero before encoding anything
  376.     
  377. asmrm2    ENDP
  378. rmanyoffs PROC
  379.     mov    eax,[bx+asmop.addrx]    ; get offs
  380.     cmp    dx,0ff05h        ; BP reg ALWAYS has offs
  381.     je    rmaomho
  382.  
  383.     or    eax,eax         ; else no offs if offs = 0
  384.     jz    rmaook
  385. ;
  386. ; if we get here we have an offset, fix the RM field and embed the
  387. ; offset
  388. ;
  389. rmaomho:
  390.     xchg    cx,bx
  391.     add    byte ptr [bx],40h    ; else set MOD field = 1
  392.     xchg    cx,bx
  393.     and    eax,NOT 7FH        ; else see if fits in a byte
  394.     jz    rmboffs
  395.     cmp    eax,NOT 7fh
  396.     je    rmboffs            ; yep, go do it
  397.     xchg    cx,bx
  398.     add    byte ptr [bx],40h    ; else MOD field = 2
  399.     xchg    cx,bx
  400.     jmp    rmwoffs            ; and go do it
  401.  
  402. rmboffs:
  403.     mov    eax,[bx+asmop.addrx]    ; get offs
  404.     stosb                  ; store a byte offs
  405. rmaook:
  406.     clc
  407.     ret
  408. rmanyoffs    ENDP
  409. rmszoffs    PROC
  410.     mov    eax,[bx+asmop.addrx]
  411.     cmp    [bx+asmop.msize],WORDMODE
  412.     jae    rmwoffs
  413.     stosb
  414.     clc
  415.     ret
  416. rmszoffs    ENDP
  417. rmwoffs    PROC
  418.     mov    eax,[bx+asmop.addrx]    ; check size
  419.     cmp     [bx+asmop.msize],WORDMODE
  420.     ja    rmdwoffs
  421.     stosw                ; word offs
  422.     clc
  423.     ret
  424. rmdwoffs:
  425.     test    [Disassemble32Bit],1
  426.     jz    rtnDirectlyToDispatcherWithCY
  427.     stosd                ; dword offs
  428.     clc
  429.     ret
  430. rmwoffs    ENDP
  431. rmszimm    PROC
  432.     mov    eax,[bx+asmop.addrx]    ; check size
  433.     cmp    [bx+asmop.asize],WORDSIZE
  434.     jae    rmszimmw
  435.     stosb
  436.     clc
  437.     ret
  438. rmszimmw:
  439.     jne    rmszimmd
  440.     stosw
  441.     ret
  442. rmszimmd:
  443.     cmp    [bx+asmop.asize],DWORDSIZE
  444.     jne    rtnDirectlyToDispatcherWithCY
  445.     test    [Disassemble32Bit],1
  446.     jz    rtnDirectlyToDispatcherWithCY
  447.     stosd
  448.     ret
  449. rmszimm    ENDP
  450. ;
  451. ; no operands. In this case, the opcode length is 1, so we go through this
  452. ;    weird locution to rep mov a single byte out of the structure and
  453. ;    into [di], wherever that points. Apparently it points into an opcode
  454. ;    buffer somewhere. If the opcode length is greater than one, what
  455. ;    happens?
  456. ;
  457. AOP0    PROC
  458.     call    noarg1            ;see if arg1.mode=0, whatever that means
  459.     push    si            ;only return here if it IS 0
  460.     movzx    cx,[si+opcode.oclength]    ;so get the length of the opcode
  461.     lea    si,[si+opcode.compare]    ;find the opcode in the structure
  462.     rep    movsb            ;copy from structure to buffer
  463.     pop    si            ;restore pointer to structure
  464.     clc                ;say no problem
  465.     ret
  466. AOP0    ENDP
  467. ;
  468. ; word reg, bits 0-2 of opcode = reg num
  469. ;
  470. AOP1    PROC
  471.     call    noarg2
  472.     call    intsize
  473.     mov    bx,offset arg1
  474.     call    chkregw
  475.     mov    al,byte ptr [si+OPCODE.COMPARE]
  476.     or    al,[arg1.areg1]
  477.     stosb
  478.     clc
  479.     ret
  480. AOP1    ENDP
  481. ;
  482. ; word acc,reg... reg = bits 0-2 of opcode
  483. ;
  484. AOP2    PROC
  485.     call    noarg3
  486.     call    intsize
  487.     mov    bx,offset arg1
  488.     call    chkaxw
  489.     mov    bx,offset arg2
  490.     call    chkregw
  491.     mov    al,byte ptr [si+opcode.compare]
  492.     or    al,[arg2.areg1]
  493.     stosb
  494.     ret
  495. AOP2    ENDP
  496. ;
  497. ; one arg, seg goes in b3-4 of opcode
  498. ;
  499. AOP3    PROC
  500.     call    noarg2
  501.     call    intsize
  502.     mov    bx,offset arg1
  503.     call    chkseg
  504.     mov    ah,byte ptr [si+OPCODE.COMPARE]
  505.     mov    al,[arg1.areg1]
  506.     cmp    ah,8
  507.     jae    aop3ext
  508.     cmp    al,4
  509.     jae    aop3errx
  510. aop3c:
  511.     shl    al,3
  512.     or    al,ah
  513.     stosb
  514.     ret
  515. aop3ext:
  516.     sub    al,4
  517.     jnc    aop3c
  518. aop3errx:
  519.     stc
  520.     ret
  521.     
  522. AOP3    ENDP
  523. ;
  524. ; either combo of a reg & rm... bit 1 of opcode set if reg is dest
  525. ; bit 0 set if size = word
  526. ;
  527. AOP4    PROC
  528.     call    noarg3
  529.     call    intsize
  530.     sub    al,al
  531.     mov    bx,offset arg1
  532.     call    sizeb0
  533.      cmp    [arg1.mode],AM_REG
  534.     jne    aop4rs
  535.     or    al,2
  536.     mov    bx,offset arg2
  537.     mov    ah,[arg1.areg1]
  538.     jmp    aop4j
  539.  
  540. aop4rs:
  541.      cmp    [arg2.mode],AM_REG
  542.     jne    aop4err
  543.     mov    bx,offset arg1
  544.     mov    ah,[arg2.areg1]
  545. aop4j:
  546.     or    al,byte ptr [si+OPCODE.COMPARE]
  547.     stosb
  548.     mov    al,ah
  549.     call    asmrm
  550.     ret
  551. aop4err:
  552.     stc
  553.     ret
  554. AOP4    ENDP
  555. ;
  556. ; use only rm, bit 0 = size (exception : jmp/call)
  557. ;
  558. AOP5    PROC
  559.     call    noarg2
  560.     call    intsize
  561.     mov    bx,offset arg1
  562.     mov    ax,[si+OPCODE.COMPARE]
  563.     test    al,1
  564.     jz    aop5cansize
  565.     cmp    [arg1.asize],DWORDSIZE    ; special sizing for jump
  566.     jne    aop5jn4
  567.     and    [PrefixBitmapWord],NOT AS_OPSIZE
  568.     or    ah,8
  569. aop5jn4:
  570.     cmp    [bx+asmop.asize],WORDSIZE
  571.     je    aop5unsized
  572.     cmp    [bx+asmop.asize],NOSIZE
  573.     je    aop5unsized
  574.     stc
  575.     ret
  576. aop5cansize:
  577.     call    sizeb0
  578. aop5unsized:
  579.     stosb
  580.     xchg    al,ah
  581.     and    al,38h
  582.     mov    bx,offset arg1
  583.     call    asmrm2
  584.     ret
  585. AOP5    ENDP
  586. ;
  587. ; rm,count or rm,cl (shifts) bit 0 = size
  588. ; bit 1 set if size = 1, bit 4 set if size = cl, otherwise follow rm with
  589. ; a count byte
  590. ;
  591. AOP6    PROC
  592.     call    noarg3
  593.     call    intsize
  594.     mov    bx,offset arg1
  595.     mov    ax,[si+opcode.compare]
  596.     call    sizeb0
  597.     cmp    [arg2.mode],AM_REG
  598.     je    aop6cl
  599.     cmp    [arg2.mode],AM_IMM
  600.     je    aop6imm
  601. aop6b:
  602.     stc
  603.     ret
  604. aop6cl:
  605.     cmp    [arg2.asize],BYTESIZE
  606.     jne    aop6b
  607.     cmp    [arg2.areg1],isECX
  608.     jne    aop6b
  609.     or    al,12h
  610.     stosb
  611.     jmp    aop6rm
  612. aop6imm:
  613.     cmp    [arg2.addrx],1
  614.     je    aop6shift1
  615.     stosb
  616.     xchg    al,ah
  617.     call    asmrm2
  618.     mov    al,byte ptr [arg2.addrx]
  619.     stosb
  620.     ret
  621. aop6shift1:
  622.     or    al,10h
  623.     stosb
  624. aop6rm:
  625.     xchg    al,ah
  626.     call    asmrm2
  627.     ret
  628. AOP6    ENDP
  629. ;
  630. ; unordered version of AOP4.  (any combo of reg and RM)
  631. ; This is XCHG instructions,
  632. ; this is unordered, so, it doesn't
  633. ; need to know which comes first
  634. ;
  635. ; bit 0 = size
  636. ;
  637. AOP7    PROC
  638.     call    noarg3
  639.     call    intsize
  640.     sub    al,al
  641.     mov    bx,offset arg1
  642.     call    sizeb0
  643.      cmp    [arg1.mode],AM_REG
  644.     jne    aop7rs
  645.     mov    bx,offset arg2
  646.     mov    ah,[arg1.areg1]
  647.     jmp    aop7j
  648.  
  649. aop7rs:
  650.      cmp    [arg2.mode],AM_REG
  651.     jne    aop7err
  652.     mov    bx,offset arg1
  653.     mov    ah,[arg2.areg1]
  654. aop7j:
  655.     or    al,byte ptr [si+OPCODE.COMPARE]
  656.     stosb
  657.     mov    al,ah
  658.     call    asmrm
  659.     ret
  660. aop7err:
  661.     stc
  662.     ret
  663. AOP7    ENDP
  664. ;
  665. ; word regrm, reg = dest.
  666. ;
  667. AOP8    PROC
  668.     call    noarg3
  669.     call    intsize
  670.     cmp    [arg1.asize],BYTESIZE
  671.     je    aop8errx
  672.     mov    bx,offset arg1
  673.     call    chkreg
  674.     mov    al,[bx+asmop.asize]
  675.     cmp    bl,1
  676.     jne    aop8ok
  677. aop8errx:
  678.     stc
  679.     ret
  680. aop8ok:
  681.     mov    al,byte ptr [si+OPCODE.COMPARE]
  682.     stosb
  683.     mov    al,[bx+asmop.areg1]
  684.     mov    bx,offset arg2
  685.     call    asmrm
  686.     ret
  687. AOP8    ENDP
  688. ;
  689. ; interrupts (imm byte)
  690. ;
  691. AOP9    PROC
  692.     call    noarg2
  693.     call    intsize
  694.     mov    bx,offset arg1
  695.     call    chkimm
  696.     cmp    byte ptr [arg1.addrx],3
  697.     je    aop9i3
  698.     mov    al,byte ptr [si+OPCODE.COMPARE]
  699.     or    al,1
  700.     stosb
  701.     mov    al,byte ptr [bx+asmop.addrx]
  702.     stosb
  703.     clc
  704.     ret
  705. aop9i3:
  706.     mov    al,0cch
  707.     stosb
  708.     ret
  709. AOP9    ENDP
  710. ;
  711. ; short relative branches
  712. ;
  713. AOP10    PROC
  714.     call    noarg2
  715.     call    intsize
  716.     mov    bx,offset arg1
  717.     call    chkimm
  718.     movzx    eax,[lastofs]
  719.     sub    eax,[bx+asmop.addrx]
  720.     neg    eax
  721.     sub    eax,2
  722.     cmp    eax,-128
  723.     jl    aop10errx
  724.     cmp    eax,127
  725.     jle    aop10ok
  726. aop10errx:
  727.     stc
  728.     ret
  729. aop10ok:
  730.     push    ax
  731.     mov    al,byte ptr [si+OPCODE.COMPARE]
  732.     stosb
  733.     pop    ax
  734.     stosb
  735.     clc
  736.     ret
  737. AOP10    ENDP
  738. ;
  739. ; RM, IMMEDIATE
  740. ; bit 0 = size
  741. ;
  742. AOP11    PROC
  743.     call    noarg3
  744.     call    intsize
  745.     mov    bx,offset arg2
  746.     call    chkimm
  747.     mov    bx,offset arg1
  748.     mov    ax,[si+OPCODE.COMPARE]
  749.     call    sizeb0
  750.     stosb
  751.     xchg    al,ah
  752.     call    asmrm2
  753.     mov    bx,offset arg2
  754.     call    rmszimm
  755.     ret
  756. AOP11    ENDP
  757. ;
  758. ; ACC,immediate
  759. ; bit 0 = size
  760. ;
  761. AOP12    PROC
  762.     call    noarg3
  763.     call    intsize
  764.     mov    bx,offset arg1
  765.     call    chkax
  766.     mov    bx,offset arg2
  767.     call    chkimm
  768.     mov    al,byte ptr [si+OPCODE.COMPARE]
  769.     call    sizeb0
  770.     stosb
  771.     call    rmszimm
  772.     ret
  773. AOP12    ENDP
  774. ;
  775. ; mem,acc
  776. ; bit 0 = size
  777. ;
  778. AOP13    PROC
  779.     call    noarg3
  780.     call    intsize
  781.     mov    bx,offset arg2
  782.     call    chkax
  783.     mov    bx,offset arg1
  784.     call    chkmem
  785.     mov    al,byte ptr [si+OPCODE.COMPARE]
  786.     call    sizeb0
  787.     stosb
  788.     call    rmszoffs
  789.     ret
  790. AOP13    ENDP
  791. ;
  792. ; sign-extended RM/IMM
  793. ; b1 = 0, treat as normal RM/IMM (aop11)
  794. ; else b01=11 means sign-extend byte to word
  795. ;
  796. AOP14    PROC
  797.     call    noarg3
  798.     call    intsize
  799.     mov    bx,offset arg2
  800.     call    chkimm
  801.     cmp    [bx+asmop.asize],BYTESIZE
  802.     je    aop11
  803.     mov    eax,[bx +asmop.addrx]
  804.     cmp    eax,-128
  805.     jl    aop11
  806.     cmp    eax,127
  807.     jge    aop11
  808. ;
  809. ; get here for signed extension
  810. ;
  811.     mov    bx,offset arg1
  812.     mov    ax,[si+opcode.compare]
  813.     or    al,3
  814.     stosb
  815.     xchg    al,ah
  816.     call    asmrm2
  817.     mov    al,byte ptr [arg2.addrx]
  818.     stosb
  819.     ret
  820. AOP14    ENDP
  821. ;
  822. ; acc,imm
  823. ; b3 of opcode = size
  824. ; 
  825. AOP15    PROC
  826.     call    noarg3
  827.     call    intsize
  828.     mov    bx,offset arg1
  829.     call    chkax
  830.     mov    bx,offset arg2
  831.     call    chkimm
  832.     mov    al,byte ptr [si+OPCODE.COMPARE]
  833.     call    sizeb3
  834.     stosb
  835.     call    rmszimm
  836.     ret
  837. AOP15    ENDP
  838. ;
  839. ; seg,regrm or regrm,seg
  840. ; b1 set if seg is dest
  841. ;
  842. AOP16    PROC
  843.     call    noarg3
  844.     call    intsize
  845.     mov    bx,offset arg1
  846.     cmp    [bx+asmop.mode],AM_SEG
  847.     jne    aop16seg2
  848.     mov    al,byte ptr [si+OPCODE.COMPARE]
  849.     or    al,2
  850.     mov    ah,[bx+asmop.areg1]
  851.     mov    bx,offset arg2
  852.     jmp    aop16rm
  853. aop16seg2:
  854.     mov    bx,offset arg2
  855.     call    chkseg
  856.     mov    al,byte ptr [si+OPCODE.COMPARE]
  857.     mov    ah,[bx+asmop.areg1]
  858.     mov    bx,offset arg1
  859. aop16rm:
  860.     stosb
  861.     xchg    al,ah
  862.     call    asmrm
  863.     ret
  864. AOP16    ENDP
  865. ;
  866. ; returns which pop the stack
  867. ;
  868. AOP17    PROC
  869.     call    noarg2
  870.     call    intsize
  871.     mov    bx,offset arg1
  872.     call    chkimm
  873.     mov    al,byte ptr [si+OPCODE.COMPARE]
  874.     stosb
  875.     mov    ax,word ptr [bx+asmop.addrx]
  876.     stosw
  877.     clc
  878.     ret
  879. AOP17    ENDP
  880. ;
  881. ; far branch or call
  882. ;
  883. AOP18    PROC
  884.     call    noarg2
  885.     call    intsize
  886.     cmp    [arg1.mode],AM_SEGOFFS
  887.     jne    aop18bad
  888.     mov    al,byte ptr [si+OPCODE.COMPARE]
  889.     stosb
  890.     mov    ax,word ptr [arg1.addrx2]
  891.     stosw
  892.     mov    ax,word ptr [arg1.addrx]
  893.     stosw
  894.     clc
  895.     ret
  896. aop18bad:
  897.     stc
  898.     ret
  899. AOP18    ENDP
  900. ;
  901. ; ESC instruction
  902. ; imm,rm... imm is six bits and fills the low three bits of the
  903. ; opcode and the reg field
  904. ;
  905. AOP19    PROC
  906.     call    noarg3
  907.     call    intsize
  908.     mov    bx,offset arg1
  909.     call    chkimm
  910.     mov    al,byte ptr [bx+asmop.addrx]
  911.     shr    al,3
  912.     and    al,7
  913.     or    al,byte ptr [si+OPCODE.compare]
  914.     stosb
  915.     mov    al,byte ptr [bx+asmop.addrx]
  916.     and    al,7
  917.     mov    bx,offset arg2
  918.     call    asmrm
  919.     ret
  920. AOP19    ENDP
  921. ;
  922. ; long relative branch
  923. ;  (the parser fills in the 0f starter)
  924. ;
  925. AOP20    PROC
  926.     call    noarg2
  927.     call    intsize
  928.     mov    bx,offset arg1
  929.     call    chkimm
  930.     movzx    eax,[lastofs]
  931.     sub    eax,[bx+asmop.addrx]
  932.     neg    eax
  933.     sub    eax,3
  934.     cmp    byte ptr [si+OPCODE.COMPARE],0e0h
  935.     jae    aop20got
  936.     dec    eax
  937. aop20got:
  938.     cmp    eax,-32768
  939.     jl    aop20errx
  940.     cmp    eax,32767
  941.     jle    aop20ok
  942. aop20errx:
  943.     stc
  944.     ret
  945. aop20ok:
  946.     push    ax
  947.     mov    al,byte ptr [si+OPCODE.COMPARE]
  948.     stosb
  949.     pop    ax
  950.     stosw
  951.     clc
  952.     ret
  953. AOP20    ENDP
  954. ;
  955. ;    acc,dx (in instructions)
  956. ;    bit 0 = size
  957. ;
  958. AOP21    PROC
  959.     call    noarg3
  960.     call    intsize
  961.     mov    bx,offset arg2
  962.     call    chkdx
  963.     mov    bx,offset arg1
  964.     call    chkax
  965.     mov    al,byte ptr [ si+OPCODE.COMPARE]
  966.     cmp    [bx+asmop.asize],BYTESIZE
  967.     je    aop21nw
  968.     or    al,1
  969. aop21nw:
  970.     cmp    [bx +asmop.asize],DWORDSIZE    ; auto prefixing on
  971.     jne    aop21nw2        ; ins & outs is disabled
  972.     or    [PrefixBitmapWord],AS_OPSIZE
  973. aop21nw2:
  974.     stosb
  975.     clc
  976.     ret
  977. AOP21    ENDP
  978. ;
  979. ; dx,acc (out_)
  980. ; bit 0 = size
  981. ;
  982. AOP22    PROC
  983.     call    noarg3
  984.     call    intsize
  985.     mov    bx,offset arg1
  986.     call    chkdx
  987.     mov    bx,offset arg2
  988.     call    chkax
  989.     mov    al,byte ptr [ si+OPCODE.COMPARE]
  990.     cmp    [bx+asmop.asize],BYTESIZE
  991.     je    aop22nw
  992.     or    al,1
  993. aop22nw:
  994.     cmp    [bx +asmop.asize],DWORDSIZE    ; auto prefixing on
  995.     jne    aop22nw2        ; ins & outs is disabled
  996.     or    [PrefixBitmapWord],AS_OPSIZE
  997. aop22nw2:
  998.     stosb
  999.     clc
  1000.     ret
  1001. AOP22    ENDP
  1002. ;
  1003. ; port,acc or acc,port
  1004. ; b0 =size, b1 = 1 if port is dest
  1005. ;
  1006. AOP23    PROC
  1007.     call    noarg3
  1008.     call    intsize
  1009.     test    byte ptr [si+OPCODE.COMPARE],2
  1010.     jz    aop23in
  1011.     mov    bx,offset arg2
  1012.     call    chkax
  1013.     mov    bx,offset arg1
  1014.     call    chkimm
  1015.     jmp    aop23j
  1016. aop23in:
  1017.     mov    bx,offset arg1
  1018.     call    chkax
  1019.     mov    bx,offset arg2
  1020.     call    chkimm
  1021. aop23j:
  1022.     mov    al,byte ptr [si+OPCODE.compare]
  1023.     cmp    [bx +asmop.asize],WORDSIZE
  1024.     jb    aop23b
  1025.            or    al,1
  1026. aop23b:
  1027.     clc
  1028.     stosb
  1029.     mov    al,byte ptr [bx +asmop.addrx]
  1030.     stosb
  1031.     ret
  1032. AOP23    ENDP
  1033. ;
  1034. ; acc,mem
  1035. ; bit 0 = size
  1036. ;
  1037. AOP24    PROC
  1038.     call    noarg3
  1039.     call    intsize
  1040.     mov    bx,offset arg1
  1041.     call    chkax
  1042.     mov    bx,offset arg2
  1043.     call    chkmem
  1044.     mov    al,byte ptr [si+OPCODE.COMPARE]
  1045.     call    sizeb0
  1046.     stosb
  1047.     call    rmszoffs
  1048.     ret
  1049. AOP24    ENDP
  1050. ;
  1051. ; immediate byte or word
  1052. ; this is push imm, bit 1 set for byte
  1053. ; we were about due for a departure from the standard...
  1054. ; anyway the op is sign-extended if it is byte size
  1055. ;
  1056. AOP25    PROC
  1057.     call    noarg2
  1058.     call    intsize
  1059.     mov    bx,offset arg1
  1060.     call    chkimm
  1061.     mov    al,byte ptr [si+OPCODE.COMPARE]
  1062.     mov    ebx,[bx+asmop.addrx]
  1063.     cmp    ebx,-128
  1064.     jl    aop25w
  1065.     cmp    ebx,127
  1066.     jg    aop25w
  1067. ;
  1068. ; byte size
  1069. ;
  1070.     or    al,2
  1071.     stosb
  1072.     mov    al,bl
  1073.     stosb
  1074.     ret
  1075. aop25w:
  1076.     stosb
  1077.     test    [PrefixBitmapWord],AS_OPSIZE
  1078.     jnz    aop25dw
  1079.     cmp    ebx,-23768
  1080.     jl    aop25dw
  1081.     cmp    ebx,32767
  1082.     jg    aop25dw
  1083.     mov    ax,bx
  1084.     stosw
  1085.     clc
  1086.     ret
  1087. aop25dw:
  1088.     or    [PrefixBitmapWord],AS_OPSIZE
  1089.     mov    eax,ebx
  1090.     stosd
  1091.     clc
  1092.     ret
  1093. AOP25    ENDP
  1094. ;
  1095. ; enter command, we have a word then a byte
  1096. ;
  1097. AOP26    PROC
  1098.     call    noarg3
  1099.     call    intsize
  1100.     mov    bx,offset arg1
  1101.     call    chkimm
  1102.     mov    [bx+asmop.asize],WORDSIZE
  1103.     mov    bx,offset arg2
  1104.     call    chkimm
  1105.     mov    [bx+asmop.asize],BYTESIZE
  1106.     mov    al,byte ptr [si+OPCODE.COMPARE]
  1107.     stosb
  1108.     mov    ax,word ptr [arg1.addrx]
  1109.     stosw
  1110.     mov    al,byte ptr [arg2.addrx]
  1111.     stosb
  1112.     ret
  1113. AOP26    ENDP
  1114. ;
  1115. ; stringu/w/d, pushaw,pushfw, etc
  1116. ; explicit byte sizing handled elsewhere (aop0)
  1117. ;
  1118. AOP27    PROC
  1119.     call    noarg1
  1120.     call    intsize
  1121.     mov    al,byte ptr [si+opcode.compare]
  1122.     cmp    [lastbyte],'w'
  1123.     je    aop27w
  1124.     cmp    [lastbyte],'d'
  1125.     je    aop27dw
  1126. ;
  1127. ; get here if no size specced.
  1128.     mov    al,byte ptr [si+opcode.compare]
  1129.     and    al,NOT 1
  1130.     cmp    al,60h        ; default for push/pop is word
  1131.     je    aop27w
  1132.     cmp    al,9ch
  1133.     je    aop27w
  1134.     stosb        ; else default is byte
  1135.     clc
  1136.     ret
  1137. aop27dw:
  1138.     or    [PrefixBitmapWord],AS_OPSIZE    ; come here if specified dword
  1139. aop27w:
  1140.     mov    al,byte ptr [si+opcode.compare] ; or here if specified word
  1141.     stosb
  1142.     clc
  1143.     ret
  1144. AOP27    ENDP
  1145. ;
  1146. ; rm,reg (test instruction)
  1147. ; bit 0 = size
  1148. ; 
  1149. AOP28    PROC
  1150.     call    noarg3
  1151.     call    intsize
  1152.     mov    bx,offset arg2
  1153.     call    chkreg
  1154.     mov    al,byte ptr [si+OPCODE.COMPARE]
  1155.     call    sizeb0
  1156.     stosb
  1157.     mov    al,[arg2.areg1]
  1158.     mov    bx,offset arg1
  1159.     call    asmrm
  1160.     ret
  1161. AOP28    ENDP
  1162. ;
  1163. ; rm, size don't care
  1164. ;
  1165. AOP29    PROC
  1166.     call    noarg2
  1167.     mov    ax,[si+OPCODE.COMPARE]
  1168.     stosb
  1169.     xchg    al,ah
  1170.     mov    bx,offset arg1
  1171.     call    asmrm2
  1172.     ret
  1173. AOP29    ENDP
  1174. ;
  1175. ; RM, shift
  1176. ; bit 0 & 1 of opcode set if uses CL
  1177. ; bit 0 & 4 set if uses uses 1
  1178. ; else nothing set
  1179. ;
  1180. AOP30    PROC
  1181.     call    noarg3
  1182.     call    intsize
  1183.     mov    ax,word ptr [si+OPCODE.compare]
  1184.     and    al,0ech    ; get rid of extraneous bits
  1185.     mov    bx,offset arg2
  1186.     cmp    [bx+asmop.areg1],isEBX
  1187.     je    aop30cl
  1188.     call    chkimm
  1189.     cmp    [bx+asmop.addrx],1
  1190.     jne    aop30xx
  1191.     or    al,11h
  1192.     stosb
  1193.     xchg    al,ah
  1194.     call    asmrm2
  1195.     ret
  1196. aop30xx:
  1197.     or    al,3
  1198.     stosb
  1199.     xchg    al,ah
  1200.     call    asmrm2
  1201.     mov    al,byte ptr [arg2.addrx]
  1202.     stosb
  1203.     ret
  1204. aop30cl:
  1205.     cmp    [bx+asmop.asize],BYTESIZE
  1206.     jne    aop30bad
  1207.     cmp    [bx+asmop.mode],AM_REG
  1208.     jne    aop30bad
  1209.     stosb
  1210.     xchg    al,ah
  1211.     call    asmrm2
  1212.     ret
  1213.  
  1214. aop30bad:
  1215.     stc
  1216.     ret
  1217. AOP30    ENDP
  1218. ;
  1219. ; reg,rm,imm or reg,imm (imul)
  1220. ; bit 1 = set if immed = signed byte
  1221. ;
  1222. AOP31    PROC
  1223.     cmp    [arg3.mode],AM_NONE
  1224.     jne    aop31three
  1225.     mov    bx,offset arg1
  1226.     call    chkreg
  1227.     mov    al,byte ptr [si+OPCODE.compare]
  1228.     mov    bx,offset arg2
  1229.     call    chkimm
  1230.     call    aop31sb
  1231.     stosb
  1232.     push    ax
  1233.     mov    al,[arg1.areg1]
  1234.     mov    ah,al
  1235.     shl    al,3
  1236.     or    al,ah
  1237.     or    al,0c0h
  1238.     stosb
  1239.     jmp    aop31sz
  1240. aop31three:
  1241.     mov    bx,offset arg1
  1242.     call    chkreg
  1243.     mov    al,byte ptr [si+OPCODE.compare]
  1244.     mov    bx,offset arg3
  1245.     call    chkimm
  1246.     call    aop31sb
  1247.     stosb
  1248.     push    ax
  1249.     push    bx
  1250.     mov    al,[arg1.areg1]
  1251.     mov    bx,offset arg2
  1252.     call    asmrm
  1253.     pop    bx
  1254.     jmp    aop31sz
  1255. aop31sz:
  1256.     pop    ax
  1257.     test    al,2
  1258.     mov    eax,dword ptr [bx +asmop.addrx]
  1259.     jnz    aop31sb1
  1260.     test    [PrefixBitmapWord],AS_OPSIZE
  1261.     jz    aop31szw
  1262.     stosd
  1263.     clc
  1264.     ret
  1265. aop31szw:
  1266.     stosw
  1267.     clc
  1268.     ret
  1269. aop31sb1:
  1270.     stosb
  1271.     clc
  1272.     ret
  1273. aop31sb    PROC
  1274.     mov    ecx,[bx+asmop.addrx]
  1275.     test    ecx,NOT 7fh
  1276.     jnz    aop31sbx
  1277.     cmp    ecx,-80h
  1278.     jl    aop31sbx
  1279.     cmp    [bx+asmop.asize],BYTESIZE
  1280.     je    aop31sbx
  1281.     or    al,2
  1282. aop31sbx:
  1283.     ret
  1284. aop31sb    ENDP
  1285.  
  1286. AOP31    ENDP
  1287. ;
  1288. ; move to/from a special register
  1289. ; bit 1 = set if spc reg is the dest
  1290. ; bit 0 & 2 define the special reg
  1291. ;
  1292. AOP32    PROC
  1293.     call    noarg3
  1294.     call    intsize
  1295.     mov    bx,offset arg1
  1296.     mov    cx,offset arg2
  1297.     mov    ax,[si+OPCODE.COMPARE]
  1298.     cmp    [arg1.asize],DWORDSIZE
  1299.     jne    aop32bad
  1300.     cmp    [arg1.mode],am_reg
  1301.     je    aop32crsource
  1302.     or    al,2
  1303.     xchg    bx,cx
  1304. aop32crsource:               
  1305.     sub    dl,dl
  1306.     cmp    [ecx+asmop.mode],AM_CR
  1307.     je    aop32c
  1308.     mov    dl,1
  1309.     cmp    [ecx+asmop.mode],AM_DR
  1310.     je    aop32c
  1311.     mov    dl,4
  1312.     cmp    [ecx+asmop.mode],AM_TR
  1313.     jne    aop32bad
  1314. aop32c:
  1315.     or    al,dl
  1316.     stosb
  1317.     
  1318.     call    chkreg
  1319.     movzx    ecx,cx
  1320.     mov    al,[ecx+asmop.areg1]
  1321.     shl    al,3
  1322.     or    al,[bx +asmop.areg1]
  1323.     or    al,ah        ; actually is a MOD/RM which is restricted
  1324.                 ; to regs
  1325.     stosb
  1326.     and    [PrefixBitmapWord],NOT AS_OPSIZE    ; don't need opsize for this
  1327.                     ; and there will be no clash
  1328.                     ; if we got this far
  1329.     ret
  1330. aop32bad:
  1331.     stc
  1332.     ret
  1333. AOP32    ENDP
  1334. ;
  1335. ; rm,reg,count (shld/shrd)
  1336. ; bit 0 = set if using CL for count
  1337. ;
  1338. ;
  1339. aop33    PROC
  1340.     mov    bx,offset arg2
  1341.     call    chkreg
  1342.     cmp    [bx+asmop.asize],BYTESIZE
  1343.     je    aop33bad
  1344.     mov    ah,[bx+asmop.areg1]
  1345.     mov    al,byte ptr [si+OPCODE.compare]
  1346.     mov    bx,offset arg3
  1347.     cmp    [bx+asmop.areg1],isECX
  1348.     je    aop33cl
  1349.     call    chkimm
  1350.     stosb
  1351.     xchg    al,ah
  1352.     mov    bx,offset arg1
  1353.     call    asmrm
  1354.     mov    al,byte ptr [arg3.addrx]
  1355.     stosb
  1356.     ret
  1357. aop33cl:
  1358.     cmp    [bx+asmop.mode],AM_REG
  1359.     jne    aop33bad
  1360.     or    al,1h
  1361.     stosb
  1362.     xchg    al,ah
  1363.     mov    bx,offset arg1
  1364.     call    asmrm
  1365.     ret
  1366.  
  1367. aop33bad:
  1368.     stc
  1369.     ret
  1370. AOP33    ENDP
  1371. ;
  1372. ; push & pop rm
  1373. ;
  1374. AOP34    PROC
  1375.     call    noarg2
  1376.     call    intsize
  1377.     mov    bx,offset arg1
  1378.     cmp    [bx+asmop.asize],BYTESIZE
  1379.     je    aop34bad
  1380.     mov    ax,[si+OPCODE.compare]
  1381.     stosb
  1382.     xchg    al,ah
  1383.     call    asmrm2
  1384.     ret
  1385. aop34bad:
  1386.     stc
  1387.     ret
  1388. AOP34    ENDP
  1389. ;
  1390. ; floating R/M
  1391. ; bit two of opcode set if size is qword
  1392. ; bit 3 of mod/rm set if last ch = 'p'
  1393. ;
  1394. AOP35    PROC
  1395.          call    noarg2
  1396.     mov    ax,[si+OPCODE.COMPARE]
  1397.     and    ax,010d8h
  1398.     cmp    [arg1.mode],AM_FPREG
  1399.     je    aop35fin
  1400.     cmp    [arg1.asize],QWORDSIZE
  1401.     jne    aop35fin
  1402.     or    al,4
  1403. aop35fin:
  1404.     cmp    [lastbyte],'p'
  1405.     jne    aop35fin2
  1406.     or    ah,8
  1407. aop35fin2:
  1408.     stosb
  1409.     xchg    al,ah
  1410.     mov    bx,offset arg1
  1411.     call    asmfrm
  1412.     ret
  1413. AOP35    ENDP
  1414. ;
  1415. ; fmathp
  1416. ; sti),st(0) or nothing
  1417. ;
  1418. AOP36    PROC
  1419.     cmp    [arg3.mode],AM_NONE
  1420.     jne    aop36errx
  1421.     mov    ax,100h
  1422.     cmp    [arg2.mode],AM_NONE
  1423.     jne    aop362arg
  1424.     call    noarg1
  1425.     jmp    aop36fin
  1426. aop362arg:
  1427.     cmp    [arg1.mode],AM_FPREG
  1428.     jne    aop36errx
  1429.     cmp    [arg2.mode],AM_FPREG
  1430.     jne    aop36errx
  1431.     cmp    [arg2.areg1],isEAX
  1432.     jne    aop36errx
  1433.     mov    ah,[arg1.areg1]
  1434. aop36fin:
  1435.     or    ax,[si+OPCODE.COMPARE]
  1436.     stosw
  1437.     ret
  1438. aop36errx:
  1439.     stc
  1440.     ret
  1441. AOP36    ENDP
  1442. ;
  1443. ; fmath
  1444. ; st(i),st(0) ; st(0), st(i), mem
  1445. ; bit two of opcode set for i dest or qword mem
  1446. ; bit 3 of mod/rm gets flipped if reg & al &6 & bit 5 of mod/rm set
  1447. ; 
  1448. ;
  1449. AOP37    PROC
  1450.     cmp    [arg3.mode],AM_NONE
  1451.     jne    aop37errx
  1452.     mov    ax,[si+OPCODE.COMPARE]
  1453.     and    al,NOT 4
  1454.     cmp    [arg2.mode], AM_NONE
  1455.     je    aop37mem
  1456.     cmp    [arg1.mode],AM_FPREG
  1457.     jne    AOP37mem
  1458.     cmp    [arg2.mode],AM_FPREG
  1459.     jne    AOP37errx
  1460.     mov    bl,[arg2.areg1]
  1461.     mov    bh,[arg1.areg1]
  1462.     cmp    bh,0
  1463.     je    aop37isrc
  1464.     cmp    bl,0
  1465.     jne    aop37errx
  1466.     xchg    bl,bh
  1467.     or    al,4
  1468. aop37isrc:
  1469.     test    al,6
  1470.     jz    aop371
  1471.     test    ah,20h
  1472.     jz    aop371
  1473.     xor    ah,8
  1474. aop371:
  1475.     or    ah,bl
  1476.     or    ah,0c0h
  1477.     stosw
  1478.     ret
  1479. aop37mem:
  1480.     cmp    [arg2.mode],AM_NONE
  1481.     jne    aop37errx
  1482.     cmp    [arg1.asize],QWORDSIZE
  1483.     jne    aop37memnq
  1484.     or    al,4
  1485. aop37memnq:
  1486.     stosb
  1487.     xchg    al,ah
  1488.     mov    bx,offset [arg1]
  1489.     call    asmfrm
  1490.     ret
  1491. aop37errx:
  1492.     stc
  1493.     ret
  1494. AOP37    ENDP
  1495. ;
  1496. ; far RM
  1497. ;
  1498. AOP38    PROC
  1499.     call    noarg2
  1500.     cmp    [arg1.asize],DWORDSIZE
  1501.     jne    aop38errx
  1502.     cmp    [arg1.mode],AM_REG
  1503.     je    aop38errx
  1504.     mov    ax,[si+opcode.compare]
  1505.     stosb
  1506.     xchg    al,ah
  1507.     mov    bx,offset arg1
  1508.     call    asmrm2
  1509.     ret
  1510. aop38errx:
  1511.     stc
  1512.     ret
  1513. AOP38    ENDP
  1514. ;
  1515. ; word regrm with reg  source
  1516. ; bug: lets arpl [bx],eax through
  1517. ;
  1518. AOP39    PROC
  1519.     cmp    [arg2.asize],BYTESIZE
  1520.     jne    AOP40
  1521.     stc
  1522.     ret
  1523. AOP39    ENDP
  1524. ;
  1525. ; regrm with reg source
  1526. ; bit 0 = size
  1527. AOP40    PROC
  1528.     call    noarg3
  1529.     call    intsize
  1530.     mov    bx,offset arg2
  1531.     call    chkreg
  1532.     mov    al,byte ptr [si+opcode.compare]
  1533.     call    sizeb0
  1534.     stosb
  1535.     mov    al,[arg2.areg1]
  1536.     mov    bx,offset arg1
  1537.     call    asmrm
  1538.     ret
  1539. AOP40    ENDP
  1540. ;
  1541. ; rm,immediate
  1542. ;
  1543. AOP41    PROC
  1544.     call    noarg3
  1545.     call    intsize
  1546.     mov    bx,offset arg2
  1547.     call    chkimm
  1548.     cmp    [arg1.asize],BYTESIZE
  1549.     je    aop41errx
  1550.     mov    ax,[si+OPCODE.COMPARE]
  1551.     stosb
  1552.     xchg    al,ah
  1553.     mov    bx,offset arg1
  1554.     call    asmrm2
  1555.     mov    al,byte ptr [arg2.addrx]
  1556.     stosb
  1557.     ret
  1558. aop41errx:
  1559.     stc
  1560.     ret
  1561. AOP41    ENDP
  1562. ;
  1563. ; regrm with reg dest & forced strictness (MOVZX & MOVSX)
  1564. ; bit 0 of opcode set if size is word
  1565. ;
  1566. AOP42    PROC
  1567.     call    noarg3
  1568.     call    intsize
  1569.     mov    bx,offset arg1
  1570.     call    chkreg
  1571.     cmp    [arg1.asize],BYTESIZE
  1572.     je    aop42errx
  1573.     cmp    [arg2.asize],NOSIZE
  1574.     je    aop42errx
  1575.     mov    bx,offset arg2
  1576.     mov    ax,[si+OPCODE.COMPARE]
  1577.     call    sizeb0
  1578.     stosb
  1579.     xchg    al,ah
  1580.     call    asmrm2
  1581.     cmp    [arg1.asize],DWORDSIZE    ; another func for which
  1582.                     ; auto extend to dword doesn't work
  1583.     jne    aop42x
  1584.     or    [PrefixBitmapWord],AS_OPSIZE
  1585. aop42x:
  1586.     clc
  1587.     ret
  1588. aop42errx:
  1589.     stc
  1590.     ret
  1591. AOP42    ENDP
  1592. ;
  1593. ; not needed in assembler, same as no args
  1594. ; 
  1595. AOP43    PROC
  1596.     jmp    aop0
  1597. AOP43    ENDP
  1598. ;
  1599. ; unused
  1600. ;
  1601. AOP44    PROC
  1602.     call    noarg2
  1603.     call    intsize
  1604.     mov    bx,offset arg1
  1605.     call    chkreg
  1606.     cmp    [bx+asmop.asize],DWORDSIZE
  1607.     jne    aop44errx
  1608.     or    [PrefixBitmapWord],AS_OPSIZE
  1609.     mov    al,byte ptr [si+OPCODE.COMPARE]
  1610.     or    al,[bx+asmop.areg1]
  1611.     stosb
  1612.     ret
  1613. aop44errx:
  1614.     stc
  1615.     ret
  1616. AOP44    ENDP
  1617. ;
  1618. ; any regrm with reg source
  1619. ; same as aop40
  1620. ;
  1621. AOP45    PROC
  1622.     jmp    aop40
  1623. AOP45    ENDP
  1624. ;
  1625. ; rm , size don't care, but no regs
  1626. ;
  1627. AOP46    PROC
  1628.     cmp    [arg1.mode],AM_FPREG
  1629.     je    aop46err
  1630.     cmp    [arg1.mode],AM_REG
  1631.     jne    aop29
  1632. aop46err:
  1633.     stc
  1634.     ret
  1635. AOP46    ENDP
  1636. ;
  1637. ; ax reg only
  1638. ;
  1639. AOP47    PROC
  1640.     call    noarg2
  1641.     mov    bx,offset arg1
  1642.     call    chkaxw
  1643.     mov    ax,[si+OPCODE.COMPARE]
  1644.     stosw
  1645.     clc
  1646.     ret
  1647. AOP47    ENDP
  1648. ;
  1649. ; bswap, 32-bit reg to bits 0-3 of opcode
  1650. ;
  1651. AOP48    PROC
  1652.     call    noarg2
  1653.     call    intsize
  1654.     mov    bx,offset arg1
  1655.     call    chkreg
  1656.     cmp    [bx+asmop.asize],DWORDSIZE
  1657.     jne    aop48errx
  1658.     or    [PrefixBitmapWord],AS_OPSIZE
  1659.     mov    al,byte ptr [si+OPCODE.COMPARE]
  1660.     or    al,[bx+asmop.areg1]
  1661.     stosb
  1662.     ret
  1663. aop48errx:
  1664.     stc
  1665.     ret
  1666. AOP48    ENDP
  1667. ;
  1668. ; fst
  1669. ; same as next but no tbyte
  1670. ;
  1671. AOP49    PROC
  1672.     cmp    [arg1.asize],TBYTESIZE
  1673.     jb    aop50
  1674.     stc
  1675.     ret
  1676. AOP49    ENDP
  1677. ;
  1678. ; fld/fstp
  1679. ; freg
  1680. ; dword,qword,tybe
  1681. ; bit 1 of opcode set for tbyte
  1682. ; bit 2 of opcode set for qword or store
  1683. ; bit 5 of modrm set if tbyte
  1684. ; bit 3 of modrm gets cleared if not tbyte && bit 4 set
  1685. ;
  1686. AOP50    PROC
  1687.     call    noarg2
  1688.     mov    ax,[si+OPCODE.COMPARE]
  1689.     AND    ax,NOT 0e006h
  1690.     cmp    [arg1.mode],AM_FPREG
  1691.     je    aop50reg
  1692.     cmp    [arg1.asize],DWORDSIZE
  1693.     jb    aop50errx
  1694. aop502:
  1695.     cmp    [arg1.asize],TBYTESIZE
  1696.     jne    aop503
  1697.     or    ax,2802h
  1698.     jmp    aop505
  1699.  
  1700. aop503:
  1701.     
  1702.     cmp    [arg1.asize],QWORDSIZE
  1703.     jne    aop504
  1704.     or    al,4
  1705. aop504:
  1706.     test    ah,10h
  1707.     jnz    aop505
  1708.     and    ah,NOT 8
  1709. aop505:
  1710.     stosb
  1711.     xchg    al,ah
  1712.     mov    bx,offset arg1
  1713.     call    asmfrm
  1714.     ret
  1715. aop50reg:
  1716.     test    ah,10h
  1717.     jnz    aop506
  1718.     and    ah,NOT 8
  1719.     jmp    aop507
  1720. aop506:
  1721.     or    al,4
  1722. aop507:
  1723.     or    ah,0c0h
  1724.     or    ah,[arg1.areg1]
  1725.     stosw
  1726.     ret
  1727. aop50errx:
  1728.     stc
  1729.     ret
  1730. AOP50    ENDP
  1731. ;
  1732. ;
  1733. ; fbld/fbstp
  1734. ; tbyte ptr mem
  1735. ;
  1736. AOP51    PROC
  1737.     call    noarg2
  1738.     cmp    [arg1.mode],AM_FPREG
  1739.     je    aop51errx
  1740.     cmp    [arg1.asize],NOSIZE
  1741.     je    aop51c
  1742.     cmp    [arg1.asize],TBYTESIZE
  1743.     jne    aop51errx
  1744. aop51c:
  1745.     mov    ax,[si+OPCODE.COMPARE]
  1746.     stosb
  1747.     xchg    al,ah
  1748.     mov    bx,offset arg1
  1749.     call    asmfrm
  1750.     ret
  1751. aop51errx:
  1752.     stc
  1753.     ret
  1754. AOP51    ENDP
  1755. ;
  1756. ; fild/fistp
  1757. ; word,dword,qword mem
  1758. ; bit 2 of opcode set if word or qword
  1759. ; bit 3 of modrm gets cleared if not qword & bit 4 is set
  1760. ; bit 5 or modrm set if qword
  1761. ;
  1762. AOP52    PROC
  1763.     call    noarg2
  1764.     mov    ax,[si+OPCODE.COMPARE]
  1765.     and    ax,NOT 2004h
  1766.     cmp    [arg1.mode],AM_FPREG
  1767.     je    aop52errx
  1768.     cmp    [arg1.asize],DWORDSIZE
  1769.     je    aop522
  1770.            or    al,4
  1771. aop522:
  1772.     cmp    [arg1.asize],QWORDSIZE
  1773.     ja    aop52errx
  1774.     jne    aop523
  1775.     or    ah,20h
  1776.     jmp    aop524
  1777. aop523:
  1778.     test    ah,10h
  1779.     jnz    aop524
  1780.     and    ah, NOT 8
  1781. aop524:    
  1782.     stosb
  1783.     xchg    al,ah
  1784.     mov    bx,offset arg1
  1785.     call    asmfrm
  1786.     ret
  1787. aop52errx:
  1788.     stc
  1789.     ret
  1790. AOP52    ENDP
  1791. ;
  1792. ; fist
  1793. ; same as above but no qword mode
  1794. ;
  1795. AOP53    PROC
  1796.     cmp    [arg1.asize],QWORDSIZE
  1797.     jb    aop52
  1798.     stc
  1799.     ret
  1800. AOP53    ENDP
  1801. ;
  1802. ; freg
  1803. ; reg put in mod/rm byte
  1804. ;
  1805. AOP54    PROC
  1806.     call    noarg2
  1807.     cmp    [arg1.mode],AM_FPREG
  1808.     jne    aop54errx
  1809.     mov    ax,[si+OPCODE.COMPARE]
  1810.     or    ah,[arg1.areg1]
  1811.     stosw
  1812.     ret
  1813. aop54errx:
  1814.     stc
  1815.     ret
  1816. AOP54    ENDP
  1817. ;
  1818. ; same as above, deault to reg 1 if no args
  1819. AOP55    PROC
  1820.     cmp    [arg3.mode],AM_NONE
  1821.     jne    aop55errx
  1822.     cmp    [arg2.mode],AM_NONE
  1823.     jne    aop55errx
  1824.     call    noarg2
  1825.     mov    ax,[si+OPCODE.COMPARE]
  1826.     cmp    [arg1.mode],AM_FPREG
  1827.     jne    aop55chknone
  1828.     or    ah,[arg1.areg1]
  1829.     stosw
  1830.     ret
  1831. aop55chknone:
  1832.     cmp    [arg1.mode],AM_NONE
  1833.     jne      aop55errx
  1834.     or    ah,1
  1835.     stosw
  1836.     ret    
  1837. aop55errx:
  1838.     stc
  1839.     ret
  1840. AOP55    ENDP
  1841. ;
  1842. ; fimath
  1843. ; word or dword arg
  1844. ; bit two gets set if word
  1845. ;
  1846. AOP56    PROC
  1847.     call    noarg2
  1848.     call    intsize
  1849.     cmp    [arg1.asize],BYTESIZE
  1850.     je    aop56errx
  1851.     cmp    [arg1.mode],AM_FPREG
  1852.     je    aop56errx
  1853.     mov    ax,[si+OPCODE.COMPARE]
  1854.     cmp    [arg1.asize],WORDSIZE
  1855.     jne    aop56c
  1856.     or    al,4
  1857. aop56c:
  1858.     stosb
  1859.     xchg    al,ah
  1860.     mov    bx,offset arg1
  1861.     call    asmfrm
  1862.     ret
  1863. aop56errx:
  1864.     ret
  1865.  
  1866. AOP56    ENDP
  1867.  
  1868. ;
  1869. ; addrsize prefix on one-byte
  1870. ;
  1871. AOP57    PROC
  1872.     or    [PrefixBitmapWord],AS_ADDRSIZE
  1873.     jmp    aop0
  1874. AOP57    ENDP
  1875. ;
  1876. ; opsize prefix on one-byte
  1877. ;
  1878. AOP58    PROC
  1879.     or    [PrefixBitmapWord],AS_OPSIZE
  1880.     jmp    aop0
  1881. AOP58    ENDP
  1882.     end