← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xserver-xgl/intrepid

« back to all changes in this revision

Viewing changes to hw/xfree86/xaa/xaaTEGlyphBlt.S

  • Committer: Bazaar Package Importer
  • Author(s): Matthew Garrett
  • Date: 2006-02-13 14:21:43 UTC
  • Revision ID: james.westby@ubuntu.com-20060213142143-mad6z9xzem7hzxz9
Tags: upstream-7.0.0
Import upstream version 7.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/xfree86/xaa/xaaTEGlyphBlt.S
 
1
/*
 
2
 * Copyright 1996  The XFree86 Project
 
3
 *
 
4
 * Permission is hereby granted, free of charge, to any person obtaining a 
 
5
 * copy of this software and associated documentation files (the "Software"), 
 
6
 * to deal in the Software without restriction, including without limitation 
 
7
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
 
8
 * and/or sell copies of the Software, and to permit persons to whom the 
 
9
 * Software is furnished to do so, subject to the following conditions:
 
10
 *
 
11
 * The above copyright notice and this permission notice shall be included in
 
12
 * all copies or substantial portions of the Software.
 
13
 * 
 
14
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
15
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
16
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
 
17
 * HARM HANEMAAYER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 
18
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
 
19
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
 
20
 * SOFTWARE.
 
21
 * 
 
22
 * Written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
 
23
 */
 
24
/* $XFree86: xc/programs/Xserver/hw/xfree86/xaa/xaaTEGlyphBlt.S,v 1.1 1999/07/10 07:24:54 dawes Exp $ */
 
25
 
 
26
 
 
27
/*
 
28
 * Intel Pentium-optimized versions of "terminal emulator font" text
 
29
 * bitmap transfer routines.
 
30
 *
 
31
 * SCANLINE_PAD_DWORD.
 
32
 *
 
33
 * Only for glyphs with a fixed width of 6 pixels or 8 pixels.
 
34
 */
 
35
 
 
36
#include "assyntax.h"
 
37
 
 
38
#ifndef QNX4
 
39
        FILE("xaaTEGlyphBlt.s")
 
40
#else
 
41
        FILE( __FILE__ )
 
42
#endif
 
43
 
 
44
        AS_BEGIN
 
45
 
 
46
/*
 
47
 * Definition of stack frame function arguments.
 
48
 * All functions have the same arguments (some don't have glyphwidth,
 
49
 * but that's OK, since it comes last and doesn't affect the offset
 
50
 * of the other arguments).
 
51
 */
 
52
 
 
53
#define base_arg        REGOFF(20,ESP)
 
54
#define glyphp_arg      REGOFF(24,ESP)
 
55
#define line_arg        REGOFF(28,ESP)
 
56
#define width_arg       REGOFF(32,ESP)
 
57
#define glyphwidth_arg  REGOFF(36,ESP)
 
58
 
 
59
#define BYTE_REVERSED   GLNAME(byte_reversed)
 
60
 
 
61
/* I assume %eax and %edx can be trashed. */
 
62
 
 
63
        SEG_TEXT
 
64
 
 
65
        ALIGNTEXT4
 
66
 
 
67
#ifdef FIXEDBASE
 
68
# ifdef MSBFIRST
 
69
        GLOBL GLNAME(DrawTETextScanlineWidth6PMSBFirstFixedBase)
 
70
GLNAME(DrawTETextScanlineWidth6PMSBFirstFixedBase):
 
71
# else
 
72
        GLOBL GLNAME(DrawTETextScanlineWidth6PLSBFirstFixedBase)
 
73
GLNAME(DrawTETextScanlineWidth6PLSBFirstFixedBase):
 
74
# endif
 
75
#else
 
76
# ifdef MSBFIRST
 
77
        GLOBL GLNAME(DrawTETextScanlineWidth6PMSBFirst)
 
78
GLNAME(DrawTETextScanlineWidth6PMSBFirst):
 
79
# else
 
80
        GLOBL GLNAME(DrawTETextScanlineWidth6PLSBFirst)
 
81
GLNAME(DrawTETextScanlineWidth6PLSBFirst):
 
82
# endif
 
83
#endif
 
84
 
 
85
/* Definition of stack frame function arguments. */
 
86
 
 
87
#define base_arg        REGOFF(20,ESP)
 
88
#define glyphp_arg      REGOFF(24,ESP)
 
89
#define line_arg        REGOFF(28,ESP)
 
90
#define width_arg       REGOFF(32,ESP)
 
91
 
 
92
        SUB_L   (CONST(16),ESP)
 
93
        MOV_L   (EBP,REGOFF(12,ESP))    /* PUSH EBP */
 
94
        MOV_L   (EBX,REGOFF(8,ESP))     /* PUSH EBX */
 
95
        MOV_L   (ESI,REGOFF(4,ESP))     /* PUSH ESI */
 
96
        MOV_L   (EDI,REGOFF(0,ESP))     /* PUSH EDI */
 
97
 
 
98
        MOV_L   (line_arg,EBP)
 
99
        MOV_L   (base_arg,EDI)
 
100
        MOV_L   (glyphp_arg,ESI)
 
101
 
 
102
        ALIGNTEXT4
 
103
 
 
104
.L6_1:
 
105
        /* Pentium-optimized instruction pairing. */
 
106
        /* EBX = bits = glyph[0][line] */
 
107
        MOV_L   (REGOFF(4,ESI),EDX)             /* glyphp[1] */
 
108
        MOV_L   (REGIND(ESI),EBX)               /* glyphp[0] */
 
109
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[1][line] */
 
110
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[0][line] */
 
111
        SAL_L   (CONST(6),EDX)                  /* glyphp[1][line] << 6 */
 
112
        MOV_L   (REGOFF(8,ESI),ECX)             /* glyphp[2] */
 
113
        MOV_L   (REGOFF(12,ESI),EAX)            /* glyphp[3] */
 
114
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[2][line] */
 
115
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[3][line] */
 
116
        SAL_L   (CONST(12),ECX)                 /* glyphp[2][line] << 12 */
 
117
        OR_L    (EDX,EBX)                       /* bits |= ..[1].. << 6 */
 
118
        SAL_L   (CONST(18),EAX)                 /* glyphp[3][line] << 18 */
 
119
        OR_L    (ECX,EBX)                       /* bits |= ..[2].. << 12 */
 
120
 
 
121
        MOV_L   (REGOFF(16,ESI),EDX)            /* glyphp[4] */
 
122
        MOV_L   (REGOFF(20,ESI),ECX)            /* glyphp[5] */
 
123
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[4][line] */
 
124
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[5][line] */
 
125
        SAL_L   (CONST(24),EDX)                 /* glyphp[4][line] << 24 */
 
