home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c019 / 2.ddi / SOURCE / AMIGA / MATCH_68.A < prev    next >
Encoding:
Text File  |  1993-09-01  |  7.9 KB  |  260 lines
  1. ; This is a 68000 assembly language version of the Zip function
  2. ; longest_match().  It is written for any 680x0 based computer, but at this
  3. ; time the feature for runtime testing of CPU type is only supported for the
  4. ; Amiga.  Hopefully a similar test for the Macintosh is possible, and for any
  5. ; other system that supports both 68000 and 68020+ CPUs.  This is written by
  6. ; Paul Kienitz, partially derived from a simpler version by Carsten Steger,
  7. ; derived in turn from a 386 assembly function by Jean-loup Gailly and Uwe
  8. ; Rommel... but also based directly on the C original.  No rights reserved.
  9. ; 
  10. ; The main difference of this from other longest_match() implementations is
  11. ; that it includes both byte based and word based versions of the function,
  12. ; and various symbols can be defined to select whether to use one routine or
  13. ; the other, or to do a platform-specific test at runtime.  The symbols that
  14. ; can be used to select behavior are as follows:
  15. ;
  16. ;   CPU020     if defined, use 68020 instructions always
  17. ;   CPUTEST    if defined, check at runtime for CPU type.  Another symbol
  18. ;               specifying the platform-specific test must be used with this.
  19. ;               If neither of these is defined, use 68000 instructions only.
  20. ;   AMIGA      use Amiga-specific test for 68020, if CPUTEST defined.  Also
  21. ;               tells it to let a0/a1/d1 be clobbered by functions.
  22. ;   ATSIGN     define entry symbols in @foo form as well as _foo, with
  23. ;               @longest_match taking its parm in d0 instead of on the stack.
  24. ;
  25. ; NOTE: no provision is made for 16 bit ints.  All external int variables are
  26. ; treated as 32 bit values.  This also assumes that longest_match's result is
  27. ; returned in D0.
  28.  
  29.         IFND    CPU020
  30.         IFND    CPUTEST
  31. CPU000  equ     1
  32.         ENDC
  33.         ENDC
  34.  
  35. ; global variables:
  36.         xref    _max_chain_length   ; unsigned int
  37.         xref    _prev_length        ; unsigned int
  38.         xref    _match_start        ; unsigned int
  39.         xref    _strstart           ; unsigned int
  40.         xref    _good_match         ; signed int
  41.         xref    _nice_match         ; signed int
  42.         xref    _window             ; array of unsigned char
  43.         xref    _prev               ; array of unsigned short
  44.  
  45. ; our entry points:
  46.         xdef    _match_init         ; void match_init(void);
  47.         xdef    _longest_match      ; int longest_match(unsigned cur_match);
  48.         IFD     ATSIGN
  49.         xdef    @match_init         ; for SAS assembler
  50.         xdef    @longest_match      ; ditto
  51.         ENDC
  52.         
  53. ; flag variable for remembering CPU type:
  54.         IFD     CPUTEST
  55.         section cpuflag,data
  56. is020:  ds.w    1
  57.         ENDC
  58.  
  59.  
  60.         section match,code
  61. _match_init:
  62.         IFD    ATSIGN
  63. @match_init:
  64.         ENDC
  65.  
  66.         IFD     CPUTEST         ; now check for platform type
  67.         IFD     AMIGA           ; Amiga specific test for '020 CPU:
  68.  
  69.         xref    _SysBase
  70.  
  71.         NOLIST
  72.         INCLUDE       'exec/execbase.i'
  73.         LIST
  74.  
  75.         clr.w   is020           ; default value is 68000 
  76.         move.l  _SysBase,a0
  77.         btst    #AFB_68020,AttnFlags+1(a0)
  78.         beq.s   cheap
  79.         move.w  #1,is020
  80.  
  81. cheap:
  82.         ELSE ; !AMIGA
  83.  
  84.  !!   Write an '020-detector for your system here!
  85.  
  86.         ENDC ; AMIGA
  87.         ENDC ; CPUTEST
  88.         rts                ; match_init consists only of rts if CPUTEST unset
  89.  
  90.  
  91.         IFD     AMIGA
  92. SAVEREGS        reg     d3-d7/a2/a3/a5      ; don't protect d0/d1/a0/a1
  93.         ELSE
  94. SAVEREGS        reg     d1/d3-d7/a0-a3/a5   ; protect all but d0 return val
  95.         ENDC
  96.  
  97. Cur_Match       equr    d0                  ; Must be in d0!
  98. Best_Len        equr    d1
  99. Scan_Start      equr    d3
  100. Scan_End        equr    d4
  101. Limit           equr    d5
  102. Chain_Length    equr    d6
  103. Scan_Test       equr    d7
  104. Scan            equr    a0
  105. Match           equr    a1
  106. Prev_Address    equr    a2
  107. Scan_Ini        equr    a3
  108. Match_Ini       equr    a5
  109.  
  110.  
  111. MAX_MATCH       equ     258
  112. MIN_MATCH       equ     3
  113. WSIZE           equ     32768
  114. MAX_DIST        equ     WSIZE-MAX_MATCH-MIN_MATCH-1
  115.  
  116. _longest_match:
  117.         move.l  4(sp),Cur_Match         ; stack arg to register
  118.         IFD     ATSIGN
  119. @longest_match:
  120.         ENDC
  121.         movem.l SAVEREGS,-(sp)
  122.  
  123. ; setup steps common to byte and word versions:
  124.         move.l  _max_chain_length,Chain_Length
  125.         move.l  _prev_length,Best_Len
  126.         lea     _prev,Prev_Address
  127.         lea     _window,Match_Ini
  128.         move.l  _strstart,Limit
  129.         move.l  Match_Ini,Scan_Ini
  130.         addq    #MIN_MATCH,Match_Ini
  131.         add.l   Limit,Scan_Ini
  132.         subi.w  #MAX_DIST,Limit
  133.         bhi.s   limit_ok
  134.         moveq   #0,Limit
  135. limit_ok:
  136.         cmp.l   _good_match,Best_Len
  137.         bcs.s   length_ok
  138.         lsr.l   #2,Chain_Length
  139. length_ok:
  140.         subq.l  #1,Chain_Length
  141.  
  142.         IFD     CPUTEST
  143.         tst.w   is020               ; can we use '020 stuff today?
  144.         bne     WORD_match
  145.         ENDC
  146.  
  147.         IFND    CPU020
  148.  
  149. ; for 68000 or 68010, use byte operations:
  150.         moveq   #0,Scan_Start       ; clear 2nd and 4th bytes, use 1st & 3rd
  151.         moveq   #0,Scan_End
  152.         moveq   #0,Scan_Test
  153.         move.b  (Scan_Ini),Scan_Start
  154.         swap    Scan_Start
  155.         move.b  1(Scan_Ini),Scan_Start
  156.         move.b  -1(Scan_Ini,Best_Len),Scan_End
  157.         swap    Scan_End
  158.         move.b  0(Scan_Ini,Best_Len),Scan_End
  159.         bra.s   bdo_scan
  160.  
  161. blong_loop:
  162.         move.b  -1(Scan_Ini,Best_Len),Scan_End
  163.         swap    Scan_End
  164.         move.b  0(Scan_Ini,Best_Len),Scan_End
  165.  
  166. bshort_loop:
  167.         add.w   Cur_Match,Cur_Match
  168.         move.w  0(Prev_Address,Cur_Match.l),Cur_Match
  169.         cmp.l   Limit,Cur_Match
  170.         dbls    Chain_Length,bdo_scan
  171.         bra     return
  172.  
  173. bdo_scan:
  174.         move.l  Match_Ini,Match
  175.         add.l   Cur_Match,Match
  176.         move.b  -MIN_MATCH-1(Match,Best_Len),Scan_Test
  177.         swap    Scan_Test
  178.         move.b  -MIN_MATCH(Match,Best_Len),Scan_Test
  179.         cmp.l   Scan_Test,Scan_End
  180.         bne.s   bshort_loop
  181.         move.b  -MIN_MATCH(Match),Scan_Test
  182.         swap    Scan_Test
  183.         move.b  -MIN_MATCH+1(Match),Scan_Test
  184.         cmp.l   Scan_Test,Scan_Start
  185.         bne.s   bshort_loop
  186.         move.w  #(MAX_MATCH-MIN_MATCH),Scan_Test
  187.         lea     MIN_MATCH(Scan_Ini),Scan
  188.  
  189. bscan_loop:
  190.         cmpm.b  (Match)+,(Scan)+
  191.         dbne    Scan_Test,bscan_loop
  192.         subq    #1,Scan
  193.  
  194.         sub.l   Scan_Ini,Scan
  195.         cmp.l   Best_Len,Scan
  196.         bls.s   bshort_loop
  197.         move.l  Scan,Best_Len
  198.         move.l  Cur_Match,_match_start
  199.         cmp.l   _nice_match,Best_Len
  200.         bcs.s   blong_loop
  201.         IFD     CPUTEST
  202.         bra     return
  203.         ENDC
  204.  
  205.         ENDC ; !CPU020
  206.  
  207.         IFND    CPU000
  208.         
  209. ; for 68020 or higher, use word operations even on odd addresses:
  210. WORD_match:
  211.         move.w  (Scan_Ini),Scan_Start
  212.         move.w  -1(Scan_Ini,Best_Len),Scan_End
  213.         bra.s   wdo_scan
  214.  
  215. wlong_loop:
  216.         move.w  -1(Scan_Ini,Best_Len),Scan_End
  217.  
  218. wshort_loop:
  219.         add.w   Cur_Match,Cur_Match
  220.         move.w  (Prev_Address,Cur_Match.l),Cur_Match
  221.         cmp.l   Limit,Cur_Match
  222.         dbls    Chain_Length,wdo_scan
  223.         bra.s   return
  224.  
  225. wdo_scan:
  226.         move.l  Match_Ini,Match
  227.         add.l   Cur_Match,Match
  228.         cmp.w   -MIN_MATCH-1(Match,Best_Len),Scan_End
  229.         bne.s   wshort_loop
  230.         cmp.w   -MIN_MATCH(Match),Scan_Start
  231.         bne.s   wshort_loop
  232.         moveq   #((MAX_MATCH-MIN_MATCH)/2),Scan_Test    ; value = 127
  233.         lea     MIN_MATCH(Scan_Ini),Scan
  234.  
  235. wscan_loop:
  236.         cmpm.w  (Match)+,(Scan)+
  237.         dbne    Scan_Test,wscan_loop
  238.         subq    #2,Scan
  239.         move.b  -MIN_MATCH+1(Match),Scan_Test
  240.         cmp.b   (Scan),Scan_Test
  241.         bne     steven
  242.         addq    #1,Scan
  243. steven:
  244.         sub.l   Scan_Ini,Scan
  245.         cmp.l   Best_Len,Scan
  246.         bls.s   wshort_loop
  247.         move.l  Scan,Best_Len
  248.         move.l  Cur_Match,_match_start
  249.         cmp.l   _nice_match,Best_Len
  250.         bcs.s   wlong_loop
  251.  
  252.         ENDC ; !CPU000
  253.  
  254. return:
  255.         move.l  Best_Len,d0             ; function return value
  256.         movem.l (sp)+,SAVEREGS
  257.         rts
  258.  
  259.         end
  260.