home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 6 File / 06-File.zip / ramfs102.zip / src / vmheap.asm < prev    next >
Assembly Source File  |  2002-10-20  |  17KB  |  663 lines
  1. ; $Id: vmheap.asm,v 1.1.2.3 2002/10/21 00:11:36 root Exp $
  2. ;
  3. ; VM block transfer routines. ALP v 4.00.007 or later required.
  4.  
  5.     .586p
  6.     .MMX
  7.     .XMM
  8.  
  9.     extern    DOS32FLATDS:abs
  10.     extern    _fix_kernel:FAR32
  11.     public    _threednow
  12.     OPTION  SEGMENT:USE16
  13.  
  14. _BSS    segment public 'BSS'
  15.     extern    _DevHlp: dword
  16.     extern    _flat_ds: word
  17.     far_gate fword    ?
  18.     _threednow dw ?
  19. _BSS    ends
  20.  
  21. DGROUP  GROUP _BSS
  22.  
  23. _TEXT32 segment para public use32 'CODE'
  24.         assume cs:_TEXT32
  25.         assume ds:FLAT, es:FLAT
  26.  
  27. ; Workhorse procedure for SIMD data transfer. Derived from:
  28. ; 
  29. ; AMD Athlon<TM> Processor x86 Code Optimization 22007J  August 2001
  30. ; Chapter 10: "3DNow!<TM> and MMX<TM> Optimizations"
  31. ;
  32. ; AMD Athlon Processor-Specific Code
  33. ;
  34. ; The following memory copy example is written with Microsoft
  35. ; Visual C++ in-line assembler syntax, and assumes that the
  36. ; Microsoft Processor Pack is installed (available from
  37. ; Microsoft's web site). This is a general purpose memcpy()
  38. ; routine, which can efficiently copy any size block, small or
  39. ; large. Data alignment is strongly recommended for good
  40. ; performance, but this code can handle non-aligned blocks.
  41. ;
  42. ; Example 2: Optimized memcpy() for Any Data Size or Alignment
  43. ;
  44. TINY_BLOCK_COPY     EQU    64  ; upper limit for movsd type copy
  45. ; The smallest copy uses the X86 "movsd" instruction, in an optimized
  46. ; form which is an "unrolled loop".
  47. IN_CACHE_COPY         EQU    64 * 1024 ; upper limit for movq/movq copy w/SW prefetch
  48. ; Next is a copy that uses the MMX registers to copy 8 bytes at a time,
  49. ; also using the "unrolled loop" optimization. This code uses
  50. ; the software prefetch instruction to get the data into the cache.
  51. UNCACHED_COPY         EQU    197 * 1024 ; upper limit for movq/movntq w/SW prefetch
  52. ; For larger blocks, which will spill beyond the cache, it's faster to
  53. ; use the Streaming Store instruction MOVNTQ. This write instruction
  54. ; bypasses the cache and writes straight to main memory. This code also
  55. ; uses the software prefetch instruction to pre-read the data.
  56. ; USE 64 * 1024 FOR THIS VALUE IF YOU'RE ALWAYS FILLING A "CLEAN CACHE"
  57. CACHEBLOCK     EQU    80h ; # of 64-byte blocks (cache lines) for block prefetch
  58. ; For the largest size blocks, a special technique called Block Prefetch
  59. ; can be used to accelerate the read operations. Block Prefetch reads
  60. ; one address per cache line, for a series of cache lines, in a short loop.
  61. ; This is faster than using software prefetch. The technique is great for
  62. ; getting maximum read bandwidth, especially in DDR memory systems.
  63.  
  64. ramfs_3dnow_transfer proc far
  65.     push    ebp
  66.     mov    ebp, esp
  67.     sub    esp, 108
  68.      fsave    [ebp-108]
  69.     mov    ebx, ecx        ; keep a copy of count
  70.     cld
  71.  
  72.     cmp    ecx, TINY_BLOCK_COPY
  73.     jb    $memcpy_ic_3        ; tiny? skip mmx copy
  74.     cmp    ecx, 32*1024        ; don't align between 32k-64k because
  75.     jbe    $memcpy_do_align    ; it appears to be slower
  76.     cmp    ecx, 64*1024
  77.     jbe    $memcpy_align_done
  78. $memcpy_do_align:
  79.     mov    ecx, 8            ; a trick that's faster than rep movsb...
  80.     sub    ecx, edi        ; align destination to qword
  81.     and    ecx, 111b        ; get the low bits
  82.     sub    ebx, ecx        ; update copy count
  83.     neg    ecx            ; set up to jump into the array
  84.     add    ecx, offset FLAT:$memcpy_align_done
  85.     jmp    ecx            ; jump to array of movsb`s
  86.     align    4
  87.     movsb
  88.     movsb
  89.     movsb
  90.     movsb
  91.     movsb
  92.     movsb
  93.     movsb
  94.     movsb
  95. $memcpy_align_done:            ; destination is dword aligned
  96.     mov    ecx, ebx        ; number of bytes left to copy
  97.     shr    ecx, 6            ; get 64-byte block count
  98.     jz    $memcpy_ic_2        ; finish the last few bytes
  99.     cmp    ecx, IN_CACHE_COPY/64    ; too big 4 cache? use uncached copy
  100.     jae    $memcpy_uc_test
  101. ; This is small block copy that uses the MMX registers to copy 8 bytes
  102. ; at a time. It uses the "unrolled loop" optimization, and also uses
  103. ; the software prefetch instruction to get the data into the cache.
  104.     ALIGN    16
  105. $memcpy_ic_1:                ; 64-byte block copies, in-cache copy
  106.     prefetchnta ds:[esi+(200*64/34+192)] ; start reading ahead
  107.     movq    mm0, ds:[esi+0]        ; read 64 bits
  108.     movq    mm1, ds:[esi+8]
  109.     movq    es:[edi+0], mm0        ; write 64 bits
  110.     movq    es:[edi+8], mm1        ; note: the normal movq writes the
  111.     movq    mm2, ds:[esi+16]    ; data to cache; a cache line will be
  112.     movq    mm3, ds:[esi+24]    ; allocated as needed, to store the data
  113.     movq    es:[edi+16], mm2
  114.     movq    es:[edi+24], mm3
  115.     movq    mm0, ds:[esi+32]
  116.     movq    mm1, ds:[esi+40]
  117.     movq    es:[edi+32], mm0
  118.     movq    es:[edi+40], mm1
  119.     movq    mm2, ds:[esi+48]
  120.     movq    mm3, ds:[esi+56]
  121.     movq    es:[edi+48], mm2
  122.     movq    es:[edi+56], mm3
  123.     add    esi, 64            ; update source pointer
  124.     add    edi, 64            ; update destination pointer
  125.     dec    ecx            ; count down
  126.     jnz    $memcpy_ic_1        ; last 64-byte block?
  127. $memcpy_ic_2:
  128.     mov    ecx, ebx        ; has valid low 6 bits of the byte count
  129. $memcpy_ic_3:
  130.     shr    ecx, 2            ; dword count
  131.     and    ecx, 1111b        ; only look at the "remainder" bits
  132.     neg    ecx            ; set up to jump into the array
  133.     add    ecx, offset FLAT:$memcpy_last_few
  134.     jmp    ecx            ; jump to array of movsd`s
  135. $memcpy_uc_test:
  136.     cmp    ecx, UNCACHED_COPY/64    ; big enough? use block prefetch copy
  137.     jae    $memcpy_bp_1
  138. $memcpy_64_test:
  139.     or    ecx, ecx        ; tail end of block prefetch will jump here
  140.     jz    $memcpy_ic_2        ; no more 64-byte blocks left
  141. ; For larger blocks, which will spill beyond the cache, it's faster to
  142. ; use the Streaming Store instruction MOVNTQ. This write instruction
  143. ; bypasses the cache and writes straight to main memory. This code also
  144. ; uses the software prefetch instruction to pre-read the data.
  145.     align    16
  146. $memcpy_uc_1:                ; 64-byte blocks, uncached copy
  147.     prefetchnta ds:[esi+(200*64/34+192)] ; start reading ahead
  148.     movq    mm0, ds:[esi+0]        ; read 64 bits
  149.     add    edi,64            ; update destination pointer
  150.     movq    mm1, ds:[esi+8]
  151.     add    esi,64            ; update source pointer
  152.     movq    mm2, ds:[esi-48]
  153.     movntq    es:[edi-64], mm0        ; write 64 bits, bypassing the cache
  154.     movq    mm0, ds:[esi-40]        ; note: movntq also prevents the CPU
  155.     movntq    es:[edi-56], mm1        ; from READING the destination address
  156.     movq    mm1, ds:[esi-32]        ; into the cache, only to be over-written
  157.     movntq    es:[edi-48], mm2        ; so that also helps performance
  158.     movq    mm2, ds:[esi-24]
  159.     movntq    es:[edi-40], mm0
  160.     movq    mm0, ds:[esi-16]
  161.     movntq    es:[edi-32], mm1
  162.     movq    mm1, ds:[esi-8]
  163.     movntq    es:[edi-24], mm2
  164.     movntq    es:[edi-16], mm0
  165.     dec    ecx
  166.     movntq    es:[edi-8], mm1
  167.     jnz    $memcpy_uc_1        ; last 64-byte block?
  168.     jmp    $memcpy_ic_2        ; almost dont
  169. ; For the largest size blocks, a special technique called Block Prefetch
  170. ; can be used to accelerate the read operations. Block Prefetch reads
  171. ; one address per cache line, for a series of cache lines, in a short loop.
  172. ; This is faster than using software prefetch. The technique is great for
  173. ; getting maximum read bandwidth, especially in DDR memory systems.
  174. $memcpy_bp_1:                ; large blocks, block prefetch copy
  175.     cmp    ecx, CACHEBLOCK        ; big enough to run another prefetch loop?
  176.     jl    $memcpy_64_test        ; no, back to regular uncached copy
  177.     mov    eax, CACHEBLOCK / 2    ; block prefetch loop, unrolled 2X
  178.     add    esi, CACHEBLOCK * 64    ; move to the top of the block
  179.     align    16
  180. $memcpy_bp_2:
  181.     mov    edx, ds:[esi-64]    ; grab one address per cache line
  182.     mov    edx, ds:[esi-128]    ; grab one address per cache line
  183.     sub    esi, 128        ; go reverse order to suppress HW prefetcher
  184.     dec    eax            ; count down the cache lines
  185.     jnz    $memcpy_bp_2        ; keep grabbing more lines into cache
  186.     mov    eax, CACHEBLOCK        ; now that it's in cache, do the copy
  187.     align    16
  188. $memcpy_bp_3:
  189.     movq    mm0, ds:[esi]        ; read 64 bits
  190.     movq    mm1, ds:[esi+8]
  191.     movq    mm2, ds:[esi+16]
  192.     movq    mm3, ds:[esi+24]
  193.     movq    mm4, ds:[esi+32]
  194.     movq    mm5, ds:[esi+40]
  195.     movq    mm6, ds:[esi+48]
  196.     movq    mm7, ds:[esi+56]
  197.     add    esi, 64            ; update source pointer
  198.     movntq    es:[edi], mm0        ; write 64 bits, bypassing cache
  199.     movntq    es:[edi+8], mm1        ; note: movntq also prevents the CPU
  200.     movntq    es:[edi+16], mm2    ; from READING the destination address
  201.     movntq    es:[edi+24], mm3    ; into the cache, only to be over-written,
  202.     movntq    es:[edi+32], mm4    ; so that also helps performance
  203.     movntq    es:[edi+40], mm5
  204.     movntq    es:[edi+48], mm6
  205.     movntq    es:[edi+56], mm7
  206.     add    edi, 64            ; update dest pointer
  207.     dec    eax            ; count down
  208.     jnz    $memcpy_bp_3        ; keep copying
  209.     sub    ecx, CACHEBLOCK        ; update the 64-byte block count
  210.     jmp    $memcpy_bp_1        ; keep processing blocks
  211. ; The smallest copy uses the X86 "movsd" instruction, in an optimized
  212. ; form which is an "unrolled loop". Then it handles the last few bytes.
  213.     align    4
  214.     movsd
  215.     movsd    ; perform last 1-15 dword copies
  216.     movsd
  217.     movsd
  218.     movsd
  219.     movsd
  220.     movsd
  221.     movsd
  222.     movsd
  223.     movsd    ; perform last 1-7 dword copies
  224.     movsd
  225.     movsd
  226.     movsd
  227.     movsd
  228.     movsd
  229.     movsd
  230. $memcpy_last_few:            ; dword aligned from before movsd`s
  231.     mov    ecx, ebx        ; has valid low 2 bits of the byte count
  232.     and    ecx, 11b        ; the last few cows must come home
  233.     jz    $memcpy_final        ; no more, let's leave
  234.     rep    movsb            ; the last 1, 2, or 3 bytes
  235. $memcpy_final:
  236.     emms                ; clean up the MMX state
  237.     sfence                ; flush the write buffer
  238.  
  239.       frstor    [ebp-108]
  240.     mov    esp, ebp
  241.     pop    ebp
  242.     retf
  243.  
  244. ramfs_3dnow_transfer    endp
  245.  
  246. ; The old yet reliable DWORD copy procedure
  247.  
  248. ramfs_dword_transfer    proc far
  249.     mov    ebx, ecx
  250.     cld
  251.     shr    ecx, 2
  252.     and    ebx, 3
  253.     rep    movsd
  254.     mov    ecx, ebx
  255.     rep    movsb
  256.     retf
  257. ramfs_dword_transfer    endp
  258.             
  259. _TEXT32 ends
  260.  
  261. _TEXT    segment public 'CODE'
  262.  
  263.     assume es:nothing, ss:nothing, ds:DGROUP, fs:nothing, gs:nothing
  264.  
  265.     public    VMVIRTTOFLAT
  266.     public    VMALLOC
  267.     public    VMFREE
  268.     public    VMREADUCHAR
  269.     public    VMREADUSHORT
  270.     public    VMREADBLK
  271.     public    VMWRITEBLK
  272.     public    VMREAD
  273.     public    VMWRITE
  274.     public    VMCOPY
  275.  
  276.  
  277. ;-----------------------------------------------------------------------------
  278. ; FLAT _pascal VMVirtToFlat (void *p);
  279. ;-----------------------------------------------------------------------------
  280.  
  281. VMVIRTTOFLAT    proc near
  282.     push    bp
  283.     mov    bp, sp
  284.     push    si
  285.  
  286.     movzx    esi, word ptr [bp+4]    ; offset of p
  287.     mov    ax, word ptr [bp+6]    ; selector of p
  288.     mov    dl, 5Bh            ; _DevHlp_VirtToLin
  289.     call    [_DevHlp]
  290.     jnc    vvtf_end
  291.     xor    eax, eax
  292. vvtf_end:
  293.  
  294.     shld    edx, eax, 16
  295.     pop    si
  296.     pop    bp
  297.     ret    4
  298. VMVIRTTOFLAT    endp
  299.  
  300.  
  301.  
  302.  
  303. ;-----------------------------------------------------------------------------
  304. ; FLAT _pascal VMAlloc (ULONG cbSize);
  305. ;-----------------------------------------------------------------------------
  306.  
  307. VMALLOC    proc near
  308.     push    bp
  309.     mov    bp, sp
  310.  
  311.     mov    ecx, [bp+4]        ; cbSize
  312.     mov    eax, 00000004h        ; flags
  313.     mov    dl, 57h            ; _DevHlp_VMAlloc
  314.     call    [_DevHlp]
  315.     jnc    va_end
  316.     xor    eax, eax
  317. va_end:
  318.  
  319.     shld    edx, eax, 16
  320.     pop    bp
  321.     ret    4
  322. VMALLOC    endp
  323.  
  324.  
  325.  
  326.  
  327. ;-----------------------------------------------------------------------------
  328. ; void _pascal VMFree (FLAT flatBlock);
  329. ;-----------------------------------------------------------------------------
  330.  
  331. VMFREE    proc near
  332.     push    bp
  333.     mov    bp, sp
  334.  
  335.     mov    eax, [bp+4]        ; flatBlock
  336.     mov    dl, 58h            ; _DevHlp_VMFree
  337.     call    [_DevHlp]
  338.     jnc    vf_end
  339.     int    3
  340. vf_end:
  341.     pop    bp
  342.     ret     4
  343. VMFREE    endp
  344.  
  345.  
  346.  
  347.  
  348. ;-----------------------------------------------------------------------------
  349. ; UCHAR _pascal VMReadUChar (FLAT flatSrc);
  350. ;-----------------------------------------------------------------------------
  351.  
  352. VMREADUCHAR    proc near
  353.     push    bp
  354.     mov    bp, sp
  355.     mov    ax, DOS32FLATDS
  356.     mov    es, ax
  357.  
  358.     mov    eax, [bp+4]        ; flatSrc
  359.     mov    al, es:[eax]
  360.  
  361.     pop    bp
  362.     ret    4
  363. VMREADUCHAR    endp
  364.  
  365.  
  366.  
  367.  
  368. ;-----------------------------------------------------------------------------
  369. ; USHORT _pascal VMReadUShort (FLAT flatSrc);
  370. ;-----------------------------------------------------------------------------
  371.  
  372. VMREADUSHORT    proc near
  373.     push    bp
  374.     mov    bp, sp
  375.     mov    ax, DOS32FLATDS
  376.     mov    es, ax
  377.  
  378.     mov    eax, [bp+4]        ; flatSrc
  379.     mov    ax, es:[eax]
  380.  
  381.     pop    bp
  382.     ret    4
  383. VMREADUSHORT    endp
  384.  
  385.  
  386.  
  387.  
  388. ;-----------------------------------------------------------------------------
  389. ; void _pascal VMReadBlk (BLOCK _ss *pBlk, FLAT flatBlk);
  390. ;-----------------------------------------------------------------------------
  391.  
  392. VMREADBLK    proc near
  393.     push    bp
  394.     mov    bp, sp
  395.     push    ds
  396.     mov    ax, DOS32FLATDS
  397.     mov    es, ax
  398.  
  399.     mov    ebx, [bp+4]        ; flatBlk
  400.     mov    eax, es:[ebx+0]
  401.     mov    edx, es:[ebx+4]
  402.     lds    bx, dword ptr [bp+8]    ; pBlk
  403.     mov    ds:[bx+0], eax
  404.     mov    ds:[bx+4], edx
  405.  
  406.     pop    ds
  407.     pop    bp
  408.     ret    8
  409. VMREADBLK    endp
  410.  
  411.  
  412.  
  413.  
  414. ;-----------------------------------------------------------------------------
  415. ; void _pascal VMWriteBlk (FLAT flatBlk, BLOCK _ss *pBlk);
  416. ;-----------------------------------------------------------------------------
  417.  
  418. VMWRITEBLK    proc near
  419.     push    bp
  420.     mov    bp, sp
  421.     push    ds
  422.     mov    ax, DOS32FLATDS
  423.     mov    es, ax
  424.  
  425.     lds    bx, dword ptr [bp+4]    ; pBlk
  426.     mov    eax, ds:[bx+0]
  427.     mov    edx, ds:[bx+4]
  428.     mov    ebx, [bp+8]        ; flatBlk
  429.     mov    es:[ebx+0], eax
  430.     mov    es:[ebx+4], edx
  431.  
  432.     pop    ds
  433.     pop    bp
  434.     ret    8
  435. VMWRITEBLK    endp
  436.  
  437.  
  438.  
  439.  
  440. ;-----------------------------------------------------------------------------
  441. ; void _pascal VMRead (void *pDest, FLAT flatSrc, USHORT cbLen);
  442. ;-----------------------------------------------------------------------------
  443.  
  444. VMREAD    proc near
  445.     push    bp
  446.     mov    bp, sp
  447.     push    si
  448.     push    di
  449.     push    ds
  450.     push    es
  451.     mov    ax, DOS32FLATDS
  452.     mov    ds, ax
  453.  
  454.     sub    ecx, ecx
  455.     mov    cx, [bp+4]        ; number of bytes to copy
  456.     xor    edi, edi
  457.     mov    esi, [bp+6]        ; source
  458.     les    di, [bp+10]        ; destination
  459.  
  460.     push    fs
  461.     mov    ax, seg    DGROUP
  462.     mov    fs, ax
  463.     call    fword ptr fs:far_gate
  464.     pop    fs
  465.  
  466.     pop    es    
  467.     pop    ds
  468.     pop    di
  469.     pop    si
  470.     pop    bp
  471.     ret    10
  472. VMREAD    endp
  473.  
  474.  
  475.  
  476. ;-----------------------------------------------------------------------------
  477. ; void _pascal VMWrite (FLAT flatDest, void *pSrc, USHORT cbLen);
  478. ;-----------------------------------------------------------------------------
  479.  
  480. VMWRITE    proc near
  481.     push    bp
  482.     mov    bp, sp
  483.     push    si
  484.     push    di
  485.     push    ds
  486.     push    es
  487.     mov    ax, DOS32FLATDS
  488.     mov    es, ax
  489.  
  490.     mov    edi, [bp+10]        ; flatDest
  491.     xor    esi, esi
  492.     lds    si, [bp+6]        ; pSrc
  493.     xor    ecx, ecx
  494.     mov    cx, word ptr [bp+4]    ; cbLen
  495.  
  496.     push    fs
  497.     mov    ax, seg    DGROUP
  498.     mov    fs, ax
  499.     call    fword ptr fs:far_gate
  500.     pop    fs
  501.  
  502.     pop    es
  503.     pop    ds
  504.     pop    di
  505.     pop    si
  506.     pop    bp
  507.     ret     10
  508. VMWRITE    endp
  509.  
  510.  
  511.  
  512.  
  513. ;-----------------------------------------------------------------------------
  514. ; void _pascal VMCopy (FLAT flatDest, FLAT flatSrc, ULONG cbLen);
  515. ;-----------------------------------------------------------------------------
  516.  
  517. VMCOPY    proc near
  518.     push    bp
  519.     mov    bp, sp
  520.     push    es
  521.     push    ds
  522.     push    si
  523.     push    di
  524.     mov    ax, DOS32FLATDS
  525.     mov    es, ax
  526.     mov    ds, ax
  527.  
  528.     mov    edi, [bp+12]        ; flatDest
  529.     mov    esi, [bp+8]        ; flatSrc
  530.     mov    ecx, [bp+4]         ; cbLen
  531.     mov    edx, ecx
  532.     cmp    edi, esi
  533.     je    vc_end
  534.     ja    vc_backwards
  535.  
  536.     ; move forwards
  537.     push    fs
  538.     mov    ax, seg    DGROUP
  539.     mov    fs, ax
  540.     call    fword ptr fs:far_gate
  541.     pop    fs
  542.     jmp    vc_end
  543.  
  544. vc_backwards:
  545.     ; move backwards
  546.     lea    esi, [esi+ecx-1]
  547.     lea    edi, [edi+ecx-1]
  548.     and    ecx, 0003h
  549.     std
  550.     rep    movs byte ptr es:[edi], byte ptr es:[esi]
  551.     sub    esi, 3
  552.     sub    edi, 3
  553.     mov    ecx, edx
  554.     shr    ecx, 2
  555.     rep    movs dword ptr es:[edi], dword ptr es:[esi]
  556.     cld
  557.  
  558. vc_end:
  559.     pop    di
  560.     pop    si
  561.     pop    ds
  562.     pop    es
  563.     pop    bp
  564.     ret    12
  565. VMCOPY    endp
  566.  
  567. ;
  568. ; Weird initialization routine. _fix_kernel can't be issued at the init time,
  569. ; so it's deferred as we plant init_cont to sit in place of real transfer
  570. ; subroutine.
  571. ; 
  572.  
  573. VMINIT    proc    near
  574.     push    ds
  575.     mov    ax, seg    DGROUP
  576.     mov    ds, ax
  577.     mov    dword ptr ds:far_gate, 0
  578.     mov    word ptr ds:far_gate, offset init_cont
  579.     mov    word ptr ds:far_gate+4, seg init_cont
  580.     pop    ds
  581.     ret
  582. init_cont:
  583.     pushad
  584.     push    ds
  585.     push    es
  586.     push    fs
  587.     mov    ax, seg    DGROUP
  588.     mov    ds, ax
  589.     mov    fs, ax
  590.     mov    al, 9            ; This is an undocumented DosEnv entry
  591.     mov    dl, 24h
  592.     call    [_DevHlp]
  593.         mov     es, ax
  594.     mov    cx, seg    DGROUP
  595.         movzx   ax, byte ptr es:[bx]
  596.         shl     ax, 2
  597.     mov    ds, cx
  598.         add     bx, ax
  599.         mov     ax, word ptr es:[bx+26h] ; Flat CS
  600.         mov     word ptr ds:far_gate+4, ax
  601.         mov     ax, word ptr es:[bx+2Ah] ; Flat DS
  602.         mov     word ptr ds:_flat_ds, ax
  603. ; Check if 3DNow! was forced
  604.     mov    ax, ds:_threednow
  605.     or    ax, ax
  606.     jz    no_3dnow
  607.     cmp    al, 1
  608.     je    ok_3dnow
  609. ; 3DNow!<TM> detection - AMD technote #21928G/0 March 2000
  610.     pushfd
  611.     pop    eax
  612.     mov    ebx, eax
  613.     xor    eax, 00200000h        ; Flip CPUID bit
  614.     push    eax
  615.     popfd
  616.     pushfd
  617.     pop    eax
  618.     cmp    eax, ebx
  619.     je    no_3dnow
  620.     mov    eax, 80000000h
  621.     cpuid
  622.     cmp    eax, 80000000h
  623.     jbe    no_3dnow
  624.     mov    eax, 80000001h
  625.     cpuid
  626.     test    edx, 80000000h
  627.     je    no_3dnow
  628. ; Now try to apply the patch. Compose the address manually using Flat CS
  629. ; provided by kernel.
  630. ok_3dnow:
  631.     push    es
  632.     push    ds
  633.     mov    dword ptr fs:far_gate, offset FLAT:_fix_kernel
  634.     mov    ax, fs:_flat_ds
  635.     mov    ds, ax
  636.     mov    es, ax
  637.      call    fword ptr fs:far_gate
  638.     pop    ds
  639.     pop    es
  640.     or    eax, eax
  641.     jz    kernel_fixed
  642.     mov    ax, fs:_threednow
  643.     cmp    al, 1            ; If 3DNow! was forced, let it stay
  644.     jne    no_3dnow
  645. kernel_fixed:
  646. ; Install the appropriate handler
  647.     mov    dword ptr ds:far_gate, offset FLAT:ramfs_3dnow_transfer
  648.     jmp    short far_gate_done
  649. no_3dnow:
  650.     mov    dword ptr ds:far_gate, offset FLAT:ramfs_dword_transfer
  651. far_gate_done:
  652.     pop    fs
  653.     pop    es
  654.     pop    ds
  655.     popad
  656.     jmp    fword ptr fs:far_gate
  657. VMINIT    endp
  658.  
  659.  
  660. _TEXT    ends
  661.  
  662.     end
  663.