126
        OR_L    (EAX,EBX)                       /* bits |= ..[3].. << 18 */
 
127
        SAL_L   (CONST(30),ECX)                 /* glyphp[5][line] << 30 */
 
128
        OR_L    (EDX,EBX)                       /* bits |= ..[4].. << 24 */
 
129
 
 
130
#ifndef MSBFIRST
 
131
        MOV_L   (REGOFF(20,ESI),EAX)            /* glyphp[5] */
 
132
        OR_L    (ECX,EBX)                       /* bits |= ..[5].. << 30 */
 
133
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[5][line] */
 
134
        MOV_L   (EBX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
135
#else
 
136
        MOV_L   (CONST(0),EAX)
 
137
        OR_L    (ECX,EBX)                       /* bits |= ..[5].. << 30 */
 
138
        MOV_L   (CONST(0),EDX)
 
139
        MOV_B   (BL,AL)
 
140
        MOV_B   (BH,DL)
 
141
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BL)
 
142
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),BH)
 
143
        ROL_L   (CONST(16),EBX)
 
144
        MOV_B   (BL,AL)
 
145
        MOV_B   (BH,DL)
 
146
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BL)
 
147
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),BH)
 
148
        ROL_L   (CONST(16),EBX)
 
149
        MOV_L   (REGOFF(20,ESI),EAX)            /* glyphp[5] */
 
150
        MOV_L   (EBX,REGIND(EDI))
 
151
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[5][line] */
 
152
#endif
 
153
 
 
154
        CMP_L   (CONST(32),width_arg)
 
155
        JG      (.L6_2)
 
156
#ifndef FIXEDBASE
 
157
        ADD_L   (CONST(4),EDI)          /* base++ */
 
158
#endif
 
159
        JMP     (.L6_4)
 
160
.L6_2:
 
161
        /* Note that glyphp[5][line] is already read again. */
 
162
        /* EAX = bits = glyphp[5][line] >> 2 */
 
163
        MOV_L   (REGOFF(24,ESI),EDX)            /* glyphp[6] */
 
164
        MOV_L   (REGOFF(28,ESI),EBX)            /* glyphp[7] */
 
165
        SHR_L   (CONST(2),EAX)                  /* glyphp[5][line] >> 2 */
 
166
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[6][line] */
 
167
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[7][line] */
 
168
        MOV_L   (REGOFF(32,ESI),ECX)            /* glyphp[8] */
 
169
        SAL_L   (CONST(4),EDX)                  /* glyphp[6][line] << 4 */
 
170
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[8][line] */
 
171
        SAL_L   (CONST(10),EBX)                 /* glyphp[7][line] << 10 */
 
172
        OR_L    (EDX,EAX)                       /* bits |= ..[6].. << 4 */
 
173
        SAL_L   (CONST(16),ECX)                 /* glyphp[8][line] << 16 */
 
174
        MOV_L   (REGOFF(36,ESI),EDX)            /* glyphp[9] */
 
175
        OR_L    (EBX,EAX)                       /* bits |= ..[7].. << 10 */
 
176
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[9][line] */
 
177
        OR_L    (ECX,EAX)                       /* bits |= ..[8].. << 16 */
 
178
        MOV_L   (REGOFF(40,ESI),EBX)            /* glyphp[10] */
 
179
        SAL_L   (CONST(22),EDX)                 /* glyphp[9][line] << 22 */
 
180
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[10][line] */
 
181
        OR_L    (EDX,EAX)                       /* bits |= ..[9].. << 22 */
 
182
 
 
183
#ifndef MSBFIRST
 
184
        MOV_L   (REGOFF(40,ESI),ECX)            /* glyphp[10] */
 
185
        SAL_L   (CONST(28),EBX)                 /* glyphp[10][line] << 28 */
 
186
        MOV_L   (REGOFF(44,ESI),EDX)            /* glyphp[11] */
 
187
        OR_L    (EBX,EAX)                       /* bits |= ..[10].. << 28 */
 
188
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[10][line] */
 
189
#ifndef FIXEDBASE
 
190
        MOV_L   (EAX,REGOFF(4,EDI)) /* WRITE_IN_BIT_ORDER(base, bits) */
 
191
#else
 
192
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
193
#endif
 
194
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[11][line] */
 
195
#else
 
196
        MOV_L   (CONST(0),ECX)
 
197
        SAL_L   (CONST(28),EBX)                 /* glyphp[10][line] << 28 */
 
198
        MOV_L   (CONST(0),EDX)
 
199
        OR_L    (EBX,EAX)                       /* bits |= ..[10].. << 28 */
 
200
        MOV_B   (AL,CL)
 
201
        MOV_B   (AH,DL)
 
202
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AL)
 
203
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),AH)
 
204
        ROL_L   (CONST(16),EAX)
 
205
        MOV_B   (AL,CL)
 
206
        MOV_B   (AH,DL)
 
207
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AL)
 
208
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),AH)
 
209
        MOV_L   (REGOFF(40,ESI),ECX)            /* glyphp[10] */
 
210
        ROL_L   (CONST(16),EAX)
 
211
        MOV_L   (REGOFF(44,ESI),EDX)            /* glyphp[11] */
 
212
#ifndef FIXEDBASE
 
213
        MOV_L   (EAX,REGOFF(4,EDI)) /* WRITE_IN_BIT_ORDER(base, bits) */
 
214
#else
 
215
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
216
#endif
 
217
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[10][line] */
 
218
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[11][line] */
 
219
#endif
 
220
 
 
221
        CMP_L   (CONST(64),width_arg)
 
222
        JG      (.L6_3)
 
223
#ifndef FIXEDBASE
 
224
        ADD_L   (CONST(8),EDI)          /* base+=2 */
 
225
#endif
 
226
        JMP     (.L6_4)
 
227
.L6_3:
 
228
        /* Note that glyphp[10][line] is read again. */
 
229
        /* EAX = bits = glyphp[10][line] >> 4 */
 
230
        SHR_L   (CONST(4),ECX)                  /* glyphp[10][line] >> 4 */
 
231
        MOV_L   (REGOFF(48,ESI),EBX)            /* glyphp[12] */
 
232
        SAL_L   (CONST(2),EDX)                  /* glyphp[11][line] << 2 */
 
233
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[12][line] */
 
234
        OR_L    (EDX,ECX)                       /* bits |= ..[11].. << 2 */
 
235
        MOV_L   (REGOFF(52,ESI),EAX)            /* glyphp[13] */
 
236
        SAL_L   (CONST(8),EBX)                  /* glyphp[12][line] << 8 */
 
237
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[13][line] */
 
238
        OR_L    (EBX,ECX)                       /* bits |= ..[12].. << 8 */
 
239
        MOV_L   (REGOFF(56,ESI),EDX)            /* glyphp[14] */
 
