|
|
page ,132;*****************************Module*Header*******************************\; Module Name: cache.asm;;; Created: 9-Dec-1992; Author: Paul Butzi;; Copyright (c) 1990-1999 Microsoft Corporation;;*************************************************************************/; Note: This module would be more efficient with Frame Pointer Omission; (FPO), whereby the stack is addressed off ESP rather than EBP, so we; could stop pushing and popping EBP. However, the ASM macros currently; don't support FPO.;*************************************************************************/
.386 .model small,c
assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT assume fs:nothing,gs:nothing
.xlist include callconv.inc include gdii386.inc .list
.codeEXTRNP xprunFindRunRFONTOBJ,2EXTRNP xpgdDefault,1EXTRNP xInsertMetricsRFONTOBJ,3EXTRNP xInsertMetricsPlusRFONTOBJ,3EXTRNP xInsertGlyphbitsRFONTOBJ,3
ifdef FE_SBEXTRNP xwpgdGetLinkMetricsRFONTOBJ,2EXTRNP xwpgdGetLinkMetricsPlusRFONTOBJ,3endif
FAST_WCHAR_BASE equ 20h ; Most ANSI fonts have a base of 32
;******************************Public*Routine******************************\;; BOOL RFONTOBJ::bGetGlyphMetrics (; COUNT c,; GLYPHPOS *pgp,; WCHAR *pwc; );;; Translate wchars into an array of GLYPHPOS structures, filling in; the pointer to GLYPHDATA field. Only the metrics are assured to be; valid; no attempt is made to ensure that the glyph data itself is; present in the cache before the return to the caller.;; This routine is to be used primarily by GetTextExtent and GetCharWidths,; which have no need for anything except metrics.;; A zero return means that we failed to insert the metrics due to some; hard error, most likely a failure to commit memory in the glyph; insertion routine.;; History:; 21-Dec-92 -by- Michael Abrash; Fixed bug in detecting run inclusion; 9-Dec-92 -by- Paul Butzi; Wrote it.;**************************************************************************/
cPublicProc xGetGlyphMetrics,4,< \ uses ebx esi edi, \ pThis: ptr dword, \ c_: dword, \ pgp: ptr dword, \ pwc: dword > mov eax, pThis ; (eax) = ptr to RFONTOBJ mov eax, [eax].prfnt ; (eax) = ptr to RFONT mov esi, pwc ; pointer to wchar data ;*486 pipelining mov eax, [eax].wcgp ; (eax) = ptr to wcgp mov edi, pgp ; pointer to glyphpos array to fill ;*486 pipelining lea ebx, [eax].agprun ; (ebx) = ptr to first wcgp run ;*486 pipelining mov ecx, [ebx].wcLow ; index of start of run mov edx, [ebx].cGlyphs ; # of glyphs in run mov ebx, [ebx].apgd ; pointer to run's pointers to cached ; glyphdata
push ebp mov ebp,c_ ; we'll use EBP for the glyph count ; ***stack frame no longer available***;; Invariants:; (esi) = ptr to wchar; (edi) = ptr to pgp; (ebx) = ptr to base of current run; (ecx) = wcLow of current run; (edx) = cGlyphs of current run; (ebp) = count of glyphs remainingloop_top:
sub eax, eax mov ax, [esi] ; (eax) = wchar, zero extended
sub eax, ecx ; get index relative to current run base cmp eax, edx ; is wchar in this run? jae short find_run ; wrong run, better go get right one
run_found:
mov eax, [ebx+4*eax] ; (ecx) = ptr to glyphdata
;; Invariants:; (esi, edi, ebx, ecx, edx) as above at loop top; (eax) = ptr to glyphdata;default_found: and eax, eax ; is cached glyphdata there? jz short get_glyph ; no glyphdata, better go get one
;; Here, we are assured that the glyphdata is present in the cache;glyph_found: mov [edi].gp_pgdf, eax ; set ptr to glyphdata in glyphpos mov eax, [eax].gd_hg mov [edi].gp_hg, eax ; set hg in glyphpos
add edi, SIZE_GLYPHPOS ; next glyphpos to fill in add esi, 2 ; next wchar to look up
dec ebp ; any more glyphs? jnz loop_top
pop ebp ; ***stack frame available***
mov eax, 1 ; success stdRET xGetGlyphMetrics
;=======================================================================; We got here because the current run does not contain the wchar we're; interested in. Note that the following invariants must hold when; we re-enter the loop (starred items must hold on entry, as well):; (esi) = ptr to wchar*; (edi) = ptr to pgp*; (ebx) = ptr to apgd of new run; (ecx) = wcLow of new run; (edx) = cGlyphs of new run; (eax) = ptr to glyphdata; (ebp) = count of glyphs remaining*;======================================================================= align 4find_run: push ebp ; preserve count of remaining glpyhs mov ebp,[esp+4] ; ***stack frame available*** ; ***************************************** ; * Note that the approach here is to get * ; * EBP off the stack, where it was * ; * pushed, by addressing off ESP. EBP * ; * remains pushed, so we don't need to * ; * re-push it when we're done. * ; * XCHGing EBP with the top of the stack * ; * would be cleaner, but XCHG locks the * ; * bus. * ; * This trick is repeated several times * ; * below. * ; *****************************************
sub eax, eax mov ax, [esi] ; (eax) = current wchar mov ebx, pThis stdcall xprunFindRunRFONTOBJ, <ebx, eax> ; find the wchar's run
pop ebp ; <ebp> = glyph count ; ***stack frame no longer available*** mov ecx, [eax].wcLow ; index of start of new run mov edx, [eax].cGlyphs ; # of glyphs in new run mov ebx, [eax].apgd ; pointer to new run's pointers to ; cached glyphdata sub eax, eax mov ax, [esi] ; (eax) = current wchar sub eax, ecx ; get index relative to new run base cmp eax, edx ; is wchar in this run? jb run_found ; yes, run with it ; not in any run; use default character push ebp ; preserve count of remaining glyphs mov ebp,[esp+4] ; ***stack frame available***ifdef FE_SB ; call off to linked font handler push ebx push ecx push edx mov eax, pThis ; (eax) = pointer to RFONTOBJ sub ebx,ebx ; (ebx) = 0 mov bx, [esi] ; (ebx) = current wchar stdcall xwpgdGetLinkMetricsRFONTOBJ,<eax,ebx> pop edx pop ecx pop ebxelse mov eax, pThis push ecx push edx stdcall xpgdDefault, <eax> ; eax = ptr to default character pop edx pop ecxendif pop ebp ; <ebp> = glyph count jmp default_found ; go with the default character
;=======================================================================; We got here because the glyph pointer in the wcgp run was null, meaning; we don't yet have the metrics for this glyph. Note that the following; invariants must be true on exit (starred items must hold on entry, as; well):; (esi) = ptr to wchar*; (edi) = ptr to pgp*; (ebx) = ptr to apgd of new run*; (ecx) = wcLow of new run*; (edx) = cGlyphs of new run*; (eax) = ptr to glyphdata; (ebp) = count of glyphs remaining*;======================================================================= align 4get_glyph: push ebp ; preserve count of remaining glpyhs mov ebp,[esp+4] ; ***stack frame available***
push ebx push edx push ecx
sub eax, eax mov ax, [esi] ; (eax) = wchar mov edx, eax ; set aside wchar sub eax, ecx ; (eax) = index into run lea ebx, [ebx+eax*4] ; (ebx) = ptr to entry mov ecx,pThis stdcall xInsertMetricsRFONTOBJ, <ecx, ebx, edx> pop ecx pop edx and eax, eax ; were we able to get the glyph metrics? jz short failed ; no
mov eax, [ebx] ; get ptr to glyphdata from cache entry
pop ebx
pop ebp ; <ebp> = glyph count ; ***stack frame no longer available*** jmp glyph_found
failed: pop ebx
pop eax ; clear glyph count from stack pop eax ; clear pushed stack frame pointer from stack
sub eax, eax ; failure stdRET xGetGlyphMetrics
stdENDP xGetGlyphMetrics
;******************************Public*Routine******************************\;; BOOL RFONTOBJ::bGetGlyphMetricsPlus (; COUNT c,; GLYPHPOS *pgp,; WCHAR *pwc,; BOOL *pbAccel; );;; Translate wchars into an array of GLYPHPOS structures, filling in; the pointer to GLYPHDATA field. Although only the metrics are assured to be; valid, an attempt is made to ensure that the glyph data itself is; present in the cache before the return to the caller. Failure in this; attempt is indicated by clearing the flag *pbAccel. This allows the; text code to tell the device driver that the STROBJ_bEnum callback is; not needed.;; This routine is to be used primarily by TextOut and its kin.;; A zero return means that we failed to insert the metrics due to some; hard error, most likely a failure to commit memory in the glyph; insertion routine.;; This is a replacement for the C++ version in cache.cxx;; History:; 21-Dec-92 -by- Michael Abrash; Fixed bug in detecting run inclusion; 9-Dec-92 -by- Paul Butzi; Wrote it.;**************************************************************************/
cPublicProc xGetGlyphMetricsPlus,5,< \ uses ebx esi edi, \ pThis: ptr dword, \ c_: dword, \ pgp: ptr dword, \ pwc: dword, \ pbAccel: ptr dword > local pbacceltmp : dword ;1 if all glyph bits have been gotten ; so far, 0 if not
mov eax, pThis ; (eax) = ptr to RFONTOBJ mov pbacceltmp,1 ; set bAccel to true (all glyph bits ; realized so far) ;*486 pipelining mov eax, [eax].prfnt ; (eax) = ptr to RFONT mov esi, pwc ; pointer to wchar data ;*486 pipelining mov eax, [eax].wcgp ; (eax) = ptr to wcgp mov edi, pgp ; pointer to glyphpos array to fill ;*486 pipelining lea ebx, [eax].agprun ; (ebx) = ptr to first wcgp run ;*486 pipelining push ebp ;*486 pipelining mov ecx, [ebx].wcLow ; index of start of run mov edx, [ebx].cGlyphs ; # of glyphs in run mov ebx, [ebx].apgd ; pointer to run's pointers to cached ; glyphdata
mov ebp,c_ ; we'll use EBP for the glyph count ; ***stack frame no longer available***
;--------------------------------------------------------------------------; Fast two-glyphs-at-a-time Pentium pipe-lined loop;; The philosophy of this loop is that for the vast majority of the time,; all the glyphs will be in the proper range, have cached glyphdata, and; have cached glyphbits -- and it takes advantage of that to better make; use of both Pentium pipes by doing two glyphs at once. If one of those; conditions fail, it converts to the single-glyph-at-a-time loop when; that happens.;; Invariants:; (esi) = ptr to 1st wchar; (edi) = ptr to pgp; (ecx) = ptr to 2nd wchar; (ecx) = wcLow of current run; (edx) = cGlyphs of current run; (ebp) = count of glyphs remaining; [esp] = wcLow of current run
cmp ecx, FAST_WCHAR_BASE ; fast loop handles wcLow values only jne gmp_slow_loop_top ; of 32
dec ebp ; pre-decrement count jz gmp_slow_loop_top ; only one character. it's okay to ; pop this through to gmp_slow_loop_top ; with a zero count -- it's effectively ; the same as a one count
push ecx ; wcLow is now at [esp]
gmp_fast_loop_top: mov eax, [esi] ; 1U (eax) = first two glyphs add edi, 2*SIZE_GLYPHPOS ; 1V each iteration does two glyphpos's. ; we do this now to eat up a free V ; pipe instruction mov ecx, eax ; 1U add esi, 4 ; 1V each iteration does two wchars. ; we do this now to eat up a free V ; pipe instruction shr ecx, 16 ; 1U (ecx) = 2nd wchar, zero extended and eax, 0ffffh ; 1V (eax) = 1st wchar, zero extended
sub eax, FAST_WCHAR_BASE ; 1U get index relative to current base sub ecx, FAST_WCHAR_BASE ; 1V get index relative to current base
cmp eax, edx ; 1U is 1st wchar in this run? jae gmp_restart_in_slow_loop; 1V wrong run, exit fast loop cmp ecx, edx ; 1U is 2nd wchar in this run? jae gmp_restart_in_slow_loop; 1V wrong run, exit fast loop
mov eax, [ebx+4*eax] ; 2U (eax) = ptr to 1st glyphdata mov ecx, [ebx+4*ecx] ; 2V (ecx) = ptr to 2nd glyphdata ; (could be 3V if in same cache ; bank)
test eax, eax ; 1U is 1st cached glyphdata there? jz gmp_restart_in_slow_loop; 1V no glyphdata, exit fast loop test ecx, ecx ; 1U is 2nd cached glyphdata there? jz gmp_restart_in_slow_loop; 1V no glyphdata, exit fast loop
cmp dword ptr [eax].gd_gdf, 0 ; 2U are 1st glyph bits in cache? je gmp_restart_in_slow_loop ; 1V no, go get them cmp dword ptr [ecx].gd_gdf, 0 ; 2U are 2nd glyph bits in cache? je gmp_restart_in_slow_loop ; 1V no, go get them
mov [edi-2*SIZE_GLYPHPOS].gp_pgdf, eax ; 1U set ptr to glyphdata in glyphpos mov eax, [eax].gd_hg ; 1V read 1st glyph handle
mov [edi-1*SIZE_GLYPHPOS].gp_pgdf, ecx ; 1U set ptr to glyphdata in glyphpos mov ecx, [ecx].gd_hg ; 1V read 2nd glyph handle
mov [edi-2*SIZE_GLYPHPOS].gp_hg,eax ; 1U set handle in glyphpos mov [edi-1*SIZE_GLYPHPOS].gp_hg,ecx ; 1V set handle in glyphpos
sub ebp, 2 ; 1U each iteration does two glyphs jg gmp_fast_loop_top ; 1V more loops to do pop ecx ; account for pushed wcLow jz gmp_slow_loop_top ; odd number of glyphs, handle last one
pop ebp ; ***stack frame available*** mov ebx,pbaccel ; where we'll store whether all glyph ; bits found mov eax, 1 ; success mov [ebx], 1 ; success
stdRET xGetGlyphMetricsPlus
;--------------------------------------------------------------------------; Not-so-fast one-glyph-at-a-time loop;; Invariants:; (esi) = ptr to wchar; (edi) = ptr to pgp; (ebx) = ptr to base of current run; (ecx) = wcLow of current run; (edx) = cGlyphs of current run; (ebp) = count of glyphs remaining
gmp_restart_in_slow_loop: pop ecx ; (ecx) = wcLow of current run inc ebp ; account for fast-loop preadjustments sub edi, 2*SIZE_GLYPHPOS sub esi, 4
gmp_slow_loop_top: sub eax, eax mov ax, [esi] ; (eax) = wchar, zero extended
sub eax, ecx ; get index relative to current run base cmp eax, edx ; is wchar in this run? jae short gmp_find_run ; wrong run, better go get right one
gmp_run_found: mov eax, [ebx+4*eax] ; (ecx) = ptr to glyphdata
;; Invariants:; (esi, edi, ebx, ecx, edx) as above at loop top; (eax) = ptr to glyphdata;gmp_default_found: and eax, eax ; is cached glyphdata there? jz gmp_get_glyph ; no glyphdata, better go get one
;; Here, we are assured that the glyphdata is present in the cache;gmp_glyph_found: cmp dword ptr [eax].gd_gdf, 0 ; are the glyph bits in the cache? jz gmp_get_bits ; no, go get them
;; Here, we have tried to get the glyphbits in the cache;gmp_got_bits: mov [edi].gp_pgdf, eax ; set ptr to glyphdata in glyphpos mov eax, [eax].gd_hg mov [edi].gp_hg, eax ; set hg in glyphpos
add edi, SIZE_GLYPHPOS ; next glyphpos to fill in add esi, 2 ; next wchar to look up
dec ebp ; any more glyphs? jg gmp_slow_loop_top ; must be 'greater than' check
pop ebp ; ***stack frame available***
mov ebx,pbaccel ; where we'll store whether all glyph bits found mov eax,pbacceltmp ; 0 if not all found, 1 if all found mov [ebx],eax ; return whether we found all glyph bits or not
mov eax, 1 ; success stdRET xGetGlyphMetricsPlus
;=======================================================================; We got here because the current run does not contain the wchar we're; interested in. Note that the following invariants must hold when; we re-enter the loop (starred items must hold on entry, as well):; (esi) = ptr to wchar*; (edi) = ptr to pgp*; (ebx) = ptr to apgd of new run; (ecx) = wcLow of new run; (edx) = cGlyphs of new run; (eax) = ptr to glyphdata; (ebp) = count of glyphs remaining*;======================================================================= align 4gmp_find_run: push ebp ; preserve count of remaining glpyhs mov ebp,[esp+4] ; ***stack frame available***
sub eax, eax mov ax, [esi] ; (eax) = current wchar mov ebx, pThis
stdcall xprunFindRunRFONTOBJ, <ebx, eax>
pop ebp ; <ebp> = glyph count ; ***stack frame no longer available*** mov ecx, [eax].wcLow ; index of start of new run mov edx, [eax].cGlyphs ; # of glyphs in new run mov ebx, [eax].apgd ; pointer to new run's pointers to ; cached glyphdata sub eax, eax mov ax, [esi] ; (eax) = current wchar sub eax, ecx ; get index relative to new run base cmp eax, edx ; is wchar in this run? jb gmp_run_found ; yes, run with it ; not in any run; use default character push ebp ; preserve count of remaining glyphs mov ebp,[esp+4] ; ***stack frame available***
ifdef FE_SB push ebx push ecx push edx mov eax, pThis ; (eax) = pointer to RFONTOBJ lea ebx, pbacceltmp ; (ebx) = pointer to pbacceltmp ; (esi) = pointer to current wchar stdcall xwpgdGetLinkMetricsPlusRFONTOBJ,<eax,esi,ebx> pop edx pop ecx pop ebx ; (eax) is now proper wpgdelse mov eax,pThis push ecx push edx stdcall xpgdDefault, <eax> ; eax = ptr to default character pop edx pop ecxendif pop ebp ; <ebp> = glyph count ; ***stack frame no longer available***
jmp gmp_default_found ; go with the default character
;=======================================================================; We got here because the glyph pointer in the wcgp run was null, meaning; we don't yet have the metrics for this glyph. Note that the following; invariants must be true on exit (starred items must hold on entry, as; well):; (esi) = ptr to wchar*; (edi) = ptr to pgp*; (ebx) = ptr to apgd of new run*; (ecx) = wcLow of new run*; (edx) = cGlyphs of new run*; (eax) = ptr to glyphdata; (ebp) = count of glyphs remaining*;======================================================================= align 4gmp_get_glyph: push ebp ; preserve count of remaining glpyhs mov ebp,[esp+4] ; ***stack frame available***
push ebx push edx push ecx
sub eax, eax mov ax, [esi] ; (eax) = wchar mov edx, eax ; set aside wchar sub eax, ecx ; (eax) = index into run lea ebx, [ebx+4*eax] ; (ebx) = ptr to entry mov ecx,pThis stdcall xInsertMetricsPlusRFONTOBJ, <ecx, ebx, edx> pop ecx pop edx and eax, eax ; were we able to get the glyph metrics? jz short gmp_failed ; no
mov eax, [ebx] ; get ptr to glyphdata from it
pop ebx
pop ebp ; <ebp> = glyph count ; ***stack frame no longer available*** jmp gmp_glyph_found
gmp_failed: pop ebx
pop eax ; clear glyph count from stack pop eax ; clear pushed stack frame pointer from stack
sub eax, eax ;failure stdRET xGetGlyphMetricsPlus
;=======================================================================; We get here if we need to try to load the bits for the glyph we're; interested in (because the bits havene't been realized yet). We only; even bother to try if all bits have successfully been realized so far,; because it's only useful to realize glyphs if we can get all of them.; Note that the following invariants must be true on both entry and exit.; (esi) = ptr to wchar; (edi) = ptr to pgp; (ebx) = ptr to apgd of new run; (ecx) = wcLow of new run; (edx) = cGlyphs of new run; (eax) = ptr to glyphdata; (ebp) = count of glyphs remaining;======================================================================= align 4gmp_get_bits: push ebp ; preserve count of remaining glpyhs mov ebp,[esp+4] ; ***stack frame available***
cmp pbacceltmp,0 ;if we already failed to get glyph bits je short got_the_bits_done ; once, no point in trying again
push ecx mov ecx, pThis push edx ;*486 pipelining mov edx, [ecx].prfnt push eax ;*486 pipelining cmp dword ptr [edx].ulContent, FO_HGLYPHS je short got_the_bits
sub edx,edx cmp pwc,esi sbb edx,-1 ; EDX == TRUE if first wc, FALSE else stdcall xInsertGlyphbitsRFONTOBJ, <ecx, eax, edx> ;try to get the bits
and eax, eax ; did we succeed in getting the bits? jnz short got_the_bits ; yes, we got the bits mov pbacceltmp, eax ; didn't get the glyph (note: EAX is zero)got_the_bits: pop eax pop edx pop ecxgot_the_bits_done: pop ebp ; <ebp> = glyph count ; ***stack frame no longer available*** jmp gmp_got_bits
stdENDP xGetGlyphMetricsPlus
end
|