240
        SAL_L   (CONST(14),EAX)                 /* glyphp[13][line] << 14 */
 
241
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[14][line] */
 
242
        OR_L    (EAX,ECX)                       /* bits |= ..[13].. << 14 */
 
243
        MOV_L   (REGOFF(60,ESI),EBX)            /* glyphp[15] */
 
244
        SAL_L   (CONST(20),EDX)                 /* glyphp[14][line] << 20 */
 
245
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[15][line] */
 
246
        OR_L    (EDX,ECX)                       /* bits |= ..[14].. << 20 */
 
247
 
 
248
#ifndef MSBFIRST
 
249
        SAL_L   (CONST(26),EBX)                 /* glyphp[15][line] << 26 */
 
250
        OR_L    (EBX,ECX)                       /* bits |= ..[15].. << 26 */
 
251
#ifndef FIXEDBASE
 
252
        MOV_L   (ECX,REGOFF(8,EDI)) /* WRITE_IN_BIT_ORDER(base, bits) */
 
253
#else
 
254
        MOV_L   (ECX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
255
#endif
 
256
#else
 
257
        MOV_L   (CONST(0),EAX)
 
258
        SAL_L   (CONST(26),EBX)                 /* glyphp[15][line] << 26 */
 
259
        MOV_L   (CONST(0),EDX)
 
260
        OR_L    (EBX,ECX)                       /* bits |= ..[15].. << 26 */
 
261
        MOV_B   (CL,AL)
 
262
        MOV_B   (CH,DL)
 
263
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),CL)
 
264
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),CH)
 
265
        ROL_L   (CONST(16),ECX)
 
266
        MOV_B   (CL,AL)
 
267
        MOV_B   (CH,DL)
 
268
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),CL)
 
269
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),CH)
 
270
        ROL_L   (CONST(16),ECX)
 
271
#ifndef FIXEDBASE
 
272
        MOV_L   (ECX,REGOFF(8,EDI)) /* WRITE_IN_BIT_ORDER(base, bits) */
 
273
#else
 
274
        MOV_L   (ECX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
275
#endif
 
276
#endif
 
277
 
 
278
#ifndef FIXEDBASE
 
279
        ADD_L   (CONST(12),EDI)         /* base += 3*/
 
280
#endif
 
281
        CMP_L   (CONST(96),width_arg)
 
282
        JLE     (.L6_4)
 
283
        ADD_L   (CONST(64),ESI)         /* glyphp += 16 */
 
284
        SUB_L   (CONST(96),width_arg)
 
285
        JMP     (.L6_1)
 
286
 
 
287
.L6_4:
 
288
 
 
289
#ifndef FIXEDBASE
 
290
        MOV_L   (EDI,EAX)               /* return base */
 
291
#else
 
292
        MOV_L   (base_arg,EAX)          /* return base */
 
293
#endif
 
294
        MOV_L   (REGOFF(0,ESP),EDI)     /* POPL EDI */
 
295
        MOV_L   (REGOFF(4,ESP),ESI)     /* POPL ESI */
 
296
        MOV_L   (REGOFF(8,ESP),EBX)     /* POPL EBX */
 
297
        MOV_L   (REGOFF(12,ESP),EBP)    /* POPL EBP */
 
298
        ADD_L   (CONST(16),ESP)
 
299
        RET
 
300
        
 
301
 
 
302
        ALIGNTEXT4
 
303
 
 
304
#ifdef FIXEDBASE
 
305
# ifdef MSBFIRST
 
306
        GLOBL GLNAME(DrawTETextScanlineWidth8PMSBFirstFixedBase)
 
307
GLNAME(DrawTETextScanlineWidth8PMSBFirstFixedBase):
 
308
# else
 
309
        GLOBL GLNAME(DrawTETextScanlineWidth8PLSBFirstFixedBase)
 
310
GLNAME(DrawTETextScanlineWidth8PLSBFirstFixedBase):
 
311
# endif
 
312
#else
 
313
# ifdef MSBFIRST
 
314
        GLOBL GLNAME(DrawTETextScanlineWidth8PMSBFirst)
 
315
GLNAME(DrawTETextScanlineWidth8PMSBFirst):
 
316
# else
 
317
        GLOBL GLNAME(DrawTETextScanlineWidth8PLSBFirst)
 
318
GLNAME(DrawTETextScanlineWidth8PLSBFirst):
 
319
# endif
 
320
#endif
 
321
 
 
322
        SUB_L   (CONST(16),ESP)
 
323
        MOV_L   (EBP,REGOFF(12,ESP))    /* PUSH EBP */
 
324
        MOV_L   (EBX,REGOFF(8,ESP))     /* PUSH EBX */
 
325
        MOV_L   (ESI,REGOFF(4,ESP))     /* PUSH ESI */
 
326
        MOV_L   (EDI,REGOFF(0,ESP))     /* PUSH EDI */
 
327
 
 
328
        MOV_L   (line_arg,EBP)
 
329
        MOV_L   (base_arg,EDI)
 
330
        MOV_L   (glyphp_arg,ESI)
 
331
 
 
332
        ALIGNTEXT4
 
333
 
 
334
.L8_1:
 
335
        /* Pentium-optimized instruction pairing. */
 
336
        /* EBX = bits */
 
337
        MOV_L   (REGIND(ESI),EAX)               /* glyphp[0] */
 
338
        MOV_L   (REGOFF(4,ESI),EDX)             /* glyphp[1] */
 
339
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[0][line] */
 
340
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[1][line] */
 
341
#ifdef MSBFIRST
 
342
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BL)
 
343
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),BH)
 
344
#else
 
345
        MOV_L   (EAX,EBX)                       /* bits = glyph[0][line] */
 
346
        MOV_B   (DL,BH)                         /* bits |= ..[1].. << 8 */
 
347
#endif
 
348
 
 
349
        ROL_L   (CONST(16),EBX)
 
350
        MOV_L   (REGOFF(8,ESI),EAX)             /* glyphp[2] */
 
351
        MOV_L   (REGOFF(12,ESI),ECX)            /* glyphp[3] */
 
352
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[2][line] */
 
353
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[3][line] */
 
354
#ifdef MSBFIRST
 
355
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BL)
 
356
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),BH)
 
357
#else
 
358
        MOV_B   (AL,BL)                         /* bits |= ..[2].. << 16 */
 
359
        MOV_B   (CL,BH)                         /* bits |= ..[3].. << 24 */
 
360
#endif
 
361
        ROL_L   (CONST(16),EBX)
 
362
        MOV_L   (EBX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
363
        CMP_L   (CONST(32),width_arg)
 
364
#ifndef FIXEDBASE
 
365
        JLE     (.L8_2)
 
366
#else
 
367
        JLE     (.L8_3)
 
368
#endif
 
369
 
 
370
        MOV_L   (REGOFF(16,ESI),EAX)            /* glyphp[4] */
 
371
        MOV_L   (REGOFF(20,ESI),EDX)            /* glyphp[5] */
 
372
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[4][line] */
 
373
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[5][line] */
 
374
#ifdef MSBFIRST
 
375
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BL)
 
376
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),BH)
 
377
#else
 
378
        MOV_L    (EAX,EBX)                      /* bits = glyph[4][line] */
 
379
        MOV_B    (DL,BH)                        /* nits |= ..[5].. << 8 */
 
380
#endif
 
381
 
 
382
        ROL_L   (CONST(16),EBX)
 
383
        MOV_L   (REGOFF(24,ESI),EAX)            /* glyphp[6] */
 
384
        MOV_L   (REGOFF(28,ESI),ECX)            /* glyphp[7] */
 
385
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[6][line] */
 
386
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[7][line] */
 
387
#ifdef MSBFIRST
 
388
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BL)
 
389
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),BH)
 
390
#else
 
391
        MOV_B   (AL,BL)                         /* bits |= ..[6].. << 16 */
 
392
        MOV_B   (CL,BH)                         /* bits |= ..[7].. << 24 */
 
393
#endif
 
394
        ROL_L   (CONST(16),EBX)
 
395
#ifndef FIXEDBASE
 
396
        MOV_L   (EAX,REGOFF(4,EDI))     /* WRITE_IN_BIT_ORDER(base+1, bits) */
 
397
        ADD_L   (CONST(8),EDI)          /* base += 2 */
 
398
#else
 
399
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
400
#endif
 
401
        CMP_L   (CONST(64),width_arg)
 
402
        JLE     (.L8_3)
 
403
        ADD_L   (CONST(32),ESI)         /* glyphp += 8 */
 
404
        SUB_L   (CONST(64),width_arg)
 
405
        JMP     (.L8_1)
 
406
 
 
407
#ifndef FIXEDBASE
 
408
.L8_2:
 
409
        ADD_L   (CONST(4),EDI)          /* base++ */
 
410
.L8_3:
 
411
        MOV_L   (EDI,EAX)               /* return base */
 
412
#else
 
413
.L8_3:
 
414
        MOV_L   (base_arg,EAX)          /* return base */
 
415
#endif
 
416
        MOV_L   (REGOFF(0,ESP),EDI)     /* POPL EDI */
 
417
        MOV_L   (REGOFF(4,ESP),ESI)     /* POPL ESI */
 
418
        MOV_L   (REGOFF(8,ESP),EBX)     /* POPL EBX */
 
419
        MOV_L   (REGOFF(12,ESP),EBP)    /* POPL EBP */
 
420
        ADD_L   (CONST(16),ESP)
 
421
        RET
 
422
 
 
423
        ALIGNTEXT4
 
424
 
 
425
#ifdef FIXEDBASE
 
426
# ifdef MSBFIRST
 
427
        GLOBL GLNAME(DrawTETextScanlineWidth9PMSBFirstFixedBase)
 
428
GLNAME(DrawTETextScanlineWidth9PMSBFirstFixedBase):
 
429
# else
 
430
        GLOBL GLNAME(DrawTETextScanlineWidth9PLSBFirstFixedBase)
 
431
GLNAME(DrawTETextScanlineWidth9PLSBFirstFixedBase):
 
432
# endif
 
433
#else
 
434
# ifdef MSBFIRST
 
435
        GLOBL GLNAME(DrawTETextScanlineWidth9PMSBFirst)
 
436
GLNAME(DrawTETextScanlineWidth9PMSBFirst):
 
437
# else
 
438
        GLOBL GLNAME(DrawTETextScanlineWidth9PLSBFirst)
 
439
GLNAME(DrawTETextScanlineWidth9PLSBFirst):
 
440
# endif
 
441
#endif
 
442
 
 
443
        SUB_L   (CONST(16),ESP)
 
444
        MOV_L   (EBP,REGOFF(12,ESP))    /* PUSH EBP */
 
445
        MOV_L   (EBX,REGOFF(8,ESP))     /* PUSH EBX */
 
446
        MOV_L   (ESI,REGOFF(4,ESP))     /* PUSH ESI */
 
447
        MOV_L   (EDI,REGOFF(0,ESP))     /* PUSH EDI */
 
448
 
 
449
        MOV_L   (line_arg,EBP)
 
450
        MOV_L   (base_arg,EDI)
 
451
        MOV_L   (glyphp_arg,ESI)
 
452
 
 
453
        ALIGNTEXT4
 
454
 
 
455
.L9_1:
 
456
        /* Pentium-optimized instruction pairing. */
 
457
        /* EAX = bits */
 
458
        MOV_L   (REGOFF(4,ESI),EBX)             /* glyphp[1] */
 
459
        MOV_L   (REGIND(ESI),EAX)               /* glyphp[0] */
 
460
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[1][line] */
 
461
        MOV_L   (REGOFF(8,ESI),ECX)             /* glyphp[2] */
 
462
        SAL_L   (CONST(9),EBX)                  /* glyphp[1][line] << 9 */
 
463
        MOV_L   (REGOFF(12,ESI),EDX)            /* glyphp[3] */
 
464
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[0][line] */
 
465
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[3][line] */
 
466
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[2][line] */
 
467
        OR_L    (EBX,EAX)                       /* bits |= ..[1].. << 9 */
 
468
        SAL_L   (CONST(18),ECX)                 /* glyphp[2][line] << 18 */
 
469
        OR_L    (ECX,EAX)                       /* bits |= ..[2].. << 18 */
 
470
        SAL_L   (CONST(27),EDX)                 /* glyphp[3][line << 27 */
 
471
                        
 
472
#ifndef MSBFIRST
 
473
        MOV_L   (REGOFF(12,ESI),EBX)            /* glyphp[3] */
 
474
        OR_L    (EDX,EAX)                       /* bits |= ..[3].. << 27 */
 
475
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[3][line] */
 
476
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
477
#else
 
478
        MOV_L   (CONST(0),EBX)
 
479
        OR_L    (EDX,EAX)                       /* bits |= ..[3].. << 27 */
 
480
        MOV_L   (CONST(0),ECX)
 
481
        MOV_B   (AL,BL)
 
482
        MOV_B   (AH,CL)
 
483
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),AL)
 
484
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AH)
 
485
        ROL_L   (CONST(16),EAX)
 
486
        MOV_B   (AL,BL)
 
487
        MOV_B   (AH,CL)
 
488
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),AL)
 
489
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AH)
 
490
        MOV_L   (REGOFF(12,ESI),EBX)            /* glyphp[3] */
 
491
        ROL_L   (CONST(16),EAX)
 
492
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[3][line] */
 
493
        MOV_L   (EAX,REGIND(EDI))
 
494
#endif
 
495
 
 
496
        CMP_L   (CONST(32),width_arg)
 
497
        JG      (.L9_2)
 
498
#ifndef FIXEDBASE
 
499
        ADD_L   (CONST(4),EDI)          /* base++ */
 
500
#endif
 
501
        JMP     (.L9_11)
 
502
.L9_2:
 
503
        /* Note that glyphp[3][line] is read again. */
 
504
        /* EAX = bits, EBX = glyphp[3][line] >> 5 */
 
505
        SHR_L   (CONST(5),EBX)                  /* glyphp[3][line] >> 5 */
 
506
        MOV_L   (REGOFF(16,ESI),EAX)            /* glyphp[4] */
 
507
        MOV_L   (REGOFF(20,ESI),ECX)            /* glyphp[5] */
 
508
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[4][line] */
 
509
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[5][line] */
 
510
        MOV_L   (REGOFF(24,ESI),EDX)            /* glyphp[6] */
 
511
        SAL_L   (CONST(4),EAX)                  /* glyphp[4][line] << 4 */
 
512
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[6][line] */
 
513
        SAL_L   (CONST(13),ECX)                 /* glyphp[5][line] << 13 */
 
514
        OR_L    (EBX,EAX)                       /* bits |= ..[4].. << 4 */
 
515
        SAL_L   (CONST(22),EDX)                 /* glyphp[6][line] << 22 */
 
516
        MOV_L   (REGOFF(28,ESI),EBX)            /* glyphp[7] */
 
517
        OR_L    (ECX,EAX)                       /* bits |= ..[5].. << 13 */
 
518
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[7][line] */
 
519
        OR_L    (EDX,EAX)                       /* bits |= ..[6].. << 22 */
 
520
 
 
521
#ifndef MSBFIRST
 
522
        MOV_L   (REGOFF(28,ESI),ECX)            /* glyphp[7] */
 
523
        SAL_L   (CONST(31),EBX)                 /* glyphp[7][line] << 31 */
 
524
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[7][line] */
 
525
        OR_L    (EBX,EAX)                       /* bits |= ..[7].. << 31 */
 
526
        MOV_L   (REGOFF(32,ESI),EDX)            /* glyphp[8] */
 
527
#ifndef FIXEDBASE
 
528
        MOV_L   (EAX,REGOFF(4,EDI))     /* WRITE_IN_BIT_ORDER(base, bits) */
 
529
#else
 
530
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
531
#endif
 
532
#else
 
533
        MOV_L   (CONST(0),ECX)
 
534
        SAL_L   (CONST(31),EBX)                 /* glyphp[7][line] << 31 */
 
535
        MOV_L   (CONST(0),EDX)
 
536
        OR_L    (EBX,EAX)                       /* bits |= ..[7].. << 31 */
 
537
        MOV_B   (AL,CL)
 
538
        MOV_B   (AH,DL)
 
539
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AL)
 
540
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),AH)
 
541
        ROL_L   (CONST(16),EAX)
 
542
        MOV_B   (AL,CL)
 
543
        MOV_B   (AH,DL)
 
544
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AL)
 
545
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),AH)
 
546
        MOV_L   (REGOFF(28,ESI),ECX)            /* glyphp[7] */
 
547
        ROL_L   (CONST(16),EAX)
 
548
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[7][line] */
 
549
#ifndef FIXEDBASE
 
550
        MOV_L   (EAX,REGOFF(4,EDI))     /* WRITE_IN_BIT_ORDER(base, bits) */
 
551
#else
 
552
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
553
#endif
 
554
        MOV_L   (REGOFF(32,ESI),EDX)            /* glyphp[8] */
 
555
#endif
 
556
 
 
557
        CMP_L   (CONST(64),width_arg)
 
558
        JG      (.L9_3)
 
559
#ifndef FIXEDBASE
 
560
        ADD_L   (CONST(8),EDI)          /* base+=2 */
 
561
#endif
 
562
        JMP     (.L9_11)
 
563
.L9_3:
 
564
 
 
565
        /* Note that glyphp[7][line] is read again. */
 
566
        /* ECX = bits = glyphp[7][line] >> 1 */
 
567
        SHR_L   (CONST(1),ECX)                  /* glyphp[7][line] >> 1 */
 
568
        MOV_L   (REGOFF(36,ESI),EBX)            /* glyphp[9] */
 
569
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[8][line] */
 
570
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[9][line] */
 
571
        SAL_L   (CONST(8),EDX)                  /* glyphp[8][line] << 8 */
 
572
        MOV_L   (REGOFF(40,ESI),EAX)            /* glyphp[10] */
 
573
        SAL_L   (CONST(17),EBX)                 /* glyphp[9][line] << 17 */
 
574
        OR_L    (EDX,ECX)                       /* bits |= ..[8].. << 8 */
 
575
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[10][line] */
 
576
        OR_L    (EBX,ECX)                       /* bits |= ..[9].. << 17 */
 
577
        SAL_L   (CONST(26),EAX)                 /* glyphp[10][line] << 26 */
 
578
 
 
579
#ifndef MSBFIRST
 
580
        MOV_L   (REGOFF(40,ESI),EDX)            /* glyphp[10] */
 
581
        OR_L    (EAX,ECX)                       /* bits |= ..[10].. << 26 */
 
582
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[10][line] */
 
583
#ifndef FIXEDBASE
 
584
        MOV_L   (ECX,REGOFF(8,EDI))     /* WRITE_IN_BIT_ORDER(base, bits) */
 
585
#else
 
586
        MOV_L   (ECX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
587
#endif
 
588
#else
 
589
        MOV_L   (CONST(0),EDX)
 
590
        OR_L    (EAX,ECX)                       /* bits |= ..[10].. << 26 */
 
591
        MOV_L   (CONST(0),EBX)
 
592
        MOV_B   (CL,DL)
 
593
        MOV_B   (CH,BL)
 
594
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),CL)
 
595
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),CH)
 
596
        ROL_L   (CONST(16),ECX)
 
597
        MOV_B   (CL,DL)
 
598
        MOV_B   (CH,BL)
 
599
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),CL)
 
600
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),CH)
 
601
        MOV_L   (REGOFF(40,ESI),EDX)            /* glyphp[10] */
 
602
        ROL_L   (CONST(16),ECX)
 
603
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[10][line] */
 
604
#ifndef FIXEDBASE
 
605
        MOV_L   (ECX,REGOFF(8,EDI))     /* WRITE_IN_BIT_ORDER(base, bits) */
 
606
#else
 
607
        MOV_L   (ECX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
608
#endif
 
609
#endif
 
610
 
 
611
        CMP_L   (CONST(96),width_arg)
 
612
        JG      (.L9_4)
 
613
#ifndef FIXEDBASE
 
614
        ADD_L   (CONST(12),EDI)         /* base+=3 */
 
615
#endif
 
616
        JMP     (.L9_11)
 
617
.L9_4:
 
618
        /* Note that glyphp[10][line] is read again. */
 
619
        /* EDX = bits = glyphp[10][line] >> 6 */
 
620
        SHR_L   (CONST(6),EDX)                  /* glyphp[10][line] >> 6 */
 
621
        MOV_L   (REGOFF(44,ESI),EBX)            /* glyphp[11] */
 
622
        MOV_L   (REGOFF(48,ESI),EAX)            /* glyphp[12] */
 
623
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[11][line] */
 
624
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[12][line] */
 
625
        MOV_L   (REGOFF(52,ESI),ECX)            /* glyphp[13] */
 
626
        SAL_L   (CONST(3),EBX)                  /* glyphp[11][line] << 3 */
 
627
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[13][line] */
 
628
        SAL_L   (CONST(12),EAX)                 /* glyphp[12][line] << 12 */
 
629
        OR_L    (EBX,EDX)                       /* bits |= ..[11].. << 3 */
 
630
        SAL_L   (CONST(21),ECX)                 /* glyphp[13][line] << 21 */
 
631
        MOV_L   (REGOFF(56,ESI),EBX)            /* glyphp[14] */
 
632
        OR_L    (EAX,EDX)                       /* bits |= ..[12].. << 17 */
 
633
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[14][line] */
 
634
        SAL_L   (CONST(30),EBX)                 /* glyphp[14][line] << 30 */
 
635
        OR_L    (ECX,EDX)                       /* bits |= ..[13].. << 21 */
 
636
 
 
637
#ifndef MSBFIRST
 
638
        MOV_L   (REGOFF(56,ESI),EAX)            /* glyphp[14] */
 
639
        OR_L    (EBX,EDX)                       /* bits |= ..[14].. << 30 */
 
640
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[14][line] */
 
641
#ifndef FIXEDBASE
 
642
        MOV_L   (EDX,REGOFF(12,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
643
#else
 
644
        MOV_L   (EDX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
645
#endif
 
646
#else
 
647
        MOV_L   (CONST(0),EAX)
 
648
        OR_L    (EBX,EDX)                       /* bits |= ..[14].. << 30 */
 
649
        MOV_L   (CONST(0),ECX)
 
650
        MOV_B   (DL,AL)
 
651
        MOV_B   (DH,CL)
 
652
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),DL)
 
653
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),DH)
 
654
        ROL_L   (CONST(16),EDX)
 
655
        MOV_B   (DL,AL)
 
656
        MOV_B   (DH,CL)
 
657
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),DL)
 
658
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),DH)
 
659
        MOV_L   (REGOFF(56,ESI),EAX)            /* glyphp[14] */
 
660
        ROL_L   (CONST(16),EDX)
 
661
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[14][line] */
 
662
#ifndef FIXEDBASE
 
663
        MOV_L   (EDX,REGOFF(12,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
664
#else
 
665
        MOV_L   (EDX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
666
#endif
 
667
#endif
 
668
 
 
669
        CMP_L   (CONST(128),width_arg)
 
670
        JG      (.L9_5)
 
671
#ifndef FIXEDBASE
 
672
        ADD_L   (CONST(16),EDI)         /* base+=4 */
 
673
#endif
 
674
        JMP     (.L9_11)
 
675
.L9_5:  
 
676
        /* Note that glyphp[14][line] is read again. */
 
677
        /* EAX = bits = glyphp[14][line] >> 2 */
 
678
        SHR_L   (CONST(2),EAX)                  /* glyphp[14][line] >> 2 */
 
679
        MOV_L   (REGOFF(60,ESI),ECX)            /* glyphp[15] */
 
680
        MOV_L   (REGOFF(64,ESI),EBX)            /* glyphp[16] */
 
681
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[15][line] */
 
682
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[16][line] */
 
683
        MOV_L   (REGOFF(68,ESI),EDX)            /* glyphp[17] */
 
684
        SAL_L   (CONST(7),ECX)                  /* glyphp[15][line] << 7 */
 
685
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[17][line] */
 
686
        SAL_L   (CONST(16),EBX)                 /* glyphp[16][line] << 16 */
 
687
        OR_L    (ECX,EAX)                       /* bits |= ..[15].. << 7 */
 
688
        SAL_L   (CONST(25),EDX)                 /* glyphp[17][line] << 25 */
 
689
        OR_L    (EBX,EAX)                       /* bits |= ..[16].. << 16 */
 
690
        
 
691
#ifndef MSBFIRST
 
692
        MOV_L   (REGOFF(68,ESI),ECX)            /* glyphp[17] */
 
693
        OR_L    (EDX,EAX)                       /* bits |= ..[17].. << 25 */
 
694
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[17][line] */
 
695
#ifndef FIXEDBASE
 
696
        MOV_L   (EAX,REGOFF(16,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
697
#else
 
698
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
699
#endif
 
700
#else
 
701
        MOV_L   (CONST(0),ECX)
 
702
        OR_L    (EDX,EAX)                       /* bits |= ..[17].. << 25 */
 
703
        MOV_L   (CONST(0),EBX)
 
704
        MOV_B   (AL,CL)
 
705
        MOV_B   (AH,BL)
 
706
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AL)
 
707
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),AH)
 
708
        ROL_L   (CONST(16),EAX)
 
709
        MOV_B   (AL,CL)
 
710
        MOV_B   (AH,BL)
 
711
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),AL)
 
712
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),AH)
 
713
        MOV_L   (REGOFF(68,ESI),ECX)            /* glyphp[17] */
 
714
        ROL_L   (CONST(16),EAX)
 
715
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[17][line] */
 
716
#ifndef FIXEDBASE
 
717
        MOV_L   (EAX,REGOFF(16,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
718
#else
 
719
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
720
#endif
 
721
#endif
 
722
 
 
723
        CMP_L   (CONST(160),width_arg)
 
724
        JG      (.L9_6)
 
725
#ifndef FIXEDBASE
 
726
        ADD_L   (CONST(20),EDI)         /* base+=5 */
 
727
#endif
 
728
        JMP     (.L9_11)
 
729
.L9_6:  
 
730
        /* Note that glyphp[17][line] is read again. */
 
731
        /* ECX = bits = glyphp[17][line] >> 7 */
 
732
        SHR_L   (CONST(7),ECX)                  /* glyphp[17][line] >> 7 */
 
733
        MOV_L   (REGOFF(72,ESI),EBX)            /* glyphp[18] */
 
734
        MOV_L   (REGOFF(76,ESI),EAX)            /* glyphp[19] */
 
735
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[18][line] */
 
736
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[19][line] */
 
737
        MOV_L   (REGOFF(80,ESI),EDX)            /* glyphp[20] */
 
738
        SAL_L   (CONST(2),EBX)                  /* glyphp[18][line] << 2 */
 
739
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[20][line] */
 
740
        SAL_L   (CONST(11),EAX)                 /* glyphp[19][line] << 11 */
 
741
        OR_L    (EBX,ECX)                       /* bits |= ..[18].. << 2 */
 
742
        SAL_L   (CONST(20),EDX)                 /* glyphp[20][line] << 20 */
 
743
        MOV_L   (REGOFF(84,ESI),EBX)            /* glyphp[21] */
 
744
        OR_L    (EAX,ECX)                       /* bits |= ..[19].. << 11 */
 
745
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[21][line] */
 
746
        OR_L    (EDX,ECX)                       /* bits |= ..[20].. << 20 */
 
747
        
 
748
#ifndef MSBFIRST
 
749
        MOV_L   (REGOFF(84,ESI),EAX)            /* glyphp[21] */
 
750
        SAL_L   (CONST(29),EBX)                 /* glyphp[21][line] << 29 */
 
751
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[21][line] */
 
752
        OR_L    (EBX,ECX)                       /* bits |= ..[14].. << 30 */
 
753
        MOV_L   (REGOFF(88,ESI),EDX)            /* glyphp[22] */
 
754
#ifndef FIXEDBASE
 
755
        MOV_L   (ECX,REGOFF(20,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
756
#else
 
757
        MOV_L   (ECX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
758
#endif
 
759
#else
 
760
        MOV_L   (CONST(0),EAX)
 
761
        SAL_L   (CONST(29),EBX)                 /* glyphp[21][line] << 29 */
 
762
        MOV_L   (CONST(0),EDX)
 
763
        OR_L    (EBX,ECX)                       /* bits |= ..[14].. << 30 */
 
764
        MOV_B   (CL,AL)
 
765
        MOV_B   (CH,DL)
 
766
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),CL)
 
767
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),CH)
 
768
        ROL_L   (CONST(16),ECX)
 
769
        MOV_B   (CL,AL)
 
770
        MOV_B   (CH,DL)
 
771
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),CL)
 
772
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),CH)
 
773
        MOV_L   (REGOFF(84,ESI),EAX)            /* glyphp[21] */
 
774
        ROL_L   (CONST(16),ECX)
 
775
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[21][line] */
 
776
#ifndef FIXEDBASE
 
777
        MOV_L   (ECX,REGOFF(20,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
778
#else
 
779
        MOV_L   (ECX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
780
#endif
 
781
        MOV_L   (REGOFF(88,ESI),EDX)            /* glyphp[22] */
 
782
#endif
 
783
 
 
784
        CMP_L   (CONST(192),width_arg)
 
785
        JG      (.L9_7)
 
786
#ifndef FIXEDBASE
 
787
        ADD_L   (CONST(24),EDI)         /* base+=6 */
 
788
#endif
 
789
        JMP     (.L9_11)
 
790
.L9_7:
 
791
        /* Note that glyphp[21][line] is read again. */
 
792
        /* EAX = bits = glyphp[21][line] >> 3 */
 
793
        SHR_L   (CONST(3),EAX)                  /* glyphp[21][line] >> 3 */
 
794
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[22][line] */
 
795
        MOV_L   (REGOFF(92,ESI),EBX)            /* glyphp[23] */
 
796
        MOV_L   (REGOFF(96,ESI),ECX)            /* glyphp[24] */
 
797
        SAL_L   (CONST(6),EDX)                  /* glyphp[22][line] << 6 */
 
798
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[23][line] */
 
799
        OR_L    (EDX,EAX)                       /* bits |= ..[22].. << 6 */
 
800
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[24][line] */
 
801
        SAL_L   (CONST(15),EBX)                 /* glyphp[23][line] << 15 */
 
802
        OR_L    (EBX,EAX)                       /* bits |= ..[23].. << 15 */
 
803
        SAL_L   (CONST(24),ECX)                 /* glyphp[24][line] << 24 */
 
804
 
 
805
#ifndef MSBFIRST
 
806
        MOV_L   (REGOFF(96,ESI),EDX)            /* glyphp[24] */
 
807
        OR_L    (ECX,EAX)                       /* bits |= ..[24].. << 24 */
 
808
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[24][line] */
 
809
#ifndef FIXEDBASE
 
810
        MOV_L   (EAX,REGOFF(24,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
811
#else
 
812
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
813
#endif
 
814
#else
 
815
        MOV_L   (CONST(0),EDX)
 
816
        OR_L    (ECX,EAX)                       /* bits |= ..[24].. << 24 */
 
817
        MOV_L   (CONST(0),EBX)
 
818
        MOV_B   (AL,DL)
 
819
        MOV_B   (AH,BL)
 
820
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),AL)
 
821
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),AH)
 
822
        ROL_L   (CONST(16),EAX)
 
823
        MOV_B   (AL,DL)
 
824
        MOV_B   (AH,BL)
 
825
        MOV_B   (REGOFF(BYTE_REVERSED,EDX),AL)
 
826
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),AH)
 
827
        MOV_L   (REGOFF(96,ESI),EDX)            /* glyphp[24] */
 
828
        ROL_L   (CONST(16),EAX)
 
829
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[24][line] */
 
830
#ifndef FIXEDBASE
 
831
        MOV_L   (EAX,REGOFF(24,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
832
#else
 
833
        MOV_L   (EAX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
834
#endif
 
835
#endif
 
836
 
 
837
        CMP_L   (CONST(224),width_arg)
 
838
        JG      (.L9_8)
 
839
#ifndef FIXEDBASE
 
840
        ADD_L   (CONST(28),EDI)         /* base+=7 */
 
841
#endif
 
842
        JMP     (.L9_11)
 
843
.L9_8:
 
844
        /* Note that glyphp[24][line] is read again. */
 
845
        /* EDX = bits = glyphp[24][line] >> 8 */
 
846
 
 
847
        SHR_L   (CONST(8),EDX)                  /* glyphp[24][line] >> 8 */
 
848
        MOV_L   (REGOFF(100,ESI),EAX)           /* glyphp[25] */
 
849
        MOV_L   (REGOFF(104,ESI),EBX)           /* glyphp[26] */
 
850
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[25][line] */
 
851
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[26][line] */
 
852
        MOV_L   (REGOFF(108,ESI),ECX)           /* glyphp[27] */
 
853
        SAL_L   (CONST(1),EAX)                  /* glyphp[25][line] << 1 */
 
854
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[27][line] */
 
855
        SAL_L   (CONST(10),EBX)                 /* glyphp[26][line] << 10 */
 
856
        OR_L    (EAX,EDX)                       /* bits |= ..[25].. << 1 */
 
857
        SAL_L   (CONST(19),ECX)                 /* glyphp[27][line] << 19 */
 
858
        OR_L    (EBX,EDX)                       /* bits |= ..[26].. << 10 */
 
859
        MOV_L   (REGOFF(112,ESI),EAX)           /* glyphp[28] */
 
860
        OR_L    (ECX,EDX)                       /* bits |= ..[27].. << 19 */
 
861
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[28][line] */
 
862
 
 
863
#ifndef MSBFIRST
 
864
        MOV_L   (REGOFF(112,ESI),EBX)           /* glyphp[28] */
 
865
        SAL_L   (CONST(28),EAX)                 /* glyphp[28][line] << 28 */
 
866
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[28][line] */
 
867
        OR_L    (EAX,EDX)                       /* bits |= ..[28].. << 28 */
 
868
        MOV_L   (REGOFF(116,ESI),ECX)           /* glyphp[29] */
 
869
#ifndef FIXEDBASE
 
870
        MOV_L   (EDX,REGOFF(28,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
871
#else
 
872
        MOV_L   (EDX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
873
#endif
 
874
#else
 
875
        MOV_L   (CONST(0),EBX)
 
876
        SAL_L   (CONST(28),EAX)                 /* glyphp[28][line] << 28 */
 
877
        MOV_L   (CONST(0),ECX)
 
878
        OR_L    (EAX,EDX)                       /* bits |= ..[28].. << 28 */
 
879
        MOV_B   (DL,BL)
 
880
        MOV_B   (DH,CL)
 
881
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),DL)
 
882
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),DH)
 
883
        ROL_L   (CONST(16),EDX)
 
884
        MOV_B   (DL,BL)
 
885
        MOV_B   (DH,CL)
 
886
        MOV_B   (REGOFF(BYTE_REVERSED,EBX),DL)
 
887
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),DH)
 
888
        MOV_L   (REGOFF(112,ESI),EBX)           /* glyphp[28] */
 
889
        ROL_L   (CONST(16),EDX)
 
890
        MOV_L   (REGOFF(116,ESI),ECX)           /* glyphp[29] */
 
891
#ifndef FIXEDBASE
 
892
        MOV_L   (EDX,REGOFF(28,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
893
#else
 
894
        MOV_L   (EDX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
895
#endif
 
896
        MOV_L   (REGBISD(EBX,EBP,4,0),EBX)      /* glyphp[28][line] */
 
897
#endif
 
898
        
 
899
        CMP_L   (CONST(256),width_arg)
 
900
        JG      (.L9_9)
 
901
#ifndef FIXEDBASE
 
902
        ADD_L   (CONST(32),EDI)         /* base+=8 */
 
903
#endif
 
904
        JMP     (.L9_11)
 
905
.L9_9:
 
906
        /* Note that glyphp[28][line] is read again. */
 
907
        /* EBX = bits = glyphp[28][line] >> 4 */
 
908
        SHR_L   (CONST(4),EBX)                  /* glyphp[28][line] >> 4 */
 
909
        MOV_L   (REGBISD(ECX,EBP,4,0),ECX)      /* glyphp[29][line] */
 
910
        MOV_L   (REGOFF(120,ESI),EAX)           /* glyphp[30] */
 
911
        MOV_L   (REGOFF(124,ESI),EDX)           /* glyphp[31] */
 
912
        SAL_L   (CONST(5),ECX)                  /* glyphp[29][line] << 5 */
 
913
        MOV_L   (REGBISD(EAX,EBP,4,0),EAX)      /* glyphp[30][line] */
 
914
        OR_L    (ECX,EBX)                       /* bits |= ..[29].. << 5 */
 
915
        MOV_L   (REGBISD(EDX,EBP,4,0),EDX)      /* glyphp[31][line] */
 
916
        SAL_L   (CONST(14),EAX)                 /* glyphp[30][line] << 14 */
 
917
        ADD_L   (CONST(128),ESI)                /* glyphp+=32 */
 
918
        SAL_L   (CONST(23),EDX)                 /* glyphp[31][line] << 23 */
 
919
        OR_L    (EAX,EBX)                       /* bits |= ..[30].. << 14 */
 
920
        SUB_L   (CONST(288),width_arg)          /* width-=288 */
 
921
        OR_L    (EDX,EBX)                       /* bits |= ..[31].. << 23 */
 
922
 
 
923
#ifndef MSBFIRST
 
924
#ifndef FIXEDBASE
 
925
        MOV_L   (EBX,REGOFF(32,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
926
#else
 
927
        MOV_L   (EBX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
928
#endif
 
929
#else
 
930
        MOV_L   (CONST(0),ECX)
 
931
        MOV_L   (CONST(0),EAX)
 
932
        MOV_B   (BL,CL)
 
933
        MOV_B   (BH,AL)
 
934
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),BL)
 
935
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BH)
 
936
        ROL_L   (CONST(16),EBX)
 
937
        MOV_B   (BL,CL)
 
938
        MOV_B   (BH,AL)
 
939
        MOV_B   (REGOFF(BYTE_REVERSED,ECX),BL)
 
940
        MOV_B   (REGOFF(BYTE_REVERSED,EAX),BH)
 
941
        ROL_L   (CONST(16),EBX)
 
942
#ifndef FIXEDBASE
 
943
        MOV_L   (EBX,REGOFF(32,EDI))    /* WRITE_IN_BIT_ORDER(base, bits) */
 
944
#else
 
945
        MOV_L   (EBX,REGIND(EDI))       /* WRITE_IN_BIT_ORDER(base, bits) */
 
946
#endif
 
947
#endif
 
948
        
 
949
        ADD_L   (CONST(36),EDI)         /* base+=9 */
 
950
        CMP_L   (CONST(0),width_arg)
 
951
        JG      (.L9_1)
 
952
                        
 
953
.L9_11:
 
954
#ifndef FIXEDBASE
 
955
        MOV_L   (EDI,EAX)               /* return base */
 
956
#else
 
957
        MOV_L   (base_arg,EAX)          /* return base */
 
958
#endif
 
959
        MOV_L   (REGOFF(0,ESP),EDI)     /* POPL EDI */
 
960
        MOV_L   (REGOFF(4,ESP),ESI)     /* POPL ESI */
 
961
        MOV_L   (REGOFF(8,ESP),EBX)     /* POPL EBX */
 
962
        MOV_L   (REGOFF(12,ESP),EBP)    /* POPL EBP */
 
963
        ADD_L   (CONST(16),ESP)
 
964
        RET